rez_core 2.2.158 → 2.2.159

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

@@ -7,17 +7,18 @@ export class OAuthService {
   private readonly gmailOAuth2Client = new google.auth.OAuth2(
     process.env.GMAIL_CLIENT_ID,
     process.env.GMAIL_CLIENT_SECRET,
-    process.env.GMAIL_REDIRECT_URI || 'http://localhost:3000/api/communication/oauth/callback/gmail'
+    process.env.GMAIL_REDIRECT_URI ||
+      'http://localhost:3000/api/communication/oauth/callback/gmail',
   );
 
   private readonly outlookScopes = [
     'https://graph.microsoft.com/mail.send',
-    'https://graph.microsoft.com/user.read'
+    'https://graph.microsoft.com/user.read',
   ];
 
   private readonly gmailScopes = [
     'https://www.googleapis.com/auth/gmail.send',
-    'https://www.googleapis.com/auth/gmail.readonly'
+    'https://www.googleapis.com/auth/gmail.readonly',
   ];
 
   generateGmailAuthUrl(state: string): string {
@@ -25,47 +26,54 @@ export class OAuthService {
       access_type: 'offline',
       scope: this.gmailScopes,
       state: state,
-      prompt: 'consent'
+      prompt: 'consent',
     });
   }
 
   generateOutlookAuthUrl(state: string): string {
     const clientId = process.env.OUTLOOK_CLIENT_ID;
-    const redirectUri = encodeURIComponent(process.env.OUTLOOK_REDIRECT_URI || 'http://localhost:3000/api/communication/oauth/callback/outlook');
+    const redirectUri = encodeURIComponent(
+      process.env.OUTLOOK_REDIRECT_URI ||
+        'http://localhost:3000/api/communication/oauth/callback/outlook',
+    );
     const scope = encodeURIComponent(this.outlookScopes.join(' '));
-    
-    return `https://login.microsoftonline.com/common/oauth2/v2.0/authorize?` +
-           `client_id=${clientId}&` +
-           `response_type=code&` +
-           `redirect_uri=${redirectUri}&` +
-           `scope=${scope}&` +
-           `response_mode=query&` +
-           `state=${state}`;
+
+    return (
+      `https://login.microsoftonline.com/common/oauth2/v2.0/authorize?` +
+      `client_id=${clientId}&` +
+      `response_type=code&` +
+      `redirect_uri=${redirectUri}&` +
+      `scope=${scope}&` +
+      `response_mode=query&` +
+      `state=${state}`
+    );
   }
 
   async exchangeGmailCode(code: string): Promise<any> {
     try {
       const { tokens } = await this.gmailOAuth2Client.getToken(code);
-      
+
       this.gmailOAuth2Client.setCredentials(tokens);
-      
+
       // Get user info
       const oauth2 = google.oauth2({
         auth: this.gmailOAuth2Client,
-        version: 'v2'
+        version: 'v2',
       });
       const userInfo = await oauth2.userinfo.get();
-      
+
       return {
         accessToken: tokens.access_token,
         refreshToken: tokens.refresh_token,
         expiresIn: tokens.expiry_date,
         email: userInfo.data.email,
         tokenType: tokens.token_type,
-        scope: tokens.scope
+        scope: tokens.scope,
       };
     } catch (error) {
-      throw new BadRequestException('Failed to exchange Gmail authorization code');
+      throw new BadRequestException(
+        'Failed to exchange Gmail authorization code',
+      );
     }
   }
 
@@ -73,10 +81,13 @@ export class OAuthService {
     try {
       const clientId = process.env.OUTLOOK_CLIENT_ID;
       const clientSecret = process.env.OUTLOOK_CLIENT_SECRET;
-      const redirectUri = process.env.OUTLOOK_REDIRECT_URI || 'http://localhost:3000/api/communication/oauth/callback/outlook';
-      
-      const tokenUrl = 'https://login.microsoftonline.com/common/oauth2/v2.0/token';
-      
+      const redirectUri =
+        process.env.OUTLOOK_REDIRECT_URI ||
+        'http://localhost:3000/api/communication/oauth/callback/outlook';
+
+      const tokenUrl =
+        'https://login.microsoftonline.com/common/oauth2/v2.0/token';
+
       const response = await fetch(tokenUrl, {
         method: 'POST',
         headers: {
@@ -88,12 +99,12 @@ export class OAuthService {
           code: code,
           redirect_uri: redirectUri,
           grant_type: 'authorization_code',
-          scope: this.outlookScopes.join(' ')
-        })
+          scope: this.outlookScopes.join(' '),
+        }),
       });
 
       const tokenData = await response.json();
