res_partner.py

# © 2021 Le Filament (<http://www.le-filament.com>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).

from pytz import timezone

from odoo import fields, models


class ScopAlfrescoAdhesionPartner(models.Model):
    _inherit = "res.partner"

    log_missing_docs = fields.Text("Documents manquants")

    # ------------------------------------------------------
    # Actions
    # ------------------------------------------------------
    # Email
    def get_recipients_adhesion(self):
        """
        Get recipients for email adhesion
        :return:
        """
        recipient_list = list()
        if self.director_ids:
            for director in self.director_ids:
                if director.email:
                    recipient_list.append(director.id)
        if not recipient_list and self.email:
            recipient_list.append(self.id)
        recipient_ids = self.browse(recipient_list)
        res = ",".join(map(lambda x: str(x), recipient_ids.ids))
        return res

    def send_mail_adhesion(self):
        """
        Send mail adhésion to coop
        :return:
        """
        self.ensure_one()
        template_id = self.env.ref("cgscop_adhesion.email_template_adhesion")
        ir_model_data = self.env["ir.model.data"]
        try:
            compose_form_id = ir_model_data.get_object_reference(
                "mail", "email_compose_message_wizard_form"
            )[1]
        except ValueError:
            compose_form_id = False
        ctx = {
            "default_model": "res.partner",
            "default_res_id": self.id,
            "default_use_template": True,
            "default_template_id": template_id.id,
            "default_subtype_id": self.env.ref(
                "cgscop_adhesion_alfodoo.mail_message_subtype_adhesion"
            ).id,
            "default_composition_mode": "comment",
        }
        return {
            "type": "ir.actions.act_window",
            "view_type": "form",
            "view_mode": "form",
            "res_model": "mail.compose.message",
            "views": [(compose_form_id, "form")],
            "view_id": compose_form_id,
            "target": "new",
            "context": ctx,
        }

    def check_docs_adhesion(self):
        compulsory_docs = self.get_compulsory_docs()
        missing_docs = self.check_compulsory_docs()
        html = str()
        for doc in compulsory_docs:
            html += "<input type='checkbox'"
            if doc.name not in missing_docs:
                html += "checked"
            html += "/> " + doc.name + "<br/>"
        local_tz = timezone("Europe/Paris")
        utc_tz = timezone("UTC")
        html += (
            "<hr/>Vérifié le "
            + "<strong>"
            + utc_tz.localize(fields.Datetime.now())
            .astimezone(local_tz)
            .strftime("%d/%m/%Y à %-H:%M")
            + "</strong>"
        )
        self.log_missing_docs = html

    # ------------------------------------------------------
    # Business method
    # ------------------------------------------------------
    def get_compulsory_docs(self):
        return self.env["scop.adhesion.file"].search(
            [
                ("coop_type_id", "=", self.cooperative_form_id.id),
                ("is_compulsory", "=", True),
            ]
        )

    # ------------------------------------------------------
    # Override parent
    # ------------------------------------------------------
    def scop_valid_cg_button(self):
        """
        Inherit button to send mail
        """
        super(ScopAlfrescoAdhesionPartner, self).scop_valid_cg_button()
        return self.send_mail_adhesion()

    def scop_valid_cg(self):
        """
        Inherit function to push files on Alfresco :
        - Facture d'adhésion
        - Courrier d'adhésion
        """
        res = super(ScopAlfrescoAdhesionPartner, self).scop_valid_cg()
        if not self.partner_cmis_folder:
            folder_coop = self.create_cmis_folder()
        else:
            folder_coop = self.partner_cmis_folder

        # Create & store Facture d'adhésion
        invoice_file = self.env.ref("account.account_invoices")._render_qweb_pdf(
            self.invoice_adhesion_id.id
        )[0]
        invoice_name = "Facture d'Adhésion"
        self.push_alfresco_file(
            file=invoice_file,
            name=invoice_name + ".pdf",
            folder=folder_coop,
            metadata={
                "cm:title": invoice_name,
                "cmis:objectTypeId": "D:crm:document",
                "cmis:secondaryObjectTypeIds": [
                    "P:crm:organisme",
                    "P:cm:titled",
                ],
                "crm:type": "FAD",
                "crm:contexte": "STD",
                "crm:annee": str(fields.Datetime.now().year),
            },
        )

        # Create & store Courrier adhésion
        report_adhesion = self.env.ref(
            "cgscop_adhesion.cgscop_adhesion_report"
        )._render_qweb_pdf(self.id)[0]
        courrier_name = "Courrier d'Adhésion"
        self.push_alfresco_file(
            file=report_adhesion,
            name=courrier_name + ".pdf",
            folder=folder_coop,
            metadata={
                "cm:title": courrier_name,
                "cmis:objectTypeId": "D:crm:document",
                "cmis:secondaryObjectTypeIds": [
                    "P:crm:organisme",
                    "P:cm:titled",
                ],
                "crm:type": "CAD",
                "crm:contexte": "STD",
                "crm:annee": str(fields.Datetime.now().year),
            },
        )

        return res

    def check_compulsory_docs(self):
        """
        Override function to check docs with cmis query
        :return:
        """
        errors = list()
        compulsory_docs = self.get_compulsory_docs()
        loaded_docs = self.env["scop.adhesion.file"].compulsory_doc_cmis_query(self)

        compulsory_docs_list = compulsory_docs.mapped(
            lambda d: {"name": d.name, "metadata": d.type_doc}
        )
        loaded_docs_list = list(
            map(lambda d: d.properties.get("crm:type"), loaded_docs)
        )
        for mandatory_doc in compulsory_docs_list:
            if mandatory_doc.get("metadata") not in loaded_docs_list:
                errors.append(mandatory_doc.get("name"))

        return errors