Merge branch 'development' into docs/README

apps/server/src/app.module.ts

@@ -9,20 +9,24 @@ import { PrivateArchitectureModule } from 'src/private-architecture/private-arch
 import { PrismaService } from 'src/prisma/prisma.service';
 import { MyModule } from './my/my.module';
 import { ScheduleModule } from '@nestjs/schedule';
-import { NcloudResourcesService } from './ncloud-resources/ncloud-resources.service.js';
-import { CloudsModule } from './clouds/clouds.module';
-import { resourceUsage } from 'process';
+import { NcloudResourcesService } from './ncloud-resource/ncloud-resource.service.js';
+import { CloudModule } from './cloud/cloud.module';
+import { RedisModule } from '@nestjs-modules/ioredis';
 
 @Module({
     imports: [
+        RedisModule.forRoot({
+            type: 'single',
+            url: `redis://${process.env.REDIS_HOST}:${process.env.REDIS_PORT}`,
+        }),
         ConfigModule.forRoot(),
         AuthModule,
         UserModule,
         PublicArchitectureModule,
         PrivateArchitectureModule,
         MyModule,
         ScheduleModule.forRoot(),
-        CloudsModule,
+        CloudModule,
     ],
     controllers: [AppController],
     providers: [AppService, PrismaService, NcloudResourcesService],

apps/server/src/clouds/clouds.controller.spec.ts → apps/server/src/cloud/cloud.controller.spec.ts

@@ -1,15 +1,15 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { CloudsController } from './clouds.controller';
+import { CloudController } from './cloud.controller';
 
-describe('CloudsController', () => {
-    let controller: CloudsController;
+describe('CloudController', () => {
+    let controller: CloudController;
 
     beforeEach(async () => {
         const module: TestingModule = await Test.createTestingModule({
-            controllers: [CloudsController],
+            controllers: [CloudController],
         }).compile();
 
-        controller = module.get<CloudsController>(CloudsController);
+        controller = module.get<CloudController>(CloudController);
     });
 
     it('should be defined', () => {

apps/server/src/cloud/cloud.controller.ts

@@ -0,0 +1,17 @@
+import { Controller, Get } from '@nestjs/common';
+import { CloudService } from './cloud.service';
+
+@Controller('cloud')
+export class CloudController {
+    constructor(private readonly service: CloudService) {}
+
+    @Get('/prices')
+    getCloudResorucePrices() {
+        return this.service.findCloudResourcePrices();
+    }
+
+    // @Get('/test')
+    // getTestPrices() {
+    //     return this.service.calculatePrice();
+    // }
+}

apps/server/src/cloud/cloud.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { CloudController } from './cloud.controller';
+import { CloudService } from './cloud.service';
+import { PrismaModule } from 'src/prisma/prisma.module';
+
+@Module({
+    imports: [PrismaModule],
+    controllers: [CloudController],
+    providers: [CloudService],
+    exports: [CloudService],
+})
+export class CloudModule {}

apps/server/src/clouds/clouds.service.spec.ts → apps/server/src/cloud/cloud.service.spec.ts

@@ -1,15 +1,15 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { CloudsService } from './clouds.service';
+import { CloudService } from './cloud.service';
 
-describe('CloudsService', () => {
-    let service: CloudsService;
+describe('CloudService', () => {
+    let service: CloudService;
 
     beforeEach(async () => {
         const module: TestingModule = await Test.createTestingModule({
-            providers: [CloudsService],
+            providers: [CloudService],
         }).compile();
 
-        service = module.get<CloudsService>(CloudsService);
+        service = module.get<CloudService>(CloudService);
     });
 
     it('should be defined', () => {

apps/server/src/cloud/cloud.service.ts

@@ -0,0 +1,65 @@
+import { InjectRedis } from '@nestjs-modules/ioredis';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import Redis from 'ioredis';
+import { PrismaService } from 'src/prisma/prisma.service';
+
+@Injectable()
+export class CloudService {
+    constructor(
+        private readonly prisma: PrismaService,
+        @InjectRedis() private readonly redis: Redis,
+    ) {}
+
+    async findCloudResourcePrices() {
+        return Object.fromEntries(await this.getCloudResourcesMap());
+    }
+
+    async calculatePrice(nodes: Record<string, any>) {
+        if (nodes && !Object.keys(nodes).length) throw new NotFoundException();
+        const cloudResourcesPriceMap = await this.getCloudResourcesMap();
+        const nodeValues = Object.values(nodes);
+        const totalMonthPrice = nodeValues.reduce(
+            (price, nodeValue): number => {
+                if (nodeValue.properties['server_spec_code']) {
+                    if (
+                        !cloudResourcesPriceMap.has(
+                            nodeValue.properties['server_spec_code'],
+                        )
+                    )
+                        throw new NotFoundException();
+                    price += cloudResourcesPriceMap.get(
+                        nodeValue.properties['server_spec_code'],
+                    ).monthCost as number;
+                    return price;
+                }
+                return price;
+            },
+            0,
+        );
+        return { totalMonthPrice };
+    }
+
+    private async getCloudResourcesMap() {
+        const cachePrices = JSON.parse(await this.redis.get('cloudResource'));
+        const prices =
+            cachePrices ||
+            (await this.prisma.ncloudServerResource.findMany({
+                select: {
+                    serverSpecCode: true,
+                    productName: true,
+                    hourCost: true,
+                    monthCost: true,
+                },
+            }));
+        const priceMap = new Map<string, Record<string, number | string>>();
+        prices.map((price) => {
+            const { productName, hourCost, monthCost } = price;
+            priceMap.set(price.serverSpecCode, {
+                productName,
+                hourCost,
+                monthCost,
+            });
+        });
+        return priceMap;
+    }
+}

apps/server/src/ncloud-resources/ncloud-resources.service.spec.ts → apps/server/src/ncloud-resource/ncloud-resource.service.spec.ts

@@ -1,5 +1,5 @@
 import { Test, TestingModule } from '@nestjs/testing';
-import { NcloudResourcesService } from './ncloud-resources.service';
+import { NcloudResourcesService } from './ncloud-resource.service';
 
 describe('NcloudResourcesService', () => {
     let service: NcloudResourcesService;

apps/server/src/ncloud-resources/ncloud-resources.service.ts → apps/server/src/ncloud-resource/ncloud-resource.service.ts

@@ -1,12 +1,16 @@
 import { Ncloud, PriceApi, ApiKeyCredentials } from '@cloud-canvas/ncloud-sdk';
+import { InjectRedis } from '@nestjs-modules/ioredis';
 import { Injectable } from '@nestjs/common';
 import { Cron, CronExpression } from '@nestjs/schedule';
+import Redis from 'ioredis';
 import { PrismaService } from 'src/prisma/prisma.service';
-import { writeFile } from 'fs/promises';
 
 @Injectable()
 export class NcloudResourcesService {
-    constructor(private readonly prisma: PrismaService) {}
+    constructor(
+        private readonly prisma: PrismaService,
+        @InjectRedis() private readonly redis: Redis,
+    ) {}
 
     @Cron(CronExpression.EVERY_DAY_AT_3AM, {
         name: 'Insert Ncloud Resource Cron Job',
@@ -93,6 +97,10 @@ export class NcloudResourcesService {
             await tx.ncloudServerResource.createMany({
                 data: flattenedResources,
             });
+            await this.redis.set(
+                'cloudResource',
+                JSON.stringify(flattenedResources),
+            );
         });
     }
 

apps/server/src/private-architecture/private-architecture.module.ts

@@ -2,9 +2,10 @@ import { Module } from '@nestjs/common';
 import { PrivateArchitectureService } from './private-architecture.service';
 import { PrivateArchitectureController } from './private-architecture.controller';
 import { PrismaModule } from 'src/prisma/prisma.module';
+import { CloudModule } from 'src/cloud/cloud.module';
 
 @Module({
-    imports: [PrismaModule],
+    imports: [PrismaModule, CloudModule],
     controllers: [PrivateArchitectureController],
     providers: [PrivateArchitectureService],
 })

apps/server/src/private-architecture/private-architecture.service.ts

@@ -8,23 +8,27 @@ import { RemoveArchitectureDto } from './dto/remove-architecture.dto';
 import { RemoveVersionDto } from './dto/remove-version.dto';
 import { SaveArchitectureDto } from './dto/save-architecture.dto';
 import { SaveVersionDto } from './dto/save-version.dto';
+import { CloudService } from 'src/cloud/cloud.service';
 
 @Injectable()
 export class PrivateArchitectureService {
-    constructor(private readonly prisma: PrismaService) {}
+    constructor(
+        private readonly prisma: PrismaService,
+        private readonly cloud: CloudService,
+    ) {}
 
-    saveArchitecture({
+    async saveArchitecture({
         title,
         userId: authorId,
         architecture,
-        cost,
     }: SaveArchitectureDto) {
+        const cost = await this.cloud.calculatePrice(architecture?.nodes);
         return this.prisma.privateArchitecture.create({
             data: {
                 title,
                 authorId,
                 architecture,
-                cost,
+                cost: cost.totalMonthPrice,
             },
         });
     }
@@ -53,9 +57,9 @@ export class PrivateArchitectureService {
         userId: authorId,
         title,
         architecture,
-        cost,
     }: ModifyArchitectureDto) {
         const isAuthor = await this.isArchitectureAuthor(id, authorId);
+        const cost = await this.cloud.calculatePrice(architecture?.nodes);
         if (!isAuthor) throw new ForbiddenException();
         return this.prisma.privateArchitecture.update({
             where: {
@@ -65,7 +69,7 @@ export class PrivateArchitectureService {
             data: {
                 title,
                 architecture,
-                cost,
+                cost: cost.totalMonthPrice,
             },
         });
     }
@@ -108,16 +112,16 @@ export class PrivateArchitectureService {
         userId: authorId,
         title,
         architecture,
-        cost,
     }: SaveVersionDto) {
         const isAuthor = await this.isArchitectureAuthor(id, authorId);
+        const cost = await this.cloud.calculatePrice(architecture?.nodes);
         if (!isAuthor) throw new ForbiddenException();
         return this.prisma.version.create({
             data: {
                 privateArchitectureId: id,
                 title,
                 architecture,
-                cost,
+                cost: cost.totalMonthPrice,
             },
         });
     }

apps/server/src/public-architecture/public-architecture.module.ts

@@ -2,9 +2,10 @@ import { Module } from '@nestjs/common';
 import { PublicArchitectureService } from './public-architecture.service';
 import { PublicArchitectureController } from './public-architecture.controller';
 import { PrismaModule } from 'src/prisma/prisma.module';
+import { CloudModule } from 'src/cloud/cloud.module';
 
 @Module({
-    imports: [PrismaModule],
+    imports: [PrismaModule, CloudModule],
     controllers: [PublicArchitectureController],
     providers: [PublicArchitectureService],
 })

apps/server/src/public-architecture/public-architecture.service.ts

@@ -13,10 +13,14 @@ import { RemoveArchitectureDto } from './dto/remove-architecture.dto';
 import { UnstarDto } from './dto/unstar.dto';
 import { StarDto } from './dto/star.dto';
 import { ImportDto } from './dto/import.dto';
+import { CloudService } from 'src/cloud/cloud.service';
 
 @Injectable()
 export class PublicArchitectureService {
-    constructor(private readonly prisma: PrismaService) {}
+    constructor(
+        private readonly prisma: PrismaService,
+        private readonly cloud: CloudService,
+    ) {}
 
     async findArchitectures(queryParams: FindArchitecturesDto) {
         const [data, total] = await this.prisma.$transaction([
@@ -55,18 +59,18 @@ export class PublicArchitectureService {
         return { data, total };
     }
 
-    saveArchitecture({
+    async saveArchitecture({
         title,
         architecture,
-        cost,
         tags,
         userId: authorId,
     }: SaveArchitectureDto) {
+        const cost = await this.cloud.calculatePrice(architecture?.nodes);
         return this.prisma.publicArchitecture.create({
             data: {
                 title,
                 architecture,
-                cost,
+                cost: cost.totalMonthPrice,
                 authorId,
                 tags: {
                     create: tags.map((name) => ({

apps/server/tsconfig.json

@@ -16,6 +16,7 @@
         "noImplicitAny": false,
         "strictBindCallApply": false,
         "forceConsistentCasingInFileNames": false,
-        "noFallthroughCasesInSwitch": false
+        "noFallthroughCasesInSwitch": false,
+        "resolveJsonModule": true
     }
 }