Automation Services

# WhatsApp Bot Implementation
from flask import Flask, request
import requests
import json

app = Flask(__name__)

class WhatsAppBot:
    def __init__(self, access_token, phone_number_id):
        self.access_token = access_token
        self.phone_number_id = phone_number_id
        self.base_url = "https://graph.facebook.com/v17.0"
    
    def send_message(self, to, message):
        url = f"{self.base_url}/{self.phone_number_id}/messages"
        headers = {
            "Authorization": f"Bearer {self.access_token}",
            "Content-Type": "application/json"
        }
        
        data = {
            "messaging_product": "whatsapp",
            "to": to,
            "text": {"body": message}
        }
        
        response = requests.post(url, headers=headers, json=data)
        return response.json()
    
    def process_message(self, message_data):
        # Extract message content
        message = message_data.get('text', {}).get('body', '')
        sender = message_data.get('from')
        
        # Simple intent recognition
        if 'hello' in message.lower():
            response = "Hello! How can I help you today?"
        elif 'price' in message.lower():
            response = "Our pricing starts at $99/month. Would you like more details?"
        elif 'support' in message.lower():
            response = "I'll connect you with our support team. Please wait a moment."
        else:
            response = "Thank you for your message. Our team will get back to you soon."
        
        return self.send_message(sender, response)

@app.route('/webhook', methods=['POST'])
def webhook():
    data = request.get_json()
    
    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:
                        bot.process_message(message)
    
    return 'OK', 200

# RPA Workflow Automation
import pandas as pd
from selenium import webdriver
from selenium.webdriver.common.by import By
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import schedule
import time

class RPAWorkflow:
    def __init__(self):
        self.driver = None
        self.setup_driver()
    
    def setup_driver(self):
        options = webdriver.ChromeOptions()
        options.add_argument('--headless')
        self.driver = webdriver.Chrome(options=options)
    
    def extract_data_from_website(self, url, selector):
        self.driver.get(url)
        elements = self.driver.find_elements(By.CSS_SELECTOR, selector)
        data = [element.text for element in elements]
        return data
    
    def process_excel_data(self, file_path):
        df = pd.read_excel(file_path)
        
        # Data processing logic
        df['processed_date'] = pd.Timestamp.now()
        df['status'] = df.apply(self._determine_status, axis=1)
        
        # Save processed data
        output_path = f"processed_{file_path}"
        df.to_excel(output_path, index=False)
        return output_path
    
    def send_automated_email(self, to_email, subject, body, attachment=None):
        smtp_server = "smtp.gmail.com"
        smtp_port = 587
        
        msg = MIMEMultipart()
        msg['From'] = "automation@company.com"
        msg['To'] = to_email
        msg['Subject'] = subject
        
        msg.attach(MIMEText(body, 'plain'))
        
        if attachment:
            with open(attachment, "rb") as f:
                attach = MIMEText(f.read(), 'base64', 'utf-8')
                attach.add_header('Content-Disposition', f'attachment; filename={attachment}')
                msg.attach(attach)
        
        server = smtplib.SMTP(smtp_server, smtp_port)
        server.starttls()
        server.login("automation@company.com", "password")
        server.send_message(msg)
        server.quit()
    
    def daily_report_automation(self):
        # Extract data from multiple sources
        web_data = self.extract_data_from_website("https://dashboard.company.com", ".metric-value")
        
        # Process Excel reports
        processed_file = self.process_excel_data("daily_data.xlsx")
        
        # Generate summary report
        report = f"""
        Daily Automation Report
        ======================
        Date: {pd.Timestamp.now().strftime('%Y-%m-%d')}
        
        Web Metrics: {len(web_data)} items processed
        Excel Data: {processed_file} generated
        
        Status: Completed Successfully
        """
        
        # Send email notification
        self.send_automated_email(
            "manager@company.com",
            "Daily Automation Report",
            report,
            processed_file
        )

# Schedule automation
rpa = RPAWorkflow()
schedule.every().day.at("09:00").do(rpa.daily_report_automation)

while True:
    schedule.run_pending()
    time.sleep(60)

# Legal Data Crawler
import scrapy
import requests
from bs4 import BeautifulSoup
import re
from datetime import datetime
import json

