rez_core 2.2.227 → 2.2.228

package/package.json

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

package/src/app.module.ts

@@ -42,7 +42,6 @@ import { WorkflowAutomationModule } from './module/workflow-automation/workflow-
     DashboardModule,
     CommunicationModule,
     AuthModule,
-    WorkflowAutomationModule,
     ScheduleModule.forRoot(),
   ],
 })

package/src/constant/global.constant.ts

@@ -48,6 +48,7 @@ export const STAGE = 'WFS';
 export const STAGE_GROUP = 'WFSG';
 export const ACTION_CATEGORY = 'WFAC';
 export const WORKFLOW_AUTOMATION = 'WFAM';
+export const WORKFLOW_AUTOMATION_ACTION = 'WFAA';
 export const STAGE_ACTION_MAPPING = 'WFSA';
 export const COMM_TEMPLATE = 'TEM';
 export const ACTION_TEMPLATE_MAPPING = 'WFAT';

package/src/core.module.ts

@@ -14,6 +14,7 @@ import { AuthModule } from './module/auth/auth.module';
 import { LeadModule } from './module/lead/lead.module';
 import { LayoutPreferenceModule } from './module/layout_preference/layout_preference.module';
 import { WorkflowModule } from './module/workflow/workflow.module';
+import { WorkflowAutomationModule } from './module/workflow-automation/workflow-automation.module';
 
 @Global()
 @Module({})
@@ -35,6 +36,7 @@ export class CoreModule {
       LeadModule,
       LayoutPreferenceModule,
       WorkflowModule,
+      WorkflowAutomationModule
     ];
 
     const exportsArray = [
@@ -49,6 +51,7 @@ export class CoreModule {
       LeadModule,
       LayoutPreferenceModule,
       WorkflowModule,
+      WorkflowAutomationModule
     ];
 
     if (isSso) {

package/src/module/enterprise/enterprise.module.ts

@@ -16,7 +16,7 @@ import { SchoolRepository } from './repository/school.repository';
     TypeOrmModule.forFeature([OrganizationData, OrganizationAppMapping]),
     forwardRef(() => UserModule),
     UtilsModule,
-    EntityModule,
+    EntityModule
   ],
   controllers: [OrganizationController],
   providers: [

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

@@ -7,18 +7,21 @@ import { SavedFilterRepositoryService } from './repository/saved-filter.reposito
 import { EntityModule } from '../meta/entity.module';
 import { FilterService } from './service/filter.service';
 import { FilterController } from './controller/filter.controller';
+import { FilterEvaluatorService } from './service/filter-evaluator.service';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([SavedFilterDetail, SavedFilterMaster]),
     forwardRef(() => EntityModule),
+    
   ],
   controllers: [FilterController],
   providers: [
     { provide: 'SavedFilterService', useClass: SavedFilterService },
     SavedFilterRepositoryService,
     FilterService,
+    FilterEvaluatorService
   ],
-  exports: ['SavedFilterService', SavedFilterRepositoryService, FilterService],
+  exports: ['SavedFilterService', SavedFilterRepositoryService, FilterService,FilterEvaluatorService],
 })
 export class FilterModule {}

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

@@ -0,0 +1,86 @@
+import { Injectable } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { SavedFilterDetail } from 'src/module/filter/entity/saved-filter-detail.entity';
+import { FilterService } from './filter.service';
+
+@Injectable()
+export class FilterEvaluatorService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly filterService: FilterService,
+  ) {}
+
+  /**
+   * Check if any of the trigger attributes are modified in this event.
+   * @param oldEntity previous state
+   * @param newEntity new state
+   * @param savedFilterCode code of saved filter that contains trigger attributes
+   * @returns true if at least one trigger attribute changed (and optionally matches value)
+   */
+  async evaluateTriggerAttributes(
+    oldEntity: Record<string, any> | null,
+    newEntity: Record<string, any>,
+    savedFilterCode: string,
+  ): Promise<boolean> {
+    // Fetch trigger filter details
+    const triggerFilters: SavedFilterDetail[] = await this.dataSource.query(
+      `SELECT * 
+       FROM cr_saved_filter_detail 
+       WHERE mapped_filter_code = ?`,
+      [savedFilterCode],
+    );
+  
+    // 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];
+  
+      // 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
+   * @param entityId id of entity to evaluate
+   * @param criteriaFilterCode saved filter code for criteria
+   * @param filterService instance of your FilterService
+   */
+  async evaluateCriteria(
+    entityType: string,
+    criteriaFilterCode: string,
+    entityId: number,
+    loggedInUser: any,
+  ): Promise<boolean> {
+    if (!criteriaFilterCode) return true; // no criteria = always true
+
+    const filterRequest = {
+      entity_type: entityType,
+      savedFilterCode: criteriaFilterCode,
+      queryParams: { id: entityId },
+      page: 1,
+      size: 1,
+      loggedInUser: loggedInUser || { organization_id: null },
+    } as any;
+
+    const result = await this.filterService.applyFilter(filterRequest);
+
+    return result?.data?.entity_list?.length > 0;
+  }
+}

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

