rez_core 6.5.61 → 6.5.63

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

@@ -1,65 +1,45 @@
-import { RoleService } from './role.service';
-import {
-  BadRequestException,
-  ForbiddenException,
-  Inject,
-  Injectable,
-} from '@nestjs/common';
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { UserData } from '../entity/user.entity';
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserRepository } from '../repository/user.repository';
-import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
-import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
-import {
-  ENTITYTYPE_ROLE,
-  STATUS_ACTIVE,
-  INVITATION_STATUS_SENT,
-} from '../../../constant/global.constant';
+import { INVITATION_STATUS_SENT } from '../../../constant/global.constant';
 import { CreateUserDto } from '../dto/create-user.dto';
 import { UserRoleMappingService } from './user-role-mapping.service';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { EntityManager, Repository } from 'typeorm';
-import { UpdateUserDto } from '../dto/update-user.dto';
 import { ConfigService } from '@nestjs/config';
-// import { UserAppMappingService } from 'src/module/meta/service/user-app-mapping.service';
-import { ServiceResult } from 'src/dtos/response.dto';
-import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
-import { OrganizationRepository } from 'src/module/enterprise/repository/organization.repository';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Action } from 'src/module/workflow-automation/interface/action.interface';
 import { ActionHandler } from 'src/module/workflow-automation/interface/action.decorator';
+import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
+import { plainToInstance } from 'class-transformer';
+import { UpdateUserDto } from '../dto/update-user.dto';
+import { EnterpriseRepository } from 'src/module/enterprise/repository/enterprise.repository';
+import { StatusConstant } from '../../../constant/status.constant';
+import { RoleRepository } from '../repository/role.repository';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 
 @Injectable()
 @ActionHandler('User')
