示例#1
0
    def __init__(self, dossier_source):
        """
        initialisation et importation des données

        :param dossier_source: Une instance de la classe dossier.DossierSource
        """
        fichier_reader = dossier_source.reader(self.nom_fichier)
        self.donnees = {}
        labels = []
        try:
            for ligne in fichier_reader:
                if len(ligne) != 2:
                    Outils.fatal(ErreurConsistance(),
                                 self.libelle + ": nombre de colonnes incorrect : " + str(len(ligne)) + ", attendu : 2")
                if ligne[0] in labels:
                    Outils.fatal(ErreurConsistance(),self.libelle + "le label '" + ligne[0] + " n'est pas unique\n")

                ligne[0], err = Outils.est_un_alphanumerique(ligne[0], "le label", chevrons=True)
                if err != "":
                    Outils.fatal(ErreurConsistance(), self.libelle + err)
                ligne[1], err = Outils.est_un_texte(ligne[1], "l'entête")
                if err != "":
                    Outils.fatal(ErreurConsistance(), self.libelle + err)

                labels.append(ligne[0])
                self.donnees[ligne[0]] = ligne[1]

        except IOError as e:
            Outils.fatal(e, "impossible d'ouvrir le fichier : "+self.nom_fichier)
示例#2
0
    def est_coherent(self):
        """
        vérifie que les données du fichier importé sont cohérentes
        :return: 1 s'il y a une erreur, 0 sinon
        """

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        donnees_dict = {}
        types = []

        del self.donnees[0]
        for donnee in self.donnees:
            donnee['type'], info = Outils.est_un_alphanumerique(
                donnee['type'], "le type subside", ligne)
            msg += info
            if info == "":
                if donnee['type'] not in types:
                    types.append(donnee['type'])
                else:
                    msg += "le type de la ligne " + str(
                        ligne) + " n'est pas unique\n"
            donnee['intitule'], info = Outils.est_un_texte(
                donnee['intitule'], "l'intitulé", ligne)
            msg += info

            if donnee['debut'] != 'NULL':
                donnee['debut'], info = Outils.est_une_date(
                    donnee['debut'], "la date de début", ligne)
                msg += info
            if donnee['fin'] != 'NULL':
                donnee['fin'], info = Outils.est_une_date(
                    donnee['fin'], "la date de fin", ligne)
                msg += info
            if donnee['debut'] != 'NULL' and donnee['fin'] != 'NULL':
                if donnee['debut'] > donnee['fin']:
                    msg += "la date de fin de la ligne " + str(
                        ligne) + " doit être postérieure à la date de début"

            donnees_dict[donnee['type']] = donnee

            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0
示例#3
0
    def est_coherent(self, groupes):
        """
        vérifie que les données du fichier importé sont cohérentes, et efface les colonnes mois et année
        :param categories: catégories importées
        :return: 1 s'il y a une erreur, 0 sinon
        """
        if self.verifie_date == 0:
            info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
            Outils.affiche_message(info)
            return 1

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        ids = []
        donnees_dict = {}

        for donnee in self.donnees:
            donnee['id_machine'], info = Outils.est_un_alphanumerique(donnee['id_machine'], "l'id machine", ligne)
            msg += info
            if info == "":
                if donnee['id_machine'] not in ids:
                    ids.append(donnee['id_machine'])
                else:
                    msg += "l'id machine '" + donnee['id_machine'] + "' de la ligne " + str(ligne) +\
                           " n'est pas unique\n"

            if donnee['id_groupe'] == "":
                msg += "l'id groupe de la ligne " + str(ligne) + " ne peut être vide\n"
            elif groupes.contient_id(donnee['id_groupe']) == 0:
                msg += "l'id groupe '" + donnee['id_groupe'] + "' de la ligne " + str(ligne) \
                       + " n'est pas référencé\n"

            donnee['tx_rabais_hc'], info = Outils.est_un_nombre(donnee['tx_rabais_hc'], "le rabais heures creuses",
                                                                ligne, min=0, max=100)
            msg += info
            donnee['nom'], info = Outils.est_un_texte(donnee['nom'], "le nom machine", ligne)
            msg += info

            del donnee['annee']
            del donnee['mois']
            donnees_dict[donnee['id_machine']] = donnee
            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0
