rez_core 1.0.60 → 1.0.62

package/package.json

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

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

@@ -6,7 +6,7 @@ export class EnterpriseData {
   id: number;
 
   @Column({ name: 'entity_type', type: 'varchar', nullable: true, length: 50 })
-  entityType: string;
+  entity_type: string;
 
   @Column({ name: 'code', type: 'varchar', nullable: true, length: 50 })
   code: string;
@@ -18,20 +18,20 @@ export class EnterpriseData {
   status: string;
 
   @Column({ name: 'created_by', type: 'int', nullable: true })
-  createdBy: number;
+  created_by: number;
 
   @Column({ name: 'modified_by', type: 'int', nullable: true })
-  modifiedBy: number;
+  modified_by: number;
 
   @Column({ name: 'created_date', type: 'datetime', nullable: true })
-  createdDate: Date;
+  created_date: Date;
 
   @Column({ name: 'modified_date', type: 'datetime', nullable: true })
-  modifiedDate: Date;
+  modified_date: Date;
 
   @Column({ name: 'app_code', type: 'varchar', nullable: true, length: 50 })
-  appCode: string;
+  app_code: string;
 
   @Column({ name: 'app_url_name', type: 'varchar', nullable: true, length: 50 })
-  appUrlName: string;
+  app_url_name: string;
 }

package/src/module/enterprise/repository/enterprise.repository.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { EnterpriseData } from '../entity/enterprise.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class EnterpriseRepository {
+  constructor(
+    @InjectRepository(EnterpriseData)
+    private readonly enterpriseRepository: Repository<EnterpriseData>,
+  ) {}
+
+  async save(enterpriseData: EnterpriseData) {
+    enterpriseData.created_date = new Date();
+    return await this.enterpriseRepository.save(enterpriseData);
+  }
+
+  async update(enterpriseData: EnterpriseData): Promise<EnterpriseData | null> {
+    const existingEnterprise = await this.enterpriseRepository.findOne({
+      where: { id: enterpriseData.id },
+    });
+    if (!existingEnterprise) {
+      throw new Error(`Enterprise with id ${enterpriseData.id} not found`);
+    }
+    enterpriseData.modified_date = new Date();
+    await this.enterpriseRepository.update(enterpriseData.id, enterpriseData);
+    return await this.enterpriseRepository.findOne({
+      where: { id: enterpriseData.id },
+    });
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+import { EnterpriseRepository } from '../repository/enterprise.repository';
+import { EnterpriseData } from '../entity/enterprise.entity';
+
+@Injectable()
+export class EnterpriseService {
+  constructor(private readonly enterpriseRepository: EnterpriseRepository) {}
+
+  async create(enterpriseData: EnterpriseData): Promise<EnterpriseData> {
+    return await this.enterpriseRepository.save(enterpriseData);
+  }
+
+  async update(enterpriseData: EnterpriseData): Promise<EnterpriseData|null> {
+    return await this.enterpriseRepository.update(enterpriseData);
+  }
+}

package/src/module/meta/controller/view-master.controller.ts

@@ -0,0 +1,48 @@
+import {
+    Controller,
+    Get,
+    Query,
+    Res,
+    HttpStatus,
+    UseGuards,
+    Inject,
+  } from '@nestjs/common';
+  import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+  import { Response } from 'express';
+import { ViewMasterService } from '../service/view-master.service';
+  
+  @Controller('entity')
+  @UseGuards(JwtAuthGuard)
+  export class ViewMasterController {
+    constructor(@Inject("ViewMasterService") private  readonly viewMaster: ViewMasterService) {}
+  
+    @Get('viewMaster')
+    async getEntityJsonByType(
+      @Query('entity_type') entityType: string,
+      @Query('type') type:string,
+      @Res() res: Response,
+    ) {
+      try {
+        if (!entityType || !type) {
+          return res.status(HttpStatus.BAD_REQUEST).json({
+            success: false,
+            message: 'Missing entity_type or type query parameter',
+          });
+        }
+  
+        const result = await this.viewMaster.getEntityJson(entityType, type);
+  
+        return res.status(HttpStatus.OK).json({
+          success: true,
+          message: 'Entity data fetched successfully',
+          data: result,
+        });
+      } catch (error) {
+        return res.status(HttpStatus.INTERNAL_SERVER_ERROR).json({
+          success: false,
+          message: error.message || 'Error fetching entity data',
+        });
+      }
+    }
+  }
+  

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

@@ -24,6 +24,12 @@ export class ViewMaster extends BaseEntity {
   @Column({type: 'json', nullable: true})
   published_form_fields: string;
 
+  @Column({type: 'json',nullable:true})
+  meta_json:string;
+
+  @Column({ nullable:true})
+  type: string;
+
   @Column({type: 'int'})
   is_default: number;
 }

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

@@ -32,6 +32,8 @@ 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';
+import { ViewMasterController } from './controller/view-master.controller';
+import { ViewMaterRespository } from './repository/view-master.repository';
 
 @Module({
   imports: [
@@ -67,6 +69,7 @@ import { ViewMasterService } from './service/view-master.service';
     AttributeMasterService,
     SectionMasterService,
     FieldGroupService,
+    ViewMaterRespository,
     { provide: 'ViewMasterService', useClass: ViewMasterService },
   ],
   exports: [
@@ -81,6 +84,6 @@ import { ViewMasterService } from './service/view-master.service';
     FieldGroupService,
     'ViewMasterService',
   ],
-  controllers: [EntityController, MasterController, MediaController],
+  controllers: [EntityController, MasterController, MediaController, ViewMasterController],
 })
 export class EntityModule {}

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

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { BaseEntity, Repository } from 'typeorm';
+import { ViewMaster } from '../entity/view-master.entity';
+
+@Injectable()
+export class ViewMaterRespository {
+  constructor(
+    @InjectRepository(ViewMaster)
+    private readonly viewMasterRepository: Repository<ViewMaster>,
+  ) {}
+
+  async getEntityJson(
+    entityType: string,
+    type: string,
+  ): Promise<ViewMaster | null> {
+    const viewMaster = await this.viewMasterRepository.findOneBy({
+      mapped_entity_type: entityType,
+      type: type,
+    });
+  
+    return viewMaster;
+  }
+}

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

@@ -148,8 +148,8 @@ export class EntityListService {
 
   public async getMaxSequenceNumber(
     tableName: string,
-    parentType: string,
-    parentId: number,
+    parentType: string | null,
+    parentId: number | null,
   ) {
     let query = `SELECT COUNT(1) seq_no
                  FROM ${tableName} WHERE 1=1 `;

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

@@ -10,18 +10,22 @@ export class EntityMasterService {
     private entityMasterRepository: Repository<EntityMaster>,
   ) {}
 
-  async getEntityData(mappedEntityType: string): Promise<EntityMaster> {
-    const entityMaster = await this.entityMasterRepository.findOne({
-      where: { mapped_entity_type: mappedEntityType },
-    });
-
-    if (!entityMaster) {
-      throw new Error(
-        `Entity with mappedEntityType "${mappedEntityType}" not found.`,
-      );
+  async getEntityData(mappedEntityType: string|null): Promise<EntityMaster> {
+    if (mappedEntityType) {
+      const entityMaster = await this.entityMasterRepository.findOne({
+        where: { mapped_entity_type: mappedEntityType },
+      });
+
+      if (!entityMaster) {
+        throw new Error(
+          `Entity with mappedEntityType "${mappedEntityType}" not found.`,
+        );
+      }
+
+      return entityMaster;
+    } else {
+      throw new Error();
     }
-
-    return entityMaster;
   }
 
   async getEntityByTableName(tableName: string) {

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

@@ -8,17 +8,19 @@ import { SectionMasterService } from './section-master.service';
 import { SectionMaster } from '../entity/section-master.entity';
 import { FieldGroup } from '../entity/field-group.entity';
 import { FieldGroupService } from './field-group.service';
+import { ViewMaterRespository } from '../repository/view-master.repository';
 @Injectable()
 export class ViewMasterService extends EntityServiceImpl {
   constructor(
     private readonly sectionMasterService: SectionMasterService,
     private readonly fieldGroupService: FieldGroupService,
+    private readonly viewMasterRepoService: ViewMaterRespository
   ) {
     super();
   }
 
   async createEntity(
-    entityData: BaseEntity,
+    entityData: ViewMaster,
     loggedInUser: UserData | null,
     manager?: EntityManager,
   ): Promise<BaseEntity> {
@@ -33,40 +35,45 @@ export class ViewMasterService extends EntityServiceImpl {
       loggedInUser,
       manager,
     );
-    let viewMaster = savedEntity as ViewMaster;
 
-    let layout = viewMaster.published_form_layout;
+    let viewMaster = savedEntity as ViewMaster;
+    if (entityData.type === 'form') {
+      let layout = viewMaster.published_form_layout;
 
-    const stepsData = this.sectionMasterService.parseLayout(layout);
-    for (var step of stepsData) {
-      let sectionMaster = new SectionMaster();
-      sectionMaster.name = step.stepLabel;
-      sectionMaster.position = step.stepPosition;
-      sectionMaster.description = step.stepLabel;
-      sectionMaster.parent_id = viewMaster.id;
-      sectionMaster.parent_type = viewMaster.entity_type;
+      const stepsData = this.sectionMasterService.parseLayout(layout);
+      for (var step of stepsData) {
+        let sectionMaster = new SectionMaster();
+        sectionMaster.name = step.stepLabel;
+        sectionMaster.position = step.stepPosition;
+        sectionMaster.description = step.stepLabel;
+        sectionMaster.parent_id = viewMaster.id;
+        sectionMaster.parent_type = viewMaster.entity_type;
 
-      const savedSectionMaster = await this.sectionMasterService.createEntity(
-        sectionMaster,
-        loggedInUser,
-        manager,
-      );
+        const savedSectionMaster = await this.sectionMasterService.createEntity(
+          sectionMaster,
+          loggedInUser,
+          manager,
+        );
 
-      const fieldGroups = step.fieldsGroup;
-      console.log('fieldGroups', fieldGroups);
+        const fieldGroups = step.fieldsGroup;
+        console.log('fieldGroups', fieldGroups);
 
-      for (var fieldGroup of fieldGroups) {
-        let fieldsGroup = new FieldGroup();
-        fieldsGroup.view_id = viewMaster.id;
-        fieldsGroup.parent_id = savedSectionMaster.id;
-        fieldsGroup.field_type = fieldGroup.type;
-        fieldsGroup.label = fieldGroup.label;
-        fieldsGroup.description = fieldGroup.label;
+        for (var fieldGroup of fieldGroups) {
+          let fieldsGroup = new FieldGroup();
+          fieldsGroup.view_id = viewMaster.id;
+          fieldsGroup.parent_id = savedSectionMaster.id;
+          fieldsGroup.field_type = fieldGroup.type;
+          fieldsGroup.label = fieldGroup.label;
+          fieldsGroup.description = fieldGroup.label;
 
-        this.fieldGroupService.createEntity(fieldsGroup, loggedInUser, manager);
+          this.fieldGroupService.createEntity(
+            fieldsGroup,
+            loggedInUser,
+            manager,
+          );
+        }
       }
-    }
-
+    } 
     return savedEntity;
   }
 
@@ -76,4 +83,20 @@ export class ViewMasterService extends EntityServiceImpl {
   ): Promise<BaseEntity> {
     return entityData;
   }
+
+  async getEntityJson(entityType: string, type: string) {
+
+    const res=  await this.viewMasterRepoService.getEntityJson(entityType,type)
+    
+    if(type=="form"){
+      return {
+        formLayoutJson:res?.published_form_layout,
+        formFieldJson:res?.published_form_fields
+      }
+    }else{
+      return {
+        metaJson:res?.meta_json
+      }
+    }
+  }
 }

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

@@ -8,9 +8,7 @@ import { UserData } from '../../user/entity/user.entity';
 @Controller('module-access')
 @UseGuards(JwtAuthGuard)
 export class ModuleAccessController {
-  constructor(private readonly moduleAccessService: ModuleAccessService,
-              @Inject('UserService') private readonly userService: UserService,
-              ) {}
+  constructor(private readonly moduleAccessService: ModuleAccessService) {}
 
   @Get('roles')
   async getRoles() {
@@ -39,39 +37,7 @@ export class ModuleAccessController {
     return this.moduleAccessService.updateModuleAccess(moduleAccessData);
   }
 
-  @Post('create-role')
-  async createRole(
-    @Body()
-    body: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    @Req() req: Request & {user: any}
-  ) {
-
-    let requestedUser = req.user;
-    let loggedInUser = await this.userService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
-    return this.moduleAccessService.createRole(body, loggedInUser as UserData);
-  }
-
-  @Post('update-role/:id')
-  async updateRole(
-    @Param('id') id: number,
-    @Body()
-    body: {
-      name?: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number; // <-- ADD THIS
-    },
-    @Req() req: Request & {user: any}
-  ) {
-    let requestedUser = req.user;
-    let loggedInUser = await this.userService.getEntityData(ENTITYTYPE_USER,requestedUser.id);
-    return this.moduleAccessService.updateRole(id, body, loggedInUser as UserData);
-  }
+  
   
 
 }

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

@@ -19,7 +19,6 @@ export class ModuleAccessRepository {
     private readonly moduleAccessRepo: Repository<ModuleAccess>,
     @InjectRepository(ModuleAction)
     private readonly moduleActionRepo: Repository<ModuleAction>,
-    private readonly clockIDGenService: ClockIDGenService,
   ) {}
 
   async getRoles() {
@@ -141,155 +140,5 @@ export class ModuleAccessRepository {
     }
   }
 
-  async createRole(
-    {
-      name,
-      description,
-      status = 'ACTIVE',
-      copyFromRoleId,
-    }: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    if (await this.isRoleNameExists(name)) {
-      throw new BadRequestException('Role name already exists.');
-    }
-
-    const sourceRole = copyFromRoleId
-      ? await this.roleRepo.findOne({ where: { id: copyFromRoleId } })
-      : null;
-
-    if (copyFromRoleId && !sourceRole) {
-      throw new BadRequestException('Source role not found.');
-    }
-
-    const newRole = this.roleRepo.create({
-      name,
-      description,
-      status,
-      created_by: loggedInUser.id,
-      created_date: new Date(),
-    });
-
-    const savedRole = await this.roleRepo.save(newRole);
-    savedRole.code = `ROL${savedRole.id}`;
-    await this.roleRepo.save(savedRole);
-
-    if (sourceRole) {
-      const sourcePermissions = await this.moduleAccessRepo.find({
-        where: { role_code: sourceRole.code },
-      });
-
-      const clonedPermissions = sourcePermissions.map(perm =>
-        this.moduleAccessRepo.create({
-          role_code: savedRole.code,
-          module_code: perm.module_code,
-          action_type: perm.action_type,
-          access_flag: perm.access_flag,
-          app_code: perm.app_code,
-        }),
-      );
-
-      await this.moduleAccessRepo.save(clonedPermissions);
-    }
-
-    return {
-      success: true,
-      msg: 'Role created successfully',
-      role: {
-        id: savedRole.id,
-        name: savedRole.name,
-        status: savedRole.status,
-        code: savedRole.code,
-      },
-    };
-  }
-
-  async updateRole(
-    roleId: number,
-    {
-      name,
-      description,
-      status = 'ACTIVE',
-      copyFromRoleId,
-    }: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    if (await this.isRoleNameExists(name, roleId)) {
-      throw new BadRequestException('Role name already exists.');
-    }
-
-    const role = await this.roleRepo.findOne({ where: { id: roleId } });
-    if (!role) {
-      throw new BadRequestException('Role not found');
-    }
 
-    Object.assign(role, {
-      name,
-      description: description || '',
-      status,
-      modified_by: loggedInUser.id,
-      modified_date: new Date(),
-    });
-
-    await this.roleRepo.save(role);
-
-    if (copyFromRoleId) {
-      const sourceRole = await this.roleRepo.findOne({ where: { id: copyFromRoleId } });
-      if (!sourceRole) {
-        throw new BadRequestException('Source role not found');
-      }
-
-      await this.moduleAccessRepo.delete({ role_code: role.code });
-
-      const sourcePermissions = await this.moduleAccessRepo.find({
-        where: { role_code: sourceRole.code },
-      });
-
-      const clonedPermissions = sourcePermissions.map(perm =>
-        this.moduleAccessRepo.create({
-          role_code: role.code,
-          module_code: perm.module_code,
-          action_type: perm.action_type,
-          access_flag: perm.access_flag,
-          app_code: perm.app_code,
-        }),
-      );
-
-      await this.moduleAccessRepo.save(clonedPermissions);
-    }
-
-    return {
-      success: true,
-      msg: 'Role updated successfully',
-      role: {
-        id: role.id,
-        name: role.name,
-        status: role.status,
-        code: role.code,
-      },
-    };
-  }
-
-  private async isRoleNameExists(name: string, excludeRoleId?: number): Promise<boolean> {
-    const query = this.roleRepo
-      .createQueryBuilder('role')
-      .where('role.name = :name', { name });
-
-    if (excludeRoleId) {
-      query.andWhere('role.id != :excludeRoleId', { excludeRoleId });
-    }
-
-    const existingRole = await query.getOne();
-    return !!existingRole;
-  }
 }

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

@@ -11,8 +11,6 @@ import { UserData } from 'src/module/user/entity/user.entity';
 export class ModuleAccessService {
   constructor(
     private readonly moduleAccessRepository: ModuleAccessRepository,
-    @Inject('RoleService') private readonly roleService: RoleService,
-    private readonly entityManager: EntityManager,
   ) {}
 
   async getRoles() {
@@ -48,64 +46,5 @@ export class ModuleAccessService {
     }
   }
 
-  async createRole(
-    body: {
-      name: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    return this.moduleAccessRepository.createRole(body, loggedInUser);
-  }
-
-  async updateRole(
-    id: number,
-    body: {
-      name?: string;
-      description?: string;
-      status?: 'ACTIVE' | 'INACTIVE';
-      copyFromRoleId?: number;
-    },
-    loggedInUser: UserData,
-  ) {
-    if (!body.name) {
-      throw new BadRequestException('Role name is required');
-    }
-
-    if (body.status === 'INACTIVE') {
-      //get role by id
-      const entityData = await this.roleService.getEntityData(
-        ENTITYTYPE_ROLE,
-        id,
-      );
-
-      const associatedUsers = await this.entityManager.query(`SELECT 	map.* 
-      FROM 	cr_user_role_mapping map 
-		  JOIN cr_user usr ON map.user_id = usr.id
-      WHERE usr.status = 'ACTIVE' and map.role_id = ${entityData?.id}`);
-
-      if (associatedUsers.length > 0) {
-        throw new BadRequestException(
-          'Cannot deactivate role as it is associated with active users',
-        );
-      }
-
-      if (!entityData) {
-        throw new BadRequestException('Role not found');
-      }
-      const role = entityData as Role;
-      if (role.is_system === 1) {
-        throw new BadRequestException('Cannot deactivate system role');
-      }
-    }
-
-    return this.moduleAccessRepository.updateRole(id, {
-      name: body.name,
-      description: body.description,
-      status: body.status,
-      copyFromRoleId: body.copyFromRoleId,
-    }, loggedInUser);
-  }
+  
 }