feat: add clear couch transaction API

env/env.development

@@ -44,3 +44,6 @@ 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

env/env.production

@@ -41,3 +41,6 @@ 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

package.json

@@ -49,6 +49,7 @@
     "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",

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/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/1729151429165-queue-table.ts

@@ -15,7 +15,7 @@ export class QueueTable1729151429165 implements MigrationInterface {
     );
 
     await queryRunner.query(
-      `ALTER TABLE "queue_tickets" ADD CONSTRAINT "FK_0e9823b8b7ca9523b3be73878e5" FOREIGN KEY ("order_id") REFERENCES "queue_orders"("id") ON DELETE CASCADE ON UPDATE CASCADE`,
+      `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`,

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/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/data/services/couch.service.ts

@@ -19,6 +19,7 @@ export class CouchService {
   }
 
   async onModuleInit() {
+    // return;
     const nano = this.nanoInstance;
     for (const database of DatabaseListen) {
       const db = nano.db.use(database);
@@ -95,4 +96,41 @@ export class CouchService {
       return null;
     }
   }
+
+  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/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/item-related/item-queue/data/models/item-queue.model.ts

@@ -10,6 +10,12 @@ export class ItemQueueModel
   extends BaseStatusModel<ItemQueueEntity>
   implements ItemQueueEntity
 {
+  @Column('int', { default: 100 })
+  max_peak_level: number;
+
+  @Column('int', { default: 5 })
+  call_preparation: number;
+
   @Column('varchar', { name: 'name' })
   name: string;
 
@@ -27,4 +33,10 @@ export class ItemQueueModel
     onUpdate: 'CASCADE',
   })
   items: ItemModel[];
+
+  @Column('boolean', { default: true })
+  use_notification: boolean;
+
+  @Column('boolean', { default: false })
+  requiring_notification: boolean;
 }

src/modules/item-related/item-queue/domain/entities/item-queue.entity.ts

@@ -6,5 +6,9 @@ export interface ItemQueueEntity extends BaseStatusEntity {
   name: string;
   item_type: ItemType;
   information?: string;
+  max_peak_level: number;
+  call_preparation: number;
   items: ItemEntity[];
+  use_notification?: boolean;
+  requiring_notification?: boolean;
 }

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

