Slack integration

.env.dist

@@ -12,3 +12,7 @@ CALAMARI_EMPLOYEE=
 
 GOOGLE_CLIENT_ID=
 GOOGLE_CLIENT_SECRET=
+
+SLACK_API_TOKEN=
+SLACK_NOTIFICATIONS_CHANNEL=worklog-monitor
+NODE_ICU_DATA=/home/node/app/node_modules/node-icu

package.json

@@ -23,6 +23,7 @@
     "@nestjs/passport": "^6.1.0",
     "@nestjs/platform-express": "^6.7.2",
     "@nestjs/swagger": "^3.1.0",
+    "@slack/web-api": "^5.2.0",
     "@typescript-eslint/eslint-plugin": "^2.3.1",
     "@typescript-eslint/eslint-plugin-tslint": "^2.3.1",
     "@typescript-eslint/parser": "^2.3.1",
@@ -36,6 +37,7 @@
     "nestjs-config": "^1.4.4",
     "passport": "^0.4.0",
     "passport-google-token": "^0.1.2",
+    "node-icu": "^1.1.0",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.0",
     "rxjs": "^6.5.3",

src/aggregator/aggregator.module.ts

@@ -11,5 +11,6 @@ import { AggregatorController } from './aggregator.controller';
   imports: [TempoModule, CalamariModule, MappedUsersModule],
   providers: [AggregatorService],
   controllers: [AggregatorController],
+  exports: [AggregatorService],
 })
 export class AggregatorModule {}

src/app.module.ts

@@ -3,6 +3,7 @@ import * as path from 'path';
 import { Module } from '@nestjs/common';
 import { ConfigModule } from 'nestjs-config';
 
+import { NotificationsModule } from './notifications/notifications.module';
 import { AppController } from './app.controller';
 import { MappedUsersModule } from './mapped-users/mapped-users.module';
 import { TempoModule } from './tempo/tempo.module';
@@ -18,6 +19,7 @@ import { AuthModule } from './auth/auth.module';
     TempoModule,
     CalamariModule,
     AggregatorModule,
+    NotificationsModule,
     AuthModule,
   ],
   controllers: [AppController],

src/config/slack.ts

@@ -0,0 +1,4 @@
+export default {
+  apiToken: process.env.SLACK_API_TOKEN || '',
+  channel: process.env.SLACK_NOTIFICATIONS_CHANNEL,
+};

src/notifications/notifications.controller.spec.ts

