rez_core 5.0.181 → 6.5.0

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

@@ -1,28 +1,28 @@
-import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'frm_entity_layout_pref' })
-export class LayoutPreference extends BaseEntity {
-  @Column({ length: 50, nullable: true })
-  user_id: string;
-
-  @Column({ nullable: true, type: 'json' })
-  mapped_json: any;
-
-  @Column({ length: 50, nullable: true, type: 'varchar' })
-  mapped_entity_type: string;
-
-  @Column({ length: 50, nullable: true, type: 'varchar' })
-  type: string;
-
-  @Column({
-    name: 'mapped_level_id',
-    type: 'varchar',
-    length: 100,
-    nullable: true,
-  })
-  mapped_level_id: string;
-
-  @Column({ name: 'mapped_level_type', type: 'varchar', nullable: true })
-  mapped_level_type: string;
-}
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'frm_entity_layout_pref' })
+export class LayoutPreference extends BaseEntity {
+  @Column({ length: 50, nullable: true })
+  user_id: string;
+
+  @Column({ nullable: true, type: 'json' })
+  mapped_json: any;
+
+  @Column({ length: 50, nullable: true, type: 'varchar' })
+  mapped_entity_type: string;
+
+  @Column({ length: 50, nullable: true, type: 'varchar' })
+  type: string;
+
+  @Column({
+    name: 'mapped_level_id',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+  })
+  mapped_level_id: string;
+
+  @Column({ name: 'mapped_level_type', type: 'varchar', nullable: true })
+  mapped_level_type: string;
+}

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

@@ -1,22 +1,22 @@
-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';
-import { AttributeMaster } from '../meta/entity/attribute-master.entity';
-
-@Module({
-  imports: [
-    EntityModule,
-    TypeOrmModule.forFeature([LayoutPreference, AttributeMaster]),
-  ],
-  controllers: [LayoutPreferenceController],
-  providers: [
-    { provide: 'LayoutPreferenceService', useClass: LayoutPreferenceService },
-    LayoutPreferenceRepository,
-  ],
-  exports: ['LayoutPreferenceService',LayoutPreferenceRepository],
-})
-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';
+import { AttributeMaster } from '../meta/entity/attribute-master.entity';
+
+@Module({
+  imports: [
+    EntityModule,
+    TypeOrmModule.forFeature([LayoutPreference, AttributeMaster]),
+  ],
+  controllers: [LayoutPreferenceController],
+  providers: [
+    { provide: 'LayoutPreferenceService', useClass: LayoutPreferenceService },
+    LayoutPreferenceRepository,
+  ],
+  exports: ['LayoutPreferenceService',LayoutPreferenceRepository],
+})
+export class LayoutPreferenceModule {}

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

@@ -1,65 +1,65 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { LayoutPreference } from '../entity/layout_preference.entity';
-import { AttributeMaster } from 'src/module/meta/entity/attribute-master.entity';
-
-@Injectable()
-export class LayoutPreferenceRepository {
-  constructor(
-    @InjectRepository(LayoutPreference)
-    private readonly layoutPreferenceRepo: Repository<LayoutPreference>,
-    @InjectRepository(AttributeMaster)
-    private readonly attributeMasterRepository: Repository<AttributeMaster>,
-  ) {}
-
-  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,
-      },
-    });
-  }
-
-  async getEntityLayoutAttributes(
-    entity_type: string,
-    query_payload: any,
-    loggedInUser: any,
-  ) {
-    let queryCondition = {
-      mapped_entity_type: entity_type,
-      enterprise_id: loggedInUser.enterprise_id,
-    };
-
-    if (query_payload) {
-      queryCondition = {
-        ...query_payload,
-        ...queryCondition,
-      };
-    }
-
-    const entityAttributes = await this.attributeMasterRepository.find({
-      where: {
-        ...queryCondition,
-      },
-    });
-
-    // Transform response
-    const formattedAttributes = entityAttributes.map((attr) => ({
-      label: attr.name,
-      value: attr.attribute_key,
-    }));
-
-    return formattedAttributes;
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { LayoutPreference } from '../entity/layout_preference.entity';
+import { AttributeMaster } from 'src/module/meta/entity/attribute-master.entity';
+
+@Injectable()
+export class LayoutPreferenceRepository {
+  constructor(
+    @InjectRepository(LayoutPreference)
+    private readonly layoutPreferenceRepo: Repository<LayoutPreference>,
+    @InjectRepository(AttributeMaster)
+    private readonly attributeMasterRepository: Repository<AttributeMaster>,
+  ) {}
+
+  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,
+      },
+    });
+  }
+
+  async getEntityLayoutAttributes(
+    entity_type: string,
+    query_payload: any,
+    loggedInUser: any,
+  ) {
+    let queryCondition = {
+      mapped_entity_type: entity_type,
+      enterprise_id: loggedInUser.enterprise_id,
+    };
+
+    if (query_payload) {
+      queryCondition = {
+        ...query_payload,
+        ...queryCondition,
+      };
+    }
+
+    const entityAttributes = await this.attributeMasterRepository.find({
+      where: {
+        ...queryCondition,
+      },
+    });
+
+    // Transform response
+    const formattedAttributes = entityAttributes.map((attr) => ({
+      label: attr.name,
+      value: attr.attribute_key,
+    }));
+
+    return formattedAttributes;
+  }
+}

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

