# Creating a Mollie customer for recurring payments
customer_data = {
    'name': partner.name,
    'email': partner.email,
    'locale': partner.lang or 'en_US',
    'metadata': {
        'odoo_partner_id': partner.id,
        'company_id': company.id
    }
}

response = mollie_client.customers.create(customer_data)
# Store customer_id in Odoo partner record
partner.mollie_customer_id = response['id']

import hashlib
import hmac

def verify_webhook_signature(request_body, mollie_signature, webhook_key):
    """Verify Mollie webhook signature"""
    calculated_signature = hmac.new(
        webhook_key.encode('utf-8'),
        request_body.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    
    return hmac.compare_digest(calculated_signature, mollie_signature)

import uuid

def create_idempotency_key(invoice_id, attempt=0):
    """Generate unique idempotency key for Mollie API"""
    return f"odoo-invoice-{invoice_id}-attempt-{attempt}-{uuid.uuid4()}"

from odoo import http
import json

class MollieWebhookController(http.Controller):
    @http.route('/mollie/webhook', type='json', auth='public', csrf=False)
    def mollie_webhook(self, **kwargs):
        """Main webhook endpoint for Mollie notifications"""
        # 1. Verify webhook signature
        if not self._verify_signature(http.request):
            return {'status': 'error', 'message': 'Invalid signature'}
        
        # 2. Parse and validate webhook data
        webhook_data = json.loads(http.request.httprequest.data)
        payment_id = webhook_data.get('id')
        
        # 3. Process based on payment status
        status = webhook_data.get('status')
        if status == 'paid':
            self._process_paid_payment(payment_id, webhook_data)
        elif status == 'failed':
            self._process_failed_payment(payment_id, webhook_data)
        elif status == 'canceled':
            self._process_canceled_payment(payment_id, webhook_data)
        
        return {'status': 'processed'}

class MolliePaymentMethod(models.Model):
    _name = 'mollie.payment.method'
    _description = 'Mollie Payment Method'
    
    partner_id = fields.Many2one('res.partner', required=True)
    mollie_customer_id = fields.Char('Mollie Customer ID')
    payment_method_id = fields.Char('Mollie Payment Method ID')
    method_type = fields.Selection([
        ('creditcard', 'Credit Card'),
        ('directdebit', 'Direct Debit'),
        ('paypal', 'PayPal')
    ])
    is_default = fields.Boolean('Default Payment Method')
    expiry_date = fields.Date('Expiry Date')
    last_used = fields.Datetime('Last Used')
    
    # Security: Never store full card numbers
    # Only store Mollie's tokenized references

class MollieSubscription(models.Model):
    _name = 'mollie.subscription'
    _description = 'Mollie Subscription'
    
    name = fields.Char('Subscription Reference')
    partner_id = fields.Many2one('res.partner', required=True)
    product_id = fields.Many2one('product.product', required=True)
    interval = fields.Selection([
        ('1 month', 'Monthly'),
        ('3 months', 'Quarterly'),
        ('12 months', 'Annual')
    ], default='1 month')
    amount = fields.Monetary('Amount', currency_field='currency_id')
    currency_id = fields.Many2one('res.currency', required=True)
    start_date = fields.Date('Start Date')
    next_payment_date = fields.Date('Next Payment Date')
    status = fields.Selection([
        ('active', 'Active'),
        ('suspended', 'Suspended'),
        ('canceled', 'Canceled'),
        ('completed', 'Completed')
    ], default='active')
    
    # Integration with Odoo Sales
    sale_order_ids = fields.One2many('sale.order', 'subscription_id')
    invoice_ids = fields.One2many('account.move', 'subscription_id')
    
    def _create_next_payment(self):
        """Create next payment in subscription cycle"""
        # 1. Create sales order
        sale_order = self.env['sale.order'].create({
            'partner_id': self.partner_id.id,
            'subscription_id': self.id,
            'order_line': [(0, 0, {
                'product_id': self.product_id.id,
                'product_uom_qty': 1,
                'price_unit': self.amount
            })]
        })
        
        # 2. Confirm order and create invoice
        sale_order.action_confirm()
        invoice = sale_order._create_invoices()
        
        # 3. Process payment through Mollie
        payment_result = self._process_mollie_payment(invoice)
        
        # 4. Update subscription dates
        self.next_payment_date = self._calculate_next_date()
        
        return invoice

# Extend sale.order model to support subscriptions
class SaleOrder(models.Model):
    _inherit = 'sale.order'
    
    subscription_id = fields.Many2one('mollie.subscription', 'Subscription')
    is_recurring = fields.Boolean('Recurring Order', compute='_compute_is_recurring')
    
    def _compute_is_recurring(self):
        for order in self:
            order.is_recurring = bool(order.subscription_id)

# Extend account.move for subscription invoices
class AccountMove(models.Model):
    _inherit = 'account.move'
    
    subscription_id = fields.Many2one('mollie.subscription', 'Subscription')
    mollie_payment_id = fields.Char('Mollie Payment ID')
    
    def action_post(self):
        """Override to handle subscription invoice posting"""
        res = super().action_post()
        
        # If this is a subscription invoice, trigger payment
        if self.subscription_id and self.move_type == 'out_invoice':
            self.subscription_id._process_payment(self)
        
        return res

# Batch processing for subscription renewals
class SubscriptionBatchProcessor(models.Model):
    _name = 'subscription.batch.processor'
    
    def process_due_subscriptions(self, batch_size=100):
        """Process subscriptions due for renewal in batches"""
        due_date = fields.Date.today()
        
        # Find subscriptions due for renewal
        due_subscriptions = self.env['mollie.subscription'].search([
            ('next_payment_date', '<=', due_date),
            ('status', '=', 'active')
        ], limit=batch_size)
        
        # Process in parallel using Odoo's queue jobs
        for subscription in due_subscriptions:
            subscription.with_delay()._create_next_payment()
        
        return len(due_subscriptions)

# Install the module
odoo-bin -c odoo.conf -i mollie_recurring

# Configure Mollie API credentials
# Settings → Mollie → Configuration