rez_core 6.5.55 → 6.5.57

package/dist/module/integration/service/integration.service.js

@@ -0,0 +1,1590 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var IntegrationService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+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 integration_config_entity_1 = require("../entity/integration-config.entity");
+const user_integration_entity_1 = require("../entity/user-integration.entity");
+const integration_entity_mapper_entity_1 = require("../entity/integration-entity-mapper.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 integration_queue_service_1 = require("./integration-queue.service");
+const field_mapper_service_1 = require("../../mapper/service/field-mapper.service");
+const global_constant_1 = require("../../../constant/global.constant");
+const entity_service_impl_service_1 = require("../../meta/service/entity-service-impl.service");
+const media_data_service_1 = require("../../meta/service/media-data.service");
+const axios_1 = require("axios");
+const reflection_helper_service_1 = require("../../../utils/service/reflection-helper.service");
+let IntegrationService = IntegrationService_1 = class IntegrationService {
+    constructor(configRepository, userIntegrationRepository, entityMapperRepository, dataSource, integrationFactory, gmailApiStrategy, sendGridApiStrategy, configService, mediaService, fieldMapperService, entityService, reflectionHelper, queueService) {
+        this.configRepository = configRepository;
+        this.userIntegrationRepository = userIntegrationRepository;
+        this.entityMapperRepository = entityMapperRepository;
+        this.dataSource = dataSource;
+        this.integrationFactory = integrationFactory;
+        this.gmailApiStrategy = gmailApiStrategy;
+        this.sendGridApiStrategy = sendGridApiStrategy;
+        this.configService = configService;
+        this.mediaService = mediaService;
+        this.fieldMapperService = fieldMapperService;
+        this.entityService = entityService;
+        this.reflectionHelper = reflectionHelper;
+        this.queueService = queueService;
+        this.logger = new common_1.Logger(IntegrationService_1.name);
+        this.gmailOAuthStates = new Map();
+    }
+    deriveServiceType(integration_type, integration_provider, config_json) {
+        return 'API';
+    }
+    async sendMessage({ levelId, levelType, app_code, to, message, mode, priority = 1, user_id, }) {
+        try {
+            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 sortedConfigs = this.sortConfigsByPriority(configs, priority);
+            for (const config of sortedConfigs) {
+                try {
+                    const result = await this.sendViaConfig(config, to, message, user_id);
+                    if (result.success) {
+                        this.logger.log(`Message sent successfully via ${config.integration_provider}`);
+                        return result;
+                    }
+                    this.logger.warn(`Failed to send via ${config.integration_provider}: ${result.error}`);
+                }
+                catch (error) {
+                    this.logger.error(`Error sending via ${config.integration_provider}:`, error.message);
+                    continue;
+                }
+            }
+            throw new Error('All communication providers failed');
+        }
+        catch (error) {
+            this.logger.error('Communication service error:', error.message);
+            throw error;
+        }
+    }
+    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) {
+            queryBuilder.andWhere('config.integration_type = :mode', { mode });
+        }
+        return await queryBuilder.getMany();
+    }
+    async getSingleActiveConfig(levelId, levelType, app_code, integration_type) {
+        const configs = await 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.integration_type = :integration_type', {
+            integration_type,
+        })
+            .andWhere('config.status = 1')
+            .orderBy('config.is_default', 'DESC')
+            .addOrderBy('config.priority', 'ASC')
+            .addOrderBy('config.created_at', 'DESC')
+            .getMany();
+        return configs.length > 0 ? configs[0] : null;
+    }
+    async getAllIntegrationData(loggedInUser, integration_type) {
+        try {
+            const integrationSourceRepo = this.reflectionHelper.getRepoService('IntegrationSource');
+            const allIntegrationData = await integrationSourceRepo.find();
+            if (integration_type) {
+                return allIntegrationData.filter((data) => data.integration_type.toLowerCase() ===
+                    integration_type.toLowerCase());
+            }
+            return allIntegrationData;
+        }
+        catch (error) {
+            this.logger.error('Error fetching integration data:', error.message);
+            return [];
+        }
+    }
+    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 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 = config.config_json;
+                const updatedConfig = {
+                    ...currentConfig,
+                    accessToken: result.refreshedToken,
+                };
+                await this.configRepository.update(config.id, {
+                    config_json: updatedConfig,
+                });
+                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}`);
+            }
+        }
+        return result;
+    }
+    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 validCombination = supportedCombinations.find((combo) => combo.mode === configType &&
+            combo.provider.toLowerCase() === provider.toLowerCase());
+        if (!validCombination) {
+            throw new Error(`Unsupported combination: ${configType}/${provider}`);
+        }
+        const service = validCombination.service;
+        const requiresOAuth = this.requiresOAuthFlow(configType, provider, config);
+        if (requiresOAuth) {
+            return await this.generateOAuthUrl(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default);
+        }
+        return await this.createDirectConfig(levelId, levelType, app_code, configType, provider, integration_source_id, config, priority, is_default);
+    }
+    getSupportedCombinations() {
+        return this.integrationFactory.getAllSupportedCombinations();
+    }
+    async getLevelConfigs(levelId, levelType, filters) {
+        const where = { level_id: levelId, level_type: levelType };
+        if (filters?.app_code) {
+            where.app_code = filters.app_code;
+        }
+        if (filters?.integration_type) {
+            where.integration_type = filters.integration_type;
+        }
+        if (filters?.integration_provider) {
+            where.integration_provider = filters.integration_provider;
+        }
+        const hubs = await this.configRepository.find({
+            where,
+            order: { created_at: 'DESC' },
+        });
+        const enhancedHubs = await Promise.all(hubs.map(async (hub) => {
+            try {
+                const relatedConfig = await this.configRepository.findOne({
+                    where: { id: hub.id },
+                });
+                if (!relatedConfig) {
+                    return {
+                        ...hub,
+                        linkedSource: 'Configuration not found',
+                        configDetails: null,
+                    };
+                }
+                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,
+                    configDetails,
+                };
+            }
+            catch (error) {
+                this.logger.warn(`Error extracting linked source for hub ${hub.id}:`, error.message);
+                return {
+                    ...hub,
+                    linkedSource: 'Error retrieving source',
+                    configDetails: null,
+                };
+            }
+        }));
+        return enhancedHubs;
+    }
+    extractLinkedSource(configType, provider, configJson) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+        try {
+            switch (key) {
+                case 'email_gmail':
+                case 'email_smtp_gmail':
+                    return configJson?.email || 'Gmail account not configured';
+                case 'email_outlook':
+                case 'email_smtp_outlook':
+                    return configJson?.email || 'Outlook account not configured';
+                case 'wa_api_whatsapp':
+                    return configJson?.phoneNumberId
+                        ? `WhatsApp Business: ${configJson.phoneNumberId}`
+                        : 'WhatsApp not configured';
+                case 'sms_third_party_twilio':
+                    return configJson?.fromNumber
+                        ? `Twilio: ${configJson.fromNumber}`
+                        : 'Twilio number not configured';
+                case 'sms_third_party_knowlarity':
+                    return configJson?.callerNumber
+                        ? `Knowlarity: ${configJson.callerNumber}`
+                        : 'Knowlarity number not configured';
+                case 'telephone_third_party_knowlarity':
+                    return configJson?.callerNumber
+                        ? `Knowlarity Voice: ${configJson.callerNumber}`
+                        : 'Knowlarity voice number not configured';
+                case 'telephone_third_party_ozonetel':
+                    return configJson?.userName
+                        ? `Ozonetel Voice: ${configJson.userName}`
+                        : 'Ozonetel voice not configured';
+                case 'email_aws-ses':
+                case 'email_ses':
+                    return configJson?.fromEmail || 'AWS SES not configured';
+                case 'email_smtp_sendgrid':
+                    return configJson?.from || 'SendGrid not configured';
+                case 'email_smtp_custom':
+                case 'email_smtp_generic':
+                    return configJson?.from || configJson?.user || 'SMTP not configured';
+                default:
+                    if (configJson?.email)
+                        return configJson.email;
+                    if (configJson?.from)
+                        return configJson.from;
+                    if (configJson?.user)
+                        return configJson.user;
+                    if (configJson?.phoneNumberId)
+                        return configJson.phoneNumberId;
+                    if (configJson?.fromNumber)
+                        return configJson.fromNumber;
+                    if (configJson?.callerNumber)
+                        return configJson.callerNumber;
+                    return `${provider} configured`;
+            }
+        }
+        catch (error) {
+            return 'Configuration error';
+        }
+    }
+    extractConfigDetails(configType, provider, configJson) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+        try {
+            switch (key) {
+                case 'email_gmail':
+                    return {
+                        email: configJson?.email,
+                        authMethod: configJson?.authMethod || 'OAUTH2',
+                        hasRefreshToken: !!configJson?.refreshToken,
+                        isExpired: configJson?.expiryDate
+                            ? new Date(configJson.expiryDate) < new Date()
+                            : false,
+                    };
+                case 'email_smtp_gmail':
+                    return {
+                        email: configJson?.email,
+                        authMethod: 'SMTP',
+                        hasPassword: !!configJson?.password,
+                    };
+                case 'email_outlook':
+                    return {
+                        email: configJson?.email,
+                        authMethod: 'OAUTH2',
+                        hasRefreshToken: !!configJson?.refreshToken,
+                        tenantId: configJson?.tenantId,
+                    };
+                case 'email_smtp_outlook':
+                    return {
+                        email: configJson?.email,
+                        authMethod: 'SMTP',
+                        hasPassword: !!configJson?.password,
+                    };
+                case 'wa_api_whatsapp':
+                    return {
+                        phoneNumberId: configJson?.phoneNumberId,
+                        apiVersion: configJson?.apiVersion || 'v17.0',
+                        hasAccessToken: !!configJson?.accessToken,
+                    };
+                case 'sms_third_party_twilio':
+                    return {
+                        fromNumber: configJson?.fromNumber,
+                        accountSid: configJson?.accountSid
+                            ? configJson.accountSid.substring(0, 8) + '...'
+                            : null,
+                        hasAuthToken: !!configJson?.authToken,
+                    };
+                case 'sms_third_party_knowlarity':
+                    return {
+                        callerNumber: configJson?.callerNumber,
+                        callType: configJson?.callType || 'sms',
+                        hasApiSecret: !!configJson?.apiSecret,
+                    };
+                case 'telephone_third_party_knowlarity':
+                    return {
+                        callerNumber: configJson?.callerNumber,
+                        callType: configJson?.callType || 'voice',
+                        language: configJson?.language || 'en',
+                        hasApiSecret: !!configJson?.apiSecret,
+                    };
+                case 'telephone_third_party_ozonetel':
+                    return {
+                        userName: configJson?.userName,
+                        agentID: configJson?.agentID,
+                        campaignName: configJson?.campaignName,
+                        agentLoginUrl: configJson?.agentLoginUrl,
+                        hasApiKey: !!configJson?.apiKey,
+                    };
+                case 'email_aws-ses':
+                case 'email_ses':
+                    return {
+                        fromEmail: configJson?.fromEmail,
+                        region: configJson?.region,
+                        hasCredentials: !!(configJson?.accessKeyId && configJson?.secretAccessKey),
+                    };
+                case 'email_smtp_sendgrid':
+                    return {
+                        from: configJson?.from,
+                        hasApiKey: !!configJson?.apiKey,
+                        templateId: configJson?.templateId,
+                    };
+                case 'email_smtp_custom':
+                case 'email_smtp_generic':
+                    return {
+                        host: configJson?.host,
+                        port: configJson?.port || 587,
+                        secure: configJson?.secure || false,
+                        from: configJson?.from || configJson?.user,
+                        hasCredentials: !!(configJson?.user && configJson?.password),
+                    };
+                default: {
+                    const safeConfig = {};
+                    const safeFields = [
+                        'email',
+                        'from',
+                        'user',
+                        'host',
+                        'port',
+                        'secure',
+                        'phoneNumberId',
+                        'fromNumber',
+                        'callerNumber',
+                        'region',
+                        'apiVersion',
+                        'callType',
+                        'language',
+                        'templateId',
+                    ];
+                    safeFields.forEach((field) => {
+                        if (configJson?.[field]) {
+                            safeConfig[field] = configJson[field];
+                        }
+                    });
+                    const sensitiveFields = [
+                        'accessToken',
+                        'refreshToken',
+                        'password',
+                        'authToken',
+                        'apiKey',
+                        'apiSecret',
+                        'clientSecret',
+                        'secretAccessKey',
+                    ];
+                    sensitiveFields.forEach((field) => {
+                        if (configJson?.[field]) {
+                            safeConfig[`has${field.charAt(0).toUpperCase() + field.slice(1)}`] = true;
+                        }
+                    });
+                    return safeConfig;
+                }
+            }
+        }
+        catch (error) {
+            return { error: 'Unable to extract configuration details' };
+        }
+    }
+    async updateConfigStatus(hubId, status) {
+        const config = await this.configRepository.findOne({
+            where: { id: hubId },
+        });
+        if (!config) {
+            throw new Error('Integration configuration not found');
+        }
+        if (status === 1) {
+            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.configRepository.update(hubId, { status });
+    }
+    async deleteConfiguration(configId) {
+        const config = await this.configRepository.findOne({
+            where: { id: configId },
+        });
+        if (!config) {
+            throw new Error('Integration configuration not found');
+        }
+        await this.configRepository.delete(configId);
+        this.logger.log(`Integration configuration deleted: ${configId}`);
+    }
+    async updateConfiguration(hubId, updateData) {
+        const config = await this.configRepository.findOne({
+            where: { id: hubId },
+        });
+        if (!config) {
+            throw new Error('Integration configuration not found');
+        }
+        if (updateData.config) {
+            const updatedConfigJson = {
+                ...config.config_json,
+                ...updateData.config,
+            };
+            await this.configRepository.update(config.id, {
+                config_json: updatedConfigJson,
+            });
+        }
+        if (updateData.is_default === true) {
+            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 });
+        }
+        if (config.integration_type === 'TELEPHONE') {
+            try {
+                const did = config.config_json.did;
+                if (did) {
+                    await this.entityMapperRepository.delete({
+                        integration_config_id: config.id,
+                    });
+                    const entityMapper = this.entityMapperRepository.create({
+                        integration_config_id: config.id,
+                        level_id: String(config.level_id),
+                        level_type: config.level_type,
+                        appcode: config.app_code,
+                        did: did,
+                        campaign_name: config.config_json.campaignName || null,
+                    });
+                    await this.entityMapperRepository.save(entityMapper);
+                    this.logger.log(`DID mapping created for TELEPHONE integration: ${did} for ${config.level_id} ${config.level_type}`);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to create DID mapping for TELEPHONE integration: ${error.message}`);
+            }
+        }
+        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);
+        }
+        const updatedConfig = await this.configRepository.findOne({
+            where: { id: hubId },
+        });
+        return {
+            ...updatedConfig,
+            config: updatedConfig?.config_json,
+        };
+    }
+    async sendGenericMessage(messageDto) {
+        try {
+            const { levelId, levelType, app_code, to, message, type, priority = 'medium', html, cc, bcc, attachments, mediaUrl, templateId, user_id, entity_id, entity_type, organization_id, mapped_entities, } = messageDto;
+            let subject = messageDto.subject;
+            const communicationType = this.detectCommunicationType(to, type);
+            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 sortedConfigs = this.sortConfigsByPriorityAndDefault(configs, priority);
+            const enhancedConfig = {
+                subject,
+                html,
+                cc,
+                bcc,
+                attachments,
+                mediaUrl,
+            };
+            const loggedInUser = {
+                id: user_id || null,
+                organization_id: organization_id || -1,
+                level_id: levelId,
+                level_type: levelType,
+                app_code: app_code,
+            };
+            if (Array.isArray(to)) {
+                const results = [];
+                let hasSuccess = false;
+                for (const recipient of to) {
+                    for (const hub of sortedConfigs) {
+                        try {
+                            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 variables;
+                            let richText;
+                            let externalTemplateId = undefined;
+                            const profile = this.configService.get('PROFILE');
+                            const subjectPrefix = this.configService.get('SUBJECT_PREFIX');
+                            if (templateId) {
+                                const templateData = await this.processTemplate(parseInt(templateId, 10), entity_type, entity_id, loggedInUser, mapped_entities);
+                                variables = templateData.variables;
+                                externalTemplateId = templateData.externalTemplateId;
+                                richText = templateData.rich_text;
+                                subject = templateData.subject;
+                            }
+                            if (subjectPrefix) {
+                                const updatedSubject = profile?.charAt(0).toUpperCase() +
+                                    profile?.slice(1) +
+                                    ' : ' +
+                                    subject;
+                                subject = updatedSubject;
+                            }
+                            let finalConfig = {
+                                ...hub.config_json,
+                                ...enhancedConfig,
+                                templateId: externalTemplateId,
+                                variables,
+                                richText,
+                                subject,
+                            };
+                            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, message, finalConfig);
+                            if (result.success) {
+                                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.integration_provider} to ${recipient}: ${result.error}`);
+                        }
+                        catch (error) {
+                            this.logger.error(`Error sending via ${hub.integration_provider} to ${recipient}:`, error.message);
+                            continue;
+                        }
+                    }
+                }
+                if (hasSuccess) {
+                    return {
+                        success: true,
+                        messageId: results.map((r) => r.messageId).join(','),
+                        provider: 'multiple',
+                        service: 'multiple',
+                        timestamp: new Date(),
+                        message: results.map((r) => r.message).join(','),
+                    };
+                }
+            }
+            else {
+                for (const hub of sortedConfigs) {
+                    try {
+                        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 variables;
+                        let externalTemplateId = undefined;
+                        let richText;
+                        if (templateId) {
+                            const templateData = await this.processTemplate(parseInt(templateId, 10), entity_type, entity_id, loggedInUser, mapped_entities);
+                            variables = templateData.variables;
+                            externalTemplateId = templateData.externalTemplateId;
+                            richText = templateData.rich_text;
+                            subject = templateData.subject;
+                        }
+                        let finalConfig = {
+                            ...hub.config_json,
+                            ...enhancedConfig,
+                            templateId: externalTemplateId,
+                            variables,
+                            richText,
+                        };
+                        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, message, finalConfig);
+                        if (result.success) {
+                            this.logger.log(`Generic message sent successfully via ${hub.integration_provider} to ${to}`);
+                            return result;
+                        }
+                        this.logger.warn(`Failed to send via ${hub.integration_provider}: ${result.error}`);
+                    }
+                    catch (error) {
+                        this.logger.error(`Error sending via ${hub.integration_provider}:`, error.message);
+                        continue;
+                    }
+                }
+            }
+            throw new Error('All communication providers failed');
+        }
+        catch (error) {
+            this.logger.error('Generic communication service error:', error.message);
+            throw error;
+        }
+    }
+    async sendBulkMessage(bulkDto) {
+        try {
+            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++) {
+                const batch = batches[i];
+                this.logger.log(`Processing batch ${i + 1}/${batches.length} with ${batch.length} recipients`);
+                const batchPromises = batch.map(async (recipient) => {
+                    try {
+                        const messageDto = {
+                            levelId,
+                            levelType,
+                            app_code,
+                            to: recipient,
+                            message,
+                            type,
+                            priority,
+                            subject,
+                            html,
+                            templateId,
+                            variables,
+                        };
+                        return await this.sendGenericMessage(messageDto);
+                    }
+                    catch (error) {
+                        return {
+                            success: false,
+                            provider: 'unknown',
+                            service: 'unknown',
+                            error: error.message,
+                            timestamp: new Date(),
+                        };
+                    }
+                });
+                const batchResults = await Promise.allSettled(batchPromises);
+                const processedResults = batchResults.map((result) => {
+                    if (result.status === 'fulfilled') {
+                        return result.value;
+                    }
+                    else {
+                        return {
+                            success: false,
+                            provider: 'unknown',
+                            service: 'unknown',
+                            error: result.reason?.message || 'Unknown error',
+                            timestamp: new Date(),
+                        };
+                    }
+                });
+                results.push(...processedResults);
+                if (i < batches.length - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+            }
+            const summary = {
+                total: results.length,
+                successful: results.filter((r) => r.success).length,
+                failed: results.filter((r) => !r.success).length,
+                successRate: ((results.filter((r) => r.success).length / results.length) *
+                    100).toFixed(2) + '%',
+            };
+            this.logger.log(`Bulk message completed: ${summary.successful}/${summary.total} successful`);
+            return { results, summary };
+        }
+        catch (error) {
+            this.logger.error('Bulk communication service error:', error.message);
+            throw error;
+        }
+    }
+    async scheduleMessage(scheduledDto) {
+        this.logger.log(`Message scheduled for ${scheduledDto.scheduleFor}`);
+        return {
+            scheduled: true,
+            scheduleId: `sched_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+        };
+    }
+    async sendTemplateMessage(templateDto) {
+        const template = await this.getTemplate(templateDto.templateId);
+        const processedMessage = this.replaceTemplateVariables(template.content, templateDto.variables);
+        const processedSubject = template.subject
+            ? this.replaceTemplateVariables(template.subject, templateDto.variables)
+            : undefined;
+        const messageDto = {
+            levelId: templateDto.levelId,
+            levelType: templateDto.levelType,
+            app_code: templateDto.app_code,
+            to: templateDto.to,
+            message: processedMessage,
+            subject: processedSubject,
+            type: templateDto.type,
+            templateId: templateDto.templateId,
+            variables: templateDto.variables,
+        };
+        return this.sendGenericMessage(messageDto);
+    }
+    detectCommunicationType(to, type) {
+        if (type) {
+            return type;
+        }
+        const recipient = Array.isArray(to) ? to[0] : to;
+        if (recipient.includes('@')) {
+            return 'EMAIL';
+        }
+        if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
+            return 'SMS';
+        }
+        return 'EMAIL';
+    }
+    sortConfigsByPriorityAndDefault(configs, _priority) {
+        return configs.sort((a, b) => {
+            if (a.is_default !== b.is_default) {
+                return b.is_default ? 1 : -1;
+            }
+            if (a.priority !== b.priority) {
+                return a.priority - b.priority;
+            }
+            return (new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+        });
+    }
+    async processTemplate(templateId, entity_type, entity_id, loggedInUser, mappedEntities) {
+        const commTemplate = await this.entityService.getEntityData(global_constant_1.COMM_TEMPLATE, templateId, {});
+        if (!commTemplate) {
+            return {
+                variables: {},
+                externalTemplateId: undefined,
+            };
+        }
+        let variables = {};
+        if (commTemplate.mapper_id) {
+            variables = await this.fieldMapperService.resolveData(commTemplate.mapper_id, 'LOOKUP', entity_type, entity_id, loggedInUser, {}, mappedEntities);
+        }
+        if (!commTemplate.template_id) {
+            let richText = commTemplate.rich_text;
+            if (!richText) {
+                if (commTemplate.markup_id) {
+                    let url = await this.mediaService.getMediaDownloadUrl(commTemplate.markup_id, {}, 60000);
+                    if (url) {
+                        let response = await axios_1.default.get(url.signedUrl, {
+                            responseType: 'text',
+                        });
+                        richText = response.data;
+                    }
+                }
+            }
+            richText = richText.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+                const value = variables[key];
+                if (value === undefined)
+                    return match;
+                if (typeof value === 'object' &&
+                    value !== null &&
+                    'signedUrl' in value) {
+                    return String(value.signedUrl);
+                }
+                return String(value);
+            });
+            return {
+                rich_text: richText,
+                subject: commTemplate.subject,
+            };
+        }
+        return {
+            variables,
+            externalTemplateId: commTemplate.template_id,
+        };
+    }
+    replaceTemplateVariables(template, variables) {
+        return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+            const value = variables[key];
+            return value !== undefined ? String(value) : match;
+        });
+    }
+    async getTemplate(templateId) {
+        return {
+            id: templateId,
+            subject: 'Default Subject {{variable}}',
+            content: 'Hello {{name}}, this is a template message with {{variable}}.',
+        };
+    }
+    chunkArray(array, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += chunkSize) {
+            chunks.push(array.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+    async initGmailOAuth(levelId, levelType, app_code, email) {
+        try {
+            const clientId = this.configService.get('CLIENT_ID');
+            const clientSecret = this.configService.get('CLIENT_SECRET');
+            if (!clientId || !clientSecret) {
+                throw new Error('Gmail OAuth credentials not configured');
+            }
+            const state = this.generateSecureState();
+            const callbackUrl = this.configService.get('CALLBACK_URL') ||
+                'http://localhost:5001/auth/google/callback';
+            this.gmailOAuthStates.set(state, {
+                levelId,
+                levelType,
+                app_code,
+                email,
+                timestamp: Date.now(),
+            });
+            setTimeout(() => {
+                this.gmailOAuthStates.delete(state);
+            }, 10 * 60 * 1000);
+            const oauth2Client = new googleapis_1.google.auth.OAuth2(clientId, clientSecret, callbackUrl);
+            const scopes = [
+                'https://www.googleapis.com/auth/gmail.send',
+                'https://www.googleapis.com/auth/gmail.readonly',
+                'https://www.googleapis.com/auth/userinfo.email',
+                'https://www.googleapis.com/auth/calendar',
+            ];
+            const authUrl = oauth2Client.generateAuthUrl({
+                access_type: 'offline',
+                scope: scopes,
+                state: `gmail_config:${state}`,
+                prompt: 'consent',
+                login_hint: email,
+            });
+            return { authUrl, state };
+        }
+        catch (error) {
+            this.logger.error('Error initializing Gmail OAuth:', error.message);
+            throw new Error('Failed to initialize Gmail OAuth');
+        }
+    }
+    async handleGmailOAuthCallback(code, state) {
+        try {
+            const oauthState = this.gmailOAuthStates.get(state);
+            if (!oauthState) {
+                throw new Error('Invalid or expired OAuth state');
+            }
+            this.gmailOAuthStates.delete(state);
+            if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
+                throw new Error('OAuth state expired');
+            }
+            const clientId = this.configService.get('CLIENT_ID');
+            const clientSecret = this.configService.get('CLIENT_SECRET');
+            const callbackUrl = this.configService.get('CALLBACK_URL') ||
+                'http://localhost:5001/auth/google/callback';
+            const oauth2Client = new googleapis_1.google.auth.OAuth2(clientId, clientSecret, callbackUrl);
+            const { tokens } = await oauth2Client.getToken(code);
+            if (!tokens.access_token) {
+                throw new Error('Failed to obtain access token');
+            }
+            oauth2Client.setCredentials(tokens);
+            const oauth2 = googleapis_1.google.oauth2({ version: 'v2', auth: oauth2Client });
+            const userInfo = await oauth2.userinfo.get();
+            const email = userInfo.data.email;
+            if (!email) {
+                throw new Error('Failed to get user email');
+            }
+            if (oauthState.email && oauthState.email !== email) {
+                throw new Error('Email mismatch with OAuth hint');
+            }
+            const gmailConfig = {
+                clientId,
+                clientSecret,
+                email: email,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                scope: tokens.scope,
+                tokenType: tokens.token_type,
+                expiryDate: tokens.expiry_date,
+            };
+            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,
+                status: 1,
+                priority: 1,
+                is_default: false,
+                config_json: gmailConfig,
+            });
+            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: savedConfig.id,
+                configId: savedConfig.id,
+            };
+        }
+        catch (error) {
+            this.logger.error('Error handling Gmail OAuth callback:', error.message);
+            throw new Error(`Failed to complete Gmail OAuth: ${error.message}`);
+        }
+    }
+    async handleGmailTokensCallback(email, accessToken, refreshToken, state) {
+        try {
+            const oauthState = this.gmailOAuthStates.get(state);
+            if (!oauthState) {
+                throw new Error('Invalid or expired OAuth state');
+            }
+            this.gmailOAuthStates.delete(state);
+            if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
+                throw new Error('OAuth state expired');
+            }
+            if (oauthState.email && oauthState.email !== email) {
+                throw new Error('Email mismatch with OAuth hint');
+            }
+            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, oauthState.app_code, 'EMAIL', 'gmail');
+            const gmailConfig = {
+                email: email,
+                accessToken: accessToken,
+                refreshToken: refreshToken,
+                authMethod: 'GOOGLE_SSO',
+                scopes: [
+                    'https://www.googleapis.com/auth/gmail.send',
+                    'https://www.googleapis.com/auth/userinfo.email',
+                ],
+            };
+            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,
+                status: 1,
+                priority: 1,
+                is_default: false,
+                config_json: gmailConfig,
+            });
+            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: savedConfig.id,
+                configId: savedConfig.id,
+            };
+        }
+        catch (error) {
+            this.logger.error('Error handling Gmail tokens callback:', error.message);
+            throw new Error(`Failed to complete Gmail tokens callback: ${error.message}`);
+        }
+    }
+    async testGmailConfig(hubId) {
+        try {
+            const integrationConfig = await this.configRepository.findOne({
+                where: { id: hubId },
+            });
+            if (!integrationConfig) {
+                throw new Error('Integration config not found');
+            }
+            const isValid = await this.gmailApiStrategy.validateConnection(integrationConfig.config_json);
+            if (!isValid) {
+                return {
+                    success: false,
+                    error: 'Gmail configuration is invalid or expired',
+                };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error('Error testing Gmail config:', error.message);
+            return { success: false, error: error.message };
+        }
+    }
+    generateSecureState() {
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+    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.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) {
+            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, provider, config) {
+        const key = `${configType.toLowerCase()}_${provider.toLowerCase()}`;
+        switch (key) {
+            case 'email_gmail':
+                return !config.accessToken || config.useOAuth === true;
+            case 'email_outlook':
+                return !config.accessToken || config.useOAuth === true;
+            default:
+                return false;
+        }
+    }
+    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_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_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}/${provider}`);
+        }
+    }
+    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.configRepository.update({
+                level_id: levelId,
+                level_type: levelType,
+                app_code: app_code,
+                integration_type: configType,
+            }, { is_default: false });
+        }
+        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,
+            status: 1,
+            priority: priority || 1,
+            is_default: is_default || false,
+            config_json: config,
+        });
+        const savedConfig = await this.configRepository.save(integrationConfig);
+        this.logger.log(`Communication config created: ${configType}/${provider} for ${levelType} ${levelId}`);
+        if (configType === 'TELEPHONE') {
+            try {
+                const did = config.did || config.callerNumber || config.fromNumber;
+                if (did) {
+                    const entityMapper = this.entityMapperRepository.create({
+                        integration_config_id: savedConfig.id,
+                        level_id: String(levelId),
+                        level_type: levelType,
+                        appcode: app_code,
+                        did: did,
+                        campaign_name: config.campaignName || null,
+                    });
+                    await this.entityMapperRepository.save(entityMapper);
+                    this.logger.log(`DID mapping created for TELEPHONE integration: ${did} for ${levelType} ${levelId}`);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to create DID mapping for TELEPHONE integration: ${error.message}`);
+            }
+        }
+        return Array.isArray(savedConfig) ? savedConfig[0] : savedConfig;
+    }
+    async initOutlookOAuth(levelId, levelType, app_code, email) {
+        try {
+            const clientId = this.configService.get('OUTLOOK_CLIENT_ID');
+            const tenantId = this.configService.get('OUTLOOK_TENANT_ID');
+            if (!clientId || !tenantId) {
+                throw new Error('Outlook OAuth credentials not configured');
+            }
+            const state = this.generateSecureState();
+            const callbackUrl = this.configService.get('OUTLOOK_CALLBACK_URL') ||
+                'http://localhost:5001/auth/outlook/callback';
+            this.gmailOAuthStates.set(state, {
+                levelId,
+                levelType,
+                app_code,
+                email,
+                timestamp: Date.now(),
+            });
+            setTimeout(() => {
+                this.gmailOAuthStates.delete(state);
+            }, 10 * 60 * 1000);
+            const scopes = [
+                'https://graph.microsoft.com/Mail.Send',
+                'https://graph.microsoft.com/User.Read',
+            ];
+            const authUrl = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/authorize?` +
+                `client_id=${clientId}&` +
+                `response_type=code&` +
+                `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
+                `scope=${encodeURIComponent(scopes.join(' '))}&` +
+                `state=outlook_config:${state}&` +
+                `response_mode=query&` +
+                `prompt=consent` +
+                (email ? `&login_hint=${encodeURIComponent(email)}` : '');
+            return { authUrl, state };
+        }
+        catch (error) {
+            this.logger.error('Error initializing Outlook OAuth:', error.message);
+            throw new Error('Failed to initialize Outlook OAuth');
+        }
+    }
+    async handleOutlookOAuthCallback(code, state) {
+        try {
+            const oauthState = this.gmailOAuthStates.get(state);
+            if (!oauthState) {
+                throw new Error('Invalid or expired OAuth state');
+            }
+            this.gmailOAuthStates.delete(state);
+            if (Date.now() - oauthState.timestamp > 10 * 60 * 1000) {
+                throw new Error('OAuth state expired');
+            }
+            const clientId = this.configService.get('OUTLOOK_CLIENT_ID');
+            const clientSecret = this.configService.get('OUTLOOK_CLIENT_SECRET');
+            const tenantId = this.configService.get('OUTLOOK_TENANT_ID');
+            const callbackUrl = this.configService.get('OUTLOOK_CALLBACK_URL') ||
+                'http://localhost:5001/auth/outlook/callback';
+            const tokenResponse = await fetch(`https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    code: code,
+                    redirect_uri: callbackUrl,
+                    grant_type: 'authorization_code',
+                }),
+            });
+            const tokens = await tokenResponse.json();
+            if (!tokens.access_token) {
+                throw new Error('Failed to obtain access token');
+            }
+            const userResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
+                headers: {
+                    Authorization: `Bearer ${tokens.access_token}`,
+                },
+            });
+            const userInfo = await userResponse.json();
+            const email = userInfo.mail || userInfo.userPrincipalName;
+            if (!email) {
+                throw new Error('Failed to get user email');
+            }
+            await this.validateUniqueActiveConfig(oauthState.levelId, oauthState.levelType, oauthState.app_code, 'EMAIL', 'outlook');
+            const outlookConfig = {
+                clientId,
+                tenantId,
+                email: email,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                scope: tokens.scope,
+                tokenType: tokens.token_type,
+                expiresIn: tokens.expires_in,
+            };
+            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,
+                status: 1,
+                priority: 1,
+                is_default: false,
+                config_json: outlookConfig,
+            });
+            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: savedConfig.id,
+                configId: savedConfig.id,
+            };
+        }
+        catch (error) {
+            this.logger.error('Error handling Outlook OAuth callback:', error.message);
+            throw new Error(`Failed to complete Outlook OAuth: ${error.message}`);
+        }
+    }
+    async getIntegrationConfigById(hubId) {
+        try {
+            const integrationConfig = await this.configRepository.findOne({
+                where: { id: hubId },
+            });
+            if (!integrationConfig) {
+                return null;
+            }
+            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 {
+                ...integrationConfig,
+                config: integrationConfig,
+                linkedSource,
+                configDetails,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error fetching communication config by ID ${hubId}:`, error.message);
+            throw new Error(`Failed to fetch communication configuration: ${error.message}`);
+        }
+    }
+    async getIntegrationTemplates(levelId, levelType, app_code, integration_type) {
+        try {
+            const config = await this.getSingleActiveConfig(levelId, levelType, app_code, integration_type);
+            if (!config) {
+                return {
+                    success: false,
+                    error: `No active ${integration_type} configuration found for this level`,
+                };
+            }
+            const strategy = this.integrationFactory.create(config.integration_type, 'API', config.integration_provider);
+            if (typeof strategy.getTemplates !== 'function') {
+                return {
+                    success: false,
+                    error: `Template retrieval not supported for provider: ${config.integration_provider}`,
+                };
+            }
+            return await strategy.getTemplates(config.config_json);
+        }
+        catch (error) {
+            this.logger.error(`Error fetching templates for ${integration_type} level ${levelId}/${levelType}:`, error.message);
+            return {
+                success: false,
+                error: `Failed to fetch templates: ${error.message}`,
+            };
+        }
+    }
+    async getSendGridTemplates(levelId, levelType, app_code) {
+        try {
+            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_json?.apiKey;
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: 'SendGrid API key not found in configuration',
+                };
+            }
+            return this.sendGridApiStrategy.getTemplates(apiKey);
+        }
+        catch (error) {
+            this.logger.error(`Error fetching SendGrid templates for level ${levelId}/${levelType}:`, error.message);
+            return {
+                success: false,
+                error: `Failed to fetch SendGrid templates: ${error.message}`,
+            };
+        }
+    }
+    async getSendGridVerifiedSenders(apiKey) {
+        try {
+            if (!apiKey) {
+                return {
+                    success: false,
+                    error: 'SendGrid API key not found in configuration',
+                };
+            }
+            return this.sendGridApiStrategy.getVerifiedSenders(apiKey);
+        }
+        catch (error) {
+            this.logger.error(`Error fetching SendGrid verified senders`, error.message);
+            return {
+                success: false,
+                error: `Failed to fetch SendGrid verified senders: ${error.message}`,
+            };
+        }
+    }
+    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 bulkCreateUserIntegration(bulkDto) {
+        const created = [];
+        const updated = [];
+        const failed = [];
+        try {
+            for (const createDto of bulkDto.user_integrations) {
+                try {
+                    const existing = await this.userIntegrationRepository.findOne({
+                        where: {
+                            user_id: createDto.user_id,
+                            integration_config_id: createDto.integration_config_id,
+                        },
+                    });
+                    if (existing) {
+                        if (createDto.external_user_id !== undefined) {
+                            existing.external_user_id = createDto.external_user_id;
+                        }
+                        if (createDto.external_user_data !== undefined) {
+                            existing.external_user_data = createDto.external_user_data;
+                        }
+                        if (createDto.is_active !== undefined) {
+                            existing.is_active = createDto.is_active;
+                        }
+                        const updatedIntegration = await this.userIntegrationRepository.save(existing);
+                        updated.push(updatedIntegration);
+                        this.logger.log(`Updated user integration mapping for user ${createDto.user_id} and config ${createDto.integration_config_id}`);
+                    }
+                    else {
+                        const config = await this.configRepository.findOne({
+                            where: { id: createDto.integration_config_id },
+                        });
+                        if (!config) {
+                            failed.push({
+                                data: createDto,
+                                error: 'Integration configuration not found',
+                            });
+                            continue;
+                        }
+                        const userIntegration = this.userIntegrationRepository.create(createDto);
+                        const savedIntegration = await this.userIntegrationRepository.save(userIntegration);
+                        created.push(savedIntegration);
+                        this.logger.log(`Created user integration mapping for user ${createDto.user_id} and config ${createDto.integration_config_id}`);
+                    }
+                }
+                catch (error) {
+                    failed.push({
+                        data: createDto,
+                        error: error.message || 'Unknown error',
+                    });
+                    this.logger.error(`Error processing user integration for user ${createDto.user_id}: ${error.message}`);
+                }
+            }
+            const summary = {
+                total: bulkDto.user_integrations.length,
+                created: created.length,
+                updated: updated.length,
+                failed: failed.length,
+            };
+            this.logger.log(`Bulk user integration completed: ${summary.created} created, ${summary.updated} updated, ${summary.failed} failed`);
+            return { created, updated, failed, summary };
+        }
+        catch (error) {
+            this.logger.error(`Error in bulk user integration creation: ${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;
+        }
+    }
+    async checkAgentStatus(levelId, levelType, appCode, userId, integrationType = 'TELEPHONE') {
+        try {
+            const config = await this.getSingleActiveConfig(levelId, levelType, appCode, integrationType);
+            if (!config) {
+                return {
+                    success: false,
+                    error: 'No active TELEPHONE configuration found',
+                };
+            }
+            const userIntegration = await this.getUserIntegrationByUserAndConfig(userId, config.id);
+            if (!userIntegration) {
+                return {
+                    success: false,
+                    error: 'User integration mapping not found. Please configure agent details.',
+                };
+            }
+            const strategy = this.integrationFactory.create(config.integration_type, 'API', config.integration_provider);
+            let mergedConfig = config.config_json;
+            if (strategy.createUserSpecificConfig) {
+                mergedConfig = strategy.createUserSpecificConfig(config.config_json, userIntegration.external_user_id);
+            }
+            if (typeof strategy.checkAgentStatus !== 'function') {
+                return {
+                    success: false,
+                    error: `Agent status check not supported for provider: ${config.integration_provider}`,
+                };
+            }
+            const statusResult = await strategy.checkAgentStatus(mergedConfig);
+            return {
+                success: true,
+                isReady: statusResult.isReady,
+                state: statusResult.state,
+                error: statusResult.error,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error checking agent status: ${error.message}`, error.stack);
+            return {
+                success: false,
+                error: error.message || 'Failed to check agent status',
+            };
+        }
+    }
+};
+exports.IntegrationService = IntegrationService;
+exports.IntegrationService = IntegrationService = IntegrationService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(integration_config_entity_1.IntegrationConfig)),
+    __param(1, (0, typeorm_1.InjectRepository)(user_integration_entity_1.UserIntegration)),
+    __param(2, (0, typeorm_1.InjectRepository)(integration_entity_mapper_entity_1.IntegrationEntityMapper)),
+    __param(9, (0, common_1.Inject)('FieldMapperService')),
+    __param(12, (0, common_1.Inject)((0, common_1.forwardRef)(() => integration_queue_service_1.IntegrationQueueService))),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.DataSource,
+        integration_factory_1.IntegrationFactory,
+        gmail_api_strategy_1.GmailApiStrategy,
+        sendgrid_api_strategy_1.SendGridApiStrategy,
+        config_1.ConfigService,
+        media_data_service_1.MediaDataService,
+        field_mapper_service_1.FieldMapperService,
+        entity_service_impl_service_1.EntityServiceImpl,
+        reflection_helper_service_1.ReflectionHelper,
+        integration_queue_service_1.IntegrationQueueService])
+], IntegrationService);
+//# sourceMappingURL=integration.service.js.map