rez_core 2.0.49 → 2.0.51

package/package.json

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

package/src/app.module.ts

@@ -10,6 +10,8 @@ import Properties from './resources/properties.module';
 import { LayoutModule } from './module/layout/layout.module';
 import { ListMasterModule } from './module/listmaster/listmaster.module';
 import { ThirdPartyModule } from './module/third-party-module/third-party.module';
+import { FilterModule } from './module/filter/filter.module';
+import { LeadModule } from './module/lead/lead.module';
 
 @Module({
   imports: [
@@ -24,6 +26,8 @@ import { ThirdPartyModule } from './module/third-party-module/third-party.module
     LayoutModule,
     ListMasterModule,
     ThirdPartyModule,
+    FilterModule,
+    LeadModule,
   ],
 })
 export class AppModule {}

package/src/module/lead/controller/lead.controller.ts

@@ -0,0 +1,30 @@
+import { Controller, Get, Param, Query } from '@nestjs/common';
+import { LeadService } from '../service/lead.service';
+
+@Controller('lead')
+export class LeadController {
+  constructor(private readonly leadService: LeadService) {}
+
+  @Get('organizations')
+  async getAllOrganizations() {
+    return this.leadService.getAllOrganizations();
+  }
+
+  @Get('brands/:organizationId')
+  async getBrandsByOrganization(
+    @Param('organizationId') organizationId: number,
+  ) {
+    return this.leadService.getBrandsByOrganization(organizationId);
+  }
+
+  @Get('schools')
+  async getSchoolsByBrandAndOrganization(
+    @Query('brandId') brandId: number,
+    @Query('organizationId') organizationId: number,
+  ) {
+    return this.leadService.getSchoolsByBrandAndOrganization(
+      brandId,
+      organizationId,
+    );
+  }
+}

package/src/module/lead/lead.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { LeadController } from './controller/lead.controller';
+import { LeadService } from './service/lead.service';
+import { LeadRepository } from './repository/lead.repository';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { OrganizationData } from '../enterprise/entity/organization.entity';
+import { BrandData } from '../enterprise/entity/brand.entity';
+import { SchoolData } from '../enterprise/entity/school.entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([OrganizationData, BrandData, SchoolData]),
+  ],
+  providers: [LeadService, LeadRepository],
+  controllers: [LeadController],
+  exports: [],
+})
+export class LeadModule {}

package/src/module/lead/repository/lead.repository.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BrandData } from 'src/module/enterprise/entity/brand.entity';
+import { OrganizationData } from 'src/module/enterprise/entity/organization.entity';
+import { SchoolData } from 'src/module/enterprise/entity/school.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class LeadRepository {
+  constructor(
+    @InjectRepository(OrganizationData)
+    private organizationRepository: Repository<OrganizationData>,
+    @InjectRepository(BrandData)
+    private brandRepository: Repository<BrandData>,
+    @InjectRepository(SchoolData)
+    private schoolRepository: Repository<SchoolData>,
+  ) {}
+
+  async getAllOrganizations(): Promise<OrganizationData[]> {
+    return this.organizationRepository.find();
+  }
+
+  async getBrandsByOrganization(organization_id: number): Promise<BrandData[]> {
+    return this.brandRepository.find({
+      where: { organization_id },
+    });
+  }
+
+  async getSchoolsByBrandAndOrganization(
+    brand_id: number,
+    organization_id: number,
+  ): Promise<SchoolData[]> {
+    return this.schoolRepository.find({
+      where: { brand_id, organization_id },
+    });
+  }
+}

package/src/module/lead/service/lead.service.ts

@@ -0,0 +1,54 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { LeadRepository } from '../repository/lead.repository';
+
+@Injectable()
+export class LeadService {
+  constructor(private readonly leadRepository: LeadRepository) {}
+
+  async getAllOrganizations() {
+    const organizations = await this.leadRepository.getAllOrganizations();
+    return organizations.map((org) => ({
+      id: org.id,
+      name: org.name,
+      // Add other organization fields as needed
+    }));
+  }
+
+  async getBrandsByOrganization(organizationId: number) {
+    const brands =
+      await this.leadRepository.getBrandsByOrganization(organizationId);
+    if (!brands.length) {
+      throw new NotFoundException(
+        `No brands found for organization ID ${organizationId}`,
+      );
+    }
+    return brands.map((brand) => ({
+      id: brand.id,
+      name: brand.name,
+      organizationId: brand.organization_id,
+      // Add other brand fields as needed
+    }));
+  }
+
+  async getSchoolsByBrandAndOrganization(
+    brandId: number,
+    organizationId: number,
+  ) {
+    const schools = await this.leadRepository.getSchoolsByBrandAndOrganization(
+      brandId,
+      organizationId,
+    );
+    if (!schools.length) {
+      throw new NotFoundException(
+        `No schools found for brand ID ${brandId} and organization ID ${organizationId}`,
+      );
+    }
+    return schools.map((school) => ({
+      id: school.id,
+      name: school.name,
+      brandId: school.brand_id,
+      organizationId: school.organization_id,
+      // Add other school fields as needed
+    }));
+  }
+}

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

@@ -12,7 +12,6 @@ import { LoginService } from '../service/login.service';
 import { GoogleAuthGuard } from '../../../module/auth/guards/google-auth.guard';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import { Request, Response } from 'express';
-import { JwtAuthService } from 'src/module/auth/services/jwt.service';
 import { UserSessionService } from '../service/user-session.service';
 
 @Controller('auth')
