rez_core 2.2.154 → 2.2.156

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

@@ -0,0 +1,124 @@
+import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class KnowlarityStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { 
+        apiKey,
+        apiSecret, 
+        callerNumber,
+        baseUrl = 'https://kpi.knowlarity.com/Basic',
+        callType = 'voice',
+        language = 'en'
+      } = config;
+
+      if (callType === 'voice') {
+        const callData = {
+          k_number: callerNumber,
+          agent_number: to,
+          caller_id: callerNumber,
+          voice_message: config.voiceMessage || message,
+          language: language,
+          api_key: apiKey,
+          api_secret: apiSecret,
+          format: 'json'
+        };
+
+        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('&');
+          }]
+        });
+
+        return {
+          success: response.data.status === 'success',
+          provider: 'knowlarity',
+          service: 'THIRD_PARTY',
+          messageId: response.data.call_id,
+          timestamp: new Date(),
+        };
+      }
+
+      if (callType === 'sms') {
+        const smsData = {
+          k_number: callerNumber,
+          agent_number: to,
+          sms_text: message,
+          api_key: apiKey,
+          api_secret: apiSecret,
+          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('&');
+          }]
+        });
+
+        return {
+          success: response.data.status === 'success',
+          provider: 'knowlarity',
+          service: 'THIRD_PARTY',
+          messageId: response.data.message_id,
+          timestamp: new Date(),
+        };
+      }
+
+      throw new Error('Invalid call type. Must be "voice" or "sms"');
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.apiKey &&
+      config.apiSecret &&
+      config.callerNumber &&
+      ['voice', 'sms'].includes(config.callType)
+    );
+  }
+
+  async getCallStatus(callId: string, config: any): Promise<any> {
+    const { apiKey, apiSecret, baseUrl = 'https://kpi.knowlarity.com/Basic' } = config;
+
+    const statusData = {
+      call_id: callId,
+      api_key: apiKey,
+      api_secret: apiSecret,
+      format: 'json'
+    };
+
+    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('&');
+      }]
+    });
+
+    return response.data;
+  }
+}

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

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import * as nodemailer from 'nodemailer';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class OutlookSMTPStrategy 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({
+        host: 'smtp-mail.outlook.com',
+        port: 587,
+        secure: false,
+        auth: {
+          user: email,
+          pass: password,
+        },
+        tls: {
+          ciphers: 'SSLv3',
+        },
+      });
+
+      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: 'outlook',
+        service: 'SMTP',
+        messageId: result.messageId,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'outlook',
+        service: 'SMTP',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.email &&
+      config.password
+    );
+  }
+}

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

@@ -0,0 +1,57 @@
+import { Injectable } from '@nestjs/common';
+import { Client } from '@microsoft/microsoft-graph-client';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class OutlookStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { accessToken } = config;
+      
+      const graphClient = Client.init({
+        authProvider: {
+          getAccessToken: async () => accessToken,
+        } as any,
+      });
+
+      const subject = config.subject || 'Notification';
+      const mail = {
+        message: {
+          subject,
+          body: {
+            contentType: config.html ? 'HTML' : 'Text',
+            content: config.html || message,
+          },
+          toRecipients: [
+            {
+              emailAddress: {
+                address: to,
+              },
+            },
+          ],
+        },
+      };
+
+      await graphClient.api('/me/sendMail').post(mail);
+
+      return {
+        success: true,
+        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.accessToken);
+  }
+}

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

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

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

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

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

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { Twilio } from 'twilio';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class SmsStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { accountSid, authToken, fromNumber } = config;
+      
+      const client = new Twilio(accountSid, authToken);
+      
+      const result = await client.messages.create({
+        body: message,
+        from: fromNumber,
+        to: to,
+      });
+
+      return {
+        success: true,
+        provider: 'twilio',
+        service: 'THIRD_PARTY',
+        messageId: result.sid,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'twilio',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.accountSid &&
+      config.authToken &&
+      config.fromNumber
+    );
+  }
+}

