env/env.development

@@ -24,8 +24,11 @@ CRON_EVERY_HOUR="0 * * * *"
 
 EMAIL_HOST=smtp.gmail.com
 EMAIL_POST=465
-EMAIL_USER=developer@eigen.co.id
-EMAIL_TOKEN=bitqkbkzjzfywxqx
+EMAIL_USER=weplayground.app@gmail.com
+EMAIL_TOKEN=sonvvwiukhsevtmv
+
+// nama email yang akan muncul ke user sebagai pengirim
+EMAIL_SENDER=no-reply@eigen.co.id 
 
 MIDTRANS_URL=https://app.sandbox.midtrans.com
 MIDTRANS_PRODUCTION=false

src/core/modules/domain/entities/base-filter.entity.ts

@@ -22,6 +22,7 @@ export interface Param {
   data: string[];
   additional?: any[];
   leftJoin?: any[];
+  isStatus?: boolean;
 }
 
 export interface RelationParam {

src/core/modules/domain/usecase/managers/base-index.manager.ts

@@ -52,10 +52,14 @@ export abstract class BaseIndexManager<Entity> extends BaseReadManager {
         // ? karena jika tidak, ketika dia search "active" maka "inactive" juga ikut
         return `'${STATUS[statusData.toUpperCase()]}'` ?? `'%${statusData}%'`;
       });
-      specificFilter.push({
-        cols: `${this.tableName}.status::text`,
-        data: data,
-      });
+
+      const exist = specificFilter.find((item) => item.isStatus);
+      if (!exist) {
+        specificFilter.push({
+          cols: `${this.tableName}.status::text`,
+          data: data,
+        });
+      }
     }
 
     new SpecificSearchFilter<Entity>(

src/core/strings/constants/privilege.constants.ts

@@ -145,7 +145,6 @@ export const PrivilegePOSConstant = [
     actions: [
       PrivilegeAction.VIEW,
       PrivilegeAction.CREATE,
-      PrivilegeAction.DELETE,
       PrivilegeAction.EDIT,
       PrivilegeAction.CANCEL,
     ],

src/database/migrations/1722581313837-update-relation-table-transaction.ts

@@ -0,0 +1,49 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class UpdateRelationTableTransaction1722581313837
+  implements MigrationInterface
+{
+  name = 'UpdateRelationTableTransaction1722581313837';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "refunds" DROP CONSTRAINT "FK_8bb3b7579f49990d2e77684acd4"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refunds" DROP CONSTRAINT "REL_8bb3b7579f49990d2e77684acd"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refund_items" DROP CONSTRAINT "FK_07b481a163c219f5de8fb1c90b3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refund_items" DROP CONSTRAINT "REL_07b481a163c219f5de8fb1c90b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refunds" ADD CONSTRAINT "FK_8bb3b7579f49990d2e77684acd4" FOREIGN KEY ("transaction_id") REFERENCES "transactions"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refund_items" ADD CONSTRAINT "FK_07b481a163c219f5de8fb1c90b3" FOREIGN KEY ("transaction_item_id") REFERENCES "transaction_items"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "refund_items" DROP CONSTRAINT "FK_07b481a163c219f5de8fb1c90b3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refunds" DROP CONSTRAINT "FK_8bb3b7579f49990d2e77684acd4"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refund_items" ADD CONSTRAINT "REL_07b481a163c219f5de8fb1c90b" UNIQUE ("transaction_item_id")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refund_items" ADD CONSTRAINT "FK_07b481a163c219f5de8fb1c90b3" FOREIGN KEY ("transaction_item_id") REFERENCES "transaction_items"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refunds" ADD CONSTRAINT "REL_8bb3b7579f49990d2e77684acd" UNIQUE ("transaction_id")`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "refunds" ADD CONSTRAINT "FK_8bb3b7579f49990d2e77684acd4" FOREIGN KEY ("transaction_id") REFERENCES "transactions"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+}

src/database/migrations/1722587128195-update-type-column-item-table.ts

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class UpdateTypeColumnItemTable1722587128195
+  implements MigrationInterface
+{
+  name = 'UpdateTypeColumnItemTable1722587128195';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "sales_margin"`);
+    await queryRunner.query(`ALTER TABLE "items" ADD "sales_margin" numeric`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "sales_margin"`);
+    await queryRunner.query(`ALTER TABLE "items" ADD "sales_margin" integer`);
+  }
+}

src/database/migrations/1722595038215-update-table-transaction.ts

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class UpdateTableTransaction1722595038215 implements MigrationInterface {
+  name = 'UpdateTableTransaction1722595038215';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."transactions_payment_type_counter_enum" AS ENUM('midtrans', 'bank transfer', 'qris', 'counter', 'cash', 'credit card', 'debit', 'e-money')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" ADD "payment_type_counter" "public"."transactions_payment_type_counter_enum"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP COLUMN "payment_type_counter"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."transactions_payment_type_counter_enum"`,
+    );
+  }
+}

src/modules/configuration/couch/domain/managers/booking.handler.ts

@@ -38,36 +38,41 @@ export class BookingHandler
     const old_data = event.data.old;
     const data = event.data.data;
 
