scripts-pde/gf2analytique.py

'''
    Script d'import des données de facturation depuis
    la base de données ASTRE-GF vers les tables de la base Analytique
    du Parc Départemental d'Erstein

    L'import se déroule en trois étapes:

    1- chargement des données issues de Astre (via le web service CG67.AstreGf) dans le fichier /work/gf2analytique/import.csv
    2- Contrôle de la validité des données, prompt éventuel pour une correction des donneés
    3- Une fois les données valides, import dans Analytique

    **IMPORTANT**: pour lancer le script sans interaction avec l'utilisateur
    (par ex, dans le cas d'une tâche planifiée), appeller le script avec l'option '-n'.

'''
import logging
import re
import sys

from path import Path  # @UnusedImport

from core import logconf
from core.pde import AnalytiqueDb, mk_workdir
from core.webservice import GfWebservice


logger = logging.getLogger("gf2analytique")
logconf.start("gf2analytique", logging.DEBUG)

# # POUR TESTER, décommenter les lignes suivantes
##-----------------------------------------------

# logger.warning("<<<<<<<<<<<<<<   Mode TEST   >>>>>>>>>>>>>>>>>")
# GfWebservice._url = r"http://webservices-t.bas-rhin.fr/CG67.AstreGF.WebServices/public/WsPDE.asmx"
# AnalytiqueDb._path = Path(r"\\h2o\local\4-transversal\BDD\mdb_test\Db_analytique.mdb")

##-----------------------------------------------

# *** Initialisation
logger.info("Initialisation...")

no_prompt = ("-n" in sys.argv)
if no_prompt:
    logger.info("> Lancé en mode automatique (sans interruption)")

# Connect to factures.mdb
analytique_db = AnalytiqueDb(autocommit=False)

# Connect to the astre gf webservice
ws = GfWebservice("GetPDEFactures")

# Make the working directory
workdir = mk_workdir("gf2analytique")
importfile = workdir / "import.csv"

# > Supprime le fichier d'import s'il existe, et le recréé avec la ligne d'en-tête
if importfile.exists():
    logger.debug("Supprime le fichier %s", importfile)
    importfile.remove()


class Facture():
    """ Modèle de données d'une facture """
    _FIELDS = ["numExBudget", "codeColl", "codeBudg", "numEnv", "codeSection", "typeMvt", "numMandat", "numLiqMandat",
                 "numLigneMandat", "codeAxe", "libAxe", "codeCout", "libCout", "dateMandat", "numBj", "numTiers",
                 "libRai", "refIntMandat", "codePeriode", "dateDepDelai", "typeNomencMarche", "mntTtcMandat",
                 "mntTvaMandat", "mntVent"]

    def __init__(self):
        """ Génère un objet facture vide, les propriétés sont générrées automatiquement à partir de la variable _FIELDS"""
        for fld in self._FIELDS:
            setattr(self, fld, None)

    @classmethod
    def from_dict(cls, data):
        """ Retourne un objet Facture à partir d'un dictionnaire de données """
        facture = cls()
        for key, value in data.items():
            setattr(facture, key, value)
        return facture

    def to_csv(self):
        """ Renvoie une chaine de caractère correspondant aux données de la Facture au format CSV
        Le séparateur est une tabulation (car c'est un caractère interdit dans Access) """
        return "\t".join([str(getattr(self, field)).replace("\t", " ") for field in self._FIELDS] + ["\n"])

    @classmethod
    def from_csv(cls, line):
        """ Retourne un objet Facture à partir d'une ligne de texte au format CSV
        Le séparateur est une tabulation (car c'est un caractère interdit dans Access) """
        return cls.from_dict(dict(zip(cls._FIELDS, line.split("\t"))))

    def est_importee(self):
        """ Renvoie True si la facture a déjà été importée dans Analytique
        ATTENTION: en l'absence d'identifiants uniques, il est difficile de contrôler de manière certaine si une ligne a déjà été importée.
        C'est pour cette raison que les données sont importées 'par blocs' """

        sql = """SELECT dblFactureId FROM tbl_Factures
                WHERE intExercice = {} AND strLiquidation = '{}' AND strEngagement = '{}' AND strService='7710'
              """.format(self.numExBudget, self.numLiqMandat, self.numMandat)
        return analytique_db.exists(sql)

    def autocorrection(self):
        """ Procède à certaines corrections automatiques sur les données de la facture """
        # correction auto des codes chantiers
        if self.codeAxe == "AFFAI" and re.match(r"\d{2}5\d{3}", self.codeCout):
            self.codeCout += "/1"

        # echappe les apostrophes
        self.libRai = self.libRai.replace("'", "''")

        # renomme automatiquement les noms de materiels
        if self.codeAxe == "ENGIN":
            row = analytique_db.first("""SELECT txtMateriel FROM tbl_materiel
                                            WHERE txtMateriel='{codeCout}' or txtMateriel='ZZ {codeCout}'
                                            """.format(codeCout=self.codeCout))
            if row:
                self.codeCout = row.txtMateriel

    def is_valid(self):
        """ controle la validité des données d'une facture """
        if not int(self.numExBudget) > 2000:
            logger.error("Exercice budgetaire invalide: %s", self.numExBudget)
            return False
        if self.codeColl != "CG67":
            logger.error("Code collectivité invalide: %s", self.codeColl)
            return False
        if self.codeBudg != "02":
            logger.error("Code budgetaire invalide: %s", self.codeBudg)
            return False
        if self.codeAxe == "ENGIN":
            # Controle l'existence du materiel
            if not analytique_db.first("SELECT intlMaterielID FROM tbl_materiel WHERE txtMateriel='{}'".format(self.codeCout)):
                logger.error("Le materiel n'existe pas: %s", self.codeCout)
                return False
        elif self.codeAxe == "AFFAI":
            # Controle l'existence de l'affaire
            if not analytique_db.first("SELECT dblAffaireId FROM tbl_Affaires WHERE strLiaisonControle='{}'".format(self.codeCout)):
                logger.error("L'affaire n'existe pas: %s", self.codeCout)
                return False
        else:
            # CodeAxe invalide
            logger.error("Code axe inconnu: %s", self.codeAxe)
            return False
        return True



