rez_core 4.0.183 → 4.0.184

package/src/module/entity_json/service/entity_json.service.ts

@@ -1,134 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { AttributeMaster } from 'src/module/meta/entity/attribute-master.entity';
-import { EntityRelation } from 'src/module/meta/entity/entity-relation.entity';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { DataSource } from 'typeorm';
-
-@Injectable()
-export class EntityJSONService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
-    super();
-  }
-
-  async getAttributeForFlatJSON(
-    entityType: string,
-    loggedInUser: any,
-  ): Promise<any[]> {
-    const result: any[] = [];
-    const orgId = loggedInUser.organization_id;
-
-    // 1. GET MAIN ENTITY ATTRIBUTES
-
-    const mainEntityAttributes = await this.dataSource
-      .getRepository(AttributeMaster)
-      .find({
-        where: {
-          mapped_entity_type: entityType,
-          organization_id: orgId,
-        },
-      });
-
-    result.push({
-      entity_type: entityType,
-      attributes: mainEntityAttributes,
-    });
-
-    // 2. GET RELATED ENTITY TYPES
-
-    const relatedEntities = await this.dataSource
-      .getRepository(EntityRelation)
-      .find({
-        where: {
-          source_entity_type: entityType,
-          organization_id: orgId,
-          relation_type: 'ONE_TO_ONE',
-        },
-      });
-
-    const relatedEntityTypes = relatedEntities.map(
-      (rel) => rel.target_entity_type,
-    );
-
-    // 3. LOOP RELATED ENTITIES
-
-    for (const relatedType of relatedEntityTypes) {
-      const attributes = await this.dataSource
-        .getRepository(AttributeMaster)
-        .find({
-          where: {
-            mapped_entity_type: relatedType,
-            organization_id: orgId,
-          },
-        });
-
-      result.push({
-        entity_type: relatedType,
-        attributes,
-      });
-    }
-
-    // 4. GET ALL ATTRIBUTES FOR ENTITY LINKED ATTRIBUTES
-    const linkedAttributes = await this.dataSource
-      .createQueryBuilder()
-      .select(['fla.applicable_entity_type', 'fea.*'])
-      .from('frm_linked_attribute', 'fla')
-      .innerJoin(
-        'frm_entity_attribute',
-        'fea',
-        'fla.applicable_entity_type = fea.mapped_entity_type AND fla.applicable_attribute_key = fea.attribute_key',
-      )
-      .where('fea.organization_id = :orgId', { orgId })
-      .getRawMany();
-
-    result.push({
-      linked_attributes: linkedAttributes,
-    });
-    return result;
-  }
-
-  async updateEntityJSON(
-    entityType: string,
-    entityId: number,
-    loggedInUser,
-  ): Promise<any[]> {
-    const newEntityJSON: any[] = [];
-
-    // 1. FETCH ENTITY DATA FOR ENTITY TYPE AND ID
-    const entityData = await this.getResolvedEntityData(
-      entityType,
-      entityId,
-      loggedInUser,
-    );
-
-    newEntityJSON.push({
-      entity_type: entityType,
-      data: entityData,
-    });
-
-    // 2. FETCH RELATED ENTITY DATA FOR ONE-TO-ONE RELATIONS
-    const relations = await this.dataSource.query(
-      `SELECT target_entity_id, target_entity_type
-                 FROM frm_entity_relation_data
-                 WHERE source_entity_type = ?
-                   AND source_entity_id = ?`,
-      [entityType, entityId],
-    );
-
-    for (const rel of relations) {
-      const relatedEntityData = await this.getResolvedEntityData(
-        rel.target_entity_type,
-        rel.target_entity_id,
-        loggedInUser,
-      );
-
-      newEntityJSON.push({
-        entity_type: rel.target_entity_type,
-        data: relatedEntityData,
-      });
-    }
-
-    // 3. TODO: SAVE THE newEntityJSON in frm_entity_json TABLE
-
-    return newEntityJSON;
-  }
-}

package/src/module/linked_attributes/controller/linked_attributes.controller.ts

