rez_core 3.1.165 → 3.1.167

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

@@ -1,1558 +0,0 @@
-"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");
-let IntegrationService = IntegrationService_1 = class IntegrationService {
-    constructor(configRepository, userIntegrationRepository, entityMapperRepository, dataSource, integrationFactory, gmailApiStrategy, sendGridApiStrategy, configService, mediaService, fieldMapperService, entityService, 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.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 allIntegrationData = await this.dataSource.query(`SELECT *
-         FROM cr_integration_master`);
-            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, } = 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,
-            };
-            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;
-                            if (templateId) {
-                                const templateData = await this.processTemplate(parseInt(templateId, 10), entity_type, entity_id);
-                                variables = templateData.variables;
-                                externalTemplateId = templateData.externalTemplateId;
-                                richText = templateData.rich_text;
-                                subject = templateData.subject;
-                            }
-                            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);
-                            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) {
-        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, {});
-        }
-        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];
-                return value !== undefined ? String(value) : match;
-            });
-            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(11, (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,
-        integration_queue_service_1.IntegrationQueueService])
-], IntegrationService);
-//# sourceMappingURL=integration.service.js.map