# *** 1- Parcourt les factures renvoyées par le webservice, et stoque toutes les lignes non-importées dans Analytique dans un fichier import.csv
logger.info("Parcourt les données fournies par le webservice")
logger.info("(les ligne à importer sont ajoutées au fichier %s)", importfile)

logger.debug("Génère le fichier %s", importfile)
firstline = "\t".join(Facture._FIELDS + ["\n"])
with open(importfile, 'w+') as f:
    f.write(firstline)


for data in ws:
    # Génère la facture à partir des données fournies par le web-service
    facture = Facture.from_dict(data)

    # Contrôle si la facture est déjà importée. Si c'est le cas, passe à la facture suivante.
    if facture.est_importee():
        continue

    logger.info("* Facture %s/%s/%s: import", facture.numExBudget, facture.numMandat, facture.numLiqMandat)

    # procède à une auto-correction des données
    facture.autocorrection()

    # Ajoute les données au format CSV au fichier d'import
    with open(importfile, 'a') as f:
        f.write(facture.to_csv())



# *** 2- Contrôle les données. En cas d'erreur, le script est interrompu et la position et la description des erreurs sont loggés.
errors = -1

while errors:
    errors = 0
    logger.info("Contrôle des données")

    # Parcourt les lignes du fichier d'import, et teste la validité de chacune.
    with open(importfile) as f:
        next(f)  # saute la première ligne

        for line in f:
            facture = Facture.from_csv(line)

            if not facture.is_valid():
                errors += 1

    if errors:
        logger.error("<!> Une ou plusieurs erreurs ont été détectées, voir le fichier de log pour plus d'information <!>")
        logger.info("Veuillez corriger les données du fichier %s", importfile)

        # En cas d'erreur(s), deux possibilités:
        # - Le script a été lancé en mode sans interruption avec l'option '-n', on interrompt le script.
        # - Le script a été lancé normalement, sans option: on attend une correction manuelle de l'utilisateur.
        if no_prompt:
            sys.exit(errors)
        else:
            input("Presser une touche pour continuer...")


logger.info("Les données sont valides.")

# 3- Si toutes les données sont valides, parcourt les lignes du fichier import.csv et les insère dans la table tbl_Facture.
logger.info("Mise à jour des tables de %s", AnalytiqueDb._path)