@@ -1,191 +1,191 @@
-import { Injectable, Logger } 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 {
-  private readonly logger = new Logger(LayoutPreferenceService.name);
-
-  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<{ label: string; value: string }[]> {
-    try {
-      const getTableMeta =
-        await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
-          entity_type,
-          entity_type,
-          'LIST',
-          loggedInUser?.enterprise_id,
-        );
-
-      const tableName = getTableMeta?.data_source;
-
-      if (!tableName) {
-        throw new Error('Invalid or missing table name in metadata');
-      }
-
-      // Query DB to get distinct column values and counts
-      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(`enterprise_id = :enterprise_id`, {
-            enterprise_id: loggedInUser?.enterprise_id,
-          })
-          .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
-          .andWhere(`level_type = :levelType`, {
-            levelType: loggedInUser?.level_type,
-          })
-          .groupBy(column)
-          .getRawMany();
-
-      if (!rawData.length) {
-        return [];
-      }
-
-      // Prepare payload for resolver
-      const payloadBeforeResolved = rawData.map((row) => ({
-        [column]: row?.column_value,
-      }));
-
-      // Resolve column values using resolverService
-      const resolvedEntityList = await Promise.all(
-        payloadBeforeResolved.map((row) =>
-          this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-        ),
-      );
-
-      // Merge resolved names with counts
-      const resolvedWithCounts = rawData.map((row, index) => {
-        const resolvedValue =
-          resolvedEntityList[index]?.[column] || row.column_value;
-        return {
-          label: resolvedValue, // Human-readable label
-          value: row.column_value, // Original DB value
-          count: Number(row.count),
-        };
-      });
-
-      // Sort based on sort_by parameter
-      switch (sort_by) {
-        case 'asc':
-          resolvedWithCounts.sort((a, b) => a.label.localeCompare(b.label));
-          break;
-        case 'dsc':
-          resolvedWithCounts.sort((a, b) => b.label.localeCompare(a.label));
-          break;
-        case 'count_asc':
-          resolvedWithCounts.sort((a, b) => a.count - b.count);
-          break;
-        case 'count_dsc':
-          resolvedWithCounts.sort((a, b) => b.count - a.count);
-          break;
-        default:
-          break;
-      }
-
-      // Clean and return only label/value pairs
-      return resolvedWithCounts
-        .filter(
-          (item) =>
-            item.label !== null &&
-            item.label !== undefined &&
-            item.label.toString().trim() !== '',
-        )
-        .map((item) => ({
-          label: item.label,
-          value: item.value,
-        }));
-    } catch (error) {
-      this.logger.error(`getColumnValue ERROR: ${error.message}`, error.stack);
-      return [];
-    }
-  }
-
-  async getEntityLayoutAttributes(
-    entity_type: string,
-    query_payload: any,
-    loggedInUser: UserData,
-  ): Promise<any> {
-    return this.layoutPreferenceRepository.getEntityLayoutAttributes(
-      entity_type,
-      query_payload,
-      loggedInUser,
-    );
-  }
-}
+import { Injectable, Logger } 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 {
+  private readonly logger = new Logger(LayoutPreferenceService.name);
+
+  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<{ label: string; value: string }[]> {
+    try {
+      const getTableMeta =
+        await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
+          entity_type,
+          entity_type,
+          'LIST',
+          loggedInUser?.enterprise_id,
+        );
+
+      const tableName = getTableMeta?.data_source;
+
+      if (!tableName) {
+        throw new Error('Invalid or missing table name in metadata');
+      }
+
+      // Query DB to get distinct column values and counts
+      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(`enterprise_id = :enterprise_id`, {
+            enterprise_id: loggedInUser?.enterprise_id,
+          })
+          .andWhere(`level_id = :levelId`, { levelId: loggedInUser?.level_id })
+          .andWhere(`level_type = :levelType`, {
+            levelType: loggedInUser?.level_type,
+          })
+          .groupBy(column)
+          .getRawMany();
+
+      if (!rawData.length) {
+        return [];
+      }
+
+      // Prepare payload for resolver
+      const payloadBeforeResolved = rawData.map((row) => ({
+        [column]: row?.column_value,
+      }));
+
+      // Resolve column values using resolverService
+      const resolvedEntityList = await Promise.all(
+        payloadBeforeResolved.map((row) =>
+          this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+        ),
+      );
+
+      // Merge resolved names with counts
+      const resolvedWithCounts = rawData.map((row, index) => {
+        const resolvedValue =
+          resolvedEntityList[index]?.[column] || row.column_value;
+        return {
+          label: resolvedValue, // Human-readable label
+          value: row.column_value, // Original DB value
+          count: Number(row.count),
+        };
+      });
+
+      // Sort based on sort_by parameter
+      switch (sort_by) {
+        case 'asc':
+          resolvedWithCounts.sort((a, b) => a.label.localeCompare(b.label));
+          break;
+        case 'dsc':
+          resolvedWithCounts.sort((a, b) => b.label.localeCompare(a.label));
+          break;
+        case 'count_asc':
+          resolvedWithCounts.sort((a, b) => a.count - b.count);
+          break;
+        case 'count_dsc':
+          resolvedWithCounts.sort((a, b) => b.count - a.count);
+          break;
+        default:
+          break;
+      }
+
+      // Clean and return only label/value pairs
+      return resolvedWithCounts
+        .filter(
+          (item) =>
+            item.label !== null &&
+            item.label !== undefined &&
+            item.label.toString().trim() !== '',
+        )
+        .map((item) => ({
+          label: item.label,
+          value: item.value,
+        }));
+    } catch (error) {
+      this.logger.error(`getColumnValue ERROR: ${error.message}`, error.stack);
+      return [];
+    }
+  }
+
+  async getEntityLayoutAttributes(
+    entity_type: string,
+    query_payload: any,
+    loggedInUser: UserData,
+  ): Promise<any> {
+    return this.layoutPreferenceRepository.getEntityLayoutAttributes(
+      entity_type,
+      query_payload,
+      loggedInUser,
+    );
+  }
+}

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