rez_core 6.5.28 → 6.5.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "6.5.28",
+  "version": "6.5.30",
   "description": "",
   "author": "",
   "private": false,
@@ -122,4 +122,4 @@
     "coverageDirectory": "../coverage",
     "testEnvironment": "node"
   }
-}
+}

package/src/app.module.ts

@@ -4,7 +4,7 @@ import { EnterpriseModule } from './module/enterprise/enterprise.module';
 import { UtilsModule } from './utils/utils.module';
 import { UserModule } from './module/user/user.module';
 import { EntityModule } from './module/meta/entity.module';
-import { ModuleAccessModule } from './module/module/module.module';
+import { ModuleModule } from './module/module/module.module';
 import { NotificationModule } from './module/notification/notification.module';
 import Properties from './resources/properties.module';
 import { LayoutModule } from './module/layout/layout.module';
@@ -31,11 +31,12 @@ import { ExportModule } from './module/export/export.module';
 
 @Module({
   imports: [
+    EntityModule,
     DatabaseModule,
     EnterpriseModule,
     UtilsModule,
     UserModule,
-    ModuleAccessModule,
+    ModuleModule,
     NotificationModule,
     Properties,
     LayoutModule,
@@ -61,8 +62,7 @@ import { ExportModule } from './module/export/export.module';
     MicroserviceClientsModule,
     LinkedAttributesModule,
     EntityJSONModule,
-    ExportModule,
-    EntityModule,
+    ExportModule
   ],
 })
-export class AppModule { }
+export class AppModule {}

package/src/core.module.ts

@@ -5,7 +5,7 @@ import { EnterpriseModule } from './module/enterprise/enterprise.module';
 import { UtilsModule } from './utils/utils.module';
 import { UserModule } from './module/user/user.module';
 import { EntityModule } from './module/meta/entity.module';
-import { ModuleAccessModule } from './module/module/module.module';
+import { ModuleModule } from './module/module/module.module';
 import { NotificationModule } from './module/notification/notification.module';
 import { LayoutModule } from './module/layout/layout.module';
 import { ListMasterModule } from './module/listmaster/listmaster.module';
@@ -32,68 +32,57 @@ export class CoreModule {
       throw new Error('Database module must be provided.');
     }
 
-    let importsArray: any = [];
-    let exportsArray: any = [];
+    const importsArray = [
+      ConfigModule.forRoot({ isGlobal: true }),
+      dbModule,
+      EntityModule,
+      UtilsModule,
+      NotificationModule,
+      ListMasterModule,
+      FilterModule,
+      AuthModule,
+      LeadModule,
+      LayoutPreferenceModule,
+      WorkflowModule,
+      WorkflowAutomationModule,
+      WorkflowScheduleModule.forRoot({ is_workflow: isWorkflow }),
+      MapperModule,
+      LinkedAttributesModule,
+      ExportModule
+    ];
+
+    const exportsArray = [
+      ConfigModule,
+      dbModule,
+      EntityModule,
+      AuthModule,
+      UtilsModule,
+      NotificationModule,
+      ListMasterModule,
+      FilterModule,
+      LeadModule,
+      LayoutPreferenceModule,
+      MapperModule,
+      WorkflowModule,
+      WorkflowAutomationModule,
+      WorkflowScheduleModule.forRoot({ is_workflow: isWorkflow }),
+      LinkedAttributesModule,
+      ExportModule
+    ];
 
     if (isSso) {
-      importsArray = [
-        ConfigModule.forRoot({ isGlobal: true }),
-        dbModule,
+      importsArray.push(
         UserModule,
-        ModuleAccessModule,
+        ModuleModule,
         LayoutModule,
         EnterpriseModule,
-        UtilsModule,
-        AuthModule,
-        NotificationModule
-      ];
-      exportsArray = [
-        ConfigModule,
+      );
+      exportsArray.push(
         UserModule,
-        ModuleAccessModule,
+        ModuleModule,
         LayoutModule,
         EnterpriseModule,
-        UtilsModule,
-        AuthModule,
-        NotificationModule
-      ];
-    } else {
-      importsArray = [
-        ConfigModule.forRoot({ isGlobal: true }),
-        dbModule,
-        EntityModule,
-        UtilsModule,
-        NotificationModule,
-        ListMasterModule,
-        FilterModule,
-        AuthModule,
-        LeadModule,
-        LayoutPreferenceModule,
-        WorkflowModule,
-        WorkflowAutomationModule,
-        WorkflowScheduleModule.forRoot({ is_workflow: isWorkflow }),
-        MapperModule,
-        LinkedAttributesModule,
-        ExportModule
-      ];
-
-      exportsArray = [
-        ConfigModule,
-        EntityModule,
-        AuthModule,
-        UtilsModule,
-        NotificationModule,
-        ListMasterModule,
-        FilterModule,
-        LeadModule,
-        LayoutPreferenceModule,
-        MapperModule,
-        WorkflowModule,
-        WorkflowAutomationModule,
-        WorkflowScheduleModule.forRoot({ is_workflow: isWorkflow }),
-        LinkedAttributesModule,
-        ExportModule
-      ];
+      );
     }
 
     return {

package/src/migrations/1732612800000-AddEntityJsonGinIndex.ts

@@ -0,0 +1,41 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddEntityJsonGinIndex1732612800000 implements MigrationInterface {
+  name = 'AddEntityJsonGinIndex1732612800000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // GIN index for JSONB operations (containment, existence checks)
+    // Using jsonb_path_ops for better performance on containment queries
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_entity_json_data_gin
+      ON frm_entity_json
+      USING GIN (json_data jsonb_path_ops);
+    `);
+
+    // Standard B-tree index for entity_type lookups
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_entity_json_entity_type
+      ON frm_entity_json (entity_type);
+    `);
+
+    // Composite index for entity_type + entity_id lookups
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_entity_json_composite
+      ON frm_entity_json (entity_type, entity_id);
+    `);
+
+    console.log('✅ GIN indexes created successfully');
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS idx_entity_json_data_gin;`);
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS idx_entity_json_entity_type;`,
+    );
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS idx_entity_json_composite;`,
+    );
+
+    console.log('✅ GIN indexes dropped successfully');
+  }
+}

