WhatsApp Integration¶

class WhatsAppMessageTemplates:
    @staticmethod
    def create_compliance_alert(issue_data):
        """Create compliance alert message"""
        return {
            "messaging_product": "whatsapp",
            "to": issue_data['phone_number'],
            "type": "template",
            "template": {
                "name": "compliance_critical_alert",
                "language": {"code": "en"},
                "components": [
                    {
                        "type": "body",
                        "parameters": [
                            {"type": "text", "text": issue_data['issue']},
                            {"type": "text", "text": issue_data['severity']},
                            {"type": "text", "text": issue_data['action']}
                        ]
                    }
                ]
            }
        }

    @staticmethod
    def create_evidence_request(request_data):
        """Create evidence collection request"""
        return {
            "messaging_product": "whatsapp",
            "to": request_data['phone_number'],
            "type": "template",
            "template": {
                "name": "evidence_collection_request",
                "language": {"code": "en"},
                "components": [
                    {
                        "type": "body",
                        "parameters": [
                            {"type": "text", "text": request_data['audit']},
                            {"type": "text", "text": request_data['evidence_type']},
                            {"type": "text", "text": request_data['deadline']}
                        ]
                    }
                ]
            }
        }

class WhatsAppEvidenceHandler:
    def __init__(self, whatsapp_client, studio_api):
        self.whatsapp = whatsapp_client
        self.studio = studio_api

    def handle_media_message(self, message_data):
        """Handle incoming media messages"""
        media_id = message_data['media_id']
        media_type = message_data['media_type']
        from_number = message_data['from']

        # Download media file
        media_content = self.download_media(media_id)

        # Upload to Studio Platform
        evidence_id = self.studio.upload_evidence(
            file_content=media_content,
            file_type=media_type,
            source="whatsapp",
            user_phone=from_number
        )

        # Send confirmation
        self.send_confirmation(from_number, evidence_id)

    def download_media(self, media_id):
        """Download media from WhatsApp"""
        url = f"https://graph.facebook.com/v18.0/{media_id}"
        headers = {"Authorization": f"Bearer {self.whatsapp.access_token}"}

        response = requests.get(url, headers=headers)
        media_data = response.json()

        # Download actual file
        file_response = requests.get(media_data['url'], headers=headers)
        return file_response.content

    def send_confirmation(self, phone_number, evidence_id):
        """Send upload confirmation"""
        message = {
            "messaging_product": "whatsapp",
            "to": phone_number,
            "type": "text",
            "text": {
                "body": f"✅ Evidence uploaded successfully! Evidence ID: {evidence_id}"
            }
        }

        self.whatsapp.send_message(message)

@app.route('/webhooks/whatsapp', methods=['POST'])
def handle_whatsapp_webhook():
    data = request.json

    # Handle different message types
    if data.get('object') == 'whatsapp_business_account':
        for entry in data.get('entry', []):
            for change in entry.get('changes', []):
                if change.get('field') == 'messages':
                    messages = change.get('value', {}).get('messages', [])
                    for message in messages:
                        process_message(message)

    return "OK", 200

def process_message(message):
    """Process incoming WhatsApp message"""
    message_type = message.get('type')
    from_number = message.get('from')

    if message_type == 'text':
        handle_text_message(message, from_number)
    elif message_type == 'image':
        handle_image_message(message, from_number)
    elif message_type == 'document':
        handle_document_message(message, from_number)
    elif message_type == 'interactive':
        handle_interactive_message(message, from_number)

def handle_interactive_message(message, from_number):
    """Handle interactive message responses"""
    interactive_response = message.get('interactive', {})
    button_reply = interactive_response.get('button_reply', {})

    button_id = button_reply.get('id')

    if button_id == 'upload_evidence':
        send_upload_instructions(from_number)
    elif button_id == 'mark_compliant':
        mark_compliance_status(from_number, True)
    elif button_id == 'mark_non_compliant':
        request_non_compliance_details(from_number)

def send_upload_instructions(phone_number):
    """Send instructions for evidence upload"""
    message = {
        "messaging_product": "whatsapp",
        "to": phone_number,
        "type": "text",
        "text": {
            "body": "📎 Please upload the evidence file directly to this chat. Supported formats: PDF, DOC, DOCX, JPG, PNG"
        }
    }

    whatsapp_client.send_message(message)

class WhatsAppComplianceWorkflow:
    def __init__(self, whatsapp_client, studio_api):
        self.whatsapp = whatsapp_client
        self.studio = studio_api

    def start_compliance_check(self, user_phone, compliance_area):
        """Start compliance verification via WhatsApp"""

        # Send initial check-in message
        check_in_message = {
            "messaging_product": "whatsapp",
            "to": user_phone,
            "type": "template",
            "template": {
                "name": "compliance_check_in",
                "language": {"code": "en"},
                "components": [
                    {
                        "type": "body",
                        "parameters": [
                            {"type": "text", "text": compliance_area}
                        ]
                    }
                ]
            }
        }

        self.whatsapp.send_message(check_in_message)

        # Schedule follow-up if no response
        self.schedule_follow_up(user_phone, compliance_area)

    def schedule_follow_up(self, phone_number, compliance_area):
        """Schedule follow-up message"""
        import threading
        import time

        def follow_up():
            time.sleep(3600)  # Wait 1 hour

            # Check if response received
            if not self.check_response_received(phone_number, compliance_area):
                self.send_reminder(phone_number, compliance_area)

        thread = threading.Thread(target=follow_up)
        thread.start()

class WhatsAppMediaProcessor:
    def __init__(self, whatsapp_client, studio_api):
        self.whatsapp = whatsapp_client
        self.studio = studio_api

    def process_uploaded_media(self, message_data):
        """Process uploaded media files"""
        media_id = message_data['media_id']
        media_type = message_data['media_type']
        from_number = message_data['from']

        # Download media
        media_content = self.download_media(media_id)

        # Process based on type
        if media_type == 'image':
            self.process_image(media_content, from_number)
        elif media_type == 'document':
            self.process_document(media_content, from_number)

    def process_image(self, image_content, from_number):
        """Process uploaded image"""
        # OCR processing if needed
        text_content = self.extract_text_from_image(image_content)

        # Upload to Studio Platform
        evidence_id = self.studio.upload_evidence(
            file_content=image_content,
            file_type='image',
            metadata={'extracted_text': text_content},
            source='whatsapp',
            user_phone=from_number
        )

        return evidence_id

    def process_document(self, document_content, from_number):
        """Process uploaded document"""
        # Extract metadata
        document_metadata = self.extract_document_metadata(document_content)

        # Upload to Studio Platform
        evidence_id = self.studio.upload_evidence(
            file_content=document_content,
            file_type='document',
            metadata=document_metadata,
            source='whatsapp',
            user_phone=from_number
        )

        return evidence_id