rez_core 2.1.109 → 2.1.111

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "rez_core",
-  "version": "2.1.109",
+  "version": "2.1.111",
   "description": "",
-  "author": "", 
+  "author": "",
   "private": false,
   "license": "UNLICENSED",
   "scripts": {

package/src/app.module.ts

@@ -13,6 +13,7 @@ import { ThirdPartyModule } from './module/third-party-module/third-party.module
 import { FilterModule } from './module/filter/filter.module';
 import { LeadModule } from './module/lead/lead.module';
 import { LayoutPreferenceModule } from './module/layout_preference/layout_preference.module';
+import { WorkflowModule } from './module/workflow/workflow.module';
 
 @Module({
   imports: [
@@ -30,6 +31,7 @@ import { LayoutPreferenceModule } from './module/layout_preference/layout_prefer
     FilterModule,
     LeadModule,
     LayoutPreferenceModule,
+    WorkflowModule,
   ],
 })
 export class AppModule {}

package/src/constant/global.constant.ts

@@ -34,3 +34,15 @@ export const ENTITYSTATUS_PUBLISHED = 'published';
 export const DISPLAY_LIST = 'LIST';
 export const DISPLAY_EXPORT = 'EXPORT';
 export const DISPLAY_REPORT = 'REPORT';
+
+//WorkFlow Type
+export const WORKFLOW = 'WRFW';
+export const ACTION = 'ACTN';
+export const STAGE = 'STG';
+export const STAGE_GROUP = 'STGP';
+export const ACTION_CATEGORY = 'ACTC';
+export const STAGE_ACTION_MAPPING = 'STGM';
+export const COMM_TEMPLATE = 'CTPL';
+export const ACTION_TEMPLATE_MAPPING = 'ATMP';
+export const WORKFLOW_DATA = 'WFDT';
+export const STAGE_MOVEMENT_DATA = 'STMV';

package/src/module/listmaster/controller/list-master.controller.ts

@@ -50,6 +50,24 @@ export class ListMasterController {
     );
   }
 
+  @Post('/getResolvedListMasterItems/:type')
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  async getResolvedListMasterItems(
+    @Body() entityData: any,
+    @Param('type') type: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const entityType = type;
+
+    return await this.listMasterItemService.getResolvedListMasterItems(
+      loggedInUser,
+      entityData,
+      entityType,
+    );
+  }
+
   @Get('/getListMasterItems/:type')
   @UseGuards(JwtAuthGuard)
   @HttpCode(HttpStatus.OK)

package/src/module/listmaster/repository/list-master-items.repository.ts

@@ -146,4 +146,8 @@ export class ListMasterItemsRepository {
   async delete(item: Partial<ListMasterItems>) {
     return this.repo.delete(item);
   }
+
+  async findById(id: number): Promise<ListMasterItems | null> {
+    return this.repo.findOne({ where: { id } });
+  }
 }

package/src/module/listmaster/service/list-master-item.service.ts

@@ -9,15 +9,19 @@ import { ListMasterItemsRepository } from '../repository/list-master-items.repos
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { CodeGeneratorService } from 'src/utils/service/codeGenerator.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
 
 @Injectable()
