first commit

modules/account_product/product.py

@@ -0,0 +1,441 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.
+from functools import wraps
+
+from sql import Null
+
+from trytond import backend
+from trytond.i18n import gettext
+from trytond.model import ModelSQL, fields
+from trytond.modules.company.model import (
+    CompanyMultiValueMixin, CompanyValueMixin)
+from trytond.pool import Pool, PoolMeta
+from trytond.pyson import Bool, Eval, Or
+from trytond.transaction import Transaction
+
+from .exceptions import AccountError, TaxError
+
+
+def account_used(field_name, field_string=None):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self):
+            account = func(self)
+            if not account:
+                account = self.get_account(field_name + '_used')
+            # Allow empty values on on_change
+            if not account and not Transaction().readonly:
+                Model = self.__class__
+                field = field_name
+                if field_string:
+                    if getattr(self, field_string, None):
+                        Model = getattr(self, field_string).__class__
+                    else:
+                        field = field_string
+                field = (
+                    Model.fields_get([field])[field]['string'])
+                raise AccountError(
+                    gettext('account_product.msg_missing_account',
+                        field=field,
+                        name=self.rec_name))
+            if account:
+                return account.current()
+        return wrapper
+    return decorator
+
+
+def template_property(field_name):
+    @property
+    @fields.depends('template')
+    def prop(self):
+        return getattr(self.template, field_name)
+    return prop
+
+
+class Category(CompanyMultiValueMixin, metaclass=PoolMeta):
+    __name__ = 'product.category'
+    accounting = fields.Boolean(
+        "Accounting",
+        states={
+            'readonly': Bool(Eval('childs', [0])) | Bool(Eval('parent')),
+            },
+        help="Check to indicate the category is used for accounting.")
+    account_parent = fields.Boolean('Use Parent\'s accounts',
+        states={
+            'invisible': ~Eval('accounting', False),
+            },
+        help="Use the accounts defined on the parent category.")
+    accounts = fields.One2Many(
+        'product.category.account', 'category', "Accounts")
+    account_expense = fields.MultiValue(fields.Many2One('account.account',
+            'Account Expense', domain=[
+                ('closed', '!=', True),
+                ('type.expense', '=', True),
+                ('company', '=', Eval('context', {}).get('company', -1)),
+                ],
+            states={
+                'invisible': (~Eval('context', {}).get('company')
+                    | Eval('account_parent')
+                    | ~Eval('accounting', False)),
+                }))
+    account_revenue = fields.MultiValue(fields.Many2One('account.account',
+            'Account Revenue', domain=[
+                ('closed', '!=', True),
+                ('type.revenue', '=', True),
+                ('company', '=', Eval('context', {}).get('company', -1)),
+                ],
+            states={
+                'invisible': (~Eval('context', {}).get('company')
+                    | Eval('account_parent')
+                    | ~Eval('accounting', False)),
+                }))
+    taxes_parent = fields.Boolean('Use the Parent\'s Taxes',
+        states={
+            'invisible': ~Eval('accounting', False),
+            },
+        help="Use the taxes defined on the parent category.")
+    customer_taxes = fields.Many2Many('product.category-customer-account.tax',
+        'category', 'tax', 'Customer Taxes',
+        order=[('tax.sequence', 'ASC'), ('tax.id', 'ASC')],
+        domain=[('parent', '=', None), ['OR',
+                ('group', '=', None),
+                ('group.kind', 'in', ['sale', 'both'])],
+            ],
+        states={
+            'invisible': (~Eval('context', {}).get('company')
+                | Eval('taxes_parent')
+                | ~Eval('accounting', False)),
+            },
+        help="The taxes to apply when selling products of this category.")
+    supplier_taxes = fields.Many2Many('product.category-supplier-account.tax',
+        'category', 'tax', 'Supplier Taxes',
+        order=[('tax.sequence', 'ASC'), ('tax.id', 'ASC')],
+        domain=[('parent', '=', None), ['OR',
+                ('group', '=', None),
+                ('group.kind', 'in', ['purchase', 'both'])],
+            ],
+        states={
+            'invisible': (~Eval('context', {}).get('company')
+                | Eval('taxes_parent')
+                | ~Eval('accounting', False)),
+            },
+        help="The taxes to apply when purchasing products of this category.")
+    supplier_taxes_deductible_rate = fields.Numeric(
+        "Supplier Taxes Deductible Rate", digits=(None, 10),
+        domain=[
+            ('supplier_taxes_deductible_rate', '>=', 0),
+            ('supplier_taxes_deductible_rate', '<=', 1),
+            ],
+        states={
+            'invisible': (
+                Eval('taxes_parent') | ~Eval('accounting', False)),
+            })
+    customer_taxes_used = fields.Function(fields.Many2Many(
+            'account.tax', None, None, "Customer Taxes Used"), 'get_taxes')
+    supplier_taxes_used = fields.Function(fields.Many2Many(
+            'account.tax', None, None, "Supplier Taxes Used"), 'get_taxes')
+
+    accounting_templates = fields.One2Many(
+        'product.template', 'account_category', "Accounting Products",
+        states={
+            'invisible': ~Eval('accounting', False),
+            },
+        help="The products for which the accounting category applies.")
+
+    @classmethod
+    def __setup__(cls):
+        super().__setup__()
+        cls.parent.domain = [
+            ('accounting', '=', Eval('accounting', False)),
+            cls.parent.domain or []]
+        cls.parent.states['required'] = Or(
+            cls.parent.states.get('required', False),
+            Eval('account_parent', False) | Eval('taxes_parent', False))
+
+    @classmethod
+    def multivalue_model(cls, field):
+        pool = Pool()
+        if field in {'account_expense', 'account_revenue'}:
+            return pool.get('product.category.account')
+        return super().multivalue_model(field)
+
+    @classmethod
+    def default_accounting(cls):
+        return False
+
+    @classmethod
+    def default_account_expense(cls, **pattern):
+        pool = Pool()
+        Configuration = pool.get('account.configuration')
+        config = Configuration(1)
+        account = config.get_multivalue(
+            'default_category_account_expense', **pattern)
+        return account.id if account else None
+
+    @classmethod
+    def default_account_revenue(cls, **pattern):
+        pool = Pool()
+        Configuration = pool.get('account.configuration')
+        config = Configuration(1)
+        account = config.get_multivalue(
+            'default_category_account_revenue', **pattern)
+        return account.id if account else None
+
+    @classmethod
+    def default_supplier_taxes_deductible_rate(cls):
+        return 1
+
+    def get_account(self, name, **pattern):
+        if self.account_parent:
+            return self.parent.get_account(name, **pattern)
+        else:
+            transaction = Transaction()
+            with transaction.reset_context(), \
+                    transaction.set_context(self._context):
+                return self.get_multivalue(name[:-5], **pattern)
+
+    def get_taxes(self, name):
+        company = Transaction().context.get('company')
+        if self.taxes_parent:
+            return [x.id for x in getattr(self.parent, name)]
+        else:
+            return [x.id for x in getattr(self, name[:-5])
+                if x.company.id == company]
+
+    @fields.depends('parent', '_parent_parent.accounting', 'accounting')
+    def on_change_with_accounting(self):
+        if self.parent:
+            return self.parent.accounting
+        return self.accounting
+
+    @fields.depends(
+        'accounting',
+        'account_parent', 'account_expense', 'account_revenue',
+        'taxes_parent', 'customer_taxes', 'supplier_taxes')
+    def on_change_accounting(self):
+        if not self.accounting:
+            self.account_parent = None
+            self.account_expense = None
+            self.account_revenue = None
+            self.taxes_parent = None
+            self.customer_taxes = None
+            self.supplier_taxes = None
+
+    @fields.depends('account_expense', 'supplier_taxes')
+    def on_change_account_expense(self):
+        if self.account_expense:
+            self.supplier_taxes = self.account_expense.taxes
+        else:
+            self.supplier_taxes = []
+
+    @fields.depends('account_revenue', 'customer_taxes')
+    def on_change_account_revenue(self):
+        if self.account_revenue:
+            self.customer_taxes = self.account_revenue.taxes
+        else:
+            self.customer_taxes = []
+
+    @classmethod
+    def view_attributes(cls):
+        return super().view_attributes() + [
+            ('/form/notebook/page[@id="accounting"]', 'states', {
+                    'invisible': ~Eval('accounting', False),
+                    }),
+            ]
+
+    @property
+    @account_used('account_expense')
+    def account_expense_used(self):
+        pass
+
+    @property
+    @account_used('account_revenue')
+    def account_revenue_used(self):
+        pass
+
+    @property
+    def supplier_taxes_deductible_rate_used(self):
+        if self.taxes_parent:
+            return self.parent.supplier_taxes_deductible_rate_used
+        else:
+            return self.supplier_taxes_deductible_rate
+
+
+class CategoryAccount(ModelSQL, CompanyValueMixin):
+    __name__ = 'product.category.account'
+    category = fields.Many2One(
+        'product.category', "Category", ondelete='CASCADE',
+        context={
+            'company': Eval('company', -1),
+            },
+        depends={'company'})
+    account_expense = fields.Many2One(
+        'account.account', "Account Expense",
+        domain=[
+            ('type.expense', '=', True),
+            ('company', '=', Eval('company', -1)),
+            ])
+    account_revenue = fields.Many2One(
+        'account.account', "Account Revenue",
+        domain=[
+            ('type.revenue', '=', True),
+            ('company', '=', Eval('company', -1)),
+            ])
+
+
+class CategoryCustomerTax(ModelSQL):
+    __name__ = 'product.category-customer-account.tax'
+    category = fields.Many2One(
+        'product.category', "Category", ondelete='CASCADE', required=True)
+    tax = fields.Many2One('account.tax', 'Tax', ondelete='RESTRICT',
+            required=True)
+
+    @classmethod
+    def __setup__(cls):
+        super().__setup__()
+        cls.__access__.add('tax')
+
+    @classmethod
+    def __register__(cls, module):
+        # Migration from 7.0: rename to standard name
+        backend.TableHandler.table_rename(
+            'product_category_customer_taxes_rel', cls._table)
+        super().__register__(module)
+
+
+class CategorySupplierTax(ModelSQL):
+    __name__ = 'product.category-supplier-account.tax'
+    category = fields.Many2One(
+        'product.category', "Category", ondelete='CASCADE', required=True)
+    tax = fields.Many2One('account.tax', 'Tax', ondelete='RESTRICT',
+            required=True)
+
+    @classmethod
+    def __setup__(cls):
+        super().__setup__()
+        cls.__access__.add('tax')
+
+    @classmethod
+    def __register__(cls, module):
+        # Migration from 7.0: rename to standard name
+        backend.TableHandler.table_rename(
+            'product_category_supplier_taxes_rel', cls._table)
+        super().__register__(module)
+
+
+class Template(CompanyMultiValueMixin, metaclass=PoolMeta):
+    __name__ = 'product.template'
+    account_category = fields.Many2One('product.category', 'Account Category',
+        domain=[
+            ('accounting', '=', True),
+            ])
+
+    @fields.depends('account_category')
+    def get_account(self, name, **pattern):
+        if self.account_category:
+            return self.account_category.get_account(name, **pattern)
+
+    @fields.depends('account_category')
+    def get_taxes(self, name):
+        if self.account_category:
+            return getattr(self.account_category, name)
+
+    @property
+    @fields.depends('account_category', methods=['get_account'])
+    @account_used('account_expense', 'account_category')
+    def account_expense_used(self):
+        pass
+
+    @property
+    @fields.depends('account_category', methods=['get_account'])
+    @account_used('account_revenue', 'account_category')
+    def account_revenue_used(self):
+        pass
+
+    @property
+    @fields.depends(methods=['get_taxes', 'account_revenue_used'])
+    def customer_taxes_used(self):
+        taxes = self.get_taxes('customer_taxes_used')
+        if taxes is None:
+            account = self.account_revenue_used
+            if account:
+                taxes = account.taxes
+        if taxes is None:
+            # Allow empty values on on_change
+            if Transaction().readonly:
+                taxes = []
+            else:
+                raise TaxError(
+                    gettext('account_product.msg_missing_taxes',
+                        name=self.rec_name))
+        return taxes
+
+    @property
+    @fields.depends(methods=['get_taxes', 'account_expense_used'])
+    def supplier_taxes_used(self):
+        taxes = self.get_taxes('supplier_taxes_used')
+        if taxes is None:
+            account = self.account_expense_used
+            if account:
+                taxes = account.taxes
+        if taxes is None:
+            # Allow empty values on on_change
+            if Transaction().readonly:
+                taxes = []
+            else:
+                raise TaxError(
+                    gettext('account_product.msg_missing_taxes',
+                        name=self.rec_name))
+        return taxes
+
+    @property
+    @fields.depends(methods=['get_taxes'])
+    def supplier_taxes_deductible_rate_used(self):
+        return self.get_taxes('supplier_taxes_deductible_rate_used')
+
+    @classmethod
+    def copy(cls, templates, default=None):
+        default = default.copy() if default else {}
+        if Transaction().check_access:
+            default.setdefault(
+                'account_category',
+                cls.default_get(
+                    ['account_category'],
+                    with_rec_name=False).get('account_category'))
+        return super().copy(templates, default=default)
+
+
+class Product(metaclass=PoolMeta):
+    __name__ = 'product.product'
+    account_expense_used = template_property('account_expense_used')
+    account_revenue_used = template_property('account_revenue_used')
+    customer_taxes_used = template_property('customer_taxes_used')
+    supplier_taxes_used = template_property('supplier_taxes_used')
+    supplier_taxes_deductible_rate_used = template_property(
+        'supplier_taxes_deductible_rate_used')
+
+
+class TemplateAccountCategory(ModelSQL):
+    __name__ = 'product.template-product.category.account'
+    template = fields.Many2One('product.template', 'Template')
+    category = fields.Many2One('product.category', 'Category')
+
+    @classmethod
+    def table_query(cls):
+        pool = Pool()
+        Template = pool.get('product.template')
+        template = Template.__table__()
+        return template.select(
+            template.id.as_('id'),
+            template.id.as_('template'),
+            template.account_category.as_('category'),
+            where=template.account_category != Null)
+
+
+class TemplateCategoryAll(metaclass=PoolMeta):
+    __name__ = 'product.template-product.category.all'
+
+    @classmethod
+    def union_models(cls):
+        return super().union_models() + [
+            'product.template-product.category.account']