chore: complete the the invoice module - not tested

src/modules/subscriptions/DTO/service-id.param.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsNotEmpty, IsUUID } from "class-validator";
+
+import { CommonMessage } from "../../../common/enums/message.enum";
+
+export class ServiceIdParamDto {
+  @IsNotEmpty({ message: CommonMessage.ID_REQUIRED })
+  @IsUUID("4", { message: CommonMessage.ID_SHOULD_BE_UUID })
+  @ApiProperty({ description: "Id of danak service", example: "8b1e8b1e-8b1e-8b1e-8b1e-8b1e8b1e8b1e" })
+  serviceId: string;
+}

src/modules/subscriptions/DTO/subscribe-service.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { IsNotEmpty, IsUUID } from "class-validator";
+
+import { SubscriptionMessage } from "../../../common/enums/message.enum";
+
+export class SubscribeServiceDto {
+  @IsNotEmpty({ message: SubscriptionMessage.PLAN_ID_REQUIRED })
+  @IsUUID(4, { message: SubscriptionMessage.PLAN_ID_SHOULD_BE_UUID })
+  @ApiProperty({ description: "The plan id to subscribe to", example: "f7b3b3b3-7b3b-4b3b-8b3b-3b3b3b3b3b3b" })
+  planId: string;
+}

src/modules/subscriptions/DTO/update-subscription.dto.ts

@@ -0,0 +1,5 @@
+import { PartialType } from "@nestjs/swagger";
+
+import { CreateSubscriptionPlanDto } from "./create-subscription.dto";
+
+export class UpdateSubscriptionPlanDto extends PartialType(CreateSubscriptionPlanDto) {}

src/modules/subscriptions/entities/user-subscription.entity.ts

@@ -3,6 +3,7 @@ import { Column, Entity, ManyToOne } from "typeorm";
 import { SubscriptionPlan } from "./subscription.entity";
 import { BaseEntity } from "../../../common/entities/base.entity";
 import { User } from "../../users/entities/user.entity";