@@ -36,6 +36,10 @@ export class DetailItemQueueManager extends BaseDetailManager<ItemQueueEntity> {
       `${this.tableName}.creator_name`,
       `${this.tableName}.updated_at`,
       `${this.tableName}.editor_name`,
+      `${this.tableName}.max_peak_level`,
+      `${this.tableName}.call_preparation`,
+      `${this.tableName}.use_notification`,
+      `${this.tableName}.requiring_notification`,
 
       `items.id`,
       `items.created_at`,

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

@@ -39,6 +39,10 @@ export class IndexItemQueueManager extends BaseIndexManager<ItemQueueEntity> {
       `${this.tableName}.creator_name`,
       `${this.tableName}.updated_at`,
       `${this.tableName}.editor_name`,
+      `${this.tableName}.max_peak_level`,
+      `${this.tableName}.call_preparation`,
+      `${this.tableName}.use_notification`,
+      `${this.tableName}.requiring_notification`,
 
       `items.id`,
       `items.created_at`,

src/modules/item-related/item-queue/infrastructure/dto/item-queue.dto.ts

@@ -1,12 +1,30 @@
 import { BaseStatusDto } from 'src/core/modules/infrastructure/dto/base-status.dto';
 import { ItemQueueEntity } from '../../domain/entities/item-queue.entity';
-import { IsArray, IsString } from 'class-validator';
+import { IsArray, IsNumber, IsString } from 'class-validator';
 import { ItemType } from '../../constants';
 import { ApiProperty } from '@nestjs/swagger';
 import { ItemEntity } from 'src/modules/item-related/item/domain/entities/item.entity';
 import { Exclude, Transform } from 'class-transformer';
 
 export class ItemQueueDto extends BaseStatusDto implements ItemQueueEntity {
+  @ApiProperty({
+    name: 'max_peak_level',
+    required: false,
+    example: 'Menentukan level peak maksimal penuhnya wahana',
+    default: 100,
+  })
+  @IsNumber()
+  max_peak_level: number;
+
+  @ApiProperty({
+    name: 'call_preparation',
+    required: false,
+    example: 'Waktu persiapan untuk memanggil antrian dalam menit',
+    default: 5,
+  })
+  @IsNumber()
+  call_preparation: number;
+
   @Exclude()
   items: ItemEntity[];
 

src/modules/item-related/item-queue/infrastructure/item-queue-read.controller.ts

@@ -1,4 +1,10 @@
-import { Controller, Get, Param, Query } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Param,
+  Query,
+  UnauthorizedException,
+} from '@nestjs/common';
 import { FilterItemQueueDto } from './dto/filter-item-queue.dto';
 import { Pagination } from 'src/core/response';
 import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
@@ -7,6 +13,7 @@ import { ItemQueueReadOrchestrator } from '../domain/usecases/item-queue-read.or
 import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
 import { MODULE_NAME } from 'src/core/strings/constants/module.constants';
 import { Public } from 'src/core/guards';
+import { validate as isValidUUID } from 'uuid';
 
 @ApiTags(`${MODULE_NAME.ITEM_QUEUE.split('-').join(' ')} - read`)
 @Controller(`v1/${MODULE_NAME.ITEM_QUEUE}`)
@@ -44,6 +51,7 @@ export class ItemQueueReadController {
   @Get('display/:id')
   @Public(true)
   async detailPublic(@Param('id') id: string): Promise<ItemQueueEntity> {
+    if (!isValidUUID(id)) throw new UnauthorizedException('id is required');
     return await this.orchestrator.detail(id);
   }
 }

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

@@ -54,7 +54,7 @@ export class ItemModel
   @Column('bigint', { name: 'base_price', nullable: true })
   base_price: number;
 
-  @Column('int', { name: 'play_estimation', nullable: true })
+  @Column('decimal', { name: 'play_estimation', nullable: true })
   play_estimation: number;
 
   @Column('boolean', { name: 'use_queue', default: false })

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

@@ -84,6 +84,12 @@ export class IndexItemManager extends BaseIndexManager<ItemEntity> {
   setQueryFilter(
     queryBuilder: SelectQueryBuilder<ItemEntity>,
   ): SelectQueryBuilder<ItemEntity> {
+    if (this.filterParam.q) {
+      queryBuilder.andWhere(
+        `${this.tableName}.name ILIKE '%${this.filterParam.q}%'`,
+      );
+    }
+
     if (this.filterParam.tenant_ids?.length) {
       queryBuilder.andWhere(`${this.tableName}.tenant_id In (:...tenantIds)`, {
         tenantIds: this.filterParam.tenant_ids,

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

@@ -115,6 +115,9 @@ export class QueueModel extends BaseModel<Queue> implements Queue {
   @Column({ type: 'bigint' })
   time: number;
 
+  @Column({ type: 'bigint', nullable: true })
+  last_notification: number;
+
   @Column({ type: 'bigint' })
   call_time: number;
 
@@ -136,4 +139,7 @@ export class QueueModel extends BaseModel<Queue> implements Queue {
 
   @Column('int')
   qty: number;
+
+  average = 0;
+  peak_level = 100;
 }

src/modules/queue/data/services/queue-bucket.ts

@@ -24,16 +24,9 @@ export class QueueBucketReadService extends BaseReadService<QueueBucketModel> {
     const start = moment().startOf('day').valueOf();
     const end = moment().endOf('day').valueOf();
 
-    const queueItem = await this.item.findOne({
-      relations: ['item'],
-      where: {
-        id: item_id,
-      },
-    });
-
     const queue = await this.repo.findOne({
       where: {
-        queue_item_id: queueItem.item.item_queue_id ?? queueItem.item.id,
+        queue_item_id: item_id,
         date: Between(start, end),
       },
     });
@@ -42,7 +35,7 @@ export class QueueBucketReadService extends BaseReadService<QueueBucketModel> {
       const regularNumber = vip ? 0 : 1;
       const vipNumber = vip ? 1 : 0;
       await this.repo.save({
-        queue_item_id: queueItem.item.item_queue_id ?? queueItem.item.id,
+        queue_item_id: item_id,
         date: start,
         regular: regularNumber,
         vip: vipNumber,

src/modules/queue/data/services/queue.service.ts

@@ -2,7 +2,7 @@ import { Injectable } from '@nestjs/common';
 
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
-import { Between, DataSource, In, Repository } from 'typeorm';
+import { Between, DataSource, In, Not, Repository } from 'typeorm';
 import {
   QueueItemModel,
   QueueModel,
@@ -10,9 +10,10 @@ import {
 } from '../models/queue.model';
 import { BaseReadService } from 'src/core/modules/data/service/base-read.service';
 import { BaseDataService } from 'src/core/modules/data/service/base-data.service';
-import * as moment from 'moment';
 import { ItemQueueModel } from 'src/modules/item-related/item-queue/data/models/item-queue.model';
+import * as moment from 'moment';
 import * as math from 'mathjs';
+import { ItemModel } from 'src/modules/item-related/item/data/models/item.model';
 
 @Injectable()
 export class QueueDataService extends BaseReadService<QueueModel> {
@@ -26,6 +27,76 @@ export class QueueDataService extends BaseReadService<QueueModel> {
     super(repo);
   }
 
+  async waitingQueue(item_queue_id: string) {
+    const start = moment().startOf('day').valueOf();
+    const end = moment().endOf('day').valueOf();
+    return this.repo.find({
+      where: {
+        time: Between(start, end),
+        item_queue_id,
+        status: 'waiting',
+      },
+      order: {
+        time: 'ASC',
+      },
+    });
+  }
+
+  async doneQueue(item_queue_id: string) {
+    const start = moment().startOf('day').valueOf();
+    const end = moment().endOf('day').valueOf();
+    return this.repo.find({
+      where: {
+        time: Between(start, end),
+        item_queue_id,
+        status: In(['done', 'called']),
+      },
+      order: {
+        time: 'ASC',
+      },
+    });
+  }
+
+  async exclude(item_queue_id: string[]) {
+    const queues = await this.itemQueueRepo.find({
+      relations: ['items'],
+      where: {
+        id: Not(In(item_queue_id)),
+      },
+    });
+
+    return queues.filter((q) => q.items.length > 0);
+  }
+
+  async allQueue() {
+    const queues = await this.itemQueueRepo.find({
+      relations: ['items'],
+    });
+
+    return queues.filter((q) => q.items.length > 0);
+  }
+
+  async lastQueue(item_queue_id: string) {
+    const start = moment().startOf('day').valueOf();
+    const end = moment().endOf('day').valueOf();
+    return this.repo.findOne({
+      where: {
+        time: Between(start, end),
+        item_queue_id,
+        status: 'called',
+      },
+      order: {
+        call_time: 'DESC',
+      },
+    });
+  }
+
+  /**
+   * @deprecated
+   * Change to QueueTimeFormula (queue-time.formula.ts)
+   * @param item_queue_id
+   * @returns
+   */
   async queueTimes(item_queue_id: string): Promise<any> {
     const queueTimes = {};
     let now = moment().valueOf();
@@ -62,6 +133,18 @@ export class QueueDataService extends BaseReadService<QueueModel> {
 
     return queueTimes;
   }
+
+  async queueItems(item_queue_id: string[]): Promise<QueueModel[]> {
+    return this.repo.find({
+      relations: ['item', 'item.item', 'item.item.item_queue'],
+      where: {
+        item: { item: { item_queue: { id: In(item_queue_id) } } },
+      },
+      order: {
+        time: 'DESC',
+      },
+    });
+  }
 }
 
 @Injectable()
@@ -73,16 +156,37 @@ export class QueueService extends BaseDataService<QueueModel> {
     @InjectRepository(QueueItemModel, CONNECTION_NAME.DEFAULT)
     private item: Repository<QueueItemModel>,
 
+    @InjectRepository(ItemModel, CONNECTION_NAME.DEFAULT)
+    private itemMaster: Repository<ItemModel>,
+
     @InjectDataSource(CONNECTION_NAME.DEFAULT)
     private dataSource: DataSource,
   ) {
     super(repo);
   }
 
+  async queueTicket(queueId: string) {
+    return this.repo.findOne({
+      relations: ['item', 'item.ticket'],
+      where: {
+        id: queueId,
+      },
+    });
+  }
+
   async queues(ids: string[]) {
     const start = moment().startOf('day').valueOf();
     const end = moment().endOf('day').valueOf();
-    return this.repo.find({
+    const playEstimations = {};
+    const queuePeakLevel = {};
+
+    for (const id of ids) {
+      const est = await this.itemAverageTimeEstimation(id);
+      playEstimations[id] = est.average;
+      queuePeakLevel[id] = est.peakLevel;
+    }
+
+    const queues = await this.repo.find({
       where: {
         item_queue_id: In(ids),
         time: Between(start, end),
@@ -91,6 +195,27 @@ export class QueueService extends BaseDataService<QueueModel> {
         time: 'ASC',
       },
     });
+
+    queues.forEach((queue) => {
+      queue.average = playEstimations[queue.item_queue_id];
+      queue.peak_level = queuePeakLevel[queue.item_queue_id];
+    });
+
+    return queues;
+  }
+
+  async itemAverageTimeEstimation(item_queue_id: string) {
+    const items = await this.itemMaster.find({
+      relations: ['item_queue'],
+      where: {
+        item_queue_id,
+      },
+    });
+
+    const times = items.map((item) => item.play_estimation ?? 0);
+    const average = times.length > 0 ? math.mean(times) * 60 * 1000 : 0; // change average minute to milliseconds
+    const peakLevel = items[0]?.item_queue?.max_peak_level ?? 100;
+    return { average, peakLevel };
   }
 
   async getTicketItems(ticket_id: string, item_id: string) {
@@ -109,6 +234,11 @@ export class QueueService extends BaseDataService<QueueModel> {
     });
   }
 
+  async updateLastNotification(queue_id: string, time: number) {
+    const query = `UPDATE queues SET last_notification = ${time} WHERE id = '${queue_id}'`;
+    this.dataSource.query(query);
+  }
+
   async updateItemQty(item_id: string, qty: number): Promise<void> {
     const query = `UPDATE queue_items SET qty = qty - ${qty} WHERE id = '${item_id}'`;
     this.dataSource.query(query);

src/modules/queue/data/services/ticket.service.ts

@@ -1,8 +1,8 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, UnprocessableEntityException } from '@nestjs/common';
 import { BaseDataService } from 'src/core/modules/data/service/base-data.service';
 import { InjectRepository } from '@nestjs/typeorm';
 import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
-import { Between, In, Repository } from 'typeorm';
+import { Between, In, IsNull, Like, Not, Repository } from 'typeorm';
 import { QueueTicket } from '../../domain/entities/ticket.entity';
 import {
   QueueItemModel,
@@ -11,6 +11,7 @@ import {
 } from '../models/queue.model';
 import { QueueOrder } from '../../domain/entities/order.entity';
 import * as moment from 'moment';
+import { TransactionModel } from 'src/modules/transaction/transaction/data/models/transaction.model';
 
 @Injectable()
 export class TicketDataService extends BaseDataService<QueueTicket> {
@@ -23,6 +24,9 @@ export class TicketDataService extends BaseDataService<QueueTicket> {
 
     @InjectRepository(QueueItemModel, CONNECTION_NAME.DEFAULT)
     private item: Repository<QueueItemModel>,
+
+    @InjectRepository(TransactionModel, CONNECTION_NAME.DEFAULT)
+    private transaction: Repository<TransactionModel>,
   ) {
     super(repo);
   }
@@ -31,10 +35,63 @@ export class TicketDataService extends BaseDataService<QueueTicket> {
     return await this.order.save(order);
   }
 
+  async updateQueueTicket(ticket: QueueTicket): Promise<QueueTicketModel> {
+    return await this.repo.save(ticket);
+  }
+
   async loginQueue(id: string): Promise<QueueOrder> {
-    return this.order.findOneOrFail({
+    const order = await this.order.findOne({
       relations: ['tickets'],
-      where: [{ transaction_id: id }, { code: id }],
+      where: [
+        { transaction_id: id },
+        { code: id, transaction_id: Not(IsNull()) },
+      ],
+    });
+
+    if (!order) {
+      const { customer_name, customer_phone } =
+        await this.transaction.findOneOrFail({
+          where: {
+            id,
+          },
+        });
+
+      const start = moment().startOf('day').valueOf();
+      const end = moment().endOf('day').valueOf();
+      const order = this.order.findOneOrFail({
+        relations: ['tickets'],
+        where: {
+          customer: customer_name,
+          phone: customer_phone,
+          date: Between(start, end),
+        },
+      });
+
+      return order;
+    }
+
+    return order;
+  }
+
+  async ticketByCode(code: string): Promise<QueueTicketModel[]> {
+    return this.repo.find({
+      where: {
+        code: Like(`${code}%`),
+      },
+    });
+  }
+
+  async ticketByUser(user: string, phone: string): Promise<QueueTicket> {
+    const start = moment().startOf('day').valueOf();
+    const end = moment().endOf('day').valueOf();
+
+    return this.repo.findOne({
+      relations: ['items'],
+      where: {
+        customer: user,
+        phone: phone,
+        date: Between(start, end),
+      },
     });
   }
 
@@ -89,8 +146,12 @@ export class TicketDataService extends BaseDataService<QueueTicket> {
   }
 
   async deleteQueue(transaction_id: string): Promise<void> {
-    const transactions = await this.transactions(transaction_id);
-    await this.order.remove(transactions);
+    try {
+      const transactions = await this.transactions(transaction_id);
+      await this.order.remove(transactions);
+    } catch (error) {
+      console.log('transaction not found');
+    }
   }
 
   async orderIds(order_id: string): Promise<string[]> {
@@ -104,17 +165,23 @@ export class TicketDataService extends BaseDataService<QueueTicket> {
     item_ids: string[],
   ): Promise<QueueOrderModel> {
     const order = await this.orderIds(order_id);
-    return this.order.findOneOrFail({
-      relations: ['tickets', 'tickets.items'],
-      where: {
-        tickets: {
-          order_id: In(order),
-          items: {
-            id: In(item_ids),
+    try {
+      const ticket = await this.order.findOneOrFail({
+        relations: ['tickets', 'tickets.items'],
+        where: {
+          tickets: {
+            order_id: In(order),
+            items: {
+              id: In(item_ids),
+            },
           },
         },
-      },
-    });
+      });
+
+      return ticket;
+    } catch (error) {
+      throw new UnprocessableEntityException('Ticket tidak dapat ditemukan');
+    }
   }
 
   async queuePosTickets(order_id: string): Promise<QueueTicketModel[]> {
@@ -149,6 +216,23 @@ export class TicketDataService extends BaseDataService<QueueTicket> {
     });
   }
 
+  async queueUniqueTickets(order_id: string): Promise<QueueTicketModel[]> {
+    const start = moment().startOf('day').valueOf();
+    const end = moment().endOf('day').valueOf();
+    return this.repo.find({
+      relations: [
+        'items',
+        'items.queue',
+        'items.item',
+        'items.item.item_queue',
+      ],
+      where: {
+        order_id: order_id,
+        date: Between(start, end),
+      },
+    });
+  }
+
   async queueTicketItems(
     order_id: string,
     ticket_id: string,

src/modules/queue/domain/entities/queue-item.entity.ts

@@ -13,6 +13,7 @@ export interface QueueItem extends BaseCoreEntity {
 export interface MergedItemQueue extends BaseCoreEntity {
   id: string;
   queue_item_id: string;
+  item_id: string;
   title: string;
   image_url: string;
   qty: number;

src/modules/queue/domain/helpers/time.helper.ts

@@ -9,3 +9,15 @@ export function toTime(timestamp: number): string {
     minutes < 10 ? '0' : ''
   }${minutes}`;
 }
+
+export function phoneNumberOnly(phone: string): string {
+  return phone.replace(/[^0-9]/g, '');
+}
+
+export function timeIsBefore(
+  currentTime: number,
+  time: number,
+  diffInMilliseconds: number,
+): boolean {
+  return time < currentTime + diffInMilliseconds;
+}

src/modules/queue/domain/queue-admin.orchestrator.ts

@@ -4,11 +4,19 @@ import { IndexQueueManager } from './usecases/index-queue.manager';
 import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
 import { Queue } from './entities/queue.entity';
 import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
-import { CallQueueManager } from './usecases/call-queue.manager';
+import {
+  CallQueueManager,
+  DoneQueueManager,
+} from './usecases/call-queue.manager';
 import {
   ORDER_TYPE,
   QUEUE_STATUS,
 } from 'src/core/strings/constants/base.constants';
+import { QueueTimeFormula } from './usecases/formula/queue-time.formula';
+import * as moment from 'moment';
+import { timeIsBefore } from './helpers/time.helper';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+import { WhatsappQueue } from 'src/services/whatsapp/entity/whatsapp-queue.entity';
 
 @Injectable()
 export class QueueAdminOrchestrator {
@@ -17,6 +25,8 @@ export class QueueAdminOrchestrator {
     private readonly service: QueueService,
     private indexManager: IndexQueueManager,
     private callManager: CallQueueManager,
+    private doneManager: DoneQueueManager,
+    private readonly queueTimeFormula: QueueTimeFormula,
   ) {}
 
   async index(params): Promise<PaginationResponse<Queue>> {
@@ -32,4 +42,60 @@ export class QueueAdminOrchestrator {
     await this.callManager.execute();
     return this.callManager.getResult();
   }
+
+  async done(dataId): Promise<string> {
+    this.doneManager.setData(dataId, QUEUE_STATUS.DONE);
+    this.doneManager.setService(this.service, TABLE_NAME.QUEUE);
+    await this.doneManager.execute();
+    return this.doneManager.getResult();
+  }
+
+  async job(): Promise<void> {
+    const notification = new WhatsappService();
+    const itemMasters = await this.dataService.allQueue();
+    const currentTime = moment().valueOf();
+
+    for (const queueItem of itemMasters) {
+      const queueTimes = await this.queueTimeFormula.items(queueItem.id);
+      const call_preparation = queueItem.call_preparation * 60 * 1000;
+      if (!queueItem.use_notification) continue;
+
+      for (const queueId in queueTimes) {
+        const callTime = queueTimes[queueId];
+
+        const queueTicket = await this.service.queueTicket(queueId);
+        if (
+          queueItem.requiring_notification ||
+          (timeIsBefore(currentTime, callTime, call_preparation) &&
+            queueTicket.time > currentTime)
+        ) {
+          const payload: WhatsappQueue = {
+            id: queueId,
+            phone: queueTicket.item.ticket.phone,
+            code: queueTicket.code,
+            name: queueTicket.item.ticket.customer,
+            item_name: queueItem.name,
+            time: callTime,
+          };
+
+          // console.table([
+          //   {
+          //     code: queueTicket.code,
+          //     currentTime: toTime(currentTime),
+          //     callTime: toTime(callTime),
+          //     lastNotification: toTime(queueTicket.last_notification),
+          //   },
+          // ]);
+
+          if (
+            queueTicket.item.ticket.phone != null &&
+            queueTicket.last_notification < currentTime - call_preparation
+          ) {
+            await notification.queueProcess(payload);
+            this.service.updateLastNotification(queueId, currentTime);
+          }
+        }
+      }
+    }
+  }
 }

src/modules/queue/domain/queue.orchestrator.ts

@@ -3,6 +3,7 @@ import { TicketDataService } from '../data/services/ticket.service';
 import { QueueOrder } from './entities/order.entity';
 import { Queue } from './entities/queue.entity';
 import {
+  QueueDataService,
   QueueOrderService,
   QueueService,
 } from '../data/services/queue.service';
@@ -21,7 +22,13 @@ import * as moment from 'moment';
 import { CustomerQueueTicketSummaryManager } from './usecases/queue/customer-queue-ticket.manager';
 import { TransactionDataService } from 'src/modules/transaction/transaction/data/services/transaction-data.service';
 import { CustomerQueuePosItemManager } from './usecases/queue/customer-queue-pos-item.manager';
-import { QueueTicketModel } from '../data/models/queue.model';
+import {
+  QueueModel,
+  QueueOrderModel,
+  QueueTicketModel,
+} from '../data/models/queue.model';
+import { CustomerQueueRecommendManager } from './usecases/queue/customer-queue-recommend.manager';
+import { GenerateQueueManager } from './usecases/generate-queue.manager';
 
 @Injectable()
 export class QueueOrchestrator {
@@ -32,11 +39,21 @@ export class QueueOrchestrator {
     private readonly queueOrderService: QueueOrderService,
     private readonly registerQueueManager: RegisterQueueManager,
     private readonly splitQueueManager: SplitQueueManager,
+    private readonly queueDataService: QueueDataService,
+    private readonly generateQueueManager: GenerateQueueManager,
   ) {}
 
+  async generate(data: any): Promise<QueueModel[]> {
+    return await this.generateQueueManager.generate(data);
+  }
+
   async loginCustomer(id: string): Promise<QueueOrder> {
     try {
-      return await this.dataService.loginQueue(id);
+      const order = await this.dataService.loginQueue(id);
+      const code = order.tickets[0].code ?? order.code;
+      const tickets = await this.dataService.ticketByCode(code);
+      order.tickets = tickets;
+      return order;
     } catch (error) {
       throw new UnauthorizedException({
         message: 'Invoice tidak ditemukan',
@@ -49,7 +66,11 @@ export class QueueOrchestrator {
     const { name, phone } = login;
     const now = moment().format('DD/MM/YYYY');
     try {
-      return await this.dataService.loginPhone(name, phone);
+      const order = await this.dataService.loginPhone(name, phone);
+      const code = order.tickets[0].code ?? order.code;
+      const tickets = await this.dataService.ticketByCode(code);
+      order.tickets = tickets;
+      return order;
     } catch (error) {
       throw new UnauthorizedException({
         message: `Antrian atas nama ${name} dan nomor telepon ${phone} pada tanggal ${now} tidak ditemukan`,
@@ -77,6 +98,32 @@ export class QueueOrchestrator {
     const queueIds = data.items.map((i) => i.queue_item_id);
     const queue = await this.dataService.orderItems(data.order_id, queueIds);
 
+    const existTicket = await this.dataService.ticketByUser(
+      data.name,
+      data.phone,
+    );
+
+    if (existTicket) {
+      const itemTickets = this.itemsFromOrder(queue);
+
+      const items = data.items.map((item) => {
+        const item_id = itemTickets[item.queue_item_id];
+        return {
+          item_queue_id: item_id,
+          item_id: item_id,
+          qty: item.qty,
+        };
+      });
+      existTicket.items.push(...items);
+      await this.dataService.updateQueueTicket(existTicket);
+
+      data.items.forEach((item) => {
+        this.queueService.updateItemQty(item.queue_item_id, item.qty);
+      });
+
+      return queue;
+    }
+
     this.splitQueueManager.setRequestData(data);
     this.splitQueueManager.setData(queue);
     this.splitQueueManager.setService(
@@ -87,6 +134,17 @@ export class QueueOrchestrator {
     return this.splitQueueManager.getResult();
   }
 
+  itemsFromOrder(order: QueueOrderModel) {
+    const itemTickets = {};
+    order.tickets.forEach((ticket) => {
+      ticket.items.forEach((item) => {
+        itemTickets[item.id] = item.item_id;
+      });
+    });
+
+    return itemTickets;
+  }
+
   async queuePOSTickets(order_id: string): Promise<any> {
     const tickets = await this.dataService.queuePosTickets(order_id);
     const manager = new CustomerQueuePosItemManager(tickets);
@@ -128,6 +186,26 @@ export class QueueOrchestrator {
     return manager.data;
   }
 
+  async queueItemRecommendation(order_id: string): Promise<any> {
+    const tickets = await this.dataService.queueTickets(order_id);
+    const queueItemIds = this.getQueueItemFromTickets(tickets);
+    const recommendItems = await this.queueDataService.exclude(queueItemIds);
+    const recommendIds = recommendItems.map((item) => item.id);
+    const queues = await this.queueService.queues(recommendIds);
+    const manager = new CustomerQueueRecommendManager(tickets);
+    manager.currentQueues(queues);
+    return manager.recommend(recommendItems);
+  }
+
+  async queueItemSummary(): Promise<any> {
+    const recommendItems = await this.queueDataService.allQueue();
+    const recommendIds = recommendItems.map((item) => item.id);
+    const queues = await this.queueService.queues(recommendIds);
+    const manager = new CustomerQueueRecommendManager(null);
+    manager.currentQueues(queues);
+    return manager.recommend(recommendItems);
+  }
+
   async queueItems(order_id: string): Promise<any> {
     const tickets = await this.dataService.queueTickets(order_id);
     const queueItemIds = this.getQueueItemFromTickets(tickets);
@@ -137,6 +215,15 @@ export class QueueOrchestrator {
     return manager.data;
   }
 
+  async queueUniqueItems(order_id: string): Promise<any> {
+    const tickets = await this.dataService.queueUniqueTickets(order_id);
+    const queueItemIds = this.getQueueItemFromTickets(tickets);
+    const queues = await this.queueService.queues(queueItemIds);
+    const manager = new CustomerQueueItemListManager(tickets);
+    manager.currentQueues(queues);
+    return manager.data;
+  }
+
   async queueOrderItems(order_id: string): Promise<any> {
     const tickets = await this.dataService.queueTickets(order_id);
     const manager = new CustomerQueueListManager(tickets);

src/modules/queue/domain/usecases/call-queue.manager.ts

@@ -38,3 +38,10 @@ export class CallQueueManager extends BaseUpdateStatusManager<Queue> {
     return [];
   }
 }
+
+@Injectable()
+export class DoneQueueManager extends CallQueueManager {
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+}

src/modules/queue/domain/usecases/formula/queue-condition.formula.ts

@@ -1,6 +1,8 @@
 import { QueueModel } from 'src/modules/queue/data/models/queue.model';
 import { toTime } from '../../helpers/time.helper';
 import * as math from 'mathjs';
+import { QueueTimeFormula } from './queue-time.formula';
+import * as moment from 'moment';
 
 export class QueueCondition {
   private ticketItems = {};
@@ -14,28 +16,69 @@ export class QueueCondition {
 
   condition(item_id: string) {
     const queues: QueueModel[] = this.ticketItems[item_id] ?? [];
-    const time = queues[0];
-    const nearest = time ? toTime(time.time) : 0;
+    const playEstimation = queues[0]?.average ?? 0;
+    const peakLevel = queues[0]?.peak_level ?? 100;
+    const [time, last] = this.queueTime(queues, playEstimation);
+    const nearest = time ? toTime(time) : 0;
+    const lastTime = last ? toTime(last + playEstimation) : 0;
+
+    const queuePeople = this.queuePeople(queues, peakLevel);
 
-    const last = [...queues].pop();
-    const lastTime = last ? toTime(last.time) : 0;
     return {
-      available: queues.length == 0,
+      available: queuePeople == 0,
       average: this.averageTime(queues),
       nearest: nearest,
-      crowded_level: queues.length,
+      crowded_level: queuePeople,
       available_time: lastTime,
     };
   }
 
+  queuePeople(queues: QueueModel[], peakLevel): number {
+    const queue = this.activeQueue(queues);
+    const level = peakLevel / 100;
+    const queuePeople = queue.reduce((acc, q) => {
+      return acc + q.qty;
+    }, 0);
+    return queuePeople * level;
+  }
+
+  activeQueue(queues: QueueModel[]) {
+    return queues.filter((q) => q.status == 'waiting');
+  }
+
+  queueTime(queues: QueueModel[], average = 0): number[] {
+    const calledQueue = queues.filter((q) =>
+      ['called', 'done'].includes(q.status),
+    );
+    const lastCalledQueue = calledQueue[calledQueue.length - 1];
+    const activeQueues = this.activeQueue(queues);
+
+    const queueTimes = QueueTimeFormula.queueTime(
+      activeQueues,
+      lastCalledQueue,
+      average,
+    );
+
+    const queueEstimation = Object.values<number>(queueTimes);
+
+    const first = queueEstimation[0] ?? moment().valueOf();
+    const last = queueEstimation[queueEstimation.length - 1] ?? 0;
+    return [first, last];
+  }
+
   averageTime(queues: QueueModel[]) {
     if (queues.length == 0) return 0;
-    const calledQueue = queues.filter((q) => q.status === 'called');
+    const calledQueue = queues.filter((q) =>
+      ['called', 'done'].includes(q.status),
+    );
+
+    if (calledQueue.length < 1) return 0;
 
     const times = calledQueue.map((queue) => {
-      return queue.call_time - queue.time;
+      return (queue.call_time - queue.time) / 1000;
     });
 
-    return math.sum(times) / times.length;
+    const avg = Math.ceil(math.mean(times));
+    return Math.max(0, avg);
   }
 }

src/modules/queue/domain/usecases/formula/queue-time.formula.ts

@@ -0,0 +1,73 @@
+import { InjectRepository } from '@nestjs/typeorm';
+import { CONNECTION_NAME } from 'src/core/strings/constants/base.constants';
+import { ItemQueueModel } from 'src/modules/item-related/item-queue/data/models/item-queue.model';
+import { QueueDataService } from 'src/modules/queue/data/services/queue.service';
+import { Repository } from 'typeorm';
+import * as moment from 'moment';
+import * as math from 'mathjs';
+import { QueueModel } from 'src/modules/queue/data/models/queue.model';
+
+export class QueueTimeFormula {
+  constructor(
+    private readonly queueDataService: QueueDataService,
+    @InjectRepository(ItemQueueModel, CONNECTION_NAME.DEFAULT)
+    private itemQueueRepo: Repository<ItemQueueModel>,
+  ) {}
+
+  public average = 0;
+
+  async items(item_queue_id: string) {
+    const queues = await this.queueDataService.waitingQueue(item_queue_id);
+    if (queues.length == 0) {
+      return {};
+    }
+
+    const itemQueue = await this.itemQueueRepo.findOne({
+      relations: ['items'],
+      where: {
+        id: item_queue_id,
+      },
+    });
+
+    const times = itemQueue.items.map((item) => item.play_estimation ?? 0);
+    const average = times.length > 0 ? math.mean(times) * 60 * 1000 : 0; // change average minute to milliseconds
+    this.average = Math.floor(average);
+
+    const calledQueue = await this.queueDataService.lastQueue(item_queue_id);
+
+    return QueueTimeFormula.queueTime(queues, calledQueue, average);
+  }
+
+  static queueTime(
+    queues: QueueModel[],
+    lastQueue: QueueModel,
+    average: number,
+  ) {
+    const queueTimes = {};
+    if (queues.length < 1) return queueTimes;
+    const timeNow = moment().valueOf();
+    const lastCall = lastQueue?.call_time ?? timeNow - average;
+
+    const callTime = +lastCall + average;
+    const currentQueueCallTime = timeNow > callTime ? timeNow : callTime;
+
+    queueTimes[queues[0].id] = currentQueueCallTime;
+    let now = currentQueueCallTime;
+
+    for (let i = 1; i < queues.length; i++) {
+      const before = queues[i - 1];
+      // duration will be total qty multiple by average from last queue
+      const duration = before.qty * average;
+
+      const queue = queues[i];
+      // time to call will be now + duration
+      const time = now + duration;
+      queueTimes[queue.id] = time;
+
+      // update now to last call time
+      now = time;
+    }
+
+    return queueTimes;
+  }
+}

src/modules/queue/domain/usecases/generate-queue.manager.ts

@@ -0,0 +1,161 @@
+import { Injectable } from '@nestjs/common';
+import * as moment from 'moment';
+import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { TransactionUserType } from 'src/modules/transaction/transaction/constants';
+import { TransactionItemModel } from 'src/modules/transaction/transaction/data/models/transaction-item.model';
+import { QueueBucketReadService } from '../../data/services/queue-bucket';
+import { QueueService } from '../../data/services/queue.service';
+import { TicketDataService } from '../../data/services/ticket.service';
+import { RegisterQueueDto } from '../../infrastructure/controllers/dto/register-queue.dto';
+import { QueueOrder } from '../entities/order.entity';
+import { QueueItem } from '../entities/queue-item.entity';
+import { QueueTicket } from '../entities/ticket.entity';
+import { QueueTimeFormula } from './formula/queue-time.formula';
+import { RegisterQueueManager } from './register-queue.manager';
+import { TransactionModel } from 'src/modules/transaction/transaction/data/models/transaction.model';
+import { QueueModel } from '../../data/models/queue.model';
+
+@Injectable()
+export class GenerateQueueManager {
+  constructor(
+    private readonly ticketService: TicketDataService,
+    private readonly queueService: QueueService,
+    private readonly bucketService: QueueBucketReadService,
+    private readonly queueTimeFormula: QueueTimeFormula,
+  ) {}
+
+  async generate(transaction: TransactionModel) {
+    const date = transaction.booking_date ?? transaction.invoice_date;
+    const queue_date = moment(date, 'YYYY-MM-DD').unix();
+
+    const { id, customer_name, customer_phone, invoice_code } = transaction;
+
+    const customerOrder = {
+      code: invoice_code,
+      customer: customer_name,
+      phone: customer_phone,
+      date: queue_date * 1000,
+      transaction_id: id,
+    };
+
+    const items = this.generateItems(transaction.items);
+
+    const existTicket = await this.ticketService.ticketByUser(
+      customer_name,
+      customer_phone,
+    );
+
+    const insertTickets: QueueTicket[] = [];
+    if (customer_name && customer_phone && existTicket) {
+      existTicket.items.push(...items);
+      await this.ticketService.updateQueueTicket(existTicket);
+
+      existTicket.items = items;
+      insertTickets.push(existTicket);
+    } else {
+      const ticket: QueueTicket = { ...customerOrder, items };
+      const order: QueueOrder = { ...customerOrder, tickets: [ticket] };
+
+      const queueOrder = await this.ticketService.createQueueOrder(order);
+      insertTickets.push(...queueOrder.tickets);
+    }
+
+    const results: QueueModel[] = [];
+    const vipCustomer =
+      transaction.customer_category?.has_vip_pass ||
+      transaction.customer_type === TransactionUserType.VIP;
+    if (vipCustomer || transaction.creator_counter_no != null) {
+      for (const ticket of insertTickets) {
+        const ticket_id = ticket.id;
+        const items = {};
+
+        ticket.items.forEach((item) => {
+          const item_id = item['item_queue_id'];
+          const currentItem = items[item_id];
+
+          if (currentItem) {
+            currentItem.qty += item.qty;
+          }
+          items[item_id] = currentItem
+            ? currentItem
+            : {
+                item_id,
+                ticket_id,
+                qty: item.qty,
+              };
+        });
+
+        for (const payload of Object.values(items)) {
+          const isVip = vipCustomer || transaction.creator_counter_no == null;
+          const result = await this.create(payload as any, isVip);
+          results.push(result);
+        }
+      }
+    }
+    return results;
+  }
+
+  generateItems(items: TransactionItemModel[]): QueueItem[] {
+    const transactionItems = [];
+
+    items.forEach((item) => {
+      if (item.item.use_queue) {
+        transactionItems.push({
+          item_queue_id: item.item.item_queue_id,
+          item_id: item.item_id,
+          qty: item.qty,
+        });
+      }
+
+      if (item.item.bundling_items.length > 0) {
+        item.item.bundling_items.forEach((bundling_item) => {
+          if (bundling_item.use_queue) {
+            transactionItems.push({
+              item_queue_id: bundling_item.item_queue_id,
+              item_id: bundling_item.id,
+              qty: item.qty,
+            });
+          }
+        });
+      }
+    });
+
+    return this.mergeQueueItems(transactionItems);
+  }
+
+  mergeQueueItems(arr) {
+    const result = {};
+    arr.forEach((item) => {
+      if (result[item.item_id]) {
+        result[item.item_id].qty += item.qty;
+      } else {
+        result[item.item_id] = { ...item };
+      }
+    });
+    return Object.values<QueueItem>(result);
+  }
+
+  async create(data: RegisterQueueDto, isVip = false): Promise<QueueModel> {
+    const queue = await this.queueService.getTicketItems(
+      data.ticket_id,
+      data.item_id,
+    );
+    const queueRequest: any = {
+      qty: data.qty,
+      item_id: queue.id,
+      vip: isVip,
+    };
+    const registerQueueManager = new RegisterQueueManager(
+      this.bucketService,
+      this.queueTimeFormula,
+    );
+    registerQueueManager.setData(queueRequest);
+    registerQueueManager.setService(this.queueService, TABLE_NAME.QUEUE);
+    await registerQueueManager.execute();
+
+    const result = await registerQueueManager.getResult();
+    result.time = null;
+
+    return result;
+  }
+}

src/modules/queue/domain/usecases/index-queue.manager.ts

@@ -8,9 +8,14 @@ import {
 import { Queue } from '../entities/queue.entity';
 import * as moment from 'moment';
 import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
+import { QueueTimeFormula } from './formula/queue-time.formula';
 
 @Injectable()
 export class IndexQueueManager extends BaseIndexManager<Queue> {
+  constructor(private readonly queueTimeFormula: QueueTimeFormula) {
+    super();
+  }
+
   private queueTimes = {};
   async prepareData(): Promise<void> {
     return;
@@ -21,7 +26,7 @@ export class IndexQueueManager extends BaseIndexManager<Queue> {
   }
 
   async afterProcess(): Promise<void> {
-    this.queueTimes = await this.dataService.queueTimes(
+    this.queueTimes = await this.queueTimeFormula.items(
       this.filterParam.queue_id,
     );
     return;
@@ -43,7 +48,7 @@ export class IndexQueueManager extends BaseIndexManager<Queue> {
       data: result.data.map((queue) => {
         return {
           ...queue,
-          time: this.queueTimes[queue.id],
+          estimation: this.queueTimes[queue.id],
         };
       }),
     };
@@ -84,10 +89,13 @@ export class IndexQueueManager extends BaseIndexManager<Queue> {
 
     console.log({ start, end, item_queue_id: this.filterParam.queue_id });
 
-    queryBuilder.andWhere(`${this.tableName}.time BETWEEN :start AND :end`, {
-      start,
-      end,
-    });
+    queryBuilder.andWhere(
+      `${this.tableName}.created_at BETWEEN :start AND :end`,
+      {
+        start,
+        end,
+      },
+    );
 
     queryBuilder.andWhere(`${this.tableName}.item_queue_id = :item_queue_id`, {
       item_queue_id: this.filterParam.queue_id,

src/modules/queue/domain/usecases/queue/customer-queue-item-list.manager.ts

@@ -6,37 +6,57 @@ import { CustomerQueueManager } from './customer-queue.manager';
 import { QueueCondition } from '../formula/queue-condition.formula';
 
 export class CustomerQueueItemListManager extends CustomerQueueManager {
-  private queues: QueueModel[] = [];
+  protected queues: QueueModel[] = [];
   currentQueues(queues: QueueModel[]) {
     this.queues = queues;
   }
   get data() {
     const tickets = this.tickets;
+    const ticketCount = {};
     const queueCondition = new QueueCondition(this.queues);
 
     const ticketItems = {};
     tickets.forEach((ticket) => {
+      const itemsInTicket = [];
       ticket.items.forEach((item) => {
         const item_id = item.item.item_queue?.id ?? item.item.id;
         const currentItem = ticketItems[item_id];
         ticketItems[item_id] = currentItem ? [...currentItem, item] : [item];
+        itemsInTicket.push(item_id);
+      });
+
+      const uniqueTicket = Array.from(new Set(itemsInTicket));
+
+      uniqueTicket.forEach((item_id) => {
+        ticketCount[item_id] = ticketCount[item_id]
+          ? ticketCount[item_id] + 1
+          : 1;
       });
     });
 
     return Object.values<QueueItemModel[]>(ticketItems).map((items) => {
       const item = items[0];
       const item_qty = items.reduce((acc, item) => acc + item.qty, 0);
+      const queue_qty = this.queueItemQty(items);
       const queueItem = item.item.item_queue ?? item.item;
       return {
         id: queueItem.id,
         queue_item_id: item.id,
         title: queueItem.name,
         image_url: item.item.image_url,
-        qty: item_qty,
+        qty: item_qty - queue_qty,
+        ticket: ticketCount[queueItem.id],
 
         queue_condition: queueCondition.condition(queueItem.id),
         ...queueCondition.condition(queueItem.id),
       };
     });
   }
+
+  protected queueItemQty(queues: QueueItemModel[]) {
+    return queues.reduce(
+      (acc, item) => acc + item.queue.reduce((acc, q) => acc + q.qty, 0),
+      0,
+    );
+  }
 }

src/modules/queue/domain/usecases/queue/customer-queue-list.manager.ts

@@ -1,7 +1,22 @@
-import { QueueItemModel } from 'src/modules/queue/data/models/queue.model';
+import {
+  QueueModel,
+  QueueTicketModel,
+} from 'src/modules/queue/data/models/queue.model';
 import { CustomerQueueManager } from './customer-queue.manager';
 
 export class CustomerQueueListManager extends CustomerQueueManager {
+  private ticketToQueues(tickets: QueueTicketModel[]): QueueModel[] {
+    const ticket = tickets.map((ticket) => {
+      const queue = ticket.items.map((item) => {
+        return item.queue;
+      });
+
+      return queue.flat();
+    });
+
+    return ticket.flat().sort((a, b) => b.time - a.time);
+  }
+
   get data() {
     const tickets = this.tickets;
     const ticketItems = {};
@@ -10,37 +25,56 @@ export class CustomerQueueListManager extends CustomerQueueManager {
       ticket.items.forEach((item) => {
         const item_id = item.item.item_queue?.id ?? item.item.id;
         const currentItem = ticketItems[item_id];
-        item.ticket = ticket;
-        ticketItems[item_id] = currentItem ? [...currentItem, item] : [item];
+        const ticketQueue = { ...ticket, items: [item] };
+
+        ticketItems[item_id] = currentItem
+          ? [...currentItem, ticketQueue]
+          : [ticketQueue];
       });
     });
 
-    return Object.values<QueueItemModel[]>(ticketItems).map((items) => {
-      const item = items[0];
-      const item_qty = items.reduce((acc, item) => acc + item.qty, 0);
-      return {
-        id: item.item_id,
-        title: item.item.item_queue?.name ?? item.item.name,
-        image_url: item.item.image_url,
-        qty: item_qty,
+    return Object.keys(ticketItems)
+      .map((item_id) => {
+        const tickets: QueueTicketModel[] = ticketItems[item_id];
+        const item = tickets[0].items[0];
+        const uniqueTicket = tickets.filter(
+          (obj1, i, arr) => arr.findIndex((obj2) => obj2.id === obj1.id) === i,
+        );
+        let totalQueue = 0;
 
-        items: items.map((item) => {
-          return {
-            code: item.ticket.code,
-            customer: item.ticket.customer,
-            phone: item.ticket.phone,
-            id: item.ticket.id,
-            queue: item.queue.map((q) => {
-              return {
-                code: q.code,
-                qty: q.qty,
-                time: this.toTime(q.time),
-                status: q.status,
-              };
-            }),
-          };
-        }),
-      };
-    });
+        const currentTickets = uniqueTicket.map((ticket) => {
+          const currentTicket = tickets.filter((t) => t.id === ticket.id);
+          const queues = this.ticketToQueues(currentTicket);
+          const currentQueues = queues.map((q) => {
+            return {
+              code: q.code,
+              qty: q.qty,
+              time: this.toTime(q.time),
+              status: q.status,
+            };
+          });
+          totalQueue += currentQueues.length;
+          return currentQueues.length > 0
+            ? {
+                code: ticket.code,
+                customer: ticket.customer,
+                phone: ticket.phone,
+                id: ticket.id,
+                queue: currentQueues,
+              }
+            : null;
+        });
+
+        return currentTickets.filter(Boolean).length > 0
+          ? {
+              id: item.item_id,
+              title: item.item.item_queue?.name ?? item.item.name,
+              image_url: item.item.image_url,
+              qty: totalQueue,
+              items: currentTickets.filter(Boolean),
+            }
+          : null;
+      })
+      .filter(Boolean);
   }
 }

src/modules/queue/domain/usecases/queue/customer-queue-pos-item.manager.ts

@@ -14,7 +14,7 @@ export class CustomerQueuePosItemManager extends CustomerQueueManager {
       items: queueItems.map((item) => {
         return {
           id: item.id,
-          item_queue_id: item.queue_item_id,
+          item_queue_id: item.item_id,
           title: item.title,
           image_url: item.image_url,
           summary: {

src/modules/queue/domain/usecases/queue/customer-queue-recommend.manager.ts

@@ -0,0 +1,21 @@
+import { QueueCondition } from '../formula/queue-condition.formula';
+import { CustomerQueueItemListManager } from './customer-queue-item-list.manager';
+import { ItemQueueModel } from 'src/modules/item-related/item-queue/data/models/item-queue.model';
+
+export class CustomerQueueRecommendManager extends CustomerQueueItemListManager {
+  recommend(items: ItemQueueModel[]) {
+    const queueCondition = new QueueCondition(this.queues);
+
+    return items.map((queueItem) => {
+      const item = queueItem.items[0];
+      return {
+        id: item.id,
+        queue_item_id: queueItem.id,
+        title: queueItem.name,
+        image_url: item.image_url,
+
+        queue_condition: queueCondition.condition(queueItem.id),
+      };
+    });
+  }
+}

src/modules/queue/domain/usecases/queue/customer-queue.manager.ts

@@ -17,7 +17,14 @@ export class CustomerQueueManager {
   }
 
   totalActivities(ticket: QueueTicketModel): number {
-    return ticket.items.length;
+    const ticketItems = {};
+    ticket.items.forEach((item) => {
+      const item_id =
+        item.item?.item_queue?.id ?? item.item?.id ?? item.item_id;
+      const currentItem = ticketItems[item_id];
+      ticketItems[item_id] = currentItem ? [...currentItem, item] : [item];
+    });
+    return Object.keys(ticketItems).length;
   }
 
   totalTickets(ticket: QueueTicketModel): number {
@@ -44,6 +51,7 @@ export class CustomerQueueManager {
       .filter((q) => ['waiting'].includes(q.status))
       .reduce((acc, item) => acc + item.qty, 0);
   }
+
   totalQueueTickets(ticket: QueueTicketModel): number {
     const tickets = ticket.items.map((item) => {
       return this.totalQueueItems(item.queue);
@@ -53,15 +61,27 @@ export class CustomerQueueManager {
     return tickets.reduce(reducer, 0);
   }
 
+  totalQueueItemTickets(ticket: QueueTicketModel): number {
+    const tickets = ticket.items
+      .map((item) => {
+        return this.totalQueueItems(item.queue);
+      })
+      .filter((item) => item > 0);
+
+    return tickets.length;
+  }
+
   summaryTicket(ticket: QueueTicketModel): any {
     const total_tickets = this.totalTickets(ticket);
     const total_used = this.totalUsedTickets(ticket);
     const total_queue = this.totalQueueTickets(ticket);
+    const total_queue_item = this.totalQueueItemTickets(ticket);
     return {
       total_activities: this.totalActivities(ticket),
       total_tickets,
       total_used,
       total_queue,
+      total_queue_item,
       remaining: total_tickets - total_queue,
     };
   }
@@ -86,7 +106,8 @@ export class CustomerQueueManager {
       const queueItem = item.item.item_queue ?? item.item;
       return {
         id: item.item_id,
-        queue_item_id: item.id,
+        queue_item_id: queueItem.id,
+        item_id: item.id,
         title: queueItem.name,
         image_url: item.item.image_url,
         qty: item_qty,

src/modules/queue/domain/usecases/register-queue.manager.ts

@@ -10,23 +10,45 @@ import { QueueItemModel, QueueModel } from '../../data/models/queue.model';
 import { padCode } from 'src/modules/transaction/vip-code/domain/usecases/managers/helpers/generate-random.helper';
 import { QueueBucketReadService } from '../../data/services/queue-bucket';
 import { ItemModel } from 'src/modules/item-related/item/data/models/item.model';
+import { QueueTimeFormula } from './formula/queue-time.formula';
+import { WhatsappService } from 'src/services/whatsapp/whatsapp.service';
+import { WhatsappQueue } from 'src/services/whatsapp/entity/whatsapp-queue.entity';
+import * as moment from 'moment';
 
 @Injectable()
 export class RegisterQueueManager extends BaseCreateManager<QueueModel> {
-  constructor(private readonly bucketService: QueueBucketReadService) {
+  constructor(
+    private readonly bucketService: QueueBucketReadService,
+    private readonly queueTimeFormula: QueueTimeFormula,
+  ) {
     super();
   }
 
+  private currentItemMaster: ItemModel;
+
   async averageTime(): Promise<number> {
     const item = await this.getItemMaster();
     return item.play_estimation;
   }
 
+  async queueTime(queue_id: string): Promise<number[]> {
+    const queueTimes = await this.queueTimeFormula.items(queue_id);
+    const queues = Object.values<number>(queueTimes);
+
+    const first = queues[0];
+    const last = queues[queues.length - 1] ?? moment().valueOf();
+    const average = this.queueTimeFormula.average;
+    return [Math.floor(first), Math.floor(last + average)];
+  }
+
   async beforeProcess(): Promise<void> {
     const vip = this.data.vip ?? false;
     const item = await this.getItemMaster();
+    this.currentItemMaster = item;
+    const [, end] = await this.queueTime(item.item_queue_id);
+
     const queueNumber = await this.bucketService.getQueue(
-      this.data.item_id,
+      item.item_queue_id,
       vip,
     );
     const prefix = vip ? 'B' : 'A';
@@ -34,7 +56,7 @@ export class RegisterQueueManager extends BaseCreateManager<QueueModel> {
 
     Object.assign(this.data, {
       status: STATUS.WAITING,
-      time: new Date().getTime(),
+      time: end,
       item_queue_id: item.item_queue_id,
       vip,
       code,
@@ -44,7 +66,7 @@ export class RegisterQueueManager extends BaseCreateManager<QueueModel> {
 
   async getItemMaster(): Promise<ItemModel> {
     const queueItem: QueueItemModel = await this.dataService.item.findOne({
-      relations: ['item'],
+      relations: ['item', 'item.item_queue'],
       where: {
         id: this.data.item_id,
       },
@@ -54,6 +76,27 @@ export class RegisterQueueManager extends BaseCreateManager<QueueModel> {
   }
 
   async afterProcess(): Promise<void> {
+    const notificationService = new WhatsappService();
+    const item = this.currentItemMaster ?? (await this.getItemMaster());
+
+    if (!item.item_queue.use_notification) return;
+
+    const queueTicket = await this.dataService.queueTicket(this.result.id);
+
+    const payload: WhatsappQueue = {
+      id: this.result.id,
+      phone: queueTicket.item.ticket.phone,
+      code: this.result.code,
+      name: queueTicket.item.ticket.customer,
+      item_name: item.name,
+      time: this.result.time,
+    };
+
+    if (payload.phone) {
+      notificationService.queueRegister(payload);
+      const currentTime = moment().valueOf();
+      this.dataService.updateLastNotification(this.result.id, currentTime);
+    }
     return;
   }
 

src/modules/queue/domain/usecases/split-queue.manager.ts

@@ -1,4 +1,8 @@
-import { Injectable } from '@nestjs/common';
+import {
+  HttpStatus,
+  Injectable,
+  UnprocessableEntityException,
+} from '@nestjs/common';
 import {
   EventTopics,
   columnUniques,
@@ -9,11 +13,15 @@ import { BaseCreateManager } from 'src/core/modules/domain/usecase/managers/base
 import { QueueOrderModel } from '../../data/models/queue.model';
 import { SplitQueueDto } from '../../infrastructure/controllers/dto/split-queue.dto';
 import { QueueService } from '../../data/services/queue.service';
+import { TicketDataService } from '../../data/services/ticket.service';
 
 @Injectable()
 export class SplitQueueManager extends BaseCreateManager<QueueOrderModel> {
   private dto: SplitQueueDto;
-  constructor(private readonly queueService: QueueService) {
+  constructor(
+    private readonly queueService: QueueService,
+    private readonly ticketService: TicketDataService,
+  ) {
     super();
   }
 
@@ -21,7 +29,25 @@ export class SplitQueueManager extends BaseCreateManager<QueueOrderModel> {
     this.dto = dto;
   }
 
-  prepareData(): Promise<void> {
+  async validateProcess(): Promise<void> {
+    await super.validateProcess();
+    const existTickets = await this.ticketService.ticketByUser(
+      this.dto.name,
+      this.dto.phone,
+    );
+    if (existTickets) {
+      throw new UnprocessableEntityException({
+        statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+        code: 20002,
+        message:
+          'Antrian dengan nama dan nomor telepon sudah terdaftar, silahkan gunakan nomor telepon atau nama lain',
+        error: 'QUEUE_ALREADY_EXIST',
+      });
+    }
+  }
+
+  async prepareData(): Promise<void> {
+    const existTickets = await this.ticketService.ticketByCode(this.data.code);
     const { tickets, ...order } = this.data;
     const ticket = tickets[0];
     const items = tickets
@@ -29,6 +55,7 @@ export class SplitQueueManager extends BaseCreateManager<QueueOrderModel> {
         return ticket.items;
       })
       .flat();
+    const postfix = existTickets.length;
     this.data = {
       code: order.code,
       customer: this.dto.name,
@@ -37,7 +64,7 @@ export class SplitQueueManager extends BaseCreateManager<QueueOrderModel> {
       updated_at: new Date().getTime(),
       tickets: [
         {
-          code: `${order.code}-1`,
+          code: `${order.code}-${postfix}`,
           customer: this.dto.name,
           phone: this.dto.phone,
           date: ticket.date,

src/modules/queue/infrastructure/controllers/dto/queue.filter.ts

@@ -1,7 +1,8 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsBoolean, ValidateIf } from 'class-validator';
+import { IsBoolean, IsEnum, ValidateIf } from 'class-validator';
 import { Transform } from 'class-transformer';
 import { FilterQueueEntity } from 'src/modules/queue/domain/entities/filter.entity';
+import { ORDER_TYPE } from 'src/core/strings/constants/base.constants';
 
 export class QueueDto implements FilterQueueEntity {
   @ApiProperty({
@@ -21,4 +22,20 @@ export class QueueDto implements FilterQueueEntity {
   @IsBoolean()
   @ValidateIf((body) => body.vip)
   vip: boolean;
+
+  @ApiProperty({ type: String, required: false })
+  order_by: string;
+
+  @ApiProperty({
+    type: 'string',
+    required: false,
+    description: `Select ("${ORDER_TYPE.ASC}", "${ORDER_TYPE.DESC}")`,
+  })
+  @ValidateIf((body) => body.order_type)
+  @IsEnum(ORDER_TYPE, {
+    message: `order_type must be a valid enum ${JSON.stringify(
+      Object.values(ORDER_TYPE),
+    )}`,
+  })
+  order_type: ORDER_TYPE;
 }

src/modules/queue/infrastructure/controllers/queue-admin.controller.ts

@@ -15,13 +15,14 @@ import { PaginationResponse } from 'src/core/response/domain/ok-response.interfa
 import { Queue } from '../../domain/entities/queue.entity';
 import { QueueDto } from './dto/queue.filter';
 import { Pagination } from 'src/core/response';
-import { Public } from 'src/core/guards';
+import { ExcludePrivilege, Public } from 'src/core/guards';
 import { UserProvider } from 'src/core/sessions';
 
 @ApiTags(`Queue Admin`)
 @Controller(`v1/${MODULE_NAME.QUEUE}-admin`)
 @ApiBearerAuth('JWT')
 @Public(false)
+@ExcludePrivilege()
 export class QueueAdminController {
   constructor(
     private orchestrator: QueueAdminOrchestrator,
@@ -56,4 +57,9 @@ export class QueueAdminController {
   async call(@Param('id') id: string) {
     return await this.orchestrator.call(id);
   }
+
+  @Post('queues/:id/done')
+  async done(@Param('id') id: string) {
+    return await this.orchestrator.done(id);
+  }
 }

src/modules/queue/infrastructure/controllers/queue-job.controller.ts

@@ -0,0 +1,23 @@
+import { Controller, Logger, Post } from '@nestjs/common';
+
+import { MODULE_NAME } from 'src/core/strings/constants/module.constants';
+import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+
+import { QueueAdminOrchestrator } from '../../domain/queue-admin.orchestrator';
+import { Public } from 'src/core/guards';
+// import { Cron } from '@nestjs/schedule';
+
+@ApiTags(`Queue Admin`)
+@Controller(`v1/${MODULE_NAME.QUEUE}-job`)
+@ApiBearerAuth('JWT')
+@Public(true)
+export class QueueJobController {
+  constructor(private orchestrator: QueueAdminOrchestrator) {}
+
+  // @Cron('*/1 * * * *')
+  @Post('queues/notification')
+  async call() {
+    Logger.log('call preparation');
+    return this.orchestrator.job();
+  }
+}

src/modules/queue/infrastructure/controllers/queue.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, Post } from '@nestjs/common';
+import { Body, Controller, Get, Param, Post, Query, Res } from '@nestjs/common';
 
 import { MODULE_NAME } from 'src/core/strings/constants/module.constants';
 import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
@@ -11,6 +11,12 @@ import { RegisterQueueDto } from './dto/register-queue.dto';
 import { SplitQueueDto } from './dto/split-queue.dto';
 import { LoginQueueDto } from './dto/login-queue.dto';
 import { LoginReceiptDto } from './dto/login-receipt.dto';
+import { mappingRevertTransaction } from 'src/modules/transaction/transaction/domain/usecases/managers/helpers/mapping-transaction.helper';
+import { TransactionType } from 'src/modules/transaction/transaction/constants';
+import { QueueModel } from '../../data/models/queue.model';
+
+import * as Gtts from 'gtts';
+import { Response } from 'express';
 
 @ApiTags(`Queue`)
 @Controller(`v1/${MODULE_NAME.QUEUE}`)
@@ -19,6 +25,12 @@ import { LoginReceiptDto } from './dto/login-receipt.dto';
 export class QueueController {
   constructor(private orchestrator: QueueOrchestrator) {}
 
+  @Post('generate')
+  async generateQueue(@Body() data: any): Promise<QueueModel[]> {
+    mappingRevertTransaction(data, TransactionType.COUNTER);
+    return await this.orchestrator.generate(data);
+  }
+
   @Post('register')
   async registerQueue(@Body() data: RegisterQueueDto): Promise<Queue> {
     return await this.orchestrator.create(data);
@@ -66,11 +78,26 @@ export class QueueController {
     return await this.orchestrator.queueTicketSummary(id, ticket_id);
   }
 
+  @Get(':id/recommendations')
+  async queueItemRecommends(@Param('id') id: string): Promise<void> {
+    return await this.orchestrator.queueItemRecommendation(id);
+  }
+
+  @Get(':id/queue-summary')
+  async queueItemSummary(): Promise<void> {
+    return await this.orchestrator.queueItemSummary();
+  }
+
   @Get(':id/items')
   async queueItems(@Param('id') id: string): Promise<void> {
     return await this.orchestrator.queueItems(id);
   }
 
+  @Get(':id/unique-items')
+  async queueUniqueItems(@Param('id') id: string): Promise<void> {
+    return await this.orchestrator.queueUniqueItems(id);
+  }
+
   @Get(':id/pos-items')
   async queuePosItems(@Param('id') id: string): Promise<void> {
     return await this.orchestrator.queuePOSTickets(id);
@@ -81,6 +108,15 @@ export class QueueController {
     return await this.orchestrator.queueOrderItems(id);
   }
 
+  @Get('speech')
+  async speech(
+    @Query('text') text: string,
+    @Res() response: Response,
+  ): Promise<void> {
+    const gtts = new Gtts(text, 'id');
+    gtts.stream().pipe(response);
+  }
+
   @Get(':id/items/:item_id')
   async queueItemTickets(
     @Param('id') id: string,

src/modules/queue/infrastructure/handlers/transaction.handler.ts

@@ -4,17 +4,7 @@ import {
   TransactionChangeStatusEvent,
   TransactionCreateQueueEvent,
 } from 'src/modules/transaction/transaction/domain/entities/event/transaction-change-status.event';
-import { TicketDataService } from '../../data/services/ticket.service';
-import { QueueOrder } from '../../domain/entities/order.entity';
-import { QueueTicket } from '../../domain/entities/ticket.entity';
-import { QueueItem } from '../../domain/entities/queue-item.entity';
-import * as moment from 'moment';
-import { TransactionUserType } from 'src/modules/transaction/transaction/constants';
-import { RegisterQueueManager } from '../../domain/usecases/register-queue.manager';
-import { RegisterQueueDto } from '../controllers/dto/register-queue.dto';
-import { QueueService } from '../../data/services/queue.service';
-import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
-import { QueueBucketReadService } from '../../data/services/queue-bucket';
+import { GenerateQueueManager } from '../../domain/usecases/generate-queue.manager';
 
 @EventsHandler(TransactionChangeStatusEvent, TransactionCreateQueueEvent)
 export class QueueTransactionHandler
@@ -22,9 +12,7 @@ export class QueueTransactionHandler
 {
   constructor(
     private readonly dataService: TransactionDataService,
-    private readonly ticketService: TicketDataService,
-    private readonly queueService: QueueService,
-    private readonly bucketService: QueueBucketReadService,
+    private readonly queueGenerateManager: GenerateQueueManager,
   ) {}
 
   async handle(event: TransactionChangeStatusEvent) {
@@ -33,77 +21,21 @@ export class QueueTransactionHandler
     /**
      * If data still in process (not settled) then don't create the queue order
      */
-    if (process_data?.status != 'settled') return;
+    if (process_data?.status != 'settled' || process_data?.pos_number != null)
+      return;
 
     const transaction = await this.dataService.getOneByOptions({
       where: {
         id: event.data.id,
       },
-      relations: ['customer_category', 'items', 'items.item'],
+      relations: [
+        'customer_category',
+        'items',
+        'items.item',
+        'items.item.bundling_items',
+      ],
     });
 
-    const date = transaction.booking_date ?? transaction.invoice_date;
-    const queue_date = moment(date, 'YYYY-MM-DD').unix();
-
-    const { id, customer_name, customer_phone, invoice_code } = transaction;
-
-    const customerOrder = {
-      code: invoice_code,
-      customer: customer_name,
-      phone: customer_phone,
-      date: queue_date * 1000,
-      transaction_id: id,
-    };
-
-    const items = transaction.items
-      .filter((item) => item.item.use_queue)
-      .map<QueueItem>((item) => {
-        return {
-          item_id: item.item_id,
-          qty: item.qty,
-        };
-      });
-
-    const ticket: QueueTicket = { ...customerOrder, items };
-    const order: QueueOrder = { ...customerOrder, tickets: [ticket] };
-
-    const queueOrder = await this.ticketService.createQueueOrder(order);
-    if (
-      transaction.customer_category?.has_vip_pass ||
-      transaction.customer_type === TransactionUserType.VIP
-    ) {
-      queueOrder.tickets.forEach((ticket) => {
-        const ticket_id = ticket.id;
-        ticket.items.forEach((item) => {
-          const item_id = item.item_id;
-
-          for (let i = 0; i < item.qty; i++) {
-            const payload = {
-              item_id,
-              ticket_id,
-              qty: 1,
-            };
-
-            this.create(payload);
-          }
-        });
-      });
-    }
-  }
-
-  async create(data: RegisterQueueDto): Promise<void> {
-    const queue = await this.queueService.getTicketItems(
-      data.ticket_id,
-      data.item_id,
-    );
-    const queueRequest: any = {
-      qty: data.qty,
-      item_id: queue.id,
-      vip: true,
-    };
-    const registerQueueManager = new RegisterQueueManager(this.bucketService);
-    registerQueueManager.setData(queueRequest);
-    registerQueueManager.setService(this.queueService, TABLE_NAME.QUEUE);
-    await registerQueueManager.execute();
+    await this.queueGenerateManager.generate(transaction);
   }
 }

src/modules/queue/queue.module.ts

@@ -26,13 +26,19 @@ import {
 import { QueueAdminController } from './infrastructure/controllers/queue-admin.controller';
 import { QueueAdminOrchestrator } from './domain/queue-admin.orchestrator';
 import { IndexQueueManager } from './domain/usecases/index-queue.manager';
-import { CallQueueManager } from './domain/usecases/call-queue.manager';
+import {
+  CallQueueManager,
+  DoneQueueManager,
+} from './domain/usecases/call-queue.manager';
 import { RegisterQueueManager } from './domain/usecases/register-queue.manager';
 import { QueueBucketModel } from './data/models/queue-bucket.model';
 import { QueueBucketReadService } from './data/services/queue-bucket';
 import { SplitQueueManager } from './domain/usecases/split-queue.manager';
 import { QueueTransactionCancelHandler } from './infrastructure/handlers/cancel-transaction.handler';
 import { ItemQueueModel } from '../item-related/item-queue/data/models/item-queue.model';
+import { QueueTimeFormula } from './domain/usecases/formula/queue-time.formula';
+import { QueueJobController } from './infrastructure/controllers/queue-job.controller';
+import { GenerateQueueManager } from './domain/usecases/generate-queue.manager';
 
 @Module({
   imports: [
@@ -52,7 +58,7 @@ import { ItemQueueModel } from '../item-related/item-queue/data/models/item-queu
     ),
     CqrsModule,
   ],
-  controllers: [QueueController, QueueAdminController],
+  controllers: [QueueController, QueueAdminController, QueueJobController],
   providers: [
     QueueOrchestrator,
     QueueAdminOrchestrator,
@@ -69,8 +75,12 @@ import { ItemQueueModel } from '../item-related/item-queue/data/models/item-queu
 
     IndexQueueManager,
     CallQueueManager,
+    DoneQueueManager,
     RegisterQueueManager,
     SplitQueueManager,
+
+    QueueTimeFormula,
+    GenerateQueueManager,
   ],
 })
 export class QueueModule {}

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

@@ -116,7 +116,7 @@ export function mappingRevertTransaction(data, type) {
     }
 
     Object.assign(data, {
-      id: data.booking_id ?? data._id,
+      id: data.booking_id ?? data._id ?? data.id,
       creator_counter_no: Number(data.pos_number),
       creator_counter_name: data.pos_name,
       settlement_date: new Date(data.created_at),

src/services/whatsapp/entity/whatsapp-queue.entity.ts

@@ -0,0 +1,8 @@
+export interface WhatsappQueue {
+  id: string;
+  phone: string;
+  code: string;
+  name: string;
+  item_name: string;
+  time: number;
+}

src/services/whatsapp/whatsapp.constant.ts

@@ -0,0 +1,14 @@
+export const WHATSAPP_BUSINESS_API_URL =
+  process.env.WHATSAPP_BUSINESS_API_URL ?? 'https://graph.facebook.com/';
+
+export const WHATSAPP_BUSINESS_VERSION =
+  process.env.WHATSAPP_BUSINESS_VERSION ?? 'v21.0';
+
+export const WHATSAPP_BUSINESS_QUEUE_URL =
+  process.env.WHATSAPP_BUSINESS_QUEUE_URL ?? 'auth/login';
+
+export const WHATSAPP_BUSINESS_ACCOUNT_NUMBER_ID =
+  process.env.WHATSAPP_BUSINESS_ACCOUNT_NUMBER_ID ?? '';
+
+export const WHATSAPP_BUSINESS_ACCESS_TOKEN =
+  process.env.WHATSAPP_BUSINESS_ACCESS_TOKEN ?? '';

src/services/whatsapp/whatsapp.helper.ts

@@ -0,0 +1,62 @@
+export function getTextMessageInput(recipient, text) {
+  return JSON.stringify({
+    messaging_product: 'whatsapp',
+    preview_url: false,
+    recipient_type: 'individual',
+    to: recipient,
+    type: 'text',
+    text: {
+      body: text,
+    },
+  });
+}
+
+export function getTemplatedMessageInput(recipient, movie, seats) {
+  return JSON.stringify({
+    messaging_product: 'whatsapp',
+    to: recipient,
+    type: 'template',
+    template: {
+      name: 'sample_movie_ticket_confirmation',
+      language: {
+        code: 'en_US',
+      },
+      components: [
+        {
+          type: 'header',
+          parameters: [
+            {
+              type: 'image',
+              image: {
+                link: movie.thumbnail,
+              },
+            },
+          ],
+        },
+        {
+          type: 'body',
+          parameters: [
+            {
+              type: 'text',
+              text: movie.title,
+            },
+            {
+              type: 'date_time',
+              date_time: {
+                fallback_value: movie.time,
+              },
+            },
+            {
+              type: 'text',
+              text: movie.venue,
+            },
+            {
+              type: 'text',
+              text: seats,
+            },
+          ],
+        },
+      ],
+    },
+  });
+}

src/services/whatsapp/whatsapp.service.ts

@@ -0,0 +1,169 @@
+import {
+  phoneNumberOnly,
+  toTime,
+} from 'src/modules/queue/domain/helpers/time.helper';
+import { WhatsappQueue } from './entity/whatsapp-queue.entity';
+import {
+  WHATSAPP_BUSINESS_ACCESS_TOKEN,
+  WHATSAPP_BUSINESS_ACCOUNT_NUMBER_ID,
+  WHATSAPP_BUSINESS_API_URL,
+  WHATSAPP_BUSINESS_QUEUE_URL,
+  WHATSAPP_BUSINESS_VERSION,
+} from './whatsapp.constant';
+import axios from 'axios';
+import { Logger } from '@nestjs/common';
+import { apm } from 'src/core/apm';
+
+export class WhatsappService {
+  async sendMessage(data) {
+    const config = {
+      method: 'post',
+      url: `${WHATSAPP_BUSINESS_API_URL}/${WHATSAPP_BUSINESS_VERSION}/${WHATSAPP_BUSINESS_ACCOUNT_NUMBER_ID}/messages`,
+      headers: {
+        Authorization: `Bearer ${WHATSAPP_BUSINESS_ACCESS_TOKEN}`,
+        'Content-Type': 'application/json',
+      },
+      data: data,
+    };
+
+    try {
+      const response = await axios(config);
+      return response.data;
+    } catch (error) {
+      Logger.error(error);
+      apm?.captureError(error);
+      return null;
+    }
+  }
+
+  async queueRegister(data: WhatsappQueue) {
+    const queueUrl = `${WHATSAPP_BUSINESS_QUEUE_URL}?id=${data.id}`;
+    const payload = {
+      messaging_product: 'whatsapp',
+      to: phoneNumberOnly(data.phone), // recipient's phone number
+      type: 'template',
+      template: {
+        name: 'queue_created',
+        language: {
+          code: 'id', // language code
+        },
+        components: [
+          {
+            type: 'header',
+            parameters: [
+              {
+                parameter_name: 'queue_code',
+                type: 'text',
+                text: data.code, // replace with queue_code variable
+              },
+            ],
+          },
+          {
+            type: 'body',
+            parameters: [
+              {
+                parameter_name: 'name',
+                type: 'text',
+                text: data.name, // replace with name variable
+              },
+              {
+                parameter_name: 'item_name',
+                type: 'text',
+                text: data.item_name, // replace with item_name variable
+              },
+              {
+                parameter_name: 'queue_code',
+                type: 'text',
+                text: data.code, // replace with queue_code variable
+              },
+              {
+                parameter_name: 'queue_time',
+                type: 'text',
+                text: toTime(data.time), // replace with queue_time variable
+              },
+            ],
+          },
+          {
+            type: 'button',
+            sub_type: 'url',
+            index: '0',
+            parameters: [
+              {
+                type: 'text',
+                text: queueUrl, // replace with dynamic URL
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const response = await this.sendMessage(payload);
+    if (response)
+      Logger.log(
+        `Notification register for ${data.code} send to ${data.phone}`,
+      );
+  }
+
+  async queueProcess(data: WhatsappQueue) {
+    const queueUrl = `${WHATSAPP_BUSINESS_QUEUE_URL}?id=${data.id}`;
+    const payload = {
+      messaging_product: 'whatsapp',
+      to: data.phone, // recipient's phone number
+      type: 'template',
+      template: {
+        name: 'queue_process',
+        language: {
+          code: 'id', // language code
+        },
+        components: [
+          {
+            type: 'header',
+            parameters: [
+              {
+                parameter_name: 'queue_code',
+                type: 'text',
+                text: data.item_name, // replace with queue_code variable
+              },
+            ],
+          },
+          {
+            type: 'body',
+            parameters: [
+              {
+                parameter_name: 'name',
+                type: 'text',
+                text: data.name, // replace with name variable
+              },
+              {
+                parameter_name: 'queue_code',
+                type: 'text',
+                text: data.code, // replace with queue_code variable
+              },
+              {
+                parameter_name: 'queue_time',
+                type: 'text',
+                text: toTime(data.time), // replace with queue_time variable
+              },
+            ],
+          },
+          {
+            type: 'button',
+            sub_type: 'url',
+            index: '0',
+            parameters: [
+              {
+                type: 'text',
+                text: queueUrl, // replace with dynamic URL
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const response = await this.sendMessage(payload);
+    if (response)
+      Logger.log(`Notification process for ${data.code} send to ${data.phone}`);
+  }
+}