vertical-cooperative/easy_my_coop_website_portal/controllers/main.py

# Copyright 2016 Jairo Llopis <jairo.llopis@tecnativa.com>
# Copyright 2017-2018 Rémy Taymans <remy@coopiteasy.be>
# Copyright 2019 Houssine Bakkali <houssine@coopiteasy.be>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).


from odoo.exceptions import AccessError, MissingError
from odoo.fields import Date
from odoo.http import request, route
from odoo import _

from odoo.addons.portal.controllers.portal import CustomerPortal
from odoo.addons.portal.controllers.portal import pager as portal_pager
from odoo.addons.payment.controllers.portal import PaymentProcessing


class CooperatorPortalAccount(CustomerPortal):
    CustomerPortal.MANDATORY_BILLING_FIELDS.extend(["iban",
                                                    "birthdate_date",
                                                    "gender"])

    def _prepare_portal_layout_values(self):
        values = super(CooperatorPortalAccount,
                       self)._prepare_portal_layout_values()
        # We assume that commercial_partner_id always point to the
        # partner itself or to the linked partner. So there is no
        # need to check if the partner is a "contact" or not.
        partner = request.env.user.partner_id
        coop = partner.commercial_partner_id
        partner_obj = request.env['res.partner']
        coop_bank = request.env['res.partner.bank'].sudo().search(
            [('partner_id', 'in', [coop.id])],
            limit=1
        )
        invoice_mgr = request.env['account.invoice']
        capital_request_count = invoice_mgr.search_count([
            ('state', 'in', ['open', 'paid', 'cancelled']),
            # Get only the release capital request
            ('release_capital_request', '=', True),
        ])

        invoice_count = invoice_mgr.search_count([
            ('release_capital_request', '=', False)
        ])
        iban = ''
        if partner.bank_ids:
            iban = partner.bank_ids[0].acc_number

        fields_desc = partner_obj.sudo().fields_get(['gender'])

        values.update({
            'coop': coop,
            'coop_bank': coop_bank,
            'capital_request_count': capital_request_count,
            'invoice_count': invoice_count,
            'iban': iban,
            'genders': fields_desc['gender']['selection']
        })
        return values

    def details_form_validate(self, data):
        error, error_message = super(CooperatorPortalAccount,
                                     self).details_form_validate(data)
        sub_req_obj = request.env['subscription.request']
        iban = data.get("iban")
        valid = sub_req_obj.check_iban(iban)

        if not valid:
            error['iban'] = 'error'
            error_message.append(_("You iban account number is not valid"))
        return error, error_message

    @route(['/my/account'], type='http', auth='user', website=True)
    def account(self, redirect=None, **post):
        res = super(CooperatorPortalAccount, self).account(
                    redirect, **post)
        if not res.qcontext.get('error'):
            partner = request.env.user.partner_id
            partner_bank = request.env['res.partner.bank']
            iban = post.get('iban')
            if iban:
                if partner.bank_ids:
                    bank_account = partner.bank_ids[0]
                    bank_account.acc_number = iban
                else:
                    partner_bank.sudo().create({
                        'partner_id': partner.id,
                        'acc_number': iban
                        })
        return res

    @route(['/my/invoices', '/my/invoices/page/<int:page>'], type='http',
           auth="user", website=True)
    def portal_my_invoices(self, page=1, date_begin=None, date_end=None,
                           sortby=None, **kw):
        res = super(CooperatorPortalAccount, self).portal_my_invoices(
                    page, date_begin, date_end, sortby, **kw)
        invoice_obj = request.env['account.invoice']
        qcontext = res.qcontext
        if qcontext:
            invoices = invoice_obj.search([('release_capital_request', '=', False)])
            invoice_count = len(invoices)
            qcontext['invoices'] = invoices
            qcontext['pager']['invoice_count'] = invoice_count
        return res

    @route(
        ['/my/release_capital_request',
         '/my/release_capital_request/page/<int:page>'],
        type='http', auth="user", website=True)
    def portal_my_release_capital_request(self, page=1, date_begin=None,
                                          date_end=None, sortby=None, **kw):
        """Render a page with the list of release capital request.
        A release capital request is an invoice with a flag that tell
        if it's a capital request or not.
        """
        values = self._prepare_portal_layout_values()
        partner = request.env.user.partner_id
        invoice_mgr = request.env['account.invoice']

        domain = [
            ('partner_id', 'in',
             [partner.commercial_partner_id.id]),
            ('state', 'in', ['open', 'paid', 'cancelled']),
            # Get only the release capital request
            ('release_capital_request', '=', True),
        ]
        archive_groups = self._get_archive_groups_sudo('account.invoice',
                                                       domain)
        if date_begin and date_end:
            domain += [('create_date', '>=', date_begin),
                       ('create_date', '<', date_end)]

        # count for pager
        capital_request_count = invoice_mgr.sudo().search_count(domain)
        # pager
        pager = portal_pager(
            url="/my/release_capital_request",
            url_args={'date_begin': date_begin, 'date_end': date_end,
                      'sortby': sortby},
            total=capital_request_count,
            page=page,
            step=self._items_per_page
        )
        # content according to pager and archive selected
        invoices = invoice_mgr.sudo().search(
            domain, limit=self._items_per_page, offset=pager['offset'])
        values.update({
            'date': date_begin,
            'capital_requests': invoices,
            'page_name': 'Release request',
            'pager': pager,
            'archive_groups': archive_groups,
            'default_url': '/my/release_capital_request',
        })
        return request.render(
            "easy_my_coop_website_portal.portal_my_capital_releases",
            values
        )

    @route(['/my/invoices/<int:invoice_id>'],
           type='http', auth="public", website=True)
    def portal_my_invoice_detail(self, invoice_id, access_token=None,
                                 report_type=None, download=False, **kw):
        # override in order to not retrieve release capital request as invoices
        try:
            invoice_sudo = self._document_check_access('account.invoice',
                                                       invoice_id,
                                                       access_token)
        except (AccessError, MissingError):
            return request.redirect('/my')
        if invoice_sudo.release_capital_request:
            report_ref = 'easy_my_coop.action_cooperator_invoices'
        else:
            report_ref = 'account.account_invoices'
        if report_type in ('html', 'pdf', 'text'):
            return self._show_report(model=invoice_sudo,
                                     report_type=report_type,
                                     report_ref=report_ref,
                                     download=download)

        values = self._invoice_get_page_view_values(invoice_sudo, access_token,
                                                    **kw)
        PaymentProcessing.remove_payment_transaction(invoice_sudo.transaction_ids)
        return request.render("account.portal_invoice_page", values)

    @route(['/my/cooperator_certificate/pdf'],
           type='http', auth="user", website=True)
    def get_cooperator_certificat(self, **kw):
        """Render the cooperator certificate pdf of the current user"""
        partner = request.env.user.partner_id

        return self._show_report(
                model=partner,
                report_type='pdf',
                report_ref='easy_my_coop.action_cooperator_report_certificat',
                download=True
            )

    def _render_pdf(self, pdf, filename):
        """Render a http response for a pdf"""
        pdfhttpheaders = [
            ('Content-Disposition', 'inline; filename="%s.pdf"' % filename),
            ('Content-Type', 'application/pdf'),
            ('Content-Length', len(pdf))
        ]
        return request.make_response(pdf, headers=pdfhttpheaders)

    def _get_archive_groups_sudo(self, model, domain=None, fields=None,
                                 groupby="create_date",
                                 order="create_date desc"):
        """Same as the one from website_portal_v10 except that it runs
        in root.
        """
        if not model:
            return []
        if domain is None:
            domain = []
        if fields is None:
            fields = ['name', 'create_date']
        groups = []
        for group in request.env[model].sudo().read_group(
                domain, fields=fields, groupby=groupby, orderby=order):
            label = group[groupby]
            date_begin = date_end = None
            for leaf in group["__domain"]:
                if leaf[0] == groupby:
                    if leaf[1] == ">=":
                        date_begin = leaf[2]
                    elif leaf[1] == "<":
                        date_end = leaf[2]
            groups.append({
                'date_begin': Date.to_string(Date.from_string(date_begin)),
                'date_end': Date.to_string(Date.from_string(date_end)),
                'name': label,
                'item_count': group[groupby + '_count']
            })
        return groups