Merge remote-tracking branch 'origin/feat/7014-restrict-by-channel' into feat/6450-insurance-branch

packages/app/src/server/service/slack-command-handler/search.js

@@ -188,7 +188,7 @@ module.exports = (crowi) => {
   handler.showNextResults = async function(client, payload) {
     const parsedValue = JSON.parse(payload.actions[0].value);
 
-    const { body, args, offsetNum } = parsedValue;
+    const { body, args, offset: offsetNum } = parsedValue;
     const newOffsetNum = offsetNum + 10;
     let searchResult;
     try {

packages/slackbot-proxy/src/controllers/slack.ts

@@ -336,26 +336,52 @@ export class SlackCtrl {
     }
 
 
+    const allowedRelations:RelationMock[] = [];
+    const disallowedGrowiUrls: Set<string> = new Set();
+    let notAllowedCommandName!:string;
     const actionId:string = payload?.actions?.[0].action_id;
+
     await Promise.all(relations.map(async(relation) => {
-      await this.relationsService.checkPermissionForInteractions(relation, channelName, callbackId, actionId);
-    }));
+      const permission = await this.relationsService.checkPermissionForInteractions(relation, channelName, callbackId, actionId);
+      const { isPermittedForInteractions, commandName } = permission;
 
+      if (!isPermittedForInteractions) {
+        disallowedGrowiUrls.add(relation.growiUri);
+        notAllowedCommandName = commandName;
+      }
 
-    const disallowedGrowiUrls = this.relationsService.getDisallowedGrowiUrls();
-    const commandName = this.relationsService.getCommandName();
+      allowedRelations.push(relation);
+    }));
 
     if (relations.length === disallowedGrowiUrls.size) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const client = generateWebClient(authorizeResult.botToken!);
-      return postNotAllowedMessage(client, body, disallowedGrowiUrls, commandName);
+      const linkUrlList = Array.from(disallowedGrowiUrls).map((growiUrl) => {
+        return '\n'
+      + `• ${new URL('/admin/slack-integration', growiUrl).toString()}`;
+      });
+      const growiDocsLink = 'https://docs.growi.org/en/admin-guide/upgrading/43x.html';
+      return client.chat.postEphemeral({
+        text: 'Error occured.',
+        channel: body.channel_id,
+        user: body.user_id,
+        blocks: [
+          markdownSectionBlock('*None of GROWI permitted the command.*'),
+          markdownSectionBlock(`*'${notAllowedCommandName}'* command was not allowed.`),
+          markdownSectionBlock(
+            `To use this command, modify settings from following pages: ${linkUrlList}`,
+          ),
+          markdownSectionBlock(
+            `Or, if your GROWI version is 4.3.0 or below, upgrade GROWI to use commands and permission settings: ${growiDocsLink}`,
+          ),
+        ],
+      });
     }
 
     /*
      * forward to GROWI server
      */
 
-    const allowedRelations = this.relationsService.getAllowedRelations();
     allowedRelations.map(async(relation) => {
       try {
         // generate API URL

packages/slackbot-proxy/src/services/RelationsService.ts

@@ -118,61 +118,39 @@ export class RelationsService {
   }
 
 
-  allowedRelations:RelationMock[] = [];
-
-  getAllowedRelations():RelationMock[] {
-    return this.allowedRelations;
-  }
-
-  disallowedGrowiUrls: Set<string> = new Set();
-
-  getDisallowedGrowiUrls():Set<string> {
-    return this.disallowedGrowiUrls;
-  }
-
-  commandName:string;
-
-  getCommandName():string {
-    return this.commandName;
-  }
-
-
   async checkPermissionForInteractions(
       // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
       relation:RelationMock, channelName:string, callbackId:string, actionId:string,
-  ):Promise<void>/* Promise<{isPermittedForInteractions:boolean, commandName:string, allowedRelations:RelationMock[], disallowedGrowiUrls:Set<string>}> */ {
+  ):Promise<{isPermittedForInteractions:boolean, commandName:string}> {
 
+    let isPermittedForInteractions!:boolean;
+    let commandName!:string;
 
     const singleUse = Object.keys(relation.permissionsForSingleUseCommands);
     const broadCastUse = Object.keys(relation.permissionsForBroadcastUseCommands);
     let permissionForInteractions:boolean|string[];
-    let isPermittedForInteractions!:boolean;
 
     [...singleUse, ...broadCastUse].forEach(async(tempCommandName) => {
 
       // ex. search OR search:handlerName
       const commandRegExp = new RegExp(`(^${tempCommandName}$)|(^${tempCommandName}:\\w+)`);
-
       // skip this forEach loop if the requested command is not in permissionsForBroadcastUseCommands and permissionsForSingleUseCommands
       if (!commandRegExp.test(actionId) && !commandRegExp.test(callbackId)) {
         return;
       }
 
-      this.commandName = tempCommandName;
+      commandName = tempCommandName;
 
       // case: singleUse
       permissionForInteractions = relation.permissionsForSingleUseCommands[tempCommandName];
-
       // case: broadcastUse
       if (permissionForInteractions == null) {
         permissionForInteractions = relation.permissionsForBroadcastUseCommands[tempCommandName];
       }
-
       if (permissionForInteractions === true) {
         isPermittedForInteractions = true;
         return;
       }
-
       // check permission at channel level
       if (Array.isArray(permissionForInteractions)) {
         isPermittedForInteractions = true;
@@ -180,11 +158,8 @@ export class RelationsService {
       }
     });
 
-    if (!isPermittedForInteractions) {
-      this.disallowedGrowiUrls.add(relation.growiUri);
-    }
 
-    this.allowedRelations.push(relation);
+    return { isPermittedForInteractions, commandName };
   }
 
 }