@boarteam/boar-pack-users-backend 5.4.2 → 5.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boarteam/boar-pack-users-backend",
-  "version": "5.4.2",
+  "version": "5.6.0",
   "description": "NestJS Users module including permissions system, authentication strategies etc",
   "main": "src/index",
   "files": [
@@ -14,7 +14,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@boarteam/boar-pack-common-backend": "^2.3.0",
+    "@boarteam/boar-pack-common-backend": "^2.3.1",
     "@casl/ability": "^6.7.0",
     "@nestjs/common": "^9.0.0",
     "@nestjs/config": "^3.2.0",
@@ -39,6 +39,7 @@
     "passport-jwt": "^4.0.1",
     "passport-local": "^1.0.0",
     "pg": "^8.13.1",
+    "telegraf": "^4.12.2",
     "typeorm": "^0.3.20",
     "ws": "^8.16.0"
   },
@@ -60,5 +61,5 @@
     "yalc:push": "yalc push",
     "gen-types": "SWAGGER=true JWT_SECRET=swagger nest start"
   },
-  "gitHead": "a679169b74b3397be6ab850474d34fcd95cc281a"
+  "gitHead": "e6e2920ef9786ec27cc616c35796f64f6183a3f5"
 }

package/src/casl/casl-ability.factory.ts

@@ -7,6 +7,7 @@ import { Permission } from '../users/entities/permissions';
 import { EventLog } from '../event-logs';
 import { Token } from "../tokens/entities/token.entity";
 import { MyToken } from "../tokens/policies/manage-my-tokens.policy";
+import { Setting } from "../settings/entities/setting.entity";
 
 type AnyObject = Record<PropertyKey, unknown>;
 
@@ -15,6 +16,7 @@ export interface TSubjects {
   EventLog: typeof EventLog;
   Token: typeof Token;
   MyToken: typeof MyToken;
+  Setting: typeof Setting;
 }
 
 export type TTextSubjects = 'all';

package/src/event-logs/event-logs.module.ts

@@ -12,7 +12,7 @@ import { CONFIGURE_EVENTS_MIDDLEWARE, SERVICE_CONFIG_TOKEN } from "./event-logs.
 import { TEventLogServiceConfig } from "./event-logs.types";
 import { EventLogsLogger } from "./event-logs.logger";
 import { EventLogMiddleware } from "./event-logs.middleware";
-import { ScheduleModule } from "@nestjs/schedule";
+import { ScheduleModule } from "@boarteam/boar-pack-common-backend";
 
 @Module({})
 export class EventLogsModule implements NestModule {
@@ -50,7 +50,7 @@ export class EventLogsModule implements NestModule {
       module: EventLogsModule,
       imports: [
         CaslModule.forFeature(),
-        ScheduleModule.forRoot(),
+        ScheduleModule,
         TypeOrmModule.forFeature([EventLog], config.dataSourceName),
       ],
       providers: [

package/src/generateTypes.ts

@@ -9,6 +9,9 @@ import { generate } from "openapi-typescript-codegen";
 import { EventLogsModule } from './event-logs'
 import { UsersModule } from "./users";
 import { TokensModule } from "./tokens";
+import { SettingsModule } from "./settings";
+import { TelegrafModule } from "./telegraf";
+import { AuthModule } from "./auth";
 
 @Module({
   imports: [
@@ -16,7 +19,7 @@ import { TokensModule } from "./tokens";
       envFilePath: resolve(__dirname, '../../.env'),
     }),
     TypeOrmModule.forRoot({
-      name: 'tid_db',
+      name: 'boar_pack_db',
       type: 'postgres',
       host: 'localhost',
       port: 5951,
@@ -27,15 +30,30 @@ import { TokensModule } from "./tokens";
         resolve(__dirname, './*/entities/*.entity.{ts,js}'),
       ],
     }),
+    AuthModule.forRoot({
+      googleAuth: false,
+      msAuth: false,
+      localAuth: false,
+      withControllers: true,
+      dataSourceName: 'boar_pack_db',
+    }),
     UsersModule.register({
       withControllers: true,
-      dataSourceName: 'tid_db',
+      dataSourceName: 'boar_pack_db',
     }),
     EventLogsModule.forRoot({
-      dataSourceName: 'tid_db'
+      dataSourceName: 'boar_pack_db'
     }),
     TokensModule.forRoot({
-      dataSourceName: 'tid_db',
+      dataSourceName: 'boar_pack_db',
+    }),
+    SettingsModule.register({
+      withControllers: true,
+      dataSourceName: 'boar_pack_db',
+    }),
+    TelegrafModule.register({
+      withControllers: true,
+      dataSourceName: 'boar_pack_db',
     }),
   ],
 })

