account-financial-reporting/account_financial_report/report/journal_ledger.py

# Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).

from odoo import api, fields, models

DIGITS = (16, 2)


class ReportJournalLedger(models.TransientModel):

    _name = "report_journal_ledger"
    _description = "Journal Ledger Report"
    _inherit = "account_financial_report_abstract"

    date_from = fields.Date(required=True)
    date_to = fields.Date(required=True)
    company_id = fields.Many2one(
        comodel_name="res.company", required=True, ondelete="cascade"
    )
    move_target = fields.Selection(
        selection="_get_move_targets", default="all", required=True,
    )
    sort_option = fields.Selection(
        selection="_get_sort_options", default="move_name", required=True,
    )
    group_option = fields.Selection(
        selection="_get_group_options", default="journal", required=True,
    )
    journal_ids = fields.Many2many(comodel_name="account.journal", required=True,)
    report_journal_ledger_ids = fields.One2many(
        comodel_name="report_journal_ledger_journal", inverse_name="report_id",
    )
    report_move_ids = fields.One2many(
        comodel_name="report_journal_ledger_move", inverse_name="report_id",
    )
    report_move_line_ids = fields.One2many(
        comodel_name="report_journal_ledger_move_line", inverse_name="report_id",
    )
    report_journal_ledger_tax_line_ids = fields.One2many(
        comodel_name="report_journal_ledger_journal_tax_line", inverse_name="report_id",
    )
    report_tax_line_ids = fields.One2many(
        comodel_name="report_journal_ledger_report_tax_line", inverse_name="report_id",
    )
    foreign_currency = fields.Boolean()
    with_account_name = fields.Boolean()

    @api.model
    def _get_move_targets(self):
        return self.env["journal.ledger.report.wizard"]._get_move_targets()

    @api.model
    def _get_sort_options(self):
        return self.env["journal.ledger.report.wizard"]._get_sort_options()

    @api.model
    def _get_group_options(self):
        return self.env["journal.ledger.report.wizard"]._get_group_options()

    def compute_data_for_report(self):
        self.ensure_one()
        self._inject_journal_values()
        self._inject_move_values()
        self._inject_move_line_values()
        self._inject_journal_tax_values()
        self._update_journal_report_total_values()

        if self.group_option == "none":
            self._inject_report_tax_values()

        # Refresh cache because all data are computed with SQL requests
        self.invalidate_cache()

    def _inject_journal_values(self):
        self.ensure_one()
        sql = """
            DELETE
            FROM report_journal_ledger_journal
            WHERE report_id = %s
        """
        params = (self.id,)
        self.env.cr.execute(sql, params)
        sql = """
            INSERT INTO report_journal_ledger_journal (
                create_uid,
                create_date,
                report_id,
                journal_id,
                name,
                code,
                company_id,
                currency_id
            )
            SELECT
                %s as create_uid,
                NOW() as create_date,
                %s as report_id,
                aj.id as journal_id,
                aj.name as name,
                aj.code as code,
                aj.company_id as company_id,
                COALESCE(aj.currency_id, company.currency_id) as currency_id
            FROM
                account_journal aj
            LEFT JOIN
                res_company company on (company.id = aj.company_id)
            WHERE
                aj.id in %s
            AND
                aj.company_id = %s
            ORDER BY
                aj.name
        """
        params = (
            self.env.uid,
            self.id,
            tuple(self.journal_ids.ids),
            self.company_id.id,
        )
        self.env.cr.execute(sql, params)

    def _inject_move_values(self):
        self.ensure_one()
        sql = """
            DELETE
            FROM report_journal_ledger_move
            WHERE report_id = %s
        """
        params = (self.id,)
        self.env.cr.execute(sql, params)
        sql = self._get_inject_move_insert()
        sql += self._get_inject_move_select()
        sql += self._get_inject_move_where_clause()
        sql += self._get_inject_move_order_by()
        params = self._get_inject_move_params()
        self.env.cr.execute(sql, params)

    def _get_inject_move_insert(self):
        return """
            INSERT INTO report_journal_ledger_move (
                create_uid,
                create_date,
                report_id,
                report_journal_ledger_id,
                move_id,
                name,
                company_id
            )
        """

    def _get_inject_move_select(self):
        return """
            SELECT
                %s as create_uid,
                NOW() as create_date,
                rjqj.report_id as report_id,
                rjqj.id as report_journal_ledger_id,
                am.id as move_id,
                am.name as name,
                am.company_id as company_id
            FROM
                account_move am
            INNER JOIN
                report_journal_ledger_journal rjqj
                    on (rjqj.journal_id = am.journal_id)
        """

    def _get_inject_move_where_clause(self):
        self.ensure_one()
        where_clause = """
            WHERE
                rjqj.report_id = %s
            AND
                am.date >= %s
            AND
                am.date <= %s
        """
        if self.move_target != "all":
            where_clause += """
                AND
                    am.state = %s
            """
        return where_clause

    def _get_inject_move_order_by(self):
        self.ensure_one()
        order_by = """
            ORDER BY
        """
        if self.sort_option == "move_name":
            order_by += " am.name"
        elif self.sort_option == "date":
            order_by += " am.date, am.name"
        return order_by

    def _get_inject_move_params(self):
        params = [self.env.uid, self.id, self.date_from, self.date_to]

        if self.move_target != "all":
            params.append(self.move_target)

        return tuple(params)

    def _inject_move_line_values(self):
        self.ensure_one()
        sql = """
            DELETE
            FROM report_journal_ledger_move_line
            WHERE report_id = %s
        """
        params = (self.id,)
        self.env.cr.execute(sql, params)
        sql = """
            INSERT INTO report_journal_ledger_move_line (
                create_uid,
                create_date,
                report_id,
                report_journal_ledger_id,
                report_move_id,
                move_line_id,
                account_id,
                account,
                account_code,
                account_type,
                partner_id,
                partner,
                date,
                entry,
                label,
                debit,
                credit,
                company_currency_id,
                amount_currency,
                currency_id,
                currency_name,
                tax_id,
                taxes_description,
                company_id
            )
            SELECT
                %s as create_uid,
                NOW() as create_date,
                rjqm.report_id as report_id,
                rjqm.report_journal_ledger_id as report_journal_ledger_id,
                rjqm.id as report_move_id,
                aml.id as move_line_id,
                aml.account_id as account_id,
                aa.name as account,
                aa.code as account_code,
                aa.internal_type as account_type,
                aml.partner_id as partner_id,
                p.name as partner,
                aml.date as date,
                rjqm.name as entry,
                aml.name as label,
                aml.debit as debit,
                aml.credit as credit,
                aml.company_currency_id as currency_id,
                aml.amount_currency as amount_currency,
                aml.currency_id as currency_id,
                currency.name as currency_name,
                aml.tax_line_id as tax_id,
                CASE
                    WHEN
                      aml.tax_line_id is not null
                THEN
                    COALESCE(at.description, at.name)
                WHEN
                    aml.tax_line_id is null
                THEN
                    (SELECT
                      array_to_string(
                          array_agg(COALESCE(at.description, at.name)
                      ), ', ')
                    FROM
                        account_move_line_account_tax_rel aml_at_rel
                    LEFT JOIN
                        account_tax at on (at.id = aml_at_rel.account_tax_id)
                    WHERE
                        aml_at_rel.account_move_line_id = aml.id)
                ELSE
                    ''
                END as taxes_description,
                aml.company_id as company_id
            FROM
                account_move_line aml
            INNER JOIN
                report_journal_ledger_move rjqm
                    on (rjqm.move_id = aml.move_id)
            LEFT JOIN
                account_account aa
                    on (aa.id = aml.account_id)
            LEFT JOIN
                res_partner p
                    on (p.id = aml.partner_id)
            LEFT JOIN
                account_tax at
                    on (at.id = aml.tax_line_id)
            LEFT JOIN
                res_currency currency
                    on (currency.id = aml.currency_id)
            WHERE
                rjqm.report_id = %s
        """
        params = (
            self.env.uid,
            self.id,
        )
        self.env.cr.execute(sql, params)

    def _inject_report_tax_values(self):
        self.ensure_one()
        sql_distinct_tax_id = """
            SELECT
                distinct(jrqjtl.tax_id)
            FROM
                report_journal_ledger_journal_tax_line jrqjtl
            WHERE
                jrqjtl.report_id = %s
        """
        self.env.cr.execute(sql_distinct_tax_id, (self.id,))
        rows = self.env.cr.fetchall()
        tax_ids = {row[0] for row in rows}

        sql = """
            INSERT INTO report_journal_ledger_report_tax_line (
                create_uid,
                create_date,
                report_id,
                tax_id,
                tax_name,
                tax_code,
                base_debit,
                base_credit,
                tax_debit,
                tax_credit
            )
            SELECT
                %s as create_uid,
                NOW() as create_date,
                %s as report_id,
                %s as tax_id,
                at.name as tax_name,
                at.description as tax_code,
                (
                    SELECT sum(base_debit)
                    FROM report_journal_ledger_journal_tax_line jrqjtl2
                    WHERE jrqjtl2.report_id = %s
                    AND jrqjtl2.tax_id = %s
                ) as base_debit,
                (
                    SELECT sum(base_credit)
                    FROM report_journal_ledger_journal_tax_line jrqjtl2
                    WHERE jrqjtl2.report_id = %s
                    AND jrqjtl2.tax_id = %s
                ) as base_credit,
                (
                    SELECT sum(tax_debit)
                    FROM report_journal_ledger_journal_tax_line jrqjtl2
                    WHERE jrqjtl2.report_id = %s
                    AND jrqjtl2.tax_id = %s
                ) as tax_debit,
                (
                    SELECT sum(tax_credit)
                    FROM report_journal_ledger_journal_tax_line jrqjtl2
                    WHERE jrqjtl2.report_id = %s
                    AND jrqjtl2.tax_id = %s
                ) as tax_credit
            FROM
                report_journal_ledger_journal_tax_line jrqjtl
            LEFT JOIN
                account_tax at
                    on (at.id = jrqjtl.tax_id)
            WHERE
                jrqjtl.report_id = %s
            AND
                jrqjtl.tax_id = %s
        """

        for tax_id in tax_ids:
            params = (
                self.env.uid,
                self.id,
                tax_id,
                self.id,
                tax_id,
                self.id,
                tax_id,
                self.id,
                tax_id,
                self.id,
                tax_id,
                self.id,
                tax_id,
            )
            self.env.cr.execute(sql, params)

    def _inject_journal_tax_values(self):
        self.ensure_one()
        sql = """
            DELETE
            FROM report_journal_ledger_journal_tax_line
            WHERE report_id = %s
        """
        params = (self.id,)
        self.env.cr.execute(sql, params)
        sql_distinct_tax_id = """
            SELECT
                distinct(jrqml.tax_id)
            FROM
                report_journal_ledger_move_line jrqml
            WHERE
                jrqml.report_journal_ledger_id = %s
        """

        tax_ids_by_journal_id = {}
        for report_journal in self.report_journal_ledger_ids:
            if report_journal.id not in tax_ids_by_journal_id:
                tax_ids_by_journal_id[report_journal.id] = []
            self.env.cr.execute(sql_distinct_tax_id, (report_journal.id,))
            rows = self.env.cr.fetchall()
            tax_ids_by_journal_id[report_journal.id].extend(
                [row[0] for row in rows if row[0]]
            )

        sql = """
            INSERT INTO report_journal_ledger_journal_tax_line (
                create_uid,
                create_date,
                report_id,
                report_journal_ledger_id,
                tax_id,
                tax_name,
                tax_code,
                base_debit,
                base_credit,
                tax_debit,
                tax_credit
            )
            SELECT
                %s as create_uid,
                NOW() as create_date,
                %s as report_id,
                %s as report_journal_ledger_id,
                %s as tax_id,
                at.name as tax_name,
                at.description as tax_code,
                (
                    SELECT sum(debit)
                    FROM report_journal_ledger_move_line jrqml2
                    WHERE jrqml2.report_journal_ledger_id = %s
                    AND (
                        SELECT
                            count(*)
                        FROM
                            account_move_line_account_tax_rel aml_at_rel
                        WHERE
                            aml_at_rel.account_move_line_id =
                                jrqml2.move_line_id
                        AND
                            aml_at_rel.account_tax_id = %s
                    ) > 0
                ) as base_debit,
                (
                    SELECT sum(credit)
                    FROM report_journal_ledger_move_line jrqml2
                    WHERE jrqml2.report_journal_ledger_id = %s
                    AND (
                        SELECT
                            count(*)
                        FROM
                            account_move_line_account_tax_rel aml_at_rel
                        WHERE
                            aml_at_rel.account_move_line_id =
                                jrqml2.move_line_id
                        AND
                            aml_at_rel.account_tax_id = %s
                    ) > 0
                ) as base_credit,
                (
                    SELECT sum(debit)
                    FROM report_journal_ledger_move_line jrqml2
                    WHERE jrqml2.report_journal_ledger_id = %s
                    AND jrqml2.tax_id = %s
                ) as tax_debit,
                (
                    SELECT sum(credit)
                    FROM report_journal_ledger_move_line jrqml2
                    WHERE jrqml2.report_journal_ledger_id = %s
                    AND jrqml2.tax_id = %s
                ) as tax_credit
            FROM
                report_journal_ledger_journal rjqj
            LEFT JOIN
                account_tax at
                    on (at.id = %s)
            WHERE
                rjqj.id = %s
        """

        for report_journal_ledger_id in tax_ids_by_journal_id:
            tax_ids = tax_ids_by_journal_id[report_journal_ledger_id]
            for tax_id in tax_ids:
                params = (
                    self.env.uid,
                    self.id,
                    report_journal_ledger_id,
                    tax_id,
                    report_journal_ledger_id,
                    tax_id,
                    report_journal_ledger_id,
                    tax_id,
                    report_journal_ledger_id,
                    tax_id,
                    report_journal_ledger_id,
                    tax_id,
                    tax_id,
                    report_journal_ledger_id,
                )
                self.env.cr.execute(sql, params)

    def _update_journal_report_total_values(self):
        self.ensure_one()
        sql = """
            UPDATE
                report_journal_ledger_journal rjqj
            SET
                debit = (
                    SELECT sum(rjqml.debit)
                    FROM report_journal_ledger_move_line rjqml
                    WHERE rjqml.report_journal_ledger_id = rjqj.id
                ),
                credit = (
                    SELECT sum(rjqml.credit)
                    FROM report_journal_ledger_move_line rjqml
                    WHERE rjqml.report_journal_ledger_id = rjqj.id
                )
            WHERE
                rjqj.report_id = %s
        """
        self.env.cr.execute(sql, (self.id,))

    def print_report(self, report_type):
        self.ensure_one()
        if report_type == "xlsx":
            report_name = "a_f_r.report_journal_ledger_xlsx"
        else:
            report_name = "account_financial_report." "report_journal_ledger_qweb"
        return (
            self.env["ir.actions.report"]
            .search(
                [("report_name", "=", report_name), ("report_type", "=", report_type)],
                limit=1,
            )
            .report_action(self, config=False)
        )

    def _get_html(self):
        result = {}
        rcontext = {}
        context = dict(self.env.context)
        report = self.browse(context.get("active_id"))
        if report:
            rcontext["o"] = report
            result["html"] = self.env.ref(
                "account_financial_report.report_journal_ledger"
            ).render(rcontext)
        return result

    @api.model
    def get_html(self, given_context=None):
        return self._get_html()

    @api.model
    def _transient_vacuum(self, force=False):
        """Remove journal ledger subtables first for avoiding a costly
        ondelete operation.
        """
        # Next 3 lines adapted from super method for mimicking behavior
        cls = type(self)
        if not force and (cls._transient_check_count < 21):
            return True  # no vacuum cleaning this time
        self.env.cr.execute("DELETE FROM report_journal_ledger_move_line")
        self.env.cr.execute("DELETE FROM report_journal_ledger_move")
        return super(ReportJournalLedger, self)._transient_vacuum(force=force)


