rez_core 0.0.7 → 1.0.2-o

package/src/module/meta/service/entity-list.service.ts

@@ -49,13 +49,13 @@ export class EntityListService {
     return entityListData;
   }
 
-  private async getFilteredList(
+  public async getFilteredList(
     entityTable: EntityTable,
     filters: Record<string, any>,
     sortColumn: string | undefined,
     sortOrder: string | undefined,
-    pageNumber: number,
-    pageSize: number,
+    pageNumber: number | undefined,
+    pageSize: number | undefined,
   ) {
     let query = this.getQuery(entityTable.data_source, null);
     let whereClause = await this.getWhereClause(entityTable, filters);
@@ -75,22 +75,32 @@ export class EntityListService {
     entityTable: EntityTable,
     filters: Record<string, any>,
   ) {
-    let query =  this.getQuery(entityTable.data_source, entityTable.tab_column);
+    let query = this.getQuery(entityTable.data_source, entityTable.tab_column);
     let whereClause = await this.getWhereClause(entityTable, filters);
     if (whereClause.query) {
       query += whereClause.query;
     }
     query += ' GROUP BY ' + entityTable.tab_column;
-    return await this.entityManager.query(query, whereClause.argumentList);
+    let tabs = await this.entityManager.query(query, whereClause.argumentList);
+    let all = 0;
+    for (const i in tabs) {
+      let tab = tabs[i] as EntityTab;
+      all += parseInt(String(tab.tab_value_count));
+    }
+    let entityTab = new EntityTab();
+    entityTab.tab_value = 'ALL';
+    entityTab.tab_value_count = all;
+    tabs.push(entityTab);
+    return tabs;
   }
 
   private getQuery(source: string, groupByColumn: string | null) {
     if (groupByColumn) {
       return `SELECT ${groupByColumn} as tab_value, COUNT(1) AS tab_value_count
-                    FROM ${source}`;
+              FROM ${source}`;
     } else {
       return `SELECT *
-                    FROM ${source}`;
+              FROM ${source}`;
     }
   }
 
@@ -135,4 +145,23 @@ export class EntityListService {
 
     return { query, argumentList: argsObjectList };
   }
+
+  public async getMaxSequenceNumber(
+    tableName: string,
+    parentType: string,
+    parentId: number,
+  ) {
+    let query = `SELECT COUNT(1) seq_no
+                 FROM ${tableName} `;
+    const argsObjectList: any[] = [];
+    if (parentId) {
+      query += `parent_id = ? AND parent_type = ? `;
+      argsObjectList.push(parentId);
+      argsObjectList.push(parentType);
+    }
+
+    let result = await this.entityManager.query(query, argsObjectList);
+
+    return result ? result[0].seq_no : 0;
+  }
 }

package/src/module/meta/service/entity-service-impl.service.ts

@@ -1,5 +1,5 @@
 import { EntityService } from './entity.service';
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { UserData } from '../../user/entity/user.entity';
 import { EntityMasterService } from './entity-master.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
@@ -7,39 +7,64 @@ import { BaseEntity } from '../entity/base-entity.entity';
 import { LoggingService } from '../../../utils/service/loggingUtil.service';
 import { EntityListData } from '../dto/entity-list-data.dto';
 import { EntityListService } from './entity-list.service';
+import { EntityManager } from 'typeorm';
+import { ExcelData } from '../../../utils/dto/excel-data.dto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ExcelHelper } from '../../../utils/service/excel-helper.service';
+import { ExcelsheetData } from '../../../utils/dto/excelsheet-data.dto';
+import { EntityTableService } from './entity-table.service';
+import { EntityTableColumnService } from './entity-table-column.service';
+import { ENTITYTYPE_ENTITYMASTER } from '../../../constant/global.constant';
 
 @Injectable()
 export class EntityServiceImpl implements EntityService<BaseEntity> {
-  constructor(
-    private entityMasterService: EntityMasterService,
-    private reflectionHelper: ReflectionHelper,
-    private entityListService: EntityListService,
-    loggingService: LoggingService,
-  ) {}
+  @Inject() protected readonly entityMasterService: EntityMasterService;
+  @Inject()
+  protected readonly entityTableColumnService: EntityTableColumnService;
+  @Inject() protected readonly entityTableService: EntityTableService;
+  @Inject() protected readonly reflectionHelper: ReflectionHelper;
+  @Inject() protected readonly entityListService: EntityListService;
+  @Inject() protected readonly loggingService: LoggingService;
 
   async createEntity(
     entityData: BaseEntity,
     loggedInUser: UserData | null,
+    manager?: EntityManager,
   ): Promise<BaseEntity> {
+    if (!entityData.entity_type) {
+      throw new BadRequestException(`EntityType is missing`);
+    }
     const entityMaster = await this.entityMasterService.getEntityData(
       entityData.entity_type,
     );
 
-    const repoService = this.reflectionHelper.getRepoService(
-      entityMaster.entityDataClass,
-    );
-    if (!repoService) {
+    const repo = manager
+      ? manager.getRepository(entityMaster.entityDataClass) // <-- Use transaction-safe repo
+      : this.reflectionHelper.getRepoService(entityMaster.entityDataClass);
+
+    if (!repo) {
       throw new Error(
         `Repository service not found for entityType: ${entityData.entity_type}`,
       );
     }
-    entityData.entity_type = entityMaster.mappedEntityType;
+
+    if (!entityData.code) {
+      let maxSeqNo = await this.getMaxSequenceNumber(
+        entityData.entity_type,
+        entityData.parent_id,
+        entityData.parent_type,
+      );
+      maxSeqNo = Number(maxSeqNo) + 1;
+      entityData.code = entityData.entity_type + maxSeqNo;
+    }
+
     entityData.created_date = new Date();
     if (loggedInUser) {
       entityData.created_by = loggedInUser.id;
     }
 
-    const savedEntity = repoService.save(entityData);
+    const savedEntity = repo.save(entityData);
     return savedEntity;
   }
 
@@ -73,13 +98,6 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     id: number,
   ): Promise<BaseEntity | null> {
     const entityData = await this.entityMasterService.getEntityData(entityType);
-    // this.loggingService.log(
-    //   'info',
-    //   EntityServiceImpl.name,
-    //   'GetEntity',
-    //   'STARTED',
-    //   [{ entityData }],
-    // );
 
     const repoService = this.reflectionHelper.getRepoService(
       entityData.entityDataClass,
@@ -151,4 +169,104 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
       pageSize,
     );
   }
+
+  async generateExcelReport(
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+  ): Promise<string | null> {
+    let fileName: string;
+    try {
+      const excelData = new ExcelData();
+      await this.populateExcelData(
+        excelData,
+        entityType,
+        filterCriteria,
+        listEntityType,
+        displayType,
+      );
+
+      const modifiedDate = new Date().toISOString().replace(/[-T:.Z]/g, '');
+      const tempDir = path.join(__dirname, '../../temp');
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+      fileName = path.join(tempDir, `export_${modifiedDate}.xlsx`);
+      excelData.filePath = fileName;
+      ExcelHelper.writeExcel(excelData);
+    } catch (error) {
+      throw error;
+    }
+    return fileName;
+  }
+
+  private async populateExcelData(
+    excelData: ExcelData,
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+  ) {
+    const sheet: ExcelsheetData = {
+      sheetName: entityType,
+      headers: [],
+      rowList: [],
+    };
+
+    const entityTable =
+      await this.entityTableService.findByEntityTypeAndListTypeAndDisplayType(
+        entityType,
+        listEntityType,
+        displayType,
+      );
+    if (entityTable) {
+      const entityTableColumnList =
+        await this.entityTableColumnService.findByParentIdAndParentType(
+          entityTable.id,
+          entityTable.entity_type,
+        );
+
+      sheet.headers = entityTableColumnList.map((col) => col.name);
+      const attributeList = entityTableColumnList.map(
+        (col) => col.attribute_key,
+      );
+
+      const filteredList = await this.entityListService.getFilteredList(
+        entityTable,
+        filterCriteria,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+      );
+
+      sheet.rowList = filteredList.map((item) =>
+        attributeList.map((attr) =>
+          item[attr] !== undefined ? item[attr] : null,
+        ),
+      );
+      excelData.addSheet(sheet);
+    }
+  }
+
+  private async getMaxSequenceNumber(
+    entityType: string,
+    parentId: number,
+    parentType: string,
+  ): Promise<number> {
+    let tableName: string;
+    if (ENTITYTYPE_ENTITYMASTER === entityType) {
+      tableName = 'cr_entity_master';
+    } else {
+      let entityMaster =
+        await this.entityMasterService.getEntityData(entityType);
+      tableName = entityMaster.dbTableName;
+    }
+    return await this.entityListService.getMaxSequenceNumber(
+      tableName,
+      parentType,
+      parentId,
+    );
+  }
 }

package/src/module/meta/service/entity-table-column.service.ts

@@ -8,11 +8,24 @@ export class EntityTableColumnService {
   ) {}
 
   async getAttributeJson(parentId: number, parentType: string) {
-    let entityTableColumns = await this.entityTableColumnRepository.findByParentIdAndParentType(parentId, parentType);
+    let entityTableColumns =
+      await this.entityTableColumnRepository.findByParentIdAndParentType(
+        parentId,
+        parentType,
+      );
     let attributeJson = {};
     entityTableColumns.forEach((value) => {
       attributeJson[value.attribute_key] = value.data_type;
     });
     return attributeJson;
   }
+
+  async findByParentIdAndParentType(parentId: number, parentType: string) {
+    let entityTableColumns =
+      await this.entityTableColumnRepository.findByParentIdAndParentType(
+        parentId,
+        parentType,
+      );
+    return entityTableColumns;
+  }
 }

