[BE] 7.07 거래 체결 기능 구현 (WebSocket) #53

BE/src/asset/asset.controller.ts

@@ -0,0 +1,6 @@
+import { Controller } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+
+@Controller('/api/assets')
+@ApiTags('자산 API')
+export class AssetController {}

BE/src/asset/asset.entity.ts

@@ -0,0 +1,30 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+const INIT_ASSET = 10000000;
+
+@Entity('assets')
+export class Asset {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ nullable: false })
+  user_id: number;
+
+  @Column({ nullable: false, default: INIT_ASSET })
+  cash_balance: number;
+
+  @Column({ nullable: false, default: 0 })
+  stock_balance: number;
+
+  @Column({ nullable: false, default: INIT_ASSET })
+  total_asset: number;
+
+  @Column({ nullable: false, default: 0 })
+  total_profit: number;
+
+  @Column('decimal', { nullable: false, default: 0, precision: 10, scale: 5 })
+  total_profit_rate: number;
+
+  @Column({ nullable: true })
+  last_updated?: Date;
+}

BE/src/asset/asset.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AssetController } from './asset.controller';
+import { AssetService } from './asset.service';
+import { AssetRepository } from './asset.repository';
+import { Asset } from './asset.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Asset])],
+  controllers: [AssetController],
+  providers: [AssetService, AssetRepository],
+  exports: [AssetRepository],
+})
+export class AssetModule {}

BE/src/asset/asset.repository.ts

@@ -0,0 +1,11 @@
+import { DataSource, Repository } from 'typeorm';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { Injectable } from '@nestjs/common';
+import { Asset } from './asset.entity';
+
+@Injectable()
+export class AssetRepository extends Repository<Asset> {
+  constructor(@InjectDataSource() dataSource: DataSource) {
+    super(Asset, dataSource.createEntityManager());
+  }
+}

BE/src/asset/asset.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AssetService {}

BE/src/auth/auth.module.ts

@@ -9,6 +9,7 @@ import { User } from './user.entity';
 import { UserRepository } from './user.repository';
 import { JwtStrategy } from './strategy/jwt.strategy';
 import { KakaoStrategy } from './strategy/kakao.strategy';
+import { AssetModule } from '../asset/asset.module';
 
 @Module({
   imports: [
@@ -25,6 +26,7 @@ import { KakaoStrategy } from './strategy/kakao.strategy';
       }),
       inject: [ConfigService],
     }),
+    AssetModule,
   ],
   controllers: [AuthController],
   providers: [AuthService, UserRepository, JwtStrategy, KakaoStrategy],

BE/src/auth/user.repository.ts

@@ -1,30 +1,63 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource, Repository } from 'typeorm';
 import * as bcrypt from 'bcrypt';
 import { User } from './user.entity';
 import { AuthCredentialsDto } from './dto/auth-credentials.dto';
