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.model import Model
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
##-----------------------------------------------

# 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")
# logger.handlers = [h for h in logger.handlers if (type(h) == logging.StreamHandler)]
# logger.warning("<<<<<<<<<<<<<<   Mode TEST   >>>>>>>>>>>>>>>>>")

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


def main():
    # *** 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 CsvFormatError(Exception):
        pass

    class Facture(Model):
        """ 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):
            super(Facture, self).__init__()

        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 """
            for field in self._FIELDS:
                if not hasattr(self, field):
                    raise CsvFormatError("Un ou plusieurs champs sont manquants dans le fichier '{}'".format(importfile))

            errors = False
            if not int(self.numExBudget) > 2000:
                logger.error("Exercice budgetaire invalide: %s", self.numExBudget)
                errors = True
            if self.codeColl != "CG67":
                logger.error("Code collectivité invalide: %s", self.codeColl)
                errors = True
            if self.codeBudg != "02":
                logger.error("Code budgetaire invalide: %s", self.codeBudg)
                errors = True
            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)
                    errors = True
            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)
                    errors = True
            else:
                # CodeAxe invalide
                logger.error("Code axe inconnu: %s", self.codeAxe)
                errors = True
            return (not errors)


    # *** 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)

    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
        facture.dump_to_csv(importfile)

    if not importfile.exists():
        logger.info("** Aucune nouvelle facture à importer **")
        sys.exit(0)

    # *** 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.
        for facture in Facture.load_csv(importfile):
            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 <!>")
            if no_prompt:
                logger.info("Veuillez executer le script manuellement: %s", Path(__file__).abspath())
            else:
                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:
                try:
                    from core import tsv_editor
                    tsv_editor.exec_(importfile.abspath())
                except:
                    logger.error("Erreur à l'ouverture du fichier %s", importfile)
                    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)

    for facture in Facture.load_csv(importfile):

        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)


if __name__ == "__main__":
    main()
    logger.info("-- Fin --")