fix: refresh token invalidate for logout

src/modules/invoices/providers/invoices.service.ts

@@ -23,9 +23,11 @@ import { WalletsService } from "../../wallets/providers/wallets.service";
 import { INVOICE } from "../constants";
 import { CreateInvoiceDto } from "../DTO/create-invoice.dto";
 import { InvoicesSearchQueryDto, UserInvoicesSearchQueryDto } from "../DTO/invoices-search-query.dto";
+import { UpdateInvoiceDto } from "../DTO/update-invoice.dto";
 import { Invoice } from "../entities/invoice.entity";
 import { RecurringPeriodEnum } from "../enums/invoice-recurring-period.enum";
 import { InvoiceStatus } from "../enums/invoice-status.enum";
+import { InvoiceItemsRepository } from "../repositories/invoice-items.repository";
 import { InvoicesRepository } from "../repositories/invoices.repository";
 
 @Injectable()
@@ -36,6 +38,7 @@ export class InvoicesService {
     @InjectQueue(INVOICE.INVOICE_QUEUE_NAME) private readonly invoiceQueue: Queue,
     private readonly notificationsService: NotificationsService,
     private readonly invoiceRepository: InvoicesRepository,
+    private readonly invoiceItemsRepository: InvoiceItemsRepository,
     private readonly usersService: UsersService,
     private readonly walletsService: WalletsService,
     private readonly otpService: OTPService,
@@ -65,7 +68,7 @@ export class InvoicesService {
 
       const dueDate = dayjs().add(INVOICE.DUEDATE, "day").toDate();
 
-      const invoice = queryRunner.manager.create(Invoice, {
+      const invoice = queryRunner.manager.create(this.invoiceRepository.target, {
         user: { id: createDto.userId },
         totalPrice: totalPrice.add(tax).toNumber(),
         items: invoiceItems,
@@ -73,7 +76,7 @@ export class InvoicesService {
         dueDate,
       });
 
-      await queryRunner.manager.save(Invoice, invoice);
+      await queryRunner.manager.save(this.invoiceRepository.target, invoice);
 
       const user = await this.usersService.findOneByIdWithQueryRunner(createDto.userId, queryRunner);
 
@@ -92,33 +95,7 @@ export class InvoicesService {
         queryRunner,
       );
 
-      //add this to queue for billing reminder
-      await this.invoiceQueue.add(
-        INVOICE.INVOICE_REMINDER_JOB_NAME,
-        { invoiceId: invoice.id },
-        {
-          delay: dayjs(invoice.dueDate).subtract(INVOICE.DAYS_BEFORE_OVERDUE, "day").diff(dayjs()),
-          attempts: INVOICE.INVOICE_REMINDER_JOB_ATTEMPTS,
-          backoff: { type: "exponential", delay: INVOICE.INVOICE_REMINDER_JOB_BACKOFF },
-        },
-      );
-      //add to queue for recurring invoice
-      if (createDto.isRecurring && createDto.recurringPeriod) {
-        await this.invoiceQueue.add(
-          INVOICE.INVOICE_RECURRING_JOB_NAME,
-          {
-            invoiceId: invoice.id,
-            adminCreated: true,
-          },
-          {
-            delay: await this.calculateRecurringDelay(createDto.recurringPeriod),
-            attempts: INVOICE.INVOICE_RECURRING_JOB_ATTEMPTS,
-            backoff: { type: "exponential", delay: INVOICE.INVOICE_REMINDER_JOB_BACKOFF },
-          },
-        );
-
-        this.logger.log(`Scheduled recurring invoice for user ${createDto.userId} with interval ${createDto.recurringPeriod}`);
-      }
+      await this.scheduleInvoiceJobs(invoice, createDto);
       await queryRunner.commitTransaction();
 
       return {
@@ -135,6 +112,59 @@ export class InvoicesService {
 
   //********************************** */
 
+  //TODO: fix this
+  async updateInvoiceAdmin(invoiceId: string, updateDto: UpdateInvoiceDto) {
+    const queryRunner = this.dataSource.createQueryRunner();
+
+    try {
+      await queryRunner.connect();
+      await queryRunner.startTransaction();
+
+      const invoice = await queryRunner.manager.findOne(this.invoiceRepository.target, {
+        where: { id: invoiceId },
+        relations: { items: true },
+      });
+
+      if (!invoice) throw new BadRequestException(InvoiceMessage.NOT_FOUND_BY_ID);
+
+      if (invoice.status !== InvoiceStatus.PENDING) throw new BadRequestException(InvoiceMessage.INVOICE_CAN_NOT_UPDATE);
+
+      if (updateDto.items) {
+        const invoiceItemsData = updateDto.items.map((item) => ({
+          name: item.name,
+          count: item.count,
+          unitPrice: item.unitPrice,
+          discount: item.discount || 0,
+          totalPrice: item.unitPrice * item.count - (item.unitPrice * item.count * item.discount) / 100,
+        }));
+        // calculate total price and tax
+        const totalPrice = invoiceItemsData.reduce((sum, item) => new Decimal(item.totalPrice).add(sum), new Decimal(0));
+        const tax = totalPrice.mul(0.1);
+        invoice.totalPrice = totalPrice.add(tax);
+        invoice.tax = tax;
+        //
+        const invoiceItems = invoiceItemsData.map((itemData) =>
+          queryRunner.manager.create(this.invoiceItemsRepository.target, {
+            ...itemData,
+            invoice: invoice,
+          }),
+        );
+        invoice.items = invoiceItems;
+      }
+
+      if (updateDto.userId) {
+        const user = await this.usersService.findOneByIdWithQueryRunner(updateDto.userId, queryRunner);
+        invoice.user = user;
+      }
+    } catch (error) {
+      await queryRunner.rollbackTransaction();
+      throw error;
+    } finally {
+      await queryRunner.release();
+    }
+  }
+  //********************************** */
+
   async approveInvoiceRequest(invoiceId: string, userId: string) {
     const { user } = await this.usersService.findOneById(userId);
 
@@ -497,6 +527,38 @@ export class InvoicesService {
     return delayMs;
   }
 
+  //*********************************** */
+  private async scheduleInvoiceJobs(invoice: Invoice, createDto?: CreateInvoiceDto) {
+    // Add to queue for billing reminder
+    await this.invoiceQueue.add(
+      INVOICE.INVOICE_REMINDER_JOB_NAME,
+      { invoiceId: invoice.id },
+      {
+        delay: dayjs(invoice.dueDate).subtract(INVOICE.DAYS_BEFORE_OVERDUE, "day").diff(dayjs()),
+        attempts: INVOICE.INVOICE_REMINDER_JOB_ATTEMPTS,
+        backoff: { type: "exponential", delay: INVOICE.INVOICE_REMINDER_JOB_BACKOFF },
+      },
+    );
+
+    // Add to queue for recurring invoice if applicable
+    if (createDto?.isRecurring && createDto?.recurringPeriod) {
+      await this.invoiceQueue.add(
+        INVOICE.INVOICE_RECURRING_JOB_NAME,
+        {
+          invoiceId: invoice.id,
+          adminCreated: true,
+        },
+        {
+          delay: await this.calculateRecurringDelay(createDto.recurringPeriod),
+          attempts: INVOICE.INVOICE_RECURRING_JOB_ATTEMPTS,
+          backoff: { type: "exponential", delay: INVOICE.INVOICE_REMINDER_JOB_BACKOFF },
+        },
+      );
+
+      this.logger.log(`Scheduled recurring invoice for user ${createDto.userId} with interval ${createDto.recurringPeriod}`);
+    }
+  }
+
   // async applyDiscount(invoiceId: string, applyDiscountDto: ApplyDiscountDto, userId: string) {
   //   const invoice = await this.invoiceRepository.findOneBy({ id: invoiceId, status: InvoiceStatus.PENDING });
   //   if (!invoice) throw new BadRequestException(InvoiceMessage.NOT_FOUND_BY_ID);