feat: create api get privilege menu

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

@@ -33,4 +33,6 @@ export interface FilterTransactionEntity extends BaseFilterEntity {
   invoice_date_to?: Date;
   settlement_date_from?: Date;
   settlement_date_to?: Date;
+  request_refund_date_from?: Date;
+  request_refund_date_to?: Date;
 }

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

@@ -9,14 +9,14 @@ export async function generateInvoiceCodeHelper(dataService) {
   const char = generateRandom(1);
   const number = generateRandom(1, true);
 
-  const invoice_code = await dataService.getOneByOptions({
+  const invoice_code = await dataService.getManyByOptions({
     where: {
       invoice_code: ILike(`%${month_year}%`),
     },
   });
+  const current_number = invoice_code.length + 1;
 
-  return `INV-${month_year}${char}${number}/${invoice_code
+  return `INV-${month_year}${char}${number}/${current_number
-    .count()
     .toString()
     .padStart(5, '0')}`;
 }

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

@@ -81,9 +81,6 @@ export function mappingRevertTransaction(data, type) {
       booking_date: data.created_at,
       settlement_date: data.created_at,
       payment_type: data.payment_type,
-      payment_type_method_id: data.payment_type_bank?._id,
-      payment_type_method_name: data.payment_type_bank?.issuer_name,
-      payment_type_method_number: data.payment_type_bank?.account_number,
       payment_card_information: data.card_information,
       payment_code_reference: data.payment_code,
       discount_code_id: data.discount_code?.id,
@@ -109,7 +106,7 @@ export function mappingRevertTransaction(data, type) {
       data.payment_type_method?.id ?? data.payment_type_bank?.id,
     payment_type_method_number:
       data.payment_type_method?.account_number ??
-      data.payment_type?.account_number,
+      data.payment_type_bank?.account_number,
     payment_type_method_name:
       data.payment_type_method?.issuer_name ??
       data.payment_type_bank?.issuer_name,

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

@@ -6,6 +6,7 @@ import {
   Param,
   RelationParam,
 } from 'src/core/modules/domain/entities/base-filter.entity';
+import { BetweenQueryHelper } from 'src/core/helpers/query/between-query.helper';
 
 @Injectable()
 export class IndexTransactionManager extends BaseIndexManager<TransactionEntity> {
@@ -75,14 +76,43 @@ export class IndexTransactionManager extends BaseIndexManager<TransactionEntity>
       `refund.id`,
       `refund.code`,
       `refund.refund_date`,
+      `refund.request_date`,
     ];
   }
 
   get specificFilter(): Param[] {
     return [
       {
-        cols: `${this.tableName}.name`,
+        cols: `${this.tableName}.invoice_code`,
-        data: this.filterParam.names,
+        data: this.filterParam.invoice_codes,
+      },
+      {
+        cols: `${this.tableName}.type`,
+        data: this.filterParam.types,
+      },
+      {
+        cols: `${this.tableName}.customer_type`,
+        data: this.filterParam.customer_types,
+      },
+      {
+        cols: `${this.tableName}.customer_name`,
+        data: this.filterParam.customer_names,
+      },
+      {
+        cols: `${this.tableName}.payment_type`,
+        data: this.filterParam.payment_types,
+      },
+      {
+        cols: `${this.tableName}.payment_bank`,
+        data: this.filterParam.payment_banks,
+      },
+      {
+        cols: `refund.code`,
+        data: this.filterParam.refund_codes,
+      },
+      {
+        cols: `${this.tableName}.creator_name`,
+        data: this.filterParam.creator_names,
       },
     ];
   }
@@ -90,6 +120,49 @@ export class IndexTransactionManager extends BaseIndexManager<TransactionEntity>
   setQueryFilter(
     queryBuilder: SelectQueryBuilder<TransactionEntity>,
   ): SelectQueryBuilder<TransactionEntity> {
+    if (this.filterParam.booking_date_from) {
+      new BetweenQueryHelper(
+        queryBuilder,
+        this.tableName,
+        'booking_date',
+        this.filterParam.booking_date_from,
+        this.filterParam.booking_date_to,
+        'booking_date',
+      ).getQuery();
+    }
+
+    if (this.filterParam.invoice_date_from) {
+      new BetweenQueryHelper(
+        queryBuilder,
+        this.tableName,
+        'invoice_date',
+        this.filterParam.invoice_date_from,
+        this.filterParam.invoice_date_to,
+        'invoice_date',
+      ).getQuery();
+    }
+
+    if (this.filterParam.settlement_date_from) {
+      new BetweenQueryHelper(
+        queryBuilder,
+        this.tableName,
+        'settlement_date',
+        this.filterParam.settlement_date_from,
+        this.filterParam.settlement_date_to,
+        'settlement_date',
+      ).getQuery();
+    }
+
+    if (this.filterParam.request_refund_date_from) {
+      new BetweenQueryHelper(
+        queryBuilder,
+        this.tableName,
+        'request_refund_date',
+        this.filterParam.request_refund_date_from,
+        this.filterParam.request_refund_date_to,
+        'request_refund',
+      ).getQuery();
+    }
     queryBuilder.andWhere(`${this.tableName}.is_recap_transaction is false`);
     return queryBuilder;
   }

src/modules/user-related/user-privilege/domain/usecases/user-privilege-configuration/managers/menu-user-privilege-configuration.manager.ts

@@ -0,0 +1,125 @@
+import { Injectable } from '@nestjs/common';
+import { UserPrivilegeConfigurationEntity } from '../../../entities/user-privilege-configuration.entity';
+import {
+  Param,
+  RelationParam,
+} from 'src/core/modules/domain/entities/base-filter.entity';
+import { BaseIndexManager } from 'src/core/modules/domain/usecase/managers/base-index.manager';
+import { ORDER_TYPE } from 'src/core/strings/constants/base.constants';
+import { SelectQueryBuilder } from 'typeorm';
+import { FilterMenuUserPrivilegeConfigurationDto } from 'src/modules/user-related/user-privilege/infrastructure/dto/filter-menu-user-privilege-configuration.dto';
+import { mod } from 'mathjs';
+import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
+import { UserRole } from 'src/modules/user-related/user/constants';
+import { UserPrivilegeConfigurationHelper } from '../helpers/generate-user-privilege-configuration.helper';
+
+@Injectable()
+export class MenuUserPrivilegeConfigurationManager extends BaseIndexManager<UserPrivilegeConfigurationEntity> {
+  async prepareData(): Promise<void> {
+    Object.assign(this.filterParam, {
+      order_by: `${this.tableName}.index`,
+      order_type: ORDER_TYPE.ASC,
+      limit: 100,
+    });
+    return;
+  }
+
+  async beforeProcess(): Promise<void> {
+    return;
+  }
+
+  async afterProcess(): Promise<void> {
+    return;
+  }
+
+  get relations(): RelationParam {
+    return {
+      joinRelations: [],
+      selectRelations: [],
+      countRelations: [],
+    };
+  }
+
+  get selects(): string[] {
+    return [];
+  }
+
+  get specificFilter(): Param[] {
+    return [];
+  }
+
+  setQueryFilter(
+    queryBuilder: SelectQueryBuilder<UserPrivilegeConfigurationEntity>,
+  ): SelectQueryBuilder<UserPrivilegeConfigurationEntity> {
+    if (this.filterParam.modules) {
+      queryBuilder.andWhere('module In (:...modules)', {
+        modules: this.filterParam.modules,
+      });
+    }
+
+    if (this.filterParam.menus) {
+      queryBuilder.andWhere('menu In (:...menus)', {
+        menus: this.filterParam.menus,
+      });
+    }
+
+    queryBuilder.andWhere('user_privilege_id = :user_privilege_id', {
+      user_privilege_id: this.userProvider.user.user_privilege_id,
+    });
+
+    queryBuilder.andWhere('view = :view', {
+      view: true,
+    });
+
+    return queryBuilder;
+  }
+
+  getMenuSuperAdmin(params: FilterMenuUserPrivilegeConfigurationDto) {
+    const modules = params?.modules ?? [];
+    const menus = params?.menus ?? [];
+    let configs = UserPrivilegeConfigurationHelper.createConfigurations();
+
+    if (modules.length > 0) {
+      configs = configs.filter((item) => modules.includes(item.module));
+    }
+
+    if (menus.length > 0) {
+      configs = configs.filter((item) => menus.includes(item.menu));
+    }
+
+    const newResult = configs.map((item) => {
+      const newItem = item;
+
+      item.actions?.forEach((element) => {
+        item[element] = true;
+      });
+
+      newItem.actions = undefined;
+
+      const cleanData = Object.entries(newItem)
+        .filter(([key, value]) => value !== undefined)
+        .reduce((obj, [key, value]) => {
+          obj[key] = value;
+          return obj;
+        }, {});
+
+      return cleanData;
+    });
+
+    return newResult as any;
+  }
+
+  getResult(): PaginationResponse<UserPrivilegeConfigurationEntity> {
+    const role = this.userProvider.user.role;
+    const isSuperAdmin = role === UserRole.SUPERADMIN;
+
+    if (isSuperAdmin) {
+      return {
+        data: this.getMenuSuperAdmin(this.filterParam),
+        total: 100,
+      };
+    }
+
+    return this.result;
+  }
+}

src/modules/user-related/user-privilege/domain/usecases/user-privilege-configuration/user-privilege-configuration-data.orchestrator.ts

@@ -5,12 +5,14 @@ import { UserPrivilegeConfigurationService } from '../../../data/service/user-pr
 import { IndexUserPrivilegeConfigurationManager } from './managers/index-user-privilege-configuration.manager';
 import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
 import { TABLE_NAME } from 'src/core/strings/constants/table.constants';
+import { MenuUserPrivilegeConfigurationManager } from './managers/menu-user-privilege-configuration.manager';
 
 @Injectable()
 export class UserPrivilegeConfigurationDataOrchestrator {
   constructor(
     private updateManager: UpdateUserPrivilegeConfigurationManager,
     private indexManager: IndexUserPrivilegeConfigurationManager,
+    private privilegeMenuManager: MenuUserPrivilegeConfigurationManager,
     private serviceData: UserPrivilegeConfigurationService,
   ) {}
 
@@ -35,4 +37,21 @@ export class UserPrivilegeConfigurationDataOrchestrator {
     await this.indexManager.execute();
     return this.indexManager.getResult();
   }
+
+  async privilegeMenu(
+    params,
+  ): Promise<PaginationResponse<UserPrivilegeConfigurationEntity>> {
+    this.privilegeMenuManager.setFilterParam({
+      page: 1,
+      limit: 100,
+      ...(params ?? {}),
+    });
+
+    this.privilegeMenuManager.setService(
+      this.serviceData,
+      TABLE_NAME.USER_PRIVILEGE_CONFIGURATION,
+    );
+    await this.privilegeMenuManager.execute();
+    return this.privilegeMenuManager.getResult();
+  }
 }

src/modules/user-related/user-privilege/infrastructure/dto/filter-menu-user-privilege-configuration.dto.ts

@@ -0,0 +1,16 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Transform } from 'class-transformer';
+
+export class FilterMenuUserPrivilegeConfigurationDto {
+  @ApiProperty({ type: ['string'], required: false })
+  @Transform((body) => {
+    return Array.isArray(body.value) ? body.value : [body.value];
+  })
+  modules: string[];
+
+  @ApiProperty({ type: ['string'], required: false })
+  @Transform((body) => {
+    return Array.isArray(body.value) ? body.value : [body.value];
+  })
+  menus: string[];
+}

src/modules/user-related/user-privilege/infrastructure/user-privilege-configuration.controller.ts

@@ -1,6 +1,6 @@
 import { Body, Controller, Get, Param, Put, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
-import { Public } from 'src/core/guards';
+import { ExcludePrivilege, Public } from 'src/core/guards';
 import { MODULE_NAME } from 'src/core/strings/constants/module.constants';
 import { UserPrivilegeConfigurationDataOrchestrator } from '../domain/usecases/user-privilege-configuration/user-privilege-configuration-data.orchestrator';
 import { UserPrivilegeConfigurationDto } from './dto/user-privilege-configuration.dto';
@@ -8,6 +8,7 @@ import { UserPrivilegeConfigurationEntity } from '../domain/entities/user-privil
 import { FilterUserPrivilegeConfigurationDto } from './dto/filter-user-privilege-configuration.dto';
 import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
 import { Pagination } from 'src/core/response';
+import { FilterMenuUserPrivilegeConfigurationDto } from './dto/filter-menu-user-privilege-configuration.dto';
 
 @ApiTags(
   `${MODULE_NAME.USER_PRIVILEGE_CONFIGURATION.split('-').join(' ')} - data`,
@@ -34,4 +35,12 @@ export class UserPrivilegeConfigurationController {
   ): Promise<PaginationResponse<UserPrivilegeConfigurationEntity>> {
     return await this.orchestrator.index(params);
   }
+
+  @Get('/menu')
+  @ExcludePrivilege()
+  async privilegeMenu(
+    @Query() params: FilterMenuUserPrivilegeConfigurationDto,
+  ): Promise<UserPrivilegeConfigurationEntity[]> {
+    return (await this.orchestrator.privilegeMenu(params)).data ?? [];
+  }
 }

src/modules/user-related/user-privilege/user-privilege.module.ts

@@ -27,6 +27,7 @@ import { UserPrivilegeConfigurationController } from './infrastructure/user-priv
 import { UserPrivilegeConfigurationDataOrchestrator } from './domain/usecases/user-privilege-configuration/user-privilege-configuration-data.orchestrator';
 import { IndexUserPrivilegeConfigurationManager } from './domain/usecases/user-privilege-configuration/managers/index-user-privilege-configuration.manager';
 import { UserPrivilegeModels } from './constants';
+import { MenuUserPrivilegeConfigurationManager } from './domain/usecases/user-privilege-configuration/managers/menu-user-privilege-configuration.manager';
 
 @Module({
   imports: [
@@ -55,6 +56,7 @@ import { UserPrivilegeModels } from './constants';
 
     IndexUserPrivilegeConfigurationManager,
     UpdateUserPrivilegeConfigurationManager,
+    MenuUserPrivilegeConfigurationManager,
 
     UserPrivilegeDataService,
     UserPrivilegeReadService,