Speeding Up PDF Report Generation in Odoo: Complete Optimization Guide

from odoo import models, api
from odoo.tools import ormcache
import hashlib

class AccountMove(models.Model):
    _inherit = 'account.move'
    
    pdf_cache = {}  # In-memory cache
    
    def get_pdf(self):
        """Get or generate PDF (cached)."""
        # Create cache key from invoice data
        cache_key = self._get_pdf_cache_key()
        
        # Check cache
        if cache_key in self.pdf_cache:
            return self.pdf_cache[cache_key]
        
        # Generate PDF
        pdf_data = self._generate_pdf()
        
        # Store in cache
        self.pdf_cache[cache_key] = pdf_data
        return pdf_data
    
    def _get_pdf_cache_key(self):
        """Generate cache key from invoice state."""
        # Cache only if invoice is finalized (won't change)
        if self.state not in ['posted', 'cancel']:
            return None
        
        # Key = invoice ID + state + amount
        key_data = f"{self.id}_{self.state}_{self.amount_total}"
        return hashlib.md5(key_data.encode()).hexdigest()
    
    def _generate_pdf(self):
        """Generate PDF from QWeb template."""
        report = self.env.ref('account.report_invoice')
        return report.render_qweb_pdf(self.ids)[0]
    
    def invalidate_pdf_cache(self):
        """Clear cache when invoice changes."""
        cache_key = self._get_pdf_cache_key()
        if cache_key in self.pdf_cache:
            del self.pdf_cache[cache_key]

from odoo.tools import ormcache
import redis
import pickle

class AccountMove(models.Model):
    _inherit = 'account.move'
    
    @ormcache('self.id')
    def get_pdf_cached(self):
        """Get PDF with Redis caching."""
        # Connect to Redis
        r = redis.Redis(host='localhost', port=6379, db=0)
        cache_key = f"invoice_pdf_{self.id}"
        
        # Try cache
        cached = r.get(cache_key)
        if cached:
            return pickle.loads(cached)
        
        # Generate
        pdf_data = self._generate_pdf()
        
        # Store in Redis (expire after 1 hour)
        r.setex(cache_key, 3600, pickle.dumps(pdf_data))
        return pdf_data

pip install odoo-bin-addons-queue-job

from odoo_bin_addons import queue_job
from odoo import models, api

class AccountMove(models.Model):
    _inherit = 'account.move'
    
    def action_print_async(self):
        """Print PDF asynchronously."""
        # Enqueue job
        self.with_delay(priority=10).generate_pdf_job()
        
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': 'PDF Generation',
                'message': 'Invoice PDF is being generated. You will receive email when ready.',
                'sticky': False,
            }
        }
    
    @job
    def generate_pdf_job(self):
        """Generate PDF in background."""
        # Generate PDF
        report = self.env.ref('account.report_invoice')
        pdf_data, _ = report.render_qweb_pdf(self.ids)
        
        # Save to attachment
        attachment = self.env['ir.attachment'].create({
            'name': f'{self.name}.pdf',
            'type': 'binary',
            'datas': base64.b64encode(pdf_data),
            'res_model': self._name,
            'res_id': self.id,
        })
        
        # Send email with PDF
        template = self.env.ref('account.email_template_invoice')
        template.send_mail(
            self.id,
            email_values={'attachment_ids': [attachment.id]},
            force_send=True
        )
        self.message_post(body="Invoice PDF generated and sent")

def action_generate_batch_pdfs(self):
    """Generate PDFs for multiple invoices."""
    invoices = self.env['account.move'].search([
        ('state', '=', 'posted'),
        ('invoice_date', '=', fields.Date.today()),
    ])
    
    # Enqueue batch job
    batch_size = 50
    for i in range(0, len(invoices), batch_size):
        batch = invoices[i:i+batch_size]
        self.with_delay(priority=5).generate_batch_pdfs_job(batch.ids)
    
    return "Enqueued %d PDF generations" % len(invoices)

@job
def generate_batch_pdfs_job(self, invoice_ids):
    """Generate PDFs for batch of invoices."""
    invoices = self.env['account.move'].browse(invoice_ids)
    report = self.env.ref('account.report_invoice')
    
    # Generate all at once (more efficient)
    pdf_data, _ = report.render_qweb_pdf(invoices.ids)
    
    # For each invoice, extract and attach
    # (implementation depends on report structure)