@@ -1,10 +0,0 @@
-import { Controller, Inject } from '@nestjs/common';
-import { LinkedAttributesService } from '../service/linked_attributes.service';
-
-@Controller('linked-attributes')
-export class LinkedAttributesController {
-  constructor(
-    @Inject('LinkedAttributesService')
-    private readonly linkedAttributesService: LinkedAttributesService,
-  ) {}
-}

package/src/module/linked_attributes/entity/linked_attribute.entity.ts

@@ -1,48 +0,0 @@
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { Column, Entity } from 'typeorm';
-
-@Entity({ name: 'frm_linked_attribute' })
-export class LinkedAttributes extends BaseEntity {
-  @Column({ name: 'field_name', type: 'varchar', length: 100, nullable: true })
-  field_name: string;
-
-  @Column({
-    name: 'attribute_key',
-    type: 'varchar',
-    length: 100,
-    nullable: true,
-  })
-  attribute_key: string;
-
-  @Column({
-    name: 'applicable_attribute_key',
-    type: 'varchar',
-    length: 100,
-    nullable: true,
-  })
-  applicable_attribute_key: string;
-
-  @Column({
-    name: 'mapped_entity_type',
-    type: 'varchar',
-    length: 50,
-    nullable: true,
-  })
-  mapped_entity_type: string;
-
-  @Column({
-    name: 'applicable_entity_type',
-    type: 'varchar',
-    length: 50,
-    nullable: true,
-  })
-  applicable_entity_type: string;
-
-  @Column({
-    name: 'saved_filter_code',
-    type: 'varchar',
-    length: 100,
-    nullable: true,
-  })
-  saved_filter_code: string;
-}

package/src/module/linked_attributes/linked_attributes.module.ts

@@ -1,16 +0,0 @@
-import { Module } from '@nestjs/common';
-import { EntityModule } from '../meta/entity.module';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { LinkedAttributes } from './entity/linked_attribute.entity';
-import { LinkedAttributesController } from './controller/linked_attributes.controller';
-import { LinkedAttributesService } from './service/linked_attributes.service';
-
-@Module({
-  imports: [EntityModule, TypeOrmModule.forFeature([LinkedAttributes])],
-  controllers: [LinkedAttributesController],
-  providers: [
-    { provide: 'LinkedAttributesService', useClass: LinkedAttributesService },
-  ],
-  exports: ['LinkedAttributesService'],
-})
-export class LinkedAttributesModule {}

package/src/module/linked_attributes/repository/linked_attribute.repository.ts

@@ -1,12 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { LinkedAttributes } from '../entity/linked_attribute.entity';
-
-@Injectable()
-export class LinkedAttributesRepository {
-  constructor(
-    @InjectRepository(LinkedAttributes)
-    private readonly linkedAttributesRepo: Repository<LinkedAttributes>,
-  ) {}
-}

package/src/module/linked_attributes/service/linked_attributes.service.ts

@@ -1,22 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-
-@Injectable()
-export class LinkedAttributesService extends EntityServiceImpl {
-  constructor() {
-    super();
-  }
-
-  async createEntity(payload: any, loggedInUser: any): Promise<any> {
-    // Auto-generate attribute_key if missing OR empty
-    if (!payload.attribute_key || payload.attribute_key.trim() === '') {
-      payload.attribute_key = payload.field_name
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, '_'); // replace spaces with underscore
-    }
-
-    // Pass to base class create method
-    return super.createEntity(payload, loggedInUser);
-  }
-}

package/src/module/meta/repository/entity-attribute-update.repository.ts

