# -*- 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.tests.test_tryton import ModuleTestCase, with_transaction
from trytond.pool import Pool
from trytond.transaction import Transaction
from trytond.exceptions import UserError
from trytond.modules.cashbook.tests import CashbookTestCase
from datetime import date
from decimal import Decimal


class ReportTestCase(CashbookTestCase):
    'Test cashbook book report module'
    module = 'cashbook_report'

    def prep_report_3books(self):
        """ create 3x cashbooks, add bookings,
        """
        pool = Pool()
        Book = pool.get('cashbook.book')
        ResUser = pool.get('res.user')

        user_admin, = ResUser.search([])
        type_cash = self.prep_type()
        type_bank = self.prep_type(name='Bank', short='BK')
        company = self.prep_company()

        ResUser.write(*[
            [user_admin],
            {
                'companies': [('add', [company.id])],
                'company': company.id,
            }])
        self.assertEqual(user_admin.company.id, company.id)

        (usd, euro) = self.prep_2nd_currency(company)
        sequ_id = self.prep_sequence().id
        category = self.prep_category(cattype='in')
        party = self.prep_party()
        books = Book.create([{
            'name': 'Book 1',
            'btype': type_cash.id,
            'company': company.id,
            'currency': usd.id,
            'number_sequ': sequ_id,
            'start_date': date(2022, 4, 1),
            'lines': [('create', [{
                    'date': date(2022, 5, 5),
                    'description': 'Income 1a',
                    'bookingtype': 'in',
                    'amount': Decimal('10.0'),
                    'category': category.id,
                    'party': party.id,
                }, {
                    'date': date(2022, 5, 5),
                    'description': 'Income 1b',
                    'bookingtype': 'in',
                    'amount': Decimal('15.0'),
                    'category': category.id,
                    'party': party.id,
                }])],
            }, {
            'name': 'Book 2',
            'btype': type_cash.id,
            'company': company.id,
            'currency': usd.id,
            'number_sequ': sequ_id,
            'start_date': date(2022, 4, 1),
            'lines': [('create', [{
                    'date': date(2022, 5, 5),
                    'description': 'Income 2a',
                    'bookingtype': 'in',
                    'amount': Decimal('5.0'),
                    'category': category.id,
                    'party': party.id,
                }, {
                    'date': date(2022, 5, 5),
                    'description': 'Income 2b',
                    'bookingtype': 'in',
                    'amount': Decimal('7.5'),
                    'category': category.id,
                    'party': party.id,
                }])],
            }, {
            'name': 'Book 3',
            'btype': type_bank.id,
            'company': company.id,
            'currency': euro.id,
            'number_sequ': sequ_id,
            'start_date': date(2022, 4, 1),
            'lines': [('create', [{
                    'date': date(2022, 5, 5),
                    'description': 'Income 3a',
                    'bookingtype': 'in',
                    'amount': Decimal('12.5'),
                    'category': category.id,
                    'party': party.id,
                }, {
                    'date': date(2022, 5, 5),
                    'description': 'Income 3b',
                    'bookingtype': 'in',
                    'amount': Decimal('10.5'),
                    'category': category.id,
                    'party': party.id,
                }])],
            }])
        self.assertEqual(len(books), 3)
        self.assertEqual(books[0].name, 'Book 1')
        self.assertEqual(books[0].btype.rec_name, 'CAS - Cash')
        self.assertEqual(len(books[0].lines), 2)
        self.assertEqual(books[0].balance, Decimal('25.0'))

        self.assertEqual(books[1].name, 'Book 2')
        self.assertEqual(books[1].btype.rec_name, 'CAS - Cash')
        self.assertEqual(len(books[1].lines), 2)
        self.assertEqual(books[1].balance, Decimal('12.5'))

        self.assertEqual(books[2].name, 'Book 3')
        self.assertEqual(books[2].btype.rec_name, 'BK - Bank')
        self.assertEqual(len(books[2].lines), 2)
        self.assertEqual(books[2].balance, Decimal('23.0'))
        return books

    @with_transaction()
    def test_report_currency_hasbookings(self):
        """ check detectpn of bookings @ currency
        """
        pool = Pool()
        Currency = pool.get('currency.currency')
        Lines = pool.get('cashbook.line')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            self.assertEqual(len(books[0].lines), 2)
            self.assertEqual(books[0].currency.code, 'usd')
            self.assertEqual(len(books[1].lines), 2)
            self.assertEqual(books[1].currency.code, 'usd')
            self.assertEqual(len(books[2].lines), 2)
            self.assertEqual(books[2].currency.code, 'EUR')

            euro, = Currency.search([('code', '=', 'EUR')])
            self.assertEqual(euro.cashbook_hasbookings, True)
            self.assertEqual(Currency.search_count([
                ('cashbook_hasbookings', '=', True)
                ]), 2)

            Lines.delete(books[2].lines)
            self.assertEqual(euro.cashbook_hasbookings, False)

            self.assertEqual(Currency.search_count([
                ('cashbook_hasbookings', '=', True)
                ]), 1)

            usd, = Currency.search([('code', '=', 'usd')])
            self.assertEqual(usd.cashbook_hasbookings, True)

            Lines.delete(books[0].lines)
            self.assertEqual(usd.cashbook_hasbookings, True)
            Lines.delete(books[1].lines)
            self.assertEqual(usd.cashbook_hasbookings, False)

            self.assertEqual(Currency.search_count([
                ('cashbook_hasbookings', '=', True)
                ]), 0)

    @with_transaction()
    def test_report_check_limited_access(self):
        """ check query of cashbook-lines selected by
            cashbook-type, limited by user-permissions
        """
        pool = Pool()
        ResUser = pool.get('res.user')
        ResGroup = pool.get('res.group')
        ModelData = pool.get('ir.model.data')
        Currency = pool.get('currency.currency')
        Evaluation = pool.get('cashbook_report.evaluation')
        Type = pool.get('cashbook.type')
        Cashbook = pool.get('cashbook.book')
        Line = pool.get('cashbook_report.eval_line')

        books = self.prep_report_3books()
        company = self.prep_company()

        # add 2x user, set owner of cashbooks to them
        group_cashbook = ResGroup(ModelData.get_id('cashbook', 'group_cashbook'))
        users = ResUser.create([{
            'name': 'User 1',
            'login': 'user1',
            'password': 'test1234',
            'groups': [('add', [group_cashbook.id])],
            'company': company.id,
            'companies': [('add', [company.id])],
            }, {
            'name': 'User 2',
            'login': 'user2',
            'password': 'test1234',
            'groups': [('add', [group_cashbook.id])],
            'company': company.id,
            'companies': [('add', [company.id])],
            }])

        Cashbook.write(*[
            [books[0], books[1]],
            {
                'owner': users[0].id,
            },
            [books[2]],
            {
                'owner': users[1].id,
            },
            ])

        # check access to data
        with Transaction().set_user(users[0].id):
            with Transaction().set_context({
                '_check_access': True,
                'company': company.id,
                }):
                books_owner1 = Cashbook.search([])
                self.assertEqual(len(books_owner1), 2)
                self.assertEqual(books_owner1[0].name, 'Book 1')
                self.assertEqual(books_owner1[0].balance, Decimal('25.0'))
                self.assertEqual(books_owner1[1].name, 'Book 2')
                self.assertEqual(books_owner1[1].balance, Decimal('12.5'))

                # add category to cashbook
                Cashbook.write(*[
                    [books_owner1[0]],
                    {
                        'categories': [('create', [{
                            'name': 'Book 1, User 1'
                            }])],
                    }])

                evaluation1, = Evaluation.create([{
                    'name': 'Evaluation User 1 - Cashbooks',
                    'dtype': 'cashbooks',
                    'cashbooks': [('add', [x.id for x in books_owner1])],
                    }])
                self.assertEqual(len(evaluation1.cashbooks), 2)
                self.assertEqual(evaluation1.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation1.line_values), 2)
                self.assertEqual(evaluation1.line_values[0].name, 'Book 1 | 25.00 usd | Open')
                self.assertEqual(evaluation1.line_values[0].balance, Decimal('23.81'))
                self.assertEqual(evaluation1.line_values[1].name, 'Book 2 | 12.50 usd | Open')
                self.assertEqual(evaluation1.line_values[1].balance, Decimal('11.9'))

                evaluation2, = Evaluation.create([{
                    'name': 'Evaluation User 1 - Types',
                    'dtype': 'types',
                    'types': [('add', [x.id for x in Type.search([])])],
                    }])
                self.assertEqual(len(evaluation2.types), 2)
                self.assertEqual(evaluation2.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation2.line_values), 2)
                self.assertEqual(evaluation2.line_values[0].name, 'BK - Bank')
                self.assertEqual(evaluation2.line_values[0].balance, Decimal('0.0'))
                self.assertEqual(evaluation2.line_values[1].name, 'CAS - Cash')
                self.assertEqual(evaluation2.line_values[1].balance, Decimal('35.71'))

                evaluation3, = Evaluation.create([{
                    'name': 'Evaluation User 1 - Currencies',
                    'dtype': 'currencies',
                    'currencies': [('add', [x.id for x in Currency.search([])])],
                    }])
                self.assertEqual(len(evaluation3.currencies), 2)
                self.assertEqual(evaluation3.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation3.line_values), 2)
                self.assertEqual(evaluation3.line_values[0].name, 'Euro')
                self.assertEqual(evaluation3.line_values[0].balance, Decimal('0.0'))
                self.assertEqual(evaluation3.line_values[1].name, 'usd')
                self.assertEqual(evaluation3.line_values[1].balance, Decimal('35.71'))

                evaluation4, = Evaluation.create([{
                    'name': 'Evaluation User 1 - Categories',
                    'dtype': 'categories',
                    'categories': [('add', [x.id for x in books_owner1[0].categories])],
                    }])
                self.assertEqual(len(evaluation4.categories), 1)
                self.assertEqual(evaluation4.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation4.line_values), 1)
                self.assertEqual(evaluation4.line_values[0].name, 'Book 1, User 1')
                self.assertEqual(evaluation4.line_values[0].balance, Decimal('23.81'))

                self.assertEqual(Evaluation.search_count([]), 4)

        with Transaction().set_user(users[1].id):
            with Transaction().set_context({
                '_check_access': True,
                'company': company.id,
                }):
                books_owner2 = Cashbook.search([])
                self.assertEqual(len(books_owner2), 1)
                self.assertEqual(books_owner2[0].name, 'Book 3')

                # add category to cashbook
                Cashbook.write(*[
                    [books_owner2[0]],
                    {
                        'categories': [('create', [{
                            'name': 'Book 3, User 2'
                            }])],
                    }])

                evaluation1, = Evaluation.create([{
                    'name': 'Evaluation User 2 - Cashbooks',
                    'dtype': 'cashbooks',
                    'cashbooks': [('add', [x.id for x in books_owner2])],
                    }])
                self.assertEqual(len(evaluation1.cashbooks), 1)
                self.assertEqual(evaluation1.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation1.line_values), 1)
                self.assertEqual(evaluation1.line_values[0].name, 'Book 3 | 23.00 € | Open')
                self.assertEqual(evaluation1.line_values[0].balance, Decimal('23.0'))

                evaluation2, = Evaluation.create([{
                    'name': 'Evaluation User 2 - Types',
                    'dtype': 'types',
                    'types': [('add', [x.id for x in Type.search([])])],
                    }])
                self.assertEqual(len(evaluation2.types), 2)
                self.assertEqual(evaluation2.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation2.line_values), 2)
                self.assertEqual(evaluation2.line_values[0].name, 'BK - Bank')
                self.assertEqual(evaluation2.line_values[0].balance, Decimal('23.0'))
                self.assertEqual(evaluation2.line_values[1].name, 'CAS - Cash')
                self.assertEqual(evaluation2.line_values[1].balance, Decimal('0.0'))

                evaluation3, = Evaluation.create([{
                    'name': 'Evaluation User 2 - Currencies',
                    'dtype': 'currencies',
                    'currencies': [('add', [x.id for x in Currency.search([])])],
                    }])
                self.assertEqual(len(evaluation3.currencies), 2)
                self.assertEqual(evaluation3.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation3.line_values), 2)
                self.assertEqual(evaluation3.line_values[0].name, 'Euro')
                self.assertEqual(evaluation3.line_values[0].balance, Decimal('23.0'))
                self.assertEqual(evaluation3.line_values[1].name, 'usd')
                self.assertEqual(evaluation3.line_values[1].balance, Decimal('0.0'))

                evaluation4, = Evaluation.create([{
                    'name': 'Evaluation User 2 - Categories',
                    'dtype': 'categories',
                    'categories': [('add', [x.id for x in books_owner2[0].categories])],
                    }])
                self.assertEqual(len(evaluation4.categories), 1)
                self.assertEqual(evaluation4.currency.rec_name, 'Euro')
                self.assertEqual(len(evaluation4.line_values), 1)
                self.assertEqual(evaluation4.line_values[0].name, 'Book 3, User 2')
                self.assertEqual(evaluation4.line_values[0].balance, Decimal('23.0'))

                self.assertEqual(Evaluation.search_count([]), 4)

        # outside of context
        # we should have access to all 8 evaluations
        evaluations = Evaluation.search([], order=[('name', 'ASC')])
        self.assertEqual(len(evaluations), 8)

        self.assertEqual(evaluations[0].name, 'Evaluation User 1 - Cashbooks')
        self.assertEqual(len(evaluations[0].cashbooks), 2)
        self.assertEqual(evaluations[0].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[0].line_values), 2)
        self.assertEqual(evaluations[0].line_values[0].name, 'Book 1 | 25.00 usd | Open')
        self.assertEqual(evaluations[0].line_values[0].balance, Decimal('23.81'))
        self.assertEqual(evaluations[0].line_values[1].name, 'Book 2 | 12.50 usd | Open')
        self.assertEqual(evaluations[0].line_values[1].balance, Decimal('11.9'))

        self.assertEqual(evaluations[1].name, 'Evaluation User 1 - Categories')
        self.assertEqual(len(evaluations[1].categories), 1)
        self.assertEqual(evaluations[1].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[1].line_values), 1)
        self.assertEqual(evaluations[1].line_values[0].name, 'Book 1, User 1')
        self.assertEqual(evaluations[1].line_values[0].balance, Decimal('23.81'))

        self.assertEqual(evaluations[2].name, 'Evaluation User 1 - Currencies')
        self.assertEqual(len(evaluations[2].currencies), 2)
        self.assertEqual(evaluations[2].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[2].line_values), 2)
        self.assertEqual(evaluations[2].line_values[0].name, 'Euro')
        self.assertEqual(evaluations[2].line_values[0].balance, Decimal('23.0'))
        self.assertEqual(evaluations[2].line_values[1].name, 'usd')
        self.assertEqual(evaluations[2].line_values[1].balance, Decimal('35.71'))

        self.assertEqual(evaluations[3].name, 'Evaluation User 1 - Types')
        self.assertEqual(len(evaluations[3].types), 2)
        self.assertEqual(evaluations[3].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[3].line_values), 2)
        self.assertEqual(evaluations[3].line_values[0].name, 'BK - Bank')
        self.assertEqual(evaluations[3].line_values[0].balance, Decimal('23.0'))
        self.assertEqual(evaluations[3].line_values[1].name, 'CAS - Cash')
        self.assertEqual(evaluations[3].line_values[1].balance, Decimal('35.71'))

        self.assertEqual(evaluations[4].name, 'Evaluation User 2 - Cashbooks')
        self.assertEqual(len(evaluations[4].cashbooks), 1)
        self.assertEqual(evaluations[4].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[4].line_values), 1)
        self.assertEqual(evaluations[4].line_values[0].name, 'Book 3 | 23.00 € | Open')
        self.assertEqual(evaluations[4].line_values[0].balance, Decimal('23.0'))

        self.assertEqual(evaluations[5].name, 'Evaluation User 2 - Categories')
        self.assertEqual(len(evaluations[5].categories), 1)
        self.assertEqual(evaluations[5].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[5].line_values), 1)
        self.assertEqual(evaluations[5].line_values[0].name, 'Book 3, User 2')
        self.assertEqual(evaluations[5].line_values[0].balance, Decimal('23.0'))

        self.assertEqual(evaluations[6].name, 'Evaluation User 2 - Currencies')
        self.assertEqual(len(evaluations[6].currencies), 2)
        self.assertEqual(evaluations[6].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[6].line_values), 2)
        self.assertEqual(evaluations[6].line_values[0].name, 'Euro')
        self.assertEqual(evaluations[6].line_values[0].balance, Decimal('23.0'))
        self.assertEqual(evaluations[6].line_values[1].name, 'usd')
        self.assertEqual(evaluations[6].line_values[1].balance, Decimal('35.71'))

        self.assertEqual(evaluations[7].name, 'Evaluation User 2 - Types')
        self.assertEqual(len(evaluations[7].types), 2)
        self.assertEqual(evaluations[7].currency.rec_name, 'Euro')
        self.assertEqual(len(evaluations[7].line_values), 2)
        self.assertEqual(evaluations[7].line_values[0].name, 'BK - Bank')
        self.assertEqual(evaluations[7].line_values[0].balance, Decimal('23.0'))
        self.assertEqual(evaluations[7].line_values[1].name, 'CAS - Cash')
        self.assertEqual(evaluations[7].line_values[1].balance, Decimal('35.71'))

    @with_transaction()
    def test_report_update_name_of_line(self):
        """ check replace rec_name-value on line with
            manually  updates value
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        Line = pool.get('cashbook_report.eval_line')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'dtype': 'cashbooks',
                'cashbooks': [('add', [x.id for x in books])],
                }])
            self.assertEqual(len(evaluation.cashbooks), 3)
            self.assertEqual(len(evaluation.line_values), 3)

            self.assertEqual(evaluation.line_values[0].name, 'Book 1 | 25.00 usd | Open')
            self.assertEqual(evaluation.line_values[0].name_line, None)

            # update 'name'
            Line.write(*[
                [evaluation.line_values[0]],
                {
                    'name': 'Book updated',
                }])
            self.assertEqual(evaluation.line_values[0].name, 'Book updated')
            self.assertEqual(evaluation.line_values[0].name_line, 'Book updated')

            # delete 'name' value to reset to origin
            Line.write(*[
                [evaluation.line_values[0]],
                {
                    'name': None,
                }])
            self.assertEqual(evaluation.line_values[0].name, 'Book 1 | 25.00 usd | Open')
            self.assertEqual(evaluation.line_values[0].name_line, None)

    @with_transaction()
    def test_report_dtype_update(self):
        """ check unlink of cashbooks/types/currencies
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        Types = pool.get('cashbook.type')
        Currency = pool.get('currency.currency')
        Category = pool.get('cashbook.bookcategory')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):

            categories = Category.create([{
                    'name': 'Cat 1',
                }, {
                    'name': 'Cat 2',
                }, {
                    'name': 'Cat 3',
                }])

            # valid
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'dtype': 'cashbooks',
                'cashbooks': [('add', [x.id for x in books])],
                }])
            self.assertEqual(len(evaluation.cashbooks), 3)
            self.assertEqual(len(evaluation.types), 0)
            self.assertEqual(len(evaluation.currencies), 0)
            self.assertEqual(len(evaluation.categories), 0)

            # investment - profit/loss amount
            if 'cashbooks_gldiff' in [x[0] for x in Evaluation.get_sel_etype()]:
                # no change if switch between cashbook-types
                Evaluation.write(*[
                    [evaluation],
                    {
                        'dtype': 'cashbooks_gldiff',
                    }])
                self.assertEqual(len(evaluation.cashbooks), 3)
                self.assertEqual(len(evaluation.types), 0)
                self.assertEqual(len(evaluation.currencies), 0)
                self.assertEqual(len(evaluation.categories), 0)

                Evaluation.write(*[
                    [evaluation],
                    {
                        'dtype': 'cashbooks_glperc',
                    }])
                self.assertEqual(len(evaluation.cashbooks), 3)
                self.assertEqual(len(evaluation.types), 0)
                self.assertEqual(len(evaluation.currencies), 0)
                self.assertEqual(len(evaluation.categories), 0)
            else :
                print('\n--== Module "cashbook_investment" not installed ==--')

            Evaluation.write(*[
                [evaluation],
                {
                    'dtype': 'types',
                    'types': [('add', [x.id for x in Types.search([])])],
                }])
            self.assertEqual(len(evaluation.cashbooks), 0)
            self.assertEqual(len(evaluation.types), 2)
            self.assertEqual(len(evaluation.currencies), 0)
            self.assertEqual(len(evaluation.categories), 0)

            # write same dtype again - no change
            Evaluation.write(*[
                [evaluation],
                {
                    'dtype': 'types',
                }])
            self.assertEqual(len(evaluation.cashbooks), 0)
            self.assertEqual(len(evaluation.types), 2)
            self.assertEqual(len(evaluation.currencies), 0)
            self.assertEqual(len(evaluation.categories), 0)

            Evaluation.write(*[
                [evaluation],
                {
                    'dtype': 'currencies',
                    'currencies': [('add', [x.id for x in Currency.search([])])],
                }])
            self.assertEqual(len(evaluation.cashbooks), 0)
            self.assertEqual(len(evaluation.types), 0)
            self.assertEqual(len(evaluation.currencies), 2)
            self.assertEqual(len(evaluation.categories), 0)

            Evaluation.write(*[
                [evaluation],
                {
                    'dtype': 'categories',
                    'categories': [('add', [x.id for x in Category.search([])])],
                }])
            self.assertEqual(len(evaluation.cashbooks), 0)
            self.assertEqual(len(evaluation.types), 0)
            self.assertEqual(len(evaluation.currencies), 0)
            self.assertEqual(len(evaluation.categories), 3)

            Evaluation.write(*[
                [evaluation],
                {
                    'dtype': 'cashbooks',
                }])
            self.assertEqual(len(evaluation.cashbooks), 0)
            self.assertEqual(len(evaluation.types), 0)
            self.assertEqual(len(evaluation.currencies), 0)
            self.assertEqual(len(evaluation.categories), 0)

    @with_transaction()
    def test_report_dtype_validation(self):
        """ check validation of dtype
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        Types = pool.get('cashbook.type')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            # valid
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'dtype': 'cashbooks',
                'cashbooks': [('add', [x.id for x in books])],
                }])

            # must fail
            self.assertRaisesRegex(UserError,
                'A value is required for field "Data type" in "Evaluation Line Relation".',
                Evaluation.create,
                [{
                    'name': 'Evaluation 1',
                    'dtype': 'types',   # wrong dtype
                    'cashbooks': [('add', [x.id for x in books])],
                }])

            evaluation, = Evaluation.create([{
                'name': 'Evaluation 2',
                'dtype': 'types',
                'types': [('add', [x.id for x in Types.search([])])],
                }])

            # must fail
            self.assertRaisesRegex(UserError,
                'A value is required for field "Cashbook" in "Evaluation Line Relation".',
                Evaluation.create,
                [{
                    'name': 'Evaluation 3',
                    'dtype': 'cashbooks',
                    'types': [('add', [x.id for x in Types.search([])])],
                }])

    @with_transaction()
    def test_report_check_update_of_actionviews(self):
        """ create 3x cashbooks, add evaluation, check created
            form + actionview
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        try :
            DashboardAction = pool.get('dashboard.action')
        except:
            print('\n--== Module "dashboard" not installed ==--')
            DashboardAction = None

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'cashbooks': [('add', [x.id for x in books])],
                }])

            # add dashboard-action
            if DashboardAction is not None:
                dbaction, = DashboardAction.create([{
                    'user': Transaction().user,
                    'act_window': evaluation.dashb_actwin.id,
                    }])
                self.assertEqual(dbaction.user.rec_name, 'Administrator')
                self.assertEqual(dbaction.act_window.name, 'Evaluation 1')

            self.assertEqual(evaluation.dtype, 'cashbooks')
            self.assertEqual(evaluation.chart, 'pie')
            self.assertEqual(evaluation.legend, True)
            self.assertEqual(evaluation.maincolor, 'default')
            self.assertEqual(evaluation.bgcolor, '#ffffc0')
            self.assertEqual(evaluation.currency.code, 'EUR')

            # check uiview
            self.assertEqual(evaluation.ui_view_chart.model, 'cashbook_report.eval_line')
            self.assertEqual(evaluation.ui_view_chart.module, 'cashbook_report')
            self.assertEqual(evaluation.ui_view_chart.priority, 10)
            self.assertEqual(evaluation.ui_view_chart.type, 'graph')
            # action-window for dashbord
            self.assertEqual(evaluation.dashb_actwin.name, 'Evaluation 1')
            self.assertEqual(evaluation.dashb_actwin.res_model,
                'cashbook_report.eval_line')
            self.assertEqual(evaluation.dashb_actwin.usage,
                'dashboard')
            self.assertEqual(evaluation.dashb_actwin.domain,
                '[["evaluation", "=", %d]]' % evaluation.id)
            # action-view
            self.assertEqual(evaluation.dashb_actview.sequence, 10)
            self.assertEqual(evaluation.dashb_actview.view.id,
                evaluation.ui_view_chart.id)
            self.assertEqual(evaluation.dashb_actview.act_window.id,
                evaluation.dashb_actwin.id)

            # update evaluation, this wil re-create the view/act-window
            # and update the dashboard-view, without removing it
            old_win_id = evaluation.dashb_actwin.id
            Evaluation.write(*[
                [evaluation],
                {
                    'name': 'Evaluation 1a',
                }])
            self.assertTrue(old_win_id != evaluation.dashb_actwin.id)

            if DashboardAction is not None:
                self.assertEqual(DashboardAction.search_count([]), 1)

    @with_transaction()
    def test_report_chart_hbar_book_investment(self):
        """ create 3x cashbooks, add bookings, rates
            create report with cashbooks, check
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        Book = pool.get('cashbook.book')

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            if 'cashbooks_gldiff' not in [x[0] for x in Evaluation.get_sel_etype()]:
                print('\n--== Module "cashbook_investment" not installed ==--')
                return

            AccType = pool.get('cashbook.type')
            Asset = pool.get('investment.asset')
            Product = pool.get('product.template')
            Uom = pool.get('product.uom')
            CbCategory = pool.get('cashbook.bookcategory')

            at, = AccType.create([{
                'name': 'depot',
                'short': 'D',
                'feature': 'asset',
                'company': company.id,
                }])

            prod_templ, = Product.create([{
                'name': 'Aurum',
                'type': 'assets',
                'list_price': Decimal('1.0'),
                'default_uom': Uom.search([('symbol', '=', 'u')])[0].id,
                'products': [('create', [{
                    'description': 'Au',
                    }])],
                }])

            asset, = Asset.create([{
                'company': company.id,
                'product': prod_templ.products[0].id,
                'currency': company.currency.id,
                'currency_digits': 4,
                'uom': prod_templ.default_uom.id,
                'rates': [('create', [{
                    'date': date(2022, 5, 1),
                    'rate': Decimal('1750.0'),
                    }, ])],
                }])
            self.assertEqual(asset.rec_name,
                'Aurum | 1,750.0000 usd/u | 05/01/2022')

            books = self.prep_report_3books()
            cb_cat, = CbCategory.create([{'name': 'CB Category'}])
            Book.write(*[
                books,
                {
                    'btype': at.id,
                    'asset': asset.id,
                    'categories': [('add', [cb_cat.id])],
                    'quantity_uom': asset.uom.id,
                    'quantity_digits': 3,
                    'lines': [('write',
                        [books[0].lines[0].id], # usd
                        {'quantity': Decimal('2.0'), 'amount': Decimal('3000.0')},
                        [books[0].lines[1].id],
                        {'quantity': Decimal('2.0'), 'amount': Decimal('3100.0')},
                        [books[1].lines[0].id], # usd
                        {'quantity': Decimal('2.0'), 'amount': Decimal('3200.0')},
                        [books[1].lines[1].id],
                        {'quantity': Decimal('2.0'), 'amount': Decimal('3300.0')},
                        [books[2].lines[0].id], # euro
                        {'quantity': Decimal('2.0'), 'amount': Decimal('3300.0')},
                        [books[2].lines[1].id],
                        {'quantity': Decimal('2.0'), 'amount': Decimal('3400.0')},
                        )],
                }])
            self.assertEqual(books[0].rec_name, 'Book 1 | 6,100.00 usd | Open | 4.000 u')
            self.assertEqual(books[0].current_value, Decimal('7000.0'))
            self.assertEqual(books[0].diff_amount, Decimal('900.0'))
            self.assertEqual(books[0].diff_percent, Decimal('14.75'))

            self.assertEqual(books[1].rec_name, 'Book 2 | 6,500.00 usd | Open | 4.000 u')
            self.assertEqual(books[1].current_value, Decimal('7000.0'))
            self.assertEqual(books[1].diff_amount, Decimal('500.0'))
            self.assertEqual(books[1].diff_percent, Decimal('7.69'))

            self.assertEqual(books[2].rec_name, 'Book 3 | 6,700.00 € | Open | 4.000 u')
            self.assertEqual(books[2].current_value, Decimal('6666.67'))
            self.assertEqual(books[2].diff_amount, Decimal('-33.33'))
            self.assertEqual(books[2].diff_percent, Decimal('-0.5'))

            # evaluation: amount-difference
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'dtype': 'cashbooks_gldiff',
                'chart': 'hbar',
                'cashbooks': [('add', [x.id for x in books])],
                }])
            self.assertEqual(evaluation.dtype, 'cashbooks_gldiff')
            self.assertEqual(evaluation.chart, 'hbar')
            self.assertEqual(evaluation.legend, True)
            self.assertEqual(evaluation.maincolor, 'default')
            self.assertEqual(evaluation.bgcolor, '#ffffc0')
            self.assertEqual(evaluation.currency.code, 'EUR')

            self.assertEqual(evaluation.line_values[0].balance, Decimal('857.14'))
            self.assertEqual(evaluation.line_values[1].balance, Decimal('476.19'))
            self.assertEqual(evaluation.line_values[2].balance, Decimal('-33.33'))

            # evaluation: percent-difference
            evaluation2, = Evaluation.create([{
                'name': 'Evaluation 2',
                'dtype': 'cashbooks_glperc',
                'chart': 'hbar',
                'cashbooks': [('add', [x.id for x in books])],
                }])
            self.assertEqual(evaluation2.dtype, 'cashbooks_glperc')
            self.assertEqual(evaluation2.chart, 'hbar')
            self.assertEqual(evaluation2.legend, True)
            self.assertEqual(evaluation2.maincolor, 'default')
            self.assertEqual(evaluation2.bgcolor, '#ffffc0')
            self.assertEqual(evaluation2.currency.code, 'EUR')

            self.assertEqual(evaluation2.line_values[0].balance, Decimal('14.75'))
            self.assertEqual(evaluation2.line_values[1].balance, Decimal('7.69'))
            self.assertEqual(evaluation2.line_values[2].balance, Decimal('-0.5'))

            # evaluation: percent-difference
            evaluation3, = Evaluation.create([{
                'name': 'Evaluation 3',
                'dtype': 'cashbooks_glvalue',
                'chart': 'hbar',
                'cashbooks': [('add', [x.id for x in books])],
                }])
            self.assertEqual(evaluation3.dtype, 'cashbooks_glvalue')
            self.assertEqual(evaluation3.chart, 'hbar')
            self.assertEqual(evaluation3.legend, True)
            self.assertEqual(evaluation3.maincolor, 'default')
            self.assertEqual(evaluation3.bgcolor, '#ffffc0')
            self.assertEqual(evaluation3.currency.code, 'EUR')

            self.assertEqual(evaluation3.line_values[0].balance, Decimal('6666.67'))
            self.assertEqual(evaluation3.line_values[1].balance, Decimal('6666.67'))
            self.assertEqual(evaluation3.line_values[2].balance, Decimal('6666.67'))

            # evaluation: category-current value
            evaluation4, = Evaluation.create([{
                'name': 'Evaluation 4',
                'dtype': 'category_glvalue',
                'chart': 'hbar',
                'categories': [('add', [cb_cat.id])],
                }])
            self.assertEqual(evaluation4.dtype, 'category_glvalue')
            self.assertEqual(evaluation4.chart, 'hbar')
            self.assertEqual(evaluation4.legend, True)
            self.assertEqual(evaluation4.maincolor, 'default')
            self.assertEqual(evaluation4.bgcolor, '#ffffc0')
            self.assertEqual(evaluation4.currency.code, 'EUR')

            self.assertEqual(len(evaluation4.line_values), 1)
            self.assertEqual(evaluation4.line_values[0].balance, Decimal('20000.01'))

            # evaluation: category- difference amount
            evaluation5, = Evaluation.create([{
                'name': 'Evaluation 5',
                'dtype': 'category_gldiff',
                'chart': 'hbar',
                'categories': [('add', [cb_cat.id])],
                }])
            self.assertEqual(evaluation5.dtype, 'category_gldiff')
            self.assertEqual(evaluation5.chart, 'hbar')
            self.assertEqual(evaluation5.legend, True)
            self.assertEqual(evaluation5.maincolor, 'default')
            self.assertEqual(evaluation5.bgcolor, '#ffffc0')
            self.assertEqual(evaluation5.currency.code, 'EUR')

            self.assertEqual(len(evaluation5.line_values), 1)
            self.assertEqual(evaluation5.line_values[0].balance, Decimal('1300.01'))

            # evaluation: category- difference amount
            evaluation6, = Evaluation.create([{
                'name': 'Evaluation 6',
                'dtype': 'category_glperc',
                'chart': 'hbar',
                'categories': [('add', [cb_cat.id])],
                }])
            self.assertEqual(evaluation6.dtype, 'category_glperc')
            self.assertEqual(evaluation6.chart, 'hbar')
            self.assertEqual(evaluation6.legend, True)
            self.assertEqual(evaluation6.maincolor, 'default')
            self.assertEqual(evaluation6.bgcolor, '#ffffc0')
            self.assertEqual(evaluation6.currency.code, 'EUR')

            self.assertEqual(len(evaluation6.line_values), 1)
            self.assertEqual(evaluation6.line_values[0].balance, Decimal('6.95'))

    @with_transaction()
    def test_report_chart_pie_book_red(self):
        """ create 3x cashbooks, add bookings,
            create report with cashbooks, check
        """
        Evaluation = Pool().get('cashbook_report.evaluation')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'cashbooks': [('add', [x.id for x in books])],
                }])
            self.assertEqual(evaluation.dtype, 'cashbooks')
            self.assertEqual(evaluation.chart, 'pie')
            self.assertEqual(evaluation.legend, True)
            self.assertEqual(evaluation.maincolor, 'default')
            self.assertEqual(evaluation.bgcolor, '#ffffc0')
            self.assertEqual(evaluation.currency.code, 'EUR')

            # check uiview
            self.assertEqual(evaluation.ui_view_chart.model, 'cashbook_report.eval_line')
            self.assertEqual(evaluation.ui_view_chart.module, 'cashbook_report')
            self.assertEqual(evaluation.ui_view_chart.priority, 10)
            self.assertEqual(evaluation.ui_view_chart.type, 'graph')
            self.assertEqual(evaluation.ui_view_chart.data, """<?xml version="1.0"?>
