rez_core 2.1.144 → 2.1.147

package/package.json

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

package/src/constant/global.constant.ts

@@ -50,3 +50,5 @@ export const COMM_TEMPLATE = 'TEM';
 export const ACTION_TEMPLATE_MAPPING = 'ATMP';
 export const WORKFLOW_DATA = 'WFDT';
 export const STAGE_MOVEMENT_DATA = 'STMV';
+
+export const ENTITY_MODIFICATION = 'ENMD';

package/src/module/enterprise/repository/school.repository.ts

@@ -3,6 +3,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { DataSource, Repository } from 'typeorm';
 import { SchoolData } from '../entity/school.entity';
 import { UserRoleMapping } from 'src/module/user/entity/user-role-mapping.entity';
+import { STATUS_INACTIVE } from 'src/constant/global.constant';
 
 @Injectable()
 export class SchoolRepository {
@@ -39,6 +40,16 @@ export class SchoolRepository {
       currentORGLevel_id = org_id;
     }
 
+    const resolvedInactiveStatus = await this.dataSource
+      .createQueryBuilder()
+      .select('*')
+      .from('cr_list_master_items', 'cli')
+      .where('cli.code = :code AND cli.organization_id = :orgId', {
+        code: STATUS_INACTIVE,
+        orgId: org_id,
+      })
+      .getRawOne();
+
     if (hasOrgAccess.length > 0) {
       const schools = await this.dataSource
         .createQueryBuilder()
@@ -129,9 +140,14 @@ export class SchoolRepository {
             })
             .getRawOne();
 
+          const finalSchoolName =
+            schoolStatus?.id === resolvedInactiveStatus?.id
+              ? `${school_name} [INACTIVE]`
+              : school_name;
+
           result[org_id].brands[brand_id].schools.push({
             school_id,
-            school_name,
+            school_name: finalSchoolName,
             school_location,
             status: schoolStatus ? schoolStatus.name : school_status,
             type: 'School',
@@ -225,13 +241,18 @@ export class SchoolRepository {
           };
         }
 
+        const finalSchoolName =
+          school_status === resolvedInactiveStatus?.id
+            ? `${school_name} [INACTIVE]`
+            : school_name;
+
         if (
           school_id &&
           !result[brand_id].schools.some((s) => s.school_id === school_id)
         ) {
           result[brand_id].schools.push({
             school_id,
-            school_name,
+            school_name: finalSchoolName,
             school_location,
             status: school_status,
             type: 'School',

package/src/module/layout_preference/controller/layout_preference.controller.ts

@@ -15,11 +15,13 @@ export class LayoutPreferenceController {
     @Query('entity_type') entity_type: string,
     @Req() req: Request & { user: any },
   ) {
-    const userId = req.user.userData.id;
+    const userDat = req.user.userData;
 
     return this.layoutPreferenceService.getLayoutPreferenceByUserID(
-      userId,
+      userDat.id,
       entity_type,
+      userDat.level_id,
+      userDat.level_type,
     );
   }
 

package/src/module/layout_preference/entity/layout_preference.entity.ts

@@ -14,4 +14,15 @@ export class LayoutPreference extends BaseEntity {
 
   @Column({ nullable: true, type: 'json' })
   navigation_tabs_json: any;
+
+  @Column({
+    name: 'mapped_level_id',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  mapped_level_id: string;
+
+  @Column({ name: 'mapped_level_type', type: 'varchar', nullable: true })
+  mapped_level_type: string;
 }

package/src/module/layout_preference/repository/layout_preference.repository.ts

@@ -11,13 +11,17 @@ export class LayoutPreferenceRepository {
   ) {}
 
   async findByEntityUserId(
-    entity_type: string,
+    mapped_entity_type: string,
+    mapped_level_id: string,
+    mapped_level_type: string,
     userId: number,
   ): Promise<LayoutPreference | null> {
     return this.layoutPreferenceRepo.findOne({
       where: {
         user_id: userId.toString(),
-        mapped_entity_type: entity_type,
+        mapped_entity_type: mapped_entity_type,
+        mapped_level_id: mapped_level_id,
+        mapped_level_type: mapped_level_type,
       },
     });
   }

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -27,6 +27,8 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     const existingLayoutPreference =
       await this.layoutPreferenceRepository.findByEntityUserId(
         mapped_entity_type,
+        loggedInUser.level_id,
+        loggedInUser.level_type,
         userId,
       );
 
@@ -38,16 +40,31 @@ export class LayoutPreferenceService extends EntityServiceImpl {
     }
 
     return await super.createEntity(
-      { ...entityData, user_id: userId } as any,
+      {
+        ...entityData,
+        user_id: userId,
+        mapped_level_id: loggedInUser.level_id,
+        mapped_level_type: loggedInUser.level_type,
+      } as any,
       loggedInUser,
     );
   }
 
-  async getLayoutPreferenceByUserID(user_id, mapped_entity_type) {
-    return await this.layoutPreferenceRepository.findByEntityUserId(
-      mapped_entity_type,
-      user_id,
-    );
+  async getLayoutPreferenceByUserID(
+    user_id,
+    mapped_entity_type,
+    mapped_level_id,
+    mapped_level_type,
+  ) {
+    const layoutPreference =
+      await this.layoutPreferenceRepository.findByEntityUserId(
+        mapped_entity_type,
+        mapped_level_id,
+        mapped_level_type,
+        user_id,
+      );
+
+    return layoutPreference;
   }
 
   async getColumnValue(
@@ -65,6 +82,7 @@ export class LayoutPreferenceService extends EntityServiceImpl {
       );
 
     const tableName = getTableMeta?.data_source;
+
     if (!tableName) {
       throw new Error('Invalid or missing table name in metadata');
     }

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

@@ -1,19 +1,17 @@
 import {
   Body,
   Controller,
+  Get,
   HttpStatus,
+  Param,
   Post,
+  Req,
   Res,
-  Get,
-  Param,
   UseGuards,
-  Req,
 } from '@nestjs/common';
-import { MediaDataService } from '../service/media-data.service';
+import { Response } from 'express';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import e, { Response } from 'express';
-import { ENTITYTYPE_MEDIA } from 'src/constant/global.constant';
-import { MediaData } from '../entity/media-data.entity';
+import { MediaDataService } from '../service/media-data.service';
 
 @Controller('media')
 @UseGuards(JwtAuthGuard)

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

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { ActionCategoryService } from '../service/action-category.service';
+
+@Controller('/actionCategory')
+@UseGuards(JwtAuthGuard)
+export class ActionCategoryController {
+  constructor(
+    @Inject('ActionCategoryService')
+    private readonly actionCategoryService: ActionCategoryService,
+  ) {}
+
+  @Post('/getActionsCategory')
+  @HttpCode(HttpStatus.OK)
+  async getActionsCat(
+    @Req() req: Request & { user: any },
+    @Body('entity_type') entity_type: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionCategoryService.getActionsCat(
+      loggedInUser,
+      entity_type,
+    );
+    return result;
+  }
+}

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

@@ -41,4 +41,15 @@ export class ActionController {
     );
     return result;
   }
+
+  @Post('/getActions')
+  @HttpCode(HttpStatus.OK)
+  async getActions(
+    @Req() req: Request & { user: any },
+    @Body('stage_id') stage_id: number,
+  ) {
+    const loggedInUser = req.user.userData;
+    const result = this.actionService.getActions(loggedInUser, stage_id);
+    return result;
+  }
 }

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

@@ -1,8 +1,9 @@
 import {
+  Body,
   Controller,
-  Get,
   HttpCode,
   HttpStatus,
+  Post,
   Query,
   Req,
   UseGuards,
@@ -15,15 +16,15 @@ import { CommTemplateService } from '../service/comm-template.service';
 export class CommTemplateController {
   constructor(private readonly commTemplateService: CommTemplateService) {}
 
-  @Get('/get-comm-template')
+  @Post('/getTemplates')
   @HttpCode(HttpStatus.OK)
   async getTemplate(
     @Req() req: Request & { user: any },
-    @Query('entity_type') entityType?: string,
+    @Body('entity_type') entity_type: string,
   ) {
     const loggedInUser = req.user.userData;
     const result = this.commTemplateService.getAllCommTemplate(
-      entityType || '',
+      entity_type || '',
       loggedInUser,
     );
     return result;

package/src/module/workflow/controller/entity-modification.controller.ts

@@ -0,0 +1,35 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { EntityModificationService } from '../service/entity-modification.service';
+
+@Controller('/entity-modification')
+@UseGuards(JwtAuthGuard)
+export class EntityModificationController {
+  constructor(
+    @Inject('EntityModificationService')
+    private readonly entityModificationService: EntityModificationService,
+  ) {}
+
+  @Post('/logModification')
+  @HttpCode(HttpStatus.OK)
+  async logModification(
+    @Body() modificationData: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.entityModificationService.logModification(
+      modificationData,
+      loggedInUser,
+    );
+  }
+}

package/src/module/workflow/controller/workflow-meta.controller.ts

@@ -0,0 +1,52 @@
+import { Controller, Get, Query, Post, Body } from '@nestjs/common';
+import { WorkflowMetaService } from '../service/workflow-meta.service';
+import { StageMovementData } from '../entity/stage-movement-data.entity';
+
+@Controller('workflow-meta')
+export class WorkflowMetaController {
+  constructor(private readonly workflowMetaService: WorkflowMetaService) {}
+
+  /**
+   * GET /meta/current-stage?entityType=...&entityId=...
+   */
+  @Get('current-stage')
+  async getCurrentStage(
+    @Query('entityType') mapped_entity_type: string,
+    @Query('entityId') mapped_entity_id: number,
+  ): Promise<StageMovementData | null> {
+    return this.workflowMetaService.getCurrentStage(mapped_entity_type, Number(mapped_entity_id));
+  }
+
+  /**
+   * GET /meta/next-stage?entityType=...&entityId=...
+   */
+  @Get('next-stage')
+  async getNextStage(
+    @Query('entityType') mapped_entity_type: string,
+    @Query('entityId') mapped_entity_id: number,
+  ): Promise<number | null> {
+    const current = await this.workflowMetaService.getCurrentStage(mapped_entity_type, Number(mapped_entity_id));
+    return current ? this.workflowMetaService.getNextStage(current) : null;
+  }
+
+  /**
+   * POST /meta/move-next-stage
+   * {
+   *   "entityType": "lead",
+   *   "entityId": 101,
+   *   "currentUserId": 5
+   * }
+   */
+  @Post('move-next-stage')
+  async moveToNextStage(
+    @Body('entityType') mapped_entity_type: string,
+    @Body('entityId') mapped_entity_id: number,
+    @Body('currentUserId') current_user_id: number,
+  ): Promise<string> {
+    return this.workflowMetaService.moveToNextStage(
+      mapped_entity_type,
+      Number(mapped_entity_id),
+      current_user_id,
+    );
+  }
+}

package/src/module/workflow/controller/workflow.controller.ts

@@ -14,6 +14,7 @@ import {
 } from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { WorkflowService } from '../service/workflow.service';
+import { PopulateWorkflowService } from '../service/populate-workflow.service';
 
 @Controller('/workflow')
 @UseGuards(JwtAuthGuard)
@@ -21,6 +22,7 @@ export class WorkflowController {
   constructor(
     @Inject('WorkflowService')
     private readonly workflowService: WorkflowService,
+    private readonly populateWorkflowService: PopulateWorkflowService,
   ) {}
 
   @Post('/getAllWorkflows')
@@ -50,4 +52,16 @@ export class WorkflowController {
     const loggedInUser = req.user?.userData;
     return this.workflowService.updateSequence(body, loggedInUser);
   }
+
+  @Post('/populateWorkflow')
+  async populateWorkflow(
+    @Body() body: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user?.userData;
+    return this.populateWorkflowService.populateWorkflowData(
+      body.organization_id,
+      loggedInUser,
+    );
+  }
 }

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

@@ -14,4 +14,7 @@ export class ActionCategory extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   modalName: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
 }

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

@@ -18,6 +18,9 @@ export class ActionEntity extends BaseEntity {
   @Column({ type: 'varchar', nullable: true })
   action_requirement: string;
 
+  @Column({ type: 'varchar', nullable: true })
+  sequence: string;
+
   @Column({ type: 'varchar', nullable: true })
   reason_code: string;
 

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

@@ -9,6 +9,23 @@ export class CommTemplate extends BaseEntity {
     this.entity_type = COMM_TEMPLATE;
   }
 
-  @Column({ type: 'varchar', nullable: true })
+  @Column({ nullable: true })
   mode: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ nullable: true })
+  subject: string;
+
+  @Column({ nullable: true })
+  format_type: string;
+
+  // if format_type is 'richtext', this field will be used
+  @Column({ type: 'longtext', nullable: true })
+  rich_text: string;
+
+  // if format_type is 'markup', this field will be used
+  @Column({ nullable: true })
+  markup_id: number;
 }

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

@@ -0,0 +1,38 @@
+import { ENTITY_MODIFICATION } from 'src/constant/global.constant';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_wf_entity_modification' })
+export class EntityModification extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITY_MODIFICATION;
+  }
+
+  @Column({ type: 'int', nullable: true })
+  mapped_entity_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mode: string;
+
+  @Column({ type: 'int', nullable: true })
+  stage_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  action_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  attribute_key: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  current_value: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  new_value: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  reason_code: string;
+}

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

@@ -23,4 +23,10 @@ export class StageMovementData extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   is_current: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ type: 'int', nullable: true })
+  mapped_entity_id: number;
 }

package/src/module/workflow/entity/template-attach-mapper.entity.ts

@@ -0,0 +1,30 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_wf_tem_attach_mapper' })
+export class TemplateAttach {
+  constructor() {}
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({})
+  entity_type: string;
+
+  @Column({ nullable: true })
+  template_id: number;
+
+  @Column({ nullable: true })
+  media_id: number;
+
+  @Column({ nullable: true })
+  organization_id: number;
+
+  @Column({ nullable: true })
+  appcode: string;
+
+  @Column({ nullable: true })
+  level_id: string;
+
+  @Column({ nullable: true })
+  level_type: string;
+}

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

@@ -3,32 +3,56 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Workflow } from '../entity/workflow.entity';
 import { Repository } from 'typeorm';
 import { CommTemplate } from '../entity/comm-template.entity';