@@ -1,44 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-
-@Injectable()
-export class EntityUpdateRepository {
-  constructor(private readonly dataSource: DataSource) {}
-
-
- async updateEntityAttribute(entity, config ) {
-  const {entityType, organization_id} = entity;
-
-  // 1. Get the table name
-
-  const result = await this.dataSource.query(
-    `SELECT data_source 
-     FROM frm_entity_master 
-     WHERE mapped_entity_type = ?
-     and organization_id = ?`,
-    [config.entity_type, organization_id],
-  );
-
-  if (!result.length) {
-    throw new Error("Entity table not found");
-  }
-
-  const entityTableName = result[0].data_source;
-
-  // 2. Determine the ID condition
-
-const isLead = config.entity_type === "LEAD";
-const idColumn = isLead ? "id" : "parent_id";
-
-  // 3. Update using dynamic table name
-
-return await this.dataSource
-  .createQueryBuilder()
-  .update(entityTableName)
-  .set({ [config.attribute_key]: config.attribute_value })
-  .where(`${idColumn} = :id`, { id: entity.id })
-  .execute();
-
-}
-
-}

package/src/module/meta/service/entity-attribute-update.service.ts

@@ -1,29 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { EntityServiceImpl } from "./entity-service-impl.service";
-import { EntityUpdateRepository } from "../repository/entity-attribute-update.repository";
-
-@Injectable()
-export class EntityUpdateService extends EntityServiceImpl{
-
-constructor(
-    private readonly entityUpdateRepository:EntityUpdateRepository
-){
-    super();
-}
-
-  async execute(payload: any): Promise<any> {
-
-    let { entity, user, config } = payload;
-    console.log(entity)
-
-
-    if (entity.entity_type !== 'LEAD') {
-      entity = await this.getEntityData('LEAD', entity.parent_id,user );
-    }
-    console.log(entity,"---------------------------------------");
-
-    return this.entityUpdateRepository.updateEntityAttribute(entity,config);
-
-
-  }
-}

package/src/module/workflow-automation/SCHEDULING_GUIDE.md

@@ -1,145 +0,0 @@
-# Workflow Automation Scheduling Guide
-
-## Overview
-This module integrates with `WorkflowScheduleModule` to enable creating scheduled workflow automations. You can create schedules that run automatically via cron, or create them in a disabled state for manual triggering only.
-
-## Controlling Auto-Scheduling Behavior
-
-### Option 1: Create Schedules WITHOUT Auto-Execution
-When creating a schedule, set `is_enabled: false` to prevent it from running automatically:
-
-```typescript
-// Inject WorkflowScheduleService in your controller/service
-constructor(
-  private readonly workflowScheduleService: WorkflowScheduleService,
-) {}
-
-// Create schedule without auto-execution
-const schedule = await this.workflowScheduleService.createSchedule(
-  {
-    workflow_id: workflowId,
-    workflow_name: 'My Workflow',
-    name: 'My Schedule',
-    cron_expression: '0 9 * * *', // Every day at 9 AM
-    timezone: 'America/New_York',
-    is_enabled: false, // 👈 This prevents auto-execution
-    // ... other fields
-  },
-  loggedInUser,
-);
-```
-
-### Option 2: Create Schedules WITH Auto-Execution
-Simply set `is_enabled: true` (or omit it, as it defaults to true):
-
-```typescript
-const schedule = await this.workflowScheduleService.createSchedule(
-  {
-    workflow_id: workflowId,
-    workflow_name: 'My Workflow',
-    name: 'My Schedule',
-    cron_expression: '0 9 * * *',
-    timezone: 'America/New_York',
-    is_enabled: true, // 👈 Schedule will run automatically on cron
-    // ... other fields
-  },
-  loggedInUser,
-);
-```
-
-## How It Works
-
-The scheduling logic in `WorkflowScheduleService.createSchedule()` (line 101-103) only adds jobs to the Bull queue if:
-1. `is_enabled === true`
-2. `schedule_status === 'ACTIVE'`
-
-If either condition is false, the schedule is saved to the database but NOT added to the queue, meaning the cron processor won't execute it.
-
-## Manual Triggering
-
-You can manually trigger any schedule (enabled or disabled) using:
-
-```typescript
-const result = await this.workflowScheduleService.triggerManualExecution(
-  scheduleId,
-  loggedInUser,
-  { /* optional metadata */ },
-);
-```
-
-## Enabling/Disabling Schedules Later
-
-### To Enable a Disabled Schedule:
-```typescript
-await this.workflowScheduleService.updateSchedule(
-  {
-    id: scheduleId,
-    is_enabled: true,
-  },
-  loggedInUser,
-);
-```
-
-### To Disable an Active Schedule:
-```typescript
-await this.workflowScheduleService.updateSchedule(
-  {
-    id: scheduleId,
-    is_enabled: false,
-  },
-  loggedInUser,
-);
-```
-
-### To Pause a Schedule Temporarily:
-```typescript
-await this.workflowScheduleService.pauseSchedule(scheduleId, loggedInUser);
-```
-
-### To Resume a Paused Schedule:
-```typescript
-await this.workflowScheduleService.resumeSchedule(scheduleId, loggedInUser);
-```
-
-## Best Practices
-
-1. **Testing**: Create schedules with `is_enabled: false` during development and testing
-2. **Staged Rollout**: Create schedules disabled, test manually, then enable when ready
-3. **Monitoring**: Use `getExecutionLogs()` and `getExecutionStats()` to monitor schedule performance
-4. **Cleanup**: Use `deleteSchedule()` to soft-delete schedules you no longer need
-
-## Example: Complete Workflow
-
-```typescript
-// 1. Create schedule (disabled)
-const schedule = await this.workflowScheduleService.createSchedule({
-  workflow_id: 123,
-  workflow_name: 'Send Daily Report',
-  name: 'Daily Report Schedule',
-  cron_expression: '0 9 * * *',
-  is_enabled: false, // Start disabled
-}, loggedInUser);
-
-// 2. Test manually
-const testResult = await this.workflowScheduleService.triggerManualExecution(
-  schedule.id,
-  loggedInUser,
-);
-
-// 3. Check execution logs
-const logs = await this.workflowScheduleService.getExecutionLogs({
-  schedule_id: schedule.id,
-}, loggedInUser);
-
-// 4. If tests pass, enable for auto-execution
-if (logs.data[0].execution_status === 'COMPLETED') {
-  await this.workflowScheduleService.updateSchedule({
-    id: schedule.id,
-    is_enabled: true, // Now it will run on cron
-  }, loggedInUser);
-}
-```
-
-## Environment Configuration
-
-The Bull queue (Redis) connection is configured in `src/config/bull.config.ts`. Ensure Redis is running and accessible for the scheduler to work.

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

