cashbook/category.py

# -*- coding: utf-8 -*-
# This file is part of the cashbook-module from m-ds for Tryton.
# The COPYRIGHT file at the top level of this repository contains the
# full copyright notices and license terms.

from trytond.model import ModelView, ModelSQL, fields, Unique, Exclude, tree, sequence_ordered
from trytond.transaction import Transaction
from trytond.pool import Pool
from trytond.pyson import Eval, If, Bool
from trytond.exceptions import UserError
from trytond.i18n import gettext
from sql.operators import Equal
from sql import With


sel_categorytype = [
    ('in', 'Revenue'),
    ('out', 'Expense'),
    ]


class Category(tree(separator='/'), sequence_ordered(), ModelSQL, ModelView):
    'Category'
    __name__ = 'cashbook.category'

    name = fields.Char(string='Name', required=True, translate=True)
    description = fields.Char(string='Description', translate=True)
    cattype = fields.Selection(string='Type', required=True,
        help='Type of Category', selection=sel_categorytype,
        states={'readonly': Bool(Eval('parent_cattype'))},
        domain=[If(Bool(Eval('parent_cattype')),
                ('cattype', '=', Eval('parent_cattype', '')),
                ())],
        depends=['parent_cattype'])
    parent_cattype = fields.Function(fields.Char(string='Parent Category Type',
        readonly=True, states={'invisible': True}),
        'on_change_with_parent_cattype')

    company = fields.Many2One(string='Company', model_name='company.company',
        required=True, ondelete="RESTRICT")
    sequence = fields.Integer(string='Sequence', select=True)
    parent = fields.Many2One(string="Parent",
        model_name='cashbook.category', ondelete='RESTRICT',
        left='left', right='right')
    childs = fields.One2Many(string='Children', field='parent',
        model_name='cashbook.category')
    left = fields.Integer(string='Left', required=True, select=True)
    right = fields.Integer(string='Right', required=True, select=True)

    @classmethod
    def __setup__(cls):
        super(Category, cls).__setup__()
        cls._order.insert(0, ('name', 'ASC'))
        t = cls.__table__()
        cls._sql_constraints.extend([
                ('name_uniq',
                    Unique(t, t.name, t.company, t.parent),
                    'cashbook.msg_category_name_unique'),
                ('name2_uniq',
                    Exclude(t,
                        (t.name, Equal),
                        (t.cattype, Equal),
                        where=(t.parent == None)),
                    'cashbook.msg_category_name_unique'),
            ])

    @classmethod
    def default_cattype(cls):
        return 'out'

    @staticmethod
    def default_company():
        return Transaction().context.get('company') or None

    @staticmethod
    def default_left():
        return 0

    @staticmethod
    def default_right():
        return 0

    @staticmethod
    def order_rec_name(tables):
        """ order by pos
        """
        Category2 = Pool().get('cashbook.category')
        tab_cat = Category2.__table__()
        table, _ = tables[None]

        categories = With('id', 'name', 'name_path', recursive=True)
        categories.query = select(tab_cat.id, tab_cat.name, array[])

# ~ with recursive categories (id, level, name, name_path) as (
    # ~ select "a"."id", 0, "a"."name", array["a"."name"]
    # ~ from cashbook_category as "a"
    # ~ where "a"."parent" is null

    # ~ union all

    # ~ select "b"."id", "c"."level" + 1, "b"."name", array_append("c"."name_path", "b"."name")
    # ~ from cashbook_category as "b"
    # ~ inner join categories as "c" on "c"."id" = "b"."parent"
# ~ )
# ~ select "d"."id", array_to_string("d"."name_path", '/') as "rec_name"
# ~ from categories as "d"
# ~ order by  "rec_name"

    @fields.depends('parent', '_parent_parent.cattype')
    def on_change_with_parent_cattype(self, name=None):
        """ get type of parent category or None
        """
        if self.parent:
            return self.parent.cattype

    @classmethod
    def check_category_hierarchy(cls, categories):
        """ check if current category-type is equal to parent
        """
        for category in categories:
            if category.parent:
                if category.parent.cattype != category.cattype:
                    raise UserError(gettext(
                        'cashbook.msg_category_type_not_like_parent',
                        parentname = category.parent.rec_name,
                        catname = category.rec_name,
                        ))

    @classmethod
    def create(cls, vlist):
        """ add debit/credit
        """
        records = super(Category, cls).create(vlist)
        cls.check_category_hierarchy(records)
        return records

    @classmethod
    def write(cls, *args):
        """ parent.cattape == cattype,
            update sub-categories
        """
        Category2 = Pool().get('cashbook.category')

        actions = iter(args)
        to_check = []
        to_write = []
        to_write2 = []
        for categories, values in zip(actions, actions):
            to_write2.extend([categories, values])

            if 'cattype' in values.keys():
                # update sub-categories
                cats = Category2.search([
                    ('parent', 'child_of', [x.id for x in categories]),
                    ])
                if len(cats) > 0:
                    to_write.extend([
                        cats,
                        {
                            'cattype': values['cattype'],
                        }])
                to_check.extend(categories)
                to_check.extend(cats)

        # add category-updates after regulary writes
        to_write2.extend(to_write)
        super(Category, cls).write(*to_write2)
        cls.check_category_hierarchy(to_check)

# end Category