Feature/issue 38

MoyeoRun_K8s/main-server-deployment.yaml

@@ -23,7 +23,7 @@ spec:
           envFrom:
             - secretRef:
                 name: main-secrets
-          image: dnatuna/moyeorun-main-server:0.0.12
+          image: dnatuna/moyeorun-main-server:0.0.18
           name: main-server
           ports:
             - containerPort: 3000

MoyeoRun_Main/src/repository/multi-room.repository.ts

@@ -113,7 +113,11 @@ export class MultiRoomRepository {
         id,
       },
       include: {
-        multiRoomMember: true,
+        multiRoomMember: {
+          include: {
+            multiRoomUser: true,
+          },
+        },
       },
     });
   }

MoyeoRun_Main/src/running/controllers/running.controller.ts

@@ -10,13 +10,13 @@ import {
 import { User } from 'src/auth/decorators/auth.decorator';
 import { DeserializeAccessToken } from 'src/auth/dto/auth.dto';
 import { JwtAccessAuthGuard } from 'src/auth/guards/access-jwt-auth.guard';
-import { MultiListElement } from '../dto/multi-room.dto';
 import {
+  MultiRunningListResponse,
   MultiRunningRequest,
   RunningListRequest,
-  RunningListResponse,
   RunningRequest,
   RunningResponse,
+  SingleRunningListResponse,
 } from '../dto/running.dto';
 import { MultiRunningService } from '../services/multi-running.service';
 import { RunningService } from '../services/running.service';
@@ -51,7 +51,7 @@ export class RunningController {
   getSingleRunList(
     @User() user: DeserializeAccessToken,
     @Query() params: RunningListRequest,
-  ): Promise<RunningListResponse> {
+  ): Promise<SingleRunningListResponse> {
     return this.runningService.getSingleRunList(user, params);
   }
 
@@ -60,7 +60,7 @@ export class RunningController {
   getMultiRunList(
     @User() user: DeserializeAccessToken,
     @Query() params: RunningListRequest,
-  ): Promise<MultiListElement[]> {
+  ): Promise<MultiRunningListResponse> {
     return this.runningService.getMultiRunList(user, params);
   }
 

MoyeoRun_Main/src/running/dto/running.dto.ts

@@ -12,6 +12,7 @@ import {
 } from 'class-validator';
 import { DeserializeAccessToken } from 'src/auth/dto/auth.dto';
 import { RunDataType, RunningType } from '../running.type';
+import { MultiListElement } from './multi-room.dto';
 
 export class RunningRequest {
   @IsEnum(RunningType)
@@ -51,7 +52,7 @@ export class RunningListRequest {
   end: Date;
 }
 
-export class RunningListResponse {
+export class SingleRunningListResponse {
   @IsNumber()
   totalDistance: number;
 
@@ -68,6 +69,23 @@ export class RunningListResponse {
   runningList: RunningResponse[];
 }
 
+export class MultiRunningListResponse {
+  @IsNumber()
+  totalDistance: number;
+
+  @IsNumber()
+  totalAveragePace: number;
+
+  @IsNumber()
+  totalTime: number;
+
+  @IsObject()
+  analysisRunningListBetweenTerm: analysisRunningListBetweenTerm[];
+
+  @IsObject()
+  runningList: MultiListElement[];
+}
+
 export class updateRunningDatabase {
   @IsString()
   id: string;

MoyeoRun_Main/src/running/repositories/running.repository.ts

@@ -40,7 +40,7 @@ export class RunningRepository {
     return await this.runningModel.find().where({ _id: ids });
   }
 
-  async findByUserBetweenTerm(
+  async findByUserAndNotMultiBetweenTerm(
     user: DeserializeAccessToken,
     start: Date,
     end: Date,
@@ -57,6 +57,21 @@ export class RunningRepository {
     });
   }
 
+  async findByUserAndMultiBetweenTerm(
+    user: DeserializeAccessToken,
+    start: Date,
+    end: Date,
+  ): Promise<Runnings[]> {
+    return await this.runningModel.find({
+      user: user,
+      type: RunningType['multi'],
+      createdAt: {
+        $gte: start,
+        $lte: end,
+      },
+    });
+  }
+
   async updateOneRunning({
     id,
     runDistance,
@@ -92,13 +107,51 @@ export class RunningRepository {
     );
   }
 
-  async countByCreatedAtBetweenTerm(
+  async countByCreatedAtAndNotMultiBetweenTerm(
+    user: DeserializeAccessToken,
+    start: Date,
+    end: Date,
+  ): Promise<analysisRunningListBetweenTerm[]> {
+    return await this.runningModel.aggregate([
+      { $match: { user: user } },
+      { $match: { type: { $ne: RunningType['multi'] } } },
+      { $match: { createdAt: { $gte: start, $lte: end } } },
+      {
+        $group: {
+          _id: {
+            year: { $year: '$createdAt' },
+            month: { $month: '$createdAt' },
+            day: { $dayOfMonth: '$createdAt' },
+          },
+          count: { $sum: 1 },
+          distance: { $sum: '$runDistance' },
+          time: { $sum: '$runTime' },
+          pace: { $avg: '$runPace' },
+          first: { $min: '$createdAt' },
+        },
+      },
+      { $sort: { _id: 1 } },
+      {
+        $project: {
+          date: '$first',
+          count: 1,
+          totalDistanceOfTerm: '$distance',
+          totalTimeOfTerm: '$time',
+          averagePaceOfTerm: '$pace',
+          _id: 0,
+        },
+      },
+    ]);
+  }
+
+  async countByCreatedAtAndMultiBetweenTerm(
     user: DeserializeAccessToken,
     start: Date,
     end: Date,
   ): Promise<analysisRunningListBetweenTerm[]> {
     return await this.runningModel.aggregate([
       { $match: { user: user } },
+      { $match: { type: RunningType['multi'] } },
       { $match: { createdAt: { $gte: start, $lte: end } } },
       {
         $group: {

MoyeoRun_Main/src/running/services/running.service.ts

@@ -7,14 +7,17 @@ import { MultiRoomMemberRepository } from 'src/repository/multi-room-member.repo
 import { MultiRoomRepository } from 'src/repository/multi-room.repository';
 import { MultiListElement } from '../dto/multi-room.dto';
 import {
+  analysisRunningListBetweenTerm,
+  MultiRunningListResponse,
   RunningListRequest,
-  RunningListResponse,
   RunningRequest,
   RunningResponse,
   RunSummary,
+  SingleRunningListResponse,
 } from '../dto/running.dto';
 import { RunDataRepository } from '../repositories/run-data.repository';
 import { RunningRepository } from '../repositories/running.repository';
+import { RunningType } from '../running.type';
 import { Runnings } from '../schemas/runnings.schema';
 
 @Injectable()
@@ -107,6 +110,76 @@ export class RunningService {
     return runSummary;
   }
 
+  private async calculateTerm(
+    user: DeserializeAccessToken,
+    type: RunningType,
+    params: RunningListRequest,
+  ): Promise<{
+    totalDistance: number;
+    totalTime: number;
+    totalAveragePace: number;
+    analysisRunningListBetweenTerm: analysisRunningListBetweenTerm[];
+    findRunning: Runnings[];
+  }> {
+    let findRunning: Runnings[];
+    console.log(type);
+    console.log(typeof type);
+    if (type == RunningType['multi']) {
+      findRunning = await this.runningRepository.findByUserAndMultiBetweenTerm(
+        user,
+        new Date(params.start),
+        new Date(params.end),
+      );
+    } else {
+      findRunning =
+        await this.runningRepository.findByUserAndNotMultiBetweenTerm(
+          user,
+          new Date(params.start),
+          new Date(params.end),
+        );
+    }
+
+    if (!findRunning) {
+      throw new HttpException('러닝이 존재하지 않습니다', 204);
+    }
+
+    let analysisRunningListBetweenTerm;
+    if (type == RunningType['multi']) {
+      analysisRunningListBetweenTerm =
+        await this.runningRepository.countByCreatedAtAndMultiBetweenTerm(
+          user,
+          new Date(params.start),
+          new Date(params.end),
+        );
+    } else {
+      analysisRunningListBetweenTerm =
+        await this.runningRepository.countByCreatedAtAndNotMultiBetweenTerm(
+          user,
+          new Date(params.start),
+          new Date(params.end),
+        );
+    }
+
+    let totalDistance = 0,
+      totalTime = 0,
+      totalAveragePace = 0;
+
+    analysisRunningListBetweenTerm.map((data) => {
+      totalDistance += data.totalDistanceOfTerm;
+      totalTime += data.totalTimeOfTerm;
+      totalAveragePace += data.averagePaceOfTerm;
+    });
+    totalAveragePace /= analysisRunningListBetweenTerm.length;
+
+    return {
+      totalDistance,
+      totalTime,
+      totalAveragePace,
+      analysisRunningListBetweenTerm,
+      findRunning,
+    };
+  }
+
   async getRunning(id: string): Promise<RunningResponse> {
     try {
       const findRunning = await this.runningRepository.findById(id);
@@ -138,37 +211,17 @@ export class RunningService {
   async getSingleRunList(
     user: DeserializeAccessToken,
     params: RunningListRequest,
-  ): Promise<RunningListResponse> {
+  ): Promise<SingleRunningListResponse> {
     try {
-      const findRunning = await this.runningRepository.findByUserBetweenTerm(
-        user,
-        new Date(params.start),
-        new Date(params.end),
-      );
-
-      if (!findRunning) {
-        throw new HttpException('러닝이 존재하지 않습니다', 204);
-      }
-
-      const analysisRunningListBetweenTerm =
-        await this.runningRepository.countByCreatedAtBetweenTerm(
-          user,
-          new Date(params.start),
-          new Date(params.end),
-        );
-
-      let totalDistance = 0,
-        totalTime = 0,
-        totalAveragePace = 0;
-
-      analysisRunningListBetweenTerm.map((data) => {
-        totalDistance += data.totalDistanceOfTerm;
-        totalTime += data.totalTimeOfTerm;
-        totalAveragePace += data.averagePaceOfTerm;
-      });
-      totalAveragePace /= analysisRunningListBetweenTerm.length;
+      const {
+        totalDistance,
+        totalAveragePace,
+        totalTime,
+        analysisRunningListBetweenTerm,
+        findRunning,
+      } = await this.calculateTerm(user, RunningType['free'], params);
 
-      const runningListResponse: RunningListResponse = {
+      const runningListResponse: SingleRunningListResponse = {
         totalTime,
         totalDistance,
         totalAveragePace,
@@ -189,7 +242,13 @@ export class RunningService {
   async getMultiRunList(
     user: DeserializeAccessToken,
     params: RunningListRequest,
-  ): Promise<MultiListElement[]> {
+  ): Promise<MultiRunningListResponse> {
+    const {
+      totalDistance,
+      totalAveragePace,
+      totalTime,
+      analysisRunningListBetweenTerm,
+    } = await this.calculateTerm(user, RunningType['multi'], params);
     const multiList =
       await this.multiRoomMemberRepository.findByUserIdWithMultiRoomBetweenTerm(
         user.id,
@@ -207,7 +266,14 @@ export class RunningService {
       });
     });
 
-    return multiListResponse;
+    const runningListResponse: MultiRunningListResponse = {
+      totalTime,
+      totalDistance,
+      totalAveragePace,
+      analysisRunningListBetweenTerm,
+      runningList: multiListResponse,
+    };
+    return runningListResponse;
   }
 
   async getMultiRun(user: DeserializeAccessToken, id: number) {