rez_core 5.0.40 → 5.0.42

package/package.json

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

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

@@ -885,8 +885,8 @@ export class FilterService {
   }
 
   private buildDateCondition(attr: string, op: string, val: any, key: string) {
-    const dateColumn = `DATE(e.${attr})`;
-    const monthColumn = `DATE_FORMAT(e.${attr}, '%Y-%m-01')`; // MySQL equivalent
+    const dateColumn = `e.${attr}::date`;
+    const monthColumn = `date_trunc('month', e.${attr})::date`;
 
     const numVal = Number(val);
 
@@ -933,12 +933,12 @@ export class FilterService {
             .startOf('month')
             .format('YYYY-MM-DD');
           return {
-            query: `${monthColumn} < DATE_FORMAT(:${key}, '%Y-%m-01')`,
+            query: `${monthColumn} < date_trunc('month', :${key})::date`,
             params: { [key]: target },
           };
         }
         return {
-          query: `${monthColumn} < DATE_FORMAT(:${key}, '%Y-%m-01')`,
+          query: `${monthColumn} < date_trunc('month', :${key})::date`,
           params: { [key]: val },
         };
 
@@ -949,12 +949,12 @@ export class FilterService {
             .startOf('month')
             .format('YYYY-MM-DD');
           return {
-            query: `${monthColumn} > DATE_FORMAT(:${key}, '%Y-%m-01')`,
+            query: `${monthColumn} > date_trunc('month', :${key})::date`,
             params: { [key]: target },
           };
         }
         return {
-          query: `${monthColumn} > DATE_FORMAT(:${key}, '%Y-%m-01')`,
+          query: `${monthColumn} > date_trunc('month', :${key})::date`,
           params: { [key]: val },
         };
 

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

@@ -35,7 +35,7 @@ export class AttributeMasterRepository {
   ): Promise<AttributeMaster[]> {
     return await this.attributeMasterRepository.find({
       where: {
-        mapped_entity_type: In([entityType]),
+        mapped_entity_type: entityType,
         organization_id: loggedInUser.organization_id,
       },
     });

package/src/module/meta/service/populate-meta.service.ts

@@ -1,56 +1,16 @@
 import { Injectable } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 import { EntityServiceImpl } from './entity-service-impl.service';
+import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
 
 @Injectable()
 export class PopulateMetaService {
   constructor(
     private readonly dataSource: DataSource,
     private readonly entityServiceImpl: EntityServiceImpl,
+    private readonly reflectionHelper: ReflectionHelper,
   ) {}
 
-  // async populateMetaData(organization_id: number) {
-  //   // Define metadata tables
-  //   const metadataTables = [
-  //     'frm_entity_master',
-  //     'frm_entity_attribute',
-  //     'frm_entity_table',
-  //   ];
-
-  //   // Fetch and transform all factory data
-  //   for (const table of metadataTables) {
-  //     const factoryData = await this.dataSource.query(
-  //       `SELECT * FROM ${table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
-  //     );
-
-  //     if (!factoryData.length) continue;
-
-  //     // Clean and transform data for insertion
-  //     const transformedData = factoryData.map((row) => {
-  //       const { id, created_date, modified_date, ...rest } = row;
-  //       return {
-  //         ...rest,
-  //         organization_id,
-  //         level_type: 'ORG',
-  //         level_id: organization_id,
-  //       };
-  //     });
-
-  //     // Perform bulk insert into the same table
-  //     await this.dataSource
-  //       .createQueryBuilder()
-  //       .insert()
-  //       .into(table)
-  //       .values(transformedData)
-  //       .execute();
-  //   }
-
-  //   return {
-  //     message: 'Metadata populated successfully',
-  //     status: 'success',
-  //   };
-  // }
-
   async populateMetaData(organization_id: number) {
     const metadataTables = [
       'frm_entity_master',
@@ -58,32 +18,64 @@ export class PopulateMetaService {
       'frm_entity_view',
       'frm_entity_relation',
     ];
-    const entityTypeToNewIdMap = new Map<string, number>();
 
-    const getStatus = await this.dataSource.query(
-      `SELECT * FROM frm_list_master_items WHERE organization_id = ${organization_id} AND code = "STATUS_ACTIVE"`,
-    );
-    const status = getStatus[0]?.id ? getStatus[0].id : 'ACTIVE';
+    const metaData = [
+      'EntityMaster',
+      'AttributeMaster',
+      'ViewMaster',
+      'EntityRelationData',
+    ];
+
+    const listMasterItemsRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
+    const viewMasterRepo = this.reflectionHelper.getRepoService('ViewMaster');
+    const relationDataRepo =
+      this.reflectionHelper.getRepoService('EntityRelationData');
+    const relationRepo = this.reflectionHelper.getRepoService('EntityRelation');
+    const attributeMasterRepo =
+      this.reflectionHelper.getRepoService('AttributeMaster');
+    const entityMasterRepo =
+      this.reflectionHelper.getRepoService('EntityMaster');
+
+    if (!listMasterItemsRepo) return;
+
+    const getStatus = (await listMasterItemsRepo.find({
+      where: { organization_id: organization_id, code: 'STATUS_ACTIVE' },
+    })) as any[];
+
+    let status: any;
+
+    if (getStatus && getStatus.length > 0) {
+      status = getStatus[0].id;
+    } else {
+      status = 'ACTIVE';
+    }
 
-    let oneToManyId = await this.dataSource.query(
-      `SELECT id FROM frm_list_master_items WHERE value = 'ONE_TO_MANY' AND organization_id = ${organization_id}`,
-    )
+    let oneToManyId = await listMasterItemsRepo?.find({
+      where: { value: 'ONE_TO_MANY', organization_id: organization_id },
+    });
 
-    let oneToOneId = await this.dataSource.query(
-      `SELECT id FROM frm_list_master_items WHERE value = 'ONE_TO_MANY' AND organization_id = ${organization_id}`,
-    )
+    let oneToOneId = await listMasterItemsRepo?.find({
+      where: { value: 'ONE_TO_ONE', organization_id: organization_id },
+    });
 
     // Step 1: Insert basic metadata tables
     for (const table of metadataTables) {
-      const factoryData = await this.dataSource.query(
-        `SELECT * FROM ${table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
-      );
-
-      if (!factoryData.length) continue;
-
       let transformedData;
 
+      let transformRepo;
+
       if (table === 'frm_entity_master') {
+        transformRepo = entityMasterRepo;
+
+        const factoryData = await transformRepo?.find({
+          where: {
+            organization_id: -1,
+            level_type: 'ORG',
+            level_id: -1,
+          },
+        });
+
         transformedData = factoryData.map(
           ({ id, created_date, modified_date, ...rest }) => ({
             ...rest,
@@ -95,31 +87,59 @@ export class PopulateMetaService {
           }),
         );
       } else if (table === 'frm_entity_attribute') {
+        transformRepo = attributeMasterRepo;
+        const factoryData = await transformRepo?.find({
+          where: {
+            organization_id: -1,
+            level_type: 'ORG',
+            level_id: -1,
+          },
+        });
+
         transformedData = factoryData.map(
           ({ id, created_date, modified_date, ...rest }) => ({
             ...rest,
             organization_id,
             level_type: 'ORG',
             level_id: organization_id,
-            is_unique: rest.is_unique == 1 ? true : false,
-            required: rest.required == 1 ? true : false,
-            is_hidden: rest.is_hidden == 1 ? true : false,
+            // is_unique: rest.is_unique == 1 ? true : false,
+            // required: rest.required == 1 ? true : false,
+            // is_hidden: rest.is_hidden == 1 ? true : false,
             status: status,
           }),
         );
-      } 
-      else if (table === 'frm_entity_relation') {
+      } else if (table === 'frm_entity_relation') {
+        if (!oneToManyId || !oneToOneId) continue;
+        transformRepo = relationRepo;
+        const factoryData = await transformRepo?.find({
+          where: {
+            organization_id: -1,
+            level_type: 'ORG',
+            level_id: -1,
+          },
+        });
         transformedData = factoryData.map(
           ({ id, created_date, modified_date, ...rest }) => ({
-          ...rest,
+            ...rest,
             organization_id,
             level_type: 'ORG',
             level_id: organization_id,
             status: status,
-            relation_id:rest.relation_type=="ONE_TO_ONE"?oneToOneId[0].id:oneToManyId[0].id
+            // relation_id:
+            //   rest.relation_type == 'ONE_TO_ONE'
+            //     ? oneToOneId[0].id
+            //     : oneToManyId[0].id,
           }),
         );
-      }else {
+      } else if (table === 'frm_entity_view') {
+        transformRepo = viewMasterRepo;
+        const factoryData = await transformRepo?.find({
+          where: {
+            organization_id: -1,
+            level_type: 'ORG',
+            level_id: -1,
+          },
+        });
         transformedData = factoryData.map(
           ({ id, created_date, modified_date, ...rest }) => ({
             ...rest,
@@ -131,17 +151,24 @@ export class PopulateMetaService {
         );
       }
 
-      await this.dataSource
-        .createQueryBuilder()
-        .insert()
-        .into(table)
-        .values(transformedData)
-        .execute();
+      await transformRepo?.save(transformedData);
     }
 
-    const entityTables = await this.dataSource.query(
-      `SELECT * FROM frm_entity_table WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
-    );
+    // table population for entity tables and entity table columns
+
+    const entityTableRepo = this.reflectionHelper.getRepoService('EntityTable');
+    const entityTableColumnRepo =
+      this.reflectionHelper.getRepoService('EntityTableColumn');
+
+    if (!entityTableRepo || !entityTableColumnRepo) return;
+
+    const entityTables = await entityTableRepo.find({
+      where: {
+        organization_id: -1,
+        level_type: 'ORG',
+        level_id: -1,
+      },
+    });
 
     for (let entityTable of entityTables) {
       const { id, mapped_entity_type, display_type, ...rest } = entityTable;
@@ -153,18 +180,23 @@ export class PopulateMetaService {
         level_id: organization_id,
         display_type: display_type,
       };
-      const insertResult = await this.dataSource
-        .createQueryBuilder()
-        .insert()
-        .into('frm_entity_table')
-        .values(entityTable)
-        .execute();
-
-      const newId = insertResult.identifiers[0].id; // or insertResult.raw.insertId if needed
-
-      const entityTableColumns = await this.dataSource.query(
-        `SELECT * FROM frm_entity_table_column WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1 AND mapped_entity_type = '${mapped_entity_type}' AND display_type = '${display_type}'`,
-      );
+
+      const insertResult = await entityTableRepo.save(entityTable);
+
+      const newId = insertResult.id;
+
+      const entityTableColumns = await entityTableColumnRepo.find({
+        where: {
+          organization_id: -1,
+          level_type: 'ORG',
+          level_id: -1,
+          mapped_entity_type: mapped_entity_type,
+          display_type: display_type,
+        },
+      });
+
+      let tableCloumnArray = [] as any[];
+
       for (const column of entityTableColumns) {
         const { id, created_date, modified_date, ...columnRest } = column;
         const newColumn = {
@@ -176,13 +208,10 @@ export class PopulateMetaService {
           mapped_entity_type: mapped_entity_type,
           display_type: display_type,
         };
-        await this.dataSource
-          .createQueryBuilder()
-          .insert()
-          .into('frm_entity_table_column')
-          .values(newColumn)
-          .execute();
+        tableCloumnArray.push(newColumn);
       }
+
+      await entityTableColumnRepo.save(tableCloumnArray);
     }
 
     return {

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

@@ -1,3 +1,5 @@
+import { create } from 'domain';
+import { CommTemplate } from './../entity/comm-template.entity';
 import { ActionCategory } from './../entity/action-category.entity';
 import { DataSource } from 'typeorm';
 import { PopulateMetaService } from './../../meta/service/populate-meta.service';
@@ -26,79 +28,44 @@ export class PopulateWorkflowService extends EntityServiceImpl {
     super();
   }
 
-  //   async populateWorkflowData(organization_id: number, loggedInUser: UserData) {
-  //     // Define workflow tables
-  //     const workflowTables = [
-  //       { table: 'frm_wf_master', entityType: 'WRFW', service: 'workflowService' },
-  //       {
-  //         table: 'frm_wf_stage_group',
-  //         entityType: 'WFSG',
-  //         service: 'stageGroupService',
-  //       },
-  //       { table: 'frm_wf_stage', entityType: 'WFS', service: 'stageService' },
-  //       { table: 'frm_wf_action', entityType: 'WFAC', service: 'actionService' },
-  //     ];
-
-  //     const getAllFactoryData = async (table: { table: string }) => {
-  //       return this.dataSource.query(
-  //         `SELECT * FROM ${table.table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
-  //       );
-  //     };
-
-  //     const factoryData = await Promise.all(
-  //       workflowTables.map((table) => getAllFactoryData(table)),
-  //     );
-
-  //     // Step 1: Insert workflow metadata
-  //     for (let i = 0; i < workflowTables.length; i++) {
-  //       const table = workflowTables[i];
-  //       const data = factoryData[i];
-
-  //       if (!data.length) continue;
-
-  //       // Clean and transform data for insertion
-  //       const transformedData = data.map((row) => {
-  //         const { id, created_date, modified_date, ...rest } = row;
-  //         return {
-  //           ...rest,
-  //           organization_id: organization_id,
-  //           level_id: organization_id,
-  //           entity_type: table.entityType,
-  //         };
-  //       });
-
-  //       const service = this[table.service];
-
-  //       for (const record of transformedData) {
-  //         await service.createEntity(record, loggedInUser);
-  //       }
-  //     }
-
-  //     return {
-  //       message: 'Workflow data populated successfully',
-  //       status: 'success',
-  //     };
-  //   }
-
   async populateWorkflowData(organization_id: number, loggedInUser: UserData) {
-    let statusRow = await this.dataSource.query(
-      `SELECT * FROM frm_list_master_items WHERE code='STATUS_ACTIVE' AND organization_id = $1`,
-      [organization_id],
-    );
+    const listMasterItemsRepo =
+      this.reflectionHelper.getRepoService('ListMasterItems');
 
-    if (statusRow.length === 0) {
-      statusRow = await this.dataSource.query(
-        `SELECT * FROM frm_list_master_items WHERE code='STATUS_ACTIVE' AND organization_id = -1`,
-      );
+    if (!listMasterItemsRepo) return;
+
+    // let statusRow = await this.dataSource.query(
+    //   `SELECT * FROM frm_list_master_items WHERE code='STATUS_ACTIVE' AND organization_id = $1`,
+    //   [organization_id],
+    // );
+
+    let statusRow = await listMasterItemsRepo.findOne({
+      where: { code: 'STATUS_ACTIVE', organization_id: organization_id },
+    });
+
+    if (!statusRow) {
+      statusRow = await listMasterItemsRepo.findOne({
+        where: { code: 'STATUS_ACTIVE', organization_id: -1 },
+      });
     }
 
-    const statusValue = statusRow[0]?.id;
+    const statusValue = statusRow?.id;
 
     // template populate
     // Step 1: Fetch default frm_wf_comm_template
-    const defaultCommTemplates = await this.dataSource.query(
-      `SELECT * FROM frm_wf_comm_template WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
-    );
+
+    const commTemplateRepo =
+      this.reflectionHelper.getRepoService('CommTemplate');
+
+    if (!commTemplateRepo) return;
+
+    const defaultCommTemplates = await commTemplateRepo.find({
+      where: {
+        organization_id: -1,
+        level_type: 'ORG',
+        level_id: -1,
+      },
+    });
 
     if (defaultCommTemplates.length > 0) {
       // Step 2: Insert default communication templates for the new organization
@@ -120,7 +87,11 @@ export class PopulateWorkflowService extends EntityServiceImpl {
     }
 
     const workflowTables = [
-      { table: 'frm_wf_master', entityType: 'WRFW', service: 'workflowService' },
+      {
+        table: 'frm_wf_master',
+        entityType: 'WRFW',
+        service: 'workflowService',
+      },
       {
         table: 'frm_wf_stage_group',
         entityType: 'WFSG',
@@ -130,18 +101,44 @@ export class PopulateWorkflowService extends EntityServiceImpl {
       { table: 'frm_wf_action', entityType: 'WFAC', service: 'actionService' },
     ];
 
-    // Fetch all base data
-    const getAllFactoryData = async (table: { table: string }) =>
-      this.dataSource.query(
-        `SELECT * FROM ${table.table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
-      );
-    const factoryData = await Promise.all(
-      workflowTables.map(getAllFactoryData),
+    const workFlowRepo = this.reflectionHelper.getRepoService('Workflow');
+    const stageGroupRepo = this.reflectionHelper.getRepoService('StageGroup');
+    const stageRepo = this.reflectionHelper.getRepoService('Stage');
+    const actionRepo = this.reflectionHelper.getRepoService('ActionEntity');
+    const stageActionMappingRepo =
+      this.reflectionHelper.getRepoService('StageActionMapping');
+    const workflowLevelMappingRepo = this.reflectionHelper.getRepoService(
+      'WorkflowLevelMappingEntity',
     );
-    const [workflows, stageGroups, stages] = factoryData;
+    const listMasterRepo = this.reflectionHelper.getRepoService('ListMaster');
+    const actionCategoryRepo =
+      this.reflectionHelper.getRepoService('ActionCategory');
+    const viewMasterRepo = this.reflectionHelper.getRepoService('ViewMaster');
+
+    // Fetch all base data
+    // const getAllFactoryData = async (table: { table: string }) =>
+    //   this.dataSource.query(
+    //     `SELECT * FROM ${table.table} WHERE organization_id = -1 AND level_type = 'ORG' AND level_id = -1`,
+    //   );
+    // const factoryData = await Promise.all(
+    //   workflowTables.map(getAllFactoryData),
+    // );
+    // const [workflows, stageGroups, stages] = factoryData;
 
     // === 1. Workflow mapping
     const workflowIdMap: Record<number, number> = {};
+
+    let transformRepo;
+
+    transformRepo = workFlowRepo;
+
+    const workflows = await transformRepo?.find({
+      where: {
+        organization_id: -1,
+        level_type: 'ORG',
+        level_id: -1,
+      },
+    });
     for (const row of workflows) {
       const { id, ...rest } = row;
       const newWf = await this.workflowService.createEntity(
@@ -156,10 +153,14 @@ export class PopulateWorkflowService extends EntityServiceImpl {
       );
 
       // adding new entry for workflow level mapping
-      await this.dataSource.query(
-        `INSERT INTO frm_wf_level_mapping (workflow_id, mapped_level_id, mapped_level_type) VALUES ($1, $2, $3)`,
-        [newWf.id, organization_id, 'ORG'],
-      );
+
+      if (!workflowLevelMappingRepo) continue;
+
+      await workflowLevelMappingRepo.create({
+        workflow_id: newWf.id,
+        mapped_level_id: organization_id.toString(),
+        mapped_level_type: 'ORG',
+      });
 
       workflowIdMap[id] = newWf.id;
     }
@@ -168,6 +169,17 @@ export class PopulateWorkflowService extends EntityServiceImpl {
     const stageGroupIdMap: Record<number, number> = {};
     // Include mapping from old stageGroupId to old workflowId to help with stage->workflow logic later:
     const stageGroupToWorkflowMap: Record<number, number> = {};
+
+    transformRepo = stageGroupRepo;
+
+    const stageGroups = await transformRepo?.find({
+      where: {
+        organization_id: -1,
+        level_type: 'ORG',
+        level_id: -1,
+      },
+    });
+
     for (const row of stageGroups) {
       const { id, workflow_id, ...rest } = row;
       const newSg = await this.stageGroupService.createEntity(
@@ -188,6 +200,16 @@ export class PopulateWorkflowService extends EntityServiceImpl {
     // === 3. Stage mapping — point to stageGroup and workflow
     const stageIdMap: Record<number, number> = {};
     const stageToStageGroupMap: Record<number, number> = {};
+
+    transformRepo = stageRepo;
+    const stages = await transformRepo?.find({
+      where: {
+        organization_id: -1,
+        level_type: 'ORG',
+        level_id: -1,
+      },
+    });
+
     for (const row of stages) {
       const { id, stage_group_id, ...rest } = row;
       // Find the original parent workflow_id using the stageGroupToWorkflowMap
@@ -212,19 +234,21 @@ export class PopulateWorkflowService extends EntityServiceImpl {
       // step 3 create new action with new stage_id and new workflow_id
       // step 4 save new action
 
-      const stageIds = await this.dataSource.query(
-        `SELECT action_id FROM frm_wf_stage_action_mapping WHERE stage_id = $1`,
-        [id],
-      );
+      if (!stageActionMappingRepo) continue;
+
+      const stageIds = await stageActionMappingRepo.find({
+        where: {
+          stage_id: id,
+        },
+      });
 
       const actionIds = stageIds.map((item) => item.action_id);
 
-      let actions = [];
+      let actions = [] as any[];
       if (actionIds.length > 0) {
-        actions = await this.dataSource.query(
-          `SELECT * FROM frm_wf_action WHERE id IN ($1)`,
-          [actionIds],
-        );
+        if (!actionRepo) continue;
+
+        actions = await actionRepo?.findByIds(actionIds);
       } else {
         // No actions to query
         actions = [];
@@ -241,16 +265,16 @@ export class PopulateWorkflowService extends EntityServiceImpl {
         const newWorkflowId = workflowIdMap[workflow_id];
 
         // Step 1: Get the code of the old is_mandatory field
-        const [oldIsMandatory] = await this.dataSource.query(
-          `SELECT code FROM frm_list_master_items WHERE id = $1`,
-          [rest.action_requirement],
-        );
+
+        const [oldIsMandatory] = await listMasterItemsRepo.find({
+          where: { id: rest.action_requirement },
+        });
 
         // Step 2: Get all new 'ACRQ' list master items for the organization
-        const newIsMandatoryList = await this.dataSource.query(
-          `SELECT id, code FROM frm_list_master_items WHERE organization_id = $1 AND listtype = 'ACRQ'`,
-          [organization_id],
-        );
+
+        const newIsMandatoryList = await listMasterItemsRepo.find({
+          where: { organization_id: organization_id, listtype: 'ACRQ' },
+        });
 
         console.log(
           `Populating action for stage ${newStage.id} in workflow ${newWorkflowId}`,
@@ -266,16 +290,19 @@ export class PopulateWorkflowService extends EntityServiceImpl {
 
         console.log(`Matched new mandatory item:`, matchedNewMandatory);
 
-        const formActionCategory = await this.dataSource.query(
-          `SELECT id FROM frm_wf_action_category WHERE id = $1 and is_form = 1`,
-          [row.action_category],
-        );
+        if (!actionCategoryRepo) continue;
+
+        const formActionCategory = await actionCategoryRepo.find({
+          where: { id: row.action_category, is_form: true },
+        });
 
         //get view master form
-        const formViewMaster = await this.dataSource.query(
-          `SELECT id FROM frm_entity_view WHERE code = "LEAD_FORM" and organization_id = $1`,
-          [organization_id],
-        );
+
+        if (!viewMasterRepo) continue;
+
+        const formViewMaster = await viewMasterRepo.find({
+          where: { code: 'LEAD_FORM', organization_id: organization_id },
+        });
 
         // Step 4: Use the matched new item's id (if found)
         await this.actionService.createEntity(