res_partner.py

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

from datetime import datetime, timedelta
from odoo import models, fields, api
from odoo.exceptions import ValidationError


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

    def _default_ur(self):
        return self.env['res.company']._ur_default_get()

    def _default_country(self):
        return self.env.ref('base.fr', False)

    # Infos générales - champs non affichés
    is_cooperative = fields.Boolean("Est une coopérative")
    current_user_ur_id = fields.Many2one(
        'union.regionale',
        string="Union Régionale de l'utilisateur",
        compute='_compute_current_user_ur_id',
        search='_search_current_user_ur_id')

    # Informations organisme - champs non affichés
    id_ur = fields.Char("Identifiant UR")
    id_riga = fields.Char("Identifiant RIGA")

    # Informations Bandeau
    project_status = fields.Selection(
        [('1_information', "Phase d'information"),
         ('2_pre-diagnostic', 'Phase de pré-diagnostic'),
         ('3_accompagnement', "Phase d'accompagnement projet"),
         ('4_adhesion', "Phase d'adhésion"),
         ('5_cg', 'Soumis CGScop'),
         ('6_suivi', 'Phase de suivi'),
         ('7_abandonne', 'Projet abandonné')],
        track_visibility='onchange',
        string='Statut projet',
        index=True)
    name = fields.Char(index=True, track_visibility='onchange')
    cooperative_form_id = fields.Many2one(
        'res.partner.cooperative.form',
        string="Cooperative form",
        on_delete='restrict',
        track_visibility='onchange')
    partner_company_type_id = fields.Many2one(
        comodel_name='res.partner.company.type',
        string='Legal Form',
        on_delete='restrict',
        track_visibility='onchange')
    membership_status = fields.Selection(
        [('member', 'Adhérent'),
         ('not_member', 'Non Adhérent'),
         ('out', 'Radié')],
        string="Statut d'adhésion",
        compute='_compute_membership', store=True)
    member_number = fields.Char(
        "No adhérent (texte)",
        compute='_compute_membership', store=True)
    member_number_int = fields.Integer(
        "No adhérent",
        compute='_compute_membership_int', store=True, group_operator="")
    member_start_stat = fields.Date(
        "Date d'adhésion statistique",
        compute='_compute_membership', store=True)
    member_start = fields.Date(
        "Date d'adhésion",
        compute='_compute_membership', store=True)
    cae = fields.Boolean("CAE", track_visibility='onchange')

    dissolution_date = fields.Date('Date de Décès',
                                   track_visibility='onchange')
    dissolution_reason_id = fields.Many2one(
        'res.partner.dissolution.reason',
        string="Motif Décès",
        on_delete='restrict',
        track_visibility='onchange')

    # Infos générales / Contact
    sigle = fields.Char("Sigle")
    street = fields.Char("Rue", track_visibility='onchange')
    street2 = fields.Char("Rue 2", track_visibility='onchange')
    street3 = fields.Char("Rue 3", track_visibility='onchange')
    zip = fields.Char("CP", change_default=True, track_visibility='onchange')
    zip_departement = fields.Char(
        "Num Département",
        compute='_compute_num_departement',
        store=True)
    region = fields.Many2one(
        comodel_name='res.country.state',
        string='Région',
        compute='_compute_region',
        store=True)
    city = fields.Char("Ville", track_visibility='onchange')
    cedex = fields.Char("Cedex", track_visibility='onchange')
    country_id = fields.Many2one('res.country', string='Country',
                                 ondelete='restrict',
                                 default=_default_country,
                                 track_visibility='onchange')
    phone = fields.Char("Téléphone 1", track_visibility='onchange')
    mobile = fields.Char("Téléphone 2", track_visibility='onchange')
    email = fields.Char("eMail administratif", track_visibility='onchange')
    facebook = fields.Char("Facebook")
    linkedin = fields.Char("LinkedIn")
    twitter = fields.Char("Twitter")
    instagram = fields.Char("Instagram")

    # Infos générales / Suivi UR
    ur_id = fields.Many2one(
        'union.regionale',
        string='Union Régionale',
        index=True,
        on_delete='restrict',
        default=_default_ur,
        track_visibility='onchange')
    creation_delegate_id = fields.Many2one(
        'res.users',
        string='Délégué de création',
        on_delete='restrict', track_visibility='onchange')
    followup_delegate_id = fields.Many2one(
        'res.users',
        string='Délégué de suivi',
        domain=[('active', '=', True)],
        on_delete='restrict',
        track_visibility='onchange')
    support_delegate_id = fields.Many2one(
        'res.users',
        string='Délégué en support',
        domain=[('active', '=', True)],
        on_delete='restrict',
        track_visibility='onchange')
    segment_1_id = fields.Many2many('res.partner.segment1',
                                    column1='partner_id',
                                    column2='segment_id',
                                    string='Segmentation 1')
    segment_2_id = fields.Many2many('res.partner.segment2',
                                    column1='partner_id',
                                    column2='segment_id',
                                    string='Segmentation 2')
    segment_3_id = fields.Many2many('res.partner.segment3',
                                    column1='partner_id',
                                    column2='segment_id',
                                    string='Segmentation 3')
    segment_4_id = fields.Many2many('res.partner.segment4',
                                    column1='partner_id',
                                    column2='segment_id',
                                    string='Segmentation 4')

    segment_1_nb = fields.Integer(
        string="Nb de segments 1",
        compute="_compute_segment_nb")
    segment_2_nb = fields.Integer(
        string="Nb de segments 2",
        compute="_compute_segment_nb")
    segment_3_nb = fields.Integer(
        string="Nb de segments 3",
        compute="_compute_segment_nb")
    segment_4_nb = fields.Integer(
        string="Nb de segments 4",
        compute="_compute_segment_nb")
    filiere_ids = fields.Many2many('res.partner.filiere',
                                    column1='partner_id',
                                    column2='filiere_id',
                                    string='Filière')


    # Infos générales / Infos activité
    creation_origin_id = fields.Many2one(
        'res.partner.creation.origin',
        string="Origine création en coop",
        domain=[('parent_id', '=', False)],
        on_delete='restrict', track_visibility='onchange')
    creation_suborigin_id = fields.Many2one(
        'res.partner.creation.origin',
        string="Sous-Origine création en coop",
        domain=[('child_ids', '=', False)],
        on_delete='restrict', track_visibility='onchange')
    date_1st_sign = fields.Date(
        'Date 1ère signature coop',
        track_visibility='onchange')
    registration_date = fields.Date(
        string="Date d'immatriculation RCS",
        track_visibility='onchange')
    social_object = fields.Text('Objet Social', track_visibility='onchange')
    naf_id = fields.Many2one(
        'res.partner.naf',
        string='Code NAF',
        on_delete='restrict',
        track_visibility='onchange')
    secteur_id = fields.Many2one(
        'res.partner.secteur.activite',
        string="Secteur d'activité",
        related='naf_id.secteur_id',
        store=True)
    activity_desc = fields.Text("Description de l'activité", track_visibility='onchange')

    certification_ids = fields.Many2many(
        comodel_name='res.partner.certification',
        string='Agrément', on_delete='restrict')
    other_certification = fields.Char(
        string='Autre agrément',
        required=False)
    siret = fields.Char(string='SIRET', size=14, index=True,
                        track_visibility='onchange')
    formatted_siret = fields.Char(string='SIRET formaté',
                                  compute='_compute_from_siret')
    siren = fields.Char(string='SIREN', size=11, compute='_compute_from_siret')
    capital = fields.Integer("Capital (en €)")
    first_closeout = fields.Date(
        '1er bilan en coop')
    closeout_month = fields.Selection(
        [(12842, 'Janvier'),
         (12843, 'Février'),
         (12844, 'Mars'),
         (12845, 'Avril'),
         (12846, 'Mai'),
         (12847, 'Juin'),
         (12848, 'Juillet'),
         (12849, 'Août'),
         (12850, 'Septembre'),
         (12851, 'Octobre'),
         (12852, 'Novembre'),
         (12853, 'Décembre')],
        string='Mois clôture exercices', default=12853)
    is_seed_scop = fields.Boolean("Est une SCOP d'amorçage")
    seed_end = fields.Date("Date de fin du dispositif d'amorçage")
    is_incubated = fields.Boolean("Est incubé")
    incubator_id = fields.Many2one(
        'res.partner',
        string='Incubateur',
        domain=[('active', '=', True), ('is_company', '=', True),
                ('organization_subtype_id.name', '=', 'Incubateur')],
        on_delete='restrict')
    is_ag_constitution = fields.Boolean('AG constitutive réalisée')
    is_federation_com = fields.Boolean(
        string='Fédération de la Communication',
        compute='_compute_federation',
        store=True,
        default=False)
    is_federation_btp = fields.Boolean(
        string='Fédération du BTP',
        compute='_compute_federation',
        store=True,
        default=False)
    is_federation_indus = fields.Boolean(
        string="Fédération de l'Industrie",
        compute='_compute_federation',
        store=True,
        default=False)
    is_federation_cae = fields.Boolean(
        string='Fédération des CAE',
        compute='_compute_federation',
        store=True,
        default=False)
    activity_federation_com_ids = fields.Many2many(
        comodel_name='scop.federation.com.activity',
        relation='res_partner_federation_com_activity_rel',
        column1='partner_id',
        column2='com_activity_id',
        string="Domaine d'activité Com",
        help="Fédération de la Com - Domaine d'activité")
    activity_federation_indus_ids = fields.Many2many(
        comodel_name='scop.federation.indus.activity',
        relation='res_partner_federation_indus_activity_rel',
        column1='partner_id',
        column2='indus_activity_id',
        string="Domaine d'activité Industrie",
        help="Fédération de l'Industrie - Domaine d'activité")
    copadev_member = fields.Boolean(
        string="Adhérent copadev",
        track_visibility='onchange')

    # Contacts
    director_ids = fields.One2many(
        'res.partner', 'parent_id',
        string='Contacts Dirigeants',
        domain=[('active', '=', True), ('mandate_id', '!=', False)])
    other_child_ids = fields.One2many(
        'res.partner', 'parent_id', string='Autres Contacts',
        domain=[('active', '=', True), ('mandate_id', '=', False)])

    # Révisions
    revision_contract = fields.Date("Date du contrat de révision",
                                    track_visibility='onchange')
    revision_company_id = fields.Many2one(
        'res.partner',
        string='Organisme de révision',
        domain=[('active', '=', True), ('is_company', '=', True),
                '|', ('organization_subtype_id.name', '=',
                      'Organisme réviseur'),
                ('organization_subtype_id.name', '=', 'Organisme réviseur, ' +
                 'Expert-comptable / Commissaire au compte')],
        on_delete='restrict',
        track_visibility='onchange')
    revision_backup_company_id = fields.Many2one(
        'res.partner',
        string='Organisme de révision suppléant',
        domain=[('active', '=', True), ('is_company', '=', True),
                '|',
                ('organization_subtype_id.name', '=', 'Organisme réviseur'),
                ('organization_subtype_id.name', '=', 'Organisme réviseur, ' +
                 'Expert-comptable / Commissaire au compte')],
        on_delete='restrict')
    revision_person_id = fields.Many2one(
        comodel_name='res.users',
        string='Réviseur',
        on_delete='restrict',
        track_visibility='onchange')
    revision_certified_person_id = fields.Many2one(
        comodel_name='res.users',
        string='Réviseur agréé',
        on_delete='restrict')
    revision_person_assign_date = fields.Date(
        string="Date de nomination du réviseur",
        track_visibility='onchange')
    revision_type = fields.Selection(
        [('1y', "Annuelle"),
         ('5y', 'Quinquennale'),
         ('5ys', "Quinquennale séquencée (annuel)"),
         ('5ys23', "Quinquennale séquencée (2 ans et 3 ans)")],
        string='Périodicité de la révision')
    revision_next_date = fields.Date("Prochain exercice révisable (old)")
    revision_format_id = fields.Many2one(
        'scop.revision.format',
        string='Format de révision',
        on_delete='restrict')
    revision_tarif = fields.Integer("Tarif de vente",
        related='revision_format_id.tarif',
        store=False)
    revision_next_exercice = fields.Integer("Prochain exercice révisable",
        compute='_compute_revision_next_exercice',
        inverse='_inverse_revision_next_exercice',
        store=True)
    revision_next_year = fields.Integer("Année prochaine révision",
        compute='_compute_revision_next_year',
        inverse='_inverse_revision_next_year',
        store=True)
    revision_ids = fields.One2many(
        comodel_name='scop.revision',
        inverse_name='partner_id',
        string='Liste des Révisions')

    # Historique
    scop_period_ids = fields.One2many(
        comodel_name='scop.period',
        inverse_name='partner_id',
        string="Historique")

    # Période d'adhésion
    membership_period_ids = fields.One2many(
        comodel_name='scop.membership.period',
        inverse_name='partner_id',
        string="Périodes d'adhésion")

    # Cotisation
    contribution_ids = fields.One2many(
        comodel_name='scop.contribution',
        inverse_name='partner_id',
        string='Cotisations')
    is_up_to_date_cg = fields.Boolean("A jour cotisation CG")
    is_up_to_date_fede = fields.Boolean("A jour cotisation Fédérations")
    is_up_to_date_ur = fields.Boolean("A jour cotisation UR")

    # Questionnaire
    # Effectifs
    staff_ids = fields.One2many(
        comodel_name='scop.partner.staff',
        inverse_name='partner_id',
        string='Effectifs',)

    # Liste Ministère
    staff_last = fields.Integer(
        string="Dernier effectif connu",
        compute="_compute_last_effective",
        store=True)
    staff_shareholder_last = fields.Integer(
        string="Dernier effectif associés connu",
        compute="_compute_last_effective",
        store=True)

    staff_last_date = fields.Date(
        string="Date dernier effectif connu",
        compute="_compute_last_effective",
        store=True)

    # Champs pour personnes
    birthyear = fields.Integer("Année de naissance")
    subscription_ids = fields.One2many(
        comodel_name='res.partner.newsletter.subscription',
        inverse_name='partner_id',
        string='Abonnements')
    contact_origin_id = fields.Many2one(
        'res.partner.rgpd.origin',
        string="Origine du contact",
        on_delete='restrict')
    mandate_id = fields.Many2one(
        'res.partner.mandate',
        string="Mandat",
        on_delete='restrict')
    function_lst_id = fields.Many2one(
        'res.partner.function_lst',
        string="Fonction",
        on_delete='restrict')
    contact_legality = fields.Selection(
        [("employee", "Salarié"),
         ("customer", "Client en contrat"),
         ("supplier", "Fournisseur en contrat"),
         ("consent", "Consentement"),
         ("legitimate", "Intérêt légitime"),
         ("none", "Aucune")],
        string="Licéité du contact",
        compute="_compute_contact_legality",
        store=True)
    associate = fields.Selection(
        selection=[('asso', "Associé extérieur"),
                   ('coop', "Associé coopérateur"),
                   ('none', "Non associé")],
        string="Associé")
    employee = fields.Boolean(
        string="Salarié",
        default=True)

    # Champs pour partenaires
    organization_type_id = fields.Many2one(
        'res.partner.organization.type',
        string="Famille",
        on_delete='restrict',
        compute='_compute_org_type_id',
        track_visibility='onchange')
    organization_subtype_id = fields.Many2one(
        'res.partner.organization.type',
        string="Type",
        domain=[('child_ids', '=', False)],
        on_delete='restrict',
        track_visibility='onchange')

    # Droits utilisateurs
    is_administrative = fields.Boolean(compute='_compute_is_administrative')

    # Hack pour la création de contacts depuis la fiche organisme
    parent_id_onchange = fields.Many2one('res.partner')

    # ------------------------------------------------------
    # Constrains
    # ------------------------------------------------------
    @api.constrains('zip_id', 'country_id', 'city_id', 'state_id')
    def _check_zip(self):
        return

    @api.constrains('siret')
    def _check_siret(self):
        if self.siret and not self.env.context.get('import_file'):
            siren = (self.siret[:3] + " "
                     + self.siret[3:6] + " "
                     + self.siret[6:9])
            if not self.siret.isdigit():
                raise ValidationError(
                    "Ce SIRET n'est pas valide")
            if len(self.siret) != 14:
                raise ValidationError(
                    "La longueur du SIRET doit être égale à 14")
            if (self.search_count([('siret', '=like', siren + "%"),
                                   ('is_cooperative', "=", True)]) > 1):
                raise ValidationError(
                    "Ce SIREN existe déjà parmi les coopératives")
            elif self.search_count([('siret', '=', self.siret)]) > 1:
                raise ValidationError("Ce SIRET existe déjà")

    # ------------------------------------------------------
    # Actions
    # ------------------------------------------------------
    @api.multi
    def open_facebook(self):
        self.ensure_one()
        return {
            "type": "ir.actions.act_url",
            "url": self.facebook,
        }

    @api.multi
    def open_linkedin(self):
        self.ensure_one()
        return {
            "type": "ir.actions.act_url",
            "url": self.linkedin,
        }

    @api.multi
    def open_twitter(self):
        self.ensure_one()
        return {
            "type": "ir.actions.act_url",
            "url": self.twitter,
        }

    @api.multi
    def open_instagram(self):
        self.ensure_one()
        return {
            "type": "ir.actions.act_url",
            "url": self.instagram,
        }

    # ------------------------------------------------------
    # Onchange
    # ------------------------------------------------------

    # Hack pour la création de contacts depuis la fiche organisme
    @api.onchange('parent_id_onchange')
    def _onchange_parent_id_onchange(self):
        self.parent_id = self.parent_id_onchange

    @api.onchange('parent_id')
    def _onchange_parent_id(self):
        if self.parent_id.ur_id:
            self.ur_id = self.parent_id.ur_id

    @api.onchange('ur_id')
    def _onchange_ur_id(self):
        if self.child_ids:
            for child in self.child_ids:
                child.ur_id = self.ur_id

    @api.onchange('creation_origin_id')
    def onchange_creation_origin_id(self):
        for coop in self:
            coop.creation_suborigin_id = False

    @api.onchange('is_seed_scop')
    def onchange_is_seed_scop(self):
        for coop in self:
            if coop.is_seed_scop == True:
                if coop.date_1st_sign:
                    coop.seed_end = coop.date_1st_sign + timedelta(2556)
                else:
                    coop.seed_end = datetime.today().date() + timedelta(2556)
            else:
                coop.seed_end = False

    @api.onchange('name')
    def onchange_name(self):
        if self.search_count([('name', '=ilike', self.name)]) > 0:
            return {
                'warning': {
                    'title': "Attention",
                    'message': "Ce nom / cette raison sociale existe déjà, "
                               + "merci de vérifier que vous n'êtes pas en "
                               + "train de créer un doublon"}}

    @api.onchange('mobile')
    def onchange_mobile(self):
        if self.mobile and len(self.mobile) > 0 and len(self.mobile) < 10:
            raise ValidationError(
                "Le numéro de téléphone doit contenir au moins 10 caractères")

    @api.onchange('phone')
    def onchange_phone(self):
        if self.phone and len(self.phone) > 0 and len(self.phone) < 10:
            raise ValidationError(
                "Le numéro de téléphone doit contenir au moins 10 caractères")

    @api.onchange('siret')
    def onchange_siret(self):
        if self.siret:
            siren = (self.siret[:3] + " "
                     + self.siret[3:6] + " "
                     + self.siret[6:9])
            if self.search_count([('siret', '=like', self.siret)]) > 0:
                return {
                    'warning': {
                        'title': "Attention",
                        'message': "Ce SIRET existe déjà, merci de vérifier "
                                   + "que vous n'êtes pas en train de créer un"
                                   + " doublon"}}
            elif self.search_count([('siret', '=like', siren + "%")]) > 0:
                return {
                    'warning': {
                        'title': "Attention",
                        'message': "Ce SIREN existe déjà, merci de vérifier "
                                   + "que vous n'êtes pas en train de créer un"
                                   + " doublon"}}

    @api.onchange('cooperative_form_id')
    def onchange_siret(self):
        if self.cooperative_form_id == self.env.ref('cgscop_partner.form_noncooperative'):
            self.creation_origin_id = None
            self.creation_suborigin_id = None
            self.is_ag_constitution = None
            self.date_1st_sign = None
            self.first_closeout = None

    # ------------------------------------------------------
    # Common functions
    # ------------------------------------------------------
    def _create_period(self, partner):
        new_period = self.env['scop.period'].create({
            'partner_id': partner.id,
            'start': partner.registration_date or fields.Date.today(),
            'name': partner.name,
            'cooperative_form_id': partner.cooperative_form_id.id,
            'partner_company_type_id': partner.partner_company_type_id.id,
            'siret': partner.siret,
            'street': partner.street,
            'street2': partner.street2,
            'street3': partner.street3,
            'zip': partner.zip,
            'zip_id': partner.zip_id.id,
            'city': partner.city,
            'cedex': partner.cedex,
            'state_id': partner.state_id.id,
            'country_id': partner.country_id.id,
            'naf_id': partner.naf_id.id,
            'ur_id': partner.ur_id.id,
            'cae': partner.cae
        })
        partner.scop_period_ids = new_period

    def get_partner_contribution_type(self):
        """
        Returns list of contribution type for partner
        """
        contribution_type = [self.env.ref("cgscop_partner.riga_14397")]
        if self.ur_id in [self.env.ref("cgscop_partner.riga_14232"), self.env.ref("cgscop_partner.riga_14243")]:
            contribution_type.append(self.env.ref("cgscop_partner.riga_14399"))
        if self.is_federation_com:
            contribution_type.append(self.env.ref("cgscop_partner.riga_14398"))
        if self.is_federation_cae:
            contribution_type.append(self.env.ref("cgscop_partner.cotiz_fede_cae"))
        return contribution_type

    # ------------------------------------------------------
    # Override ORM
    # ------------------------------------------------------
    @api.model
    def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
        args = args or []
        domain = ['|', ('name', operator, name), ('member_number', 'ilike', name)]
        partner_ids = self._search(
            domain + args,
            limit=limit, access_rights_uid=name_get_uid)
        return self.browse(partner_ids).name_get()

    # Creation d'une periode lorsque le statut passe en Phase de Suivi
    @api.multi
    def write(self, vals):
        # Gestion casse des informations
        if vals.get('name'):
            vals['name'] = vals.get('name').title()
        if vals.get('lastname'):
            vals['lastname'] = vals.get('lastname').title()
        if vals.get('firstname'):
            vals['firstname'] = vals.get('firstname').title()
        if vals.get('city'):
            vals['city'] = vals.get('city').upper()
        if len(self) == 1 and self.parent_id:
            if self.type in ('contact', 'invoice', 'private'):
                parent_ur_id = self.parent_id.ur_id.id
                vals['ur_id'] = parent_ur_id

        result = super(ScopPartner, self).write(vals)

        # Hack pour notification lors de la modification du logo
        if 'image' in vals:
            self.message_post(
                body="Modification Logo",
                subtype='cgscop_base.cg_values_change',
            )

        for partner in self:
            # Contrainte de tel ou mail lors de la modification d'un contact
            if (not partner.is_company
                    and partner.type == 'contact'
                    and not partner.user_ids):
                if (not partner.email and not partner.phone
                        and not partner.mobile):
                    raise ValidationError(
                        "Vous devez saisir au moins un e-mail ou un téléphone\
                        pour " + partner.name)

            # Création d'une période lors du changement de statut en Suivi            
            if (vals.get('project_status') == '6_suivi'
                    and not self.env.context.get('import_file')):
                if not partner.scop_period_ids:
                    partner._create_period(partner)

            # Ajout des followers de la fiche
            partners_to_subscribe = [
                partner.followup_delegate_id.partner_id.id,
                partner.creation_delegate_id.partner_id.id
            ]
            partner.message_subscribe(partner_ids=partners_to_subscribe)

        return result

    # Création d'une période lors de la création d'une coopérative
    @api.model_create_multi
    def create(self, vals_list):
        # Gestion casse des informations
        for vals in vals_list:
            if vals.get('name'):
                vals['name'] = vals.get('name').title()
            if vals.get('lastname'):
                vals['lastname'] = vals.get('lastname').title()
            if vals.get('firstname'):
                vals['firstname'] = vals.get('firstname').title()
            if vals.get('city'):
                vals['city'] = vals.get('city').upper()

        partners = super(ScopPartner, self).create(vals_list)


        for vals in vals_list:
            # Création d'une période si la coop est en statut en Suivi
            if vals.get('is_cooperative') and vals.get(
                    'project_status') == '6_suivi':
                for partner in partners:
                    if not partner.scop_period_ids:
                        partner._create_period(partner)

        # Ajout des followers de la fiche
        for partner in partners:
            partners_to_subscribe = [
                partner.followup_delegate_id.partner_id.id,
                partner.creation_delegate_id.partner_id.id
            ]
            partner.message_subscribe(partner_ids=partners_to_subscribe)
        return partners

    # ------------------------------------------------------
    # Override parent
    # ------------------------------------------------------
    def _get_contact_name(self, partner, name):
        result = super(ScopPartner, self)._get_contact_name(partner, name)
        return "%s, %s" % (
            name, partner.commercial_company_name or partner.parent_id.name)

    # ------------------------------------------------------
    # Computed Fields
    # ------------------------------------------------------
    @api.depends('siret')
    def _compute_from_siret(self):
        for company in self:
            if company.siret:
                company.siren = (company.siret[:3] + " "
                                 + company.siret[3:6] + " "
                                 + company.siret[6:9])
                company.formatted_siret = (company.siret[:3] + " "
                                           + company.siret[3:6] + " "
                                           + company.siret[6:9] + " "
                                           + company.siret[9:])

    @api.depends('zip', 'state_id')
    def _compute_num_departement(self):
        for company in self:
            if company.zip:
                if company.state_id == self.env.ref('cgscop_partner.domtom'):
                    company.zip_departement = company.zip[:3]
                else:
                    company.zip_departement = company.zip[:2]

    @api.depends('zip')
    def _compute_region(self):
        for partner in self:
            if partner.zip:
                zip_id = self.env['res.city.zip'].search([
                    ('name', '=', partner.zip)])
                if zip_id:
                    partner.region = zip_id[0].city_id[0].state_id

    @api.model
    def _compute_current_user_ur_id(self):
        for partner in self:
            partner.current_user_ur_id = self.env.user.company_id.ur_id.id

    def _search_current_user_ur_id(self, operator, value):
        return [('ur_id', '=', self.env.user.company_id.ur_id.id)]

    @api.depends('contact_origin_id',
                 'parent_id.cooperative_form_id',
                 'parent_id.membership_status')
    def _compute_contact_legality(self):
        for partner in self:
            partner.contact_legality = 'none'
            if (partner.contact_origin_id.name ==
                    "Fiche contact, site internet"):
                partner.contact_legality = 'consent'
            if partner.contact_origin_id.name in (
                    "Prospect journée d'info coll",
                    "Prospect (salon, rdv, internet…)",
                    "Elus"):
                partner.contact_legality = 'legitimate'
            if (partner.contact_origin_id.name in (
                    "Salariés CG", "Salariés UR", "Salariés Fédération")):
                partner.contact_legality = 'employee'
            if (partner.contact_origin_id.name in (
                    "Elus", "VIP, Officiels", "Fournisseurs")):
                partner.contact_legality = 'legitimate'
            if not partner.is_company and partner.parent_id:
                parent = partner.parent_id
                if (partner.contact_origin_id.name in (
                        "Dossiers d'adhésion",
                        "Dossiers annuels non LM (scic, scop47)")
                        and parent.cooperative_form_id
                        and parent.membership_status == "member"):
                    partner.contact_legality = 'customer'
                if (partner.contact_origin_id.name == (
                        "Dossiers annuels non LM (scic, scop47)")
                        and parent.membership_status != "member"):
                    partner.contact_legality = 'legitimate'
                if (partner.contact_origin_id.name == (
                        "Dossiers Liste ministère")
                        and parent.cooperative_form_id.name == "SCIC"):
                    partner.contact_legality = 'customer'

    @api.depends('membership_period_ids',
                 'membership_period_ids.end_reason_id',
                 'membership_period_ids.number',
                 'membership_period_ids.end')
    @api.multi
    def _compute_membership(self):
        for partner in self:
            type_cg = self.env.ref('cgscop_partner.membership_type_1').id
            last_membership_period = self.env['scop.membership.period'].search(
                [('partner_id', '=', partner.id),
                 ('type_id', '=', type_cg)],
                limit=1,
                order='start desc')
            if (last_membership_period
                    and not last_membership_period.end):
                partner.membership_status = "member"
                partner.member_number = last_membership_period.number
                partner.member_start_stat = last_membership_period.start_stat
                partner.member_start = last_membership_period.start
            elif (last_membership_period
                  and last_membership_period.end_reason_id):
                partner.membership_status = "out"
                partner.member_number = last_membership_period.number
            else:
                partner.membership_status = "not_member"

    @api.depends('member_number')
    @api.multi
    def _compute_membership_int(self):
        for partner in self:
            if partner.member_number:
                partner.member_number_int = int(partner.member_number)

    @api.depends('membership_period_ids',
                 'membership_period_ids.end')
    @api.multi
    def _compute_federation(self):
        for partner in self:
            if partner.is_cooperative:
                partner.is_federation_com = partner._get_federation(
                    'cgscop_partner.membership_type_2')
                partner.is_federation_btp = partner._get_federation(
                    'cgscop_partner.membership_type_4')
                partner.is_federation_indus = partner._get_federation(
                    'cgscop_partner.membership_type_3')
                partner.is_federation_cae = partner._get_federation(
                    'cgscop_partner.membership_type_5')

    def _get_federation(self, external_id):
        member_type_id = self.env.ref(external_id).id
        partner_id = self.id
        membership_period = self.env['scop.membership.period'].search([
            ('partner_id', '=', partner_id),
            ('type_id', '=', member_type_id),
            ('end', '=', False)])
        if membership_period:
            return True
        else:
            return False

    @api.depends('staff_ids', 'staff_ids.staff_count',
                 'staff_ids.staff_shareholder_count',
                 'staff_ids.effective_date')
    @api.multi
    def _compute_last_effective(self):
        for partner in self:
            lm = partner.staff_ids.search(
                [['partner_id', '=', partner.id], ['staff_count', '>', 0]],
                limit=1,
                order='effective_date desc')
            if lm:
                partner.staff_last = lm[0].staff_count
                partner.staff_shareholder_last = lm[0].staff_shareholder_count
                partner.staff_last_date = lm[0].effective_date

    @api.multi
    def _compute_segment_nb(self):
        for partner in self:
            # Calcul nombre de segment 1
            seg1 = partner.env['res.partner.segment1'].search([
                ('ur_id', '=', self.env.user.ur_id.id)])
            partner.segment_1_nb = len(seg1)
            # Calcul nombre de segment 2
            seg2 = partner.env['res.partner.segment2'].search([
                ('ur_id', '=', self.env.user.ur_id.id)])
            partner.segment_2_nb = len(seg2)
            # Calcul nombre de segment 3
            seg3 = partner.env['res.partner.segment3'].search([
                ('ur_id', '=', self.env.user.ur_id.id)])
            partner.segment_3_nb = len(seg3)
            # Calcul nombre de segment 4
            seg4 = partner.env['res.partner.segment4'].search([
                ('ur_id', '=', self.env.user.ur_id.id)])
            partner.segment_4_nb = len(seg4)

    @api.depends('organization_subtype_id')
    def _compute_org_type_id(self):
        for partner in self:
            if partner.organization_subtype_id:
                partner.organization_type_id = partner.organization_subtype_id.parent_id
            else:
                partner.organization_type_id = False

    def _compute_is_administrative(self):
        for partner in self:
            if self.env.user.has_group('cgscop_partner.group_cg_administrative'):
                partner.is_administrative = True
            else:
                partner.is_administrative = False

    @api.depends('revision_next_exercice')
    def _compute_revision_next_year(self):
        for partner in self:
            partner.revision_next_year = partner.revision_next_exercice + 1

    def _inverse_revision_next_year(self):
        for expense in self:
            return

    @api.depends('revision_type', 'revision_ids',
                 'revision_ids.revision_result_year', 'first_closeout')
    @api.multi
    def _compute_revision_next_exercice(self):
        for partner in self:
            # Si aucune périodicité de défini, on n'insiste pas
            if (partner.revision_type == False):
                return

            # On commence par regarder si l'on a des révisions
            last_rev = partner.revision_ids.sorted(
                key=lambda r: r.revision_result_year, reverse=True)
            # On calcule l'année de référence du calcul
            base_rev = partner.first_closeout.year - 1

            if len(last_rev) > 0:
                # si On a déjà révisé un exercice il devient la base du calcul
                base_rev = last_rev[0].revision_result_year

            # On calcule le prochain exercice révisable
            # Cas d'une révision annuelle
            if partner.revision_type == '1y':
                partner.revision_next_exercice = base_rev + 1

            # Cas d'une révision quinquénnale
            if partner.revision_type == '5y':
                partner.revision_next_exercice = base_rev + 5

            # Cas d'une révision quinquénnale séquencée (annuelle)
            if partner.revision_type == '5ys':
                partner.revision_next_exercice = base_rev + 1

            # Cas d'une révision quinquénnale séquencée (2 et 3)
            if partner.revision_type == '5ys23':
                # On doit regarder l'écart avec la révision précédente
                if len(last_rev) > 1:
                    # On a une réunion précédente, il faut regarder l'écart entre les deux
                    ex1 = last_rev[0].revision_result_year
                    ex2 = last_rev[1].revision_result_year
                    # le prochain exercie est donc 5 moins la durée de la précédente révision
                    partner.revision_next_exercice = base_rev + (
                                5 - (ex1 - ex2))
                else:
                    # Pas de révision précédente
                    partner.revision_next_exercice = base_rev + 2

    def _inverse_revision_next_exercice(self):
        for expense in self:
            return

    # ------------------------------------------------------
    # Button Action
    # ------------------------------------------------------
    @api.multi
    def scop_send_to_cg(self):
        self.write({
            'project_status': '5_cg',
        })
        return True

    @api.multi
    def partner_archive(self):
        self.active = False

    # TODO - remove temporary function once RIGA API in place