rez_core 2.2.188 → 2.2.189

package/package.json

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

package/src/module/communication/controller/communication.controller.ts

@@ -5,12 +5,15 @@ import {
   Param,
   Post,
   Put,
+  Delete,
   ParseIntPipe,
   HttpStatus,
   HttpCode,
   Query,
+  BadRequestException,
 } from '@nestjs/common';
 import { CommunicationService } from '../service/communication.service';
+import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
 import {
   CreateConfigDto,
   UpdateConfigStatusDto,
@@ -18,6 +21,7 @@ import {
   BulkMessageDto,
   GmailOAuthInitDto,
   OutlookOAuthInitDto,
+  SendGridVerifiedSendersDto,
 } from '../dto/create-config.dto';
 
 export class ScheduledMessageDto extends GenericSendMessageDto {
@@ -27,7 +31,10 @@ export class ScheduledMessageDto extends GenericSendMessageDto {
 
 @Controller('communication')
 export class CommunicationController {
-  constructor(private readonly communicationService: CommunicationService) {}
+  constructor(
+    private readonly communicationService: CommunicationService,
+    private readonly sendGridApiStrategy: SendGridApiStrategy,
+  ) {}
 
   @Post('send')
   @HttpCode(HttpStatus.OK)
@@ -64,16 +71,66 @@ export class CommunicationController {
 
   @Post('config')
   async createConfig(@Body() createConfigDto: CreateConfigDto) {
-    return this.communicationService.createCommunicationConfig(
-      createConfigDto.levelId,
-      createConfigDto.levelType,
-      createConfigDto.configType,
-      createConfigDto.service,
-      createConfigDto.provider,
-      createConfigDto.config,
-      createConfigDto.priority,
-      createConfigDto.is_default,
-    );
+    try {
+      const result = await this.communicationService.createCommunicationConfig(
+        createConfigDto.levelId,
+        createConfigDto.levelType,
+        createConfigDto.configType,
+        createConfigDto.service,
+        createConfigDto.provider,
+        createConfigDto.config,
+        createConfigDto.priority,
+        createConfigDto.is_default,
+      );
+
+      return {
+        success: true,
+        data: result,
+        message: 'Communication configuration created successfully',
+      };
+    } catch (error) {
+      // Handle validation errors with BadRequest status
+      if (
+        error.message?.includes('active') &&
+        error.message?.includes('configuration already exists')
+      ) {
+        throw new BadRequestException({
+          success: false,
+          error: 'DUPLICATE_CONFIGURATION',
+          message: error.message,
+          code: 'VALIDATION_ERROR',
+        });
+      }
+
+      // Handle unsupported combination errors
+      if (error.message?.includes('Unsupported combination')) {
+        throw new BadRequestException({
+          success: false,
+          error: 'UNSUPPORTED_COMBINATION',
+          message: error.message,
+          code: 'VALIDATION_ERROR',
+        });
+      }
+
+      // Handle OAuth redirect responses (return as success with OAuth info)
+      if (error.authUrl && error.state) {
+        return {
+          success: false,
+          requiresOAuth: true,
+          authUrl: error.authUrl,
+          state: error.state,
+          message: error.message || 'OAuth authorization required',
+        };
+      }
+
+      // Handle other errors as BadRequest
+      throw new BadRequestException({
+        success: false,
+        error: 'CONFIGURATION_ERROR',
+        message: error.message || 'Failed to create communication configuration',
+        code: 'INTERNAL_ERROR',
+      });
+    }
   }
 
   @Get('supported-combinations')
@@ -141,4 +198,30 @@ export class CommunicationController {
       initDto.email,
     );
   }
+
+  @Post('sendgrid/verified-senders')
+  @HttpCode(HttpStatus.OK)
+  async getSendGridVerifiedSenders(@Body() dto: SendGridVerifiedSendersDto) {
+    return this.sendGridApiStrategy.getVerifiedSenders(dto.apiKey);
+  }
+
+  @Post('config/delete/:hubId')
+  @HttpCode(HttpStatus.OK)
+  async disconnectConfig(@Param('hubId', ParseIntPipe) hubId: number) {
+    try {
+      await this.communicationService.deleteConfiguration(hubId);
+
+      return {
+        success: true,
+        message: 'Communication configuration deleted successfully',
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'DELETE_ERROR',
+        message: error.message || 'Failed to delete communication configuration',
+        code: 'CONFIGURATION_ERROR',
+      });
+    }
+  }
 }

package/src/module/communication/dto/create-config.dto.ts

@@ -251,3 +251,29 @@ export class OutlookOAuthInitDto {
   @IsString()
   email?: string;
 }
+
+export class SendGridVerifiedSendersDto {
+  @IsNotEmpty()
+  @IsString()
+  apiKey: string;
+}
+
+export class VerifiedSenderDto {
+  @IsString()
+  label: string;
+
+  @IsString()
+  value: string;
+}
+
+export class VerifiedSendersResponseDto {
+  @IsBoolean()
+  success: boolean;
+
+  @IsOptional()
+  data?: VerifiedSenderDto[];
+
+  @IsOptional()
+  @IsString()
+  error?: string;
+}

package/src/module/communication/service/communication.service.ts

@@ -267,6 +267,9 @@ export class CommunicationService {
   ): Promise<
     CommunicationHub | { authUrl: string; state: string; message: string }
   > {
+    // Validate that no active configuration of the same type exists (first check)
+    await this.validateUniqueActiveConfig(levelId, levelType, configType);
+
     // Validate service/provider combination using supported combinations
     const supportedCombinations = await this.getSupportedCombinations();
     const isValidCombination = supportedCombinations.some(
@@ -647,6 +650,25 @@ export class CommunicationService {
     await this.hubRepository.update(hubId, { status });
   }
 
+  async deleteConfiguration(hubId: number): Promise<void> {
+    // Find the hub to get the config_id
+    const hub = await this.hubRepository.findOne({
+      where: { id: hubId },
+    });
+
+    if (!hub) {
+      throw new Error('Communication configuration not found');
+    }
+
+    await this.hubRepository.delete(hubId);
+
+    await this.configRepository.delete(hub.config_id);
+
+    this.logger.log(
+      `Communication configuration deleted: Hub ${hubId}, Config ${hub.config_id}`,
+    );
+  }
+
   async sendGenericMessage(
     messageDto: GenericMessageDto,
   ): Promise<CommunicationResult> {
@@ -1075,6 +1097,7 @@ export class CommunicationService {
         'https://www.googleapis.com/auth/gmail.send',
         'https://www.googleapis.com/auth/gmail.readonly',
         'https://www.googleapis.com/auth/userinfo.email',
+        'https://www.googleapis.com/auth/calendar',
       ];
 
       const authUrl = oauth2Client.generateAuthUrl({
@@ -1153,6 +1176,13 @@ export class CommunicationService {
         expiryDate: tokens.expiry_date,
       };
 
+      // Validate that no active EMAIL configuration exists
+      await this.validateUniqueActiveConfig(
+        oauthState.levelId,
+        oauthState.levelType,
+        CommunicationConfigType.EMAIL,
+      );
+
       // Create communication config
       const communicationConfig = this.configRepository.create({
         config_json: gmailConfig as any,
@@ -1209,6 +1239,13 @@ export class CommunicationService {
         throw new Error('Email mismatch with OAuth hint');
       }
 
+      // Validate that no active EMAIL configuration exists
+      await this.validateUniqueActiveConfig(
+        oauthState.levelId,
+        oauthState.levelType,
+        CommunicationConfigType.EMAIL,
+      );
+
       // Pure SSO configuration - no client credentials stored per user
       const gmailConfig = {
         email: email,
@@ -1298,6 +1335,27 @@ export class CommunicationService {
     return Math.random().toString(36).substring(2) + Date.now().toString(36);
   }
 
+  private async validateUniqueActiveConfig(
+    levelId: number,
+    levelType: string,
+    configType: CommunicationConfigType,
+  ): Promise<void> {
+    const existingActiveConfig = await this.hubRepository.findOne({
+      where: {
+        level_id: levelId,
+        level_type: levelType,
+        communication_config_type: configType,
+        status: 1, // Active status
+      },
+    });
+
+    if (existingActiveConfig) {
+      throw new Error(
+        `An active ${configType} configuration already exists for ${levelType} ${levelId}. Please deactivate the existing configuration first.`,
+      );
+    }
+  }
+
   private requiresOAuthFlow(
     configType: CommunicationConfigType,
     service: string,
@@ -1378,6 +1436,9 @@ export class CommunicationService {
     priority?: number,
     is_default?: boolean,
   ): Promise<CommunicationHub> {
+    // Validate that no active configuration of the same type exists
+    await this.validateUniqueActiveConfig(levelId, levelType, configType);
+
     // If setting as default, remove default from other configurations of same type
     if (is_default) {
       await this.hubRepository.update(
@@ -1537,6 +1598,13 @@ export class CommunicationService {
         throw new Error('Failed to get user email');
       }
 
+      // Validate that no active EMAIL configuration exists
+      await this.validateUniqueActiveConfig(
+        oauthState.levelId,
+        oauthState.levelType,
+        CommunicationConfigType.EMAIL,
+      );
+
       const outlookConfig = {
         clientId,
         tenantId,
@@ -1583,131 +1651,4 @@ export class CommunicationService {
       throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
     }
   }
-
-  // Simple Queue Integration Methods
-
-  async queueMessage(
-    messageDto: GenericMessageDto & { useQueue?: boolean; scheduledFor?: Date },
-  ): Promise<{
-    queued: boolean;
-    messageId?: string;
-    result?: CommunicationResult;
-  }> {
-    if (!this.queueService || !messageDto.useQueue) {
-      // Fallback to immediate sending if queue is not available or not requested
-      const result = await this.sendGenericMessage(messageDto);
-      return { queued: false, result };
-    }
-
-    try {
-      const priority = this.mapPriorityToSimpleQueue(messageDto.priority);
-
-      const messageId = await this.queueService.queueMessage(
-        messageDto.levelId,
-        messageDto.levelType,
-        Array.isArray(messageDto.to) ? messageDto.to[0] : messageDto.to,
-        messageDto.message,
-        messageDto.type,
-        priority,
-        messageDto.scheduledFor,
-        {
-          subject: messageDto.subject,
-          html: messageDto.html,
-          cc: messageDto.cc,
-          bcc: messageDto.bcc,
-          attachments: messageDto.attachments,
-          mediaUrl: messageDto.mediaUrl,
-          templateId: messageDto.templateId,
-          variables: messageDto.variables,
-        },
-      );
-
-      return { queued: true, messageId };
-    } catch (error) {
-      this.logger.error(
-        'Error queuing message, falling back to immediate send:',
-        error.message,
-      );
-      // Fallback to immediate sending
-      const result = await this.sendGenericMessage(messageDto);
-      return { queued: false, result };
-    }
-  }
-
-  async queueBulkMessage(
-    bulkDto: BulkMessageDto & { useQueue?: boolean; scheduledFor?: Date },
-  ): Promise<{ queued: boolean; messageIds?: string[]; result?: any }> {
-    if (!this.queueService || !bulkDto.useQueue) {
-      // Fallback to immediate sending if queue is not available or not requested
-      const result = await this.sendBulkMessage(bulkDto);
-      return { queued: false, result };
-    }
-
-    try {
-      const priority = this.mapPriorityToSimpleQueue(bulkDto.priority) || 'low';
-
-      const messageIds = await this.queueService.queueBulkMessages(
-        bulkDto.levelId,
-        bulkDto.levelType,
-        bulkDto.recipients,
-        bulkDto.message,
-        bulkDto.type,
-        priority,
-        {
-          subject: bulkDto.subject,
-          html: bulkDto.html,
-          templateId: bulkDto.templateId,
-          variables: bulkDto.variables,
-        },
-      );
-
-      return { queued: true, messageIds };
-    } catch (error) {
-      this.logger.error(
-        'Error queuing bulk message, falling back to immediate send:',
-        error.message,
-      );
-      // Fallback to immediate sending
-      const result = await this.sendBulkMessage(bulkDto);
-      return { queued: false, result };
-    }
-  }
-
-  // Helper method to check if queue service is available
-  isQueueAvailable(): boolean {
-    return !!this.queueService;
-  }
-
-  // Helper method to get queue stats if available
-  getQueueStats() {
-    if (!this.queueService) {
-      return null;
-    }
-
-    return this.queueService.getQueueStats();
-  }
-
-  // Helper method to cancel queued messages
-  cancelQueuedMessage(messageId: string): boolean {
-    if (!this.queueService) {
-      return false;
-    }
-
-    return this.queueService.cancelMessage(messageId);
-  }
-
-  private mapPriorityToSimpleQueue(
-    priority?: string,
-  ): 'high' | 'medium' | 'low' {
-    switch (priority?.toLowerCase()) {
-      case 'high':
-      case 'urgent':
-        return 'high';
-      case 'low':
-        return 'low';
-      case 'medium':
-      default:
-        return 'medium';
-    }
-  }
 }

package/src/module/communication/strategies/email/sendgrid-api.strategy.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import * as sgMail from '@sendgrid/mail';
+import axios from 'axios';
 import {
   CommunicationStrategy,
   CommunicationResult,
@@ -114,4 +115,68 @@ export class SendGridApiStrategy implements CommunicationStrategy {
   validateConfig(config: any): boolean {
     return !!(config.apiKey && config.fromEmail);
   }
+
+  async getVerifiedSenders(apiKey: string): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      if (!apiKey) {
+        throw new Error('SendGrid API key is required');
+      }
+
+      const response = await axios.get(
+        'https://api.sendgrid.com/v3/verified_senders',
+        {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+
+      const verifiedSenders = response.data.results || response.data || [];
+
+      // Format the response for dropdown usage with label and value both as from_email
+      const formattedSenders = verifiedSenders
+        .filter((sender: any) => sender.verified === true)
+        .map((sender: any) => {
+          const fromEmail = sender.from_email || sender.email;
+          return {
+            label: fromEmail,
+            value: fromEmail,
+          };
+        });
+
+      return {
+        success: true,
+        data: formattedSenders,
+      };
+    } catch (error) {
+      let errorMessage = 'Failed to fetch verified senders';
+
+      if (error.response?.status === 401) {
+        errorMessage = 'Invalid SendGrid API key';
+      } else if (error.response?.status === 403) {
+        errorMessage = 'SendGrid API key does not have required permissions';
+      } else if (error.response?.data?.errors) {
+        errorMessage = error.response.data.errors
+          .map((err: any) => err.message)
+          .join(', ');
+      } else if (error.response?.data?.message) {
+        errorMessage = error.response.data.message;
+      } else if (error.message) {
+        errorMessage = error.message;
+      }
+
+      return {
+        success: false,
+        error: errorMessage,
+      };
+    }
+  }
 }

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

@@ -1,48 +1,60 @@
-// src/calendar/calendar.service.ts
 import { Injectable } from '@nestjs/common';
-import { createEvent } from 'ics';
-import { CreateInviteDto } from '../dto/ics.dto';
+import { v4 as uuidv4 } from 'uuid';
+import * as moment from 'moment';
 
 @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(),
-    ];
+  private formatUtc(dateIso: string | Date): string {
+    return moment.utc(dateIso).format('YYYYMMDDTHHmmss[Z]');
   }
 
-  async generateIcs(dto: CreateInviteDto): Promise<string> {
-    const startParts = this.toDateParts(dto.startsAt);
+  async generateIcs(dto: any): Promise<string> {
+    const uid = `${uuidv4()}@etherapp.in`;
+    const now = this.formatUtc(new Date());
 
-    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,
-    };
+    const dtStart = this.formatUtc(dto.startsAt);
+    const dtEnd = this.formatUtc(
+      new Date(new Date(dto.startsAt).getTime() + dto.durationMinutes * 60000),
+    );
 
-    return new Promise((resolve, reject) => {
-      createEvent(event, (err, value) => {
-        if (err) reject(err);
+    const organizer = dto.organizerEmail
+      ? `ORGANIZER;CN=${dto.organizerName ?? 'Organizer'}:mailto:${dto.organizerEmail}`
+      : '';
 
-        const base64 = Buffer.from(value, 'utf-8').toString('base64');
-        resolve(base64);
-      });
-    });
+    const attendees = dto.attendees
+      ?.map(
+        (a) =>
+          `ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=${a.partStat ?? 'NEEDS-ACTION'};CN=${a.name};X-NUM-GUESTS=0:mailto:${a.email}`,
+      )
+      .join('\r\n');
+
+    const icsContent = [
+      'BEGIN:VCALENDAR',
+      'PRODID:-//Google Inc//Google Calendar 70.9054//EN',
+      'VERSION:2.0',
+      'CALSCALE:GREGORIAN',
+      'METHOD:REPLY',
+      'BEGIN:VEVENT',
+      `DTSTART:${dtStart}`,
+      `DTEND:${dtEnd}`,
+      `DTSTAMP:${now}`,
+      organizer,
+      `UID:${uid}`,
+      attendees ?? '',
+      `CREATED:${now}`,
+      `DESCRIPTION:${dto.description ?? ''}`,
+      `LAST-MODIFIED:${now}`,
+      `LOCATION:${dto.location ?? 'Google Meet'}`,
+      'SEQUENCE:0',
+      'STATUS:CONFIRMED',
+      `SUMMARY:${dto.title}`,
+      'TRANSP:OPAQUE',
+      'END:VEVENT',
+      'END:VCALENDAR',
+    ]
+      .filter(Boolean)
+      .join('\r\n');
+
+    return Buffer.from(icsContent, 'utf-8').toString('base64');
   }
 }

package/src/module/listmaster/service/list-master.service.ts

@@ -296,16 +296,13 @@ export class ListMasterService {
   async createEntity(entityData: any, loggedInUser: UserData): Promise<any> {
     // Trim and validate name and code
     const name = entityData.name?.trim();
-    const code = entityData.code?.trim();
+    // const code = entityData.code?.trim();
 
-    if (!name || !code) {
-      throw new BadRequestException(
-        'Name and Code are required and cannot be empty',
-      );
+    if (!name) {
+      throw new BadRequestException('Name is required and cannot be empty');
     }
 
     entityData.name = name;
-    entityData.code = code;
     entityData.is_factory = entityData.is_factory || 0;
     entityData.source = entityData.source || 'master';
     entityData.status = entityData.status || 'ACTIVE';

package/src/module/notification/controller/notification.controller.ts

@@ -1,4 +1,12 @@
-import { Body, Controller, Get, Post, Req, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
 import { NotificationsService } from '../service/notification.service';
 
@@ -26,8 +34,18 @@ export class NotificationsController {
 
   @Get('all')
   @UseGuards(JwtAuthGuard)
-  async getNotifications(@Req() req: any) {
+  async getNotifications(@Req() req: any, @Query() filterQuery: any) {
     const loggedInUser = req.user.userData;
-    return this.notificationsService.getAllNotifications(loggedInUser);
+    return this.notificationsService.getAllNotifications(
+      loggedInUser,
+      filterQuery,
+    );
+  }
+
+  @Post('mark-all-read')
+  @UseGuards(JwtAuthGuard)
+  async markAllAsRead(@Req() req: any) {
+    const loggedInUser = req.user.userData;
+    return this.notificationsService.markAllAsRead(loggedInUser);
   }
 }