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
from subprocess import call
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
##-----------------------------------------------

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



# *** 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:
                call(["start", importfile])
            except:
                logger.error("Erreur au lancement 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)



logging.shutdown()