rez_core 2.2.190 → 2.2.192

package/package.json

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

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

@@ -38,10 +38,12 @@ import { SmsFactory } from './factories/sms.factory';
 import { WhatsAppFactory } from './factories/whatsapp.factory';
 import { TelephoneFactory } from './factories/telephone.factory';
 import { CommunicationFactory } from './factories/communication.factory';
+import { GoogleController } from './controller/calender-event.controller';
+import { GoogleService } from './service/calendar-event.service';
 
 @Module({
   imports: [TypeOrmModule.forFeature([CommunicationConfig, CommunicationHub])],
-  controllers: [CommunicationController],
+  controllers: [CommunicationController, GoogleController],
   providers: [
     // Main Services
     CommunicationService,
@@ -75,6 +77,8 @@ import { CommunicationFactory } from './factories/communication.factory';
     WhatsAppFactory,
     TelephoneFactory,
     CommunicationFactory,
+
+    GoogleService,
   ],
   exports: [
     CommunicationService,

package/src/module/communication/controller/calender-event.controller.ts

@@ -0,0 +1,31 @@
+// src/google/google.controller.ts
+import { Body, Controller, Param, Patch, Post } from '@nestjs/common';
+import { GoogleService } from '../service/calendar-event.service';
+
+@Controller('google/calendar')
+export class GoogleController {
+  constructor(private readonly googleService: GoogleService) {}
+
+  /**
+   * Create calendar event
+   */
+  @Post('create')
+  async createEvent(
+    @Body('googleCred') googleCred: any,
+    @Body('payload') payload: any,
+  ) {
+    return this.googleService.createEvent(googleCred, payload);
+  }
+
+  /**
+   * Update calendar event
+   */
+  @Patch('update/:eventId')
+  async updateEvent(
+    @Param('eventId') eventId: string,
+    @Body('googleCred') googleCred: any,
+    @Body('payload') payload: any,
+  ) {
+    return this.googleService.updateEvent(googleCred, eventId, payload);
+  }
+}

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

@@ -20,6 +20,7 @@ import {
   GmailOAuthInitDto,
   OutlookOAuthInitDto,
   SendGridVerifiedSendersDto,
+  UpdateConfigDto,
   UpdateConfigStatusDto,
 } from '../dto/create-config.dto';
 
@@ -150,6 +151,39 @@ export class CommunicationController {
     });
   }
 
+  @Get('config/:id')
+  async getCommunicationConfigById(@Param('id', ParseIntPipe) hubId: number) {
+    try {
+      const config =
+        await this.communicationService.getCommunicationConfigById(hubId);
+
+      if (!config) {
+        throw new BadRequestException({
+          success: false,
+          error: 'NOT_FOUND',
+          message: 'Communication configuration not found',
+          code: 'CONFIGURATION_NOT_FOUND',
+        });
+      }
+
+      return {
+        success: true,
+        data: config,
+      };
+    } catch (error) {
+      if (error instanceof BadRequestException) {
+        throw error;
+      }
+
+      throw new BadRequestException({
+        success: false,
+        error: 'FETCH_ERROR',
+        message: error.message || 'Failed to fetch communication configuration',
+        code: 'INTERNAL_ERROR',
+      });
+    }
+  }
+
   @Put('config/:id/status')
   async updateConfigStatus(
     @Param('id', ParseIntPipe) hubId: number,
@@ -221,4 +255,32 @@ export class CommunicationController {
       });
     }
   }
+
+  @Post('config/update/:hubId')
+  @HttpCode(HttpStatus.OK)
+  async updateConfig(
+    @Param('hubId', ParseIntPipe) hubId: number,
+    @Body() updateDto: UpdateConfigDto,
+  ) {
+    try {
+      const result = await this.communicationService.updateConfiguration(
+        hubId,
+        updateDto,
+      );
+
+      return {
+        success: true,
+        message: 'Communication configuration updated successfully',
+        data: result,
+      };
+    } catch (error) {
+      throw new BadRequestException({
+        success: false,
+        error: 'UPDATE_ERROR',
+        message:
+          error.message || 'Failed to update communication configuration',
+        code: 'CONFIGURATION_ERROR',
+      });
+    }
+  }
 }

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

@@ -115,6 +115,77 @@ export class UpdateConfigStatusDto {
   status: number;
 }
 
