rez_core 6.5.61 → 6.5.63

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

@@ -1,27 +1,29 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { EnterpriseData } from './enterprise.entity';
 
 @Entity({ name: 'sso_organization' })
 export class OrganizationData {
   @PrimaryGeneratedColumn({ name: 'id', type: 'int' })
   id: number;
 
-  @Column({ name: 'enterprise_id', type: 'int' })
+  @Column({type: 'int', nullable: true})
   enterprise_id: number;
 
+  @ManyToOne(() => EnterpriseData, {nullable: true, onDelete: 'SET NULL'})
+  @JoinColumn({ name: 'enterprise_id', referencedColumnName: 'id' })
+  enterprise: EnterpriseData;
+
   @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: 'seq_no', nullable: true })
-  seq_no: number;
+  @Column({ name: 'parent_id', nullable: true })
+  parent_id: number;
 
   @Column({ name: 'created_by', nullable: true })
   created_by: number;
@@ -29,61 +31,12 @@ export class OrganizationData {
   @Column({ name: 'modified_by', nullable: true })
   modified_by: number;
 
-  @Column({ name: 'created_date', nullable: true })
+  @CreateDateColumn({ name: 'created_date', nullable: true })
   created_date: Date;
 
-  @Column({ name: 'parent_id', nullable: true })
-  parent_id: number;
-
-  @Column({ name: 'modified_date', nullable: true })
+  @UpdateDateColumn({ 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,22 +10,44 @@ export class EnterpriseRepository {
     private readonly enterpriseRepository: Repository<EnterpriseData>,
   ) {}
 
-  async save(enterpriseData: EnterpriseData) {
-    enterpriseData.created_date = new Date();
+  async save(enterpriseData: EnterpriseData, loggedInUser: any) {
+    if (loggedInUser) {
+      enterpriseData.created_by = loggedInUser.id;
+      enterpriseData.modified_by = loggedInUser.id;
+    }
     return await this.enterpriseRepository.save(enterpriseData);
   }
 
-  async update(enterpriseData: EnterpriseData): Promise<EnterpriseData | null> {
+  async update(
+    enterpriseData: EnterpriseData,
+    loggedInUser: any,
+  ): 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`);
     }
-    enterpriseData.modified_date = new Date();
+    if (loggedInUser) {
+      enterpriseData.modified_by = loggedInUser.id;
+    }
     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 },
+    });
+  }
 }

package/src/module/enterprise/service/brand-profile.service.ts

@@ -0,0 +1,10 @@
+// import { Inject, Injectable } from '@nestjs/common';
+// import { firstValueFrom } from 'rxjs';
+// import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+//
+// @Injectable()
+// export class BrandProfileService extends EntityServiceImpl {
+//   constructor() {
+//     super();
+//   }
+// }

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

@@ -1,5 +1,75 @@
-import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-
-@Injectable()
-export class BrandService extends EntityServiceImpl {}
+// import { Injectable } from '@nestjs/common';
+// import { InjectRepository } from '@nestjs/typeorm';
+//
+// @Injectable()
+// export class BrandService {
+//   constructor(
+//     @InjectRepository(Brand)
+//   ) {
+//
+//   }
+//
+//   async getEntityData(
+//     entityType: string,
+//     id: number,
+//     loggedInUser,
+//   ): Promise<any> {
+//     const brandResponse = await super.getEntityData(
+//       entityType,
+//       id,
+//       loggedInUser,
+//     );
+//
+//     return brandResponse;
+//   }
+//
+//   async createEntity(body: any, userData): Promise<any> {
+//     const { entity_type, ...data } = body;
+//
+//     const brandData = await super.createEntity(
+//       {
+//         ...data,
+//
+//         entity_type: 'ORG',
+//         type: 'BRN',
+//         parent_id: userData.organization_id,
+//       },
+//       userData,
+//     );
+//
+//     // save brand profile
+//
+//     const brandProfile = await super.createEntity(
+//       {
+//         ...body,
+//         parent_id: brandData.id,
+//         organization_id: brandData.organization_id,
+//         entity_type: 'BRNP',
+//       },
+//       userData,
+//     );
+//
+//     return brandProfile;
+//   }
+//
+//   async updateEntity(body: any, userData): Promise<any> {
+//     // update brand table
+//     const { id, entity_type, organization_id, ...newBody } = body;
+//
+//     const brandProfile = await super.updateEntity(body, userData);
+//
+//     // update brand
+//     await super.updateEntity(
+//       {
+//         ...newBody,
+//         id: brandProfile.parent_id,
+//         parent_id: userData.organization_id,
+//         entity_type: 'ORG',
+//         type: 'BRN',
+//       },
+//       userData,
+//     );
+//
+//     return brandProfile;
+//   }
+// }

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

@@ -1,16 +1,24 @@
 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 {
   constructor(private readonly enterpriseRepository: EnterpriseRepository) {}
 
-  async create(enterpriseData: EnterpriseData): Promise<EnterpriseData> {
-    return await this.enterpriseRepository.save(enterpriseData);
+  async create(
+    enterpriseData: EnterpriseData,
+    loggedInUser: any,
+  ): Promise<EnterpriseData> {
+    enterpriseData.status = StatusConstant.ACTIVE;
+    return await this.enterpriseRepository.save(enterpriseData, loggedInUser);
   }
 
-  async update(enterpriseData: EnterpriseData): Promise<EnterpriseData | null> {
-    return await this.enterpriseRepository.update(enterpriseData);
+  async update(
+    enterpriseData: EnterpriseData,
+    loggedInUser: any,
+  ): Promise<EnterpriseData | null> {
+    return await this.enterpriseRepository.update(enterpriseData, loggedInUser);
   }
 }

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

@@ -1,40 +1,38 @@
-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 {
   constructor(
     @InjectRepository(OrganizationData)
     private readonly organizationRepository: Repository<OrganizationData>,
+    private readonly schoolRepository: SchoolRepository,
     private readonly idGen: ClockIDGenService,
     private readonly wbcCodeGenService: WBSCodeGenService,
-    private readonly schoolRepository: SchoolRepository,
   ) {}
 
   async create(
     organizationDto: Partial<OrganizationData>,
+    loggedInUser?: any,
     manager?: EntityManager,
   ): Promise<OrganizationData> {
     const repo = manager
       ? manager.getRepository(OrganizationData)
       : this.organizationRepository;
 
-    const isBrand = organizationDto.type === 'BRN';
-
-    if (isBrand) {
-      // BRN case
-      const parentOrgId = organizationDto.parent_id;
-
-      if (!parentOrgId) {
-        throw new Error('Parent Org ID is required to create a brand.');
-      }
+    const parentOrgId = organizationDto.parent_id;
 
+    if (parentOrgId) {
+      // Sub-org case: parent_id is present
       const parentOrg = await repo.findOne({
         where: { id: parentOrgId },
       });
@@ -43,45 +41,70 @@ export class OrganizationService {
         throw new Error('Parent organization not found.');
       }
 
-      const existingBrands = await repo.find({
+      if (!parentOrg.wbs_code) {
+        throw new Error('Parent organization must have a WBS code.');
+      }
+
+      // Find existing sub-orgs with the same parent_id
+      const existingSubOrgs = await repo.find({
         where: {
-          type: 'BRN',
           parent_id: parentOrgId,
         },
         select: ['wbs_code'],
       });
 
-      const brandCodes = existingBrands
-        .map((b) => b.wbs_code?.split('.')[1])
+      // Extract the last part of WBS codes (after the dot)
+      const subOrgCodes = existingSubOrgs
+        .map((subOrg) => {
+          const parts = subOrg.wbs_code?.split('.');
+          return parts && parts.length > 1 ? parts[parts.length - 1] : null;
+        })
         .filter(Boolean)
         .map(Number);
 
-      const nextBrnCode = brandCodes.length ? Math.max(...brandCodes) + 1 : 1;
+      // Generate next sequential code
+      const nextSubOrgCode = subOrgCodes.length
+        ? Math.max(...subOrgCodes) + 1
+        : 1;
 
-      const brnWbsCode = this.wbcCodeGenService.padCode(nextBrnCode);
-      organizationDto.wbs_code = `${parentOrg.wbs_code}.${brnWbsCode}`;
+      const subOrgWbsCode = this.wbcCodeGenService.padCode(nextSubOrgCode);
+      organizationDto.wbs_code = `${parentOrg.wbs_code}.${subOrgWbsCode}`;
+      organizationDto.parent_id = parentOrgId;
     } else {
-      // ORG case
+      // Main org case: no parent_id
       const existingOrgs = await repo.find({
         where: {
-          type: IsNull(),
+          parent_id: IsNull(),
         },
         select: ['wbs_code'],
       });
 
+      // Extract WBS codes (should be simple numbers like 00001, 00002)
       const orgCodes = existingOrgs
-        .map((org) => org.wbs_code)
-        .filter(Boolean)
-        .map(Number);
+        .map((org) => {
+          // If WBS code contains a dot, it's not a main org, skip it
+          if (org.wbs_code?.includes('.')) {
+            return null;
+          }
+          return org.wbs_code ? Number(org.wbs_code) : null;
+        })
+        .filter((code): code is number => code !== null);
 
+      // Generate next sequential code
       const nextOrgCode = orgCodes.length ? Math.max(...orgCodes) + 1 : 1;
 
       organizationDto.wbs_code = this.wbcCodeGenService.padCode(nextOrgCode);
     }
 
-    organizationDto.code = this.idGen.idGenerator('ORG');
-    // organizationDto.status = 'ACTIVE';
-    organizationDto.created_date = new Date();
+    if (!organizationDto.code) {
+      organizationDto.code = this.idGen.idGenerator('ORG');
+    }
+    organizationDto.status = StatusConstant.ACTIVE;
+
+    if (loggedInUser) {
+      organizationDto.modified_by = loggedInUser.id;
+      organizationDto.created_by = loggedInUser.id;
+    }
 
     const organization = repo.create(organizationDto);
     return await repo.save(organization);
@@ -113,12 +136,112 @@ export class OrganizationService {
   async update(
     id: number,
     organizationDto: Partial<OrganizationData>,
+    loggedInUser?: any,
     manager?: EntityManager,
   ): Promise<OrganizationData | null> {
     const repo = manager
       ? manager.getRepository(OrganizationData)
       : this.organizationRepository;
 
+    // Get existing organization
+    const existingOrg = await repo.findOne({ where: { id } });
+    if (!existingOrg) {
+      throw new Error(`Organization with id ${id} not found.`);
+    }
+
+    // Prevent circular reference - check if trying to set itself as parent
+    if (organizationDto.parent_id === id) {
+      throw new Error('Organization cannot be its own parent.');
+    }
+
+    // Check if parent_id is being changed
+    const parentIdChanged =
+      organizationDto.parent_id !== undefined &&
+      organizationDto.parent_id !== existingOrg.parent_id;
+
+    // If parent_id is being set or changed, recalculate WBS code
+    if (parentIdChanged) {
+      const newParentId = organizationDto.parent_id;
+
+      if (newParentId) {
+        // Sub-org case: parent_id is being set
+        const parentOrg = await repo.findOne({
+          where: { id: newParentId },
+        });
+
+        if (!parentOrg) {
+          throw new Error('Parent organization not found.');
+        }
+
+        if (!parentOrg.wbs_code) {
+          throw new Error('Parent organization must have a WBS code.');
+        }
+
+        // Prevent setting a descendant as parent (circular reference check)
+        if (parentOrg.wbs_code?.startsWith(existingOrg.wbs_code || '')) {
+          throw new Error(
+            'Cannot set a descendant organization as parent (circular reference).',
+          );
+        }
+
+        // Find existing sub-orgs with the same parent_id (excluding current org)
+        const existingSubOrgs = await repo.find({
+          where: {
+            parent_id: newParentId,
+          },
+          select: ['wbs_code', 'id'],
+        });
+
+        // Extract the last part of WBS codes (after the dot)
+        const subOrgCodes = existingSubOrgs
+          .filter((subOrg) => subOrg.id !== id) // Exclude current org
+          .map((subOrg) => {
+            const parts = subOrg.wbs_code?.split('.');
+            return parts && parts.length > 1 ? parts[parts.length - 1] : null;
+          })
+          .filter(Boolean)
+          .map(Number);
+
+        // Generate next sequential code
+        const nextSubOrgCode = subOrgCodes.length
+          ? Math.max(...subOrgCodes) + 1
+          : 1;
+
+        const subOrgWbsCode = this.wbcCodeGenService.padCode(nextSubOrgCode);
+        organizationDto.wbs_code = `${parentOrg.wbs_code}.${subOrgWbsCode}`;
+      } else {
+        // Main org case: parent_id is being removed
+        const existingOrgs = await repo.find({
+          where: {
+            parent_id: IsNull(),
+          },
+          select: ['wbs_code', 'id'],
+        });
+
+        // Extract WBS codes (should be simple numbers like 00001, 00002)
+        const orgCodes = existingOrgs
+          .filter((org) => org.id !== id) // Exclude current org
+          .map((org) => {
+            // If WBS code contains a dot, it's not a main org, skip it
+            if (org.wbs_code?.includes('.')) {
+              return null;
+            }
+            return org.wbs_code ? Number(org.wbs_code) : null;
+          })
+          .filter((code): code is number => code !== null);
+
+        // Generate next sequential code
+        const nextOrgCode = orgCodes.length ? Math.max(...orgCodes) + 1 : 1;
+
+        organizationDto.wbs_code = this.wbcCodeGenService.padCode(nextOrgCode);
+      }
+    }
+
+    // Set modified_by
+    if (loggedInUser) {
+      organizationDto.modified_by = loggedInUser.id;
+    }
+
     await repo.update(id, organizationDto);
     return await repo.findOne({ where: { id } });
   }

package/src/module/{meta → enterprise}/service/populate-meta.service.ts

@@ -1,15 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-import { EntityServiceImpl } from './entity-service-impl.service';
 import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
 
 @Injectable()
 export class PopulateMetaService {
   constructor(
-    private readonly dataSource: DataSource,
-    private readonly entityServiceImpl: EntityServiceImpl,
     private readonly reflectionHelper: ReflectionHelper,
-  ) {}
+  ) {
+  }
 
   async populateMetaData(organization_id: number) {
     const metadataTables = [

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

@@ -0,0 +1,5 @@
+// import { Injectable } from '@nestjs/common';
+// import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+//
+// @Injectable()
+// export class SchoolService extends EntityServiceImpl {}

package/src/module/entity_json/controller/entity_json.controller.ts

@@ -44,17 +44,4 @@ export class EntityJSONController {
       loggedInUser,
     );
   }
-
-  // @Get('/get_attributes/:entityType')
-  // @UseGuards(JwtAuthGuard)
-  // async getAttributesByMappedEntityType(
-  //   @Param('entityType') entityType: string,
-  //   @Req() req: Request & { user: any },
-  // ) {
-  //   const loggedInUser = req.user?.userData;
-  //   return this.entityJSONService.getAttributesByMappedEntityType(
-  //     entityType,
-  //     loggedInUser,
-  //   );
-  // }
 }

package/src/module/entity_json/entity/entityJson.entity.ts

@@ -29,14 +29,11 @@ export class EntityJson {
   created_by: number;
 
   @Column({ type: 'int', nullable: true })
-  organization_id: number;
+  updated_by: number;
 
   @CreateDateColumn({ type: 'timestamp', nullable: true })
   created_at: Date;
 
   @UpdateDateColumn({ type: 'timestamp', nullable: true })
   updated_at: Date;
-
-  @UpdateDateColumn({ type: 'varchar', nullable: true })
-  updated_by: string;
 }

package/src/module/entity_json/entity_json.module.ts

@@ -1,4 +1,4 @@
-import { Module, forwardRef } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 import { EntityModule } from '../meta/entity.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { EntityJSONService } from './service/entity_json.service';
@@ -8,15 +8,11 @@ import { UtilsModule } from 'src/utils/utils.module';
 import { EntityJson } from './entity/entityJson.entity';
 import { EntityJSONRepository } from './service/entityJson.repository';
 
+
 @Module({
-  imports: [
-    forwardRef(() => EntityModule),
-    TypeOrmModule.forFeature([EntityJson]),
-    forwardRef(() => FilterModule),
-    UtilsModule,
-  ],
+  imports: [EntityModule, TypeOrmModule.forFeature([EntityJson]),FilterModule,UtilsModule],
   controllers: [EntityJSONController],
-  providers: [EntityJSONService, EntityJSONRepository],
-  exports: [EntityJSONService],
+  providers: [EntityJSONService,EntityJSONRepository],
+  exports: [],
 })
 export class EntityJSONModule {}