package/src/index.ts

@@ -6,3 +6,5 @@ export * from './bcrypt';
 export * from './tokens';
 export * from './ws-auth';
 export * from './event-logs';
+export * from './settings';
+export * from './telegraf';

package/src/settings/dto/event-settings.dto.ts

@@ -0,0 +1,3 @@
+export class EventSettingsDto {
+  [key: string]: boolean;
+}

package/src/settings/entities/setting.entity.ts

@@ -0,0 +1,19 @@
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn, } from 'typeorm';
+
+@Entity('settings')
+export class Setting {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ unique: true })
+  key: string;
+
+  @Column()
+  value: string;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt: Date;
+}

package/src/settings/index.ts

@@ -0,0 +1,5 @@
+export * from './settings.module';
+export * from './settings.service';
+export * from './settings.constants';
+export * from './entities/setting.entity';
+export * from './settings.permissions';

package/src/settings/policies/manage-settings.policy.ts

@@ -0,0 +1,8 @@
+import { Setting } from "../entities/setting.entity";
+import { Action, AppAbility, IPolicyHandler } from "../../casl";
+
+export class ManageSettingsPolicy implements IPolicyHandler {
+  handle(ability: AppAbility) {
+    return ability.can(Action.Manage, Setting);
+  }
+}

package/src/settings/settings.constants.ts

@@ -0,0 +1,9 @@
+export enum Notifications {
+  QuotesByProviderStatus = 'notifications.quotes_by_provider_status',
+  QuotesByUserStatus = 'notifications.quotes_by_user_status',
+}
+
+export enum SettingsValues {
+  NO = 'no',
+  YES = 'yes',
+}

package/src/settings/settings.controller.ts

@@ -0,0 +1,32 @@
+import { Body, Controller, Get, Patch } from "@nestjs/common";
+import { SettingsService } from "./settings.service";
+import { ManageSettingsPolicy } from "./policies/manage-settings.policy";
+import { ApiOkResponse, ApiTags } from "@nestjs/swagger";
+import { CheckPolicies, ManageAllPolicy } from "../casl";
+import { EventSettingsDto } from "./dto/event-settings.dto";
+
+@CheckPolicies(new ManageAllPolicy())
+@ApiTags('Settings')
+@Controller('settings')
+export class SettingsController {
+  constructor(
+    private readonly settingsService: SettingsService,
+  ) {}
+
+  @CheckPolicies(new ManageSettingsPolicy())
+  @Get('events')
+  @ApiOkResponse({
+    type: EventSettingsDto,
+  })
+  getEventSettings(): Promise<EventSettingsDto> {
+    return this.settingsService.getEventSettings();
+  }
+
+  @CheckPolicies(new ManageSettingsPolicy())
+  @Patch('events')
+  setEventSettings(
+    @Body() events: EventSettingsDto,
+  ) {
+    return this.settingsService.setEventSettings(events);
+  }
+}

package/src/settings/settings.module.ts

@@ -0,0 +1,46 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { getDataSourceToken, TypeOrmModule } from '@nestjs/typeorm';
+import { SettingsController } from "./settings.controller";
+import { SettingsService } from "./settings.service";
+import { Setting } from "./entities/setting.entity";
+import { DataSource } from "typeorm";
+import { Action, CaslAbilityFactory } from "../casl";
+import { SettingsPermissions } from "./settings.permissions";
+
+@Module({})
+export class SettingsModule {
+  static register(config: {
+    withControllers: boolean,
+    dataSourceName: string,
+  }): DynamicModule {
+    return {
+      module: SettingsModule,
+      imports: [
+        TypeOrmModule.forFeature([Setting], config.dataSourceName),
+      ],
+      controllers: config.withControllers ? [
+        SettingsController,
+      ] : [],
+      providers: [
+        {
+          provide: SettingsService,
+          inject: [getDataSourceToken(config.dataSourceName)],
+          useFactory: (dataSource: DataSource) => {
+            return new SettingsService(dataSource.getRepository(Setting));
+          }
+        }
+      ],
+      exports: [
+        SettingsService,
+      ],
+    };
+  }
+
+  constructor() {
+    CaslAbilityFactory.addPermissionToAction({
+      permission: SettingsPermissions.MANAGE,
+      action: Action.Manage,
+      subject: Setting,
+    });
+  }
+}