package/src/module/auth/strategies/jwt.strategy.ts

@@ -21,13 +21,12 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
     const {
       id,
       sessionToken,
-      app_id,
+      appcode,
       email_id,
       organization_id,
       enterprise_id,
       level_id,
       level_type,
-      appcode
     } = payload;
 
     // Check if session exists and is valid
@@ -46,13 +45,12 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
     const userData = {
       id: id,
       sessionToken: sessionToken,
-      app_id: app_id,
+      appcode: appcode,
       email_id: email_id,
       organization_id: organization_id,
       enterprise_id: enterprise_id,
       level_id: level_id,
       level_type: level_type,
-      appcode: appcode
     };
 
     return { userData };

package/src/module/dashboard/dashboard.module.ts

@@ -6,16 +6,16 @@ import { DashboardPageData } from './entity/dashboard_page_data.entity';
 import { DashboardController } from './controller/dashboard.controller';
 import { DashboardService } from './service/dashboard.service';
 import { DashboardRepository } from './repository/dashboard.repository';
-import { ModuleAccessModule } from '../module/module.module';
+import { ModuleModule } from '../module/module.module';
 
 @Module({
   imports: [
     EntityModule,
     TypeOrmModule.forFeature([WidgetMaster, DashboardPageData]),
-    ModuleAccessModule,
+    ModuleModule,
   ],
   controllers: [DashboardController],
   providers: [DashboardService, DashboardRepository],
   exports: [DashboardService],
 })
-export class DashboardModule { }
+export class DashboardModule {}

package/src/module/dashboard/service/dashboard.service.ts

@@ -17,9 +17,10 @@ export class DashboardService {
 
     const access = await this.moduleAccessService.getUserPermissions({
       userId: loggedInUser.id,
-      app_id: loggedInUser.app_id,
+      appcode: loggedInUser.appcode,
       level_type: loggedInUser.level_type,
-      level_id: loggedInUser.level_id
+      level_id: loggedInUser.level_id,
+      enterprise_id: loggedInUser.enterprise_id,
     });
 
     // Build a set of accessible codes

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

@@ -1,43 +1,18 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Put,
-  Delete,
-  Body,
-  Param,
-  Inject,
-  Req,
-  UseGuards,
-  HttpCode,
-  HttpStatus,
-  ParseIntPipe,
-} from '@nestjs/common';
+import { Controller, Get, Inject, Req, UseGuards } from '@nestjs/common';
 import { Request } from 'express';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { UserService } from 'src/module/user/service/user.service';
 import { OrganizationService } from '../service/organization.service';