示例#4
0
    def est_coherent(self, clients):
        """
        vérifie que les données du fichier importé sont cohérentes
        :param clients: clients importés
        :return: 1 s'il y a une erreur, 0 sinon
        """

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        donnees_dict = {}
        ids = []

        del self.donnees[0]
        for donnee in self.donnees:
            if donnee['id_plateforme'] == "":
                msg += "l'id plateforme " + str(ligne) + " ne peut être vide\n"
            elif donnee['id_plateforme'] not in clients.obtenir_codes():
                msg += "l'id plateforme de la ligne " + str(
                    ligne) + " n'existe pas dans les clients \n"
            elif donnee['id_plateforme'] not in ids:
                ids.append(donnee['id_plateforme'])
            else:
                msg += "l'id plateforme de la ligne " + str(
                    ligne) + " n'est pas unique \n"
            donnee['code_p'], info = Outils.est_un_alphanumerique(
                donnee['code_p'], "le code P", ligne)
            msg += info
            donnee['centre'], info = Outils.est_un_alphanumerique(
                donnee['centre'], "le centre financier", ligne)
            msg += info
            donnee['fonds'], info = Outils.est_un_alphanumerique(
                donnee['fonds'], "les fonds à créditer", ligne)
            msg += info
            donnee['intitule'], info = Outils.est_un_texte(
                donnee['intitule'], "l'intitulé", ligne)
            msg += info
            donnee['grille'], info = Outils.est_un_document(
                donnee['grille'], "la grille tarifaire", ligne, True)
            msg += info

            donnees_dict[donnee['id_plateforme']] = donnee
            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0
