Odoo-Modules/fusion_plating/fusion_plating_invoicing/models/sale_order.py

# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
# Part of the Fusion Plating product family.

import logging

from odoo import api, fields, models, _
from odoo.exceptions import UserError

_logger = logging.getLogger(__name__)


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

    @api.onchange('partner_id')
    def _onchange_partner_id_invoice_strategy(self):
        """Auto-fill invoice strategy from customer defaults."""
        if self.partner_id:
            default = self.env['fp.invoice.strategy.default'].search(
                [('partner_id', '=', self.partner_id.id)], limit=1,
            )
            if default:
                self.x_fc_invoice_strategy = default.default_strategy
                self.x_fc_deposit_percent = default.default_deposit_percent
                if default.payment_term_id:
                    self.payment_term_id = default.payment_term_id

    def action_confirm(self):
        """Override to check account hold and trigger invoice strategy."""
        for order in self:
            # --- Account hold check ---
            if order.partner_id.x_fc_account_hold:
                is_manager = self.env.user.has_group(
                    'fusion_plating.group_fusion_plating_manager'
                )
                if not is_manager:
                    raise UserError(_(
                        'Cannot confirm — customer "%s" is on account hold.\n'
                        'Reason: %s\n\n'
                        'Contact a manager to override.'
                    ) % (order.partner_id.name,
                         order.partner_id.x_fc_account_hold_reason or 'No reason specified'))
                else:
                    order.message_post(
                        body=_(
                            'Warning: Customer "%s" is on account hold (reason: %s). '
                            'Order confirmed by manager override.'
                        ) % (order.partner_id.name,
                             order.partner_id.x_fc_account_hold_reason or 'N/A'),
                    )

        res = super().action_confirm()

        # --- Invoice strategy automation (on confirm) ---
        for order in self:
            strategy = order.x_fc_invoice_strategy
            if not strategy:
                continue
            if strategy == 'deposit' and order.x_fc_deposit_percent:
                order._create_deposit_invoice()
            elif strategy == 'cod_prepay':
                order._create_full_invoice()
            elif strategy == 'progress' and order.x_fc_progress_initial_percent:
                order._create_progress_initial_invoice()
            # 'net_terms' — no action on confirm; invoiced when delivery is marked delivered

        return res

    # ------------------------------------------------------------------
    # Strategy implementations
    # ------------------------------------------------------------------
    def _create_deposit_invoice(self):
        """Deposit strategy: down-payment invoice for the deposit %."""
        self.ensure_one()
        percent = self.x_fc_deposit_percent
        if not percent or percent <= 0:
            return
        try:
            # The wizard's sale_order_ids default reads active_ids AT CREATE
            # time — context must be set on .with_context(), not on the
            # subsequent create_invoices() call.
            wizard = self.env['sale.advance.payment.inv'].with_context(
                active_ids=self.ids,
                active_model='sale.order',
                active_id=self.id,
            ).create({
                'advance_payment_method': 'percentage',
                'amount': percent,
            })
            wizard.create_invoices()
            self.message_post(
                body=_('Deposit invoice (%.0f%%) created — strategy: Deposit.') % percent,
            )
        except Exception as e:
            _logger.warning('Failed to create deposit invoice for SO %s: %s', self.name, e)
            self.message_post(
                body=_('Failed to auto-create deposit invoice: %s. Create manually.') % str(e),
            )

    def _create_full_invoice(self):
        """COD / Prepay: invoice the entire order immediately."""
        self.ensure_one()
        try:
            invoices = self._create_invoices()
            if invoices:
                self.message_post(
                    body=_('Full invoice created — strategy: COD / Prepay.'),
                )
        except Exception as e:
            _logger.warning('Failed to create COD invoice for SO %s: %s', self.name, e)
            self.message_post(
                body=_('Failed to auto-create invoice: %s. Create manually.') % str(e),
            )

    def _create_progress_initial_invoice(self):
        """Progress Billing — first invoice at SO confirm.

        Uses Odoo's down-payment mechanism to bill the initial percentage.
        The remainder is billed on delivery via `_create_final_balance_invoice`.
        """
        self.ensure_one()
        percent = self.x_fc_progress_initial_percent
        if not percent or percent <= 0:
            return
        try:
            wizard = self.env['sale.advance.payment.inv'].with_context(
                active_ids=self.ids,
                active_model='sale.order',
                active_id=self.id,
            ).create({
                'advance_payment_method': 'percentage',
                'amount': percent,
            })
            wizard.create_invoices()
            self.message_post(
                body=_(
                    'Progress invoice — initial %.0f%% created — strategy: Progress Billing. '
                    'Final balance will be invoiced on delivery.'
                ) % percent,
            )
        except Exception as e:
            _logger.warning('Failed progress-initial invoice for SO %s: %s', self.name, e)
            self.message_post(
                body=_('Failed to auto-create progress invoice: %s') % str(e),
            )

    def _create_final_balance_invoice(self):
        """Create the closing invoice for Progress Billing / Net Terms.

        Called when delivery is marked delivered. Uses the standard
        `_create_invoices()` method which bills the remainder (net of any
        previously-posted down payments).
        """
        self.ensure_one()
        if self.x_fc_final_invoice_id:
            return self.x_fc_final_invoice_id  # Already invoiced — don't double
        if self.invoice_status == 'invoiced':
            return False  # Nothing more to bill
        try:
            invoices = self._create_invoices(final=True)
            if invoices:
                self.x_fc_final_invoice_id = invoices[:1].id
                strategy_label = dict(
                    self._fields['x_fc_invoice_strategy'].selection
                ).get(self.x_fc_invoice_strategy, self.x_fc_invoice_strategy)
                self.message_post(
                    body=_(
                        'Final invoice created on delivery — strategy: %s.'
                    ) % strategy_label,
                )
                return invoices
        except Exception as e:
            _logger.warning('Failed final invoice for SO %s: %s', self.name, e)
            self.message_post(
                body=_(
                    'Failed to auto-create final invoice: %s. '
                    'Create manually from the SO.'
                ) % str(e),
            )
        return False