rez_core 6.5.83 → 6.5.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "6.5.83",
+  "version": "6.5.84",
   "description": "",
   "author": "",
   "private": false,

package/src/module/filter/service/filter.service.ts

@@ -1245,18 +1245,19 @@ export class FilterService {
     }
 
     if (op === 'equal') {
-      return {
-        query: `e.${attr}::text IN (:...${key})`,
-        params: { [key]: arr },
-      };
-    }
+  return {
+    query: `e.${attr}::text = ANY(:${key})`,
+    params: { [key]: arr },
+  };
+}
+
+if (op === 'not_equal') {
+  return {
+    query: `NOT (e.${attr}::text = ANY(:${key}))`,
+    params: { [key]: arr },
+  };
+}
 
-    if (op === 'not_equal') {
-      return {
-        query: `e.${attr}::text NOT IN (:...${key})`,
-        params: { [key]: arr },
-      };
-    }
 
     if (op === 'contains') {
       return {

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

@@ -60,84 +60,177 @@ export class ListMasterItemService extends EntityServiceImpl {
     loggedInUser,
   ): Promise<any> {
     const entId = loggedInUser.enterprise_id;
-
     const errors: any[] = [];
 
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      const name = item.name?.trim();
-      const code = item.code?.trim();
-      const itemId = item.id;
+    // 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,
+    }));
 
-      try {
-        if (!name) {
-          throw new BadRequestException(`name is missing at index ${i}`);
-        }
+    // Step 2: Fetch all existing items for this list type in one query
+    const existingItems = await this.listItemsRepo.findAllItemsByListType(
+      listType,
+      'asc',
+      entId,
+    );
 
-        // Check if this is an update (item has an id)
-        let existingItem;
-        if (itemId) {
-          existingItem = await this.listItemsRepo.findOneByCondition({
-            id: itemId,
-            listtype: listType,
-            enterprise_id: 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])
+    );
 
-          if (!existingItem) {
-            throw new BadRequestException(
-              `list item with id ${itemId} not found`,
-            );
-          }
-        }
+    // Step 3: Validate all items and collect errors
+    const validItems: any[] = [];
 
-        // Check for duplicate name (excluding current item if updating)
-        const nameExists = await this.listItemsRepo.findOneByCondition({
-          name,
-          listtype: listType,
-          enterprise_id: entId,
+    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 (nameExists && (!itemId || nameExists.id !== itemId)) {
-          throw new BadRequestException(
-            `list item with name ${name} already exists`,
-          );
+      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 duplicate code (excluding current item if updating)
-        if (code) {
-          const codeExists = await this.listItemsRepo.findOneByCondition({
-            code,
-            listtype: listType,
-            enterprise_id: entId,
+      // 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 (codeExists && (!itemId || codeExists.id !== itemId)) {
-            throw new BadRequestException(
-              `list item with code ${code} already exists`,
-            );
-          }
+      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,
+        });
+      }
+    }
 
-        // Update or Create
+    // 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 path
+          // Update existing item
           await this.updateEntity(
             {
-              ...item,
-              id: itemId,
+              ...restOfItem,
+              id: existingItem.id, // Use the existing item's ID
               name,
-              code: code || existingItem.code,
+              code,
               listtype: listType,
             },
             loggedInUser,
           );
         } else {
-          // Creation path
+          // Create new item
           await this.createEntity(
             {
-              ...item,
+              ...restOfItem,
               name,
-              code: code,
+              code,
               listtype: listType,
               value: '',
             },
@@ -145,19 +238,20 @@ export class ListMasterItemService extends EntityServiceImpl {
           );
         }
       } catch (error) {
+        // Catch any runtime errors during create/update
         errors.push({
-          row: i,
+          row: index,
           errors: [
             {
-              field: 'name',
-              message:
-                error.message || 'An error occurred while processing the item',
+              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',