class LegalCrawler:
    def __init__(self):
        self.session = requests.Session()
        self.base_urls = {
            'court_records': 'https://courtrecords.gov',
            'regulations': 'https://regulations.gov',
            'case_law': 'https://caselaw.findlaw.com'
        }
    
    def crawl_court_records(self, case_number):
        url = f"{self.base_urls['court_records']}/search"
        params = {'case_number': case_number}
        
        response = self.session.get(url, params=params)
        soup = BeautifulSoup(response.content, 'html.parser')
        
        case_data = {
            'case_number': case_number,
            'title': soup.find('h1', class_='case-title').text.strip(),
            'date_filed': soup.find('span', class_='date-filed').text.strip(),
            'status': soup.find('span', class_='case-status').text.strip(),
            'parties': self._extract_parties(soup),
            'documents': self._extract_documents(soup),
            'crawled_at': datetime.now().isoformat()
        }
        
        return case_data
    
    def monitor_regulatory_changes(self, keywords):
        url = f"{self.base_urls['regulations']}/api/documents"
        params = {
            'filter[searchTerm]': ' '.join(keywords),
            'filter[postedDate][gte]': datetime.now().strftime('%Y-%m-%d'),
            'sort': '-postedDate'
        }
        
        response = self.session.get(url, params=params)
        data = response.json()
        
        new_regulations = []
        for document in data.get('data', []):
            regulation = {
                'title': document['attributes']['title'],
                'agency': document['attributes']['agencyId'],
                'posted_date': document['attributes']['postedDate'],
                'summary': document['attributes']['summary'],
                'document_id': document['id'],
                'url': f"https://regulations.gov/document/{document['id']}"
            }
            new_regulations.append(regulation)
        
        return new_regulations
    
    def extract_case_citations(self, text):
        # Pattern for legal citations (simplified)
        citation_patterns = [
            r'\d+\s+[A-Z][a-z\.]+\s+\d+',  # Volume Reporter Page
            r'\d+\s+U\.S\.\s+\d+',        # Supreme Court
            r'\d+\s+F\.\d+d\s+\d+'        # Federal Reporter
        ]
        
        citations = []
        for pattern in citation_patterns:
            matches = re.findall(pattern, text)
            citations.extend(matches)
        
        return list(set(citations))  # Remove duplicates
    
    def analyze_legal_document(self, document_text):
        analysis = {
            'word_count': len(document_text.split()),
            'citations': self.extract_case_citations(document_text),
            'key_terms': self._extract_legal_terms(document_text),
            'sentiment': self._analyze_sentiment(document_text),
            'complexity_score': self._calculate_complexity(document_text)
        }
        
        return analysis
    
    def generate_compliance_report(self, company_name, regulations):
        report = {
            'company': company_name,
            'report_date': datetime.now().isoformat(),
            'regulations_checked': len(regulations),
            'compliance_status': [],
            'recommendations': []
        }
        
        for regulation in regulations:
            compliance_check = self._check_compliance(company_name, regulation)
            report['compliance_status'].append(compliance_check)
            
            if not compliance_check['compliant']:
                report['recommendations'].append({
                    'regulation': regulation['title'],
                    'action_required': compliance_check['action_required'],
                    'deadline': compliance_check.get('deadline'),
                    'priority': compliance_check.get('priority', 'Medium')
                })
        
        return report

# System Integration Framework
import asyncio
import aiohttp
import json
from datetime import datetime
import logging

class SystemIntegrator:
    def __init__(self):
        self.integrations = {}
        self.logger = logging.getLogger(__name__)
    
    async def register_system(self, system_name, config):
        self.integrations[system_name] = {
            'config': config,
            'last_sync': None,
            'status': 'active'
        }
    
    async def sync_data(self, source_system, target_system, data_mapping):
        try:
            # Extract data from source
            source_data = await self._extract_data(source_system)
            
            # Transform data according to mapping
            transformed_data = self._transform_data(source_data, data_mapping)
            
            # Load data to target system
            result = await self._load_data(target_system, transformed_data)
            
            # Update sync status
            self.integrations[source_system]['last_sync'] = datetime.now()
            
            return {
                'status': 'success',
                'records_processed': len(transformed_data),
                'timestamp': datetime.now().isoformat()
            }
            
        except Exception as e:
            self.logger.error(f"Sync failed: {str(e)}")
            return {'status': 'error', 'message': str(e)}
    
    async def _extract_data(self, system_name):
        config = self.integrations[system_name]['config']
        
        if config['type'] == 'rest_api':
            async with aiohttp.ClientSession() as session:
                headers = {'Authorization': f"Bearer {config['api_key']}"}
                async with session.get(config['endpoint'], headers=headers) as response:
                    return await response.json()
        
        elif config['type'] == 'database':
            # Database extraction logic
            import asyncpg
            conn = await asyncpg.connect(config['connection_string'])
            rows = await conn.fetch(config['query'])
            await conn.close()
            return [dict(row) for row in rows]
    
    def _transform_data(self, data, mapping):
        transformed = []
        
        for record in data:
            new_record = {}
            for source_field, target_field in mapping.items():
                if source_field in record:
                    value = record[source_field]
                    
                    # Apply transformations
                    if isinstance(target_field, dict):
                        if 'transform' in target_field:
                            value = self._apply_transformation(value, target_field['transform'])
                        new_record[target_field['field']] = value
                    else:
                        new_record[target_field] = value
            
            transformed.append(new_record)
        
        return transformed
    
    async def _load_data(self, system_name, data):
        config = self.integrations[system_name]['config']
        
        if config['type'] == 'rest_api':
            async with aiohttp.ClientSession() as session:
                headers = {
                    'Authorization': f"Bearer {config['api_key']}",
                    'Content-Type': 'application/json'
                }
                
                results = []
                for record in data:
                    async with session.post(config['endpoint'], 
                                          headers=headers, 
                                          json=record) as response:
                        results.append(await response.json())
                
                return results
    
    async def real_time_sync(self, source_system, target_system, mapping):
        # Set up real-time synchronization using webhooks or polling
        while True:
            try:
                result = await self.sync_data(source_system, target_system, mapping)
                self.logger.info(f"Sync completed: {result}")
                
                # Wait before next sync (configurable interval)
                await asyncio.sleep(300)  # 5 minutes
                
            except Exception as e:
                self.logger.error(f"Real-time sync error: {str(e)}")
                await asyncio.sleep(60)  # Wait 1 minute before retry

# Usage example
async def main():
    integrator = SystemIntegrator()
    
    # Register systems
    await integrator.register_system('crm', {
        'type': 'rest_api',
        'endpoint': 'https://api.crm.com/contacts',
        'api_key': 'your_api_key'
    })
    
    await integrator.register_system('email_marketing', {
        'type': 'rest_api',
        'endpoint': 'https://api.emailservice.com/subscribers',
        'api_key': 'your_email_api_key'
    })
    
    # Define data mapping
    mapping = {
        'email': 'email_address',
        'first_name': 'first_name',
        'last_name': 'last_name',
        'created_at': {'field': 'signup_date', 'transform': 'date_format'}
    }
    
    # Start real-time sync
    await integrator.real_time_sync('crm', 'email_marketing', mapping)