Telegram Integration¶

from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters

class TelegramBotHandler:
    def __init__(self, bot_token, studio_api):
        self.updater = Updater(token=bot_token)
        self.studio = studio_api
        self.setup_handlers()

    def setup_handlers(self):
        """Setup bot command handlers"""
        dispatcher = self.updater.dispatcher

        # Command handlers
        dispatcher.add_handler(CommandHandler("compliance", self.compliance_command))
        dispatcher.add_handler(CommandHandler("evidence", self.evidence_command))
        dispatcher.add_handler(CommandHandler("risk", self.risk_command))
        dispatcher.add_handler(CommandHandler("audit", self.audit_command))
        dispatcher.add_handler(CommandHandler("reports", self.reports_command))
        dispatcher.add_handler(CommandHandler("help", self.help_command))

        # Message handlers
        dispatcher.add_handler(MessageHandler(Filters.document, self.handle_document))
        dispatcher.add_handler(MessageHandler(Filters.photo, self.handle_photo))

    def compliance_command(self, update: Update, context):
        """Handle /compliance command"""
        args = context.args
        framework = args[0] if args else None

        # Get compliance data
        compliance_data = self.studio.get_compliance_status(framework)

        # Format response
        response = self.format_compliance_response(compliance_data)

        # Send response
        update.message.reply_text(response, parse_mode='Markdown')

    def evidence_command(self, update: Update, context):
        """Handle /evidence command"""
        args = context.args

        if len(args) < 2:
            update.message.reply_text(
                "Usage: /evidence <type> <description>\n"
                "Example: /evidence document \"Quarterly compliance report\""
            )
            return

        evidence_type = args[0]
        description = " ".join(args[1:])

        # Create evidence record
        evidence_id = self.studio.create_evidence_record(
            type=evidence_type,
            description=description,
            user_id=update.effective_user.id
        )

        # Send upload instructions
        keyboard = [
            [InlineKeyboardButton("Upload Document", callback_data=f"upload_doc_{evidence_id}")],
            [InlineKeyboardButton("Upload Photo", callback_data=f"upload_photo_{evidence_id}")]
        ]

        reply_markup = InlineKeyboardMarkup(keyboard)

        update.message.reply_text(
            f"Evidence record created (ID: {evidence_id}). "
            "Please upload the evidence file:",
            reply_markup=reply_markup
        )

    def risk_command(self, update: Update, context):
        """Handle /risk command"""
        args = context.args
        level_filter = args[0] if args else None

        # Get risk assessment
        risk_data = self.studio.get_risk_assessment(level_filter)

        # Format response
        response = self.format_risk_response(risk_data)

        # Send response
        update.message.reply_text(response, parse_mode='Markdown')

    def format_compliance_response(self, data):
        """Format compliance status response"""
        response = f"📊 *Compliance Status*\n\n"
        response += f"Overall Score: {data['overall_score']}/100\n"
        response += f"Critical Issues: {data['critical_issues']}\n"
        response += f"Open Tasks: {data['open_tasks']}\n"
        response += f"Last Updated: {data['last_updated']}\n\n"

        if data['frameworks']:
            response += "*Framework Details:*\n"
            for framework in data['frameworks']:
                response += f"• {framework['name']}: {framework['score']}/100\n"

        return response

    def format_risk_response(self, data):
        """Format risk assessment response"""
        response = f"⚠️ *Risk Assessment*\n\n"
        response += f"Total Risks: {data['total_risks']}\n"
        response += f"Critical: {data['critical_risks']}\n"
        response += f"High: {data['high_risks']}\n"
        response += f"Medium: {data['medium_risks']}\n"
        response += f"Low: {data['low_risks']}\n\n"

        if data['top_risks']:
            response += "*Top Risks:*\n"
            for risk in data['top_risks'][:5]:
                response += f"• {risk['title']} ({risk['level']})\n"

        return response

def handle_document(self, update: Update, context):
    """Handle document uploads"""
    document = update.message.document

    # Download file
    file_info = context.bot.get_file(document.file_id)
    file_content = file_info.download_as_bytearray()

    # Upload to Studio Platform
    evidence_id = self.studio.upload_evidence(
        file_content=file_content,
        file_name=document.file_name,
        file_size=document.file_size,
        mime_type=document.mime_type,
        user_id=update.effective_user.id,
        source='telegram'
    )

    # Send confirmation
    update.message.reply_text(
        f"✅ Document uploaded successfully!\n"
        f"File: {document.file_name}\n"
        f"Evidence ID: {evidence_id}"
    )

def handle_photo(self, update: Update, context):
    """Handle photo uploads"""
    photo = update.message.photo[-1]  # Get highest resolution

    # Download file
    file_info = context.bot.get_file(photo.file_id)
    file_content = file_info.download_as_bytearray()

    # Upload to Studio Platform
    evidence_id = self.studio.upload_evidence(
        file_content=file_content,
        file_name=f"photo_{photo.file_unique_id}.jpg",
        file_size=photo.file_size,
        mime_type='image/jpeg',
        user_id=update.effective_user.id,
        source='telegram'
    )

    # Send confirmation
    update.message.reply_text(
        f"✅ Photo uploaded successfully!\n"
        f"Evidence ID: {evidence_id}"
    )

