rez_core 3.1.106 → 3.1.108

package/src/module/layout_preference/layout_preference.module.ts

@@ -1,18 +1,18 @@
-import { Module } from '@nestjs/common';
-import { LayoutPreferenceController } from './controller/layout_preference.controller';
-import { LayoutPreferenceService } from './service/layout_preference.service';
-import { EntityModule } from '../meta/entity.module';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { LayoutPreference } from './entity/layout_preference.entity';
-import { LayoutPreferenceRepository } from './repository/layout_preference.repository';
-
-@Module({
-  imports: [EntityModule, TypeOrmModule.forFeature([LayoutPreference])],
-  controllers: [LayoutPreferenceController],
-  providers: [
-    { provide: 'LayoutPreferenceService', useClass: LayoutPreferenceService },
-    LayoutPreferenceRepository,
-  ],
-  exports: ['LayoutPreferenceService'],
-})
-export class LayoutPreferenceModule {}
+import { Module } from '@nestjs/common';
+import { LayoutPreferenceController } from './controller/layout_preference.controller';
+import { LayoutPreferenceService } from './service/layout_preference.service';
+import { EntityModule } from '../meta/entity.module';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { LayoutPreference } from './entity/layout_preference.entity';
+import { LayoutPreferenceRepository } from './repository/layout_preference.repository';
+
+@Module({
+  imports: [EntityModule, TypeOrmModule.forFeature([LayoutPreference])],
+  controllers: [LayoutPreferenceController],
+  providers: [
+    { provide: 'LayoutPreferenceService', useClass: LayoutPreferenceService },
+    LayoutPreferenceRepository,
+  ],
+  exports: ['LayoutPreferenceService'],
+})
+export class LayoutPreferenceModule {}

package/src/module/layout_preference/repository/layout_preference.repository.ts