示例#5
0
    def est_coherent(self, comptes, machines, users):
        """
        vérifie que les données du fichier importé sont cohérentes, et efface les colonnes mois et année
        :param comptes: comptes importés
        :param machines: machines importées
        :param users: users importés
        :return: 1 s'il y a une erreur, 0 sinon
        """
        if self.verifie_date == 0:
            info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
            Outils.affiche_message(info)
            return 1

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        donnees_list = []

        for donnee in self.donnees:
            if donnee['id_compte'] == "":
                msg += "le compte id de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif comptes.contient_id(donnee['id_compte']) == 0:
                msg += "le compte id '" + donnee[
                    'id_compte'] + "' de la ligne " + str(
                        ligne) + " n'est pas référencé\n"
            elif donnee['id_compte'] not in self.comptes:
                self.comptes.append(donnee['id_compte'])

            if donnee['id_machine'] == "":
                msg += "le machine id de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif machines.contient_id(donnee['id_machine']) == 0:
                msg += "le machine id '" + donnee['id_machine'] + "' de la ligne " + str(ligne)\
                       + " n'est pas référencé\n"

            if donnee['id_user'] == "":
                msg += "le user id de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif users.contient_id(donnee['id_user']) == 0:
                msg += "le user id '" + donnee['id_user'] + "' de la ligne " + str(ligne) \
                       + " n'est pas référencé\n"

            if donnee['id_op'] == "":
                msg += "l'id opérateur de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif users.contient_id(donnee['id_op']) == 0:
                msg += "l'id opérateur '" + donnee['id_op'] + "' de la ligne " + str(ligne) \
                       + " n'est pas référencé\n"

            donnee['duree_machine_hp'], info = Outils.est_un_nombre(
                donnee['duree_machine_hp'], "la durée machine hp", ligne, 4, 0)
            msg += info
            donnee['duree_machine_hc'], info = Outils.est_un_nombre(
                donnee['duree_machine_hc'], "la durée machine hc", ligne, 4, 0)
            msg += info
            donnee['duree_operateur'], info = Outils.est_un_nombre(
                donnee['duree_operateur'], "la durée opérateur", ligne, 4, 0)
            msg += info

            donnee['date_login'], info = Outils.est_une_date(
                donnee['date_login'], "la date de login", ligne)
            msg += info

            donnee['remarque_op'], info = Outils.est_un_texte(
                donnee['remarque_op'], "la remarque opérateur", ligne, True)
            msg += info

            donnee['remarque_staff'], info = Outils.est_un_texte(
                donnee['remarque_staff'], "la remarque staff", ligne, True)
            msg += info

            del donnee['annee']
            del donnee['mois']
            donnees_list.append(donnee)

            ligne += 1

        self.donnees = donnees_list
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0
示例#6
0
    def __init__(self, dossier_source):
        """
        initialisation et importation des données

        :param dossier_source: Une instance de la classe dossier.DossierSource
        """
        donnees_csv = []
        self.verifie_coherence = 0
        msg = ""
        try:
            for ligne in dossier_source.reader(self.nom_fichier):
                donnees_csv.append(ligne)
        except IOError as e:
            Outils.fatal(
                e, "impossible d'ouvrir le fichier : " + self.nom_fichier)

        num = 5
        if len(donnees_csv) != num:
            Outils.fatal(
                ErreurConsistance(),
                self.libelle + ": nombre de lignes incorrect : " +
                str(len(donnees_csv)) + ", attendu : " + str(num))

        self.annee, err = Outils.est_un_entier(donnees_csv[0][1],
                                               "l'année",
                                               min=2000,
                                               max=2099)
        msg += err

        self.mois, err = Outils.est_un_entier(donnees_csv[1][1],
                                              "le mois",
                                              min=1,
                                              max=12)
        msg += err

        self.version, err = Outils.est_un_entier(donnees_csv[2][1],
                                                 "la version",
                                                 min=0)
        msg += err

        self.client_unique = donnees_csv[3][1]
        if self.version == 0 and self.client_unique != "":
            msg += " il ne peut pas y avoir de client unique pour la version 0"
        if self.version > 0 and self.client_unique == "":
            msg += " il doit y avoir un client unique pour une version > 0"
        self.filigrane, err = Outils.est_un_texte(donnees_csv[4][1],
                                                  "le filigrane",
                                                  vide=True)
        msg += err

        jours = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        if self.mois != 2:
            jour = jours[self.mois - 1]
        else:
            if self.annee % 4 == 0:
                if self.annee % 100 == 0:
                    if self.annee % 400 == 0:
                        jour = 29
                    else:
                        jour = 28
                else:
                    jour = 29
            else:
                jour = 28
        self.dernier_jour = jour

        mois_fr = [
            "janvier", "février", "mars", "avril", "mai", "juin", "juillet",
            "août", "septembre", "octobre", "novembre", "décembre"
        ]
        self.mois_txt = mois_fr[self.mois - 1]

        if msg != "":
            Outils.fatal(ErreurConsistance(), Edition.libelle + "\n" + msg)
示例#7
0
    def est_coherent(self, generaux, plateformes):
        """
        vérifie que les données du fichier importé sont cohérentes
        :param generaux: paramètres généraux
        :param plateformes: plateformes importées
        :return: 1 s'il y a une erreur, 0 sinon
        """

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        donnees_dict = {}
        ids = []

        del self.donnees[0]
        for donnee in self.donnees:
            donnee['id_categorie'], info = Outils.est_un_alphanumerique(
                donnee['id_categorie'], "l'id catégorie", ligne)
            msg += info
            if info == "":
                if donnee['id_categorie'] not in ids:
                    ids.append(donnee['id_categorie'])
                else:
                    msg += "l'id catégorie '" + donnee['id_categorie'] + "' de la ligne " + str(ligne) +\
                           " n'est pas unique\n"

            if donnee['code_d'] == "":
                msg += "le code D de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif donnee['code_d'] != generaux.obtenir_code_d(
            )[0] and donnee['code_d'] != generaux.obtenir_code_d()[1]:
                msg += "le code D de la ligne " + str(
                    ligne) + " n'est pas un code D1 ou D2\n"

            if donnee['id_plateforme'] == "":
                msg += "l'id plateforme de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif plateformes.contient_id(donnee['id_plateforme']) == 0:
                msg += "l'id plateforme '" + donnee['id_plateforme'] + "' de la ligne " + str(ligne) \
                       + " n'est pas référencé\n"

            donnee['no_categorie'], info = Outils.est_un_alphanumerique(
                donnee['no_categorie'], "le no catégorie", ligne)
            msg += info
            donnee['intitule'], info = Outils.est_un_texte(
                donnee['intitule'], "l'intitulé", ligne)
            msg += info
            donnee['unite'], info = Outils.est_un_texte(
                donnee['unite'], "l'unité", ligne)
            msg += info

            donnees_dict[donnee['id_categorie']] = donnee
            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0