-import { OrganizationData } from '../entity/organization.entity';
 
 @Controller('organization')
-@UseGuards(JwtAuthGuard)
 export class OrganizationController {
   constructor(
     private readonly orgService: OrganizationService,
+    @Inject('UserService') private readonly userService: UserService,
   ) {}
 
-  @Post('create')
-  @HttpCode(HttpStatus.OK)
-  async create(
-    @Body() organizationDto: Partial<OrganizationData>,
-    @Req() req: Request & { user: any },
-  ): Promise<OrganizationData> {
-    const loggedInUser = req.user.userData;
-    return await this.orgService.create(organizationDto, loggedInUser);
-  }
-
+  @UseGuards(JwtAuthGuard)
   @Get('dropdown')
-  @HttpCode(HttpStatus.OK)
   async getOrganizationDropdown(@Req() req: Request & { user: any }) {
     const userData = req.user.userData;
     // const userData = await this.userService.getEntityData(ENTITYTYPE_USER, userId);
@@ -45,8 +20,8 @@ export class OrganizationController {
     return this.orgService.findById(userData?.organization_id);
   }
 
+  @UseGuards(JwtAuthGuard)
   @Get('hierarchy')
-  @HttpCode(HttpStatus.OK)
   async getOrganizationHierarchy(@Req() req: Request & { user: any }) {
     const userId = req.user.userData?.id;
     const appcode = req.user.userData?.appcode;
@@ -58,35 +33,4 @@ export class OrganizationController {
       org_id,
     );
   }
-
-  @Get()
-  @HttpCode(HttpStatus.OK)
-  async findAll(): Promise<OrganizationData[]> {
-    return await this.orgService.findAll();
-  }
-
-  @Get(':id')
-  @HttpCode(HttpStatus.OK)
-  async findOne(
-    @Param('id', ParseIntPipe) id: number,
-  ): Promise<OrganizationData | null> {
-    return await this.orgService.findOne(id);
-  }
-
-  @Post('update/:id')
-  @HttpCode(HttpStatus.OK)
-  async update(
-    @Param('id', ParseIntPipe) id: number,
-    @Body() organizationDto: Partial<OrganizationData>,
-    @Req() req: Request & { user: any },
-  ): Promise<OrganizationData | null> {
-    const loggedInUser = req.user.userData;
-    return await this.orgService.update(id, organizationDto, loggedInUser);
-  }
-
-  @Delete(':id')
-  @HttpCode(HttpStatus.OK)
-  async remove(@Param('id', ParseIntPipe) id: number): Promise<void> {
-    return await this.orgService.remove(id);
-  }
 }

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

@@ -1,33 +1,33 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { OrganizationService } from './service/organization.service';
-import { OrganizationData } from './entity/organization.entity';
+import { UserModule } from '../user/user.module';
 import { OrganizationController } from './controller/organization.controller';
-import { OrganizationAppMappingService } from './service/organization-app-mapping.service';
 import { OrganizationAppMapping } from './entity/organization-app-mapping.entity';
-// import { BrandData } from './entity/brand.entity';
-// import { SchoolData } from './entity/school.entity';
-// import { BrandRepository } from './repository/brand.repository';
+import { OrganizationData } from './entity/organization.entity';
+import { OrganizationAppMappingService } from './service/organization-app-mapping.service';
+import { OrganizationService } from './service/organization.service';
 import { UtilsModule } from 'src/utils/utils.module';
+import { EntityModule } from '../meta/entity.module';
 import { OrganizationRepository } from './repository/organization.repository';
 import { SchoolRepository } from './repository/school.repository';
+import { WorkflowAutomationModule } from '../workflow-automation/workflow-automation.module';
 import { EnterpriseService } from './service/enterprise.service';
+import { BrandService } from './service/brand.service';
 import { EnterpriseRepository } from './repository/enterprise.repository';
 import { EnterpriseData } from './entity/enterprise.entity';
-import { EnterpriseController } from './controller/enterprise.controller';
-import { PopulateMetaService } from './service/populate-meta.service';
-import { MetaController } from './controller/meta.controller';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       OrganizationData,
       OrganizationAppMapping,
-      EnterpriseData,
+      EnterpriseData
     ]),
