rez_core 2.2.177 → 2.2.180

package/package.json

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

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

@@ -327,7 +327,7 @@ export class CommunicationService {
       service?: 'API' | 'THIRD_PARTY' | 'SMTP';
       provider?: string;
     },
-  ): Promise<Array<CommunicationHub & { linkedSource?: string; configDetails?: any }>> {
+  ): Promise<CommunicationHub[]> {
     const where: any = { level_id: levelId, level_type: levelType };
 
     if (filters?.communication_config_type) {
@@ -342,272 +342,10 @@ export class CommunicationService {
       where.provider = filters.provider;
     }
 
-    const hubs = await this.hubRepository.find({
+    return 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

@@ -30,9 +30,10 @@ export class UserController {
   @Post('check-email')
   @HttpCode(HttpStatus.OK)
   async checkEmail(@Body() body, @Res() res: Response) {
-    const { email, subdomain } = body;
+    const { email_id, subdomain } = body;
+    console.log(body, 'body-----------------------------body');
     const result = await this.userService.checkEmailExists({
-      email,
+      email_id,
       subdomain,
     });
     return res.status(HttpStatus.OK).json(result);

package/src/module/user/service/user.service.ts

@@ -302,14 +302,12 @@ export class UserService extends EntityServiceImpl {
   }
 
   async checkEmailExists(data: {
-    email: string;
+    email_id: string;
     subdomain: string;
   }): Promise<any> {
-    const { email, subdomain } = data;
+    const { email_id, subdomain } = data;
 
-    console.log('Email and Subdomain', email, subdomain);
-
-    if (!email || !subdomain) {
+    if (!email_id || !subdomain) {
       return { success: false, message: 'Email and Subdomain is required' };
     }
 
@@ -326,10 +324,8 @@ export class UserService extends EntityServiceImpl {
       }
     }
 
-    console.log('Email and Subdomain 2nd', email, subdomain);
-
     // 🔹 Step 2: Find the user by email + organization check
-    const user = await this.userRepository.findByEmailId(email);
+    const user = await this.userRepository.findByEmailId(email_id);
 
     if (!user || (organization && user.organization_id !== organization.id)) {
       throw new BadRequestException('User not found in organization.');

package/.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint"
-    ]
-}