package/src/module/communication/strategies/telephone/knowlarity-voice.strategy.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import {
+  CommunicationStrategy,
+  CommunicationResult,
+} from '../communication.strategy';
+
+@Injectable()
+export class KnowlarityVoiceStrategy implements CommunicationStrategy {
+  async sendMessage(
+    to: string,
+    message: string,
+    config: any,
+  ): Promise<CommunicationResult> {
+    try {
+      if (!this.validateConfig(config)) {
+        throw new Error('Invalid Knowlarity Voice configuration');
+      }
+
+      // Knowlarity Voice API implementation would go here
+      // This is a placeholder for actual voice call integration
+      console.log('Initiating voice call via Knowlarity to:', to);
+
+      return {
+        success: true,
+        messageId: `knowlarity-voice-${Date.now()}`,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'knowlarity',
+        service: 'THIRD_PARTY',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return config && config.apiKey && config.callerId && config.voiceUrl;
+  }
+}

package/src/module/communication/strategies/whatsapp/whatsapp-cloud.strategy.ts

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

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

@@ -0,0 +1,53 @@
+import { Injectable } from '@nestjs/common';
+import axios from 'axios';
+import { CommunicationStrategy, CommunicationResult } from './communication.strategy';
+
+@Injectable()
+export class WhatsAppStrategy implements CommunicationStrategy {
+  async sendMessage(to: string, message: string, config: any): Promise<CommunicationResult> {
+    try {
+      const { accessToken, phoneNumberId, apiVersion = 'v17.0' } = config;
+      
+      const url = `https://graph.facebook.com/${apiVersion}/${phoneNumberId}/messages`;
+      
+      const payload = {
+        messaging_product: 'whatsapp',
+        to: to,
+        type: 'text',
+        text: {
+          body: message,
+        },
+      };
+
+      const response = await axios.post(url, payload, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      return {
+        success: true,
+        provider: 'whatsapp',
+        service: 'API',
+        messageId: response.data.messages[0].id,
+        timestamp: new Date(),
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider: 'whatsapp',
+        service: 'API',
+        error: error.message,
+        timestamp: new Date(),
+      };
+    }
+  }
+
+  validateConfig(config: any): boolean {
+    return !!(
+      config.accessToken &&
+      config.phoneNumberId
+    );
+  }
+}

package/src/module/meta/entity.module.ts

@@ -80,7 +80,7 @@ import { CommonService } from './service/common.service';
     EntityMasterService,
     EntityServiceImpl,
     EntityDynamicService,
-    CommonService,
+    { provide: 'CommonService', useClass: CommonService },
     AttributeMasterRepository,
     PreferenceService,
     PreferenceRepository,
@@ -132,6 +132,7 @@ import { CommonService } from './service/common.service';
     MasterService,
     ResolverService,
     EntityDynamicService,
+    'CommonService',
   ],
   controllers: [
     EntityController,

package/src/module/user/controller/login.controller.ts

@@ -15,6 +15,7 @@ import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
 import { Request, Response } from 'express';
 import { UserSessionService } from '../service/user-session.service';
 import { ConfigService } from '@nestjs/config';
+import { CommunicationService } from '../../communication/service/communication.service';
 
 @Controller('auth')
 export class LoginController {
@@ -22,6 +23,7 @@ export class LoginController {
     private loginService: LoginService,
     private userSessionService: UserSessionService,
     private configService: ConfigService,
+    private communicationService: CommunicationService,
   ) {}
 
   @Post('login')
@@ -42,7 +44,7 @@ export class LoginController {
     @Req() request: Request & { user: any },
     @Res() response: Response,
   ) {
-    let requestUser: any = request.user.userData;
+    const requestUser: any = request.user.userData;
     response
       .status(HttpStatus.OK)
       .json(await this.loginService.logout(requestUser.sessionToken));
@@ -58,9 +60,38 @@ export class LoginController {
   @Get('google/callback')
   @UseGuards(GoogleAuthGuard)
   async googleAuthRedirect(@Req() req: any, @Res() res: Response) {
-    let { email, name } = req.user; // Extracted from Google Strategy
+    const { email, name, accessToken: googleAccessToken, refreshToken: googleRefreshToken } = req.user;
+    const { state } = req.query;
 
-    // Call LoginService to validate user, create session, and return JWT
+    // Check if this is a Gmail configuration request
+    if (state && typeof state === 'string' && state.startsWith('gmail_config:')) {
+      try {
+        // Extract the actual state from the prefixed state
+        const actualState = state.replace('gmail_config:', '');
+        
+        // Forward to communication service for Gmail config handling using already exchanged tokens
+        const result = await this.communicationService.handleGmailTokensCallback(
+          email, 
+          googleAccessToken, 
+          googleRefreshToken, 
+          actualState
+        );
+        
+        return res.status(200).json({
+          success: true,
+          message: 'Gmail configuration saved successfully',
+          hubId: result.hubId,
+          configId: result.configId,
+        });
+      } catch (error) {
+        return res.status(500).json({
+          success: false,
+          error: error.message,
+        });
+      }
+    }
+
+    // Original login flow
     const data = await this.loginService.loginWithGoogle(email, name);
 
     if (!('accessToken' in data) || !data.accessToken)

package/src/module/workflow/service/populate-workflow.service.ts

@@ -36,7 +36,7 @@ export class PopulateWorkflowService extends EntityServiceImpl {
   //         service: 'stageGroupService',
   //       },
   //       { table: 'cr_wf_stage', entityType: 'WFS', service: 'stageService' },
-  //       { table: 'cr_wf_action', entityType: 'WFA', service: 'actionService' },
+  //       { table: 'cr_wf_action', entityType: 'WFAC', service: 'actionService' },
   //     ];
 
   //     const getAllFactoryData = async (table: { table: string }) => {
@@ -136,7 +136,7 @@ export class PopulateWorkflowService extends EntityServiceImpl {
         service: 'stageGroupService',
       },
       { table: 'cr_wf_stage', entityType: 'WFS', service: 'stageService' },
-      { table: 'cr_wf_action', entityType: 'WFA', service: 'actionService' },
+      { table: 'cr_wf_action', entityType: 'WFAC', service: 'actionService' },
     ];
 
     // Fetch all base data
@@ -308,7 +308,7 @@ export class PopulateWorkflowService extends EntityServiceImpl {
             organization_id,
             action_requirement: matchedNewMandatory?.id ?? null,
             level_id: organization_id,
-            entity_type: 'WFA',
+            entity_type: 'WFAC',
             form: formActionCategory.length > 0 ? formViewMaster[0]?.id : null,
             status: statusValue,
           },

package/src/module/workflow/service/stage.service.ts

@@ -81,7 +81,7 @@ export class StageService extends EntityServiceImpl {
     if (getAllStageAction.length > 0) {
       for (const action of getAllStageAction) {
         await this.actionService.deleteEntity(
-          'WFA',
+          'WFAC',
           action.action_id,
           loggedInUser,
         );

package/src/resources/dev.properties.yaml

@@ -10,6 +10,7 @@ SECRET_KEY: '1hard_to_guess_secret7890a'
 CLIENT_ID: '819281384645-2tnuvm80sul1n2ahqa4eg6kjd19pnbu9.apps.googleusercontent.com'
 CLIENT_SECRET: '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'
 CALLBACK_URL: 'http://localhost:5001/auth/google/callback'
+BASE_URL: 'http://localhost:5001'
 OTP_EXPIRY: '10'
 OTP_LENGTH: '6'
 VERIFY_OTP: 'false'