示例#8
0
    def est_coherent(self, generaux):
        """
        vérifie que les données du fichier importé sont cohérentes, et efface les colonnes mois et année
        :param generaux: paramètres généraux
        :return: 1 s'il y a une erreur, 0 sinon
        """
        if self.verifie_date == 0:
            info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
            Outils.affiche_message(info)
            return 1

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        donnees_dict = {}

        for donnee in self.donnees:
            donnee['code_sap'], info = Outils.est_un_alphanumerique(
                donnee['code_sap'], "le code client sap", ligne)
            msg += info

            donnee['code'], info = Outils.est_un_alphanumerique(
                donnee['code'], "le code client", ligne)
            msg += info
            if info == "":
                if donnee['code'] not in self.codes:
                    self.codes.append(donnee['code'])
                else:
                    msg += "le code client '" + donnee['code'] + "' de la ligne " + str(ligne) +\
                           " n'est pas unique\n"

            donnee['abrev_labo'], info = Outils.est_un_alphanumerique(
                donnee['abrev_labo'], "l'abrev. labo", ligne)
            msg += info
            donnee['nom_labo'], info = Outils.est_un_texte(
                donnee['nom_labo'], "le nom labo", ligne, True)
            msg += info
            donnee['ref'], info = Outils.est_un_texte(donnee['ref'],
                                                      "la référence", ligne,
                                                      True)
            msg += info
            donnee['dest'], info = Outils.est_un_texte(donnee['dest'],
                                                       "le destinataire",
                                                       ligne, True)
            msg += info

            if donnee['nature'] == "":
                msg += "le type de labo de la ligne " + str(
                    ligne) + " ne peut être vide\n"
            elif donnee['nature'] not in generaux.obtenir_code_n():
                msg += "le type de labo '" + donnee['nature'] + "' de la ligne " + str(ligne) +\
                    " n'existe pas dans les types N\n"
            else:
                av_hc = generaux.avantage_hc_par_code_n(donnee['nature'])
                donnee['rh'] = 1
                donnee['bh'] = 0
                if av_hc == 'BONUS':
                    donnee['bh'] = 1
                    donnee['rh'] = 0

            if (donnee['mode'] != "") and (
                    donnee['mode'] not in generaux.obtenir_modes_envoi()):
                msg += "le mode d'envoi '" + donnee['mode'] + "' de la ligne " + str(ligne) +\
                    " n'existe pas dans les modes d'envoi généraux\n"

            if (donnee['mode'] == "MAIL") and (not re.match(
                    "[^@]+@[^@]+\.[^@]+", donnee['email'])):
                msg += "le format de l'e-mail '" + donnee['email'] + "' de la ligne " + str(ligne) +\
                    " n'est pas correct\n"

            del donnee['annee']
            del donnee['mois']
            donnees_dict[donnee['code']] = donnee

            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0
