# Example Odoo model structure showing modular separation
class SaleOrder(models.Model):
    _name = 'sale.order'
    _inherit = ['mail.thread', 'mail.activity.mixin']
    
    # Sales-specific fields
    partner_id = fields.Many2one('res.partner', string='Customer')
    order_line = fields.One2many('sale.order.line', 'order_id')
    amount_total = fields.Monetary(string='Total', store=True)
    
    # Integration hooks
    def _prepare_invoice(self):
        """Prepare invoice values for accounting integration"""
        invoice_vals = super()._prepare_invoice()
        # Add Xero-specific mapping
        invoice_vals.update({
            'xero_contact_id': self.partner_id.xero_id,
            'xero_account_code': self.team_id.xero_account_code
        })
        return invoice_vals

# Odoo JSON-RPC API call example for invoice creation
import json
import requests

odoo_url = "https://your-instance.odoo.com/jsonrpc"
headers = {'Content-Type': 'application/json'}

# Create invoice from sale order
def create_odoo_invoice(sale_order_id):
    data = {
        "jsonrpc": "2.0",
        "method": "call",
        "params": {
            "service": "object",
            "method": "execute",
            "args": [
                "database_name",
                "user_id",
                "api_key",
                "account.move",
                "create",
                {
                    "move_type": "out_invoice",
                    "partner_id": customer_id,
                    "invoice_line_ids": invoice_lines
                }
            ]
        },
        "id": 1
    }
    response = requests.post(odoo_url, data=json.dumps(data), headers=headers)
    return response.json()

# Xero OAuth 2.0 token management
import requests
from datetime import datetime, timedelta

class XeroAuthManager:
    def __init__(self, client_id, client_secret, redirect_uri):
        self.client_id = client_id
        self.client_secret = client_secret
        self.redirect_uri = redirect_uri
        self.token_url = "https://identity.xero.com/connect/token"
        
    def refresh_access_token(self, refresh_token):
        """Refresh expired access token"""
        data = {
            'grant_type': 'refresh_token',
            'refresh_token': refresh_token,
            'client_id': self.client_id,
            'client_secret': self.client_secret
        }
        
        response = requests.post(self.token_url, data=data)
        if response.status_code == 200:
            token_data = response.json()
            # Store tokens with expiration
            return {
                'access_token': token_data['access_token'],
                'refresh_token': token_data['refresh_token'],
                'expires_at': datetime.now() + timedelta(seconds=token_data['expires_in'])
            }
        raise Exception(f"Token refresh failed: {response.text}")

# Event-driven synchronization handler
from odoo import api, models

class AccountMove(models.Model):
    _inherit = 'account.move'
    
    @api.model
    def create(self, vals):
        """Override create to trigger Xero sync"""
        invoice = super().create(vals)
        
        # Trigger async job for Xero sync
        if invoice.move_type in ('out_invoice', 'out_refund'):
            self.env['xero.sync.job'].create({
                'invoice_id': invoice.id,
                'operation': 'create',
                'status': 'pending'
            })
        return invoice
    
    def action_post(self):
        """Override post action for approved invoices"""
        result = super().action_post()
        
        # Sync approved invoices to Xero
        for invoice in self:
            if invoice.state == 'posted':
                self._schedule_xero_sync(invoice)
        return result

# Core synchronization service
class XeroSyncService:
    def __init__(self, odoo_env, xero_client):
        self.odoo = odoo_env
        self.xero = xero_client
        
    def sync_invoice_to_xero(self, odoo_invoice):
        """Map Odoo invoice to Xero format and create/update"""
        # Map Odoo customer to Xero contact
        xero_contact_id = self._get_or_create_xero_contact(odoo_invoice.partner_id)
        
        # Prepare invoice data
        invoice_data = {
            "Type": "ACCREC",
            "Contact": {"ContactID": xero_contact_id},
            "Date": odoo_invoice.invoice_date.isoformat(),
            "DueDate": odoo_invoice.invoice_date_due.isoformat(),
            "LineItems": []
        }
        
        # Map line items
        for line in odoo_invoice.invoice_line_ids:
            xero_account_code = self._map_account_code(line.account_id)
            invoice_data["LineItems"].append({
                "Description": line.name,
                "Quantity": line.quantity,
                "UnitAmount": line.price_unit,
                "AccountCode": xero_account_code,
                "TaxType": self._map_tax_type(line.tax_ids)
            })
        
        # Create or update in Xero
        if odoo_invoice.xero_invoice_id:
            invoice_data["InvoiceID"] = odoo_invoice.xero_invoice_id
            return self.xero.invoices.update(invoice_data)
        else:
            result = self.xero.invoices.create(invoice_data)
            # Store Xero ID in Odoo
            odoo_invoice.write({'xero_invoice_id': result['InvoiceID']})
            return result

# Robust error handling with retry logic
import tenacity
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10),
    retry=retry_if_exception_type((requests.exceptions.Timeout, 
                                   requests.exceptions.ConnectionError))
)
def sync_with_retry(sync_method, *args, **kwargs):
    """Execute sync with automatic retry on transient errors"""
    try:
        return sync_method(*args, **kwargs)
    except XeroRateLimitException as e:
        # Handle rate limiting
        time.sleep(e.retry_after)
        raise
    except XeroValidationException as e:
        # Log validation errors for manual review
        logger.error(f"Validation error: {e.errors}")
        raise

# Simplified deployment architecture
architecture:
  odoo_cluster:
    nodes: 3
    load_balancer: haproxy
    database: postgresql_cluster
    filestore: s3_compatible
    
  integration_layer:
    message_queue: rabbitmq_cluster
    cache: redis_cluster
    job_workers: 5
    
  monitoring:
    metrics: prometheus
    logging: elk_stack
    alerting: alertmanager

# Multi-company synchronization logic
class MultiCompanySyncHandler:
    def sync_all_companies(self):
        """Sync data for all configured companies"""
        companies = self.env['res.company'].search([])
        
        for company in companies:
            # Switch to company context
            with self.env.cr.savepoint():
                self.env.company = company
                
                # Get company-specific Xero credentials
                xero_config = company.xero_config_id
                
                # Sync company data
                self._sync_company_invoices(company, xero_config)
                self._sync_company_payments(company, xero_config)
                
                # Log sync completion
                self._log_sync_result(company, 'completed')

# Comprehensive monitoring setup
class IntegrationMonitor:
    def __init__(self):
        self.metrics = {
            'sync_success_rate': Gauge('xero_sync_success_rate', 'Sync success rate'),
            'sync_duration': Histogram('xero_sync_duration', 'Sync duration distribution'),
            'api_errors': Counter('xero_api_errors', 'API error count')
        }
    
    def record_sync_attempt(self, success, duration, entity_type):
        """Record sync attempt metrics"""
        self.metrics['sync_success_rate'].set(1 if success else 0)
        self.metrics['sync_duration'].observe(duration)
        
        if not success:
            self.metrics['api_errors'].inc()
            
        # Log detailed context
        logger.info(f"Sync {entity_type}: success={success}, duration={duration}s")