Merge branch 'development' of ssh://git.eigen.co.id:2222/eigen/pos-be into production

Reviewed-on: #180

.drone.yml

@@ -2,29 +2,37 @@ kind: pipeline
 type: docker
 name: server
 steps:
-  - name: build
-    image: appleboy/drone-ssh
+  # - name: build
+  #   image: appleboy/drone-ssh
+  #   settings:
+  #     host:
+  #       - 172.10.10.10
+  #     username: eigen
+  #     key:
+  #       from_secret: DEVOPS_SSH_PRIVATE_OPEN
+  #     port: 22
+  #     script:
+  #       - cd /home/eigen/PROJECT/POS/POS.DEV/BE
+  #       - sh build.sh
+  #   when:
+  #     ref:
+  #       - refs/tags/devel_*
+  #       - refs/tags/*-alpha.*
+  - name: build-testing
+    image: plugins/docker
     settings:
-      host:
-        - 172.10.10.10
-      username: eigen
-      key:
-        from_secret: DEVOPS_SSH_PRIVATE_OPEN
-      port: 22
-      script:
-        - cd /home/eigen/PROJECT/POS/POS.DEV/BE
-        - sh build.sh
+      registry: registry.eigen.co.id
+      repo: registry.eigen.co.id/eigen/${DRONE_REPO_NAME}
+      tags: ${DRONE_TAG}
+      custom_dns: 172.10.10.16
     when:
       ref:
