def Importation(self):
DB = GestionDB.DB()
# Récupération des unités de réservations
req = """SELECT IDunite, IDactivite, nom, unites_principales, unites_secondaires, ordre
FROM portail_unites;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictUnites = {}
for IDunite, IDactivite, nom, unites_principales, unites_secondaires, ordre in listeDonnees :
unites_principales = UTILS_Texte.ConvertStrToListe(unites_principales)
unites_secondaires = UTILS_Texte.ConvertStrToListe(unites_secondaires)
self.dictUnites[IDunite] = {
"IDactivite" : IDactivite, "nom" : nom, "unites_principales" : unites_principales,
"unites_secondaires" : unites_secondaires, "ordre" : ordre,
}
# Récupération des activités
req = """SELECT IDactivite, nom, portail_reservations_limite, portail_reservations_absenti
FROM activites;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictActivites = {}
for IDactivite, nom, portail_reservations_limite, portail_reservations_absenti in listeDonnees :
self.dictActivites[IDactivite] = {
"nom" : nom, "portail_reservations_limite" : portail_reservations_limite,
"portail_reservations_absenti" : portail_reservations_absenti,
}
DB.Close()
def ConvertParametresEnDict(texte=""):
dictDonnees = {}
if texte in ("", None) : return dictDonnees
listeDonnees = texte.split("##")
for donnee in listeDonnees :
champ, valeur = donnee.split(":=")
if champ == "ETIQUETTES" and valeur != None :
etiquettes = UTILS_Texte.ConvertStrToListe(valeur)
dictDonnees["etiquettes"] = etiquettes
if champ == "ETAT" and valeur != None :
dictDonnees["etat"] = valeur
if champ == "QUANTITE" and valeur != None :
dictDonnees["quantite"] = int(valeur)
if champ == "HEUREDEBUT" and valeur != None :
dictDonnees["heure_debut"] = valeur
if champ == "HEUREFIN" and valeur != None :
dictDonnees["heure_fin"] = valeur
return dictDonnees
def SetIDcoches(self, listeIDcoches=[]):
if type(listeIDcoches) == str:
listeIDcoches = UTILS_Texte.ConvertStrToListe(listeIDcoches)
index = 0
for index, IDcategorie in self.dictCategories.iteritems():
if IDcategorie in listeIDcoches:
self.Check(index)
def GetEtiquettes(self):
if self.check_etiquettes.GetValue() == True:
texteEtiquettes = UTILS_Texte.ConvertListeToStr(
self.ctrl_etiquettes.GetCoches())
else:
texteEtiquettes = None
return texteEtiquettes
def GetCategories(categories_tarifs):
listeTemp = []
for IDcategorie in UTILS_Texte.ConvertStrToListe(
categories_tarifs):
if self.dictCategories.has_key(IDcategorie):
listeTemp.append(self.dictCategories[IDcategorie])
return ", ".join(listeTemp)
def GetIDcoches(self):
listeIDcoches = []
for index, IDcategorie in self.dictCategories.iteritems():
if self.IsChecked(index):
listeIDcoches.append(IDcategorie)
listeIDcoches = UTILS_Texte.ConvertListeToStr(listeIDcoches)
return listeIDcoches
def Importation_tarifs(self, IDcategorie_tarif=0):
if IDcategorie_tarif == None : return []
DB = GestionDB.DB()
# Recherche les tarifs
dictIndividus = {}
req = """SELECT IDtarif, tarifs.IDactivite,
tarifs.IDnom_tarif, noms_tarifs.nom,
date_debut, date_fin, methode, categories_tarifs, groupes
FROM tarifs
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
ORDER BY noms_tarifs.nom, date_debut;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeTarifs = []
for IDtarif, IDactivite, IDnom_tarif, nomTarif, date_debut, date_fin, methode, categories_tarifs, groupes in listeDonnees :
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
listeCategoriesTarifs = UTILS_Texte.ConvertStrToListe(categories_tarifs)
dictTemp = {
"IDtarif" : IDtarif, "IDactivite" : IDactivite,
"IDnom_tarif" : IDnom_tarif, "nomTarif" : nomTarif, "date_debut" : date_debut,
"date_fin" : date_fin, "methode" : methode, "categories_tarifs":categories_tarifs, "groupes":groupes,
}
if listeCategoriesTarifs != None :
if IDcategorie_tarif in listeCategoriesTarifs :
listeTarifs.append(dictTemp)
return listeTarifs
def SetEtiquettes(self, etiquettes=None):
if etiquettes not in (None, ""):
etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes)
self.ctrl_etiquettes.SetCoches(etiquettes)
self.check_etiquettes.SetValue(True)
else:
self.check_etiquettes.SetValue(False)
self.OnCheckEtiquettes(None)
def GetDonnees(self):
""" Récupération des données """
conditions = self.ctrl_conditions.GetValeur()
if self.radio_heure_debut_fixe.GetValue() == True:
heure_debut = self.ctrl_heure_debut.GetHeure()
else:
heure_debut = "FORMULE:" + self.ctrl_heure_debut_formule.GetValue()
if self.radio_heure_fin_fixe.GetValue() == True:
heure_fin = self.ctrl_heure_fin.GetHeure()
else:
heure_fin = "FORMULE:" + self.ctrl_heure_fin_formule.GetValue()
etiquettes = self.ctrl_etiquettes.GetCoches()
etat = self.ctrl_etat.GetValeur()
quantite = self.ctrl_quantite.GetValue()
# Conversion en str
etiquettesStr = "ETIQUETTES:="
if etiquettes == []:
etiquettesStr += ""
else:
etiquettesStr += UTILS_Texte.ConvertListeToStr(etiquettes)
quantiteStr = "QUANTITE:=%d" % quantite
heure_debutStr = "HEUREDEBUT:="
if heure_debut == None:
heure_debutStr += ""
else:
heure_debutStr += heure_debut
heure_finStr = "HEUREFIN:="
if heure_fin == None:
heure_finStr += ""
else:
heure_finStr += heure_fin
etatStr = "ETAT:=%s" % etat
listeTemp = (etiquettesStr, etatStr, quantiteStr, heure_debutStr,
heure_finStr)
parametres = "##".join(listeTemp)
# Mémorisation
dictDonnees = {
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"etiquettes": etiquettes,
"etat": etat,
"quantite": quantite,
"conditions": conditions,
"parametres": parametres,
}
return dictDonnees
def GetProchainRUM(self):
""" Recherche le prochain RUM pour un nouveau mandat """
DB = GestionDB.DB()
req = """SELECT IDmandat, rum FROM mandats
ORDER BY IDmandat DESC;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0 :
dernierRum = "0"
else :
IDmandat, dernierRum = listeDonnees[0]
if dernierRum == None :
dernierRum = "0"
rum = UTILS_Texte.Incrementer(dernierRum)
return rum
def MAJ(self):
if type(self.categories) == str:
self.categories = UTILS_Texte.ConvertStrToListe(self.categories)
# Génération du texte Catégories
listeTemp = []
for IDcategorie in self.categories:
nom = None
if IDcategorie == 0:
nom = _(u"Toutes les catégories inutilisées")
if self.parent.dictCategories.has_key(IDcategorie):
nom = self.parent.dictCategories[IDcategorie]
if nom != None:
listeTemp.append(nom)
listeTemp.sort()
self.texte_categories = u", ".join(listeTemp)
def CreerMode(self):
""" Créer un mode 'Remboursement' """
# Vérifie si un mode Remboursement n'existe pas déj�
DB = GestionDB.DB()
req = """SELECT IDmode, label FROM modes_reglements;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
present = False
for IDmode, label in listeDonnees:
if "remboursement" in UTILS_Texte.Supprime_accent(label.lower()):
present = True
if present == True:
dlg = wx.MessageDialog(
self,
_(u"Il semblerait qu'un mode 'Remboursement' soit déjà présent.\n\nSouhaitez-vous quand même créer un nouveau mode ?"
), _(u"Avertissement"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
# Confirmation
dlg = wx.MessageDialog(
self,
_(u"Confirmez-vous la création d'un mode de règlement 'Remboursement' ?"
), _(u"Confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
# Sauvegarde
DB = GestionDB.DB()
listeDonnees = [
("label", _(u"Remboursement")),
]
IDmode = DB.ReqInsert("modes_reglements", listeDonnees)
DB.Close()
# MAJ Contrôle Modes
self.ctrl_mode.MAJ()
self.SelectModeRemboursement()
def RechercheNbreConsoAssociees(self):
""" Recherche si les IDetiquette données sont déjà associées à des consommations """
DB = GestionDB.DB()
req = """SELECT IDconso, etiquettes
FROM consommations
WHERE etiquettes IS NOT NULL or etiquettes='';"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
dictResultats = {}
for IDconso, etiquettes in listeDonnees:
etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes)
for IDetiquette in etiquettes:
if dictResultats.has_key(IDetiquette) == False:
dictResultats[IDetiquette] = 0
dictResultats[IDetiquette] += 1
return dictResultats
def SetParametres(self, texte=""):
if texte in ("", None) : return
listeDonnees = texte.split("##")
for donnee in listeDonnees :
champ, valeur = donnee.split(":=")
if champ == "ETIQUETTES" and valeur != None :
etiquettes = UTILS_Texte.ConvertStrToListe(valeur)
self.ctrl_etiquettes.SetCoches(etiquettes)
if champ == "ETAT" and valeur != None :
self.ctrl_etat.SetValeur(valeur)
if champ == "QUANTITE" and valeur != None :
self.ctrl_quantite.SetValue(int(valeur))
if champ == "HEUREDEBUT" and valeur != None :
heure_debut = valeur
if "FORMULE:" in heure_debut :
self.radio_heure_debut_formule.SetValue(True)
heure_debut = heure_debut.replace("FORMULE:", "")
self.ctrl_heure_debut_formule.SetValue(heure_debut)
else :
self.radio_heure_debut_fixe.SetValue(True)
if heure_debut not in (None, "") :
self.ctrl_heure_debut.SetHeure(heure_debut)
if champ == "HEUREFIN" and valeur != None :
heure_fin = valeur
if "FORMULE:" in heure_fin :
self.radio_heure_fin_formule.SetValue(True)
heure_fin = heure_fin.replace("FORMULE:", "")
self.ctrl_heure_fin_formule.SetValue(heure_fin)
else :
self.radio_heure_fin_fixe.SetValue(True)
if heure_fin not in (None, "") :
self.ctrl_heure_fin.SetHeure(heure_fin)
# Init contrôles
self.OnRadioHeureDebut(None)
self.OnRadioHeureFin(None)
def Importation(self):
""" Importation des valeurs """
db = GestionDB.DB()
req = """SELECT IDunite_remplissage, nom, abrege, seuil_alerte, date_debut, date_fin, heure_min, heure_max, afficher_page_accueil, afficher_grille_conso, etiquettes
FROM unites_remplissage WHERE IDunite_remplissage=%d;""" % self.IDunite_remplissage
db.ExecuterReq(req)
listeTemp = db.ResultatReq()
db.Close()
if len(listeTemp) == 0: return
listeTemp = listeTemp[0]
nom = listeTemp[1]
abrege = listeTemp[2]
seuil_alerte = listeTemp[3]
date_debut = listeTemp[4]
date_fin = listeTemp[5]
heure_min = listeTemp[6]
heure_max = listeTemp[7]
afficher_page_accueil = listeTemp[8]
afficher_grille_conso = listeTemp[9]
etiquettes = listeTemp[10]
self.ctrl_nom.SetValue(nom)
self.ctrl_abrege.SetValue(abrege)
self.ctrl_seuil.SetValue(seuil_alerte)
self.ctrl_heure_min.SetHeure(heure_min)
self.ctrl_heure_max.SetHeure(heure_max)
if date_debut != "1977-01-01" and date_fin != "2999-01-01":
self.ctrl_date_debut.SetDate(date_debut)
self.ctrl_date_fin.SetDate(date_fin)
self.radio_limitee.SetValue(True)
if afficher_page_accueil == 0:
self.check_afficher_page_accueil.SetValue(False)
if afficher_grille_conso == 0:
self.check_afficher_grille_conso.SetValue(False)
self.ctrl_etiquettes.SetCoches(
UTILS_Texte.ConvertStrToListe(etiquettes))
self.ctrl_unites.Importation()
def SelectModeRemboursement(self):
for index, dictTemp in self.ctrl_mode.dictDonnees.iteritems():
if "remboursement" in UTILS_Texte.Supprime_accent(
dictTemp["label"].lower()):
self.ctrl_mode.SetID(dictTemp["ID"])
def Importation(self):
DB = GestionDB.DB()
if len(self.listeGroupes) == 0: conditionGroupes = "()"
elif len(self.listeGroupes) == 1:
conditionGroupes = "(%d)" % self.listeGroupes[0]
else:
conditionGroupes = str(tuple(self.listeGroupes))
if self.affichage_mode == "reservation":
if len(self.affichage_etat) == 0:
conditionEtat = "()"
elif len(self.affichage_etat) == 1:
conditionEtat = "('%s')" % self.affichage_etat[0]
else:
conditionEtat = str(tuple(self.affichage_etat))
elif self.affichage_mode == "attente":
conditionEtat = "('attente')"
elif self.affichage_mode == "refus":
conditionEtat = "('refus')"
else:
conditionEtat = "()"
# Unités
req = """SELECT IDunite, nom, abrege
FROM unites
WHERE IDactivite=%d
ORDER BY ordre;""" % self.IDactivite
DB.ExecuterReq(req)
listeUnites = DB.ResultatReq()
# Groupes
req = """SELECT IDgroupe, nom, abrege
FROM groupes
WHERE IDactivite=%d
ORDER BY ordre;""" % self.IDactivite
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
# Evènements
self.dictEvenements = {}
req = """SELECT IDevenement, nom, date
FROM evenements
WHERE IDactivite=%d
AND date>='%s' AND date<='%s'
;""" % (self.IDactivite, self.date_debut, self.date_fin)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDevenement, nom, date in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
self.dictEvenements[IDevenement] = {"nom": nom, "date": date}
# Etiquettes
self.dictEtiquettes = {}
req = """SELECT IDetiquette, label, IDactivite, parent, ordre, couleur
FROM etiquettes;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDetiquette, label, IDactivite, parent, ordre, couleur in listeDonnees:
couleurTemp = couleur[1:-1].split(",")
couleur = wx.Colour(int(couleurTemp[0]), int(couleurTemp[1]),
int(couleurTemp[2]))
self.dictEtiquettes[IDetiquette] = {
"label": label,
"IDactivite": IDactivite,
"parent": parent,
"ordre": ordre,
"couleur": couleur
}
# Consommations
req = """SELECT IDconso, consommations.date, consommations.IDindividu, consommations.IDunite, consommations.IDgroupe, consommations.IDactivite, consommations.etiquettes,
heure_debut, heure_fin, etat, quantite, IDevenement, consommations.IDprestation, prestations.temps_facture,
comptes_payeurs.IDfamille,
activites.nom,
groupes.nom,
categories_tarifs.nom
FROM consommations
LEFT JOIN prestations ON prestations.IDprestation = consommations.IDprestation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur
LEFT JOIN activites ON activites.IDactivite = consommations.IDactivite
LEFT JOIN groupes ON groupes.IDgroupe = consommations.IDgroupe
LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = consommations.IDcategorie_tarif
WHERE consommations.IDactivite=%d AND consommations.IDgroupe IN %s
AND consommations.date>='%s' AND consommations.date<='%s'
AND etat IN %s
;""" % (self.IDactivite, conditionGroupes, self.date_debut,
self.date_fin, conditionEtat)
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
DB.Close()
# Calcul des données
dictResultats = {}
listePrestationsTraitees = []
for IDconso, date, IDindividu, IDunite, IDgroupe, IDactivite, etiquettes, heure_debut, heure_fin, etat, quantite, IDevenement, IDprestation, tempsFacture, IDfamille, nomActivite, nomGroupe, nomCategorie in listeConsommations:
date = DateEngEnDateDD(date)
mois = date.month
annee = date.year
# Recherche du regroupement
try:
if self.affichage_regroupement == "jour": regroupement = date
if self.affichage_regroupement == "mois":
regroupement = (annee, mois)
if self.affichage_regroupement == "annee": regroupement = annee
if self.affichage_regroupement == "activite":
regroupement = nomActivite
if self.affichage_regroupement == "groupe":
regroupement = nomGroupe
if self.affichage_regroupement == "evenement":
regroupement = IDevenement
if self.affichage_regroupement == "evenement_date":
regroupement = IDevenement
if self.affichage_regroupement == "categorie_tarif":
regroupement = nomCategorie
if self.affichage_regroupement == "ville_residence":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_VILLE"]
if self.affichage_regroupement == "secteur":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_SECTEUR"]
if self.affichage_regroupement == "genre":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_SEXE"]
if self.affichage_regroupement == "age":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_AGE_INT"]
if self.affichage_regroupement == "ville_naissance":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_VILLE_NAISS"]
if self.affichage_regroupement == "nom_ecole":
regroupement = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_ECOLE"]
if self.affichage_regroupement == "nom_classe":
regroupement = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_CLASSE"]
if self.affichage_regroupement == "nom_niveau_scolaire":
regroupement = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_NIVEAU"]
if self.affichage_regroupement == "famille":
regroupement = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM"]
if self.affichage_regroupement == "individu":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_NOM_COMPLET"]
if self.affichage_regroupement == "regime":
regroupement = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM_REGIME"]
if self.affichage_regroupement == "caisse":
regroupement = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM_CAISSE"]
if self.affichage_regroupement == "categorie_travail":
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_CATEGORIE_TRAVAIL"]
if self.affichage_regroupement == "categorie_travail_pere":
regroupement = self.dictInfosIndividus[IDindividu][
"PERE_CATEGORIE_TRAVAIL"]
if self.affichage_regroupement == "categorie_travail_mere":
regroupement = self.dictInfosIndividus[IDindividu][
"MERE_CATEGORIE_TRAVAIL"]
# QF
if self.affichage_regroupement == "qf":
regroupement = None
qf = self.dictInfosFamilles[IDfamille][
"FAMILLE_QF_ACTUEL_INT"]
for x in range(0, 10000, 100):
min, max = x, x + 99
if qf >= min and qf <= max:
regroupement = (min, max)
# Etiquettes
if self.affichage_regroupement == "etiquette":
etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes)
if len(etiquettes) > 0:
temp = []
for IDetiquette in etiquettes:
if self.dictEtiquettes.has_key(IDetiquette):
temp.append(
self.dictEtiquettes[IDetiquette]["label"])
regroupement = temp
else:
regroupement = _(u"- Aucune étiquette -")
# Questionnaires
if self.affichage_regroupement.startswith(
"question_"
) and "famille" in self.affichage_regroupement:
regroupement = self.dictInfosFamilles[IDfamille][
"QUESTION_%s" % self.affichage_regroupement[17:]]
if self.affichage_regroupement.startswith(
"question_"
) and "individu" in self.affichage_regroupement:
regroupement = self.dictInfosIndividus[IDindividu][
"QUESTION_%s" % self.affichage_regroupement[18:]]
except:
regroupement = None
if regroupement in ("", None):
regroupement = _(u"- Non renseigné -")
# Quantité
if quantite == None:
quantite = 1
# Formatage des heures
if heure_debut != None and heure_debut != "":
h, m = heure_debut.split(":")
heure_debut = datetime.time(int(h), int(m))
if heure_fin != None and heure_fin != "":
h, m = heure_fin.split(":")
heure_fin = datetime.time(int(h), int(m))
# Calcul du temps
temps_presence = datetime.timedelta(hours=0, minutes=0)
if heure_debut != None and heure_debut != "" and heure_fin != None and heure_fin != "":
valeur = datetime.timedelta(
hours=heure_fin.hour,
minutes=heure_fin.minute) - datetime.timedelta(
hours=heure_debut.hour, minutes=heure_debut.minute)
temps_presence += valeur
# Si c'est en fonction du temps facturé
temps_facture = datetime.timedelta(hours=0, minutes=0)
if tempsFacture != None and tempsFacture != "":
if IDprestation not in listePrestationsTraitees:
hr, mn = tempsFacture.split(":")
temps_facture += datetime.timedelta(hours=int(hr),
minutes=int(mn))
listePrestationsTraitees.append(IDprestation)
if self.detail_groupes == True:
groupe = IDgroupe
else:
groupe = None
if self.affichage_donnees == "quantite": valeur = quantite
if self.affichage_donnees == "temps_presence":
valeur = temps_presence
if self.affichage_donnees == "temps_facture":
valeur = temps_facture
if self.affichage_donnees == "quantite":
defaut = 0
else:
defaut = datetime.timedelta(hours=0, minutes=0)
# En cas de regroupements multiples :
if type(regroupement) == list:
listeRegroupements = regroupement
else:
listeRegroupements = [
regroupement,
]
for regroupement in listeRegroupements:
if dictResultats.has_key(groupe) == False:
dictResultats[groupe] = {}
if dictResultats[groupe].has_key(IDunite) == False:
dictResultats[groupe][IDunite] = {}
if dictResultats[groupe][IDunite].has_key(
regroupement) == False:
dictResultats[groupe][IDunite][regroupement] = defaut
dictResultats[groupe][IDunite][regroupement] += valeur
return dictResultats, listeUnites, listeGroupes
def GetXMLSepa(dictDonnees):
""" Génération du fichier XML SEPA """
doc = Document()
# Variables principales
type_remise = dictDonnees["type_remise"]
nom_fichier = dictDonnees["nom_fichier"]
remise_nom = dictDonnees["remise_nom"]
remise_date_heure = dictDonnees["remise_date_heure"]
remise_nbre = dictDonnees["remise_nbre"]
remise_montant = dictDonnees["remise_montant"]
creancier_nom = dictDonnees["creancier_nom"]
creancier_rue = dictDonnees["creancier_rue"]
creancier_cp = dictDonnees["creancier_cp"]
creancier_ville = dictDonnees["creancier_ville"]
creancier_pays = dictDonnees["creancier_pays"]
creancier_siret = dictDonnees["creancier_siret"]
listeLots = dictDonnees["lots"]
# Génération du document XML
racine = doc.createElement("Document")
racine.setAttribute("xmlns:xsi",
"http://www.w3.org/2001/XMLSchema-instance")
racine.setAttribute("xmlns",
"urn:iso:std:iso:20022:tech:xsd:pain.008.001.02")
doc.appendChild(racine)
# CstmrDrctDbtInitn
CstmrDrctDbtInitn = doc.createElement("CstmrDrctDbtInitn")
racine.appendChild(CstmrDrctDbtInitn)
# ----------------------------------------------------------- NIVEAU MESSAGE ------------------------------------------------------------------------------
# ------------- Caractéristiques générales du prélèvement -------------------
# GrpHdr
GrpHdr = doc.createElement("GrpHdr")
CstmrDrctDbtInitn.appendChild(GrpHdr)
# MsgId
MsgId = doc.createElement("MsgId")
GrpHdr.appendChild(MsgId)
if type_remise == "public_dft":
MsgId.appendChild(doc.createTextNode(nom_fichier))
else:
MsgId.appendChild(doc.createTextNode(remise_nom))
# CreDtTm
CreDtTm = doc.createElement("CreDtTm")
GrpHdr.appendChild(CreDtTm)
CreDtTm.appendChild(doc.createTextNode(remise_date_heure))
# NbOfTxs
NbOfTxs = doc.createElement("NbOfTxs")
GrpHdr.appendChild(NbOfTxs)
NbOfTxs.appendChild(doc.createTextNode(remise_nbre))
# CtrlSum
CtrlSum = doc.createElement("CtrlSum")
GrpHdr.appendChild(CtrlSum)
CtrlSum.appendChild(doc.createTextNode(remise_montant))
# ------------- Créantier (organisateur) -------------------
# InitgPty
InitgPty = doc.createElement("InitgPty")
GrpHdr.appendChild(InitgPty)
# Nm
Nm = doc.createElement("Nm")
InitgPty.appendChild(Nm)
Nm.appendChild(doc.createTextNode(creancier_nom[:70]))
# Id
Id = doc.createElement("Id")
InitgPty.appendChild(Id)
# OrgId
OrgId = doc.createElement("OrgId")
Id.appendChild(OrgId)
# Othr
Othr = doc.createElement("Othr")
OrgId.appendChild(Othr)
# Id
Id = doc.createElement("Id")
Othr.appendChild(Id)
Id.appendChild(doc.createTextNode(creancier_siret))
# SchmeNm
SchmeNm = doc.createElement("SchmeNm")
Othr.appendChild(SchmeNm)
# Prtry
Prtry = doc.createElement("Prtry")
SchmeNm.appendChild(Prtry)
Prtry.appendChild(doc.createTextNode("SIRET"))
# ----------------------------------------------------------- NIVEAU LOT ------------------------------------------------------------------------------
for dictLot in listeLots:
lot_nom = dictLot["lot_nom"]
lot_nbre = dictLot["lot_nbre"]
lot_montant = dictLot["lot_montant"]
lot_date = dictLot["lot_date"]
lot_iban = dictLot["lot_iban"]
lot_bic = dictLot["lot_bic"]
lot_ics = dictLot["lot_ics"]
lot_dft_titulaire = dictLot["dft_titulaire"]
lot_dft_iban = dictLot["dft_iban"]
lot_motif = dictLot["motif"]
lot_sequence = dictLot["lot_sequence"]
listeTransactions = dictLot["transactions"]
# PmtInf
PmtInf = doc.createElement("PmtInf")
CstmrDrctDbtInitn.appendChild(PmtInf)
# PmtInfId
PmtInfId = doc.createElement("PmtInfId")
PmtInf.appendChild(PmtInfId)
PmtInfId.appendChild(doc.createTextNode(lot_nom))
# PmtMtd
PmtMtd = doc.createElement("PmtMtd")
PmtInf.appendChild(PmtMtd)
PmtMtd.appendChild(doc.createTextNode("DD"))
# NbOfTxs
NbOfTxs = doc.createElement("NbOfTxs")
PmtInf.appendChild(NbOfTxs)
NbOfTxs.appendChild(doc.createTextNode(lot_nbre))
# CtrlSum
CtrlSum = doc.createElement("CtrlSum")
PmtInf.appendChild(CtrlSum)
CtrlSum.appendChild(doc.createTextNode(lot_montant))
# PmtTpInf
PmtTpInf = doc.createElement("PmtTpInf")
PmtInf.appendChild(PmtTpInf)
# SvcLvl
SvcLvl = doc.createElement("SvcLvl")
PmtTpInf.appendChild(SvcLvl)
# Cd
Cd = doc.createElement("Cd")
SvcLvl.appendChild(Cd)
Cd.appendChild(doc.createTextNode("SEPA"))
# LclInstrm
LclInstrm = doc.createElement("LclInstrm")
PmtTpInf.appendChild(LclInstrm)
# Cd
Cd = doc.createElement("Cd")
LclInstrm.appendChild(Cd)
Cd.appendChild(doc.createTextNode("CORE"))
# SeqTp
SeqTp = doc.createElement("SeqTp")
PmtTpInf.appendChild(SeqTp)
SeqTp.appendChild(doc.createTextNode(lot_sequence))
# ReqdColltnDt
ReqdColltnDt = doc.createElement("ReqdColltnDt")
PmtInf.appendChild(ReqdColltnDt)
ReqdColltnDt.appendChild(doc.createTextNode(lot_date))
# Cdtr
Cdtr = doc.createElement("Cdtr")
PmtInf.appendChild(Cdtr)
if type_remise == "prive":
# Cdtr
Nm = doc.createElement("Nm")
Cdtr.appendChild(Nm)
Nm.appendChild(doc.createTextNode(creancier_nom))
if type_remise == "public_dft":
perception = dictDonnees["perception"]
# Cdtr
Nm = doc.createElement("Nm")
Cdtr.appendChild(Nm)
Nm.appendChild(doc.createTextNode(perception["nom"]))
# PstlAdr
PstlAdr = doc.createElement("PstlAdr")
Cdtr.appendChild(PstlAdr)
# Ctry
Ctry = doc.createElement("Ctry")
PstlAdr.appendChild(Ctry)
Ctry.appendChild(doc.createTextNode("FR"))
# AdrLine
AdrLine = doc.createElement("AdrLine")
PstlAdr.appendChild(AdrLine)
AdrLine.appendChild(doc.createTextNode(perception["rue_resid"]))
# AdrLine
AdrLine = doc.createElement("AdrLine")
PstlAdr.appendChild(AdrLine)
AdrLine.appendChild(
doc.createTextNode(
u"%s %s" %
(perception["cp_resid"], perception["ville_resid"])))
# CdtrAcct
CdtrAcct = doc.createElement("CdtrAcct")
PmtInf.appendChild(CdtrAcct)
# Id
Id = doc.createElement("Id")
CdtrAcct.appendChild(Id)
# IBAN
IBAN = doc.createElement("IBAN")
Id.appendChild(IBAN)
IBAN.appendChild(doc.createTextNode(lot_iban))
# CdtrAgt
CdtrAgt = doc.createElement("CdtrAgt")
PmtInf.appendChild(CdtrAgt)
# FinInstnId
FinInstnId = doc.createElement("FinInstnId")
CdtrAgt.appendChild(FinInstnId)
# BIC
BIC = doc.createElement("BIC")
FinInstnId.appendChild(BIC)
BIC.appendChild(doc.createTextNode(lot_bic))
if type_remise == "public_dft":
# UltmtCdtr
UltmtCdtr = doc.createElement("UltmtCdtr")
PmtInf.appendChild(UltmtCdtr)
# Nm
Nm = doc.createElement("Nm")
UltmtCdtr.appendChild(Nm)
Nm.appendChild(doc.createTextNode(lot_dft_titulaire))
# Id
Id = doc.createElement("Id")
UltmtCdtr.appendChild(Id)
# OrgId
OrgId = doc.createElement("OrgId")
Id.appendChild(OrgId)
# Othr
Othr = doc.createElement("Othr")
OrgId.appendChild(Othr)
# Id
Id = doc.createElement("Id")
Othr.appendChild(Id)
Id.appendChild(doc.createTextNode(lot_dft_iban))
# ChrgBr
ChrgBr = doc.createElement("ChrgBr")
PmtInf.appendChild(ChrgBr)
ChrgBr.appendChild(doc.createTextNode("SLEV"))
# CdtrSchmeId
CdtrSchmeId = doc.createElement("CdtrSchmeId")
PmtInf.appendChild(CdtrSchmeId)
# Id
Id = doc.createElement("Id")
CdtrSchmeId.appendChild(Id)
# PrvtId
PrvtId = doc.createElement("PrvtId")
Id.appendChild(PrvtId)
# Othr
Othr = doc.createElement("Othr")
PrvtId.appendChild(Othr)
# Id
Id = doc.createElement("Id")
Othr.appendChild(Id)
Id.appendChild(doc.createTextNode(lot_ics))
# SchmeNm
SchmeNm = doc.createElement("SchmeNm")
Othr.appendChild(SchmeNm)
# Prtry
Prtry = doc.createElement("Prtry")
SchmeNm.appendChild(Prtry)
Prtry.appendChild(doc.createTextNode("SEPA"))
# ----------------------------------------------------------- NIVEAU TRANSACTION ------------------------------------------------------------------------------
for dictTransaction in listeTransactions:
transaction_id = dictTransaction["transaction_id"]
transaction_montant = dictTransaction["transaction_montant"]
transaction_mandat_id = dictTransaction["transaction_mandat_id"]
transaction_mandat_date = dictTransaction[
"transaction_mandat_date"]
transaction_bic = dictTransaction["transaction_bic"]
transaction_debiteur = dictTransaction["transaction_debiteur"]
transaction_iban = dictTransaction["transaction_iban"]
# DrctDbtTxInf
DrctDbtTxInf = doc.createElement("DrctDbtTxInf")
PmtInf.appendChild(DrctDbtTxInf)
# PmtId
PmtId = doc.createElement("PmtId")
DrctDbtTxInf.appendChild(PmtId)
# EndToEndId
EndToEndId = doc.createElement("EndToEndId")
PmtId.appendChild(EndToEndId)
if type_remise == "public_dft":
endtoend = "1D%s0%s" % (dictDonnees["poste_comptable"],
transaction_id)
EndToEndId.appendChild(doc.createTextNode(endtoend))
else:
EndToEndId.appendChild(doc.createTextNode(transaction_id))
# InstdAmt
InstdAmt = doc.createElement("InstdAmt")
DrctDbtTxInf.appendChild(InstdAmt)
InstdAmt.appendChild(doc.createTextNode(transaction_montant))
InstdAmt.setAttribute("Ccy", "EUR")
# DrctDbtTx
DrctDbtTx = doc.createElement("DrctDbtTx")
DrctDbtTxInf.appendChild(DrctDbtTx)
# MndtRltdInf
MndtRltdInf = doc.createElement("MndtRltdInf")
DrctDbtTx.appendChild(MndtRltdInf)
# MndtId
MndtId = doc.createElement("MndtId")
MndtRltdInf.appendChild(MndtId)
MndtId.appendChild(doc.createTextNode(transaction_mandat_id))
# DtOfSgntr
DtOfSgntr = doc.createElement("DtOfSgntr")
MndtRltdInf.appendChild(DtOfSgntr)
DtOfSgntr.appendChild(doc.createTextNode(transaction_mandat_date))
# AmdmntInd
AmdmntInd = doc.createElement("AmdmntInd")
MndtRltdInf.appendChild(AmdmntInd)
AmdmntInd.appendChild(doc.createTextNode("false"))
# DbtrAgt
DbtrAgt = doc.createElement("DbtrAgt")
DrctDbtTxInf.appendChild(DbtrAgt)
# FinInstnId
FinInstnId = doc.createElement("FinInstnId")
DbtrAgt.appendChild(FinInstnId)
# Dbtr
BIC = doc.createElement("BIC")
FinInstnId.appendChild(BIC)
BIC.appendChild(doc.createTextNode(transaction_bic))
# Dbtr
Dbtr = doc.createElement("Dbtr")
DrctDbtTxInf.appendChild(Dbtr)
# Nm
Nm = doc.createElement("Nm")
Dbtr.appendChild(Nm)
Nm.appendChild(
doc.createTextNode(
UTILS_Texte.Supprime_accent(transaction_debiteur[:70])))
# DbtrAcct
DbtrAcct = doc.createElement("DbtrAcct")
DrctDbtTxInf.appendChild(DbtrAcct)
# Id
Id = doc.createElement("Id")
DbtrAcct.appendChild(Id)
# IBAN
IBAN = doc.createElement("IBAN")
Id.appendChild(IBAN)
IBAN.appendChild(doc.createTextNode(transaction_iban))
if type_remise == "public_dft":
# RmtInf
RmtInf = doc.createElement("RmtInf")
DrctDbtTxInf.appendChild(RmtInf)
# Ustrd
Ustrd = doc.createElement("Ustrd")
RmtInf.appendChild(Ustrd)
Ustrd.appendChild(doc.createTextNode(lot_motif))
return doc
def Sauvegarde(self):
# Récupération des tracks
liste_tracks = self.ctrl_listview.GetTracksCoches()
# Récupération des paramètres
IDtype_cotisation = self.ctrl_parametres.ctrl_type.GetID()
IDunite_cotisation = self.ctrl_parametres.ctrl_unite.GetID()
date_saisie = self.ctrl_parametres.date_saisie
IDutilisateur = self.ctrl_parametres.IDutilisateur
date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate()
date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate()
activites = self.ctrl_parametres.ctrl_activites.GetDonnees(
format="texte")
observations = self.ctrl_parametres.ctrl_observations.GetValue()
type_cotisation = self.ctrl_parametres.ctrl_type.GetDetailDonnees(
)["type"]
# Vérifie que les cotisations n'existent pas déj�
liste_IDindividu = [
track.IDindividu for track in liste_tracks
if track.IDindividu != None
]
if len(liste_IDindividu) == 1:
condition_individus = "AND cotisations.IDindividu == %d" % liste_IDindividu[
0]
elif len(liste_IDindividu) > 1:
condition_individus = "AND cotisations.IDindividu IN %s" % str(
tuple(liste_IDindividu))
else:
condition_individus = ""
liste_IDfamille = [
track.IDfamille for track in liste_tracks
if track.IDfamille != None
]
if len(liste_IDfamille) == 1:
condition_familles = "AND cotisations.IDfamille == %d" % liste_IDfamille[
0]
elif len(liste_IDfamille) > 1:
condition_familles = "AND cotisations.IDfamille IN %s" % str(
tuple(liste_IDfamille))
else:
condition_familles = ""
DB = GestionDB.DB()
req = """SELECT IDcotisation, IDfamille, cotisations.IDindividu, numero, individus.prenom, individus.nom
FROM cotisations
LEFT JOIN individus ON individus.IDindividu = cotisations.IDindividu
WHERE IDtype_cotisation=%d AND IDunite_cotisation=%d
%s %s;""" % (IDtype_cotisation, IDunite_cotisation,
condition_individus, condition_familles)
DB.ExecuterReq(req)
listeCotisationsExistantes = DB.ResultatReq()
DB.Close()
if len(listeCotisationsExistantes) > 0:
dictTitulaires = UTILS_Titulaires.GetTitulaires()
liste_details = []
for IDcotisation, IDfamille, IDindividu, numero, prenom_individu, nom_individu in listeCotisationsExistantes:
# Si cotisation familiale
if IDfamille != None and IDfamille in dictTitulaires:
nom_famille = dictTitulaires[IDfamille][
"titulairesSansCivilite"]
liste_details.append(
_(u"Famille de %s : Cotisation n°%s") %
(nom_famille, numero))
# Si cotisation individuelle
if IDindividu != None:
if prenom_individu == None: prenom_individu = ""
liste_details.append(
_(u"%s %s : Cotisation n°%s") %
(nom_individu, prenom_individu, numero))
# Demande si on continue ou non
intro = _(
u"Les cotisations suivantes existent déjà avec le même type et la même unité de cotisation :"
)
conclusion = _(
u"Souhaitez-vous quand même les générer une nouvelle fois ?"
)
detail = "\n".join(liste_details)
dlg = DLG_Messagebox.Dialog(
self,
titre=_(u"Avertissement"),
introduction=intro,
detail=detail,
conclusion=conclusion,
icone=wx.ICON_EXCLAMATION,
boutons=[_(u"Oui"), _(u"Non"),
_(u"Annuler")])
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse in (1, 2):
return False
# Création de la carte
if self.ctrl_parametres.ctrl_creation.GetValue() == True:
numero_manuel = self.ctrl_parametres.radio_numero_manuel.GetValue()
date_creation_carte = self.ctrl_parametres.ctrl_date_creation.GetDate(
)
numero = self.ctrl_parametres.ctrl_numero.GetValue()
else:
numero_manuel = False
date_creation_carte = None
numero = None
# Confirmation
dlg = wx.MessageDialog(
self,
_(u"Confirmez-vous la génération de %d cotisations ?") %
len(liste_tracks), _(u"Confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
# Sauvegarde
DB = GestionDB.DB()
dlgprogress = wx.ProgressDialog(_(u"Génération des cotisations"),
_(u"Veuillez patienter..."),
maximum=len(liste_tracks),
parent=None,
style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE
| wx.PD_APP_MODAL)
index = 1
for track in liste_tracks:
dlgprogress.Update(
index,
_(u"Génération de la cotisation %d sur %d") %
(index, len(liste_tracks)))
if numero_manuel == True:
numero = track.numero
if type_cotisation == "famille":
IDfamille = track.IDfamille
else:
IDfamille = None
listeDonnees = [
("IDfamille", IDfamille),
("IDindividu", track.IDindividu),
("IDtype_cotisation", IDtype_cotisation),
("IDunite_cotisation", IDunite_cotisation),
("date_saisie", date_saisie),
("IDutilisateur", IDutilisateur),
("date_creation_carte", date_creation_carte),
("numero", numero),
("date_debut", date_debut),
("date_fin", date_fin),
("observations", observations),
("activites", activites),
]
IDcotisation = DB.ReqInsert("cotisations", listeDonnees)
# Sauvegarde de la prestation
facturer = self.ctrl_parametres.ctrl_facturer.GetValue()
date_facturation = self.ctrl_parametres.ctrl_date_prestation.GetDate(
)
montant = self.ctrl_parametres.ctrl_montant.GetMontant()
label_prestation = self.ctrl_parametres.ctrl_label.GetValue()
if facturer == True:
# Création d'une prestation
listeDonnees = [
("IDcompte_payeur", track.IDcompte_payeur),
("date", date_facturation),
("categorie", "cotisation"),
("label", label_prestation),
("montant_initial", montant),
("montant", montant),
("IDfamille", track.IDfamille),
("IDindividu", track.IDindividu),
]
listeDonnees.append(
("date_valeur", str(datetime.date.today())))
IDprestation = DB.ReqInsert("prestations", listeDonnees)
# Insertion du IDprestation dans la cotisation
DB.ReqMAJ("cotisations", [
("IDprestation", IDprestation),
], "IDcotisation", IDcotisation)
# Mémorise l'action dans l'historique
date_debut_periode = UTILS_Dates.DateEngFr(str(date_debut))
date_fin_periode = UTILS_Dates.DateEngFr(str(date_fin))
UTILS_Historique.InsertActions([
{
"IDindividu":
track.IDindividu,
"IDfamille":
track.IDfamille,
"IDcategorie":
21,
"action":
_(u"Saisie de la cotisation ID%d '%s' pour la période du %s au %s"
) % (IDcotisation, label_prestation, date_debut_periode,
date_fin_periode),
},
])
# Génération du prochain numéro de cotisation
if numero != None:
numero = UTILS_Texte.Incrementer(numero)
index += 1
DB.Close()
dlgprogress.Destroy()
# Succès
dlg = wx.MessageDialog(
self,
_(u"Les %d cotisations ont été générées avec succès.") %
len(liste_tracks), _(u"Fin"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
# MAJ
self.ctrl_listview.MAJ()
return True
def Importation(self, DBtemp=None):
""" Importation depuis la base """
dictValeurs = {}
# Lecture de la base
if DBtemp == None:
DB = GestionDB.DB()
else:
DB = DBtemp
# Informations générales sur le contrat
if self.IDcontrat != None:
req = """SELECT contrats.IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type,
duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning,
individus.nom, individus.prenom
FROM contrats
LEFT JOIN individus ON individus.IDindividu = contrats.IDindividu
WHERE IDcontrat=%d
;""" % self.IDcontrat
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type_contrat, duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning, individu_nom, individu_prenom = listeDonnees[
0]
self.IDinscription = IDinscription
dictValeurs["IDinscription"] = self.IDinscription
dictValeurs["date_debut"] = UTILS_Dates.DateEngEnDateDD(
date_debut)
dictValeurs["date_fin"] = UTILS_Dates.DateEngEnDateDD(date_fin)
dictValeurs["observations"] = observations
dictValeurs["IDactivite"] = IDactivite
dictValeurs["type_contrat"] = type_contrat
dictValeurs[
"duree_absences_prevues"] = UTILS_Dates.HeureStrEnDelta(
duree_absences_prevues)
dictValeurs[
"duree_heures_regularisation"] = UTILS_Dates.HeureStrEnDelta(
duree_heures_regularisation)
dictValeurs[
"duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta(
duree_tolerance_depassement)
dictValeurs["individu_nom"] = individu_nom
dictValeurs["individu_prenom"] = individu_prenom
dictValeurs["arrondi_type"] = arrondi_type
dictValeurs["arrondi_delta"] = arrondi_delta
dictValeurs["planning"] = planning
if individu_prenom != None:
dictValeurs["individu_nom_complet"] = u"%s %s" % (
individu_nom, individu_prenom)
else:
dictValeurs["individu_nom_complet"] = individu_nom
# Importation des données de l'inscription
if self.IDinscription != None:
req = """SELECT IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti
FROM inscriptions
WHERE inscriptions.statut='ok' AND IDinscription=%d
;""" % self.IDinscription
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti = listeDonnees[
0]
dictValeurs["IDinscription"] = self.IDinscription
dictValeurs["IDindividu"] = IDindividu
dictValeurs["IDfamille"] = IDfamille
dictValeurs["IDactivite"] = IDactivite
dictValeurs["IDgroupe"] = IDgroupe
dictValeurs["IDcategorie_tarif"] = IDcategorie_tarif
dictValeurs["IDcompte_payeur"] = IDcompte_payeur
dictValeurs["date_inscription"] = date_inscription
dictValeurs["parti"] = parti
# Infos sur le dernier contrat saisi
req = """SELECT arrondi_type, arrondi_delta, duree_tolerance_depassement
FROM contrats
WHERE type='psu' AND IDactivite=%d
ORDER BY IDcontrat DESC LIMIT 1
;""" % IDactivite
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
arrondi_type, arrondi_delta, duree_tolerance_depassement = listeDonnees[
0]
dictValeurs["arrondi_type"] = arrondi_type
dictValeurs["arrondi_delta"] = arrondi_delta
dictValeurs[
"duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta(
duree_tolerance_depassement)
# Informations sur l'activité
req = """SELECT psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt
FROM activites
WHERE IDactivite=%d
;""" % dictValeurs["IDactivite"]
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt = listeDonnees[
0]
dictValeurs["IDunite_prevision"] = psu_unite_prevision
dictValeurs["IDunite_presence"] = psu_unite_presence
dictValeurs["IDtarif"] = psu_tarif_forfait
dictValeurs["psu_etiquette_rtt"] = psu_etiquette_rtt
dictValeurs["duree_absences_prises"] = datetime.timedelta(0)
# Mémorise les données déjà importées
self.SetValeurs(dictValeurs)
# Echap sur nouveau contrat
if self.IDcontrat == None:
DB.Close()
return
# Lecture des consommations
req = """SELECT IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, consommations.etat, verrouillage, date_saisie, IDutilisateur,
IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes
FROM consommations
WHERE IDinscription=%d AND date>='%s' AND date<='%s'
;""" % (self.IDinscription, dictValeurs["date_debut"],
dictValeurs["date_fin"])
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
tracks_previsions = []
liste_IDconso = []
liste_conso = []
dict_conso = {}
for IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, verrouillage, date_saisie, IDutilisateur, IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
date_saisie = UTILS_Dates.DateEngEnDateDD(date_saisie)
heure_debut_time = UTILS_Dates.HeureStrEnTime(heure_debut)
heure_fin_time = UTILS_Dates.HeureStrEnTime(heure_fin)
etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes)
dictConso = {
"IDconso": IDconso,
"date": date,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"etat": etat,
"verrouillage": verrouillage,
"date_saisie": date_saisie,
"IDutilisateur": IDutilisateur,
"IDcategorie_tarif": IDcategorie_tarif,
"IDprestation": IDprestation,
"forfait": forfait,
"quantite": quantite,
"etiquettes": etiquettes,
"heure_debut_time": heure_debut_time,
"heure_fin_time": heure_fin_time,
}
track = Track_conso(self, dictConso)
liste_conso.append(track)
if (date in dict_conso) == False:
dict_conso[date] = []
dict_conso[date].append(track)
if IDunite == self.GetValeur("IDunite_prevision", None):
tracks_previsions.append(track)
liste_IDconso.append(IDconso)
if dictValeurs["psu_etiquette_rtt"] in etiquettes:
dictValeurs["duree_absences_prises"] += track.duree_arrondie
dictValeurs["liste_conso"] = liste_conso
dictValeurs["dict_conso"] = dict_conso
dictValeurs["tracks_previsions"] = tracks_previsions
dictValeurs["liste_IDconso"] = liste_IDconso
# Lecture des tarifs du contrat
req = """SELECT IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement
FROM contrats_tarifs
WHERE IDcontrat=%d
;""" % self.IDcontrat
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
tracks_tarifs = []
liste_IDtarif = []
for IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
dictTarif = {
"IDcontrat_tarif": IDcontrat_tarif,
"date_debut": date_debut,
"revenu": revenu,
"quotient": quotient,
"taux": taux,
"tarif_base": tarif_base,
"tarif_depassement": tarif_depassement,
}
tracks_tarifs.append(Track_tarif(dictTarif))
liste_IDtarif.append(IDcontrat_tarif)
dictValeurs["tracks_tarifs"] = tracks_tarifs
dictValeurs["liste_IDtarif"] = liste_IDtarif
# Lecture des mensualités
req = """SELECT IDprestation, date, label, montant_initial, prestations.montant, prestations.IDfacture, temps_facture,
forfait_date_debut, forfait_date_fin, factures.numero
FROM prestations
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
WHERE IDcontrat=%d
;""" % self.IDcontrat
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_prestations = []
liste_IDprestation = []
for IDprestation, date_facturation, label, montant_initial, montant, IDfacture, temps_facture, forfait_date_debut, forfait_date_fin, num_facture in listeDonnees:
date_facturation = UTILS_Dates.DateEngEnDateDD(date_facturation)
forfait_date_debut = UTILS_Dates.DateEngEnDateDD(
forfait_date_debut)
forfait_date_fin = UTILS_Dates.DateEngEnDateDD(forfait_date_fin)
montant_initial = FloatToDecimal(montant_initial)
montant = FloatToDecimal(montant)
temps_facture = UTILS_Dates.HeureStrEnDelta(temps_facture)
dictMensualite = {
"IDprestation": IDprestation,
"date_facturation": date_facturation,
"label": label,
"montant_initial": montant_initial,
"montant": montant,
"IDfacture": IDfacture,
"temps_facture": temps_facture,
"forfait_date_debut": forfait_date_debut,
"forfait_date_fin": forfait_date_fin,
"num_facture": num_facture,
}
liste_prestations.append(dictMensualite)
liste_IDprestation.append(IDprestation)
dictValeurs["liste_prestations"] = liste_prestations
dictValeurs["liste_IDprestation"] = liste_IDprestation
# Fermeture de la base
if DBtemp == None:
DB.Close()
# Mémorisation des données
self.SetValeurs(dictValeurs)
def __init__(self, parent, index=None, item=None):
self.parent = parent
self.index = index
self.nom = item[0]
self.categories = UTILS_Texte.ConvertStrToListe(item[1])
self.MAJ()
def GetPropositionsLocations(dictFiltresSelection={},
dictDemandeSelection=None,
uniquement_disponibles=True):
DB = GestionDB.DB()
# Importation des questionnaires des produits
req = """SELECT IDreponse, IDquestion, reponse, IDdonnee
FROM questionnaire_reponses
WHERE type='produit';"""
DB.ExecuterReq(req)
listeReponses = DB.ResultatReq()
dictReponses = {}
for IDreponse, IDquestion, reponse, IDproduit in listeReponses:
dictTemp = {
"IDreponse": IDreponse,
"IDquestion": IDquestion,
"reponse": reponse
}
if dictReponses.has_key(IDproduit) == False:
dictReponses[IDproduit] = []
dictReponses[IDproduit].append(dictTemp)
# Recherche les produits non disponibles
dictLocations = GetProduitsLoues(DB=DB)
# Importation des produits
req = """SELECT IDproduit, IDcategorie, nom, quantite
FROM produits;"""
DB.ExecuterReq(req)
listeProduitsTemp = DB.ResultatReq()
listeProduits = []
dictProduits = {}
dictProduitsByCategories = {}
for IDproduit, IDcategorie, nom, quantite in listeProduitsTemp:
if quantite == None:
quantite = 1
# Recherche les réponses au questionnaire du produit
if dictReponses.has_key(IDproduit):
reponses = dictReponses[IDproduit]
else:
reponses = []
# Recherche les locations en cours du produit
if dictLocations.has_key(IDproduit):
disponible = quantite
for dictLocation in dictLocations[IDproduit]:
disponible -= dictLocation["quantite"]
else:
disponible = quantite
if uniquement_disponibles == False or disponible > 0:
dictTemp = {
"IDproduit": IDproduit,
"IDcategorie": IDcategorie,
"disponible": disponible,
"nom": nom,
"reponses": reponses
}
listeProduits.append(dictTemp)
dictProduits[IDproduit] = dictTemp
if dictProduitsByCategories.has_key(IDcategorie) == False:
dictProduitsByCategories[IDcategorie] = []
dictProduitsByCategories[IDcategorie].append(dictTemp)
# Recherche les filtres de questionnaires
req = """SELECT IDfiltre, questionnaire_filtres.IDquestion, choix, criteres, IDdonnee,
questionnaire_categories.type, controle
FROM questionnaire_filtres
LEFT JOIN questionnaire_questions ON questionnaire_questions.IDquestion = questionnaire_filtres.IDquestion
LEFT JOIN questionnaire_categories ON questionnaire_categories.IDcategorie = questionnaire_questions.IDcategorie
WHERE categorie='location_demande';"""
DB.ExecuterReq(req)
listeFiltres = DB.ResultatReq()
dictFiltres = {}
for IDfiltre, IDquestion, choix, criteres, IDdemande, type, controle in listeFiltres:
if dictFiltres.has_key(IDdemande) == False:
dictFiltres[IDdemande] = []
dictFiltres[IDdemande].append({
"IDfiltre": IDfiltre,
"IDquestion": IDquestion,
"choix": choix,
"criteres": criteres,
"type": type,
"controle": controle
})
# Ajoute ou remplace avec le dictDemandeSelection
if dictFiltresSelection != None:
for IDdemande, listeFiltres in dictFiltresSelection.iteritems():
dictFiltres[IDdemande] = listeFiltres
# Importation des demandes de locations
# if dictDemande == None :
# req = """SELECT IDdemande, date, IDfamille, categories, produits
# FROM locations_demandes
# WHERE statut='attente'
# ORDER BY IDdemande;"""
# DB.ExecuterReq(req)
# listeDemandes = DB.ResultatReq()
# else :
# listeDemandes = [dictDemande,]
req = """SELECT IDdemande, date, IDfamille, categories, produits
FROM locations_demandes
WHERE statut='attente'
ORDER BY IDdemande;"""
DB.ExecuterReq(req)
listeDemandes = DB.ResultatReq()
if dictDemandeSelection != None and dictDemandeSelection[
"IDdemande"] == None:
listeDemandes.append(dictDemandeSelection)
DB.Close()
# Parcours les demandes
dictControles = UTILS_Filtres_questionnaires.GetDictControles()
dictPropositions = {}
dictPositions = {}
for demande in listeDemandes:
# Met les données dans un dict
if not isinstance(demande, dict):
categories = UTILS_Texte.ConvertStrToListe(demande[3], siVide=[])
produits = UTILS_Texte.ConvertStrToListe(demande[4], siVide=[])
dictDemandeTemp = {
"IDdemande": demande[0],
"date": demande[1],
"IDfamille": demande[2],
"categories": categories,
"produits": produits
}
else:
dictDemandeTemp = demande
if dictDemandeSelection != None and dictDemandeSelection[
"IDdemande"] == dictDemandeTemp["IDdemande"]:
dictDemandeTemp = dictDemandeSelection
IDdemande = dictDemandeTemp["IDdemande"]
# Pré-sélection des produits à étudier
listeProduitsTemp = []
if dictDemandeTemp["categories"] != []:
for IDcategorie in dictDemandeTemp["categories"]:
if dictProduitsByCategories.has_key(IDcategorie):
listeProduitsTemp.extend(
dictProduitsByCategories[IDcategorie])
if dictDemandeTemp["produits"] != []:
for IDproduit in dictDemandeTemp["produits"]:
dictProduit = dictProduits[IDproduit]
if dictProduits.has_key(
IDproduit) and dictProduit not in listeProduitsTemp:
if dictDemandeTemp["categories"] == [] or dictProduit[
"IDcategorie"] in dictDemandeTemp["categories"]:
listeProduitsTemp.append(dictProduit)
if len(listeProduitsTemp) == 0:
listeProduitsTemp = listeProduits
# Parcours les produits
for dictProduit in listeProduitsTemp:
valide = True
# # Vérifie si le produit est dans la liste des catégories souhaitées
# if valide == True and dictDemandeTemp["categories"] != [] and dictProduit["IDcategorie"] not in dictDemandeTemp["categories"] :
# valide = False
#
# # Vérifie si le produit est dans la liste des produits souhaités
# if valide == True and dictDemandeTemp["produits"] != [] and dictProduit["IDproduit"] not in dictDemandeTemp["produits"] :
# valide = False
# Vérifie si le produit répond aux filtres de la demande
if valide == True and dictFiltres.has_key(IDdemande):
for dictFiltre in dictFiltres[IDdemande]:
for dictReponse in dictProduit["reponses"]:
resultat = UTILS_Filtres_questionnaires.Filtre(
controle=dictFiltre["controle"],
choix=dictFiltre["choix"],
criteres=dictFiltre["criteres"],
reponse=dictReponse["reponse"],
dictControles=dictControles)
if resultat == False:
valide = False
# Mémorisation de la proposition
if valide == True:
# Position dans la liste du produit
if dictPositions.has_key(dictProduit["IDproduit"]) == False:
dictPositions[dictProduit["IDproduit"]] = 0
dictPositions[dictProduit["IDproduit"]] += 1
position = dictPositions[dictProduit["IDproduit"]]
# Proposition
dictProduit = dict(dictProduit)
if dictPropositions.has_key(IDdemande) == False:
dictPropositions[IDdemande] = []
dictProduit["position"] = position
dictPropositions[IDdemande].append(dictProduit)
return dictPropositions
def __init__(self, listview=None, donnees=None):
self.IDdemande = donnees[0]
self.date = donnees[1]
self.IDfamille = donnees[2]
self.observations = donnees[3]
# Catégories
self.categories = UTILS_Texte.ConvertStrToListe(donnees[4], siVide=[])
liste_labels = []
for IDcategorie in self.categories :
if IDcategorie in listview.dictCategories :
liste_labels.append(listview.dictCategories[IDcategorie])
self.texte_categories = ", ".join(liste_labels)
# Produits
self.produits = UTILS_Texte.ConvertStrToListe(donnees[5], siVide=[])
liste_labels = []
for IDproduit in self.produits :
if IDproduit in listview.dictProduits :
liste_labels.append(listview.dictProduits[IDproduit])
self.texte_produits = ", ".join(liste_labels)
# Statut
self.statut = donnees[6]
# Position
self.position = None
# Vérifie s'il y a des propositions de produits
if self.statut == "refusee" :
self.texte_statut = _(u"Refusée")
elif self.statut == "attribuee" :
self.texte_statut = _(u"Demande satisfaite")
elif self.statut == "attente" :
if self.IDdemande in listview.dictPropositions :
# Recherche disponibilités
listeProduitsProposes = listview.dictPropositions[self.IDdemande]
if len(listeProduitsProposes) == 0 :
self.texte_statut = _(u"En attente")
elif len(listeProduitsProposes) == 1 :
self.texte_statut = _(u"1 produit disponible")
else :
self.texte_statut = _(u"%d produits disponibles") % len(listeProduitsProposes)
self.statut = "disponibilite"
# Recherche meilleure position
self.position = UTILS_Locations.GetMeilleurePosition(dictPropositions=listview.dictPropositions, IDdemande=self.IDdemande)
else :
self.texte_statut = _(u"En attente")
# Formatage date
if isinstance(self.date, str) or isinstance(self.date, six.text_type) :
self.date = datetime.datetime.strptime(self.date, "%Y-%m-%d %H:%M:%S")
# Récupération des réponses des questionnaires
for dictQuestion in listview.liste_questions :
setattr(self, "question_%d" % dictQuestion["IDquestion"], listview.GetReponse(dictQuestion["IDquestion"], self.IDdemande))
# Famille
if listview.IDfamille == None :
self.nomTitulaires = listview.dict_titulaires[self.IDfamille]["titulairesSansCivilite"]
self.rue = listview.dict_titulaires[self.IDfamille]["adresse"]["rue"]
self.cp = listview.dict_titulaires[self.IDfamille]["adresse"]["cp"]
self.ville = listview.dict_titulaires[self.IDfamille]["adresse"]["ville"]
def GetHTML(self, IDactivite=None):
if IDactivite == None:
return ""
DB = GestionDB.DB()
# Importation des infos sur l'activité
req = """SELECT nom, date_debut, date_fin
FROM activites
WHERE IDactivite=%d
;""" % IDactivite
DB.ExecuterReq(req)
listeInfos = DB.ResultatReq()
if len(listeInfos) == 0:
return ""
activite_nom, activite_date_debut, activite_date_fin = listeInfos[0]
# Importation des tarifs
req = """SELECT IDtarif, categories_tarifs, date_debut, date_fin, methode, noms_tarifs.IDnom_tarif, noms_tarifs.nom
FROM tarifs
LEFT JOIN noms_tarifs ON noms_tarifs.IDnom_tarif = tarifs.IDnom_tarif
WHERE tarifs.IDactivite=%d
ORDER BY date_debut DESC;""" % IDactivite
DB.ExecuterReq(req)
listeTarifs = DB.ResultatReq()
req = """SELECT IDcategorie_tarif, nom
FROM categories_tarifs
WHERE IDactivite=%d;""" % IDactivite
DB.ExecuterReq(req)
listeCategories = DB.ResultatReq()
dictCategories = {}
for IDcategorie_tarif, nom in listeCategories:
dictCategories[IDcategorie_tarif] = nom
# Importation des lignes de tarif
champsTable = ", ".join(CHAMPS_TABLE_LIGNES)
req = """SELECT %s
FROM tarifs_lignes
WHERE IDactivite=%d
ORDER BY num_ligne;""" % (champsTable, IDactivite)
DB.ExecuterReq(req)
listeLignes = DB.ResultatReq()
DB.Close()
source = []
source.append(u"<FONT SIZE=+1><B>%s</B></FONT>" % activite_nom)
source.append(u"<HR WIDTH='100%'>")
if len(listeTarifs) == 0:
source.append(u"<P>Aucun tarif</P>")
for IDtarif, categories_tarifs, date_debut, date_fin, methode, IDnom_tarif, nom_prestation in listeTarifs:
listeCategories = UTILS_Texte.ConvertStrToListe(categories_tarifs)
liste_temp = []
for IDcategorie_tarif in listeCategories:
liste_temp.append(dictCategories[IDcategorie_tarif])
texte_categories = u", ".join(liste_temp)
if True: #IDtarif in liste_tarifs_valides :
# Création des champs
index = 0
for dictMethode in LISTE_METHODES:
if dictMethode["code"] == methode:
champs = dictMethode["champs"]
index += 1
tableau = []
ligne = []
dict_remplissage_colonnes = {}
numColonne = 0
for code in champs:
for dict_colonne in LISTE_COLONNES:
if dict_colonne["code"] == code:
ligne.append(dict_colonne["label"])
dict_remplissage_colonnes[numColonne] = 0
numColonne += 1
tableau.append(ligne)
numLigne = 0
for valeurs in listeLignes:
IDtarif_ligne = valeurs[2]
code = valeurs[3]
ligne = []
if IDtarif == IDtarif_ligne:
dictValeurs = {}
# Récupération des valeurs de la base
indexValeur = 0
for valeur in valeurs:
if valeur == "None": valeur = None
dictValeurs[
CHAMPS_TABLE_LIGNES[indexValeur]] = valeur
indexValeur += 1
# Remplissage de la ligne
numColonne = 0
for codeChamp in champs:
valeur = dictValeurs[codeChamp]
if type(valeur) == int or type(valeur) == float:
if codeChamp in ("montant_unique",
"montant_min", "montant_max",
"ajustement", "revenu_min",
"revenu_max"):
valeur = u"%.2f %s" % (valeur, SYMBOLE)
else:
valeur = str(valeur)
if valeur == "None": valeur = ""
if codeChamp == "date" and valeur != None:
valeur = UTILS_Dates.DateEngFr(valeur)
if valeur == None: valeur = ""
ligne.append(valeur)
if valeur != "":
dict_remplissage_colonnes[numColonne] += 1
numColonne += 1
tableau.append(ligne)
numLigne += 1
# Enlève des colonnes vides
numColonne = 0
tableau2 = []
for ligne in tableau:
ligne2 = []
numColonne = 0
for valeur in ligne:
if dict_remplissage_colonnes[numColonne] > 0:
ligne2.append(valeur)
numColonne += 1
tableau2.append(ligne2)
#print (nom_prestation, date_debut, date_fin)
#for ligne in tableau2 :
# print " ", ligne
source.append(
u"<P><B>%s</B><BR><FONT SIZE=-2>%s - Tarif à partir du %s</FONT></P>"
% (nom_prestation, texte_categories,
UTILS_Dates.DateEngFr(date_debut)))
source.append(u"<P><TABLE BORDER CELLSPACING=1 BORDER=0>")
for ligne in tableau2:
source.append(u"<TR ALIGN=CENTER>")
for valeur in ligne:
source.append(u"<TD>%s</TD>" % valeur)
source.append(u"</TR>")
source.append(u"</TABLE></P>")
return "\n".join(source)
def OnBoutonOk(self, event):
# Date et heure de la demande
date_demande = self.ctrl_date_demande.GetDate()
if date_demande == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date pour cette demande !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_demande.SetFocus()
return
heure_demande = self.ctrl_heure_demande.GetHeure()
if heure_demande == None or self.ctrl_heure_demande.Validation(
) == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une heure pour cette demande !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_demande.SetFocus()
return
date_demande = datetime.datetime(year=date_demande.year,
month=date_demande.month,
day=date_demande.day,
hour=int(heure_demande[:2]),
minute=int(heure_demande[3:]))
# Loueur
IDfamille = self.ctrl_loueur.GetIDfamille()
if IDfamille == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un loueur pour cette demande !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Observations
observations = self.ctrl_observations.GetValue()
# Critères
categories = UTILS_Texte.ConvertListeToStr(
self.notebook.GetPage(
"criteres").ctrl_categories.GetListeCategories())
produits = UTILS_Texte.ConvertListeToStr(
self.notebook.GetPage("criteres").ctrl_produits.GetListeProduits())
# Statut
statut = self.ctrl_statut.GetCodePageActive()
motif_refus = self.ctrl_statut.GetPageByCode(
"refusee").ctrl_motif.GetValue()
IDlocation = self.ctrl_attribution.GetIDlocation(
) # self.ctrl_statut.GetPageByCode("attribuee").GetIDlocation()
if IDlocation != None:
statut = "attribuee"
# Sauvegarde
DB = GestionDB.DB()
listeDonnees = [
("date", date_demande),
("IDfamille", IDfamille),
("observations", observations),
("categories", categories),
("produits", produits),
("statut", statut),
("motif_refus", motif_refus),
("IDlocation", IDlocation),
]
if self.IDdemande == None:
self.IDdemande = DB.ReqInsert("locations_demandes", listeDonnees)
else:
DB.ReqMAJ("locations_demandes", listeDonnees, "IDdemande",
self.IDdemande)
# Sauvegarde des filtres
listeID = []
for dictFiltre in self.notebook.GetPage(
"criteres").ctrl_filtres.GetDonnees():
listeID.append(dictFiltre["IDfiltre"])
listeDonnees = [
("IDquestion", dictFiltre["IDquestion"]),
("categorie", "location_demande"),
("choix", dictFiltre["choix"]),
("criteres", dictFiltre["criteres"]),
("IDdonnee", self.IDdemande),
]
# Sauvegarde dans DB
if dictFiltre["IDfiltre"] == None:
IDfiltre = DB.ReqInsert("questionnaire_filtres", listeDonnees)
else:
DB.ReqMAJ("questionnaire_filtres", listeDonnees, "IDfiltre",
dictFiltre["IDfiltre"])
for dictInitialFiltre in self.listeInitialeFiltres:
if dictInitialFiltre["IDfiltre"] not in listeID:
DB.ReqDEL("questionnaire_filtres", "IDfiltre",
dictInitialFiltre["IDfiltre"])
# Sauvegarde du questionnaire
self.notebook.GetPage("questionnaire").ctrl_questionnaire.Sauvegarde(
DB=DB, IDdonnee=self.IDdemande)
# Fermeture de la base
DB.Close()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def Importation(self):
""" Importation des données """
if self.IDdemande != None:
DB = GestionDB.DB()
req = """SELECT date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation
FROM locations_demandes WHERE IDdemande=%d;""" % self.IDdemande
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation = listeDonnees[
0]
req = """SELECT IDfiltre, IDquestion, categorie, choix, criteres FROM questionnaire_filtres WHERE categorie='location_demande' AND IDdonnee=%d;""" % self.IDdemande
DB.ExecuterReq(req)
listeFiltres = DB.ResultatReq()
DB.Close()
else:
date = None
IDfamille = None
observations = ""
categories = ""
produits = ""
statut = "attente"
motif_refus = ""
IDlocation = None
listeFiltres = []
# Généralités
if date != None:
self.ctrl_date_demande.SetDate(
datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date),
"%Y-%m-%d"))
self.ctrl_heure_demande.SetHeure(
datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date),
"%H:%M"))
if IDfamille != None:
self.ctrl_loueur.SetIDfamille(IDfamille)
if observations != None:
self.ctrl_observations.SetValue(observations)
# Critères
self.notebook.GetPage("criteres").ctrl_categories.SetListeCategories(
UTILS_Texte.ConvertStrToListe(categories))
self.notebook.GetPage("criteres").ctrl_produits.SetListeProduits(
UTILS_Texte.ConvertStrToListe(produits))
# Filtres
listeDonnees = []
for IDfiltre, IDquestion, categorie, choix, criteres in listeFiltres:
listeDonnees.append({
"IDfiltre": IDfiltre,
"IDquestion": IDquestion,
"choix": choix,
"criteres": criteres
})
self.notebook.GetPage("criteres").ctrl_filtres.SetDonnees(listeDonnees)
self.listeInitialeFiltres = copy.deepcopy(listeDonnees)
# Statut
self.ctrl_statut.SetPageByCode(statut)
if motif_refus != None:
self.ctrl_statut.GetPageByCode("refusee").ctrl_motif.SetValue(
motif_refus)
self.ctrl_statut.Show(True)
self.ctrl_attribution.Show(False)
if IDlocation != None:
#self.ctrl_statut.GetPageByCode("attribuee").SetIDlocation(IDlocation)
#self.ctrl_statut.GetChoiceCtrl().Enable(False)
self.SetAttribution(IDlocation)
def SetCategories(self, categories_tarifs):
if categories_tarifs != None :
listeCategories = UTILS_Texte.ConvertStrToListe(categories_tarifs)
self.ctrl_categories.SetIDcoches(listeCategories)
def Sauvegarde(self):
# Nom
nom = self.ctrl_nom.GetValue()
if nom == "":
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir un nom !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
abrege = self.ctrl_abrege.GetValue()
if abrege == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir un nom abrégé !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
seuil_alerte = int(self.ctrl_seuil.GetValue())
heure_min = self.ctrl_heure_min.GetHeure()
if heure_min != None and self.ctrl_heure_min.Validation() == False:
dlg = wx.MessageDialog(
self, _(u"L'heure minimale semble être incorrecte !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_min.SetFocus()
return False
heure_max = self.ctrl_heure_max.GetHeure()
if heure_max != None and self.ctrl_heure_max.Validation() == False:
dlg = wx.MessageDialog(
self, _(u"L'heure maximale semble être incorrecte !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_max.SetFocus()
return False
if (heure_min != None
and heure_max == None) or (heure_min == None
and heure_max != None):
dlg = wx.MessageDialog(self,
_(u"La plage horaire est incomplète !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_min.SetFocus()
return False
# Affichage
afficher_page_accueil = int(
self.check_afficher_page_accueil.GetValue())
afficher_grille_conso = int(
self.check_afficher_grille_conso.GetValue())
# Validité
if self.radio_illimitee.GetValue() == True:
date_debut = "1977-01-01"
date_fin = "2999-01-01"
else:
date_debut = self.ctrl_date_debut.GetDate()
if date_debut == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de début de validité !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
date_fin = self.ctrl_date_fin.GetDate()
if date_fin == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de fin de validité !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Etiquettes
etiquettes = UTILS_Texte.ConvertListeToStr(
self.ctrl_etiquettes.GetCoches())
# Enregistrement
DB = GestionDB.DB()
listeDonnees = [
("IDactivite", self.IDactivite),
("nom", nom),
("abrege", abrege),
("seuil_alerte", seuil_alerte),
("date_debut", date_debut),
("date_fin", date_fin),
("heure_min", heure_min),
("heure_max", heure_max),
("afficher_page_accueil", afficher_page_accueil),
("afficher_grille_conso", afficher_grille_conso),
("etiquettes", etiquettes),
]
if self.IDunite_remplissage == None:
# Recherche le numéro d'ordre
req = """SELECT IDunite_remplissage, ordre
FROM unites_remplissage WHERE IDactivite=%d
ORDER BY ordre DESC LIMIT 1
;""" % self.IDactivite
DB.ExecuterReq(req)
listeTemp = DB.ResultatReq()
if len(listeTemp) == 0:
ordre = 1
else:
ordre = listeTemp[0][1] + 1
listeDonnees.append(("ordre", ordre))
self.IDunite_remplissage = DB.ReqInsert("unites_remplissage",
listeDonnees)
self.ctrl_unites.IDunite_remplissage = self.IDunite_remplissage
else:
DB.ReqMAJ("unites_remplissage", listeDonnees,
"IDunite_remplissage", self.IDunite_remplissage)
# Incompatibilités
self.ctrl_unites.Sauvegarde()
DB.Close()
return True
def GetDonneesImpression(self, listeDemandes=[]):
""" Impression des locations """
dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
# Récupère les données de la facture
if len(listeDemandes) == 0:
conditions = "()"
elif len(listeDemandes) == 1:
conditions = "(%d)" % listeDemandes[0]
else:
conditions = str(tuple(listeDemandes))
DB = GestionDB.DB()
# Importation des catégories de produits
req = """SELECT IDcategorie, nom
FROM produits_categories;"""
DB.ExecuterReq(req)
listeCategories = DB.ResultatReq()
self.dictCategories = {}
for IDcategorie, nom in listeCategories :
self.dictCategories[IDcategorie] = nom
# Importation des produits
req = """SELECT IDproduit, nom
FROM produits;"""
DB.ExecuterReq(req)
listeProduits = DB.ResultatReq()
self.dictProduits = {}
for IDproduit, nom in listeProduits :
self.dictProduits[IDproduit] = nom
# # Importation des critères
# req = """SELECT IDfiltre, IDquestion, categorie, choix, criteres FROM questionnaire_filtres WHERE categorie='location_demande' AND IDdonnee IN %s;""" % conditions
# DB.ExecuterReq(req)
# listeFiltres = DB.ResultatReq()
#
# req = """SELECT IDquestion, label, controle
# FROM questionnaire_questions;"""
# DB.ExecuterReq(req)
# listeQuestions = DB.ResultatReq()
# DICT_QUESTIONS = {}
# for IDquestion, label, controle in listeQuestions:
# DICT_QUESTIONS[IDquestion] = {"label": label, "controle": controle}
#
# # Importation des choix
# req = """SELECT IDchoix, IDquestion, label
# FROM questionnaire_choix
# ORDER BY ordre;"""
# DB.ExecuterReq(req)
# listeChoix = DB.ResultatReq()
# DICT_CHOIX = {}
# for IDchoix, IDquestion, label in listeChoix:
# DICT_CHOIX[IDchoix] = {"label": label, "IDquestion": IDquestion, }
# Recherche les locations
req = """SELECT IDdemande, date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation
FROM locations_demandes
WHERE IDdemande IN %s;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
del dlgAttente
return False
dictDonnees = {}
dictChampsFusion = {}
for item in listeDonnees:
IDdemande = item[0]
date = item[1]
IDfamille = item[2]
observations = item[3]
categories = item[4]
produits = item[5]
statut = item[6]
motif_refus = item[7]
IDlocation = item[8]
# Date de la demande
if isinstance(date, str) or isinstance(date, six.text_type):
date = datetime.datetime.strptime(date, "%Y-%m-%d %H:%M:%S")
date_texte = datetime.datetime.strftime(date, "%d/%m/%Y")
heure_texte = datetime.datetime.strftime(date, "%Hh%M")
# Catégories
categories = UTILS_Texte.ConvertStrToListe(categories, siVide=[])
liste_labels = []
for IDcategorie in categories:
if IDcategorie in self.dictCategories:
liste_labels.append(self.dictCategories[IDcategorie])
texte_categories = ", ".join(liste_labels)
# Produits
produits = UTILS_Texte.ConvertStrToListe(produits, siVide=[])
liste_labels = []
for IDproduit in produits:
if IDproduit in self.dictProduits:
liste_labels.append(self.dictProduits[IDproduit])
texte_produits = ", ".join(liste_labels)
# if IDindividu != None and self.dictIndividus.has_key(IDindividu):
# beneficiaires = self.dictIndividus[IDindividu]["nom_complet"]
# rue = self.dictIndividus[IDindividu]["rue"]
# cp = self.dictIndividus[IDindividu]["cp"]
# ville = self.dictIndividus[IDindividu]["ville"]
# Famille
if IDfamille != None:
nomTitulaires = self.dictTitulaires[IDfamille]["titulairesAvecCivilite"]
famille_rue = self.dictTitulaires[IDfamille]["adresse"]["rue"]
famille_cp = self.dictTitulaires[IDfamille]["adresse"]["cp"]
famille_ville = self.dictTitulaires[IDfamille]["adresse"]["ville"]
else:
nomTitulaires = "Famille inconnue"
famille_rue = ""
famille_cp = ""
famille_ville = ""
# Mémorisation des données
dictDonnee = {
"select": True,
"{IDDEMANDE}": str(IDdemande),
"{DATE}": date_texte,
"{HEURE}": heure_texte,
"{CATEGORIES}": texte_categories,
"{PRODUITS}": texte_produits,
"{NOTES}": observations,
"{ORGANISATEUR_NOM}": self.dictOrganisme["nom"],
"{ORGANISATEUR_RUE}": self.dictOrganisme["rue"],
"{ORGANISATEUR_CP}": self.dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}": self.dictOrganisme["ville"],
"{ORGANISATEUR_TEL}": self.dictOrganisme["tel"],
"{ORGANISATEUR_FAX}": self.dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}": self.dictOrganisme["mail"],
"{ORGANISATEUR_SITE}": self.dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}": self.dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}": self.dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}": self.dictOrganisme["code_ape"],
"{DATE_EDITION_COURT}": UTILS_Dates.DateDDEnFr(datetime.date.today()),
"{DATE_EDITION_LONG}": UTILS_Dates.DateComplete(datetime.date.today()),
}
# Ajoute les informations de base individus et familles
# if IDindividu != None:
# dictDonnee.update(self.infosIndividus.GetDictValeurs(mode="individu", ID=IDindividu, formatChamp=True))
if IDfamille != None:
dictDonnee.update(self.infosIndividus.GetDictValeurs(mode="famille", ID=IDfamille, formatChamp=True))
# Ajoute les réponses des questionnaires
for dictReponse in self.Questionnaires_familles.GetDonnees(IDfamille):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee["{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"]
for dictReponse in self.Questionnaires_demandes.GetDonnees(IDdemande):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee["{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"]
dictDonnees[IDdemande] = dictDonnee
# Champs de fusion pour Email
dictChampsFusion[IDdemande] = {}
for key, valeur in dictDonnee.items():
if key[0] == "{":
dictChampsFusion[IDdemande][key] = valeur
del dlgAttente
return dictDonnees, dictChampsFusion
def OnBoutonTraiter(self, event=None):
self.parent.EcritLog(_(u"Application de la demande de locations"),
self.ctrl_log)
resultats = {
"ajouter": {
True: 0,
False: 0
},
"modifier": {
True: 0,
False: 0
},
"supprimer": {
True: 0,
False: 0
}
}
DB = GestionDB.DB()
for track in self.ctrl_locations.donnees:
listeDonnees = [
("IDfamille", self.track.IDfamille),
("IDproduit", track.IDproduit),
("date_debut", track.date_debut),
("date_fin", track.date_fin),
("quantite", track.quantite),
]
if track.resultat != "ok":
if track.etat == "ajouter":
if track.action_possible == True:
listeDonnees.append(
("date_saisie", datetime.date.today()))
listeDonnees.append(
("IDlocation_portail", track.IDlocation))
IDlocation = DB.ReqInsert("locations", listeDonnees)
resultat = _(u"Ajout de %s du %s") % (
track.nom_produit, track.date_debut_txt)
DB.ReqMAJ("portail_reservations_locations",
[("resultat", "ok")], "IDreservation",
track.IDreservation)
else:
resultat = _(u"%s du %s : %s") % (track.nom_produit,
track.date_debut_txt,
track.statut)
self.parent.EcritLog(resultat, self.ctrl_log)
if track.etat == "modifier":
if track.action_possible == True:
if "-" in track.IDlocation:
DB.ReqMAJ("locations",
listeDonnees,
"IDlocation_portail",
track.IDlocation,
IDestChaine=True)
else:
DB.ReqMAJ("locations", listeDonnees, "IDlocation",
int(track.IDlocation))
resultat = _(u"Modification de %s du %s") % (
track.nom_produit, track.date_debut_txt)
DB.ReqMAJ("portail_reservations_locations",
[("resultat", "ok")], "IDreservation",
track.IDreservation)
else:
resultat = _(u"%s du %s : %s") % (track.nom_produit,
track.date_debut_txt,
track.statut)
self.parent.EcritLog(resultat, self.ctrl_log)
if track.etat == "supprimer":
if track.action_possible == True:
if "-" in track.IDlocation:
DB.ReqDEL("locations",
"IDlocation_portail",
track.IDlocation,
IDestChaine=True)
else:
DB.ReqDEL("locations", "IDlocation",
int(track.IDlocation))
resultat = _(u"Suppression de %s du %s") % (
track.nom_produit, track.date_debut_txt)
DB.ReqMAJ("portail_reservations_locations",
[("resultat", "ok")], "IDreservation",
track.IDreservation)
else:
resultat = _(u"%s du %s : %s") % (track.nom_produit,
track.date_debut_txt,
track.statut)
self.parent.EcritLog(resultat, self.ctrl_log)
# Mémorisation pour réponse
resultats[track.etat][track.action_possible] += 1
DB.Close()
# Formatage de la réponse
liste_resultats = []
for etat, valeurs in resultats.items():
for succes, quantite in valeurs.items():
if quantite:
if succes == True:
txt_validation = u"validé"
else:
txt_validation = u"refusé"
if quantite == 1:
pluriel = ""
else:
pluriel = "s"
if etat == "ajouter":
liste_resultats.append(
u"%d ajout%s %s%s" %
(quantite, pluriel, txt_validation, pluriel))
if etat == "modifier":
liste_resultats.append(
u"%d modification%s %se%s" %
(quantite, pluriel, txt_validation, pluriel))
if etat == "supprimer":
liste_resultats.append(
u"%d suppression%s %se%s" %
(quantite, pluriel, txt_validation, pluriel))
if liste_resultats:
self.reponse = UTILS_Texte.ConvertListeToPhrase(
liste_resultats) + "."
self.parent.EcritLog(
_(u"Réponse : %s") % self.reponse, self.ctrl_log)
# MAJ de la liste des actions
self.ctrl_locations.MAJ(track_demande=self.track)