-export class ListMasterItemService {
+export class ListMasterItemService extends EntityServiceImpl {
   constructor(
     private readonly listItemsRepo: ListMasterItemsRepository,
     private readonly listMasterRepo: ListMasterItemsRepository,
     @Inject(forwardRef(() => EntityServiceImpl))
     private readonly entityServiceImpl: EntityServiceImpl,
-  ) {}
+    private readonly attributeMasterService: AttributeMasterService,
+  ) {
+    super();
+  }
 
   async getListMasterItemsByType(
     listType: string,
@@ -178,4 +182,97 @@ export class ListMasterItemService {
     await this.listItemsRepo.delete({ code, listtype: listType });
     return `Item with name ${code} deleted successfully from type ${listType}`;
   }
+
+  // async getResolvedListMasterItems(
+  //   loggedInUser: UserData,
+  //   entityData: any,
+  //   entityType: string,
+  // ): Promise<any> {
+  //   const attributeItems =
+  //     await this.attributeMasterService.findAttributesByMappedEntityType(
+  //       entityType,
+  //       loggedInUser,
+  //     );
+
+  //   const masterAttributes = attributeItems.filter(
+  //     (attr) => attr.data_source_type === 'master',
+  //   );
+
+  //   const resolvedEntityData = { ...entityData };
+
+  //   for (const attr of masterAttributes) {
+  //     const field = attr.attribute_key;
+  //     const codeValue = entityData[field];
+  //     if (!codeValue) continue;
+
+  //     const listItems = await this.listItemsRepo.findById(codeValue);
+  //     if (!listItems) continue;
+
+  //   }
+
+  //   return resolvedEntityData;
+  // }
+
+  async getResolvedListMasterItems(
+    loggedInUser: UserData,
+    entityData: any,
+    entityType: string,
+  ): Promise<any> {
+    const attributeItems =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entityType,
+        loggedInUser,
+      );
+
+    const resolvedEntityData = { ...entityData };
+
+    for (const attr of attributeItems) {
+      const field = attr.attribute_key;
+      const codeValue = entityData[field];
+
+      if (!codeValue) continue;
+
+      // ---------- ENTITY data_source_type ----------
+      if (attr.data_source_type === 'entity') {
+        if (Array.isArray(codeValue)) {
+          const resolvedValues: string[] = [];
+          for (const code of codeValue) {
+            const item = await super.getEntityData(
+              attr.datasource_list,
+              code,
+              loggedInUser,
+            );
+            resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
+          }
+          resolvedEntityData[field] = resolvedValues;
+        } else {
+          const item = await super.getEntityData(
+            attr.datasource_list,
+            codeValue,
+            loggedInUser,
+          );
+          resolvedEntityData[field] =
+            item?.[attr.data_source_attribute] ?? codeValue;
+        }
+      }
+
+      // ---------- MASTER data_source_type ----------
+      else if (attr.data_source_type === 'master') {
+        if (Array.isArray(codeValue)) {
+          const resolvedValues: string[] = [];
+          for (const code of codeValue) {
+            const item = await this.listItemsRepo.findById(code);
+            resolvedValues.push(item?.[attr.data_source_attribute] ?? code);
+          }
+          resolvedEntityData[field] = resolvedValues;
+        } else {
+          const item = await this.listItemsRepo.findById(codeValue);
+          resolvedEntityData[field] =
+            item?.[attr.data_source_attribute] ?? codeValue;
+        }
+      }
+    }
+
+    return resolvedEntityData;
+  }
 }

package/src/module/master/controller/master.controller.ts

@@ -19,7 +19,7 @@ import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.s
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 
 @Controller('master')