class ReportJournalLedgerJournal(models.TransientModel):

    _name = "report_journal_ledger_journal"
    _inherit = "account_financial_report_abstract"

    name = fields.Char(required=True,)
    code = fields.Char()
    report_id = fields.Many2one(
        comodel_name="report_journal_ledger", required=True, ondelete="cascade"
    )
    journal_id = fields.Many2one(
        comodel_name="account.journal", required=True, ondelete="cascade",
    )
    report_move_ids = fields.One2many(
        comodel_name="report_journal_ledger_move",
        inverse_name="report_journal_ledger_id",
    )
    report_tax_line_ids = fields.One2many(
        comodel_name="report_journal_ledger_journal_tax_line",
        inverse_name="report_journal_ledger_id",
    )
    debit = fields.Float(digits=DIGITS,)
    credit = fields.Float(digits=DIGITS,)
    company_id = fields.Many2one(
        comodel_name="res.company", required=True, ondelete="cascade"
    )
    currency_id = fields.Many2one(comodel_name="res.currency",)


class ReportJournalLedgerMove(models.TransientModel):

    _name = "report_journal_ledger_move"
    _inherit = "account_financial_report_abstract"

    report_id = fields.Many2one(
        comodel_name="report_journal_ledger", required=True, ondelete="cascade"
    )
    report_journal_ledger_id = fields.Many2one(
        comodel_name="report_journal_ledger_journal", required=True, ondelete="cascade",
    )
    move_id = fields.Many2one(
        comodel_name="account.move", required=True, ondelete="cascade",
    )
    report_move_line_ids = fields.One2many(
        comodel_name="report_journal_ledger_move_line", inverse_name="report_move_id",
    )
    name = fields.Char()
    company_id = fields.Many2one(
        comodel_name="res.company", required=True, ondelete="cascade"
    )


