Feature/#12 - 알림 구현

packages/backend/package.json

@@ -47,6 +47,7 @@
     "socket.io": "^4.8.1",
     "typeorm": "^0.3.20",
     "unzipper": "^0.12.3",
+    "web-push": "^3.6.7",
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0",
     "ws": "^8.18.0"
@@ -63,6 +64,7 @@
     "@types/passport-local": "^1.0.38",
     "@types/supertest": "^6.0.0",
     "@types/unzipper": "^0.10.10",
+    "@types/web-push": "^3.6.4",
     "@types/ws": "^8.5.13",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",

packages/backend/src/alarm/alarm.controller.ts

@@ -0,0 +1,145 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Param,
+  Body,
+  Put,
+  Delete,
+  UseGuards,
+} from '@nestjs/common';
+import { ApiOkResponse, ApiOperation, ApiParam } from '@nestjs/swagger';
+import { AlarmService } from './alarm.service';
+import { AlarmRequest } from './dto/alarm.request';
+import { AlarmResponse, AlarmSuccessResponse } from './dto/alarm.response';
+import SessionGuard from '@/auth/session/session.guard';
+import { GetUser } from '@/common/decorator/user.decorator';
+import { User } from '@/user/domain/user.entity';
+
+@Controller('alarm')
+export class AlarmController {
+  constructor(private readonly alarmService: AlarmService) {}
+
+  @Post()
+  @ApiOperation({
+    summary: '알림 생성',
+    description: '각 정보에 맞는 알림을 생성한다.',
+  })
+  @ApiOkResponse({
+    description: '알림 생성 완료',
+    type: AlarmResponse,
+  })
+  @UseGuards(SessionGuard)
+  async create(
+    @Body() alarmRequest: AlarmRequest,
+    @GetUser() user: User,
+  ): Promise<AlarmResponse> {
+    const userId = user.id;
+
+    return await this.alarmService.create(alarmRequest, userId);
+  }
+
+  @Get(':id')
+  @ApiOperation({
+    summary: '등록된 알림 확인',
+    description: '등록된 알림을 알림 아이디를 기준으로 찾을 수 있다.',
+  })
+  @ApiOkResponse({
+    description: '알림 아이디와 동일한 알림 찾음',
+    type: AlarmResponse,
+  })
+  @ApiParam({
+    name: 'id',
+    type: Number,
+    description: '알림 아이디',
+    example: 1,
+  })
+  @UseGuards(SessionGuard)
+  async findOne(@Param('id') alarmId: number): Promise<AlarmResponse> {
+    return this.alarmService.findOne(alarmId);
+  }
+
+  @Put(':id')
+  @ApiOperation({
+    summary: '등록된 알림 업데이트',
+    description: '알림 아이디 기준으로 업데이트를 할 수 있다.',
+  })
+  @ApiOkResponse({
+    description: '아이디와 동일한 알림 업데이트',
+    type: AlarmResponse,
+  })
+  @ApiParam({
+    name: 'id',
+    type: Number,
+    description: '알림 아이디',
+    example: 1,
+  })
+  @UseGuards(SessionGuard)
+  async update(
+    @Param('id') alarmId: number,
+    @Body() updateData: AlarmRequest,
+  ): Promise<AlarmResponse> {
+    return this.alarmService.update(alarmId, updateData);
+  }
+
+  @Delete(':id')
+  @ApiParam({
+    name: 'id',
+    type: Number,
+    description: '알림 아이디',
+    example: 1,
+  })
+  @ApiOperation({
+    summary: '등록된 알림 삭제',
+    description: '알림 아이디 기준으로 삭제를 할 수 있다.',
+  })
+  @ApiOkResponse({
+    description: '아이디와 동일한 알림 삭제',
+    type: AlarmSuccessResponse,
+  })
+  @UseGuards(SessionGuard)
+  async delete(@Param('id') alarmId: number) {
+    await this.alarmService.delete(alarmId);
+
+    return new AlarmSuccessResponse('알림 삭제를 성공했습니다.');
+  }
+
+  @Get('user')
+  @ApiOperation({
+    summary: '사용자별 알림 조회',
+    description: '사용자 아이디를 기준으로 모든 알림을 조회한다.',
+  })
+  @ApiOkResponse({
+    description: '사용자에게 등록되어 있는 모든 알림 조회',
+    type: [AlarmResponse],
+  })
+  @UseGuards(SessionGuard)
+  async getByUserId(@GetUser() user: User) {
+    const userId = user.id;
+
+    return await this.alarmService.findByUserId(userId);
+  }
+
+  @Get('stock/:stockId')
+  @ApiOperation({
+    summary: '주식별 알림 조회',
+    description: '주식 아이디를 기준으로 알림을 조회한다.',
+  })
+  @ApiOkResponse({
+    description:
+      '주식 아이디에 등록되어 있는 알림 중 유저에 해당하는 알림 조회',
+    type: [AlarmResponse],
+  })
+  @ApiParam({
+    name: 'id',
+    type: String,
+    description: '주식 아이디',
+    example: '005930',
+  })
+  @UseGuards(SessionGuard)
+  async getByStockId(@Param('stockId') stockId: string, @GetUser() user: User) {
+    const userId = user.id;
+
+    return await this.alarmService.findByStockId(stockId, userId);
+  }
+}