-    if (data.payment_type != TransactionPaymentType.COUNTER) return;
-
-    const booking = await this.bookingService.getOneByOptions({
-      where: {
-        id: data.id,
-      },
-      relations: ['items'],
-    });
-
-    mappingTransaction(booking);
-
     if (
-      old_data?.status != data.status &&
-      [STATUS.PENDING, STATUS.ACTIVE].includes(data.status)
+      data.payment_type == TransactionPaymentType.COUNTER ||
+      ([STATUS.ACTIVE, STATUS.SETTLED].includes(data.status) &&
+        data.payment_type != TransactionPaymentType.COUNTER)
     ) {
-      await this.couchService.createDoc(
-        {
-          _id: booking.id,
-          ...booking,
+      const booking = await this.bookingService.getOneByOptions({
+        where: {
+          id: data.id,
         },
-        'booking',
-      );
-    } else {
-      await this.couchService.updateDoc(
-        {
-          _id: booking.id,
-          ...booking,
-        },
-        'booking',
-      );
+        relations: ['items'],
+      });
+
+      mappingTransaction(booking);
+
+      if (
+        (old_data?.status != data.status ||
+          data.payment_type != TransactionPaymentType.COUNTER) &&
+        [STATUS.PENDING, STATUS.ACTIVE, STATUS.SETTLED].includes(data.status)
+      ) {
+        await this.couchService.createDoc(
+          {
+            _id: booking.id,
+            ...booking,
+          },
+          'booking',
+        );
+      } else {
+        await this.couchService.updateDoc(
+          {
+            _id: booking.id,
+            ...booking,
+          },
+          'booking',
+        );
+      }
     }
   }
 }

src/modules/configuration/google-calendar/domain/usecases/managers/helpers/create-event-calanedar.helper.ts

