rez_core 6.5.59 → 6.5.61

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

@@ -1,3 +1,4 @@
+import { OrganizationData } from './../../enterprise/entity/organization.entity';
 import { Repository } from 'typeorm';
 import { UserData } from '../entity/user.entity';
 import { Injectable } from '@nestjs/common';
@@ -7,46 +8,34 @@ import { InjectRepository } from '@nestjs/typeorm';
 export class UserRepository {
   constructor(
     @InjectRepository(UserData) private userRepository: Repository<UserData>,
-  ) { }
+  ) {}
 
   async findById(userId: number): Promise<UserData | null> {
     return this.userRepository.findOne({ where: { id: userId } });
   }
-
   async findByEmailId(
     email: string,
-    enterprise_id?: number,
-    getLastApp?: boolean,
+    organization_id?: number,
   ): Promise<UserData | null> {
     if (!email) return null;
 
     const where: any = { email_id: email };
-
-    if (enterprise_id !== undefined) {
-      where.enterprise_id = enterprise_id;
+    if (organization_id !== undefined) {
+      where.organization_id = organization_id;
     }
-
-    const options: any = { where };
-
-    if (getLastApp) {
-      options.relations = {
-        last_app: true,
-      };
-    }
-
-    return this.userRepository.findOne(options);
+    return this.userRepository.findOne({ where });
   }
 
   async findByMobile(
     mobile: string,
-    enterprise_id?: number,
+    organization_id?: number,
     appCode?: string,
   ): Promise<UserData | null> {
     if (!mobile) return null;
 
     const where: any = { mobile };
-    if (enterprise_id !== undefined) {
-      where.enterprise_id = enterprise_id;
+    if (organization_id !== undefined) {
+      where.organization_id = organization_id;
     }
     if (appCode !== undefined) {
       where.appcode = appCode;
@@ -58,20 +47,4 @@ export class UserRepository {
   async saveUser(user: UserData): Promise<UserData> {
     return this.userRepository.save(user);
   }
-
-  async updateUser(id: number, user: UserData) {
-    return await this.userRepository.update(id, user);
-  }
-
-  async find(options: any): Promise<UserData[]> {
-    return await this.userRepository.find(options);
-  }
-
-  async findMaxIdRecord() {
-    return await this.userRepository.findOne({
-      order: { id: 'DESC' },
-      select: ['id'],
-      where:{}
-    });
-  }
 }

package/src/module/user/repository/userSession.repository.ts

@@ -8,7 +8,7 @@ export class UserSessionRepository {
   constructor(
     @InjectRepository(UserSession)
     private userSessionRepo: Repository<UserSession>,
-  ) { }
+  ) {}
 
   async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
     return this.userSessionRepo.findOne({ where: { session_key: sessionKey } });
@@ -24,10 +24,6 @@ export class UserSessionRepository {
     return this.userSessionRepo.save(session);
   }
 
-  async fetchUserFcmToken(user_id: number) {
-    return await this.userSessionRepo.findOne({ where: { user_id }, select: ['fcm_token'], order: { login_time: 'DESC' } });
-  }
-
   async logoutSession(sessionKey: string): Promise<void> {
     await this.userSessionRepo.update(
       { session_key: sessionKey },

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

@@ -2,6 +2,8 @@ import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { InjectRepository } from '@nestjs/typeorm';
 import { INVITATION_STATUS_ACCEPTED, STATUS_ACTIVE } from 'src/constant/global.constant';
+import { OrganizationRepository } from 'src/module/enterprise/repository/organization.repository';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { Repository } from 'typeorm';
 import { EncryptUtilService } from '../../../utils/service/encryptUtil.service';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
@@ -9,8 +11,6 @@ import { UserSessionService } from './user-session.service';
 import { UserService } from './user.service';
 import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { EnterpriseRepository } from 'src/module/enterprise/repository/enterprise.repository';
-import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
 export class LoginService {
@@ -20,7 +20,9 @@ export class LoginService {
     private configService: ConfigService,
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-    private readonly enterpriseRepository: EnterpriseRepository,
+    private readonly organizationRepository: OrganizationRepository,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
     private readonly jwtAuthService: JwtAuthService,
     private readonly reflectionHelper: ReflectionHelper,
   ) {
@@ -37,49 +39,53 @@ export class LoginService {
   }): Promise<any> {
     const { email_id, password, is_otp = false, subdomain } = data;
 
-    let enterprise;
+    let organization;
 
     if (subdomain) {
-      enterprise =
-        await this.enterpriseRepository.findEnterpriseBySubdomain(
+      organization =
+        await this.organizationRepository.findOrganizationBySubdomain(
           subdomain,
         );
 
-      if (!enterprise) {
+      if (!organization) {
         return {
           success: false,
-          message: 'Enterprise not found.',
+          message: 'Organization not found.',
         };
       }
     }
 
-    // 🔹 Step 2: Find the user by email + enterprise check
+    // 🔹 Step 2: Find the user by email + organization check
     const user = await this.userService.findByEmailId(
       email_id,
-      enterprise?.id,
-      true
+      organization?.id,
     );
 
-    if (!user || (enterprise && user.enterprise_id !== enterprise.id)) {
+    if (!user || (organization && user.organization_id !== organization.id)) {
       return {
         success: false,
-        message: 'User not found in Enterprise.',
+        message: 'User not found in organization.',
       };
     }
 
     // 🔹 Step 3: Verify org status
-    const userOrgData = await this.enterpriseRepository.findById(
-      user.enterprise_id,
+    const userOrgData = await this.organizationRepository.findOrganizationById(
+      user.organization_id,
+    );
+
+    const resolveStatus = await this.listMasterService.getResolvedListCode(
+      STATUS_ACTIVE,
+      user?.organization_id || 0,
     );
 
     if (
-      user.status != StatusConstant.ACTIVE ||
-      userOrgData?.status != StatusConstant.ACTIVE
+      user.status != resolveStatus.id ||
+      userOrgData?.status != resolveStatus.id
     ) {
       return {
         success: false,
         message:
-          'Your account or Enterprise is inactive. Please contact admin.',
+          'Your account or organization is inactive. Please contact admin.',
       };
     }
 
@@ -101,23 +107,20 @@ export class LoginService {
     }
 
     // 🔹 Step 5: App access check
-    let app_id = user.last_app_access_id;
+    let appcode = user.last_app_access;
 
-    if (!user.last_app_access_id) {
-      await this.userService.setDefaultLastAccess(user.id, app_id);
+    if (!user.last_app_access || user.last_app_access == '') {
+      await this.userService.setDefaultLastAccess(user.id, appcode);
     }
 
     const whereCondition: any = { user_id: user.id };
 
-    if (app_id) {
-      whereCondition.app_id = app_id;
+    if (appcode && appcode !== '') {
+      whereCondition.appcode = appcode;
     }
 
     const roleMappings = await this.userRoleMappingRepository.find({
       where: whereCondition,
-      relations: {
-        app: true
-      }
     });
 
     if (!roleMappings.length) {
@@ -134,29 +137,33 @@ export class LoginService {
       user.id,
       defaultAccess.level_type,
       defaultAccess.level_id,
-      defaultAccess.app_id,
+      defaultAccess.appcode,
     );
 
     const token = await this.userSessionService.createSession(
       user,
-      defaultAccess.app_id,
+      defaultAccess.appcode,
       defaultAccess,
-      defaultAccess.appcode
     );
 
     // 🔹 Step 7: Update first login + invitation status
+    const resolvedInvitationStatus =
+      await this.listMasterService.getResolvedListCode(
+        INVITATION_STATUS_ACCEPTED,
+        user?.organization_id || 0,
+      );
 
     if (user.is_firstlogin === 1) {
-      user.invitation_status = INVITATION_STATUS_ACCEPTED;
+      user.invitation_status = resolvedInvitationStatus.id;
       user.is_firstlogin = 0;
       const { password, ...userWithoutPassword } = user;
-      await this.userService.updateUser(user.id, userWithoutPassword, user);
+      await this.userService.updateEntity(userWithoutPassword, user);
     }
 
     // 🔹 Step 8: Return response
 
-    const org = await this.enterpriseRepository.findById(
-      user.enterprise_id,
+    const org = await this.organizationRepository.findOrganizationById(
+      user.organization_id,
     );
     let slug: string;
     if (org) {
@@ -164,24 +171,23 @@ export class LoginService {
     } else {
       return {
         success: false,
-        message: 'Enterprise not found for the user.',
+        message: 'Organization not found for the user.',
       };
     }
 
     return {
       success: true,
       accessToken: token,
-      app_id: defaultAccess.app_id,
+      appcode: defaultAccess.appcode,
       level_type: defaultAccess.level_type,
       level_id: defaultAccess.level_id,
       slug: slug,
-      appcode: defaultAccess.appcode
     };
   }
 
   async formLogin(body: any): Promise<any> {
     if (body) {
-      const { entity_id } = body;
+      const { entity_type, entity_id } = body;
 
       const leadRepo = this.reflectionHelper.getRepoService('CRMLead');
       const entityData = await leadRepo.findOne({
@@ -191,12 +197,12 @@ export class LoginService {
       if (entityData) {
         const level_id = entityData.level_id;
         const level_type = entityData.level_type;
-        const enterprise_id = entityData.enterprise_id;
+        const organization_id = entityData.organization_id;
 
         const token = this.jwtAuthService.generateJwt({
           level_id: level_id,
           level_type: level_type,
-          enterprise_id: enterprise_id,
+          organization_id: organization_id,
         });
 
         return {
@@ -210,7 +216,7 @@ export class LoginService {
   private async getDefaultAccess(
     user: any,
     roleMappings: any[],
-  ): Promise<{ level_type: string; level_id: string; app_id: number; appcode?:string }> {
+  ): Promise<{ level_type: string; level_id: string; appcode: string }> {
     const orgAccess = roleMappings.find((r) => r.level_type === 'ORG');
     const brnAccesses = roleMappings.filter((r) => r.level_type === 'BRN');
     const schAccesses = roleMappings.filter((r) => r.level_type === 'SCH');
@@ -218,7 +224,7 @@ export class LoginService {
     let validURM;
 
     validURM = roleMappings.some(
-      (r) => r.level_type == 'ORG' && r.level_id == user.enterprise_id,
+      (r) => r.level_type == 'ORG' && r.level_id == user.organization_id,
     );
 
     if (!validURM) {
@@ -233,8 +239,7 @@ export class LoginService {
       return {
         level_type: user.last_level_type,
         level_id: user.last_level_id,
-        app_id: user.last_app_access_id,
-        appcode: user.last_app.code
+        appcode: user.last_app_access,
       };
     }
 
@@ -242,8 +247,7 @@ export class LoginService {
       return {
         level_type: 'ORG',
         level_id: orgAccess.level_id,
-        app_id: orgAccess.app_id,
-        appcode: orgAccess.app.code
+        appcode: orgAccess.appcode,
       };
     }
 
@@ -265,7 +269,7 @@ export class LoginService {
         return {
           level_type: 'SCH',
           level_id: rows.id,
-          app_id: brnAccesses[0].app_id,
+          appcode: brnAccesses[0].appcode,
         };
       } else {
         throw new BadRequestException(
@@ -278,7 +282,7 @@ export class LoginService {
       return {
         level_type: 'SCH',
         level_id: schAccesses[0].level_id,
-        app_id: schAccesses[0].app_id,
+        appcode: schAccesses[0].appcode,
       };
     }
 

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

@@ -1,68 +1,69 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserData } from '../entity/user.entity';
 import { Role } from '../entity/role.entity';
-import { STATUS_INACTIVE } from 'src/constant/global.constant';
+import { ENTITYTYPE_ROLE, STATUS_INACTIVE } from 'src/constant/global.constant';
 import { RoleRepository } from '../repository/role.repository';
-import { Repository } from 'typeorm';
+import { EntityManager, Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
 import { ModuleAccess } from '../../module/entity/module-access.entity';
+import { ServiceResult } from 'src/dtos/response';
+import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
+import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
 import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { plainToInstance } from 'class-transformer';
-import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
-export class RoleService {
+export class RoleService extends EntityServiceImpl {
   constructor(
     private readonly roleRepository: RoleRepository,
+    private readonly entityManager: EntityManager,
     @InjectRepository(ModuleAccess)
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
+    @Inject('ListMasterService')
+    private readonly listMasterService: ListMasterService,
     @InjectRepository(UserRoleMapping)
     private readonly userRoleMappingRepo: Repository<UserRoleMapping>,
   ) {
+    super();
   }
 
-  async createRole(
-    role: Role,
-    loggedInUser: any,
-  ) {
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData,
+  ): Promise<ServiceResult<BaseEntity>> {
+    const role = entityData as Role;
 
     // if level_type and level_id are not provided, use loggedInUser's values
-    role.level_type = role.level_type || loggedInUser.level_type;
-    role.level_id = role.level_id || loggedInUser.level_id;
-    role.created_by = loggedInUser.id;
-    role.enterprise_id = loggedInUser.enterprise_id;
-    role.app_id = role.app_id || loggedInUser.app_id;
+    role.level_type = entityData.level_type || loggedInUser.level_type;
+    role.level_id = entityData.level_id || loggedInUser.level_id;
+    role.appcode = entityData.appcode || loggedInUser.appcode;
 
     if (
       await this.roleRepository.isRoleNameWithLevelExists(role.name, {
-        enterprise_id: loggedInUser.enterprise_id,
-        level_type: role.level_type || loggedInUser?.level_type,
+        organization_id: loggedInUser?.organization_id || undefined,
+        level_type: entityData.level_type || loggedInUser?.level_type,
         level_id:
-          parseInt(role.level_id) ||
+          parseInt(entityData.level_id) ||
           parseInt(loggedInUser?.level_id || '', 10),
       })
     ) {
       return { success: false, error: 'Role name already exists.' };
     }
 
-    if(!role.code) {
-      const maxId = await this.roleRepository.findMaxIdRecord();
-      if(maxId && maxId.id) {
-        role.code = `ROL${maxId.id + 1}`;
-      } else {
-        role.code = `ROL1`;
-      }
-    }
-
     const sourceRole = role.copy_from_role_id
-      ? await this.roleRepository.findById(role.copy_from_role_id)
+      ? await this.getEntityData(
+          ENTITYTYPE_ROLE,
+          role.copy_from_role_id,
+          loggedInUser,
+        )
       : null;
 
     if (role.copy_from_role_id && !sourceRole) {
       return { success: false, error: 'Source role not found.' };
     }
-    role.status = StatusConstant.ACTIVE;
-    const savedRole = await this.roleRepository.saveRole(role);
+
+    const savedRole = await super.createEntity(role, loggedInUser);
     if (sourceRole) {
       const sourcePermissions = await this.moduleAccessRepo.find({
         where: { role_code: sourceRole.code },
@@ -71,11 +72,11 @@ export class RoleService {
       const clonedPermissions = sourcePermissions.map((perm) =>
         this.moduleAccessRepo.create({
           role_code: savedRole.code,
+          module_code: perm.module_code,
           action_type: perm.action_type,
           access_flag: perm.access_flag,
           level_type: perm.level_type,
           appcode: perm.appcode,
-          module_id: perm.module_id
         }),
       );
 
@@ -84,31 +85,40 @@ export class RoleService {
     return { success: true, data: savedRole };
   }
 
-  async updateRole(
-    id: number,
-    role: Role,
+  async updateEntity(
+    entityData: BaseEntity,
     loggedInUser: UserData,
-  ) {
-    if (!role.name) {
+  ): Promise<ServiceResult<BaseEntity>> {
+    if (!entityData.name) {
       return { success: false, error: 'Role name is required' };
     }
+    const role = entityData as Role;
 
-    if (role.status == STATUS_INACTIVE) {
+    const resolveStatus = await this.listMasterService.getResolvedListCode(
+      STATUS_INACTIVE,
+      loggedInUser?.organization_id || 0,
+    );
+
+    if (entityData.status == resolveStatus.id) {
       //get role by id
-      const existingRole = await this.roleRepository.findById(id);
+      const existingRole = await this.getEntityData(
+        ENTITYTYPE_ROLE,
+        entityData.id,
+        loggedInUser,
+      );
 
       if (!existingRole) {
         return { success: false, error: 'Role not found' };
       }
 
       const associatedUsers = await this.userRoleMappingRepo
-        .createQueryBuilder('map')
-        .innerJoin('sso_user', 'usr', 'map.user_id = usr.id')
-        .where('usr.status::text = :status', { status: StatusConstant.INACTIVE })
-        .andWhere('map.role_id::text = :roleId', {
+        .createQueryBuilder("map")
+        .innerJoin("sso_user", "usr", "map.user_id = usr.id")
+        .where("usr.status::text = :status", { status: String(resolveStatus.id) })
+        .andWhere("map.role_id::text = :roleId", {
           roleId: String(existingRole?.id),
         })
-        .select('map') // same as SELECT map.*
+        .select("map") // same as SELECT map.*
         .getRawMany();
 
       if (associatedUsers.length > 0) {
@@ -127,9 +137,9 @@ export class RoleService {
     }
 
     if (
-      await this.roleRepository.isRoleNameExists(role.name, {
-        excludeRoleId: role.id,
-        enterprise_id: loggedInUser?.enterprise_id,
+      await this.roleRepository.isRoleNameExists(entityData.name, {
+        excludeRoleId: entityData.id,
+        organization_id: loggedInUser?.organization_id,
       })
     ) {
       return {
@@ -139,13 +149,14 @@ export class RoleService {
     }
 
     const { copy_from_role_id, ...persistableData } = role;
-
-    const entity = plainToInstance(Role, persistableData);
-    const updatedRole = await this.roleRepository.updateRole(id, entity);
+    const updatedRole = await super.updateEntity(persistableData, loggedInUser);
 
     if (role.copy_from_role_id) {
-
-      const sourceRole = await this.roleRepository.findById(role.copy_from_role_id);
+      const sourceRole = await this.getEntityData(
+        ENTITYTYPE_ROLE,
+        role.copy_from_role_id,
+        loggedInUser,
+      );
 
       if (!sourceRole) {
         return {
@@ -163,7 +174,7 @@ export class RoleService {
       const clonedPermissions = sourcePermissions.map((perm) =>
         this.moduleAccessRepo.create({
           role_code: role.code,
-          module_id: perm.module_id,
+          module_code: perm.module_code,
           action_type: perm.action_type,
           access_flag: perm.access_flag,
           appcode: perm.appcode,
@@ -183,16 +194,4 @@ export class RoleService {
   }): Promise<Role[] | null> {
     return await this.roleRepository.find(data);
   }
-
-  async findByCode(code: string) {
-    return await this.roleRepository.findByCode(code);
-  }
-
-  async findById(id: number) {
-    return await this.roleRepository.findById(id);
-  }
-
-  async find(options: any): Promise<Role[]> {
-    return await this.roleRepository.findRoles(options);
-  }
 }

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

@@ -7,7 +7,7 @@ import { UserRoleMapping } from '../entity/user-role-mapping.entity';
 export class UserRoleMappingService {
   constructor(
     private readonly userRoleMappingRepository: UserRoleMappingRepository,
-  ) { }
+  ) {}
 
   async assignUserRole(userRoleMapping: UserRoleMapping) {
     const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
@@ -95,26 +95,4 @@ export class UserRoleMappingService {
       levelId,
     );
   }
-
-  async find(options: any): Promise<UserRoleMapping[]> {
-    return await this.userRoleMappingRepository.find(options);
-  }
-
-  async create(data: any, loggedInUser: any) {
-    // Assuming data maps to UserRoleMapping or needs transformation
-    // Based on usage in controller: this.roleMappingService.createEntity(data.userRoleMappingData, data.loggedInUserData)
-
-    // If data is already a UserRoleMapping object or similar
-    // We might need to adjust this based on actual DTO structure, but for now passing it through or saving
-
-    // If it's a direct save:
-    // return await this.userRoleMappingRepository.save(data);
-
-    // However, assignUserRole seems to be the main method for creating/assigning. 
-    // Let's use assignUserRole if data matches, or save if it's a raw entity.
-    // The controller passes `data.userRoleMappingData`.
-
-    // Let's assume it's a UserRoleMapping compatible object.
-    return await this.assignUserRole(data);
-  }
 }