packages/backend/src/alarm/alarm.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AlarmController } from './alarm.controller';
+import { AlarmService } from './alarm.service';
+import { AlarmSubscriber } from './alarm.subscriber';
+import { Alarm } from './domain/alarm.entity';
+import { PushSubscription } from './domain/subscription.entity';
+import { PushController } from './push.controller';
+import { PushService } from './push.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Alarm, PushSubscription])],
+  controllers: [AlarmController, PushController],
+  providers: [AlarmService, PushService, AlarmSubscriber],
+  exports: [AlarmService],
+})
+export class AlarmModule {}

packages/backend/src/alarm/alarm.service.ts

@@ -0,0 +1,115 @@
+import {
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSource, Repository } from 'typeorm';
+import { Alarm } from './domain/alarm.entity';
+import { PushSubscription } from './domain/subscription.entity';
+import { AlarmRequest } from './dto/alarm.request';
+import { AlarmResponse } from './dto/alarm.response';
+import { PushService } from './push.service';
+import { User } from '@/user/domain/user.entity';
+
+@Injectable()
+export class AlarmService {
+  constructor(
+    @InjectRepository(Alarm)
+    private readonly alarmRepository: Repository<Alarm>,
+    private readonly dataSource: DataSource,
+    private readonly pushService: PushService,
+  ) {}
+
+  async create(alarmData: AlarmRequest, userId: number) {
+    return await this.dataSource.transaction(async (manager) => {
+      const repository = manager.getRepository(Alarm);
+      const user = await manager.findOne(User, { where: { id: userId } });
+      if (!user) {
+        throw new ForbiddenException('유저를 찾을 수 없습니다.');
+      }
+
+      const newAlarm = repository.create({
+        ...alarmData,
+        user,
+        stock: { id: alarmData.stockId },
+      });
+      const result = await repository.save(newAlarm);
+      return new AlarmResponse(result);
+    });
+  }
+
+  async findByUserId(userId: number) {
+    const result = await this.alarmRepository.find({
+      where: { user: { id: userId } },
+      relations: ['user', 'stock'],
+    });
+    return result.map((val) => new AlarmResponse(val));
+  }
+
+  async findByStockId(stockId: string, userId: number): Promise<Alarm[]> {
+    return await this.alarmRepository.find({
+      where: { stock: { id: stockId }, user: { id: userId } },
+      relations: ['user', 'stock'],
+    });
+  }
+
+  async findOne(id: number) {
+    const result = await this.alarmRepository.findOne({
+      where: { id },
+      relations: ['user', 'stock'],
+    });
+    if (result) return new AlarmResponse(result);
+    else throw new NotFoundException('등록된 알림을 찾을 수 없습니다.');
+  }
+
+  async update(id: number, updateData: AlarmRequest) {
+    const alarm = await this.alarmRepository.findOne({ where: { id } });
+    if (!alarm) {
+      throw new NotFoundException('등록된 알림을 찾을 수 없습니다.');
+    }
+
+    await this.alarmRepository.update(id, updateData);
+    const updatedAlarm = await this.alarmRepository.findOne({
+      where: { id },
+      relations: ['user', 'stock'],
+    });
+    if (updatedAlarm) return new AlarmResponse(updatedAlarm);
+    else
+      throw new NotFoundException(
+        `${id} : 업데이트할 알림을 찾을 수 없습니다.`,
+      );
+  }
+
+  async delete(id: number) {
+    const alarm = await this.alarmRepository.findOne({ where: { id } });
+    if (!alarm) {
+      throw new NotFoundException(`${id} : 삭제할 알림을 찾을 수 없습니다.`);
+    }
+
+    await this.alarmRepository.delete(id);
+  }
+
+  async sendPushNotification(alarm: Alarm): Promise<void> {
+    const { user, stock, targetPrice, targetVolume } = alarm;
+
+    const payload = {
+      title: '주식 알림',
+      body: `${stock.name}: ${
+        targetPrice ? `가격이 ${targetPrice}에 도달했습니다.` : ''
+      } ${targetVolume ? `거래량이 ${targetVolume}에 도달했습니다.` : ''}`,
+      stockId: stock.id,
+    };
+
+    const subscriptions = await this.dataSource.manager.findBy(
+      PushSubscription,
+      {
+        user: { id: user.id },
+      },
+    );
+
+    for (const subscription of subscriptions) {
+      await this.pushService.sendPushNotification(subscription, payload);
+    }
+  }
+}