@@ -61,8 +61,12 @@ export async function CreateEventCalendarHelper(
 
 function mappingData(transaction) {
   return {
-    summary: transaction.invoice_code,
-    description: `Booking for invoice ${transaction.invoice_code}`,
+    summary: transaction.customer_name ?? transaction.invoice_code,
+    description: `<b>Booking for invoice ${
+      transaction.invoice_code
+    }</b><p>List Items :</p><ul>${transaction.items.map(
+      (item) => `<li>${item.item_name}</li>`,
+    )}</ul>`,
     start: {
       dateTime: new Date(transaction.booking_date).toISOString(),
       timeZone: 'Asia/Jakarta',

src/modules/configuration/mail/domain/helpers/send-email.helper.ts

@@ -20,9 +20,9 @@ export async function sendEmail(receivers, subject) {
       if (receiver.payment_type == TransactionPaymentType.MIDTRANS)
         templateName = 'payment-confirmation-midtrans';
 
-      let templatePath = path.resolve(
+      let templatePath = path.join(
         __dirname,
-        `../email-template/${ templateName }.html`,
+        `../email-template/${templateName}.html`,
       );
       templatePath = templatePath.replace(/dist/g, 'src');
       const templateSource = fs.readFileSync(templatePath, 'utf8');
@@ -31,7 +31,7 @@ export async function sendEmail(receivers, subject) {
       const htmlToSend = template(receiver);
 
       const emailContext = {
-        from: 'no-reply@eigen.co.id',
+        from: process.env.EMAIL_SENDER ?? 'no-reply@weplayground.app',
         to: receiver.email,
         subject: subject,
         html: htmlToSend,
@@ -42,13 +42,13 @@ export async function sendEmail(receivers, subject) {
 
       smtpTransport.sendMail(emailContext, function (err, data) {
         if (err) {
-          console.log(err, `Error occurs on send to ${ receiver.email }`);
+          console.log(err, `Error occurs on send to ${receiver.email}`);
         } else {
-          console.log(`Email sent to ${ receiver.email }`);
+          console.log(`Email sent to ${receiver.email}`);
         }
       });
     } catch (error) {
-      console.log(error, `Error occurs on send to ${ receiver.email }`)
+      console.log(error, `Error occurs on send to ${receiver.email}`);
     }
   }
 }

src/modules/configuration/mail/infrastructure/mail.controller.ts

@@ -0,0 +1,57 @@
+import { Controller, Get, Injectable } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { Public } from 'src/core/guards';
+import * as path from 'path';
+import * as fs from 'fs';
+
+@ApiTags(`email templates`)
+@Controller('v1/email-templates')
+@Public()
+@Injectable()
+export class MailTemplateController {
+  constructor() {}
+
+  getTemplate(templateName) {
+    const templatePath = path.join(
+      __dirname,
+      '../../../../../',
+      `src/modules/configuration/mail/domain/email-template/${templateName}.html`,
+    );
+    return fs.readFileSync(templatePath, 'utf8');
+  }
+
+  @Get('date-change')
+  async getDateChange() {
+    return this.getTemplate('change-date');
+  }
+
+  @Get('invoice')
+  async getBookingInvoice() {
+    return this.getTemplate('invoice');
+  }
+
+  @Get('payment-confirmation-bank')
+  async getPaymentConfirmation() {
+    return this.getTemplate('payment-confirmation-bank');
+  }
+
+  @Get('payment-confirmation-midtrans')
+  async getPaymentConfirmationMidtrans() {
+    return this.getTemplate('payment-confirmation-midtrans');
+  }
+
+  @Get('invoice-expired')
+  async getInvoiceExpired() {
+    return this.getTemplate('invoice-expired');
+  }
+
+  @Get('refund-confirmation')
+  async getRefundConfirmation() {
+    return this.getTemplate('refund-confirmation');
+  }
+
+  @Get('refund-request')
+  async getRefundRequest() {
+    return this.getTemplate('refunr-request');
+  }
+}

src/modules/configuration/mail/mail.module.ts

@@ -8,6 +8,7 @@ import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
 import { TransactionModel } from 'src/modules/transaction/transaction/data/models/transaction.model';
 import { TransactionDataService } from 'src/modules/transaction/transaction/data/services/transaction-data.service';
 import { PaymentTransactionHandler } from './domain/handlers/payment-transaction.handler';
+import { MailTemplateController } from './infrastructure/mail.controller';
 
 @Module({
   imports: [
@@ -18,7 +19,7 @@ import { PaymentTransactionHandler } from './domain/handlers/payment-transaction
     ),
     CqrsModule,
   ],
-  controllers: [],
+  controllers: [MailTemplateController],
   providers: [
     PaymentTransactionHandler,
     PaymentMethodDataService,

src/modules/configuration/midtrans/infrastructure/midtrans.controller.ts

@@ -18,7 +18,20 @@ export class MidtransController {
 
   @Get(':id/status')
   async getStatus(@Param('id') id: string) {
-    return await this.dataService.getStatus(id);
+    try {
+      const data = await this.dataService.getStatus(id);
+      this.eventBus.publishAll([
+        new MidtransCallbackEvent({
+          id: id,
+          data: data,
+        }),
+      ]);
+
+      return 'Berhasil update status transaksi';
+    } catch (error) {
+      console.log(error.message);
+      throw new Error('Gagal update status transaksi');
+    }
   }
 
   @Post('callback')

src/modules/item-related/item-rate/domain/usecases/handlers/item-created.handler.ts

@@ -32,7 +32,10 @@ export class SeasonPeriodHolidayHandler
         const rate = new ItemRateModel();
         rate.item_id = event.data.id;
         rate.season_period_id = season.id;
-        rate.price = event.data.data.total_price ?? event.data.data.base_price;
+        rate.price =
+          Number(event.data.data.total_price) != 0
+            ? event.data.data.total_price
+            : event.data.data.base_price;
 
         rates.push(rate);
       }

src/modules/item-related/item/data/models/item.model.ts

@@ -38,7 +38,7 @@ export class ItemModel
   @Column('bigint', { name: 'hpp', nullable: true })
   hpp: number;
 
-  @Column('int', { name: 'sales_margin', nullable: true })
+  @Column('decimal', { name: 'sales_margin', nullable: true })
   sales_margin: number;
 
   @Column('bigint', { name: 'total_price', nullable: true })

src/modules/item-related/item/domain/usecases/managers/active-item.manager.ts

@@ -36,7 +36,12 @@ export class ActiveItemManager extends BaseUpdateStatusManager<ItemEntity> {
       {
         relation: 'tenant',
         singleQuery: ['status', '!=', STATUS.ACTIVE],
-        message: `Gagal! Belum ada item yang aktif`,
+        message: `Gagal! tenant tidak aktif`,
+      },
+      {
+        relation: 'bundling_items',
+        singleQuery: ['status', '!=', STATUS.ACTIVE],
+        message: `Gagal! Terdapat item yang belum aktif`,
       },
     ];
   }

src/modules/item-related/item/domain/usecases/managers/batch-active-item.manager.ts

@@ -7,11 +7,7 @@ import {
 import { ItemModel } from '../../../data/models/item.model';
 import { ItemChangeStatusEvent } from '../../entities/event/item-change-status.event';
 import { BatchResult } from 'src/core/response/domain/ok-response.interface';
-import {
-  HttpStatus,
-  Injectable,
-  UnprocessableEntityException,
-} from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { STATUS } from 'src/core/strings/constants/base.constants';
 
 @Injectable()
@@ -33,7 +29,12 @@ export class BatchActiveItemManager extends BaseBatchUpdateStatusManager<ItemEnt
       {
         relation: 'tenant',
         singleQuery: ['status', '!=', STATUS.ACTIVE],
-        message: `Gagal! Belum ada item yang aktif`,
+        message: `Gagal! tenant tidak aktif`,
+      },
+      {
+        relation: 'bundling_items',
+        singleQuery: ['status', '!=', STATUS.ACTIVE],
+        message: `Gagal! Terdapat item yang belum aktif`,
       },
     ];
   }

src/modules/item-related/item/domain/usecases/managers/batch-confirm-item.manager.ts

@@ -29,7 +29,12 @@ export class BatchConfirmItemManager extends BaseBatchUpdateStatusManager<ItemEn
       {
         relation: 'tenant',
         singleQuery: ['status', '!=', STATUS.ACTIVE],
-        message: `Gagal! Belum ada item yang aktif`,
+        message: `Gagal! tenant tidak aktif`,
+      },
+      {
+        relation: 'bundling_items',
+        singleQuery: ['status', '!=', STATUS.ACTIVE],
+        message: `Gagal! Terdapat item yang belum aktif`,
       },
     ];
   }

src/modules/item-related/item/domain/usecases/managers/confirm-item.manager.ts

@@ -32,7 +32,12 @@ export class ConfirmItemManager extends BaseUpdateStatusManager<ItemEntity> {
       {
         relation: 'tenant',
         singleQuery: ['status', '!=', STATUS.ACTIVE],
-        message: `Gagal! Belum ada item yang aktif`,
+        message: `Gagal! tenant tidak aktif`,
+      },
+      {
+        relation: 'bundling_items',
+        singleQuery: ['status', '!=', STATUS.ACTIVE],
+        message: `Gagal! Terdapat item yang belum aktif`,
       },
     ];
   }

src/modules/item-related/item/domain/usecases/managers/helpers/validasi-relation.helper.ts

@@ -1,8 +1,11 @@
 import { HttpStatus, UnprocessableEntityException } from '@nestjs/common';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import { In } from 'typeorm';
 
 export async function validateRelation(dataService, id) {
   const haveRelation = await dataService.getOneByOptions({
     where: {
+      status: In([STATUS.ACTIVE]),
       bundling_items: {
         id: id,
       },

src/modules/transaction/reconciliation/domain/usecases/managers/detail-reconciliation.manager.ts

@@ -36,6 +36,7 @@ export class DetailReconciliationManager extends BaseDetailManager<TransactionEn
       `${this.tableName}.reconciliation_mdr`,
 
       `${this.tableName}.payment_type`,
+      `${this.tableName}.payment_type_counter`,
       `${this.tableName}.payment_type_method_id`,
       `${this.tableName}.payment_type_method_name`,
       `${this.tableName}.payment_type_method_number`,

src/modules/transaction/reconciliation/domain/usecases/managers/index-reconciliation.manager.ts

@@ -51,6 +51,7 @@ export class IndexReconciliationManager extends BaseIndexManager<TransactionEnti
       `${this.tableName}.invoice_code`,
       `${this.tableName}.booking_date`,
       `${this.tableName}.payment_type`,
+      `${this.tableName}.payment_type_counter`,
       `${this.tableName}.payment_type_method_id`,
       `${this.tableName}.payment_type_method_name`,
       `${this.tableName}.payment_type_method_number`,
@@ -65,6 +66,11 @@ export class IndexReconciliationManager extends BaseIndexManager<TransactionEnti
 
   get specificFilter(): Param[] {
     return [
+      {
+        cols: `${this.tableName}.reconciliation_status::text`,
+        data: this.filterParam.statuses,
+        isStatus: true,
+      },
       {
         cols: `${this.tableName}.customer_name`,
         data: this.filterParam.customer_names,
@@ -115,36 +121,46 @@ export class IndexReconciliationManager extends BaseIndexManager<TransactionEnti
 
     if (this.filterParam.payment_type) {
       queryBuilder.andWhere(
-        `${this.tableName}.creator_counter_no In (:...counters)`,
+        `${this.tableName}.payment_type::text In (:...paymentType)`,
         {
-          counters: [this.filterParam.couner_no],
+          paymentType: [this.filterParam.payment_type],
         },
       );
     }
 
     if (this.filterParam.payment_via) {
-      queryBuilder.andWhere(`${this.tableName}.payment_type In (:...type)`, {
-        type: [this.filterParam.payment_via],
-      });
+      queryBuilder.andWhere(
+        `${this.tableName}.payment_type::text In (:...type)`,
+        {
+          type: [`%${this.filterParam.payment_via}%`],
+        },
+      );
     }
 
     if (this.filterParam.payment_bank) {
       queryBuilder.andWhere(
-        `${this.tableName}.payment_type_method_name In (:...banks)`,
+        `${this.tableName}.payment_type_method_name::text In (:...banks)`,
         {
-          banks: [this.filterParam.payment_bank],
+          banks: [`%${this.filterParam.payment_bank}%`],
         },
       );
     }
 
     if (this.filterParam.confirmation_date_from) {
+      const confirmationDateFrom = new Date(
+        this.filterParam?.confirmation_date_from,
+      ).getTime();
+      const confirmationDateTo = new Date(
+        `${this.filterParam?.confirmation_date_to?.split(' ')[0]} 23:59:59`,
+      ).getTime();
+
       new BetweenQueryHelper(
         queryBuilder,
         this.tableName,
-        'payment_date',
-        this.filterParam.confirmation_date_from,
-        this.filterParam.confirmation_date_to,
-        'payment_created',
+        'reconciliation_confirm_date',
+        confirmationDateFrom,
+        confirmationDateTo,
+        'reconciliation_confirm_dated',
       ).getQuery();
     }
 

src/modules/transaction/reconciliation/domain/usecases/managers/recap-reconciliation.manager.ts

@@ -35,27 +35,24 @@ export class RecapReconciliationManager extends BaseCustomManager<TransactionEnt
     const transactions = await this.dataService.getManyByOptions({
       where: {
         is_recap_transaction: false,
-        type: TransactionType.COUNTER,
+        paymnet_type: TransactionType.COUNTER,
         status: STATUS.SETTLED,
         created_at: Between(this.startOfDay, this.endOfDay),
       },
     });
 
-    const payCounserTransactions = await this.dataService.getManyByOptions({
-      where: {
-        is_recap_transaction: false,
-        payment_code: ILike('%SLS%'),
-        status: STATUS.SETTLED,
-        created_at: Between(this.startOfDay, this.endOfDay),
-      },
-    });
-    transactions.push(...payCounserTransactions);
-
     for (const transaction of transactions) {
-      const { creator_counter_no, payment_type, payment_type_method_id } =
-        transaction;
+      const {
+        creator_counter_no,
+        payment_type_counter,
+        payment_type_method_id,
+      } = transaction;
       const group_by =
-        creator_counter_no + '-' + payment_type + '-' + payment_type_method_id;
+        creator_counter_no +
+        '-' +
+        payment_type_counter +
+        '-' +
+        payment_type_method_id;
       if (!this.recapTransactions[group_by]) {
         this.recapTransactions[group_by] = [];
       }
@@ -69,25 +66,26 @@ export class RecapReconciliationManager extends BaseCustomManager<TransactionEnt
     const total_recap = Object.keys(this.recapTransactions);
     for (const recap of total_recap) {
       const first_transaction = this.recapTransactions[recap][0];
-      const { creator_counter_no, payment_type, payment_type_method_id } =
-        first_transaction;
+      const {
+        creator_counter_no,
+        payment_type_counter,
+        payment_type_method_id,
+      } = first_transaction;
 
       let query = {
         is_recap_transaction: true,
         created_at: Between(this.startOfDay, this.endOfDay),
         creator_counter_no: creator_counter_no,
-        payment_type: payment_type,
+        payment_type: payment_type_counter,
       };
 
-      if (payment_type != 'cash')
+      if (payment_type_counter != 'cash')
         query['payment_type_method_id'] = payment_type_method_id ?? EMPTY_UUID;
 
       const exist = await this.dataService.getOneByOptions({
         where: query,
       });
 
-      if (payment_type == 'cash') console.log(exist, 'das', query);
-
       const new_recap = new TransactionModel();
       const total = _.sumBy(this.recapTransactions[recap], (recap) =>
         parseFloat(recap.payment_total),
@@ -112,7 +110,8 @@ export class RecapReconciliationManager extends BaseCustomManager<TransactionEnt
           booking_date: new Date(),
           payment_date: new Date(),
           creator_counter_no: first_transaction.creator_counter_no,
-          payment_type: first_transaction.payment_type,
+          payment_type: first_transaction.payment_type_counter,
+          payment_type_counter: first_transaction.payment_type_counter,
           payment_type_method_id: first_transaction.payment_type_method_id,
           payment_type_method_number:
             first_transaction.payment_type_method_number,

src/modules/transaction/refund/data/models/refund-item.model.ts

@@ -29,7 +29,7 @@ export class RefundItemModel
   // transaction to transaction item
   @Column('varchar', { name: 'transaction_item_id', nullable: true })
   transaction_item_id: string;
-  @OneToOne(() => TransactionItemModel, (model) => model.refund, {
+  @ManyToOne(() => TransactionItemModel, (model) => model.refunds, {
     onDelete: 'CASCADE',
     onUpdate: 'CASCADE',
   })

src/modules/transaction/refund/data/models/refund.model.ts

@@ -1,6 +1,6 @@
 import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
 import { RefundEntity } from '../../domain/entities/refund.entity';
-import { Column, Entity, JoinColumn, OneToMany, OneToOne } from 'typeorm';
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 import { BaseStatusModel } from 'src/core/modules/data/model/base-status.model';
 import { TransactionModel } from 'src/modules/transaction/transaction/data/models/transaction.model';
 import { RefundItemModel } from './refund-item.model';
@@ -64,7 +64,7 @@ export class RefundModel
   // relation to transaction
   @Column('varchar', { name: 'transaction_id', nullable: true })
   transaction_id: string;
-  @OneToOne(() => TransactionModel, (model) => model.refund, {
+  @ManyToOne(() => TransactionModel, (model) => model.refunds, {
     onDelete: 'CASCADE',
     onUpdate: 'CASCADE',
   })

src/modules/transaction/refund/domain/usecases/managers/batch-confirm-refund.manager.ts

@@ -38,7 +38,6 @@ export class BatchConfirmRefundManager extends BaseBatchUpdateStatusManager<Refu
 
     if (this.data.status == STATUS.DRAFT) {
       Object.assign(this.data, {
-        code: `RF-${data?.['transaction']?.invoice_code.split('-')[1]}`,
         request_date: new Date(),
         status: STATUS.PENDING,
       });

src/modules/transaction/refund/domain/usecases/managers/confirm-refund.manager.ts

@@ -53,7 +53,6 @@ export class ConfirmRefundManager extends BaseUpdateStatusManager<RefundEntity>
 
     if (data.status == STATUS.DRAFT) {
       Object.assign(this.data, {
-        code: `RF-${data.transaction?.invoice_code?.split('-')[1]}`,
         request_date: new Date(),
         status: STATUS.PENDING,
       });

src/modules/transaction/refund/domain/usecases/managers/create-refund.manager.ts

@@ -13,6 +13,8 @@ import { RefundModel } from '../../../data/models/refund.model';
 import { BaseCreateManager } from 'src/core/modules/domain/usecase/managers/base-create.manager';
 import { RefundCreatedEvent } from '../../entities/event/refund-created.event';
 import { STATUS } from 'src/core/strings/constants/base.constants';
+import { In, Not } from 'typeorm';
+import { generateInvoiceCodeHelper } from 'src/modules/transaction/transaction/domain/usecases/managers/helpers/generate-invoice-code.helper';
 
 @Injectable()
 export class CreateRefundManager extends BaseCreateManager<RefundEntity> {
@@ -26,13 +28,10 @@ export class CreateRefundManager extends BaseCreateManager<RefundEntity> {
       };
     });
 
-    Object.assign(this.data, {
-      refund_items: refund_items,
-    });
-
     const exist = await this.dataService.getOneByOptions({
       where: {
         transaction_id: this.data.transaction.id,
+        status: Not(In([STATUS.CANCEL])),
       },
     });
     if (exist) {
@@ -57,6 +56,11 @@ export class CreateRefundManager extends BaseCreateManager<RefundEntity> {
         error: 'Unprocessable Entity',
       });
     }
+
+    Object.assign(this.data, {
+      refund_items: refund_items,
+      code: await generateInvoiceCodeHelper(this.dataService, 'RF'),
+    });
     return;
   }
 

src/modules/transaction/refund/domain/usecases/managers/detail-refund.manager.ts

@@ -15,7 +15,7 @@ export class DetailRefundManager extends BaseDetailManager<RefundEntity> {
   }
 
   async afterProcess(): Promise<void> {
-    mappingTransaction(this.result['transaction']);
+    mappingTransaction(this.result['transaction'], this.dataId);
     return;
   }
 
@@ -25,7 +25,12 @@ export class DetailRefundManager extends BaseDetailManager<RefundEntity> {
       joinRelations: [],
 
       // relation join and select (relasi yang ingin ditampilkan),
-      selectRelations: ['transaction', 'transaction.items', 'items.refund'],
+      selectRelations: [
+        'transaction',
+        'transaction.items',
+        'items.refunds item_refunds',
+        'item_refunds.refund item_refunds_refund',
+      ],
 
       // relation yang hanya ingin dihitung (akan return number)
       countRelations: [],
@@ -55,7 +60,9 @@ export class DetailRefundManager extends BaseDetailManager<RefundEntity> {
 
       'transaction',
       'items',
-      'refund',
+      'item_refunds',
+      'item_refunds_refund.id',
+      'item_refunds_refund.status',
     ];
   }
 

src/modules/transaction/refund/domain/usecases/managers/update-refund.manager.ts

@@ -12,25 +12,10 @@ import {
   columnUniques,
   validateRelations,
 } from 'src/core/strings/constants/interface.constants';
-import { STATUS } from 'src/core/strings/constants/base.constants';
 
 @Injectable()
 export class UpdateRefundManager extends BaseUpdateManager<RefundEntity> {
   async validateProcess(): Promise<void> {
-    const transaction = await this.dataServiceFirstOpt.getOneByOptions({
-      where: {
-        id: this.data.transaction.id,
-        status: STATUS.SETTLED,
-      },
-    });
-
-    if (!transaction) {
-      throw new UnprocessableEntityException({
-        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
-        message: `Gagal! hanya pemesanan dengan status ${STATUS.SETTLED} yang dapat dikembalikan`,
-        error: 'Unprocessable Entity',
-      });
-    }
     return;
   }
 

src/modules/transaction/transaction/data/models/transaction-item.model.ts

@@ -1,5 +1,5 @@
 import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
-import { Column, Entity, JoinColumn, ManyToOne, OneToOne } from 'typeorm';
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 import { BaseCoreModel } from 'src/core/modules/data/model/base-core.model';
 import { TransactionItemEntity } from '../../domain/entities/transaction-item.entity';
 import { TransactionModel } from './transaction.model';
@@ -80,10 +80,10 @@ export class TransactionItemModel
   transaction: TransactionModel;
 
   // relations to refund
-  @OneToOne(() => RefundItemModel, (model) => model.transaction_item, {
+  @OneToMany(() => RefundItemModel, (model) => model.transaction_item, {
     cascade: true,
     onDelete: 'CASCADE',
     onUpdate: 'CASCADE',
   })
-  refund: RefundItemModel;
+  refunds: RefundItemModel[];
 }

src/modules/transaction/transaction/data/models/transaction.model.ts

@@ -1,6 +1,6 @@
 import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
 import { TransactionEntity } from '../../domain/entities/transaction.entity';
-import { Column, Entity, OneToMany, OneToOne } from 'typeorm';
+import { Column, Entity, OneToMany } from 'typeorm';
 import { BaseStatusModel } from 'src/core/modules/data/model/base-status.model';
 import {
   TransactionType,
@@ -107,6 +107,13 @@ export class TransactionModel
   })
   payment_type: TransactionPaymentType;
 
+  @Column('enum', {
+    name: 'payment_type_counter',
+    enum: TransactionPaymentType,
+    nullable: true,
+  })
+  payment_type_counter: TransactionPaymentType;
+
   @Column('varchar', { name: 'payment_code', nullable: true })
   payment_code: string;
 
@@ -233,10 +240,10 @@ export class TransactionModel
   taxes: TransactionTaxModel[];
 
   // relations to refund
-  @OneToOne(() => RefundModel, (model) => model.transaction, {
+  @OneToMany(() => RefundModel, (model) => model.transaction, {
     cascade: true,
     onDelete: 'CASCADE',
     onUpdate: 'CASCADE',
   })
-  refund: RefundModel;
+  refunds: RefundModel[];
 }

src/modules/transaction/transaction/domain/entities/transaction.entity.ts

@@ -41,6 +41,7 @@ export interface TransactionEntity extends BaseStatusEntity {
 
   // payment data
   payment_type: TransactionPaymentType;
+  payment_type_counter: TransactionPaymentType;
   payment_type_method_id: string;
   payment_type_method_name: string;
   payment_type_method_number: string;

src/modules/transaction/transaction/domain/usecases/handlers/settled-transaction.handler.ts

@@ -37,57 +37,59 @@ export class SettledTransactionHandler
       relations: ['items'],
     });
 
-    if (!settled || !oldSettled) return;
+    if (settled || oldSettled) {
+      const queryRunner = this.dataService
+        .getRepository()
+        .manager.connection.createQueryRunner();
 
-    const queryRunner = this.dataService
-      .getRepository()
-      .manager.connection.createQueryRunner();
+      if (settled) {
+        const profit_formula = await this.formulaService.getOneByOptions({
+          where: {
+            type: FormulaType.PROFIT_SHARE,
+          },
+        });
 
-    if (settled) {
-      const profit_formula = await this.formulaService.getOneByOptions({
-        where: {
-          type: FormulaType.PROFIT_SHARE,
-        },
-      });
+        const sales_price = await this.formulaService.getOneByOptions({
+          where: {
+            type: FormulaType.SALES_PRICE,
+          },
+        });
 
-      const sales_price = await this.formulaService.getOneByOptions({
-        where: {
-          type: FormulaType.SALES_PRICE,
-        },
-      });
+        const taxes = await this.taxService.getManyByOptions({
+          where: {
+            status: STATUS.ACTIVE,
+          },
+        });
 
-      const taxes = await this.taxService.getManyByOptions({
-        where: {
-          status: STATUS.ACTIVE,
-        },
-      });
+        // const profit_share_value = this.calculateFormula(profit_formula.formula_string, taxes, data.payment_total_net_profit ?? 0);
+        const { dpp_value, tax_datas } = calculateSalesFormula(
+          sales_price.formula_string,
+          taxes,
+          data.payment_total_net_profit ?? 0,
+        );
 
-      // const profit_share_value = this.calculateFormula(profit_formula.formula_string, taxes, data.payment_total_net_profit ?? 0);
-      const { dpp_value, tax_datas } = calculateSalesFormula(
-        sales_price.formula_string,
-        taxes,
-        data.payment_total_net_profit ?? 0,
-      );
+        console.log(data, 'dsa');
+        const google_calendar = await CreateEventCalendarHelper(data);
 
-      const google_calendar = await CreateEventCalendarHelper(data);
+        Object.assign(data, {
+          payment_total_dpp: dpp_value,
+          profit_share_formula: profit_formula.formula_string,
+          sales_price_formula: sales_price.formula_string,
+          taxes: tax_datas,
+          calendar_id: google_calendar?.id,
+          calendar_link: google_calendar?.htmlLink,
+        });
+      } else if (oldSettled) {
+        console.log(data, 'data oldSettled');
+        const google_calendar = await CreateEventCalendarHelper(data);
 
-      Object.assign(data, {
-        payment_total_dpp: dpp_value,
-        profit_share_formula: profit_formula.formula_string,
-        sales_price_formula: sales_price.formula_string,
-        taxes: tax_datas,
-        calendar_id: google_calendar?.id,
-        calendar_link: google_calendar?.htmlLink,
-      });
-    } else if (oldSettled) {
-      const google_calendar = await CreateEventCalendarHelper(data);
+        Object.assign(data, {
+          calendar_id: null,
+          calendar_link: null,
+        });
+      }
 
-      Object.assign(data, {
-        calendar_id: null,
-        calendar_link: null,
-      });
+      await this.dataService.create(queryRunner, TransactionModel, data);
     }
-
-    await this.dataService.create(queryRunner, TransactionModel, data);
   }
 }

src/modules/transaction/transaction/domain/usecases/managers/active-transaction.manager.ts

@@ -11,7 +11,7 @@ import { TransactionChangeStatusEvent } from '../../entities/event/transaction-c
 @Injectable()
 export class ActiveTransactionManager extends BaseUpdateStatusManager<TransactionEntity> {
   getResult(): string {
-    return `Success active data ${this.result.invoice_code}`;
+    return `Success ${this.dataStatus} data ${this.result.invoice_code}`;
   }
 
   async validateProcess(): Promise<void> {

src/modules/transaction/transaction/domain/usecases/managers/cancel-transaction.manager.ts

@@ -16,11 +16,11 @@ import { STATUS } from 'src/core/strings/constants/base.constants';
 @Injectable()
 export class CancelTransactionManager extends BaseUpdateStatusManager<TransactionEntity> {
   getResult(): string {
-    return `Success active data ${this.result.invoice_code}`;
+    return `Success ${this.dataStatus} data ${this.result.invoice_code}`;
   }
 
   async validateProcess(): Promise<void> {
-    if (![STATUS.EXPIRED, STATUS.PENDING].includes(this.data.status)) {
+    if (![STATUS.EXPIRED, STATUS.PENDING].includes(this.oldData.status)) {
       throw new UnprocessableEntityException({
         statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
         message: `Gagal! hanya tranksaksi dengan status ${STATUS.PENDING} dan ${STATUS.EXPIRED} yang dapat di${this.dataStatus}`,

src/modules/transaction/transaction/domain/usecases/managers/detail-transaction.manager.ts

@@ -25,7 +25,12 @@ export class DetailTransactionManager extends BaseDetailManager<TransactionEntit
       joinRelations: [],
 
       // relation join and select (relasi yang ingin ditampilkan),
-      selectRelations: ['items', 'items.refund item_refund', 'refund'],
+      selectRelations: [
+        'items',
+        'items.refunds item_refunds',
+        'item_refunds.refund item_refunds_refund',
+        'refunds',
+      ],
 
       // relation yang hanya ingin dihitung (akan return number)
       countRelations: [],
@@ -62,6 +67,7 @@ export class DetailTransactionManager extends BaseDetailManager<TransactionEntit
       `${this.tableName}.discount_value`,
 
       `${this.tableName}.payment_type`,
+      `${this.tableName}.payment_type_counter`,
       `${this.tableName}.payment_date`,
       `${this.tableName}.payment_total_pay`,
       `${this.tableName}.payment_type_method_id`,
@@ -76,8 +82,11 @@ export class DetailTransactionManager extends BaseDetailManager<TransactionEntit
       `${this.tableName}.payment_total`,
 
       'items',
-      'item_refund',
-      'refund',
+      'item_refunds',
+      'item_refunds_refund.id',
+      'item_refunds_refund.status',
+
+      'refunds',
     ];
   }
 

src/modules/transaction/transaction/domain/usecases/managers/helpers/generate-invoice-code.helper.ts

@@ -12,6 +12,12 @@ export async function generateInvoiceCodeHelper(dataService, code) {
     invoice_code: ILike(`%${month_year}%`),
   };
 
+  if (code == 'RF') {
+    query = {
+      code: ILike(`%${month_year}%`),
+    };
+  }
+
   if (code == 'PYM') {
     query = {
       payment_code: ILike(`%${month_year}%`),

src/modules/transaction/transaction/domain/usecases/managers/helpers/mapping-transaction.helper.ts

@@ -4,7 +4,7 @@ import {
   TransactionType,
 } from 'src/modules/transaction/transaction/constants';
 
-export function mappingTransaction(data) {
+export function mappingTransaction(data, refundId?: string) {
   let payment_type_bank: any = null;
   const season_period = {
     id: data.season_period_id,
@@ -26,6 +26,9 @@ export function mappingTransaction(data) {
 
   const items = data?.['items']?.map((itemData) => {
     let tenant;
+    let refund = itemData.refunds?.find(
+      (item) => ![STATUS.CANCEL].includes(item.refund.status),
+    );
 
     if (itemData.item_tenant_id) {
       tenant = {
@@ -35,6 +38,9 @@ export function mappingTransaction(data) {
       };
     }
 
+    if (refundId)
+      refund = itemData.refunds?.find((item) => item.refund.id == refundId);
+
     return {
       item: {
         id: itemData.item_id,
@@ -49,20 +55,27 @@ export function mappingTransaction(data) {
         },
       },
       id: itemData.id,
-      refund: itemData.refund,
+      refund: refund,
       qty: itemData.qty,
       qty_remaining: itemData.qty_remaining,
-      total_price_refund: itemData.refund?.refund_total ?? 0,
+      total_price_refund: refund?.refund_total ?? 0,
       total_price: itemData.total_price,
     };
   });
 
+  const refund = data.refunds?.find(
+    (refund) => ![STATUS.CANCEL].includes(refund.status),
+  );
+
   Object.assign(data, {
     season_period: season_period,
     items: items,
     payment_type_bank: payment_type_bank,
+    refund: refund,
   });
 
+  delete data.refunds;
+
   delete data.season_period_id;
   delete data.season_period_name;
   delete data.season_period_type_id;
@@ -85,6 +98,7 @@ export function mappingRevertTransaction(data, type) {
       });
     } else {
       Object.assign(data, {
+        type: type,
         creator_id: data.pos_admin?.id,
         creator_name: data.pos_admin?.name,
         invoice_code: data.code,
@@ -94,11 +108,11 @@ export function mappingRevertTransaction(data, type) {
     Object.assign(data, {
       id: data.booking_id ?? data._id,
       creator_counter_no: Number(data.pos_number),
-      status: STATUS.SETTLED,
       settlement_date: new Date(data.created_at),
       payment_date: new Date(data.created_at),
       invoice_date: new Date(data.created_at),
-      payment_type:
+      payment_type: TransactionPaymentType.COUNTER,
+      payment_type_counter:
         data.payment_type == 'cc'
           ? TransactionPaymentType.CC
           : data.payment_type,
@@ -109,13 +123,12 @@ export function mappingRevertTransaction(data, type) {
       discount_percentage: data.discount_code?.discount,
     });
   } else {
-    // Object.assign(data, {
-    //   payment_type:
-    // })
+    Object.assign(data, {
+      type: type,
+    });
   }
 
   Object.assign(data, {
-    type: type,
     payment_total_net_profit: data.payment_total,
     customer_category_id: data.customer_category?.id ?? null,
     customer_category_name: data.customer_category?.name ?? null,

src/modules/transaction/transaction/domain/usecases/managers/index-transaction.manager.ts

@@ -7,6 +7,7 @@ import {
   RelationParam,
 } from 'src/core/modules/domain/entities/base-filter.entity';
 import { BetweenQueryHelper } from 'src/core/helpers/query/between-query.helper';
+import { STATUS } from 'src/core/strings/constants/base.constants';
 
 @Injectable()
 export class IndexTransactionManager extends BaseIndexManager<TransactionEntity> {
@@ -20,12 +21,16 @@ export class IndexTransactionManager extends BaseIndexManager<TransactionEntity>
 
   async afterProcess(): Promise<void> {
     this.result?.data?.map((item) => {
+      const activeRefund = item['refunds'].find(
+        (refund) => ![STATUS.CANCEL].includes(refund.status),
+      );
+
       Object.assign(item, {
-        refund_code: item['refund']?.code ?? null,
-        refund_date: item['refund']?.refund_date ?? null,
+        refund_code: activeRefund?.code ?? null,
+        refund_date: activeRefund?.refund_date ?? null,
       });
 
-      delete item['refund'];
+      delete item['refunds'];
     });
     return;
   }
@@ -36,7 +41,7 @@ export class IndexTransactionManager extends BaseIndexManager<TransactionEntity>
       joinRelations: [],
 
       // relation join and select (relasi yang ingin ditampilkan),
-      selectRelations: ['items', 'refund'],
+      selectRelations: ['items', 'refunds'],
 
       // relation yang hanya ingin dihitung (akan return number)
       countRelations: [],
@@ -70,16 +75,17 @@ export class IndexTransactionManager extends BaseIndexManager<TransactionEntity>
       `${this.tableName}.payment_code`,
       `${this.tableName}.payment_card_information`,
       `${this.tableName}.payment_type`,
+      `${this.tableName}.payment_type_counter`,
       `${this.tableName}.payment_date`,
       `${this.tableName}.payment_total_pay`,
       `${this.tableName}.payment_type_method_id`,
       `${this.tableName}.payment_type_method_name`,
       `${this.tableName}.payment_type_method_number`,
 
-      `refund.id`,
-      `refund.code`,
-      `refund.refund_date`,
-      `refund.request_date`,
+      `refunds.id`,
+      `refunds.code`,
+      `refunds.refund_date`,
+      `refunds.request_date`,
     ];
   }