@@ -1,30 +1,30 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { LayoutPreference } from '../entity/layout_preference.entity';
-
-@Injectable()
-export class LayoutPreferenceRepository {
-  constructor(
-    @InjectRepository(LayoutPreference)
-    private readonly layoutPreferenceRepo: Repository<LayoutPreference>,
-  ) {}
-
-  async findByEntityUserId(
-    mapped_entity_type: string,
-    mapped_level_id: string,
-    mapped_level_type: string,
-    userId: number,
-    type: string,
-  ): Promise<LayoutPreference | null> {
-    return this.layoutPreferenceRepo.findOne({
-      where: {
-        user_id: userId.toString(),
-        mapped_entity_type: mapped_entity_type,
-        mapped_level_id: mapped_level_id,
-        mapped_level_type: mapped_level_type,
-        type: type,
-      },
-    });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { LayoutPreference } from '../entity/layout_preference.entity';
+
+@Injectable()
+export class LayoutPreferenceRepository {
+  constructor(
+    @InjectRepository(LayoutPreference)
+    private readonly layoutPreferenceRepo: Repository<LayoutPreference>,
+  ) {}
+
+  async findByEntityUserId(
+    mapped_entity_type: string,
+    mapped_level_id: string,
+    mapped_level_type: string,
+    userId: number,
+    type: string,
+  ): Promise<LayoutPreference | null> {
+    return this.layoutPreferenceRepo.findOne({
+      where: {
+        user_id: userId.toString(),
+        mapped_entity_type: mapped_entity_type,
+        mapped_level_id: mapped_level_id,
+        mapped_level_type: mapped_level_type,
+        type: type,
+      },
+    });
+  }
+}

package/src/module/layout_preference/service/layout_preference.service.ts

@@ -1,140 +1,140 @@
-import { Injectable } from '@nestjs/common';
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { UserData } from 'src/module/user/entity/user.entity';
-import { LayoutPreferenceRepository } from '../repository/layout_preference.repository';
-import { DataSource } from 'typeorm';
-
-@Injectable()
-export class LayoutPreferenceService extends EntityServiceImpl {
-  constructor(
-    private layoutPreferenceRepository: LayoutPreferenceRepository,
-    private readonly dataSource: DataSource,
-  ) {
-    super();
-  }
-
-  async createEntity(entityData: BaseEntity, loggedInUser: UserData) {
-    const { mapped_entity_type, type } = entityData as any;
-    const userId = loggedInUser?.id;
-
-    if (userId === undefined) {
-      throw new Error('User ID is required to create layout preference.');
-    }
-
-    const existingLayoutPreference =
-      await this.layoutPreferenceRepository.findByEntityUserId(
-        mapped_entity_type,
-        loggedInUser.level_id,
-        loggedInUser.level_type,
-        userId,
-        type,
-      );
-
-    if (existingLayoutPreference) {
-      return await super.updateEntity(
-        { ...entityData, id: existingLayoutPreference.id },
-        loggedInUser,
-      );
-    }
-
-    return await super.createEntity(
-      {
-        ...entityData,
-        user_id: userId,
-        mapped_level_id: loggedInUser.level_id,
-        mapped_level_type: loggedInUser.level_type,
-      } as any,
-      loggedInUser,
-    );
-  }
-
-  async getLayoutPreferenceByUserID(
-    user_id,
-    mapped_entity_type,
-    mapped_level_id,
-    mapped_level_type,
-    type,
-  ) {
-    const layoutPreference =
-      await this.layoutPreferenceRepository.findByEntityUserId(
-        mapped_entity_type,
-        mapped_level_id,
-        mapped_level_type,
-        user_id,
-        type,
-      );
-
-    if (layoutPreference) {
-      return layoutPreference;
-    }
-    return {
-      mapped_json: {},
-    };
-  }
-
-  async getColumnValue(
-    entity_type: string,
-    column: string,
-    sort_by: string,
-    loggedInUser: UserData,
-  ): Promise<string[]> {
-    const getTableMeta =
-      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
-        entity_type,
-        entity_type,
-        'LIST',
-        loggedInUser?.organization_id,
-      );
-
-    const tableName = getTableMeta?.data_source;
-
-    if (!tableName) {
-      throw new Error('Invalid or missing table name in metadata');
-    }
-
-    // Query to get counts of distinct values in the column
-    const rawData: { column_value: string; count: number }[] =
-      await this.dataSource
-        .createQueryBuilder()
-        .select(`${column} AS column_value`)
-        .addSelect(`COUNT(*) AS count`)
-        .from(tableName, tableName)
-        .where(`${column} IS NOT NULL`)
-        .andWhere(`organization_id = :organizationId`, {
-          organizationId: loggedInUser?.organization_id,
-        })
-        .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
-        .andWhere(`level_type = :levelType`, {
-          levelType: loggedInUser?.level_type,
-        })
-        .groupBy(column)
-        .getRawMany();
-
-    // Convert result to map and sort
-    const result = Object.fromEntries(
-      rawData.map((row) => [row.column_value, Number(row.count)]),
-    );
-
-    const entries = Object.entries(result);
-
-    switch (sort_by) {
-      case 'asc':
-        entries.sort(([a], [b]) => a.localeCompare(b));
-        break;
-      case 'dsc':
-        entries.sort(([a], [b]) => b.localeCompare(a));
-        break;
-      case 'count_asc':
-        entries.sort(([, countA], [, countB]) => countA - countB);
-        break;
-      case 'count_dsc':
-        entries.sort(([, countA], [, countB]) => countB - countA);
-        break;
-      default:
-        break;
-    }
-
-    return entries.map(([value]) => value);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { UserData } from 'src/module/user/entity/user.entity';
+import { LayoutPreferenceRepository } from '../repository/layout_preference.repository';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class LayoutPreferenceService extends EntityServiceImpl {
+  constructor(
+    private layoutPreferenceRepository: LayoutPreferenceRepository,
+    private readonly dataSource: DataSource,
+  ) {
+    super();
+  }
+
+  async createEntity(entityData: BaseEntity, loggedInUser: UserData) {
+    const { mapped_entity_type, type } = entityData as any;
+    const userId = loggedInUser?.id;
+
+    if (userId === undefined) {
+      throw new Error('User ID is required to create layout preference.');
+    }
+
+    const existingLayoutPreference =
+      await this.layoutPreferenceRepository.findByEntityUserId(
+        mapped_entity_type,
+        loggedInUser.level_id,
+        loggedInUser.level_type,
+        userId,
+        type,
+      );
+
+    if (existingLayoutPreference) {
+      return await super.updateEntity(
+        { ...entityData, id: existingLayoutPreference.id },
+        loggedInUser,
+      );
+    }
+
+    return await super.createEntity(
+      {
+        ...entityData,
+        user_id: userId,
+        mapped_level_id: loggedInUser.level_id,
+        mapped_level_type: loggedInUser.level_type,
+      } as any,
+      loggedInUser,
+    );
+  }
+
+  async getLayoutPreferenceByUserID(
+    user_id,
+    mapped_entity_type,
+    mapped_level_id,
+    mapped_level_type,
+    type,
+  ) {
+    const layoutPreference =
+      await this.layoutPreferenceRepository.findByEntityUserId(
+        mapped_entity_type,
+        mapped_level_id,
+        mapped_level_type,
+        user_id,
+        type,
+      );
+
+    if (layoutPreference) {
+      return layoutPreference;
+    }
+    return {
+      mapped_json: {},
+    };
+  }
+
+  async getColumnValue(
+    entity_type: string,
+    column: string,
+    sort_by: string,
+    loggedInUser: UserData,
+  ): Promise<string[]> {
+    const getTableMeta =
+      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
+        entity_type,
+        entity_type,
+        'LIST',
+        loggedInUser?.organization_id,
+      );
+
+    const tableName = getTableMeta?.data_source;
+
+    if (!tableName) {
+      throw new Error('Invalid or missing table name in metadata');
+    }
+
+    // Query to get counts of distinct values in the column
+    const rawData: { column_value: string; count: number }[] =
+      await this.dataSource
+        .createQueryBuilder()
+        .select(`${column} AS column_value`)
+        .addSelect(`COUNT(*) AS count`)
+        .from(tableName, tableName)
+        .where(`${column} IS NOT NULL`)
+        .andWhere(`organization_id = :organizationId`, {
+          organizationId: loggedInUser?.organization_id,
+        })
+        .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
+        .andWhere(`level_type = :levelType`, {
+          levelType: loggedInUser?.level_type,
+        })
+        .groupBy(column)
+        .getRawMany();
+
+    // Convert result to map and sort
+    const result = Object.fromEntries(
+      rawData.map((row) => [row.column_value, Number(row.count)]),
+    );
+
+    const entries = Object.entries(result);
+
+    switch (sort_by) {
+      case 'asc':
+        entries.sort(([a], [b]) => a.localeCompare(b));
+        break;
+      case 'dsc':
+        entries.sort(([a], [b]) => b.localeCompare(a));
+        break;
+      case 'count_asc':
+        entries.sort(([, countA], [, countB]) => countA - countB);
+        break;
+      case 'count_dsc':
+        entries.sort(([, countA], [, countB]) => countB - countA);
+        break;
+      default:
+        break;
+    }
+
+    return entries.map(([value]) => value);
+  }
+}

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

@@ -1,30 +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,
-    );
-  }
-}
+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 +1,14 @@
-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 {}
+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 +1,41 @@
-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('eth_school_profile', 'sch')
-      .where('sch.brand_id = :brdId', { brdId: brand_id })
-      .andWhere('sch.organization_id = :orgId', { orgId: organization_id })
-      .getRawMany();
-  }
-}
+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('eth_school_profile', 'sch')
+      .where('sch.brand_id = :brdId', { brdId: brand_id })
+      .andWhere('sch.organization_id = :orgId', { orgId: organization_id })
+      .getRawMany();
+  }
+}

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

@@ -1,54 +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
-    }));
-  }
-}
+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
+    }));
+  }
+}