class TelegramNotificationService:
    def __init__(self, bot_token, studio_api):
        self.bot = telegram.Bot(token=bot_token)
        self.studio = studio_api

    def send_compliance_alert(self, alert_data):
        """Send compliance alert"""
        chat_id = alert_data.get('chat_id', '@compliance_alerts')

        # Format message
        message = self.format_alert_message(alert_data)

        # Send message
        self.bot.send_message(
            chat_id=chat_id,
            text=message,
            parse_mode='Markdown',
            disable_web_page_preview=True
        )

    def format_alert_message(self, data):
        """Format alert message"""
        severity_emoji = {
            'critical': '🚨',
            'high': '⚠️',
            'medium': '📋',
            'low': 'ℹ️'
        }

        emoji = severity_emoji.get(data['severity'], '📢')

        message = f"{emoji} *{data['title']}*\n\n"
        message += f"*Severity:* {data['severity'].title()}\n"
        message += f"*Description:* {data['description']}\n"

        if data.get('action_required'):
            message += f"*Action Required:* {data['action_required']}\n"

        if data.get('due_date'):
            message += f"*Due Date:* {data['due_date']}\n"

        if data.get('link'):
            message += f"\n[View Details]({data['link']})"

        return message

    def send_report_notification(self, report_data):
        """Send report ready notification"""
        chat_id = report_data.get('chat_id', '@compliance_reports')

        message = f"📊 *Report Ready*\n\n"
        message += f"*Report:* {report_data['title']}\n"
        message += f"*Period:* {report_data['period']}\n"
        message += f"*Generated:* {report_data['generated_date']}\n\n"

        if report_data.get('download_link'):
            message += f"[Download Report]({report_data['download_link']})"

        self.bot.send_message(
            chat_id=chat_id,
            text=message,
            parse_mode='Markdown'
        )

class ComplianceAssistantBot:
    def __init__(self, bot_token, studio_api):
        self.bot = telegram.Bot(token=bot_token)
        self.studio = studio_api
        self.setup_handlers()

    def setup_handlers(self):
        """Setup advanced bot handlers"""
        # Inline query handler
        self.dispatcher.add_handler(InlineQueryHandler(self.inline_query_handler))

        # Callback query handler
        self.dispatcher.add_handler(CallbackQueryHandler(self.callback_query_handler))

    def inline_query_handler(self, update: Update, context):
        """Handle inline queries"""
        query = update.inline_query.query
        results = []

        if query.startswith('compliance'):
            # Search compliance items
            compliance_items = self.studio.search_compliance(query[11:])

            for item in compliance_items:
                results.append(
                    telegram.InlineQueryResultArticle(
                        id=item['id'],
                        title=item['title'],
                        description=item['description'],
                        input_message_content=telegram.InputTextMessageContent(
                            message_text=f"Compliance Item: {item['title']}\n{item['description']}"
                        )
                    )
                )

        update.inline_query.answer(results)

    def callback_query_handler(self, update: Update, context):
        """Handle button callbacks"""
        query = update.callback_query
        query.answer()

        if query.data.startswith('upload_'):
            self.handle_upload_callback(query)
        elif query.data.startswith('approve_'):
            self.handle_approve_callback(query)

    def handle_upload_callback(self, query):
        """Handle upload button callback"""
        evidence_id = query.data.split('_')[2]

        query.edit_message_text(
            text=f"Please upload the evidence file for Evidence ID: {evidence_id}"
        )

class TelegramWorkflowIntegration:
    def __init__(self, telegram_bot, studio_api):
        self.telegram = telegram_bot
        self.studio = studio_api

    def start_compliance_workflow(self, user_id, workflow_type):
        """Start compliance workflow via Telegram"""

        if workflow_type == 'evidence_collection':
            self.start_evidence_collection_workflow(user_id)
        elif workflow_type == 'compliance_review':
            self.start_compliance_review_workflow(user_id)
        elif workflow_type == 'risk_assessment':
            self.start_risk_assessment_workflow(user_id)

    def start_evidence_collection_workflow(self, user_id):
        """Start evidence collection workflow"""

        # Create workflow instance
        workflow_id = self.studio.create_workflow(
            type='evidence_collection',
            user_id=user_id
        )

        # Send initial message
        keyboard = [
            [telegram.InlineKeyboardButton("Upload Document", callback_data=f"upload_doc_{workflow_id}")],
            [telegram.InlineKeyboardButton("Upload Photo", callback_data=f"upload_photo_{workflow_id}")],
            [telegram.InlineKeyboardButton("Cancel", callback_data=f"cancel_{workflow_id}")]
        ]

        reply_markup = telegram.InlineKeyboardMarkup(keyboard)

        self.telegram.bot.send_message(
            chat_id=user_id,
            text="📋 Evidence Collection Workflow\n\n"
                 "Please select the type of evidence you want to upload:",
            reply_markup=reply_markup
        )