-      
+
       if (!response.ok) {
         throw new Error(tokenData.error_description || 'Token exchange failed');
       }
@@ -106,33 +117,35 @@ export class OAuthService {
       });
 
       const userInfo = await graphClient.api('/me').get();
-      
+
       return {
         accessToken: tokenData.access_token,
         refreshToken: tokenData.refresh_token,
         expiresIn: tokenData.expires_in,
         email: userInfo.mail || userInfo.userPrincipalName,
         tokenType: tokenData.token_type,
-        scope: tokenData.scope
+        scope: tokenData.scope,
       };
     } catch (error) {
-      throw new BadRequestException('Failed to exchange Outlook authorization code');
+      throw new BadRequestException(
+        'Failed to exchange Outlook authorization code',
+      );
     }
   }
 
   async refreshGmailToken(refreshToken: string): Promise<any> {
     try {
       this.gmailOAuth2Client.setCredentials({
-        refresh_token: refreshToken
+        refresh_token: refreshToken,
       });
 
       const { credentials } = await this.gmailOAuth2Client.refreshAccessToken();
-      
+
       return {
         accessToken: credentials.access_token,
         refreshToken: credentials.refresh_token || refreshToken,
         expiresIn: credentials.expiry_date,
-        tokenType: credentials.token_type
+        tokenType: credentials.token_type,
       };
     } catch (error) {
       throw new BadRequestException('Failed to refresh Gmail token');
@@ -143,9 +156,10 @@ export class OAuthService {
     try {
       const clientId = process.env.OUTLOOK_CLIENT_ID;
       const clientSecret = process.env.OUTLOOK_CLIENT_SECRET;
-      
-      const tokenUrl = 'https://login.microsoftonline.com/common/oauth2/v2.0/token';
-      
+
+      const tokenUrl =
+        'https://login.microsoftonline.com/common/oauth2/v2.0/token';
+
       const response = await fetch(tokenUrl, {
         method: 'POST',
         headers: {
@@ -156,21 +170,21 @@ export class OAuthService {
           client_secret: clientSecret!,
           refresh_token: refreshToken,
           grant_type: 'refresh_token',
-          scope: this.outlookScopes.join(' ')
-        })
+          scope: this.outlookScopes.join(' '),
+        }),
       });
 
       const tokenData = await response.json();
-      
+
       if (!response.ok) {
         throw new Error(tokenData.error_description || 'Token refresh failed');
       }
-      
+
       return {
         accessToken: tokenData.access_token,
         refreshToken: tokenData.refresh_token || refreshToken,
         expiresIn: tokenData.expires_in,
-        tokenType: tokenData.token_type
+        tokenType: tokenData.token_type,
       };
     } catch (error) {
       throw new BadRequestException('Failed to refresh Outlook token');
@@ -184,20 +198,27 @@ export class OAuthService {
     return `${prefix}:${timestamp}:${random}:${Buffer.from(data).toString('base64')}`;
   }
 
-  parseState(state: string): { prefix: string; timestamp: number; random: string; data: any } {
+  parseState(state: string): {
+    prefix: string;
+    timestamp: number;
+    random: string;
+    data: any;
+  } {
     const parts = state.split(':');
     if (parts.length !== 4) {
       throw new BadRequestException('Invalid state parameter');
     }
-    
+
     const [prefix, timestamp, random, encodedData] = parts;
-    const data = encodedData ? JSON.parse(Buffer.from(encodedData, 'base64').toString()) : null;
-    
+    const data = encodedData
+      ? JSON.parse(Buffer.from(encodedData, 'base64').toString())
+      : null;
+
     return {
       prefix,
       timestamp: parseInt(timestamp),
       random,
-      data
+      data,
     };
   }
-}
+}

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

@@ -23,8 +23,16 @@ export class GmailApiStrategy implements CommunicationStrategy {
       console.log('accessToken:', accessToken ? 'Present' : 'Missing');
 
       const toRecipients = Array.isArray(to) ? to.join(', ') : to;
-      const ccRecipients = cc ? (Array.isArray(cc) ? cc.join(', ') : cc) : undefined;
-      const bccRecipients = bcc ? (Array.isArray(bcc) ? bcc.join(', ') : bcc) : undefined;
+      const ccRecipients = cc
+        ? Array.isArray(cc)
+          ? cc.join(', ')
+          : cc
+        : undefined;
+      const bccRecipients = bcc
+        ? Array.isArray(bcc)
+          ? bcc.join(', ')
+          : bcc
+        : undefined;
 
       const emailLines = [
         `To: ${toRecipients}`,
@@ -63,11 +71,11 @@ export class GmailApiStrategy implements CommunicationStrategy {
         },
         {
           headers: {
-            'Authorization': `Bearer ${accessToken}`,
+            Authorization: `Bearer ${accessToken}`,
             'Content-Type': 'application/json',
           },
           timeout: 30000, // 30 second timeout
-        }
+        },
       );
 
       console.log('---- Gmail HTTP API Success ----');
@@ -91,7 +99,10 @@ export class GmailApiStrategy implements CommunicationStrategy {
         success: false,
         provider: 'gmail',
         service: 'API',
-        error: error.response?.data?.error?.message || error.message || 'Gmail API error',
+        error:
+          error.response?.data?.error?.message ||
+          error.message ||
+          'Gmail API error',
         timestamp: new Date(),
       };
     }