-@UseGuards(JwtAuthGuard)
+// @UseGuards(JwtAuthGuard)
 export class MasterController {
   constructor(
     private readonly masterService: MasterService,

package/src/module/master/service/master.service.ts

@@ -161,9 +161,14 @@ export class MasterService {
       const entityMasterData =
         await this.entityMasterService.getEntityByTableName(table);
 
+      if (!entityMasterData || !entityMasterData.mapped_entity_type) {
+        console.error('Entity master data or mapped entity type is missing');
+        return;
+      }
+
       const attributes =
         await this.attributeMasterService.findAttributesByMappedEntityType(
-          entityMasterData?.mapped_entity_type,
+          entityMasterData.mapped_entity_type,
           loggedInUser.organization_id,
         );
 

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

@@ -62,6 +62,9 @@ export class AttributeMaster extends BaseEntity {
   @Column({ name: 'is_unique', nullable: true })
   is_unique: number;
 
+  @Column({ name: 'data_source_attribute', nullable: true })
+  data_source_attribute: string;
+
   @Column({ name: 'regex', nullable: true })
   regex: string;
 

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

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AttributeMaster } from '../entity/attribute-master.entity';
 import { In, Repository } from 'typeorm';
+import { UserData } from 'src/module/user/entity/user.entity';
 
 @Injectable()
 export class AttributeMasterRepository {
@@ -28,12 +29,14 @@ export class AttributeMasterRepository {
 
   async findAttributesByMappedEntityType(
     entityType: string,
-    organizationId: number,
+    loggedInUser: UserData,
   ): Promise<AttributeMaster[]> {
     return await this.attributeMasterRepository.find({
       where: {
-        mapped_entity_type: In([entityType, 'DEF']),
-        organization_id: organizationId,
+        mapped_entity_type: In([entityType]),
+        organization_id: loggedInUser.organization_id,
+        level_type: loggedInUser.level_type,
+        level_id: loggedInUser.level_id,
       },
     });
   }

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

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { In } from 'typeorm';
 import { AttributeMasterRepository } from '../repository/attribute-master.repository';
+import { UserData } from 'src/module/user/entity/user.entity';
 
 @Injectable()
 export class AttributeMasterService {
@@ -9,10 +8,13 @@ export class AttributeMasterService {
     private readonly attributeMasterRepository: AttributeMasterRepository,
   ) {}
 
-  async findAttributesByMappedEntityType(entity_type, organization_id) {
+  async findAttributesByMappedEntityType(
+    entity_type: string,
+    loggedInUser: UserData,
+  ) {
     return await this.attributeMasterRepository.findAttributesByMappedEntityType(
       entity_type,
-      organization_id,
+      loggedInUser,
     );
   }
 }

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

@@ -44,7 +44,7 @@ export class RoleService extends EntityServiceImpl {
           parseInt(loggedInUser?.level_id || '', 10),
       })
     ) {
-      return { success: false, error: 'Role code already exists.' };
+      return { success: false, error: 'Role name already exists.' };
     }
 
     const sourceRole = role.copy_from_role_id
@@ -95,7 +95,7 @@ export class RoleService extends EntityServiceImpl {
       loggedInUser?.organization_id || 0,
     );
 
-    if (entityData.status == resolveStatus.id || 'INACTIVE') {
+    if (entityData.status == resolveStatus.id) {
       //get role by id
       const existingRole = await this.getEntityData(
         ENTITYTYPE_ROLE,

package/src/module/workflow/controller/workflow-list-master.controller.ts

@@ -0,0 +1,25 @@
+import { Controller, Post, Body, HttpCode, HttpStatus } from '@nestjs/common';
+import { WorkflowListMasterService } from '../service/workflow-list-master.service';
+
+@Controller('/workflow-list')
+export class WorkflowListMasterController {
+  constructor(private readonly workflowService: WorkflowListMasterService) {}
+
+  @Post('/getActionsByStage')
+  @HttpCode(HttpStatus.OK)
+  async getActionsByStage(@Body() body: { stage_id: number }) {
+    const result = await this.workflowService.getActionCategoryListByStageId(
+      body.stage_id,
+    );
+    return result;
+  }
+
+  @Post('/getStagesByGroup')
+  @HttpCode(HttpStatus.OK)
+  async getStagesByGroup(@Body() body: { stage_group_id: number }) {
+    const result = await this.workflowService.getStagesByGroup(
+      body.stage_group_id,
+    );
+    return result;
+  }
+}

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

@@ -0,0 +1,17 @@
+import { ACTION_CATEGORY } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_action_category' })
+export class ActionCategory extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ACTION_CATEGORY;
+  }
+
+  @Column({ type: 'varchar', nullable: true })
+  logo: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  modalName: string;
+}

package/src/module/workflow/entity/action-template-mapping.entity.ts

@@ -0,0 +1,17 @@
+import { ACTION_TEMPLATE_MAPPING } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_action_template_mapping' })
+export class ActionTemplateMapping extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ACTION_TEMPLATE_MAPPING;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  stg_act_mapping_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  template_code: string;
+}

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

@@ -0,0 +1,20 @@
+import { ACTION } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_action' })
+export class Action extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ACTION;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  workflow_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  action_cat_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  action_requirement: string;
+}

package/src/module/workflow/entity/comm-template.entity.ts

@@ -0,0 +1,11 @@
+import { COMM_TEMPLATE } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_comm_template' })
+export class CommTemplate extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = COMM_TEMPLATE;
+  }
+}

package/src/module/workflow/entity/stage-action-mapping.entity.ts

@@ -0,0 +1,17 @@
+import { STAGE_ACTION_MAPPING } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_stage_action_mapping' })
+export class StageActionMapping extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = STAGE_ACTION_MAPPING;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  stage_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  action_id: number;
+}

