rez_core 2.2.183 → 2.2.185

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "2.2.183",
+  "version": "2.2.185",
   "description": "",
   "author": "",
   "private": false,
@@ -34,6 +34,7 @@
     "@nestjs/schedule": "^6.0.0",
     "@nestjs/swagger": "^11.0.3",
     "@nestjs/typeorm": "^11.0.0",
+    "@sendgrid/mail": "^8.1.5",
     "250218_nodejs_core": "file:",
     "aws-sdk": "^2.1692.0",
     "axios": "^1.9.0",

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

@@ -16,6 +16,7 @@ import { CommunicationController } from './controller/communication.controller';
 import { GmailApiStrategy } from './strategies/email/gmail-api.strategy';
 import { GmailSmtpStrategy } from './strategies/email/gmail-smtp.strategy';
 import { OutlookApiStrategy } from './strategies/email/outlook-api.strategy';
+import { SendGridApiStrategy } from './strategies/email/sendgrid-api.strategy';
 import { TwilioStrategy } from './strategies/sms/twilio.strategy';
 import { KnowlarityStrategy as KnowlaritySMSStrategy } from './strategies/sms/knowlarity.strategy';
 import { WhatsAppCloudStrategy } from './strategies/whatsapp/whatsapp-cloud.strategy';
@@ -39,12 +40,7 @@ import { TelephoneFactory } from './factories/telephone.factory';
 import { CommunicationFactory } from './factories/communication.factory';
 
 @Module({
-  imports: [
-    TypeOrmModule.forFeature([
-      CommunicationConfig,
-      CommunicationHub,
-    ]),
-  ],
+  imports: [TypeOrmModule.forFeature([CommunicationConfig, CommunicationHub])],
   controllers: [CommunicationController],
   providers: [
     // Main Services
@@ -56,6 +52,7 @@ import { CommunicationFactory } from './factories/communication.factory';
     GmailApiStrategy,
     GmailSmtpStrategy,
     OutlookApiStrategy,
+    SendGridApiStrategy,
 
     // Existing SMS/WhatsApp/Telephone Strategies
     TwilioStrategy,

package/src/module/communication/factories/email.factory.ts

@@ -5,6 +5,7 @@ import { GmailStrategy } from '../strategies/gmail.strategy';
 import { OutlookStrategy } from '../strategies/outlook.strategy';
 import { GmailSMTPStrategy } from '../strategies/gmail-smtp.strategy';
 import { OutlookSMTPStrategy } from '../strategies/outlook-smtp.strategy';
+import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
 
 @Injectable()
 export class EmailFactory implements BaseFactory {
@@ -13,6 +14,7 @@ export class EmailFactory implements BaseFactory {
     private outlookStrategy: OutlookStrategy,
     private gmailSMTPStrategy: GmailSMTPStrategy,
     private outlookSMTPStrategy: OutlookSMTPStrategy,
+    private sendGridApiStrategy: SendGridApiStrategy,
   ) {}
 
   createProvider(service: string, provider: string): CommunicationStrategy {
@@ -23,6 +25,8 @@ export class EmailFactory implements BaseFactory {
         return this.gmailStrategy;
       case 'api_outlook':
         return this.outlookStrategy;
+      case 'api_sendgrid':
+        return this.sendGridApiStrategy;
       case 'smtp_gmail':
         return this.gmailSMTPStrategy;
       case 'smtp_outlook':
@@ -39,6 +43,7 @@ export class EmailFactory implements BaseFactory {
     return [
       { service: 'API', provider: 'gmail' },
       { service: 'API', provider: 'outlook' },
+      { service: 'API', provider: 'sendgrid' },
       { service: 'SMTP', provider: 'gmail' },
       { service: 'SMTP', provider: 'outlook' },
     ];

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

@@ -37,7 +37,7 @@ export class CommunicationQueueService {
     metadata?: any,
   ): Promise<string> {
     const messageId = this.generateMessageId();
-    
+
     const queuedMessage: QueuedMessage = {
       id: messageId,
       levelId,
@@ -56,7 +56,9 @@ export class CommunicationQueueService {
     this.queue.push(queuedMessage);
     this.sortQueue();
 
-    this.logger.log(`Message queued: ${messageId} for ${recipient} with priority ${priority}`);
+    this.logger.log(
+      `Message queued: ${messageId} for ${recipient} with priority ${priority}`,
+    );
     return messageId;
   }
 
@@ -90,13 +92,17 @@ export class CommunicationQueueService {
 
   getQueueStats() {
     const total = this.queue.length;
-    const pending = this.queue.filter(m => !m.scheduledFor || m.scheduledFor <= new Date()).length;
-    const scheduled = this.queue.filter(m => m.scheduledFor && m.scheduledFor > new Date()).length;
-    
+    const pending = this.queue.filter(
+      (m) => !m.scheduledFor || m.scheduledFor <= new Date(),
+    ).length;
+    const scheduled = this.queue.filter(
+      (m) => m.scheduledFor && m.scheduledFor > new Date(),
+    ).length;
+
     const byPriority = {
-      high: this.queue.filter(m => m.priority === 'high').length,
-      medium: this.queue.filter(m => m.priority === 'medium').length,
-      low: this.queue.filter(m => m.priority === 'low').length,
+      high: this.queue.filter((m) => m.priority === 'high').length,
+      medium: this.queue.filter((m) => m.priority === 'medium').length,
+      low: this.queue.filter((m) => m.priority === 'low').length,
     };
 
     return {
@@ -117,10 +123,10 @@ export class CommunicationQueueService {
 
     try {
       const now = new Date();
-      
+
       // Get messages ready to send (not scheduled or scheduled time has passed)
       const readyMessages = this.queue.filter(
-        message => !message.scheduledFor || message.scheduledFor <= now
+        (message) => !message.scheduledFor || message.scheduledFor <= now,
       );
 
       if (readyMessages.length === 0) {
@@ -139,28 +145,37 @@ export class CommunicationQueueService {
       for (const message of messagesToProcess) {
         try {
           // Remove message from queue
-          this.queue = this.queue.filter(m => m.id !== message.id);
-          
-          this.logger.log(`Processing queued message ${message.id} for ${message.recipient}`);
-          
+          this.queue = this.queue.filter((m) => m.id !== message.id);
+
+          this.logger.log(
+            `Processing queued message ${message.id} for ${message.recipient}`,
+          );
+
           // Note: In a real implementation, you would call the communication service here
           // For now, we just simulate successful processing
-          
         } catch (error) {
-          this.logger.error(`Failed to process message ${message.id}:`, error.message);
-          
+          this.logger.error(
+            `Failed to process message ${message.id}:`,
+            error.message,
+          );
+
           // Retry logic
           if (message.retryCount < message.maxRetries) {
             message.retryCount++;
-            message.scheduledFor = new Date(Date.now() + (message.retryCount * 60000)); // Retry after 1, 2, 3 minutes
+            message.scheduledFor = new Date(
+              Date.now() + message.retryCount * 60000,
+            ); // Retry after 1, 2, 3 minutes
             this.queue.push(message);
-            this.logger.warn(`Message ${message.id} will be retried (attempt ${message.retryCount}/${message.maxRetries})`);
+            this.logger.warn(
+              `Message ${message.id} will be retried (attempt ${message.retryCount}/${message.maxRetries})`,
+            );
           } else {
-            this.logger.error(`Message ${message.id} failed permanently after ${message.maxRetries} attempts`);
+            this.logger.error(
+              `Message ${message.id} failed permanently after ${message.maxRetries} attempts`,
+            );
           }
         }
       }
-
     } catch (error) {
       this.logger.error('Error processing queue:', error.message);
     } finally {
@@ -175,7 +190,7 @@ export class CommunicationQueueService {
       if (priorityOrder[a.priority] !== priorityOrder[b.priority]) {
         return priorityOrder[b.priority] - priorityOrder[a.priority];
       }
-      
+
       // Then by creation time (oldest first)
       return a.createdAt.getTime() - b.createdAt.getTime();
     });
@@ -202,13 +217,13 @@ export class CommunicationQueueService {
   // Cancel a specific message
   cancelMessage(messageId: string): boolean {
     const initialLength = this.queue.length;
-    this.queue = this.queue.filter(m => m.id !== messageId);
+    this.queue = this.queue.filter((m) => m.id !== messageId);
     const canceled = this.queue.length < initialLength;
-    
+
     if (canceled) {
       this.logger.log(`Message ${messageId} canceled`);
     }
-    
+
     return canceled;
   }
-}
+}

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

@@ -16,7 +16,9 @@ export class GmailApiStrategy implements CommunicationStrategy {
   ): Promise<CommunicationResult> {
     try {
       if (!config || !config.refreshToken) {
-        throw new Error('Invalid Gmail API configuration - missing refresh token');
+        throw new Error(
+          'Invalid Gmail API configuration - missing refresh token',
+        );
       }
 
       const { subject, html, cc, bcc } = config;

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

@@ -0,0 +1,117 @@
+import { Injectable } from '@nestjs/common';
+import * as sgMail from '@sendgrid/mail';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class SendGridApiStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      const {
+        apiKey,
+        fromEmail,
+        templateId,
+        dynamicTemplateData,
+        subject,
+        html,
+      } = config;
+
+      if (!apiKey || !fromEmail) {
+        throw new Error(
+          'Missing required SendGrid credentials: apiKey and fromEmail are required',
+        );
+      }
+
+      sgMail.setApiKey(apiKey);
+
+      const toArray = Array.isArray(to) ? to : [to];
+      const mailData: any = {
+        to: toArray,
+        from: fromEmail,
+        subject: subject || 'Notification',
+      };
+
+      // Handle template emails
+      if (templateId) {
+        mailData.templateId = templateId;
+        if (dynamicTemplateData) {
+          mailData.dynamicTemplateData = dynamicTemplateData;
+        }
+      } else {
+        // Regular email content
+        if (html && message) {
+          mailData.html = html;
+          mailData.text = message;
+        } else if (html) {
+          mailData.html = html;
+        } else {
+          mailData.text = message || 'Hello from SendGrid!';
+        }
+      }
+
+      // Add CC/BCC if provided
+      if (config.cc) {
+        mailData.cc = Array.isArray(config.cc) ? config.cc : [config.cc];
+      }
+      if (config.bcc) {
+        mailData.bcc = Array.isArray(config.bcc) ? config.bcc : [config.bcc];
+      }
+
+      // Add additional SendGrid features
+      if (config.attachments) {
+        mailData.attachments = config.attachments;
+      }
+      if (config.categories) {
+        mailData.categories = Array.isArray(config.categories)
+          ? config.categories
+          : [config.categories];
+      }
+      if (config.customArgs) {
+        mailData.customArgs = config.customArgs;
+      }
+      if (config.sendAt) {
+        mailData.sendAt = config.sendAt;
+      }
+
+      const result = await sgMail.send(mailData);
+
+      return {
+        success: true,
+        provider: 'sendgrid',
+        service: 'API',
+        messageId: result[0].headers['x-message-id'] || undefined,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      let errorMessage = 'Unknown error';
+
+      if (error.response?.body?.errors) {
+        errorMessage = error.response.body.errors
+          .map((err: any) => err.message)
+          .join(', ');
+      } else if (error.response?.body?.message) {
+        errorMessage = error.response.body.message;
+      } else if (error.message) {
+        errorMessage = error.message;
+      }
+
+      return {
+        success: false,
+        provider: 'sendgrid',
+        service: 'API',
+        error: errorMessage,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(config.apiKey && config.fromEmail);
+  }
+}

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

@@ -20,20 +20,26 @@ export class GmailStrategy implements CommunicationStrategy {
 
       // For backward compatibility, only validate essential fields for sending
       if (!refreshToken || !email) {
-        throw new Error('Missing required Gmail credentials: refreshToken and email are required');
+        throw new Error(
+          'Missing required Gmail credentials: refreshToken and email are required',
+        );
       }
 
       // Get system OAuth credentials
       const systemClientId = this.configService.get<string>('CLIENT_ID');
-      const systemClientSecret = this.configService.get<string>('CLIENT_SECRET');
+      const systemClientSecret =
+        this.configService.get<string>('CLIENT_SECRET');
 
       if (!systemClientId || !systemClientSecret) {
         throw new Error('Gmail OAuth system credentials not configured');
       }
 
       // Create OAuth2 client with system credentials
-      const oauth2Client = new google.auth.OAuth2(systemClientId, systemClientSecret);
-      
+      const oauth2Client = new google.auth.OAuth2(
+        systemClientId,
+        systemClientSecret,
+      );
+
       oauth2Client.setCredentials({
         refresh_token: refreshToken,
         access_token: accessToken,
@@ -82,16 +88,20 @@ export class GmailStrategy implements CommunicationStrategy {
         service: 'API',
         messageId: result.data.id || undefined,
         timestamp: new Date(),
-        refreshedToken: config.accessToken !== accessToken ? config.accessToken : undefined,
+        refreshedToken:
+          config.accessToken !== accessToken ? config.accessToken : undefined,
       };
     } catch (error) {
       console.log('Gmail strategy error:', error);
-      console.log('Config validation:', JSON.stringify({ 
-        hasRefreshToken: !!config.refreshToken,
-        hasAccessToken: !!config.accessToken,
-        hasEmail: !!config.email
-      }));
-      
+      console.log(
+        'Config validation:',
+        JSON.stringify({
+          hasRefreshToken: !!config.refreshToken,
+          hasAccessToken: !!config.accessToken,
+          hasEmail: !!config.email,
+        }),
+      );
+
       return {
         success: false,
         provider: 'gmail',

package/src/module/workflow/controller/comm-template.controller.ts

@@ -21,10 +21,12 @@ export class CommTemplateController {
   async getTemplate(
     @Req() req: Request & { user: any },
     @Body('entity_type') entity_type: string,
+    @Body('action_id') action_id: number,
   ) {
     const loggedInUser = req.user.userData;
     const result = this.commTemplateService.getAllCommTemplate(
       entity_type || '',
+      action_id,
       loggedInUser,
     );
     return result;

package/src/module/workflow/entity/comm-template.entity.ts

@@ -28,4 +28,7 @@ export class CommTemplate extends BaseEntity {
   // if format_type is 'markup', this field will be used
   @Column({ nullable: true })
   markup_id: number;
+
+  @Column({ nullable: true })
+  is_template: boolean;
 }

package/src/module/workflow/repository/comm-template.repository.ts

@@ -1,7 +1,7 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Workflow } from '../entity/workflow.entity';
-import { Repository } from 'typeorm';
+import { DataSource, Repository } from 'typeorm';
 import { CommTemplate } from '../entity/comm-template.entity';
 import { TemplateAttach } from '../entity/template-attach-mapper.entity';
 import { MediaDataService } from 'src/module/meta/service/media-data.service';
@@ -14,15 +14,44 @@ export class CommTemplateRepository {
     @InjectRepository(TemplateAttach)
     private readonly templateAttachEntity: Repository<TemplateAttach>,
     private readonly mediaDataService: MediaDataService,
+    private readonly dataSource: DataSource,
   ) {}
 
-  async getAllCommTemplate(entity_type: string, loggedInUser) {
+  async getAllCommTemplate(
+    entity_type: string,
+    action_id: number,
+    loggedInUser,
+  ) {
     const { organization_id } = loggedInUser;
+
+    const [actionResult] = await this.dataSource.query(
+      `SELECT is_template 
+       FROM cr_wf_action 
+       WHERE id = ? AND organization_id = ? 
+       LIMIT 1`,
+      [action_id, organization_id],
+    );
+
+    if (!actionResult) {
+      throw new Error('Invalid action_id');
+    }
+
+    const { is_template } = actionResult;
+
+    await this.dataSource.query(
+      `UPDATE cr_wf_comm_template
+     SET is_template = ?
+     WHERE mapped_entity_type = ?
+       AND organization_id = ?`,
+      [is_template, entity_type, organization_id],
+    );
+
     return this.commTemplateRepository.find({
-      select: ['name', 'code', 'mode'],
+      select: ['name', 'code', 'mode', 'is_template'],
       where: {
         mapped_entity_type: entity_type,
-        organization_id: organization_id,
+        organization_id,
+        is_template,
       },
     });
   }

package/src/module/workflow/service/comm-template.service.ts

@@ -78,10 +78,15 @@ export class CommTemplateService extends EntityServiceImpl {
     return getTemplate;
   }
 
-  async getAllCommTemplate(entity_type: string, loggedInUser) {
+  async getAllCommTemplate(
+    entity_type: string,
+    action_id: number,
+    loggedInUser,
+  ) {
     const commTemplateData =
       await this.commTemplateRepository.getAllCommTemplate(
         entity_type,
+        action_id,
         loggedInUser,
       );
 
@@ -89,6 +94,7 @@ export class CommTemplateService extends EntityServiceImpl {
       value: item.code,
       label: item.name,
       mode: item.mode,
+      template: item.is_template,
     }));
 
     return response;

package/.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint"
-    ]
-}