Odoo 19 Cash Flow Forecasting:
Real-Time Liquidity Planning for SMBs

from odoo import api, fields, models
from datetime import timedelta


class CashFlowForecast(models.TransientModel):
    _name = "cash.flow.forecast"
    _description = "Cash Flow Forecast Report"

    date_from = fields.Date(
        default=fields.Date.today,
    )
    date_to = fields.Date(
        default=lambda self: fields.Date.today()
        + timedelta(days=90),
    )
    journal_ids = fields.Many2many(
        "account.journal",
        string="Bank Journals",
        domain=[("type", "=", "bank")],
    )
    include_draft = fields.Boolean(
        string="Include Draft Invoices",
        default=False,
        help="Include unposted invoices in projections. "
             "Useful for sales pipeline visibility.",
    )

    @api.model
    def _get_opening_balance(self, journals, date):
        """Sum of all bank journal balances as of date."""
        balances = []
        for journal in journals:
            account = journal.default_account_id
            balance = self.env["account.move.line"].read_group(
                domain=[
                    ("account_id", "=", account.id),
                    ("date", "<=", date),
                    ("parent_state", "=", "posted"),
                ],
                fields=["balance:sum"],
                groupby=[],
            )
            balances.append(
                balance[0]["balance"] if balance else 0.0
            )
        return sum(balances)

    def _get_projected_inflows(self, date_from, date_to):
        """Receivables due in the forecast window."""
        domain = [
            ("move_id.move_type", "in",
             ["out_invoice", "out_refund"]),
            ("date_maturity", ">=", date_from),
            ("date_maturity", "<=", date_to),
            ("amount_residual", ">", 0),
        ]
        if not self.include_draft:
            domain.append(
                ("parent_state", "=", "posted")
            )
        return self.env["account.move.line"].search(domain)

    def _get_projected_outflows(self, date_from, date_to):
        """Payables due in the forecast window."""
        domain = [
            ("move_id.move_type", "in",
             ["in_invoice", "in_refund"]),
            ("date_maturity", ">=", date_from),
            ("date_maturity", "<=", date_to),
            ("amount_residual", ">", 0),
        ]
        if not self.include_draft:
            domain.append(
                ("parent_state", "=", "posted")
            )
        return self.env["account.move.line"].search(domain)

from odoo import api, fields, models
from datetime import timedelta
import logging

_logger = logging.getLogger(__name__)


class CashFlowAlert(models.Model):
    _name = "cash.flow.alert"
    _description = "Low Cash Alert Configuration"

    name = fields.Char(required=True)
    threshold = fields.Float(
        string="Minimum Cash Threshold",
        required=True,
        help="Alert when projected balance falls below.",
    )
    forecast_days = fields.Integer(
        default=30,
        help="How many days ahead to check.",
    )
    notify_user_ids = fields.Many2many(
        "res.users",
        string="Notify",
    )

    @api.model
    def _cron_check_cash_alerts(self):
        """Called daily by ir.cron scheduled action."""
        alerts = self.search([])
        for alert in alerts:
            forecast = self.env["cash.flow.forecast"].create(
                {{
                    "date_from": fields.Date.today(),
                    "date_to": (
                        fields.Date.today()
                        + timedelta(days=alert.forecast_days)
                    ),
                }}
            )
            # Check weekly buckets for threshold breach
            current = fields.Date.today()
            end = current + timedelta(days=alert.forecast_days)
            balance = forecast._get_opening_balance(
                forecast.journal_ids, current
            )

            while current <= end:
                week_end = current + timedelta(days=7)
                inflows = sum(
                    forecast._get_projected_inflows(
                        current, week_end
                    ).mapped("amount_residual")
                )
                outflows = sum(
                    forecast._get_projected_outflows(
                        current, week_end
                    ).mapped("amount_residual")
                )
                balance += inflows - outflows

                if balance < alert.threshold:
                    self._send_low_cash_notification(
                        alert, current, balance
                    )
                    break
                current = week_end

    def _send_low_cash_notification(
        self, alert, breach_date, projected_balance
    ):
        """Send Odoo Discuss notification to alert users."""
        msg = (
            f"⚠️ Cash flow alert: Projected balance "
            f"drops to {{projected_balance:,.2f}} by "
            f"{{breach_date}}, below your "
            f"{{alert.threshold:,.2f}} threshold."
        )
        for user in alert.notify_user_ids:
            user.partner_id.message_post(
                body=msg,
                message_type="notification",
                subtype_xmlid="mail.mt_note",
            )
        _logger.warning(
            "Low cash alert '%s': projected %s by %s",
            alert.name, projected_balance, breach_date,
        )