feat(SPG-123) Abstraction Transaction Data

src/core/helpers/query/check-duplicate.helpers.ts

@@ -0,0 +1,41 @@
+import { HttpStatus, UnprocessableEntityException } from '@nestjs/common';
+import { BaseDataService } from 'src/core/modules/data/service/base-data.service';
+
+export class CheckDuplicateHelper {
+  constructor(
+    private dataService: BaseDataService<any>,
+    private duplicateColumn: string[],
+    private entity: any,
+    private entityId?: string,
+  ) {}
+
+  async execute() {
+    for (const column of this.duplicateColumn) {
+      const queryBuilder = this.dataService
+        .getRepository()
+        .createQueryBuilder();
+      queryBuilder.orWhere(
+        `replace(trim(lower(${column})), '  ',' ') = :query`,
+        {
+          query: this.entity[column]
+            ?.toLowerCase()
+            .trim()
+            .replace(/ +(?= )/g, ''),
+        },
+      );
+
+      if (this.entityId) {
+        queryBuilder.andWhere(`id Not In ('${this.entityId}')`);
+      }
+
+      const data_exists = await queryBuilder.getCount();
+      if (data_exists > 0) {
+        throw new UnprocessableEntityException({
+          statusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+          message: `Entity with ${column} : ${this.entity[column]} already exist`,
+          error: 'Unprocessable Entity',
+        });
+      }
+    }
+  }
+}

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

@@ -1,8 +1,4 @@
-import {
+import { Inject, Injectable, Logger } from '@nestjs/common';
-  Inject,
-  Injectable,
-  Logger,
-} from '@nestjs/common';
 import { EventBus } from '@nestjs/cqrs';
 import { UserProvider, UsersSession } from 'src/core/sessions';
 import { BLANK_USER } from 'src/core/strings/constants/base.constants';

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

@@ -1,10 +1,11 @@
+import { CheckDuplicateHelper } from 'src/core/helpers/query/check-duplicate.helpers';
 import { BaseManager } from '../base.manager';
-import { Injectable } from '@nestjs/common';
 
 export abstract class BaseCreateManager<Entity> extends BaseManager {
   protected result: Entity;
   protected duplicateColumn: string[];
   abstract get entityTarget(): any;
+  abstract get uniqueColumns(): string[];
 
   setData(entity: Entity): void {
     this.data = entity;
@@ -19,6 +20,17 @@ export abstract class BaseCreateManager<Entity> extends BaseManager {
     });
   }
 