<graph type="pie" legend="1"  background="#ffffc0">
    <x>
        <field name="name"/>
    </x>
    <y>
        <field name="balance" fill="1" empty="0" string="Cashbooks [Amount]"/>
    </y>
</graph>
""")

            self.assertEqual(len(evaluation.cashbooks), 3)
            self.assertEqual(evaluation.cashbooks[0].rec_name, 'Book 1 | 25.00 usd | Open')
            self.assertEqual(evaluation.cashbooks[1].rec_name, 'Book 2 | 12.50 usd | Open')
            self.assertEqual(evaluation.cashbooks[2].rec_name, 'Book 3 | 23.00 € | Open')
            self.assertEqual(evaluation.cashbooks[0].currency.code, 'usd')
            self.assertEqual(evaluation.cashbooks[1].currency.code, 'usd')
            self.assertEqual(evaluation.cashbooks[2].currency.code, 'EUR')

            self.assertEqual(len(evaluation.line_values), 3)
            self.assertEqual(evaluation.line_values[0].name, 'Book 1 | 25.00 usd | Open')
            self.assertEqual(evaluation.line_values[1].name, 'Book 2 | 12.50 usd | Open')
            self.assertEqual(evaluation.line_values[2].name, 'Book 3 | 23.00 € | Open')

            self.assertEqual(evaluation.line_values[0].eval_currency.code, 'EUR')
            self.assertEqual(evaluation.line_values[1].eval_currency.code, 'EUR')
            self.assertEqual(evaluation.line_values[2].eval_currency.code, 'EUR')

            self.assertEqual(evaluation.line_values[0].balance, Decimal('23.81'))
            self.assertEqual(evaluation.line_values[1].balance, Decimal('11.90'))
            self.assertEqual(evaluation.line_values[2].balance, Decimal('23.00'))

    @with_transaction()
    def test_report_chart_pie_type_red(self):
        """ create 3x cashbooks, add bookings,
            create report with types of cashbooks, check
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        Types = pool.get('cashbook.type')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,  # company-currency: EUR
            'date': date(2022, 5, 15),
            }):
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'dtype': 'types',
                'types': [('add', [x.id for x in Types.search([])])],
                }])
            self.assertEqual(evaluation.dtype, 'types')
            self.assertEqual(evaluation.chart, 'pie')
            self.assertEqual(evaluation.legend, True)
            self.assertEqual(evaluation.maincolor, 'default')
            self.assertEqual(evaluation.bgcolor, '#ffffc0')
            self.assertEqual(evaluation.currency.code, 'EUR')

            # 37.50 USD, Cash
            # 23.00 EUR, Bank
            self.assertEqual(len(evaluation.types), 2)
            self.assertEqual(evaluation.types[0].rec_name, 'BK - Bank')
            self.assertEqual(evaluation.types[1].rec_name, 'CAS - Cash')
            # 23.00 EUR
            self.assertEqual(len(evaluation.line_values), 2)
            self.assertEqual(evaluation.line_values[0].eval_currency.code, 'EUR')
            self.assertEqual(evaluation.line_values[0].name, 'BK - Bank')
            self.assertEqual(evaluation.line_values[0].balance, Decimal('23.0'))

            # 37.50 USD --> EUR
            self.assertEqual(evaluation.line_values[1].name, 'CAS - Cash')
            self.assertEqual(evaluation.line_values[1].eval_currency.code, 'EUR')
            self.assertEqual(evaluation.line_values[1].balance, Decimal('35.71'))

    @with_transaction()
    def test_report_chart_pie_currency_red(self):
        """ create 3x cashbooks, add bookings,
            create report with types of cashbooks, check
        """
        pool = Pool()
        Evaluation = pool.get('cashbook_report.evaluation')
        Currency = pool.get('currency.currency')

        books = self.prep_report_3books()

        company = self.prep_company()
        with Transaction().set_context({
            'company': company.id,
            }):
            evaluation, = Evaluation.create([{
                'name': 'Evaluation 1',
                'dtype': 'currencies',
                'currencies': [('add', [x.id for x in Currency.search([])])],
                }])
            self.assertEqual(evaluation.dtype, 'currencies')
            self.assertEqual(evaluation.chart, 'pie')
            self.assertEqual(evaluation.legend, True)
            self.assertEqual(evaluation.maincolor, 'default')
            self.assertEqual(evaluation.bgcolor, '#ffffc0')
            self.assertEqual(evaluation.currency.code, 'EUR')

            self.assertEqual(len(evaluation.currencies), 2)
            self.assertEqual(evaluation.currencies[0].code, 'EUR')
            self.assertEqual(evaluation.currencies[1].code, 'usd')

            self.assertEqual(len(evaluation.line_values), 2)
            self.assertEqual(evaluation.line_values[0].name, 'Euro')
            self.assertEqual(evaluation.line_values[0].balance, Decimal('23.0'))
            self.assertEqual(evaluation.line_values[1].name, 'usd')
            self.assertEqual(evaluation.line_values[1].balance, Decimal('35.71'))

# end ReportTestCase