cashbook_investment/line.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 decimal import Decimal
from trytond.model import fields
from trytond.pool import PoolMeta, Pool
from trytond.pyson import Eval, Or, If
from trytond.exceptions import UserError
from trytond.i18n import gettext
from trytond.modules.cashbook.line import STATES, DEPENDS
from .mixin import SecondUomMixin

STATESQ = {
    'required': Eval('feature', '') == 'asset',
    'invisible': Eval('feature', '') != 'asset',
    'readonly': Or(
        STATES['readonly'],
        Eval('bookingtype', '').in_(['spin', 'spout']),
        ),
    }
DEPENDSQ = DEPENDS+['feature', 'quantity_digits', 'bookingtype']


class Line(SecondUomMixin, metaclass=PoolMeta):
    __name__ = 'cashbook.line'

    quantity = fields.Numeric(string='Quantity',
        digits=(16, Eval('quantity_digits', 4)),
        states=STATESQ, depends=DEPENDSQ)
    quantity_credit = fields.Numeric(string='Quantity Credit',
        digits=(16, Eval('quantity_digits', 4)), readonly=True,
        states={
            'invisible': STATESQ['invisible'],
            'required': STATESQ['required'],
        }, depends=DEPENDSQ)
    quantity_debit = fields.Numeric(string='Quantity Debit',
        digits=(16, Eval('quantity_digits', 4)), readonly=True,
        states={
            'invisible': STATESQ['invisible'],
            'required': STATESQ['required'],
        }, depends=DEPENDSQ)

    quantity_digits = fields.Function(fields.Integer(string='Digits',
        readonly=True, states={'invisible': True}),
        'on_change_with_quantity_digits')
    quantity_uom = fields.Function(fields.Many2One(string='Symbol',
        readonly=True, model_name='product.uom'),
        'on_change_with_quantity_uom')
    asset_rate = fields.Function(fields.Numeric(string='Rate',
        readonly=True,
        digits=(16, If(
            Eval('currency_digits', 2) > Eval('quantity_digits', 2),
            Eval('currency_digits', 2), Eval('quantity_digits', 2))),
        states={
            'invisible': Eval('feature', '') != 'asset',
        }, depends=['currency_digits', 'quantity_digits', 'feature']),
        'on_change_with_asset_rate')
    quantity_balance = fields.Function(fields.Numeric(string='Quantity',
        digits=(16, Eval('quantity_digits', 4)), readonly=True,
        help='Number of shares in the cashbook up to the current row if the default sort applies.',
        states={
            'invisible': Eval('feature', '') != 'asset',
        }, depends=['quantity_digits', 'feature']),
        'on_change_with_quantity_balance')

    @classmethod
    def get_debit_credit(cls, values, line=None):
        """ compute quantity_debit/quantity_credit from quantity
        """
        Cashbook = Pool().get('cashbook.book')

        result = super(Line, cls).get_debit_credit(values, line)
        if line:
            cashbook = line.cashbook
        else:
            id_cashbook = values.get('cashbook', None)
            cashbook = None
            if id_cashbook:
                cashbook = Cashbook.browse([id_cashbook])[0]

        if isinstance(values, dict):
            type_ = values.get('bookingtype', None)
            quantity = values.get('quantity', None)
        else :
            type_ = getattr(values, 'bookingtype', None)
            quantity = getattr(values, 'quantity', None)

        if (type_ is not None) and (cashbook.feature == 'asset'):
            if quantity is not None:
                if type_ in ['in', 'mvin', 'spin']:
                    result.update({
                        'quantity_debit': Decimal('0.0'),
                        'quantity_credit': quantity,
                        })
                elif type_ in ['out', 'mvout', 'spout']:
                    result.update({
                        'quantity_debit': quantity,
                        'quantity_credit': Decimal('0.0'),
                        })
                else :
                    raise ValueError('invalid "bookingtype"')
        return result

    @classmethod
    def get_counterpart_values(cls, line, values={}):
        """ add quantity to counterpart
        """
        result = super(Line, cls).get_counterpart_values(line, values)

        line_uom = getattr(line.quantity_uom, 'id', None)
        booktransf_uom = getattr(getattr(line.booktransf, 'quantity_uom', {}), 'id', None)

        if booktransf_uom is None:
            # counterpart-cashbook has no uom -> no quantity
            result.update({
                'quantity': None,
                'quantity_2nd_uom': None,
                })
        else :
            if line_uom is None:
                result.update({
                    'quantity': line.quantity,
                    'quantity_2nd_uom': None,
                    })
            elif line_uom == booktransf_uom:
                result.update({
                    'quantity': line.quantity,
                    'quantity_2nd_uom': None,
                    })
            else :
                result.update({
                    'quantity': line.quantity_2nd_uom,
                    'quantity_2nd_uom': line.quantity,
                    })
        return result

    @fields.depends('id', 'date', 'cashbook', 'feature',\
        '_parent_cashbook.id', 'reconciliation', \
        '_parent_reconciliation.start_quantity',\
        '_parent_reconciliation.state')
    def on_change_with_quantity_balance(self, name=None):
        """ get quantity-balance
        """
        Line2 = Pool().get('cashbook.line')

        if self.feature == 'asset':
            return Line2.get_balance_of_line(self,
                field_name='quantity',
                credit_name='quantity_credit',
                debit_name='quantity_debit')

    @fields.depends('quantity', 'amount', 'currency_digits', 'quantity_digits')
    def on_change_with_asset_rate(self, name=None):
        """ get rate
        """
        if (self.quantity is None) or (self.amount is None):
            return
        digit = max(
            self.currency_digits if self.currency_digits is not None else 2,
            self.quantity_digits if self.quantity_digits is not None else 4)
        if self.quantity != Decimal('0.0'):
            return (
                    self.amount / self.quantity
                ).quantize(Decimal(Decimal(1) / 10**digit))

    @fields.depends('cashbook', '_parent_cashbook.quantity_uom')
    def on_change_with_quantity_uom(self, name=None):
        """ get quantity-unit of asset
        """
        if self.cashbook:
            if self.cashbook.quantity_uom:
                return self.cashbook.quantity_uom.id

    @fields.depends('cashbook', '_parent_cashbook.quantity_digits')
    def on_change_with_quantity_digits(self, name=None):
        """ get digits from cashbook
        """
        if self.cashbook:
            return self.cashbook.quantity_digits
        return 4

    @classmethod
    def validate(cls, lines):
        """ deny pos/neg mismatch
        """
        super(Line, cls).validate(lines)

        for line in lines:
            # ignore non-asset-lines
            if line.cashbook.feature != 'asset':
                continue

            # quantity must be set
            if (line.quantity is None) or \
                (line.quantity_credit is None) or \
                (line.quantity_debit is None):
                raise UserError(gettext(
                    'cashbook_investment.msg_line_quantity_not_set',
                    linetxt = line.rec_name,
                    ))

            # quantity and amount must with same sign
            (amount_sign, a_dig, a_exp) = line.amount.as_tuple()
            (quantity_sign, q_dig, q_exp) = line.quantity.as_tuple()
            if amount_sign != quantity_sign:
                raise UserError(gettext(
                    'cashbook_investment.msg_line_sign_mismatch',
                    linetxt = line.rec_name,
                    ))

    @classmethod
    def add_2nd_unit_values(cls, values):
        """ extend create-values
        """
        Cashbook = Pool().get('cashbook.book')

        values = super(Line, cls).add_2nd_unit_values(values)
        cashbook = values.get('cashbook', None)

        if cashbook:
            values.update(cls.add_2nd_quantity(values, Cashbook(cashbook).quantity_uom))
        return values

    @classmethod
    def write(cls, *args):
        """ add or update quanity_debit/credit
        """
        actions = iter(args)
        to_write = []
        for lines, values in zip(actions, actions):
            # update debit / credit
            if len(set(values.keys()).intersection(set({'quantity', 'bookingtype'}))) > 0:
                for line in lines:
                    values2 = {}
                    values2.update(values)
                    values2.update(cls.get_debit_credit({
                            x:values.get(x, getattr(line, x)) for x in ['quantity', 'bookingtype']
                        }, line=line))
                    to_write.extend([lines, values2])
            else :
                to_write.extend([lines, values])
        super(Line, cls).write(*to_write)

# end Line