package/src/settings/settings.permissions.ts

@@ -0,0 +1,3 @@
+export enum SettingsPermissions {
+  MANAGE = 'manage_settings',
+}

package/src/settings/settings.service.ts

@@ -0,0 +1,51 @@
+import { Injectable } from "@nestjs/common";
+import { In, Like, Repository } from "typeorm";
+import { Setting } from "./entities/setting.entity";
+import { EventSettingsDto } from "./dto/event-settings.dto";
+import { SettingsValues } from "./settings.constants";
+
+@Injectable()
+export class SettingsService {
+  constructor(readonly repo: Repository<Setting>) {
+  }
+
+  public getSettings(settingsNames: string[]): Promise<Setting[]> {
+    return this.repo.find({
+      where: {
+        key: In(settingsNames),
+      }
+    });
+  }
+
+  async updateSettings(settings: Pick<Setting, 'key' | 'value'>[]): Promise<void> {
+    await this.repo.upsert(settings, ['key']);
+  }
+
+  async getEventSettings(): Promise<EventSettingsDto> {
+    const settings = await this.repo.find({
+      where: {
+        key: Like('notifications.%'),
+      }
+    });
+
+    const eventSettings = new EventSettingsDto();
+    settings.forEach(setting => {
+      eventSettings[setting.key] = setting.value === SettingsValues.YES
+    });
+
+    return eventSettings;
+  }
+
+  async setEventSettings(updateDto: EventSettingsDto): Promise<void> {
+    const settings: Pick<Setting, 'key' | 'value'>[] = [];
+
+    for (const key in updateDto) {
+      settings.push({
+        key: key,
+        value: updateDto[key] ? SettingsValues.YES : SettingsValues.NO,
+      });
+    }
+
+    await this.repo.upsert(settings, ['key']);
+  }
+}

package/src/telegraf/dto/telegram-settings-update.dto.ts

@@ -0,0 +1,13 @@
+import Joi from "joi";
+import { JoiSchema } from 'nestjs-joi';
+
+export class TelegramSettingsUpdateDto {
+  @JoiSchema(Joi.boolean().optional())
+  enabled?: boolean;
+
+  @JoiSchema(Joi.string().trim().optional().allow(''))
+  botToken?: string;
+
+  @JoiSchema(Joi.string().trim().optional().allow(''))
+  chatId?: string;
+}

package/src/telegraf/dto/telegram-settings.dto.ts

@@ -0,0 +1,5 @@
+export class TelegramSettingsDto {
+  enabled: boolean;
+  botToken: string | null;
+  chatId: string | null;
+}

package/src/telegraf/index.ts

@@ -0,0 +1,3 @@
+export * from './telegraf.module';
+export * from './telegraf.service';
+export * from './telegraf.constants';

package/src/telegraf/telegraf.constants.ts

@@ -0,0 +1,5 @@
+export const Telegram = {
+  BotToken: 'telegram.bot_token',
+  ChatId: 'telegram.chat_id',
+  Enabled: 'telegram.enabled',
+} as const;

package/src/telegraf/telegraf.controller.ts

@@ -0,0 +1,40 @@
+import { Body, Controller, Get, Patch, Post } from "@nestjs/common";
+import { TelegrafService } from "./telegraf.service";
+import { ApiOkResponse, ApiTags } from "@nestjs/swagger";
+import { ManageSettingsPolicy } from "../settings/policies/manage-settings.policy";
+import { CheckPolicies, ManageAllPolicy } from "../casl";
+import { TelegramSettingsDto } from "./dto/telegram-settings.dto";
+import { TelegramSettingsUpdateDto } from "./dto/telegram-settings-update.dto";
+
+@CheckPolicies(new ManageAllPolicy())
+@ApiTags('Telegraf')
+@Controller('telegraf')
+export class TelegrafController {
+  constructor(
+    private readonly telegrafService: TelegrafService,
+  ) {
+  }
+
+  @CheckPolicies(new ManageSettingsPolicy())
+  @Get('telegram')
+  @ApiOkResponse({
+    type: TelegramSettingsDto,
+  })
+  getTelegramSettings(): Promise<TelegramSettingsDto> {
+    return this.telegrafService.getTelegramSettings();
+  }
+
+  @CheckPolicies(new ManageSettingsPolicy())
+  @Patch('telegram')
+  setTelegramSettings(
+    @Body() telegram: TelegramSettingsUpdateDto,
+  ) {
+    return this.telegrafService.setTelegramSettings(telegram);
+  }
+
+  @CheckPolicies(new ManageSettingsPolicy())
+  @Post('test')
+  async testTelegraf() {
+    return await this.telegrafService.test();
+  }
+}

