rez_core 2.0.2 → 2.0.4

package/package.json

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

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

@@ -0,0 +1,13 @@
+import { Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { BaseEntity } from './base-entity.entity';
+
+@Entity({ name: 'cr_app_master' })
+export class UserAppMapping extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'APM';
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+}

package/src/module/meta/entity/user-app-mapping.entity.ts

@@ -0,0 +1,21 @@
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_user_app_mapping' })
+export class UserAppMapping {
+  constructor(user_id: number) {
+    this.user_id = user_id;
+    this.entity_type = 'UAP';
+  }
+
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'bigint', nullable: true })
+  user_id: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  appcode: string;
+
+  @Column({ type: 'varchar' })
+  entity_type: string;
+}

package/src/module/meta/entity.module.ts

@@ -38,6 +38,9 @@ import { MetaController } from './controller/meta.controller';
 import { EntityValidationService } from './service/entity-validation.service';
 import { ListMasterModule } from '../listmaster/listmaster.module';
 import { FilterModule } from '../filter/filter.module';
+import { UserAppMappingService } from './service/user-app-mapping.service';
+import { UserAppMappingRepository } from './repository/user-app-mapping.repository';
+import { UserAppMapping } from './entity/user-app-mapping.entity';
 
 @Module({
   imports: [
@@ -53,10 +56,12 @@ import { FilterModule } from '../filter/filter.module';
       SchoolAddressEntity,
       SectionMaster,
       FieldGroup,
+      UserAppMapping,
     ]),
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
-    UtilsModule  ],
+    UtilsModule,
+  ],
   providers: [
     EntityMasterService,
     EntityServiceImpl,
@@ -77,6 +82,8 @@ import { FilterModule } from '../filter/filter.module';
     ViewMaterRespository,
     EntityValidationService,
     { provide: 'ViewMasterService', useClass: ViewMasterService },
+    UserAppMappingService,
+    UserAppMappingRepository,
   ],
   exports: [
     EntityMasterService,
@@ -91,6 +98,8 @@ import { FilterModule } from '../filter/filter.module';
     FieldGroupService,
     'ViewMasterService',
     AttributeMasterService,
+    UserAppMappingService,
+    UserAppMappingRepository,
   ],
   controllers: [
     EntityController,

package/src/module/meta/repository/user-app-mapping.repository.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { UserAppMapping } from '../entity/user-app-mapping.entity';
+
+@Injectable()
+export class UserAppMappingRepository {
+  constructor(
+    @InjectRepository(UserAppMapping)
+    private readonly userAppMappingRepository: Repository<UserAppMapping>,
+  ) {}
+
+  async save(userId: number, appCode: string): Promise<UserAppMapping | null> {
+    const mapping = this.userAppMappingRepository.create({
+      user_id: userId,
+      appcode: appCode,
+    });
+    return await this.userAppMappingRepository.save(mapping);
+  }
+
+  async findByUserIdAndAppCode(
+    userId: number,
+    appCode: string,
+  ): Promise<UserAppMapping | null> {
+    return await this.userAppMappingRepository.findOne({
+      where: { user_id: userId, appcode: appCode },
+    });
+  }
+}

package/src/module/meta/service/entity-list.service.ts

@@ -71,9 +71,9 @@ export class EntityListService {
     appcode?: string,
   ) {
     // Add appcode to filters if provided
-    if (appcode) {
-      filters = { ...filters, appcode };
-    }
+    // if (appcode) {
+    //   filters = { ...filters, appcode };
+    // }
 
     let query = this.getQuery(entityTable.data_source, null);
     let whereClause = await this.getWhereClause(entityTable, filters);
@@ -95,7 +95,7 @@ export class EntityListService {
     appcode?: string,
   ) {
     let query = this.getQuery(entityTable.data_source, entityTable.tab_column);
-    let whereClause = await this.getWhereClause(entityTable, filters, appcode);
+    let whereClause = await this.getWhereClause(entityTable, filters);
     if (whereClause.query) {
       query += whereClause.query;
     }

package/src/module/meta/service/entity-service-impl.service.ts

@@ -35,7 +35,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     loggedInUser: UserData | null,
     manager?: EntityManager | null,
     appcode?: string,
-  ){
+  ) {
     if (!entityData.entity_type) {
       throw new BadRequestException(`EntityType is missing`);
     }
@@ -49,10 +49,10 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
         entityMaster,
       );
     if (validationErrors.length > 0) {
-      return {
+      throw new BadRequestException({
         success: false,
         errors: validationErrors,
-      };
+      });
     }
 
     const repo = manager

package/src/module/meta/service/user-app-mapping.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { UserAppMappingRepository } from '../repository/user-app-mapping.repository';
+
+@Injectable()
+export class UserAppMappingService {
+  constructor(
+    private readonly userAppMappingRepository: UserAppMappingRepository,
+  ) {}
+
+  async assignUserAppMapping(userId: number, appCode: string) {
+    return await this.userAppMappingRepository.save(userId, appCode);
+  }
+
+  async getUserAppMappings(userId: number , appCode: string) {
+    return await this.userAppMappingRepository.findByUserIdAndAppCode(userId, appCode);
+  }
+}

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

@@ -12,7 +12,7 @@ export class UserRoleMapping {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column({type: 'varchar'})
+  @Column({ type: 'varchar' })
   entity_type: string;
 
   @Column({ type: 'bigint', nullable: true })
@@ -24,6 +24,6 @@ export class UserRoleMapping {
   @Column({ type: 'int', nullable: true })
   is_default: number;
 
-  @Column({type: 'varchar'})
+  @Column({ type: 'varchar', nullable: true })
   appcode: string;
 }

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

@@ -4,6 +4,7 @@ import { UserData } from '../entity/user.entity';
 import { UserSessionService } from './user-session.service';
 import { UserService } from './user.service';
 import { ConfigService } from '@nestjs/config';
+import { UserAppMappingService } from 'src/module/meta/service/user-app-mapping.service';
 
 @Injectable()
 export class LoginService {
@@ -11,13 +12,20 @@ export class LoginService {
     @Inject('UserService') private readonly userService: UserService,
     private userSessionService: UserSessionService,
     private configService: ConfigService,
+    private readonly userAppMappingService: UserAppMappingService,
   ) {}
 
   masterKey: string = this.configService.get('MASTER_KEY') || '';
   masterIv: string = this.configService.get('MASTER_IV') || '';
 
-  async login(email: string, password: string,appcode:string,organization_id) {
-    const user = await this.userService.findByEmailId(email,organization_id,appcode);
+  async login(
+    email: string,
+    password: string,
+    appcode: string,
+    organization_id,
+  ) {
+    const user = await this.userService.findByEmailId(email, organization_id);
+
     if (!user) {
       return {
         success: false,
@@ -26,6 +34,18 @@ export class LoginService {
       };
     }
 
+    const userAppMapping = await this.userAppMappingService.getUserAppMappings(
+      user.id,
+      appcode,
+    );
+
+    if (!userAppMapping) {
+      // If user is not mapped to the app, throw an error
+      throw new BadRequestException(
+        `User with email ${email} is not mapped to the app ${appcode}.`,
+      );
+    }
+
     if (user.status !== 'ACTIVE') {
       return {
         success: false,
@@ -48,7 +68,7 @@ export class LoginService {
       };
     }
 
-    const token = await this.userSessionService.createSession(user);
+    const token = await this.userSessionService.createSession(user, appcode);
 
     if (user.is_firstlogin === 1) {
       user.invitation_status = 'ACCEPTED';

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

@@ -13,7 +13,7 @@ export class UserSessionService {
     private readonly clockIDGenService: ClockIDGenService,
     private configService: ConfigService,
   ) {}
-  async createSession(user) {
+  async createSession(user, appcode?: string) {
     const sessionToken = this.clockIDGenService.idGenerator('SES');
 
     const userSession: any = new UserSession();
@@ -28,7 +28,7 @@ export class UserSessionService {
 
     await this.userSessionRepository.saveSession(userSession);
 
-    const payload = { userId: user.id, sessionToken, appcode: user.appcode };
+    const payload = { userId: user.id, sessionToken, appcode: appcode };
     const accessToken = this.jwtAuthService.generateJwt(payload);
 
     userSession.access_token = accessToken;

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

@@ -1,4 +1,5 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { RoleService } from './role.service';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
 import { UserData } from '../entity/user.entity';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
@@ -16,6 +17,8 @@ import { plainToInstance } from 'class-transformer';
 import { EntityManager } 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 { Role } from '../entity/role.entity';
 
 @Injectable()
 export class UserService extends EntityServiceImpl {
@@ -24,6 +27,8 @@ export class UserService extends EntityServiceImpl {
     private userRoleMappingService: UserRoleMappingService,
     private readonly clockIDGenService: ClockIDGenService,
     private configService: ConfigService,
+    private readonly userAppMappingService: UserAppMappingService,
+    @Inject('RoleService') private readonly roleService: RoleService,
   ) {
     super();
   }
@@ -38,7 +43,7 @@ export class UserService extends EntityServiceImpl {
     appcode?: string,
   ): Promise<BaseEntity> {
     let userData = entityData as CreateUserDto;
-    if(appcode){
+    if (appcode) {
       userData.appcode = appcode;
     }
     let existingUser = await this.userRepository.findByEmailId(
@@ -75,9 +80,12 @@ export class UserService extends EntityServiceImpl {
     }
     userData.password = password;
     userData.is_firstlogin = 1;
+    userData.roles = [];
     userData.invitation_status = 'SENT';
     userData.status = STATUS_ACTIVE;
     const savedData = await super.createEntity(userData, loggedInUser);
+    userData.roles.push('1');
+    userData.roles.push('2');
     if (userData.roles) {
       let roles = userData.roles;
       await this.userRoleMappingService.deleteByUserId(userData.id);
@@ -86,10 +94,53 @@ export class UserService extends EntityServiceImpl {
           savedData.id,
           Number(roles[role]),
         );
+      
         await this.userRoleMappingService.assignUserRole(userRoleMapping);
       }
     }
 
+    //Assign user app mapping as per user
+
+    const appcodedata = ['CRM', 'ERP'];
+
+    if (savedData.id) {
+      for (const app of appcodedata) {
+        await this.userAppMappingService.assignUserAppMapping(
+          savedData.id,
+          app,
+        );
+      }
+    }
+
+    // let role = new Role();
+    // role.organization_id = savedData.organization_id;
+    // role.enterprise_id = savedData.enterprise_id;
+    // role.is_system = 1;
+    // role.status = 'ACTIVE';
+    // role.name = 'School Admin';
+
+    // let defaultadminERP: string | undefined = 'ADMIN';
+    // let defaultadminCRM: string | undefined = 'ADMIN_CRM';
+
+    // if (defaultadminERP && defaultadminCRM) {
+    //   let defaultAdminRoleERP = await this.roleService.findByCode(
+    //     ENTITYTYPE_ROLE,
+    //     defaultadminERP,
+    //   );
+    //   let defaultAdminRoleCRM = await this.roleService.findByCode(
+    //     ENTITYTYPE_ROLE,
+    //     defaultadminCRM,
+    //   );
+    //   if (defaultAdminRoleERP) {
+    //     role.copy_from_role_id = defaultAdminRoleERP.id;
+    //     let savedRoleERP = await this.roleService.createEntity(role, null);
+    //   }
+    //   if (defaultAdminRoleCRM) {
+    //     role.copy_from_role_id = defaultAdminRoleCRM.id;
+    //     let savedRoleCRM = await this.roleService.createEntity(role, null);
+    //   }
+    // }
+
     return savedData;
   }
 
@@ -169,11 +220,27 @@ export class UserService extends EntityServiceImpl {
     return savedData;
   }
 
-  async findByEmailId(email_id: string,organization_id?: number,appCode?:string): Promise<UserData | null> {
-    return await this.userRepository.findByEmailId(email_id,organization_id,appCode);
+  async findByEmailId(
+    email_id: string,
+    organization_id?: number,
+    appCode?: string,
+  ): Promise<UserData | null> {
+    return await this.userRepository.findByEmailId(
+      email_id,
+      organization_id,
+      appCode,
+    );
   }
 
-  async findByMobile(mobile: string,organization_id?: number,appCode?:string): Promise<UserData | null> {
-    return await this.userRepository.findByMobile(mobile,organization_id,appCode);
+  async findByMobile(
+    mobile: string,
+    organization_id?: number,
+    appCode?: string,
+  ): Promise<UserData | null> {
+    return await this.userRepository.findByMobile(
+      mobile,
+      organization_id,
+      appCode,
+    );
   }
 }