示例#9
0
    def __init__(self, dossier_source, prod2qual=None):
        """
        initialisation et importation des données

        :param dossier_source: Une instance de la classe dossier.DossierSource
        :param prod2qual: Une instance de la classe Prod2Qual si on souhaite éditer
                          des factures et annexes avec les codes d'articles de
                          qualification
        """
        self._donnees = {}
        self.verifie_coherence = 0
        try:
            for ligne in dossier_source.reader(self.nom_fichier):
                cle = ligne.pop(0)
                if cle not in self.cles_autorisees:
                    Outils.fatal(ErreurConsistance(),
                                 "Clé inconnue dans %s: %s" % (self.nom_fichier, cle))
                if cle != "texte_sap":
                    while ligne[-1] == "":
                        del ligne[-1]
                self._donnees[cle] = ligne
        except IOError as e:
            Outils.fatal(e, "impossible d'ouvrir le fichier : "+self.nom_fichier)
        if prod2qual and 'code_sap_qas' in self._donnees:
            self._donnees['code_sap'] = self._donnees['code_sap_qas']

        erreurs = ""
        for cle in self.cles_obligatoires:
            if cle not in self._donnees:
                erreurs += "\nClé manquante dans %s: %s" % (self.nom_fichier, cle)

        self._donnees['centre'][1], err = Outils.est_un_texte(self._donnees['centre'][1], "le centre")
        erreurs += err
        self._donnees['origine'][1], err = Outils.est_un_alphanumerique(self._donnees['origine'][1], "l'origine")
        erreurs += err
        self._donnees['code_int'][1], err = Outils.est_un_alphanumerique(self._donnees['code_int'][1], "le code INT")
        erreurs += err
        self._donnees['code_ext'][1], err = Outils.est_un_alphanumerique(self._donnees['code_ext'][1], "le code EXT")
        erreurs += err
        self._donnees['commerciale'][1], err = Outils.est_un_alphanumerique(self._donnees['commerciale'][1], "le com.")
        erreurs += err
        self._donnees['canal'][1], err = Outils.est_un_alphanumerique(self._donnees['canal'][1], "le canal")
        erreurs += err
        self._donnees['secteur'][1], err = Outils.est_un_alphanumerique(self._donnees['secteur'][1], "le secteur")
        erreurs += err
        self._donnees['devise'][1], err = Outils.est_un_alphanumerique(self._donnees['devise'][1], "la devise")
        erreurs += err
        self._donnees['financier'][1], err = Outils.est_un_alphanumerique(self._donnees['financier'][1], "le financier")
        erreurs += err
        self._donnees['fonds'][1], err = Outils.est_un_alphanumerique(self._donnees['fonds'][1], "le fonds")
        erreurs += err
        self._donnees['entete'][1], err = Outils.est_un_texte(self._donnees['entete'][1], "l'entête", vide=True)
        erreurs += err
        self._donnees['poste_reservation'][1], err = Outils.est_un_entier(self._donnees['poste_reservation'][1],
                                                                          "le poste réservation", min=1, max=9)
        erreurs += err
        self._donnees['lien'][1], err = Outils.est_un_chemin(self._donnees['lien'][1], "le lien")
        erreurs += err
        self._donnees['chemin'][1], err = Outils.est_un_chemin(self._donnees['chemin'][1], "le chemin")
        erreurs += err
        self._donnees['chemin_propre'][1], err = Outils.est_un_chemin(self._donnees['chemin_propre'][1],
                                                                      "le chemin propre")
        erreurs += err
        self._donnees['chemin_filigrane'][1], err = Outils.est_un_chemin(self._donnees['chemin_filigrane'][1],
                                                                         "le chemin filigrane")
        erreurs += err
        for intitule in self._donnees['intitule_n'][1:]:
            intitule, err = Outils.est_un_texte(intitule, "l'intitulé N")
            erreurs += err
        for code_s in self._donnees['code_sap'][1:]:
            code_s, err = Outils.est_un_entier(code_s, "le code sap", min=1)
            erreurs += err
        for code_sq in self._donnees['code_sap_qas'][1:]:
            code_sq, err = Outils.est_un_entier(code_sq, "le code sap qas", min=1)
            erreurs += err
        for quantite in self._donnees['quantite'][1:]:
            quantite, err = Outils.est_un_nombre(quantite, "la quantité", arrondi=3, min=0)
            erreurs += err
        for unite in self._donnees['unite'][1:]:
            unite, err = Outils.est_un_texte(unite, "l'unité")
            erreurs += err
        for type_prix in self._donnees['type_prix'][1:]:
            type_prix, err = Outils.est_un_alphanumerique(type_prix, "le type de prix")
            erreurs += err
        for type_rabais in self._donnees['type_rabais'][1:]:
            type_rabais, err = Outils.est_un_alphanumerique(type_rabais, "le type de rabais")
            erreurs += err
        for texte_sap in self._donnees['texte_sap'][1:]:
            texte_sap, err = Outils.est_un_texte(texte_sap, "le texte sap", vide=True)
            erreurs += err
        for intitule_long in self._donnees['intitule_long'][1:]:
            intitule_long, err = Outils.est_un_texte(intitule_long, "l'intitulé long")
            erreurs += err
        for intitule_court in self._donnees['intitule_court'][1:]:
            intitule_court, err = Outils.est_un_texte(intitule_court, "l'intitulé court")
            erreurs += err
        for modes in self._donnees['modes'][1:]:
            modes, err = Outils.est_un_alphanumerique(modes, "le mode d'envoi", vide=True)
            erreurs += err
        self._donnees['min_fact_rese'][1], err = Outils.est_un_nombre(
            self._donnees['min_fact_rese'][1], "le montant minimum pour des frais de facturation", arrondi=2, min=0)
        erreurs += err

        codes_n = []
        for nn in self._donnees['code_n'][1:]:
            nn, err = Outils.est_un_alphanumerique(nn, "le code N")
            erreurs += err
            if nn not in codes_n:
                codes_n.append(nn)
            else:
                erreurs += "le code N '" + nn + "' n'est pas unique\n"
        codes_d = []
        for dd in self._donnees['code_d'][1:]:
            dd, err = Outils.est_un_alphanumerique(dd, "le code D")
            erreurs += err
            if dd not in codes_d:
                codes_d.append(dd)
            else:
                erreurs += "le code D '" + dd + "' n'est pas unique\n"

        len_ok = True
        if len(self._donnees['code_n']) != len(self._donnees['intitule_n']) or \
                len(self._donnees['code_n']) != len(self._donnees['code_ref_fact']) or \
                len(self._donnees['code_n']) != len(self._donnees['avantage_HC']) or \
                len(self._donnees['code_n']) != len(self._donnees['subsides']) or \
                len(self._donnees['code_n']) != len(self._donnees['rabais_excep']) or \
                len(self._donnees['code_n']) != len(self._donnees['filtrer_article_nul']):
            len_ok = False
            erreurs += "le nombre de colonees doit être le même pour le code N, l'intitulé N, " \
                       "le code référence du client, l'avantage HC, le mode subsides, le mode rabais exceptionnel et " \
                       "le filtre articles nuls\n"

        if len_ok:
            for i in range(1, len(self._donnees['code_n'])):
                if self._donnees['code_ref_fact'][i] != 'INT' and self._donnees['code_ref_fact'][i] != 'EXT':
                    erreurs += "le code référence client doit être INT ou EXT\n"
                if self._donnees['avantage_HC'][i] != 'BONUS' and self._donnees['avantage_HC'][i] != 'RABAIS':
                    erreurs += "l'avantage HC doit être BONUS ou RABAIS\n"
                if self._donnees['subsides'][i] != 'BONUS' and self._donnees['subsides'][i] != 'RABAIS':
                    erreurs += "le mode subsides doit être BONUS ou RABAIS\n"
                if self._donnees['rabais_excep'][i] != 'BONUS' and self._donnees['rabais_excep'][i] != 'RABAIS':
                    erreurs += "le mode rabais exceptionnel doit être BONUS ou RABAIS\n"
                if self._donnees['filtrer_article_nul'][i] != 'OUI' and self._donnees['filtrer_article_nul'][i] != 'NON':
                    erreurs += "le filtre articles nuls doit être OUI ou NON\n"

        if len(self._donnees['code_d']) != len(self._donnees['code_sap']) or \
                len(self._donnees['code_d']) != len(self._donnees['quantite']) or \
                len(self._donnees['code_d']) != len(self._donnees['unite']) or \
                len(self._donnees['code_d']) != len(self._donnees['type_prix']) or \
                len(self._donnees['code_d']) != len(self._donnees['intitule_long']) or \
                len(self._donnees['code_d']) != len(self._donnees['intitule_court']) or \
                len(self._donnees['code_d']) != len(self._donnees['type_rabais']) or \
                len(self._donnees['code_d']) != len(self._donnees['texte_sap']):
            erreurs += "le nombre de colonnes doit être le même pour le code D, le code SAP, la quantité, l'unité, " \
                       "le type de prix, le type de rabais, le texte SAP, l'intitulé long et l'intitulé court\n"

        if len(self._donnees['centre'][1]) > 70:
            erreurs += "le string du paramètre centre est trop long"

        if erreurs != "":
            Outils.fatal(ErreurConsistance(), self.libelle + "\n" + erreurs)
