Merged 7281

packages/app/src/server/routes/apiv3/slack-integration-settings.js

@@ -400,24 +400,18 @@ module.exports = (crowi) => {
    *            description: Succeeded to create slack app integration
    */
   router.put('/slack-app-integrations', loginRequiredStrictly, adminRequired, csrf, async(req, res) => {
-    const SlackAppIntegrationRecordsNum = await SlackAppIntegration.countDocuments();
-    if (SlackAppIntegrationRecordsNum >= 10) {
+    const SlackAppIntegrationMock = mongoose.model('SlackAppIntegrationMock');
+    const SlackAppIntegrationMockRecordsNum = await SlackAppIntegrationMock.countDocuments();
+    if (SlackAppIntegrationMockRecordsNum >= 10) {
       const msg = 'Not be able to create more than 10 slack workspace integration settings';
       logger.error('Error', msg);
       return res.apiv3Err(new ErrorV3(msg, 'create-slackAppIntegeration-failed'), 500);
     }
 
-    const { tokenGtoP, tokenPtoG } = await SlackAppIntegration.generateUniqueAccessTokens();
+    const { tokenGtoP, tokenPtoG } = await SlackAppIntegrationMock.generateUniqueAccessTokens();
     try {
-      const slackAppTokens = await SlackAppIntegration.create({
-        tokenGtoP,
-        tokenPtoG,
-        supportedCommandsForBroadcastUse: defaultSupportedCommandsNameForBroadcastUse,
-        supportedCommandsForSingleUse: defaultSupportedCommandsNameForSingleUse,
-      });
       // MOCK DATA DELETE THIS GW-6972 ---------------
       /* This code represents the creation of the new SlackAppIntegration model instance. */
-      const SlackAppIntegrationMock = mongoose.model('SlackAppIntegrationMock');
       const initialSupportedCommandsForBroadcastUse = new Map();
       const initialSupportedCommandsForSingleUse = new Map();
       defaultSupportedCommandsNameForBroadcastUse.forEach((commandName) => {
@@ -426,14 +420,14 @@ module.exports = (crowi) => {
       defaultSupportedCommandsNameForSingleUse.forEach((commandName) => {
         initialSupportedCommandsForSingleUse.set(commandName, true);
       });
-      const MOCK = await SlackAppIntegrationMock.create({
+      const slackAppTokensMOCK = await SlackAppIntegrationMock.create({
         tokenGtoP,
         tokenPtoG,
         permissionsForBroadcastUseCommands: initialSupportedCommandsForBroadcastUse,
         permissionsForSingleUseCommands: initialSupportedCommandsForSingleUse,
       });
       // MOCK DATA DELETE THIS GW-6972 ---------------
-      return res.apiv3(slackAppTokens, 200);
+      return res.apiv3(slackAppTokensMOCK, 200);
     }
     catch (error) {
       const msg = 'Error occurred during creating slack integration settings procedure';
@@ -535,25 +529,14 @@ module.exports = (crowi) => {
     const { id } = req.params;
 
     try {
+      // NOT MOCK DATA BUT REFER THIS GW-7006
       const slackAppIntegration = await SlackAppIntegration.findByIdAndUpdate(
         id,
         { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse },
         { new: true },
       );
 
-      // await requestToProxyServer(
-      //   slackAppIntegration.tokenGtoP,
-      //   'put',
-      //   '/g2s/supported-commands',
-      //   {
-      //     supportedCommandsForBroadcastUse: slackAppIntegration.supportedCommandsForBroadcastUse,
-      //     supportedCommandsForSingleUse: slackAppIntegration.supportedCommandsForSingleUse,
-      //   },
-      // );
-
-      // return res.apiv3({ slackAppIntegration });
-
-      // MOCK DATA DELETE THIS GW-6972 ---------------
+      // MOCK DATA MODIFY THIS GW-6972 ---------------
       /**
        * this code represents the update operation using request from client (slackapp integration settings page)
        * , then send request to proxy to update cache
@@ -561,15 +544,18 @@ module.exports = (crowi) => {
        */
       const SlackAppIntegrationMock = mongoose.model('SlackAppIntegrationMock');
       // MOCK DATA FROM CLIENT assume that these data were sent from client
-      const permittedChannelsForEachCommandFromClient = {
-        channelsObject: { search: ['random'] },
+      const permissionsForBroadcastUseCommandsFromClient = {
+        search: false,
+      };
+      const permissionsForSingleUseCommandsFromClient = {
+        create: ['random'],
       };
       const slackAppIntegrationMock = await SlackAppIntegrationMock.findOneAndUpdate(
+        // MOCK DATA USE id IN req.params LIKE ABOVE
         { tokenPtoG: slackAppIntegration.tokenPtoG },
         {
-          supportedCommandsForBroadcastUse,
-          supportedCommandsForSingleUse,
-          permittedChannelsForEachCommand: permittedChannelsForEachCommandFromClient,
+          permissionsForBroadcastUseCommands: permissionsForBroadcastUseCommandsFromClient,
+          permissionsForSingleUseCommands: permissionsForSingleUseCommandsFromClient,
         },
         { new: true },
       );
@@ -579,12 +565,11 @@ module.exports = (crowi) => {
         'put',
         '/g2s/supported-commands',
         {
-          supportedCommandsForBroadcastUse: slackAppIntegrationMock.supportedCommandsForBroadcastUse,
-          supportedCommandsForSingleUse: slackAppIntegrationMock.supportedCommandsForSingleUse,
-          permittedChannelsForEachCommand: slackAppIntegrationMock.permittedChannelsForEachCommand,
+          permissionsForBroadcastUseCommands: slackAppIntegrationMock.permissionsForBroadcastUseCommands,
+          permissionsForSingleUseCommands: slackAppIntegrationMock.permissionsForSingleUseCommands,
         },
       );
-      // MOCK DATA DELETE THIS GW-6972 ---------------
+      // MOCK DATA MODIFY THIS GW-6972 ---------------
 
       return res.apiv3({ slackAppIntegrationMock });
     }
@@ -625,20 +610,23 @@ module.exports = (crowi) => {
     const { slackAppIntegrationId } = req.body;
     let slackBotToken;
     try {
-      const slackAppIntegration = await SlackAppIntegration.findOne({ _id: slackAppIntegrationId });
-      if (slackAppIntegration == null) {
+      // MOCK DATA DELETE THIS GW-6972 ---------------
+      const SlackAppIntegrationMock = mongoose.model('SlackAppIntegrationMock');
+      const slackAppIntegrationMock = await SlackAppIntegrationMock.findOne({ _id: slackAppIntegrationId });
+      // MOCK DATA DELETE THIS GW-6972 ---------------
+      if (slackAppIntegrationMock == null) {
         const msg = 'Could not find SlackAppIntegration by id';
         return res.apiv3Err(new ErrorV3(msg, 'find-slackAppIntegration-failed'), 400);
       }
 
       // USE MOCK DATA HERE FOR cache creation at /relation-test GW-7021
       const result = await requestToProxyServer(
-        slackAppIntegration.tokenGtoP,
+        slackAppIntegrationMock.tokenGtoP,
         'post',
         '/g2s/relation-test',
         {
-          supportedCommandsForBroadcastUse: slackAppIntegration.supportedCommandsForBroadcastUse,
-          supportedCommandsForSingleUse: slackAppIntegration.supportedCommandsForSingleUse,
+          permissionsForBroadcastUseCommands: slackAppIntegrationMock.permissionsForBroadcastUseCommands,
+          permissionsForSingleUseCommands: slackAppIntegrationMock.permissionsForSingleUseCommands,
         },
       );
 

packages/app/src/server/routes/apiv3/slack-integration.js

@@ -8,7 +8,8 @@ const { verifySlackRequest, generateWebClient, getSupportedGrowiActionsRegExps }
 
 const logger = loggerFactory('growi:routes:apiv3:slack-integration');
 const router = express.Router();
-const SlackAppIntegration = mongoose.model('SlackAppIntegration');
+const SlackAppIntegration = mongoose.model('SlackAppIntegrationMock');
+const SlackAppIntegrationMock = mongoose.model('SlackAppIntegrationMock');
 const { respondIfSlackbotError } = require('../../service/slack-command-handler/respond-if-slackbot-error');
 
 module.exports = (crowi) => {
@@ -26,14 +27,15 @@ module.exports = (crowi) => {
       return res.status(400).send({ message });
     }
 
-    const slackAppIntegrationCount = await SlackAppIntegration.countDocuments({ tokenPtoG });
+    // MOCK DATA MODIFY THIS WITH SlackAppIntegration GW-7006 --------------
+    const slackAppIntegrationMockCount = await SlackAppIntegrationMock.countDocuments({ tokenPtoG });
 
     logger.debug('verifyAccessTokenFromProxy', {
       tokenPtoG,
-      slackAppIntegrationCount,
+      slackAppIntegrationMockCount,
     });
 
-    if (slackAppIntegrationCount === 0) {
+    if (slackAppIntegrationMockCount === 0) {
       return res.status(403).send({
         message: 'The access token that identifies the request source is slackbot-proxy is invalid. Did you setup with `/growi register`.\n'
         + 'Or did you delete registration for GROWI ? if so, the link with GROWI has been disconnected. '
@@ -264,7 +266,8 @@ module.exports = (crowi) => {
     // MOCK DATA DELETE THIS GW-6972 ---------
     const SlackAppIntegrationMock = mongoose.model('SlackAppIntegrationMock');
     const slackAppIntegrationMock = await SlackAppIntegrationMock.findOne({ tokenPtoG });
-    return res.apiv3({ slackAppIntegrationMock });
+    const { permissionsForBroadcastUseCommands, permissionsForSingleUseCommands } = slackAppIntegrationMock;
+    return res.apiv3({ permissionsForBroadcastUseCommands, permissionsForSingleUseCommands });
     // MOCK DATA DELETE THIS GW-6972 ---------
 
     // const slackAppIntegration = await SlackAppIntegration.findOne({ tokenPtoG });

packages/slack/src/middlewares/verify-growi-to-slack-request.ts

@@ -4,7 +4,7 @@ import createError from 'http-errors';
 import loggerFactory from '../utils/logger';
 import { RequestFromGrowi } from '../interfaces/request-between-growi-and-proxy';
 
-const logger = loggerFactory('@growi/slack:middlewares:verify-slack-request');
+const logger = loggerFactory('@growi/slack:middlewares:verify-growi-to-slack-request');
 
 /**
  * Verify if the request came from slack

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

@@ -102,24 +102,21 @@ export class GrowiToSlackCtrl {
     // asserted (tokenGtoPs.length > 0) by verifyGrowiToSlackRequest
     const { tokenGtoPs } = req;
 
-    // const { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse } = req.body;
-
-    // MOCK DATA DELETE THIS GW 6972 -----------
-    const { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse, permittedChannelsForEachCommand } = req.body;
-    // MOCK DATA DELETE THIS GW 6972 -----------
+    // MOCK DATA SO FAR BUT THIS CAN BE USED AS AN ACTUAL CODE AS WELL GW 6972 -----------
+    const { permissionsForBroadcastUseCommands, permissionsForSingleUseCommands } = req.body;
+    // MOCK DATA SO FAR BUT THIS CAN BE USED AS AN ACTUAL CODE AS WELL GW 6972 -----------
 
     if (tokenGtoPs.length !== 1) {
       throw createError(400, 'installation is invalid');
     }
 
     const tokenGtoP = tokenGtoPs[0];
-    const relation = await this.relationRepository.update({ tokenGtoP }, { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse });
 
-    // MOCK DATA DELETE THIS GW 6972 -----------
+    // MOCK DATA MODIFY THIS GW 6972 -----------
     const relationMock = await this.relationMockRepository.update(
-      { tokenGtoP }, { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse, permittedChannelsForEachCommand },
+      { tokenGtoP }, { permissionsForBroadcastUseCommands, permissionsForSingleUseCommands },
     );
-    // MOCK DATA DELETE THIS GW 6972 -----------
+    // MOCK DATA MODIFY THIS GW 6972 -----------
 
     return res.send({ relationMock });
   }
@@ -136,22 +133,22 @@ export class GrowiToSlackCtrl {
     const tokenGtoP = tokenGtoPs[0];
 
     // retrieve relation with Installation
-    const relation = await this.relationRepository.createQueryBuilder('relation')
+    const relationMock = await this.relationMockRepository.createQueryBuilder('relation_mock')
       .where('tokenGtoP = :token', { token: tokenGtoP })
-      .leftJoinAndSelect('relation.installation', 'installation')
+      .leftJoinAndSelect('relation_mock.installation', 'installation')
       .getOne();
 
     // Returns the result of the test if it already exists
-    if (relation != null) {
-      logger.debug('relation found', relation);
+    if (relationMock != null) {
+      logger.debug('relation found', relationMock);
 
-      const token = relation.installation.data.bot?.token;
+      const token = relationMock.installation.data.bot?.token;
       if (token == null) {
         throw createError(400, 'installation is invalid');
       }
 
       try {
-        await this.requestToGrowi(relation.growiUri, relation.tokenPtoG);
+        await this.requestToGrowi(relationMock.growiUri, relationMock.tokenPtoG);
       }
       catch (err) {
         logger.error(err);
@@ -163,7 +160,7 @@ export class GrowiToSlackCtrl {
         throw createError(400, `failed to get connection. err: ${status.error}`);
       }
 
-      return res.send({ relation, slackBotToken: token });
+      return res.send({ relationMock, slackBotToken: token });
     }
 
     // retrieve latest Order with Installation
@@ -203,55 +200,34 @@ export class GrowiToSlackCtrl {
     // temporary cache for 48 hours
     const expiredAtCommands = addHours(new Date(), 48);
 
-    // Transaction is not considered because it is used infrequently,
-    const response = await this.relationRepository.createQueryBuilder('relation')
-      .insert()
-      .values({
-        installation: order.installation,
-        tokenGtoP: order.tokenGtoP,
-        tokenPtoG: order.tokenPtoG,
-        growiUri: order.growiUrl,
-        supportedCommandsForBroadcastUse: req.body.supportedCommandsForBroadcastUse,
-        supportedCommandsForSingleUse: req.body.supportedCommandsForSingleUse,
-        expiredAtCommands,
-      })
-      // https://github.com/typeorm/typeorm/issues/1090#issuecomment-634391487
-      .orUpdate({
-        conflict_target: ['installation', 'growiUri'],
-        overwrite: ['tokenGtoP', 'tokenPtoG', 'supportedCommandsForBroadcastUse', 'supportedCommandsForSingleUse'],
-      })
-      .execute();
-
     // MOCK DATA DELETE THIS GW-6972 7004 ---------------
     /**
      * this code represents the creation of cache (Relation schema) using request from GROWI
      */
-    await this.relationMockRepository.createQueryBuilder('relation_mock')
+    // Transaction is not considered because it is used infrequently
+    const response = await this.relationMockRepository.createQueryBuilder('relation_mock')
       .insert()
       .values({
         installation: order.installation,
         tokenGtoP: order.tokenGtoP,
         tokenPtoG: order.tokenPtoG,
         growiUri: order.growiUrl,
-        supportedCommandsForBroadcastUse: req.body.supportedCommandsForBroadcastUse,
-        supportedCommandsForSingleUse: req.body.supportedCommandsForSingleUse,
-        permittedChannelsForEachCommand: {
-          channelsObject: {},
-        },
+        permissionsForBroadcastUseCommands: req.body.permissionsForBroadcastUseCommands,
+        permissionsForSingleUseCommands: req.body.permissionsForSingleUseCommands,
         expiredAtCommands,
       })
       // https://github.com/typeorm/typeorm/issues/1090#issuecomment-634391487
       .orUpdate({
         conflict_target: ['installation', 'growiUri'],
-        overwrite: ['tokenGtoP', 'tokenPtoG', 'supportedCommandsForBroadcastUse', 'supportedCommandsForSingleUse'],
+        overwrite: ['tokenGtoP', 'tokenPtoG', 'permissionsForBroadcastUseCommands', 'permissionsForSingleUseCommands'],
       })
       .execute();
     // MOCK DATA DELETE THIS GW-6972 7004 ---------------
 
     // Find the generated relation
-    const generatedRelation = await this.relationRepository.findOne({ id: response.identifiers[0].id });
+    const generatedRelationMock = await this.relationMockRepository.findOne({ id: response.identifiers[0].id });
 
-    return res.send({ relation: generatedRelation, slackBotToken: token });
+    return res.send({ relationMock: generatedRelationMock, slackBotToken: token });
   }
 
   injectGrowiUri(req: GrowiReq, growiUri: string): void {
@@ -298,16 +274,16 @@ export class GrowiToSlackCtrl {
     const tokenGtoP = tokenGtoPs[0];
 
     // retrieve relation with Installation
-    const relation = await this.relationRepository.createQueryBuilder('relation')
+    const relationMock = await this.relationMockRepository.createQueryBuilder('relation')
       .where('tokenGtoP = :token', { token: tokenGtoP })
       .leftJoinAndSelect('relation.installation', 'installation')
       .getOne();
 
-    if (relation == null) {
+    if (relationMock == null) {
       return res.webClientErr('relation is invalid', 'invalid_relation');
     }
 
-    const token = relation.installation.data.bot?.token;
+    const token = relationMock.installation.data.bot?.token;
     if (token == null) {
       return res.webClientErr('installation is invalid', 'invalid_installation');
     }
@@ -315,7 +291,7 @@ export class GrowiToSlackCtrl {
     const client = generateWebClient(token);
 
     try {
-      this.injectGrowiUri(req, relation.growiUri);
+      this.injectGrowiUri(req, relationMock.growiUri);
 
       const opt = req.body;
       opt.headers = req.headers;

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

@@ -13,7 +13,8 @@ import {
 import { Relation } from '~/entities/relation';
 import { SlackOauthReq } from '~/interfaces/slack-to-growi/slack-oauth-req';
 import { InstallationRepository } from '~/repositories/installation';
-import { RelationRepository } from '~/repositories/relation';
+import { RelationMock } from '~/entities/relation-mock';
+import { RelationMockRepository } from '~/repositories/relation-mock';
 import { OrderRepository } from '~/repositories/order';
 import { AddSigningSecretToReq } from '~/middlewares/slack-to-growi/add-signing-secret-to-req';
 import { AuthorizeCommandMiddleware, AuthorizeInteractionMiddleware } from '~/middlewares/slack-to-growi/authorizer';
@@ -40,7 +41,7 @@ export class SlackCtrl {
   installationRepository: InstallationRepository;
 
   @Inject()
-  relationRepository: RelationRepository;
+  relationMockRepository: RelationMockRepository;
 
   @Inject()
   orderRepository: OrderRepository;
@@ -64,21 +65,21 @@ export class SlackCtrl {
    * @param body
    * @returns
    */
-  private async sendCommand(growiCommand: GrowiCommand, relations: Relation[], body: any) {
-    if (relations.length === 0) {
+  private async sendCommand(growiCommand: GrowiCommand, relationMocks: RelationMock[], body: any) {
+    if (relationMocks.length === 0) {
       throw new Error('relations must be set');
     }
-    const botToken = relations[0].installation?.data.bot?.token; // relations[0] should be exist
+    const botToken = relationMocks[0].installation?.data.bot?.token; // relations[0] should be exist
 
-    const promises = relations.map((relation: Relation) => {
+    const promises = relationMocks.map((relationMock: RelationMock) => {
       // generate API URL
-      const url = new URL('/_api/v3/slack-integration/proxied/commands', relation.growiUri);
+      const url = new URL('/_api/v3/slack-integration/proxied/commands', relationMock.growiUri);
       return axios.post(url.toString(), {
         ...body,
         growiCommand,
       }, {
         headers: {
-          'x-growi-ptog-tokens': relation.tokenPtoG,
+          'x-growi-ptog-tokens': relationMock.tokenPtoG,
         },
       });
     });
@@ -135,12 +136,12 @@ export class SlackCtrl {
     const installationId = authorizeResult.enterpriseId || authorizeResult.teamId;
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const installation = await this.installationRepository.findByTeamIdOrEnterpriseId(installationId!);
-    const relations = await this.relationRepository.createQueryBuilder('relation')
-      .where('relation.installationId = :id', { id: installation?.id })
-      .leftJoinAndSelect('relation.installation', 'installation')
+    const relationMocks = await this.relationMockRepository.createQueryBuilder('relation_mock')
+      .where('relation_mock.installationId = :id', { id: installation?.id })
+      .leftJoinAndSelect('relation_mock.installation', 'installation')
       .getMany();
 
-    if (relations.length === 0) {
+    if (relationMocks.length === 0) {
       return res.json({
         blocks: [
           markdownSectionBlock('*No relation found.*'),
@@ -154,7 +155,7 @@ export class SlackCtrl {
       return res.json({
         blocks: [
           markdownSectionBlock('*Found Relations to GROWI.*'),
-          ...relations.map(relation => markdownSectionBlock(`GROWI url: ${relation.growiUri}`)),
+          ...relationMocks.map(relationMock => markdownSectionBlock(`GROWI url: ${relationMock.growiUri}`)),
         ],
       });
     }
@@ -165,40 +166,40 @@ export class SlackCtrl {
 
     const baseDate = new Date();
 
-    const relationsForSingleUse:Relation[] = [];
-    await Promise.all(relations.map(async(relation) => {
-      const isSupported = await this.relationsService.isSupportedGrowiCommandForSingleUse(relation, growiCommand.growiCommandType, baseDate);
+    const relationMocksForSingleUse:RelationMock[] = [];
+    await Promise.all(relationMocks.map(async(relationMock) => {
+      const isSupported = await this.relationsService.isSupportedGrowiCommandForSingleUse(relationMock, growiCommand.growiCommandType, baseDate);
       if (isSupported) {
-        relationsForSingleUse.push(relation);
+        relationMocksForSingleUse.push(relationMock);
       }
     }));
 
     let isCommandPermitted = false;
 
-    if (relationsForSingleUse.length > 0) {
+    if (relationMocksForSingleUse.length > 0) {
       isCommandPermitted = true;
-      body.growiUrisForSingleUse = relationsForSingleUse.map(v => v.growiUri);
+      body.growiUrisForSingleUse = relationMocksForSingleUse.map(v => v.growiUri);
       return this.selectGrowiService.process(growiCommand, authorizeResult, body);
     }
 
-    const relationsForBroadcastUse:Relation[] = [];
-    await Promise.all(relations.map(async(relation) => {
-      const isSupported = await this.relationsService.isSupportedGrowiCommandForBroadcastUse(relation, growiCommand.growiCommandType, baseDate);
+    const relationMocksForBroadcastUse:RelationMock[] = [];
+    await Promise.all(relationMocks.map(async(relationMock) => {
+      const isSupported = await this.relationsService.isSupportedGrowiCommandForBroadcastUse(relationMock, growiCommand.growiCommandType, baseDate);
       if (isSupported) {
-        relationsForBroadcastUse.push(relation);
+        relationMocksForBroadcastUse.push(relationMock);
       }
     }));
 
     /*
      * forward to GROWI server
      */
-    if (relationsForBroadcastUse.length > 0) {
+    if (relationMocksForBroadcastUse.length > 0) {
       isCommandPermitted = true;
-      this.sendCommand(growiCommand, relationsForBroadcastUse, body);
+      this.sendCommand(growiCommand, relationMocksForBroadcastUse, body);
     }
 
     if (!isCommandPermitted) {
-      const botToken = relations[0].installation?.data.bot?.token;
+      const botToken = relationMocks[0].installation?.data.bot?.token;
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const client = generateWebClient(botToken!);
@@ -264,13 +265,13 @@ export class SlackCtrl {
     // forward to GROWI server
     if (callBackId === 'select_growi') {
       const selectedGrowiInformation = await this.selectGrowiService.handleSelectInteraction(installation, payload);
-      return this.sendCommand(selectedGrowiInformation.growiCommand, [selectedGrowiInformation.relation], selectedGrowiInformation.sendCommandBody);
+      return this.sendCommand(selectedGrowiInformation.growiCommand, [selectedGrowiInformation.relationMock], selectedGrowiInformation.sendCommandBody);
     }
 
     /*
     * forward to GROWI server
     */
-    const relation = await this.relationRepository.findOne({ installation, growiUri: req.growiUri });
+    const relation = await this.relationMockRepository.findOne({ installation, growiUri: req.growiUri });
 
     if (relation == null) {
       logger.error('*No relation found.*');

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

@@ -2,9 +2,6 @@ import { Inject, Service } from '@tsed/di';
 import axios from 'axios';
 import { addHours } from 'date-fns';
 
-import { Relation } from '~/entities/relation';
-import { RelationRepository } from '~/repositories/relation';
-
 import { RelationMock } from '~/entities/relation-mock';
 import { RelationMockRepository } from '~/repositories/relation-mock';
 
@@ -15,57 +12,31 @@ const logger = loggerFactory('slackbot-proxy:services:RelationsService');
 @Service()
 export class RelationsService {
 
-  @Inject()
-  relationRepository: RelationRepository;
-
   @Inject()
   relationMockRepository: RelationMockRepository;
 
-  // MOCK DATA DELETE THIS METHOD GW-6972
-  async getMockFromRelation(relation: Relation): Promise<RelationMock|null> {
-    const tokenGtoP = relation.tokenGtoP;
-    const relationMock = await this.relationMockRepository.findOne({ where: [{ tokenGtoP }] });
-
-    return relationMock || null;
-  }
-
-  async getSupportedGrowiCommands(relation:Relation):Promise<any> {
+  async getSupportedGrowiCommands(relationMock:RelationMock):Promise<any> {
     // generate API URL
-    const url = new URL('/_api/v3/slack-integration/supported-commands', relation.growiUri);
+    const url = new URL('/_api/v3/slack-integration/supported-commands', relationMock.growiUri);
     return axios.get(url.toString(), {
       headers: {
-        'x-growi-ptog-tokens': relation.tokenPtoG,
+        'x-growi-ptog-tokens': relationMock.tokenPtoG,
       },
     });
   }
 
-  async syncSupportedGrowiCommands(relation:Relation): Promise<RelationMock> {
-    const res = await this.getSupportedGrowiCommands(relation);
-    // const { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse } = res.data;
-    // relation.supportedCommandsForBroadcastUse = supportedCommandsForBroadcastUse;
-    // relation.supportedCommandsForSingleUse = supportedCommandsForSingleUse;
-    // relation.expiredAtCommands = addHours(new Date(), 48);
-
-    // return this.relationRepository.save(relation);
+  async syncSupportedGrowiCommands(relationMock:RelationMock): Promise<RelationMock> {
+    const res = await this.getSupportedGrowiCommands(relationMock);
 
     // MOCK DATA MODIFY THIS GW-6972 ---------------
     /**
      * this code represents the update of cache (Relation schema) using request from GROWI
      */
-    const relationMock = await this.getMockFromRelation(relation);
-    const { supportedCommandsForBroadcastUse, supportedCommandsForSingleUse, permittedChannelsForEachCommand } = res.data;
+    const { permissionsForBroadcastUseCommands, permissionsForSingleUseCommands } = res.data.data;
     if (relationMock !== null) {
-      relationMock.supportedCommandsForBroadcastUse = supportedCommandsForBroadcastUse;
-      relationMock.supportedCommandsForSingleUse = supportedCommandsForSingleUse;
-      relationMock.permittedChannelsForEachCommand = permittedChannelsForEachCommand;
+      relationMock.permissionsForBroadcastUseCommands = permissionsForBroadcastUseCommands;
+      relationMock.permissionsForSingleUseCommands = permissionsForSingleUseCommands;
       relationMock.expiredAtCommands = addHours(new Date(), 48);
-
-      // NOT MOCK DATA MODIFY THIS ORIGINAL OPERATION GW-6972
-      relation.supportedCommandsForBroadcastUse = supportedCommandsForBroadcastUse;
-      relation.supportedCommandsForSingleUse = supportedCommandsForSingleUse;
-      relation.expiredAtCommands = addHours(new Date(), 48);
-      this.relationRepository.save(relation);
-
       return this.relationMockRepository.save(relationMock);
     }
     throw Error('No relation mock exists.');
@@ -73,8 +44,7 @@ export class RelationsService {
   }
 
   // MODIFY THIS METHOD USING ORIGINAL RELATION MODEL GW-6972
-  async syncRelation(relation:Relation, baseDate:Date):Promise<RelationMock|null> {
-    const relationMock = await this.getMockFromRelation(relation);
+  async syncRelation(relationMock:RelationMock, baseDate:Date):Promise<RelationMock|null> {
     if (relationMock == null) return null;
 
     const distanceMillisecondsToExpiredAt = relationMock.getDistanceInMillisecondsToExpiredAt(baseDate);
@@ -102,20 +72,26 @@ export class RelationsService {
     return relationMock;
   }
 
-  async isSupportedGrowiCommandForSingleUse(relation:Relation, growiCommandType:string, baseDate:Date):Promise<boolean> {
-    const syncedRelation = await this.syncRelation(relation, baseDate);
+  async isSupportedGrowiCommandForSingleUse(relationMock:RelationMock, growiCommandType:string, baseDate:Date):Promise<boolean> {
+    const syncedRelation = await this.syncRelation(relationMock, baseDate);
     if (syncedRelation == null) {
       return false;
     }
-    return relation.supportedCommandsForSingleUse.includes(growiCommandType);
+    // MOCK DATA THIS CODE SHOULD BE IMPLEMENTED IN GW-7017
+    // return relationMock.supportedCommandsForSingleUse.includes(growiCommandType);
+    return false;
+    // MOCK DATA THIS CODE SHOULD BE IMPLEMENTED IN GW-7017
   }
 
-  async isSupportedGrowiCommandForBroadcastUse(relation:Relation, growiCommandType:string, baseDate:Date):Promise<boolean> {
-    const syncedRelation = await this.syncRelation(relation, baseDate);
+  async isSupportedGrowiCommandForBroadcastUse(relationMock:RelationMock, growiCommandType:string, baseDate:Date):Promise<boolean> {
+    const syncedRelation = await this.syncRelation(relationMock, baseDate);
     if (syncedRelation == null) {
       return false;
     }
-    return relation.supportedCommandsForBroadcastUse.includes(growiCommandType);
+    // MOCK DATA THIS CODE SHOULD BE IMPLEMENTED IN GW-7017
+    // return relationMock.supportedCommandsForBroadcastUse.includes(growiCommandType);
+    return true;
+    // MOCK DATA THIS CODE SHOULD BE IMPLEMENTED IN GW-7017
   }
 
 }

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

@@ -5,12 +5,12 @@ import { AuthorizeResult } from '@slack/oauth';
 
 import { GrowiCommandProcessor } from '~/interfaces/slack-to-growi/growi-command-processor';
 import { Installation } from '~/entities/installation';
-import { Relation } from '~/entities/relation';
-import { RelationRepository } from '~/repositories/relation';
+import { RelationMock } from '~/entities/relation-mock';
+import { RelationMockRepository } from '~/repositories/relation-mock';
 
 
 export type SelectedGrowiInformation = {
-  relation: Relation,
+  relationMock: RelationMock,
   growiCommand: GrowiCommand,
   sendCommandBody: any,
 }
@@ -19,7 +19,7 @@ export type SelectedGrowiInformation = {
 export class SelectGrowiService implements GrowiCommandProcessor {
 
   @Inject()
-  relationRepository: RelationRepository;
+  relationMockRepository: RelationMockRepository;
 
   async process(growiCommand: GrowiCommand, authorizeResult: AuthorizeResult, body: {[key:string]:string } & {growiUrisForSingleUse:string[]}): Promise<void> {
     const { botToken } = authorizeResult;
@@ -93,19 +93,19 @@ export class SelectGrowiService implements GrowiCommandProcessor {
     // ovverride trigger_id
     sendCommandBody.trigger_id = triggerId;
 
-    const relation = await this.relationRepository.createQueryBuilder('relation')
-      .where('relation.growiUri =:growiUri', { growiUri })
-      .andWhere('relation.installationId = :id', { id: installation?.id })
-      .leftJoinAndSelect('relation.installation', 'installation')
+    const relationMock = await this.relationMockRepository.createQueryBuilder('relation_mock')
+      .where('relation_mock.growiUri =:growiUri', { growiUri })
+      .andWhere('relation_mock.installationId = :id', { id: installation?.id })
+      .leftJoinAndSelect('relation_mock.installation', 'installation')
       .getOne();
 
-    if (relation == null) {
+    if (relationMock == null) {
       // TODO: postEphemeralErrors
       throw new Error('No relation found.');
     }
 
     return {
-      relation,
+      relationMock,
       growiCommand,
       sendCommandBody,
     };