class ReportJournalLedgerMoveLine(models.TransientModel):

    _name = "report_journal_ledger_move_line"
    _inherit = "account_financial_report_abstract"
    _order = "partner_id desc, account_id desc"

    report_id = fields.Many2one(
        comodel_name="report_journal_ledger", required=True, ondelete="cascade"
    )
    report_journal_ledger_id = fields.Many2one(
        comodel_name="report_journal_ledger_journal", required=True, ondelete="cascade",
    )
    report_move_id = fields.Many2one(
        comodel_name="report_journal_ledger_move", required=True, ondelete="cascade",
    )
    move_line_id = fields.Many2one(
        comodel_name="account.move.line", required=True, ondelete="cascade",
    )
    account_id = fields.Many2one(comodel_name="account.account", string="Account ID",)
    account = fields.Char()
    account_code = fields.Char()
    account_type = fields.Char()
    partner = fields.Char()
    partner_id = fields.Many2one(comodel_name="res.partner", string="Partner ID",)
    date = fields.Date()
    entry = fields.Char()
    label = fields.Char()
    debit = fields.Float(digits=DIGITS,)
    credit = fields.Float(digits=DIGITS,)
    company_currency_id = fields.Many2one(comodel_name="res.currency",)
    amount_currency = fields.Monetary(currency_field="currency_id",)
    currency_id = fields.Many2one(comodel_name="res.currency",)
    currency_name = fields.Char()
    taxes_description = fields.Char()
    tax_id = fields.Many2one(comodel_name="account.tax")
    company_id = fields.Many2one(
        comodel_name="res.company", required=True, ondelete="cascade"
    )