-        - refs/tags/devel_*
         - refs/tags/*-alpha.*
   - name: build-production
     image: plugins/docker
     settings:
       registry: registry.eigen.co.id
       repo: registry.eigen.co.id/eigen/${DRONE_REPO_NAME}
-      build_args:
-        - env_target=env.production
       tags: ${DRONE_TAG}
       custom_dns: 172.10.10.16
     when:
@@ -46,3 +54,56 @@ trigger:
   event:
     exclude:
       - promote
+---
+kind: pipeline
+type: docker
+name: kustomize
+
+clone:
+  disable: true
+
+steps:
+  - name: kustomize-testing
+    image: registry.k8s.io/kustomize/kustomize:v5.0.0
+    environment:
+      DEVOPS_SSH_PRIVATE:
+        from_secret: DEVOPS_SSH_PRIVATE
+      DEVOPS_SSH_PUBLIC:
+        from_secret: DEVOPS_SSH_PUBLIC
+      INFRASTRUCTURE_REPO: "k8s-kustomize-external"
+      DIRECTORY_NAME: "weplay-pos-testing"
+    commands:
+      - mkdir -p ~/.ssh &&
+      - echo $DEVOPS_SSH_PRIVATE | base64 -d > ~/.ssh/id_rsa &&
+      - echo $DEVOPS_SSH_PUBLIC | base64 -d > ~/.ssh/id_rsa.pub &&
+      - ssh-keyscan -H -p 2222 git.eigen.co.id >> ~/.ssh/known_hosts &&
+      - chmod 700 ~/.ssh/ &&
+      - chmod 600 ~/.ssh/id_rsa &&
+      - git clone ssh://git@git.eigen.co.id:2222/eigen/$INFRASTRUCTURE_REPO.git &&
+      - cd $INFRASTRUCTURE_REPO/$DIRECTORY_NAME
+      - kustomize edit set image registry.eigen.co.id/eigen/$DRONE_REPO_NAME=registry.eigen.co.id/eigen/$DRONE_REPO_NAME:$DRONE_TAG &&
+      - git add . &&
+      - |-
+        git commit -m "feat: update $DRONE_REPO_NAME testing to $DRONE_TAG" &&
+      - git push origin master
+  - name: send-message
+    image: harbor.eigen.co.id/docker.com/plugins/webhook
+    settings:
+      urls: https://mattermost.eigen.co.id/api/v4/posts
+      content_type: application/json
+      headers:
+        - Authorization=Bearer 5zubexudb38uuradfa36qy98ca
+      template: |
+        {
+          "channel_id": "s1ekqde1c3du5p35g6budnuotc",
+          "message": "ALERT: {{ repo.name }} gagal update dengan tag ${DRONE_TAG}"
+        }
+    when:
+      status:
+        - failure
+trigger:
+  ref:
+    include:
+      - refs/tags/*-alpha.*
+depends_on:
+  - server

Dockerfile

@@ -5,11 +5,11 @@ COPY . .
 RUN yarn install
 RUN yarn build
 FROM node:18.17-alpine
-ARG env_target
+# ARG env_target
 WORKDIR /app
-RUN echo ${env_target}
-COPY env/$env_target /app/.env
-COPY --from=builder /app/env/$env_target .env
+# RUN echo ${env_target}
+# COPY env/$env_target /app/.env
+# COPY --from=builder /app/env/$env_target .env
 COPY --from=builder /app/node_modules ./node_modules
 COPY --from=builder /app/dist ./dist
 COPY --from=builder /app/assets ./assets

env/env.development

@@ -44,3 +44,10 @@ GOOGLE_CALENDAR_ID="326464ac296874c7121825f5ef2e2799baa90b51da240f0045aae22beec1
 SUPERSET_URL=https://dashboard.weplayground.eigen.co.id
 SUPERSET_ADMIN_USERNAME=admin
 SUPERSET_ADMIN_PASSWORD=admin
+
+WHATSAPP_BUSINESS_ACCOUNT_NUMBER_ID=604883366037548
+WHATSAPP_BUSINESS_ACCESS_TOKEN=EAAINOvRRiEEBO9yQsYDnYtjHZB7q1nZCwbBpRcxIGMDWajKZBtmWxNRKvPYkS95KQZBsZBOvSFyjiEg5CcCZBZBtaSZApxyV8fiA3cEyVwf7iVZBQP2YCTPRQZArMFeeXbO0uq5TGygmjsIz3M4YxcUHxPzKO4pKxIyxnzcoUZCqCSo1NqQSLVf3a0JyZAwgDXGL55dV
+
+SETUP_SCHEDULING_KEY=scheduling_key_example
+
+SKIP_TRANSACTION_FEATURE=false

env/env.production

@@ -41,3 +41,10 @@ GOOGLE_CALENDAR_ID="326464ac296874c7121825f5ef2e2799baa90b51da240f0045aae22beec1
 SUPERSET_URL=https://dashboard.weplayground.eigen.co.id
 SUPERSET_ADMIN_USERNAME=admin
 SUPERSET_ADMIN_PASSWORD=admin
+
+WHATSAPP_BUSINESS_ACCOUNT_NUMBER_ID=604883366037548
+WHATSAPP_BUSINESS_ACCESS_TOKEN=EAAINOvRRiEEBO9yQsYDnYtjHZB7q1nZCwbBpRcxIGMDWajKZBtmWxNRKvPYkS95KQZBsZBOvSFyjiEg5CcCZBZBtaSZApxyV8fiA3cEyVwf7iVZBQP2YCTPRQZArMFeeXbO0uq5TGygmjsIz3M4YxcUHxPzKO4pKxIyxnzcoUZCqCSo1NqQSLVf3a0JyZAwgDXGL55dV
+
+SETUP_SCHEDULING_KEY=scheduling_key_example
+
+SKIP_TRANSACTION_FEATURE=false

package.json

@@ -49,15 +49,18 @@
     "exceljs": "^4.4.0",
     "fs-extra": "^11.2.0",
     "googleapis": "^140.0.0",
+    "gtts": "^0.2.1",
     "handlebars": "^4.7.8",
     "mathjs": "^13.0.2",
     "midtrans-client": "^1.3.1",
     "moment": "^2.30.1",
+    "moment-timezone": "^0.6.0",
     "nano": "^10.1.3",
     "nodemailer": "^6.9.14",
     "pdfmake": "^0.2.10",
     "pg": "^8.11.5",
     "plop": "^4.0.1",
+    "qrcode": "^1.5.4",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.5.0",
     "typeorm": "^0.3.20",
@@ -70,6 +73,7 @@
     "@types/express": "^4.17.13",
     "@types/jest": "29.5.12",
     "@types/node": "^20.12.13",
+    "@types/qrcode": "^1.5.5",
     "@types/supertest": "^2.0.11",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",

src/app.module.ts

@@ -33,7 +33,10 @@ import { SeasonTypeModel } from './modules/season-related/season-type/data/model
 import { TaxModule } from './modules/transaction/tax/tax.module';
 import { TaxModel } from './modules/transaction/tax/data/models/tax.model';
 import { SalesPriceFormulaModule } from './modules/transaction/sales-price-formula/sales-price-formula.module';
-import { SalesPriceFormulaModel } from './modules/transaction/sales-price-formula/data/models/sales-price-formula.model';
+import {
+  SalesPriceFormulaModel,
+  TransactionSettingModel,
+} from './modules/transaction/sales-price-formula/data/models/sales-price-formula.model';
 import { ProfitShareFormulaModule } from './modules/transaction/profit-share-formula/profit-share-formula.module';
 import { PaymentMethodModule } from './modules/transaction/payment-method/payment-method.module';
 import { PaymentMethodModel } from './modules/transaction/payment-method/data/models/payment-method.model';
@@ -83,6 +86,31 @@ import { UserLoginModel } from './modules/user-related/user/data/models/user-log
 import { LogUserLoginModel } from './modules/configuration/log/data/models/log-user-login.model';
 import { AuthService } from './core/guards/domain/services/auth.service';
 import { ReportSummaryModule } from './modules/reports/report-summary/report-summary.module';
+import { QueueModule } from './modules/queue/queue.module';
+import {
+  QueueOrderModel,
+  QueueTicketModel,
+  QueueItemModel,
+  QueueModel,
+} from './modules/queue/data/models/queue.model';
+import { ItemQueueModule } from './modules/item-related/item-queue/item-queue.module';
+import { ItemQueueModel } from './modules/item-related/item-queue/data/models/item-queue.model';
+import { QueueBucketModel } from './modules/queue/data/models/queue-bucket.model';
+import { VerificationModel } from './modules/booking-online/authentication/data/models/verification.model';
+import { BookingOnlineAuthModule } from './modules/booking-online/authentication/auth.module';
+import { BookingOrderModule } from './modules/booking-online/order/order.module';
+import { TimeGroupModule } from './modules/item-related/time-group/time-group.module';
+import { TimeGroupModel } from './modules/item-related/time-group/data/models/time-group.model';
+
+import { OtpVerificationModule } from './modules/configuration/otp-verification/otp-verification.module';
+import { OtpVerificationModel } from './modules/configuration/otp-verification/data/models/otp-verification.model';
+import { OtpVerifierModel } from './modules/configuration/otp-verification/data/models/otp-verifier.model';
+import { RescheduleVerificationModel } from './modules/booking-online/order/data/models/reschedule-verification.model';
+import { OtpCheckerGuard } from './core/guards/domain/otp-checker.guard';
+import { DataSchedulingModel } from './modules/configuration/data-scheduling/data/models/data-scheduling.model';
+import { DataSchedulingModule } from './modules/configuration/data-scheduling/data-scheduling.module';
+import { DataSchedulingDefaultModel } from './modules/configuration/data-scheduling/data/models/data-scheduling-default.model';
+import { DataSchedulingLogModel } from './modules/configuration/data-scheduling/data/models/data-scheduling-log.model';
 
 @Module({
   imports: [
@@ -107,6 +135,8 @@ import { ReportSummaryModule } from './modules/reports/report-summary/report-sum
         ItemModel,
         ItemCategoryModel,
         ItemRateModel,
+        ItemQueueModel,
+        TimeGroupModel,
         LogModel,
         LogUserLoginModel,
         NewsModel,
@@ -126,6 +156,7 @@ import { ReportSummaryModule } from './modules/reports/report-summary/report-sum
         TransactionItemBreakdownModel,
         TransactionItemTaxModel,
         TransactionBreakdownTaxModel,
+        TransactionSettingModel,
         UserModel,
         UserLoginModel,
 
@@ -135,6 +166,25 @@ import { ReportSummaryModule } from './modules/reports/report-summary/report-sum
         // report
         ReportBookmarkModel,
         ExportReportHistoryModel,
+
+        // Queue
+        QueueOrderModel,
+        QueueTicketModel,
+        QueueItemModel,
+        QueueModel,
+        QueueBucketModel,
+
+        // Booking Online
+        VerificationModel,
+        RescheduleVerificationModel,
+
+        OtpVerificationModel,
+        OtpVerifierModel,
+
+        // Data Scheduling
+        DataSchedulingModel,
+        DataSchedulingDefaultModel,
+        DataSchedulingLogModel,
       ],
       synchronize: false,
     }),
@@ -160,6 +210,8 @@ import { ReportSummaryModule } from './modules/reports/report-summary/report-sum
     ItemCategoryModule,
     ItemModule,
     ItemRateModule,
+    ItemQueueModule,
+    TimeGroupModule,
 
     // transaction
     PaymentMethodModule,
@@ -193,11 +245,20 @@ import { ReportSummaryModule } from './modules/reports/report-summary/report-sum
     SupersetModule,
 
     GateScanModule,
+
+    QueueModule,
+
+    BookingOnlineAuthModule,
+    BookingOrderModule,
+    OtpVerificationModule,
+    DataSchedulingModule,
   ],
   controllers: [],
   providers: [
     AuthService,
     PrivilegeService,
+    OtpCheckerGuard,
+
     /**
      * By default all request from client will protect by JWT
      * if there is some endpoint/function that does'nt require authentication

src/core/guards/domain/otp-checker.guard.ts

@@ -0,0 +1,57 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnprocessableEntityException,
+} from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { OtpVerificationModel } from 'src/modules/configuration/otp-verification/data/models/otp-verification.model';
+import { OtpVerificationEntity } from 'src/modules/configuration/otp-verification/domain/entities/otp-verification.entity';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class OtpCheckerGuard implements CanActivate {
+  constructor(
+    @InjectDataSource(CONNECTION_NAME.DEFAULT)
+    protected readonly dataSource: DataSource,
+  ) {}
+
+  get otpRepository() {
+    return this.dataSource.getRepository(OtpVerificationModel);
+  }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const verificationCode = request.headers['x-verification-code'];
+    console.log({ verificationCode });
+
+    if (verificationCode) {
+      const decoded = Buffer.from(verificationCode, 'base64').toString('ascii');
+      const [dataIdentity, otpCode] = decoded.split('|');
+
+      let otpData: OtpVerificationEntity;
+
+      otpData = await this.otpRepository.findOne({
+        where: {
+          otp_code: otpCode,
+          target_id: dataIdentity,
+        },
+      });
+
+      if (!otpData) {
+        otpData = await this.otpRepository.findOne({
+          where: {
+            otp_code: otpCode,
+            reference: dataIdentity,
+          },
+        });
+      }
+
+      // console.log({ dataIdentity, otpCode, otpData });
+      if (otpData && otpData?.verified_at) return true;
+    }
+
+    throw new UnprocessableEntityException('OTP not verified.');
+  }
+}

src/core/helpers/otp/otp-service.ts

@@ -0,0 +1,66 @@
+interface OtpServiceEntity {
+  length?: number;
+}
+
+export class OtpService {
+  private readonly otpLength: number;
+
+  constructor({ length = 4 }: OtpServiceEntity) {
+    this.otpLength = Math.max(length, 4); // Minimum of 4 digits
+  }
+
+  private hasSequentialDigits(str: string): boolean {
+    for (let i = 0; i < str.length - 1; i++) {
+      const current = parseInt(str[i], 10);
+      const next = parseInt(str[i + 1], 10);
+      if (next === current + 1 || next === current - 1) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private hasRepeatedDigits(str: string): boolean {
+    return str.split('').every((char) => char === str[0]);
+  }
+
+  private isPalindrome(str: string): boolean {
+    return str === str.split('').reverse().join('');
+  }
+
+  private hasPartiallyRepeatedDigits(str: string): boolean {
+    const counts: Record<string, number> = {};
+    for (const char of str) {
+      counts[char] = (counts[char] || 0) + 1;
+    }
+
+    // Reject if any digit appears more than twice
+    return Object.values(counts).some((count) => count > 2);
+  }
+
+  private hasNoMatchLength(str: string) {
+    return str.length !== this.otpLength;
+  }
+
+  private hasStartWithZero(str: string) {
+    return str.split('')[0] === '0';
+  }
+
+  public generateSecureOTP(): string {
+    let otp: string;
+
+    do {
+      otp = Array.from({ length: this.otpLength }, () =>
+        Math.floor(Math.random() * 10).toString(),
+      ).join('');
+    } while (
+      this.hasNoMatchLength(otp) ||
+      this.hasSequentialDigits(otp) ||
+      this.hasRepeatedDigits(otp) ||
+      this.isPalindrome(otp) ||
+      this.hasPartiallyRepeatedDigits(otp) ||
+      this.hasStartWithZero(otp)
+    );
+    return otp;
+  }
+}

src/core/helpers/path/upload-store-path.helper.ts

@@ -8,7 +8,9 @@ import { diskStorage } from 'multer';
 const MB = 1024 * 1024;
 
 const fileFilter = (req, file, callback) => {
-  if (file.mimetype.match(/\/(jpg|jpeg|png)$/)) {
+  if (
+    file.mimetype.match(/\/(jpg|jpeg|png|flv|mp4|m3u8|ts|3gp|mov|avi|wmv)$/)
+  ) {
     callback(null, true);
   } else {
     callback(

src/core/helpers/validation/validate-relation.helper.ts

@@ -52,10 +52,12 @@ export class ValidateRelationHelper<Entity> {
         `Failed! this data already connected to ${relation.relation}`;
 
       if (relation.singleQuery) {
+        const relationObject = data[relation.relation] ?? {};
+        const isRelationExist = `${relation.singleQuery[0]}` in relationObject;
         const relationColumn =
           data[relation.relation]?.[`${relation.singleQuery[0]}`];
         if (
-          !!relationColumn &&
+          isRelationExist &&
           this.mappingValidator(
             relationColumn,
             relation.singleQuery[1],
@@ -69,6 +71,7 @@ export class ValidateRelationHelper<Entity> {
   }
 
   mappingValidator(column, operator, value) {
+    const candidates = Array.isArray(value) ? value : [value];
     switch (operator) {
       case '!=':
         return column != value;
@@ -76,6 +79,12 @@ export class ValidateRelationHelper<Entity> {
       case '==':
         return column == value;
 
+      case 'in':
+        return candidates.includes(column);
+
+      case 'not in':
+        return !candidates.includes(column);
+
       default:
         return column == value;
     }

src/core/modules/domain/usecase/base.manager.ts

@@ -32,7 +32,7 @@ export abstract class BaseManager {
 
   setUser() {
     try {
-      this.user = this.userProvider?.user;
+      this.user = this.userProvider?.user ?? BLANK_USER;
     } catch (error) {
       this.user = BLANK_USER;
     }

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

@@ -71,7 +71,7 @@ export abstract class BaseCreateManager<Entity> extends BaseManager {
   }
 
   async publishEvents() {
-    this.eventBus.publish(
+    this.eventBus?.publish(
       new RecordLog({
         id: this.result['id'],
         old: null,

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

@@ -50,7 +50,7 @@ export abstract class BaseIndexManager<Entity> extends BaseReadManager {
 
         // jika searching status terdapat dalam enum, maka dia mencari specific data
         // ? karena jika tidak, ketika dia search "active" maka "inactive" juga ikut
-        return `'${STATUS[statusData.toUpperCase()]}'` ?? `'%${statusData}%'`;
+        return `'${STATUS[statusData.toUpperCase()]}'`;
       });
 
       const exist = specificFilter.find((item) => item.isStatus);

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

@@ -1,6 +1,10 @@
 import { ValidateRelationHelper } from 'src/core/helpers/validation/validate-relation.helper';
 import { BaseManager } from '../base.manager';
-import { OPERATION, STATUS } from 'src/core/strings/constants/base.constants';
+import {
+  OPERATION,
+  QUEUE_STATUS,
+  STATUS,
+} from 'src/core/strings/constants/base.constants';
 import * as _ from 'lodash';
 import { RecordLog } from 'src/modules/configuration/log/domain/entities/log.event';
 
@@ -8,12 +12,12 @@ export abstract class BaseUpdateStatusManager<Entity> extends BaseManager {
   protected dataId: string;
   protected result: Entity;
   protected oldData: Entity;
-  protected dataStatus: STATUS;
+  protected dataStatus: STATUS | QUEUE_STATUS;
   protected relations = [];
   protected duplicateColumn: string[];
   abstract get entityTarget(): any;
 
-  setData(id: string, status: STATUS): void {
+  setData(id: string, status: STATUS | QUEUE_STATUS): void {
     /**
      * // TODO: Handle case confirm multiple tabs;
      * Pola id yang dikirim dirubah menjadi data_id___updated_at

src/core/modules/infrastructure/dto/base-filter.dto.ts

@@ -23,6 +23,7 @@ export class BaseFilterDto implements BaseFilterEntity {
   @IsNumber()
   limit = 10;
 
+  @ApiProperty({ type: String, required: false })
   q: string;
 
   @ApiProperty({ type: ['string'], required: false })

src/core/sessions/domain/entities/user-sessions.interface.ts

@@ -6,5 +6,6 @@ export interface UsersSession {
   name: string;
   role: UserRole;
   source?: AppSource;
+  item_id?: string;
   user_privilege_id: string;
 }

src/core/strings/constants/base.constants.ts

@@ -15,6 +15,11 @@ export enum STATUS {
   WAITING = 'waiting',
 }
 
+export enum QUEUE_STATUS {
+  DONE = 'done',
+  CALLED = 'called',
+}
+
 export enum ORDER_TYPE {
   ASC = 'ASC',
   DESC = 'DESC',

src/core/strings/constants/module.constants.ts

@@ -4,6 +4,7 @@ export enum MODULE_NAME {
   GATE = 'gates',
   ITEM = 'items',
   ITEM_CATEGORY = 'item-categories',
+  ITEM_QUEUE = 'item-queues',
   ITEM_RATE = 'item-rates',
   NEWS = 'news',
   PAYMENT_METHOD = 'payment-methods',
@@ -25,4 +26,16 @@ export enum MODULE_NAME {
   REPORT_BOOKMARK = 'report-bookmark',
   REPORT_EXPORT = 'report-export',
   REPORT_SUMMARY = 'report-summary',
+
+  QUEUE = 'queue',
+
+  TIME_GROUPS = 'time-groups',
+  OTP_VERIFICATIONS = 'otp-verification',
+
+  OTP_VERIFIER = 'otp-verifier',
+  DATA_SCHEDULING = 'data-scheduling',
+  DATA_SCHEDULING_LOG = 'data-scheduling-log',
+  DATA_SCHEDULING_DEFAULT = 'data-scheduling-default',
+  DATA_SCHEDULING_ACTIVE = 'data-scheduling-active',
+  DATA_SCHEDULING_SETUP = 'data-scheduling-setup',
 }

src/core/strings/constants/table.constants.ts

@@ -4,6 +4,7 @@ export enum TABLE_NAME {
   FAQ = 'faqs',
   ITEM = 'items',
   ITEM_CATEGORY = 'item_categories',
+  ITEM_QUEUE = 'item_queues',
   ITEM_RATE = 'item_rates',
   GATE = 'gates',
   LOG = 'logs',
@@ -11,6 +12,7 @@ export enum TABLE_NAME {
   NEWS = 'news',
   PAYMENT_METHOD = 'payment_methods',
   PRICE_FORMULA = 'price_formulas',
+
   REFUND = 'refunds',
   REFUND_ITEM = 'refund_items',
   SEASON_TYPE = 'season_types',
@@ -25,6 +27,8 @@ export enum TABLE_NAME {
   TRANSACTION_ITEM_TAX = 'transaction_item_taxes',
   TRANSACTION_ITEM_BREAKDOWN_TAX = 't_breakdown_item_taxes',
   TRANSACTION_DEMOGRAPHY = 'transaction_demographies',
+  TRANSACTION_SETTING = 'api_settings',
+
   USER = 'users',
   USER_LOGIN = 'users_login',
   LOG_USER_LOGIN = 'log_users_login',
@@ -35,4 +39,18 @@ export enum TABLE_NAME {
 
   REPORT_BOOKMARK = 'report_bookmark',
   EXPORT_REPORT_HISTORY = 'export_report_history',
+
+  QUEUE = 'queues',
+  QUEUE_ORDER = 'queue_orders',
+  QUEUE_TICKET = 'queue_tickets',
+  QUEUE_ITEM = 'queue_items',
+  QUEUE_BUCKET = 'queue_bucket',
+
+  TIME_GROUPS = 'time_groups',
+  OTP_VERIFICATIONS = 'otp_verifications',
+  OTP_VERIFIER = 'otp_verifier',
+
+  DATA_SCHEDULING = 'event_scheduling',
+  DATA_SCHEDULING_DEFAULT = 'event_scheduling_default',
+  DATA_SCHEDULING_LOG = 'event_scheduling_log',
 }

src/database/migrations/1723801180604-add-estimation-to-item.ts

@@ -5,7 +5,7 @@ export class AddEstimationToItem1723801180604 implements MigrationInterface {
 
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.query(
-      `ALTER TABLE "items" ADD "play_estimation" integer`,
+      `ALTER TABLE "items" ADD "play_estimation" numeric`,
     );
   }
 

src/database/migrations/1728377112337-add-discount-value-to-voucher.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddDiscountValueToVoucher1728377112337
+  implements MigrationInterface
+{
+  name = 'AddDiscountValueToVoucher1728377112337';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "vip_codes" ADD "discount_value" numeric`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "vip_codes" ALTER COLUMN "discount" DROP NOT NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "vip_codes" ALTER COLUMN "discount" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "vip_codes" DROP COLUMN "discount_value"`,
+    );
+  }
+}

src/database/migrations/1729072422409-item-video-and-vip-pass.ts

@@ -0,0 +1,21 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ItemVideoAndVipPass1729072422409 implements MigrationInterface {
+  name = 'ItemVideoAndVipPass1729072422409';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD "video_url" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "vip_categories" ADD "has_vip_pass" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "vip_categories" DROP COLUMN "has_vip_pass"`,
+    );
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "video_url"`);
+  }
+}

src/database/migrations/1729151429165-queue-table.ts

@@ -0,0 +1,43 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class QueueTable1729151429165 implements MigrationInterface {
+  name = 'QueueTable1729151429165';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "queue_orders" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "code" character varying NOT NULL, "customer" character varying, "phone" character varying, "date" bigint NOT NULL, CONSTRAINT "PK_b139e4cc9ca3e709c152f820d2e" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "queue_tickets" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "code" character varying NOT NULL, "customer" character varying, "phone" character varying, "date" bigint NOT NULL, "order_id" uuid, CONSTRAINT "PK_1b903aa90bcc04136caa6540c55" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "queue_items" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "qty" integer NOT NULL, "ticket_id" uuid, "item_id" uuid, CONSTRAINT "PK_2245e11ac3517494bacfe932773" PRIMARY KEY ("id"))`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "queue_tickets" ADD CONSTRAINT "FK_0e9823b8b7ca9523b3be73878e5" FOREIGN KEY ("order_id") REFERENCES "queue_orders"("id") ON DELETE SET NULL ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queue_items" ADD CONSTRAINT "FK_25352739034765f6917757df74b" FOREIGN KEY ("ticket_id") REFERENCES "queue_tickets"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queue_items" ADD CONSTRAINT "FK_ab15c053aeb4f739ebf533b61cd" FOREIGN KEY ("item_id") REFERENCES "items"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queue_items" DROP CONSTRAINT "FK_ab15c053aeb4f739ebf533b61cd"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queue_items" DROP CONSTRAINT "FK_25352739034765f6917757df74b"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queue_tickets" DROP CONSTRAINT "FK_0e9823b8b7ca9523b3be73878e5"`,
+    );
+
+    await queryRunner.query(`DROP TABLE "queue_items"`);
+    await queryRunner.query(`DROP TABLE "queue_tickets"`);
+    await queryRunner.query(`DROP TABLE "queue_orders"`);
+  }
+}

src/database/migrations/1729248576381-video-url-to-json.ts

@@ -0,0 +1,18 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class VideoUrlToJson1729248576381 implements MigrationInterface {
+  name = 'VideoUrlToJson1729248576381';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "video_url"`);
+    await queryRunner.query(`ALTER TABLE "items" ADD "video_url" json`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "video_url"`);
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD "video_url" character varying`,
+    );
+    await queryRunner.query(`DROP TABLE "item_queues"`);
+  }
+}

src/database/migrations/1729570177597-item-queues.ts

@@ -0,0 +1,33 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ItemQueues1729570177597 implements MigrationInterface {
+  name = 'ItemQueues1729570177597';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."item_queues_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'partial refund', 'pending', 'proses refund', 'refunded', 'rejected', 'settled', 'waiting')`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."item_queues_item_type_enum" AS ENUM('tiket masuk', 'wahana', 'bundling', 'free gift', 'other')`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "item_queues" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."item_queues_status_enum" NOT NULL DEFAULT 'draft', "name" character varying NOT NULL, "item_type" "public"."item_queues_item_type_enum" NOT NULL DEFAULT 'tiket masuk', CONSTRAINT "PK_e19adb0b99d995e8f10c189985f" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(`ALTER TABLE "items" ADD "item_queue_id" uuid`);
+
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD CONSTRAINT "FK_2cbbeb03e176addcf60d65f7c9c" FOREIGN KEY ("item_queue_id") REFERENCES "item_queues"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "items" DROP CONSTRAINT "FK_2cbbeb03e176addcf60d65f7c9c"`,
+    );
+
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "item_queue_id"`);
+    await queryRunner.query(`DROP TABLE "item_queues"`);
+    await queryRunner.query(`DROP TYPE "public"."item_queues_item_type_enum"`);
+    await queryRunner.query(`DROP TYPE "public"."item_queues_status_enum"`);
+  }
+}

src/database/migrations/1729582398827-item-queue-on-delete.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ItemQueueOnDelete1729582398827 implements MigrationInterface {
+  name = 'ItemQueueOnDelete1729582398827';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "items" DROP CONSTRAINT "FK_2cbbeb03e176addcf60d65f7c9c"`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD CONSTRAINT "FK_2cbbeb03e176addcf60d65f7c9c" FOREIGN KEY ("item_queue_id") REFERENCES "item_queues"("id") ON DELETE SET NULL ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "items" DROP CONSTRAINT "FK_2cbbeb03e176addcf60d65f7c9c"`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD CONSTRAINT "FK_2cbbeb03e176addcf60d65f7c9c" FOREIGN KEY ("item_queue_id") REFERENCES "item_queues"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+}

src/database/migrations/1729653046392-add-transaction-id-to-queue-order.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddTransactionIdToQueueOrder1729653046392
+  implements MigrationInterface
+{
+  name = 'AddTransactionIdToQueueOrder1729653046392';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queue_orders" ADD "transaction_id" character varying NOT NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queue_orders" DROP COLUMN "transaction_id"`,
+    );
+  }
+}

src/database/migrations/1729756969674-add-queue-table.ts

@@ -0,0 +1,22 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddQueueTable1729756969674 implements MigrationInterface {
+  name = 'AddQueueTable1729756969674';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "queues" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "code" character varying NOT NULL, "status" character varying NOT NULL, "time" bigint NOT NULL, "call_time" bigint NOT NULL, "vip" boolean NOT NULL, "item_id" uuid NOT NULL, "qty" integer NOT NULL, CONSTRAINT "PK_d966f9eb39a9396658387071bb3" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD CONSTRAINT "FK_435954e9a0d9967f17e043d54b4" FOREIGN KEY ("item_id") REFERENCES "queue_items"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queues" DROP CONSTRAINT "FK_435954e9a0d9967f17e043d54b4"`,
+    );
+
+    await queryRunner.query(`DROP TABLE "queues"`);
+  }
+}

src/database/migrations/1729838994129-add-queue-base-model.ts

@@ -0,0 +1,39 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddQueueBaseModel1729838994129 implements MigrationInterface {
+  name = 'AddQueueBaseModel1729838994129';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "creator_id" character varying(36)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "creator_name" character varying(125)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "editor_id" character varying(36)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "editor_name" character varying(125)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "created_at" bigint NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "updated_at" bigint NOT NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queues" ALTER COLUMN "call_time" DROP NOT NULL`,
+    );
+
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "updated_at"`);
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "created_at"`);
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "editor_name"`);
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "editor_id"`);
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "creator_name"`);
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "creator_id"`);
+  }
+}

src/database/migrations/1730859187883-add-queue-bucket.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddQueueBucket1730859187883 implements MigrationInterface {
+  name = 'AddQueueBucket1730859187883';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "queue_bucket" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "queue_item_id" character varying NOT NULL, "date" bigint NOT NULL, "regular" integer NOT NULL, "vip" integer NOT NULL, CONSTRAINT "PK_cdd58b0d9e93e4be922da9d8bd6" PRIMARY KEY ("id"))`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "queue_bucket"`);
+  }
+}

src/database/migrations/1731383726542-add-transaction-and-item-relation.ts

@@ -0,0 +1,50 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddTransactionAndItemRelation1731383726542
+  implements MigrationInterface
+{
+  name = 'AddTransactionAndItemRelation1731383726542';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "transaction_items" DROP COLUMN "item_id"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transaction_items" ADD "item_id" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP COLUMN "customer_category_id"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" ADD "customer_category_id" uuid`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "transaction_items" ADD CONSTRAINT "FK_edb934ab033f847e3f7ed4fc0fc" FOREIGN KEY ("item_id") REFERENCES "items"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" ADD CONSTRAINT "FK_08dc8138714894a66e94820766d" FOREIGN KEY ("customer_category_id") REFERENCES "vip_categories"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP CONSTRAINT "FK_08dc8138714894a66e94820766d"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transaction_items" DROP CONSTRAINT "FK_edb934ab033f847e3f7ed4fc0fc"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP COLUMN "customer_category_id"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" ADD "customer_category_id" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transaction_items" DROP COLUMN "item_id"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transaction_items" ADD "item_id" character varying`,
+    );
+  }
+}

src/database/migrations/1731498661938-add-item-queue-to-queue.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddItemQueueToQueue1731498661938 implements MigrationInterface {
+  name = 'AddItemQueueToQueue1731498661938';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "item_queue_id" character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "queues" DROP COLUMN "item_queue_id"`);
+  }
+}

src/database/migrations/1731570311609-add-information-to-item-queue.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddInformationToItemQueue1731570311609
+  implements MigrationInterface
+{
+  name = 'AddInformationToItemQueue1731570311609';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" ADD "information" character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" DROP COLUMN "information"`,
+    );
+  }
+}

src/database/migrations/1733199330134-item-queue-add-time-and-peak-level.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ItemQueueAddTimeAndPeakLevel1733199330134
+  implements MigrationInterface
+{
+  name = 'ItemQueueAddTimeAndPeakLevel1733199330134';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" ADD "max_peak_level" integer NOT NULL DEFAULT '100'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" ADD "call_preparation" integer NOT NULL DEFAULT '5'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" DROP COLUMN "call_preparation"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" DROP COLUMN "max_peak_level"`,
+    );
+  }
+}

src/database/migrations/1734717058658-add-notification-config-to-item-queue.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddNotificationConfigToItemQueue1734717058658
+  implements MigrationInterface
+{
+  name = 'AddNotificationConfigToItemQueue1734717058658';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" ADD "use_notification" boolean NOT NULL DEFAULT true`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" ADD "requiring_notification" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" DROP COLUMN "requiring_notification"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" DROP COLUMN "use_notification"`,
+    );
+  }
+}

src/database/migrations/1734718462106-add-last-notification-to-queue.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddLastNotificationToQueue1734718462106
+  implements MigrationInterface
+{
+  name = 'AddLastNotificationToQueue1734718462106';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queues" ADD "last_notification" bigint NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "queues" DROP COLUMN "last_notification"`,
+    );
+  }
+}

src/database/migrations/1748313715598-booking-authentication.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class BookingAuthentication1748313715598 implements MigrationInterface {
+  name = 'BookingAuthentication1748313715598';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "booking_verification" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" character varying NOT NULL, "phone_number" character varying NOT NULL, "code" character varying, "tried" integer NOT NULL DEFAULT '0', "created_at" bigint NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000, "updated_at" bigint NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000, CONSTRAINT "PK_046e9288c7dd05c7259275d9fc0" PRIMARY KEY ("id"))`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "booking_verification"`);
+  }
+}

src/database/migrations/1748409891706-create-time-group-table.ts

@@ -0,0 +1,27 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateTimeGroupTable1748409891706 implements MigrationInterface {
+  name = 'CreateTimeGroupTable1748409891706';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."time_groups_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'partial refund', 'pending', 'proses refund', 'refunded', 'rejected', 'settled', 'waiting')`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "time_groups" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."time_groups_status_enum" NOT NULL DEFAULT 'draft', "name" character varying NOT NULL, "start_time" TIME NOT NULL, "end_time" TIME NOT NULL, "max_usage_time" TIME NOT NULL, CONSTRAINT "PK_083d02988db7bedfe3b7c869b50" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(`ALTER TABLE "items" ADD "time_group_id" uuid`);
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD CONSTRAINT "FK_f44f222e1808448dca1b6cc4557" FOREIGN KEY ("time_group_id") REFERENCES "time_groups"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "items" DROP CONSTRAINT "FK_f44f222e1808448dca1b6cc4557"`,
+    );
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "time_group_id"`);
+    await queryRunner.query(`DROP TABLE "time_groups"`);
+    await queryRunner.query(`DROP TYPE "public"."time_groups_status_enum"`);
+  }
+}

src/database/migrations/1748935417155-add_column_otp_code.ts

@@ -0,0 +1,21 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddColumnOtpCode1748935417155 implements MigrationInterface {
+  name = 'AddColumnOtpCode1748935417155';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "vip_codes" ADD "otp_code" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" ADD "otp_code" character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP COLUMN "otp_code"`,
+    );
+    await queryRunner.query(`ALTER TABLE "vip_codes" DROP COLUMN "otp_code"`);
+  }
+}

src/database/migrations/1749028279580-create-table-otp-cerifications.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateTableOtpCerifications1749028279580
+  implements MigrationInterface
+{
+  name = 'CreateTableOtpCerifications1749028279580';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifications_action_type_enum" AS ENUM('CREATE_DISCOUNT', 'CANCEL_TRANSACTION')`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifications_source_enum" AS ENUM('POS', 'WEB')`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "otp_verifications" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "otp_code" character varying NOT NULL, "action_type" "public"."otp_verifications_action_type_enum" NOT NULL, "target_id" character varying, "reference" character varying, "source" "public"."otp_verifications_source_enum" NOT NULL, "is_used" boolean NOT NULL DEFAULT false, "expired_at" bigint NOT NULL, "verified_at" bigint, CONSTRAINT "PK_91d17e75ac3182dba6701869b39" PRIMARY KEY ("id"))`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "otp_verifications"`);
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifications_source_enum"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifications_action_type_enum"`,
+    );
+  }
+}

src/database/migrations/1749030419440-add_column_is_replaced_otp_verification.ts

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddColumnIsReplacedOtpVerification1749030419440
+  implements MigrationInterface
+{
+  name = 'AddColumnIsReplacedOtpVerification1749030419440';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifications" ADD "is_replaced" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifications" DROP COLUMN "is_replaced"`,
+    );
+  }
+}

src/database/migrations/1749043616622-add_table_otp_verifier.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddTableOtpVerifier1749043616622 implements MigrationInterface {
+  name = 'AddTableOtpVerifier1749043616622';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "otp_verifier" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "name" character varying, "phone_number" character varying NOT NULL, CONSTRAINT "PK_884e2d0873fc589a1bdc477b2ea" PRIMARY KEY ("id"))`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "otp_verifier"`);
+  }
+}

src/database/migrations/1749046285398-update_enum_otp_action_type.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class UpdateEnumOtpActionType1749046285398
+  implements MigrationInterface
+{
+  name = 'UpdateEnumOtpActionType1749046285398';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TYPE "public"."otp_verifications_action_type_enum" RENAME TO "otp_verifications_action_type_enum_old"`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifications_action_type_enum" AS ENUM('CREATE_DISCOUNT', 'CANCEL_TRANSACTION', 'REJECT_RECONCILIATION')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifications" ALTER COLUMN "action_type" TYPE "public"."otp_verifications_action_type_enum" USING "action_type"::"text"::"public"."otp_verifications_action_type_enum"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifications_action_type_enum_old"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifications_action_type_enum_old" AS ENUM('CREATE_DISCOUNT', 'CANCEL_TRANSACTION')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifications" ALTER COLUMN "action_type" TYPE "public"."otp_verifications_action_type_enum_old" USING "action_type"::"text"::"public"."otp_verifications_action_type_enum_old"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifications_action_type_enum"`,
+    );
+    await queryRunner.query(
+      `ALTER TYPE "public"."otp_verifications_action_type_enum_old" RENAME TO "otp_verifications_action_type_enum"`,
+    );
+  }
+}

src/database/migrations/1749524993295-reschedule-otp.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class RescheduleOtp1749524993295 implements MigrationInterface {
+  name = 'RescheduleOtp1749524993295';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "reschedule_verification" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" character varying NOT NULL, "phone_number" character varying NOT NULL, "booking_id" character varying NOT NULL, "reschedule_date" character varying NOT NULL, "code" integer NOT NULL, "tried" integer NOT NULL DEFAULT '0', "created_at" bigint NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000, "updated_at" bigint NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000, CONSTRAINT "PK_d4df453337ca12771eb223323d8" PRIMARY KEY ("id"))`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "booking_verification" ALTER COLUMN "created_at" SET DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "booking_verification" ALTER COLUMN "updated_at" SET DEFAULT EXTRACT(EPOCH FROM NOW()) * 1000`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "booking_verification" ALTER COLUMN "updated_at" SET DEFAULT (EXTRACT(epoch FROM now()) * (1000))`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "booking_verification" ALTER COLUMN "created_at" SET DEFAULT (EXTRACT(epoch FROM now()) * (1000))`,
+    );
+    await queryRunner.query(`DROP TABLE "reschedule_verification"`);
+  }
+}

src/database/migrations/1749537252986-add-booking-description-to-item.ts

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

src/database/migrations/1749604239749-add-booking-parent-to-transaction.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddBookingParentToTransaction1749604239749
+  implements MigrationInterface
+{
+  name = 'AddBookingParentToTransaction1749604239749';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "transactions" ADD "parent_id" uuid`);
+
+    await queryRunner.query(
+      `ALTER TABLE "transactions" ADD CONSTRAINT "FK_413e95171729ba18cabce1c31e3" FOREIGN KEY ("parent_id") REFERENCES "transactions"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP CONSTRAINT "FK_413e95171729ba18cabce1c31e3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "transactions" DROP COLUMN "parent_id"`,
+    );
+  }
+}

src/database/migrations/1750045520332-add_enum_otp_action_type_and_update_column_otp_verifier.ts

@@ -0,0 +1,55 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddEnumOtpActionTypeAndUpdateColumnOtpVerifier1750045520332
+  implements MigrationInterface
+{
+  name = 'AddEnumOtpActionTypeAndUpdateColumnOtpVerifier1750045520332';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifier" ADD "is_all_action" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifier_action_types_enum" AS ENUM('CREATE_DISCOUNT', 'CANCEL_TRANSACTION', 'REJECT_RECONCILIATION', 'ACTIVATE_ITEM', 'ACTIVATE_USER', 'UPDATE_ITEM_PRICE', 'UPDATE_ITEM_DETAILS', 'CONFIRM_TRANSACTION')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifier" ADD "action_types" "public"."otp_verifier_action_types_enum" array`,
+    );
+    await queryRunner.query(
+      `ALTER TYPE "public"."otp_verifications_action_type_enum" RENAME TO "otp_verifications_action_type_enum_old"`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifications_action_type_enum" AS ENUM('CREATE_DISCOUNT', 'CANCEL_TRANSACTION', 'REJECT_RECONCILIATION', 'ACTIVATE_ITEM', 'ACTIVATE_USER', 'UPDATE_ITEM_PRICE', 'UPDATE_ITEM_DETAILS', 'CONFIRM_TRANSACTION')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifications" ALTER COLUMN "action_type" TYPE "public"."otp_verifications_action_type_enum" USING "action_type"::"text"::"public"."otp_verifications_action_type_enum"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifications_action_type_enum_old"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."otp_verifications_action_type_enum_old" AS ENUM('CREATE_DISCOUNT', 'CANCEL_TRANSACTION', 'REJECT_RECONCILIATION')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifications" ALTER COLUMN "action_type" TYPE "public"."otp_verifications_action_type_enum_old" USING "action_type"::"text"::"public"."otp_verifications_action_type_enum_old"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifications_action_type_enum"`,
+    );
+    await queryRunner.query(
+      `ALTER TYPE "public"."otp_verifications_action_type_enum_old" RENAME TO "otp_verifications_action_type_enum"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifier" DROP COLUMN "action_types"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."otp_verifier_action_types_enum"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "otp_verifier" DROP COLUMN "is_all_action"`,
+    );
+  }
+}

src/database/migrations/1750319148269-add-usage-type-to-item.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddUsageTypeToItem1750319148269 implements MigrationInterface {
+  name = 'AddUsageTypeToItem1750319148269';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."item_queues_usage_type_enum" AS ENUM('one_time', 'multiple')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" ADD "usage_type" "public"."item_queues_usage_type_enum" NOT NULL DEFAULT 'one_time'`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."items_usage_type_enum" AS ENUM('one_time', 'multiple')`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "items" ADD "usage_type" "public"."items_usage_type_enum" NOT NULL DEFAULT 'one_time'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "items" DROP COLUMN "usage_type"`);
+    await queryRunner.query(`DROP TYPE "public"."items_usage_type_enum"`);
+    await queryRunner.query(
+      `ALTER TABLE "item_queues" DROP COLUMN "usage_type"`,
+    );
+    await queryRunner.query(`DROP TYPE "public"."item_queues_usage_type_enum"`);
+  }
+}

src/database/migrations/1750834308368-remove-item-name-unique.ts

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

src/database/migrations/1751942902581-renam-table-config.ts

@@ -0,0 +1,38 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class RenamTableConfig1751942902581 implements MigrationInterface {
+  name = 'RenamTableConfig1751942902581';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "api_settings" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "value" numeric NOT NULL DEFAULT '100', CONSTRAINT "PK_14bbb118ae1b2bd2385186cffb9" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."event_scheduling_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'partial refund', 'pending', 'proses refund', 'refunded', 'rejected', 'settled', 'waiting')`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "event_scheduling" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."event_scheduling_status_enum" NOT NULL DEFAULT 'draft', "name" character varying NOT NULL, "indexing_key" character varying NOT NULL, "schedule_date_from" date NOT NULL, "schedule_date_to" date NOT NULL, CONSTRAINT "PK_a2ccd3f6ab787b0d7e2af09d30c" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "event_scheduling_default" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "default_value" integer NOT NULL, CONSTRAINT "PK_9caf65330e76243e9f9285ae2e1" PRIMARY KEY ("id"))`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "api_settings" ADD "key" character varying`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "event_scheduling_default"`);
+    await queryRunner.query(`DROP TABLE "event_scheduling"`);
+    await queryRunner.query(
+      `DROP TYPE "public"."event_scheduling_status_enum"`,
+    );
+    await queryRunner.query(`DROP TABLE "api_settings"`);
+    await queryRunner.query(
+      `ALTER TABLE "item_bundlings" ADD CONSTRAINT "FK_a50e7abf2caba4d0394f3726b86" FOREIGN KEY ("item_bundling_id") REFERENCES "items"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "queue_tickets" ADD CONSTRAINT "FK_0e9823b8b7ca9523b3be73878e5" FOREIGN KEY ("order_id") REFERENCES "queue_orders"("id") ON DELETE SET NULL ON UPDATE CASCADE`,
+    );
+  }
+}

src/database/migrations/1752146975330-data-scheduling-log.ts

@@ -0,0 +1,33 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class DataSchedulingLog1752146975330 implements MigrationInterface {
+  name = 'DataSchedulingLog1752146975330';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TYPE "public"."event_scheduling_log_status_enum" AS ENUM('active', 'cancel', 'confirmed', 'draft', 'expired', 'inactive', 'partial refund', 'pending', 'proses refund', 'refunded', 'rejected', 'settled', 'waiting')`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."event_scheduling_log_type_enum" AS ENUM('Default Percentage', 'Data Scheduling')`,
+    );
+    await queryRunner.query(
+      `CREATE TYPE "public"."event_scheduling_log_action_enum" AS ENUM('CREATE', 'UPDATE', 'DELETE', 'CHANGE_STATUS')`,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "event_scheduling_log" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "creator_id" character varying(36), "creator_name" character varying(125), "editor_id" character varying(36), "editor_name" character varying(125), "created_at" bigint NOT NULL, "updated_at" bigint NOT NULL, "status" "public"."event_scheduling_log_status_enum" NOT NULL DEFAULT 'draft', "type" "public"."event_scheduling_log_type_enum" NOT NULL, "action" "public"."event_scheduling_log_action_enum" NOT NULL, "log_created_at" bigint NOT NULL, "data_id" character varying, "name" character varying, "indexing_key" character varying, "schedule_date_from" date, "schedule_date_to" date, "default_value" integer, "description" text, CONSTRAINT "PK_984247db566636baacab18f593a" PRIMARY KEY ("id"))`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "event_scheduling_log"`);
+    await queryRunner.query(
+      `DROP TYPE "public"."event_scheduling_log_action_enum"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."event_scheduling_log_type_enum"`,
+    );
+    await queryRunner.query(
+      `DROP TYPE "public"."event_scheduling_log_status_enum"`,
+    );
+  }
+}

src/modules/booking-online/authentication/auth.module.ts

@@ -0,0 +1,25 @@
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+
+import { ConfigModule } from '@nestjs/config';
+import { Module } from '@nestjs/common';
+import { VerificationModel } from './data/models/verification.model';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { BookingAuthenticationController } from './infrastructure/controllers/booking-authentication.controller';
+import { VerificationService } from './data/services/verification.service';
+import { JwtModule } from '@nestjs/jwt';
+import { JWT_EXPIRED } from 'src/core/sessions/constants';
+import { JWT_SECRET } from 'src/core/sessions/constants';
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    TypeOrmModule.forFeature([VerificationModel], CONNECTION_NAME.DEFAULT),
+
+    JwtModule.register({
+      secret: JWT_SECRET,
+      signOptions: { expiresIn: JWT_EXPIRED },
+    }),
+  ],
+  controllers: [BookingAuthenticationController],
+  providers: [VerificationService],
+})
+export class BookingOnlineAuthModule {}

src/modules/booking-online/authentication/data/models/verification.model.ts

@@ -0,0 +1,29 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { BookingVerification } from '../../domain/entities/booking-verification.entity';
+@Entity('booking_verification')
+export class VerificationModel implements BookingVerification {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column()
+  phone_number: string;
+
+  @Column({ nullable: true })
+  code?: string;
+
+  @Column({ default: 0 })
+  tried: number;
+
+  @Column({ type: 'bigint', default: () => 'EXTRACT(EPOCH FROM NOW()) * 1000' })
+  created_at: number;
+
+  @Column({
+    type: 'bigint',
+    default: () => 'EXTRACT(EPOCH FROM NOW()) * 1000',
+    onUpdate: 'EXTRACT(EPOCH FROM NOW()) * 1000',
+  })
+  updated_at: number;
+}

src/modules/booking-online/authentication/data/services/verification.service.ts

@@ -0,0 +1,110 @@
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { VerificationModel } from '../models/verification.model';
+import { BookingVerification } from '../../domain/entities/booking-verification.entity';
+import { UnprocessableEntityException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+export class VerificationService {
+  constructor(
+    @InjectRepository(VerificationModel)
+    private readonly verificationRepository: Repository<VerificationModel>,
+    private readonly jwtService: JwtService,
+  ) {}
+
+  maxAttempts = 3;
+  expiredTime = 5 * 60 * 1000;
+  expiredTimeRegister = 1 * 60 * 1000;
+
+  async generateToken(payload: BookingVerification) {
+    return this.jwtService.sign({
+      phone_number: payload.phone_number,
+      name: payload.name,
+      created_at: payload.created_at,
+    });
+  }
+
+  async register(data: BookingVerification) {
+    const isProduction = process.env.NODE_ENV === 'true';
+    const currentTime = Math.floor(Date.now()); // current time in seconds
+
+    // Generate a 4 digit OTP code
+    const otpCode = Math.floor(1000 + Math.random() * 9000).toString();
+
+    let verification = await this.verificationRepository.findOne({
+      where: { phone_number: data.phone_number },
+    });
+
+    if (
+      isProduction &&
+      verification.updated_at &&
+      currentTime - verification.updated_at < this.expiredTimeRegister
+    ) {
+      throw new UnprocessableEntityException('Please try again in 1 minute');
+    }
+
+    data.code = otpCode;
+    data.tried = 0;
+    data.updated_at = currentTime;
+
+    if (verification) {
+      // Update existing record
+      verification = this.verificationRepository.merge(verification, data);
+    } else {
+      // Create new record
+      verification = this.verificationRepository.create(data);
+    }
+    const payload = await this.verificationRepository.save(verification);
+
+    const notificationService = new WhatsappService();
+    notificationService.sendOtpNotification({
+      phone: data.phone_number,
+      code: otpCode,
+    });
+
+    return payload;
+  }
+
+  async findByPhoneNumber(phoneNumber: string) {
+    return this.verificationRepository.findOne({
+      where: { phone_number: phoneNumber },
+    });
+  }
+
+  async verify(data: BookingVerification): Promise<BookingVerification> {
+    const verification = await this.findByPhoneNumber(data.phone_number);
+    if (!verification) {
+      throw new UnprocessableEntityException('Phone number not found');
+    }
+
+    if (verification.tried >= this.maxAttempts) {
+      throw new UnprocessableEntityException(
+        'Too many attempts, please resend OTP Code',
+      );
+    }
+
+    if (verification.code != data.code) {
+      verification.tried++;
+      await this.verificationRepository.save(verification);
+      throw new UnprocessableEntityException('Invalid verification code');
+    }
+
+    const currentTime = Math.floor(Date.now());
+    if (
+      verification.updated_at &&
+      currentTime - verification.updated_at > this.expiredTime
+    ) {
+      throw new UnprocessableEntityException('Verification code expired');
+    }
+
+    return verification;
+  }
+
+  async update(id: string, data: BookingVerification) {
+    return this.verificationRepository.update(id, data);
+  }
+
+  async delete(id: string) {
+    return this.verificationRepository.delete(id);
+  }
+}

src/modules/booking-online/authentication/domain/entities/booking-verification.entity.ts

@@ -0,0 +1,9 @@
+export interface BookingVerification {
+  id: string;
+  name: string;
+  phone_number: string;
+  code?: string;
+  tried?: number;
+  created_at?: number;
+  updated_at?: number;
+}

src/modules/booking-online/authentication/infrastructure/controllers/booking-authentication.controller.ts

@@ -0,0 +1,43 @@
+import { Controller, Post, Body, Get, Param } from '@nestjs/common';
+
+import {
+  BookingVerificationDto,
+  VerificationCodeDto,
+} from '../dto/booking-verification.dto';
+import { VerificationService } from '../../data/services/verification.service';
+import { Public } from 'src/core/guards/domain/decorators/unprotected.guard';
+import { ApiTags } from '@nestjs/swagger';
+
+@ApiTags('Booking Authentication')
+@Public()
+@Controller('v1/booking-authentication')
+export class BookingAuthenticationController {
+  constructor(
+    private readonly bookingAuthenticationService: VerificationService,
+  ) {}
+
+  @Post('verify')
+  async verify(@Body() body: VerificationCodeDto) {
+    const verification = await this.bookingAuthenticationService.verify(body);
+    const token = await this.bookingAuthenticationService.generateToken(
+      verification,
+    );
+    return {
+      message: `Verification successful for ${verification.phone_number}`,
+      token,
+    };
+  }
+
+  @Post('register')
+  async register(@Body() body: BookingVerificationDto) {
+    const verification = await this.bookingAuthenticationService.register(body);
+    return {
+      message: `Verification code sent to ${verification.phone_number}`,
+    };
+  }
+
+  @Get('get-by-phone/:phone_number')
+  async getByPhoneNumber(@Param('phone_number') phone_number: string) {
+    return this.bookingAuthenticationService.findByPhoneNumber(phone_number);
+  }
+}

src/modules/booking-online/authentication/infrastructure/dto/booking-verification.dto.ts

@@ -0,0 +1,67 @@
+import { BookingVerification } from '../../domain/entities/booking-verification.entity';
+import { IsString, IsNotEmpty, Matches } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class BookingVerificationDto implements BookingVerification {
+  id: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: 'John Doe',
+    description: 'Name of the person booking',
+  })
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '628123456789',
+    description: 'Phone number containing only numeric characters',
+  })
+  @IsString()
+  @IsNotEmpty()
+  @Matches(/^\d+$/, {
+    message: 'phone_number must contain only numeric characters',
+  })
+  phone_number: string;
+}
+
+export class VerificationCodeDto implements BookingVerification {
+  id: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: 'John Doe',
+    description: 'Name of the person booking',
+  })
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '628123456789',
+    description: 'Phone number containing only numeric characters',
+  })
+  @IsString()
+  @IsNotEmpty()
+  @Matches(/^\d+$/, {
+    message: 'phone_number must contain only numeric characters',
+  })
+  phone_number: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '1234',
+    description: 'Verification code',
+  })
+  @IsString()
+  @IsNotEmpty()
+  code?: string;
+}

src/modules/booking-online/helpers/generate-otp.ts

@@ -0,0 +1,9 @@
+export function generateOtp(digits = 4): number {
+  if (digits < 1) {
+    throw new Error('OTP digits must be at least 1');
+  }
+  const min = Math.pow(10, digits - 1);
+  const max = Math.pow(10, digits) - 1;
+  const otp = Math.floor(Math.random() * (max - min + 1)) + min;
+  return otp;
+}

src/modules/booking-online/order/data/models/reschedule-verification.model.ts

@@ -0,0 +1,36 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { RescheduleVerification } from '../../domain/entities/reschedule-verification.entity';
+
+@Entity('reschedule_verification')
+export class RescheduleVerificationModel implements RescheduleVerification {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column()
+  phone_number: string;
+
+  @Column()
+  booking_id: string;
+
+  @Column()
+  reschedule_date: string;
+
+  @Column()
+  code: number;
+
+  @Column({ default: 0 })
+  tried: number;
+
+  @Column({ type: 'bigint', default: () => 'EXTRACT(EPOCH FROM NOW()) * 1000' })
+  created_at: number;
+
+  @Column({
+    type: 'bigint',
+    default: () => 'EXTRACT(EPOCH FROM NOW()) * 1000',
+    onUpdate: 'EXTRACT(EPOCH FROM NOW()) * 1000',
+  })
+  updated_at: number;
+}

src/modules/booking-online/order/domain/entities/reschedule-verification.entity.ts

@@ -0,0 +1,16 @@
+export interface RescheduleVerification {
+  id: string;
+  name: string;
+  phone_number: string;
+  booking_id: string;
+  reschedule_date: string;
+  code: number;
+  tried?: number;
+  created_at?: number;
+  updated_at?: number;
+}
+
+export interface RescheduleRequest {
+  booking_id: string;
+  reschedule_date: string;
+}

src/modules/booking-online/order/domain/usecases/managers/booking-item.manager.ts

@@ -0,0 +1,67 @@
+import { Injectable } from '@nestjs/common';
+import { RelationParam } from 'src/core/modules/domain/entities/base-filter.entity';
+import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
+import { ItemEntity } from 'src/modules/item-related/item/domain/entities/item.entity';
+import { IndexItemManager } from 'src/modules/item-related/item/domain/usecases/managers/index-item.manager';
+import { SelectQueryBuilder } from 'typeorm';
+
+@Injectable()
+export class BookingItemManager extends IndexItemManager {
+  get relations(): RelationParam {
+    return {
+      // relation only join (for query purpose)
+      joinRelations: [],
+
+      // relation join and select (relasi yang ingin ditampilkan),
+      selectRelations: [
+        'item_category',
+        'bundling_items',
+        'tenant',
+        'time_group',
+        'item_rates',
+      ],
+
+      // relation yang hanya ingin dihitung (akan return number)
+      countRelations: [],
+    };
+  }
+
+  get selects(): string[] {
+    const parent = super.selects;
+    return [
+      ...parent,
+      `${this.tableName}.image_url`,
+      'item_rates.id',
+      'item_rates.price',
+      'item_rates.season_period_id',
+    ];
+  }
+
+  getResult(): PaginationResponse<ItemEntity> {
+    const result = super.getResult();
+    const { data, total } = result;
+    const hasRates = (this.filterParam.season_period_ids?.length ?? 0) > 0;
+    const items = data.map((item) => {
+      const currentRate = item.item_rates.find((rate) =>
+        this.filterParam.season_period_ids?.includes(rate.season_period_id),
+      );
+      const { item_rates, ...rest } = item;
+      const rate = currentRate?.['price'] ?? rest.base_price;
+      return {
+        ...rest,
+        base_price: hasRates ? rate : rest.base_price,
+      };
+    });
+    return { total, data: items };
+  }
+
+  setQueryFilter(
+    queryBuilder: SelectQueryBuilder<ItemEntity>,
+  ): SelectQueryBuilder<ItemEntity> {
+    const query = super.setQueryFilter(queryBuilder);
+
+    query.andWhere(`${this.tableName}.status = 'active'`);
+
+    return query;
+  }
+}

src/modules/booking-online/order/domain/usecases/managers/create-booking.manager.ts

@@ -0,0 +1,64 @@
+import { HttpStatus } from '@nestjs/common';
+import { UnprocessableEntityException } from '@nestjs/common';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import { TransactionType } from 'src/modules/transaction/transaction/constants';
+import { CreateTransactionManager } from 'src/modules/transaction/transaction/domain/usecases/managers/create-transaction.manager';
+import { generateInvoiceCodeHelper } from 'src/modules/transaction/transaction/domain/usecases/managers/helpers/generate-invoice-code.helper';
+import { mappingRevertTransaction } from 'src/modules/transaction/transaction/domain/usecases/managers/helpers/mapping-transaction.helper';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+import { v4 as uuidv4 } from 'uuid';
+
+export class CreateBookingManager extends CreateTransactionManager {
+  async beforeProcess(): Promise<void> {
+    mappingRevertTransaction(this.data, TransactionType.ONLINE);
+
+    const id = uuidv4();
+    const invoiceCode = await generateInvoiceCodeHelper(
+      this.dataService,
+      'BOOK',
+    );
+
+    try {
+      const { token, redirect_url } = await this.dataServiceFirstOpt.create({
+        ...this.data,
+        id,
+      });
+      Object.assign(this.data, {
+        payment_midtrans_token: token,
+        payment_midtrans_url: redirect_url,
+      });
+    } catch (error) {
+      console.log({ error });
+      throw new UnprocessableEntityException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        message: `Gagal! transaksi telah terbuat, silahkan periksa email untuk melanjutkan pembayaran`,
+        error: 'Unprocessable Entity',
+      });
+    }
+
+    Object.assign(this.data, {
+      id,
+      invoice_code: invoiceCode,
+      status: STATUS.PENDING,
+      invoice_date: new Date(),
+    });
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    const whatsapp = new WhatsappService();
+    console.log(`/snap/v4/redirection/${this.data.payment_midtrans_token}`);
+    console.log(this.data.payment_midtrans_url);
+    await whatsapp.bookingRegister(
+      {
+        phone: this.data.customer_phone,
+        code: this.data.invoice_code,
+        name: this.data.customer_name,
+        time: this.data.booking_date,
+        id: this.data.id,
+      },
+      this.data.payment_total,
+      `snap/v4/redirection/${this.data.payment_midtrans_token}`,
+    );
+  }
+}

src/modules/booking-online/order/domain/usecases/managers/reschedule-verification.manager.ts

@@ -0,0 +1,115 @@
+import { Injectable, UnprocessableEntityException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { RescheduleVerificationModel } from '../../../data/models/reschedule-verification.model';
+import {
+  RescheduleRequest,
+  RescheduleVerification,
+} from '../../entities/reschedule-verification.entity';
+import { generateOtp } from 'src/modules/booking-online/helpers/generate-otp';
+import { TransactionReadService } from 'src/modules/transaction/transaction/data/services/transaction-read.service';
+import { TransactionEntity } from 'src/modules/transaction/transaction/domain/entities/transaction.entity';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+
+@Injectable()
+export class RescheduleVerificationManager {
+  constructor(
+    @InjectRepository(RescheduleVerificationModel)
+    private readonly rescheduleVerificationRepository: Repository<RescheduleVerificationModel>,
+    private readonly transactionService: TransactionReadService,
+  ) {}
+
+  async saveVerification(
+    request: RescheduleRequest,
+  ): Promise<RescheduleVerificationModel> {
+    try {
+      const otp = generateOtp();
+      const transaction = await this.findDetailByBookingId(request.booking_id);
+
+      if (!transaction) {
+        throw new Error('Transaction not found for the provided booking id');
+      }
+
+      const data: Partial<RescheduleVerification> = {
+        code: otp,
+        booking_id: transaction.id,
+        name: transaction.customer_name,
+        phone_number: transaction.customer_phone,
+        reschedule_date: request.reschedule_date,
+      };
+
+      const existTransaction =
+        await this.rescheduleVerificationRepository.findOne({
+          where: {
+            booking_id: transaction.id,
+          },
+        });
+
+      const verification =
+        existTransaction ?? this.rescheduleVerificationRepository.create(data);
+      const result = await this.rescheduleVerificationRepository.save({
+        ...verification,
+        code: otp,
+      });
+
+      const whatsapp = new WhatsappService();
+      whatsapp.sendOtpNotification({
+        phone: transaction.customer_phone,
+        code: otp.toString(),
+      });
+      //   whatsapp.bookingRescheduleOTP({
+      //     phone: transaction.customer_phone,
+      //     code: otp.toString(),
+      //     name: transaction.customer_name,
+      //     time: new Date(request.reschedule_date).getTime(),
+      //     id: transaction.id,
+      //   });
+      return result;
+    } catch (error) {
+      // You can customize the error handling as needed, e.g., throw HttpException for NestJS
+      throw new UnprocessableEntityException(
+        `Failed to save reschedule verification: ${error.message}`,
+      );
+    }
+  }
+
+  async verifyOtp(
+    booking_id: string,
+    code: number,
+  ): Promise<RescheduleVerificationModel> {
+    const verification = await this.rescheduleVerificationRepository.findOne({
+      where: { booking_id, code },
+      order: { created_at: 'DESC' },
+    });
+
+    if (!verification) {
+      throw new UnprocessableEntityException({
+        success: false,
+        message: 'Verification code not match',
+      });
+    }
+
+    // Optionally, you can implement OTP expiration logic here
+
+    if (verification.code !== code) {
+      // Increment tried count
+      verification.tried = (verification.tried || 0) + 1;
+      await this.rescheduleVerificationRepository.save(verification);
+      throw new UnprocessableEntityException({
+        success: false,
+        message: 'Invalid verification code.',
+      });
+    }
+
+    // Optionally, you can mark the verification as used or verified here
+
+    return verification;
+  }
+
+  async findDetailByBookingId(bookingId: string): Promise<TransactionEntity> {
+    const transaction = await this.transactionService.getOneByOptions({
+      where: { id: bookingId },
+    });
+    return transaction;
+  }
+}

src/modules/booking-online/order/domain/usecases/managers/reschedule.manager.ts

@@ -0,0 +1,90 @@
+import { Injectable, UnprocessableEntityException } from '@nestjs/common';
+import { TransactionModel } from 'src/modules/transaction/transaction/data/models/transaction.model';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import { v4 as uuidv4 } from 'uuid';
+import { TransactionDataService } from 'src/modules/transaction/transaction/data/services/transaction-data.service';
+import { generateInvoiceCodeHelper } from 'src/modules/transaction/transaction/domain/usecases/managers/helpers/generate-invoice-code.helper';
+import * as moment from 'moment';
+import { TransactionItemModel } from 'src/modules/transaction/transaction/data/models/transaction-item.model';
+import { RescheduleVerificationModel } from '../../../data/models/reschedule-verification.model';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+
+@Injectable()
+export class RescheduleManager {
+  constructor(private serviceData: TransactionDataService) {}
+
+  async reschedule(data: RescheduleVerificationModel) {
+    const transaction = await this.serviceData.getTransactionWithReschedule(
+      data.booking_id,
+    );
+
+    const rescheduleDate = moment(data.reschedule_date, 'DD-MM-YYYY');
+
+    const id = uuidv4();
+    const invoiceCode = await generateInvoiceCodeHelper(
+      this.serviceData,
+      'BOOK',
+    );
+
+    const items = this.makeItemZeroPrice(transaction.items);
+    const transactionData = this.makeTransactionZeroPrice(transaction);
+
+    Object.assign(transactionData, {
+      parent_id: transaction.id,
+      id,
+      invoice_code: invoiceCode,
+      status: STATUS.SETTLED,
+      invoice_date: rescheduleDate.format('YYYY-MM-DD'),
+      booking_date: rescheduleDate.format('YYYY-MM-DD'),
+      created_at: moment().unix() * 1000,
+      updated_at: moment().unix() * 1000,
+      items,
+    });
+
+    await this.serviceData.getRepository().save(transactionData);
+
+    const whatsapp = new WhatsappService();
+    whatsapp.rescheduleCreated({
+      id: transactionData.id,
+      name: transactionData.customer_name,
+      phone: transactionData.customer_phone,
+      time: moment(transactionData.invoice_date).unix() * 1000,
+      code: transactionData.invoice_code,
+    });
+
+    return transactionData;
+  }
+
+  private makeItemZeroPrice(items: TransactionItemModel[]) {
+    return items.map((item) => {
+      return {
+        ...item,
+        id: uuidv4(),
+        item_price: 0,
+        total_price: 0,
+        total_hpp: 0,
+        total_profit: 0,
+        total_profit_share: 0,
+        payment_total_dpp: 0,
+        payment_total_tax: 0,
+        total_net_price: 0,
+      };
+    });
+  }
+
+  private makeTransactionZeroPrice(transaction: TransactionModel) {
+    return {
+      ...transaction,
+      payment_sub_total: 0,
+      payment_discount_total: 0,
+      payment_total: 0,
+      payment_total_pay: 0,
+      payment_total_share: 0,
+      payment_total_tax: 0,
+      payment_total_profit: 0,
+      payment_total_net_profit: 0,
+      payment_total_dpp: 0,
+      discount_percentage: 0,
+    };
+  }
+}

src/modules/booking-online/order/infrastructure/dto/booking-order.dto.ts

@@ -0,0 +1,121 @@
+import { BaseStatusDto } from 'src/core/modules/infrastructure/dto/base-status.dto';
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  IsArray,
+  IsNumber,
+  IsObject,
+  IsString,
+  ValidateIf,
+} from 'class-validator';
+import { SeasonPeriodEntity } from 'src/modules/season-related/season-period/domain/entities/season-period.entity';
+import { TransactionItemEntity } from 'src/modules/transaction/transaction/domain/entities/transaction-item.entity';
+import {
+  TransactionPaymentType,
+  TransactionUserType,
+} from 'src/modules/transaction/transaction/constants';
+
+export class TransactionDto extends BaseStatusDto {
+  @ApiProperty({
+    type: Object,
+    required: false,
+    example: {
+      id: 'uuid',
+      season_type: {
+        id: 'uuid',
+        name: 'high season',
+      },
+    },
+  })
+  @IsObject()
+  @ValidateIf((body) => body.season_period)
+  season_period: SeasonPeriodEntity;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: TransactionUserType.GROUP,
+  })
+  @IsString()
+  customer_type: TransactionUserType;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: 'Andika',
+  })
+  @IsString()
+  customer_name: string;
+
+  @ApiProperty({
+    type: String,
+    required: false,
+    example: '0823...',
+  })
+  @ValidateIf((body) => body.customer_phone)
+  customer_phone: string;
+
+  @ApiProperty({
+    type: Date,
+    required: true,
+    example: '2024-01-01',
+  })
+  booking_date: Date;
+
+  @ApiProperty({
+    type: String,
+    required: false,
+    example: TransactionPaymentType.MIDTRANS,
+  })
+  payment_type: TransactionPaymentType;
+
+  @ApiProperty({
+    type: Number,
+    required: true,
+    example: 7000000,
+  })
+  @IsNumber()
+  payment_sub_total: number;
+
+  @ApiProperty({
+    type: Number,
+    required: true,
+    example: 3500000,
+  })
+  @IsNumber()
+  payment_total: number;
+
+  @ApiProperty({
+    type: [Object],
+    required: true,
+    example: [
+      {
+        item: {
+          id: '68aa12f7-2cce-422b-9bae-185eb1343b94',
+          created_at: '1718876384378',
+          status: 'active',
+          name: 'tes',
+          item_type: 'bundling',
+          hpp: '100000',
+          base_price: '100000',
+          limit_type: 'no limit',
+          limit_value: 0,
+          item_category: {
+            id: 'ab15981a-a656-4efc-856c-b2abfbe30979',
+            name: 'Kategori Bundling 2',
+          },
+          bundling_items: [
+            {
+              id: 'bd5a7a38-df25-4203-a1cd-bf94867946b2',
+              name: 'Wahana 21 panjangggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg',
+            },
+          ],
+          tenant: null,
+        },
+        qty: 40,
+        total_price: 4000000,
+      },
+    ],
+  })
+  @IsArray()
+  items: TransactionItemEntity[];
+}

src/modules/booking-online/order/infrastructure/dto/reschedule.dto.ts

@@ -0,0 +1,47 @@
+import { IsString, Matches } from 'class-validator';
+import { RescheduleRequest } from 'src/modules/booking-online/order/domain/entities/reschedule-verification.entity';
+
+import { ApiProperty } from '@nestjs/swagger';
+
+export class RescheduleRequestDTO implements RescheduleRequest {
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '123e4567-e89b-12d3-a456-426614174000',
+    description: 'The unique identifier of the booking',
+  })
+  @IsString()
+  booking_id: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '25-12-2024',
+    description: 'The new date for rescheduling in the format DD-MM-YYYY',
+  })
+  @IsString()
+  @Matches(/^(0[1-9]|[12][0-9]|3[01])-(0[1-9]|1[0-2])-\d{4}$/, {
+    message: 'reschedule_date must be in the format DD-MM-YYYY',
+  })
+  reschedule_date: string;
+}
+
+export class RescheduleVerificationOTP {
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '123e4567-e89b-12d3-a456-426614174000',
+    description: 'The unique identifier of the booking',
+  })
+  @IsString()
+  booking_id: string;
+
+  @ApiProperty({
+    type: String,
+    required: true,
+    example: '123456',
+    description: 'The OTP code sent for verification',
+  })
+  @IsString()
+  code: string;
+}

src/modules/booking-online/order/infrastructure/item.controller.ts

@@ -0,0 +1,32 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { Public } from 'src/core/guards';
+import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { ItemReadService } from 'src/modules/item-related/item/data/services/item-read.service';
+import { ItemEntity } from 'src/modules/item-related/item/domain/entities/item.entity';
+import { FilterItemDto } from 'src/modules/item-related/item/infrastructure/dto/filter-item.dto';
+import { BookingItemManager } from '../domain/usecases/managers/booking-item.manager';
+
+@ApiTags('Booking Item')
+@Controller('v1/booking-item')
+@Public(true)
+export class ItemController {
+  constructor(
+    private indexManager: BookingItemManager,
+    private serviceData: ItemReadService,
+  ) {}
+
+  @Get()
+  async index(
+    @Query() params: FilterItemDto,
+  ): Promise<PaginationResponse<ItemEntity>> {
+    params.limit = 1000;
+    params.show_to_booking = true;
+    params.all_item = true;
+    this.indexManager.setFilterParam(params);
+    this.indexManager.setService(this.serviceData, TABLE_NAME.ITEM);
+    await this.indexManager.execute();
+    return this.indexManager.getResult();
+  }
+}

src/modules/booking-online/order/infrastructure/order.controller.ts

@@ -0,0 +1,274 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Post,
+  Res,
+  UnprocessableEntityException,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { Public } from 'src/core/guards';
+import { TransactionDto } from './dto/booking-order.dto';
+import { TransactionEntity } from 'src/modules/transaction/transaction/domain/entities/transaction.entity';
+import { TransactionDataService } from 'src/modules/transaction/transaction/data/services/transaction-data.service';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { MidtransService } from 'src/modules/configuration/midtrans/data/services/midtrans.service';
+import { CreateBookingManager } from '../domain/usecases/managers/create-booking.manager';
+import * as QRCode from 'qrcode';
+import { Gate } from 'src/core/response/domain/decorators/pagination.response';
+import { Response } from 'express';
+import {
+  RescheduleRequestDTO,
+  RescheduleVerificationOTP,
+} from './dto/reschedule.dto';
+import { RescheduleVerificationManager } from '../domain/usecases/managers/reschedule-verification.manager';
+import { RescheduleManager } from '../domain/usecases/managers/reschedule.manager';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import * as moment from 'moment';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+
+@ApiTags('Booking Order')
+@Controller('v1/booking')
+@Public(true)
+export class BookingOrderController {
+  constructor(
+    private createBooking: CreateBookingManager,
+    private serviceData: TransactionDataService,
+    private midtransService: MidtransService,
+    private rescheduleVerification: RescheduleVerificationManager,
+    private rescheduleManager: RescheduleManager,
+  ) {}
+
+  @Post()
+  async create(@Body() data: TransactionDto) {
+    const payload: Partial<TransactionEntity> = data;
+
+    this.createBooking.setData(payload as any);
+    this.createBooking.setService(
+      this.serviceData,
+      TABLE_NAME.TRANSACTION,
+      this.midtransService,
+    );
+    await this.createBooking.execute();
+    const result = await this.createBooking.getResult();
+    const {
+      invoice_code,
+      status,
+      payment_midtrans_token,
+      payment_midtrans_url,
+      id,
+    } = result;
+
+    return {
+      id,
+      invoice_code,
+      status,
+      payment_midtrans_token,
+      payment_midtrans_url,
+    };
+  }
+
+  @Post('reschedule')
+  async reschedule(@Body() data: RescheduleRequestDTO) {
+    const transaction = await this.serviceData.getTransactionWithReschedule(
+      data.booking_id,
+    );
+
+    const today = moment().startOf('day');
+    const rescheduleDate = moment(data.reschedule_date, 'DD-MM-YYYY');
+    const rescheduleDateStartOfDay = rescheduleDate.startOf('day');
+
+    //TODO: validate session period priority
+
+    if (rescheduleDateStartOfDay.isSameOrBefore(today)) {
+      throw new UnprocessableEntityException(
+        'Reschedule date must be in the future',
+      );
+    }
+
+    if (!transaction) {
+      throw new UnprocessableEntityException('Transaction not found');
+    }
+
+    if (transaction.status !== STATUS.SETTLED) {
+      throw new UnprocessableEntityException('Transaction is not settled');
+    }
+
+    if (transaction.children_transactions.length > 0) {
+      throw new UnprocessableEntityException('Transaction already rescheduled');
+    }
+
+    if (transaction.parent_id) {
+      throw new UnprocessableEntityException('Transaction is a reschedule');
+    }
+
+    const result = await this.rescheduleVerification.saveVerification(data);
+    const maskedPhoneNumber = result.phone_number.replace(/.(?=.{4})/g, '*');
+    result.phone_number = maskedPhoneNumber;
+
+    return `Verification code sent to ${maskedPhoneNumber}`;
+  }
+
+  @Post('reschedule/verification')
+  async verificationReschedule(@Body() data: RescheduleVerificationOTP) {
+    const result = await this.rescheduleVerification.verifyOtp(
+      data.booking_id,
+      +data.code,
+    );
+
+    const reschedule = await this.rescheduleManager.reschedule(result);
+    const transaction = await this.get(reschedule.id);
+
+    return {
+      id: reschedule.id,
+      phone_number: result.phone_number,
+      name: result.name,
+      reschedule_date: result.reschedule_date,
+      transaction,
+    };
+  }
+
+  @Get(':id')
+  async get(@Param('id') transactionId: string) {
+    const data = await this.serviceData.getOneByOptions({
+      relations: [
+        'items',
+        'parent_transaction',
+        'items.item',
+        'items.item.time_group',
+      ],
+      where: { id: transactionId },
+    });
+
+    const {
+      parent_id,
+      customer_name,
+      customer_phone,
+      booking_date,
+      invoice_code,
+      status,
+      id,
+      items,
+      parent_transaction,
+    } = data;
+
+    let timeGroup = null;
+
+    const usageItems = items.map((item) => {
+      const itemData = item.item;
+      if (itemData.time_group) {
+        const timeGroupData = itemData.time_group;
+        const {
+          id: groupId,
+          name,
+          start_time,
+          end_time,
+          max_usage_time,
+        } = timeGroupData;
+        timeGroup = {
+          id: groupId,
+          name,
+          start_time,
+          end_time,
+          max_usage_time,
+        };
+      }
+      const {
+        id,
+        item_id,
+        item_name,
+        item_price,
+        item_category_name,
+        total_price,
+        total_net_price,
+        qty,
+        qty_remaining,
+      } = item;
+      return {
+        id,
+        item_id,
+        item_name,
+        item_price,
+        item_category_name,
+        total_price,
+        total_net_price,
+        qty,
+        qty_remaining,
+      };
+    });
+
+    // Mask customer_phone with * and keep last 4 numbers
+    let maskedCustomerPhone = customer_phone;
+    if (typeof customer_phone === 'string' && customer_phone.length > 4) {
+      const last4 = customer_phone.slice(-4);
+      maskedCustomerPhone = '*'.repeat(customer_phone.length - 4) + last4;
+    }
+
+    let parentTransaction = undefined;
+    if (parent_transaction) {
+      const {
+        id: parentId,
+        invoice_code: parentInvoiceCode,
+        invoice_date: parentInvoiceDate,
+      } = parent_transaction;
+      parentTransaction = {
+        id: parentId,
+        invoice_code: parentInvoiceCode,
+        invoice_date: parentInvoiceDate,
+      };
+    }
+
+    return {
+      customer_name,
+      customer_phone: maskedCustomerPhone,
+      booking_date,
+      invoice_code,
+      status,
+      id,
+      is_reschedule: !!parent_id,
+      items: usageItems,
+      time_group: timeGroup,
+      parent: parentTransaction,
+    };
+  }
+
+  @Gate()
+  @Get('qrcode/:id')
+  async getQRcode(@Param('id') id: string, @Res() res: Response) {
+    console.log(QRCode);
+    const qrData = id;
+    const data = await QRCode.toDataURL(qrData);
+    res.setHeader('Content-Type', 'image/png');
+    const base64Data = data.split(',')[1];
+    const buffer = Buffer.from(base64Data, 'base64');
+    res.send(buffer);
+  }
+
+  @Post('resend-notification/:id')
+  async resendNotification(@Param('id') id: string) {
+    try {
+      const transaction = await this.serviceData.getOneByOptions({
+        where: { id },
+      });
+
+      const whatsappService = new WhatsappService();
+      const formattedDate = moment(transaction.booking_date);
+      const payload = {
+        id: transaction.id,
+        phone: transaction.customer_phone,
+        code: transaction.invoice_code,
+        name: transaction.customer_name,
+        time: formattedDate.valueOf(),
+      };
+      await whatsappService.bookingCreated(payload);
+      return {
+        message: 'Notification sent successfully',
+      };
+    } catch (error) {
+      throw new UnprocessableEntityException({
+        message: 'Failed to send notification',
+      });
+    }
+  }
+}

src/modules/booking-online/order/order.module.ts

@@ -0,0 +1,38 @@
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+
+import { ConfigModule } from '@nestjs/config';
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ItemModel } from 'src/modules/item-related/item/data/models/item.model';
+import { ItemModule } from 'src/modules/item-related/item/item.module';
+import { ItemController } from './infrastructure/item.controller';
+import { TransactionModule } from 'src/modules/transaction/transaction/transaction.module';
+import { BookingOrderController } from './infrastructure/order.controller';
+import { CreateBookingManager } from './domain/usecases/managers/create-booking.manager';
+import { MidtransModule } from 'src/modules/configuration/midtrans/midtrans.module';
+import { CqrsModule } from '@nestjs/cqrs';
+import { RescheduleVerificationModel } from './data/models/reschedule-verification.model';
+import { RescheduleVerificationManager } from './domain/usecases/managers/reschedule-verification.manager';
+import { RescheduleManager } from './domain/usecases/managers/reschedule.manager';
+import { BookingItemManager } from './domain/usecases/managers/booking-item.manager';
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    TypeOrmModule.forFeature(
+      [ItemModel, RescheduleVerificationModel],
+      CONNECTION_NAME.DEFAULT,
+    ),
+    ItemModule,
+    TransactionModule,
+    MidtransModule,
+    CqrsModule,
+  ],
+  controllers: [ItemController, BookingOrderController],
+  providers: [
+    CreateBookingManager,
+    RescheduleVerificationManager,
+    RescheduleManager,
+    BookingItemManager,
+  ],
+})
+export class BookingOrderModule {}

src/modules/configuration/auth/domain/managers/admin-queue/login-admin-queue.manager.ts

@@ -73,13 +73,14 @@ export class LoginAdminQueueManager extends BaseCustomManager<UserEntity> {
         message: `Akun anda sudah login di item "${hasLoginAsQueue?.item_name}"`,
         error: 'Unauthorized',
       });
-    } else if (itemLogin && itemLogin.user_id !== this.userLogin.id) {
-      throw new UnauthorizedException({
-        statusCode: HttpStatus.UNAUTHORIZED,
-        message: `"${userLoginItem.name}" masih login sebagai admin antrian `,
-        error: 'Unauthorized',
-      });
     }
+    // else if (itemLogin && itemLogin.user_id !== this.userLogin.id) {
+    //   throw new UnauthorizedException({
+    //     statusCode: HttpStatus.UNAUTHORIZED,
+    //     message: `"${userLoginItem.name}" masih login sebagai admin antrian `,
+    //     error: 'Unauthorized',
+    //   });
+    // }
 
     // * Disini untuk isi token
     const tokenData = {

src/modules/configuration/couch/constants.ts

@@ -3,4 +3,6 @@ export const DatabaseListen = [
   'vip_code',
   'pos_activity',
   'pos_cash_activity',
+  'time_groups',
+  'api_configuration',
 ];

src/modules/configuration/couch/couch.module.ts

@@ -52,6 +52,14 @@ import { SeasonPeriodDataService } from 'src/modules/season-related/season-perio
 import { SeasonPeriodModel } from 'src/modules/season-related/season-period/data/models/season-period.model';
 import { TransactionDemographyModel } from 'src/modules/transaction/transaction/data/models/transaction-demography.model';
 import { UserLoginModel } from 'src/modules/user-related/user/data/models/user-login.model';
+import {
+  TimeGroupDeletedHandler,
+  TimeGroupUpdatedHandler,
+} from './domain/managers/time-group.handle';
+
+import { DataSchedulingUpdatedHandler } from './domain/managers/data-scheduling.handler';
+import { DataSchedulingDefaultModel } from '../data-scheduling/data/models/data-scheduling-default.model';
+import { DataSchedulingModel } from '../data-scheduling/data/models/data-scheduling.model';
 
 @Module({
   imports: [
@@ -67,6 +75,9 @@ import { UserLoginModel } from 'src/modules/user-related/user/data/models/user-l
         TransactionTaxModel,
         TransactionItemModel,
         TransactionDemographyModel,
+
+        DataSchedulingDefaultModel,
+        DataSchedulingModel,
       ],
       CONNECTION_NAME.DEFAULT,
     ),
@@ -83,6 +94,10 @@ import { UserLoginModel } from 'src/modules/user-related/user/data/models/user-l
     VipCodeCreatedHandler,
     VipCategoryDeletedHandler,
     VipCategoryUpdatedHandler,
+
+    TimeGroupDeletedHandler,
+    TimeGroupUpdatedHandler,
+
     SeasonPeriodDeletedHandler,
     SeasonPeriodUpdatedHandler,
     ItemUpdatedHandler,
@@ -96,6 +111,8 @@ import { UserLoginModel } from 'src/modules/user-related/user/data/models/user-l
     SeasonTypeDeletedHandler,
     SeasonTypeUpdatedHandler,
 
+    DataSchedulingUpdatedHandler,
+
     SeasonPeriodDataService,
     TransactionDataService,
     UserDataService,

src/modules/configuration/couch/data/services/couch.service.ts

@@ -19,15 +19,18 @@ export class CouchService {
   }
 
   async onModuleInit() {
+    // return;
     const nano = this.nanoInstance;
     for (const database of DatabaseListen) {
       const db = nano.db.use(database);
-      db.changesReader.start({ includeDocs: true }).on('change', (change) => {
+      db.changesReader
+        .start({ includeDocs: true })
+        .on('change', async (change) => {
           Logger.verbose(
             `Receive Data from ${database}: ${change?.id}`,
             'CouchService',
           );
-        this.changeDoc(change, database);
+          await this.changeDoc(change, database);
         });
 
       // transaction
@@ -35,8 +38,8 @@ export class CouchService {
     }
   }
 
-  private changeDoc(data, database) {
-    this.eventBus.publish(
+  private async changeDoc(data, database) {
+    await this.eventBus.publish(
       new ChangeDocEvent({
         id: data.id,
         database: database,
@@ -95,4 +98,76 @@ export class CouchService {
       return null;
     }
   }
+
+  public async totalTodayTransactions(database = 'transaction') {
+    try {
+      const nano = this.nanoInstance;
+      const db = nano.use<any>(database);
+
+      // Get today's start timestamp (midnight)
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const todayTimestamp = today.getTime();
+
+      // Query for documents created today
+      const selector = {
+        created_at: {
+          $gte: todayTimestamp,
+        },
+        status: 'settled',
+      };
+
+      const result = await db.find({
+        selector: selector,
+        fields: ['_id', 'payment_total_pay'],
+        limit: 10000,
+      });
+
+      return result.docs.reduce(
+        (sum, doc) => sum + (doc.payment_total_pay || 0),
+        0,
+      );
+    } catch (error) {
+      console.log(error);
+      apm.captureError(error);
+      return 0;
+    }
+  }
+
+  getUnixTimestampLast7Days() {
+    const date = new Date();
+    date.setDate(date.getDate() - 4);
+    date.setHours(0, 0, 0, 0);
+    return date.getTime();
+  }
+
+  public async clearTransactions() {
+    const nano = this.nanoInstance;
+    const transaction = nano.use('transaction');
+
+    const expiredDate = this.getUnixTimestampLast7Days();
+
+    const selectorPayment = {
+      created_at: {
+        $lt: expiredDate,
+      },
+    };
+
+    const transactions = await transaction.find({
+      selector: selectorPayment,
+      fields: ['_id', '_rev'],
+      limit: 100000,
+    });
+
+    const { docs } = transactions;
+    console.log(docs.length);
+    const deletedDocs = {
+      docs: docs.map((doc) => ({
+        _id: doc._id,
+        _rev: doc._rev,
+        _deleted: true,
+      })),
+    };
+    await transaction.bulk(deletedDocs);
+  }
 }

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

@@ -97,9 +97,7 @@ export class ChangeStatusBookingHandler
       },
       relations: ['items', 'items.bundling_items'],
     });
-    console.log('change status', { dataID, couchData, booking });
     mappingTransaction(booking);
-    console.log('after mapping');
 
     if (!couchData) {
       console.log('save data to couch');

src/modules/configuration/couch/domain/managers/data-scheduling.handler.ts

@@ -0,0 +1,90 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { CouchService } from '../../data/services/couch.service';
+import { DataSchedulingDeletedEvent } from 'src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-deleted.event';
+import { DataSchedulingChangeStatusEvent } from 'src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-change-status.event';
+import { DataSchedulingUpdatedEvent } from 'src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-updated.event';
+import { DataSchedulingCreatedEvent } from 'src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-created.event';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSchedulingDefaultModel } from 'src/modules/configuration/data-scheduling/data/models/data-scheduling-default.model';
+import { DataSchedulingModel } from 'src/modules/configuration/data-scheduling/data/models/data-scheduling.model';
+import { Repository } from 'typeorm';
+
+import * as momentTz from 'moment-timezone';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { DataSchedulingEntity } from 'src/modules/configuration/data-scheduling/domain/entities/data-scheduling.entity';
+import { decryptionTotal } from 'src/modules/configuration/data-scheduling/infrastructure/helpers';
+import { Logger } from '@nestjs/common';
+
+@EventsHandler(
+  DataSchedulingCreatedEvent,
+  DataSchedulingUpdatedEvent,
+  DataSchedulingChangeStatusEvent,
+  DataSchedulingDeletedEvent,
+)
+export class DataSchedulingUpdatedHandler implements IEventHandler {
+  private readonly logger = new Logger(DataSchedulingUpdatedHandler.name);
+  private readonly permanentID = 'e6166c86-d85d-43f8-86ad-c9e85a88f68f';
+  private readonly couchTableName = 'api_configuration';
+
+  constructor(
+    private couchService: CouchService,
+
+    @InjectRepository(DataSchedulingDefaultModel)
+    private repository: Repository<DataSchedulingDefaultModel>,
+
+    @InjectRepository(DataSchedulingModel)
+    private repoSchedule: Repository<DataSchedulingModel>,
+  ) {}
+
+  async handle() {
+    const activeData = await this.getActiveData();
+    const existData = await this.couchService.getDoc(
+      this.permanentID,
+      this.couchTableName,
+    );
+    if (!existData) {
+      this.logger.verbose('CREATE SCHEDULING CONFIG');
+      await this.couchService.createDoc(
+        {
+          _id: this.permanentID,
+          id: this.permanentID,
+          ...activeData,
+        },
+        this.couchTableName,
+      );
+    } else if (existData) {
+      this.logger.verbose('UPDATE SCHEDULING CONFIG');
+      await this.couchService.updateDoc(
+        {
+          _id: this.permanentID,
+          id: this.permanentID,
+          ...activeData,
+        },
+        this.couchTableName,
+      );
+    }
+  }
+
+  async getActiveData() {
+    const timeZoneWIB = 'Asia/Jakarta';
+    const nowInWIB = momentTz().tz(timeZoneWIB).format('YYYY-MM-DD');
+    const date = nowInWIB;
+
+    const qb = this.repoSchedule.createQueryBuilder(TABLE_NAME.DATA_SCHEDULING);
+
+    const findData: DataSchedulingEntity = await qb
+      .where('status = :status', { status: 'active' })
+      .andWhere('schedule_date_from <= :date', { date: date })
+      .andWhere('schedule_date_to >= :date', { date: date })
+      .getOne();
+
+    if (!findData) {
+      const defaultData = await this.repository
+        .createQueryBuilder(TABLE_NAME.DATA_SCHEDULING_DEFAULT)
+        .getOne();
+      return { value: defaultData?.default_value };
+    }
+
+    return { value: decryptionTotal(findData.indexing_key as string), date };
+  }
+}

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

@@ -44,10 +44,12 @@ export class ItemUpdatedHandler
         'item_category',
         'bundling_items',
         'bundling_items.item_category',
+        'bundling_items.time_group',
         'item_rates',
         'item_rates.item',
         'item_rates.season_period',
         'item_rates.season_period.season_type',
+        'time_group',
       ],
     });
 
@@ -105,10 +107,12 @@ export class ItemPriceUpdatedHandler
           'item_category',
           'bundling_items',
           'bundling_items.item_category',
+          'bundling_items.time_group',
           'item_rates',
           'item_rates.item',
           'item_rates.season_period',
           'item_rates.season_period.season_type',
+          'time_group',
         ],
       });
 
@@ -146,10 +150,12 @@ export class ItemRateUpdatedHandler
         'item_category',
         'bundling_items',
         'bundling_items.item_category',
+        'bundling_items.time_group',
         'item_rates',
         'item_rates.item',
         'item_rates.season_period',
         'item_rates.season_period.season_type',
+        'time_group',
       ],
     });
 

src/modules/configuration/couch/domain/managers/time-group.handle.ts

@@ -0,0 +1,65 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { CouchService } from '../../data/services/couch.service';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import { TimeGroupDeletedEvent } from 'src/modules/item-related/time-group/domain/entities/event/time-group-deleted.event';
+import { TimeGroupChangeStatusEvent } from 'src/modules/item-related/time-group/domain/entities/event/time-group-change-status.event';
+import { TimeGroupUpdatedEvent } from 'src/modules/item-related/time-group/domain/entities/event/time-group-updated.event';
+
+@EventsHandler(TimeGroupDeletedEvent)
+export class TimeGroupDeletedHandler
+  implements IEventHandler<TimeGroupDeletedEvent>
+{
+  constructor(private couchService: CouchService) {}
+
+  async handle(event: TimeGroupDeletedEvent) {
+    const data = await this.couchService.deleteDoc(
+      {
+        _id: event.data.id,
+        ...event.data.data,
+      },
+      'time_groups',
+    );
+  }
+}
+
+@EventsHandler(TimeGroupChangeStatusEvent, TimeGroupUpdatedEvent)
+export class TimeGroupUpdatedHandler
+  implements IEventHandler<TimeGroupChangeStatusEvent>
+{
+  constructor(private couchService: CouchService) {}
+
+  async handle(event: TimeGroupChangeStatusEvent) {
+    const dataOld = event.data.old;
+    const data = event.data.data;
+
+    // change status to active
+    if (dataOld?.status != data.status && data.status == STATUS.ACTIVE) {
+      await this.couchService.createDoc(
+        {
+          _id: data.id,
+          ...data,
+        },
+        'time_groups',
+      );
+    } else if (dataOld?.status != data.status) {
+      await this.couchService.deleteDoc(
+        {
+          _id: data.id,
+          ...data,
+        },
+        'time_groups',
+      );
+    }
+
+    // update
+    else {
+      await this.couchService.updateDoc(
+        {
+          _id: data.id,
+          ...data,
+        },
+        'time_groups',
+      );
+    }
+  }
+}

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

@@ -5,13 +5,17 @@ import { Public } from 'src/core/guards';
 import * as Nano from 'nano';
 import { CreateUserPrivilegeDto } from 'src/modules/user-related/user-privilege/infrastructure/dto/create-user-privilege.dto';
 import { ConfigService } from '@nestjs/config';
+import { CouchService } from '../data/services/couch.service';
 
 @ApiTags(`couch`)
 @Controller('v1/couch')
 @Public()
 @Injectable()
 export class CouchDataController {
-  constructor(private configService: ConfigService) {}
+  constructor(
+    private configService: ConfigService,
+    private couchService: CouchService,
+  ) {}
 
   get nanoInstance() {
     const couchConfiguration = this.configService.get<string>('COUCHDB_CONFIG');
@@ -64,4 +68,11 @@ export class CouchDataController {
       // return people.get();
     } catch (error) {}
   }
+
+  @Public(true)
+  @Get('clear-transactions')
+  async clearTransactions(): Promise<string> {
+    await this.couchService.clearTransactions();
+    return 'OK';
+  }
 }

src/modules/configuration/data-scheduling/data-scheduling.module.ts

@@ -0,0 +1,105 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { DataSchedulingDataService } from './data/services/data-scheduling-data.service';
+import { DataSchedulingReadService } from './data/services/data-scheduling-read.service';
+import {
+  DataSchedulingLogReadController,
+  DataSchedulingReadController,
+} from './infrastructure/data-scheduling-read.controller';
+import { DataSchedulingReadOrchestrator } from './domain/usecases/data-scheduling-read.orchestrator';
+import {
+  DataSchedulingDataController,
+  DataSchedulingDefaultController,
+  DataSchedulingDataLogController,
+  DataSchedulingSetupController,
+} from './infrastructure/data-scheduling-data.controller';
+import { DataSchedulingDataOrchestrator } from './domain/usecases/data-scheduling-data.orchestrator';
+import { CreateDataSchedulingManager } from './domain/usecases/managers/create-data-scheduling.manager';
+import { CqrsModule } from '@nestjs/cqrs';
+import { IndexDataSchedulingManager } from './domain/usecases/managers/index-data-scheduling.manager';
+import { DeleteDataSchedulingManager } from './domain/usecases/managers/delete-data-scheduling.manager';
+import { UpdateDataSchedulingManager } from './domain/usecases/managers/update-data-scheduling.manager';
+import { ActiveDataSchedulingManager } from './domain/usecases/managers/active-data-scheduling.manager';
+import { ConfirmDataSchedulingManager } from './domain/usecases/managers/confirm-data-scheduling.manager';
+import { InactiveDataSchedulingManager } from './domain/usecases/managers/inactive-data-scheduling.manager';
+import { DetailDataSchedulingManager } from './domain/usecases/managers/detail-data-scheduling.manager';
+import { BatchDeleteDataSchedulingManager } from './domain/usecases/managers/batch-delete-data-scheduling.manager';
+import { BatchActiveDataSchedulingManager } from './domain/usecases/managers/batch-active-data-scheduling.manager';
+import { BatchConfirmDataSchedulingManager } from './domain/usecases/managers/batch-confirm-data-scheduling.manager';
+import { BatchInactiveDataSchedulingManager } from './domain/usecases/managers/batch-inactive-data-scheduling.manager';
+import { DataSchedulingModel } from './data/models/data-scheduling.model';
+import { DataSchedulingDefaultModel } from './data/models/data-scheduling-default.model';
+import { DataSchedulingManager } from './domain/usecases/managers/data-scheduling-default.manager';
+import { SetupSchedulingGuard } from './infrastructure/guards/setup-scheduling.guard';
+
+import { DataSchedulingChangeStatusHandler } from './domain/usecases/handlers/data-scheduling-change-status.handler';
+import { DataSchedulingCreatedHandler } from './domain/usecases/handlers/data-scheduling-created.handler';
+import { DataSchedulingDeletedHandler } from './domain/usecases/handlers/data-scheduling-deleted.handler';
+import { DataSchedulingUpdatedHandler } from './domain/usecases/handlers/data-scheduling-updated.handler';
+
+import { JwtModule } from '@nestjs/jwt';
+import { JWT_EXPIRED } from 'src/core/sessions/constants';
+import { JWT_SECRET } from 'src/core/sessions/constants';
+
+import { DataSchedulingLogDataService } from './data/services/data-scheduling-log-data.service';
+import { DataSchedulingLogModel } from './data/models/data-scheduling-log.model';
+import { DataSchedulingLogReadService } from './data/services/data-scheduling-log-read.service';
+import { IndexDataSchedulingLogManager } from './domain/usecases/managers/index-data-scheduling-log.manager';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    TypeOrmModule.forFeature(
+      [DataSchedulingModel, DataSchedulingDefaultModel, DataSchedulingLogModel],
+      CONNECTION_NAME.DEFAULT,
+    ),
+    JwtModule.register({
+      secret: JWT_SECRET,
+      signOptions: { expiresIn: JWT_EXPIRED },
+    }),
+    CqrsModule,
+  ],
+  controllers: [
+    DataSchedulingDataController,
+    DataSchedulingReadController,
+    DataSchedulingDefaultController,
+    DataSchedulingSetupController,
+    DataSchedulingLogReadController,
+    DataSchedulingDataLogController,
+  ],
+  providers: [
+    SetupSchedulingGuard,
+    IndexDataSchedulingManager,
+    DetailDataSchedulingManager,
+    CreateDataSchedulingManager,
+    DeleteDataSchedulingManager,
+    UpdateDataSchedulingManager,
+    ActiveDataSchedulingManager,
+    ConfirmDataSchedulingManager,
+    InactiveDataSchedulingManager,
+    BatchDeleteDataSchedulingManager,
+    BatchActiveDataSchedulingManager,
+    BatchConfirmDataSchedulingManager,
+    BatchInactiveDataSchedulingManager,
+
+    DataSchedulingLogDataService,
+    DataSchedulingLogReadService,
+    DataSchedulingDataService,
+    DataSchedulingReadService,
+    DataSchedulingLogDataService,
+
+    DataSchedulingDataOrchestrator,
+    DataSchedulingReadOrchestrator,
+
+    DataSchedulingManager,
+    IndexDataSchedulingLogManager,
+
+    DataSchedulingChangeStatusHandler,
+    DataSchedulingCreatedHandler,
+    DataSchedulingDeletedHandler,
+    DataSchedulingUpdatedHandler,
+  ],
+})
+export class DataSchedulingModule {}

src/modules/configuration/data-scheduling/data/models/data-scheduling-default.model.ts

@@ -0,0 +1,13 @@
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { DataSchedulingDefaultEntity } from '../../domain/entities/data-scheduling.entity';
+import { Column, Entity } from 'typeorm';
+import { BaseModel } from 'src/core/modules/data/model/base.model';
+
+@Entity(TABLE_NAME.DATA_SCHEDULING_DEFAULT)
+export class DataSchedulingDefaultModel
+  extends BaseModel<DataSchedulingDefaultEntity>
+  implements DataSchedulingDefaultEntity
+{
+  @Column('int', { nullable: false })
+  default_value: number;
+}

src/modules/configuration/data-scheduling/data/models/data-scheduling-log.model.ts

@@ -0,0 +1,44 @@
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import {
+  DataSchedulingLogEntity,
+  SCHEDULING_LOG_ACTION_ENUM,
+  SCHEDULING_LOG_TYPE_ENUM,
+} from '../../domain/entities/data-scheduling.entity';
+import { Column, Entity } from 'typeorm';
+import { BaseStatusModel } from 'src/core/modules/data/model/base-status.model';
+
+@Entity(TABLE_NAME.DATA_SCHEDULING_LOG)
+export class DataSchedulingLogModel
+  extends BaseStatusModel<DataSchedulingLogEntity>
+  implements DataSchedulingLogEntity
+{
+  @Column({ type: 'enum', enum: SCHEDULING_LOG_TYPE_ENUM, nullable: false })
+  type: SCHEDULING_LOG_TYPE_ENUM;
+
+  @Column({ type: 'enum', enum: SCHEDULING_LOG_ACTION_ENUM, nullable: false })
+  action: SCHEDULING_LOG_ACTION_ENUM;
+
+  @Column({ type: 'bigint', nullable: false })
+  log_created_at: number;
+
+  @Column('varchar', { name: 'data_id', nullable: true })
+  data_id: string;
+
+  @Column('varchar', { name: 'name', nullable: true })
+  name: string;
+
+  @Column('varchar', { name: 'indexing_key', nullable: true })
+  indexing_key: string;
+
+  @Column('date', { name: 'schedule_date_from', nullable: true })
+  schedule_date_from: Date;
+
+  @Column('date', { name: 'schedule_date_to', nullable: true })
+  schedule_date_to: Date;
+
+  @Column('int', { nullable: true })
+  default_value: number;
+
+  @Column('text', { name: 'description', nullable: true })
+  description: string;
+}

src/modules/configuration/data-scheduling/data/models/data-scheduling.model.ts

@@ -0,0 +1,22 @@
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { DataSchedulingEntity } from '../../domain/entities/data-scheduling.entity';
+import { Column, Entity } from 'typeorm';
+import { BaseStatusModel } from 'src/core/modules/data/model/base-status.model';
+
+@Entity(TABLE_NAME.DATA_SCHEDULING)
+export class DataSchedulingModel
+  extends BaseStatusModel<DataSchedulingEntity>
+  implements DataSchedulingEntity
+{
+  @Column('varchar', { name: 'name' })
+  name: string;
+
+  @Column('varchar', { name: 'indexing_key' })
+  indexing_key: string;
+
+  @Column('date', { name: 'schedule_date_from', nullable: false })
+  schedule_date_from: Date;
+
+  @Column('date', { name: 'schedule_date_to', nullable: false })
+  schedule_date_to: Date;
+}

src/modules/configuration/data-scheduling/data/services/data-scheduling-data.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { BaseDataService } from 'src/core/modules/data/service/base-data.service';
+import { DataSchedulingEntity } from '../../domain/entities/data-scheduling.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSchedulingModel } from '../models/data-scheduling.model';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class DataSchedulingDataService extends BaseDataService<DataSchedulingEntity> {
+  constructor(
+    @InjectRepository(DataSchedulingModel, CONNECTION_NAME.DEFAULT)
+    private repo: Repository<DataSchedulingModel>,
+  ) {
+    super(repo);
+  }
+}

src/modules/configuration/data-scheduling/data/services/data-scheduling-log-data.service.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { DataSchedulingLogModel } from '../models/data-scheduling-log.model';
+import { Repository } from 'typeorm';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+
+@Injectable()
+export class DataSchedulingLogDataService {
+  constructor(
+    @InjectRepository(DataSchedulingLogModel, CONNECTION_NAME.DEFAULT)
+    private repo: Repository<DataSchedulingLogModel>,
+  ) {}
+
+  async create(entity: any): Promise<any> {
+    return await this.repo.save(entity);
+  }
+
+  async deleteRange(from: number, to: number): Promise<any> {
+    try {
+      const deleteResult = await this.repo
+        .createQueryBuilder()
+        .delete()
+        .from(TABLE_NAME.DATA_SCHEDULING_LOG)
+        .where('log_created_at BETWEEN :from AND :to', { from, to })
+        .execute();
+
+      return deleteResult;
+    } catch (error) {
+      throw new Error('Failed to delete range due to an internal error.');
+    }
+  }
+}

src/modules/configuration/data-scheduling/data/services/data-scheduling-log-read.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { DataSchedulingLogEntity } from '../../domain/entities/data-scheduling.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseReadService } from 'src/core/modules/data/service/base-read.service';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { Repository } from 'typeorm';
+import { DataSchedulingLogModel } from '../models/data-scheduling-log.model';
+
+@Injectable()
+export class DataSchedulingLogReadService extends BaseReadService<DataSchedulingLogEntity> {
+  constructor(
+    @InjectRepository(DataSchedulingLogModel, CONNECTION_NAME.DEFAULT)
+    private repo: Repository<DataSchedulingLogModel>,
+  ) {
+    super(repo);
+  }
+}

src/modules/configuration/data-scheduling/data/services/data-scheduling-read.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { DataSchedulingEntity } from '../../domain/entities/data-scheduling.entity';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSchedulingModel } from '../models/data-scheduling.model';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { Repository } from 'typeorm';
+import { BaseReadService } from 'src/core/modules/data/service/base-read.service';
+
+@Injectable()
+export class DataSchedulingReadService extends BaseReadService<DataSchedulingEntity> {
+  constructor(
+    @InjectRepository(DataSchedulingModel, CONNECTION_NAME.DEFAULT)
+    private repo: Repository<DataSchedulingModel>,
+  ) {
+    super(repo);
+  }
+}

src/modules/configuration/data-scheduling/domain/entities/data-scheduling.entity.ts

@@ -0,0 +1,47 @@
+import { BaseStatusEntity } from 'src/core/modules/domain/entities/base-status.entity';
+import { BaseEntity } from 'src/core/modules/domain/entities/base.entity';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+
+export interface DataSchedulingEntity extends BaseStatusEntity {
+  name: string;
+  indexing_key: number | string;
+  schedule_date_from: Date;
+  schedule_date_to: Date;
+}
+
+export interface DataSchedulingDefaultEntity extends BaseEntity {
+  default_value: number;
+}
+
+export interface DataSchedulingActiveEntity {
+  value: number;
+}
+
+export enum SCHEDULING_LOG_TYPE_ENUM {
+  DEFAULT_PERCENTAGE = 'Default Percentage',
+  DATA_SCHEDULING = 'Data Scheduling',
+}
+
+export enum SCHEDULING_LOG_ACTION_ENUM {
+  CREATE = 'CREATE',
+  UPDATE = 'UPDATE',
+  DELETE = 'DELETE',
+  CHANGE_STATUS = 'CHANGE_STATUS',
+}
+
+export interface DataSchedulingLogEntity extends BaseStatusEntity {
+  type: SCHEDULING_LOG_TYPE_ENUM;
+  action: SCHEDULING_LOG_ACTION_ENUM;
+  log_created_at: number;
+
+  data_id?: string;
+
+  name?: string;
+  indexing_key?: number | string;
+  schedule_date_from?: Date;
+  schedule_date_to?: Date;
+
+  default_value?: number;
+
+  description?: string;
+}

src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-change-status.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class DataSchedulingChangeStatusEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-created.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class DataSchedulingCreatedEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-deleted.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class DataSchedulingDeletedEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/configuration/data-scheduling/domain/entities/event/data-scheduling-updated.event.ts

@@ -0,0 +1,5 @@
+import { IEvent } from 'src/core/strings/constants/interface.constants';
+
+export class DataSchedulingUpdatedEvent {
+  constructor(public readonly data: IEvent) {}
+}

src/modules/configuration/data-scheduling/domain/entities/filter-data-scheduling.entity.ts

@@ -0,0 +1,6 @@
+import { BaseFilterEntity } from 'src/core/modules/domain/entities/base-filter.entity';
+
+export interface FilterDataSchedulingEntity extends BaseFilterEntity {
+  schedule_date_from: Date;
+  schedule_date_to: Date;
+}

src/modules/configuration/data-scheduling/domain/usecases/data-scheduling-data.orchestrator.ts

@@ -0,0 +1,125 @@
+import { Injectable } from '@nestjs/common';
+import { CreateDataSchedulingManager } from './managers/create-data-scheduling.manager';
+import { DataSchedulingDataService } from '../../data/services/data-scheduling-data.service';
+import { DataSchedulingEntity } from '../entities/data-scheduling.entity';
+import { DeleteDataSchedulingManager } from './managers/delete-data-scheduling.manager';
+import { UpdateDataSchedulingManager } from './managers/update-data-scheduling.manager';
+import { BaseDataTransactionOrchestrator } from 'src/core/modules/domain/usecase/orchestrators/base-data-transaction.orchestrator';
+import { ActiveDataSchedulingManager } from './managers/active-data-scheduling.manager';
+import { InactiveDataSchedulingManager } from './managers/inactive-data-scheduling.manager';
+import { ConfirmDataSchedulingManager } from './managers/confirm-data-scheduling.manager';
+import { STATUS } from 'src/core/strings/constants/base.constants';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { BatchConfirmDataSchedulingManager } from './managers/batch-confirm-data-scheduling.manager';
+import { BatchInactiveDataSchedulingManager } from './managers/batch-inactive-data-scheduling.manager';
+import { BatchActiveDataSchedulingManager } from './managers/batch-active-data-scheduling.manager';
+import { BatchDeleteDataSchedulingManager } from './managers/batch-delete-data-scheduling.manager';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+
+@Injectable()
+export class DataSchedulingDataOrchestrator extends BaseDataTransactionOrchestrator<DataSchedulingEntity> {
+  constructor(
+    private createManager: CreateDataSchedulingManager,
+    private updateManager: UpdateDataSchedulingManager,
+    private deleteManager: DeleteDataSchedulingManager,
+    private activeManager: ActiveDataSchedulingManager,
+    private confirmManager: ConfirmDataSchedulingManager,
+    private inactiveManager: InactiveDataSchedulingManager,
+    private batchDeleteManager: BatchDeleteDataSchedulingManager,
+    private batchActiveManager: BatchActiveDataSchedulingManager,
+    private batchConfirmManager: BatchConfirmDataSchedulingManager,
+    private batchInactiveManager: BatchInactiveDataSchedulingManager,
+    private serviceData: DataSchedulingDataService,
+  ) {
+    super();
+  }
+
+  async create(data): Promise<DataSchedulingEntity> {
+    this.createManager.setData(data);
+    this.createManager.setService(this.serviceData, TABLE_NAME.DATA_SCHEDULING);
+    await this.createManager.execute();
+    await this.createManager.generateConfig();
+    return this.createManager.getResult();
+  }
+
+  async update(dataId, data): Promise<DataSchedulingEntity> {
+    this.updateManager.setData(dataId, data);
+    this.updateManager.setService(this.serviceData, TABLE_NAME.DATA_SCHEDULING);
+    await this.updateManager.execute();
+    return this.updateManager.getResult();
+  }
+
+  async delete(dataId): Promise<string> {
+    this.deleteManager.setData(dataId);
+    this.deleteManager.setService(this.serviceData, TABLE_NAME.DATA_SCHEDULING);
+    await this.deleteManager.execute();
+    return this.deleteManager.getResult();
+  }
+
+  async batchDelete(dataIds: string[]): Promise<BatchResult> {
+    this.batchDeleteManager.setData(dataIds);
+    this.batchDeleteManager.setService(
+      this.serviceData,
+      TABLE_NAME.DATA_SCHEDULING,
+    );
+    await this.batchDeleteManager.execute();
+    return this.batchDeleteManager.getResult();
+  }
+
+  async active(dataId): Promise<string> {
+    this.activeManager.setData(dataId, STATUS.ACTIVE);
+    this.activeManager.setService(this.serviceData, TABLE_NAME.DATA_SCHEDULING);
+    await this.activeManager.execute();
+    return this.activeManager.getResult();
+  }
+
+  async batchActive(dataIds: string[]): Promise<BatchResult> {
+    this.batchActiveManager.setData(dataIds, STATUS.ACTIVE);
+    this.batchActiveManager.setService(
+      this.serviceData,
+      TABLE_NAME.DATA_SCHEDULING,
+    );
+    await this.batchActiveManager.execute();
+    return this.batchActiveManager.getResult();
+  }
+
+  async confirm(dataId): Promise<string> {
+    this.confirmManager.setData(dataId, STATUS.ACTIVE);
+    this.confirmManager.setService(
+      this.serviceData,
+      TABLE_NAME.DATA_SCHEDULING,
+    );
+    await this.confirmManager.execute();
+    return this.confirmManager.getResult();
+  }
+
+  async batchConfirm(dataIds: string[]): Promise<BatchResult> {
+    this.batchConfirmManager.setData(dataIds, STATUS.ACTIVE);
+    this.batchConfirmManager.setService(
+      this.serviceData,
+      TABLE_NAME.DATA_SCHEDULING,
+    );
+    await this.batchConfirmManager.execute();
+    return this.batchConfirmManager.getResult();
+  }
+
+  async inactive(dataId): Promise<string> {
+    this.inactiveManager.setData(dataId, STATUS.INACTIVE);
+    this.inactiveManager.setService(
+      this.serviceData,
+      TABLE_NAME.DATA_SCHEDULING,
+    );
+    await this.inactiveManager.execute();
+    return this.inactiveManager.getResult();
+  }
+
+  async batchInactive(dataIds: string[]): Promise<BatchResult> {
+    this.batchInactiveManager.setData(dataIds, STATUS.INACTIVE);
+    this.batchInactiveManager.setService(
+      this.serviceData,
+      TABLE_NAME.DATA_SCHEDULING,
+    );
+    await this.batchInactiveManager.execute();
+    return this.batchInactiveManager.getResult();
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/data-scheduling-read.orchestrator.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@nestjs/common';
+import { IndexDataSchedulingManager } from './managers/index-data-scheduling.manager';
+import { DataSchedulingReadService } from '../../data/services/data-scheduling-read.service';
+import {
+  DataSchedulingEntity,
+  DataSchedulingLogEntity,
+} from '../entities/data-scheduling.entity';
+import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
+import { BaseReadOrchestrator } from 'src/core/modules/domain/usecase/orchestrators/base-read.orchestrator';
+import { DetailDataSchedulingManager } from './managers/detail-data-scheduling.manager';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { IndexDataSchedulingLogManager } from './managers/index-data-scheduling-log.manager';
+import { DataSchedulingLogReadService } from '../../data/services/data-scheduling-log-read.service';
+
+@Injectable()
+export class DataSchedulingReadOrchestrator extends BaseReadOrchestrator<DataSchedulingEntity> {
+  constructor(
+    private indexManager: IndexDataSchedulingManager,
+    private indexLogManager: IndexDataSchedulingLogManager,
+    private detailManager: DetailDataSchedulingManager,
+    private serviceData: DataSchedulingReadService,
+    private logServiceData: DataSchedulingLogReadService,
+  ) {
+    super();
+  }
+
+  async index(params): Promise<PaginationResponse<DataSchedulingEntity>> {
+    this.indexManager.setFilterParam(params);
+    this.indexManager.setService(this.serviceData, TABLE_NAME.DATA_SCHEDULING);
+    await this.indexManager.execute();
+    return this.indexManager.getResult();
+  }
+
+  async indexLog(params): Promise<PaginationResponse<DataSchedulingLogEntity>> {
+    this.indexLogManager.setFilterParam(params);
+    this.indexLogManager.setService(
+      this.logServiceData,
+      TABLE_NAME.DATA_SCHEDULING_LOG,
+    );
+    await this.indexLogManager.execute();
+    return this.indexLogManager.getResult();
+  }
+
+  async detail(dataId: string): Promise<DataSchedulingEntity> {
+    this.detailManager.setData(dataId);
+    this.detailManager.setService(this.serviceData, TABLE_NAME.DATA_SCHEDULING);
+    await this.detailManager.execute();
+    return this.detailManager.getResult();
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/handlers/data-scheduling-change-status.handler.ts

@@ -0,0 +1,63 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { DataSchedulingChangeStatusEvent } from '../../entities/event/data-scheduling-change-status.event';
+import { capitalizeEachWord } from 'src/modules/reports/shared/helpers';
+import {
+  DataSchedulingLogEntity,
+  SCHEDULING_LOG_ACTION_ENUM,
+  SCHEDULING_LOG_TYPE_ENUM,
+} from '../../entities/data-scheduling.entity';
+import { Logger } from '@nestjs/common';
+import { DataSchedulingLogDataService } from '../../../data/services/data-scheduling-log-data.service';
+import { decryptionTotal } from '../../../infrastructure/helpers';
+
+@EventsHandler(DataSchedulingChangeStatusEvent)
+export class DataSchedulingChangeStatusHandler
+  implements IEventHandler<DataSchedulingChangeStatusEvent>
+{
+  private readonly logger = new Logger(DataSchedulingChangeStatusHandler.name);
+
+  constructor(private service: DataSchedulingLogDataService) {}
+
+  async handle(event: DataSchedulingChangeStatusEvent) {
+    // Prevent execution if the event data is null, which can happen if triggered from the default percentage update service.
+    if (event.data?.data) {
+      const oldData = event?.data?.old;
+      const newData = event?.data?.data;
+
+      const oldStatus = capitalizeEachWord(oldData?.status);
+      const newStatus = capitalizeEachWord(newData?.status);
+
+      const scheduleName = newData?.name || 'an item';
+      const editorName = newData.editor_name || 'System';
+      const totalPercentage = decryptionTotal(newData?.indexing_key);
+
+      const description = `<div><b>${editorName}</b> changed the status of <b><i>${scheduleName} (${totalPercentage}%)</i></b> schedule from <b><i>${newData?.schedule_date_from}</i></b> to <b><i>${newData.schedule_date_to}</i></b> from <b><i>${oldStatus}</i></b> to <b><i>${newStatus}</i></b>.</div>`;
+
+      const payload: DataSchedulingLogEntity = {
+        type: SCHEDULING_LOG_TYPE_ENUM.DATA_SCHEDULING,
+        action: SCHEDULING_LOG_ACTION_ENUM.CHANGE_STATUS,
+        log_created_at: new Date().getTime(),
+
+        data_id: newData?.id,
+        name: newData?.name,
+        indexing_key: newData?.indexing_key,
+        schedule_date_from: newData?.schedule_date_from,
+        schedule_date_to: newData?.schedule_date_to,
+
+        status: newData?.status,
+        creator_id: newData?.creator_id,
+        creator_name: newData?.creator_name,
+        editor_id: newData?.editor_id,
+        editor_name: newData?.editor_name,
+        created_at: newData?.created_at,
+        updated_at: newData?.updated_at,
+        description: description,
+      };
+
+      await this.service.create(payload as any);
+      this.logger.verbose(
+        `[SCHEDULING LOG] Change status data for ID: ${payload.data_id}`,
+      );
+    }
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/handlers/data-scheduling-created.handler.ts

@@ -0,0 +1,53 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { DataSchedulingCreatedEvent } from '../../entities/event/data-scheduling-created.event';
+import {
+  DataSchedulingLogEntity,
+  SCHEDULING_LOG_ACTION_ENUM,
+  SCHEDULING_LOG_TYPE_ENUM,
+} from '../../entities/data-scheduling.entity';
+import { decryptionTotal } from '../../../infrastructure/helpers';
+import { Logger } from '@nestjs/common';
+import { DataSchedulingLogDataService } from '../../../data/services/data-scheduling-log-data.service';
+
+@EventsHandler(DataSchedulingCreatedEvent)
+export class DataSchedulingCreatedHandler
+  implements IEventHandler<DataSchedulingCreatedEvent>
+{
+  private readonly logger = new Logger(DataSchedulingCreatedHandler.name);
+
+  constructor(private service: DataSchedulingLogDataService) {}
+
+  async handle(event: DataSchedulingCreatedEvent) {
+    const data = event?.data?.data;
+    const totalPercentage = decryptionTotal(data?.indexing_key);
+
+    const scheduleName = data?.name || 'a new schedule';
+    const description = `<div><b>${data.creator_name}</b> created <b><i>${scheduleName}</i></b> schedule from <b><i>${data?.schedule_date_from}</i></b> to <b><i>${data.schedule_date_to}</i></b> with a total percentage of <b><i>${totalPercentage}%</i></b>.</div>`;
+
+    const payload: DataSchedulingLogEntity = {
+      type: SCHEDULING_LOG_TYPE_ENUM.DATA_SCHEDULING,
+      action: SCHEDULING_LOG_ACTION_ENUM.CREATE,
+      log_created_at: new Date().getTime(),
+
+      data_id: data?.id,
+      name: data?.name,
+      indexing_key: data?.indexing_key,
+      schedule_date_from: data?.schedule_date_from,
+      schedule_date_to: data?.schedule_date_to,
+
+      status: data?.status,
+      creator_id: data?.creator_id,
+      creator_name: data?.creator_name,
+      editor_id: data?.editor_id,
+      editor_name: data?.editor_name,
+      created_at: data?.created_at,
+      updated_at: data?.updated_at,
+      description: description,
+    };
+
+    await this.service.create(payload as any);
+    this.logger.verbose(
+      `[SCHEDULING LOG] Create data for ID: ${payload.data_id}`,
+    );
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/handlers/data-scheduling-deleted.handler.ts

@@ -0,0 +1,60 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { DataSchedulingDeletedEvent } from '../../entities/event/data-scheduling-deleted.event';
+import {
+  DataSchedulingLogEntity,
+  SCHEDULING_LOG_ACTION_ENUM,
+  SCHEDULING_LOG_TYPE_ENUM,
+} from '../../entities/data-scheduling.entity';
+import { Logger } from '@nestjs/common';
+import { DataSchedulingLogDataService } from '../../../data/services/data-scheduling-log-data.service';
+import { decryptionTotal } from '../../../infrastructure/helpers';
+
+@EventsHandler(DataSchedulingDeletedEvent)
+export class DataSchedulingDeletedHandler
+  implements IEventHandler<DataSchedulingDeletedEvent>
+{
+  private readonly logger = new Logger(DataSchedulingDeletedHandler.name);
+
+  constructor(private service: DataSchedulingLogDataService) {}
+
+  async handle(event: DataSchedulingDeletedEvent) {
+    const deletedData = event?.data?.data;
+    const user = event?.data?.user;
+
+    const deleterName =
+      user?.name ||
+      deletedData?.editor_name ||
+      deletedData?.creator_name ||
+      'System';
+
+    const scheduleName = deletedData?.name || 'an item';
+    const totalPercentage = decryptionTotal(deletedData?.indexing_key);
+    const description = `<div><b>${deleterName}</b> deleted schedule: <b><i>${scheduleName} (${totalPercentage}%)</i></b> schedule from <b><i>${deletedData?.schedule_date_from}</i></b> to <b><i>${deletedData.schedule_date_to}</i></b>.</div>`;
+
+    const payload: DataSchedulingLogEntity = {
+      type: SCHEDULING_LOG_TYPE_ENUM.DATA_SCHEDULING,
+      action: SCHEDULING_LOG_ACTION_ENUM.DELETE,
+      log_created_at: new Date().getTime(),
+
+      data_id: deletedData?.id,
+      name: deletedData?.name,
+      indexing_key: deletedData?.indexing_key,
+      schedule_date_from: deletedData?.schedule_date_from,
+      schedule_date_to: deletedData?.schedule_date_to,
+      status: deletedData?.status,
+
+      creator_id: deletedData?.creator_id,
+      creator_name: deletedData?.creator_name,
+      editor_id: deletedData?.editor_id,
+      editor_name: deletedData?.editor_name,
+      created_at: deletedData?.created_at,
+      updated_at: deletedData?.updated_at,
+      description: description,
+    };
+
+    await this.service.create(payload as any);
+    this.logger.verbose(
+      `[SCHEDULING LOG] Delete data for ID: ${payload.data_id}`,
+    );
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/handlers/data-scheduling-updated.handler.ts

@@ -0,0 +1,157 @@
+import { EventsHandler, IEventHandler } from '@nestjs/cqrs';
+import { DataSchedulingUpdatedEvent } from '../../entities/event/data-scheduling-updated.event';
+import {
+  DataSchedulingLogEntity,
+  SCHEDULING_LOG_ACTION_ENUM,
+  SCHEDULING_LOG_TYPE_ENUM,
+} from '../../entities/data-scheduling.entity';
+import {
+  decryptionTotal,
+  encryptionTotal,
+} from '../../../infrastructure/helpers';
+import { Logger } from '@nestjs/common';
+import { DataSchedulingLogDataService } from '../../../data/services/data-scheduling-log-data.service';
+
+@EventsHandler(DataSchedulingUpdatedEvent)
+export class DataSchedulingUpdatedHandler
+  implements IEventHandler<DataSchedulingUpdatedEvent>
+{
+  private readonly logger = new Logger(DataSchedulingUpdatedHandler.name);
+
+  constructor(private service: DataSchedulingLogDataService) {}
+
+  // Map for readable labels
+  private readonly labelMap: { [key: string]: string } = {
+    name: 'Name',
+    indexing_key: 'Total Data',
+    schedule_date_from: 'Start Date',
+    schedule_date_to: 'End Date',
+  };
+
+  // Relevant keys for comparing changes
+  private readonly keysToCompare: string[] = [
+    'name',
+    'indexing_key',
+    'schedule_date_from',
+    'schedule_date_to',
+  ];
+
+  async handle(event: DataSchedulingUpdatedEvent) {
+    const oldData = event?.data?.old;
+    // Decrypt oldData.indexing_key here before comparison
+    if (oldData?.indexing_key !== undefined && oldData?.indexing_key !== null) {
+      oldData.indexing_key = decryptionTotal(oldData.indexing_key);
+    }
+
+    const newData = event?.data?.data;
+    // Decrypt newData.indexing_key here before comparison
+    if (newData?.indexing_key !== undefined && newData?.indexing_key !== null) {
+      newData.indexing_key = decryptionTotal(newData.indexing_key);
+    }
+
+    const changingData = this.getChangingData(oldData, newData);
+    const description = this.generateDescription(
+      oldData,
+      newData,
+      changingData,
+    );
+
+    const payload: DataSchedulingLogEntity = {
+      type: SCHEDULING_LOG_TYPE_ENUM.DATA_SCHEDULING,
+      action: SCHEDULING_LOG_ACTION_ENUM.UPDATE,
+      log_created_at: new Date().getTime(),
+
+      data_id: newData?.id,
+      name: newData?.name,
+      indexing_key: encryptionTotal(newData?.indexing_key),
+      schedule_date_from: newData?.schedule_date_from,
+      schedule_date_to: newData?.schedule_date_to,
+
+      status: newData?.status,
+      creator_id: newData?.creator_id,
+      creator_name: newData?.creator_name,
+      editor_id: newData?.editor_id,
+      editor_name: newData?.editor_name,
+      created_at: newData?.created_at,
+      updated_at: newData?.updated_at,
+      description: description,
+    };
+
+    await this.service.create(payload as any);
+    this.logger.verbose(
+      `[SCHEDULING LOG] Update data for ID: ${payload.data_id}`,
+    );
+  }
+
+  /**
+   * Compares old and new data to find changes.
+   * @param oldData Data before the change.
+   * @param newData Data after the change.
+   * @returns An object containing the old and new changed data.
+   */
+  private getChangingData(oldData: any, newData: any): { old: any; new: any } {
+    const changingData: { old: any; new: any } = { old: {}, new: {} };
+
+    this.keysToCompare.forEach((key) => {
+      // Ensure comparisons are made on decrypted values if decryption happens before this
+      if (oldData?.[key] !== newData?.[key]) {
+        changingData.old[key] = oldData?.[key];
+        changingData.new[key] = newData?.[key];
+      }
+    });
+
+    return changingData;
+  }
+
+  /**
+   * Generates an HTML description string based on data changes.
+   * Includes the name from oldData for identification.
+   * @param oldData Old data, used to get the name of the item.
+   * @param newData New data containing editor information.
+   * @param changingData An object containing the changed data.
+   * @returns The HTML string of the change description.
+   */
+  private generateDescription(
+    oldData: any,
+    newData: any,
+    changingData: { old: any; new: any },
+  ): string {
+    const editorName = newData.editor_name || 'System';
+    const itemName = oldData?.name || 'an item';
+
+    const totalPercentageOld = oldData?.indexing_key;
+    const totalPercentageNew = newData?.indexing_key;
+    const isTotalSame = totalPercentageOld === totalPercentageNew;
+    const labelName = `${
+      isTotalSame
+        ? `${totalPercentageNew}%`
+        : `${totalPercentageOld}% to ${totalPercentageNew}%`
+    }`;
+
+    let description = `<div><b>${editorName}</b> has updated schedule for <b><i>${itemName} (${labelName})</i></b> schedule from <b><i>${newData?.schedule_date_from}</i></b> to <b><i>${newData.schedule_date_to}</i></b>.<br>`;
+
+    if (Object.keys(changingData.old).length > 0) {
+      description += `Change details:<ul>`;
+      for (const key in changingData.old) {
+        if (Object.prototype.hasOwnProperty.call(changingData.old, key)) {
+          const label = this.labelMap[key] || key;
+          let oldValue = changingData.old[key] || 'empty';
+          let newValue = changingData.new[key] || 'empty';
+
+          // Add '%' suffix if the key is 'indexing_key'
+          if (key === 'indexing_key') {
+            oldValue = `${oldValue}%`;
+            newValue = `${newValue}%`;
+          }
+
+          description += `<li><b>${label}</b> changed from <b><i>${oldValue}</i></b> to <b><i>${newValue}</i></b>.</li>`;
+        }
+      }
+      description += `</ul></div>`;
+    } else {
+      description += ` No significant data detail changes.</p>`;
+    }
+
+    return description;
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/managers/active-data-scheduling.manager.ts

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { BaseUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-update-status.manager';
+import { DataSchedulingEntity } from '../../entities/data-scheduling.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { DataSchedulingModel } from '../../../data/models/data-scheduling.model';
+import { DataSchedulingChangeStatusEvent } from '../../entities/event/data-scheduling-change-status.event';
+
+@Injectable()
+export class ActiveDataSchedulingManager extends BaseUpdateStatusManager<DataSchedulingEntity> {
+  getResult(): string {
+    return `Success active data ${this.result.name}`;
+  }
+
+  async validateProcess(): Promise<void> {
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return DataSchedulingModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: DataSchedulingChangeStatusEvent,
+        data: this.data,
+      },
+    ];
+  }
+}

