rez_core 2.2.180 → 2.2.182

package/package.json

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

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

@@ -85,7 +85,8 @@ export class CommunicationController {
   async getLevelConfigs(
     @Param('id', ParseIntPipe) levelId: number,
     @Param('type') levelType: string,
-    @Query('communication_config_type') configType?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE',
+    @Query('communication_config_type')
+    configType?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE',
     @Query('service') service?: 'API' | 'THIRD_PARTY' | 'SMTP',
     @Query('provider') provider?: string,
   ) {
@@ -112,10 +113,10 @@ export class CommunicationController {
   @HttpCode(HttpStatus.OK)
   async activateConfig(
     @Param('id', ParseIntPipe) hubId: number,
-    @Param('status', ParseIntPipe) status: number,
+    @Query('status') status: number,
   ) {
     await this.communicationService.updateConfigStatus(hubId, status);
-    return { message: 'Configuration activated successfully' };
+    return { message: 'Configuration updated' };
   }
 
   @Post('gmail/oauth/init')

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

@@ -146,7 +146,11 @@ export class CommunicationService {
   ): Promise<CommunicationHubWithConfig[]> {
     let query = this.hubRepository
       .createQueryBuilder('hub')
-      .leftJoin('cr_communication_config', 'config', 'config.id = hub.config_id')
+      .leftJoin(
+        'cr_communication_config',
+        'config',
+        'config.id = hub.config_id',
+      )
       .select([
         'hub.id as hub_id',
         'hub.level_id as hub_level_id',
@@ -219,7 +223,11 @@ export class CommunicationService {
       hub.provider,
     );
 
-    const result = await strategy.sendMessage(to, message, hub.config.config_json);
+    const result = await strategy.sendMessage(
+      to,
+      message,
+      hub.config.config_json,
+    );
 
     // If token was refreshed, update it in the database
     if (result.refreshedToken && result.success) {
@@ -229,11 +237,11 @@ export class CommunicationService {
           ...currentConfig,
           accessToken: result.refreshedToken,
         };
-        
+
         await this.configRepository.update(hub.config.id, {
           config_json: updatedConfig,
         } as any);
-        
+
         this.logger.log(
           `Updated access token for ${hub.provider}/${hub.service} configuration`,
         );
@@ -309,13 +317,11 @@ export class CommunicationService {
     );
   }
 
-  async getSupportedCombinations(): Promise<
-    {
-      mode: string;
-      service: string;
-      provider: string;
-    }[]
-  > {
+  getSupportedCombinations(): {
+    mode: string;
+    service: string;
+    provider: string;
+  }[] {
     return this.communicationFactory.getAllSupportedCombinations();
   }
 
@@ -327,8 +333,10 @@ export class CommunicationService {
       service?: 'API' | 'THIRD_PARTY' | 'SMTP';
       provider?: string;
     },
-  ): Promise<CommunicationHub[]> {
-    const where: any = { level_id: levelId, level_type: levelType };
+  ): Promise<
+    Array<CommunicationHub & { linkedSource?: string; configDetails?: any }>
+  > {
+    const where: any = { level_id: levelId, level_type: levelType, status: 1 };
 
     if (filters?.communication_config_type) {
       where.communication_config_type = filters.communication_config_type;
@@ -342,10 +350,297 @@ export class CommunicationService {
       where.provider = filters.provider;
     }
 
-    return this.hubRepository.find({
+    const hubs = await this.hubRepository.find({
       where,
       order: { created_at: 'DESC' },
     });
+
+    // Enhance hubs with linked source information
+    const enhancedHubs = await Promise.all(
+      hubs.map(async (hub) => {
+        try {
+          const config = await this.configRepository.findOne({
+            where: { id: hub.config_id },
+          });
+
+          if (!config) {
+            return {
+              ...hub,
+              linkedSource: 'Configuration not found',
+              configDetails: null,
+            };
+          }
+
+          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,
+            linkedSource,
+            configDetails,
+          };
+        } catch (error) {
+          this.logger.warn(
+            `Error extracting linked source for hub ${hub.id}:`,
+            error.message,
+          );
+          return {
+            ...hub,
+            linkedSource: 'Error retrieving source',
+            configDetails: null,
+          };
+        }
+      }),
+    );
+
+    return enhancedHubs;
+  }
+
+  private extractLinkedSource(
+    configType: string,
+    service: string,
+    provider: string,
+    configJson: any,
+  ): string {
+    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+
+    try {
+      switch (key) {
+        // Gmail configurations
+        case 'email_api_gmail':
+        case 'email_smtp_gmail':
+          return configJson?.email || 'Gmail account not configured';
+
+        // Outlook configurations
+        case 'email_api_outlook':
+        case 'email_smtp_outlook':
+          return configJson?.email || 'Outlook account not configured';
+
+        // WhatsApp configurations
+        case 'wa_api_whatsapp':
+          return configJson?.phoneNumberId
+            ? `WhatsApp Business: ${configJson.phoneNumberId}`
+            : 'WhatsApp not configured';
+
+        // SMS configurations
+        case 'sms_third_party_twilio':
+          return configJson?.fromNumber
+            ? `Twilio: ${configJson.fromNumber}`
+            : 'Twilio number not configured';
+
+        case 'sms_third_party_knowlarity':
+          return configJson?.callerNumber
+            ? `Knowlarity: ${configJson.callerNumber}`
+            : 'Knowlarity number not configured';
+
+        // Telephone configurations
+        case 'telephone_third_party_knowlarity':
+          return configJson?.callerNumber
+            ? `Knowlarity Voice: ${configJson.callerNumber}`
+            : 'Knowlarity voice number not configured';
+
+        // AWS SES configurations
+        case 'email_api_aws-ses':
+        case 'email_api_ses':
+          return configJson?.fromEmail || 'AWS SES not configured';
+
+        // SendGrid configurations
+        case 'email_smtp_sendgrid':
+          return configJson?.from || 'SendGrid not configured';
+
+        // Generic SMTP configurations
+        case 'email_smtp_custom':
+        case 'email_smtp_generic':
+          return configJson?.from || configJson?.user || 'SMTP not configured';
+
+        default:
+          // Generic fallback - try to find common identifier fields
+          if (configJson?.email) return configJson.email;
+          if (configJson?.from) return configJson.from;
+          if (configJson?.user) return configJson.user;
+          if (configJson?.phoneNumberId) return configJson.phoneNumberId;
+          if (configJson?.fromNumber) return configJson.fromNumber;
+          if (configJson?.callerNumber) return configJson.callerNumber;
+
+          return `${provider} configured`;
+      }
+    } catch (error) {
+      return 'Configuration error';
+    }
+  }
+
+  private extractConfigDetails(
+    configType: string,
+    service: string,
+    provider: string,
+    configJson: any,
+  ): any {
+    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+
+    try {
+      switch (key) {
+        // Gmail configurations
+        case 'email_api_gmail':
+          return {
+            email: configJson?.email,
+            authMethod: configJson?.authMethod || 'OAUTH2',
+            hasRefreshToken: !!configJson?.refreshToken,
+            isExpired: configJson?.expiryDate
+              ? new Date(configJson.expiryDate) < new Date()
+              : false,
+          };
+
+        case 'email_smtp_gmail':
+          return {
+            email: configJson?.email,
+            authMethod: 'SMTP',
+            hasPassword: !!configJson?.password,
+          };
+
+        // Outlook configurations
+        case 'email_api_outlook':
+          return {
+            email: configJson?.email,
+            authMethod: 'OAUTH2',
+            hasRefreshToken: !!configJson?.refreshToken,
+            tenantId: configJson?.tenantId,
+          };
+
+        case 'email_smtp_outlook':
+          return {
+            email: configJson?.email,
+            authMethod: 'SMTP',
+            hasPassword: !!configJson?.password,
+          };
+
+        // WhatsApp configurations
+        case 'wa_api_whatsapp':
+          return {
+            phoneNumberId: configJson?.phoneNumberId,
+            apiVersion: configJson?.apiVersion || 'v17.0',
+            hasAccessToken: !!configJson?.accessToken,
+          };
+
+        // SMS configurations
+        case 'sms_third_party_twilio':
+          return {
+            fromNumber: configJson?.fromNumber,
+            accountSid: configJson?.accountSid
+              ? configJson.accountSid.substring(0, 8) + '...'
+              : null,
+            hasAuthToken: !!configJson?.authToken,
+          };
+
+        case 'sms_third_party_knowlarity':
+          return {
+            callerNumber: configJson?.callerNumber,
+            callType: configJson?.callType || 'sms',
+            hasApiSecret: !!configJson?.apiSecret,
+          };
+
+        // Telephone configurations
+        case 'telephone_third_party_knowlarity':
+          return {
+            callerNumber: configJson?.callerNumber,
+            callType: configJson?.callType || 'voice',
+            language: configJson?.language || 'en',
+            hasApiSecret: !!configJson?.apiSecret,
+          };
+
+        // AWS SES configurations
+        case 'email_api_aws-ses':
+        case 'email_api_ses':
+          return {
+            fromEmail: configJson?.fromEmail,
+            region: configJson?.region,
+            hasCredentials: !!(
+              configJson?.accessKeyId && configJson?.secretAccessKey
+            ),
+          };
+
+        // SendGrid configurations
+        case 'email_smtp_sendgrid':
+          return {
+            from: configJson?.from,
+            hasApiKey: !!configJson?.apiKey,
+            templateId: configJson?.templateId,
+          };
+
+        // Generic SMTP configurations
+        case 'email_smtp_custom':
+        case 'email_smtp_generic':
+          return {
+            host: configJson?.host,
+            port: configJson?.port || 587,
+            secure: configJson?.secure || false,
+            from: configJson?.from || configJson?.user,
+            hasCredentials: !!(configJson?.user && configJson?.password),
+          };
+
+        default:
+          // Generic details - return safe subset of config
+          const safeConfig: any = {};
+
+          // Include non-sensitive fields
+          const safeFields = [
+            'email',
+            'from',
+            'user',
+            'host',
+            'port',
+            'secure',
+            'phoneNumberId',
+            'fromNumber',
+            'callerNumber',
+            'region',
+            'apiVersion',
+            'callType',
+            'language',
+            'templateId',
+          ];
+
+          safeFields.forEach((field) => {
+            if (configJson?.[field]) {
+              safeConfig[field] = configJson[field];
+            }
+          });
+
+          // Include boolean indicators for sensitive fields
+          const sensitiveFields = [
+            'accessToken',
+            'refreshToken',
+            'password',
+            'authToken',
+            'apiKey',
+            'apiSecret',
+            'clientSecret',
+            'secretAccessKey',
+          ];
+
+          sensitiveFields.forEach((field) => {
+            if (configJson?.[field]) {
+              safeConfig[
+                `has${field.charAt(0).toUpperCase() + field.slice(1)}`
+              ] = true;
+            }
+          });
+
+          return safeConfig;
+      }
+    } catch (error) {
+      return { error: 'Unable to extract configuration details' };
+    }
   }
 
   async updateConfigStatus(hubId: number, status: number): Promise<void> {
@@ -385,7 +680,7 @@ export class CommunicationService {
 
       if (!hubs.length) {
         this.logger.warn(
-          `No communication hubs found for ${levelType} ${levelId}. Please configure communication providers using the createCommunicationConfig method.`
+          `No communication hubs found for ${levelType} ${levelId}. Please configure communication providers using the createCommunicationConfig method.`,
         );
         throw new Error(
           `No active ${communicationType} configuration found for ${levelType} ${levelId}. Please configure a communication provider first.`,
@@ -1293,7 +1588,11 @@ export class CommunicationService {
 
   async queueMessage(
     messageDto: GenericMessageDto & { useQueue?: boolean; scheduledFor?: Date },
-  ): Promise<{ queued: boolean; messageId?: string; result?: CommunicationResult }> {
+  ): Promise<{
+    queued: boolean;
+    messageId?: string;
+    result?: CommunicationResult;
+  }> {
     if (!this.queueService || !messageDto.useQueue) {
       // Fallback to immediate sending if queue is not available or not requested
       const result = await this.sendGenericMessage(messageDto);
@@ -1325,7 +1624,10 @@ export class CommunicationService {
 
       return { queued: true, messageId };
     } catch (error) {
-      this.logger.error('Error queuing message, falling back to immediate send:', error.message);
+      this.logger.error(
+        'Error queuing message, falling back to immediate send:',
+        error.message,
+      );
       // Fallback to immediate sending
       const result = await this.sendGenericMessage(messageDto);
       return { queued: false, result };
@@ -1361,7 +1663,10 @@ export class CommunicationService {
 
       return { queued: true, messageIds };
     } catch (error) {
-      this.logger.error('Error queuing bulk message, falling back to immediate send:', error.message);
+      this.logger.error(
+        'Error queuing bulk message, falling back to immediate send:',
+        error.message,
+      );
       // Fallback to immediate sending
       const result = await this.sendBulkMessage(bulkDto);
       return { queued: false, result };
@@ -1391,7 +1696,9 @@ export class CommunicationService {
     return this.queueService.cancelMessage(messageId);
   }
 
-  private mapPriorityToSimpleQueue(priority?: string): 'high' | 'medium' | 'low' {
+  private mapPriorityToSimpleQueue(
+    priority?: string,
+  ): 'high' | 'medium' | 'low' {
     switch (priority?.toLowerCase()) {
       case 'high':
       case 'urgent':

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

@@ -31,7 +31,6 @@ export class UserController {
   @HttpCode(HttpStatus.OK)
   async checkEmail(@Body() body, @Res() res: Response) {
     const { email_id, subdomain } = body;
-    console.log(body, 'body-----------------------------body');
     const result = await this.userService.checkEmailExists({
       email_id,
       subdomain,