Custom Dashboards in Odoo 19:
Real-Time KPI Views with OWL & Spreadsheets

<odoo>
  <record id="sale_order_dashboard_view" model="ir.ui.view">
    <field name="name">sale.order.dashboard</field>
    <field name="model">sale.order</field>
    <field name="arch" type="xml">
      <dashboard>
        <group>
          <aggregate
            name="total_revenue"
            field="amount_total"
            string="Total Revenue"
            group_operator="sum"
            measure="amount_total"
          />
          <aggregate
            name="order_count"
            field="id"
            string="Orders"
            group_operator="count"
          />
          <aggregate
            name="avg_order_value"
            field="amount_total"
            string="Avg Order Value"
            group_operator="avg"
          />
          <aggregate
            name="untaxed_total"
            field="amount_untaxed"
            string="Untaxed Total"
            group_operator="sum"
            domain="[('state', 'in', ['sale', 'done'])]"
          />
        </group>

        <!-- Sub-view: pivot table below the KPIs -->
        <view type="pivot" ref="sale.view_sale_order_pivot"/>

        <!-- Optional: graph view as alternative -->
        <view type="graph" ref="sale.view_sale_order_graph"/>
      </dashboard>
    </field>
  </record>

  <!-- Menu action using the dashboard view -->
  <record id="action_sale_dashboard" model="ir.actions.act_window">
    <field name="name">Sales Dashboard</field>
    <field name="res_model">sale.order</field>
    <field name="view_mode">dashboard,pivot,graph,list</field>
  </record>

  <menuitem
    id="menu_sale_dashboard"
    name="Sales Dashboard"
    parent="sale.sale_menu_root"
    action="action_sale_dashboard"
    sequence="1"
  />
</odoo>

/** @odoo-module **/

import { Component, useState, onWillStart, onMounted } from "@odoo/owl";
import { registry } from "@web/core/registry";
import { useService } from "@web/core/utils/hooks";
import { _t } from "@web/core/l10n/translation";

class KpiDashboard extends Component {
    static template = "my_dashboard.KpiDashboard";
    static props = { "*": true };

    setup() {
        this.orm = useService("orm");
        this.action = useService("action");
        this.state = useState({
            kpis: {},
            topProducts: [],
            revenueByMonth: [],
            isLoading: true,
            lastRefresh: null,
        });

        onWillStart(async () => {
            await this.loadDashboardData();
        });

        onMounted(() => {
            // Auto-refresh every 60 seconds
            this.refreshInterval = setInterval(
                () => this.loadDashboardData(),
                60000
            );
        });
    }

    async loadDashboardData() {
        this.state.isLoading = true;
        try {
            // Single RPC call to a dedicated controller method
            const data = await this.orm.call(
                "sale.order",
                "get_dashboard_data",
                [],
                {}
            );
            this.state.kpis = data.kpis;
            this.state.topProducts = data.top_products;
            this.state.revenueByMonth = data.revenue_by_month;
            this.state.lastRefresh = luxon.DateTime.now()
                .toLocaleString(luxon.DateTime.TIME_24_SIMPLE);
        } catch (error) {
            console.error("Dashboard data fetch failed:", error);
        }
        this.state.isLoading = false;
    }

    onKpiCardClick(action_xmlid) {
        // Navigate to a specific Odoo view when a KPI card is clicked
        this.action.doAction(action_xmlid);
    }

    onRefreshClick() {
        this.loadDashboardData();
    }

    destroy() {
        if (this.refreshInterval) {
            clearInterval(this.refreshInterval);
        }
        super.destroy(...arguments);
    }
}

// Register as a client action
registry.category("actions").add("my_dashboard.kpi_dashboard", KpiDashboard);

from odoo import models, fields, api
from datetime import date, timedelta
from dateutil.relativedelta import relativedelta


class SaleOrder(models.Model):
    _inherit = "sale.order"

    @api.model
    def get_dashboard_data(self):
        """Return all KPI data for the operations dashboard.

        Returns a single dict consumed by the OWL KpiDashboard component.
        All aggregation happens server-side to minimize RPC round-trips.
        """
        today = date.today()
        first_of_month = today.replace(day=1)
        last_month_start = first_of_month - relativedelta(months=1)
        last_month_end = first_of_month - timedelta(days=1)

        # ── Current month revenue ─────────────────────────
        current_revenue = self._get_revenue_sum(
            first_of_month, today
        )
        last_month_revenue = self._get_revenue_sum(
            last_month_start, last_month_end
        )
        revenue_trend = (
            round(
                (current_revenue - last_month_revenue)
                / (last_month_revenue or 1) * 100, 1
            )
        )

        # ── Open orders count ─────────────────────────────
        open_orders = self.search_count([
            ("state", "=", "sale"),
            ("invoice_status", "!=", "invoiced"),
        ])

        # ── Average fulfillment time (last 90 days) ──────
        fulfilled = self.search([
            ("state", "=", "done"),
            ("date_order", ">=", today - timedelta(days=90)),
        ])
        if fulfilled:
            deltas = [
                (rec.commitment_date or rec.date_order).date()
                - rec.date_order.date()
                for rec in fulfilled
                if rec.date_order
            ]
            avg_days = round(
                sum(d.days for d in deltas) / len(deltas), 1
            ) if deltas else 0
        else:
            avg_days = 0

        # ── Overdue invoices ──────────────────────────────
        overdue_invoices = self.env["account.move"].search_count([
            ("move_type", "=", "out_invoice"),
            ("payment_state", "!=", "paid"),
            ("invoice_date_due", "<", today),
        ])

        # ── Revenue by month (last 6 months) ─────────────
        six_months_ago = first_of_month - relativedelta(months=5)
        revenue_groups = self.read_group(
            domain=[
                ("state", "in", ["sale", "done"]),
                ("date_order", ">=", six_months_ago),
            ],
            fields=["amount_total:sum"],
            groupby=["date_order:month"],
            orderby="date_order:month asc",
        )
        revenue_by_month = [
            {
                "month": group["date_order:month"],
                "total": group["amount_total"],
            }
            for group in revenue_groups
        ]

        # ── Top 10 products by revenue ────────────────────
        top_products = self.env["sale.order.line"].read_group(
            domain=[
                ("order_id.state", "in", ["sale", "done"]),
                ("order_id.date_order", ">=", six_months_ago),
            ],
            fields=[
                "product_id",
                "product_uom_qty:sum",
                "price_subtotal:sum",
            ],
            groupby=["product_id"],
            orderby="price_subtotal desc",
            limit=10,
        )
        top_products_data = [
            {
                "id": p["product_id"][0],
                "name": p["product_id"][1],
                "qty_sold": p["product_uom_qty"],
                "revenue": round(p["price_subtotal"], 2),
            }
            for p in top_products
        ]

        return {
            "kpis": {
                "total_revenue": round(current_revenue, 2),
                "revenue_trend": revenue_trend,
                "open_orders": open_orders,
                "avg_fulfillment_days": avg_days,
                "overdue_invoices": overdue_invoices,
            },
            "revenue_by_month": revenue_by_month,
            "top_products": top_products_data,
        }

    def _get_revenue_sum(self, date_from, date_to):
        """Sum confirmed sale order revenue in a date range."""
        result = self.read_group(
            domain=[
                ("state", "in", ["sale", "done"]),
                ("date_order", ">=", date_from),
                ("date_order", "<=", date_to),
            ],
            fields=["amount_total:sum"],
            groupby=[],
        )
        return result[0]["amount_total"] if result else 0