+    forwardRef(() => UserModule),
     UtilsModule,
+    EntityModule,
   ],
-  controllers: [OrganizationController, EnterpriseController, MetaController],
+  controllers: [OrganizationController],
   providers: [
     OrganizationService,
     OrganizationAppMappingService,
@@ -35,9 +35,11 @@ import { MetaController } from './controller/meta.controller';
     OrganizationRepository,
     EnterpriseService,
     EnterpriseRepository,
-    PopulateMetaService
+    {
+      provide: 'BrandService',
+      useClass: BrandService,
+    },
   ],
-  exports: [OrganizationService, OrganizationRepository, EnterpriseService, EnterpriseRepository, PopulateMetaService],
+  exports: [OrganizationService, OrganizationRepository,EnterpriseService],
 })
-export class EnterpriseModule {
-}
+export class EnterpriseModule {}

package/src/module/enterprise/entity/enterprise.entity.ts

@@ -1,10 +1,13 @@
-import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'sso_enterprise' })
 export class EnterpriseData {
   @PrimaryGeneratedColumn({ name: 'id', type: 'bigint' })
   id: number;
 
+  @Column({ name: 'entity_type', type: 'varchar', nullable: true, length: 50 })
+  entity_type: string;
+
   @Column({ name: 'code', type: 'varchar', nullable: true, length: 50 })
   code: string;
 
@@ -20,12 +23,15 @@ export class EnterpriseData {
   @Column({ name: 'modified_by', type: 'int', nullable: true })
   modified_by: number;
 
-  @CreateDateColumn({ name: 'created_date', nullable: true })
+  @Column({ name: 'created_date', nullable: true })
   created_date: Date;
 
-  @UpdateDateColumn({ name: 'modified_date', nullable: true })
+  @Column({ name: 'modified_date', nullable: true })
   modified_date: Date;
 
-  @Column({ name: 'slug', type: 'varchar', nullable: true, length: 50 })
-  slug: string;
+  @Column({ name: 'appcode', type: 'varchar', nullable: true, length: 50 })
+  appcode: string;
+
+  @Column({ name: 'app_url_name', type: 'varchar', nullable: true, length: 50 })
+  app_url_name: string;
 }

package/src/module/enterprise/entity/organization-app-mapping.entity.ts

@@ -1,27 +1,13 @@
-import { Column, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, Unique } from 'typeorm';
-import { OrganizationData } from './organization.entity';
-import { AppMaster } from '../../meta/entity/app-master.entity';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'sso_organization_app_mapping' })
-@Unique(['organization', 'app'])
 export class OrganizationAppMapping {
   @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
   id: number;
 
-  @Column({ type: 'int', nullable: true })
-  organization_id: number;
+  @Column({ name: 'organization_id', nullable: true })
+  organization_id: string;
 
-  @ManyToOne(() => OrganizationData, { nullable: true, onDelete: 'SET NULL' })
-  @JoinColumn({ name: 'organization_id', referencedColumnName: 'id' })
-  organization: OrganizationData;
-
-  @Column({ type: 'int', nullable: true })
-  app_id: number;
-
-  @ManyToOne(() => AppMaster, { nullable: true, onDelete: 'SET NULL' })
-  @JoinColumn({ name: 'app_id', referencedColumnName: 'id' })
-  app: AppMaster;
-
-  @Column({type: 'varchar', nullable: true})
+  @Column({ name: 'appcode', nullable: true })
   appcode: string;
 }

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

