rez_core 7.0.0 → 7.0.1

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

@@ -1,374 +0,0 @@
-import { Inject, Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-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 { SchoolRepository } from '../repository/school.repository';
-import { WBSCodeGenService } from 'src/utils/service/wbsCodeGen.service';
-import { StatusConstant } from '../../../constant/status.constant';
-
-// Type for update operation result
-export type UpdateResult<T> = 
-  | { success: true; data: T }
-  | { success: false; error: string };
-
-@Injectable()
-export class OrganizationService {
-  constructor(
-    @InjectRepository(OrganizationData)
-    private readonly organizationRepository: Repository<OrganizationData>,
-    private readonly schoolRepository: SchoolRepository,
-    private readonly idGen: ClockIDGenService,
-    private readonly wbcCodeGenService: WBSCodeGenService,
-  ) {}
-
-  async create(
-    organizationDto: Partial<OrganizationData>,
-    loggedInUser?: any,
-    manager?: EntityManager,
-  ): Promise<OrganizationData> {
-    const repo = manager
-      ? manager.getRepository(OrganizationData)
-      : this.organizationRepository;
-
-    const parentOrgId = organizationDto.parent_id;
-
-    if (parentOrgId) {
-      // Sub-org case: parent_id is present
-      const parentOrg = await repo.findOne({
-        where: { id: parentOrgId },
-      });
-
-      if (!parentOrg) {
-        throw new Error('Parent organization not found.');
-      }
-
-      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: {
-          parent_id: parentOrgId,
-        },
-        select: ['wbs_code'],
-      });
-
-      // 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);
-
-      // 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}`;
-      organizationDto.parent_id = parentOrgId;
-    } else {
-      // Main org case: no parent_id
-      const existingOrgs = await repo.find({
-        where: {
-          parent_id: IsNull(),
-        },
-        select: ['wbs_code'],
-      });
-
-      // Extract WBS codes (should be simple numbers like 00001, 00002)
-      const orgCodes = existingOrgs
-        .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);
-    }
-
-    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);
-  }
-
-  async findAll(manager?: EntityManager): Promise<OrganizationData[]> {
-    const repo = manager
-      ? manager.getRepository(OrganizationData)
-      : this.organizationRepository;
-
-    return await repo.find();
-  }
-
-  async findOne(
-    id: number,
-    manager?: EntityManager,
-  ): Promise<OrganizationData | null> {
-    const repo = manager
-      ? manager.getRepository(OrganizationData)
-      : this.organizationRepository;
-
-    return await repo.findOne({ where: { id } });
-  }
-
-  async findById(id: number | undefined) {
-    return await this.organizationRepository.find({ where: { id } });
-  }
-
-  async update(
-    id: number,
-    organizationDto: Partial<OrganizationData>,
-    loggedInUser?: any,
-    manager?: EntityManager,
-  ): Promise<UpdateResult<OrganizationData>> {
-    const repo = manager
-      ? manager.getRepository(OrganizationData)
-      : this.organizationRepository;
-
-    // Get existing organization
-    const existingOrg = await repo.findOne({ where: { id } });
-    if (!existingOrg) {
-      return {
-        success: false,
-        error: `Organization with id ${id} not found.`,
-      };
-    }
-
-    // Prevent circular reference - check if trying to set itself as parent
-    if (organizationDto.parent_id === id) {
-      return {
-        success: false,
-        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) {
-      // VALIDATION: Cannot change parent of organizations with WBS code length 5 or 11
-      const wbsCodeLength = existingOrg.wbs_code?.length || 0;
-      if (wbsCodeLength === 5 || wbsCodeLength === 11) {
-        return {
-          success: false,
-          error:
-            `Cannot change parent of organization with WBS code length ${wbsCodeLength}. ` +
-            `Organizations at this level (${existingOrg.wbs_code}) are locked and cannot be moved.`,
-        };
-      }
-
-      const newParentId = organizationDto.parent_id;
-      const oldWbsCode = existingOrg.wbs_code;
-
-      if (newParentId) {
-        // Sub-org case: parent_id is being set
-        const parentOrg = await repo.findOne({
-          where: { id: newParentId },
-        });
-
-        if (!parentOrg) {
-          return {
-            success: false,
-            error: 'Parent organization not found.',
-          };
-        }
-
-        if (!parentOrg.wbs_code) {
-          return {
-            success: false,
-            error: 'Parent organization must have a WBS code.',
-          };
-        }
-
-        // CIRCULAR DEPENDENCY CHECK: Prevent setting a descendant as parent
-        // This checks if the proposed parent is actually a child/descendant of the current org
-        if (existingOrg.wbs_code && parentOrg.wbs_code) {
-          // Check if parent's WBS starts with current org's WBS (parent is a descendant)
-          if (parentOrg.wbs_code.startsWith(existingOrg.wbs_code + '.')) {
-            return {
-              success: false,
-              error:
-                `Cannot set organization ${parentOrg.wbs_code} as parent. ` +
-                `It is a descendant of ${existingOrg.wbs_code} (circular reference).`,
-            };
-          }
-          
-          // Also check if they're the same (redundant with earlier check, but explicit)
-          if (parentOrg.wbs_code === existingOrg.wbs_code) {
-            return {
-              success: false,
-              error: 'Organization cannot be its own 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);
-      }
-
-      // CASCADE UPDATE: Update all descendant organizations' WBS codes
-      const newWbsCode = organizationDto.wbs_code;
-      if (oldWbsCode && newWbsCode && oldWbsCode !== newWbsCode) {
-        await this.updateDescendantWbsCodes(
-          repo,
-          oldWbsCode,
-          newWbsCode,
-          loggedInUser,
-        );
-      }
-    }
-
-    // Set modified_by
-    if (loggedInUser) {
-      organizationDto.modified_by = loggedInUser.id;
-    }
-
-    await repo.update(id, organizationDto);
-    const updatedOrg = await repo.findOne({ where: { id } });
-    
-    if (!updatedOrg) {
-      return {
-        success: false,
-        error: 'Failed to retrieve updated organization.',
-      };
-    }
-
-    return {
-      success: true,
-      data: updatedOrg,
-    };
-  }
-
-  async remove(id: number, manager?: EntityManager): Promise<void> {
-    const repo = manager
-      ? manager.getRepository(OrganizationData)
-      : this.organizationRepository;
-
-    await repo.delete(id);
-  }
-
-  /**
-   * Recursively updates WBS codes for all descendant organizations
-   * when a parent organization's WBS code changes
-   */
-  private async updateDescendantWbsCodes(
-    repo: Repository<OrganizationData>,
-    oldWbsCode: string,
-    newWbsCode: string,
-    loggedInUser?: any,
-  ): Promise<void> {
-    // Find all organizations whose WBS code starts with the old WBS code
-    // This will get all direct and indirect descendants
-    const descendants = await repo
-      .createQueryBuilder('org')
-      .where('org.wbs_code LIKE :pattern', { pattern: `${oldWbsCode}.%` })
-      .getMany();
-
-    // Update each descendant's WBS code
-    for (const descendant of descendants) {
-      if (descendant.wbs_code) {
-        // Replace the old WBS prefix with the new one
-        const updatedWbsCode = descendant.wbs_code.replace(
-          oldWbsCode,
-          newWbsCode,
-        );
-
-        const updateData: Partial<OrganizationData> = {
-          wbs_code: updatedWbsCode,
-        };
-
-        if (loggedInUser) {
-          updateData.modified_by = loggedInUser.id;
-        }
-
-        await repo.update(descendant.id, updateData);
-      }
-    }
-  }
-
-  async getOrganizationHierarchy(
-    userId: number,
-    appCode: string,
-    orgId: number,
-  ) {
-    return await this.schoolRepository.getUserContextDropdown(
-      userId,
-      appCode,
-      orgId,
-    );
-  }
-}

package/src/module/enterprise/service/populate-meta.service.ts

@@ -1,210 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { ReflectionHelper } from 'src/utils/service/reflection-helper.service';
-
-@Injectable()
-export class PopulateMetaService {
-  constructor(
-    private readonly reflectionHelper: ReflectionHelper,
-  ) {
-  }
-
-  async populateMetaData(enterprise_id: number, organization_id: number) {
-    const metadataTables = [
-      'frm_entity_master',
-      'frm_entity_attribute',
-      'frm_entity_view',
-      'frm_entity_relation',
-    ];
-
-    const listMasterItemsRepo =
-      this.reflectionHelper.getRepoService('ListMasterItems');
-    const viewMasterRepo = this.reflectionHelper.getRepoService('ViewMaster');
-    const relationRepo = this.reflectionHelper.getRepoService('EntityRelation');
-    const attributeMasterRepo =
-      this.reflectionHelper.getRepoService('AttributeMaster');
-    const entityMasterRepo =
-      this.reflectionHelper.getRepoService('EntityMaster');
-
-    if (!listMasterItemsRepo) return;
-
-    const getStatus = (await listMasterItemsRepo.find({
-      where: { enterprise_id: enterprise_id, code: 'STATUS_ACTIVE' },
-    })) as any[];
-
-    let status: any;
-
-    if (getStatus && getStatus.length > 0) {
-      status = getStatus[0].id;
-    } else {
-      status = 'ACTIVE';
-    }
-
-    let oneToManyId = await listMasterItemsRepo?.find({
-      where: { value: 'ONE_TO_MANY', enterprise_id: enterprise_id },
-    });
-
-    let oneToOneId = await listMasterItemsRepo?.find({
-      where: { value: 'ONE_TO_ONE', enterprise_id: enterprise_id },
-    });
-
-    // Step 1: Insert basic metadata tables
-    for (const table of metadataTables) {
-      let transformedData;
-
-      let transformRepo;
-
-      if (table === 'frm_entity_master') {
-        transformRepo = entityMasterRepo;
-
-        const factoryData = await transformRepo?.find({
-          where: {
-            enterprise_id: 1,
-            level_type: 'ORG',
-            level_id: 1,
-          },
-        });
-
-        transformedData = factoryData.map(
-          ({ id, created_date, modified_date, ...rest }) => ({
-            ...rest,
-            enterprise_id,
-            level_type: 'ORG',
-            level_id: organization_id,
-            is_workflow: rest.is_workflow == 1 ? true : false,
-            status: status,
-          }),
-        );
-      } else if (table === 'frm_entity_attribute') {
-        transformRepo = attributeMasterRepo;
-        const factoryData = await transformRepo?.find({
-          where: {
-            enterprise_id: 1,
-            level_type: 'ORG',
-            level_id: 1,
-          },
-        });
-
-        transformedData = factoryData.map(
-          ({ id, created_date, modified_date, ...rest }) => ({
-            ...rest,
-            level_type: 'ORG',
-            level_id: organization_id,
-            enterprise_id,
-            // is_unique: rest.is_unique == 1 ? true : false,
-            // required: rest.required == 1 ? true : false,
-            // is_hidden: rest.is_hidden == 1 ? true : false,
-            status: status,
-          }),
-        );
-      } else if (table === 'frm_entity_relation') {
-        if (!oneToManyId || !oneToOneId) continue;
-        transformRepo = relationRepo;
-        const factoryData = await transformRepo?.find({
-          where: {
-            enterprise_id: 1,
-            level_type: 'ORG',
-            level_id: 1,
-          },
-        });
-        transformedData = factoryData.map(
-          ({ id, created_date, modified_date, ...rest }) => ({
-            ...rest,
-            level_type: 'ORG',
-            level_id: organization_id,
-            status: status,
-            enterprise_id,
-            relation_id:
-              rest.relation_type == 'ONE_TO_ONE'
-                ? oneToOneId[0].id
-                : oneToManyId[0].id,
-          }),
-        );
-      } else if (table === 'frm_entity_view') {
-        transformRepo = viewMasterRepo;
-        const factoryData = await transformRepo?.find({
-          where: {
-            enterprise_id: 1,
-            level_type: 'ORG',
-            level_id: 1,
-          },
-        });
-        transformedData = factoryData.map(
-          ({ id, created_date, modified_date, ...rest }) => ({
-            ...rest,
-            enterprise_id,
-            level_type: 'ORG',
-            level_id: organization_id,
-            status: status,
-          }),
-        );
-      }
-
-      await transformRepo?.save(transformedData);
-    }
-
-    // table population for entity tables and entity table columns
-
-    const entityTableRepo = this.reflectionHelper.getRepoService('EntityTable');
-    const entityTableColumnRepo =
-      this.reflectionHelper.getRepoService('EntityTableColumn');
-
-    if (!entityTableRepo || !entityTableColumnRepo) return;
-
-    const entityTables = await entityTableRepo.find({
-      where: {
-        enterprise_id: 1,
-        level_type: 'ORG',
-        level_id: 1,
-      },
-    });
-
-    for (let entityTable of entityTables) {
-      const { id, mapped_entity_type, display_type, ...rest } = entityTable;
-      entityTable = {
-        ...rest,
-        mapped_entity_type: mapped_entity_type,
-        level_type: 'ORG',
-        level_id: organization_id,
-        enterprise_id,
-        display_type: display_type,
-      };
-
-      const insertResult = await entityTableRepo.save(entityTable);
-
-      const newId = insertResult.id;
-
-      const entityTableColumns = await entityTableColumnRepo.find({
-        where: {
-          enterprise_id: 1,
-          level_type: 'ORG',
-          level_id: 1,
-          mapped_entity_type: mapped_entity_type,
-          display_type: display_type,
-        },
-      });
-
-      let tableCloumnArray = [] as any[];
-
-      for (const column of entityTableColumns) {
-        const { id, created_date, modified_date, ...columnRest } = column;
-        const newColumn = {
-          ...columnRest,
-          parent_id: newId,
-          level_type: 'ORG',
-          level_id: organization_id,
-          enterprise_id,
-          mapped_entity_type: mapped_entity_type,
-          display_type: display_type,
-        };
-        tableCloumnArray.push(newColumn);
-      }
-
-      await entityTableColumnRepo.save(tableCloumnArray);
-    }
-
-    return {
-      message: 'Metadata populated successfully',
-      status: 'success',
-    };
-  }
-}

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

@@ -1,5 +0,0 @@
-// 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/lead/controller/lead.controller.ts

@@ -1,30 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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';
-
-@Module({
-  imports: [TypeOrmModule.forFeature([OrganizationData])],
-  providers: [LeadService, LeadRepository],
-  controllers: [],
-  exports: [LeadService],
-})
-export class LeadModule {}

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

@@ -1,41 +0,0 @@
-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 { DataSource, Repository } from 'typeorm';
-
-@Injectable()
-export class LeadRepository {
-  constructor(
-    @InjectRepository(OrganizationData)
-    private organizationRepository: Repository<OrganizationData>,
-    private readonly dataSource: DataSource,
-  ) {}
-
-  async getAllOrganizations(): Promise<OrganizationData[]> {
-    return this.organizationRepository.find();
-  }
-
-  async getBrandsByOrganization(organization_id: number): Promise<any[]> {
-    return await this.dataSource
-      .createQueryBuilder()
-      .select(['*'])
-      .from('eth_brand_profile', 'brd')
-      .where('brd.organization_id = :orgId', { orgId: organization_id })
-      .getRawMany();
-  }
-
-  async getSchoolsByBrandAndOrganization(
-    brand_id: number,
-    organization_id: number,
-  ): Promise<any[]> {
-    return await this.dataSource
-      .createQueryBuilder()
-      .select(['*'])
-      .from('sso_school', 'sch')
-      .where('sch.brand_id = :brdId', { brdId: brand_id })
-      .andWhere('sch.organization_id = :orgId', { orgId: organization_id })
-      .getRawMany();
-  }
-}