packages/backend/src/alarm/alarm.subscriber.ts

@@ -0,0 +1,62 @@
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  DataSource,
+  EntitySubscriberInterface,
+  EventSubscriber,
+  InsertEvent,
+} from 'typeorm';
+import { Logger } from 'winston';
+import { AlarmService } from './alarm.service';
+import { Alarm } from './domain/alarm.entity';
+import { StockMinutely } from '@/stock/domain/stockData.entity';
+
+@Injectable()
+@EventSubscriber()
+export class AlarmSubscriber
+  implements EntitySubscriberInterface<StockMinutely>
+{
+  constructor(
+    private readonly datasource: DataSource,
+    private readonly alarmService: AlarmService,
+    @Inject('winston') private readonly logger: Logger,
+  ) {
+    this.datasource.subscribers.push(this);
+  }
+
+  listenTo() {
+    return StockMinutely;
+  }
+
+  isValidAlarm(alarm: Alarm, entity: StockMinutely) {
+    if (alarm.alarmDate && alarm.alarmDate > entity.createdAt) {
+      return false;
+    } else {
+      if (alarm.targetPrice && alarm.targetPrice >= entity.open) {
+        return true;
+      }
+      if (alarm.targetVolume && alarm.targetVolume >= entity.volume) {
+        return true;
+      }
+      return false;
+    }
+  }
+
+  async afterInsert(event: InsertEvent<StockMinutely>) {
+    try {
+      const stockMinutely = event.entity;
+      const rawAlarms = await this.datasource.manager.find(Alarm, {
+        where: { stock: { id: stockMinutely.stock.id } },
+        relations: ['user', 'stock'],
+      });
+
+      const alarms = rawAlarms.filter((val) =>
+        this.isValidAlarm(val, stockMinutely),
+      );
+      for (const alarm of alarms) {
+        await this.alarmService.sendPushNotification(alarm);
+      }
+    } catch (error) {
+      this.logger.warn(`Failed to handle alarm afterInsert event : ${error}`);
+    }
+  }
+}

packages/backend/src/alarm/domain/alarm.entity.ts

@@ -0,0 +1,40 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { Stock } from '@/stock/domain/stock.entity';
+import { User } from '@/user/domain/user.entity';
+
+@Entity()
+export class Alarm {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @ManyToOne(() => User, (user) => user.alarms, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => Stock, (stock) => stock.alarms, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'stock_id' })
+  stock: Stock;
+
+  @Column({ type: 'int', name: 'target_price', nullable: true })
+  targetPrice?: number;
+
+  @Column({ type: 'bigint', name: 'target_volume', nullable: true })
+  targetVolume?: number;
+
+  @Column({ type: 'timestamp', name: 'alarm_date', nullable: true })
+  alarmDate?: Date;
+
+  @CreateDateColumn({ type: 'timestamp', name: 'created_at' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamp', name: 'updated_at' })
+  updatedAt: Date;
+}