package/src/module/workflow/entity/stage-group.entity.ts

@@ -0,0 +1,17 @@
+import { STAGE_GROUP } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_stage_group' })
+export class StageGroup extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = STAGE_GROUP;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  workflow_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  sortindex: number;
+}

package/src/module/workflow/entity/stage-movement-data.entity.ts

@@ -0,0 +1,26 @@
+import { STAGE_MOVEMENT_DATA } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_stage_movement_data' })
+export class StageMovementData extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = STAGE_MOVEMENT_DATA;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  current_user_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  stage_action_mapping_id: number;
+
+  @Column({ type: 'date', nullable: true })
+  start_date: Date;
+
+  @Column({ type: 'date', nullable: true })
+  end_date: Date;
+
+  @Column({ type: 'varchar', nullable: true })
+  is_current: string;
+}

package/src/module/workflow/entity/stage.entity.ts

@@ -0,0 +1,20 @@
+import { STAGE } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_stage' })
+export class Stage extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = STAGE;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  stage_group_id: number;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  full_name: string;
+
+  @Column({ type: 'int', nullable: true })
+  sortindex: number;
+}

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

@@ -0,0 +1,11 @@
+import { WORKFLOW_DATA } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Entity } from 'typeorm';
+
+@Entity({ name: 'cr_workflow_data' })
+export class WorkFlowData extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = WORKFLOW_DATA;
+  }
+}

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

@@ -0,0 +1,14 @@
+import { WORKFLOW } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_workflow' })
+export class Workflow extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = WORKFLOW;
+  }
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+}

package/src/module/workflow/repository/workflow.repository.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class WorkflowRepsository {}

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

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+
+@Injectable()
+export class ActionCategoryService extends EntityServiceImpl {}

package/src/module/workflow/service/action-template-mapping.service.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+
+@Injectable()
+export class ActionTemplateMappingService extends EntityServiceImpl {}

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

@@ -0,0 +1,80 @@
+import { Injectable } from '@nestjs/common';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { DataSource, EntityManager } from 'typeorm';
+
+@Injectable()
+export class ActionService extends EntityServiceImpl {
+  constructor(private readonly dataSource: DataSource) {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager | null,
+    appcode?: string,
+  ): Promise<any> {
+    console.log('entityData', entityData);
+
+    let actionData = entityData as any;
+
+    let action = await super.createEntity(
+      entityData,
+      loggedInUser,
+      manager,
+      appcode,
+    );
+
+    let stageActionMapping = {
+      action_id: action.id,
+      stage_id: actionData.stage_id,
+      entity_type: 'STGM',
+    } as any;
+
+    let stageActionMappingData = await super.createEntity(
+      stageActionMapping,
+      loggedInUser,
+      manager,
+      appcode,
+    );
+
+    if (Array.isArray(actionData.template) && actionData.template.length > 0) {
+      const templates = actionData.template;
+
+      for (let i = 0; i < templates.length; i++) {
+        const templateId = templates[i];
+
+        // Fetch the template code from `cr_wf_comm_template`
+        const templateResult = await this.dataSource.query(
+          `SELECT code FROM cr_wf_comm_template WHERE id = ?`,
+          [templateId],
+        );
+
+        if (templateResult.length === 0) {
+          console.warn(`Template not found for id: ${templateId}`);
+          continue;
+        }
+
+        const templateCode = templateResult[0].code;
+
+        // Create Action-Template Mapping
+        const actionTemplateMapping = {
+          stg_act_mapping_id: stageActionMappingData.id,
+          template_code: templateCode,
+          entity_type: 'ATMP',
+        } as any;
+
+        await super.createEntity(
+          actionTemplateMapping,
+          loggedInUser,
+          manager,
+          appcode,
+        );
+      }
+    }
+
+    return actionData;
+  }
+}

package/src/module/workflow/service/comm-template.service.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+
+@Injectable()
+export class CommTemplateService extends EntityServiceImpl {}

package/src/module/workflow/service/stage-action-mapping.service.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+
+@Injectable()
+export class StageActionMappingService extends EntityServiceImpl {}

package/src/module/workflow/service/stage-group.service.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+
+@Injectable()
+export class StageGroupService extends EntityServiceImpl {}