rez_core 6.5.52 → 6.5.53

package/package.json

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

package/src/module/enterprise/service/enterprise.service.ts

@@ -1,6 +1,7 @@
 import { Injectable } from '@nestjs/common';
 import { EnterpriseRepository } from '../repository/enterprise.repository';
 import { EnterpriseData } from '../entity/enterprise.entity';
+import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
 export class EnterpriseService {
@@ -10,6 +11,7 @@ export class EnterpriseService {
     enterpriseData: EnterpriseData,
     loggedInUser: any,
   ): Promise<EnterpriseData> {
+    enterpriseData.status = StatusConstant.ACTIVE;
     return await this.enterpriseRepository.save(enterpriseData, loggedInUser);
   }
 

package/src/module/enterprise/service/organization.service.ts

@@ -1,11 +1,14 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { ClockIDGenService } from 'src/utils/service/clockIDGenUtil.service';
 import { EntityManager, IsNull, Repository } from 'typeorm';
 import { OrganizationData } from '../entity/organization.entity';
+import { ClockIDGenService } from 'src/utils/service/clockIDGenUtil.service';
+import { UserService } from 'src/module/user/service/user.service';
+import { ENTITYTYPE_USER } from 'src/constant/global.constant';
 // import { BrandRepository } from '../repository/brand.repository';
-import { WBSCodeGenService } from 'src/utils/service/wbsCodeGen.service';
 import { SchoolRepository } from '../repository/school.repository';
+import { WBSCodeGenService } from 'src/utils/service/wbsCodeGen.service';
+import { StatusConstant } from '../../../constant/status.constant';
 
 @Injectable()
 export class OrganizationService {
@@ -66,6 +69,7 @@ export class OrganizationService {
 
       const subOrgWbsCode = this.wbcCodeGenService.padCode(nextSubOrgCode);
       organizationDto.wbs_code = `${parentOrg.wbs_code}.${subOrgWbsCode}`;
+      organizationDto.parent_id = parentOrgId;
     } else {
       // Main org case: no parent_id
       const existingOrgs = await repo.find({
@@ -92,8 +96,10 @@ export class OrganizationService {
       organizationDto.wbs_code = this.wbcCodeGenService.padCode(nextOrgCode);
     }
 
-    organizationDto.code = this.idGen.idGenerator('ORG');
-    // organizationDto.status = 'ACTIVE';
+    if (!organizationDto.code) {
+      organizationDto.code = this.idGen.idGenerator('ORG');
+    }
+    organizationDto.status = StatusConstant.ACTIVE;
 
     if (loggedInUser) {
       organizationDto.modified_by = loggedInUser.id;

package/src/module/module/repository/module-access.repository.ts

@@ -165,7 +165,7 @@ export class ModuleAccessRepository {
 
   async getAllModulesByLevel(mainModIds: string[], appcode: string, levelType) {
     const appMasterRepo = this.reflectionHelper.getRepoService('AppMaster');
-
+// TODO Permissions not getting populated
     const appMaster = await appMasterRepo.find({
       where: {
         code: appcode,
@@ -209,14 +209,16 @@ export class ModuleAccessRepository {
 
     const modules = allModules.map((m) => m.id);
 
-    const allActions = await this.moduleActionRepo.find({
-      where: { module_id: In(modules) },
-    });
+    const allActions: any = await this.moduleActionRepo.createQueryBuilder('action')
+      .select(['action.id', 'action.action_name', 'module.module_code'])
+      .leftJoin('action.module', 'module')
+      .where('module.module_id IN (:...moduleIds)', { modules })
+      .getMany();
 
     // Map actions by module_code with VIEW action first
     const actionMap = allActions.reduce(
       (acc, action) => {
-        if (!acc[action.module_id]) acc[action.module_id] = [];
+        if (!acc[action.module_code]) acc[action.module_code] = [];
 
         const actionItem = {
           action: action.action_code,
@@ -224,9 +226,9 @@ export class ModuleAccessRepository {
         };
 
         if (action.action_code === 'VIEW') {
-          acc[action.module_id].unshift(actionItem); // ➕ Add VIEW at start
+          acc[action.module_code].unshift(actionItem); // ➕ Add VIEW at start
         } else {
-          acc[action.module_id].push(actionItem); // ➕ Add others at end
+          acc[action.module_code].push(actionItem); // ➕ Add others at end
         }
 
         return acc;

package/src/module/notification/notification.module.ts

@@ -16,10 +16,13 @@ import { NotificationData } from './entity/notification.entity';
 import { NotificationsController } from './controller/notification.controller';
 import { NotificationsService } from './service/notification.service';
 import { FirebaseAdminProvider } from './firebase-admin.config';
+import { PreferenceService } from '../preference_master/preference.service';
+import { PreferenceRepository } from '../meta/repository/preference.repository';
+import { PreferenceData } from '../preference_master/entity/preference.entity';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([Otp, NotificationData]),
+    TypeOrmModule.forFeature([Otp, NotificationData, PreferenceData]),
     MailerModule.forRootAsync({
       imports: [ConfigModule],
       inject: [ConfigService],
@@ -54,7 +57,7 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
     OtpRepository,
     EmailService,
     NotificationsService,
-    FirebaseAdminProvider,
+    FirebaseAdminProvider
   ],
   exports: [
     OtpService,
@@ -64,4 +67,4 @@ import { FirebaseAdminProvider } from './firebase-admin.config';
   ],
   controllers: [OtpController, NotificationsController],
 })
-export class NotificationModule {}
+export class NotificationModule { }

package/src/module/notification/service/email.service.ts

@@ -10,7 +10,7 @@ export class EmailService {
     private readonly mailerService: MailerService,
     private readonly datasource: DataSource,
     private readonly icsService: IcsMeetingService,
-  ) {}
+  ) { }
 
   async sendEmail(
     email: string,
@@ -124,4 +124,19 @@ export class EmailService {
 
     return { success: true, message: 'Email sent successfully' };
   }
+
+  async sendEmailWithoutTemplate(to: string, subject: string, body: string) {
+    try {
+      await this.mailerService.sendMail({
+        to,
+        subject,
+        html: body,
+      });
+      console.log(`Email sent successfully to ${to} via NodeMailer.`);
+    } catch (error) {
+      console.error(`Failed to send email to ${to} via NodeMailer:`, error);
+      throw error; // Re-throw to allow calling context to handle
+    }
+  }
+
 }

package/src/module/notification/service/otp.service.ts

@@ -6,6 +6,7 @@ import { Otp } from '../entity/otp.entity';
 import { OtpRepository } from '../repository/otp.repository';
 import { LoginService } from './../../user/service/login.service';
 import { EmailService } from './email.service';
+import { PreferenceService } from 'src/module/preference_master/preference.service';
 
 @Injectable()
 export class OtpService {
@@ -14,8 +15,9 @@ export class OtpService {
     private readonly idGen: ClockIDGenService,
     private configService: ConfigService,
     private readonly loginService: LoginService,
-    private readonly emailService: EmailService,
     private readonly dataSource: DataSource,
+    // private readonly preferenceService: PreferenceService,
+    private readonly emailService: EmailService,
   ) {
   }
 
@@ -40,7 +42,7 @@ export class OtpService {
     otp.verified = 0;
     otp.expiration_date = new Date(Date.now() + expiresIn * 60 * 1000);
 
-    const userData = await this.dataSource
+    const userData: any = await this.dataSource
       .getRepository('sso_user')
       .findOne({ where: { email_id: identifier } });
 
@@ -49,7 +51,15 @@ export class OtpService {
       otp: otp.otp,
     };
 
-    // await this.emailService.sendEmail(identifier, 'OTP Verification', data);
+    // TODO: Inject and use PreferenceService here
+    // const preference = await this.preferenceService.fetchPreferenceByType('OTP', true);
+
+    // if (preference) {
+    //   let otpBody = preference.filter((item) => item.key === 'OTP_BODY')[0].value;
+    //   otpBody = otpBody.replace('${otp}', otp.otp);
+    //   const otpSubject = preference.filter((item) => item.key === 'OTP_SUBJECT')[0].value;
+    //   this.emailService.sendEmailWithoutTemplate(userData.email_id, otpSubject, otpBody);
+    // }
 
     return await this.otpRepository.save(otp);
   }

package/src/module/preference_master/entity/preference.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
+
+@Entity('sso_preference_master')
+export class PreferenceData {
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column({ name: 'enterprise_id', type: 'int' })
+    enterpriseId: number;
+
+    @Column({ name: 'preference_type', type: 'varchar', length: 15 })
+    preferenceType: string;
+
+    @Column({ type: 'varchar', length: 255 })
+    key: string;
+
+    @Column({ type: 'text' })
+    value: string;
+
+    @CreateDateColumn({ name: 'created_date', type: 'timestamp' })
+    createdDate: Date;
+
+    @Column({ type: 'boolean', default: true })
+    status: boolean;
+}

package/src/module/preference_master/preference.service.ts

@@ -0,0 +1,27 @@
+// src/module/preference_master/preference.service.ts
+import { Injectable } from '@nestjs/common';
+import { PreferenceData } from './entity/preference.entity';
+import { PreferenceRepository } from './repo/preference.repository';
+
+@Injectable()
+export class PreferenceService {
+    constructor(
+        private readonly preferenceRepository: PreferenceRepository
+    ) { }
+
+    async fetchPreference(
+        entID: number,
+        key: string,
+        status: boolean,
+    ): Promise<PreferenceData | null> {
+        return await this.preferenceRepository.findByEntIdAndKeyAndStatus(
+            entID,
+            key,
+            status,
+        );
+    }
+
+    async fetchPreferenceByType(preferenceType: string, status: boolean) {
+        return await this.preferenceRepository.findByPreferenceType(preferenceType, status);
+    }
+}

package/src/module/preference_master/repo/preference.repository.ts

@@ -0,0 +1,36 @@
+// src/module/preference_master/preference.repository.ts
+import { Injectable } from '@nestjs/common';
+import { Repository } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { PreferenceData } from '../entity/preference.entity';
+
+@Injectable()
+export class PreferenceRepository {
+    constructor(
+        @InjectRepository(PreferenceData)
+        private preferenceRepository: Repository<PreferenceData>,
+    ) { }
+
+    async findByEntIdAndKeyAndStatus(
+        entID: number,
+        key: string,
+        status: boolean,
+    ): Promise<PreferenceData | null> {
+        return this.preferenceRepository.findOne({
+            where: {
+                enterpriseId: entID,
+                key,
+                status,
+            },
+        });
+    }
+
+    async findByPreferenceType(preferenceType: string, status: boolean) {
+        return this.preferenceRepository.find({
+            where: {
+                preferenceType,
+                status,
+            },
+        });
+    }
+}