Merge pull request #552 from chaynHQ/develop

Merge Develop onto Main

src/api/slack/slack-api.ts

@@ -25,4 +25,23 @@ export class SlackMessageClient {
       return err;
     }
   }
+
+  public async sendMessageToBloomUserChannel(text: string): Promise<AxiosResponse | string> {
+    if (!isProduction) return; // only send messages in production environment
+
+    try {
+      const response = await apiCall({
+        url: process.env.SLACK_BLOOM_USERS_WEBHOOK_URL,
+        type: 'post',
+        data: {
+          text: text,
+        },
+      });
+      this.logger.log({ event: 'SESSION_FEEDBACK_SLACK_MESSAGE_SENT' });
+      return response;
+    } catch (err) {
+      this.logger.error('Unable to sendMessageToBloomUserSlackChannel', err);
+      return err;
+    }
+  }
 }

src/session-feedback/dtos/session-feedback.dto.ts

@@ -17,7 +17,6 @@ export class SessionFeedbackDto {
   })
   feedbackTags: FEEDBACK_TAGS_ENUM;
 
-  @IsNotEmpty()
   @IsString()
   @ApiProperty({ type: String })
   feedbackDescription: string;

src/session-feedback/session-feedback.service.spec.ts

@@ -2,6 +2,7 @@ import { createMock, DeepMocked } from '@golevelup/ts-jest';
 import { HttpException, HttpStatus } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { getRepositoryToken } from '@nestjs/typeorm';
+import { SlackMessageClient } from 'src/api/slack/slack-api';
 import { PartnerAccessEntity } from 'src/entities/partner-access.entity';
 import { PartnerEntity } from 'src/entities/partner.entity';
 import { SessionFeedbackEntity } from 'src/entities/session-feedback.entity';
@@ -34,6 +35,7 @@ describe('SessionFeedbackService', () => {
   let mockTherapySessionRepository: DeepMocked<Repository<TherapySessionEntity>>;
   let mockSessionFeedbackRepository: DeepMocked<Repository<SessionFeedbackEntity>>;
   let mockSessionService: DeepMocked<SessionService>;
+  let mockSlackMessageClient: DeepMocked<SlackMessageClient>;
 
   beforeEach(async () => {
     mockPartnerAccessRepository = createMock<Repository<PartnerAccessEntity>>();
@@ -45,6 +47,7 @@ describe('SessionFeedbackService', () => {
     mockTherapySessionRepository = createMock<Repository<TherapySessionEntity>>();
     mockSessionFeedbackRepository = createMock<Repository<SessionFeedbackEntity>>();
     mockSessionService = createMock<SessionService>();
+    mockSlackMessageClient = createMock<SlackMessageClient>();
 
     const module: TestingModule = await Test.createTestingModule({
       providers: [
@@ -85,6 +88,7 @@ describe('SessionFeedbackService', () => {
           provide: SessionService,
           useValue: mockSessionService,
         },
+        { provide: SlackMessageClient, useValue: mockSlackMessageClient },
       ],
     }).compile();
 
@@ -96,13 +100,15 @@ describe('SessionFeedbackService', () => {
   });
   describe('createSessionFeedback', () => {
     it('when session id exists should return dto', async () => {
-      jest.spyOn(mockSessionService, 'getSession').mockResolvedValueOnce(mockSessionEntity);
+      jest
+        .spyOn(mockSessionService, 'getSessionAndCourse')
+        .mockResolvedValueOnce(mockSessionEntity);
       const response = await service.createSessionFeedback(sessionFeedbackDto);
 
       expect(response).toMatchObject(sessionFeedbackDto);
     });
     it('when session id does not exist should throw exception', async () => {
-      jest.spyOn(mockSessionService, 'getSession').mockResolvedValueOnce(null);
+      jest.spyOn(mockSessionService, 'getSessionAndCourse').mockResolvedValueOnce(null);
 
       await expect(service.createSessionFeedback(sessionFeedbackDto)).rejects.toThrow(
         new HttpException('SESSION NOT FOUND', HttpStatus.NOT_FOUND),

src/session-feedback/session-feedback.service.ts

@@ -1,5 +1,6 @@
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
+import { SlackMessageClient } from 'src/api/slack/slack-api';
 import { PartnerAccessEntity } from 'src/entities/partner-access.entity';
 import { PartnerEntity } from 'src/entities/partner.entity';
 import { SessionFeedbackEntity } from 'src/entities/session-feedback.entity';
@@ -32,20 +33,28 @@ export class SessionFeedbackService {
     @InjectRepository(SessionFeedbackEntity)
     private sessionFeedbackRepository: Repository<SessionFeedbackEntity>,
     private readonly sessionService: SessionService,
+    private slackMessageClient: SlackMessageClient,
   ) {}
 
   public async createSessionFeedback(
     sessionFeedbackDto: SessionFeedbackDto,
   ): Promise<SessionFeedbackDto> {
-    const session = await this.sessionService.getSession(sessionFeedbackDto.sessionId);
+    const session = await this.sessionService.getSessionAndCourse(sessionFeedbackDto.sessionId);
 
     if (!session) {
       throw new HttpException('SESSION NOT FOUND', HttpStatus.NOT_FOUND);
     }
 
     const sessionFeedbackObject = this.sessionFeedbackRepository.create(sessionFeedbackDto);
     await this.sessionFeedbackRepository.save(sessionFeedbackObject);
+    this.sendSlackSessionFeedback(sessionFeedbackDto, session);
 
     return sessionFeedbackDto;
   }
+  // We don't need to wait for this to finish so async is not needed
+  sendSlackSessionFeedback(sessionFeedbackDto: SessionFeedbackDto, session: SessionEntity) {
+    this.slackMessageClient.sendMessageToBloomUserChannel(
+      `*${session.name}* in *${session.course?.name}* was rated *_${sessionFeedbackDto.feedbackTags}_* ${sessionFeedbackDto.feedbackDescription.length > 0 ? `with the comment: \n> _${sessionFeedbackDto.feedbackDescription}_` : ''}`,
+    );
+  }
 }

src/session/session.service.ts

@@ -13,6 +13,14 @@ export class SessionService {
     return await this.sessionRepository.findOneBy({ id });
   }
 
+  async getSessionAndCourse(id: string): Promise<SessionEntity> {
+    return await this.sessionRepository
+      .createQueryBuilder('session')
+      .leftJoinAndSelect('session.course', 'course')
+      .where('session.id = :id', { id })
+      .getOne();
+  }
+
   async getSessionByStoryblokId(storyblokId: number): Promise<SessionEntity> {
     return await this.sessionRepository
       .createQueryBuilder('session')

src/user/user.controller.ts

@@ -108,7 +108,7 @@ export class UserController {
   // Use only if users have not been added to mailchimp due to e.g. an ongoing bug
   @ApiBearerAuth()
   @Post('/bulk-mailchimp-upload')
-  @UseGuards(FirebaseAuthGuard)
+  @UseGuards(SuperAdminAuthGuard)
   async bulkUploadMailchimpProfiles() {
     return await this.userService.bulkUploadMailchimpProfiles();
   }