class ReportJournalLedgerReportTaxLine(models.TransientModel):

    _name = "report_journal_ledger_report_tax_line"
    _inherit = "account_financial_report_abstract"
    _order = "tax_code"

    report_id = fields.Many2one(
        comodel_name="report_journal_ledger", required=True, ondelete="cascade"
    )
    tax_id = fields.Many2one(comodel_name="account.tax")
    tax_name = fields.Char()
    tax_code = fields.Char()
    base_debit = fields.Float(digits=DIGITS,)
    base_credit = fields.Float(digits=DIGITS,)
    base_balance = fields.Float(digits=DIGITS, compute="_compute_base_balance",)
    tax_debit = fields.Float(digits=DIGITS,)
    tax_credit = fields.Float(digits=DIGITS,)
    tax_balance = fields.Float(digits=DIGITS, compute="_compute_tax_balance")

    def _compute_base_balance(self):
        for rec in self:
            rec.base_balance = rec.base_debit - rec.base_credit

    def _compute_tax_balance(self):
        for rec in self:
            rec.tax_balance = rec.tax_debit - rec.tax_credit


class ReportJournalLedgerJournalTaxLine(models.TransientModel):

    _name = "report_journal_ledger_journal_tax_line"
    _inherit = "report_journal_ledger_report_tax_line"
    _order = "tax_code"

    report_journal_ledger_id = fields.Many2one(
        comodel_name="report_journal_ledger_journal", required=True, ondelete="cascade",
    )