Changed the variable name relationMock -> relation

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

@@ -113,12 +113,12 @@ export class GrowiToSlackCtrl {
     const tokenGtoP = tokenGtoPs[0];
 
     // MOCK DATA MODIFY THIS GW 6972 -----------
-    const relationMock = await this.relationMockRepository.update(
+    const relation = await this.relationMockRepository.update(
       { tokenGtoP }, { permissionsForBroadcastUseCommands, permissionsForSingleUseCommands },
     );
     // MOCK DATA MODIFY THIS GW 6972 -----------
 
-    return res.send({ relationMock });
+    return res.send({ relation });
   }
 
   @Post('/relation-test')
@@ -133,22 +133,22 @@ export class GrowiToSlackCtrl {
     const tokenGtoP = tokenGtoPs[0];
 
     // retrieve relation with Installation
-    const relationMock = await this.relationMockRepository.createQueryBuilder('relation_mock')
+    const relation = await this.relationMockRepository.createQueryBuilder('relation_mock')
       .where('tokenGtoP = :token', { token: tokenGtoP })
       .leftJoinAndSelect('relation_mock.installation', 'installation')
       .getOne();
 
     // Returns the result of the test if it already exists
-    if (relationMock != null) {
-      logger.debug('relation found', relationMock);
+    if (relation != null) {
+      logger.debug('relation found', relation);
 
-      const token = relationMock.installation.data.bot?.token;
+      const token = relation.installation.data.bot?.token;
       if (token == null) {
         throw createError(400, 'installation is invalid');
       }
 
       try {
-        await this.requestToGrowi(relationMock.growiUri, relationMock.tokenPtoG);
+        await this.requestToGrowi(relation.growiUri, relation.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({ relationMock, slackBotToken: token });
+      return res.send({ relation, slackBotToken: token });
     }
 
     // retrieve latest Order with Installation
@@ -227,7 +227,7 @@ export class GrowiToSlackCtrl {
     // Find the generated relation
     const generatedRelationMock = await this.relationMockRepository.findOne({ id: response.identifiers[0].id });
 
-    return res.send({ relationMock: generatedRelationMock, slackBotToken: token });
+    return res.send({ relation: generatedRelationMock, slackBotToken: token });
   }
 
   injectGrowiUri(req: GrowiReq, growiUri: string): void {
@@ -274,16 +274,16 @@ export class GrowiToSlackCtrl {
     const tokenGtoP = tokenGtoPs[0];
 
     // retrieve relation with Installation
-    const relationMock = await this.relationMockRepository.createQueryBuilder('relation')
+    const relation = await this.relationMockRepository.createQueryBuilder('relation')
       .where('tokenGtoP = :token', { token: tokenGtoP })
       .leftJoinAndSelect('relation.installation', 'installation')
       .getOne();
 
-    if (relationMock == null) {
+    if (relation == null) {
       return res.webClientErr('relation is invalid', 'invalid_relation');
     }
 
-    const token = relationMock.installation.data.bot?.token;
+    const token = relation.installation.data.bot?.token;
     if (token == null) {
       return res.webClientErr('installation is invalid', 'invalid_installation');
     }
@@ -291,7 +291,7 @@ export class GrowiToSlackCtrl {
     const client = generateWebClient(token);
 
     try {
-      this.injectGrowiUri(req, relationMock.growiUri);
+      this.injectGrowiUri(req, relation.growiUri);
 
       const opt = req.body;
       opt.headers = req.headers;

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

@@ -65,21 +65,21 @@ export class SlackCtrl {
    * @param body
    * @returns
    */
-  private async sendCommand(growiCommand: GrowiCommand, relationMocks: RelationMock[], body: any) {
-    if (relationMocks.length === 0) {
+  private async sendCommand(growiCommand: GrowiCommand, relations: RelationMock[], body: any) {
+    if (relations.length === 0) {
       throw new Error('relations must be set');
     }
-    const botToken = relationMocks[0].installation?.data.bot?.token; // relations[0] should be exist
+    const botToken = relations[0].installation?.data.bot?.token; // relations[0] should be exist
 
-    const promises = relationMocks.map((relationMock: RelationMock) => {
+    const promises = relations.map((relation: RelationMock) => {
       // generate API URL
-      const url = new URL('/_api/v3/slack-integration/proxied/commands', relationMock.growiUri);
+      const url = new URL('/_api/v3/slack-integration/proxied/commands', relation.growiUri);
       return axios.post(url.toString(), {
         ...body,
         growiCommand,
       }, {
         headers: {
-          'x-growi-ptog-tokens': relationMock.tokenPtoG,
+          'x-growi-ptog-tokens': relation.tokenPtoG,
         },
       });
     });
@@ -155,7 +155,7 @@ export class SlackCtrl {
       return res.json({
         blocks: [
           markdownSectionBlock('*Found Relations to GROWI.*'),
-          ...relationMocks.map(relationMock => markdownSectionBlock(`GROWI url: ${relationMock.growiUri}`)),
+          ...relationMocks.map(relation => markdownSectionBlock(`GROWI url: ${relation.growiUri}`)),
         ],
       });
     }
@@ -167,10 +167,10 @@ export class SlackCtrl {
     const baseDate = new Date();
 
     const relationMocksForSingleUse:RelationMock[] = [];
-    await Promise.all(relationMocks.map(async(relationMock) => {
-      const isSupported = await this.relationsService.isSupportedGrowiCommandForSingleUse(relationMock, growiCommand.growiCommandType, baseDate);
+    await Promise.all(relationMocks.map(async(relation) => {
+      const isSupported = await this.relationsService.isSupportedGrowiCommandForSingleUse(relation, growiCommand.growiCommandType, baseDate);
       if (isSupported) {
-        relationMocksForSingleUse.push(relationMock);
+        relationMocksForSingleUse.push(relation);
       }
     }));
 
@@ -183,10 +183,10 @@ export class SlackCtrl {
     }
 
     const relationMocksForBroadcastUse:RelationMock[] = [];
-    await Promise.all(relationMocks.map(async(relationMock) => {
-      const isSupported = await this.relationsService.isSupportedGrowiCommandForBroadcastUse(relationMock, growiCommand.growiCommandType, baseDate);
+    await Promise.all(relationMocks.map(async(relation) => {
+      const isSupported = await this.relationsService.isSupportedGrowiCommandForBroadcastUse(relation, growiCommand.growiCommandType, baseDate);
       if (isSupported) {
-        relationMocksForBroadcastUse.push(relationMock);
+        relationMocksForBroadcastUse.push(relation);
       }
     }));
 
@@ -265,7 +265,7 @@ 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.relationMock], selectedGrowiInformation.sendCommandBody);
+      return this.sendCommand(selectedGrowiInformation.growiCommand, [selectedGrowiInformation.relation], selectedGrowiInformation.sendCommandBody);
     }
 
     /*

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

@@ -15,43 +15,43 @@ export class RelationsService {
   @Inject()
   relationMockRepository: RelationMockRepository;
 
-  async getSupportedGrowiCommands(relationMock:RelationMock):Promise<any> {
+  async getSupportedGrowiCommands(relation:RelationMock):Promise<any> {
     // generate API URL
-    const url = new URL('/_api/v3/slack-integration/supported-commands', relationMock.growiUri);
+    const url = new URL('/_api/v3/slack-integration/supported-commands', relation.growiUri);
     return axios.get(url.toString(), {
       headers: {
-        'x-growi-ptog-tokens': relationMock.tokenPtoG,
+        'x-growi-ptog-tokens': relation.tokenPtoG,
       },
     });
   }
 
-  async syncSupportedGrowiCommands(relationMock:RelationMock): Promise<RelationMock> {
-    const res = await this.getSupportedGrowiCommands(relationMock);
+  async syncSupportedGrowiCommands(relation:RelationMock): Promise<RelationMock> {
+    const res = await this.getSupportedGrowiCommands(relation);
 
     // MOCK DATA MODIFY THIS GW-6972 ---------------
     /**
      * this code represents the update of cache (Relation schema) using request from GROWI
      */
     const { permissionsForBroadcastUseCommands, permissionsForSingleUseCommands } = res.data.data;
-    if (relationMock !== null) {
-      relationMock.permissionsForBroadcastUseCommands = permissionsForBroadcastUseCommands;
-      relationMock.permissionsForSingleUseCommands = permissionsForSingleUseCommands;
-      relationMock.expiredAtCommands = addHours(new Date(), 48);
-      return this.relationMockRepository.save(relationMock);
+    if (relation !== null) {
+      relation.permissionsForBroadcastUseCommands = permissionsForBroadcastUseCommands;
+      relation.permissionsForSingleUseCommands = permissionsForSingleUseCommands;
+      relation.expiredAtCommands = addHours(new Date(), 48);
+      return this.relationMockRepository.save(relation);
     }
-    throw Error('No relation mock exists.');
+    throw Error('No relation exists.');
     // MOCK DATA MODIFY THIS GW-6972 ---------------
   }
 
   // MODIFY THIS METHOD USING ORIGINAL RELATION MODEL GW-6972
-  async syncRelation(relationMock:RelationMock, baseDate:Date):Promise<RelationMock|null> {
-    if (relationMock == null) return null;
+  async syncRelation(relation:RelationMock, baseDate:Date):Promise<RelationMock|null> {
+    if (relation == null) return null;
 
-    const distanceMillisecondsToExpiredAt = relationMock.getDistanceInMillisecondsToExpiredAt(baseDate);
+    const distanceMillisecondsToExpiredAt = relation.getDistanceInMillisecondsToExpiredAt(baseDate);
 
     if (distanceMillisecondsToExpiredAt < 0) {
       try {
-        return await this.syncSupportedGrowiCommands(relationMock);
+        return await this.syncSupportedGrowiCommands(relation);
       }
       catch (err) {
         logger.error(err);
@@ -62,18 +62,18 @@ export class RelationsService {
     // 24 hours
     if (distanceMillisecondsToExpiredAt < 24 * 60 * 60 * 1000) {
       try {
-        this.syncSupportedGrowiCommands(relationMock);
+        this.syncSupportedGrowiCommands(relation);
       }
       catch (err) {
         logger.error(err);
       }
     }
 
-    return relationMock;
+    return relation;
   }
 
-  async isSupportedGrowiCommandForSingleUse(relationMock:RelationMock, growiCommandType:string, baseDate:Date):Promise<boolean> {
-    const syncedRelation = await this.syncRelation(relationMock, baseDate);
+  async isSupportedGrowiCommandForSingleUse(relation:RelationMock, growiCommandType:string, baseDate:Date):Promise<boolean> {
+    const syncedRelation = await this.syncRelation(relation, baseDate);
     if (syncedRelation == null) {
       return false;
     }
@@ -83,8 +83,8 @@ export class RelationsService {
     // MOCK DATA THIS CODE SHOULD BE IMPLEMENTED IN GW-7017
   }
 
-  async isSupportedGrowiCommandForBroadcastUse(relationMock:RelationMock, growiCommandType:string, baseDate:Date):Promise<boolean> {
-    const syncedRelation = await this.syncRelation(relationMock, baseDate);
+  async isSupportedGrowiCommandForBroadcastUse(relation:RelationMock, growiCommandType:string, baseDate:Date):Promise<boolean> {
+    const syncedRelation = await this.syncRelation(relation, baseDate);
     if (syncedRelation == null) {
       return false;
     }

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

@@ -10,7 +10,7 @@ import { RelationMockRepository } from '~/repositories/relation-mock';
 
 
 export type SelectedGrowiInformation = {
-  relationMock: RelationMock,
+  relation: RelationMock,
   growiCommand: GrowiCommand,
   sendCommandBody: any,
 }
@@ -93,19 +93,19 @@ export class SelectGrowiService implements GrowiCommandProcessor {
     // ovverride trigger_id
     sendCommandBody.trigger_id = triggerId;
 
-    const relationMock = await this.relationMockRepository.createQueryBuilder('relation_mock')
+    const relation = 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 (relationMock == null) {
+    if (relation == null) {
       // TODO: postEphemeralErrors
       throw new Error('No relation found.');
     }
 
     return {
-      relationMock,
+      relation,
       growiCommand,
       sendCommandBody,
     };