[BE#374] polling 처리 및 시간 슬라이싱 저장

BE/src/app.module.ts

@@ -14,6 +14,7 @@ import { LoggingMiddleware } from './common/middleware/logging.middleware';
 import { typeormConfig } from './common/config/typeorm.config';
 import { staticConfig } from './common/config/static.config';
 import { AdminModule } from './admin/admin.module';
+import { HeartbeatModule } from './heartbeat/heartbeat.module';
 
 @Module({
   imports: [
@@ -32,6 +33,7 @@ import { AdminModule } from './admin/admin.module';
     PassportModule,
     AuthModule,
     AdminModule,
+    HeartbeatModule,
   ],
   controllers: [AppController],
   providers: [AppService],

BE/src/common/redis.service.ts

@@ -8,15 +8,23 @@ export class RedisService {
     this.client = createClient();
     this.client.connect();
   }
-  async set(key: string, value: string) {
-    await this.client.set(key, value);
+  async hset(key: string, field: string, value: string) {
+    await this.client.hSet(key, field, value);
   }
 
-  get(key: string): Promise<string | null> {
-    return this.client.get(key);
+  hget(key: string, field: string): Promise<string | null> {
+    return this.client.hGet(key, field);
   }
 
-  async del(key: string): Promise<void> {
+  async hdel(key: string, field: string): Promise<void> {
+    await this.client.hDel(key, field);
+  }
+
+  async del(key: string) {
     await this.client.del(key);
   }
+
+  getKeys() {
+    return this.client.keys('*');
+  }
 }

BE/src/heartbeat/heartbeat.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { HeartbeatService } from './heartbeat.service';
+import { User } from 'src/users/decorator/user.decorator';
+import { AccessTokenGuard } from 'src/auth/guard/bearer-token.guard';
+
+@Controller()
+export class HeartbeatController {
+  constructor(private readonly heartbeatsService: HeartbeatService) {}
+
+  @UseGuards(AccessTokenGuard)
+  @Get('/heartbeat')
+  heartbeat(@User('id') userId: number) {
+    this.heartbeatsService.recordHeartbeat(userId);
+    return { statusCode: 200, message: 'OK' };
+  }
+}

BE/src/heartbeat/heartbeat.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { HeartbeatService } from './heartbeat.service';
+import { HeartbeatController } from './heartbeat.controller';
+import { AuthModule } from 'src/auth/auth.module';
+import { UsersModule } from 'src/users/users.module';
+import { RedisService } from 'src/common/redis.service';
+
+@Module({
+  imports: [AuthModule, UsersModule],
+  controllers: [HeartbeatController],
+  providers: [HeartbeatService, RedisService],
+})
+export class HeartbeatModule {}

BE/src/heartbeat/heartbeat.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { RedisService } from 'src/common/redis.service';
+
+@Injectable()
+export class HeartbeatService {
+  constructor(private redisService: RedisService) {}
+
+  recordHeartbeat(userId: number) {
+    this.redisService.hset(`${userId}`, 'received_at', `${Date.now()}`);
+  }
+
+  async startCheckingHeartbeats() {
+    setInterval(async () => {
+      const now = Date.now();
+      const clients = await this.redisService.getKeys();
+      for (const clientId of clients) {
+        const received_at = await this.redisService.hget(
+          `${clientId}`,
+          'received_at',
+        );
+        if (now - +received_at > 30000) {
+          await this.redisService.del(`${clientId}`);
+        }
+      }
+    }, 10000);
+  }
+}

BE/src/main.ts

@@ -10,6 +10,7 @@ import { LoggingInterceptor } from './common/interceptor/logging.interceptor';
 import { HttpExceptionFilter } from './common/exception-filter/http-exception-filter';
 import { swaggerConfig } from './common/config/swagger.config';
 import { ENV } from './common/const/env-keys.const';
+import { HeartbeatService } from './heartbeat/heartbeat.service';
 
 async function bootstrap() {
   const configService = new ConfigService();
@@ -35,6 +36,9 @@ async function bootstrap() {
   app.useGlobalInterceptors(new LoggingInterceptor());
   app.useGlobalFilters(new HttpExceptionFilter());
 
+  const heartbeatService = app.get(HeartbeatService);
+  heartbeatService.startCheckingHeartbeats();
+
   await app.listen(configService.get<number>(ENV.PORT) || 3000);
 }
 bootstrap();

BE/src/mates/mates.service.ts

@@ -68,7 +68,10 @@ export class MatesService {
     );
     return Promise.all(
       studyTimeByFollowing.map(async (record) => {
-        const started_at = await this.redisService.get(`${record.id}`);
+        const started_at = await this.redisService.hget(
+          `${record.id}`,
+          'started_at',
+        );
         return {
           ...record,
           image_url: getImageUrl(
@@ -89,7 +92,7 @@ export class MatesService {
     const userIds = result.map((following) => following.following_id.id);
     return Promise.all(
       userIds.map(async (id) => {
-        const started_at = await this.redisService.get(`${id}`);
+        const started_at = await this.redisService.hget(`${id}`, 'started_at');
         return { id, started_at };
       }),
     );

BE/src/study-logs/dto/request/create-study-logs.dto.ts

@@ -5,14 +5,14 @@ export class StudyLogsCreateDto {
     example: '2023-11-23',
     description: '학습을 시작한 날짜',
   })
-  date: Date;
+  date: string;
 
   @ApiProperty({
     type: 'date',
     example: '2023-11-23 11:00:12',
     description: '학습을 시작/종료 시점의 시간',
   })
-  created_at: Date;
+  created_at: string;
 
   @ApiProperty({
     type: 'enum',

BE/src/study-logs/study-logs.controller.ts

@@ -38,15 +38,11 @@ export class StudyLogsController {
     @User('id') userId: number,
     @Body() studyLogsData: StudyLogsCreateDto,
   ): Promise<ResponseDto> {
-    const { created_at, learning_time, type } = studyLogsData;
+    const { type } = studyLogsData;
     if (type === 'start') {
       await this.studyLogsService.createStartLog(studyLogsData, userId);
       return new ResponseDto(200, 'OK');
     }
-    studyLogsData.date = this.studyLogsService.calculateStartDay(
-      new Date(created_at),
-      learning_time,
-    );
     await this.studyLogsService.createFinishLog(studyLogsData, userId);
     return new ResponseDto(200, 'OK');
   }

BE/src/study-logs/study-logs.service.ts

@@ -25,25 +25,35 @@ export class StudyLogsService {
     user_id: number,
   ): Promise<void> {
     const { created_at } = studyLogsData;
-    await this.redisService.set(`${user_id}`, `${created_at}`);
+    await this.redisService.hset(`${user_id}`, 'started_at', `${created_at}`);
+    await this.redisService.hset(`${user_id}`, 'received_at', `${Date.now()}`);
   }
 
   async createFinishLog(
     studyLogsData: StudyLogsCreateDto,
     user_id: number,
-  ): Promise<StudyLogsDto> {
-    const { category_id, ...data } = studyLogsData;
+  ): Promise<void> {
+    const { category_id } = studyLogsData;
     const user = { id: user_id } as UsersModel;
     const category = { id: category_id ?? null } as Categories;
 
-    const studyLog = this.studyLogsRepository.create({
-      ...data,
-      user_id: user,
-      category_id: category,
-    });
-    const savedStudyLog = await this.studyLogsRepository.save(studyLog);
+    const learningTimes = this.calculateLearningTimes(
+      studyLogsData.created_at,
+      studyLogsData.learning_time,
+    );
+
+    for (const { started_at, date, learning_time } of learningTimes) {
+      const studyLog = this.studyLogsRepository.create({
+        type: 'finish',
+        date,
+        learning_time,
+        created_at: started_at,
+        user_id: user,
+        category_id: category,
+      });
+      await this.studyLogsRepository.save(studyLog);
+    }
     await this.redisService.del(`${user_id}`);
-    return this.entityToDto(savedStudyLog);
   }
 
   async findAll(): Promise<StudyLogs[]> {
@@ -59,6 +69,38 @@ export class StudyLogsService {
     return started_at;
   }
 
+  calculateLearningTimes(
+    created_at: string,
+    learning_time: number,
+  ): { started_at: string; date: string; learning_time: number }[] {
+    const finishedAt = moment(new Date(created_at));
+    const startedAt = finishedAt.clone().subtract(learning_time, 's');
+    if (startedAt.get('date') !== finishedAt.get('date')) {
+      return [
+        {
+          started_at: startedAt.toISOString(),
+          date: startedAt.format('YYYY-MM-DD'),
+          learning_time:
+            startedAt.clone().endOf('day').diff(startedAt, 's') + 1,
+        },
+        {
+          started_at: finishedAt.clone().startOf('day').toISOString(),
+          date: finishedAt.format('YYYY-MM-DD'),
+          learning_time: finishedAt
+            .clone()
+            .diff(finishedAt.clone().startOf('day'), 's'),
+        },
+      ];
+    }
+    return [
+      {
+        started_at: startedAt.toISOString(),
+        date: startedAt.format('YYYY-MM-DD'),
+        learning_time: learning_time,
+      },
+    ];
+  }
+
   async calculateTotalTimes(
     user_id: number,
     start_date: string,