@@ -1,26 +1,27 @@
-import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
-import { EnterpriseData } from './enterprise.entity';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity({ name: 'sso_organization' })
 export class OrganizationData {
   @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
   id: number;
 
-  @ManyToOne(() => EnterpriseData, {nullable: true, onDelete: 'SET NULL'})
-  @JoinColumn({ name: 'enterprise_id', referencedColumnName: 'id' })
-  enterprise_id: EnterpriseData;
+  @Column({ name: 'enterprise_id', type: 'int' })
+  enterprise_id: number;
 
   @Column({ name: 'code', nullable: true })
   code: string;
 
+  @Column({ name: 'appcode', nullable: true })
+  appcode: string;
+
   @Column({ name: 'name', nullable: true })
   name: string;
 
   @Column({ name: 'status', type: 'varchar', nullable: true })
   status: string;
 
-  @Column({ name: 'parent_id', nullable: true })
-  parent_id: number;
+  @Column({ name: 'seq_no', nullable: true })
+  seq_no: number;
 
   @Column({ name: 'created_by', nullable: true })
   created_by: number;
@@ -28,12 +29,61 @@ export class OrganizationData {
   @Column({ name: 'modified_by', nullable: true })
   modified_by: number;
 
-  @CreateDateColumn({ name: 'created_date', nullable: true })
+  @Column({ name: 'created_date', nullable: true })
   created_date: Date;
 
-  @UpdateDateColumn({ name: 'modified_date', nullable: true })
+  @Column({ name: 'parent_id', nullable: true })
+  parent_id: number;
+
+  @Column({ name: 'modified_date', nullable: true })
   modified_date: Date;
 
+  @Column({ name: 'contact_number', nullable: true })
+  contact_number: string;
+
+  @Column({ name: 'email', nullable: true })
+  emailId: string;
+
+  @Column({ name: 'entity_type', nullable: true })
+  entity_type: string;
+
+  @Column({ name: 'primary_contact_name', nullable: true })
+  primary_contact_name: string;
+
+  @Column({ name: 'address', nullable: true })
+  address: string;
+
+  @Column({ name: 'gstin', nullable: true })
+  gstin: string;
+
+  @Column({ name: 'company_pan_number', nullable: true })
+  company_pan_number: string;
+
+  @Column({ name: 'bankacc_benef_name', nullable: true })
+  bankacc_benef_name: string;
+
+  @Column({ name: 'bankacc_bank_name', nullable: true })
+  bankacc_bank_name: string;
+
+  @Column({ name: 'bankacc_account_number', nullable: true })
+  bankaccAccountNumber: string;
+
+  @Column({ name: 'bankacc_branch_ifsc', nullable: true })
+  bankacc_account_number: string;
+
+  @Column({
+    name: 'organization_type',
+    type: 'varchar',
+    nullable: true,
+  })
+  organization_type: string;
+
+  @Column({ name: 'is_brand', type: 'boolean', nullable: true })
+  is_brand: boolean;
+
+  @Column({ name: 'type', nullable: true })
+  type: string;
+
   @Column({ name: 'wbs_code', nullable: true })
   wbs_code: string;
 

package/src/module/enterprise/repository/enterprise.repository.ts

@@ -10,44 +10,22 @@ export class EnterpriseRepository {
     private readonly enterpriseRepository: Repository<EnterpriseData>,
   ) {}
 
-  async save(enterpriseData: EnterpriseData, loggedInUser: any) {
-    if (loggedInUser) {
-      enterpriseData.created_by = loggedInUser.id;
-      enterpriseData.modified_by = loggedInUser.id;
-    }
+  async save(enterpriseData: EnterpriseData) {
+    enterpriseData.created_date = new Date();
     return await this.enterpriseRepository.save(enterpriseData);
   }
 
-  async update(
-    enterpriseData: EnterpriseData,
-    loggedInUser: any,
-  ): Promise<EnterpriseData | null> {
+  async update(enterpriseData: EnterpriseData): Promise<EnterpriseData | null> {
     const existingEnterprise = await this.enterpriseRepository.findOne({
       where: { id: enterpriseData.id },
     });
     if (!existingEnterprise) {
       throw new Error(`Enterprise with id ${enterpriseData.id} not found`);
     }
-    if (loggedInUser) {
-      enterpriseData.modified_by = loggedInUser.id;
-    }
+    enterpriseData.modified_date = new Date();
     await this.enterpriseRepository.update(enterpriseData.id, enterpriseData);
     return await this.enterpriseRepository.findOne({
       where: { id: enterpriseData.id },
     });
   }
-
-  async findEnterpriseBySubdomain(
-    slug: string,
-  ): Promise<EnterpriseData | null> {
-    return await this.enterpriseRepository.findOne({
-      where: { slug },
-    });
-  }
-
-  async findById(id: number) {
-    return await this.enterpriseRepository.findOne({
-      where: { id },
-    });
-  }
 }