rez_core 1.0.47 → 1.0.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "",
   "author": "",
   "private": false,

package/src/constant/global.constant.ts

@@ -9,6 +9,10 @@ export const ENTITYTYPE_VIEWMASTER = 'VMS';
 export const ENTITYTYPE_MEDIA = 'MDA';
 export const ENTITYTYPE_LISTMASTER = 'LMS';
 export const ENTITYTYPE_LISTMASTERITEMS = 'LMI';
+export const ENTITYTYPE_SECTIONMASTER = 'SEC';
+export const ENTITYTYPE_FIELDMASTER = 'FLD';
+export const ENTITYTYPE_USRROLMAP = 'URM';
+
 
 export const STORAGETYPE_SINGLEJSON = 'singlejson';
 export const STORAGETYPE_COLUMN = 'column';
@@ -23,4 +27,4 @@ export const STATUS_PENDING = 'PENDING';
 
 // Entity Status
 export const ENTITYSTATUS_TO_BE_PUBLISHED = 'to_be_published';
-export const ENTITYSTATUS_PUBLISHED = 'published';
+export const ENTITYSTATUS_PUBLISHED = 'published';

package/src/module/master/service/master.service.ts

@@ -3,6 +3,9 @@ import { EntityManager, Unique } from 'typeorm';
 import { ExcelUtil } from 'src/utils/service/excelUtil.service';
 import { EntityMasterService } from '../../meta/service/entity-master.service';
 import { table } from 'console';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { EntityMaster } from 'src/module/meta/entity/entity-master.entity';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 
 interface ParentEntity {
   id: number;
@@ -14,7 +17,9 @@ export class MasterService {
   constructor(
     private readonly entityManager: EntityManager,
     private readonly entityMasterService: EntityMasterService,
+    private readonly attributeMasterService: AttributeMasterService,
     private readonly excelUtil: ExcelUtil,
+    private readonly entityServiceImpl: EntityServiceImpl,
   ) {}
 
   private readonly metaSheets = [
@@ -42,10 +47,65 @@ export class MasterService {
     },
   ];
 
+  private readonly dataSequence = [
+    {
+      table: 'cr_user',
+      unique_fields: ['code'],
+    },
+    {
+      table: 'cr_role',
+      unique_fields: ['code'],
+    },
+    {
+      table: 'cr_user_role_mapping',
+      unique_fields: ['user_id', 'role_id'],
+    },
+    {
+      table: 'eth_school',
+      unique_fields: ['code'],
+    },
+    {
+      table: 'eth_school_address',
+      unique_fields: ['code'],
+    },
+  ];
+
   private isMetaSheet(sheetName: string): boolean {
     return this.metaSheets.includes(sheetName.toLowerCase());
   }
 
+  private async resolveParent(row: any): Promise<void> {
+    const parentType = row.parent_type; // (Future use maybe)
+    const code = row.parent_id;
+
+    if (!code) {
+      throw new Error('Parent code is missing in the row');
+    }
+
+    const parentEntity: EntityMaster | null =
+      await this.entityMasterService.findByMappedEntityType(parentType);
+
+    const tableName: any = parentEntity?.db_table_name;
+    if (!tableName) {
+      throw new Error(`Table name not found for parent type ${parentType}`);
+    }
+
+    // Using RAW SQL Query
+    const entityData = await this.entityManager.query(
+      `SELECT * FROM ${tableName} WHERE code = ? LIMIT 1`,
+      [code],
+    );
+
+    if (!entityData || entityData.length === 0) {
+      throw new Error(
+        `Parent entity with code ${code} not found in table ${tableName}`,
+      );
+    }
+
+    // entityData is an array when using .query()
+    row.parent_id = entityData[0].id;
+  }
+
   async uploadMasterData(file) {
     const data = ExcelUtil.readExcel(file.buffer);
 
@@ -61,12 +121,47 @@ export class MasterService {
         console.log(`Processing sheet: ${table}`);
         await this.upsertData(table, unique_fields, sheetData);
       }
-      else{
+    }
+    for (let i = 0; i < this.dataSequence.length; i++) {
+      const { table, unique_fields } = this.dataSequence[i];
+      const sheetData = data[table];
+
+      if (!sheetData) {
+        console.log(`Sheet ${table} not found in the Excel file.`);
+        continue;
+      }
+
+      const entityMasterData =
+        await this.entityMasterService.getEntityByTableName(table);
 
-        
+      const attributes =
+        await this.attributeMasterService.findAttributesByMappedEntityType(
+          entityMasterData?.mapped_entity_type,
+        );
 
+        console.log(attributes,"((((((((((((((((((((((((((")
+      for (const row of sheetData) {
+        if (row.parent_type !== undefined && row.parent_id !== undefined) {
+          this.resolveParent(row);
+        }
+
+        for (const attribute of attributes) {
+          if (attribute.data_source_type === 'entity') {
+            console.log(attribute.data_source_type)
+            let entityMaster = await this.entityMasterService.getEntityData(
+              attribute.datasource_list,
+            );
+            const entityData = await this.entityManager.query(
+              `SELECT * FROM ${entityMaster.db_table_name} WHERE code = ? LIMIT 1`,
+              [row[attribute.attribute_key]],
+            );
+            row[attribute.attribute_key] = entityData[0].id;
+          }
+        }
       }
-      
+
+      console.log(`Processing sheet: ${table}`);
+      await this.upsertData(table, unique_fields, sheetData);
     }
     return {
       message: 'Data uploaded successfully',

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

@@ -8,7 +8,8 @@ import {
   Post,
   Query,
   Res,
-  UseGuards,
+  Req,
+  UseGuards, Inject,
 } from '@nestjs/common';
 import { EntityServiceImpl } from '../service/entity-service-impl.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
@@ -18,6 +19,9 @@ import { BaseEntity } from '../entity/base-entity.entity';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import * as fs from 'fs';
 import * as path from 'path';
+import { UserService } from '../../user/service/user.service';
+import { ENTITYTYPE_USER } from '../../../constant/global.constant';
+import { UserData } from '../../user/entity/user.entity';
 
 @UseGuards(JwtAuthGuard)
 @Controller('entity')
@@ -58,7 +62,11 @@ export class EntityController {
     @Body() entityData: BaseEntity,
     @Query('entity_type') entityType: string,
     @Res() res: Response,
+    @Req() req: Request & {user: any}
   ) {
+    let requestedUser = req.user;
+    let loggedInUser = await this.entityService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
+
     if (!entityType) {
       throw new BadRequestException(
         'Query parameter "entity_type" is required',
@@ -75,7 +83,7 @@ export class EntityController {
     if (entityService) {
       return res
         .status(HttpStatus.OK)
-        .json(await entityService.createEntity(entityData, null));
+        .json(await entityService.createEntity(entityData, loggedInUser as UserData));
     }
   }
 
@@ -85,7 +93,10 @@ export class EntityController {
     @Body() entityData: BaseEntity,
     @Query('entity_type') entityType: string,
     @Res() response: Response,
+    @Req() req: Request & {user: any}
   ) {
+    let requestedUser = req.user;
+    let loggedInUser = await this.entityService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
     if (!entityType) {
       throw new BadRequestException(
         'Query parameter "entity_type" is required',
@@ -106,7 +117,7 @@ export class EntityController {
       }
       // let mergeEntity = JsonUtil.merge(existingEntity, entityData);
 
-      entityData = await entityService.updateEntity(entityData, null);
+      entityData = await entityService.updateEntity(entityData, loggedInUser as UserData);
       return response.status(HttpStatus.OK).json(entityData);
     }
   }

package/src/module/meta/controller/media.controller.ts

@@ -4,17 +4,22 @@ import {
   HttpStatus,
   Post,
   Res,
+  Get,
+  Param,
   UseGuards,
 } from '@nestjs/common';
 import { MediaDataService } from '../service/media-data.service';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-import { Response } from 'express';
+import e, { Response } from 'express';
+import { ENTITYTYPE_MEDIA } from 'src/constant/global.constant';
+import { MediaData } from '../entity/media-data.entity';
 
 @Controller('media')
 // @UseGuards(JwtAuthGuard)
 export class MediaController {
   constructor(private readonly mediaDataService: MediaDataService) {}
 
+  // Method for initiating an upload
   @Post('initiate-upload')
   async initiateUpload(
     @Body()
@@ -42,4 +47,25 @@ export class MediaController {
       throw new Error('Something went wrong!');
     }
   }
+
+  // Method to fetch the download URL for a media file
+  @Get('download/:id')
+  async getDownloadUrl(@Param('id') id: number, @Res() res: Response) {
+    try {
+      
+      const entityData = await this.mediaDataService.getEntityData(ENTITYTYPE_MEDIA, id);
+      let mediaData = entityData as MediaData;
+      const downloadUrl = await this.mediaDataService.getMediaDownloadUrl(mediaData.media_url);
+      res.status(HttpStatus.OK).json({
+        message: 'Download URL fetched successfully',
+        success: true,
+        data: { downloadUrl },
+      });
+    } catch (error) {
+      res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+        message: error.message || 'Error fetching download URL',
+        success: false,
+      });
+    }
+  }
 }

package/src/module/meta/entity/field-group.entity.ts

@@ -0,0 +1,25 @@
+import { ENTITYTYPE_FIELDMASTER } from 'src/constant/global.constant';
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_field_group' })
+export class FieldGroup extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_FIELDMASTER;
+  }
+  @Column({ length: 50, nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ length: 50, nullable: true })
+  field_type: string;
+
+  @Column({ nullable: true })
+  description: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  label: string;
+
+  @Column({ type: 'int', nullable: true })
+  view_id: number;
+}

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

@@ -0,0 +1,23 @@
+import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+
+@Entity({ name: 'eth_school_temp' })
+export class SchoolEntity {
+
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column({})
+    code: string;
+
+    @Column({})
+    name:string;
+
+    @Column({})
+    logo:string;
+    
+    @Column({nullable:true})
+    parent_id:number;
+    
+    @Column({nullable:true})
+    parent_type:string;
+}

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

@@ -0,0 +1,25 @@
+import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+
+@Entity({ name: 'eth_school_address_temp' })
+export class SchoolAddressEntity {
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column({})
+    code: string;
+
+    @Column({})
+    city: string;
+
+    @Column({})
+    state: string;
+
+    @Column({})
+    school_id: number;
+
+    @Column({})
+    parent_type: string;
+
+    @Column({})
+    parent_id: number;
+}

package/src/module/meta/entity/section-master.entity.ts

@@ -0,0 +1,28 @@
+import { ENTITYTYPE_SECTIONMASTER } from 'src/constant/global.constant';
+import { BaseEntity } from './base-entity.entity';
+import { Column, Entity } from 'typeorm';
+
+@Entity({ name: 'cr_section_master' })
+export class SectionMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_SECTIONMASTER;
+  }
+  @Column({ length: 50, nullable: true })
+  mapped_entity_type: string;
+
+  @Column({ length: 50, nullable: true })
+  section_type: string;
+
+  @Column({ nullable: true })
+  description: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  tooltip: string;
+
+  @Column({ type: 'int', nullable: true })
+  visible_in_add: number;
+
+  @Column({ type: 'int', nullable: true })
+  position: number;
+}

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

@@ -24,6 +24,14 @@ import { MediaDataService } from './service/media-data.service';
 import { MediaDataRepository } from './repository/media-data.repository';
 import { MediaController } from './controller/media.controller';
 import { ViewMaster } from './entity/view-master.entity';
+import { SchoolEntity } from './entity/school.entity';
+import { SchoolAddressEntity } from './entity/schoolAddress.entity';
+import { AttributeMasterService } from './service/attribute-master.service';
+import { SectionMasterService } from './service/section-master.service';
+import { SectionMaster } from './entity/section-master.entity';
+import { FieldGroup } from './entity/field-group.entity';
+import { FieldGroupService } from './service/field-group.service';
+import { ViewMasterService } from './service/view-master.service';
 
 @Module({
   imports: [
@@ -35,6 +43,10 @@ import { ViewMaster } from './entity/view-master.entity';
       EntityTableColumn,
       MediaData,
       ViewMaster,
+      SchoolEntity,
+      SchoolAddressEntity,
+      SectionMaster,
+      FieldGroup,
     ]),
     UtilsModule,
   ],
@@ -52,6 +64,10 @@ import { ViewMaster } from './entity/view-master.entity';
     EntityListService,
     MediaDataRepository,
     MediaDataService,
+    AttributeMasterService,
+    SectionMasterService,
+    FieldGroupService,
+    { provide: 'ViewMasterService', useClass: ViewMasterService },
   ],
   exports: [
     EntityMasterService,
@@ -61,6 +77,9 @@ import { ViewMaster } from './entity/view-master.entity';
     EntityTableService,
     EntityTableColumnService,
     MediaDataService,
+    SectionMasterService,
+    FieldGroupService,
+    'ViewMasterService',
   ],
   controllers: [EntityController, MasterController, MediaController],
 })

