rez_core 2.2.258 → 2.2.259

package/dist/module/{communication/service/communication.service.js → integration/service/integration.service.js}

@@ -11,50 +11,53 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var CommunicationService_1;
+var IntegrationService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommunicationService = void 0;
+exports.IntegrationService = void 0;
 const common_1 = require("@nestjs/common");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const config_1 = require("@nestjs/config");
 const googleapis_1 = require("googleapis");
-const communication_hub_entity_1 = require("../entity/communication-hub.entity");
-const communication_config_entity_1 = require("../entity/communication-config.entity");
-const communication_factory_1 = require("../factories/communication.factory");
+const integration_config_entity_1 = require("../entity/integration-config.entity");
+const user_integration_entity_1 = require("../entity/user-integration.entity");
+const integration_factory_1 = require("../factories/integration.factory");
 const gmail_api_strategy_1 = require("../strategies/email/gmail-api.strategy");
 const sendgrid_api_strategy_1 = require("../strategies/email/sendgrid-api.strategy");
-const communication_queue_service_1 = require("./communication-queue.service");
-let CommunicationService = CommunicationService_1 = class CommunicationService {
-    constructor(hubRepository, configRepository, communicationFactory, gmailApiStrategy, sendGridApiStrategy, configService, queueService) {
-        this.hubRepository = hubRepository;
+const integration_queue_service_1 = require("./integration-queue.service");
+let IntegrationService = IntegrationService_1 = class IntegrationService {
+    constructor(configRepository, userIntegrationRepository, integrationFactory, gmailApiStrategy, sendGridApiStrategy, configService, queueService) {
         this.configRepository = configRepository;
-        this.communicationFactory = communicationFactory;
+        this.userIntegrationRepository = userIntegrationRepository;
+        this.integrationFactory = integrationFactory;
         this.gmailApiStrategy = gmailApiStrategy;
         this.sendGridApiStrategy = sendGridApiStrategy;
         this.configService = configService;
         this.queueService = queueService;
-        this.logger = new common_1.Logger(CommunicationService_1.name);
+        this.logger = new common_1.Logger(IntegrationService_1.name);
         this.gmailOAuthStates = new Map();
     }
-    async sendMessage({ levelId, levelType, to, message, mode, priority = 1, }) {
+    deriveServiceType(integration_type, integration_provider, config_json) {
+        return 'API';
+    }
+    async sendMessage({ levelId, levelType, app_code, to, message, mode, priority = 1, user_id, }) {
         try {
-            const hubs = await this.getActiveHubs(levelId, levelType, mode);
-            if (!hubs.length) {
+            const configs = await this.getActiveConfigs(levelId, levelType, app_code, mode);
+            if (!configs.length) {
                 throw new Error(`No active communication configuration found for ${levelType} ${levelId}`);
             }
-            const sortedHubs = this.sortHubsByPriority(hubs, priority);
-            for (const hub of sortedHubs) {
+            const sortedConfigs = this.sortConfigsByPriority(configs, priority);
+            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}`);
+                        this.logger.log(`Message sent successfully via ${config.integration_provider}`);
                         return result;
                     }
-                    this.logger.warn(`Failed to send via ${hub.provider}/${hub.service}: ${result.error}`);
+                    this.logger.warn(`Failed to send via ${config.integration_provider}: ${result.error}`);
                 }
                 catch (error) {
-                    this.logger.error(`Error sending via ${hub.provider}/${hub.service}:`, error.message);
+                    this.logger.error(`Error sending via ${config.integration_provider}:`, error.message);
                     continue;
                 }
             }
@@ -65,74 +68,50 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             throw error;
         }
     }
-    async getActiveHubs(levelId, levelType, mode) {
-        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 });
+    async getActiveConfigs(levelId, levelType, app_code, mode) {
+        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 });
-        }
-        const results = await query.getRawMany();
-        const hubsWithConfig = 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;
+            queryBuilder.andWhere('config.integration_type = :mode', { mode });
+        }
+        return await queryBuilder.getMany();
     }
-    sortHubsByPriority(hubs, _priority) {
-        return hubs;
+    sortConfigsByPriority(configs, _priority) {
+        return configs.sort((a, b) => {
+            if (a.is_default !== b.is_default) {
+                return a.is_default ? -1 : 1;
+            }
+            return a.priority - b.priority;
+        });
     }
-    async sendViaHub(hub, to, message) {
-        const strategy = this.communicationFactory.create(hub.communication_config_type, hub.service, hub.provider);
-        const result = await strategy.sendMessage(to, message, hub.config.config_json);
+    async sendViaConfig(config, to, message, user_id) {
+        const strategy = this.integrationFactory.create(config.integration_type, 'API', config.integration_provider);
+        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 (result.refreshedToken && result.success) {
             try {
-                const currentConfig = hub.config.config_json;
+                const currentConfig = config.config_json;
                 const updatedConfig = {
                     ...currentConfig,
                     accessToken: result.refreshedToken,
                 };
-                await this.configRepository.update(hub.config.id, {
+                await this.configRepository.update(config.id, {
                     config_json: updatedConfig,
                 });
-                this.logger.log(`Updated access token for ${hub.provider}/${hub.service} configuration`);
+                this.logger.log(`Updated access token for ${config.integration_provider} configuration`);
             }
             catch (error) {
                 this.logger.warn(`Failed to update refreshed token in database: ${error.message}`);
@@ -140,53 +119,60 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
         }
         return result;
     }
-    async createCommunicationConfig(levelId, levelType, configType, service, provider, config, priority, is_default) {
-        await this.validateUniqueActiveConfig(levelId, levelType, configType);
+    async createIntegrationConfig(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default) {
+        await this.validateUniqueActiveConfig(levelId, levelType, app_code, configType, provider);
+        await this.configRepository.update({
+            level_id: levelId,
+            level_type: levelType,
+            app_code: app_code,
+            integration_type: configType,
+            status: 1,
+        }, { status: 0 });
         const supportedCombinations = await this.getSupportedCombinations();
-        const isValidCombination = supportedCombinations.some((combo) => combo.mode === configType &&
-            combo.service.toLowerCase() === service.toLowerCase() &&
+        const validCombination = supportedCombinations.find((combo) => combo.mode === configType &&
             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 requiresOAuth = this.requiresOAuthFlow(configType, service, provider, config);
+        const service = validCombination.service;
+        const requiresOAuth = this.requiresOAuthFlow(configType, provider, config);
         if (requiresOAuth) {
-            return await this.generateOAuthUrl(levelId, levelType, configType, service, provider, config, priority, is_default);
+            return await this.generateOAuthUrl(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default);
         }
-        return await this.createDirectConfig(levelId, levelType, configType, service, provider, config, priority, is_default);
+        return await this.createDirectConfig(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default);
     }
     getSupportedCombinations() {
-        return this.communicationFactory.getAllSupportedCombinations();
+        return this.integrationFactory.getAllSupportedCombinations();
     }
     async getLevelConfigs(levelId, levelType, filters) {
         const where = { 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' },
         });
         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',
                         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);
+                const linkedSource = this.extractLinkedSource(hub.integration_type, hub.integration_provider, relatedConfig.config_json);
+                const configDetails = this.extractConfigDetails(hub.integration_type, hub.integration_provider, relatedConfig.config_json);
                 return {
                     ...hub,
                     linkedSource,
@@ -204,14 +190,14 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
         }));
         return enhancedHubs;
     }
-    extractLinkedSource(configType, service, provider, configJson) {
-        const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    extractLinkedSource(configType, provider, configJson) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
         try {
             switch (key) {
-                case 'email_api_gmail':
+                case 'email_gmail':
                 case 'email_smtp_gmail':
                     return configJson?.email || 'Gmail account not configured';
-                case 'email_api_outlook':
+                case 'email_outlook':
                 case 'email_smtp_outlook':
                     return configJson?.email || 'Outlook account not configured';
                 case 'wa_api_whatsapp':
@@ -234,8 +220,8 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                     return configJson?.userName
                         ? `Ozonetel Voice: ${configJson.userName}`
                         : 'Ozonetel voice not configured';
-                case 'email_api_aws-ses':
-                case 'email_api_ses':
+                case 'email_aws-ses':
+                case 'email_ses':
                     return configJson?.fromEmail || 'AWS SES not configured';
                 case 'email_smtp_sendgrid':
                     return configJson?.from || 'SendGrid not configured';
@@ -262,11 +248,11 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             return 'Configuration error';
         }
     }
-    extractConfigDetails(configType, service, provider, configJson) {
-        const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    extractConfigDetails(configType, provider, configJson) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
         try {
             switch (key) {
-                case 'email_api_gmail':
+                case 'email_gmail':
                     return {
                         email: configJson?.email,
                         authMethod: configJson?.authMethod || 'OAUTH2',
@@ -281,7 +267,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                         authMethod: 'SMTP',
                         hasPassword: !!configJson?.password,
                     };
-                case 'email_api_outlook':
+                case 'email_outlook':
                     return {
                         email: configJson?.email,
                         authMethod: 'OAUTH2',
@@ -329,8 +315,8 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                         agentLoginUrl: configJson?.agentLoginUrl,
                         hasApiKey: !!configJson?.apiKey,
                     };
-                case 'email_api_aws-ses':
-                case 'email_api_ses':
+                case 'email_aws-ses':
+                case 'email_ses':
                     return {
                         fromEmail: configJson?.fromEmail,
                         region: configJson?.region,
@@ -398,102 +384,86 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
         }
     }
     async updateConfigStatus(hubId, status) {
-        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 (status === 1) {
-            await this.hubRepository.update({
-                level_id: hub.level_id,
-                level_type: hub.level_type,
-                communication_config_type: hub.communication_config_type,
+            await this.configRepository.update({
+                level_id: config.level_id,
+                level_type: config.level_type,
+                app_code: config.app_code,
+                integration_type: config.integration_type,
                 status: 1,
                 id: (0, typeorm_2.Not)(hubId),
             }, { status: 0 });
         }
-        await this.hubRepository.update(hubId, { status });
+        await this.configRepository.update(hubId, { status });
     }
-    async deleteConfiguration(hubId) {
-        const hub = await this.hubRepository.findOne({
-            where: { id: hubId },
+    async deleteConfiguration(configId) {
+        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);
-        this.logger.log(`Communication configuration deleted: Hub ${hubId}, Config ${hub.config_id}`);
+        await this.configRepository.delete(configId);
+        this.logger.log(`Integration configuration deleted: ${configId}`);
     }
     async updateConfiguration(hubId, updateData) {
-        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 (updateData.config) {
-            const existingConfig = await this.configRepository.findOne({
-                where: { id: hub.config_id },
-            });
-            if (!existingConfig) {
-                throw new Error('Configuration record not found');
-            }
             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,
             });
         }
-        if (updateData.status === 1) {
-            await this.validateUniqueActiveConfig(hub.level_id, hub.level_type, hub.communication_config_type, hubId);
-        }
         if (updateData.is_default === true) {
-            await this.hubRepository.update({
-                level_id: hub.level_id,
-                level_type: hub.level_type,
-                communication_config_type: hub.communication_config_type,
+            await this.configRepository.update({
+                level_id: config.level_id,
+                level_type: config.level_type,
+                integration_type: config.integration_type,
                 id: (0, typeorm_2.Not)(hubId),
             }, { is_default: false });
         }
-        const hubUpdateData = {};
-        if (updateData.priority !== undefined) {
-            hubUpdateData.priority = updateData.priority;
+        const directUpdates = {};
+        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);
         }
-        if (updateData.is_default !== undefined) {
-            hubUpdateData.is_default = updateData.is_default;
-        }
-        if (updateData.status !== undefined) {
-            hubUpdateData.status = updateData.status;
-        }
-        if (Object.keys(hubUpdateData).length > 0) {
-            await this.hubRepository.update(hubId, hubUpdateData);
-        }
-        const updatedHub = await this.hubRepository.findOne({
-            where: { id: hubId },
-        });
         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,
         };
     }
     async sendGenericMessage(messageDto) {
         try {
-            const { levelId, levelType, to, message, type, priority = 'medium', subject, html, cc, bcc, attachments, mediaUrl, templateId, variables, } = messageDto;
+            const { levelId, levelType, app_code, to, message, type, priority = 'medium', subject, html, cc, bcc, attachments, mediaUrl, templateId, variables, user_id, } = messageDto;
             const communicationType = this.detectCommunicationType(to, type);
-            const hubs = await this.getActiveHubs(levelId, levelType, communicationType);
-            if (!hubs.length) {
-                this.logger.warn(`No communication hubs found for ${levelType} ${levelId}. Please configure communication providers using the createCommunicationConfig method.`);
+            const configs = await this.getActiveConfigs(levelId, levelType, app_code, communicationType);
+            if (!configs.length) {
+                this.logger.warn(`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.`);
             }
-            const sortedHubs = this.sortHubsByPriorityAndDefault(hubs, priority);
+            const sortedConfigs = this.sortConfigsByPriorityAndDefault(configs, priority);
             const enhancedConfig = {
                 subject,
                 html,
@@ -506,30 +476,40 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                 const results = [];
                 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);
                             let processedMessage = message;
                             if (templateId && variables) {
                                 processedMessage = this.processTemplate(message, variables);
                             }
-                            const finalConfig = {
-                                ...hub.config.config_json,
+                            let finalConfig = {
+                                ...hub.config_json,
                                 ...enhancedConfig,
                                 templateId,
                                 variables,
                             };
+                            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, finalConfig);
                             if (result.success) {
-                                this.logger.log(`Generic message sent successfully via ${hub.provider}/${hub.service} to ${recipient}`);
+                                this.logger.log(`Generic message sent successfully via ${hub.integration_provider} to ${recipient}`);
                                 results.push(result);
                                 hasSuccess = true;
                                 break;
                             }
-                            this.logger.warn(`Failed to send via ${hub.provider}/${hub.service} to ${recipient}: ${result.error}`);
+                            this.logger.warn(`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.message);
+                            this.logger.error(`Error sending via ${hub.integration_provider} to ${recipient}:`, error.message);
                             continue;
                         }
                     }
@@ -545,28 +525,38 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                 }
             }
             else {
-                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);
                         let processedMessage = message;
                         if (html && variables) {
                             processedMessage = this.processTemplate(html ? html : message, variables);
                         }
-                        const finalConfig = {
-                            ...hub.config.config_json,
+                        let finalConfig = {
+                            ...hub.config_json,
                             ...enhancedConfig,
                             templateId,
                             variables,
                         };
+                        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, finalConfig);
                         if (result.success) {
-                            this.logger.log(`Generic message sent successfully via ${hub.provider}/${hub.service} to ${to}`);
+                            this.logger.log(`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}`);
+                        this.logger.warn(`Failed to send via ${hub.integration_provider}: ${result.error}`);
                     }
                     catch (error) {
-                        this.logger.error(`Error sending via ${hub.provider}/${hub.service}:`, error.message);
+                        this.logger.error(`Error sending via ${hub.integration_provider}:`, error.message);
                         continue;
                     }
                 }
@@ -580,7 +570,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
     }
     async sendBulkMessage(bulkDto) {
         try {
-            const { levelId, levelType, recipients, message, type, priority = 'low', subject, html, templateId, variables, batchSize = 10, } = bulkDto;
+            const { levelId, levelType, app_code, recipients, message, type, priority = 'low', subject, html, templateId, variables, batchSize = 10, } = bulkDto;
             const results = [];
             const batches = this.chunkArray(recipients, batchSize);
             for (let i = 0; i < batches.length; i++) {
@@ -591,6 +581,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                         const messageDto = {
                             levelId,
                             levelType,
+                            app_code,
                             to: recipient,
                             message,
                             type,
@@ -663,6 +654,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
         const messageDto = {
             levelId: templateDto.levelId,
             levelType: templateDto.levelType,
+            app_code: templateDto.app_code,
             to: templateDto.to,
             message: processedMessage,
             subject: processedSubject,
@@ -678,15 +670,15 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
         }
         const recipient = Array.isArray(to) ? to[0] : to;
         if (recipient.includes('@')) {
-            return communication_hub_entity_1.CommunicationConfigType.EMAIL;
+            return 'EMAIL';
         }
         if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
-            return communication_hub_entity_1.CommunicationConfigType.SMS;
+            return 'SMS';
         }
-        return communication_hub_entity_1.CommunicationConfigType.EMAIL;
+        return 'EMAIL';
     }
-    sortHubsByPriorityAndDefault(hubs, _priority) {
-        return hubs.sort((a, b) => {
+    sortConfigsByPriorityAndDefault(configs, _priority) {
+        return configs.sort((a, b) => {
             if (a.is_default !== b.is_default) {
                 return b.is_default ? 1 : -1;
             }
@@ -716,7 +708,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
         }
         return chunks;
     }
-    async initGmailOAuth(levelId, levelType, email) {
+    async initGmailOAuth(levelId, levelType, app_code, email) {
         try {
             const clientId = this.configService.get('CLIENT_ID');
             const clientSecret = this.configService.get('CLIENT_SECRET');
@@ -729,6 +721,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             this.gmailOAuthStates.set(state, {
                 levelId,
                 levelType,
+                app_code,
                 email,
                 timestamp: Date.now(),
             });
@@ -795,24 +788,23 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                 tokenType: tokens.token_type,
                 expiryDate: tokens.expiry_date,
             };
-            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, communication_hub_entity_1.CommunicationConfigType.EMAIL);
-            const communicationConfig = this.configRepository.create({
-                config_json: gmailConfig,
-            });
-            const savedConfig = await this.configRepository.save(communicationConfig);
-            const hub = this.hubRepository.create({
+            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, oauthState.app_code, 'EMAIL', 'gmail');
+            const config = this.configRepository.create({
+                app_code: oauthState.app_code,
+                integration_type: 'EMAIL',
+                integration_provider: 'gmail',
+                integration_source_id: 1,
                 level_id: oauthState.levelId,
                 level_type: oauthState.levelType,
-                config_id: savedConfig.id,
-                communication_config_type: communication_hub_entity_1.CommunicationConfigType.EMAIL,
-                service: 'API',
-                provider: 'gmail',
                 status: 1,
+                priority: 1,
+                is_default: false,
+                config_json: gmailConfig,
             });
-            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,
             };
         }
@@ -834,7 +826,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             if (oauthState.email && oauthState.email !== email) {
                 throw new Error('Email mismatch with OAuth hint');
             }
-            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, communication_hub_entity_1.CommunicationConfigType.EMAIL);
+            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, oauthState.app_code, 'EMAIL', 'gmail');
             const gmailConfig = {
                 email: email,
                 accessToken: accessToken,
@@ -845,23 +837,22 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                     'https://www.googleapis.com/auth/userinfo.email',
                 ],
             };
-            const communicationConfig = this.configRepository.create({
-                config_json: gmailConfig,
-            });
-            const savedConfig = await this.configRepository.save(communicationConfig);
-            const hub = this.hubRepository.create({
+            const config = this.configRepository.create({
+                app_code: oauthState.app_code,
+                integration_type: 'EMAIL',
+                integration_provider: 'gmail',
+                integration_source_id: 1,
                 level_id: oauthState.levelId,
                 level_type: oauthState.levelType,
-                config_id: savedConfig.id,
-                communication_config_type: communication_hub_entity_1.CommunicationConfigType.EMAIL,
-                service: 'API',
-                provider: 'gmail',
                 status: 1,
+                priority: 1,
+                is_default: false,
+                config_json: gmailConfig,
             });
-            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,
             };
         }
@@ -872,19 +863,13 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
     }
     async testGmailConfig(hubId) {
         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);
+            const isValid = await this.gmailApiStrategy.validateConnection(integrationConfig.config_json);
             if (!isValid) {
                 return {
                     success: false,
@@ -901,89 +886,89 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
     generateSecureState() {
         return Math.random().toString(36).substring(2) + Date.now().toString(36);
     }
-    async validateUniqueActiveConfig(levelId, levelType, configType, excludeHubId) {
-        const query = this.hubRepository
+    async validateUniqueActiveConfig(levelId, levelType, app_code, configType, provider, excludeHubId) {
+        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 });
         if (excludeHubId) {
             query.andWhere('hub.id != :excludeHubId', { excludeHubId });
         }
         const existingActiveConfigs = await query.getMany();
         if (existingActiveConfigs.length > 0) {
-            await this.hubRepository.update({
-                level_id: levelId,
-                level_type: levelType,
-                communication_config_type: configType,
-                status: 1,
-                ...(excludeHubId && { id: (0, typeorm_2.Not)(excludeHubId) }),
-            }, { status: 0 });
-            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.`);
         }
     }
-    requiresOAuthFlow(configType, service, provider, config) {
-        const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    requiresOAuthFlow(configType, provider, config) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
         switch (key) {
-            case 'email_api_gmail':
+            case 'email_gmail':
                 return !config.accessToken || config.useOAuth === true;
-            case 'email_api_outlook':
+            case 'email_outlook':
                 return !config.accessToken || config.useOAuth === true;
             default:
                 return false;
         }
     }
-    async generateOAuthUrl(levelId, levelType, configType, service, provider, config, priority, is_default) {
-        const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+    async generateOAuthUrl(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
         switch (key) {
-            case 'email_api_gmail':
-                const gmailResult = await this.initGmailOAuth(levelId, levelType, config.email);
+            case 'email_gmail':
+                const gmailResult = await this.initGmailOAuth(levelId, levelType, app_code, config.email);
                 return {
                     authUrl: gmailResult.authUrl,
                     state: gmailResult.state,
                     message: 'Please complete Gmail OAuth authorization. Configuration will be created automatically after authorization.',
                 };
-            case 'email_api_outlook':
-                const outlookResult = await this.initOutlookOAuth(levelId, levelType, config.email);
+            case 'email_outlook':
+                const outlookResult = await this.initOutlookOAuth(levelId, levelType, app_code, config.email);
                 return {
                     authUrl: outlookResult.authUrl,
                     state: outlookResult.state,
                     message: 'Please complete Outlook OAuth authorization. Configuration will be created automatically after authorization.',
                 };
             default:
-                throw new Error(`OAuth not supported for ${configType}/${service}/${provider}`);
+                throw new Error(`OAuth not supported for ${configType}/${provider}`);
         }
     }
-    async createDirectConfig(levelId, levelType, configType, service, provider, config, priority, is_default) {
-        await this.validateUniqueActiveConfig(levelId, levelType, configType);
+    async createDirectConfig(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default) {
+        await this.validateUniqueActiveConfig(levelId, levelType, app_code, configType, provider);
+        await this.configRepository.update({
+            level_id: levelId,
+            level_type: levelType,
+            app_code: app_code,
+            integration_type: configType,
+            status: 1,
+        }, { status: 0 });
         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 });
         }
-        const communicationConfig = this.configRepository.create({
-            config_json: config,
-        });
-        const savedConfig = await this.configRepository.save(communicationConfig);
-        const hub = this.hubRepository.create({
+        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,
-            provider: provider,
+            status: 1,
             priority: priority || 1,
             is_default: is_default || false,
-            status: 1,
+            config_json: config,
         });
-        const savedHub = await this.hubRepository.save(hub);
-        this.logger.log(`Communication config created: ${configType}/${service}/${provider} for ${levelType} ${levelId}`);
-        return Array.isArray(savedHub) ? savedHub[0] : savedHub;
+        const savedConfig = await this.configRepository.save(integrationConfig);
+        this.logger.log(`Communication config created: ${configType}/${provider} for ${levelType} ${levelId}`);
+        return Array.isArray(savedConfig) ? savedConfig[0] : savedConfig;
     }
-    async initOutlookOAuth(levelId, levelType, email) {
+    async initOutlookOAuth(levelId, levelType, app_code, email) {
         try {
             const clientId = this.configService.get('OUTLOOK_CLIENT_ID');
             const tenantId = this.configService.get('OUTLOOK_TENANT_ID');
@@ -996,6 +981,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             this.gmailOAuthStates.set(state, {
                 levelId,
                 levelType,
+                app_code,
                 email,
                 timestamp: Date.now(),
             });
@@ -1064,7 +1050,7 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             if (!email) {
                 throw new Error('Failed to get user email');
             }
-            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, communication_hub_entity_1.CommunicationConfigType.EMAIL);
+            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, oauthState.app_code, 'EMAIL', 'outlook');
             const outlookConfig = {
                 clientId,
                 tenantId,
@@ -1075,23 +1061,22 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
                 tokenType: tokens.token_type,
                 expiresIn: tokens.expires_in,
             };
-            const communicationConfig = this.configRepository.create({
-                config_json: outlookConfig,
-            });
-            const savedConfig = await this.configRepository.save(communicationConfig);
-            const hub = this.hubRepository.create({
+            const config = this.configRepository.create({
+                app_code: oauthState.app_code,
+                integration_type: 'EMAIL',
+                integration_provider: 'outlook',
+                integration_source_id: 1,
                 level_id: oauthState.levelId,
                 level_type: oauthState.levelType,
-                config_id: savedConfig.id,
-                communication_config_type: communication_hub_entity_1.CommunicationConfigType.EMAIL,
-                service: 'API',
-                provider: 'outlook',
                 status: 1,
+                priority: 1,
+                is_default: false,
+                config_json: outlookConfig,
             });
-            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,
             };
         }
@@ -1100,31 +1085,19 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
         }
     }
-    async getCommunicationConfigById(hubId) {
+    async getIntegrationConfigById(hubId) {
         try {
-            const hub = await this.hubRepository.findOne({
+            const integrationConfig = await this.configRepository.findOne({
                 where: { id: hubId },
             });
-            if (!hub) {
+            if (!integrationConfig) {
                 return null;
             }
-            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,
-                    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);
+            const linkedSource = this.extractLinkedSource(integrationConfig.integration_type, integrationConfig.integration_provider, integrationConfig.config_json);
+            const configDetails = this.extractConfigDetails(integrationConfig.integration_type, integrationConfig.integration_provider, integrationConfig.config_json);
             return {
-                ...hub,
-                config,
+                ...integrationConfig,
+                config: integrationConfig,
                 linkedSource,
                 configDetails,
             };
@@ -1134,17 +1107,17 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             throw new Error(`Failed to fetch communication configuration: ${error.message}`);
         }
     }
-    async getSendGridTemplates(levelId, levelType) {
+    async getSendGridTemplates(levelId, levelType, app_code) {
         try {
-            const hubs = await this.getActiveHubs(levelId, levelType, communication_hub_entity_1.CommunicationConfigType.EMAIL);
-            const sendGridHub = hubs.find((hub) => hub.provider === 'sendgrid');
+            const hubs = await this.getActiveConfigs(levelId, levelType, app_code, 'EMAIL');
+            const sendGridHub = hubs.find((hub) => hub.integration_provider === 'sendgrid');
             if (!sendGridHub) {
                 return {
                     success: false,
                     error: 'No active SendGrid configuration found for this level',
                 };
             }
-            const apiKey = sendGridHub.config?.config_json?.apiKey;
+            const apiKey = sendGridHub.config_json?.apiKey;
             if (!apiKey) {
                 return {
                     success: false,
@@ -1179,19 +1152,130 @@ let CommunicationService = CommunicationService_1 = class CommunicationService {
             };
         }
     }
+    async createUserIntegration(createDto) {
+        try {
+            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');
+            }
+            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) {
+        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) {
+        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, configId) {
+        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, updateDto) {
+        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) {
+        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;
+        }
+    }
+    async getUserIntegrationForStrategy(userId, integrationConfigId) {
+        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;
+        }
+    }
 };
-exports.CommunicationService = CommunicationService;
-exports.CommunicationService = CommunicationService = CommunicationService_1 = __decorate([
+exports.IntegrationService = IntegrationService;
+exports.IntegrationService = IntegrationService = IntegrationService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, typeorm_1.InjectRepository)(communication_hub_entity_1.CommunicationHub)),
-    __param(1, (0, typeorm_1.InjectRepository)(communication_config_entity_1.CommunicationConfig)),
-    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => communication_queue_service_1.CommunicationQueueService))),
+    __param(0, (0, typeorm_1.InjectRepository)(integration_config_entity_1.IntegrationConfig)),
+    __param(1, (0, typeorm_1.InjectRepository)(user_integration_entity_1.UserIntegration)),
+    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => integration_queue_service_1.IntegrationQueueService))),
     __metadata("design:paramtypes", [typeorm_2.Repository,
         typeorm_2.Repository,
-        communication_factory_1.CommunicationFactory,
+        integration_factory_1.IntegrationFactory,
         gmail_api_strategy_1.GmailApiStrategy,
         sendgrid_api_strategy_1.SendGridApiStrategy,
         config_1.ConfigService,
-        communication_queue_service_1.CommunicationQueueService])
-], CommunicationService);
-//# sourceMappingURL=communication.service.js.map
+        integration_queue_service_1.IntegrationQueueService])
+], IntegrationService);
+//# sourceMappingURL=integration.service.js.map