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 '--auto'.

'''
from datetime import datetime
import logging
import re
import sys

from path import Path  # @UnusedImport

from core import logconf
from core.model import Sql
from core.pde import AnalytiqueDb, FactureGf
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 = ("--auto" 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")
    ws.parse()

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

    factures = []

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

        # Contrôle si la facture est déjà importée. Si c'est le cas, passe à la facture suivante.
        #  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'
        if analytique_db.exists(Sql.format("""SELECT dblFactureId FROM tbl_Factures
                    WHERE intExercice = {} AND strLiquidation = {:text} AND strEngagement = {:text} AND strService='7710'
                  """, facture.numExBudget, facture.numLiqMandat, facture.numMandat)):
            continue

        logger.info("* La facture %s/%s/%s sera importée", facture.numExBudget, facture.numMandat, facture.numLiqMandat)

        # # Auto-correction des données
        # correction auto des codes chantiers
        if facture.codeAxe == "AFFAI" and re.match(r"\d{2}5\d{3}", facture.codeCout):
            facture.codeCout += "/1"

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

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

        factures.append(facture)

    if not factures:
        logger.info("** Aucune nouvelle facture à importer **")
        return

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

        for facture in factures:
            prefix = "* Facture {}/{}/{}: ".format(facture.numExBudget, facture.numMandat, facture.numLiqMandat)

            if not int(facture.numExBudget) > 2000:
                logger.error(prefix + "Exercice budgetaire invalide: %s", facture.numExBudget)
                errors += 1
                if not no_prompt:
                    facture.numExBudget = input("Saisir la nouvelle valeur:")

            if facture.codeColl != "CG67":
                logger.error(prefix + "Code collectivité invalide: %s", facture.codeColl)
                errors += 1
                if not no_prompt:
                    facture.codeColl = input("Saisir la nouvelle valeur:")

            if facture.codeBudg != "02":
                logger.error(prefix + "Code budgetaire invalide: %s", facture.codeBudg)
                errors += 1
                if not no_prompt:
                    facture.codeBudg = input("Saisir la nouvelle valeur:")

            if facture.codeAxe == "ENGIN":
                # Controle l'existence du materiel
                if not analytique_db.exists(Sql.format("SELECT intlMaterielID FROM tbl_materiel WHERE txtMateriel={:text}", facture.codeCout)):
                    logger.error(prefix + "Le materiel n'existe pas: %s", facture.codeCout)
                    errors += 1
                    if not no_prompt:
                        facture.codeCout = input("Saisir la nouvelle valeur:")

            elif facture.codeAxe == "AFFAI":
                # Controle l'existence de l'affaire
                if not analytique_db.exists(Sql.format("SELECT dblAffaireId FROM tbl_Affaires WHERE strLiaisonControle={:text}", facture.codeCout)):
                    logger.error(prefix + "L'affaire n'existe pas: %s", facture.codeCout)
                    errors += 1
                    if not no_prompt:
                        facture.codeCout = input("Saisir la nouvelle valeur:")

            else:
                # CodeAxe invalide
                logger.error(prefix + "Code axe inconnu: %s", facture.codeAxe)
                errors += 1
                if not no_prompt:
                    facture.codeAxe = input("Saisir la nouvelle valeur:")

        if no_prompt:
            if errors:
                logger.error("<!> Une ou plusieurs erreurs ont été détectées, voir le fichier de log pour plus d'information <!>")
                logger.info("* Opération annulée *")
                return

    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 la base Analytique")

    for facture in factures:

        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 = Sql.format("""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:text}, {intLiquidationLigne}, {strEngagement:text},
                          {strEnveloppe:text}, {strService:text}, {strTiers:text}, {strTiersLibelle:text}, {strMotsClefs:text},
                          {dtmDeb:date}, {intOperation}, {strNomenclature0:text}, {strAxe:text}, {strCentreCout:text},
                          {strObjet:text}, {dblMontantTotal}, {dblMontantTVA}, {strORIGINE_DONNEES:text})
              """, intExercice=facture.numExBudget,
                         strLiquidation=facture.numLiqMandat,
                         intLiquidationLigne=facture.numLigneMandat,
                         strEngagement=facture.numMandat,
                         strEnveloppe=facture.numEnv,
                         strService='7710',
                         strTiers=facture.numTiers,
                         strTiersLibelle=facture.libRai,
                         strMotsClefs=facture.refIntMandat,
                         dtmDeb=facture.dateDepDelai,
                         intOperation=facture.codePeriode or None,
                         strNomenclature0=facture.typeNomencMarche,
                         strAxe=facture.codeAxe,
                         strCentreCout=facture.codeCout,
                         strObjet=facture.dateMandat.strftime("%d/%m/%Y"),
                         dblMontantTVA=facture.mntTvaMandat or 0,
                         dblMontantTotal=facture.mntVent or 0,
                         strORIGINE_DONNEES='ASTRE_{:%y%m%d}'.format(datetime.now())
                         )
        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 = Sql.format("""INSERT INTO tbl_Facture_Engin ( intlMaterielID, txtMateriel, dblFactureId, strLibelle, dblMontant, strType )
                    VALUES ({}, {:text}, {}, {:text}, {}, {:text})
            """, materielId,
                       facture.codeCout,
                       facture.factureId,
                       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 = Sql.format("""INSERT INTO tbl_Facture_Affaire ( strAffaireId, dblFactureId, strLibelle, dblMontant, strType )
                  VALUES ({:text}, {}, {:text}, {}, {:text})
                  """, facture.codeCout,
                             facture.factureId,
                             facture.libRai ,
                             facture.mntVent,
                             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 = Sql.format("""INSERT INTO tbl_Mandatement ( dblFacture, strNumMandat, dtmMandat, strBordereau )
              VALUES ({}, {:text}, {:date}, {:text})
              """, facture.factureId, facture.numMandat, 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 --")