+import { AssetRepository } from '../asset/asset.repository';
 
 @Injectable()
 export class UserRepository extends Repository<User> {
-  constructor(@InjectDataSource() dataSource: DataSource) {
+  constructor(
+    @InjectDataSource() private dataSource: DataSource,
+    private readonly assetRepository: AssetRepository,
+  ) {
     super(User, dataSource.createEntityManager());
   }
 
   async registerUser(authCredentialsDto: AuthCredentialsDto) {
     const { email, password } = authCredentialsDto;
-    const salt: string = await bcrypt.genSalt();
-    const hashedPassword: string = await bcrypt.hash(password, salt);
-    const user = this.create({ email, password: hashedPassword });
-    await this.save(user);
+
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.startTransaction();
+
+    try {
+      const salt: string = await bcrypt.genSalt();
+      const hashedPassword: string = await bcrypt.hash(password, salt);
+      const user = this.create({ email, password: hashedPassword });
+      await queryRunner.manager.save(user);
+      const asset = this.assetRepository.create({ user_id: user.id });
+      await queryRunner.manager.save(asset);
+
+      await queryRunner.commitTransaction();
+    } catch (err) {
+      await queryRunner.rollbackTransaction();
+      throw new InternalServerErrorException();
+    } finally {
+      await queryRunner.release();
+    }
   }
 
   async registerKakaoUser(authCredentialsDto: AuthCredentialsDto) {
-    const { kakaoId, email } = authCredentialsDto;
-    const salt: string = await bcrypt.genSalt();
-    const hashedPassword: string = await bcrypt.hash(String(kakaoId), salt);
-    const user = this.create({ email, kakaoId, password: hashedPassword });
-    await this.save(user);
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.startTransaction();
+
+    try {
+      const { kakaoId, email } = authCredentialsDto;
+      const salt: string = await bcrypt.genSalt();
+      const hashedPassword: string = await bcrypt.hash(String(kakaoId), salt);
+      const user = this.create({ email, kakaoId, password: hashedPassword });
+      await this.save(user);
+      const asset = this.assetRepository.create({ user_id: user.id });
+      await queryRunner.manager.save(asset);
+
+      await queryRunner.commitTransaction();
+    } catch (err) {
+      await queryRunner.rollbackTransaction();
+      throw new InternalServerErrorException();
+    } finally {
+      await queryRunner.release();
+    }
   }
 
   async updateUserWithRefreshToken(

BE/src/websocket/stock-index-socket.service.ts → BE/src/stock/index/stock-index-socket.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';
-import { StockIndexValueElementDto } from '../stock/index/dto/stock-index-value-element.dto';
-import { BaseSocketService } from './base-socket.service';
-import { SocketGateway } from './socket.gateway';
+import { StockIndexValueElementDto } from './dto/stock-index-value-element.dto';
+import { BaseSocketService } from '../../websocket/base-socket.service';
+import { SocketGateway } from '../../websocket/socket.gateway';
 
 @Injectable()
 export class StockIndexSocketService {

BE/src/stock/index/stock-index.module.ts

@@ -3,10 +3,11 @@ import { StockIndexController } from './stock-index.controller';
 import { StockIndexService } from './stock-index.service';
 import { KoreaInvestmentModule } from '../../koreaInvestment/korea-investment.module';
 import { SocketModule } from '../../websocket/socket.module';
+import { StockIndexSocketService } from './stock-index-socket.service';
 
 @Module({
   imports: [KoreaInvestmentModule, SocketModule],
   controllers: [StockIndexController],
-  providers: [StockIndexService],
+  providers: [StockIndexService, StockIndexSocketService],
 })
 export class StockIndexModule {}

BE/src/stock/order/dto/stock-order-request.dto.ts

@@ -2,10 +2,8 @@ import { ApiProperty } from '@nestjs/swagger';
 import { IsInt, IsNumber, IsPositive } from 'class-validator';
 
 export class StockOrderRequestDto {
-  @ApiProperty({ description: '주식 id' })
-  @IsInt()
-  @IsPositive()
-  stock_id: number;
+  @ApiProperty({ description: '주식 id', example: '005930' })
+  stock_code: string;
 
   @ApiProperty({ description: '매수/매도 희망 가격' })
   @IsNumber()

BE/src/stock/order/stock-order-socket.service.ts

@@ -0,0 +1,119 @@
+import {
+  Injectable,
+  InternalServerErrorException,
+  Logger,
+} from '@nestjs/common';
+import { LessThanOrEqual, MoreThanOrEqual } from 'typeorm';
+import { BaseSocketService } from '../../websocket/base-socket.service';
+import { SocketGateway } from '../../websocket/socket.gateway';
+import { Order } from './stock-order.entity';
+import { TradeType } from './enum/trade-type';
+import { StatusType } from './enum/status-type';
+import { StockOrderRepository } from './stock-order.repository';
+
+@Injectable()
+export class StockOrderSocketService {
+  private TR_ID = 'H0STCNT0';
+
+  private readonly logger = new Logger();
+
+  constructor(
+    private readonly socketGateway: SocketGateway,
+    private readonly baseSocketService: BaseSocketService,
+    private readonly stockOrderRepository: StockOrderRepository,
+  ) {
+    baseSocketService.registerSocketOpenHandler(async () => {
+      const orders: Order[] =
+        await this.stockOrderRepository.findAllCodeByStatus();
+      orders.forEach((order) => {
+        baseSocketService.registerCode(this.TR_ID, order.stock_code);
+      });
+    });
+
+    baseSocketService.registerSocketDataHandler(
+      this.TR_ID,
+      (data: string[]) => {
+        this.checkExecutableOrder(
+          data[0], // 주식 코드
+          data[2], // 주식 체결가
+        ).catch(() => {
+          throw new InternalServerErrorException();
+        });
+      },
+    );
+  }
+
+  subscribeByCode(trKey: string) {
+    this.baseSocketService.registerCode(this.TR_ID, trKey);
+  }
+
+  unsubscribeByCode(trKey: string) {
+    this.baseSocketService.unregisterCode(this.TR_ID, trKey);
+  }
+
+  private async checkExecutableOrder(stockCode: string, value) {
+    const buyOrders = await this.stockOrderRepository.find({
+      where: {
+        stock_code: stockCode,
+        trade_type: TradeType.BUY,
+        status: StatusType.PENDING,
+        price: MoreThanOrEqual(value),
+      },
+    });
+
+    const sellOrders = await this.stockOrderRepository.find({
+      where: {
+        stock_code: stockCode,
+        trade_type: TradeType.SELL,
+        status: StatusType.PENDING,
+        price: LessThanOrEqual(value),
+      },
+    });
+
+    await Promise.all(buyOrders.map((buyOrder) => this.executeBuy(buyOrder)));
+    await Promise.all(
+      sellOrders.map((sellOrder) => this.executeSell(sellOrder)),
+    );
+
+    if (
+      !(await this.stockOrderRepository.existsBy({
+        stock_code: stockCode,
+        status: StatusType.PENDING,
+      }))
+    )
+      this.unsubscribeByCode(stockCode);
+  }
+
+  private async executeBuy(order) {
+    this.logger.log(`${order.id}번 매수 예약이 체결되었습니다.`, 'BUY');
+
+    const totalPrice = order.price * order.amount;
+    const fee = this.calculateFee(totalPrice);
+    await this.stockOrderRepository.updateOrderAndAssetWhenBuy(
+      order,
+      totalPrice + fee,
+    );
+  }
+
+  private async executeSell(order) {
+    this.logger.log(`${order.id}번 매도 예약이 체결되었습니다.`, 'SELL');
+
+    const totalPrice = order.price * order.amount;
+    const fee = this.calculateFee(totalPrice);
+    await this.stockOrderRepository.updateOrderAndAssetWhenSell(
+      order,
+      totalPrice - fee,
+    );
+  }
+
+  private calculateFee(totalPrice: number) {
+    if (totalPrice <= 10000000) return totalPrice * 0.16;
+    if (totalPrice > 10000000 && totalPrice <= 50000000)
+      return totalPrice * 0.14;
+    if (totalPrice > 50000000 && totalPrice <= 100000000)
+      return totalPrice * 0.12;
+    if (totalPrice > 100000000 && totalPrice <= 300000000)
+      return totalPrice * 0.1;
+    return totalPrice * 0.08;
+  }
+}

BE/src/stock/order/stock-order.entity.ts

@@ -16,7 +16,7 @@ export class Order {
   user_id: number;
 
   @Column({ nullable: false })
-  stock_id: number;
+  stock_code: string;
 
   @Column({
     type: 'enum',

BE/src/stock/order/stock-order.module.ts

@@ -4,10 +4,13 @@ import { StockOrderController } from './stock-order.controller';
 import { StockOrderService } from './stock-order.service';
 import { Order } from './stock-order.entity';
 import { StockOrderRepository } from './stock-order.repository';
+import { SocketModule } from '../../websocket/socket.module';
+import { AssetModule } from '../../asset/asset.module';
+import { StockOrderSocketService } from './stock-order-socket.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Order])],
+  imports: [TypeOrmModule.forFeature([Order]), SocketModule, AssetModule],
   controllers: [StockOrderController],
-  providers: [StockOrderService, StockOrderRepository],
+  providers: [StockOrderService, StockOrderRepository, StockOrderSocketService],
 })
 export class StockOrderModule {}