rez_core 2.2.154 → 2.2.156

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

@@ -0,0 +1,203 @@
+import { Injectable, BadRequestException } from '@nestjs/common';
+import { google } from 'googleapis';
+import { Client } from '@microsoft/microsoft-graph-client';
+
+@Injectable()
+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'
+  );
+
+  private readonly outlookScopes = [
+    'https://graph.microsoft.com/mail.send',
+    'https://graph.microsoft.com/user.read'
+  ];
+
+  private readonly gmailScopes = [
+    'https://www.googleapis.com/auth/gmail.send',
+    'https://www.googleapis.com/auth/gmail.readonly'
+  ];
+
+  generateGmailAuthUrl(state: string): string {
+    return this.gmailOAuth2Client.generateAuthUrl({
+      access_type: 'offline',
+      scope: this.gmailScopes,
+      state: state,
+      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 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}`;
+  }
+
+  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'
+      });
+      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
+      };
+    } catch (error) {
+      throw new BadRequestException('Failed to exchange Gmail authorization code');
+    }
+  }
+
+  async exchangeOutlookCode(code: string): Promise<any> {
+    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 response = await fetch(tokenUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+          client_id: clientId!,
+          client_secret: clientSecret!,
+          code: code,
+          redirect_uri: redirectUri,
+          grant_type: 'authorization_code',
+          scope: this.outlookScopes.join(' ')
+        })
+      });
+
+      const tokenData = await response.json();
+      
+      if (!response.ok) {
+        throw new Error(tokenData.error_description || 'Token exchange failed');
+      }
+
+      // Get user info using the access token
+      const graphClient = Client.init({
+        authProvider: {
+          getAccessToken: async () => tokenData.access_token,
+        } as any,
+      });
+
+      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
+      };
+    } catch (error) {
+      throw new BadRequestException('Failed to exchange Outlook authorization code');
+    }
+  }
+
+  async refreshGmailToken(refreshToken: string): Promise<any> {
+    try {
+      this.gmailOAuth2Client.setCredentials({
+        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
+      };
+    } catch (error) {
+      throw new BadRequestException('Failed to refresh Gmail token');
+    }
+  }
+
+  async refreshOutlookToken(refreshToken: string): Promise<any> {
+    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 response = await fetch(tokenUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+          client_id: clientId!,
+          client_secret: clientSecret!,
+          refresh_token: refreshToken,
+          grant_type: 'refresh_token',
+          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
+      };
+    } catch (error) {
+      throw new BadRequestException('Failed to refresh Outlook token');
+    }
+  }
+
+  generateState(prefix: string, additionalData?: any): string {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(7);
+    const data = additionalData ? JSON.stringify(additionalData) : '';
+    return `${prefix}:${timestamp}:${random}:${Buffer.from(data).toString('base64')}`;
+  }
+
+  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;
+    
+    return {
+      prefix,
+      timestamp: parseInt(timestamp),
+      random,
+      data
+    };
+  }
+}

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

@@ -0,0 +1,23 @@
+export interface CommunicationStrategy {
+  sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult>;
+  validateConfig(config: any): boolean;
+}
+
+export interface CommunicationResult {
+  success: boolean;
+  messageId?: string;
+  provider: string;
+  service: string;
+  error?: string;
+  timestamp: Date;
+}
+
+export interface MessageTemplate {
+  subject?: string;
+  body: string;
+  attachments?: any[];
+}

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

@@ -0,0 +1,161 @@
+import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class GmailApiStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string | string[],
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Gmail API configuration');
+      }
+
+      const { accessToken, subject, html, cc, bcc } = config;
+
+      console.log('---- Using HTTP Gmail API ----');
+      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 emailLines = [
+        `To: ${toRecipients}`,
+        `Subject: ${subject || 'Notification'}`,
+      ];
+
+      if (ccRecipients) {
+        emailLines.push(`Cc: ${ccRecipients}`);
+      }
+
+      if (bccRecipients) {
+        emailLines.push(`Bcc: ${bccRecipients}`);
+      }
+
+      emailLines.push('Content-Type: text/html; charset=utf-8');
+      emailLines.push('');
+
+      if (html) {
+        emailLines.push(html);
+      } else {
+        emailLines.push(message);
+      }
+
+      const emailContent = emailLines.join('\n');
+      const encodedMessage = Buffer.from(emailContent)
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+
+      // Direct HTTP call to Gmail API
+      const response = await axios.post(
+        'https://gmail.googleapis.com/gmail/v1/users/me/messages/send',
+        {
+          raw: encodedMessage,
+        },
+        {
+          headers: {
+            'Authorization': `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+          },
+          timeout: 30000, // 30 second timeout
+        }
+      );
+
+      console.log('---- Gmail HTTP API Success ----');
+      console.log('Response status:', response.status);
+      console.log('Message ID:', response.data?.id);
+
+      return {
+        success: true,
+        messageId: response.data?.id || undefined,
+        provider: 'gmail',
+        service: 'API',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      console.error('---- Gmail HTTP API Error ----');
+      console.error('Error message:', error.message);
+      console.error('Status:', error.response?.status);
+      console.error('Response data:', error.response?.data);
+
+      return {
+        success: false,
+        provider: 'gmail',
+        service: 'API',
+        error: error.response?.data?.error?.message || error.message || 'Gmail API error',
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    if (!config) return false;
+
+    // For HTTP API, we just need accessToken
+    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',
+        },
+      });
+
+      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}`);
+    }
+  }
+
+  async validateConnection(config: any): Promise<boolean> {
+    try {
+      if (!this.validateConfig(config)) {
+        return false;
+      }
+
+      const { accessToken } = config;
+
+      // Test the connection by getting user profile
+      const response = await axios.get(
+        'https://gmail.googleapis.com/gmail/v1/users/me/profile',
+        {
+          headers: {
+            '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);
+      return false;
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class GmailSmtpStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Gmail SMTP configuration');
+      }
+
+      // SMTP implementation would go here using nodemailer
+      // This is a placeholder for actual SMTP integration
+      console.log('Sending email via Gmail SMTP to:', to);
+
+      return {
+        success: true,
+        messageId: `gmail-smtp-${Date.now()}`,
+        provider: 'gmail',
+        service: 'SMTP',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'gmail',
+        service: 'SMTP',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return (
+      config &&
+      config.host &&
+      config.port &&
+      config.auth &&
+      config.auth.user &&
+      config.auth.pass
+    );
+  }
+}

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

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class OutlookApiStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Outlook API configuration');
+      }
+
+      // Microsoft Graph API implementation would go here
+      // This is a placeholder for actual Outlook API integration
+      console.log('Sending email via Outlook API to:', to);
+
+      return {
+        success: true,
+        messageId: `outlook-${Date.now()}`,
+        provider: 'outlook',
+        service: 'API',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'outlook',
+        service: 'API',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return config && config.clientId && config.clientSecret && config.tenantId;
+  }
+}

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

@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+import * as nodemailer from 'nodemailer';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class GmailSMTPStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { 
+        email, 
+        password, 
+        subject = 'Notification',
+        html,
+        attachments,
+        cc,
+        bcc 
+      } = config;
+
+      const transporter = nodemailer.createTransport({
+        service: 'gmail',
+        auth: {
+          user: email,
+          pass: password,
+        },
+      });
+
+      const mailOptions = {
+        from: email,
+        to: Array.isArray(to) ? to.join(',') : to,
+        cc: cc ? (Array.isArray(cc) ? cc.join(',') : cc) : undefined,
+        bcc: bcc ? (Array.isArray(bcc) ? bcc.join(',') : bcc) : undefined,
+        subject,
+        text: message,
+        html: html || message,
+        attachments: attachments || [],
+      };
+
+      const result = await transporter.sendMail(mailOptions);
+
+      return {
+        success: true,
+        provider: 'gmail',
+        service: 'SMTP',
+        messageId: result.messageId,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'gmail',
+        service: 'SMTP',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.email &&
+      config.password
+    );
+  }
+}

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

@@ -0,0 +1,68 @@
+import { Injectable } from '@nestjs/common';
+import { google } from 'googleapis';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class GmailStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { clientId, clientSecret, refreshToken, accessToken, email } = config;
+      
+      const oauth2Client = new google.auth.OAuth2(clientId, clientSecret);
+      oauth2Client.setCredentials({
+        refresh_token: refreshToken,
+        access_token: accessToken,
+      });
+
+      const gmail = google.gmail({ version: 'v1', auth: oauth2Client });
+      
+      const subject = config.subject || 'Notification';
+      const emailContent = [
+        `From: ${email}`,
+        `To: ${to}`,
+        `Subject: ${subject}`,
+        'Content-Type: text/html; charset=utf-8',
+        '',
+        config.html || message,
+      ].join('\n');
+
+      const encodedMessage = Buffer.from(emailContent)
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+      
+      const result = await gmail.users.messages.send({
+        userId: 'me',
+        requestBody: {
+          raw: encodedMessage,
+        },
+      });
+
+      return {
+        success: true,
+        provider: 'gmail',
+        service: 'API',
+        messageId: result.data.id || undefined,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'gmail',
+        service: 'API',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.clientId &&
+      config.clientSecret &&
+      config.refreshToken &&
+      config.email
+    );
+  }
+}