rez_core 2.2.109 → 2.2.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.2.109",
+  "version": "2.2.111",
   "description": "",
   "author": "",
   "private": false,
@@ -43,6 +43,7 @@
     "dotenv": "^16.4.7",
     "exceljs": "^4.4.0",
     "handlebars": "^4.7.8",
+    "ics": "^3.8.1",
     "moment": "^2.30.1",
     "moment-timezone": "^0.6.0",
     "multer": "^1.4.5-lts.2",

package/src/app.module.ts

@@ -14,6 +14,7 @@ import { FilterModule } from './module/filter/filter.module';
 import { LeadModule } from './module/lead/lead.module';
 import { LayoutPreferenceModule } from './module/layout_preference/layout_preference.module';
 import { WorkflowModule } from './module/workflow/workflow.module';
+import { IcsMeetingModule } from './module/ics/ics.module';
 
 @Module({
   imports: [
@@ -32,6 +33,7 @@ import { WorkflowModule } from './module/workflow/workflow.module';
     LeadModule,
     LayoutPreferenceModule,
     WorkflowModule,
+    IcsMeetingModule,
   ],
 })
 export class AppModule {}

package/src/constant/global.constant.ts

@@ -14,6 +14,8 @@ export const ENTITYTYPE_FIELDMASTER = 'FLD';
 export const ENTITYTYPE_USRROLMAP = 'URM';
 export const ENTITYTYPE_SAVEDFILTERMASTER = 'SFM';
 export const ENTITYTYPE_SAVEDFILTERDETAIL = 'SFD';
+export const ENTITYTYPE_ENTITY_RELATION = 'ENR';
+export const ENTITYTYPE_ENTITY_RELATION_DATA = 'ERD';
 
 export const STORAGETYPE_SINGLEJSON = 'singlejson';
 export const STORAGETYPE_COLUMN = 'column';

package/src/module/ics/controller/ics.controller.ts

@@ -0,0 +1,21 @@
+// src/calendar/calendar.controller.ts
+import { Body, Controller, Post, Res, UseGuards } from '@nestjs/common';
+import { Response } from 'express';
+import { IcsMeetingService } from '../service/ics.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { CreateInviteDto } from '../dto/ics.dto';
+
+@Controller('/ics')
+export class IcsMeetingController {
+  constructor(private readonly calendarService: IcsMeetingService) {}
+
+  // Download ICS file
+  @Post('/create')
+  @UseGuards(JwtAuthGuard)
+  async getIcs(@Body() dto: CreateInviteDto, @Res() res: Response) {
+    const ics = await this.calendarService.generateIcs(dto);
+    res.setHeader('Content-Type', 'text/calendar; charset=utf-8');
+    res.setHeader('Content-Disposition', 'attachment; filename="invite.ics"');
+    return res.send(ics);
+  }
+}

package/src/module/ics/dto/ics.dto.ts

@@ -0,0 +1,55 @@
+// src/calendar/dto/create-invite.dto.ts
+import {
+  IsArray,
+  IsEmail,
+  IsISO8601,
+  IsOptional,
+  IsString,
+  IsInt,
+  MinLength,
+  ValidateNested,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+import { BaseEntity } from 'src/module/meta/entity/base-entity.entity';
+
+class IcsMeetingDto extends BaseEntity {
+  @IsString() name: string;
+  @IsEmail() email: string;
+}
+
+export class CreateInviteDto {
+  @IsString()
+  @MinLength(3)
+  title: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsISO8601()
+  startsAt: string; // ISO string e.g. "2025-08-30T10:00:00+05:30"
+
+  @IsInt()
+  durationMinutes: number;
+
+  @IsString()
+  @IsOptional()
+  meetingUrl?: string;
+
+  @IsString()
+  @IsOptional()
+  location?: string;
+
+  @IsString()
+  @IsOptional()
+  organizerName?: string;
+
+  @IsEmail()
+  @IsOptional()
+  organizerEmail?: string;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => IcsMeetingDto)
+  attendees: IcsMeetingDto[];
+}

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

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { IcsMeetingService } from './service/ics.service';
+import { IcsMeetingController } from './controller/ics.controller';
+import { CreateInviteDto } from './dto/ics.dto';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([CreateInviteDto])],
+  controllers: [IcsMeetingController],
+  providers: [IcsMeetingService],
+  exports: [IcsMeetingService],
+})
+export class IcsMeetingModule {}

package/src/module/ics/service/ics.service.ts

