rez_core 3.1.136 → 3.1.138

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

@@ -1,169 +1,169 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository, In } 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?,
-    inactiveIdsArray?: number[],
-    organizationId?: number,
-    params?: Record<string, string>,
-  ) {
-    let orderBy: Record<string, 'ASC' | 'DESC'> = {};
-
-    // Initial where clause
-    const whereClause: any = {
-      listtype: type,
-      organization_id: organizationId,
-      status: 'ACTIVE',
-    };
-
-    // Sorting logic
-    if (sort_by) {
-      const listMasterItem = await this.repo.findOne({
-        where: { id: 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) {
-      const parentItem = await this.repo.findOne({
-        where: { id: parseInt(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: i.id,
-    }));
-
-    // Handle inactive items if specified
-    if (inactiveIdsArray?.length) {
-      const inactiveItems = await this.repo.find({
-        where: {
-          listtype: type,
-          organization_id: organizationId,
-          status: 'INACTIVE',
-          id: In(inactiveIdsArray),
-        },
-        order: orderBy,
-      });
-
-      const inactiveMapped = inactiveItems.map((i) => ({
-        label: `${i.name} [INACTIVE]`,
-        value: i.id,
-      }));
-
-      result = [...result, ...inactiveMapped];
-    }
-
-    return result;
-  }
-
-  async findOperatorsByType(type: string, organizationId?: number) {
-    const items = await this.repo.find({
-      where: {
-        listtype: type,
-        organization_id: organizationId,
-        status: 'ACTIVE',
-      },
-      order: { sortindex: 'ASC' },
-    });
-    return items.map((i) => ({ label: i.name, value: i.value }));
-  }
-
-  async findItemByCode(
-    code: string,
-    organizationId?: number,
-  ): Promise<ListMasterItems | null> {
-    return this.repo.findOne({
-      where: {
-        code: code,
-        organization_id: organizationId,
-      },
-    });
-  }
-
-  async findAllItemsByListType(
-    type: string,
-    sortBy: string,
-    organizationId: number,
-    search?: string,
-  ) {
-    const qb = this.repo
-      .createQueryBuilder('item')
-      .where('item.listtype = :type', { type })
-      .andWhere('item.organization_id = :organizationId', { organizationId });
-
-    if (search?.trim()) {
-      qb.andWhere(
-        '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',
-        { search: `%${search.toLowerCase()}%` },
-      );
-    }
-
-    qb.orderBy('item.sortindex', sortBy === 'asc' ? 'ASC' : 'DESC');
-
-    return await qb.getMany();
-  }
-
-  // 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 } 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?,
+    inactiveIdsArray?: number[],
+    organizationId?: number,
+    params?: Record<string, string>,
+  ) {
+    let orderBy: Record<string, 'ASC' | 'DESC'> = {};
+
+    // Initial where clause
+    const whereClause: any = {
+      listtype: type,
+      organization_id: organizationId,
+      status: 'ACTIVE',
+    };
+
+    // Sorting logic
+    if (sort_by) {
+      const listMasterItem = await this.repo.findOne({
+        where: { id: 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) {
+      const parentItem = await this.repo.findOne({
+        where: { id: parseInt(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: i.id,
+    }));
+
+    // Handle inactive items if specified
+    if (inactiveIdsArray?.length) {
+      const inactiveItems = await this.repo.find({
+        where: {
+          listtype: type,
+          organization_id: organizationId,
+          status: 'INACTIVE',
+          id: In(inactiveIdsArray),
+        },
+        order: orderBy,
+      });
+
+      const inactiveMapped = inactiveItems.map((i) => ({
+        label: `${i.name} [INACTIVE]`,
+        value: i.id,
+      }));
+
+      result = [...result, ...inactiveMapped];
+    }
+
+    return result;
+  }
+
+  async findOperatorsByType(type: string, organizationId?: number) {
+    const items = await this.repo.find({
+      where: {
+        listtype: type,
+        organization_id: organizationId,
+        status: 'ACTIVE',
+      },
+      order: { sortindex: 'ASC' },
+    });
+    return items.map((i) => ({ label: i.name, value: i.value }));
+  }
+
+  async findItemByCode(
+    code: string,
+    organizationId?: number,
+  ): Promise<ListMasterItems | null> {
+    return this.repo.findOne({
+      where: {
+        code: code,
+        organization_id: organizationId,
+      },
+    });
+  }
+
+  async findAllItemsByListType(
+    type: string,
+    sortBy: string,
+    organizationId: number,
+    search?: string,
+  ) {
+    const qb = this.repo
+      .createQueryBuilder('item')
+      .where('item.listtype = :type', { type })
+      .andWhere('item.organization_id = :organizationId', { organizationId });
+
+    if (search?.trim()) {
+      qb.andWhere(
+        '(LOWER(item.name) LIKE :search OR LOWER(item.code) LIKE :search)',
+        { search: `%${search.toLowerCase()}%` },
+      );
+    }
+
+    qb.orderBy('item.sortindex', sortBy === 'asc' ? 'ASC' : 'DESC');
+
+    return await qb.getMany();
+  }
+
+  // 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,46 +1,46 @@
-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, organizationId?: number) {
-    return this.repo.findOne({
-      where: {
-        type: type,
-        organization_id: organizationId,
-      },
-    });
-  }
-
-  // much better generic find method
-  async findOneByCondition(condition: Partial<ListMasterData>) {
-    return await this.repo.findOne({ where: condition });
-  }
-
-  async findAllItems(organizationId: number, search?: string) {
-    const qb = this.repo
-      .createQueryBuilder('item')
-      .where('item.source = :source', { source: 'master' })
-      .andWhere('item.organization_id = :organizationId', { organizationId });
-    // .andWhere('item.is_factory = :isFactory', { isFactory: false });
-
-    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();
-  }
-}
+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, organizationId?: number) {
+    return this.repo.findOne({
+      where: {
+        type: type,
+        organization_id: organizationId,
+      },
+    });
+  }
+
+  // much better generic find method
+  async findOneByCondition(condition: Partial<ListMasterData>) {
+    return await this.repo.findOne({ where: condition });
+  }
+
+  async findAllItems(organizationId: number, search?: string) {
+    const qb = this.repo
+      .createQueryBuilder('item')
+      .where('item.source = :source', { source: 'master' })
+      .andWhere('item.organization_id = :organizationId', { organizationId });
+    // .andWhere('item.is_factory = :isFactory', { isFactory: false });
+
+    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();
+  }
+}