chore: complete the the invoice module - not tested

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();
+    }
+  }
 }