@@ -101,35 +112,41 @@ export class GmailApiStrategy implements CommunicationStrategy {
     if (!config) return false;
 
     // For HTTP API, we just need accessToken
-    return (
-      config.accessToken &&
-      typeof config.accessToken === 'string'
-    );
+    return config.accessToken && typeof config.accessToken === 'string';
   }
 
   async refreshAccessToken(config: any): Promise<string> {
     try {
       const { clientId, clientSecret, refreshToken } = config;
-      
+
       if (!clientId || !clientSecret || !refreshToken) {
         throw new Error('Missing OAuth credentials for token refresh');
       }
 
-      const response = await axios.post('https://oauth2.googleapis.com/token', {
-        client_id: clientId,
-        client_secret: clientSecret,
-        refresh_token: refreshToken,
-        grant_type: 'refresh_token',
-      }, {
-        headers: {
-          'Content-Type': 'application/json',
+      const response = await axios.post(
+        'https://oauth2.googleapis.com/token',
+        {
+          client_id: clientId,
+          client_secret: clientSecret,
+          refresh_token: refreshToken,
+          grant_type: 'refresh_token',
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+          },
         },
-      });
+      );
 
       return response.data.access_token || '';
     } catch (error) {
-      console.error('Failed to refresh access token:', error.response?.data || error.message);
-      throw new Error(`Failed to refresh Gmail access token: ${error.response?.data?.error_description || error.message}`);
+      console.error(
+        'Failed to refresh access token:',
+        error.response?.data || error.message,
+      );
+      throw new Error(
+        `Failed to refresh Gmail access token: ${error.response?.data?.error_description || error.message}`,
+      );
     }
   }
 
@@ -146,15 +163,18 @@ export class GmailApiStrategy implements CommunicationStrategy {
         'https://gmail.googleapis.com/gmail/v1/users/me/profile',
         {
           headers: {
-            'Authorization': `Bearer ${accessToken}`,
+            Authorization: `Bearer ${accessToken}`,
           },
           timeout: 10000, // 10 second timeout for validation
-        }
+        },
       );
 
       return response.status === 200 && response.data.emailAddress;
     } catch (error) {
-      console.error('Gmail connection validation failed:', error.response?.data || error.message);
+      console.error(
+        'Gmail connection validation failed:',
+        error.response?.data || error.message,
+      );
       return false;
     }
   }

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

@@ -1,19 +1,26 @@
 import { Injectable } from '@nestjs/common';
 import * as nodemailer from 'nodemailer';
