rez_core 7.0.0 → 7.0.1

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

@@ -1,197 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { UserData } from '../entity/user.entity';
-import { Role } from '../entity/role.entity';
-import { RoleRepository } from '../repository/role.repository';
-import { Repository } from 'typeorm';
-import { InjectRepository } from '@nestjs/typeorm';
-import { ModuleAccess } from '../../module/entity/module-access.entity';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { plainToInstance } from 'class-transformer';
-import { StatusConstant } from '../../../constant/status.constant';
-
-@Injectable()
-export class RoleService {
-  constructor(
-    private readonly roleRepository: RoleRepository,
-    @InjectRepository(ModuleAccess)
-    private readonly moduleAccessRepo: Repository<ModuleAccess>,
-    @InjectRepository(UserRoleMapping)
-    private readonly userRoleMappingRepo: Repository<UserRoleMapping>,
-  ) {
-  }
-
-  async createRole(
-    role: Role,
-    loggedInUser: any,
-  ) {
-
-    // 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;
-
-    if (
-      await this.roleRepository.isRoleNameWithLevelExists(role.name, {
-        enterprise_id: loggedInUser.enterprise_id,
-        level_type: role.level_type || loggedInUser?.level_type,
-        level_id:
-          parseInt(role.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)
-      : 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);
-    if (sourceRole) {
-      const sourcePermissions = await this.moduleAccessRepo.find({
-        where: { role_code: sourceRole.code },
-      });
-
-      const clonedPermissions = sourcePermissions.map((perm) =>
-        this.moduleAccessRepo.create({
-          role_code: savedRole.code,
-          action_type: perm.action_type,
-          access_flag: perm.access_flag,
-          level_type: perm.level_type,
-          appcode: perm.appcode,
-          module_id: perm.module_id,
-        }),
-      );
-
-      await this.moduleAccessRepo.save(clonedPermissions);
-    }
-    return { success: true, data: savedRole };
-  }
-
-  async updateRole(
-    id: number,
-    role: Role,
-    loggedInUser: UserData,
-  ) {
-    if (!role.name) {
-      return { success: false, error: 'Role name is required' };
-    }
-
-    if (role.status == StatusConstant.INACTIVE) {
-      //get role by id
-      const existingRole = await this.roleRepository.findById(id);
-
-      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', {
-          roleId: String(existingRole?.id),
-        })
-        .select('map') // same as SELECT map.*
-        .getRawMany();
-
-      if (associatedUsers.length > 0) {
-        return {
-          success: false,
-          error: 'Cannot deactivate role as it is associated with active users',
-        };
-      }
-
-      if (role.is_system === 1) {
-        return {
-          success: false,
-          error: 'Cannot deactivate system role',
-        };
-      }
-    }
-
-    if (
-      await this.roleRepository.isRoleNameExists(role.name, {
-        excludeRoleId: role.id,
-        enterprise_id: loggedInUser?.enterprise_id,
-      })
-    ) {
-      return {
-        success: false,
-        error: 'Role name already exists.',
-      };
-    }
-
-    const { copy_from_role_id, ...persistableData } = role;
-
-    const entity = plainToInstance(Role, persistableData);
-    const updatedRole = await this.roleRepository.updateRole(id, entity);
-
-    if (role.copy_from_role_id) {
-
-      const sourceRole = await this.roleRepository.findById(role.copy_from_role_id);
-
-      if (!sourceRole) {
-        return {
-          success: false,
-          error: 'Source role not found',
-        };
-      }
-
-      await this.moduleAccessRepo.delete({ role_code: role.code });
-
-      const sourcePermissions = await this.moduleAccessRepo.find({
-        where: { role_code: sourceRole.code },
-      });
-
-      const clonedPermissions = sourcePermissions.map((perm) =>
-        this.moduleAccessRepo.create({
-          role_code: role.code,
-          module_id: perm.module_id,
-          action_type: perm.action_type,
-          access_flag: perm.access_flag,
-          appcode: perm.appcode,
-          level_type: perm.level_type,
-        }),
-      );
-
-      await this.moduleAccessRepo.save(clonedPermissions);
-    }
-    return { success: true, data: updatedRole };
-  }
-
-  async getDefaultRole(data: {
-    is_factory?: boolean;
-    level_id?: number;
-    level_type?: string;
-  }): 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

@@ -1,128 +0,0 @@
-import { level } from 'winston';
-import { Injectable } from '@nestjs/common';
-import { UserRoleMappingRepository } from '../repository/user-role-mapping.repository';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-
-@Injectable()
-export class UserRoleMappingService {
-  constructor(
-    private readonly userRoleMappingRepository: UserRoleMappingRepository,
-  ) { }
-
-  async assignUserRole(userRoleMapping: UserRoleMapping) {
-    const existing = await this.userRoleMappingRepository.findByUserIdAndRoleId(
-      userRoleMapping.user_id,
-      userRoleMapping.role_id,
-      userRoleMapping.appcode,
-      userRoleMapping.level_id,
-      userRoleMapping.level_type,
-    );
-
-    if (!existing) {
-      return await this.userRoleMappingRepository.save(userRoleMapping);
-    }
-  }
-
-  async updateAssignedRole(userRoleMapping: UserRoleMapping) {
-    // 1. If ID is provided, try to fetch existing mapping by ID
-    if (userRoleMapping.id) {
-      const existing = await this.userRoleMappingRepository.findByUSRId(
-        userRoleMapping.id,
-      );
-      if (existing) {
-        existing.appcode = userRoleMapping.appcode;
-        existing.level_id = userRoleMapping.level_id;
-        existing.level_type = userRoleMapping.level_type;
-        existing.role_id = userRoleMapping.role_id;
-
-        return await this.userRoleMappingRepository.save(existing);
-      }
-    }
-
-    // 2. Check if a similar mapping already exists (same user-role-level-app)
-    const duplicate =
-      await this.userRoleMappingRepository.findByUserIdAndRoleId(
-        userRoleMapping.user_id,
-        userRoleMapping.role_id,
-        userRoleMapping.appcode,
-        userRoleMapping.level_id,
-        userRoleMapping.level_type,
-      );
-
-    if (duplicate) {
-      return duplicate; // or null, depending on how you want to handle it
-    }
-
-    return await this.userRoleMappingRepository.save(userRoleMapping);
-  }
-
-  async findByUserId(userId: number): Promise<UserRoleMapping[] | null> {
-    return await this.userRoleMappingRepository.findByUserId(userId);
-  }
-
-  async deleteByUserId(
-    userId: number,
-    levelType?: string,
-    levelId?,
-  ): Promise<void> {
-    await this.userRoleMappingRepository.deleteByUserId(
-      userId,
-      levelType,
-      levelId,
-    );
-  }
-
-  async getUserByIdAndAppCode(
-    userId: number,
-    appCode: string,
-  ): Promise<UserRoleMapping | null> {
-    return await this.userRoleMappingRepository.findByUserIdAndAppCode(
-      userId,
-      appCode,
-    );
-  }
-
-  async getUserByIdAppCodeAndLevel(
-    userId: number,
-    appCode: string,
-    levelType: string,
-    levelId: string,
-  ): Promise<UserRoleMapping | null> {
-    return await this.userRoleMappingRepository.findByUserIdAndAppCodeAndLevel(
-      userId,
-      appCode,
-      levelType,
-      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);
-  }
-
-  async findDistinctAppcodeByUserId(
-    userId: number,
-  ): Promise<{ appcode: string[] }> {
-    return await this.userRoleMappingRepository.findDistinctAppcodeByUserId(
-      userId,
-    );
-  }
-}

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

@@ -1,203 +0,0 @@
-import { UserSession } from '../entity/user-session.entity';
-import { ClockIDGenService } from '../../../utils/service/clockIDGenUtil.service';
-import { BadRequestException, Injectable } from '@nestjs/common';
-import { UserSessionRepository } from '../repository/userSession.repository';
-import { JwtAuthService } from 'src/module/auth/services/jwt.service';
-import { ConfigService } from '@nestjs/config';
-import { Repository } from 'typeorm';
-import { UserRoleMapping } from '../entity/user-role-mapping.entity';
-import { UserData } from '../entity/user.entity';
-import { InjectRepository } from '@nestjs/typeorm';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-
-@Injectable()
-export class UserSessionService {
-  constructor(
-    private readonly userSessionRepository: UserSessionRepository,
-    private readonly jwtAuthService: JwtAuthService,
-    private readonly clockIDGenService: ClockIDGenService,
-    private configService: ConfigService,
-    @InjectRepository(UserData)
-    private readonly userDataRepository: Repository<UserData>,
-    private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
-
-  async createSession(user, app_id?: number, accessInfo?: any, appcode?: string) {
-    const sessionToken = this.clockIDGenService.idGenerator('SES');
-
-    const userSession: any = new UserSession();
-    userSession.user_id = user.id;
-    userSession.session_key = sessionToken;
-    userSession.is_session_loggedout = 0;
-    // userSession.login_time = new Date(); -- Changed login_time to be auto generated by typeorm
-
-    const expiryTokenInHours = this.configService.get('TOKEN_EXPIRY') || 1;
-    userSession.expiry_date = new Date(
-      Date.now() + expiryTokenInHours * 60 * 60 * 1000,
-    );
-
-    await this.userSessionRepository.saveSession(userSession);
-
-    const payload: any = {
-      id: user.id,
-      sessionToken,
-      app_id,
-      email_id: user.email_id,
-      organization_id: user.organization_id,
-      enterprise_id: user.enterprise_id,
-      appcode,
-    };
-
-    // ✅ Add role access details
-    if (accessInfo) {
-      payload.level_type = accessInfo.level_type;
-      payload.level_id = accessInfo.level_id;
-    }
-
-    const accessToken = this.jwtAuthService.generateJwt(payload);
-
-    await this.userSessionRepository.saveSession(userSession);
-
-    return accessToken;
-  }
-
-  async findBySessionKey(sessionKey: string): Promise<UserSession | null> {
-    return await this.userSessionRepository.findBySessionKey(sessionKey);
-  }
-
-  async updateSession(userSession: UserSession) {
-    await this.userSessionRepository.saveSession(userSession);
-  }
-
-  async fetchUserFcmToken(user_id: number) {
-    return await this.userSessionRepository.fetchUserFcmToken(user_id);
-  };
-
-
-  async switchCurrentLevelService(
-    currentUser: any,
-    data: any,
-  ): Promise<{
-    success: boolean;
-    accessToken: string;
-    appcode: string;
-    level_type: string;
-    level_id: string;
-  }> {
-    let payload;
-
-    payload = {
-      ...currentUser,
-      level_id: data.level_id,
-      level_type: data.level_type,
-      appcode: data.appcode,
-    };
-
-    let getUserDetails: UserData | null = null;
-
-    if (currentUser) {
-      // Check if user has any role mappings for the given appcode
-
-      getUserDetails = await this.userDataRepository.findOne({
-        where: {
-          id: currentUser.id,
-        },
-      });
-    }
-
-    if (getUserDetails?.enterprise_id == 1 && payload.level_type == 'ORG') {
-      payload.organization_id = payload.level_id;
-    }
-
-    await this.userDataRepository.update(currentUser.id, {
-      last_app_access_id: data.app_id,
-      last_level_type: data.level_type,
-      last_level_id: data.level_id,
-    });
-
-    return {
-      success: true,
-      accessToken: this.jwtAuthService.generateJwt(payload),
-      appcode: data.appcode,
-      level_type: data.level_type,
-      level_id: data.level_id,
-    };
-  }
-
-  async checkIfUserHasMapping(
-    userId: number,
-    appcode: string,
-    levelType: string,
-    levelId: string,
-  ): Promise<boolean> {
-    // Get repositories dynamically via reflectionHelper
-    const userRoleMappingRepo =
-      this.reflectionHelper.getRepoService('UserRoleMapping');
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
-    // Use QueryBuilder with proper aliases
-    const count = await userRoleMappingRepo
-      .createQueryBuilder('urm')
-      .innerJoin(
-        appMasterRepo.metadata.tableName,
-        'app',
-        'app.appcode = urm.appcode',
-      )
-      .where('urm.user_id = :userId', { userId })
-      .andWhere('urm.appcode = :appcode', { appcode })
-      .andWhere('urm.level_type = :levelType', { levelType })
-      .andWhere('urm.level_id = :levelId', { levelId })
-      .andWhere('app.show_in_ui = true')
-      .getCount();
-
-    return count > 0;
-  }
-
-  async getUserRoleMappingForApp(userId: number, appcode: string) {
-    const userRoleMappingRepo =
-      this.reflectionHelper.getRepoService('UserRoleMapping');
-    const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
-    const mapping = await userRoleMappingRepo
-      .createQueryBuilder('urm')
-      .innerJoin(
-        appMasterRepo.metadata.tableName,
-        'app',
-        'app.appcode = urm.appcode',
-      )
-      .where('urm.user_id = :userId', { userId })
-      .andWhere('urm.appcode = :appcode', { appcode })
-      .andWhere('app.show_in_ui = true')
-      .getOne();
-
-    if (!mapping) {
-      throw new BadRequestException(
-        `User does not have visible access to app ${appcode}`,
-      );
-    }
-
-    if (mapping.level_type !== 'BRN') {
-      return mapping;
-    }
-
-    // Resolve SCH under brand
-    const schoolRepo = this.reflectionHelper.getRepoService('SSOSchool');
-    const school = await schoolRepo.findOne({
-      where: { brand_id: mapping.level_id },
-      order: { id: 'ASC' },
-    });
-
-    if (!school) {
-      throw new BadRequestException(
-        `No schools found under brand ${mapping.level_id}`,
-      );
-    }
-
-    return {
-      ...mapping,
-      level_type: 'SCH',
-      level_id: school.id,
-    };
-  }
-}