-export class UserService extends EntityServiceImpl implements Action {
+export class UserService {
   constructor(
     private userRepository: UserRepository,
     private userRoleMappingService: UserRoleMappingService,
-    private readonly clockIDGenService: ClockIDGenService,
+    private roleRepo: RoleRepository,
     private configService: ConfigService,
-    private readonly organizationRepository: OrganizationRepository,
-    // private readonly userAppMappingService: UserAppMappingService,
-    @Inject('RoleService') private readonly roleService: RoleService,
-    @Inject('ListMasterService')
-    private readonly listMasterService: ListMasterService,
+    private readonly enterpriseRepository: EnterpriseRepository,
+    private readonly reflectionHelper: ReflectionHelper
   ) {
-    super();
   }
 
   masterKey = this.configService.get('MASTER_KEY') || '';
   masterIv = this.configService.get('MASTER_IV') || '';
 
-  async createEntity(
-    entityData: BaseEntity,
-    loggedInUser: UserData | null,
-    manager?: EntityManager,
-  ): Promise<ServiceResult<BaseEntity>> {
-    const userData = entityData as CreateUserDto;
+  async createUser(
+    entityData: CreateUserDto,
+    loggedInUser: UserData,
+  ) {
+    const userData = entityData;
 
     let existingUser = await this.userRepository.findByEmailId(
       userData.email_id,
-      loggedInUser?.organization_id,
+      loggedInUser?.enterprise_id,
     );
     if (existingUser) {
       return { success: false, error: 'User with this email already exists' };
@@ -67,43 +47,46 @@ export class UserService extends EntityServiceImpl implements Action {
 
     existingUser = await this.userRepository.findByMobile(
       userData.mobile,
-      loggedInUser?.organization_id,
+      loggedInUser?.enterprise_id,
     );
     if (existingUser) {
       return { success: false, error: 'User with this mobile already exists' };
     }
 
-    const resolveStatus = await this.listMasterService.getResolvedListCode(
-      STATUS_ACTIVE,
-      loggedInUser?.organization_id || 0,
-    );
-
-    const resolvedInvitationStatus =
-      await this.listMasterService.getResolvedListCode(
-        INVITATION_STATUS_SENT,
-        loggedInUser?.organization_id || 0,
-      );
+    if(!userData.code) {
+      const maxId = await this.userRepository.findMaxIdRecord();
+      if(maxId && maxId.id) {
+        userData.code = `USR${maxId.id + 1}`;
+      } else {
+        userData.code = `USR1`;
+      }
+    }
 
-    userData.name =
-      (userData.first_name || '') + ' ' + (userData.last_name || '');
     userData.password = EncryptUtilService.encryptGCM(
       userData.password || 'Admin@123',
       this.masterKey,
       this.masterIv,
     );
+
+    userData.enterprise_id = loggedInUser.enterprise_id;
+    userData.level_type = loggedInUser.level_type;
+    userData.level_id = loggedInUser.level_id;
+
     userData.is_firstlogin = 1;
     userData.roles = [];
-    userData.invitation_status = resolvedInvitationStatus.id;
-    userData.status = resolveStatus.id || 'ACTIVE';
+    userData.invitation_status = INVITATION_STATUS_SENT;
+    userData.status = StatusConstant.ACTIVE;
 
-    const savedData = await super.createEntity(userData, loggedInUser);
+    const entity = plainToInstance(UserData, userData);
+    entity.created_by = loggedInUser.created_by;
+
+    const savedData = await this.userRepository.saveUser(entity);
 
     const insertPromises: Promise<UserRoleMapping | void | null | undefined>[] =
       [];
 
     for (const entry of userData.access || []) {
       const { level_type, level_ids, app_code, role_id } = entry;
-
       if (
         !level_type ||
         !Array.isArray(level_ids) ||
@@ -113,13 +96,19 @@ export class UserService extends EntityServiceImpl implements Action {
       ) {
         return { success: false, error: 'Invalid access level entry' };
       }
-
+      const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
+      const appMaster = await appMasterRepo.findOne({
+        where: {
+          code: app_code
+        }
+      })
       for (const levelId of level_ids) {
         const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
         userRoleMapping.level_type = level_type;
         userRoleMapping.level_id = String(levelId);
         userRoleMapping.appcode = app_code;
-        userRoleMapping.organization_id = loggedInUser?.organization_id || 0;
+        userRoleMapping.app_id = appMaster.id
+        userRoleMapping.enterprise_id = loggedInUser?.enterprise_id || 0;
         insertPromises.push(
           this.userRoleMappingService.assignUserRole(userRoleMapping),
         );
@@ -139,15 +128,10 @@ export class UserService extends EntityServiceImpl implements Action {
   }
 
   name: string = 'UserService';
-  async execute(payload: any): Promise<any> {
-    console.log('payload', payload);
-  }
 
-  async getEntityData(
-    entityType: string,
+  async getUserData(
     id: number,
-    loggedInUser?: UserData,
-  ): Promise<BaseEntity | null> {
+  ) {
     const user = await this.userRepository.findById(id);
     if (user) {
       const userRoleMappings: UserRoleMapping[] | null =
@@ -158,11 +142,7 @@ export class UserService extends EntityServiceImpl implements Action {
         for (const i in userRoleMappings) {
           const userRoleMapping = userRoleMappings[i];
           const roleId = userRoleMapping.role_id;
-          const role = await super.getEntityData(
-            ENTITYTYPE_ROLE,
-            roleId,
-            loggedInUser,
-          );
+          const role = await this.roleRepo.findById(roleId);
           roles.push(role);
         }
         userDto.roles = roles;
@@ -172,13 +152,13 @@ export class UserService extends EntityServiceImpl implements Action {
     return null;
   }
 
-  async updateEntity(
-    entityData: BaseEntity,
+  async updateUser(
+    id: number,
+    userDto: UpdateUserDto,
     loggedInUserData: UserData,
-  ): Promise<ServiceResult<BaseEntity>> {
-    const userDto = entityData as UpdateUserDto;
+  ) {
 
-    const existingUser = await this.userRepository.findById(entityData.id);
+    const existingUser = await this.userRepository.findById(id);
 
     if (!existingUser) {
       return { success: false, error: 'User not found' };
@@ -208,10 +188,7 @@ export class UserService extends EntityServiceImpl implements Action {
     const updatedUserData = { ...userDto } as any;
     delete updatedUserData.access;
 
-    const savedData = await super.updateEntity(
-      updatedUserData,
-      loggedInUserData,
-    );
+    const savedData = await this.userRepository.updateUser(id, updatedUserData);
 
     // Handle updated access levels
     if (userDto.access && userDto.access.length > 0) {
@@ -235,12 +212,11 @@ export class UserService extends EntityServiceImpl implements Action {
         }
 
         for (const levelId of level_ids) {
-          const userRoleMapping = new UserRoleMapping(savedData.id, role_id);
+          const userRoleMapping = new UserRoleMapping(id, role_id);
           userRoleMapping.level_type = level_type;
           userRoleMapping.level_id = String(levelId);
           userRoleMapping.appcode = app_code;
-          userRoleMapping.organization_id =
-            loggedInUserData?.organization_id || 0;
+          userRoleMapping.enterprise_id = loggedInUserData.enterprise_id;
 
           insertPromises.push(
             this.userRoleMappingService.assignUserRole(userRoleMapping),
@@ -261,9 +237,10 @@ export class UserService extends EntityServiceImpl implements Action {
 
   async findByEmailId(
     email_id: string,
-    organization_id?: number,
+    enterprise_id?: number,
+    getLastApp?: boolean,
   ): Promise<UserData | null> {
-    return await this.userRepository.findByEmailId(email_id, organization_id);
+    return await this.userRepository.findByEmailId(email_id, enterprise_id, getLastApp);
   }
 
   async findByMobile(
@@ -278,14 +255,14 @@ export class UserService extends EntityServiceImpl implements Action {
     );
   }
 
-  async setDefaultLastAccess(userId: number, appcode: string): Promise<void> {
+  async setDefaultLastAccess(userId: number, app_id: number): Promise<void> {
     const user = await this.userRepository.findById(userId);
 
     if (!user) {
       throw new BadRequestException('User not found');
     }
 
-    user.last_app_access = appcode;
+    user.last_app_access_id = app_id;
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
@@ -294,7 +271,7 @@ export class UserService extends EntityServiceImpl implements Action {
     userId: number,
     levelType: string,
     levelId: string,
-    appcode: string,
+    app_id: number,
   ): Promise<void> {
     const user = await this.userRepository.findById(userId);
 
@@ -304,7 +281,7 @@ export class UserService extends EntityServiceImpl implements Action {
 
     user.last_level_type = levelType;
     user.last_level_id = levelId;
-    user.last_app_access = appcode;
+    user.last_app_access_id = app_id;
 
     await this.userRepository.saveUser(user); // This persists the updated field
   }
@@ -319,15 +296,15 @@ export class UserService extends EntityServiceImpl implements Action {
       return { success: false, message: 'Email and Subdomain is required' };
     }
 
-    let organization;
+    let enterprise;
 
     if (subdomain) {
-      organization =
-        await this.organizationRepository.findOrganizationBySubdomain(
+      enterprise =
+        await this.enterpriseRepository.findEnterpriseBySubdomain(
           subdomain,
         );
 
-      if (!organization) {
+      if (!enterprise) {
         // throw new BadRequestException('Organization not found.');
         return {
           success: false,
@@ -339,14 +316,14 @@ export class UserService extends EntityServiceImpl implements Action {
     // 🔹 Step 2: Find the user by email + organization check
     const user = await this.userRepository.findByEmailId(
       email_id,
-      organization?.id,
+      enterprise?.id,
     );
 
-    if (!user || (organization && user.organization_id !== organization.id)) {
+    if (!user || (enterprise && user.enterprise_id !== enterprise.id)) {
       // throw new BadRequestException('User not found in organization.');
       return {
         success: false,
-        message: 'User not found in organization.',
+        message: 'User not found in enterprise.',
       };
     }
 
@@ -365,4 +342,8 @@ export class UserService extends EntityServiceImpl implements Action {
       };
     }
   }
+
+  async find(options: any): Promise<UserData[]> {
+    return await this.userRepository.find(options);
+  }
 }

package/src/module/user/user.module.ts

@@ -23,6 +23,7 @@ import { ModuleAccess } from '../module/entity/module-access.entity';
 import { EnterpriseModule } from '../enterprise/enterprise.module';
 import { ListMasterModule } from '../listmaster/listmaster.module';
 import { IntegrationModule } from '../integration/integration.module';
+import { EnterpriseData } from '../enterprise/entity/enterprise.entity';
 
 @Module({
   imports: [
@@ -34,11 +35,8 @@ import { IntegrationModule } from '../integration/integration.module';
       ModuleAccess,
     ]),
     forwardRef(() => AuthModule),
-    EntityModule,
     UtilsModule,
-    ListMasterModule,
-    IntegrationModule,
-    forwardRef(() => EnterpriseModule),
+    forwardRef(() => EnterpriseModule)
   ],
   providers: [
     { provide: 'UserService', useClass: UserService },
@@ -59,7 +57,8 @@ import { IntegrationModule } from '../integration/integration.module';
     UserRoleMappingService,
     RoleRepository,
     LoginService,
+    UserRoleMappingRepository
   ],
   controllers: [LoginController, UserController],
 })
-export class UserModule {}
+export class UserModule { }

package/src/module/workflow/repository/action-data.repository.ts

@@ -51,7 +51,6 @@ export class ActionDataRepository extends EntityServiceImpl {
           action_id: act.id,
           sequence: act.sequence,
           name: act.name,
-          organization_id: loggedInUser.organization_id,
           enterprise_id: loggedInUser.enterprise_id,
           mapped_entity_id,
           mapped_entity_type,
@@ -116,7 +115,6 @@ export class ActionDataRepository extends EntityServiceImpl {
               this.reflectionHelper.getRepoService('EntityRelationData');
 
             await entityRelationDataRepo.save({
-              organization_id: loggedInUser.organization_id,
               enterprise_id: loggedInUser.enterprise_id,
               source_entity_id: createdEntity.mapped_entity_id,
               source_entity_type: createdEntity.mapped_entity_type,
@@ -189,7 +187,7 @@ export class ActionDataRepository extends EntityServiceImpl {
   }
 
   async resubmitAction(
-    organization_id: number,
+    loggedInUser: UserData,
     mapped_entity_type: string,
     mapped_entity_id: number,
     stage_id: number,
@@ -198,7 +196,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Get the current active action
     const currentAction = await this.actionDataRepo.findOne({
       where: {
-        organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
         stage_id,
         mapped_entity_id,
         mapped_entity_type,
@@ -215,7 +213,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Find the immediate previous action in the sequence
     const previousAction = await this.actionDataRepo.findOne({
       where: {
-        organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
         stage_id,
         mapped_entity_id,
         mapped_entity_type,
@@ -232,7 +230,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Unset current action
     currentAction.is_current = null as any;
     currentAction.modified_date = new Date();
-    currentAction.modified_by = organization_id;
+    currentAction.modified_by = loggedInUser.id;
     currentAction.start_time = null as any;
     currentAction.resubmit_count = (currentAction.resubmit_count ?? 0) + 1;
 
@@ -241,7 +239,7 @@ export class ActionDataRepository extends EntityServiceImpl {
     // Mark previous action as current again
     previousAction.is_current = 'Y';
     previousAction.modified_date = new Date();
-    previousAction.modified_by = organization_id;
+    previousAction.modified_by = loggedInUser.id;
     previousAction.end_time = null as any; // Reset end time
     previousAction.is_done = false;
     await this.actionDataRepo.update(previousAction.id, previousAction);
@@ -268,7 +266,7 @@ export class ActionDataRepository extends EntityServiceImpl {
         const listMasterItem = await listMasterItemRepo.findOne({
           where: {
             code: 'in_progress',
-            organization_id: organization_id,
+            enterprise_id: loggedInUser.enterprise_id,
             listtype: 'TKST',
           },
         });

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

@@ -8,12 +8,12 @@ export class ActionRepository {
   constructor(private readonly reflectionHelper: ReflectionHelper) {}
 
   async getReasonCode(loggedInUser: UserData): Promise<any> {
-    const { organization_id } = loggedInUser;
+    const { enterprise_id } = loggedInUser;
     const listMasterRepo =
       this.reflectionHelper.getRepoService('ListMasterData');
     const result = await listMasterRepo.find({
       where: {
-        organization_id,
+        enterprise_id,
         source: 'master',
       },
     });
@@ -27,7 +27,7 @@ export class ActionRepository {
   }
 
   async defaultReasonCode(list_type: string, loggedInUser: UserData) {
-    const { organization_id } = loggedInUser;
+    const { enterprise_id } = loggedInUser;
     if (!list_type) {
       throw new BadRequestException('list_type is required');
     }
@@ -38,7 +38,7 @@ export class ActionRepository {
     const result = await listMasterItemsRepo.find({
       where: {
         listtype: list_type,
-        organization_id,
+        enterprise_id,
       },
     });
 
@@ -50,7 +50,7 @@ export class ActionRepository {
   }
 
   async getActions(loggedInUser: UserData, stage_id: number) {
-    const { organization_id } = loggedInUser;
+    const { enterprise_id } = loggedInUser;
 
     const workflowStageActionRepo =
       this.reflectionHelper.getRepoService('StageActionMapping');
@@ -88,7 +88,7 @@ export class ActionRepository {
       const templates = await workflowCommTemplateRepo.find({
         where: {
           code: In(templateCodes),
-          organization_id: organization_id,
+          enterprise_id: enterprise_id,
         },
       });
 
@@ -148,10 +148,10 @@ export class ActionRepository {
         'ar',
         `ar.id::text = a.action_requirement 
       AND ar.listtype = 'ACRQ' 
-      AND ar.organization_id = :orgId`,
-        { orgId: organization_id },
+      AND ar.enterprise_id = :entId`,
+        { entId: enterprise_id },
       )
-      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .where('a.enterprise_id = :entId', { entId: enterprise_id })
       .andWhere('a.id::text IN (:...actionIds)', { actionIds })
       .getRawMany();
 
@@ -218,7 +218,7 @@ export class ActionRepository {
   }
 
   async getAction(
-    organization_id: number,
+    enterprise_id: number,
     stage_id: number,
     mapped_entity_id: number,
     mapped_entity_type: string,
@@ -268,7 +268,7 @@ export class ActionRepository {
         'ac',
         'ac.id = a.action_category::bigint',
       )
-      .where('a.organization_id = :orgId', { orgId: organization_id })
+      .where('a.enterprise_id = :entId', { entId: enterprise_id })
       .andWhere('a.id IN (:...actionIds)', { actionIds })
       .orderBy('a.sequence', 'ASC')
       .getRawMany();

package/src/module/workflow/repository/form-master.repository.ts

@@ -8,12 +8,12 @@ export class FormMasterRepository {
     private readonly reflectionHelper: ReflectionHelper,
   ) {}
 
-  async getForms(organization_id: number, source_entity_type: string) {
+  async getForms(enterprise_id: number, source_entity_type: string) {
 
     const viewMasterRepo = this.reflectionHelper.getRepoService('ViewMaster');
     const forms = await viewMasterRepo.find({
       where: {
-        organization_id,
+        enterprise_id,
         mapped_entity_type: source_entity_type
       }
     });

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

@@ -3,6 +3,7 @@ import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.s
 import { UserData } from 'src/module/user/entity/user.entity';
 import { DataSource } from 'typeorm';
 import { ActionDataRepository } from '../repository/action-data.repository';
+import { log } from 'console';
 
 @Injectable()
 export class ActionDataService extends EntityServiceImpl {
@@ -50,9 +51,9 @@ export class ActionDataService extends EntityServiceImpl {
     stage_id: number,
     action_id: number,
   ) {
-    const { organization_id } = loggedInUser;
+  
     return this.actionDataRepo.resubmitAction(
-      organization_id,
+      loggedInUser,
       mapped_entity_type,
       mapped_entity_id,
       stage_id,

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

@@ -291,9 +291,9 @@ export class ActionService extends EntityServiceImpl {
     mapped_entity_id: number,
     mapped_entity_type: string,
   ) {
-    const { organization_id } = loggedInUser;
+    const { enterprise_id } = loggedInUser;
     return this.actionRepository.getAction(
-      organization_id,
+      enterprise_id,
       stage_id,
       mapped_entity_id,
       mapped_entity_type,

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

@@ -75,9 +75,7 @@ export class CommTemplateService extends EntityServiceImpl {
         entity_type: templateData.entity_type,
         template_id: tempData.id,
         media_id: attachment,
-        organization_id: loggedInUser.organization_id,
         enterprise_id: loggedInUser.enterprise_id,
-        appcode: loggedInUser.appcode,
         level_id: loggedInUser.level_id,
         level_type: loggedInUser.level_type,
       }));

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

@@ -17,7 +17,6 @@ export class EntityModificationService extends EntityServiceImpl {
   async logModification(modificationData: any, loggedInUser: UserData) {
     const { mapped_entity_type, mapped_entity_id, attribute_key } =
       modificationData;
-    const { organization_id } = loggedInUser;
 
     if (!mapped_entity_type || !mapped_entity_id || !attribute_key) {
       throw new BadRequestException(

package/src/module/workflow/service/form-master.service.ts

@@ -10,9 +10,9 @@ export class FormMasterService extends EntityServiceImpl {
   }
 
   async getForms(loggedInUser: UserData, source_entity_type: string) {
-    const { organization_id } = loggedInUser;
+    const { enterprise_id } = loggedInUser;
     return this.formMasterRepository.getForms(
-      organization_id,
+      enterprise_id,
       source_entity_type,
     );
   }

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

@@ -2,7 +2,7 @@ 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';
+import { PopulateMetaService } from '../../enterprise/service/populate-meta.service';
 import { Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { WorkflowService } from './workflow.service';

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

@@ -81,7 +81,6 @@ export class TaskService extends EntityServiceImpl {
       entityData,
       loggedInUser,
       manager,
-      appcode,
     );
 
     try {
@@ -208,7 +207,6 @@ export class TaskService extends EntityServiceImpl {
           description: `${updatedEntity.code} was marked as completed`,
           category: ACTIVITY_CATEGORIES.TASK,
           action: 'completed',
-          appcode: loggedInUser.appcode,
         };
 
         await this.activityLogService.logActivity(
@@ -223,7 +221,6 @@ export class TaskService extends EntityServiceImpl {
           description: `${updatedEntity.code} was edited`,
           category: ACTIVITY_CATEGORIES.TASK,
           action: 'edit',
-          appcode: loggedInUser.appcode,
         };
 
         await this.activityLogService.logActivity(editLogData, loggedInUser);
@@ -499,7 +496,6 @@ export class TaskService extends EntityServiceImpl {
         description: `${task.name} was deleted`,
         category: ACTIVITY_CATEGORIES.TASK,
         action: 'delete',
-        appcode: loggedInUser.appcode,
       };
 
       await this.activityLogService.logActivity(logData, loggedInUser);