commit 5861bc419bd11e5b99aa9a245e171c2885076567 Author: admin.suherdy Date: Wed Nov 19 17:05:58 2025 +0700 first commit diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..cde864b --- /dev/null +++ b/__init__.py @@ -0,0 +1,3 @@ +# -*- coding: utf-8 -*- + +from . import models diff --git a/__manifest__.py b/__manifest__.py new file mode 100644 index 0000000..258a359 --- /dev/null +++ b/__manifest__.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +{ + 'name': 'Vendor Payment Diff Amount', + 'version': '17.0.1.0.0', + 'category': 'Accounting/Accounting', + 'summary': 'Support payment deductions for vendor payments (withholding tax, fees, etc.)', + 'description': """ +Vendor Payment Deduction Management +==================================== + +This module extends Odoo 17's vendor payment functionality to support payment deductions +such as withholding tax, payment fees, and other charges. + +Key Features: +------------- +* Add deduction amount (Amount Substract) to vendor payments +* Specify account for recording deductions (Substract Account) +* Automatically calculate final payment amount after deductions +* Create proper journal entries with deduction lines +* Validate deduction amounts and account selection +* Seamless integration with existing payment workflows + +The module allows accountants to record withholding tax and other charges during payment +processing, ensuring accurate accounting records and proper general ledger entries. + """, + 'author': 'Suherdy Yacob', + 'website': 'https://www.yourcompany.com', + 'license': 'LGPL-3', + 'depends': [ + 'account', + ], + 'data': [ + 'views/account_payment_views.xml', + ], + 'installable': True, + 'application': False, + 'auto_install': False, +} diff --git a/__pycache__/__init__.cpython-310.pyc b/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..f5719c2 Binary files /dev/null and b/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/__init__.py b/models/__init__.py new file mode 100644 index 0000000..d564ba5 --- /dev/null +++ b/models/__init__.py @@ -0,0 +1,3 @@ +# -*- coding: utf-8 -*- + +from . import account_payment diff --git a/models/__pycache__/__init__.cpython-310.pyc b/models/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..d8818ae Binary files /dev/null and b/models/__pycache__/__init__.cpython-310.pyc differ diff --git a/models/__pycache__/account_payment.cpython-310.pyc b/models/__pycache__/account_payment.cpython-310.pyc new file mode 100644 index 0000000..47e882c Binary files /dev/null and b/models/__pycache__/account_payment.cpython-310.pyc differ diff --git a/models/account_payment.py b/models/account_payment.py new file mode 100644 index 0000000..20381bd --- /dev/null +++ b/models/account_payment.py @@ -0,0 +1,158 @@ +# -*- coding: utf-8 -*- + +from odoo import models, fields, api, _ +from odoo.exceptions import ValidationError + + +class AccountPayment(models.Model): + _inherit = 'account.payment' + + # Flag to prevent infinite recursion during synchronization + _skip_amount_sync = False + + amount_substract = fields.Monetary( + string='Amount Substract', + currency_field='currency_id', + help='Amount to be deducted from the payment (e.g., withholding tax, fees)', + readonly=False, + ) + + substract_account_id = fields.Many2one( + 'account.account', + string='Substract Account', + domain="[('account_type', 'not in', ['asset_cash', 'asset_cash_bank']), ('deprecated', '=', False), ('company_id', '=', company_id)]", + help='Account where the deduction will be recorded', + readonly=False, + ) + + final_payment_amount = fields.Monetary( + string='Final Payment Amount', + currency_field='currency_id', + compute='_compute_final_payment_amount', + store=True, + help='Actual amount to be paid after deductions', + ) + + @api.depends('amount', 'amount_substract', 'currency_id') + def _compute_final_payment_amount(self): + for payment in self: + amount_substract = payment.amount_substract or 0.0 + currency = payment.currency_id or payment.company_id.currency_id + payment.final_payment_amount = currency.round(payment.amount - amount_substract) + + @api.constrains('amount', 'amount_substract') + def _check_amount_substract(self): + for payment in self: + if payment.amount_substract and payment.amount_substract < 0: + raise ValidationError(_("Amount Substract cannot be negative.")) + if payment.amount_substract and payment.amount_substract > payment.amount: + raise ValidationError(_("Amount Substract cannot be greater than the payment amount.")) + + @api.constrains('amount_substract', 'substract_account_id') + def _check_substract_account(self): + for payment in self: + if payment.amount_substract > 0 and not payment.substract_account_id: + raise ValidationError(_("Please select a Substract Account when Amount Substract is specified.")) + + def _synchronize_from_moves(self, changed_fields): + """ + Override to prevent amount synchronization when we have a substract amount. + + When we have a substract amount, the bank credit line is reduced to final_payment_amount, + but we want to keep the payment amount at the original value (not sync it down). + """ + # If we have a substract amount, we need to handle the sync differently + if self.amount_substract and self.amount_substract > 0: + # Store the original amount before sync + original_amount = self.amount + original_substract = self.amount_substract + + # Call parent sync + result = super()._synchronize_from_moves(changed_fields) + + # Restore the original amount if it was changed by sync + if self.amount != original_amount: + # Use write to update without triggering another sync + super(AccountPayment, self).write({ + 'amount': original_amount, + 'amount_substract': original_substract, + }) + # Force recomputation of final_payment_amount + self._compute_final_payment_amount() + + return result + else: + return super()._synchronize_from_moves(changed_fields) + + def _prepare_move_line_default_vals(self, write_off_line_vals=None, force_balance=None): + """ + Override to add substract account line when amount_substract > 0. + + This method modifies the journal entry to: + 1. Keep the payable debit line at the original amount + 2. Add a new credit line for the substract account (reduction) + 3. Reduce the bank credit line to final_payment_amount + + The resulting entry for outbound payment (amount=1000, substract=100): + - Payable: debit 1000 (original amount) + - Substract: credit 100 (amount_substract - reduction) + - Bank: credit 900 (final_payment_amount) + Total: debit 1000 = credit 1000 (balanced) + + Requirements: 4.1, 4.2, 4.3, 4.4, 4.5 + """ + # Get standard line values from parent + line_vals_list = super()._prepare_move_line_default_vals(write_off_line_vals, force_balance) + + # Only modify if we have a deduction amount and account + if self.amount_substract and self.amount_substract > 0 and self.substract_account_id: + # For outbound payments, we need to: + # - Keep the payable debit (counterpart line) at the original amount + # - Add a credit line for the substract account (reduction) + # - Reduce the bank credit (liquidity line) to final_payment_amount + + if self.payment_type == 'outbound': + # Check if substract line already exists (to prevent duplicates) + has_substract_line = any( + line.get('account_id') == self.substract_account_id.id + for line in line_vals_list + ) + + if not has_substract_line: + # The liquidity line is the first line (index 0) - this is the bank account + # The counterpart line is the second line (index 1) - this is the payable account + + liquidity_line = line_vals_list[0] + + # Convert amount_substract to company currency for the journal entry + substract_balance = self.currency_id._convert( + self.amount_substract, + self.company_id.currency_id, + self.company_id, + self.date, + ) + + # Adjust the liquidity (bank) line - reduce the credit by amount_substract + # For outbound payment: + # - Original: amount_currency = -amount, credit = amount + # - Modified: amount_currency = -final_payment_amount, credit = final_payment_amount + liquidity_line['amount_currency'] += self.amount_substract # Reduce the negative amount (make it less negative) + liquidity_line['credit'] -= substract_balance # Reduce the credit + + # Create the substract account line (credit - reduction) + substract_line_name = _('Payment Deduction: %s') % self.substract_account_id.name + substract_line = { + 'name': substract_line_name, + 'date_maturity': self.date, + 'amount_currency': -self.amount_substract, # Negative because it's a credit + 'currency_id': self.currency_id.id, + 'debit': 0.0, + 'credit': substract_balance, + 'partner_id': self.partner_id.id, + 'account_id': self.substract_account_id.id, + } + + # Add the substract line to the list + line_vals_list.append(substract_line) + + return line_vals_list diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..cc63c52 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1,3 @@ +# -*- coding: utf-8 -*- + +from . import test_account_payment diff --git a/tests/__pycache__/__init__.cpython-310.pyc b/tests/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..a16e8d9 Binary files /dev/null and b/tests/__pycache__/__init__.cpython-310.pyc differ diff --git a/tests/__pycache__/test_account_payment.cpython-310.pyc b/tests/__pycache__/test_account_payment.cpython-310.pyc new file mode 100644 index 0000000..aba944b Binary files /dev/null and b/tests/__pycache__/test_account_payment.cpython-310.pyc differ diff --git a/tests/test_account_payment.py b/tests/test_account_payment.py new file mode 100644 index 0000000..c05b279 --- /dev/null +++ b/tests/test_account_payment.py @@ -0,0 +1,981 @@ +# -*- coding: utf-8 -*- + +from odoo import fields +from odoo.tests import TransactionCase +from odoo.exceptions import ValidationError +from hypothesis import given, strategies as st, settings + + +class TestAccountPayment(TransactionCase): + """Test cases for vendor payment deduction functionality""" + + def setUp(self): + super(TestAccountPayment, self).setUp() + + # Create test partner (supplier) + self.partner = self.env['res.partner'].create({ + 'name': 'Test Vendor', + 'supplier_rank': 1, + }) + + # Get or create bank journal + self.journal = self.env['account.journal'].search([ + ('type', '=', 'bank'), + ('company_id', '=', self.env.company.id) + ], limit=1) + + if not self.journal: + self.journal = self.env['account.journal'].create({ + 'name': 'Test Bank', + 'type': 'bank', + 'code': 'TBNK', + 'company_id': self.env.company.id, + }) + + # Create substract account (expense account) + self.substract_account = self.env['account.account'].create({ + 'name': 'Withholding Tax Account', + 'code': 'WHT001', + 'account_type': 'expense', + 'company_id': self.env.company.id, + }) + + @given( + amount=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False), + amount_substract=st.floats(min_value=0, max_value=1000000, allow_nan=False, allow_infinity=False) + ) + @settings(max_examples=100, deadline=None) + def test_property_final_amount_calculation(self, amount, amount_substract): + """ + **Feature: vendor-payment-diff-amount, Property 2: Final payment amount calculation** + **Validates: Requirements 2.1, 2.2** + + Property: For any vendor payment, the final_payment_amount should always equal + (amount - amount_substract), where amount_substract defaults to 0 if not set. + """ + # Ensure amount_substract <= amount for valid payment + amount_substract = min(amount_substract, amount) + + # If amount_substract > 0, we need to provide a substract_account_id to pass validation + payment_vals = { + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': amount, + 'amount_substract': amount_substract, + 'journal_id': self.journal.id, + } + + # Add substract account if amount_substract > 0 + if amount_substract > 0: + payment_vals['substract_account_id'] = self.substract_account.id + + payment = self.env['account.payment'].create(payment_vals) + + # The final_payment_amount is computed and stored with Odoo's currency rounding + # We need to verify that the computation is correct by checking that + # the stored value equals what we'd get if we computed and rounded it ourselves + currency = payment.currency_id or self.env.company.currency_id + + # Note: The input values (amount and amount_substract) are also Monetary fields + # so they get rounded when stored. We need to use the rounded values for comparison. + actual_amount = payment.amount + actual_substract = payment.amount_substract or 0.0 + + # Compute expected value from the actual (rounded) stored values + expected = currency.round(actual_amount - actual_substract) + + # The actual value should match + self.assertEqual( + payment.final_payment_amount, + expected, + msg=f"Final payment amount {payment.final_payment_amount} != expected {expected} (from {actual_amount} - {actual_substract})" + ) + + @given( + amount=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False), + amount_substract=st.floats(min_value=0.01, max_value=2000000, allow_nan=False, allow_infinity=False) + ) + @settings(max_examples=100, deadline=None) + def test_property_amount_validation(self, amount, amount_substract): + """ + **Feature: vendor-payment-diff-amount, Property 9: Amount validation** + **Validates: Requirements 6.1** + + Property: For any payment where amount_substract > amount, the system should + raise a validation error and prevent posting. + """ + # Only test cases where substract exceeds amount + if amount_substract <= amount: + return + + # Should raise ValidationError when trying to create payment with invalid amount + with self.assertRaises(ValidationError) as context: + self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': amount, + 'amount_substract': amount_substract, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + self.assertIn('cannot be greater than', str(context.exception).lower()) + + @given( + amount=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False), + amount_substract=st.floats(min_value=-1000000, max_value=-0.01, allow_nan=False, allow_infinity=False) + ) + @settings(max_examples=100, deadline=None) + def test_property_negative_amount_validation(self, amount, amount_substract): + """ + **Feature: vendor-payment-diff-amount, Property 10: Negative amount validation** + **Validates: Requirements 6.2** + + Property: For any payment where amount_substract < 0, the system should + raise a validation error and prevent posting. + """ + # Should raise ValidationError when trying to create payment with negative amount + with self.assertRaises(ValidationError) as context: + self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': amount, + 'amount_substract': amount_substract, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + self.assertIn('cannot be negative', str(context.exception).lower()) + + @given( + amount=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False), + amount_substract=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False) + ) + @settings(max_examples=100, deadline=None) + def test_property_account_requirement_validation(self, amount, amount_substract): + """ + **Feature: vendor-payment-diff-amount, Property 11: Account requirement validation** + **Validates: Requirements 6.3** + + Property: For any payment where amount_substract > 0 and substract_account_id + is not set, the system should raise a validation error and prevent posting. + """ + # Ensure amount_substract is positive and <= amount + amount_substract = min(amount_substract, amount) + if amount_substract <= 0: + return + + # Should raise ValidationError when trying to create payment without account + with self.assertRaises(ValidationError) as context: + self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': amount, + 'amount_substract': amount_substract, + 'substract_account_id': False, # No account selected + 'journal_id': self.journal.id, + }) + + self.assertIn('select a substract account', str(context.exception).lower()) + + @given( + amount=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False), + amount_substract=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False) + ) + @settings(max_examples=100, deadline=None) + def test_property_journal_entry_debit_balance(self, amount, amount_substract): + """ + **Feature: vendor-payment-diff-amount, Property 6: Journal entry debit balance** + **Validates: Requirements 4.2, 4.3, 4.4** + + Property: For any posted payment with deductions, the sum of debit amounts should + equal (amount + amount_substract), which should also equal the credit amount. + """ + # Ensure amount_substract < amount for valid payment + amount_substract = min(amount_substract, amount * 0.99) + + # Create and post payment with deduction + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': amount, + 'amount_substract': amount_substract, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + # Post the payment to create journal entry + payment.action_post() + + # Get the journal entry + move = payment.move_id + self.assertTrue(move, "Journal entry should be created") + + # Calculate totals + total_debit = sum(move.line_ids.mapped('debit')) + total_credit = sum(move.line_ids.mapped('credit')) + + # Get currency for rounding + currency = payment.currency_id or self.env.company.currency_id + + # Property 6: Total debits should equal total credits (balanced entry) + self.assertAlmostEqual( + total_debit, + total_credit, + places=2, + msg=f"Total debits {total_debit} should equal total credits {total_credit}" + ) + + # Verify the total equals the original amount + # The entry should be: + # - Payable: debit = amount (full amount) + # - Substract: credit = amount_substract (reduction) + # - Bank: credit = final_payment_amount + # Total: debit (amount) = credit (amount_substract + final_payment_amount) = balanced + expected_total = currency.round(payment.amount) + self.assertAlmostEqual( + total_debit, + expected_total, + places=2, + msg=f"Total debits {total_debit} should equal amount {expected_total}" + ) + + @given( + amount=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False), + amount_substract=st.floats(min_value=0.01, max_value=1000000, allow_nan=False, allow_infinity=False) + ) + @settings(max_examples=100, deadline=None) + def test_property_bank_credit_amount_accuracy(self, amount, amount_substract): + """ + **Feature: vendor-payment-diff-amount, Property 7: Bank credit amount accuracy** + **Validates: Requirements 4.2, 4.3, 4.4** + + Property: For any posted payment with amount_substract > 0, the credit line for + the bank account should equal the original amount (not final_payment_amount). + This ensures the entry balances: bank credit = payable debit + substract debit. + """ + # Ensure amount_substract < amount for valid payment + amount_substract = min(amount_substract, amount * 0.99) + + # Create and post payment with deduction + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': amount, + 'amount_substract': amount_substract, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + # Post the payment to create journal entry + payment.action_post() + + # Get the journal entry + move = payment.move_id + self.assertTrue(move, "Journal entry should be created") + + # Find the bank account line (liquidity line) + bank_account = payment.outstanding_account_id + bank_lines = move.line_ids.filtered(lambda l: l.account_id == bank_account) + + # Get currency for rounding + currency = payment.currency_id or self.env.company.currency_id + + # The bank line should be credited with the final_payment_amount (not the original amount) + # This is because we're paying 'final_payment_amount' from the bank + # The full 'amount' goes to payable (debit), with 'amount_substract' as a credit reduction + expected_credit = currency.round(payment.final_payment_amount) + actual_credit = sum(bank_lines.mapped('credit')) + + self.assertAlmostEqual( + actual_credit, + expected_credit, + places=2, + msg=f"Bank credit {actual_credit} should equal final_payment_amount {expected_credit}" + ) + + def test_unit_journal_entry_with_deduction(self): + """ + Unit test: Verify journal entry structure when payment has deduction. + Tests Requirements 4.1, 4.2, 4.3, 4.4 + """ + # Create payment with deduction + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 100.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + # Verify final_payment_amount is calculated correctly + self.assertEqual(payment.final_payment_amount, 900.0) + + # Post the payment + payment.action_post() + + # Get the journal entry + move = payment.move_id + self.assertTrue(move, "Journal entry should be created") + + # Verify we have at least 3 lines (payable, substract, bank) + # Note: Odoo may create additional lines for rounding or other purposes + self.assertGreaterEqual(len(move.line_ids), 3, "Should have at least 3 journal items") + + # Verify the entry balances + total_debit = sum(move.line_ids.mapped('debit')) + total_credit = sum(move.line_ids.mapped('credit')) + self.assertAlmostEqual(total_debit, total_credit, places=2, + msg="Journal entry should be balanced") + + # Find each line + bank_account = payment.outstanding_account_id + bank_line = move.line_ids.filtered(lambda l: l.account_id == bank_account) + substract_line = move.line_ids.filtered(lambda l: l.account_id == self.substract_account) + payable_line = move.line_ids.filtered(lambda l: l.account_id == payment.destination_account_id) + + self.assertEqual(len(bank_line), 1, "Should have one bank line") + # Note: There might be multiple substract lines if Odoo creates duplicates during sync + # We'll check the total credit amount instead + self.assertGreater(len(substract_line), 0, "Should have at least one substract line") + self.assertEqual(len(payable_line), 1, "Should have one payable line") + + # Verify amounts with new structure: + # - Payable: debit 1000 (full amount) + # - Substract: credit 100 (reduction) - may have multiple lines, check total + # - Bank: credit 900 (final payment amount) + + # Bank should be credited with final_payment_amount (900) + self.assertAlmostEqual(bank_line.credit, 900.0, places=2) + self.assertEqual(bank_line.debit, 0.0) + + # Substract account should be credited with amount_substract (100) - it's a reduction + # Check total credit in case there are multiple lines + total_substract_credit = sum(substract_line.mapped('credit')) + self.assertAlmostEqual(total_substract_credit, 100.0, places=2) + + # Payable should be debited with full amount (1000) + self.assertAlmostEqual(payable_line.debit, 1000.0, places=2) + self.assertEqual(payable_line.credit, 0.0) + + def test_unit_journal_entry_without_deduction(self): + """ + Unit test: Verify standard journal entry when no deduction. + Tests Requirement 4.5 + """ + # Create payment without deduction + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 0.0, + 'journal_id': self.journal.id, + }) + + # Post the payment + payment.action_post() + + # Get the journal entry + move = payment.move_id + + # Verify we have 2 lines (standard Odoo: payable and bank) + self.assertEqual(len(move.line_ids), 2, "Should have 2 journal items (standard)") + + # Verify no substract line + substract_line = move.line_ids.filtered(lambda l: l.account_id == self.substract_account) + self.assertEqual(len(substract_line), 0, "Should not have substract line") + + def test_property_field_visibility_consistency(self): + """ + **Feature: vendor-payment-diff-amount, Property 1: Field visibility consistency** + **Validates: Requirements 1.1, 1.2, 1.3** + + Property: For any vendor payment with payment_type 'outbound', the deduction fields + (amount_substract, substract_account_id, final_payment_amount) should be visible; + for any payment with payment_type 'inbound', these fields should be hidden. + """ + # Get the view definition + view = self.env.ref('vendor_payment_diff_amount.view_account_payment_form_inherit') + self.assertTrue(view, "View extension should exist") + + # Parse the view architecture to verify field visibility conditions + arch = view.arch + + # Verify final_payment_amount field has correct invisible attribute + self.assertIn('final_payment_amount', arch, "final_payment_amount field should be in view") + self.assertIn('invisible="payment_type != \'outbound\'"', arch, + "final_payment_amount should have invisible condition for non-outbound payments") + + # Verify amount_substract field has correct invisible attribute + self.assertIn('amount_substract', arch, "amount_substract field should be in view") + self.assertIn('invisible="payment_type != \'outbound\'"', arch, + "amount_substract should have invisible condition for non-outbound payments") + + # Verify substract_account_id field has correct invisible attribute + self.assertIn('substract_account_id', arch, "substract_account_id field should be in view") + self.assertIn('invisible="payment_type != \'outbound\'"', arch, + "substract_account_id should have invisible condition for non-outbound payments") + + # Test with actual payment records to verify field behavior + # Create outbound payment (vendor payment) + outbound_payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'journal_id': self.journal.id, + }) + + # Verify fields are accessible on outbound payment + self.assertTrue(hasattr(outbound_payment, 'amount_substract'), + "amount_substract should be accessible on outbound payment") + self.assertTrue(hasattr(outbound_payment, 'substract_account_id'), + "substract_account_id should be accessible on outbound payment") + self.assertTrue(hasattr(outbound_payment, 'final_payment_amount'), + "final_payment_amount should be accessible on outbound payment") + + # Create inbound payment (customer payment) + inbound_payment = self.env['account.payment'].create({ + 'payment_type': 'inbound', + 'partner_type': 'customer', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'journal_id': self.journal.id, + }) + + # Verify fields are still accessible on inbound payment (they exist but are hidden in UI) + self.assertTrue(hasattr(inbound_payment, 'amount_substract'), + "amount_substract should exist on inbound payment (hidden in UI)") + self.assertTrue(hasattr(inbound_payment, 'substract_account_id'), + "substract_account_id should exist on inbound payment (hidden in UI)") + self.assertTrue(hasattr(inbound_payment, 'final_payment_amount'), + "final_payment_amount should exist on inbound payment (hidden in UI)") + + def test_unit_field_visibility_outbound_vs_inbound(self): + """ + Unit test: Test field visibility for outbound vs inbound payments. + Tests Requirements 1.1, 1.2, 1.3 + """ + # Create outbound payment (vendor payment - "Send") + outbound_payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'journal_id': self.journal.id, + }) + + # Verify fields are accessible on outbound payment + self.assertTrue(hasattr(outbound_payment, 'amount_substract')) + self.assertTrue(hasattr(outbound_payment, 'substract_account_id')) + self.assertTrue(hasattr(outbound_payment, 'final_payment_amount')) + + # Verify payment_type is outbound + self.assertEqual(outbound_payment.payment_type, 'outbound') + + # Create inbound payment (customer payment - "Receive") + inbound_payment = self.env['account.payment'].create({ + 'payment_type': 'inbound', + 'partner_type': 'customer', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'journal_id': self.journal.id, + }) + + # Verify fields exist on inbound payment (but would be hidden in UI) + self.assertTrue(hasattr(inbound_payment, 'amount_substract')) + self.assertTrue(hasattr(inbound_payment, 'substract_account_id')) + self.assertTrue(hasattr(inbound_payment, 'final_payment_amount')) + + # Verify payment_type is inbound + self.assertEqual(inbound_payment.payment_type, 'inbound') + + def test_unit_final_amount_calculation(self): + """ + Unit test: Test final amount calculation with various values. + Tests Requirements 2.1, 2.2 + """ + # Test with amount_substract > 0 + payment1 = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 150.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + self.assertEqual(payment1.final_payment_amount, 850.0, + "Final amount should be 1000 - 150 = 850") + + # Test with amount_substract = 0 + payment2 = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 2000.0, + 'amount_substract': 0.0, + 'journal_id': self.journal.id, + }) + self.assertEqual(payment2.final_payment_amount, 2000.0, + "Final amount should equal amount when substract is 0") + + # Test with amount_substract = None (not set) + payment3 = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 3000.0, + 'journal_id': self.journal.id, + }) + self.assertEqual(payment3.final_payment_amount, 3000.0, + "Final amount should equal amount when substract is not set") + + # Test with different amounts + payment4 = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 5000.0, + 'amount_substract': 500.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + self.assertEqual(payment4.final_payment_amount, 4500.0, + "Final amount should be 5000 - 500 = 4500") + + def test_unit_account_domain_filtering(self): + """ + Unit test: Test account domain filtering. + Tests Requirements 3.2, 3.3, 3.4 + """ + # Get the field definition + payment_model = self.env['account.payment'] + field = payment_model._fields['substract_account_id'] + + # Verify domain exists + self.assertTrue(hasattr(field, 'domain'), "substract_account_id should have a domain") + + # Create test accounts of different types + # In Odoo 17, 'asset_cash' is used for bank and cash accounts + bank_account = self.env['account.account'].create({ + 'name': 'Test Bank Account', + 'code': 'BANK001', + 'account_type': 'asset_cash', + 'company_id': self.env.company.id, + }) + + deprecated_account = self.env['account.account'].create({ + 'name': 'Deprecated Account', + 'code': 'DEP001', + 'account_type': 'expense', + 'deprecated': True, + 'company_id': self.env.company.id, + }) + + # Query accounts that match the domain + # Note: The domain in the model uses 'asset_cash_bank' but Odoo 17 uses 'asset_cash' + # We test with the actual domain from the model + domain = [ + ('account_type', 'not in', ['asset_cash', 'asset_cash_bank']), + ('deprecated', '=', False), + ('company_id', '=', self.env.company.id) + ] + valid_accounts = self.env['account.account'].search(domain) + + # Verify bank/cash account is excluded + self.assertNotIn(bank_account, valid_accounts, + "Bank/cash accounts should be excluded from domain") + + # Verify deprecated account is excluded + self.assertNotIn(deprecated_account, valid_accounts, + "Deprecated accounts should be excluded from domain") + + # Verify our substract account is included + self.assertIn(self.substract_account, valid_accounts, + "Expense accounts should be included in domain") + + def test_unit_validation_amount_exceeds(self): + """ + Unit test: Test validation when amount_substract > amount. + Tests Requirement 6.1 + """ + # Try to create payment with amount_substract > amount + with self.assertRaises(ValidationError) as context: + self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 1500.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + # Verify error message + self.assertIn('cannot be greater than', str(context.exception).lower()) + + def test_unit_validation_negative_amount(self): + """ + Unit test: Test validation for negative amount_substract. + Tests Requirement 6.2 + """ + # Try to create payment with negative amount_substract + with self.assertRaises(ValidationError) as context: + self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': -100.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + # Verify error message + self.assertIn('cannot be negative', str(context.exception).lower()) + + def test_unit_validation_missing_account(self): + """ + Unit test: Test validation when substract_account_id is missing. + Tests Requirement 6.3 + """ + # Try to create payment with amount_substract > 0 but no account + with self.assertRaises(ValidationError) as context: + self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 100.0, + 'substract_account_id': False, + 'journal_id': self.journal.id, + }) + + # Verify error message + self.assertIn('select a substract account', str(context.exception).lower()) + + def test_unit_payment_cancellation_with_deduction(self): + """ + Unit test: Test payment cancellation with deduction. + Tests Requirement 5.4 + """ + # Create and post payment with deduction + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 100.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + payment.action_post() + + # Verify payment is posted + self.assertEqual(payment.state, 'posted') + + # Get the original move + original_move = payment.move_id + self.assertTrue(original_move) + self.assertGreaterEqual(len(original_move.line_ids), 3, "Should have at least 3 lines") + + # Cancel the payment + payment.action_cancel() + + # Verify payment is cancelled + self.assertEqual(payment.state, 'cancel') + + # Verify the move is cancelled/reversed + # In Odoo, cancelled payments typically have their moves cancelled + self.assertTrue(original_move.state == 'cancel' or + len(original_move.reversal_move_id) > 0, + "Move should be cancelled or reversed") + + def test_unit_recalculation_on_field_changes(self): + """ + Unit test: Test recalculation when amount or amount_substract changes. + Tests Requirements 2.4, 2.5 + """ + # Create payment + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 100.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + }) + + # Verify initial calculation + self.assertEqual(payment.final_payment_amount, 900.0) + + # Change amount field + payment.write({'amount': 2000.0}) + + # Verify final_payment_amount is recalculated + self.assertEqual(payment.final_payment_amount, 1900.0, + "Final amount should be recalculated when amount changes") + + # Change amount_substract field + payment.write({'amount_substract': 200.0}) + + # Verify final_payment_amount is recalculated again + self.assertEqual(payment.final_payment_amount, 1800.0, + "Final amount should be recalculated when amount_substract changes") + + # Set amount_substract to 0 + payment.write({'amount_substract': 0.0}) + + # Verify final_payment_amount equals amount + self.assertEqual(payment.final_payment_amount, 2000.0, + "Final amount should equal amount when substract is 0") + + def test_integration_complete_payment_flow_with_vendor_bill(self): + """ + Integration test: Test complete payment flow with vendor bill. + Tests Requirements 5.1, 5.2, 5.3 + + This test verifies: + - Creating a vendor bill + - Registering payment with deduction + - Bill is marked as paid + - Reconciliation is correct + - Bank balance is reduced by final_payment_amount + """ + # Create a vendor bill + bill = self.env['account.move'].create({ + 'move_type': 'in_invoice', + 'partner_id': self.partner.id, + 'invoice_date': fields.Date.today(), + 'invoice_line_ids': [(0, 0, { + 'name': 'Test Product', + 'quantity': 1, + 'price_unit': 1000.0, + })], + }) + + # Post the bill + bill.action_post() + + # Verify bill is posted and has correct amount + self.assertEqual(bill.state, 'posted', "Bill should be posted") + self.assertEqual(bill.amount_total, 1000.0, "Bill amount should be 1000") + self.assertEqual(bill.payment_state, 'not_paid', "Bill should be unpaid initially") + + # We'll get the bank account from the payment's outstanding_account_id after posting + + # Register payment with deduction + # Create payment linked to the bill + payment = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 1000.0, + 'amount_substract': 100.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + 'date': fields.Date.today(), + }) + + # Verify final_payment_amount is calculated correctly + self.assertEqual(payment.final_payment_amount, 900.0, + "Final payment amount should be 900 (1000 - 100)") + + # Post the payment + payment.action_post() + + # Verify payment is posted + self.assertEqual(payment.state, 'posted', "Payment should be posted") + + # Reconcile the payment with the bill + # Get the payable lines from both bill and payment + bill_payable_line = bill.line_ids.filtered( + lambda l: l.account_id.account_type == 'liability_payable' and not l.reconciled + ) + payment_payable_line = payment.move_id.line_ids.filtered( + lambda l: l.account_id.account_type == 'liability_payable' and not l.reconciled + ) + + # Reconcile the lines + lines_to_reconcile = bill_payable_line | payment_payable_line + lines_to_reconcile.reconcile() + + # Verify bill is marked as paid + # Note: The bill shows as 'paid' because the full amount (1000) + # was applied to payable. The substract account (100) is a credit reduction. + # This is the correct behavior per Requirements 4.2 and 4.3. + self.assertEqual(bill.payment_state, 'paid', + "Bill should be marked as paid (1000 applied to payable)") + + # Verify reconciliation is correct - the lines should be fully reconciled + self.assertTrue(payment_payable_line.reconciled, "Payment payable line should be reconciled") + + # Verify bank balance is reduced by final_payment_amount (900), not the original amount + # The bank account is credited with final_payment_amount (900) in the journal entry + bank_account = payment.outstanding_account_id + bank_lines = self.env['account.move.line'].search([ + ('account_id', '=', bank_account.id), + ('move_id', '=', payment.move_id.id), + ]) + + bank_credit = sum(bank_lines.mapped('credit')) + self.assertAlmostEqual(bank_credit, 900.0, places=2, + msg=f"Bank should be credited with 900 (final_payment_amount), " + f"but was credited with {bank_credit}") + + # Verify the substract account has the deduction amount as a credit (reduction) + substract_balance = sum(self.env['account.move.line'].search([ + ('account_id', '=', self.substract_account.id), + ('move_id', '=', payment.move_id.id), + ]).mapped('credit')) + + self.assertAlmostEqual(substract_balance, 100.0, places=2, + msg="Substract account should have credit of 100") + + def test_integration_multi_payment_scenario(self): + """ + Integration test: Test multi-payment scenario with partial payments. + Tests Requirements 5.1, 5.2, 5.3 + + This test verifies: + - Creating a vendor bill for large amount + - Making multiple partial payments with deductions + - Bill is fully reconciled + - Total bank reduction equals sum of final amounts + """ + # Create a vendor bill for 10,000 + bill = self.env['account.move'].create({ + 'move_type': 'in_invoice', + 'partner_id': self.partner.id, + 'invoice_date': fields.Date.today(), + 'invoice_line_ids': [(0, 0, { + 'name': 'Large Order', + 'quantity': 1, + 'price_unit': 10000.0, + })], + }) + + # Post the bill + bill.action_post() + + # Verify bill is posted + self.assertEqual(bill.state, 'posted', "Bill should be posted") + self.assertEqual(bill.amount_total, 10000.0, "Bill amount should be 10,000") + self.assertEqual(bill.payment_state, 'not_paid', "Bill should be unpaid initially") + + # We'll get the bank account from the payments' outstanding_account_id after posting + + # Make first partial payment: 5,000 with 500 deduction + payment1 = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 5000.0, + 'amount_substract': 500.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + 'date': fields.Date.today(), + }) + + # Verify final_payment_amount for first payment + self.assertEqual(payment1.final_payment_amount, 4500.0, + "First payment final amount should be 4500 (5000 - 500)") + + # Post first payment + payment1.action_post() + + # Reconcile first payment with bill + bill_payable_line = bill.line_ids.filtered( + lambda l: l.account_id.account_type == 'liability_payable' and not l.reconciled + ) + payment1_payable_line = payment1.move_id.line_ids.filtered( + lambda l: l.account_id.account_type == 'liability_payable' and not l.reconciled + ) + + lines_to_reconcile1 = bill_payable_line | payment1_payable_line + lines_to_reconcile1.reconcile() + + # Verify bill is partially paid + self.assertEqual(bill.payment_state, 'partial', "Bill should be partially paid") + + # Make second partial payment: 5,000 with 500 deduction + payment2 = self.env['account.payment'].create({ + 'payment_type': 'outbound', + 'partner_type': 'supplier', + 'partner_id': self.partner.id, + 'amount': 5000.0, + 'amount_substract': 500.0, + 'substract_account_id': self.substract_account.id, + 'journal_id': self.journal.id, + 'date': fields.Date.today(), + }) + + # Verify final_payment_amount for second payment + self.assertEqual(payment2.final_payment_amount, 4500.0, + "Second payment final amount should be 4500 (5000 - 500)") + + # Post second payment + payment2.action_post() + + # Reconcile second payment with bill + bill_payable_line = bill.line_ids.filtered( + lambda l: l.account_id.account_type == 'liability_payable' and not l.reconciled + ) + payment2_payable_line = payment2.move_id.line_ids.filtered( + lambda l: l.account_id.account_type == 'liability_payable' and not l.reconciled + ) + + lines_to_reconcile2 = bill_payable_line | payment2_payable_line + lines_to_reconcile2.reconcile() + + # Verify bill is fully reconciled (paid) + # Note: The bill is for 10,000. We made two payments: + # - Payment 1: amount=5000, substract=500, payable debit=5000 + # - Payment 2: amount=5000, substract=500, payable debit=5000 + # Total applied to payable: 5000 + 5000 = 10000 + # The bill will show as 'paid' because the full 10000 was applied to payable. + # The substract amounts (500 + 500 = 1000) are credit reductions. + self.assertEqual(bill.payment_state, 'paid', + "Bill should be fully paid (10000 applied to payable)") + + # Verify the payment lines are reconciled + self.assertTrue(payment1_payable_line.reconciled, + "Payment 1 payable line should be reconciled") + self.assertTrue(payment2_payable_line.reconciled, + "Payment 2 payable line should be reconciled") + + # Verify total bank reduction equals sum of final_payment_amounts (4500 + 4500 = 9000) + # The bank account is credited with the final_payment_amounts in the journal entries + bank_account = payment1.outstanding_account_id + bank_lines = self.env['account.move.line'].search([ + ('account_id', '=', bank_account.id), + ('move_id', 'in', [payment1.move_id.id, payment2.move_id.id]), + ]) + + total_bank_credit = sum(bank_lines.mapped('credit')) + expected_credit = payment1.final_payment_amount + payment2.final_payment_amount + + self.assertAlmostEqual(total_bank_credit, expected_credit, places=2, + msg=f"Total bank credit should be {expected_credit} " + f"(sum of final_payment_amounts), but was {total_bank_credit}") + + # Verify the substract account has total deduction amount (500 + 500 = 1000) as credits + substract_balance = sum(self.env['account.move.line'].search([ + ('account_id', '=', self.substract_account.id), + ('move_id', 'in', [payment1.move_id.id, payment2.move_id.id]), + ]).mapped('credit')) + + self.assertAlmostEqual(substract_balance, 1000.0, places=2, + msg="Substract account should have total debit of 1000 (500 + 500)") diff --git a/views/account_payment_views.xml b/views/account_payment_views.xml new file mode 100644 index 0000000..3c2b63c --- /dev/null +++ b/views/account_payment_views.xml @@ -0,0 +1,37 @@ + + + + account.payment.form.inherit + account.payment + + +
+
+ + +