rez_core 2.2.258 → 2.2.259

package/src/module/{communication/service/communication.service.ts → integration/service/integration.service.ts}

@@ -3,29 +3,34 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Not, Repository } from 'typeorm';
 import { ConfigService } from '@nestjs/config';
 import { google } from 'googleapis';
-import {
-  CommunicationConfigType,
-  CommunicationHub,
-} from '../entity/communication-hub.entity';
-import { CommunicationConfig } from '../entity/communication-config.entity';
-import { CommunicationFactory } from '../factories/communication.factory';
-import { CommunicationResult } from '../strategies/communication.strategy';
+import { IntegrationConfig } from '../entity/integration-config.entity';
+import { UserIntegration } from '../entity/user-integration.entity';
+import { IntegrationFactory } from '../factories/integration.factory';
+import { IntegrationResult } from '../strategies/integration.strategy';
 import { GmailApiStrategy } from '../strategies/email/gmail-api.strategy';
 import { SendGridApiStrategy } from '../strategies/email/sendgrid-api.strategy';
-import { CommunicationQueueService } from './communication-queue.service';
+import { IntegrationQueueService } from './integration-queue.service';
+import {
+  BulkMessageDto,
+  CreateUserIntegrationDto,
+  UpdateUserIntegrationDto,
+} from '../dto/create-config.dto';
 
 export interface SendMessageDto {
   levelId: number;
   levelType: string;
+  app_code: string;
   to: string;
   message: string;
-  mode?: CommunicationConfigType;
+  mode?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
   priority?: number;
+  user_id?: number;
 }
 
 export interface GenericMessageDto {
   levelId: number;
   levelType: string;
+  app_code: string;
   to: string | string[];
   message: string;
   subject?: string;
@@ -38,29 +43,17 @@ export interface GenericMessageDto {
   mediaUrl?: string;
   templateId?: string;
   variables?: Record<string, any>;
+  user_id?: number;
 }
 
-export interface BulkMessageDto {
-  levelId: number;
-  levelType: string;
-  recipients: string[];
-  message: string;
-  subject?: string;
-  type?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
-  priority?: 'high' | 'medium' | 'low';
-  html?: string;
-  templateId?: string;
-  variables?: Record<string, any>;
-  batchSize?: number;
-}
-
-export interface CommunicationHubWithConfig extends CommunicationHub {
-  config: CommunicationConfig;
+export interface IntegrationConfigWithConfig extends IntegrationConfig {
+  config?: any;
 }
 
 interface GmailOAuthState {
   levelId: number;
   levelType: string;
+  app_code: string;
   email?: string;
   timestamp: number;
 }
@@ -71,63 +64,78 @@ export interface GmailSSOResult {
 }
 
 @Injectable()
-export class CommunicationService {
-  private readonly logger = new Logger(CommunicationService.name);
+export class IntegrationService {
+  private readonly logger = new Logger(IntegrationService.name);
   private readonly gmailOAuthStates = new Map<string, GmailOAuthState>();
 
   constructor(
-    @InjectRepository(CommunicationHub)
-    private readonly hubRepository: Repository<CommunicationHub>,
-
-    @InjectRepository(CommunicationConfig)
-    private readonly configRepository: Repository<CommunicationConfig>,
+    @InjectRepository(IntegrationConfig)
+    private readonly configRepository: Repository<IntegrationConfig>,
+    @InjectRepository(UserIntegration)
+    private readonly userIntegrationRepository: Repository<UserIntegration>,
 
-    private readonly communicationFactory: CommunicationFactory,
+    private readonly integrationFactory: IntegrationFactory,
     private readonly gmailApiStrategy: GmailApiStrategy,
     private readonly sendGridApiStrategy: SendGridApiStrategy,
     private readonly configService: ConfigService,
-    @Inject(forwardRef(() => CommunicationQueueService))
-    private readonly queueService?: CommunicationQueueService,
+    @Inject(forwardRef(() => IntegrationQueueService))
+    private readonly queueService?: IntegrationQueueService,
   ) {}
 
+  private deriveServiceType(
+    integration_type: string,
+    integration_provider: string,
+    config_json: any,
+  ): string {
+    // All integrations use API only (no SMTP support)
+    return 'API';
+  }
+
   async sendMessage({
     levelId,
     levelType,
+    app_code,
     to,
     message,
     mode,
     priority = 1,
-  }: SendMessageDto): Promise<CommunicationResult> {
+    user_id,
+  }: SendMessageDto): Promise<IntegrationResult> {
     try {
-      // Get active communication hubs for the level
-      const hubs = await this.getActiveHubs(levelId, levelType, mode);
+      // Get active communication configs for the level
+      const configs = await this.getActiveConfigs(
+        levelId,
+        levelType,
+        app_code,
+        mode,
+      );
 
-      if (!hubs.length) {
+      if (!configs.length) {
         throw new Error(
           `No active communication configuration found for ${levelType} ${levelId}`,
         );
       }
 
       // Sort by priority if provided
-      const sortedHubs = this.sortHubsByPriority(hubs, priority);
+      const sortedConfigs = this.sortConfigsByPriority(configs, priority);
 
-      // Try each hub until one succeeds
-      for (const hub of sortedHubs) {
+      // Try each config until one succeeds
+      for (const config of sortedConfigs) {
         try {
-          const result = await this.sendViaHub(hub, to, message);
+          const result = await this.sendViaConfig(config, to, message, user_id);
           if (result.success) {
             this.logger.log(
-              `Message sent successfully via ${hub.provider}/${hub.service}`,
+              `Message sent successfully via ${config.integration_provider}`,
             );
             return result;
           }
 
           this.logger.warn(
-            `Failed to send via ${hub.provider}/${hub.service}: ${result.error}`,
+            `Failed to send via ${config.integration_provider}: ${result.error}`,
           );
         } catch (error) {
           this.logger.error(
-            `Error sending via ${hub.provider}/${hub.service}:`,
+            `Error sending via ${config.integration_provider}:`,
             error.message,
           );
           continue;
@@ -141,111 +149,85 @@ export class CommunicationService {
     }
   }
 
-  async getActiveHubs(
+  async getActiveConfigs(
     levelId: number,
     levelType: string,
-    mode?: CommunicationConfigType,
-  ): Promise<CommunicationHubWithConfig[]> {
-    let query = this.hubRepository
-      .createQueryBuilder('hub')
-      .leftJoin(
-        'cr_communication_config',
-        'config',
-        'config.id = hub.config_id',
-      )
-      .select([
-        'hub.id as hub_id',
-        'hub.level_id as hub_level_id',
-        'hub.level_type as hub_level_type',
-        'hub.status as hub_status',
-        'hub.config_id as hub_config_id',
-        'hub.communication_config_type as hub_communication_config_type',
-        'hub.service as hub_service',
-        'hub.provider as hub_provider',
-        'hub.priority as hub_priority',
-        'hub.is_default as hub_is_default',
-        'hub.created_at as hub_created_at',
-        'hub.updated_at as hub_updated_at',
-        'config.id as config_id',
-        'config.config_json as config_json',
-        'config.created_at as config_created_at',
-        'config.updated_at as config_updated_at',
-      ])
-      .where('hub.level_id = :levelId', { levelId })
-      .andWhere('hub.level_type = :levelType', { levelType })
-      .andWhere('hub.status = :status', { status: 1 });
+    app_code: string,
+    mode?: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+  ): Promise<IntegrationConfig[]> {
+    const queryBuilder = this.configRepository
+      .createQueryBuilder('config')
+      .where('config.level_id = :levelId', { levelId })
+      .andWhere('config.level_type = :levelType', { levelType })
+      .andWhere('config.app_code = :app_code', { app_code })
+      .andWhere('config.status = 1');
 
     if (mode) {
-      query = query.andWhere('hub.communication_config_type = :mode', { mode });
+      queryBuilder.andWhere('config.integration_type = :mode', { mode });
     }
 
-    const results = await query.getRawMany();
-
-    // Transform the raw results into the expected format
-    const hubsWithConfig: CommunicationHubWithConfig[] = results.map((row) => ({
-      id: row.hub_id,
-      level_id: row.hub_level_id,
-      level_type: row.hub_level_type,
-      status: row.hub_status,
-      config_id: row.hub_config_id,
-      communication_config_type: row.hub_communication_config_type,
-      service: row.hub_service,
-      provider: row.hub_provider,
-      priority: row.hub_priority || 1,
-      is_default: row.hub_is_default || false,
-      created_at: row.hub_created_at,
-      updated_at: row.hub_updated_at,
-      config: {
-        id: row.config_id,
-        config_json: row.config_json,
-        created_at: row.config_created_at,
-        updated_at: row.config_updated_at,
-      },
-    }));
-
-    return hubsWithConfig;
+    return await queryBuilder.getMany();
   }
 
-  private sortHubsByPriority(
-    hubs: CommunicationHubWithConfig[],
+  private sortConfigsByPriority(
+    configs: IntegrationConfig[],
     _priority: number,
-  ): CommunicationHubWithConfig[] {
-    // For now, just return as-is. In the future, implement priority logic
-    return hubs;
+  ): IntegrationConfig[] {
+    return configs.sort((a, b) => {
+      // First sort by default (true comes first)
+      if (a.is_default !== b.is_default) {
+        return a.is_default ? -1 : 1;
+      }
+      // Then by priority (lower number = higher priority)
+      return a.priority - b.priority;
+    });
   }
 
-  private async sendViaHub(
-    hub: CommunicationHubWithConfig,
+  private async sendViaConfig(
+    config: IntegrationConfig,
     to: string,
     message: string,
-  ): Promise<CommunicationResult> {
-    const strategy = this.communicationFactory.create(
-      hub.communication_config_type,
-      hub.service,
-      hub.provider,
+    user_id?: number,
+  ): Promise<IntegrationResult> {
+    const strategy = this.integrationFactory.create(
+      config.integration_type,
+      'API', // service is deprecated, using default
+      config.integration_provider,
     );
 
-    const result = await strategy.sendMessage(
-      to,
-      message,
-      hub.config.config_json,
-    );
+    // Get user integration data if user_id provided
+    let finalConfig = config.config_json;
+    if (user_id) {
+      const userIntegrationData = await this.getUserIntegrationForStrategy(
+        user_id,
+        config.id,
+      );
+
+      if (userIntegrationData) {
+        finalConfig = {
+          ...config.config_json,
+          external_user_id: userIntegrationData.external_user_id,
+        };
+      }
+    }
+
+    const result = await strategy.sendMessage(to, message, finalConfig);
 
     // If token was refreshed, update it in the database
     if (result.refreshedToken && result.success) {
       try {
-        const currentConfig = hub.config.config_json as any;
+        const currentConfig = config.config_json as any;
         const updatedConfig = {
           ...currentConfig,
           accessToken: result.refreshedToken,
         };
 
-        await this.configRepository.update(hub.config.id, {
+        await this.configRepository.update(config.id, {
           config_json: updatedConfig,
         } as any);
 
         this.logger.log(
-          `Updated access token for ${hub.provider}/${hub.service} configuration`,
+          `Updated access token for ${config.integration_provider} configuration`,
         );
       } catch (error) {
         this.logger.warn(
@@ -257,52 +239,66 @@ export class CommunicationService {
     return result;
   }
 
-  async createCommunicationConfig(
+  async createIntegrationConfig(
     levelId: number,
     levelType: string,
-    configType: CommunicationConfigType,
-    service: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
     provider: string,
+    integration_source_id: number,
     config: any,
     priority?: number,
     is_default?: boolean,
   ): Promise<
-    CommunicationHub | { authUrl: string; state: string; message: string }
+    IntegrationConfig | { authUrl: string; state: string; message: string }
   > {
-    // Deactivate any existing active configurations of the same type to ensure only one is active
-    await this.validateUniqueActiveConfig(levelId, levelType, configType);
+    // Validate that no duplicate provider configurations exist
+    await this.validateUniqueActiveConfig(
+      levelId,
+      levelType,
+      app_code,
+      configType,
+      provider,
+    );
 
-    // Validate service/provider combination using supported combinations
+    // Deactivate all other configurations of the same integration type
+    await this.configRepository.update(
+      {
+        level_id: levelId,
+        level_type: levelType,
+        app_code: app_code,
+        integration_type: configType,
+        status: 1,
+      },
+      { status: 0 },
+    );
+
+    // Validate provider and get service type from supported combinations
     const supportedCombinations = await this.getSupportedCombinations();
-    const isValidCombination = supportedCombinations.some(
+    const validCombination = supportedCombinations.find(
       (combo) =>
         combo.mode === configType &&
-        combo.service.toLowerCase() === service.toLowerCase() &&
         combo.provider.toLowerCase() === provider.toLowerCase(),
     );
 
-    if (!isValidCombination) {
-      throw new Error(
-        `Unsupported combination: ${configType}/${service}/${provider}`,
-      );
+    if (!validCombination) {
+      throw new Error(`Unsupported combination: ${configType}/${provider}`);
     }
 
+    const service = validCombination.service;
+
     // Check if this requires OAuth flow
-    const requiresOAuth = this.requiresOAuthFlow(
-      configType,
-      service,
-      provider,
-      config,
-    );
+    const requiresOAuth = this.requiresOAuthFlow(configType, provider, config);
 
     if (requiresOAuth) {
       // Generate OAuth URL and return it instead of creating config immediately
       return await this.generateOAuthUrl(
         levelId,
         levelType,
+        app_code,
         configType,
-        service,
         provider,
+        integration_source_id,
         config,
         priority,
         is_default,
@@ -313,9 +309,10 @@ export class CommunicationService {
     return await this.createDirectConfig(
       levelId,
       levelType,
+      app_code,
       configType,
-      service,
       provider,
+      integration_source_id,
       config,
       priority,
       is_default,
@@ -327,35 +324,35 @@ export class CommunicationService {
     service: string;
     provider: string;
   }[] {
-    return this.communicationFactory.getAllSupportedCombinations();
+    return this.integrationFactory.getAllSupportedCombinations();
   }
 
   async getLevelConfigs(
     levelId: number,
     levelType: string,
     filters?: {
-      communication_config_type?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE';
-      service?: 'API' | 'THIRD_PARTY' | 'SMTP';
-      provider?: string;
+      app_code?: string;
+      integration_type?: 'WA' | 'SMS' | 'EMAIL' | 'TELEPHONE';
+      integration_provider?: string;
     },
   ): Promise<
-    Array<CommunicationHub & { linkedSource?: string; configDetails?: any }>
+    Array<IntegrationConfig & { linkedSource?: string; configDetails?: any }>
   > {
     const where: any = { level_id: levelId, level_type: levelType };
 
-    if (filters?.communication_config_type) {
-      where.communication_config_type = filters.communication_config_type;
+    if (filters?.app_code) {
+      where.app_code = filters.app_code;
     }
 
-    if (filters?.service) {
-      where.service = filters.service;
+    if (filters?.integration_type) {
+      where.integration_type = filters.integration_type;
     }
 
-    if (filters?.provider) {
-      where.provider = filters.provider;
+    if (filters?.integration_provider) {
+      where.integration_provider = filters.integration_provider;
     }
 
-    const hubs = await this.hubRepository.find({
+    const hubs = await this.configRepository.find({
       where,
       order: { created_at: 'DESC' },
     });
@@ -364,11 +361,11 @@ export class CommunicationService {
     const enhancedHubs = await Promise.all(
       hubs.map(async (hub) => {
         try {
-          const config = await this.configRepository.findOne({
-            where: { id: hub.config_id },
+          const relatedConfig = await this.configRepository.findOne({
+            where: { id: hub.id },
           });
 
-          if (!config) {
+          if (!relatedConfig) {
             return {
               ...hub,
               linkedSource: 'Configuration not found',
@@ -377,17 +374,15 @@ export class CommunicationService {
           }
 
           const linkedSource = this.extractLinkedSource(
-            hub.communication_config_type,
-            hub.service,
-            hub.provider,
-            config.config_json,
+            hub.integration_type,
+            hub.integration_provider,
+            relatedConfig.config_json,
           );
 
           const configDetails = this.extractConfigDetails(
-            hub.communication_config_type,
-            hub.service,
-            hub.provider,
-            config.config_json,
+            hub.integration_type,
+            hub.integration_provider,
+            relatedConfig.config_json,
           );
 
           return {
@@ -414,21 +409,20 @@ export class CommunicationService {
 
   private extractLinkedSource(
     configType: string,
-    service: string,
     provider: string,
     configJson: any,
   ): string {
-    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
 
     try {
       switch (key) {
         // Gmail configurations
-        case 'email_api_gmail':
+        case 'email_gmail':
         case 'email_smtp_gmail':
           return configJson?.email || 'Gmail account not configured';
 
         // Outlook configurations
-        case 'email_api_outlook':
+        case 'email_outlook':
         case 'email_smtp_outlook':
           return configJson?.email || 'Outlook account not configured';
 
@@ -461,8 +455,8 @@ export class CommunicationService {
             : 'Ozonetel voice not configured';
 
         // AWS SES configurations
-        case 'email_api_aws-ses':
-        case 'email_api_ses':
+        case 'email_aws-ses':
+        case 'email_ses':
           return configJson?.fromEmail || 'AWS SES not configured';
 
         // SendGrid configurations
@@ -492,16 +486,15 @@ export class CommunicationService {
 
   private extractConfigDetails(
     configType: string,
-    service: string,
     provider: string,
     configJson: any,
   ): any {
-    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
 
     try {
       switch (key) {
         // Gmail configurations
-        case 'email_api_gmail':
+        case 'email_gmail':
           return {
             email: configJson?.email,
             authMethod: configJson?.authMethod || 'OAUTH2',
@@ -519,7 +512,7 @@ export class CommunicationService {
           };
 
         // Outlook configurations
-        case 'email_api_outlook':
+        case 'email_outlook':
           return {
             email: configJson?.email,
             authMethod: 'OAUTH2',
@@ -578,8 +571,8 @@ export class CommunicationService {
           };
 
         // AWS SES configurations
-        case 'email_api_aws-ses':
-        case 'email_api_ses':
+        case 'email_aws-ses':
+        case 'email_ses':
           return {
             fromEmail: configJson?.fromEmail,
             region: configJson?.region,
@@ -665,21 +658,22 @@ export class CommunicationService {
 
   async updateConfigStatus(hubId: number, status: number): Promise<void> {
     // Find the hub to get level and type information
-    const hub = await this.hubRepository.findOne({
+    const config = await this.configRepository.findOne({
       where: { id: hubId },
     });
 
-    if (!hub) {
-      throw new Error('Communication configuration not found');
+    if (!config) {
+      throw new Error('Integration configuration not found');
     }
 
-    // If activating, deactivate other configs with same level_id + level_type + communication_config_type
+    // If activating, deactivate ALL other configs of the same integration type
     if (status === 1) {
-      await this.hubRepository.update(
+      await this.configRepository.update(
         {
-          level_id: hub.level_id,
-          level_type: hub.level_type,
-          communication_config_type: hub.communication_config_type,
+          level_id: config.level_id,
+          level_type: config.level_type,
+          app_code: config.app_code,
+          integration_type: config.integration_type,
           status: 1,
           id: Not(hubId),
         },
@@ -688,26 +682,22 @@ export class CommunicationService {
     }
 
     // Update the requested config
-    await this.hubRepository.update(hubId, { status });
+    await this.configRepository.update(hubId, { status });
   }
 
-  async deleteConfiguration(hubId: number): Promise<void> {
-    // Find the hub to get the config_id
-    const hub = await this.hubRepository.findOne({
-      where: { id: hubId },
+  async deleteConfiguration(configId: number): Promise<void> {
+    // Find the hub to get the id
+    const config = await this.configRepository.findOne({
+      where: { id: configId },
     });
 
-    if (!hub) {
-      throw new Error('Communication configuration not found');
+    if (!config) {
+      throw new Error('Integration configuration not found');
     }
 
-    await this.hubRepository.delete(hubId);
-
-    await this.configRepository.delete(hub.config_id);
+    await this.configRepository.delete(configId);
 
-    this.logger.log(
-      `Communication configuration deleted: Hub ${hubId}, Config ${hub.config_id}`,
-    );
+    this.logger.log(`Integration configuration deleted: ${configId}`);
   }
 
   async updateConfiguration(
@@ -718,104 +708,75 @@ export class CommunicationService {
       is_default?: boolean;
       status?: number;
     },
-  ): Promise<CommunicationHub & { config?: any }> {
+  ): Promise<IntegrationConfig & { config?: any }> {
     // Find the existing hub
-    const hub = await this.hubRepository.findOne({
+    const config = await this.configRepository.findOne({
       where: { id: hubId },
     });
 
-    if (!hub) {
-      throw new Error('Communication configuration not found');
+    if (!config) {
+      throw new Error('Integration 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,
+        ...config.config_json,
         ...updateData.config,
       };
 
-      await this.configRepository.update(hub.config_id, {
+      await this.configRepository.update(config.id, {
         config_json: updatedConfigJson,
-      });
-    }
-
-    // Deactivate other configurations if this one is being activated
-    if (updateData.status === 1) {
-      await this.validateUniqueActiveConfig(
-        hub.level_id,
-        hub.level_type,
-        hub.communication_config_type,
-        hubId, // Exclude current hub
-      );
+      } as any);
     }
 
-    // Handle default configuration logic
+    // Handle default configuration logic (simplified for now)
     if (updateData.is_default === true) {
       // Remove default from other configurations of same type and level
-      await this.hubRepository.update(
+      await this.configRepository.update(
         {
-          level_id: hub.level_id,
-          level_type: hub.level_type,
-          communication_config_type: hub.communication_config_type,
-          id: Not(hubId), // Exclude current hub
+          level_id: config.level_id,
+          level_type: config.level_type,
+          integration_type: config.integration_type,
+          id: Not(hubId),
         },
         { 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 direct config updates if any
+    const directUpdates: any = {};
+    if (updateData.priority !== undefined)
+      directUpdates.priority = updateData.priority;
+    if (updateData.is_default !== undefined)
+      directUpdates.is_default = updateData.is_default;
+    if (updateData.status !== undefined)
+      directUpdates.status = updateData.status;
+
+    if (Object.keys(directUpdates).length > 0) {
+      await this.configRepository.update(config.id, directUpdates);
     }
 
-    // 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 },
-    });
-
+    // Fetch and return updated config
     const updatedConfig = await this.configRepository.findOne({
-      where: { id: hub.config_id },
+      where: { id: hubId },
     });
 
-    this.logger.log(
-      `Communication configuration updated: Hub ${hubId}, Type ${hub.communication_config_type}`,
-    );
-
     return {
-      ...updatedHub!,
+      ...updatedConfig,
       config: updatedConfig?.config_json,
-    };
+    } as any;
   }
 
   async sendGenericMessage(
     messageDto: GenericMessageDto,
-  ): Promise<CommunicationResult> {
+  ): Promise<IntegrationResult> {
     try {
       const {
         levelId,
         levelType,
+        app_code,
         to,
         message,
         type,
@@ -828,21 +789,23 @@ export class CommunicationService {
         mediaUrl,
         templateId,
         variables,
+        user_id,
       } = messageDto;
 
       // Auto-detect communication type if not specified
       const communicationType = this.detectCommunicationType(to, type);
 
-      // Get active hubs for the detected type
-      const hubs = await this.getActiveHubs(
+      // Get active configs for the detected type
+      const configs = await this.getActiveConfigs(
         levelId,
         levelType,
+        app_code,
         communicationType,
       );
 
-      if (!hubs.length) {
+      if (!configs.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 integration providers using the createIntegrationConfig method.`,
         );
         throw new Error(
           `No active ${communicationType} configuration found for ${levelType} ${levelId}. Please configure a communication provider first.`,
@@ -850,7 +813,10 @@ export class CommunicationService {
       }
 
       // Sort hubs by priority and default preference
-      const sortedHubs = this.sortHubsByPriorityAndDefault(hubs, priority);
+      const sortedConfigs = this.sortConfigsByPriorityAndDefault(
+        configs,
+        priority,
+      );
 
       // Prepare enhanced config with additional parameters
       const enhancedConfig = {
@@ -864,16 +830,21 @@ export class CommunicationService {
 
       // Handle multiple recipients by sending to each individually
       if (Array.isArray(to)) {
-        const results: CommunicationResult[] = [];
+        const results: IntegrationResult[] = [];
         let hasSuccess = false;
 
         for (const recipient of to) {
-          for (const hub of sortedHubs) {
+          for (const hub of sortedConfigs) {
             try {
-              const strategy = this.communicationFactory.create(
-                hub.communication_config_type,
-                hub.service,
-                hub.provider,
+              const serviceType = this.deriveServiceType(
+                hub.integration_type,
+                hub.integration_provider,
+                hub.config_json,
+              );
+              const strategy = this.integrationFactory.create(
+                hub.integration_type,
+                serviceType,
+                hub.integration_provider,
               );
 
               // Process template if provided
@@ -883,13 +854,26 @@ export class CommunicationService {
               }
 
               // Merge config with enhanced parameters
-              const finalConfig = {
-                ...hub.config.config_json,
+              let finalConfig = {
+                ...hub.config_json,
                 ...enhancedConfig,
                 templateId,
                 variables,
               };
 
+              // Handle user integration if user_id provided
+              if (user_id) {
+                const userIntegrationData =
+                  await this.getUserIntegrationForStrategy(user_id, hub.id);
+
+                if (userIntegrationData) {
+                  finalConfig = {
+                    ...finalConfig,
+                    external_user_id: userIntegrationData.external_user_id,
+                  };
+                }
+              }
+
               const result = await strategy.sendMessage(
                 recipient,
                 processedMessage,
@@ -898,7 +882,7 @@ export class CommunicationService {
 
               if (result.success) {
                 this.logger.log(
-                  `Generic message sent successfully via ${hub.provider}/${hub.service} to ${recipient}`,
+                  `Generic message sent successfully via ${hub.integration_provider} to ${recipient}`,
                 );
                 results.push(result);
                 hasSuccess = true;
@@ -906,11 +890,11 @@ export class CommunicationService {
               }
 
               this.logger.warn(
-                `Failed to send via ${hub.provider}/${hub.service} to ${recipient}: ${result.error}`,
+                `Failed to send via ${hub.integration_provider} to ${recipient}: ${result.error}`,
               );
             } catch (error) {
               this.logger.error(
-                `Error sending via ${hub.provider}/${hub.service} to ${recipient}:`,
+                `Error sending via ${hub.integration_provider} to ${recipient}:`,
                 error.message,
               );
               continue;
@@ -929,12 +913,17 @@ export class CommunicationService {
         }
       } else {
         // Handle single recipient
-        for (const hub of sortedHubs) {
+        for (const hub of sortedConfigs) {
           try {
-            const strategy = this.communicationFactory.create(
-              hub.communication_config_type,
-              hub.service,
-              hub.provider,
+            const serviceType = this.deriveServiceType(
+              hub.integration_type,
+              hub.integration_provider,
+              hub.config_json,
+            );
+            const strategy = this.integrationFactory.create(
+              hub.integration_type,
+              serviceType,
+              hub.integration_provider,
             );
 
             // Process template if provided
@@ -947,13 +936,26 @@ export class CommunicationService {
             }
 
             // Merge config with enhanced parameters
-            const finalConfig = {
-              ...hub.config.config_json,
+            let finalConfig = {
+              ...hub.config_json,
               ...enhancedConfig,
               templateId,
               variables,
             };
 
+            // Handle user integration if user_id provided
+            if (user_id) {
+              const userIntegrationData =
+                await this.getUserIntegrationForStrategy(user_id, hub.id);
+
+              if (userIntegrationData) {
+                finalConfig = {
+                  ...finalConfig,
+                  external_user_id: userIntegrationData.external_user_id,
+                };
+              }
+            }
+
             const result = await strategy.sendMessage(
               to,
               processedMessage,
@@ -962,17 +964,17 @@ export class CommunicationService {
 
             if (result.success) {
               this.logger.log(
-                `Generic message sent successfully via ${hub.provider}/${hub.service} to ${to}`,
+                `Generic message sent successfully via ${hub.integration_provider} to ${to}`,
               );
               return result;
             }
 
             this.logger.warn(
-              `Failed to send via ${hub.provider}/${hub.service}: ${result.error}`,
+              `Failed to send via ${hub.integration_provider}: ${result.error}`,
             );
           } catch (error) {
             this.logger.error(
-              `Error sending via ${hub.provider}/${hub.service}:`,
+              `Error sending via ${hub.integration_provider}:`,
               error.message,
             );
             continue;
@@ -989,11 +991,12 @@ export class CommunicationService {
 
   async sendBulkMessage(
     bulkDto: BulkMessageDto,
-  ): Promise<{ results: CommunicationResult[]; summary: any }> {
+  ): Promise<{ results: IntegrationResult[]; summary: any }> {
     try {
       const {
         levelId,
         levelType,
+        app_code,
         recipients,
         message,
         type,
@@ -1005,7 +1008,7 @@ export class CommunicationService {
         batchSize = 10,
       } = bulkDto;
 
-      const results: CommunicationResult[] = [];
+      const results: IntegrationResult[] = [];
       const batches = this.chunkArray(recipients, batchSize);
 
       for (let i = 0; i < batches.length; i++) {
@@ -1019,6 +1022,7 @@ export class CommunicationService {
             const messageDto: GenericMessageDto = {
               levelId,
               levelType,
+              app_code,
               to: recipient,
               message,
               type,
@@ -1037,7 +1041,7 @@ export class CommunicationService {
               service: 'unknown',
               error: error.message,
               timestamp: new Date(),
-            } as CommunicationResult;
+            } as IntegrationResult;
           }
         });
 
@@ -1052,7 +1056,7 @@ export class CommunicationService {
               service: 'unknown',
               error: result.reason?.message || 'Unknown error',
               timestamp: new Date(),
-            } as CommunicationResult;
+            } as IntegrationResult;
           }
         });
 
@@ -1098,7 +1102,7 @@ export class CommunicationService {
     };
   }
 
-  async sendTemplateMessage(templateDto: any): Promise<CommunicationResult> {
+  async sendTemplateMessage(templateDto: any): Promise<IntegrationResult> {
     // Get template content (integrate with your template system)
     const template = await this.getTemplate(templateDto.templateId);
 
@@ -1113,6 +1117,7 @@ export class CommunicationService {
     const messageDto: GenericMessageDto = {
       levelId: templateDto.levelId,
       levelType: templateDto.levelType,
+      app_code: templateDto.app_code,
       to: templateDto.to,
       message: processedMessage,
       subject: processedSubject,
@@ -1127,33 +1132,33 @@ export class CommunicationService {
   private detectCommunicationType(
     to: string | string[],
     type?: string,
-  ): CommunicationConfigType {
+  ): 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE' {
     if (type) {
-      return type as CommunicationConfigType;
+      return type as 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE';
     }
 
     const recipient = Array.isArray(to) ? to[0] : to;
 
     // Email detection
     if (recipient.includes('@')) {
-      return CommunicationConfigType.EMAIL;
+      return 'EMAIL';
     }
 
     // Phone number detection (basic)
     if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
       // Could be SMS or WhatsApp, default to SMS
-      return CommunicationConfigType.SMS;
+      return 'SMS';
     }
 
     // Default to EMAIL if unsure
-    return CommunicationConfigType.EMAIL;
+    return 'EMAIL';
   }
 
-  private sortHubsByPriorityAndDefault(
-    hubs: CommunicationHubWithConfig[],
+  private sortConfigsByPriorityAndDefault(
+    configs: IntegrationConfigWithConfig[],
     _priority: string,
-  ): CommunicationHubWithConfig[] {
-    return hubs.sort((a, b) => {
+  ): IntegrationConfigWithConfig[] {
+    return configs.sort((a, b) => {
       // First sort by default (true comes first)
       if (a.is_default !== b.is_default) {
         return b.is_default ? 1 : -1;
@@ -1202,6 +1207,7 @@ export class CommunicationService {
   async initGmailOAuth(
     levelId: number,
     levelType: string,
+    app_code: string,
     email?: string,
   ): Promise<{ authUrl: string; state: string }> {
     try {
@@ -1222,6 +1228,7 @@ export class CommunicationService {
       this.gmailOAuthStates.set(state, {
         levelId,
         levelType,
+        app_code,
         email,
         timestamp: Date.now(),
       });
@@ -1327,34 +1334,33 @@ export class CommunicationService {
       await this.validateUniqueActiveConfig(
         oauthState.levelId,
         oauthState.levelType,
-        CommunicationConfigType.EMAIL,
+        oauthState.app_code,
+        'EMAIL',
+        'gmail',
       );
 
-      // Create communication config
-      const communicationConfig = this.configRepository.create({
-        config_json: gmailConfig as any,
-      });
-      const savedConfig = await this.configRepository.save(communicationConfig);
-
-      // Create communication hub
-      const hub = this.hubRepository.create({
+      // Create integration config
+      const config = this.configRepository.create({
+        app_code: oauthState.app_code,
+        integration_type: 'EMAIL',
+        integration_provider: 'gmail',
+        integration_source_id: 1, // Gmail source ID
         level_id: oauthState.levelId,
         level_type: oauthState.levelType,
-        config_id: savedConfig.id,
-        communication_config_type: CommunicationConfigType.EMAIL,
-        service: 'API',
-        provider: 'gmail',
         status: 1,
+        priority: 1,
+        is_default: false,
+        config_json: gmailConfig as any,
       });
 
-      const savedHub = await this.hubRepository.save(hub);
+      const savedConfig = await this.configRepository.save(config);
 
       this.logger.log(
         `Gmail OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
       );
 
       return {
-        hubId: savedHub.id,
+        hubId: savedConfig.id,
         configId: savedConfig.id,
       };
     } catch (error) {
@@ -1390,7 +1396,9 @@ export class CommunicationService {
       await this.validateUniqueActiveConfig(
         oauthState.levelId,
         oauthState.levelType,
-        CommunicationConfigType.EMAIL,
+        oauthState.app_code,
+        'EMAIL',
+        'gmail',
       );
 
       // Pure SSO configuration - no client credentials stored per user
@@ -1405,31 +1413,28 @@ export class CommunicationService {
         ],
       };
 
-      // Create communication config
-      const communicationConfig = this.configRepository.create({
-        config_json: gmailConfig as any,
-      });
-      const savedConfig = await this.configRepository.save(communicationConfig);
-
-      // Create communication hub
-      const hub = this.hubRepository.create({
+      // Create integration config
+      const config = this.configRepository.create({
+        app_code: oauthState.app_code,
+        integration_type: 'EMAIL',
+        integration_provider: 'gmail',
+        integration_source_id: 1, // Gmail source ID
         level_id: oauthState.levelId,
         level_type: oauthState.levelType,
-        config_id: savedConfig.id,
-        communication_config_type: CommunicationConfigType.EMAIL,
-        service: 'API',
-        provider: 'gmail',
         status: 1,
+        priority: 1,
+        is_default: false,
+        config_json: gmailConfig as any,
       });
 
-      const savedHub = await this.hubRepository.save(hub);
+      const savedConfig = await this.configRepository.save(config);
 
       this.logger.log(
         `Gmail tokens configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
       );
 
       return {
-        hubId: savedHub.id,
+        hubId: savedConfig.id,
         configId: savedConfig.id,
       };
     } catch (error) {
@@ -1444,24 +1449,16 @@ export class CommunicationService {
     hubId: number,
   ): Promise<{ success: boolean; error?: string }> {
     try {
-      const hub = await this.hubRepository.findOne({
+      const integrationConfig = await this.configRepository.findOne({
         where: { id: hubId },
       });
 
-      if (!hub) {
-        throw new Error('Communication hub not found');
-      }
-
-      const config = await this.configRepository.findOne({
-        where: { id: hub.config_id },
-      });
-
-      if (!config) {
-        throw new Error('Configuration not found');
+      if (!integrationConfig) {
+        throw new Error('Integration config not found');
       }
 
       const isValid = await this.gmailApiStrategy.validateConnection(
-        config.config_json,
+        integrationConfig.config_json,
       );
 
       if (!isValid) {
@@ -1485,15 +1482,19 @@ export class CommunicationService {
   private async validateUniqueActiveConfig(
     levelId: number,
     levelType: string,
-    configType: CommunicationConfigType,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
+    provider: string,
     excludeHubId?: number,
   ): Promise<void> {
-    // Find all active configurations of the same type for this level
-    const query = this.hubRepository
+    // Find all active configurations of the same provider for this level and app_code
+    const query = this.configRepository
       .createQueryBuilder('hub')
       .where('hub.level_id = :levelId', { levelId })
       .andWhere('hub.level_type = :levelType', { levelType })
-      .andWhere('hub.communication_config_type = :configType', { configType })
+      .andWhere('hub.app_code = :app_code', { app_code })
+      .andWhere('hub.integration_type = :configType', { configType })
+      .andWhere('hub.integration_provider = :provider', { provider })
       .andWhere('hub.status = :status', { status: 1 });
 
     // Exclude current hub if updating
@@ -1503,40 +1504,28 @@ export class CommunicationService {
 
     const existingActiveConfigs = await query.getMany();
 
-    // If there are existing active configurations, deactivate them
+    // If there are existing active configurations of the same provider, throw error
     if (existingActiveConfigs.length > 0) {
-      await this.hubRepository.update(
-        {
-          level_id: levelId,
-          level_type: levelType,
-          communication_config_type: configType,
-          status: 1,
-          ...(excludeHubId && { id: Not(excludeHubId) }),
-        },
-        { status: 0 }, // Deactivate
-      );
-
-      this.logger.log(
-        `Deactivated ${existingActiveConfigs.length} existing ${configType} configuration(s) for ${levelType} ${levelId} to maintain single active provider rule.`,
+      throw new Error(
+        `A ${provider} configuration already exists for ${configType} in app_code ${app_code}, ${levelType} ${levelId}. Only one configuration per provider is allowed.`,
       );
     }
   }
 
   private requiresOAuthFlow(
-    configType: CommunicationConfigType,
-    service: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
     provider: string,
     config: any,
   ): boolean {
     // Check if config indicates OAuth is needed (missing tokens or explicit OAuth request)
-    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
 
     switch (key) {
-      case 'email_api_gmail':
+      case 'email_gmail':
         // Requires OAuth if no access token provided or OAuth explicitly requested
         return !config.accessToken || config.useOAuth === true;
 
-      case 'email_api_outlook':
+      case 'email_outlook':
         // Requires OAuth if no access token provided or OAuth explicitly requested
         return !config.accessToken || config.useOAuth === true;
 
@@ -1549,20 +1538,22 @@ export class CommunicationService {
   private async generateOAuthUrl(
     levelId: number,
     levelType: string,
-    configType: CommunicationConfigType,
-    service: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
     provider: string,
+    integration_source_id: number,
     config: any,
     priority?: number,
     is_default?: boolean,
   ): Promise<{ authUrl: string; state: string; message: string }> {
-    const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
 
     switch (key) {
-      case 'email_api_gmail':
+      case 'email_gmail':
         const gmailResult = await this.initGmailOAuth(
           levelId,
           levelType,
+          app_code,
           config.email,
         );
         return {
@@ -1572,10 +1563,11 @@ export class CommunicationService {
             'Please complete Gmail OAuth authorization. Configuration will be created automatically after authorization.',
         };
 
-      case 'email_api_outlook':
+      case 'email_outlook':
         const outlookResult = await this.initOutlookOAuth(
           levelId,
           levelType,
+          app_code,
           config.email,
         );
         return {
@@ -1586,67 +1578,81 @@ export class CommunicationService {
         };
 
       default:
-        throw new Error(
-          `OAuth not supported for ${configType}/${service}/${provider}`,
-        );
+        throw new Error(`OAuth not supported for ${configType}/${provider}`);
     }
   }
 
   private async createDirectConfig(
     levelId: number,
     levelType: string,
-    configType: CommunicationConfigType,
-    service: string,
+    app_code: string,
+    configType: 'EMAIL' | 'SMS' | 'WA' | 'TELEPHONE',
     provider: string,
+    integration_source_id: number,
     config: any,
     priority?: number,
     is_default?: boolean,
-  ): Promise<CommunicationHub> {
-    // Deactivate any existing active configurations of the same type to ensure only one is active
-    await this.validateUniqueActiveConfig(levelId, levelType, configType);
+  ): Promise<IntegrationConfig> {
+    // Validate that no duplicate provider configurations exist
+    await this.validateUniqueActiveConfig(
+      levelId,
+      levelType,
+      app_code,
+      configType,
+      provider,
+    );
+
+    // Deactivate all other configurations of the same integration type
+    await this.configRepository.update(
+      {
+        level_id: levelId,
+        level_type: levelType,
+        app_code: app_code,
+        integration_type: configType,
+        status: 1,
+      },
+      { status: 0 },
+    );
 
-    // If setting as default, remove default from other configurations of same type
+    // If setting as default, remove default from other configurations of same type and app_code
     if (is_default) {
-      await this.hubRepository.update(
+      await this.configRepository.update(
         {
           level_id: levelId,
           level_type: levelType,
-          communication_config_type: configType,
+          app_code: app_code,
+          integration_type: configType,
         },
         { is_default: false },
       );
     }
 
-    // First, create the config
-    const communicationConfig = this.configRepository.create({
-      config_json: config,
-    });
-    const savedConfig = await this.configRepository.save(communicationConfig);
-
-    // Then create the hub
-    const hub = this.hubRepository.create({
+    // Create integration config
+    const integrationConfig = this.configRepository.create({
+      app_code: app_code,
+      integration_type: configType,
+      integration_provider: provider,
+      integration_source_id: integration_source_id,
       level_id: levelId,
       level_type: levelType,
-      config_id: savedConfig.id,
-      communication_config_type: configType,
-      service: service as any,
-      provider: provider as any,
+      status: 1,
       priority: priority || 1,
       is_default: is_default || false,
-      status: 1,
+      config_json: config,
     });
 
-    const savedHub = await this.hubRepository.save(hub);
+    const savedConfig = await this.configRepository.save(integrationConfig);
     this.logger.log(
-      `Communication config created: ${configType}/${service}/${provider} for ${levelType} ${levelId}`,
+      `Communication config created: ${configType}/${provider} for ${levelType} ${levelId}`,
     );
 
-    return Array.isArray(savedHub) ? savedHub[0] : savedHub;
+    return Array.isArray(savedConfig) ? savedConfig[0] : savedConfig;
   }
 
   async initOutlookOAuth(
     levelId: number,
     levelType: string,
+    app_code: string,
     email?: string,
   ): Promise<{ authUrl: string; state: string }> {
     try {
@@ -1666,6 +1672,7 @@ export class CommunicationService {
       this.gmailOAuthStates.set(state, {
         levelId,
         levelType,
+        app_code,
         email,
         timestamp: Date.now(),
       });
@@ -1768,7 +1775,9 @@ export class CommunicationService {
       await this.validateUniqueActiveConfig(
         oauthState.levelId,
         oauthState.levelType,
-        CommunicationConfigType.EMAIL,
+        oauthState.app_code,
+        'EMAIL',
+        'outlook',
       );
 
       const outlookConfig = {
@@ -1782,31 +1791,28 @@ export class CommunicationService {
         expiresIn: tokens.expires_in,
       };
 
-      // Create communication config
-      const communicationConfig = this.configRepository.create({
-        config_json: outlookConfig as any,
-      });
-      const savedConfig = await this.configRepository.save(communicationConfig);
-
-      // Create communication hub
-      const hub = this.hubRepository.create({
+      // Create integration config
+      const config = this.configRepository.create({
+        app_code: oauthState.app_code,
+        integration_type: 'EMAIL',
+        integration_provider: 'outlook',
+        integration_source_id: 1, // Outlook source ID
         level_id: oauthState.levelId,
         level_type: oauthState.levelType,
-        config_id: savedConfig.id,
-        communication_config_type: CommunicationConfigType.EMAIL,
-        service: 'API',
-        provider: 'outlook',
         status: 1,
+        priority: 1,
+        is_default: false,
+        config_json: outlookConfig as any,
       });
 
-      const savedHub = await this.hubRepository.save(hub);
+      const savedConfig = await this.configRepository.save(config);
 
       this.logger.log(
         `Outlook OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`,
       );
 
       return {
-        hubId: savedHub.id,
+        hubId: savedConfig.id,
         configId: savedConfig.id,
       };
     } catch (error) {
@@ -1818,59 +1824,40 @@ export class CommunicationService {
     }
   }
 
-  async getCommunicationConfigById(hubId: number): Promise<
-    | (CommunicationHub & {
-        config: CommunicationConfig;
+  async getIntegrationConfigById(hubId: number): Promise<
+    | (IntegrationConfig & {
+        config: IntegrationConfig;
         linkedSource?: string;
         configDetails?: any;
       })
     | null
   > {
     try {
-      // Find the communication hub by ID
-      const hub = await this.hubRepository.findOne({
+      // Find the integration config by ID
+      const integrationConfig = await this.configRepository.findOne({
         where: { id: hubId },
       });
 
-      if (!hub) {
+      if (!integrationConfig) {
         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,
+        integrationConfig.integration_type,
+        integrationConfig.integration_provider,
+        integrationConfig.config_json,
       );
 
       const configDetails = this.extractConfigDetails(
-        hub.communication_config_type,
-        hub.service,
-        hub.provider,
-        config.config_json,
+        integrationConfig.integration_type,
+        integrationConfig.integration_provider,
+        integrationConfig.config_json,
       );
 
       return {
-        ...hub,
-        config,
+        ...integrationConfig,
+        config: integrationConfig,
         linkedSource,
         configDetails,
       };
@@ -1888,6 +1875,7 @@ export class CommunicationService {
   async getSendGridTemplates(
     levelId: number,
     levelType: string,
+    app_code: string,
   ): Promise<{
     success: boolean;
     data?: Array<{
@@ -1898,14 +1886,17 @@ export class CommunicationService {
   }> {
     try {
       // Find active SendGrid configurations for this level
-      const hubs = await this.getActiveHubs(
+      const hubs = await this.getActiveConfigs(
         levelId,
         levelType,
-        CommunicationConfigType.EMAIL,
+        app_code,
+        'EMAIL',
       );
 
       // Look for SendGrid provider
-      const sendGridHub = hubs.find((hub) => hub.provider === 'sendgrid');
+      const sendGridHub = hubs.find(
+        (hub) => hub.integration_provider === 'sendgrid',
+      );
 
       if (!sendGridHub) {
         return {
@@ -1915,7 +1906,7 @@ export class CommunicationService {
       }
 
       // Extract API key from configuration
-      const apiKey = sendGridHub.config?.config_json?.apiKey;
+      const apiKey = sendGridHub.config_json?.apiKey;
 
       if (!apiKey) {
         return {
@@ -1967,4 +1958,163 @@ export class CommunicationService {
       };
     }
   }
+
+  // UserIntegration Management Methods
+
+  async createUserIntegration(
+    createDto: CreateUserIntegrationDto,
+  ): Promise<UserIntegration> {
+    try {
+      // Check if mapping already exists
+      const existing = await this.userIntegrationRepository.findOne({
+        where: {
+          user_id: createDto.user_id,
+          integration_config_id: createDto.integration_config_id,
+        },
+      });
+
+      if (existing) {
+        throw new Error('User integration mapping already exists');
+      }
+
+      // Verify integration config exists
+      const config = await this.configRepository.findOne({
+        where: { id: createDto.integration_config_id },
+      });
+
+      if (!config) {
+        throw new Error('Integration configuration not found');
+      }
+
+      const userIntegration = this.userIntegrationRepository.create(createDto);
+      return await this.userIntegrationRepository.save(userIntegration);
+    } catch (error) {
+      this.logger.error(
+        `Error creating user integration mapping: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async getUserIntegrations(userId: number): Promise<UserIntegration[]> {
+    try {
+      return await this.userIntegrationRepository.find({
+        where: { user_id: userId, is_active: true },
+        order: { created_at: 'DESC' },
+      });
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integrations for user ${userId}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async getConfigUserIntegrations(
+    configId: number,
+  ): Promise<UserIntegration[]> {
+    try {
+      return await this.userIntegrationRepository.find({
+        where: { integration_config_id: configId, is_active: true },
+        order: { created_at: 'DESC' },
+      });
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integrations for config ${configId}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async getUserIntegrationByUserAndConfig(
+    userId: number,
+    configId: number,
+  ): Promise<UserIntegration | null> {
+    try {
+      return await this.userIntegrationRepository.findOne({
+        where: {
+          user_id: userId,
+          integration_config_id: configId,
+          is_active: true,
+        },
+      });
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integration for user ${userId} and config ${configId}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async updateUserIntegration(
+    id: number,
+    updateDto: UpdateUserIntegrationDto,
+  ): Promise<UserIntegration> {
+    try {
+      const userIntegration = await this.userIntegrationRepository.findOne({
+        where: { id },
+      });
+
+      if (!userIntegration) {
+        throw new Error('User integration mapping not found');
+      }
+
+      Object.assign(userIntegration, updateDto);
+      return await this.userIntegrationRepository.save(userIntegration);
+    } catch (error) {
+      this.logger.error(
+        `Error updating user integration ${id}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  async deleteUserIntegration(id: number): Promise<void> {
+    try {
+      const userIntegration = await this.userIntegrationRepository.findOne({
+        where: { id },
+      });
+
+      if (!userIntegration) {
+        throw new Error('User integration mapping not found');
+      }
+
+      await this.userIntegrationRepository.remove(userIntegration);
+    } catch (error) {
+      this.logger.error(
+        `Error deleting user integration ${id}: ${error.message}`,
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Get user integration data for a specific integration strategy
+   * This method is intended to be used by strategies that need user mapping
+   */
+  async getUserIntegrationForStrategy(
+    userId: number,
+    integrationConfigId: number,
+  ): Promise<any | null> {
+    try {
+      const userIntegration = await this.getUserIntegrationByUserAndConfig(
+        userId,
+        integrationConfigId,
+      );
+
+      if (!userIntegration) {
+        return null;
+      }
+
+      return {
+        external_user_id: userIntegration.external_user_id,
+        external_user_data: userIntegration.external_user_data,
+      };
+    } catch (error) {
+      this.logger.error(
+        `Error fetching user integration data for strategy: ${error.message}`,
+      );
+      return null;
+    }
+  }
 }