Skip to content
Extraits de code Groupes Projets
Sélectionner une révision Git
  • 424620023032573b8a8b7023a6f06928f04261ef
  • 12.0 par défaut protégée
2 résultats

riga_odoo_import.py

Blame
  • riga_odoo_import.py 8,58 Kio
    # © 2019 Le Filament (<http://www.le-filament.com>)
    # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
    
    import csv
    import io
    import datetime
    import logging
    from ftplib import FTP
    
    from odoo import models, fields, exceptions
    
    _logger = logging.getLogger(__name__)
    
    
    class CgscopRigaOdooImport(models.Model):
        """ Ce modèle permet de logguer les imports de RIGA
        vers Odoo
        """
        _name = 'riga.odoo.import'
        _description = 'Synchronisation RIGA vers Odoo'
        _rec_name = 'model_id'
        _order = 'create_date desc'
    
        model_id = fields.Many2one(
            comodel_name='ir.model',
            string='Modèle')
        is_sync = fields.Boolean('Synchronisé', default=False)
        is_warning = fields.Boolean('Warning', default=False)
        log = fields.Text('Log')
        is_error = fields.Boolean('Erreur Synchro', default=False)
    
        # ------------------------------------------------------
        # Fonctions génériques
        # ------------------------------------------------------
        def _get_ftp_file(self, filename, ftp_channel):
            """ Fonction de récupértion d'ufichier sur un FTP.
    
            Cette fonction prend en paramètre un nom de fichier et recherche
            dans le fichier de conf Odoo les login et password, puis dans les
            paramètres système l'url et le path pour se connecter et retourner
            le fichier binaire souhaité.
    
            : param filename: (string) nom du fichier
    
            @return csv_file: (binary) fichier binaire à traiter
            """
            param = ftp_channel
            ftp_login = param.login
            ftp_pass = param.password
            # Connexion FTP
            try:
                # Connexion ftp
                ftp = FTP(param.url, ftp_login, ftp_pass)
                # Changement de path
                ftp.cwd(param.path)
                # Lecture du fichier
                csv_file = io.BytesIO()
                ftp.retrbinary(
                    "RETR " + filename,
                    csv_file.write)
                _logger.info(
                    "Connecté à l'URL : %s  - Path : %s",
                    param.url,
                    param.path
                )
                return csv_file
            except Exception as e:
                raise exceptions.Warning(e)
    
        def _read_file(self, model, file, table, primary_key, header_key):
            """ Cette fonction prend en paramètre un fichier CSV et lit
            chaque ligne pour mettre à jour la ligne de la table correspondante
            si elle existe ou la créer si l'organisme existe
    
            :param model (obj): modèle pour importer les données
            :param file (binary): fichier CSV à traiter
            :param table (list): liste de tuples de correspondance
                                ('champ_odoo', 'champ_csv')
            :param primary_key (string): header du fichier CSV correspondant à la clé
            :param parent_id (string):  header du fichier CSV pour lequel on va
                                        rechercher l'ID RIGA de l'organisme
            """
            # try:
            file.seek(0)
            # Création du lecteur CSV.
            reader = csv.DictReader(
                io.TextIOWrapper(file, encoding="utf-8-sig", newline=None),
                delimiter=';')
            model_obj = self.env[model.model]
            crea_nb = 0
            maj_nb = 0
            log = ""
            # Lecture de chaque ligne
            for row in reader:
                # Création de l'objet
                vals = {}
                for field in table:
                    print
                    vals.update({
                        field[0]: self._cast_type(
                            model=model,
                            field=field[0],
                            value=row[field[1]],
                            relation=field[2])
                    })
                # Vérification de la ligne dans la base
                line = model_obj.search([
                    ['id_riga', '=', row[primary_key]]])
                # Si il y a un enregistrement, on met à jour
                if line:
                    line.write(vals)
                    maj_nb += 1
                else:
                    # Check d'un organisme dans la base
                    partner = self.env['res.partner'].search([
                        ['id_riga', '=', row[header_key]],
                        ['is_cooperative', '=', True]])
                    # Si l'organisme existe, on crée un enregistrement
                    if partner:
                        vals.update({
                            'partner_id': partner.id
                        })
                        model_obj.create(vals)
                        crea_nb += 1
                    else:
                        log += ("Pas d'enredistrement trouvé pour l'id " +
                                row[primary_key] + " avec l'id riga " +
                                row[header_key] + "\n")
    
            # Création du log
            self.create({
                'model_id': model.id,
                'is_sync': True,
                'log': ("Import du fichier réussi : \n" + 
                        " - Création de " + str(crea_nb) + " lignes\n" +
                        " - Mise à jour de " + str(maj_nb) + " lignes\n\n" + log),
                'is_warning': True if log else False,
            })
    
            # except Exception as e:
            #     _logger.error(e.__str__())
            #     # Création du log
            #     self.create({
            #         'model_id': model.id,
            #         'is_sync': False,
            #         'is_error': True,
            #         'log': str(e)
            #     })
    
        def _cast_type(self, model, field, value, relation=None):
            """ Détermine en fonction du champ la valeur typée à renvoyer
            pour l'ORM
    
            :param model : objet modèle de donnée Odoo
            :param field : nom du champ
            :param value : valeur à caster
    
            @return valeur castée
            """
            odoo_field = self.env['ir.model.fields'].search([
                ['model', '=', model.model],
                ['name', '=', field]])
            field_type = odoo_field.ttype
            if value:
                if field_type == 'integer':
                    return int(float(value.replace(',', '.')))
                elif field_type == 'float':
                    return float(value.replace(',', '.'))
                elif field_type == 'date':
                    date_value = datetime.datetime.strptime(
                        value, '%d/%m/%Y')
                    return date_value
                elif field_type == 'datetime':
                    date_value = datetime.datetime.strptime(
                        value, '%d/%m/%Y %H:%M:%S')
                    return date_value
                elif field_type == 'selection':
                    selection = self.env[model.model]._fields.get(odoo_field.name).selection
                    for item in selection:
                        if item[1] == value:
                            return item[0]
                elif field_type == 'many2one':
                    m2o_value = self.env[odoo_field.relation].search([
                        [relation, '=', value]]).id
                    return m2o_value
                else:
                    return value
            else:
                return False
    
        # ------------------------------------------------------
        # Import données
        # ------------------------------------------------------
    
        def odoo_sync(self):
            model_sync = self.env['riga.files.matching'].sudo().search([
                ['is_active', '=', True]])
            self.sync_file(model_sync)
    
        def sync_file(self, model_sync):
            """ Fonction de synchronisation des fichiers CSV RIGA
            avec les tables associées Odoo.
    
            La fonction recherche l'ensembles des synchronisations actives
            dans la table riga.files.matching, elle transforme la table
            de correspondance de string à list puis appelle la fonction
            _read_file qui permet d'intégrer ou de metre à jour les valeurs
            """
            for model in model_sync:
                table = []
                # Calcul nom du fichier
                if model.params_active:
                    date_value = fields.Datetime.now() + datetime.timedelta(days=model.day)
                    filename = (model.riga_filename +
                                date_value.strftime(model.suffix) + '.' +
                                model.riga_extension)
                else:
                    filename = (model.riga_filename + '.' +
                                model.riga_extension)
                _logger.info(
                    "Lecture Fichier %s pour le modèle %s",
                    filename,
                    model.model_id.name
                )
                for header in model.matching_table_ids:
                    table.append([header.name, header.riga_name, header.relation])
                self._read_file(
                    model=model.model_id,
                    file=self._get_ftp_file(model.riga_filename, model.ftp_channel_id),
                    table=table,
                    primary_key=model.primary_key,
                    header_key=model.header_key)