@@ -1,150 +0,0 @@
-import { Inject, Injectable, Logger } from '@nestjs/common';
-import { FilterEvaluatorService } from 'src/module/filter/service/filter-evaluator.service';
-import { DataSource } from 'typeorm';
-import { WorkflowAutomationEngineService } from './workflow-automation-engine.service';
-
-@Injectable()
-export class ScheduleHandlerService {
-  private readonly logger = new Logger(ScheduleHandlerService.name);
-
-  constructor(
-    private readonly dataSource: DataSource,
-    private readonly filterEvaluator: FilterEvaluatorService,
-    // @Inject('WorkflowAutomationEngineService')
-    private readonly workflowAutomationEngineService: WorkflowAutomationEngineService,
-  ) {}
-
-  async scheduleQueryBuilder(workflowId: number, jobData: any) {
-    // 1️⃣ Fetch workflow automation config
-    const [workflow] = await this.dataSource.query(
-      `SELECT * FROM frm_wf_automation WHERE id = ? AND organization_id = ?`,
-      [workflowId, jobData.organizationId],
-    );
-
-    if (!workflow) throw new Error(`Workflow with ID ${workflowId} not found`);
-
-    const event = JSON.parse(workflow.event_json || '{}');
-    const scheduleJson = workflow.schedule;
-    const entityType = workflow.applicable_entity_type;
-
-    // 2️⃣ Get table name from frm_entity_master
-    const [entity] = await this.dataSource.query(
-      `SELECT data_source FROM frm_entity_master WHERE mapped_entity_type = ? AND organization_id = ?`,
-      [entityType, jobData.organizationId],
-    );
-    if (!entity?.data_source) throw new Error(`Entity ${entityType} not found`);
-
-    const tableName = entity.data_source;
-
-    // 3️⃣ Resolve executionDate (list master item name)
-    const [executionDateItem] = await this.dataSource.query(
-      `SELECT name FROM frm_list_master_items WHERE id = ?`,
-      [scheduleJson.executionDate],
-    );
-    const executionDateName = executionDateItem?.name?.toLowerCase() || '';
-    const executionDataOrTime = scheduleJson.executionDateOrTime;
-
-    const executionUnits = Number(scheduleJson.executionDateUnits || 0);
-    const fixedTime = scheduleJson.fixedTime; // e.g. "16:00"
-
-    // Build time window logic
-    let comparisonDateCondition = '';
-
-    if (executionDateName.includes('after')) {
-      comparisonDateCondition = `
-    ${executionDataOrTime} >= CURDATE() + INTERVAL ${executionUnits} DAY
-    AND ${executionDataOrTime} < CURDATE() + INTERVAL ${executionUnits + 1} DAY
-  `;
-    } else if (executionDateName.includes('before')) {
-      comparisonDateCondition = `
-    ${executionDataOrTime} >= CURDATE() - INTERVAL ${executionUnits + 1} DAY
-    AND ${executionDataOrTime} < CURDATE() - INTERVAL ${executionUnits} DAY
-  `;
-    } else if (executionDateName.includes('same')) {
-      comparisonDateCondition = `
-    ${executionDataOrTime} >= CURDATE()
-    AND ${executionDataOrTime} < CURDATE() + INTERVAL 1 DAY
-  `;
-    }
-
-    const query = `
-  SELECT *
-  FROM ${tableName}
-  WHERE ${comparisonDateCondition}
-    AND organization_id = ?
-`;
-
-    this.logger.debug(`Executing Scheduler Query: ${query}`);
-
-    const results = await this.dataSource.query(query, [
-      jobData.organizationId,
-    ]);
-
-    this.logger.log(
-      `Found ${results.length} scheduled records for ${tableName}`,
-    );
-
-    return { results, workflow, tableName };
-  }
-
-  // ⚙️ Step 2: Handle scheduled automation (main entry point)
-  async handleScheduledWorkflow(workflowId: number, jobData: any) {
-    const { results, workflow, tableName } = await this.scheduleQueryBuilder(
-      workflowId,
-      jobData,
-    );
-
-    if (!results?.length) {
-      this.logger.warn(`No records found for scheduled workflow ${workflowId}`);
-      return;
-    }
-
-    this.logger.log(
-      `Processing ${results.length} records for workflow ${workflowId}`,
-    );
-
-    // Parse the workflow event JSON again to get filter/action info
-    const event = JSON.parse(workflow.event_json || '{}');
-    const filter = workflow.condition_filter_code;
-    const mappedEntityType = workflow.applicable_entity_type;
-
-    const matchedEntities: any[] = [];
-
-    // 🔁 Step 2A: Evaluate criteria for each record
-    for (const record of results) {
-      const entityIdToUse = record.id; // assuming 'id' column in the table
-      const criteriaMatched = await this.filterEvaluator.evaluateCriteria(
-        mappedEntityType,
-        filter,
-        entityIdToUse,
-        jobData,
-      );
-
-      this.logger.debug(
-        `⚖️ Criteria check for entity ${entityIdToUse} -> ${criteriaMatched}`,
-      );
-
-      if (criteriaMatched) {
-        matchedEntities.push(record);
-      }
-    }
-
-    // 🧮 Step 3: Execute workflow actions for matched entities
-    if (!matchedEntities.length) {
-      this.logger.log(`No records passed criteria for workflow ${workflowId}`);
-      return;
-    }
-
-    this.logger.log(
-      `✅ ${matchedEntities.length} entities passed criteria, executing actions...`,
-    );
-
-    for (const entity of matchedEntities) {
-      await this.workflowAutomationEngineService.executeActions(
-        workflowId,
-        entity,
-        jobData,
-      );
-    }
-  }
-}