rez_core 4.0.178 → 4.0.180

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

@@ -1,88 +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;
-  }
-}

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/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,
-      );
-    }
-  }
-}

package/src/module/workflow-schedule/INSTALLATION.md

@@ -1,244 +0,0 @@
-# Workflow Schedule Module - Installation Guide
-
-## Quick Start
-
-### Step 1: Install Dependencies
-
-```bash
-npm install @nestjs/bull bull redis cron-parser
-npm install --save-dev @types/bull
-```
-
-**Note:** `cron-parser` includes its own TypeScript definitions, so no `@types` package is needed.
-
-### Step 2: Setup Redis
-
-#### Option A: Using Docker (Recommended)
-```bash
-docker run -d \
-  --name redis-workflow \
-  -p 6379:6379 \
-  redis:latest
-```
-
-#### Option B: Local Installation
-**macOS:**
-```bash
-brew install redis
-brew services start redis
-```
-
-**Ubuntu/Debian:**
-```bash
-sudo apt-get install redis-server
-sudo systemctl start redis-server
-```
-
-**Windows:**
-Download from: https://redis.io/download
-
-### Step 3: Configure Environment Variables
-
-Add to your `.env` file:
-
-```env
-# Redis Configuration
-REDIS_HOST=localhost
-REDIS_PORT=6379
-REDIS_PASSWORD=
-REDIS_DB=0
-
-# Existing Database Configuration (verify these)
-DB_HOST=13.234.25.234
-DB_PORT=3306
-DB_USER=root
-DB_PASS=Rezolut@123
-DB_NAME=core
-```
-
-### Step 4: Verify Redis Connection
-
-```bash
-# Test Redis connection
-redis-cli ping
-# Should respond: PONG
-```
-
-### Step 5: Run Database Migrations
-
-The module requires three migrations to be run:
-
-```bash
-# Using TypeORM CLI (recommended)
-npx ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli.js migration:run -d src/config/database.config.ts
-
-# Or create a migration script in package.json:
-# "migration:run": "typeorm migration:run -d src/config/database.config.ts"
-# Then run:
-npm run migration:run
-```
-
-**Migrations will create:**
-1. ✅ `workflow_type` column in `cr_wf_master` table
-2. ✅ `cr_wf_scheduled_workflow` table with indexes
-3. ✅ `cr_wf_execution_log` table with indexes
-
-### Step 6: Start Your Application
-
-```bash
-npm run start:dev
-```
-
-### Step 7: Verify Installation
-
-Check the console logs for:
-```
-[Nest] INFO [BullModule] Bull queues registered
-[Nest] INFO [WorkflowScheduleModule] Workflow Schedule Module initialized
-```
-
-## Quick Test
-
-### Create Your First Schedule
-
-```bash
-curl -X POST http://localhost:3000/workflow-schedule/create \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
-  -d '{
-    "workflow_id": 1,
-    "name": "Test Schedule",
-    "cron_expression": "*/5 * * * *",
-    "timezone": "Asia/Kolkata",
-    "actions": []
-  }'
-```
-
-### List All Schedules
-
-```bash
-curl -X GET http://localhost:3000/workflow-schedule/list \
-  -H "Authorization: Bearer YOUR_JWT_TOKEN"
-```
-
-## Troubleshooting
-
-### Issue: Cannot connect to Redis
-
-**Solution:**
-```bash
-# Check if Redis is running
-redis-cli ping
-
-# If not running, start Redis
-docker start redis-workflow
-# or
-brew services start redis
-```
-
-### Issue: Migration fails with "Table already exists"
-
-**Solution:**
-Migrations check if tables exist before creating them. If you see this message, the tables are already present. You can safely ignore it.
-
-### Issue: Jobs are not processing
-
-**Checklist:**
-- [ ] Redis is running and accessible
-- [ ] Schedule status is `ACTIVE`
-- [ ] Schedule `is_enabled` is `true`
-- [ ] Cron expression is valid
-- [ ] Application has restarted after creating the schedule
-
-**Verify:**
-```bash
-# Check Redis keys
-redis-cli KEYS "bull:workflow-schedule:*"
-
-# Should show keys if jobs are queued
-```
-
-### Issue: TypeScript errors after installation
-
-**Solution:**
-```bash
-# Clear node_modules and reinstall
-rm -rf node_modules package-lock.json
-npm install
-
-# Restart your IDE/editor
-```
-
-## Verify Bull Queue Dashboard (Optional)
-
-Install Bull Board for visual queue monitoring:
-
-```bash
-npm install @bull-board/express @bull-board/api
-```
-
-Add to your `main.ts`:
-```typescript
-import { createBullBoard } from '@bull-board/api';
-import { BullAdapter } from '@bull-board/api/bullAdapter';
-import { ExpressAdapter } from '@bull-board/express';
-
-// Get queue from your app
-const schedulerQueue = app.get('BullQueue_workflow-schedule');
-
-const serverAdapter = new ExpressAdapter();
-createBullBoard({
-  queues: [new BullAdapter(schedulerQueue)],
-  serverAdapter,
-});
-
-serverAdapter.setBasePath('/admin/queues');
-app.use('/admin/queues', serverAdapter.getRouter());
-```
-
-Then access: `http://localhost:3000/admin/queues`
-
-## Package Versions
-
-Tested with:
-```json
-{
-  "@nestjs/bull": "^10.0.0",
-  "@nestjs/common": "^11.0.0",
-  "@nestjs/core": "^11.0.0",
-  "bull": "^4.12.0",
-  "redis": "^4.6.0",
-  "cron-parser": "^4.9.0"
-}
-```
-
-## Production Checklist
-
-Before deploying to production:
-
-- [ ] Configure Redis with persistence
-- [ ] Set up Redis password authentication
-- [ ] Configure appropriate retry strategies
-- [ ] Set up monitoring and alerting
-- [ ] Configure log retention policies
-- [ ] Test failover scenarios
-- [ ] Set up backup for scheduled workflow configurations
-- [ ] Document schedule ownership and purpose
-- [ ] Configure rate limiting if needed
-- [ ] Set up Redis clustering for high availability
-
-## Next Steps
-
-1. Read the full [README.md](./README.md) for API documentation
-2. Test the 9 API endpoints
-3. Create your first scheduled workflow
-4. Monitor execution logs
-5. Set up Bull Board for visual monitoring
-
-## Support
-
-If you encounter issues:
-1. Check application logs
-2. Verify Redis connectivity
-3. Ensure migrations ran successfully
-4. Review the [README.md](./README.md) troubleshooting section