rez_core 2.2.154 → 2.2.156

package/dist/module/communication/service/communication.service.js

@@ -0,0 +1,726 @@
+"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 CommunicationService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunicationService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const config_1 = require("@nestjs/config");
+const googleapis_1 = require("googleapis");
+const communication_hub_entity_1 = require("../entity/communication-hub.entity");
+const communication_config_entity_1 = require("../entity/communication-config.entity");
+const communication_factory_1 = require("../factories/communication.factory");
+const gmail_api_strategy_1 = require("../strategies/email/gmail-api.strategy");
+let CommunicationService = CommunicationService_1 = class CommunicationService {
+    constructor(hubRepository, configRepository, communicationFactory, gmailApiStrategy, configService) {
+        this.hubRepository = hubRepository;
+        this.configRepository = configRepository;
+        this.communicationFactory = communicationFactory;
+        this.gmailApiStrategy = gmailApiStrategy;
+        this.configService = configService;
+        this.logger = new common_1.Logger(CommunicationService_1.name);
+        this.gmailOAuthStates = new Map();
+    }
+    async sendMessage({ levelId, levelType, to, message, mode, priority = 1, }) {
+        try {
+            const hubs = await this.getActiveHubs(levelId, levelType, mode);
+            if (!hubs.length) {
+                throw new Error(`No active communication configuration found for ${levelType} ${levelId}`);
+            }
+            const sortedHubs = this.sortHubsByPriority(hubs, priority);
+            for (const hub of sortedHubs) {
+                try {
+                    const result = await this.sendViaHub(hub, to, message);
+                    if (result.success) {
+                        this.logger.log(`Message sent successfully via ${hub.provider}/${hub.service}`);
+                        return result;
+                    }
+                    this.logger.warn(`Failed to send via ${hub.provider}/${hub.service}: ${result.error}`);
+                }
+                catch (error) {
+                    this.logger.error(`Error sending via ${hub.provider}/${hub.service}:`, error.message);
+                    continue;
+                }
+            }
+            throw new Error('All communication providers failed');
+        }
+        catch (error) {
+            this.logger.error('Communication service error:', error.message);
+            throw error;
+        }
+    }
+    async getActiveHubs(levelId, levelType, mode) {
+        let query = this.hubRepository
+            .createQueryBuilder('hub')
+            .leftJoin('communication_config', 'config', 'config.id = hub.config_id')
+            .select([
+            'hub.id',
+            'hub.status',
+            'hub.config_id',
+            'hub.communication_config_type',
+            'hub.service',
+            'hub.provider',
+            'hub.priority',
+            'hub.is_default',
+            'hub.created_at',
+            'hub.updated_at',
+            'config.id as config_id',
+            'config.config_json as config_json',
+            'config.created_at as config_created_at',
+            'config.updated_at as config_updated_at'
+        ])
+            .where('hub.level_id = :levelId', { levelId })
+            .andWhere('hub.level_type = :levelType', { levelType })
+            .andWhere('hub.status = :status', { status: 1 });
+        if (mode) {
+            query = query.andWhere('hub.communication_config_type = :mode', { mode });
+        }
+        const results = await query.getRawMany();
+        const hubsWithConfig = results.map(row => ({
+            id: row.hub_id,
+            level_id: row.hub_level_id,
+            level_type: row.hub_level_type,
+            status: row.hub_status,
+            config_id: row.hub_config_id,
+            communication_config_type: row.hub_communication_config_type,
+            service: row.hub_service,
+            provider: row.hub_provider,
+            priority: row.hub_priority || 1,
+            is_default: row.hub_is_default || false,
+            created_at: row.hub_created_at,
+            updated_at: row.hub_updated_at,
+            config: {
+                id: row.config_id,
+                config_json: row.config_json,
+                created_at: row.config_created_at,
+                updated_at: row.config_updated_at,
+            },
+        }));
+        return hubsWithConfig;
+    }
+    sortHubsByPriority(hubs, _priority) {
+        return hubs;
+    }
+    async sendViaHub(hub, to, message) {
+        const strategy = this.communicationFactory.create(hub.communication_config_type, hub.service, hub.provider);
+        return strategy.sendMessage(to, message, hub.config.config_json);
+    }
+    async createCommunicationConfig(levelId, levelType, configType, service, provider, config, priority, is_default) {
+        const supportedCombinations = await this.getSupportedCombinations();
+        const isValidCombination = supportedCombinations.some(combo => combo.mode === configType &&
+            combo.service.toLowerCase() === service.toLowerCase() &&
+            combo.provider.toLowerCase() === provider.toLowerCase());
+        if (!isValidCombination) {
+            throw new Error(`Unsupported combination: ${configType}/${service}/${provider}`);
+        }
+        const requiresOAuth = this.requiresOAuthFlow(configType, service, provider, config);
+        if (requiresOAuth) {
+            return await this.generateOAuthUrl(levelId, levelType, configType, service, provider, config, priority, is_default);
+        }
+        return await this.createDirectConfig(levelId, levelType, configType, service, provider, config, priority, is_default);
+    }
+    async getSupportedCombinations() {
+        return this.communicationFactory.getAllSupportedCombinations();
+    }
+    async getLevelConfigs(levelId, levelType) {
+        return this.hubRepository.find({
+            where: { level_id: levelId, level_type: levelType },
+            order: { created_at: 'DESC' },
+        });
+    }
+    async updateConfigStatus(hubId, status) {
+        await this.hubRepository.update(hubId, { status });
+    }
+    async sendGenericMessage(messageDto) {
+        try {
+            const { levelId, levelType, to, message, type, priority = 'medium', subject, html, cc, bcc, attachments, mediaUrl, templateId, variables } = messageDto;
+            const communicationType = this.detectCommunicationType(to, type);
+            const hubs = await this.getActiveHubs(levelId, levelType, communicationType);
+            if (!hubs.length) {
+                throw new Error(`No active ${communicationType} configuration found for ${levelType} ${levelId}`);
+            }
+            const sortedHubs = this.sortHubsByPriorityAndDefault(hubs, 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 sortedHubs) {
+                        try {
+                            const strategy = this.communicationFactory.create(hub.communication_config_type, hub.service, hub.provider);
+                            let processedMessage = message;
+                            if (templateId && variables) {
+                                processedMessage = this.processTemplate(message, variables);
+                            }
+                            const finalConfig = { ...hub.config.config_json, ...enhancedConfig };
+                            const result = await strategy.sendMessage(recipient, processedMessage, finalConfig);
+                            if (result.success) {
+                                this.logger.log(`Generic message sent successfully via ${hub.provider}/${hub.service} to ${recipient}`);
+                                results.push(result);
+                                hasSuccess = true;
+                                break;
+                            }
+                            this.logger.warn(`Failed to send via ${hub.provider}/${hub.service} to ${recipient}: ${result.error}`);
+                        }
+                        catch (error) {
+                            this.logger.error(`Error sending via ${hub.provider}/${hub.service} to ${recipient}:`, error.message);
+                            continue;
+                        }
+                    }
+                }
+                if (hasSuccess) {
+                    return {
+                        success: true,
+                        messageId: results.map(r => r.messageId).join(','),
+                        provider: 'multiple',
+                        service: 'multiple',
+                        timestamp: new Date(),
+                    };
+                }
+            }
+            else {
+                for (const hub of sortedHubs) {
+                    try {
+                        const strategy = this.communicationFactory.create(hub.communication_config_type, hub.service, hub.provider);
+                        let processedMessage = message;
+                        if (templateId && variables) {
+                            processedMessage = this.processTemplate(message, variables);
+                        }
+                        const finalConfig = { ...hub.config.config_json, ...enhancedConfig };
+                        const result = await strategy.sendMessage(to, processedMessage, finalConfig);
+                        if (result.success) {
+                            this.logger.log(`Generic message sent successfully via ${hub.provider}/${hub.service} to ${to}`);
+                            return result;
+                        }
+                        this.logger.warn(`Failed to send via ${hub.provider}/${hub.service}: ${result.error}`);
+                    }
+                    catch (error) {
+                        this.logger.error(`Error sending via ${hub.provider}/${hub.service}:`, 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, 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,
+                            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.processTemplate(template.content, templateDto.variables);
+        const processedSubject = template.subject ? this.processTemplate(template.subject, templateDto.variables) : undefined;
+        const messageDto = {
+            levelId: templateDto.levelId,
+            levelType: templateDto.levelType,
+            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 communication_hub_entity_1.CommunicationConfigType.EMAIL;
+        }
+        if (/^\+?[\d\s\-\(\)]+$/.test(recipient)) {
+            return communication_hub_entity_1.CommunicationConfigType.SMS;
+        }
+        return communication_hub_entity_1.CommunicationConfigType.EMAIL;
+    }
+    sortHubsByPriorityAndDefault(hubs, _priority) {
+        return hubs.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();
+        });
+    }
+    processTemplate(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, 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,
+                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',
+            ];
+            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,
+            };
+            const communicationConfig = this.configRepository.create({
+                config_json: gmailConfig,
+            });
+            const savedConfig = await this.configRepository.save(communicationConfig);
+            const hub = this.hubRepository.create({
+                level_id: oauthState.levelId,
+                level_type: oauthState.levelType,
+                config_id: savedConfig.id,
+                communication_config_type: communication_hub_entity_1.CommunicationConfigType.EMAIL,
+                service: 'API',
+                provider: 'gmail',
+                status: 1,
+            });
+            const savedHub = await this.hubRepository.save(hub);
+            this.logger.log(`Gmail OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`);
+            return {
+                hubId: savedHub.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');
+            }
+            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 communicationConfig = this.configRepository.create({
+                config_json: gmailConfig,
+            });
+            const savedConfig = await this.configRepository.save(communicationConfig);
+            const hub = this.hubRepository.create({
+                level_id: oauthState.levelId,
+                level_type: oauthState.levelType,
+                config_id: savedConfig.id,
+                communication_config_type: communication_hub_entity_1.CommunicationConfigType.EMAIL,
+                service: 'API',
+                provider: 'gmail',
+                status: 1,
+            });
+            const savedHub = await this.hubRepository.save(hub);
+            this.logger.log(`Gmail tokens configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`);
+            return {
+                hubId: savedHub.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 hub = await this.hubRepository.findOne({
+                where: { id: hubId },
+            });
+            if (!hub) {
+                throw new Error('Communication hub not found');
+            }
+            const config = await this.configRepository.findOne({
+                where: { id: hub.config_id },
+            });
+            if (!config) {
+                throw new Error('Configuration not found');
+            }
+            const isValid = await this.gmailApiStrategy.validateConnection(config.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);
+    }
+    requiresOAuthFlow(configType, service, provider, config) {
+        const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+        switch (key) {
+            case 'email_api_gmail':
+                return !config.accessToken || config.useOAuth === true;
+            case 'email_api_outlook':
+                return !config.accessToken || config.useOAuth === true;
+            default:
+                return false;
+        }
+    }
+    async generateOAuthUrl(levelId, levelType, configType, service, provider, config, priority, is_default) {
+        const key = `${configType.toLowerCase()}_${service.toLowerCase()}_${provider.toLowerCase()}`;
+        switch (key) {
+            case 'email_api_gmail':
+                const gmailResult = await this.initGmailOAuth(levelId, levelType, config.email);
+                return {
+                    authUrl: gmailResult.authUrl,
+                    state: gmailResult.state,
+                    message: 'Please complete Gmail OAuth authorization. Configuration will be created automatically after authorization.'
+                };
+            case 'email_api_outlook':
+                const outlookResult = await this.initOutlookOAuth(levelId, levelType, config.email);
+                return {
+                    authUrl: outlookResult.authUrl,
+                    state: outlookResult.state,
+                    message: 'Please complete Outlook OAuth authorization. Configuration will be created automatically after authorization.'
+                };
+            default:
+                throw new Error(`OAuth not supported for ${configType}/${service}/${provider}`);
+        }
+    }
+    async createDirectConfig(levelId, levelType, configType, service, provider, config, priority, is_default) {
+        if (is_default) {
+            await this.hubRepository.update({
+                level_id: levelId,
+                level_type: levelType,
+                communication_config_type: configType,
+            }, { is_default: false });
+        }
+        const communicationConfig = this.configRepository.create({
+            config_json: config,
+        });
+        const savedConfig = await this.configRepository.save(communicationConfig);
+        const hub = this.hubRepository.create({
+            level_id: levelId,
+            level_type: levelType,
+            config_id: savedConfig.id,
+            communication_config_type: configType,
+            service: service,
+            provider: provider,
+            priority: priority || 1,
+            is_default: is_default || false,
+            status: 1,
+        });
+        const savedHub = await this.hubRepository.save(hub);
+        this.logger.log(`Communication config created: ${configType}/${service}/${provider} for ${levelType} ${levelId}`);
+        return Array.isArray(savedHub) ? savedHub[0] : savedHub;
+    }
+    async initOutlookOAuth(levelId, levelType, 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,
+                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');
+            }
+            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 communicationConfig = this.configRepository.create({
+                config_json: outlookConfig,
+            });
+            const savedConfig = await this.configRepository.save(communicationConfig);
+            const hub = this.hubRepository.create({
+                level_id: oauthState.levelId,
+                level_type: oauthState.levelType,
+                config_id: savedConfig.id,
+                communication_config_type: communication_hub_entity_1.CommunicationConfigType.EMAIL,
+                service: 'API',
+                provider: 'outlook',
+                status: 1,
+            });
+            const savedHub = await this.hubRepository.save(hub);
+            this.logger.log(`Outlook OAuth configuration created successfully for ${oauthState.levelType} ${oauthState.levelId} and email ${email}`);
+            return {
+                hubId: savedHub.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}`);
+        }
+    }
+};
+exports.CommunicationService = CommunicationService;
+exports.CommunicationService = CommunicationService = CommunicationService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(communication_hub_entity_1.CommunicationHub)),
+    __param(1, (0, typeorm_1.InjectRepository)(communication_config_entity_1.CommunicationConfig)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        communication_factory_1.CommunicationFactory,
+        gmail_api_strategy_1.GmailApiStrategy,
+        config_1.ConfigService])
+], CommunicationService);
+//# sourceMappingURL=communication.service.js.map