+  async validateProcess(): Promise<void> {
+    if (this.uniqueColumns.length) {
+      await new CheckDuplicateHelper(
+        this.dataService,
+        this.uniqueColumns,
+        this.data,
+      ).execute();
+    }
+    return;
+  }
+
   async process(): Promise<void> {
     this.result = await this.dataService.create(
       this.queryRunner,

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

@@ -0,0 +1,21 @@
+import { BaseManager } from '../base.manager';
+
+export abstract class BaseCustomManager<Entity> extends BaseManager {
+  protected result: Entity;
+  abstract get entityTarget(): any;
+
+  setData(entity: Entity): void {
+    this.data = entity;
+  }
+
+  async prepareData(): Promise<void> {
+    if (this.data)
+      Object.assign(this.data, {
+        editor_id: this.user.id,
+        editor_name: this.user.name,
+        updated_at: new Date().getTime(),
+      });
+  }
+
+  abstract getResult(): any;
+}

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

@@ -1,8 +1,4 @@
-import {
+import { HttpStatus, UnprocessableEntityException } from '@nestjs/common';
-  HttpStatus,
-  Injectable,
-  UnprocessableEntityException,
-} from '@nestjs/common';
 import { BaseManager } from '../base.manager';
 
 export abstract class BaseDeleteManager<Entity> extends BaseManager {

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

@@ -1,24 +1,23 @@
-import { BaseReadManager } from "../base-read.manager";
+import { BaseReadManager } from '../base-read.manager';
 
 export abstract class BaseDetailManager<Entity> extends BaseReadManager {
+  protected dataId: string;
+  protected result: Entity;
 
-    protected dataId: string;
+  abstract get selectData(): string[];
-    protected result: Entity;
+  abstract get relationData(): string[];
+  abstract get setFindProperties(): any;
 
-    abstract get selectData(): string[];
+  setData(dataId: string): void {
-    abstract get relationData(): string[];
+    this.dataId = dataId;
-    abstract get setFindProperties(): any;
+  }
 
-    setData(dataId: string): void {
+  async process(): Promise<void> {
-        this.dataId = dataId;
+    this.queryBuilder.select(this.selectData).where(this.setFindProperties);
-    }
+    this.result = await this.queryBuilder.getOne();
+  }
 
-    async process(): Promise<void> {
+  getResult(): Entity {
-        this.queryBuilder.select(this.selectData).where(this.setFindProperties);
+    return this.result;
-        this.result = await this.queryBuilder.getOne();
+  }
-    }
-
-    getResult(): Entity {
-        return this.result;
-    }
 }

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

@@ -1,54 +1,57 @@
-import { PaginationResponse } from "src/core/response/domain/ok-response.interface";
+import { PaginationResponse } from 'src/core/response/domain/ok-response.interface';
-import { BaseReadManager } from "../base-read.manager";
+import { BaseReadManager } from '../base-read.manager';
-import { SelectQueryBuilder } from "typeorm";
+import { SelectQueryBuilder } from 'typeorm';
-import { BaseFilterEntity } from "../../entities/base-filter.entity";
+import {
-import { Param, SpecificSearchFilter } from "src/core/helpers/query/specific-search.helper";
+  Param,
+  SpecificSearchFilter,
+} from 'src/core/helpers/query/specific-search.helper';
 
 export abstract class BaseIndexManager<Entity> extends BaseReadManager {
+  protected result: PaginationResponse<Entity>;
+  public filterParam: any;
+  abstract get specificFilter(): Param[];
 
-    protected result: PaginationResponse<Entity>;
+  setFilterParam(param: any): void {
-    public filterParam: BaseFilterEntity;
+    this.filterParam = param;
-    abstract get specificFilter(): Param[];
+  }
 
-    setFilterParam(param: BaseFilterEntity): void {
+  async process(): Promise<void> {
-        this.filterParam = param;
+    // const filterSearch: string[] = this.setFilterSearch();
-    }
 
-    async process(): Promise<void> {
+    // this.queryBuilder.andWhere(
-        // const filterSearch: string[] = this.setFilterSearch();
+    //   new Brackets((qb) => {
+    //     filterSearch.map((fSearch) => {
+    //       qb.orWhere(`${fSearch} ILIKE :query`, {
+    //         query: `%${
+    //           this.filterParam.q.trim().replace(/\s+/g, ' ') ?? ''
+    //         }%`,
+    //       });
+    //     });
+    //   }),
+    // );
 
-        // this.queryBuilder.andWhere(
+    // new SpecificSearchFilter<Entity>(
-        //   new Brackets((qb) => {
+    //   this.queryBuilder,
-        //     filterSearch.map((fSearch) => {
+    //   this.tableName,
-        //       qb.orWhere(`${fSearch} ILIKE :query`, {
+    //   this.specificFilter,
-        //         query: `%${
+    // ).getFilter();
-        //           this.filterParam.q.trim().replace(/\s+/g, ' ') ?? ''
+    this.setQueryFilter(this.queryBuilder);
-        //         }%`,
-        //       });
-        //     });
-        //   }),
-        // );
 
-        new SpecificSearchFilter<Entity>(this.queryBuilder, this.tableName, this.specificFilter).getFilter();
+    this.result = await this.dataService.getIndex(
-        this.setQueryFilter(this.queryBuilder);
+      this.queryBuilder,
+      this.filterParam,
+    );
+  }
 
-        this.result = await this.dataService.getIndex(
+  setFilterSearch(): string[] {
-            this.queryBuilder,
+    return [];
-            this.filterParam,
+  }
-        );
-    }
 
+  abstract setQueryFilter(
+    queryBuilder: SelectQueryBuilder<Entity>,
+  ): SelectQueryBuilder<Entity>;
 
-    setFilterSearch(): string[] {
+  getResult(): PaginationResponse<Entity> {
-        return [];
+    return this.result;
-    }
+  }
-        
-    abstract setQueryFilter(
-        queryBuilder: SelectQueryBuilder<Entity>,
-    ): SelectQueryBuilder<Entity>;
-    
-    
-    getResult(): PaginationResponse<Entity> {
-        return this.result;
-    }
 }

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

@@ -1,6 +1,6 @@
 import { BaseManager } from '../base.manager';
 import { STATUS } from 'src/core/strings/constants/base.constants';
-import { UserPrivilegeModel } from 'src/modules/user-related/user-privilege/data/model/user-privilege.model';
+import { UserPrivilegeModel } from 'src/modules/user-related/user-privilege/data/models/user-privilege.model';
 
 export abstract class BaseUpdateStatusManager<Entity> extends BaseManager {
   protected dataId: string;

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { CheckDuplicateHelper } from 'src/core/helpers/query/check-duplicate.helpers';
 import { BaseManager } from '../base.manager';
 
 export abstract class BaseUpdateManager<Entity> extends BaseManager {
@@ -6,6 +6,7 @@ export abstract class BaseUpdateManager<Entity> extends BaseManager {
   protected result: Entity;
   protected duplicateColumn: string[];
   abstract get entityTarget(): any;
+  abstract get uniqueColumns(): string[];
 
   setData(id: string, entity: Entity): void {
     this.dataId = id;
@@ -18,6 +19,15 @@ export abstract class BaseUpdateManager<Entity> extends BaseManager {
       editor_name: this.user.name,
       updated_at: new Date().getTime(),
     });
+
+    if (this.uniqueColumns.length) {
+      await new CheckDuplicateHelper(
+        this.dataService,
+        this.uniqueColumns,
+        this.data,
+        this.dataId,
+      ).execute();
+    }
   }
 
   async process(): Promise<void> {