@@ -24,8 +23,8 @@ export class LoginController {
 
   @Post('login')
   async login(@Body() body, @Res() res: Response) {
-    const { email_id, password, appcode } = body;
-    const result = await this.loginService.login(email_id, password, appcode);
+    const { email_id, password, appcode, organization_id } = body;
+    const result = await this.loginService.login(email_id, password);
     return res.status(HttpStatus.OK).json(result);
   }
 

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

@@ -41,4 +41,7 @@ export class UserData extends BaseEntity {
 
   @Column({ type: 'int', nullable: true })
   is_factory: number;
+
+  @Column({ type: 'varchar', nullable: true })
+  last_app_access: string;
 }

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

@@ -18,17 +18,17 @@ export class LoginService {
     private userSessionService: UserSessionService,
     private configService: ConfigService,
     @InjectRepository(UserRoleMapping)
-       private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
-          @InjectRepository(Role)
-           private readonly roleRepo: Repository<Role>,
+    private readonly userRoleMappingRepository: Repository<UserRoleMapping>,
+    @InjectRepository(Role)
+    private readonly roleRepo: Repository<Role>,
   ) {}
 
   masterKey: string = this.configService.get('MASTER_KEY') || '';
   masterIv: string = this.configService.get('MASTER_IV') || '';
 
-  async login(email: string, password: string, appcode: string) {
+  async login(email: string, password: string) {
     const user = await this.userService.findByEmailId(email);
-  
+
     if (!user) {
       return {
         success: false,
@@ -36,7 +36,7 @@ export class LoginService {
         type: 'email',
       };
     }
-  
+
     if (user.status !== 'ACTIVE') {
       return {
         success: false,
@@ -44,9 +44,13 @@ export class LoginService {
         type: 'email',
       };
     }
-  
-    const encryptedPassword = EncryptUtilService.encryptGCM(password, this.masterKey, this.masterIv);
-  
+
+    const encryptedPassword = EncryptUtilService.encryptGCM(
+      password,
+      this.masterKey,
+      this.masterIv,
+    );
+
     if (encryptedPassword !== user.password) {
       return {
         success: false,
@@ -54,50 +58,57 @@ export class LoginService {
         type: 'password',
       };
     }
-  
+
     // ✅ Get user-role mappings for this app
     const roleMappings = await this.userRoleMappingRepository.find({
       where: {
         user_id: user.id,
-        appcode: appcode,
       },
     });
-  
+
     if (!roleMappings.length) {
-      throw new BadRequestException('User does not have any access mapped for this app.');
+      throw new BadRequestException(
+        'User does not have any access mapped for this app.',
+      );
     }
-  
+
     // ✅ Pick default access based on priority
     const priority = { org: 1, sch: 2, brn: 3 };
     const defaultAccess = roleMappings.sort(
       (a, b) => priority[a.level_type] - priority[b.level_type],
     )[0];
-  
-    // ✅ Manually fetch role_code from cr_role table
-    const role = await this.roleRepo.findOne({
-      where: { id: defaultAccess.role_id },
-    });
-  
-    const token = await this.userSessionService.createSession(user, appcode, {
-      level_type: defaultAccess.level_type,
-      level_id: defaultAccess.level_id,
-      role_id: defaultAccess.role_id,
-      role_code: role?.code || null, // fallback if role not found
-    });
-  
+
+    //appcode
+
+    let appcode = user.last_app_access;
+
+    if (!appcode) {
+      appcode = 'ADM';
+      await this.userService.setDefaultLastAccess(user.id, appcode);
+    }
+
+    const token = await this.userSessionService.createSession(
+      user,
+      user.appcode,
+      {
+        level_type: defaultAccess.level_type,
+        level_id: defaultAccess.level_id,
+      },
+    );
+
     if (user.is_firstlogin === 1) {
       user.invitation_status = 'ACCEPTED';
       user.is_firstlogin = 0;
       const { password, ...userWithoutPassword } = user;
       await this.userService.updateEntity(userWithoutPassword, user);
     }
-  
+
     return {
       success: true,
       accessToken: token,
+      appcode,
     };
   }
-  
 
   async loginWithGoogle(email: string, name) {
     let user = await this.userService.findByEmailId(email);

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

@@ -38,8 +38,6 @@ export class UserSessionService {
       sessionToken,
       appcode,
       email_id: user.email_id,
-      level_type: user.level_type,
-      level_id: user.level_id,
       organization_id: user.organization_id,
       enterprise_id: user.enterprise_id,
     };
@@ -48,8 +46,6 @@ export class UserSessionService {
     if (accessInfo) {
       payload.level_type = accessInfo.level_type;
       payload.level_id = accessInfo.level_id;
-      payload.role_id = accessInfo.role_id;
-      payload.role_code = accessInfo.role_code;
     }
 
     const accessToken = this.jwtAuthService.generateJwt(payload);
@@ -98,6 +94,12 @@ export class UserSessionService {
       level_type: currentUserLevelType,
       appcode: data.appcode,
     };
+
+    await this.dataSource.query(
+      `UPDATE cr_user SET last_app_access = ? WHERE id = ?`,
+      [data.appcode, userId],
+    );
+
     // }
 
     // Step 2: Level switch logic

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

@@ -252,4 +252,16 @@ export class UserService extends EntityServiceImpl {
       appCode,
     );
   }
+
+  async setDefaultLastAccess(userId: number, appcode: string): Promise<void> {
+    const user = await this.userRepository.findById(userId);
+
+    if (!user) {
+      throw new BadRequestException('User not found');
+    }
+
+    user.last_app_access = appcode;
+
+    await this.userRepository.saveUser(user); // This persists the updated field
+  }
 }