rez_core 1.0.99 → 1.1.1

package/package.json

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

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

@@ -100,11 +100,11 @@ export class FilterService {
     // Get and parse filters
     const savedFilters = await this.getSavedFilters(savedFilterCode);
     const baseFilters = [
-      ...(quickFilter || []).filter(f => f.filter_value !== ""),
-      ...savedFilters.filter(f => f.filter_value !== ""),
-      ...(attributeFilter || []).filter(f => f.filter_value !== ""),
+      ...(quickFilter || []).filter((f) => f.filter_value !== ''),
+      ...savedFilters.filter((f) => f.filter_value !== ''),
+      ...(attributeFilter || []).filter((f) => f.filter_value !== ''),
     ];
-    
+
     const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
 
     // Build query for tab counts (no tab.value filter here)
@@ -229,7 +229,7 @@ export class FilterService {
       case 'select':
         return this.buildSelectCondition(attr, op, val, key);
       case 'multiselect':
-        return this.buildMultiSelectCondition(attr, val, key);
+        return this.buildMultiSelectCondition(attr, op, val, key);
       default:
         return null;
     }
@@ -310,18 +310,56 @@ export class FilterService {
       case 'equal':
         return { query: `e.${attr} = :${key}`, params: { [key]: val } };
 
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+
       default:
         throw new BadRequestException(`Unsupported operator for select: ${op}`);
     }
   }
 
-  private buildMultiSelectCondition(attr: string, val: any[], key: string) {
-    if (!Array.isArray(val)) {
-      throw new BadRequestException(`Expected array for multiselect: ${attr}`);
+  private buildMultiSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        if (!Array.isArray(val)) {
+          throw new BadRequestException(
+            `Value for multi-select must be an array for operator: ${op}`,
+          );
+        }
+        return { query: `e.${attr} IN (:...${key})`, params: { [key]: val } };
+
+      case 'not_equal':
+        if (!Array.isArray(val)) {
+          throw new BadRequestException(
+            `Value for multi-select must be an array for operator: ${op}`,
+          );
+        }
+        return {
+          query: `e.${attr} NOT IN (:...${key})`,
+          params: { [key]: val },
+        };
+
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+
+      default:
+        throw new BadRequestException(
+          `Unsupported operator for multiselect: ${op}`,
+        );
     }
-    return {
-      query: `e.${attr} IN (:...${key})`,
-      params: { [key]: val },
-    };
   }
 }

package/src/module/master/service/master.service.ts

@@ -257,17 +257,27 @@ export class MasterService {
               continue;
             }
 
+            const existingError = errors.find((e) => e.row === i + 1);
+
             if (refData[0].organization_id !== loggedInUser.organization_id) {
-              errors.push({
-                row: i + 1,
-                errors: [
-                  {
-                    field: attr.name,
-                    message: `Reference entity with code ${row[attr.attribute_key]} does not belong to the organization`,
-                  },
-                ],
-              });
-              continue;
+              if (existingError) {
+                existingError.errors.push({
+                  field: attr.name,
+                  message: `Reference entity not found for code: ${row[attr.attribute_key]} does not belong to the organization`,
+                });
+                continue;
+              } else {
+                errors.push({
+                  row: i + 1,
+                  errors: [
+                    {
+                      field: attr.name,
+                      message: `Reference entity with code ${row[attr.attribute_key]} does not belong to the organization`,
+                    },
+                  ],
+                });
+                continue;
+              }
             }
 
             row[attr.attribute_key] = refData[0].id;
@@ -407,11 +417,17 @@ export class MasterService {
           entityMaster,
         );
 
+      const existingError = errors.find((e) => e.row === i + 1);
+
       if (rowErrors?.length > 0) {
-        errors.push({
-          row: i + 1,
-          errors: rowErrors,
-        });
+        if (existingError) {
+          existingError.errors.push(...rowErrors);
+        } else {
+          errors.push({
+            row: i + 1,
+            errors: rowErrors,
+          });
+        }
       }
     }
 
@@ -419,7 +435,7 @@ export class MasterService {
       throw new BadRequestException({
         status: false,
         message: `Validation errors found in the uploaded data.`,
-        details: errors,
+        error: errors,
       });
     }