-import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from './communication.strategy';
 
 @Injectable()
 export class GmailSMTPStrategy implements CommunicationStrategy {
-  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
     try {
-      const { 
-        email, 
-        password, 
+      const {
+        email,
+        password,
         subject = 'Notification',
         html,
         attachments,
         cc,
-        bcc 
+        bcc,
       } = config;
 
       const transporter = nodemailer.createTransport({
@@ -56,9 +63,6 @@ export class GmailSMTPStrategy implements CommunicationStrategy {
   }
 
   validateConfig(config: any): boolean {
-    return !!(
-      config.email &&
-      config.password
-    );
+    return !!(config.email && config.password);
   }
-}
+}

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

@@ -1,13 +1,21 @@
 import { Injectable } from '@nestjs/common';
 import { google } from 'googleapis';
-import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from './communication.strategy';
 
 @Injectable()
 export class GmailStrategy implements CommunicationStrategy {
-  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
     try {
-      const { clientId, clientSecret, refreshToken, accessToken, email } = config;
-      
+      const { clientId, clientSecret, refreshToken, accessToken, email } =
+        config;
+
       const oauth2Client = new google.auth.OAuth2(clientId, clientSecret);
       oauth2Client.setCredentials({
         refresh_token: refreshToken,
@@ -15,7 +23,7 @@ export class GmailStrategy implements CommunicationStrategy {
       });
 
       const gmail = google.gmail({ version: 'v1', auth: oauth2Client });
-      
+
       const subject = config.subject || 'Notification';
       const emailContent = [
         `From: ${email}`,
@@ -31,7 +39,7 @@ export class GmailStrategy implements CommunicationStrategy {
         .replace(/\+/g, '-')
         .replace(/\//g, '_')
         .replace(/=+$/, '');
-      
+
       const result = await gmail.users.messages.send({
         userId: 'me',
         requestBody: {
@@ -65,4 +73,4 @@ export class GmailStrategy implements CommunicationStrategy {
       config.email
     );
   }
-}
+}

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

@@ -1,18 +1,25 @@
 import { Injectable } from '@nestjs/common';
 import axios from 'axios';
-import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from './communication.strategy';
 
 @Injectable()
 export class KnowlarityStrategy implements CommunicationStrategy {
-  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
     try {
-      const { 
+      const {
         apiKey,
-        apiSecret, 
+        apiSecret,
         callerNumber,
         baseUrl = 'https://kpi.knowlarity.com/Basic',
         callType = 'voice',
-        language = 'en'
+        language = 'en',
       } = config;
 
       if (callType === 'voice') {
@@ -24,19 +31,28 @@ export class KnowlarityStrategy implements CommunicationStrategy {
           language: language,
           api_key: apiKey,
           api_secret: apiSecret,
-          format: 'json'
+          format: 'json',
         };
 
-        const response = await axios.post(`${baseUrl}/start_call.php`, callData, {
-          headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
+        const response = await axios.post(
+          `${baseUrl}/start_call.php`,
+          callData,
+          {
+            headers: {
+              'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            transformRequest: [
+              (data) => {
+                return Object.keys(data)
+                  .map(
+                    (key) =>
+                      `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
+                  )
+                  .join('&');
+              },
+            ],
           },
-          transformRequest: [(data) => {
-            return Object.keys(data)
-              .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
-              .join('&');
-          }]
-        });
+        );
 
         return {
           success: response.data.status === 'success',
@@ -54,18 +70,23 @@ export class KnowlarityStrategy implements CommunicationStrategy {
           sms_text: message,
           api_key: apiKey,
           api_secret: apiSecret,
-          format: 'json'
+          format: 'json',
         };
 
         const response = await axios.post(`${baseUrl}/send_sms.php`, smsData, {
           headers: {
             'Content-Type': 'application/x-www-form-urlencoded',
           },
-          transformRequest: [(data) => {
-            return Object.keys(data)
-              .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
-              .join('&');
-          }]
+          transformRequest: [
+            (data) => {
+              return Object.keys(data)
+                .map(
+                  (key) =>
+                    `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
+                )
+                .join('&');
+            },
+          ],
         });
 
         return {
@@ -99,26 +120,39 @@ export class KnowlarityStrategy implements CommunicationStrategy {
   }
 
   async getCallStatus(callId: string, config: any): Promise<any> {
-    const { apiKey, apiSecret, baseUrl = 'https://kpi.knowlarity.com/Basic' } = config;
+    const {
+      apiKey,
+      apiSecret,
+      baseUrl = 'https://kpi.knowlarity.com/Basic',
+    } = config;
 
     const statusData = {
       call_id: callId,
       api_key: apiKey,
       api_secret: apiSecret,
-      format: 'json'
+      format: 'json',
     };
 
-    const response = await axios.post(`${baseUrl}/call_details.php`, statusData, {
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
+    const response = await axios.post(
+      `${baseUrl}/call_details.php`,
+      statusData,
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        transformRequest: [
+          (data) => {
+            return Object.keys(data)
+              .map(
+                (key) =>
+                  `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`,
+              )
+              .join('&');
+          },
+        ],
       },
-      transformRequest: [(data) => {
-        return Object.keys(data)
-          .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
-          .join('&');
-      }]
-    });
+    );
 
     return response.data;
   }
-}
+}

package/src/module/communication/strategies/outlook-smtp.strategy.ts

@@ -1,19 +1,26 @@
 import { Injectable } from '@nestjs/common';
 import * as nodemailer from 'nodemailer';
-import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from './communication.strategy';
 
 @Injectable()
 export class OutlookSMTPStrategy implements CommunicationStrategy {
-  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
     try {
-      const { 
-        email, 
-        password, 
+      const {
+        email,
+        password,
         subject = 'Notification',
         html,
         attachments,
         cc,
-        bcc 
+        bcc,
       } = config;
 
       const transporter = nodemailer.createTransport({
@@ -61,9 +68,6 @@ export class OutlookSMTPStrategy implements CommunicationStrategy {
   }
 
   validateConfig(config: any): boolean {
-    return !!(
-      config.email &&
-      config.password
-    );
+    return !!(config.email && config.password);
   }
-}
+}