示例#10
0
    def est_coherent(self, generaux, coefprests, plateformes, machines):
        """
        vérifie que les données du fichier importé sont cohérentes et efface les colonnes mois et année
        :param generaux: paramètres généraux
        :param coefprests: coefficients prestations importés
        :param plateformes: plateformes importées
        :param machines: machines importées
        :return: 1 s'il y a une erreur, 0 sinon
        """
        if self.verifie_date == 0:
            info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
            Outils.affiche_message(info)
            return 1

        if self.verifie_coherence == 1:
            print(self.libelle + ": cohérence déjà vérifiée")
            return 0

        msg = ""
        ligne = 1
        ids = []
        donnees_dict = {}

        for donnee in self.donnees:
            donnee['id_prestation'], info = Outils.est_un_alphanumerique(donnee['id_prestation'], "l'id prestation",
                                                                         ligne)
            msg += info
            if info == "":
                if donnee['id_prestation'] not in ids:
                    ids.append(donnee['id_prestation'])
                else:
                    msg += "l'id prestation '" + donnee['id_prestation'] + "' de la ligne " + str(ligne) +\
                           " n'est pas unique\n"

            if donnee['no_prestation'] == "":
                msg += "le numéro de prestation de la ligne " + str(ligne) + " ne peut être vide\n"
            else:
                donnee['no_prestation'], info = Outils.est_un_alphanumerique(donnee['no_prestation'],
                                                                             "le no prestation", ligne)
                msg += info

            donnee['designation'], info = Outils.est_un_texte(donnee['designation'], "la désignation", ligne)
            msg += info
            donnee['unite_prest'], info = Outils.est_un_texte(donnee['unite_prest'], "l'unité prestation", ligne, True)
            msg += info

            if donnee['categorie'] == "":
                msg += "la catégorie  de la ligne " + str(ligne) + " ne peut être vide\n"
            elif donnee['categorie'] not in generaux.codes_d3():
                msg += "la catégorie '" + donnee['categorie'] + "' de la ligne " + str(ligne) +\
                       " n'existe pas dans les paramètres D3\n"
            elif coefprests.contient_categorie(donnee['categorie']) == 0:
                msg += "la catégorie prestation '" + donnee['categorie'] + "' de la ligne " + str(ligne) +\
                       " n'est pas référencée dans les coefficients\n"

            if donnee['id_plateforme'] == "":
                msg += "l'id plateforme de la ligne " + str(ligne) + " ne peut être vide\n"
            elif plateformes.contient_id(donnee['id_plateforme']) == 0:
                msg += "l'id plateforme '" + donnee['id_plateforme'] + "' de la ligne " + str(ligne) \
                       + " n'est pas référencé\n"

            if donnee['id_machine'] == "":
                msg += "l'id machine de la ligne " + str(ligne) + " ne peut être vide\n"
            elif donnee['id_machine'] != "0":
                if machines.contient_id(donnee['id_machine']) == 0:
                    msg += "l'id machine '" + donnee['id_machine'] + "' de la ligne " + str(ligne) \
                           + " n'est pas référencé ni égal à 0\n"

            donnee['prix_unit'], info = Outils.est_un_nombre(donnee['prix_unit'], "le prix unitaire", ligne, 2, 0)
            msg += info

            del donnee['annee']
            del donnee['mois']
            donnees_dict[donnee['id_prestation']] = donnee
            ligne += 1

        self.donnees = donnees_dict
        self.verifie_coherence = 1

        if msg != "":
            msg = self.libelle + "\n" + msg
            Outils.affiche_message(msg)
            return 1
        return 0