@@ -0,0 +1,48 @@
+// src/calendar/calendar.service.ts
+import { Injectable } from '@nestjs/common';
+import { createEvent } from 'ics';
+import { CreateInviteDto } from '../dto/ics.dto';
+
+@Injectable()
+export class IcsMeetingService {
+  private toDateParts(iso: string): number[] {
+    const d = new Date(iso);
+    return [
+      d.getUTCFullYear(),
+      d.getUTCMonth() + 1,
+      d.getUTCDate(),
+      d.getUTCHours(),
+      d.getUTCMinutes(),
+    ];
+  }
+
+  async generateIcs(dto: CreateInviteDto): Promise<string> {
+    const startParts = this.toDateParts(dto.startsAt);
+
+    const event: any = {
+      start: startParts,
+      duration: {
+        hours: Math.floor(dto.durationMinutes / 60),
+        minutes: dto.durationMinutes % 60,
+      },
+      title: dto.title,
+      description: dto.description ?? '',
+      location: dto.location ?? 'Online',
+      url: dto.meetingUrl,
+      organizer: dto.organizerEmail
+        ? { name: dto.organizerName ?? 'Organizer', email: dto.organizerEmail }
+        : undefined,
+      attendees: dto.attendees?.map((a) => ({ name: a.name, email: a.email })),
+      status: 'CONFIRMED' as const,
+    };
+
+    return new Promise((resolve, reject) => {
+      createEvent(event, (err, value) => {
+        if (err) reject(err);
+
+        const base64 = Buffer.from(value, 'utf-8').toString('base64');
+        resolve(base64);
+      });
+    });
+  }
+}

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

@@ -1,83 +1,99 @@
 import {
-    Body,
-    Controller,
-    Get,
-    Param,
-    Post,
-    Query,
-    Req,
-    BadRequestException,
-    NotFoundException,
-    HttpCode,
-    HttpStatus,
-    UseGuards,
-  } from '@nestjs/common';
-  import { Request } from 'express';
-  import { EntityDynamicService } from '../service/entity-dynamic.service';
-  import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
-  
-  @UseGuards(JwtAuthGuard)
-  @Controller('dynamic-entity')
-  export class EntityDynamicController {
-    constructor(private readonly entityDynamicService: EntityDynamicService) {}
-  
-    @Post('create')
-    @HttpCode(HttpStatus.OK)
-    async createEntity(
-      @Body() data: Record<string, any>,
-      @Query('entity_type') entityType: string,
-      @Req() req: Request & { user: any },
-    ) {
-      const loggedInUser = req.user.userData;
-  
-      if (!entityType) {
-        throw new BadRequestException(`Query param "entity_type" is required`);
-      }
-  
-      return await this.entityDynamicService.createEntity(entityType, data, loggedInUser);
+  Body,
+  Controller,
+  Get,
+  Param,
+  Post,
+  Query,
+  Req,
+  BadRequestException,
+  NotFoundException,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
+import { Request } from 'express';
+import { EntityDynamicService } from '../service/entity-dynamic.service';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+
+@UseGuards(JwtAuthGuard)
+@Controller('dynamic-entity')
+export class EntityDynamicController {
+  constructor(private readonly entityDynamicService: EntityDynamicService) {}
+
+  @Post('create')
+  @HttpCode(HttpStatus.OK)
+  async createEntity(
+    @Body() data: Record<string, any>,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(`Query param "entity_type" is required`);
     }
-  
-    @Post('update/:id')
-    @HttpCode(HttpStatus.OK)
-    async updateEntity(
-      @Param('id') id: number,
-      @Body() data: Record<string, any>,
-      @Query('entity_type') entityType: string,
-      @Req() req: Request & { user: any },
-    ) {
-      const loggedInUser = req.user.userData;
-  
-      if (!entityType) {
-        throw new BadRequestException(`Query param "entity_type" is required`);
-      }
-  
-      const existingEntity = await this.entityDynamicService.getEntity(entityType, id, loggedInUser);
-      if (!existingEntity) {
-        throw new NotFoundException(`No entity found for id "${id}"`);
-      }
-  
-      return await this.entityDynamicService.updateEntity(entityType, id, data, loggedInUser);
+
+    return await this.entityDynamicService.createEntityWithRelation(
+      entityType,
+      data,
+      loggedInUser,
+    );
+  }
+
+  @Post('update/:id')
+  @HttpCode(HttpStatus.OK)
+  async updateEntity(
+    @Param('id') id: number,
+    @Body() data: Record<string, any>,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(`Query param "entity_type" is required`);
+    }
+
+    const existingEntity = await this.entityDynamicService.getEntity(
+      entityType,
+      id,
+      loggedInUser,
+    );
+    if (!existingEntity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
+    }
+
+    return await this.entityDynamicService.updateEntityWithRelations(
+      entityType,
+      id,
+      data,
+      loggedInUser,
+    );
+  }
+
+  @Get('get/:id')
+  @HttpCode(HttpStatus.OK)
+  async getEntity(
+    @Param('id') id: number,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(`Query param "entity_type" is required`);
     }
-  
-    @Get('get/:id')
-    @HttpCode(HttpStatus.OK)
-    async getEntity(
-      @Param('id') id: number,
-      @Query('entity_type') entityType: string,
-      @Req() req: Request & { user: any },
-    ) {
-      const loggedInUser = req.user.userData;
-  
-      if (!entityType) {
-        throw new BadRequestException(`Query param "entity_type" is required`);
-      }
-  
-      const entity = await this.entityDynamicService.getEntity(entityType, id, loggedInUser);
-      if (!entity) {
-        throw new NotFoundException(`No entity found for id "${id}"`);
-      }
-  
-      return entity;
+
+    const entity = await this.entityDynamicService.getEntityWithRelation(
+      entityType,
+      id,
+      loggedInUser,
+    );
+    if (!entity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
     }
+
+    return entity;
   }
-  
+}

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

@@ -0,0 +1,31 @@
+import {
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Request,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+import { EntityRelationService } from '../service/entity-relation.service';
+
+@UseGuards(JwtAuthGuard)
+@Controller('entity-relation')
+export class EntityRelationController {
+  constructor(
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+  ) {}
+
+  @Get(':source_entity_type')
+  async getEntityRelations(
+    @Param('source_entity_type') sourceEntityType: string,
+    @Request() req: any,
+  ): Promise<any> {
+    const loggedInUser = req.user.userData;
+    return this.entityRelationService.getEntityRelations(
+      sourceEntityType,
+      loggedInUser,
+    );
+  }
+}

package/src/module/meta/entity/entity-relation-data.entity.ts

@@ -0,0 +1,29 @@
+import { ENTITYTYPE_ENTITY_RELATION_DATA } from 'src/constant/global.constant';
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from './base-entity.entity';
+
+@Entity({ name: 'cr_entity_relation_data' })
+export class EntityRelationData extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_ENTITY_RELATION_DATA;
+  }
+
+  @Column({ nullable: true })
+  source_entity_type: string;
+
+  @Column({ nullable: true })
+  source_entity_id: number;
+
+  @Column({ nullable: true })
+  target_entity_type: string;
+
+  @Column({ nullable: true })
+  target_entity_id: number;
+
+  @Column({ nullable: true })
+  relation_type: string;
+
+  @Column({ nullable: true })
+  relation_id: number;
+}

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