with open(importfile) as f:
    next(f)  # saute la première ligne

    for line in f:
        facture = Facture.from_csv(line)

        logger.info("* Facture %s/%s/%s: traitement", facture.numExBudget, facture.numMandat, facture.numLiqMandat)
        # NB: les données ne sont committées qu'aprés l'exécution de toutes les requêtes suivantes

        logger.info("> mise à jour de tbl_Factures")

        # Insère les données dans la table tbl_Factures
        sql = """INSERT INTO tbl_Factures ( intExercice, strLiquidation, intLiquidationLigne, strEngagement,
                                            strEnveloppe, strService, strTiers, strTiersLibelle, strMotsClefs,
                                            dtmDeb, intOperation, strNomenclature0, strAXE, strCentreCout,
                                            strObjet, dblMontantTotal, dblMontantTVA, strORIGINE_DONNEES
                                        )
                  VALUES ({intExercice}, '{strLiquidation}', {intLiquidationLigne}, '{strEngagement}',
                          '{strEnveloppe}', '{strService}', '{strTiers}', '{strTiersLibelle}', '{strMotsClefs}',
                          #{dtmDeb}#, {intOperation}, '{strNomenclature0}', '{strAxe}', '{strCentreCout}',
                          '{strObjet}', {dblMontantTotal}, {dblMontantTVA}, '{strORIGINE_DONNEES}')
              """.format(
                         intExercice=facture.numExBudget,
                         strLiquidation=facture.numLiqMandat,
                         intLiquidationLigne=facture.numLigneMandat,
                         strEngagement=facture.numMandat,
                         strEnveloppe=facture.numEnv,
                         strService='7710',
                         strTiers=facture.numTiers,
                         strTiersLibelle=facture.libRai,
                         strMotsClefs=AnalytiqueDb.nz(facture.refIntMandat),
                         dtmDeb=AnalytiqueDb.format_date(facture.dateDepDelai),
                         intOperation=AnalytiqueDb.nz(facture.codePeriode, "Null"),
                         strNomenclature0=facture.typeNomencMarche,
                         strAxe=facture.codeAxe,
                         strCentreCout=facture.codeCout,
                         strObjet=AnalytiqueDb.format_date(facture.dateMandat, out_format="%d/%m/%Y"),
                         dblMontantTVA=facture.mntTvaMandat,
                         dblMontantTotal=facture.mntVent,
                         strORIGINE_DONNEES='ASTRE'
                         )
        logger.debug("> %s", sql)
        analytique_db.execute(sql)

        facture.factureId = analytique_db.first("SELECT TOP 1 dblFactureId FROM tbl_Factures ORDER BY dblFactureId DESC").dblFactureId


        if facture.codeAxe == "ENGIN":
            # La ligne concerne un engin: insère les données dans la table tbl_Facture_Engin
            logger.info("> mise à jour de tbl_Facture_Engin")

            materiel = analytique_db.first("SELECT intlMaterielID FROM tbl_Materiel WHERE [txtMateriel]='{}'".format(facture.codeCout))
            materielId = materiel.intlMaterielID if materiel else '859'
            logger.debug("retrieve intlMaterielID: %s", materielId)

            sql = """INSERT INTO tbl_Facture_Engin ( intlMaterielID, txtMateriel, dblFactureId, strLibelle, dblMontant, strType )
                    VALUES ({}, '{}', {}, '{}', {}, '{}')
            """.format(materielId,
                       facture.codeCout,
                       facture.factureId,
                       AnalytiqueDb.nz(facture.libCout),
                       facture.mntVent,
                       facture.libRai
                       )
            logger.debug("> %s", sql)
            analytique_db.execute(sql)

        elif facture.codeAxe == "AFFAI":
            # La ligne concerne une affaire: insère les données dans la table tbl_Facture_Affaire
            logger.info("> mise à jour de tbl_Facture_Affaire")

            sql = """INSERT INTO tbl_Facture_Affaire ( strAffaireId, dblFactureId, strLibelle, dblMontant, strType )
                  VALUES ('{}', {}, '{}', {}, '{}')
                  """.format(facture.codeCout,
                             facture.factureId,
                             facture.libRai ,
                             facture.mntVent,
                             AnalytiqueDb.nz(facture.libCout),
                             )
            logger.debug("> %s", sql)
            analytique_db.execute(sql)


        logger.info("> mise à jour de tbl_Mandatement")

        # Insère les données dans la table tbl_Mandatement
        sql = """INSERT INTO tbl_Mandatement ( dblFacture, strNumMandat, dtmMandat, strBordereau )
              VALUES ({}, '{}', #{}#, '{}')
              """.format(facture.factureId,
                         facture.numMandat,
                         AnalytiqueDb.format_date(facture.dateMandat),
                         facture.numBj
                       )
        logger.debug("> %s", sql)
        analytique_db.execute(sql)

        # Commit les insertions dans la base
        analytique_db.commit()

        logger.info("Facture %s : ok", facture.factureId)



logging.shutdown()