from odoo import models, fields, api
from odoo_bin_addons import queue_job
import base64

class SaleOrder(models.Model):
    _inherit = 'sale.order'
    
    # Track invoice generation status
    invoice_pdf_status = fields.Selection([
        ('pending', 'Pending'),
        ('generating', 'Generating'),
        ('ready', 'Ready'),
        ('sent', 'Sent'),
    ], default='pending')
    
    invoice_pdf = fields.Binary(
        string='Invoice PDF',
        attachment=True
    )
    
    def action_confirm(self):
        """Confirm order and generate invoice async."""
        result = super().action_confirm()
        
        # Create invoice
        self._create_invoices()
        
        # Generate PDF asynchronously
        invoice = self.invoice_ids[0]
        invoice.with_delay(priority=10).generate_invoice_pdf_async()
        
        return result
    
    def action_generate_all_daily_invoices(self):
        """Batch generate all invoices for today."""
        orders = self.search([
            ('order_date', '=', fields.Date.today()),
            ('state', '=', 'sale'),
            ('invoice_ids', '!=', False),
        ])
        
        invoices = orders.mapped('invoice_ids')
        
        # Enqueue batch job
        batch_size = 50
        total = len(invoices)
        for i in range(0, total, batch_size):
            batch = invoices[i:i+batch_size]
            self.env['account.move'].with_delay(
                priority=5
            ).generate_batch_invoices_async(batch.ids)
        
        return {
            'type': 'ir.actions.client',
            'tag': 'display_notification',
            'params': {
                'title': 'Batch PDF Generation',
                'message': f'Enqueued {total} invoices for PDF generation. You will be notified when complete.',
                'sticky': False,
            }
        }

class AccountMove(models.Model):
    _inherit = 'account.move'
    
    pdf_status = fields.Selection([
        ('pending', 'Pending'),
        ('generating', 'Generating'),
        ('ready', 'Ready'),
    ], default='pending')
    
    @job(default_channel='root.invoice_pdf')
    def generate_invoice_pdf_async(self):
        """Generate PDF in background."""
        self.pdf_status = 'generating'
        
        # Generate PDF with caching
        pdf_data = self.get_pdf_cached()
        
        # Save as attachment
        attachment = self.env['ir.attachment'].create({
            'name': f'{self.name}_invoice.pdf',
            'type': 'binary',
            'datas': base64.b64encode(pdf_data),
            'res_model': 'account.move',
            'res_id': self.id,
        })
        
        # Update status
        self.pdf_status = 'ready'
        
        # Send email
        self._send_invoice_email(attachment.id)
    
    @job(default_channel='root.batch_pdf')
    def generate_batch_invoices_async(self, invoice_ids):
        """Generate batch of invoices."""
        invoices = self.env['account.move'].browse(invoice_ids)
        
        for invoice in invoices:
            invoice.generate_invoice_pdf_async()
        
        return f"Generated {len(invoices)} PDFs"

<t t-foreach="order.order_line" t-as="line">
    <!-- Complex calculations in template -->
    <tr>
        <td>
            <!-- Load product info (causes queries!) -->
            <span t-field="line.product_id.name"/>
            <span t-field="line.product_id.categ_id.name"/>
            <!-- Format price (expensive) -->
            <span t-esc="'{:,.2f}'.format(line.price_total)"/>
        </td>
    </tr>
</t>

<t t-foreach="lines_data" t-as="line">
    <!-- Pre-calculated data -->
    <tr>
        <td t-esc="line['product_name']"/>
        <td t-esc="line['category_name']"/>
        <td t-esc="line['price_formatted']"/>
    </tr>
</t>

def get_pdf_with_precalc(self):
    """Generate PDF with pre-calculated data."""
    # Pre-calculate complex data
    lines_data = []
    for line in self.order_line:
        lines_data.append({
            'product_name': line.product_id.name,
            'category_name': line.product_id.categ_id.name,
            'price_formatted': '{:,.2f}'.format(line.price_total),
            'qty': line.product_qty,
        })
    
    # Pass pre-calculated data to template
    report = self.env.ref('sale.report_order')
    
    # Custom context with pre-calculated data
    pdf_data = report.render_qweb_pdf(self.ids,
        data={'lines_data': lines_data}
    )[0]
    
    return pdf_data