+import { SubscriptionStatus } from "../enums/subscription-status.enum";
 
 @Entity()
 export class UserSubscription extends BaseEntity {
@@ -18,6 +19,9 @@ export class UserSubscription extends BaseEntity {
   @Column({ type: "timestamp", nullable: false })
   endDate: Date;
 
+  @Column({ type: "enum", enum: SubscriptionStatus, default: SubscriptionStatus.PENDING })
+  status: SubscriptionStatus;
+
   @Column({ type: "boolean", default: false })
   isCanceled: boolean;
 }

src/modules/subscriptions/enums/subscription-status.enum.ts

@@ -0,0 +1,7 @@
+export enum SubscriptionStatus {
+  ACTIVE = "ACTIVE",
+  INACTIVE = "INACTIVE",
+  PENDING = "PENDING",
+  CANCELED = "CANCELED",
+  EXPIRED = "EXPIRED",
+}

src/modules/subscriptions/providers/subscriptions.service.ts

@@ -1,15 +1,33 @@
 import { BadRequestException, Injectable } from "@nestjs/common";
+// eslint-disable-next-line import/no-named-as-default
+import Decimal from "decimal.js";
+import { DataSource } from "typeorm";
 
-import { ServiceMessage, SubscriptionMessage } from "../../../common/enums/message.enum";
+import { ServiceMessage, SubscriptionMessage, WalletMessage } from "../../../common/enums/message.enum";
 import { DanakServicesService } from "../../danak-services/providers/danak-services.service";
+import { InvoicesService } from "../../invoices/providers/invoices.service";
+import { UsersService } from "../../users/providers/users.service";
+import { Wallet } from "../../wallets/entities/wallet.entity";
+import { WalletsService } from "../../wallets/providers/wallets.service";
 import { CreateSubscriptionPlanDto } from "../DTO/create-subscription.dto";
+import { SubscribeServiceDto } from "../DTO/subscribe-service.dto";
+import { UpdateSubscriptionPlanDto } from "../DTO/update-subscription.dto";
+import { SubscriptionPlan } from "../entities/subscription.entity";
+import { UserSubscription } from "../entities/user-subscription.entity";
+import { SubscriptionStatus } from "../enums/subscription-status.enum";
 import { SubscriptionsPlanRepository } from "../repositories/subscriptions.repository";
+// import { UserSubscriptionsRepository } from "../repositories/user-subscriptions.repository";
 
 @Injectable()
 export class SubscriptionsService {
   constructor(
     private readonly subscriptionsPlanRepository: SubscriptionsPlanRepository,
+    // private readonly userSubscriptionsRepository: UserSubscriptionsRepository,
+    private readonly invoicesService: InvoicesService,
+    private readonly usersService: UsersService,
+    private readonly walletsService: WalletsService,
     private readonly danakServices: DanakServicesService,
+    private readonly dataSource: DataSource,
   ) {}
 
   //************************************ */
@@ -20,7 +38,7 @@ export class SubscriptionsService {
     const existSubscription = await this.subscriptionsPlanRepository.findOneByName(createDto.name);
     if (existSubscription) throw new BadRequestException(SubscriptionMessage.NAME_EXIST);
 
-    const subscription = this.subscriptionsPlanRepository.create(createDto);
+    const subscription = this.subscriptionsPlanRepository.create({ ...createDto, service: { id: createDto.serviceId } });
     await this.subscriptionsPlanRepository.save(subscription);
     return {
       message: SubscriptionMessage.CREATED,
@@ -28,21 +46,107 @@ export class SubscriptionsService {
     };
   }
   //************************************ */
-  async updateSubscriptionPlan(id: string, updateDto: CreateSubscriptionPlanDto) {
-    const danakService = await this.danakServices.findServiceById(updateDto.serviceId);
-    if (!danakService) throw new BadRequestException(ServiceMessage.SERVICE_NOT_FOUND_BY_ID);
+  async updateSubscriptionPlan(id: string, updateDto: UpdateSubscriptionPlanDto) {
+    if (updateDto.serviceId) {
+      const danakService = await this.danakServices.findServiceById(updateDto.serviceId);
+      if (!danakService) throw new BadRequestException(ServiceMessage.SERVICE_NOT_FOUND_BY_ID);
+    }
 
     const subscription = await this.subscriptionsPlanRepository.findOneBy({ id });
     if (!subscription) throw new BadRequestException(SubscriptionMessage.NOT_FOUND);
 
-    const existSubscription = await this.subscriptionsPlanRepository.findOneByName(updateDto.name, id);
-    if (existSubscription) throw new BadRequestException(SubscriptionMessage.NAME_EXIST);
+    if (updateDto.name) {
+      const existSubscription = await this.subscriptionsPlanRepository.findOneByName(updateDto.name, id);
+      if (existSubscription) throw new BadRequestException(SubscriptionMessage.NAME_EXIST);
+    }
 
     await this.subscriptionsPlanRepository.update(id, updateDto);
-    await this.subscriptionsPlanRepository.save({ ...subscription, ...updateDto, service: danakService });
+    await this.subscriptionsPlanRepository.save({
+      ...subscription,
+      ...updateDto,
+      service: updateDto.serviceId ? { id: updateDto.serviceId } : subscription.service,
+    });
     return {
       message: SubscriptionMessage.UPDATED,
       subscription,
     };
   }
+  //************************************ */
+
+  async getSubscriptionPlanById(subscriptionId: string) {
+    const subscription = await this.subscriptionsPlanRepository.findOneBy({ id: subscriptionId });
+    if (!subscription) throw new BadRequestException(SubscriptionMessage.NOT_FOUND);
+    return {
+      subscription,
+    };
+  }
+  //************************************ */
+
+  async getSubscriptionsPlans() {
+    const subscriptions = await this.subscriptionsPlanRepository.find({ relations: ["service"] });
+    return {
+      subscriptions,
+    };
+  }
+
+  //************************************ */
+
+  async subscribeToPlan(serviceId: string, subscribeDto: SubscribeServiceDto, userId: string) {
+    const queryRunner = this.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+      const user = await this.usersService.findOneByIdWithQueryRunner(userId, queryRunner);
+
+      const plan = await queryRunner.manager.findOne(SubscriptionPlan, {
+        where: { id: subscribeDto.planId, service: { id: serviceId } },
+        relations: {
+          service: true,
+        },
+      });
+
+      if (!plan) throw new BadRequestException(SubscriptionMessage.NOT_FOUND);
+
+      const startDate = new Date();
+      const endDate = new Date();
+      endDate.setDate(startDate.getDate() + plan.duration);
+      //
+      const userSubscription = queryRunner.manager.create(UserSubscription, { user, plan, startDate, endDate });
+
+      await queryRunner.manager.save(UserSubscription, userSubscription);
+
+      const userWallet = await this.walletsService.getWalletByUserId(user.id, queryRunner);
+
+      if (userWallet.balance < plan.price) throw new BadRequestException(WalletMessage.INSUFFICIENT_BALANCE);
+
+      //
+      userWallet.balance = new Decimal(userWallet.balance).sub(plan.price);
+
+      await queryRunner.manager.save(Wallet, userWallet);
+      //
+
+      await this.walletsService.createSubscriptionTransaction(plan.price, userWallet.id, queryRunner);
+      //TODO: need queue handling for notification
+      const invoiceDueDate = new Date(userSubscription.endDate);
+      invoiceDueDate.setDate(userSubscription.endDate.getDate() - 3);
+
+      const invoice = await this.invoicesService.createInvoiceForSubscription(userId, plan, invoiceDueDate, queryRunner);
+
+      userSubscription.status = SubscriptionStatus.ACTIVE;
+
+      await queryRunner.manager.save(UserSubscription, userSubscription);
+
+      await queryRunner.commitTransaction();
+      return {
+        message: SubscriptionMessage.SUBSCRIBED,
+        userSubscription,
+        invoice,
+      };
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      throw error;
+    } finally {
+      await queryRunner.release();
+    }
+  }
 }

src/modules/subscriptions/subscriptions.controller.ts

@@ -1,10 +1,15 @@
-import { Body, Controller, Post } from "@nestjs/common";
+import { Body, Controller, Get, Param, Patch, Post } from "@nestjs/common";
 import { ApiOperation } from "@nestjs/swagger";
 
 import { CreateSubscriptionPlanDto } from "./DTO/create-subscription.dto";
+import { ServiceIdParamDto } from "./DTO/service-id.param.dto";
+import { SubscribeServiceDto } from "./DTO/subscribe-service.dto";
+import { UpdateSubscriptionPlanDto } from "./DTO/update-subscription.dto";
 import { SubscriptionsService } from "./providers/subscriptions.service";
 import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
 import { Roles } from "../../common/decorators/roles.decorator";
+import { UserDec } from "../../common/decorators/user.decorator";
+import { ParamDto } from "../../common/DTO/param.dto";
 import { RoleEnum } from "../users/enums/role.enum";
 
 @Controller("subscriptions")
@@ -14,8 +19,40 @@ export class SubscriptionsController {
   @ApiOperation({ summary: "Create a subscription plan" })
   @AuthGuards()
   @Roles(RoleEnum.ADMIN)
-  @Post("/plan")
+  @Post()
   createSubscription(@Body() createDto: CreateSubscriptionPlanDto) {
     return this.subscriptionService.createSubscriptionsPlan(createDto);
   }
+
+  @ApiOperation({ summary: "get all subscription plans" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Get()
+  getAllSubscriptions() {
+    return this.subscriptionService.getSubscriptionsPlans();
+  }
+
+  @ApiOperation({ summary: "get a subscription plan by id" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Get(":id")
+  getSubscription(@Param() paramDto: ParamDto) {
+    return this.subscriptionService.getSubscriptionPlanById(paramDto.id);
+  }
+
+  @ApiOperation({ summary: "update a subscription plan by id" })
+  @AuthGuards()
+  @Roles(RoleEnum.ADMIN)
+  @Patch(":id")
+  updateSubscription(@Param() paramDto: ParamDto, @Body() updateDto: UpdateSubscriptionPlanDto) {
+    return this.subscriptionService.updateSubscriptionPlan(paramDto.id, updateDto);
+  }
+
+  @ApiOperation({ summary: "subscribe to a service ==> user route" })
+  @AuthGuards()
+  @Roles(RoleEnum.USER)
+  @Post(":serviceId/subscribe")
+  subscribe(@Param() paramDto: ServiceIdParamDto, @Body() subscribeDto: SubscribeServiceDto, @UserDec("id") userId: string) {
+    return this.subscriptionService.subscribeToPlan(paramDto.serviceId, subscribeDto, userId);
+  }
 }

src/modules/subscriptions/subscriptions.module.ts

@@ -8,9 +8,18 @@ import { SubscriptionsPlanRepository } from "./repositories/subscriptions.reposi
 import { UserSubscriptionsRepository } from "./repositories/user-subscriptions.repository";
 import { SubscriptionsController } from "./subscriptions.controller";
 import { DanakServicesModule } from "../danak-services/danak-services.module";
+import { InvoicesModule } from "../invoices/invoices.module";
+import { UsersModule } from "../users/users.module";
+import { WalletsModule } from "../wallets/wallets.module";
 
 @Module({
-  imports: [TypeOrmModule.forFeature([SubscriptionPlan, UserSubscription]), DanakServicesModule],
+  imports: [
+    TypeOrmModule.forFeature([SubscriptionPlan, UserSubscription]),
+    DanakServicesModule,
+    UsersModule,
+    WalletsModule,
+    InvoicesModule,
+  ],
   providers: [SubscriptionsService, SubscriptionsPlanRepository, UserSubscriptionsRepository],
   controllers: [SubscriptionsController],
   exports: [SubscriptionsService],