rez_core 2.2.180 → 2.2.181

package/package.json

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

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

@@ -112,10 +112,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

@@ -327,8 +327,8 @@ 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 +342,272 @@ 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> {

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,