package/src/module/meta/repository/attribute-master.repository.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AttributeMaster } from '../entity/attribute-master.entity';
-import { Repository } from 'typeorm';
+import { In, Repository } from 'typeorm';
 
 @Injectable()
 export class AttributeMasterRepository {
@@ -25,4 +25,14 @@ export class AttributeMasterRepository {
       },
     });
   }
+
+
+  async findAttributesByMappedEntityType(entityType: string): Promise<AttributeMaster[]> {
+    return await this.attributeMasterRepository.find({
+      where: {
+        mapped_entity_type: In([entityType, 'DEF']),
+      },
+    });
+  }
+  
 }

package/src/module/meta/service/attribute-master.service.ts

@@ -0,0 +1,17 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { In } from "typeorm";
+import { AttributeMasterRepository } from "../repository/attribute-master.repository";
+
+
+@Injectable()
+export class AttributeMasterService {
+  constructor(
+    private readonly attributeMasterRepository: AttributeMasterRepository,
+  ) {}
+
+  async findAttributesByMappedEntityType(entity_type){
+    return await this.attributeMasterRepository.findAttributesByMappedEntityType(entity_type);
+  }
+
+}

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

@@ -155,7 +155,7 @@ export class EntityListService {
                  FROM ${tableName} WHERE 1=1 `;
     const argsObjectList: any[] = [];
     if (parentId) {
-      query += `AND parent_id = ? AND parent_type = ? `;
+      query += ` AND parent_id = ? AND parent_type = ? `;
       argsObjectList.push(parentId);
       argsObjectList.push(parentType);
     }

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

@@ -24,6 +24,13 @@ export class EntityMasterService {
     return entityMaster;
   }
 
+  async getEntityByTableName(tableName: string) {
+    const entityMaster = await this.entityMasterRepository.findOne({  
+      where: { db_table_name: tableName },
+    });
+    return entityMaster;
+  }
+
   async save(entityMaster: EntityMaster) {
     return await this.entityMasterRepository.save(entityMaster);
   }

package/src/module/meta/service/field-group.service.ts

@@ -0,0 +1,104 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from './entity-service-impl.service';
+import { BaseEntity } from '../entity/base-entity.entity';
+import { UserData } from '../../user/entity/user.entity';
+import { EntityManager } from 'typeorm';
+import { ViewMaster } from '../entity/view-master.entity';
+
+@Injectable()
+export class FieldGroupService extends EntityServiceImpl {
+  constructor() {
+    super();
+  }
+
+  async createEntity(
+    entityData: BaseEntity,
+    loggedInUser: UserData | null,
+    manager?: EntityManager,
+  ): Promise<BaseEntity> {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityData.entity_type,
+    );
+    entityData.parent_id = entityMaster.id;
+    entityData.parent_type = entityMaster.entity_type;
+
+    const savedEntity = await super.createEntity(
+      entityData,
+      loggedInUser,
+      manager,
+    );
+    return savedEntity;
+  }
+
+  async updateEntity(
+    entityData: ViewMaster,
+    loggedInUserData: UserData | null,
+  ): Promise<BaseEntity> {
+    return entityData;
+  }
+
+  parseLayout(layoutJson: any) {
+    const stepsData: {
+      stepType: string;
+      stepId: string;
+      stepLabel: string;
+      stepPosition: number;
+      fields: {
+        type: string;
+        label: string;
+        id: string;
+      }[];
+    }[] = [];
+
+    if (layoutJson?.form?.children && Array.isArray(layoutJson.form.children)) {
+      const firstChild = layoutJson.form.children[0];
+      console.log('First Child:', firstChild);
+
+      if (firstChild.type === 'wizard' && Array.isArray(firstChild.steps)) {
+        console.log('Wizard Steps:', firstChild.steps);
+        let i = 0;
+        for (const step of firstChild.steps) {
+          if (step.type === 'step') {
+            const fields = this.extractFields(step.fields);
+
+            stepsData.push({
+              stepType: step.type,
+              stepId: step.id,
+              stepLabel: step.label,
+              stepPosition: ++i,
+              fields: fields,
+            });
+          }
+        }
+      }
+    }
+    return stepsData;
+  }
+
+  extractFields(fieldsArray: any[]): {
+    type: string;
+    label: string;
+    id: string;
+  }[] {
+    const extractedFields: { type: string; label: string; id: string }[] = [];
+
+    function traverse(fields: any[]) {
+      for (const field of fields) {
+        if (field.type === 'field-set') {
+          extractedFields.push({
+            type: field.type,
+            label: field.label || 'No Label',
+            id: field.id || 'No ID',
+          });
+        }
+        if (Array.isArray(field.fields)) {
+          traverse(field.fields); // 📢 Recursive call
+        }
+      }
+    }
+
+    traverse(fieldsArray);
+
+    return extractedFields;
+  }
+}

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

@@ -10,17 +10,16 @@ import { v4 as uuidv4 } from 'uuid';
 @Injectable()
 export class MediaDataService extends EntityServiceImpl {
 
-
   constructor(
     private readonly configService: ConfigService,
     private readonly mediaRepository: MediaDataRepository,
   ) {
     super();
   }
-  
-  s3AccessKeyID=this.configService.get('AWS.S3.AWS_ACCESS_KEY_ID')
-  s3AccessKeySecret=this.configService.get('AWS.S3.AWS_SECRET_KEY')
-  s3Region=this.configService.get('AWS.S3.AWS_REGION')
+
+  s3AccessKeyID = this.configService.get('AWS.S3.AWS_ACCESS_KEY_ID');
+  s3AccessKeySecret = this.configService.get('AWS.S3.AWS_SECRET_KEY');
+  s3Region = this.configService.get('AWS.S3.AWS_REGION');
   bucketName = this.configService.get<string>('AWS.S3.BUCKET_NAME');
 
   s3 = new S3({
@@ -29,15 +28,13 @@ export class MediaDataService extends EntityServiceImpl {
     region: this.s3Region,
     signatureVersion: 'v4',
   });
-  
-  
+
   async generateMediaUploadDetails(
     fileName: string,
     mappedAttributeKey: string,
     mappedEntityType?: string,
     mappedEntityId?: number,
   ) {
-      
     if (!fileName || !mappedAttributeKey) {
       return null;
     }
@@ -45,7 +42,7 @@ export class MediaDataService extends EntityServiceImpl {
 
     const id = uuidv4();
     const s3Key = `uploads/${id}.${ext}`;
-    console.log(s3Key)
+    console.log(s3Key);
 
     const uploadUrl = await this.s3.getSignedUrlPromise('putObject', {
       Bucket: this.bucketName,
@@ -63,6 +60,7 @@ export class MediaDataService extends EntityServiceImpl {
     if (mappedEntityId) {
       mediaData.mapped_entity_id = mappedEntityId;
     }
+    mediaData.media_url = s3Key;
 
     let savedEntity = await super.createEntity(mediaData, null);
 
@@ -115,4 +113,19 @@ export class MediaDataService extends EntityServiceImpl {
     };
     return map[ext] || 'application/octet-stream';
   }
+
+  // New method to get the signed URL for the media (download link)
+  async getMediaDownloadUrl(s3Key: string): Promise<string> {
+    try {
+      const signedUrl = await this.s3.getSignedUrlPromise('getObject', {
+        Bucket: this.bucketName,
+        Key: s3Key,
+        Expires: 60 * 5, // URL valid for 5 mins
+      });
+      return signedUrl;
+    } catch (error) {
+      console.error('Error generating signed URL for media:', error);
+      throw new Error('Failed to generate signed URL');
+    }
+  }
 }