WIP: backend

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,16 @@ 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,
       });
+      console.log('ここやでえ');
+      console.log(slackAppTokensMOCK);
       // 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';

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

@@ -133,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);
@@ -160,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
@@ -200,30 +200,12 @@ 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,
@@ -237,7 +219,7 @@ export class GrowiToSlackCtrl {
       // 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 ---------------

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,32 @@ 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;
     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 +45,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 +73,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 true;
+    // 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,
     };