package/src/module/meta/service/entity-table.service.ts

@@ -6,6 +6,13 @@ export class EntityTableService {
   constructor(private entityTableRepository: EntityTableRepository) {}
 
   async findByEntityTypeAndListType(entityType: string, listType: string) {
-    return await this.entityTableRepository.findByEntityTypeAndListType(entityType, listType);
+    return await this.entityTableRepository.findByEntityTypeAndListType(
+      entityType,
+      listType,
+    );
+  }
+
+  async findByEntityTypeAndListTypeAndDisplayType(entityType: string, listType: string, displayType: string) {
+    return await this.entityTableRepository.findByEntityTypeAndListTypeAndDisplayType(entityType, listType, displayType);
   }
 }

package/src/module/meta/service/entity.service.ts

@@ -1,9 +1,14 @@
 import { UserData } from '../../user/entity/user.entity';
 import { BaseEntity } from '../entity/base-entity.entity';
 import { EntityListData } from '../dto/entity-list-data.dto';
+import { EntityManager } from 'typeorm';
 
 export interface EntityService<T extends BaseEntity> {
-  createEntity(entityData: T, loggedInUser: UserData): Promise<BaseEntity>;
+  createEntity(
+    entityData: T,
+    loggedInUser: UserData,
+    manager?: EntityManager,
+  ): Promise<BaseEntity>;
 
   getEntityData(
     entityType: string,
@@ -31,4 +36,11 @@ export interface EntityService<T extends BaseEntity> {
     pageNumber: number,
     pageSize: number,
   ): Promise<EntityListData>;
+
+  generateExcelReport(
+    entityType: string,
+    filterCriteria: Record<string, any>,
+    listEntityType: string,
+    displayType: string,
+  ): Promise<string | null>;
 }

package/src/module/meta/service/media-data.service.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { MediaDataRepository } from '../repository/media-data.repository';
+
+@Injectable()
+export class MediaDataService extends EntityServiceImpl {
+  constructor(private readonly mediaRepository: MediaDataRepository) {
+    super();
+  }
+
+  async findByAttributeKeyAndMappedEntityIdAndMappedEntityType(
+    attributeKey: string,
+    mappedEntityId: number,
+    mappedEntityType: string,
+  ) {
+    return await this.mediaRepository.findByAttributeKeyAndMappedEntityIdAndMappedEntityType(
+      attributeKey,
+      mappedEntityId,
+      mappedEntityType,
+    );
+  }
+
+  async findByMappedEntityIdAndMappedEntityType(
+    mappedEntityId: number,
+    mappedEntityType: string,
+  ) {
+    return await this.mediaRepository.findByMappedEntityIdAndMappedEntityType(
+      mappedEntityId,
+      mappedEntityType,
+    );
+  }
+
+  async deleteByAttributeKeyAndMappedEntityIdAndMappedEntityType(
+    attributeKey: string,
+    mappedEntityId: number,
+    mappedEntityType: string,
+  ) {
+    return await this.mediaRepository.deleteByAttributeKeyAndMappedEntityIdAndMappedEntityType(
+      attributeKey,
+      mappedEntityId,
+      mappedEntityType,
+    );
+  }
+}

package/src/module/meta/service/preference.service.ts

@@ -1,26 +1,11 @@
 import { EntityServiceImpl } from './entity-service-impl.service';
 import { Injectable } from '@nestjs/common';
 import { PreferenceRepository } from '../repository/preference.repository';
-import { EntityMasterService } from './entity-master.service';
-import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { LoggingService } from '../../../utils/service/loggingUtil.service';
-import { EntityListService } from './entity-list.service';
 
 @Injectable()
 export class PreferenceService extends EntityServiceImpl {
-  constructor(
-    entityMasterService: EntityMasterService,
-    reflectionHelper: ReflectionHelper,
-    loggingService: LoggingService,
-    entityListService: EntityListService,
-    private readonly preferenceRepository: PreferenceRepository,
-  ) {
-    super(
-      entityMasterService,
-      reflectionHelper,
-      entityListService,
-      loggingService,
-    );
+  constructor(private readonly preferenceRepository: PreferenceRepository) {
+    super();
   }
 
   async getPreferenceValue(preferenceKey: string): Promise<string | undefined> {

package/src/module/module/controller/menu.controller.ts

@@ -1,15 +1,15 @@
-import { Controller, Get, Request, UseGuards } from '@nestjs/common';
-import { MenuService } from '../service/menu.service';
-import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
-
-@Controller('menu')
-export class MenuController {
-  constructor(private readonly menuService: MenuService) {}
-
-  @UseGuards(JwtAuthGuard)
-  @Get()
-  async getMenu(@Request() req) {
-    const userId = req.user.userId;
-    return this.menuService.getUserMenu(userId);
-  }
-}
+import { Controller, Get, Request, UseGuards } from '@nestjs/common';
+import { MenuService } from '../service/menu.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+
+@Controller('menu')
+export class MenuController {
+  constructor(private readonly menuService: MenuService) {}
+
+  @UseGuards(JwtAuthGuard)
+  @Get()
+  async getMenu(@Request() req) {
+    const userId = req.user.userId;
+    return this.menuService.getUserMenu(userId);
+  }
+}

package/src/module/module/controller/module-access.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Get, Post, Body, Query } from '@nestjs/common';
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
 import { ModuleAccessService } from '../service/module-access.service';
 
 @Controller('module-access')

package/src/module/module/entity/menu.entity.ts

@@ -1,5 +1,4 @@
 import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-import { StatusType } from '../../../constant/status.constant';
 
 @Entity({ name: 'cr_menu' })
 export class MenuData {
@@ -9,30 +8,30 @@ export class MenuData {
   @Column({ type: 'varchar', length: 100, nullable: true })
   name: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_code: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
-  status: StatusType;
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  status: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   wbs_code: string;
 
-  @Column({type: 'varchar', nullable: true })
+  @Column({ type: 'varchar', nullable: true })
   path: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   icon: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_level: string;
 
-  @Column({type: 'int', nullable: true})
+  @Column({ type: 'int', nullable: true })
   parent_id: number;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   parent_code: string;
 
-  @Column({type: 'int', nullable: true})
+  @Column({ type: 'int', nullable: true })
   ui_visible: number;
 }

package/src/module/module/entity/module-access.entity.ts

@@ -1,22 +1,22 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'cr_module_access' })
-export class ModuleAccess {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({type: 'varchar', length: 100, nullable: true})
-  module_code: string;
-
-  @Column({type: 'varchar', length: 100, nullable: true })
-  role_code: string;
-
-  @Column({type: 'int', nullable: true })
-  access_flag: number;
-
-  @Column({type: 'varchar', length: 100, nullable: true })
-  action_type: string;
-
-  @Column({type: 'varchar', length: 100, nullable: true})
-  app_code: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'cr_module_access' })
+export class ModuleAccess {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  module_code: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  role_code: string;
+
+  @Column({type: 'int', nullable: true })
+  access_flag: number;
+
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_type: string;
+
+  @Column({type: 'varchar', length: 100, nullable: true})
+  app_code: string;
+}

package/src/module/module/entity/module-action.entity.ts

@@ -1,19 +1,19 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity({ name: 'module_action' })
-export class ModuleAction {
-  @PrimaryGeneratedColumn()
-  id: number;
-
-  @Column({type: 'int', nullable: true})
-  module_id: number;
-  
-  @Column({type: 'varchar', length: 100, nullable: true })
-  module_code: string;
-  
-  @Column({type: 'varchar', length: 100, nullable: true })
-  action_name:string
-
-  @Column({type: 'varchar', length: 50, nullable: true })
-  action_type: string;
-}
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity({ name: 'module_action' })
+export class ModuleAction {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({type: 'int', nullable: true})
+  module_id: number;
+  
+  @Column({type: 'varchar', length: 100, nullable: true })
+  module_code: string;
+  
+  @Column({type: 'varchar', length: 100, nullable: true })
+  action_name:string
+
+  @Column({type: 'varchar', length: 50, nullable: true })
+  action_type: string;
+}

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

@@ -1,32 +1,31 @@
 import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-import { StatusType } from '../../../constant/status.constant';
 
 @Entity({ name: 'cr_module' })
 export class ModuleData {
   @PrimaryGeneratedColumn({ type: 'int' })
   id: number;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   name: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_code: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   wbs_code: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
-  status: StatusType;
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  status: string;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   module_level: string;
 
-  @Column({type: 'int', nullable: true })
+  @Column({ type: 'int', nullable: true })
   parent_id: number;
 
-  @Column({type: 'varchar', length: 100, nullable: true })
+  @Column({ type: 'varchar', length: 100, nullable: true })
   parent_code: string;
 
-  @Column({type: 'int', nullable: true})
+  @Column({ type: 'int', nullable: true })
   ui_visible: number;
 }

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

@@ -13,7 +13,6 @@ import { ModuleAccessRepository } from './repository/module-access.repository';
 import { ModuleAccessController } from './controller/module-access.controller';
 import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
 import { UserModule } from '../user/user.module';
-import { RoleRepository } from '../user/repository/role.repository';
 import { Role } from '../user/entity/role.entity';
 
 @Module({
@@ -24,10 +23,10 @@ import { Role } from '../user/entity/role.entity';
       ModuleAction,
       MenuData,
       UserRoleMapping,
-      Role
+      Role,
     ]),
     UtilsModule,
-    UserModule
+    UserModule,
   ],
   controllers: [MenuController, ModuleAccessController],
   providers: [
@@ -35,7 +34,6 @@ import { Role } from '../user/entity/role.entity';
     MenuService,
     MenuRepository,
     ModuleAccessRepository,
-  
   ],
   exports: [ModuleAccessService],
 })