@@ -0,0 +1,29 @@
+import { ENTITYTYPE_ENTITY_RELATION } from 'src/constant/global.constant';
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from './base-entity.entity';
+
+@Entity({ name: 'cr_entity_relation' })
+export class EntityRelation extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = ENTITYTYPE_ENTITY_RELATION;
+  }
+
+  @Column({ nullable: true })
+  source_entity_type: string;
+
+  @Column({ nullable: true })
+  source_entity_id: number;
+
+  @Column({ nullable: true })
+  target_entity_type: string;
+
+  @Column({ nullable: true })
+  target_entity_id: number;
+
+  @Column({ nullable: true })
+  relation_type: string;
+
+  @Column({ nullable: true })
+  relation_id: number;
+}

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

@@ -50,6 +50,11 @@ import { AttributeMasterController } from './controller/attribute-master.control
 import { EntityDynamicController } from './controller/entity-dynamic.controller';
 import { EntityDynamicService } from './service/entity-dynamic.service';
 import { ResolverService } from './service/resolver.service';
+import { EntityRelation } from './entity/entity-relation.entity';
+import { EntityRelationData } from './entity/entity-relation-data.entity';
+import { EntityRelationService } from './service/entity-relation.service';
+import { EntityRelationDataService } from './service/entity-realation-data.service';
+import { EntityRelationController } from './controller/entity-relation.controller';
 
 @Module({
   imports: [
@@ -62,8 +67,9 @@ import { ResolverService } from './service/resolver.service';
       MediaData,
       ViewMaster,
       UserRoleMapping,
-      AppMaster
-     
+      AppMaster,
+      EntityRelation,
+      EntityRelationData,
     ]),
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
@@ -91,12 +97,18 @@ import { ResolverService } from './service/resolver.service';
     ViewMaterRespository,
     EntityValidationService,
     { provide: 'ViewMasterService', useClass: ViewMasterService },
+    { provide: 'EntityRelationService', useClass: EntityRelationService },
+    {
+      provide: 'EntityRelationDataService',
+      useClass: EntityRelationDataService,
+    },
+
     // UserAppMappingService,
     // UserAppMappingRepository,
     UserRoleMappingRepository,
     AppMasterRespository,
     AppMasterService,
-    ResolverService
+    ResolverService,
   ],
   exports: [
     EntityMasterService,
@@ -116,7 +128,7 @@ import { ResolverService } from './service/resolver.service';
     // UserAppMappingRepository,
     AppMasterService,
     MasterService,
-ResolverService
+    ResolverService,
   ],
   controllers: [
     EntityController,
@@ -127,6 +139,7 @@ ResolverService
     AppMasterController,
     AttributeMasterController,
     EntityDynamicController,
+    EntityRelationController,
   ],
 })
 export class EntityModule {}