@@ -0,0 +1,19 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { NotificationsController } from './notifications.controller';
+
+describe('Notifications Controller', () => {
+  let controller: NotificationsController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [NotificationsController],
+    }).compile();
+
+    controller = module.get<NotificationsController>(NotificationsController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/notifications/notifications.controller.ts

@@ -0,0 +1,36 @@
+import { Controller, Post, Query } from '@nestjs/common';
+
+import { UserWorklogResult } from '../aggregator/interfaces/user-worklog-result.interface';
+import { AggregatorService } from '../aggregator/aggregator.service';
+import { CalamariService } from '../calamari/calamari.service';
+
+import { NotificationsService } from './notifications.service';
+
+@Controller('notifications')
+export class NotificationsController {
+  constructor(
+    private readonly aggregatorService: AggregatorService,
+    private readonly calamariService: CalamariService,
+    private readonly notificationsService: NotificationsService,
+  ) {
+  }
+
+  @Post('/slack/to-users')
+  public async sendNotificationsToUsers(@Query('date') date: string) {
+    const lastWorkingDate = await this.calamariService.previousWorkingDay(new Date(date));
+    const users: UserWorklogResult[] = await this.aggregatorService.aggregate(lastWorkingDate);
+    const lazyUsers = users.filter(user => !user.worklogs.length);
+
+    lazyUsers.forEach(workLogResult => this.notificationsService.sendToUser(workLogResult, lastWorkingDate));
+  }
+
+  @Post('/slack/to-channel')
+  public async sendNotificationToChannel(@Query('date') date: string) {
+    const lastWorkingDate = await this.calamariService.previousWorkingDay(new Date(date));
+    const users: UserWorklogResult[] = await this.aggregatorService.aggregate(lastWorkingDate);
+
+    const lazyUsers = users.filter(user => !user.worklogs.length);
+
+    await this.notificationsService.sendToChannel(lazyUsers, lastWorkingDate);
+  }
+}

src/notifications/notifications.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+
+import { AggregatorModule } from '../aggregator/aggregator.module';
+import { CalamariModule } from '../calamari/calamari.module';
+
+import { NotificationsController } from './notifications.controller';
+import { NotificationsService } from './notifications.service';
+import { SlackService } from './slack/slack.service';
+
+@Module({
+  imports: [AggregatorModule, CalamariModule],
+  controllers: [NotificationsController],
+  providers: [NotificationsService, SlackService],
+})
+export class NotificationsModule {
+}

src/notifications/notifications.service.spec.ts

@@ -0,0 +1,19 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { NotificationsService } from './notifications.service';
+
+describe('NotificationsService', () => {
+  let service: NotificationsService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [NotificationsService],
+    }).compile();
+
+    service = module.get<NotificationsService>(NotificationsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/notifications/notifications.service.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from 'nestjs-config';
+
+import { UserWorklogResult } from '../aggregator/interfaces/user-worklog-result.interface';
+
+import { SlackService } from './slack/slack.service';
+
+@Injectable()
+export class NotificationsService {
+  constructor(
+    private readonly slackService: SlackService,
+    private readonly config: ConfigService,
+  ) {
+  }
+
+  public sendToUser(workLogResult: UserWorklogResult, date: Date) {
+    const dateString = date.toLocaleDateString('pl', {
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+    });
+
+    const message = `Cześć ${workLogResult.firstName} :wave:. Uzupełnij work log za ${dateString}. Dzięki!`;
+
+    return this.slackService.sendToUser(message, workLogResult.email);
+  }
+
+  public sendToChannel(workLogResults: UserWorklogResult[], date: Date) {
+    const dateString = date.toLocaleDateString('pl', {
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+    });
+    const message = `:alert: Brakujące work logi za *${dateString}* :alert: \n\n${workLogResults
+      .map(result => [`:pisiorek: ${result.firstName} ${result.lastName}`])
+      .join('\n')}`;
+
+    return this.slackService.sendToChannel(message, this.config.get('slack.channel'));
+  }
+}

src/notifications/slack/slack.service.spec.ts

@@ -0,0 +1,19 @@
+import { Test, TestingModule } from '@nestjs/testing';
+
+import { SlackService } from './slack.service';
+
+describe('SlackService', () => {
+  let service: SlackService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [SlackService],
+    }).compile();
+
+    service = module.get<SlackService>(SlackService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/notifications/slack/slack.service.ts

@@ -0,0 +1,49 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { WebAPICallResult, WebClient } from '@slack/web-api';
+import { ConfigService } from 'nestjs-config';
+
+@Injectable()
+export class SlackService {
+  private readonly webClient: WebClient;
+
+  private readonly channel: string;
+
+  constructor(
+    private readonly configService: ConfigService,
+  ) {
+    this.webClient = new WebClient(configService.get('slack.apiToken'));
+    this.channel = configService.get('slack.channel');
+  }
+
+  public async sendToChannel(message: string, channel = null): Promise<WebAPICallResult> {
+    try {
+      return this.webClient.chat.postMessage({
+        channel: channel || this.channel,
+        text: message,
+      });
+    } catch (e) {
+      throw new BadRequestException(`Unable to post a message to channel ${channel}`);
+    }
+  }
+
+  public async sendToUser(message: string, email: string): Promise<WebAPICallResult> {
+    let user;
+    try {
+      const userResponse = await this.webClient.users.lookupByEmail({
+        email,
+      });
+      user = userResponse.user;
+    } catch (e) {
+      throw new BadRequestException(`Unable to lookup user by email '${email}'`);
+    }
+
+    try {
+      return await this.webClient.chat.postMessage({
+        channel: user.id,
+        text: message,
+      });
+    } catch (e) {
+      throw new BadRequestException(`Unable to post a message to ${email}`);
+    }
+  }
+}