rez_core 2.2.263 → 3.1.0

package/package.json

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

package/src/module/filter/controller/filter.controller.ts

@@ -48,7 +48,7 @@ export class FilterController {
       sortby,
     } = body;
 
-    return this.filterService.applyFilter({
+    return this.filterService.applyFilterWrapper({
       entity_type,
       quickFilter,
       savedFilterCode,

package/src/module/filter/dto/filter-request.dto.ts

@@ -2,9 +2,13 @@ import { UserData } from 'src/module/user/entity/user.entity';
 
 // src/module/filter/dto/filter-request.dto.ts
 export interface FilterCondition {
+  filter_entity_type: string; // main or sub-entity code (e.g. LEAD, CONTACT, ORG)
   filter_attribute: string;
   filter_operator: string;
-  filter_value?: string | number | boolean;
+  filter_value?: string | number | boolean | (string | number | boolean)[];
+  filter_attribute_name?: string; // NEW - main/sub entity type (e.g. LEAD, CONTACT, ORG)
+  filter_attribute_data_type?: string;
+  filter_entity_name?: string;  
 }
 
 export interface TabsConfig {
@@ -19,7 +23,7 @@ export interface SortConfig {
 export interface FilterRequestDto {
   entity_type: string;
   quickFilter?: FilterCondition[];
-  savedFilterCode?: string;
+  savedFilterCode?: string | null ;
   attributeFilter?: FilterCondition[];
   sortby?: SortConfig[];
   tabs?: TabsConfig;

package/src/module/filter/entity/saved-filter-detail.entity.ts

@@ -10,7 +10,10 @@ export class SavedFilterDetail extends BaseEntity {
   }
 
   @Column()
-  mapped_filter_code: string; // This links to SavedFilterMaster.code (no relation, manual)
+  mapped_filter_code: string; // links to SavedFilterMaster.code (manual, not FK)
+
+  @Column()
+  filter_entity_type: string; // NEW - main/sub entity type (e.g. LEAD, CONTACT, ORG)
 
   @Column()
   filter_attribute: string;
@@ -18,6 +21,15 @@ export class SavedFilterDetail extends BaseEntity {
   @Column()
   filter_operator: string;
 
+  @Column()
+  filter_attribute_name: string; // NEW - main/sub entity type (e.g. LEAD, CONTACT, ORG)
+
+  @Column()
+  filter_attribute_data_type: string;
+
+  @Column()
+  filter_entity_name: string;
+
   @Column()
   filter_value: string;
 

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

@@ -23,42 +23,38 @@ export class FilterEvaluatorService {
     savedFilterCode: string,
   ): Promise<boolean> {
     // Fetch trigger filter details
-    console.log("IN FILTER EVALUATOR SERVICE");
+    console.log('IN FILTER EVALUATOR SERVICE');
     const triggerFilters: SavedFilterDetail[] = await this.dataSource.query(
       `SELECT * 
        FROM cr_saved_filter_detail 
        WHERE mapped_filter_code = ?`,
       [savedFilterCode],
     );
-  
-    console.log(triggerFilters, 'triggerFilters');
 
     // If no trigger filters defined, just return true (so criteria can run)
     if (!triggerFilters || triggerFilters.length === 0) {
       return true;
     }
-  
+
     const oldState = oldEntity || {};
-  
+
     // Check each trigger attribute
     for (const filter of triggerFilters) {
       const attr = filter.filter_attribute;
       const expectedValue = filter.filter_value;
-  
+
       const oldVal = oldState[attr];
       const newVal = newEntity[attr];
-  
-      console.log(oldVal, newVal, expectedValue, 'comparing values');
       // If value changed and (no expected value defined OR matches expected)
       if (oldVal !== newVal && (!expectedValue || newVal == expectedValue)) {
         return true;
       }
     }
-  
+
     // No trigger attribute matched
     return false;
   }
-  
+
   /**
    * Evaluate the criteria for an entity using the filter service
    * @param entityType type of entity
@@ -83,9 +79,7 @@ export class FilterEvaluatorService {
       loggedInUser: loggedInUser || { organization_id: null },
     } as any;
 
-    console.log(filterRequest, 'filterRequest');
-
-    const result = await this.filterService.applyFilter(filterRequest);
+    const result = await this.filterService.applyFilterWrapper(filterRequest);
 
     return result?.data?.entity_list?.length > 0;
   }

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

@@ -4,7 +4,7 @@ import { EntityMasterService } from 'src/module/meta/service/entity-master.servi
 import { EntityTableColumnService } from 'src/module/meta/service/entity-table-column.service';
 import { EntityTableService } from 'src/module/meta/service/entity-table.service';
 import { DataSource } from 'typeorm';
-import { FilterRequestDto } from '../dto/filter-request.dto';
+import { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
 import { SavedFilterService } from './saved-filter.service';
 
 import * as moment from 'moment';
@@ -13,8 +13,8 @@ import * as moment from 'moment';
 export class FilterService {
   constructor(
     private dataSource: DataSource,
-    private readonly entityTableService: EntityTableService,
-    private readonly entityTableColumnService: EntityTableColumnService,
+    private readonly attributeMasterService: AttributeMasterService,
+    private readonly entityMasterService: EntityMasterService,
     @Inject('SavedFilterService')
     private readonly savedFilterService: SavedFilterService,
   ) {}
@@ -69,6 +69,86 @@ export class FilterService {
     ];
   }
 
+  async applyFilterWrapper(dto: FilterRequestDto) {
+    const {
+      entity_type,
+      quickFilter = [],
+      savedFilterCode,
+      attributeFilter = [],
+    } = dto;
+
+    // 🔹 Step 1: Collect all filters (from body + savedFilter)
+    const savedFilters = await this.getSavedFilters(
+      savedFilterCode ?? undefined,
+    );
+    const allFilters = [
+      ...quickFilter,
+      ...attributeFilter,
+      ...savedFilters,
+    ].filter((f) => f.filter_value !== '');
+
+    // 🔹 Step 2: Group filters by filter_entity_type
+    const grouped = allFilters.reduce(
+      (acc, f) => {
+        if (!acc[f.filter_entity_type]) acc[f.filter_entity_type] = [];
+        acc[f.filter_entity_type].push(f);
+        return acc;
+      },
+      {} as Record<string, any[]>,
+    );
+
+    // 🔹 Step 3: Handle sub-entities first
+    let intersectionIds: number[] | null = null;
+    for (const [subEntityType, filters] of Object.entries(grouped)) {
+      if (subEntityType === entity_type) continue; // skip main entity for now
+
+      let { queryParams, ...newDto } = dto;
+
+      const subDto: FilterRequestDto = {
+        ...newDto,
+        entity_type: subEntityType,
+        quickFilter: filters as FilterCondition[],
+        savedFilterCode: null, // already merged
+        attributeFilter: [],
+      };
+
+      const subResult = await this.applyFilter(subDto);
+
+      // extract parent ids from sub entity result
+      const parentIds = subResult.data.entity_list.map((row) => row.parent_id);
+
+      // keep intersection
+      intersectionIds =
+        intersectionIds === null
+          ? parentIds
+          : intersectionIds.filter((id) => parentIds.includes(id));
+
+      // early exit if no intersection
+      if (intersectionIds.length === 0) {
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} },
+        };
+      }
+    }
+
+    // 🔹 Step 4: Call applyFilter for main entity
+    const mainFilters = grouped[entity_type] || [];
+    const mainDto: FilterRequestDto = {
+      ...dto,
+      quickFilter: mainFilters,
+      savedFilterCode: null,
+      attributeFilter: [],
+    };
+
+    // pass intersection ids as an extra constraint
+    if (intersectionIds && intersectionIds.length > 0) {
+      mainDto['restrictIds'] = intersectionIds;
+    }
+
+    return this.applyFilter(mainDto);
+  }
+
   async applyFilter(dto: FilterRequestDto) {
     const {
       entity_type,
@@ -94,7 +174,7 @@ export class FilterService {
     } = loggedInUser || {};
 
     // Fetch meta from entity table service
-    const entityMeta = await this.entityTableService.getEntityData(
+    const entityMeta = await this.entityMasterService.getEntityData(
       entity_type,
       loggedInUser,
     );
@@ -105,29 +185,25 @@ export class FilterService {
     }
 
     // get table meta from cr_entity_table
-    const getTableMeta =
-      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
-        entity_type,
-        entity_type,
-        'LIST',
-        organization_id,
-      );
-
-    if (!getTableMeta) {
-      throw new BadRequestException(
-        `Table meta not found for entity_type: ${entity_type}`,
-      );
-    }
+    // const getTableMeta =
+    //   await this.attributeMasterService.findAttributesByMappedEntityType(
+    //     entity_type,
+    //     loggedInUser,
+    //   );
+
+    // if (!getTableMeta) {
+    //   throw new BadRequestException(
+    //     `Table meta not found for entity_type: ${entity_type}`,
+    //   );
+    // }
 
-    const getTableColumnMeta =
-      await this.entityTableColumnService.findByParentIdAndParentType(
-        getTableMeta.id,
-        getTableMeta.entity_type,
-        true,
+    const getAttributeColumnMeta =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entity_type,
+        loggedInUser,
       );
 
-
-    const attributeMetaMap = getTableColumnMeta.reduce(
+    const attributeMetaMap = getAttributeColumnMeta.reduce(
       (acc, attr) => {
         acc[attr.attribute_key] = attr;
         return acc;
@@ -136,19 +212,27 @@ export class FilterService {
     );
 
     // Get and parse saved filters
-    console.log("IN FILTER SERVICE",savedFilterCode);
-    const savedFilters = await this.getSavedFilters(savedFilterCode);
-    console.log("SAVED FILTERS", savedFilters);
-    const savedFiltersNormalized = savedFilters.map(f => ({
+    console.log('IN FILTER SERVICE', savedFilterCode);
+    const savedFilters = await this.getSavedFilters(
+      savedFilterCode ?? undefined,
+    );
+    console.log('SAVED FILTERS', savedFilters);
+    const savedFiltersNormalized = savedFilters.map((f) => ({
       filter_attribute: f.filter_attribute,
       filter_operator: f.filter_operator,
-      filter_value: f.filter_value
+      filter_value: f.filter_value,
     }));
-    
+
     const baseFilters = [
-      ...(quickFilter || []).filter(f => f.filter_value != null && f.filter_value !== ''),
-      ...savedFiltersNormalized.filter(f => f.filter_value != null && f.filter_value !== ''),
-      ...(attributeFilter || []).filter(f => f.filter_value != null && f.filter_value !== ''),
+      ...(quickFilter || []).filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+      ...savedFiltersNormalized.filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+      ...(attributeFilter || []).filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
     ];
 
     // Build where clauses
@@ -228,7 +312,6 @@ export class FilterService {
       [user_id, entity_type, level_id, level_type],
     );
 
-
     // Extract layout preference
     const layout = layoutPreference?.[0]?.mapped_json?.quick_tab || {};
 
@@ -237,13 +320,13 @@ export class FilterService {
     let allTabs;
     if (layout.attribute) {
       allTabs = await this.gettab_value_counts(
-        getTableMeta.data_source,
+        entityMeta?.data_source,
         layout.attribute,
         baseWhere,
       );
     } else {
       allTabs = await this.gettab_value_counts(
-        getTableMeta.data_source,
+        entityMeta?.data_source,
         tabs?.columnName,
         baseWhere,
       );
@@ -431,7 +514,6 @@ export class FilterService {
     const size = dto.size && dto.size > 0 ? dto.size : 10;
     qb.skip((page - 1) * size).take(size);
 
-
     const entity_list = await qb.getRawMany();
 
     // 1. Extract all date-type attribute keys

package/src/module/meta/entity/attribute-master.entity.ts

@@ -20,6 +20,14 @@ export class AttributeMaster extends BaseEntity {
   })
   data_source_type: string;
 
+  @Column({
+    name: 'data_type',
+    type: 'varchar',
+    nullable: true,
+    length: 50,
+  })
+  data_type: string;
+
   @Column({ name: 'datasource_list', type: 'varchar', nullable: true })
   datasource_list: string;
 

package/src/module/user/entity/role.entity.ts

@@ -24,4 +24,10 @@ export class Role extends BaseEntity {
 
   @Column({ type: 'int', nullable: true })
   is_factory: number;
+
+  @Column({ type: 'varchar', length: 250, nullable: true })
+  parent_type: string;
+
+  @Column({ type: 'int', nullable: true })
+  parent_id: number;
 }

package/src/module/user/service/user.service.ts

@@ -31,7 +31,7 @@ import { Action } from 'src/module/workflow-automation/interface/action.interfac
 import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
 
 @Injectable()
-@ActionHandler('User')  
+@ActionHandler('User')
 export class UserService extends EntityServiceImpl implements Action {
   constructor(
     private userRepository: UserRepository,
@@ -138,7 +138,7 @@ export class UserService extends EntityServiceImpl implements Action {
     return { success: true, data: savedData };
   }
 
-  name : string = 'UserService';
+  name: string = 'UserService';
   async execute(payload: any): Promise<any> {
     console.log('payload', payload);
   }

package/src/module/workflow/controller/action-category.controller.ts

@@ -44,4 +44,11 @@ export class ActionCategoryController {
     const result = this.actionCategoryService.getActionCategory(action_cat_id);
     return result;
   }
+
+  @Post('/actionscategoryinfo')
+  @HttpCode(HttpStatus.OK)
+  async actionscategoryinfo(@Body('entity_type') entity_type: string) {
+    const result = this.actionCategoryService.actionscategoryinfo(entity_type);
+    return result;
+  }
 }

package/src/module/workflow/repository/action-category.repository.ts

@@ -53,4 +53,27 @@ export class ActionCategoryRepository {
 
     return result;
   }
+
+  async actionscategoryinfo(entity_type: string) {
+    const result = await this.actionCategoryRepository
+      .createQueryBuilder('ac')
+      .select(['ac.id', 'ac.name', 'ac.logo', 'ac.modalName'])
+      .where('ac.mapped_entity_type = :entityType', { entityType: entity_type })
+      .getRawMany();
+
+    const mapped = result.map((row) => ({
+      label: row.ac_name,
+      logo: row.ac_logo,
+      modalName: row.ac_modalName,
+      value: String(row.ac_id),
+    }));
+
+    return mapped.reduce(
+      (acc, { value, ...rest }) => {
+        acc[value] = rest;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+  }
 }

package/src/module/workflow/service/action-category.service.ts

@@ -26,4 +26,8 @@ export class ActionCategoryService extends EntityServiceImpl {
   async getActionCategory(action_cat_id: number) {
     return this.actionCategoryRepository.getActionCategory(action_cat_id);
   }
+
+  async actionscategoryinfo(entity_type: string) {
+    return this.actionCategoryRepository.actionscategoryinfo(entity_type);
+  }
 }

package/src/module/workflow/service/task.service.ts

@@ -8,8 +8,10 @@ import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
 import { ActivityLogService } from './activity-log.service';
 import { ACTIVITY_CATEGORIES } from '../repository/activity-log.repository';
 import { MediaDataService } from 'src/module/meta/service/media-data.service';
+import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
 
 @Injectable()
+@ActionHandler('add_task')
 export class TaskService extends EntityServiceImpl {
   constructor(
     private readonly taskRepository: TaskRepository,
@@ -21,6 +23,49 @@ export class TaskService extends EntityServiceImpl {
   ) {
     super();
   }
+  name: string = 'add_task';
+
+  async execute(payload: any): Promise<any> {
+    console.log('BHUSHAN');
+    const { entity, user, config } = payload;
+
+    let toValue: string | null = null;
+
+    // 2. Get current stage_id from cr_wf_stage_movement_data
+    const stageRow = await this.dataSource.query(
+      `SELECT stage_id
+       FROM cr_wf_stage_movement_data
+      WHERE mapped_entity_id = ? 
+        AND is_current = 'Y'
+      LIMIT 1`,
+      [entity.id],
+    );
+
+    const stageId = stageRow.length > 0 ? stageRow[0].stage_id : null;
+
+    if (!stageId) {
+      throw new Error(
+        `No current stage found in cr_wf_stage_movement_data for entity_id=${entity.id}`,
+      );
+    }
+
+    // 3. Build entityData
+    const entityData = {
+      ...config,
+      mapped_entity_id: entity.id,
+      mapped_entity_type: entity.entity_type,
+      task_owner: config.task_owner,
+      stage_id: stageId,
+      status: config.status,
+      due_date: config.due_date,
+      due_time: config.due_time,
+      reminder: config.reminder,
+      description: config.description,
+      is_mandatory: config.is_mandatory,
+    };
+
+    return await this.createEntity(entityData, user);
+  }
 
   async createEntity(
     entityData: any,

package/src/module/workflow-automation/entity/workflow-automation-action.entity.ts

@@ -25,5 +25,5 @@ export class WorkflowAutomationActionEntity extends BaseEntity {
   entity_method: string;
 
   @Column({ type: 'varchar', nullable: true })
-  action_category_name: string;
+  actionCategoryName: string;
 }

package/src/module/workflow-automation/service/workflow-automation-engine.service.ts

@@ -29,12 +29,15 @@ export class WorkflowAutomationEngineService {
     user: any,
     preUpdateStates?: Record<number, boolean> | null,
   ) {
-    const workflows = await this.wfService.getActiveRules(entityType, eventType);
-  
+    const workflows = await this.wfService.getActiveRules(
+      entityType,
+      eventType,
+    );
+
     for (const wf of workflows) {
       // Step 1️⃣ Condition / Trigger evaluation
       let triggerMatched = false;
-  
+
       if (eventType === 'CREATE') {
         triggerMatched = await this.filterEvaluator.evaluateCriteria(
           entityType,
@@ -52,15 +55,15 @@ export class WorkflowAutomationEngineService {
         );
         triggerMatched = before !== after && after === true;
       }
-  
+
       // 🔍 Log Step 1 result
       console.log(
         `[Workflow:${wf.id}] Step 1 - Trigger matched:`,
         triggerMatched,
       );
-  
+
       if (!triggerMatched) continue;
-  
+
       // Step 2️⃣ Final criteria evaluation
       const criteriaMatched = await this.filterEvaluator.evaluateCriteria(
         entityType,
@@ -68,20 +71,19 @@ export class WorkflowAutomationEngineService {
         newEntity.id,
         user,
       );
-  
+
       // 🔍 Log Step 2 result
       console.log(
         `[Workflow:${wf.id}] Step 2 - Criteria matched:`,
         criteriaMatched,
       );
-  
+
       if (!criteriaMatched) continue;
-  
+
       // Step 3️⃣ Execute workflow actions
       await this.executeActions(wf.id, newEntity, user);
     }
   }
-  
 
   private async executeActions(
     workflow_automation_id: number,
@@ -89,17 +91,22 @@ export class WorkflowAutomationEngineService {
     user: any,
   ) {
     // Load actions for this rule from DB
-    const actions = await this.wfService.getActionsForRule(workflow_automation_id);
-    console.log(actions, 'actions found');
+    const actions = await this.wfService.getActionsForRule(
+      workflow_automation_id,
+    );
 
     for (const action of actions) {
       const impl = this.actions.get(String(action.action_decorator)); // action_code = registered name
       if (!impl) {
-        console.warn(`⚠️ No implementation found for action: ${action.action_decorator}`);
+        console.warn(
+          `⚠️ No implementation found for action: ${action.action_decorator}`,
+        );
         continue;
       }
 
-      console.log(`🚀 Executing action ${action.action_decorator} for entity ${entity.id}`);
+      console.log(
+        `🚀 Executing action ${action.action_decorator} for entity ${entity.id}`,
+      );
       await impl.execute({ entity, user, config: action.payload });
     }
   }

package/src/module/workflow-automation/service/workflow-automation.service.ts

@@ -199,8 +199,8 @@ export class WorkflowAutomationService extends EntityServiceImpl {
         if (existing) {
           // update
           existing.payload = a.actionPayload ?? {};
-          existing.action_category_name =
-            a.actionCategoryName ?? existing.action_category_name;
+          existing.actionCategoryName =
+            a.actionCategoryName ?? existing.actionCategoryName;
           await this.dataSource
             .getRepository(WorkflowAutomationActionEntity)
             .save(existing);
@@ -211,7 +211,7 @@ export class WorkflowAutomationService extends EntityServiceImpl {
           actionEntity.entity_type = 'WFAA';
           actionEntity.workflow_automation_id = workflow.id;
           actionEntity.action_category_id = a.actionCategory;
-          actionEntity.action_category_name = a.action_category_name;
+          actionEntity.actionCategoryName = a.actionCategoryName;
           actionEntity.payload = a.actionPayload ?? {};
 
           await this.dataSource
@@ -313,7 +313,7 @@ export class WorkflowAutomationService extends EntityServiceImpl {
 
     const action = actions.map((a) => ({
       actionCategory: a.action_category_id,
-      actionCategoryName: a.action_category_name,
+      actionCategoryName: a.actionCategoryName,
       actionPayload: a.payload,
     }));
 

package/.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint"
-    ]
-}