rez_core 7.1.1 → 7.1.2

package/src/module/listmaster/service/list-master-item.service.ts

@@ -1,382 +1,382 @@
-import { DataSource } from 'typeorm';
-import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { UserData } from 'src/module/auth/dto/user.dto';
-import { CodeGeneratorService } from 'src/utils/service/codeGenerator.service';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { ListMasterRepository } from '../repository/list-master.repository';
-
-@Injectable()
-export class ListMasterItemService extends EntityServiceImpl {
-  constructor(
-    private readonly listItemsRepo: ListMasterItemsRepository,
-    private readonly listMasterRepo: ListMasterRepository,
-    @Inject(forwardRef(() => EntityServiceImpl))
-    private readonly entityServiceImpl: EntityServiceImpl,
-    @Inject('AttributeMasterService')
-    protected readonly attributeMasterService: AttributeMasterService,
-    private readonly dataSource: DataSource,
-  ) {
-    super();
-  }
-
-  async getListMasterItemsByType(
-    listType: string,
-    enterprise_id: number,
-    search?: string,
-  ) {
-    // this method retrieves all list master items for a specific type and organization
-    return this.listItemsRepo.findAllItemsByListType(
-      listType,
-      'asc',
-      enterprise_id,
-      search,
-    );
-  }
-
-  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
-    try {
-      const generatedCode = CodeGeneratorService.generateCode(entityData.code);
-
-      entityData.code = generatedCode;
-      entityData.value = generatedCode;
-
-      return await this.entityServiceImpl.createEntity(
-        entityData,
-        loggedInUser,
-      );
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
-    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
-  }
-
-  async upsertListMasterItem(
-    listType: string,
-    items: any[],
-    loggedInUser,
-  ): Promise<any> {
-    const entId = loggedInUser.enterprise_id;
-    const errors: any[] = [];
-
-    // Step 1: Validate and prepare items
-    const processedItems = items.map((item, index) => ({
-      ...item,
-      index,
-      name: item.name?.trim(),
-      code: item.code?.trim(),
-      itemId: item.id,
-    }));
-
-    // Step 2: Fetch all existing items for this list type in one query
-    const existingItems = await this.listItemsRepo.findAllItemsByListType(
-      listType,
-      'asc',
-      entId,
-    );
-
-    // Create lookup maps for efficient validation
-    const existingItemsById = new Map(existingItems.map(item => [item.id, item]));
-    const existingItemsByName = new Map(existingItems.map(item => [item.name?.toLowerCase(), item]));
-    const existingItemsByCode = new Map(
-      existingItems.filter(item => item.code).map(item => [item.code?.toLowerCase(), item])
-    );
-
-    // Step 3: Validate all items and collect errors
-    const validItems: any[] = [];
-
-    for (const processedItem of processedItems) {
-      const { index, name, code, itemId } = processedItem;
-      const itemErrors: any[] = [];
-
-      // Validate required fields - both name and code are required
-      if (!name) {
-        itemErrors.push({
-          field: 'name',
-          message: 'Name is required',
-        });
-      }
-
-      if (!code) {
-        itemErrors.push({
-          field: 'code',
-          message: 'Code is required',
-        });
-      }
-
-      // Determine if this is an update by checking for existing item
-      let existingItem: any = null;
-      let effectiveItemId = itemId; // Track the ID we'll use for this item
-      
-      // First, check if ID is provided and exists
-      if (itemId) {
-        existingItem = existingItemsById.get(itemId) || null;
-        if (!existingItem) {
-          itemErrors.push({
-            field: 'id',
-            message: `List item with id ${itemId} not found`,
-          });
-        } else if (existingItem.listtype !== listType) {
-          itemErrors.push({
-            field: 'id',
-            message: `List item with id ${itemId} does not belong to list type ${listType}`,
-          });
-        }
-      } else {
-        // If no ID provided, check if item exists by name or code (for upsert)
-        const existingByName = name ? existingItemsByName.get(name.toLowerCase()) : null;
-        const existingByCode = code ? existingItemsByCode.get(code.toLowerCase()) : null;
-
-        // If both name and code match the same item, it's an update - use that item's ID
-        if (existingByName && existingByCode && existingByName.id === existingByCode.id) {
-          existingItem = existingByName;
-          effectiveItemId = existingItem.id; // Automatically use the existing item's ID
-        }
-        // If name matches one item and code matches a different item, it's a conflict
-        else if (existingByName && existingByCode && existingByName.id !== existingByCode.id) {
-          itemErrors.push({
-            field: 'name',
-            message: `Name "${name}" belongs to item with code "${existingByName.code}"`,
-          });
-          itemErrors.push({
-            field: 'code',
-            message: `Code "${code}" belongs to item with name "${existingByCode.name}"`,
-          });
-        }
-        // If only name matches, it's a conflict (trying to create with existing name but different code)
-        else if (existingByName) {
-          itemErrors.push({
-            field: 'name',
-            message: `List item with name "${name}" already exists with code "${existingByName.code}"`,
-          });
-        }
-        // If only code matches, it's a conflict (trying to create with existing code but different name)
-        else if (existingByCode) {
-          itemErrors.push({
-            field: 'code',
-            message: `List item with code "${code}" already exists with name "${existingByCode.name}"`,
-          });
-        }
-      }
-
-      // Check for duplicates within the current batch
-      if (name) {
-        const duplicateInBatch = processedItems.find(
-          (other, otherIndex) =>
-            otherIndex < index &&
-            other.name?.toLowerCase() === name.toLowerCase() &&
-            (!effectiveItemId || other.itemId !== effectiveItemId)
-        );
-        if (duplicateInBatch) {
-          itemErrors.push({
-            field: 'name',
-            message: `Duplicate name "${name}" found in batch at row ${duplicateInBatch.index}`,
-          });
-        }
-      }
-
-      if (code) {
-        const duplicateCodeInBatch = processedItems.find(
-          (other, otherIndex) =>
-            otherIndex < index &&
-            other.code?.toLowerCase() === code.toLowerCase() &&
-            (!effectiveItemId || other.itemId !== effectiveItemId)
-        );
-        if (duplicateCodeInBatch) {
-          itemErrors.push({
-            field: 'code',
-            message: `Duplicate code "${code}" found in batch at row ${duplicateCodeInBatch.index}`,
-          });
-        }
-      }
-
-      // If there are validation errors, add to errors array
-      if (itemErrors.length > 0) {
-        errors.push({
-          row: index,
-          errors: itemErrors,
-        });
-      } else {
-        validItems.push({
-          ...processedItem,
-          existingItem,
-        });
-      }
-    }
-
-    // Step 4: Process valid items (create or update)
-    for (const validItem of validItems) {
-      const { index, name, code, itemId, existingItem, ...restOfItem } = validItem;
-
-      try {
-        if (existingItem) {
-          // Update existing item
-          await this.updateEntity(
-            {
-              ...restOfItem,
-              id: existingItem.id, // Use the existing item's ID
-              name,
-              code,
-              listtype: listType,
-            },
-            loggedInUser,
-          );
-        } else {
-          // Create new item
-          await this.createEntity(
-            {
-              ...restOfItem,
-              name,
-              code,
-              listtype: listType,
-              value: '',
-            },
-            loggedInUser,
-          );
-        }
-      } catch (error) {
-        // Catch any runtime errors during create/update
-        errors.push({
-          row: index,
-          errors: [
-            {
-              field: 'general',
-              message: error.message || 'An error occurred while processing the item',
-            },
-          ],
-        });
-      }
-    }
-
-    // Step 5: Fetch updated items and return response
-    const updatedItems = await this.listItemsRepo.findAllItemsByListType(
-      listType,
-      'asc',
-      entId,
-    );
-
-    return {
-      success: errors.length === 0,
-      listType,
-      errors,
-      items: updatedItems,
-    };
-  }
-
-  async deleteListMasterItem(listType: string, code: string): Promise<string> {
-    const item = await this.listItemsRepo.findOneByCondition({
-      code,
-      listtype: listType,
-    });
-    if (!item) {
-      throw new NotFoundException(
-        `Item with name ${code} not found in type ${listType}`,
-      );
-    }
-    await this.listItemsRepo.delete({ code, listtype: listType });
-    return `Item with name ${code} deleted successfully from type ${listType}`;
-  }
-
-  async getListSourceType(
-    loggedInUser: UserData,
-    source: string,
-  ): Promise<any> {
-    return await this.listMasterRepo.findByEnterpriseIdAndSource(loggedInUser.enterprise_id, source);
-  }
-
-  // async getResolvedListMasterItems(
-  //   loggedInUser: UserData,
-  //   entityData: any,
-  //   entityType: string,
-  // ): Promise<any> {
-  //   const attributeItems =
-  //     await this.attributeMasterService.findAttributesByMappedEntityType(
-  //       entityType,
-  //       loggedInUser,
-  //     );
-
-  //   const masterAttributes = attributeItems.filter(
-  //     (attr) => attr.data_source_type === 'master',
-  //   );
-
-  //   const resolvedEntityData = { ...entityData };
-
-  //   for (const attr of masterAttributes) {
-  //     const field = attr.attribute_key;
-  //     const codeValue = entityData[field];
-  //     if (!codeValue) continue;
-
-  //     const listItems = await this.listItemsRepo.findById(codeValue);
-  //     if (!listItems) continue;
-
-  //   }
-
-  //   return resolvedEntityData;
-  // }
-
-  // async getResolvedListMasterItems(
-  //   loggedInUser: UserData,
-  //   entityData: any,
-  //   entityType: string,
-  // ): Promise<any> {
-  //   // const resolvedEntityData = super.getResolvedData(
-  //   //   loggedInUser,
-  //   //   entityData,
-  //   //   entityType,
-  //   // );
-  //   // const attributeItems =
-  //   //   await this.attributeMasterService.findAttributesByMappedEntityType(
-  //   //     entityType,
-  //   //     loggedInUser,
-  //   //   );
-  //   // const resolvedEntityData = { ...entityData };
-  //   // for (const attr of attributeItems) {
-  //   //   const field = attr.attribute_key;
-  //   //   const codeValue = entityData[field];
-  //   //   if (!codeValue) continue;
-  //   //   // ---------- ENTITY data_source_type ----------
-  //   //   if (attr.data_source_type === 'entity') {
-  //   //     if (Array.isArray(codeValue)) {
-  //   //       const resolvedValues: string[] = [];
-  //   //       for (const code of codeValue) {
-  //   //         const item = await super.getEntityData(
-  //   //           attr.datasource_list,
-  //   //           code,
-  //   //           loggedInUser,
-  //   //         );
-  //   //         resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
-  //   //       }
-  //   //       resolvedEntityData[field] = resolvedValues;
-  //   //     } else {
-  //   //       const item = await super.getEntityData(
-  //   //         attr.datasource_list,
-  //   //         codeValue,
-  //   //         loggedInUser,
-  //   //       );
-  //   //       resolvedEntityData[field] =
-  //   //         item?.[attr.data_source_attribute] ?? codeValue;
-  //   //     }
-  //   //   }
-  //   //   // ---------- MASTER data_source_type ----------
-  //   //   else if (attr.data_source_type === 'master') {
-  //   //     if (Array.isArray(codeValue)) {
-  //   //       const resolvedValues: string[] = [];
-  //   //       for (const code of codeValue) {
-  //   //         const item = await this.listItemsRepo.findById(code);
-  //   //         resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
-  //   //       }
-  //   //       resolvedEntityData[field] = resolvedValues;
-  //   //     } else {
-  //   //       const item = await this.listItemsRepo.findById(codeValue);
-  //   //       resolvedEntityData[field] =
-  //   //         item?.[attr.data_source_attribute] ?? codeValue;
-  //   //     }
-  //   //   }
-  //   // }
-  //   // return resolvedEntityData;
-  // }
-}
+import { DataSource } from 'typeorm';
+import { BadRequestException, forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { ListMasterItemsRepository } from '../repository/list-master-items.repository';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/auth/dto/user.dto';
+import { CodeGeneratorService } from 'src/utils/service/codeGenerator.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { ListMasterRepository } from '../repository/list-master.repository';
+
+@Injectable()
+export class ListMasterItemService extends EntityServiceImpl {
+  constructor(
+    private readonly listItemsRepo: ListMasterItemsRepository,
+    private readonly listMasterRepo: ListMasterRepository,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
+    @Inject('AttributeMasterService')
+    protected readonly attributeMasterService: AttributeMasterService,
+    private readonly dataSource: DataSource,
+  ) {
+    super();
+  }
+
+  async getListMasterItemsByType(
+    listType: string,
+    enterprise_id: number,
+    search?: string,
+  ) {
+    // this method retrieves all list master items for a specific type and organization
+    return this.listItemsRepo.findAllItemsByListType(
+      listType,
+      'asc',
+      enterprise_id,
+      search,
+    );
+  }
+
+  async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    try {
+      const generatedCode = CodeGeneratorService.generateCode(entityData.code);
+
+      entityData.code = generatedCode;
+      entityData.value = generatedCode;
+
+      return await this.entityServiceImpl.createEntity(
+        entityData,
+        loggedInUser,
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async updateEntity(entityData: any, loggedInUser: UserData): Promise<any> {
+    return await this.entityServiceImpl.updateEntity(entityData, loggedInUser);
+  }
+
+  async upsertListMasterItem(
+    listType: string,
+    items: any[],
+    loggedInUser,
+  ): Promise<any> {
+    const entId = loggedInUser.enterprise_id;
+    const errors: any[] = [];
+
+    // Step 1: Validate and prepare items
+    const processedItems = items.map((item, index) => ({
+      ...item,
+      index,
+      name: item.name?.trim(),
+      code: item.code?.trim(),
+      itemId: item.id,
+    }));
+
+    // Step 2: Fetch all existing items for this list type in one query
+    const existingItems = await this.listItemsRepo.findAllItemsByListType(
+      listType,
+      'asc',
+      entId,
+    );
+
+    // Create lookup maps for efficient validation
+    const existingItemsById = new Map(existingItems.map(item => [item.id, item]));
+    const existingItemsByName = new Map(existingItems.map(item => [item.name?.toLowerCase(), item]));
+    const existingItemsByCode = new Map(
+      existingItems.filter(item => item.code).map(item => [item.code?.toLowerCase(), item])
+    );
+
+    // Step 3: Validate all items and collect errors
+    const validItems: any[] = [];
+
+    for (const processedItem of processedItems) {
+      const { index, name, code, itemId } = processedItem;
+      const itemErrors: any[] = [];
+
+      // Validate required fields - both name and code are required
+      if (!name) {
+        itemErrors.push({
+          field: 'name',
+          message: 'Name is required',
+        });
+      }
+
+      if (!code) {
+        itemErrors.push({
+          field: 'code',
+          message: 'Code is required',
+        });
+      }
+
+      // Determine if this is an update by checking for existing item
+      let existingItem: any = null;
+      let effectiveItemId = itemId; // Track the ID we'll use for this item
+      
+      // First, check if ID is provided and exists
+      if (itemId) {
+        existingItem = existingItemsById.get(itemId) || null;
+        if (!existingItem) {
+          itemErrors.push({
+            field: 'id',
+            message: `List item with id ${itemId} not found`,
+          });
+        } else if (existingItem.listtype !== listType) {
+          itemErrors.push({
+            field: 'id',
+            message: `List item with id ${itemId} does not belong to list type ${listType}`,
+          });
+        }
+      } else {
+        // If no ID provided, check if item exists by name or code (for upsert)
+        const existingByName = name ? existingItemsByName.get(name.toLowerCase()) : null;
+        const existingByCode = code ? existingItemsByCode.get(code.toLowerCase()) : null;
+
+        // If both name and code match the same item, it's an update - use that item's ID
+        if (existingByName && existingByCode && existingByName.id === existingByCode.id) {
+          existingItem = existingByName;
+          effectiveItemId = existingItem.id; // Automatically use the existing item's ID
+        }
+        // If name matches one item and code matches a different item, it's a conflict
+        else if (existingByName && existingByCode && existingByName.id !== existingByCode.id) {
+          itemErrors.push({
+            field: 'name',
+            message: `Name "${name}" belongs to item with code "${existingByName.code}"`,
+          });
+          itemErrors.push({
+            field: 'code',
+            message: `Code "${code}" belongs to item with name "${existingByCode.name}"`,
+          });
+        }
+        // If only name matches, it's a conflict (trying to create with existing name but different code)
+        else if (existingByName) {
+          itemErrors.push({
+            field: 'name',
+            message: `List item with name "${name}" already exists with code "${existingByName.code}"`,
+          });
+        }
+        // If only code matches, it's a conflict (trying to create with existing code but different name)
+        else if (existingByCode) {
+          itemErrors.push({
+            field: 'code',
+            message: `List item with code "${code}" already exists with name "${existingByCode.name}"`,
+          });
+        }
+      }
+
+      // Check for duplicates within the current batch
+      if (name) {
+        const duplicateInBatch = processedItems.find(
+          (other, otherIndex) =>
+            otherIndex < index &&
+            other.name?.toLowerCase() === name.toLowerCase() &&
+            (!effectiveItemId || other.itemId !== effectiveItemId)
+        );
+        if (duplicateInBatch) {
+          itemErrors.push({
+            field: 'name',
+            message: `Duplicate name "${name}" found in batch at row ${duplicateInBatch.index}`,
+          });
+        }
+      }
+
+      if (code) {
+        const duplicateCodeInBatch = processedItems.find(
+          (other, otherIndex) =>
+            otherIndex < index &&
+            other.code?.toLowerCase() === code.toLowerCase() &&
+            (!effectiveItemId || other.itemId !== effectiveItemId)
+        );
+        if (duplicateCodeInBatch) {
+          itemErrors.push({
+            field: 'code',
+            message: `Duplicate code "${code}" found in batch at row ${duplicateCodeInBatch.index}`,
+          });
+        }
+      }
+
+      // If there are validation errors, add to errors array
+      if (itemErrors.length > 0) {
+        errors.push({
+          row: index,
+          errors: itemErrors,
+        });
+      } else {
+        validItems.push({
+          ...processedItem,
+          existingItem,
+        });
+      }
+    }
+
+    // Step 4: Process valid items (create or update)
+    for (const validItem of validItems) {
+      const { index, name, code, itemId, existingItem, ...restOfItem } = validItem;
+
+      try {
+        if (existingItem) {
+          // Update existing item
+          await this.updateEntity(
+            {
+              ...restOfItem,
+              id: existingItem.id, // Use the existing item's ID
+              name,
+              code,
+              listtype: listType,
+            },
+            loggedInUser,
+          );
+        } else {
+          // Create new item
+          await this.createEntity(
+            {
+              ...restOfItem,
+              name,
+              code,
+              listtype: listType,
+              value: '',
+            },
+            loggedInUser,
+          );
+        }
+      } catch (error) {
+        // Catch any runtime errors during create/update
+        errors.push({
+          row: index,
+          errors: [
+            {
+              field: 'general',
+              message: error.message || 'An error occurred while processing the item',
+            },
+          ],
+        });
+      }
+    }
+
+    // Step 5: Fetch updated items and return response
+    const updatedItems = await this.listItemsRepo.findAllItemsByListType(
+      listType,
+      'asc',
+      entId,
+    );
+
+    return {
+      success: errors.length === 0,
+      listType,
+      errors,
+      items: updatedItems,
+    };
+  }
+
+  async deleteListMasterItem(listType: string, code: string): Promise<string> {
+    const item = await this.listItemsRepo.findOneByCondition({
+      code,
+      listtype: listType,
+    });
+    if (!item) {
+      throw new NotFoundException(
+        `Item with name ${code} not found in type ${listType}`,
+      );
+    }
+    await this.listItemsRepo.delete({ code, listtype: listType });
+    return `Item with name ${code} deleted successfully from type ${listType}`;
+  }
+
+  async getListSourceType(
+    loggedInUser: UserData,
+    source: string,
+  ): Promise<any> {
+    return await this.listMasterRepo.findByEnterpriseIdAndSource(loggedInUser.enterprise_id, source);
+  }
+
+  // async getResolvedListMasterItems(
+  //   loggedInUser: UserData,
+  //   entityData: any,
+  //   entityType: string,
+  // ): Promise<any> {
+  //   const attributeItems =
+  //     await this.attributeMasterService.findAttributesByMappedEntityType(
+  //       entityType,
+  //       loggedInUser,
+  //     );
+
+  //   const masterAttributes = attributeItems.filter(
+  //     (attr) => attr.data_source_type === 'master',
+  //   );
+
+  //   const resolvedEntityData = { ...entityData };
+
+  //   for (const attr of masterAttributes) {
+  //     const field = attr.attribute_key;
+  //     const codeValue = entityData[field];
+  //     if (!codeValue) continue;
+
+  //     const listItems = await this.listItemsRepo.findById(codeValue);
+  //     if (!listItems) continue;
+
+  //   }
+
+  //   return resolvedEntityData;
+  // }
+
+  // async getResolvedListMasterItems(
+  //   loggedInUser: UserData,
+  //   entityData: any,
+  //   entityType: string,
+  // ): Promise<any> {
+  //   // const resolvedEntityData = super.getResolvedData(
+  //   //   loggedInUser,
+  //   //   entityData,
+  //   //   entityType,
+  //   // );
+  //   // const attributeItems =
+  //   //   await this.attributeMasterService.findAttributesByMappedEntityType(
+  //   //     entityType,
+  //   //     loggedInUser,
+  //   //   );
+  //   // const resolvedEntityData = { ...entityData };
+  //   // for (const attr of attributeItems) {
+  //   //   const field = attr.attribute_key;
+  //   //   const codeValue = entityData[field];
+  //   //   if (!codeValue) continue;
+  //   //   // ---------- ENTITY data_source_type ----------
+  //   //   if (attr.data_source_type === 'entity') {
+  //   //     if (Array.isArray(codeValue)) {
+  //   //       const resolvedValues: string[] = [];
+  //   //       for (const code of codeValue) {
+  //   //         const item = await super.getEntityData(
+  //   //           attr.datasource_list,
+  //   //           code,
+  //   //           loggedInUser,
+  //   //         );
+  //   //         resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
+  //   //       }
+  //   //       resolvedEntityData[field] = resolvedValues;
+  //   //     } else {
+  //   //       const item = await super.getEntityData(
+  //   //         attr.datasource_list,
+  //   //         codeValue,
+  //   //         loggedInUser,
+  //   //       );
+  //   //       resolvedEntityData[field] =
+  //   //         item?.[attr.data_source_attribute] ?? codeValue;
+  //   //     }
+  //   //   }
+  //   //   // ---------- MASTER data_source_type ----------
+  //   //   else if (attr.data_source_type === 'master') {
+  //   //     if (Array.isArray(codeValue)) {
+  //   //       const resolvedValues: string[] = [];
+  //   //       for (const code of codeValue) {
+  //   //         const item = await this.listItemsRepo.findById(code);
+  //   //         resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
+  //   //       }
+  //   //       resolvedEntityData[field] = resolvedValues;
+  //   //     } else {
+  //   //       const item = await this.listItemsRepo.findById(codeValue);
+  //   //       resolvedEntityData[field] =
+  //   //         item?.[attr.data_source_attribute] ?? codeValue;
+  //   //     }
+  //   //   }
+  //   // }
+  //   // return resolvedEntityData;
+  // }
+}