+import { TemplateAttach } from '../entity/template-attach-mapper.entity';
+import { MediaDataService } from 'src/module/meta/service/media-data.service';
 
 @Injectable()
 export class CommTemplateRepository {
   constructor(
     @InjectRepository(CommTemplate)
     private readonly commTemplateRepository: Repository<CommTemplate>,
+    @InjectRepository(TemplateAttach)
+    private readonly templateAttachEntity: Repository<TemplateAttach>,
+    private readonly mediaDataService: MediaDataService,
   ) {}
 
   async getAllCommTemplate(entity_type: string, loggedInUser) {
+    const { organization_id } = loggedInUser;
     return this.commTemplateRepository.find({
       select: ['name', 'code'],
       where: {
-        entity_type: entity_type,
+        mapped_entity_type: entity_type,
+        organization_id: organization_id,
       },
     });
   }
 
+  async save(commTemplate: any): Promise<any> {
+    // // delete existing mapper
+    // for (const attachment of commTemplate || []) {
+    //   await this.templateAttachEntity.delete({
+    //     entity_type: attachment.entity_type,
+    //     template_id: attachment.template_id,
+    //   });
+    // }
+
+    return this.templateAttachEntity.save(commTemplate);
+  }
+
+  async delete(id: any): Promise<any> {
+    // delete existing mapper
+    return await this.templateAttachEntity.delete(id);
+  }
+
   async getTemplateByCode(
     entity_type: string,
     code: string,
     loggedInUser,
-  ): Promise<CommTemplate | null> {
+  ): Promise<any | null> {
     const template = await this.commTemplateRepository.findOne({
       where: {
-        entity_type: entity_type,
-        code: code,
+        entity_type,
+        code,
       },
     });
 
@@ -36,6 +60,35 @@ export class CommTemplateRepository {
       throw new NotFoundException(`Template with code ${code} not found`);
     }
 
-    return template;
+    if (template.format_type === 'markup') {
+      const media = await this.mediaDataService.getMediaDownloadUrl(
+        template.markup_id,
+        loggedInUser,
+      );
+
+      console.log(media);
+    }
+
+    if (template.format_type === 'richtext') {
+      return template;
+    }
+
+    // Get only attachment IDs
+    const attachments = await this.templateAttachEntity.find({
+      select: ['media_id'],
+      where: {
+        entity_type: entity_type,
+        template_id: template.id,
+      },
+    });
+
+    const media = await this.mediaDataService.getMediaDownloadUrl(
+      1,
+      loggedInUser,
+    );
+
+    console.log(media);
+
+    return { ...template, attachments: attachments.map((att) => att.media_id) };
   }
 }

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

@@ -1,5 +1,27 @@
 import { Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { DataSource } from 'typeorm';
 
 @Injectable()
-export class ActionCategoryService extends EntityServiceImpl {}
+export class ActionCategoryService extends EntityServiceImpl {
+  constructor(private readonly dataSource: DataSource) {
+    super();
+  }
+
+  async getActionsCat(loggedInUser: UserData, entity_type: string) {
+    const { organization_id } = loggedInUser;
+
+    const result = await this.dataSource.query(
+      `
+    SELECT id, name 
+    FROM cr_wf_action_category 
+    WHERE mapped_entity_type = ? 
+      AND organization_id = ?
+    `,
+      [entity_type, organization_id],
+    );
+
+    return result;
+  }
+}

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

@@ -36,7 +36,7 @@ export class ActionTemplateMappingService extends EntityServiceImpl {
       [mode],
     );
 
-    if (!listMasterItemData?.length) return []; // 🛑 No mode found
+    if (!listMasterItemData?.length) return [];
 
     const templateCodes = templates.map((t) => t.template_code);
     if (!templateCodes.length) return [];