rez_core 2.2.192 → 2.2.193

package/package.json

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

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

@@ -12,7 +12,6 @@ import {
   Query,
 } from '@nestjs/common';
 import { CommunicationService } from '../service/communication.service';
-import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
 import {
   BulkMessageDto,
   CreateConfigDto,
@@ -20,6 +19,7 @@ import {
   GmailOAuthInitDto,
   OutlookOAuthInitDto,
   SendGridVerifiedSendersDto,
+  SendGridTemplatesDto,
   UpdateConfigDto,
   UpdateConfigStatusDto,
 } from '../dto/create-config.dto';
@@ -33,7 +33,6 @@ export class ScheduledMessageDto extends GenericSendMessageDto {
 export class CommunicationController {
   constructor(
     private readonly communicationService: CommunicationService,
-    private readonly sendGridApiStrategy: SendGridApiStrategy,
   ) {}
 
   @Post('send')
@@ -232,7 +231,19 @@ export class CommunicationController {
   @Post('sendgrid/verified-senders')
   @HttpCode(HttpStatus.OK)
   async getSendGridVerifiedSenders(@Body() dto: SendGridVerifiedSendersDto) {
-    return this.sendGridApiStrategy.getVerifiedSenders(dto.apiKey);
+    return this.communicationService.getSendGridVerifiedSenders(
+      dto.levelId,
+      dto.levelType,
+    );
+  }
+
+  @Post('sendgrid/templates')
+  @HttpCode(HttpStatus.OK)
+  async getSendGridTemplates(@Body() dto: SendGridTemplatesDto) {
+    return this.communicationService.getSendGridTemplates(
+      dto.levelId,
+      dto.levelType,
+    );
   }
 
   @Post('config/delete/:hubId')

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

@@ -324,9 +324,23 @@ export class OutlookOAuthInitDto {
 }
 
 export class SendGridVerifiedSendersDto {
+  @IsNotEmpty()
+  @IsNumber()
+  levelId: number;
+
+  @IsNotEmpty()
+  @IsString()
+  levelType: string;
+}
+
+export class SendGridTemplatesDto {
+  @IsNotEmpty()
+  @IsNumber()
+  levelId: number;
+
   @IsNotEmpty()
   @IsString()
-  apiKey: string;
+  levelType: string;
 }
 
 export class VerifiedSenderDto {
@@ -337,6 +351,17 @@ export class VerifiedSenderDto {
   value: string;
 }
 
+export class TemplateDto {
+  @IsString()
+  id: string;
+
+  @IsString()
+  name: string;
+
+  @IsString()
+  generation: string;
+}
+
 export class VerifiedSendersResponseDto {
   @IsBoolean()
   success: boolean;
@@ -348,3 +373,15 @@ export class VerifiedSendersResponseDto {
   @IsString()
   error?: string;
 }
+
+export class TemplatesResponseDto {
+  @IsBoolean()
+  success: boolean;
+
+  @IsOptional()
+  data?: TemplateDto[];
+
+  @IsOptional()
+  @IsString()
+  error?: string;
+}

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

@@ -11,6 +11,7 @@ import { CommunicationConfig } from '../entity/communication-config.entity';
 import { CommunicationFactory } from '../factories/communication.factory';
 import { CommunicationResult } from '../strategies/communication.strategy';
 import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
+import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
 import { CommunicationQueueService } from './communication-queue.service';
 
 export interface SendMessageDto {
@@ -83,6 +84,7 @@ export class CommunicationService {
 
     private readonly communicationFactory: CommunicationFactory,
     private readonly gmailApiStrategy: GmailApiStrategy,
+    private readonly sendGridApiStrategy: SendGridApiStrategy,
     private readonly configService: ConfigService,
     @Inject(forwardRef(() => CommunicationQueueService))
     private readonly queueService?: CommunicationQueueService,
@@ -647,6 +649,35 @@ export class CommunicationService {
   }
 
   async updateConfigStatus(hubId: number, status: number): Promise<void> {
+    // Validate active status change to prevent multiple active configurations
+    if (status === 1) {
+      // Find the hub to get level and type information
+      const hub = await this.hubRepository.findOne({
+        where: { id: hubId },
+      });
+
+      if (!hub) {
+        throw new Error('Communication configuration not found');
+      }
+
+      // Check for existing active configuration of same type
+      const existingActiveConfig = await this.hubRepository.findOne({
+        where: {
+          level_id: hub.level_id,
+          level_type: hub.level_type,
+          communication_config_type: hub.communication_config_type,
+          status: 1, // Active status
+          id: Not(hubId), // Exclude current hub
+        },
+      });
+
+      if (existingActiveConfig) {
+        throw new Error(
+          `An active ${hub.communication_config_type} configuration already exists for ${hub.level_type} ${hub.level_id}. Please deactivate the existing configuration first.`,
+        );
+      }
+    }
+
     await this.hubRepository.update(hubId, { status });
   }
 
@@ -708,6 +739,25 @@ export class CommunicationService {
       });
     }
 
+    // Validate active status change to prevent multiple active configurations
+    if (updateData.status === 1) {
+      const existingActiveConfig = await this.hubRepository.findOne({
+        where: {
+          level_id: hub.level_id,
+          level_type: hub.level_type,
+          communication_config_type: hub.communication_config_type,
+          status: 1, // Active status
+          id: Not(hubId), // Exclude current hub
+        },
+      });
+
+      if (existingActiveConfig) {
+        throw new Error(
+          `An active ${hub.communication_config_type} configuration already exists for ${hub.level_type} ${hub.level_id}. Please deactivate the existing configuration first.`,
+        );
+      }
+    }
+
     // Handle default configuration logic
     if (updateData.is_default === true) {
       // Remove default from other configurations of same type and level
@@ -1741,9 +1791,14 @@ export class CommunicationService {
     }
   }
 
-  async getCommunicationConfigById(
-    hubId: number,
-  ): Promise<(CommunicationHub & { config: CommunicationConfig; linkedSource?: string; configDetails?: any }) | null> {
+  async getCommunicationConfigById(hubId: number): Promise<
+    | (CommunicationHub & {
+        config: CommunicationConfig;
+        linkedSource?: string;
+        configDetails?: any;
+      })
+    | null
+  > {
     try {
       // Find the communication hub by ID
       const hub = await this.hubRepository.findOne({
@@ -1802,4 +1857,103 @@ export class CommunicationService {
       );
     }
   }
+
+  async getSendGridTemplates(
+    levelId: number,
+    levelType: string,
+  ): Promise<{
+    success: boolean;
+    data?: Array<{
+      id: string;
+      name: string;
+      generation: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      // Find active SendGrid configurations for this level
+      const hubs = await this.getActiveHubs(levelId, levelType, CommunicationConfigType.EMAIL);
+      
+      // Look for SendGrid provider
+      const sendGridHub = hubs.find(hub => hub.provider === 'sendgrid');
+      
+      if (!sendGridHub) {
+        return {
+          success: false,
+          error: 'No active SendGrid configuration found for this level',
+        };
+      }
+
+      // Extract API key from configuration
+      const apiKey = sendGridHub.config?.config_json?.apiKey;
+      
+      if (!apiKey) {
+        return {
+          success: false,
+          error: 'SendGrid API key not found in configuration',
+        };
+      }
+
+      // Use the SendGrid strategy to fetch templates
+      return this.sendGridApiStrategy.getTemplates(apiKey);
+    } catch (error) {
+      this.logger.error(
+        `Error fetching SendGrid templates for level ${levelId}/${levelType}:`,
+        error.message,
+      );
+      return {
+        success: false,
+        error: `Failed to fetch SendGrid templates: ${error.message}`,
+      };
+    }
+  }
+
+  async getSendGridVerifiedSenders(
+    levelId: number,
+    levelType: string,
+  ): Promise<{
+    success: boolean;
+    data?: Array<{
+      label: string;
+      value: string;
+    }>;
+    error?: string;
+  }> {
+    try {
+      // Find active SendGrid configurations for this level
+      const hubs = await this.getActiveHubs(levelId, levelType, CommunicationConfigType.EMAIL);
+      
+      // Look for SendGrid provider
+      const sendGridHub = hubs.find(hub => hub.provider === 'sendgrid');
+      
+      if (!sendGridHub) {
+        return {
+          success: false,
+          error: 'No active SendGrid configuration found for this level',
+        };
+      }
+
+      // Extract API key from configuration
+      const apiKey = sendGridHub.config?.config_json?.apiKey;
+      
+      if (!apiKey) {
+        return {
+          success: false,
+          error: 'SendGrid API key not found in configuration',
+        };
+      }
+
+      // Use the SendGrid strategy to fetch verified senders
+      return this.sendGridApiStrategy.getVerifiedSenders(apiKey);
+    } catch (error) {
+      this.logger.error(
+        `Error fetching SendGrid verified senders for level ${levelId}/${levelType}:`,
+        error.message,
+      );
+      return {
+        success: false,
+        error: `Failed to fetch SendGrid verified senders: ${error.message}`,
+      };
+    }
+  }
 }

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

@@ -0,0 +1,185 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import {
+  CommunicationService,
+  GenericMessageDto,
+} from './communication.service';
+import { GoogleService } from './calendar-event.service';
+import { IcsMeetingService } from 'src/module/ics/service/ics.service';
+
+@Injectable()
+export class WrapperService {
+  private readonly logger = new Logger(WrapperService.name);
+
+  constructor(
+    private readonly datasource: DataSource,
+    private readonly communicationService: CommunicationService,
+    private readonly googleService: GoogleService,
+    private readonly icsService: IcsMeetingService,
+  ) {}
+
+  /**
+   * Wrapper for sending mail
+   */
+  async sendMailWrapper(payload: any, loggedInUser: any) {
+    try {
+      const { level_id, level_type } = loggedInUser;
+
+      // 1. Check for config at user’s level
+      const configs = await this.datasource.query(
+        `SELECT * 
+         FROM cr_communication_hub 
+         WHERE level_id = ? 
+           AND level_type = ? 
+           AND communication_config_type = 'EMAIL'`,
+        [level_id, level_type],
+      );
+
+      let payloadSendMail: GenericMessageDto;
+
+      if (configs && configs.length > 0) {
+        payloadSendMail = {
+          levelId: level_id,
+          levelType: level_type,
+          to: payload.to,
+          message: payload.message,
+          subject: payload.subject,
+          type: 'EMAIL',
+          cc: payload.cc,
+          bcc: payload.bcc,
+          html: payload.html,
+          attachments: payload.attachments,
+          templateId: payload.templateId,
+          variables: payload.variables,
+        };
+      } else {
+        // 2. Fallback → ORG-level config
+        const fallbackConfigs = await this.datasource.query(
+          `SELECT * 
+           FROM cr_communication_hub 
+           WHERE level_type = 'ORG' 
+             AND communication_config_type = 'EMAIL'`,
+        );
+
+        if (!fallbackConfigs || fallbackConfigs.length === 0) {
+          throw new Error('No active email communication config found');
+        }
+
+        payloadSendMail = {
+          levelId: 1,
+          levelType: 'ORG',
+          to: payload.to,
+          message: payload.message,
+          subject: payload.subject,
+          type: 'EMAIL',
+          cc: payload.cc,
+          bcc: payload.bcc,
+          html: payload.html,
+          attachments: payload.attachments,
+          templateId: payload.templateId,
+          variables: payload.variables,
+        };
+      }
+
+      // 3. Call communication service
+      const result =
+        await this.communicationService.sendGenericMessage(payloadSendMail);
+
+      return {
+        success: true,
+        data: result,
+      };
+    } catch (error: any) {
+      this.logger.error('sendMailWrapper error', error.message);
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Wrapper for scheduling meeting in Google Calendar
+   */
+  async scheduleMeetingWrapper(payload: any, loggedInUser: any) {
+    try {
+      this.logger.log(
+        `scheduleMeetingWrapper called by user: ${loggedInUser?.id || 'unknown'}`,
+      );
+
+      const { level_id, level_type } = loggedInUser;
+
+      // 1. Check for config at user’s level
+      const configs = await this.datasource.query(
+        `SELECT * 
+         FROM cr_communication_hub 
+         WHERE level_id = ? 
+           AND level_type = ? 
+           AND communication_config_type = 'EMAIL' AND provider = 'gmail' AND service = 'API'`,
+        [level_id, level_type],
+      );
+
+      let configCred;
+
+      if (configs && configs.length > 0) {
+        // only if type is gmail
+        configCred = await this.datasource.query(
+          `SELECT config_json
+            FROM cr_communication_config
+            WHERE id = ?`,
+          [configs[0].config_id],
+        );
+
+        if (!configCred || configCred.length === 0) {
+          throw new Error('No Google credentials found for user-level config');
+        }
+
+        configCred = configCred[0].config_json;
+        // 3. Call google service
+        const result = await this.googleService.createEvent(
+          configCred,
+          payload,
+        );
+      } else {
+        // 2. Fallback → ORG-level config
+        const fallbackConfigs = await this.datasource.query(
+          `SELECT * 
+           FROM cr_communication_hub 
+           WHERE level_type = 'ORG' 
+             AND communication_config_type = 'CALENDAR'`,
+        );
+
+        configCred = await this.datasource.query(
+          `SELECT config_json
+            FROM cr_communication_config
+            WHERE id = ?`,
+          [fallbackConfigs[0]?.config_id],
+        );
+
+        const base64String = await this.icsService.generateIcs(payload);
+
+        const result = await this.communicationService.sendGenericMessage({
+          ...payload,
+          attachments: [
+            {
+              content: base64String,
+              type: 'text/calendar',
+              filename: 'invite.ics',
+              disposition: 'attachment',
+            },
+          ],
+        });
+      }
+
+      return {
+        success: true,
+      };
+    } catch (error: any) {
+      this.logger.error('scheduleMeetingWrapper error', error.message);
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  }
+}

package/src/module/communication/strategies/communication.strategy.ts

@@ -17,8 +17,70 @@ export interface CommunicationResult {
   refreshedToken?: string;
 }
 
+export interface EmailAttachment {
+  filename: string;
+  content: string; // base64 encoded content
+  contentType: string; // MIME type (e.g., 'application/pdf', 'image/png')
+  disposition?: 'attachment' | 'inline'; // default: 'attachment'
+  contentId?: string; // for inline images
+}
+
 export interface MessageTemplate {
   subject?: string;
   body: string;
-  attachments?: any[];
+  attachments?: EmailAttachment[];
+}
+
+export class EmailAttachmentValidator {
+  static validate(attachments: EmailAttachment[], maxSizeBytes: number, providerName: string): void {
+    let totalSize = 0;
+
+    for (const attachment of attachments) {
+      // Validate required fields
+      if (!attachment.filename) {
+        throw new Error('Attachment filename is required');
+      }
+
+      if (!attachment.content) {
+        throw new Error(
+          `Attachment content is required for ${attachment.filename}`,
+        );
+      }
+
+      if (!attachment.contentType) {
+        throw new Error(
+          `Attachment contentType is required for ${attachment.filename}`,
+        );
+      }
+
+      // Validate base64 format
+      if (!this.isValidBase64(attachment.content)) {
+        throw new Error(
+          `Invalid base64 content for attachment ${attachment.filename}`,
+        );
+      }
+
+      // Calculate size (base64 is ~4/3 of original size)
+      const attachmentSize = (attachment.content.length * 3) / 4;
+      totalSize += attachmentSize;
+
+      if (totalSize > maxSizeBytes) {
+        const maxSizeMB = Math.floor(maxSizeBytes / (1024 * 1024));
+        throw new Error(`Total attachment size exceeds ${providerName} limit of ${maxSizeMB}MB`);
+      }
+    }
+  }
+
+  private static isValidBase64(str: string): boolean {
+    try {
+      // Check if string is valid base64
+      const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+      return (
+        base64Regex.test(str) &&
+        Buffer.from(str, 'base64').toString('base64') === str
+      );
+    } catch {
+      return false;
+    }
+  }
 }