@@ -1,5 +1,5 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { BadRequestException, forwardRef, Inject, Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserData } from '../../user/entity/user.entity';
 import { SavedFilterMaster } from '../entity/saved-filter-master.entity';
@@ -9,7 +9,8 @@ import { SavedFilterRepositoryService } from '../repository/saved-filter.reposit
 
 @Injectable()
 export class SavedFilterService extends EntityServiceImpl {
-  constructor(private readonly savedFilterRepo: SavedFilterRepositoryService) {
+  constructor(private readonly savedFilterRepo: SavedFilterRepositoryService
+  ) {
     super();
   }
 

package/src/module/meta/controller/entity.controller.ts

@@ -27,6 +27,7 @@ import * as path from 'path';
 import { UserService } from '../../user/service/user.service';
 import { ENTITYTYPE_USER } from '../../../constant/global.constant';
 import { UserData } from '../../user/entity/user.entity';
+import { WorkflowAutomationEngineService } from 'src/module/workflow-automation/service/workflow-automation-engine.service';
 
 @UseGuards(JwtAuthGuard)
 @Controller('entity')
@@ -35,6 +36,7 @@ export class EntityController {
     private entityService: EntityServiceImpl,
     private reflectionHelper: ReflectionHelper,
     private entityMasterService: EntityMasterService,
+    private readonly workflowAutomationEngineService: WorkflowAutomationEngineService,
   ) {}
 
   @Get('getById/:id')
@@ -163,12 +165,22 @@ export class EntityController {
       );
     }
 
-    return entityService.createEntity(
+    let savedData = await entityService.createEntity(
       entityData,
       loggedInUser as UserData,
       null,
       appcode,
     );
+
+    await this.workflowAutomationEngineService.handleEntityEvent(
+      entityData.entity_type,
+      'CREATE',
+      entityData,
+      null,
+      loggedInUser,
+    );
+
+    return savedData;
   }
 
   @Post('update/:id')
@@ -213,11 +225,20 @@ export class EntityController {
       throw new NotFoundException(`No entity found for id "${id}"`);
     }
 
-    return await entityService.updateEntity(
+    let updatedData = await entityService.updateEntity(
       entityData,
       loggedInUser as UserData,
     );
 
+    await this.workflowAutomationEngineService.handleEntityEvent(
+      entityData.entity_type,
+      'UPDATE',
+      entityData,
+      existingEntity,
+      loggedInUser,
+    );
+
+    return updatedData;
     // return {
     //   success: true,
     //   data: updatedEntity,

package/src/module/meta/entity.module.ts

@@ -58,6 +58,7 @@ import { EntityRelationController } from './controller/entity-relation.controlle
 import { CommonService } from './service/common.service';
 import { EntityMasterRepository } from './repository/entity-master.repository';
 import { EntityMasterController } from './controller/entity-master.controller';
+import { WorkflowAutomationModule } from '../workflow-automation/workflow-automation.module';
 
 @Module({
   imports: [
@@ -77,6 +78,7 @@ import { EntityMasterController } from './controller/entity-master.controller';
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
     UtilsModule,
+    WorkflowAutomationModule
   ],
   providers: [
     EntityMasterService,

package/src/module/meta/service/entity-service-impl.service.ts

@@ -1,6 +1,7 @@
 import { EntityService } from './entity.service';
 import {
   BadRequestException,
+  forwardRef,
   Inject,
   Injectable,
   NotFoundException,
@@ -30,6 +31,7 @@ import { ListMasterItemService } from 'src/module/listmaster/service/list-master
 import { AttributeMasterService } from './attribute-master.service';
 import { ResolverService } from './resolver.service';
 import { NotFound } from '@aws-sdk/client-s3';
+import { WorkflowAutomationEngineService } from 'src/module/workflow-automation/service/workflow-automation-engine.service';
 
 @Injectable()
 export class EntityServiceImpl implements EntityService<BaseEntity> {
@@ -124,7 +126,9 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       if (!entityData.status) entityData.status = statusList[0].id;
     }
 
-    return repo.save(entityData);
+    let savedData = repo.save(entityData);
+  
+    return savedData;
   }
 
   async deleteEntity(entityType: string, entityId: number, loggedInUser) {

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

@@ -27,6 +27,8 @@ import { ServiceResult } from 'src/dtos/response.dto';
 import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { OrganizationRepository } from 'src/module/enterprise/repository/organization.repository';
 import { InjectRepository } from '@nestjs/typeorm';
+import { Action } from 'src/module/workflow-automation/interface/action.interface';
+import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
 
 @Injectable()
 export class UserService extends EntityServiceImpl {
@@ -135,6 +137,11 @@ export class UserService extends EntityServiceImpl {
     return { success: true, data: savedData };
   }
 
+  name : string = 'UserService';
+  async execute(payload: any): Promise<any> {
+    console.log('payload', payload);
+  }
+
   async getEntityData(
     entityType: string,
     id: number,

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

@@ -0,0 +1,26 @@
+import { WORKFLOW_AUTOMATION_ACTION } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_workflow_automation_action' })
+export class WorkflowAutomationActionEntity extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = WORKFLOW_AUTOMATION_ACTION;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  workflow_automation_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  action_category_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  payload: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  action_decorator: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  entity_method: string;
+}

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

@@ -23,7 +23,4 @@ export class WorkflowAutomation extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   criteria_filter_code: string;
-
-  @Column({ nullable: true })
-  is_active: boolean;
 }

package/src/module/workflow-automation/interface/action.decorator.ts

@@ -0,0 +1,7 @@
+// src/module/workflow-automation/interface/action.decorator.ts
+import { SetMetadata } from '@nestjs/common';
+
+export const ACTION_HANDLER = 'ACTION_HANDLER';
+
+export const ActionHandler = (actionName: string) =>
+  SetMetadata(ACTION_HANDLER, actionName);

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

@@ -0,0 +1,5 @@
+// package/src/interfaces/action.interface.ts
+export interface Action {
+  name: string; // unique identifier of the action
+  execute(payload: any): Promise<any>; // execution logic
+}

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

@@ -0,0 +1,35 @@
+// src/module/workflow-automation/service/action-registry.service.ts
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, ModuleRef, Reflector } from '@nestjs/core';
+import { WorkflowAutomationEngineService } from './workflow-automation-engine.service';
+import { Action } from '../interface/action.interface';
+import { ACTION_HANDLER } from '../interface/action.decorator';
+
+@Injectable()
+export class ActionRegistryService implements OnModuleInit {
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    private readonly moduleRef: ModuleRef,
+    private readonly reflector: Reflector,
+    private readonly engine: WorkflowAutomationEngineService,
+  ) {}
+
+  onModuleInit() {
+    const providers = this.discoveryService.getProviders();
+
+    for (const wrapper of providers) {
+      const { instance } = wrapper;
+      if (!instance) continue;
+
+      const actionName = this.reflector.get<string>(
+        ACTION_HANDLER,
+        instance.constructor,
+      );
+
+      if (actionName) {
+        this.engine.registerAction(actionName, instance as Action);
+        console.log(`✅ Registered action handler: ${actionName}`);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,76 @@
+// package/src/services/workflow-automation-engine.service.ts
+import { Injectable, Inject } from '@nestjs/common';
+import { WorkflowAutomationService } from './workflow-automation.service';
+import { FilterEvaluatorService } from '../../filter/service/filter-evaluator.service';
+import { Action } from '../interface/action.interface';
+
+@Injectable()
+export class WorkflowAutomationEngineService {
+  private readonly actions = new Map<string, Action>();
+
+  constructor(
+    @Inject('WorkflowAutomationService')
+    private readonly wfService: WorkflowAutomationService,
+    private readonly filterEvaluator: FilterEvaluatorService,
+  ) {}
+
+  registerAction(actionName: string, actionInstance: Action) {
+    this.actions.set(actionName, actionInstance);
+  }
+
+  /**
+   * Called from entity hooks (CREATE / UPDATE / DELETE)
+   */
+  async handleEntityEvent(entityType, eventType, newEntity, oldEntity, user) {
+    const workflows = await this.wfService.getActiveRules(
+      entityType,
+      eventType,
+    );
+
+    for (const wf of workflows) {
+      const eventMatched = await this.filterEvaluator.evaluateTriggerAttributes(
+        oldEntity,
+        newEntity,
+        wf.condition_filter_code,
+      );
+      if (!eventMatched) continue;
+
+      const criteriaMatched = await this.filterEvaluator.evaluateCriteria(
+        entityType,
+        wf.criteria_filter_code,
+        newEntity.id,
+        user,
+      );
+      if (!criteriaMatched) continue;
+
+      await this.executeActions(wf.id, newEntity, user);
+    }
+  }
+
+  private async executeActions(
+    workflow_automation_id: number,
+    entity: any,
+    user: any,
+  ) {
+    // 1. Load actions for this rule from DB
+    const actions = await this.wfService.getActionsForRule(
+      workflow_automation_id,
+    );
+    // (this should fetch from cr_workflow_automation_action)
+
+    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}`,
+        );
+        continue;
+      }
+
+      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

@@ -1,10 +1,58 @@
 import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { DataSource } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { WorkflowAutomation } from '../entity/workflow-automation.entity';
+import { WorkflowAutomationActionEntity } from '../entity/workflow-automation-action.entity';
 
 @Injectable()
-export class WorkflowAutomationService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
-    super();
+export class WorkflowAutomationService {
+  constructor(
+    @InjectRepository(WorkflowAutomation)
+    private readonly wfRepo: Repository<WorkflowAutomation>,
+    @InjectRepository(WorkflowAutomationActionEntity)
+    private readonly actionRepo: Repository<WorkflowAutomationActionEntity>,
+  ) {}
+
+  async createRule(
+    data: Partial<WorkflowAutomation>,
+  ): Promise<WorkflowAutomation> {
+    const rule = this.wfRepo.create(data);
+    return this.wfRepo.save(rule);
+  }
+
+  async updateRule(
+    id: number,
+    data: Partial<WorkflowAutomation>,
+  ): Promise<WorkflowAutomation | null> {
+    await this.wfRepo.update(id, data);
+    return this.wfRepo.findOneBy({ id });
+  }
+
+  async deleteRule(id: number): Promise<void> {
+    await this.wfRepo.delete(id);
+  }
+
+  async getRule(id: number): Promise<WorkflowAutomation | null> {
+    return this.wfRepo.findOneBy({ id });
+  }
+
+  async getActiveRules(
+    entityType: string,
+    event: string,
+  ): Promise<WorkflowAutomation[]> {
+    return this.wfRepo.find({
+      where: {
+        mapped_entity_type: entityType,
+        trigger_event: event,
+      },
+    });
+  }
+
+  async getActionsForRule(
+    workflow_automation_id: number,
+  ): Promise<WorkflowAutomationActionEntity[]> {
+    return this.actionRepo.find({
+      where: { workflow_automation_id },
+    });
   }
 }

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

@@ -1,19 +1,32 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { DiscoveryModule } from '@nestjs/core';
 import { WorkflowAutomation } from './entity/workflow-automation.entity';
 import { WorkflowAutomationController } from './controller/workflow-automation.controller';
+import { WorkflowAutomationEngineService } from './service/workflow-automation-engine.service';
+import { FilterModule } from '../filter/filter.module';
 import { WorkflowAutomationService } from './service/workflow-automation.service';
-import { EntityModule } from '../meta/entity.module';
+import { WorkflowAutomationActionEntity } from './entity/workflow-automation-action.entity';
+import { ActionRegistryService } from './service/action-registery.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([WorkflowAutomation]), EntityModule],
+  imports: [
+    TypeOrmModule.forFeature([
+      WorkflowAutomation,
+      WorkflowAutomationActionEntity,
+    ]),
+    FilterModule,
+    DiscoveryModule, // 👈 enables provider scanning
+  ],
   providers: [
+    WorkflowAutomationEngineService,
     {
       provide: 'WorkflowAutomationService',
       useClass: WorkflowAutomationService,
     },
+    ActionRegistryService, // 👈 auto-registers actions
   ],
-  exports: [],
+  exports: [WorkflowAutomationEngineService, 'WorkflowAutomationService'],
   controllers: [WorkflowAutomationController],
 })
 export class WorkflowAutomationModule {}

package/src/module/user/test/user.controller.spec.ts

@@ -1,61 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { UserService } from '../service/user.service';
-import { ForbiddenException } from '@nestjs/common';
-import { UserController } from '../controller/user.controller';
-
-describe('UserController', () => {
-  let userController: UserController;
-  let userService: UserService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [UserController],
-      providers: [
-        {
-          provide: 'UserService',
-          useValue: {
-            checkEmailExists: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    userController = module.get<UserController>(UserController);
-    userService = module.get<UserService>('UserService');
-  });
-
-  describe('checkEmail', () => {
-    it('✅ should return success response when email exists', async () => {
-      const mockResponse = {
-        success: true,
-        message:
-          'An account already exists for this email address. Login or use a different email address to sign up.',
-        userId: 101,
-      };
-
-      (userService.checkEmailExists as jest.Mock).mockResolvedValue(
-        mockResponse,
-      );
-
-      const result = await userController.checkEmail('test@example.com');
-
-      expect(result).toEqual(mockResponse);
-      expect(userService.checkEmailExists).toHaveBeenCalledWith(
-        'test@example.com',
-      );
-    });
-
-    it('❌ should throw ForbiddenException when email does not exist', async () => {
-      (userService.checkEmailExists as jest.Mock).mockRejectedValue(
-        new ForbiddenException('No account found with this email address.'),
-      );
-
-      await expect(
-        userController.checkEmail('notfound@example.com'),
-      ).rejects.toThrow(ForbiddenException);
-      expect(userService.checkEmailExists).toHaveBeenCalledWith(
-        'notfound@example.com',
-      );
-    });
-  });
-});