package/src/telegraf/telegraf.module.ts

@@ -0,0 +1,28 @@
+import { DynamicModule, Module } from "@nestjs/common";
+import { TelegrafService } from "./telegraf.service";
+import { SettingsModule } from "../settings/settings.module";
+import { TelegrafController } from "./telegraf.controller";
+
+@Module({})
+export class TelegrafModule {
+  static register(config: {
+    withControllers: boolean,
+    dataSourceName: string,
+  }): DynamicModule {
+    return {
+      module: TelegrafModule,
+      imports: [
+        SettingsModule.register({ withControllers: false, dataSourceName: config.dataSourceName }),
+      ],
+      controllers: config.withControllers ? [
+        TelegrafController,
+      ] : [],
+      providers: [
+        TelegrafService,
+      ],
+      exports: [
+        TelegrafService,
+      ],
+    };
+  }
+}

package/src/telegraf/telegraf.service.ts

@@ -0,0 +1,110 @@
+import { BadRequestException, Injectable, Logger } from "@nestjs/common";
+import { Notifications, Setting, SettingsService, SettingsValues } from "../settings";
+import { FmtString } from "telegraf/format";
+
+import { Telegraf } from "telegraf";
+import { Telegram } from "./telegraf.constants";
+import { TelegramSettingsDto } from "./dto/telegram-settings.dto";
+import { TelegramSettingsUpdateDto } from "./dto/telegram-settings-update.dto";
+
+export const settingsToDtoPropMap = {
+  [Telegram.Enabled]: 'enabled',
+  [Telegram.BotToken]: 'botToken',
+  [Telegram.ChatId]: 'chatId',
+} as const;
+
+@Injectable()
+export class TelegrafService {
+  private readonly logger = new Logger(TelegrafService.name);
+
+  constructor(
+    private readonly settingsService: SettingsService,
+  ) {
+  }
+
+  async getTelegramSettings(): Promise<TelegramSettingsDto> {
+    const settings = await this.settingsService.getSettings([
+      Telegram.Enabled,
+      Telegram.BotToken,
+      Telegram.ChatId
+    ])
+
+    const telegramSettings = {
+      enabled: false,
+      botToken: '',
+      chatId: '',
+    };
+    settings.forEach((setting) => {
+      switch (setting.key) {
+        case Telegram.Enabled:
+          telegramSettings[settingsToDtoPropMap[setting.key]] = setting.value === SettingsValues.YES;
+          break;
+
+        case Telegram.BotToken:
+        case Telegram.ChatId:
+          telegramSettings[settingsToDtoPropMap[setting.key]] = setting.value;
+          break;
+      }
+    });
+
+    return telegramSettings;
+  }
+
+  async setTelegramSettings(updateDto: TelegramSettingsUpdateDto): Promise<void> {
+    const settings: Pick<Setting, 'key' | 'value'>[] = [];
+
+    if (updateDto.enabled) {
+      settings.push({
+        key: Telegram.Enabled,
+        value: updateDto.enabled ? SettingsValues.YES : SettingsValues.NO,
+      });
+    }
+
+    if (updateDto.botToken) {
+      settings.push({
+        key: Telegram.BotToken,
+        value: updateDto.botToken,
+      });
+    }
+
+    if (updateDto.chatId) {
+      settings.push({
+        key: Telegram.ChatId,
+        value: updateDto.chatId,
+      });
+    }
+
+    await this.settingsService.updateSettings(settings);
+  }
+
+  async sendMessage(message: string | FmtString, type: Notifications | null): Promise<void> {
+    const config = await this.getTelegramSettings();
+    if (!config.enabled) {
+      this.logger.log('Suppressed telegram message because it is disabled');
+      return;
+    }
+
+    if (!config.botToken || !config.chatId) {
+      this.logger.log('Suppressed telegram message because bot token or chat id is not set');
+      return;
+    }
+
+    const bot = new Telegraf(config.botToken);
+
+    try {
+      await bot.telegram.sendMessage(config.chatId, message);
+    } catch (e) {
+      this.logger.error('Failed to send telegram message');
+      this.logger.error(e, e.stack);
+    }
+  }
+
+  async test() {
+    try {
+      return await this.sendMessage('Test message', null);
+    } catch (e) {
+      this.logger.error(e, e.stack);
+      throw new BadRequestException('Wrong bot token or chat id')
+    }
+  }
+}