+export class UpdateConfigDto {
+  @IsOptional()
+  @IsObject()
+  config?: {
+    // OAuth Control
+    useOAuth?: boolean;
+
+    // Gmail API Config
+    clientId?: string;
+    clientSecret?: string;
+    refreshToken?: string;
+    accessToken?: string;
+
+    // Outlook API Config
+    tenantId?: string;
+
+    // WhatsApp Config
+    phoneNumberId?: string;
+    apiVersion?: string;
+
+    // Twilio Config
+    accountSid?: string;
+    authToken?: string;
+    fromNumber?: string;
+
+    // AWS SES Config
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    region?: string;
+    fromEmail?: string;
+
+    // SMTP Config (Gmail, Outlook, Generic)
+    email?: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    user?: string;
+    from?: string;
+    tls?: any;
+
+    // SendGrid SMTP Config
+    apiKey?: string;
+    templateId?: string;
+    dynamicTemplateData?: any;
+
+    // Knowlarity Config
+    callerNumber?: string;
+    apiSecret?: string;
+    baseUrl?: string;
+    callType?: 'voice' | 'sms';
+    voiceMessage?: string;
+    language?: string;
+
+    // Common optional fields
+    [key: string]: any;
+  };
+
+  @IsOptional()
+  @IsNumber()
+  priority?: number;
+
+  @IsOptional()
+  @IsBoolean()
+  is_default?: boolean;
+
+  @IsOptional()
+  @IsNumber()
+  status?: number;
+}
+
 export class GenericSendMessageDto {
   @IsNotEmpty()
   @IsNumber()

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

@@ -2,10 +2,14 @@ import { Injectable } from '@nestjs/common';
 import { BaseFactory } from './base.factory';
 import { CommunicationStrategy } from '../strategies/communication.strategy';
 import { WhatsAppStrategy } from '../strategies/whatsapp.strategy';
+import { WhatsAppCloudStrategy } from '../strategies/whatsapp/whatsapp-cloud.strategy';
 
 @Injectable()
 export class WhatsAppFactory implements BaseFactory {
-  constructor(private whatsappStrategy: WhatsAppStrategy) {}
+  constructor(
+    private whatsappStrategy: WhatsAppStrategy,
+    private whatsappCloudStrategy: WhatsAppCloudStrategy,
+  ) {}
 
   createProvider(service: string, provider: string): CommunicationStrategy {
     const key = `${service.toLowerCase()}_${provider.toLowerCase()}`;
@@ -13,6 +17,9 @@ export class WhatsAppFactory implements BaseFactory {
     switch (key) {
       case 'api_whatsapp':
         return this.whatsappStrategy;
+      case 'api_whatsapp-cloud':
+      case 'api_meta':
+        return this.whatsappCloudStrategy;
 
       default:
         throw new Error(
@@ -22,7 +29,11 @@ export class WhatsAppFactory implements BaseFactory {
   }
 
   getSupportedCombinations(): Array<{ service: string; provider: string }> {
-    return [{ service: 'API', provider: 'whatsapp' }];
+    return [
+      { service: 'API', provider: 'whatsapp' },
+      { service: 'API', provider: 'whatsapp-cloud' },
+      { service: 'API', provider: 'meta' },
+    ];
   }
 
   validateCombination(service: string, provider: string): boolean {

package/src/module/communication/service/calendar-event.service.ts

@@ -0,0 +1,123 @@
+// src/google/google.service.ts
+import { Injectable, Logger } from '@nestjs/common';
+import axios from 'axios';
+import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
+
+@Injectable()
+export class GoogleService {
+  private readonly logger = new Logger(GoogleService.name);
+
+  constructor(private readonly gmailApiStrategy: GmailApiStrategy) {}
+
+  /**
+   * Create a Google Calendar event
+   */
+  async createEvent(googleCred: any, payload: any) {
+    if (!googleCred?.refreshToken) {
+      throw new Error('Missing refresh token');
+    }
+
+    try {
+      const accessToken =
+        await this.gmailApiStrategy.refreshAccessToken(googleCred);
+
+      const event = {
+        summary: payload.title,
+        description: payload.description,
+        location: payload.location,
+        start: {
+          dateTime: payload.startTime,
+          timeZone: payload.timeZone || 'Asia/Kolkata',
+        },
+        end: {
+          dateTime: payload.endTime,
+          timeZone: payload.timeZone || 'Asia/Kolkata',
+        },
+        attendees: payload.attendees?.map((email) => ({ email })) || [],
+      };
+
+      const response = await axios.post(
+        'https://www.googleapis.com/calendar/v3/calendars/primary/events?sendUpdates=all',
+        event,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+
+      this.logger.log(`Event created: ${response.data.id}`);
+      return {
+        success: true,
+        eventId: response.data.id,
+        htmlLink: response.data.htmlLink,
+        accessToken,
+      };
+    } catch (error: any) {
+      this.logger.error('CreateEvent error', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.error?.message || error.message,
+      };
+    }
+  }
+
+  /**
+   * Update a Google Calendar event
+   */
+  async updateEvent(googleCred: any, eventId: string, payload: any) {
+    if (!googleCred?.refreshToken) {
+      throw new Error('Missing refresh token');
+    }
+
+    try {
+      const accessToken =
+        await this.gmailApiStrategy.refreshAccessToken(googleCred);
+
+      const event = {
+        summary: payload.title,
+        description: payload.description,
+        location: payload.location,
+        start: {
+          dateTime: payload.startTime,
+          timeZone: payload.timeZone || 'Asia/Kolkata',
+        },
+        end: {
+          dateTime: payload.endTime,
+          timeZone: payload.timeZone || 'Asia/Kolkata',
+        },
+        attendees: payload.attendees?.map((email) => ({ email })) || [],
+      };
+
+      if (payload.meetingType === 'online' && payload.meetingLink) {
+        event.description = `${event.description || ''}\nJoin here: ${payload.meetingLink}`;
+      }
+
+      const response = await axios.patch(
+        `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}?sendUpdates=all`,
+        event,
+        {
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+
+      this.logger.log(`Event updated: ${response.data.id}`);
+      return {
+        success: true,
+        eventId: response.data.id,
+        htmlLink: response.data.htmlLink,
+        accessToken,
+      };
+    } catch (error: any) {
+      this.logger.error('UpdateEvent error', error.message);
+      return {
+        success: false,
+        error: error.response?.data?.error?.message || error.message,
+      };
+    }
+  }
+}

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

@@ -1,6 +1,6 @@
 import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { Repository, Not } from 'typeorm';
 import { ConfigService } from '@nestjs/config';
 import { google } from 'googleapis';
 import {
@@ -339,7 +339,7 @@ export class CommunicationService {
   ): Promise<
     Array<CommunicationHub & { linkedSource?: string; configDetails?: any }>
   > {
-    const where: any = { level_id: levelId, level_type: levelType, status: 1 };
+    const where: any = { level_id: levelId, level_type: levelType };
 
     if (filters?.communication_config_type) {
       where.communication_config_type = filters.communication_config_type;
@@ -669,6 +669,95 @@ export class CommunicationService {
     );
   }
 
+  async updateConfiguration(
+    hubId: number,
+    updateData: {
+      config?: any;
+      priority?: number;
+      is_default?: boolean;
+      status?: number;
+    },
+  ): Promise<CommunicationHub & { config?: any }> {
+    // Find the existing hub
+    const hub = await this.hubRepository.findOne({
+      where: { id: hubId },
+    });
+
+    if (!hub) {
+      throw new Error('Communication configuration not found');
+    }
+
+    // Update configuration JSON if provided
+    if (updateData.config) {
+      const existingConfig = await this.configRepository.findOne({
+        where: { id: hub.config_id },
+      });
+
+      if (!existingConfig) {
+        throw new Error('Configuration record not found');
+      }
+
+      // Merge the new config with existing config
+      const updatedConfigJson = {
+        ...existingConfig.config_json,
+        ...updateData.config,
+      };
+
+      await this.configRepository.update(hub.config_id, {
+        config_json: updatedConfigJson,
+      });
+    }
+
+    // Handle default configuration logic
+    if (updateData.is_default === true) {
+      // Remove default from other configurations of same type and level
+      await this.hubRepository.update(
+        {
+          level_id: hub.level_id,
+          level_type: hub.level_type,
+          communication_config_type: hub.communication_config_type,
+          id: Not(hubId), // Exclude current hub
+        },
+        { is_default: false },
+      );
+    }
+
+    // Update hub metadata
+    const hubUpdateData: any = {};
+    if (updateData.priority !== undefined) {
+      hubUpdateData.priority = updateData.priority;
+    }
+    if (updateData.is_default !== undefined) {
+      hubUpdateData.is_default = updateData.is_default;
+    }
+    if (updateData.status !== undefined) {
+      hubUpdateData.status = updateData.status;
+    }
+
+    // Apply hub updates if any
+    if (Object.keys(hubUpdateData).length > 0) {
+      await this.hubRepository.update(hubId, hubUpdateData);
+    }
+
+    // Fetch and return updated hub with config
+    const updatedHub = await this.hubRepository.findOne({
+      where: { id: hubId },
+    });
+
+    const updatedConfig = await this.configRepository.findOne({
+      where: { id: hub.config_id },
+    });
+
+    this.logger.log(
+      `Communication configuration updated: Hub ${hubId}, Type ${hub.communication_config_type}`,
+    );
+
+    return {
+      ...updatedHub!,
+      config: updatedConfig?.config_json,
+    };
+  }
+
   async sendGenericMessage(
     messageDto: GenericMessageDto,
   ): Promise<CommunicationResult> {
@@ -1651,4 +1740,66 @@ export class CommunicationService {
       throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
     }
   }
+
+  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({
+        where: { id: hubId },
+      });
+
+      if (!hub) {
+        return null;
+      }
+
+      // Find the associated config
+      const config = await this.configRepository.findOne({
+        where: { id: hub.config_id },
+      });
+
+      if (!config) {
+        this.logger.warn(
+          `Configuration not found for hub ${hubId} with config_id ${hub.config_id}`,
+        );
+        return {
+          ...hub,
+          config: null as any,
+          linkedSource: 'Configuration not found',
+          configDetails: null,
+        };
+      }
+
+      // Extract linked source and config details
+      const linkedSource = this.extractLinkedSource(
+        hub.communication_config_type,
+        hub.service,
+        hub.provider,
+        config.config_json,
+      );
+
+      const configDetails = this.extractConfigDetails(
+        hub.communication_config_type,
+        hub.service,
+        hub.provider,
+        config.config_json,
+      );
+
+      return {
+        ...hub,
+        config,
+        linkedSource,
+        configDetails,
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error fetching communication config by ID ${hubId}:`,
+        error.message,
+      );
+      throw new Error(
+        `Failed to fetch communication configuration: ${error.message}`,
+      );
+    }
+  }
 }