rez_core 7.1.1 → 7.1.2

package/src/module/listmaster/repository/list-master-items.repository.ts

@@ -1,262 +1,261 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, In, Raw, Or, And, FindOptionsWhere } from 'typeorm';
-import { ListMasterItems } from '../entity/list-master-items.entity';
-import { ListMasterData } from '../entity/list-master.entity';
-
-@Injectable()
-export class ListMasterItemsRepository {
-  constructor(
-    @InjectRepository(ListMasterItems)
-    private repo: Repository<ListMasterItems>,
-  ) {
-  }
-
-  async create(item: Partial<ListMasterItems>) {
-    const newItem = this.repo.create(item);
-    return this.repo.save(newItem);
-  }
-
-  async update(id: number, item: Partial<ListMasterItems>) {
-    await this.repo.update(id, item);
-    return this.repo.findOne({ where: { id } });
-  }
-
-  async findItemsByType(
-    type: string,
-    sort_by?,
-    storage_type?,
-    enterprise_id?: number,
-    params?: Record<string, string>,
-    values?: any[],
-    inactiveIds?: number[],
-  ) {
-    let orderBy: Record<string, 'ASC' | 'DESC'> = {};
-
-    if (values?.length) {
-      if (storage_type === 'code') {
-        const itemValues = await this.repo.find({
-          where: {
-            listtype: type,
-            code: In(values),
-          },
-          order: orderBy,
-        });
-
-        const itemsMapped = itemValues.map((i) => ({
-          label: `${i.name}`,
-          value: String(i.code),
-        }));
-
-        return [...itemsMapped];
-      } else {
-        const itemValues = await this.repo.find({
-          where: {
-            listtype: type,
-            id: In(values),
-          },
-          order: orderBy,
-        });
-
-        const itemsMapped = itemValues.map((i) => ({
-          label: `${i.name}`,
-          value: String(i.id),
-        }));
-
-        return [...itemsMapped];
-      }
-    }
-
-
-    // Initial where clause
-    const whereClause: any = {
-      listtype: type,
-      enterprise_id: enterprise_id,
-      status: 'ACTIVE',
-    };
-
-    // Helper to check numeric
-    const isNumeric = (value: any) => !isNaN(Number(value));
-
-    // Sorting logic
-    if (sort_by && isNumeric(sort_by)) {
-      const listMasterItem = await this.repo.findOne({
-        where: { id: Number(sort_by) },
-      });
-
-      const sortValue = listMasterItem?.value?.toLowerCase();
-
-      if (sortValue) {
-        switch (sortValue) {
-          case 'az':
-            orderBy = { name: 'ASC' };
-            break;
-          case 'za':
-            orderBy = { name: 'DESC' };
-            break;
-          case 'custom':
-            orderBy = { sortindex: 'ASC' };
-            break;
-        }
-      }
-    }
-
-    // Handle parent_code logic
-    if (params?.parent && isNumeric(params.parent)) {
-      const parentItem = await this.repo.findOne({
-        where: { id: Number(params.parent) },
-      });
-
-      if (parentItem?.code) {
-        whereClause.parent_code = parentItem.code;
-      }
-    }
-
-    // Fetch active items
-    const items = await this.repo.find({
-      where: whereClause,
-      order: orderBy,
-    });
-
-
-    let result = items.map((i) => ({
-      label: i.name,
-      value: storage_type === 'code' ? i.code : String(i.id),
-    }));
-
-
-    // Handle inactive items if specified
-    if (inactiveIds?.length) {
-      if (storage_type === 'code') {
-        const inactiveItems = await this.repo.find({
-          where: {
-            listtype: type,
-            enterprise_id: enterprise_id,
-            code: In(inactiveIds),
-          },
-          order: orderBy,
-        });
-
-        const inactiveMapped = inactiveItems.map((i) => ({
-          label: `${i.name} [INACTIVE]`,
-          value: String(i.code),
-        }));
-
-        result = [...result, ...inactiveMapped];
-      } else {
-        const inactiveItems = await this.repo.find({
-          where: {
-            listtype: type,
-            // enterprise_id: enterprise_id,
-            id: In(inactiveIds),
-          },
-          order: orderBy,
-        });
-
-        const inactiveMapped = inactiveItems.map((i) => ({
-          label: `${i.name} [INACTIVE]`,
-          value: String(i.id),
-        }));
-
-        result = [...result, ...inactiveMapped];
-      }
-    }
-
-    return result;
-  }
-
-  async findOperatorsByType(type: string, enterprise_id?: number) {
-    const items = await this.repo.find({
-      where: {
-        listtype: type,
-        enterprise_id: enterprise_id,
-        status: 'ACTIVE',
-      },
-      order: { sortindex: 'ASC' },
-    });
-    return items.map((i) => ({ label: i.name, value: i.value }));
-  }
-
-  async findItemByCode(
-    code: string,
-    enterprise_id?: number,
-  ): Promise<ListMasterItems | null> {
-    return this.repo.findOne({
-      where: {
-        code: code,
-        enterprise_id: enterprise_id,
-      },
-    });
-  }
-
-  async findAllItemsByListType(
-    type: string,
-    sortBy: string,
-    enterprise_id: number,
-    search?: string,
-  ) {
-    const where: FindOptionsWhere<ListMasterItems> = {
-      listtype: type,
-      enterprise_id: enterprise_id,
-    };
-
-    if (search?.trim()) {
-      const lowerSearch = `%${search.toLowerCase()}%`;
-      where.name = Raw((alias) => `LOWER(${alias}) LIKE :search`, {
-        search: lowerSearch,
-      });
-      where.code = Raw((alias) => `LOWER(${alias}) LIKE :search`, {
-        search: lowerSearch,
-      });
-      // To achieve the OR condition between name and code, we need to use an array of conditions
-      // for the `where` clause, or use the `Or` operator.
-      // For this specific case, since `name` and `code` are at the same level as `listtype` and `enterprise_id`
-      // in the original query builder, we need to combine them correctly.
-      // The most direct translation for `AND (OR)` with `find` is to use `And` and `Or` from TypeORM.
-      Object.assign(where, {
-        And: [
-          { listtype: type },
-          { enterprise_id: enterprise_id },
-          {
-            Or: [
-              {
-                name: Raw((alias) => `LOWER(${alias}) LIKE :search`, {
-                  search: lowerSearch,
-                }),
-              },
-              {
-                code: Raw((alias) => `LOWER(${alias}) LIKE :search`, {
-                  search: lowerSearch,
-                }),
-              },
-            ],
-          },
-        ],
-      });
-    }
-
-    const items = await this.repo.find({
-      where: where,
-      order: { sortindex: sortBy === 'asc' ? 'ASC' : 'DESC' },
-    });
-
-    return items;
-  }
-
-  // more generic find method
-  async findOneByCondition(condition: Partial<ListMasterItems>) {
-    return this.repo.findOne({
-      where: {
-        ...condition,
-      },
-    });
-  }
-
-  async delete(item: Partial<ListMasterItems>) {
-    return this.repo.delete(item);
-  }
-
-  async findById(id: number): Promise<ListMasterItems | null> {
-    return this.repo.findOne({ where: { id } });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, In, Raw, Or, And, FindOptionsWhere } from 'typeorm';
+import { ListMasterItems } from '../entity/list-master-items.entity';
+
+@Injectable()
+export class ListMasterItemsRepository {
+  constructor(
+    @InjectRepository(ListMasterItems)
+    private repo: Repository<ListMasterItems>,
+  ) {
+  }
+
+  async create(item: Partial<ListMasterItems>) {
+    const newItem = this.repo.create(item);
+    return this.repo.save(newItem);
+  }
+
+  async update(id: number, item: Partial<ListMasterItems>) {
+    await this.repo.update(id, item);
+    return this.repo.findOne({ where: { id } });
+  }
+
+  async findItemsByType(
+    type: string,
+    sort_by?,
+    storage_type?,
+    enterprise_id?: number,
+    params?: Record<string, string>,
+    values?: any[],
+    inactiveIds?: number[],
+  ) {
+    let orderBy: Record<string, 'ASC' | 'DESC'> = {};
+
+    if (values?.length) {
+      if (storage_type === 'code') {
+        const itemValues = await this.repo.find({
+          where: {
+            listtype: type,
+            code: In(values),
+          },
+          order: orderBy,
+        });
+
+        const itemsMapped = itemValues.map((i) => ({
+          label: `${i.name} [INACTIVE]`,
+          value: String(i.code),
+        }));
+
+        return [...itemsMapped];
+      } else {
+        const itemValues = await this.repo.find({
+          where: {
+            listtype: type,
+            id: In(values),
+          },
+          order: orderBy,
+        });
+
+        const itemsMapped = itemValues.map((i) => ({
+          label: `${i.name}`,
+          value: String(i.id),
+        }));
+
+        return [...itemsMapped];
+      }
+    }
+
+
+    // Initial where clause
+    const whereClause: any = {
+      listtype: type,
+      enterprise_id: enterprise_id,
+      status: 'ACTIVE',
+    };
+
+    // Helper to check numeric
+    const isNumeric = (value: any) => !isNaN(Number(value));
+
+    // Sorting logic
+    if (sort_by && isNumeric(sort_by)) {
+      const listMasterItem = await this.repo.findOne({
+        where: { id: Number(sort_by) },
+      });
+
+      const sortValue = listMasterItem?.value?.toLowerCase();
+
+      if (sortValue) {
+        switch (sortValue) {
+          case 'az':
+            orderBy = { name: 'ASC' };
+            break;
+          case 'za':
+            orderBy = { name: 'DESC' };
+            break;
+          case 'custom':
+            orderBy = { sortindex: 'ASC' };
+            break;
+        }
+      }
+    }
+
+    // Handle parent_code logic
+    if (params?.parent && isNumeric(params.parent)) {
+      const parentItem = await this.repo.findOne({
+        where: { id: Number(params.parent) },
+      });
+
+      if (parentItem?.code) {
+        whereClause.parent_code = parentItem.code;
+      }
+    }
+
+    // Fetch active items
+    const items = await this.repo.find({
+      where: whereClause,
+      order: orderBy,
+    });
+
+
+    let result = items.map((i) => ({
+      label: i.name,
+      value: storage_type === 'code' ? i.code : String(i.id),
+    }));
+
+
+    // Handle inactive items if specified
+    if (inactiveIds?.length) {
+      if (storage_type === 'code') {
+        const inactiveItems = await this.repo.find({
+          where: {
+            listtype: type,
+            enterprise_id: enterprise_id,
+            code: In(inactiveIds),
+          },
+          order: orderBy,
+        });
+
+        const inactiveMapped = inactiveItems.map((i) => ({
+          label: `${i.name} [INACTIVE]`,
+          value: String(i.code),
+        }));
+
+        result = [...result, ...inactiveMapped];
+      } else {
+        const inactiveItems = await this.repo.find({
+          where: {
+            listtype: type,
+            // enterprise_id: enterprise_id,
+            id: In(inactiveIds),
+          },
+          order: orderBy,
+        });
+
+        const inactiveMapped = inactiveItems.map((i) => ({
+          label: `${i.name} [INACTIVE]`,
+          value: String(i.id),
+        }));
+
+        result = [...result, ...inactiveMapped];
+      }
+    }
+
+    return result;
+  }
+
+  async findOperatorsByType(type: string, enterprise_id?: number) {
+    const items = await this.repo.find({
+      where: {
+        listtype: type,
+        enterprise_id: enterprise_id,
+        status: 'ACTIVE',
+      },
+      order: { sortindex: 'ASC' },
+    });
+    return items.map((i) => ({ label: i.name, value: i.value }));
+  }
+
+  async findItemByCode(
+    code: string,
+    enterprise_id?: number,
+  ): Promise<ListMasterItems | null> {
+    return this.repo.findOne({
+      where: {
+        code: code,
+        enterprise_id: enterprise_id,
+      },
+    });
+  }
+
+  async findAllItemsByListType(
+    type: string,
+    sortBy: string,
+    enterprise_id: number,
+    search?: string,
+  ) {
+    const where: FindOptionsWhere<ListMasterItems> = {
+      listtype: type,
+      enterprise_id: enterprise_id,
+    };
+
+    if (search?.trim()) {
+      const lowerSearch = `%${search.toLowerCase()}%`;
+      where.name = Raw((alias) => `LOWER(${alias}) LIKE :search`, {
+        search: lowerSearch,
+      });
+      where.code = Raw((alias) => `LOWER(${alias}) LIKE :search`, {
+        search: lowerSearch,
+      });
+      // To achieve the OR condition between name and code, we need to use an array of conditions
+      // for the `where` clause, or use the `Or` operator.
+      // For this specific case, since `name` and `code` are at the same level as `listtype` and `enterprise_id`
+      // in the original query builder, we need to combine them correctly.
+      // The most direct translation for `AND (OR)` with `find` is to use `And` and `Or` from TypeORM.
+      Object.assign(where, {
+        And: [
+          { listtype: type },
+          { enterprise_id: enterprise_id },
+          {
+            Or: [
+              {
+                name: Raw((alias) => `LOWER(${alias}) LIKE :search`, {
+                  search: lowerSearch,
+                }),
+              },
+              {
+                code: Raw((alias) => `LOWER(${alias}) LIKE :search`, {
+                  search: lowerSearch,
+                }),
+              },
+            ],
+          },
+        ],
+      });
+    }
+
+    const items = await this.repo.find({
+      where: where,
+      order: { sortindex: sortBy === 'asc' ? 'ASC' : 'DESC' },
+    });
+
+    return items;
+  }
+
+  // more generic find method
+  async findOneByCondition(condition: Partial<ListMasterItems>) {
+    return this.repo.findOne({
+      where: {
+        ...condition,
+      },
+    });
+  }
+
+  async delete(item: Partial<ListMasterItems>) {
+    return this.repo.delete(item);
+  }
+
+  async findById(id: number): Promise<ListMasterItems | null> {
+    return this.repo.findOne({ where: { id } });
+  }
+}

package/src/module/listmaster/repository/list-master.repository.ts

@@ -1,60 +1,60 @@
-import { Injectable } from '@nestjs/common';
-import { ListMasterData } from '../entity/list-master.entity';
-import { Repository } from 'typeorm';
-import { InjectRepository } from '@nestjs/typeorm';
-
-@Injectable()
-export class ListMasterRepository {
-  constructor(
-    @InjectRepository(ListMasterData)
-    private readonly repo: Repository<ListMasterData>,
-  ) {}
-
-  findByType(type: string, enterprise_id?: number) {
-    return this.repo.findOne({
-      where: {
-        type: type,
-        enterprise_id: enterprise_id,
-      },
-    });
-  }
-
-  // much better generic find method
-  async findOneByCondition(condition: Partial<ListMasterData>) {
-    return await this.repo.findOne({ where: condition });
-  }
-
-  async findAllItems(enterprise_id: number, app_code?: string, search?: string) {
-    const qb = this.repo
-      .createQueryBuilder('item')
-      .where('item.source = :source', { source: 'master' })
-      .andWhere('item.enterprise_id = :enterprise_id', { enterprise_id });
-    // .andWhere('item.is_factory = :isFactory', { isFactory: false });
-
-    if (app_code) {
-      qb.andWhere('item.app_code = :app_code', { app_code: app_code });
-    }
-
-    if (search?.trim()) {
-      qb.andWhere(
-        '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',
-        { search: `%${search.toLowerCase()}%` },
-      );
-    }
-
-    // sort by created_at in descending order
-    qb.orderBy('item.created_date', 'DESC');
-
-    return await qb.getMany();
-  }
-
-  async findByEnterpriseIdAndSource(enterprise_id, source) {
-    return await this.repo
-      .createQueryBuilder("lm")
-      .select("lm.name", "label")
-      .addSelect("lm.type", "value")
-      .where("lm.enterprise_id = :entId", { entId: enterprise_id })
-      .andWhere("lm.source = :source", { source })
-      .getRawMany();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { ListMasterData } from '../entity/list-master.entity';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+
+@Injectable()
+export class ListMasterRepository {
+  constructor(
+    @InjectRepository(ListMasterData)
+    private readonly repo: Repository<ListMasterData>,
+  ) {}
+
+  findByType(type: string, enterprise_id?: number) {
+    return this.repo.findOne({
+      where: {
+        type: type,
+        enterprise_id: enterprise_id,
+      },
+    });
+  }
+
+  // much better generic find method
+  async findOneByCondition(condition: Partial<ListMasterData>) {
+    return await this.repo.findOne({ where: condition });
+  }
+
+  async findAllItems(enterprise_id: number, app_code?: string, search?: string) {
+    const qb = this.repo
+      .createQueryBuilder('item')
+      .where('item.source = :source', { source: 'master' })
+      .andWhere('item.enterprise_id = :enterprise_id', { enterprise_id });
+    // .andWhere('item.is_factory = :isFactory', { isFactory: false });
+
+    if (app_code) {
+      qb.andWhere('item.app_code = :app_code', { app_code: app_code });
+    }
+
+    if (search?.trim()) {
+      qb.andWhere(
+        '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',
+        { search: `%${search.toLowerCase()}%` },
+      );
+    }
+
+    // sort by created_at in descending order
+    qb.orderBy('item.created_date', 'DESC');
+
+    return await qb.getMany();
+  }
+
+  async findByEnterpriseIdAndSource(enterprise_id, source) {
+    return await this.repo
+      .createQueryBuilder("lm")
+      .select("lm.name", "label")
+      .addSelect("lm.type", "value")
+      .where("lm.enterprise_id = :entId", { entId: enterprise_id })
+      .andWhere("lm.source = :source", { source })
+      .getRawMany();
+  }
+}