src/modules/configuration/data-scheduling/domain/usecases/managers/batch-active-data-scheduling.manager.ts

@@ -0,0 +1,45 @@
+import { BaseBatchUpdateStatusManager } from 'src/core/modules/domain/usecase/managers/base-batch-update-status.manager';
+import { DataSchedulingEntity } from '../../entities/data-scheduling.entity';
+import {
+  EventTopics,
+  validateRelations,
+} from 'src/core/strings/constants/interface.constants';
+import { DataSchedulingModel } from '../../../data/models/data-scheduling.model';
+import { DataSchedulingChangeStatusEvent } from '../../entities/event/data-scheduling-change-status.event';
+import { BatchResult } from 'src/core/response/domain/ok-response.interface';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class BatchActiveDataSchedulingManager extends BaseBatchUpdateStatusManager<DataSchedulingEntity> {
+  validateData(data: DataSchedulingEntity): Promise<void> {
+    return;
+  }
+
+  beforeProcess(): Promise<void> {
+    return;
+  }
+
+  afterProcess(): Promise<void> {
+    return;
+  }
+
+  get validateRelations(): validateRelations[] {
+    return [];
+  }
+
+  get entityTarget(): any {
+    return DataSchedulingModel;
+  }
+
+  get eventTopics(): EventTopics[] {
+    return [
+      {
+        topic: DataSchedulingChangeStatusEvent,
+      },
+    ];
+  }
+
+  getResult(): BatchResult {
+    return this.result;
+  }
+}