def GetTracks(self):
""" Récupération des données """
DB = GestionDB.DB()
# Lecture Individus
req = """SELECT IDindividu, nom, prenom
FROM individus;"""
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
dictIndividus = {}
for IDindividu, nom, prenom in listeIndividus:
if prenom == None: prenom = ""
dictIndividus[IDindividu] = u"%s %s" % (nom, prenom)
# Lecture unités
req = """SELECT IDunite, nom, abrege
FROM unites
ORDER BY ordre;"""
DB.ExecuterReq(req)
listeUnites = DB.ResultatReq()
dictUnites = {}
for IDunite, nom, abrege in listeUnites:
dictUnites[IDunite] = nom
DB.Close()
# Récupération du IDfichier
IDfichier = FonctionsPerso.GetIDfichier()
# Lecture des fichiers du répertoire SYNC
listeFichiers = os.listdir(UTILS_Fichiers.GetRepSync())
listeListeView = []
listeDictTempTraites = []
for nomFichier in listeFichiers:
if nomFichier.startswith("actions_%s" % IDfichier) and (
nomFichier.endswith(".dat") and self.listeFichiers
== None) or (self.listeFichiers != None
and nomFichier in self.listeFichiers):
nomFichierCourt = nomFichier.replace(".dat", "").replace(
".archive", "")
if nomFichier not in self.listeFichiersTrouves:
self.listeFichiersTrouves.append(nomFichier)
# Taille fichier
tailleFichier = os.path.getsize(
UTILS_Fichiers.GetRepSync(nomFichier))
# Horodatage
horodatage = nomFichierCourt.split("_")[2]
horodatage = UTILS_Dates.HorodatageEnDatetime(horodatage)
# Lecture du contenu du fichier
DB = GestionDB.DB(
suffixe=None,
nomFichier=UTILS_Fichiers.GetRepSync(nomFichier),
modeCreation=False)
req = """SELECT IDparametre, nom, valeur
FROM parametres;"""
DB.ExecuterReq(req)
listeParametres = DB.ResultatReq()
dictParametres = {}
for IDparametre, nom, valeur in listeParametres:
dictParametres[nom] = valeur
if dictParametres.has_key("nom_appareil") == False:
dictParametres["nom_appareil"] = "Appareil inconnu"
if dictParametres.has_key("ID_appareil") == False:
dictParametres["ID_appareil"] = "IDAppareil inconnu"
# Mémorise l'IDappareil
self.dictIDappareil[nomFichierCourt] = dictParametres[
"ID_appareil"]
# Lecture des consommations
req = """SELECT IDconso, horodatage, action, IDindividu, IDactivite, IDinscription, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, date_saisie, IDutilisateur, IDcategorie_tarif, IDcompte_payeur, quantite, IDfamille
FROM consommations;"""
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
for IDconso, horodatage, action, IDindividu, IDactivite, IDinscription, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, date_saisie, IDutilisateur, IDcategorie_tarif, IDcompte_payeur, quantite, IDfamille in listeConsommations:
horodatage = UTILS_Dates.HorodatageEnDatetime(
horodatage, separation="-")
date = UTILS_Dates.DateEngEnDateDD(date)
date_saisie = UTILS_Dates.DateEngEnDateDD(date_saisie)
dictTemp = {
"categorie": "consommation",
"IDconso": IDconso,
"horodatage": horodatage,
"action": action,
"IDindividu": IDindividu,
"IDactivite": IDactivite,
"IDinscription": IDinscription,
"date": date,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"etat": etat,
"quantite": quantite,
"date_saisie": date_saisie,
"IDutilisateur": IDutilisateur,
"IDcategorie_tarif": IDcategorie_tarif,
"IDcompte_payeur": IDcompte_payeur,
"IDfamille": IDfamille,
}
# Vérifie que cette action n'est pas déjà dans la liste
if dictTemp not in listeDictTempTraites:
listeListeView.append(
Track(dictTemp,
dictIndividus=dictIndividus,
dictUnites=dictUnites,
dictParametres=dictParametres,
nomFichier=nomFichier))
if self.cacher_doublons == True:
listeDictTempTraites.append(dictTemp)
# Lecture des mémos journaliers
req = """SELECT IDmemo, horodatage, action, IDindividu, date, texte
FROM memo_journee;"""
DB.ExecuterReq(req)
listeMemosJournees = DB.ResultatReq()
for IDmemo, horodatage, action, IDindividu, date, texte in listeMemosJournees:
horodatage = UTILS_Dates.HorodatageEnDatetime(
horodatage, separation="-")
date = UTILS_Dates.DateEngEnDateDD(date)
dictTemp = {
"categorie": "memo_journee",
"IDmemo": IDmemo,
"horodatage": horodatage,
"action": action,
"IDindividu": IDindividu,
"date": date,
"texte": texte,
}
# Vérifie que cette action n'est pas déjà dans la liste
if dictTemp not in listeDictTempTraites:
listeListeView.append(
Track(dictTemp,
dictIndividus=dictIndividus,
dictParametres=dictParametres,
nomFichier=nomFichier))
if self.cacher_doublons == True:
listeDictTempTraites.append(dictTemp)
DB.Close()
return listeListeView
def GetListeFactures(self):
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Conditions
listeConditions = []
if self.IDcompte_payeur != None:
listeConditions.append("prestations.IDcompte_payeur = %d" %
self.IDcompte_payeur)
# 1ère série de filtres
if self.filtres != None:
for filtre in self.filtres:
# IDfacture_intervalle
if filtre["type"] == "IDfacture_intervalle":
listeConditions.append(
"(factures.IDfacture>=%d AND factures.IDfacture<=%d)" %
(filtre["IDfacture_min"], filtre["IDfacture_max"]))
# IDfacture_liste
if filtre["type"] == "IDfacture_liste":
if len(filtre["liste"]) == 0: listeTemp = "()"
elif len(filtre["liste"]) == 1:
listeTemp = "(%d)" % filtre["liste"][0]
else:
listeTemp = str(tuple(filtre["liste"]))
listeConditions.append("factures.IDfacture IN %s" %
listeTemp)
# Préfixe
if filtre["type"] == "prefixe":
if filtre["IDprefixe"] == None:
listeConditions.append("factures.IDprefixe IS NULL")
else:
listeConditions.append("factures.IDprefixe=%d" %
filtre["IDprefixe"])
# Lot de factures
if filtre["type"] == "lot":
listeConditions.append("factures.IDlot=%d" %
filtre["IDlot"])
# Date d'émission
if filtre["type"] == "date_emission":
listeConditions.append(
"(factures.date_edition>='%s' AND factures.date_edition<='%s')"
% (filtre["date_min"], filtre["date_max"]))
# Date d'échéance
if filtre["type"] == "date_echeance":
listeConditions.append(
"(factures.date_echeance>='%s' AND factures.date_echeance<='%s')"
% (filtre["date_min"], filtre["date_max"]))
# numero_intervalle
if filtre["type"] == "numero_intervalle":
listeConditions.append(
"(factures.numero>=%d AND factures.numero<=%d)" %
(filtre["numero_min"], filtre["numero_max"]))
# numero_liste
if filtre["type"] == "numero_liste":
if len(filtre["liste"]) == 0: listeTemp = "()"
elif len(filtre["liste"]) == 1:
listeTemp = "(%d)" % filtre["liste"][0]
else:
listeTemp = str(tuple(filtre["liste"]))
listeConditions.append("factures.numero IN %s" % listeTemp)
if len(listeConditions) > 0:
conditions = "WHERE %s" % " AND ".join(listeConditions)
else:
conditions = ""
# Récupération des totaux des prestations pour chaque facture
req = """
SELECT
prestations.IDfacture, SUM(prestations.montant)
FROM prestations
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestations = {}
for IDfacture, totalPrestations in listeDonnees:
if IDfacture != None:
dictPrestations[IDfacture] = totalPrestations
# Récupération des factures
req = """
SELECT factures.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.IDcompte_payeur,
factures.date_edition, factures.date_echeance, factures.IDutilisateur,
factures.date_debut, factures.date_fin, factures.total, factures.regle, factures.solde,
comptes_payeurs.IDfamille, factures.IDlot, lots_factures.nom, factures.etat
FROM factures
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur
LEFT JOIN lots_factures ON lots_factures.IDlot = factures.IDlot
LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe
%s
ORDER BY factures.date_edition
;""" % conditions.replace("prestations.IDcompte_payeur",
"comptes_payeurs.IDcompte_payeur")
DB.ExecuterReq(req)
listeFactures = DB.ResultatReq()
# Récupération de la ventilation
req = """
SELECT prestations.IDfacture, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDfacture, montantVentilation in listeVentilation:
if IDfacture != None:
dictVentilation[IDfacture] = montantVentilation
# Infos Prélèvement + Envoi par Email des factures
if self.IDcompte_payeur != None:
conditions = "WHERE comptes_payeurs.IDcompte_payeur = %d" % self.IDcompte_payeur
else:
conditions = ""
req = """
SELECT
prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque,
prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville,
prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat,
email_factures,
comptes_payeurs.IDcompte_payeur,
individus.nom, individus.prenom,
titulaire_helios
FROM familles
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille
LEFT JOIN individus ON individus.IDindividu = prelevement_individu
%s
;""" % conditions
DB.ExecuterReq(req)
listeInfosFamilles = DB.ResultatReq()
dictInfosFamilles = {}
for prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, IDcompte_payeur, nomPayeur, prenomPayeur, titulaire_helios in listeInfosFamilles:
prelevement_date_mandat = UTILS_Dates.DateEngEnDateDD(
prelevement_date_mandat)
dictInfosFamilles[IDcompte_payeur] = {
"prelevement_activation": prelevement_activation,
"prelevement_etab": prelevement_etab,
"prelevement_guichet": prelevement_guichet,
"prelevement_numero": prelevement_numero,
"prelevement_cle": prelevement_cle,
"prelevement_banque": prelevement_banque,
"prelevement_individu": prelevement_individu,
"prelevement_nom": prelevement_nom,
"prelevement_rue": prelevement_rue,
"prelevement_cp": prelevement_cp,
"prelevement_ville": prelevement_ville,
"prelevement_cle_iban": prelevement_cle_iban,
"prelevement_iban": prelevement_iban,
"prelevement_bic": prelevement_bic,
"prelevement_reference_mandat": prelevement_reference_mandat,
"prelevement_date_mandat": prelevement_date_mandat,
"email_factures": email_factures,
"nomPayeur": nomPayeur,
"prenomPayeur": prenomPayeur,
"titulaire_helios": titulaire_helios,
}
DB.Close()
listeResultats = []
for IDfacture, IDprefixe, prefixe, numero, IDcompte_payeur, date_edition, date_echeance, IDutilisateur, date_debut, date_fin, total, regle, solde, IDfamille, IDlot, nomLot, etat in listeFactures:
if numero == None: numero = 0
date_edition = UTILS_Dates.DateEngEnDateDD(date_edition)
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
date_echeance = UTILS_Dates.DateEngEnDateDD(date_echeance)
total = FloatToDecimal(total)
if dictVentilation.has_key(IDfacture):
totalVentilation = FloatToDecimal(dictVentilation[IDfacture])
else:
totalVentilation = FloatToDecimal(0.0)
if dictPrestations.has_key(IDfacture):
totalPrestations = FloatToDecimal(dictPrestations[IDfacture])
else:
totalPrestations = FloatToDecimal(0.0)
solde_actuel = totalPrestations - totalVentilation
if dictTitulaires.has_key(IDfamille) == True:
titulaires = dictTitulaires[IDfamille][
"titulairesSansCivilite"]
adresse_famille = dictTitulaires[IDfamille]["adresse"]
dictTemp = {
"IDfacture": IDfacture,
"IDprefixe": IDprefixe,
"prefixe": prefixe,
"numero": numero,
"IDcompte_payeur": IDcompte_payeur,
"date_edition": date_edition,
"date_echeance": date_echeance,
"IDutilisateur": IDutilisateur,
"date_debut": date_debut,
"date_fin": date_fin,
"total": total,
"regle": regle,
"solde": solde,
"totalPrestations": totalPrestations,
"totalVentilation": totalVentilation,
"IDfamille": IDfamille,
"titulaires": titulaires,
"IDlot": IDlot,
"nomLot": nomLot,
"adresse_famille": adresse_famille,
"etat": etat,
}
if dictInfosFamilles.has_key(IDcompte_payeur):
dictTemp.update(dictInfosFamilles[IDcompte_payeur])
valide = True
# 2ème série de filtres
if self.filtres != None:
for filtre in self.filtres:
# IDfacture_intervalle
if filtre["type"] == "solde_initial":
if self.ComparateurFiltre(
-solde, filtre["operateur"],
filtre["montant"]) == False:
valide = False
if filtre["type"] == "solde_actuel":
if self.ComparateurFiltre(
-solde_actuel, filtre["operateur"],
filtre["montant"]) == False:
valide = False
if filtre["type"] == "prelevement":
if filtre["choix"] == True:
if dictTemp["prelevement_activation"] == None:
valide = False
else:
if dictTemp["prelevement_activation"] != None:
valide = False
if filtre["type"] == "email":
if filtre["choix"] == True:
if dictTemp["email_factures"] == None:
valide = False
else:
if dictTemp["email_factures"] != None:
valide = False
if etat == "annulation" and self.afficherAnnulations == False:
valide = False
# Mémorisation des valeurs
if valide == True:
listeResultats.append(dictTemp)
return listeResultats
def OnBoutonOk(self, event):
# Validation des données
titre = self.ctrl_titre.GetValue()
if titre == "":
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir un titre !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_titre.SetFocus()
return
texte = self.ctrl_texte.GetValue()
if texte == "":
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir un texte !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_texte.SetFocus()
return
if self.radio_dates.GetValue() == True:
affichage_date_debut = self.ctrl_affichage_date_debut.GetDate()
if affichage_date_debut == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de début pour l'affichage !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_affichage_date_debut.SetFocus()
return
affichage_heure_debut = self.ctrl_affichage_heure_debut.GetHeure()
if affichage_heure_debut == None or self.ctrl_affichage_heure_debut.Validation(
) == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une heure de début valide pour l'affichage !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_affichage_heure_debut.SetFocus()
return
affichage_date_fin = self.ctrl_affichage_date_fin.GetDate()
if affichage_date_fin == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de fin pour l'affichage !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_affichage_date_fin.SetFocus()
return
affichage_heure_fin = self.ctrl_affichage_heure_fin.GetHeure()
if affichage_heure_fin == None or self.ctrl_affichage_heure_fin.Validation(
) == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une heure de fin valide pour l'affichage !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_affichage_heure_fin.SetFocus()
return
if affichage_date_debut > affichage_date_fin:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de fin supérieure à la date de début pour l'affichage !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_affichage_date_fin.SetFocus()
return
# Assemblage des dates et heures d'affichage
affichage_date_debut = datetime.datetime(
year=affichage_date_debut.year,
month=affichage_date_debut.month,
day=affichage_date_debut.day,
hour=int(affichage_heure_debut[:2]),
minute=int(affichage_heure_debut[3:]))
affichage_date_fin = datetime.datetime(
year=affichage_date_fin.year,
month=affichage_date_fin.month,
day=affichage_date_fin.day,
hour=int(affichage_heure_fin[:2]),
minute=int(affichage_heure_fin[3:]))
else:
affichage_date_debut = None
affichage_date_fin = None
# Sauvegarde des données
DB = GestionDB.DB()
listeDonnees = [
("titre", titre),
("texte", texte),
("affichage_date_debut", affichage_date_debut),
("affichage_date_fin", affichage_date_fin),
]
if self.IDmessage == None:
self.IDmessage = DB.ReqInsert("portail_messages", listeDonnees)
else:
DB.ReqMAJ("portail_messages", listeDonnees, "IDmessage",
self.IDmessage)
DB.Close()
self.EndModal(wx.ID_OK)
def Importation(self):
DB = GestionDB.DB()
if len(self.listeActivites) == 0: conditionActivites = "()"
elif len(self.listeActivites) == 1: conditionActivites = "(%d)" % self.listeActivites[0]
else: conditionActivites = str(tuple(self.listeActivites))
if self.affichage_caisse:
conditionsCaisse = "AND aides.IDcaisse=%d" % self.affichage_caisse
else:
conditionsCaisse = ""
# Déductions
req = """SELECT
IDdeduction, deductions.IDprestation, deductions.IDcompte_payeur, deductions.date, deductions.montant, deductions.label, deductions.IDaide,
individus.nom, individus.prenom, individus.date_naiss,
prestations.label, prestations.montant, prestations.montant_initial, prestations.IDfamille, prestations.IDactivite, activites.abrege, prestations.IDindividu, prestations.date, prestations.IDfacture,
familles.IDcaisse, familles.num_allocataire, caisses.nom, aides.nom
FROM deductions
LEFT JOIN prestations ON prestations.IDprestation = deductions.IDprestation
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
LEFT JOIN familles ON familles.IDfamille = prestations.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN aides ON aides.IDaide = deductions.IDaide
WHERE deductions.date>='%s' AND deductions.date<='%s' AND prestations.IDactivite IN %s
%s;""" % (self.date_debut, self.date_fin, conditionActivites, conditionsCaisse)
DB.ExecuterReq(req)
listeDeductions = DB.ResultatReq()
DB.Close()
# Calcul des données
dictResultats = {}
listePrestations = []
for IDdeduction, IDprestation, IDcompte_payeur, date, montant, label, IDaide, nomIndividu, prenomIndividu, date_naiss, labelPrestation, montantPrestation, montantInitialPrestation, IDfamille, IDactivite, abregeActivite, IDindividu, datePrestation, IDfacture, IDcaisse, num_allocataire, nomCaisse, nomAide in listeDeductions:
date = UTILS_Dates.DateEngEnDateDD(date)
datePrestation = UTILS_Dates.DateEngEnDateDD(datePrestation)
date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss)
mois = date.month
annee = date.year
nom_complet_individu = u"%s %s" % (nomIndividu, prenomIndividu)
montantInitialPrestation = FloatToDecimal(montantInitialPrestation)
montant = FloatToDecimal(montant)
montantPrestation = FloatToDecimal(montantPrestation)
# 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 == "montant_deduction": regroupement = montant
if self.affichage_regroupement == "nom_aide" : regroupement = nomAide
if self.affichage_regroupement == "nom_deduction": regroupement = label
if self.affichage_regroupement == "ville_residence" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_VILLE"]
if self.affichage_regroupement == "secteur" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_SECTEUR"]
if self.affichage_regroupement == "famille" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM"]
if self.affichage_regroupement == "individu": regroupement = IDindividu
if self.affichage_regroupement == "regime" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_REGIME"]
if self.affichage_regroupement == "caisse" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_CAISSE"]
# 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)
# Questionnaires
if self.affichage_regroupement.startswith("question_") and "famille" in self.affichage_regroupement:
regroupement = self.dictInfosFamilles[IDfamille]["QUESTION_%s" % self.affichage_regroupement[17:]]
except :
regroupement = None
if regroupement in ("", None):
regroupement = _(u"- Non renseigné -")
# Colonne
if labelPrestation not in listePrestations:
listePrestations.append(labelPrestation)
# Regroupement
if regroupement not in dictResultats:
dictResultats[regroupement] = {
"caisse": nomCaisse, "num_allocataire": num_allocataire, "prestations": {},
"montant_initial": FloatToDecimal(0), "montant_deduction": FloatToDecimal(0), "montant_final": FloatToDecimal(0),
"liste_dates": [], "individu": nom_complet_individu, "famille": self.dictInfosFamilles[IDfamille]["FAMILLE_NOM"],
}
dictResultats[regroupement]["montant_initial"] += montantInitialPrestation
dictResultats[regroupement]["montant_deduction"] += montant
dictResultats[regroupement]["montant_final"] += montantPrestation
if date not in dictResultats[regroupement]["liste_dates"]:
dictResultats[regroupement]["liste_dates"].append(date)
# Prestations
if labelPrestation not in dictResultats[regroupement]["prestations"]:
dictResultats[regroupement]["prestations"][labelPrestation] = {
"nbre": 0, "liste_dates": [], "montant_initial": montantInitialPrestation,
"montant_deduction": montant, "montant_final": montantPrestation,
}
dictResultats[regroupement]["prestations"][labelPrestation]["nbre"] += 1
if date not in dictResultats[regroupement]["prestations"][labelPrestation]["liste_dates"]:
dictResultats[regroupement]["prestations"][labelPrestation]["liste_dates"].append(date)
dictResultats[regroupement]["prestations"][labelPrestation]["montant_initial"] += montantInitialPrestation
dictResultats[regroupement]["prestations"][labelPrestation]["montant_deduction"] += montant
dictResultats[regroupement]["prestations"][labelPrestation]["montant_final"] += montantPrestation
return dictResultats, listePrestations
def MAJ(self):
""" MAJ integrale du controle avec MAJ des donnees """
if self.majEffectuee == False:
self.ctrl_parametres.MAJ()
DB = GestionDB.DB()
req = """SELECT internet_actif, internet_identifiant, internet_mdp, titulaire_helios, code_comptable, idtiers_helios, natidtiers_helios, reftiers_helios, cattiers_helios, natjur_helios, autre_adresse_facturation
FROM familles
WHERE IDfamille=%d;""" % self.IDfamille
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) > 0:
internet_actif, internet_identifiant, internet_mdp, titulaire_helios, code_comptable, idtiers_helios, natidtiers_helios, reftiers_helios, cattiers_helios, natjur_helios, autre_adresse_facturation = listeDonnees[
0]
# Compte internet
self.ctrl_compte_internet.SetDonnees({
"internet_actif":
internet_actif,
"internet_identifiant":
internet_identifiant,
"internet_mdp":
internet_mdp
})
# Hélios
self.ctrl_parametres.SetPropertyValue("titulaire_helios",
titulaire_helios)
if idtiers_helios != None:
self.ctrl_parametres.SetPropertyValue(
"idtiers_helios", idtiers_helios)
if natidtiers_helios != None:
self.ctrl_parametres.SetPropertyValue(
"natidtiers_helios", natidtiers_helios)
if reftiers_helios != None:
self.ctrl_parametres.SetPropertyValue(
"reftiers_helios", reftiers_helios)
if cattiers_helios != None:
self.ctrl_parametres.SetPropertyValue(
"cattiers_helios", cattiers_helios)
if natjur_helios != None:
self.ctrl_parametres.SetPropertyValue(
"natjur_helios", natjur_helios)
# Autre adresse de facturation
self.ctrl_parametres.SetAdresseFacturation(
autre_adresse_facturation)
# Code comptable
self.ctrl_parametres.SetPropertyValue("code_comptable",
code_comptable)
self.MAJaffichage()
else:
self.ctrl_parametres.MAJ()
# Droits utilisateurs
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"familles_compte_internet", "modifier",
afficheMessage=False) == False:
self.bouton_modifier.Enable(False)
self.majEffectuee = True
def Importation_prestations(self):
""" Importation des données """
# Chargement des informations individuelles
self.infosIndividus = UTILS_Infos_individus.Informations(date_reference=self.date_debut, qf=True, inscriptions=True, messages=False, infosMedicales=False, cotisationsManquantes=False, piecesManquantes=False, questionnaires=True, scolarite=True)
self.dictInfosIndividus = self.infosIndividus.GetDictValeurs(mode="individu", ID=None, formatChamp=False)
self.dictInfosFamilles = self.infosIndividus.GetDictValeurs(mode="famille", ID=None, formatChamp=False)
DB = GestionDB.DB()
# Récupèration de la ventilation des prestations de la période
conditionDepots = ""
if self.filtreDepots == True and self.filtreDepots_dateDebut != None and self.filtreDepots_dateFin !=None :
conditionDepots = " AND (depots.date>='%s' and depots.date<='%s') " % (self.filtreDepots_dateDebut, self.filtreDepots_dateFin)
conditionReglements = ""
if self.filtreReglements == True and self.filtreReglements_dateDebut != None and self.filtreReglements_dateFin !=None :
conditionReglements = " AND (reglements.date_saisie>='%s' and reglements.date_saisie<='%s') " % (self.filtreReglements_dateDebut, self.filtreReglements_dateFin)
req = """SELECT
ventilation.IDventilation, ventilation.IDreglement, ventilation.IDprestation, ventilation.montant,
reglements.date, reglements.date_saisie, depots.date,
prestations.date
FROM ventilation
LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN depots ON depots.IDdepot = reglements.IDdepot
WHERE prestations.date>='%s' AND prestations.date <='%s' %s %s
ORDER BY prestations.date; """ % (self.date_debut, self.date_fin, conditionDepots, conditionReglements)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDventilation, IDreglement, IDprestation, montantVentilation, dateReglement, dateSaisieReglement, dateDepotReglement, datePrestation in listeVentilation :
if (IDprestation in dictVentilation) == False :
dictVentilation[IDprestation] = 0.0
dictVentilation[IDprestation] += montantVentilation
# Condition Afficher Cotisations et/ou Consommations ?
listeAffichage = []
if self.afficher_cotisations == True : listeAffichage.append("cotisation")
if self.afficher_consommations == True : listeAffichage.append("consommation")
if self.afficher_autres == True : listeAffichage.append("autre")
if len(listeAffichage) == 0 : conditionAfficher = "categorie='xxxxxxx' "
elif len(listeAffichage) == 1 : conditionAfficher = "categorie='%s'" % listeAffichage[0]
else : conditionAfficher = "categorie IN %s" % str(tuple(listeAffichage))
# Condition Activités affichées
if len(self.listeActivites) == 0 : conditionActivites = "prestations.IDactivite=9999999"
elif len(self.listeActivites) == 1 : conditionActivites = "prestations.IDactivite=%d" % self.listeActivites[0]
else : conditionActivites = "prestations.IDactivite IN %s" % str(tuple(self.listeActivites))
# Filtre Prestation facturée / non facturée
conditionFacturee = ""
if "facturee" in self.mode_affichage :
conditionFacturee = " AND prestations.IDfacture IS NOT NULL"
if "nonfacturee" in self.mode_affichage :
conditionFacturee = " AND prestations.IDfacture IS NULL"
# Récupération de toutes les prestations de la période
req = """SELECT IDprestation, date, categorie, label, montant, prestations.IDactivite, prestations.IDcategorie_tarif, IDfamille, IDindividu
FROM prestations
WHERE date>='%s' AND date <='%s'
AND %s AND (%s OR prestations.IDactivite IS NULL)
%s
ORDER BY date; """ % (self.date_debut, self.date_fin, conditionAfficher, conditionActivites, conditionFacturee)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Récupération des tranches de tarifs paramétrées
if len(self.listeActivites) == 0 :
condition = ""
else :
condition = "AND %s" % conditionActivites.replace("prestations.", "")
req = """SELECT IDligne, qf_min, qf_max
FROM tarifs_lignes
WHERE qf_min IS NOT NULL AND qf_max IS NOT NULL
%s
;""" % condition
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_tranches = []
for IDligne, qf_min, qf_max in listeDonnees:
tranche = qf_min, qf_max
if tranche not in liste_tranches :
liste_tranches.append(tranche)
liste_tranches.sort()
DB.Close()
dictPrestations = {}
listeRegroupements = []
dictLabelsRegroupements = {}
for IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDfamille, IDindividu in listePrestations :
date = UTILS_Dates.DateEngEnDateDD(date)
annee = date.year
mois = date.month
if montant == None :
montant = 0.0
def GetKey(key_code=""):
key = None
key_label = ""
key_tri = None
if key_code == "jour":
key = date
key_tri = key
key_label = UTILS_Dates.DateEngFr(date)
if key_code == "mois":
key = (annee, mois)
key_tri = key
key_label = PeriodeComplete(mois, annee)
if key_code == "annee":
key = annee
key_tri = key
key_label = str(annee)
if key_code == "label_prestation":
key = label
key_tri = label
key_label = label
if key_code == "activite":
key = IDactivite
if IDactivite == None or (IDactivite in self.dictActivites) == False:
key_label = _(u"Activité inconnue")
else:
key_label = self.dictActivites[IDactivite]["nom"]
key_tri = key_label
if key_code == "categorie_tarif":
key = IDcategorie_tarif
if IDcategorie_tarif == None or (IDcategorie_tarif in self.dictCategoriesTarifs) == False:
key_label = _(u"Sans catégorie")
else:
key_label = self.dictCategoriesTarifs[IDcategorie_tarif]["nomCategorie"]
key_tri = key_label
if key_code == "famille":
key = IDfamille
if IDfamille == None or (IDfamille in self.dict_titulaires) == False:
key_label = _(u"Famille inconnue")
else:
key_label = self.dict_titulaires[IDfamille]["titulairesSansCivilite"]
key_tri = key_label
if key_code == "individu":
key = IDindividu
if IDindividu == None or (IDindividu in self.dictIndividus) == False:
key_label = _(u"Individu inconnu")
else:
key_label = self.dictIndividus[IDindividu]["nom_complet"]
key_tri = key_label
if key_code == "ville_residence" and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["INDIVIDU_VILLE"]
key_label = key
key_tri = key
if key_code == "secteur" and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["INDIVIDU_SECTEUR"]
key_label = key
key_tri = key
if key_code == "age" and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["INDIVIDU_AGE_INT"]
key_label = str(key)
key_tri = key
if key_code == "nom_ecole" and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["SCOLARITE_NOM_ECOLE"]
key_label = key
key_tri = key
if key_code == "nom_classe" and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["SCOLARITE_NOM_CLASSE"]
key_label = key
key_tri = key
if key_code == "nom_niveau_scolaire" and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["SCOLARITE_NOM_NIVEAU"]
key_label = key
key_tri = key
if key_code == "regime":
key = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_REGIME"]
key_label = key
key_tri = key
if key_code == "caisse":
key = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_CAISSE"]
key_label = key
key_tri = key
# QF
if key_code.startswith("qf"):
key = None
if "FAMILLE_QF_ACTUEL_INT" in self.dictInfosFamilles[IDfamille]:
qf = self.dictInfosFamilles[IDfamille]["FAMILLE_QF_ACTUEL_INT"]
# Tranches de 100
if key_code == "qf_100" :
for x in range(0, 10000, 100):
min, max = x, x + 99
if qf >= min and qf <= max:
key = (min, max)
key_tri = key
key_label = "%s - %s" % (min, max)
# Tranches paramétrées
if key_code == "qf_tarifs" :
for min, max in liste_tranches :
if qf >= min and qf <= max:
key = (min, max)
key_tri = key
key_label = "%s - %s" % (min, max)
# Questionnaires
if key_code.startswith("question_") and "famille" in key_code:
key = self.dictInfosFamilles[IDfamille]["QUESTION_%s" % key_code[17:]]
key_label = six.text_type(key)
key_tri = key_label
if key_code.startswith("question_") and "individu" in key_code and IDindividu not in (0, None) :
key = self.dictInfosIndividus[IDindividu]["QUESTION_%s" % key_code[18:]]
key_label = six.text_type(key)
key_tri = key_label
if key in ("", None) :
key = _(u"- Autre -")
key_label = key
key_tri = key_label
return key, key_label, key_tri
# Création des keys de regroupements
regroupement, labelRegroupement, triRegroupement = GetKey(self.key_colonne)
key1, key1_label, key1_tri = GetKey(self.key_ligne1)
key2, key2_label, key2_tri = GetKey(self.key_ligne2)
# Mémorisation du regroupement
if regroupement not in listeRegroupements :
listeRegroupements.append(regroupement)
dictLabelsRegroupements[regroupement] = labelRegroupement
# Total
if (key1 in dictPrestations) == False :
dictPrestations[key1] = {"label" : key1_label, "tri" : key1_tri, "nbre" : 0, "facture" : 0.0, "regle" : 0.0, "impaye" : 0.0, "regroupements" : {} }
dictPrestations[key1]["nbre"] += 1
dictPrestations[key1]["facture"] += montant
# Détail par période
if (regroupement in dictPrestations[key1]["regroupements"]) == False :
dictPrestations[key1]["regroupements"][regroupement] = {"nbre" : 0, "facture" : 0.0, "regle" : 0.0, "impaye" : 0.0, "key2" : {} }
dictPrestations[key1]["regroupements"][regroupement]["nbre"] += 1
dictPrestations[key1]["regroupements"][regroupement]["facture"] += montant
# Détail par catégorie de tarifs
if (key2 in dictPrestations[key1]["regroupements"][regroupement]["key2"]) == False :
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2] = {"label" : key2_label, "tri" : key2_tri, "nbre" : 0, "facture" : 0.0, "regle" : 0.0, "impaye" : 0.0}
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2]["nbre"] += 1
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2]["facture"] += montant
# Ajoute la ventilation
if IDprestation in dictVentilation :
dictPrestations[key1]["regle"] += dictVentilation[IDprestation]
dictPrestations[key1]["regroupements"][regroupement]["regle"] += dictVentilation[IDprestation]
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2]["regle"] += dictVentilation[IDprestation]
# Calcule les impayés
dictPrestations[key1]["impaye"] = dictPrestations[key1]["regle"] - dictPrestations[key1]["facture"]
dictPrestations[key1]["regroupements"][regroupement]["impaye"] = dictPrestations[key1]["regroupements"][regroupement]["regle"] - dictPrestations[key1]["regroupements"][regroupement]["facture"]
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2]["impaye"] = dictPrestations[key1]["regroupements"][regroupement]["key2"][key2]["regle"] - dictPrestations[key1]["regroupements"][regroupement]["key2"][key2]["facture"]
listeRegroupements.sort()
return dictPrestations, listeRegroupements, dictLabelsRegroupements
def __init__(self, parent, IDutilisateur=None):
wx.Dialog.__init__(self,
parent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.parent = parent
self.IDutilisateur = IDutilisateur
self.mdp = None
self.mdpcrypt = None
if IDutilisateur == None:
DB = GestionDB.DB()
IDutilisateur = DB.GetProchainID("utilisateurs")
DB.Close()
# Identité
self.staticbox_identite_staticbox = wx.StaticBox(
self, -1, _(u"Identité"))
self.label_sexe = wx.StaticText(self, -1, _(u"Sexe :"))
self.ctrl_sexe = wx.Choice(self,
-1,
choices=[_(u"Homme"),
_(u"Femme")])
self.label_nom = wx.StaticText(self, -1, _(u"Nom :"))
self.ctrl_nom = wx.TextCtrl(self, -1, u"")
self.label_prenom = wx.StaticText(self, -1, _(u"Prénom :"))
self.ctrl_prenom = wx.TextCtrl(self, -1, u"")
# Image
self.staticbox_image_staticbox = wx.StaticBox(self, -1, _(u"Avatar"))
self.ctrl_image = CTRL_Image(self)
self.hyper_image = Hyperlien(
self,
label=_(u"Choisir un avatar"),
infobulle=_(
u"Cliquez ici pour modifier l'avatar de l'utilisateur"),
URL="")
# Accès
self.staticbox_acces_staticbox = wx.StaticBox(self, -1, _(u"Accès"))
self.ctrl_actif = wx.CheckBox(self, -1, u"Utilisateur actif")
self.ctrl_actif.SetValue(True)
self.bouton_modif_mdp = CTRL_Bouton_image.CTRL(
self, texte="", cheminImage="Images/32x32/Cle.png")
# Compte internet
self.staticbox_internet_staticbox = wx.StaticBox(
self, -1, _(u"Compte internet"))
self.ctrl_compte_internet = CTRL_Compte_internet.CTRL(
self, IDutilisateur=IDutilisateur, couleurFond=wx.WHITE)
self.bouton_modifier = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Modifier.png"),
wx.BITMAP_TYPE_ANY))
#self.bouton_envoi_mail = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Emails_exp.png"), wx.BITMAP_TYPE_ANY))
self.bouton_envoi_pressepapiers = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Clipboard.png"),
wx.BITMAP_TYPE_ANY))
#self.bouton_historique = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Historique.png"), wx.BITMAP_TYPE_ANY))
# Droits
self.staticbox_droits_staticbox = wx.StaticBox(self, -1, _(u"Droits"))
self.radio_droits_admin = wx.RadioButton(self,
-1,
_(u"Administrateur"),
style=wx.RB_GROUP)
self.radio_droits_modele = wx.RadioButton(
self, -1, _(u"Le modèle de droits suivant :"))
self.ctrl_modele_droits = CTRL_Modeles_droits(self)
self.radio_droits_perso = wx.RadioButton(
self, -1, _(u"Les droits personnalisés suivants :"))
self.ctrl_droits = CTRL_Droits.CTRL(self,
IDutilisateur=self.IDutilisateur)
self.ctrl_droits.MAJ()
# Commandes
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_ok = CTRL_Bouton_image.CTRL(
self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_annuler = CTRL_Bouton_image.CTRL(
self,
id=wx.ID_CANCEL,
texte=_(u"Annuler"),
cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonModifMdp, self.bouton_modif_mdp)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioDroits,
self.radio_droits_admin)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioDroits,
self.radio_droits_modele)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioDroits,
self.radio_droits_perso)
self.Bind(wx.EVT_BUTTON, self.ctrl_compte_internet.Modifier,
self.bouton_modifier)
#self.Bind(wx.EVT_BUTTON, self.Envoyer_email, self.bouton_envoi_mail)
self.Bind(wx.EVT_BUTTON,
self.ctrl_compte_internet.Envoyer_pressepapiers,
self.bouton_envoi_pressepapiers)
#self.Bind(wx.EVT_BUTTON, self.Consulter_historique, self.bouton_historique)
if self.IDutilisateur == None:
self.SetTitle(_(u"Saisie d'un utilisateur"))
# Création des codes internet
internet_identifiant = UTILS_Internet.CreationIdentifiant(
IDutilisateur=IDutilisateur)
internet_mdp = UTILS_Internet.CreationMDP(nbreCaract=8)
self.ctrl_compte_internet.SetDonnees({
"internet_actif": 0,
"internet_identifiant": internet_identifiant,
"internet_mdp": internet_mdp
})
else:
self.SetTitle(_(u"Modification d'un utilisateur"))
self.Importation()
self.OnRadioDroits(None)
self.MAJboutonMdp()
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, consommations.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 consommations.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 IDetiquette in self.dictEtiquettes:
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 (groupe in dictResultats) == False:
dictResultats[groupe] = {}
if (IDunite in dictResultats[groupe]) == False:
dictResultats[groupe][IDunite] = {}
if (regroupement in dictResultats[groupe][IDunite]) == False:
dictResultats[groupe][IDunite][regroupement] = defaut
dictResultats[groupe][IDunite][regroupement] += valeur
return dictResultats, listeUnites, listeGroupes
def GetDonneesImpression(self, listeInscriptions=[]):
""" Impression des inscriptions """
dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
# Récupère les données de la facture
if len(listeInscriptions) == 0:
conditions = "()"
elif len(listeInscriptions) == 1:
conditions = "(%d)" % listeInscriptions[0]
else:
conditions = str(tuple(listeInscriptions))
# Récupération des informations sur l'inscription
dictChamps = {
"inscriptions.IDinscription": "IDINSCRIPTION",
"inscriptions.date_inscription": "DATE_INSCRIPTION",
"inscriptions.date_desinscription": "EST_PARTI",
"activites.IDactivite": "IDACTIVITE",
"activites.nom": "ACTIVITE_NOM_LONG",
"activites.abrege": "ACTIVITE_NOM_COURT",
"groupes.IDgroupe": "IDGROUPE",
"groupes.nom": "GROUPE_NOM_LONG",
"groupes.abrege": "GROUPE_NOM_COURT",
"categories_tarifs.IDcategorie_tarif": "IDCATEGORIETARIF",
"categories_tarifs.nom": "NOM_CATEGORIE_TARIF",
"individus.IDindividu": "IDINDIVIDU",
"individus.IDcivilite": "IDCIVILITE",
"individus.nom": "INDIVIDU_NOM",
"individus.prenom": "INDIVIDU_PRENOM",
"individus.date_naiss": "INDIVIDU_DATE_NAISS",
"individus.cp_naiss": "INDIVIDU_CP_NAISS",
"individus.ville_naiss": "INDIVIDU_VILLE_NAISS",
"individus.adresse_auto": "INDIVIDU_ADRESSE_AUTO",
"individus.rue_resid": "INDIVIDU_RUE",
"individus.cp_resid": "INDIVIDU_CP",
"individus.ville_resid": "INDIVIDU_VILLE",
"individus.profession": "INDIVIDU_PROFESSION",
"individus.employeur": "INDIVIDU_EMPLOYEUR",
"individus.tel_domicile": "INDIVIDU_TEL_DOMICILE",
"individus.tel_mobile": "INDIVIDU_TEL_MOBILE",
"individus.tel_fax": "INDIVIDU_FAX",
"individus.mail": "INDIVIDU_EMAIL",
"individus.travail_tel": "INDIVIDU_TEL_PRO",
"individus.travail_fax": "INDIVIDU_FAX_PRO",
"individus.travail_mail": "INDIVIDU_EMAIL_PRO",
"familles.IDfamille": "IDFAMILLE",
"caisses.nom": "FAMILLE_CAISSE",
"regimes.nom": "FAMILLE_REGIME",
"familles.num_allocataire": "FAMILLE_NUMALLOC",
}
listeChamps = list(dictChamps.keys())
DB = GestionDB.DB()
req = """SELECT %s
FROM inscriptions
LEFT JOIN activites ON activites.IDactivite = inscriptions.IDactivite
LEFT JOIN groupes ON groupes.IDgroupe = inscriptions.IDgroupe
LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
LEFT JOIN familles ON familles.IDfamille = inscriptions.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime
WHERE IDinscription IN %s
""" % (", ".join(listeChamps), conditions)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
del dlgAttente
return False
dictDonnees = {}
dictChampsFusion = {}
for item in listeDonnees:
dictDonnee = {}
index = 0
for nomChamp in listeChamps:
code = dictChamps[nomChamp]
valeur = item[index]
dictDonnee["{%s}" % code] = valeur
index += 1
IDinscription = dictDonnee["{IDINSCRIPTION}"]
IDfamille = dictDonnee["{IDFAMILLE}"]
IDindividu = dictDonnee["{IDINDIVIDU}"]
# 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.update({
"select":
True,
"{IDFAMILLE}":
str(IDfamille),
"{FAMILLE_NOM}":
nomTitulaires,
"{FAMILLE_RUE}":
famille_rue,
"{FAMILLE_CP}":
famille_cp,
"{FAMILLE_VILLE}":
famille_ville,
"{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()),
})
# Formatage spécial
dictDonnee["{DATE_INSCRIPTION}"] = UTILS_Dates.DateEngFr(
dictDonnee["{DATE_INSCRIPTION}"])
dictDonnee["{INDIVIDU_DATE_NAISS}"] = UTILS_Dates.DateEngFr(
dictDonnee["{INDIVIDU_DATE_NAISS}"])
# Autres données
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_individus.GetDonnees(
IDindividu):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
for dictReponse in self.Questionnaires_inscriptions.GetDonnees(
IDinscription):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
dictDonnees[IDinscription] = dictDonnee
# Champs de fusion pour Email
dictChampsFusion[IDinscription] = {}
for key, valeur in dictDonnee.items():
if key[0] == "{":
dictChampsFusion[IDinscription][key] = valeur
del dlgAttente
return dictDonnees, dictChampsFusion
def Supprimer(self, event):
if len(self.Selection()) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune inscription à supprimer dans la liste"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
IDinscription = self.Selection()[0].IDinscription
IDfamille = self.Selection()[0].IDfamille
IDindividu = self.Selection()[0].IDindividu
nomActivite = self.Selection()[0].nom_activite
IDactivite = self.Selection()[0].IDactivite
# Verrouillage utilisateurs
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"individus_inscriptions", "supprimer",
IDactivite=IDactivite) == False:
return
DB = GestionDB.DB()
# Recherche si des consommations existent
req = """SELECT IDconso, date, forfait
FROM consommations
WHERE IDinscription=%d AND (forfait IS NULL OR forfait=1);""" % IDinscription
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeConso = []
for IDconso, date, forfait in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
listeConso.append({
"IDconso": IDconso,
"date": date,
"forfait": forfait
})
if len(listeConso) > 0:
dlg = wx.MessageDialog(
self,
_(u"Il existe déjà %d consommations enregistrées sur cette inscription. \n\nIl est donc impossible de la supprimer !"
) % len(listeConso), _(u"Annulation impossible"),
wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
DB.Close()
return
# Recherche si des prestations existent
req = """SELECT IDprestation, prestations.date, prestations.forfait
FROM prestations
WHERE IDactivite=%d AND IDindividu=%d
;""" % (IDactivite, IDindividu)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
listePrestationsForfait = []
listePrestationsNormales = []
listeDatesPrestations = []
for IDprestation, date, forfait in listePrestations:
listeDatesPrestations.append(UTILS_Dates.DateEngEnDateDD(date))
if forfait == 2:
if IDprestation not in listePrestationsForfait:
listePrestationsForfait.append(IDprestation)
else:
if IDprestation not in listePrestationsNormales:
listePrestationsNormales.append(IDprestation)
if len(listePrestations) - len(listePrestationsForfait) > 0:
dlg = wx.MessageDialog(
self,
_(u"Il existe déjà %d prestations enregistrées sur cette inscription. \n\nIl est donc impossible de la supprimer !"
) % len(listePrestations), _(u"Annulation impossible"),
wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
DB.Close()
return
DB.Close()
# Périodes de gestion
self.gestion = UTILS_Gestion.Gestion(self)
if self.gestion.Verification("consommations", listeConso) == False:
return False
if self.gestion.Verification("prestations",
listeDatesPrestations) == False:
return False
# Demande de confirmation
if len(listePrestationsForfait) == 0: texteForfait = u""
elif len(listePrestationsForfait) == 1:
texteForfait = _(
u"\n\n(La prestation associée sera également supprimée)")
else:
texteForfait = _(
u"\n\n(Les %d prestations associées seront également supprimées)"
) % len(listePrestationsForfait)
dlg = wx.MessageDialog(
self,
_(u"Souhaitez-vous vraiment supprimer cette inscription ?%s") %
texteForfait, _(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
IDinscription = self.Selection()[0].IDinscription
DB = GestionDB.DB()
DB.ReqDEL("inscriptions", "IDinscription", IDinscription)
# Suppression des forfaits associés déjà saisis
for IDprestation in listePrestationsForfait:
DB.ReqDEL("prestations", "IDprestation", IDprestation)
DB.ReqDEL("consommations", "IDprestation", IDprestation)
DB.ReqDEL("deductions", "IDprestation", IDprestation)
DB.ReqDEL("ventilation", "IDprestation", IDprestation)
DB.Close()
# Mémorise l'action dans l'historique
UTILS_Historique.InsertActions([
{
"IDindividu":
self.IDindividu,
"IDfamille":
IDfamille,
"IDcategorie":
19,
"action":
_(u"Suppression de l'inscription à l'activité '%s'") %
nomActivite
},
])
# Actualise l'affichage
self.MAJ()
dlg.Destroy()
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
# Règle la taille des images
self.afficheImages = UTILS_Config.GetParametre(
"depots_afficher_images", defaut=True)
if self.afficheImages == True:
taille = self.tailleImagesMaxi
else:
taille = self.tailleImagesMini
# Image list
dictImages = {"standard": {}, "modes": {}, "emetteurs": {}}
imageList = wx.ImageList(taille[0], taille[1])
# Images standard
dictImages["standard"]["vert"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_vert.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["orange"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath(
"Images/16x16/Ventilation_orange.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["rouge"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath(
"Images/16x16/Ventilation_rouge.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["ok"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["erreur"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["attente"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Attente.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["avis_depot_oui"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Emails_exp.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["avis_depot_non"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Emails_exp_gris.png"),
wx.BITMAP_TYPE_PNG), taille))
# Images Modes
if self.afficheImages == True:
DB = GestionDB.DB()
req = """SELECT modes_reglements.IDmode, modes_reglements.image FROM modes_reglements"""
DB.ExecuterReq(req)
listeModes = DB.ResultatReq()
for IDmode, buffer in listeModes:
bmp = self.GetImagefromBuffer(buffer, taille)
dictImages["modes"][IDmode] = imageList.Add(bmp)
# Images Emetteurs
req = """SELECT emetteurs.IDemetteur, emetteurs.image FROM emetteurs"""
DB.ExecuterReq(req)
listeEmetteurs = DB.ResultatReq()
for IDemetteur, buffer in listeEmetteurs:
bmp = self.GetImagefromBuffer(buffer, taille)
dictImages["emetteurs"][IDemetteur] = imageList.Add(bmp)
DB.Close()
self.SetImageLists(imageList, imageList)
# Flèches tri
bmp_haut = self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Fleche_haut_2.png"),
wx.BITMAP_TYPE_PNG), taille)
bmp_bas = self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Fleche_bas_2.png"),
wx.BITMAP_TYPE_PNG), taille)
self.RegisterSortIndicators(bmp_haut, bmp_bas)
def GetImageMode(track):
if dictImages["modes"].has_key(track.IDmode):
return dictImages["modes"][track.IDmode]
else:
return None
def GetImageEmetteur(track):
if dictImages["emetteurs"].has_key(track.IDemetteur):
return dictImages["emetteurs"][track.IDemetteur]
else:
return None
def GetImageVentilation(track):
if track.montant_ventilation == None:
return dictImages["standard"]["rouge"]
resteAVentiler = decimal.Decimal(str(
track.montant)) - decimal.Decimal(
str(track.montant_ventilation))
if resteAVentiler == decimal.Decimal(str("0.0")):
return dictImages["standard"]["vert"]
if resteAVentiler > decimal.Decimal(str("0.0")):
return dictImages["standard"]["orange"]
if resteAVentiler < decimal.Decimal(str("0.0")):
return dictImages["standard"]["rouge"]
def GetImageDepot(track):
if track.IDdepot == None:
if track.encaissement_attente == 1:
return dictImages["standard"]["attente"]
else:
return dictImages["standard"]["erreur"]
else:
return dictImages["standard"]["ok"]
def GetImageDiffere(track):
if track.date_differe == None:
return None
if track.date_differe <= datetime.date.today():
return dictImages["standard"]["ok"]
else:
return dictImages["standard"]["erreur"]
def GetImageAttente(track):
if track.encaissement_attente == True:
return dictImages["standard"]["attente"]
return None
def GetImageAvisDepot(track):
if track.avis_depot != None:
return dictImages["standard"]["avis_depot_oui"]
if track.email_depots != None:
return dictImages["standard"]["avis_depot_non"]
return None
def FormateDateLong(dateDD):
return DateComplete(dateDD)
def FormateDateCourt(dateDD):
if dateDD == None:
return ""
else:
return DateEngFr(str(dateDD))
def FormateMontant(montant):
if montant == None: return u""
return u"%.2f %s" % (montant, SYMBOLE)
def FormateAttente(attente):
if attente == True:
return _(u"Attente !")
return ""
def rowFormatter(listItem, track):
# Si Observations
if track.observations != "":
listItem.SetTextColour((0, 102, 205))
# Si en attente
if track.encaissement_attente == True:
listItem.SetTextColour((255, 0, 0))
# Si date différé est supérieure à la date d'aujourd'hui
if track.date_differe != None:
if track.date_differe > datetime.date.today():
listItem.SetTextColour((255, 0, 0))
liste_Colonnes = [
ColumnDefn(_(u"ID"), "left", 0, "IDreglement",
typeDonnee="entier"),
ColumnDefn(_(u"Date"),
'left',
80,
"date",
typeDonnee="date",
stringConverter=FormateDateCourt),
ColumnDefn(_(u"Mode"),
'left',
120,
"nom_mode",
typeDonnee="texte",
imageGetter=GetImageMode),
ColumnDefn(_(u"Emetteur"),
'left',
145,
"nom_emetteur",
typeDonnee="texte",
imageGetter=GetImageEmetteur),
ColumnDefn(_(u"Numéro"),
'left',
60,
"numero_piece",
typeDonnee="texte"),
ColumnDefn(_(u"Payeur"),
'left',
160,
"nom_payeur",
typeDonnee="texte"),
ColumnDefn(_(u"Montant"),
'right',
80,
"montant",
typeDonnee="montant",
stringConverter=FormateMontant),
ColumnDefn(_(u"Avis"),
'left',
110,
"avis_depot",
typeDonnee="date",
stringConverter=FormateDateCourt,
imageGetter=GetImageAvisDepot),
ColumnDefn(_(u"Compte"),
'left',
100,
"nom_compte",
typeDonnee="texte"),
ColumnDefn(_(u"Différé"),
'left',
85,
"date_differe",
typeDonnee="date",
stringConverter=FormateDateCourt
), #, imageGetter=GetImageDiffere),
ColumnDefn(_(u"Attente"),
'left',
65,
"encaissement_attente",
typeDonnee="texte",
stringConverter=FormateAttente
), #, imageGetter=GetImageAttente),
ColumnDefn(_(u"Quittancier"),
'left',
75,
"numero_quittancier",
typeDonnee="texte"),
ColumnDefn(_(u"Observations"),
'left',
200,
"observations",
typeDonnee="texte"),
]
self.rowFormatter = rowFormatter
self.SetColumns(liste_Colonnes)
if self.inclus == True:
self.SetEmptyListMsg(_(u"Aucun règlement dans ce dépôt"))
else:
self.SetEmptyListMsg(_(u"Aucun règlement disponible"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
## self.SetSortColumn(self.columns[self.numColonneTri])
self.SortBy(self.numColonneTri, ascending=self.ordreAscendant)
self.SetObjects(self.donnees)
def __init__(self, parent, labelControleNom=_(u"Nom")):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.labelControleNom = labelControleNom
# Nom
self.box_nom_staticbox = wx.StaticBox(self, -1, labelControleNom)
self.label_nom = wx.StaticText(self, -1, u"%s :" % labelControleNom)
self.ctrl_nom = wx.TextCtrl(self, -1, u"")
# Protection
self.box_mdp_staticbox = wx.StaticBox(self, -1, _(u"Protection"))
self.label_cryptage = wx.StaticText(self, -1, _(u"Cryptage :"))
self.check_cryptage = wx.CheckBox(self, -1, u"")
self.label_mdp = wx.StaticText(self, -1, _(u"Mot de passe :"))
self.ctrl_mdp = wx.TextCtrl(self, -1, u"", style=wx.TE_PASSWORD)
self.label_confirmation = wx.StaticText(self, -1, _(u"Confirmation :"))
self.ctrl_confirmation = wx.TextCtrl(self,
-1,
u"",
style=wx.TE_PASSWORD)
# Destination
self.box_destination_staticbox = wx.StaticBox(self, -1,
_(u"Destination"))
self.check_repertoire = wx.CheckBox(self, -1, _(u"Répertoire :"))
self.ctrl_repertoire = wx.TextCtrl(self, -1, u"")
self.bouton_repertoire = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Repertoire.png"),
wx.BITMAP_TYPE_ANY))
self.check_email = wx.CheckBox(self, -1, _(u"Envoi par Email :"))
self.ctrl_email = wx.TextCtrl(self, -1, u"")
# Données
self.box_donnees_staticbox = wx.StaticBox(
self, -1, _(u"Données à sauvegarder"))
self.ctrl_donnees = CTRL_Donnees(self)
self.ctrl_donnees.SetMinSize((300, -1))
self.check_locaux = wx.CheckBox(self, -1, _(u"Fichiers locaux"))
self.check_reseau = wx.CheckBox(self, -1, _(u"Fichiers réseau"))
self.__set_properties()
self.__do_layout()
# Binds
self.Bind(wx.EVT_CHECKBOX, self.OnCheckCryptage, self.check_cryptage)
self.Bind(wx.EVT_CHECKBOX, self.OnCheckRepertoire,
self.check_repertoire)
self.Bind(wx.EVT_BUTTON, self.OnBoutonRepertoire,
self.bouton_repertoire)
self.Bind(wx.EVT_CHECKBOX, self.OnCheckEmail, self.check_email)
self.Bind(wx.EVT_CHECKBOX, self.OnCheckLocaux, self.check_locaux)
self.Bind(wx.EVT_CHECKBOX, self.OnCheckReseau, self.check_reseau)
# Init Contrôles
self.OnCheckCryptage(None)
self.OnCheckRepertoire(None)
self.OnCheckEmail(None)
self.check_locaux.SetValue(True)
# Récupération des paramètres de connexion réseau
self.dictConnexion = None
DB = GestionDB.DB()
if DB.echec != 1:
if DB.isNetwork == True:
self.check_reseau.SetValue(True)
self.dictConnexion = DB.GetParamConnexionReseau()
DB.Close()
self.ctrl_donnees.MAJ()
def GetTracks(self):
""" Récupération des données """
listeID = None
db = GestionDB.DB()
if self.IDindividu != None:
# Pour un individu
if self.dictFamillesRattachees != None:
listeIDfamille = []
for IDfamille, dictFamille in self.dictFamillesRattachees.iteritems(
):
if dictFamille["IDcategorie"] in (1, 2):
listeIDfamille.append(IDfamille)
if len(listeIDfamille) == 0: conditionIDfamille = "()"
if len(listeIDfamille) == 1:
conditionIDfamille = "(%d)" % listeIDfamille[0]
else:
conditionIDfamille = str(tuple(listeIDfamille))
else:
conditionIDfamille = "()"
req = """
SELECT
IDpiece, pieces.IDtype_piece, pieces.IDindividu, pieces.IDfamille, date_debut, date_fin,
types_pieces.nom, public, duree_validite, valide_rattachement,
individus.nom, individus.prenom
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
LEFT JOIN individus ON pieces.IDindividu = individus.IDindividu
WHERE pieces.IDindividu=%d OR (pieces.IDfamille IN %s AND pieces.IDindividu IS NULL);
""" % (self.IDindividu, conditionIDfamille)
else:
# Pour une famille
req = """
SELECT IDindividu, IDcategorie
FROM rattachements
WHERE IDfamille=%d AND IDcategorie IN (1, 2);
""" % self.IDfamille
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
listeIDindividus = []
for IDindividu, IDcategorie in listeDonnees:
if IDindividu not in listeIDindividus:
listeIDindividus.append(IDindividu)
if len(listeIDindividus) == 0: conditionIndividus = "()"
if len(listeIDindividus) == 1:
conditionIndividus = "(%d)" % listeIDindividus[0]
else:
conditionIndividus = str(tuple(listeIDindividus))
req = """
SELECT
IDpiece, pieces.IDtype_piece, pieces.IDindividu, pieces.IDfamille, date_debut, date_fin,
types_pieces.nom, public, duree_validite, valide_rattachement,
individus.nom, individus.prenom
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
LEFT JOIN individus ON pieces.IDindividu = individus.IDindividu
WHERE pieces.IDfamille=%d OR (pieces.IDindividu IN %s AND pieces.IDfamille IS NULL);
""" % (self.IDfamille, conditionIndividus)
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
listeListeView = []
listeIDfamilles = []
for item in listeDonnees:
# Pour compter le nbre de familles
IDfamille = item[3]
if IDfamille not in listeIDfamilles and IDfamille != None:
listeIDfamilles.append(IDfamille)
valide = True
if listeID != None:
if item[0] not in listeID:
valide = False
if valide == True:
track = Track(self, item)
listeListeView.append(track)
if self.selectionID == item[0]:
self.selectionTrack = track
self.nbreFamilles = len(listeIDfamilles)
return listeListeView
def Remplissage(self):
# Récupération des données
self.listePiecesObligatoires = []
self.dictItems = {}
# Création des conditions
condition = ""
# Si pour fiche FAMILLE :
if self.IDfamille != None:
condition = "WHERE inscriptions.IDfamille=%d " % self.IDfamille
# Si pour fiche INDIVIDU
if self.IDindividu != None:
condition = "WHERE inscriptions.IDindividu=%d " % self.IDindividu
DB = GestionDB.DB()
# Récupération des pièces à fournir pour la famille ou l'individu
req = """
SELECT
inscriptions.IDfamille, pieces_activites.IDtype_piece, types_pieces.nom, types_pieces.public, types_pieces.valide_rattachement, individus.prenom, individus.IDindividu
FROM pieces_activites
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces_activites.IDtype_piece
LEFT JOIN inscriptions ON inscriptions.IDactivite = pieces_activites.IDactivite
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
%s
GROUP BY inscriptions.IDfamille, pieces_activites.IDtype_piece, individus.IDindividu;
""" % condition
DB.ExecuterReq(req)
listePiecesObligatoires = DB.ResultatReq()
# Récupération des pièces de la famille
dateDuJour = datetime.date.today()
if self.IDindividu != None:
# Pour un individu
if self.dictFamillesRattachees != None:
listeIDfamille = []
for IDfamille, dictFamille in self.dictFamillesRattachees.iteritems(
):
if dictFamille["IDcategorie"] in (1, 2):
listeIDfamille.append(IDfamille)
if len(listeIDfamille) == 0: conditionIDfamille = "()"
if len(listeIDfamille) == 1:
conditionIDfamille = "(%d)" % listeIDfamille[0]
else:
conditionIDfamille = str(tuple(listeIDfamille))
else:
conditionIDfamille = "()"
req = """
SELECT IDpiece, pieces.IDtype_piece, IDindividu, IDfamille, date_debut, date_fin, public
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
WHERE date_debut <= '%s' AND date_fin >= '%s'
AND (IDindividu=%d OR (IDfamille IN %s AND IDindividu IS NULL))
ORDER BY date_fin
;""" % (str(dateDuJour), str(dateDuJour), self.IDindividu,
conditionIDfamille)
else:
# Pour une famille
req = """
SELECT IDindividu, IDcategorie
FROM rattachements
WHERE IDfamille=%d AND IDcategorie IN (1, 2);
""" % self.IDfamille
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeIDindividus = []
for IDindividu, IDcategorie in listeDonnees:
if IDindividu not in listeIDindividus:
listeIDindividus.append(IDindividu)
if len(listeIDindividus) == 0: conditionIndividus = "()"
if len(listeIDindividus) == 1:
conditionIndividus = "(%d)" % listeIDindividus[0]
else:
conditionIndividus = str(tuple(listeIDindividus))
req = """
SELECT IDpiece, pieces.IDtype_piece, IDindividu, IDfamille, date_debut, date_fin, public
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
WHERE date_debut <= '%s' AND date_fin >= '%s'
AND (IDfamille=%s OR (IDindividu IN %s AND IDfamille IS NULL))
ORDER BY date_fin
""" % (str(dateDuJour), str(dateDuJour), self.IDfamille,
conditionIndividus)
## condition = ""
## # Si pour fiche famille
## if self.IDfamille != None :
## condition = " AND IDfamille=%d " % self.IDfamille
## # Si pour fiche INDIVIDU
## if self.IDindividu != None :
## condition = " AND IDindividu=%d " % self.IDindividu
## req = """
## SELECT IDpiece, pieces.IDtype_piece, IDindividu, IDfamille, date_debut, date_fin, public
## FROM pieces
## LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
## WHERE date_debut <= '%s' AND date_fin >= '%s' %s
## ORDER BY date_fin;
## """ % (str(dateDuJour), str(dateDuJour), condition)
DB.ExecuterReq(req)
listePiecesFournies = DB.ResultatReq()
DB.Close()
dictPiecesFournies = {}
for IDpiece, IDtype_piece, IDindividu, IDfamille, date_debut, date_fin, publicPiece in listePiecesFournies:
# Pour les pièces familiales :
if publicPiece == "famille": IDindividu = None
date_debut = DateEngEnDateDD(date_debut)
date_fin = DateEngEnDateDD(date_fin)
dictPiecesFournies[(IDfamille, IDtype_piece,
IDindividu)] = (date_debut, date_fin)
# Comparaison de la liste des pièces à fournir et la liste des pièces fournies
dictDonnees = {}
for IDfamille, IDtype_piece, nomPiece, publicPiece, rattachementPiece, prenom, IDindividu in listePiecesObligatoires:
# Pour les pièces familiales :
if publicPiece == "famille": IDindividu = None
# Pour les pièces qui sont indépendantes de la famille
if rattachementPiece == 1:
IDfamille = None
# Mémorise pour la fenêtre de saisie d'une pièce
self.listePiecesObligatoires.append(
(IDfamille, IDtype_piece, IDindividu))
if dictPiecesFournies.has_key(
(IDfamille, IDtype_piece, IDindividu)):
date_debut, date_fin = dictPiecesFournies[(IDfamille,
IDtype_piece,
IDindividu)]
nbreJoursRestants = (date_fin - datetime.date.today()).days
if nbreJoursRestants > 15:
valide = "ok"
else:
valide = "attention"
else:
valide = "pasok"
dictDonnees[(IDfamille, IDtype_piece,
IDindividu)] = (IDfamille, IDtype_piece, nomPiece,
publicPiece, prenom, IDindividu,
valide)
# Répartition par famille
dictPieces = {}
nbreFamilles = 0
for key, valeurs in dictDonnees.iteritems():
IDfamille = valeurs[0]
if dictPieces.has_key(IDfamille) == False:
dictPieces[IDfamille] = []
if IDfamille != None:
nbreFamilles += 1
dictPieces[IDfamille].append(valeurs)
dictPieces[IDfamille].sort()
# Création de la racine
self.root = self.AddRoot(_(u"Racine"))
# Création des branches
for IDfamille, valeurs in dictPieces.iteritems():
# Niveau 1 : Titulaires des familles
if nbreFamilles > 1:
if IDfamille == None:
label = _(u"Pièces indépendantes")
else:
if self.dictFamillesRattachees != None and len(
self.dictFamillesRattachees) > 0:
label = self.dictFamillesRattachees[IDfamille][
"nomsTitulaires"]
else:
label = _(u"IDfamille=%d") % IDfamille
niveau1 = self.AppendItem(self.root, label)
self.SetPyData(niveau1, {
"type": "famille",
"IDfamille": IDfamille
})
self.SetItemBold(niveau1, True)
else:
niveau1 = self.root
# Niveau 2 : Nom des pièces
for IDfamille, IDtype_piece, nomPiece, publicPiece, prenom, IDindividu, valide in valeurs:
if publicPiece == "famille" or self.IDindividu != None:
label = nomPiece
else:
label = _(u"%s de %s") % (nomPiece, prenom)
niveau2 = self.AppendItem(niveau1, label)
self.SetPyData(
niveau2, {
"type": "piece",
"IDtype_piece": IDtype_piece,
"IDindividu": IDindividu,
"IDfamille": IDfamille,
"valide": valide,
"nomPiece": nomPiece
})
self.dictItems[(IDfamille, IDtype_piece, IDindividu)] = niveau2
if valide == "ok":
self.SetItemImage(niveau2,
self.img_ok,
which=wx.TreeItemIcon_Normal)
if valide == "attention":
self.SetItemImage(niveau2,
self.img_attention,
which=wx.TreeItemIcon_Normal)
if valide == "pasok":
self.SetItemImage(niveau2,
self.img_pasok,
which=wx.TreeItemIcon_Normal)
if nbreFamilles < 2:
self.SetAGWWindowStyleFlag(wx.TR_NO_LINES | wx.TR_HIDE_ROOT
| wx.TR_NO_BUTTONS
| wx.TR_HAS_VARIABLE_ROW_HEIGHT
| HTL.TR_NO_HEADER)
self.ExpandAllChildren(self.root)
def GetListeUtilisateurs(nomFichier=""):
""" Récupère la liste des utilisateurs et de leurs droits """
DB = GestionDB.DB(nomFichier=nomFichier)
# Droits
req = """SELECT IDdroit, IDutilisateur, IDmodele, categorie, action, etat
FROM droits;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDroitsUtilisateurs = {}
dictDroitsModeles = {}
for IDdroit, IDutilisateur, IDmodele, categorie, action, etat in listeDonnees:
key = (categorie, action)
if IDutilisateur != None:
if dictDroitsUtilisateurs.has_key(IDutilisateur) == False:
dictDroitsUtilisateurs[IDutilisateur] = {}
dictDroitsUtilisateurs[IDutilisateur][key] = etat
if IDmodele != None:
if dictDroitsModeles.has_key(IDmodele) == False:
dictDroitsModeles[IDmodele] = {}
dictDroitsModeles[IDmodele][key] = etat
# Utilisateurs
req = """SELECT IDutilisateur, sexe, nom, prenom, mdp, profil, actif
FROM utilisateurs
WHERE actif=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeUtilisateurs = []
# chargement avatars
try:
req = """SELECT IDutilisateur, image
FROM utilisateurs;"""
DB.ExecuterReq(req)
listeAvatars = DB.ResultatReq()
except:
pass
dictAvatars = {}
for IDutilisateur, image in listeAvatars:
dictAvatars[IDutilisateur] = image
for IDutilisateur, sexe, nom, prenom, mdp, profil, actif in listeDonnees:
droits = None
if profil.startswith("administrateur"):
droits = None
if profil.startswith("modele"):
IDmodele = int(profil.split(":")[1])
if dictDroitsModeles.has_key(IDmodele):
droits = dictDroitsModeles[IDmodele]
if profil.startswith("perso"):
if dictDroitsUtilisateurs.has_key(IDutilisateur):
droits = dictDroitsUtilisateurs[IDutilisateur]
# Avatar
if dictAvatars.has_key(IDutilisateur):
image = dictAvatars[IDutilisateur]
else:
image = "Automatique"
dictTemp = {
"IDutilisateur": IDutilisateur,
"nom": nom,
"prenom": prenom,
"sexe": sexe,
"mdp": mdp,
"profil": profil,
"actif": actif,
"image": image,
"droits": droits
}
listeUtilisateurs.append(dictTemp)
DB.Close()
return listeUtilisateurs
def Impression(self,
listeInscriptions=[],
nomDoc=None,
afficherDoc=True,
dictOptions=None,
repertoire=None,
repertoireTemp=False):
""" Impression des inscriptions """
from Utils import UTILS_Impression_inscription
# Récupération des données à partir des IDinscription
resultat = self.GetDonneesImpression(listeInscriptions)
if resultat == False:
return False
dictInscriptions, dictChampsFusion = resultat
# Récupération des paramètres d'affichage
if dictOptions == None:
if afficherDoc == False:
dlg = DLG_Apercu_inscription.Dialog(
None,
titre=_(u"Sélection des paramètres de l'inscription"),
intro=
_(u"Sélectionnez ici les paramètres d'affichage de l'inscription."
))
dlg.bouton_ok.SetImageEtTexte("Images/32x32/Valider.png",
_("Ok"))
else:
dlg = DLG_Apercu_inscription.Dialog(None)
if dlg.ShowModal() == wx.ID_OK:
dictOptions = dlg.GetParametres()
dlg.Destroy()
else:
dlg.Destroy()
return False
# Création des PDF à l'unité
def CreationPDFunique(repertoireCible=""):
dictPieces = {}
dlgAttente = wx.BusyInfo(
_(u"Génération des PDF à l'unité en cours..."), None)
try:
index = 0
for IDinscription, dictInscription in dictInscriptions.items():
if dictInscription["select"] == True:
nomTitulaires = self.Supprime_accent(
dictInscription["{FAMILLE_NOM}"])
nomFichier = _(u"Inscription %d - %s") % (
IDinscription, nomTitulaires)
cheminFichier = u"%s/%s.pdf" % (repertoireCible,
nomFichier)
dictComptesTemp = {IDinscription: dictInscription}
self.EcritStatusbar(
_(u"Edition de l'inscription %d/%d : %s") %
(index, len(dictInscription), nomFichier))
UTILS_Impression_inscription.Impression(
dictComptesTemp,
dictOptions,
IDmodele=dictOptions["IDmodele"],
ouverture=False,
nomFichier=cheminFichier)
dictPieces[IDinscription] = cheminFichier
index += 1
self.EcritStatusbar("")
del dlgAttente
return dictPieces
except Exception as err:
del dlgAttente
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(
None,
_(u"Désolé, le problème suivant a été rencontré dans l'édition des inscriptions : \n\n%s"
) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
# Répertoire souhaité par l'utilisateur
if repertoire != None:
resultat = CreationPDFunique(repertoire)
if resultat == False:
return False
# Répertoire TEMP (pour Emails)
dictPieces = {}
if repertoireTemp == True:
dictPieces = CreationPDFunique(UTILS_Fichiers.GetRepTemp())
if dictPieces == False:
return False
# Sauvegarde dans un porte-documents
if dictOptions["questionnaire"] != None:
# Création des PDF
if len(dictPieces) == 0:
dictPieces = CreationPDFunique(UTILS_Fichiers.GetRepTemp())
# Recherche des IDreponse
IDquestion = dictOptions["questionnaire"]
DB = GestionDB.DB()
req = """SELECT IDreponse, IDdonnee
FROM questionnaire_reponses
WHERE IDquestion=%d
;""" % IDquestion
DB.ExecuterReq(req)
listeReponses = DB.ResultatReq()
DB.Close()
dictReponses = {}
for IDreponse, IDinscription in listeReponses:
dictReponses[IDinscription] = IDreponse
DB = GestionDB.DB(suffixe="DOCUMENTS")
for IDinscription, cheminFichier in dictPieces.items():
# Préparation du blob
fichier = open(cheminFichier, "rb")
data = fichier.read()
fichier.close()
buffer = six.BytesIO(data)
blob = buffer.read()
# Recherche l'IDreponse
if IDinscription in dictReponses:
IDreponse = dictReponses[IDinscription]
else:
# Création d'une réponse de questionnaire
listeDonnees = [
("IDquestion", IDquestion),
("reponse", "##DOCUMENTS##"),
("type", "inscription"),
("IDdonnee", IDinscription),
]
DB2 = GestionDB.DB()
IDreponse = DB2.ReqInsert("questionnaire_reponses",
listeDonnees)
DB2.Close()
# Sauvegarde du document
listeDonnees = [("IDreponse", IDreponse), ("type", "pdf"),
("label", dictOptions["nomModele"]),
("last_update", datetime.datetime.now())]
IDdocument = DB.ReqInsert("documents", listeDonnees)
DB.MAJimage(table="documents",
key="IDdocument",
IDkey=IDdocument,
blobImage=blob,
nomChampBlob="document")
DB.Close()
# Fabrication du PDF global
if repertoireTemp == False:
dlgAttente = wx.BusyInfo(_(u"Création du PDF en cours..."), None)
self.EcritStatusbar(
_(u"Création du PDF des inscriptions en cours... veuillez patienter..."
))
try:
UTILS_Impression_inscription.Impression(
dictInscriptions,
dictOptions,
IDmodele=dictOptions["IDmodele"],
ouverture=afficherDoc,
nomFichier=nomDoc)
self.EcritStatusbar("")
del dlgAttente
except Exception as err:
del dlgAttente
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(
None,
u"Désolé, le problème suivant a été rencontré dans l'édition des inscriptions : \n\n%s"
% err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
return dictChampsFusion, dictPieces
def SauvegardeFactures(self):
""" Sauvegarde des factures """
# Récupère Utilisateur en cours
IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Génération des factures
listeFacturesGenerees = []
# Tri par ordre alphabétique de la liste
listeComptes = []
for track in self.ctrl_factures.GetTracksCoches():
listeComptes.append((track.nomSansCivilite, track.IDcompte_payeur))
listeComptes.sort()
# ProgressBar
dlgProgress = wx.ProgressDialog(_(u"Génération des factures"),
_(u"Initialisation..."),
maximum=len(listeComptes),
parent=None,
style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE
| wx.PD_APP_MODAL)
# Sélection du prochain numéro de facture
numero = self.parent.dictParametres["prochain_numero"]
IDprefixe = self.parent.dictParametres["IDprefixe"]
if numero == None:
# Recherche du prochain numéro de facture si mode AUTO
if IDprefixe == None:
conditions = "WHERE IDprefixe IS NULL"
else:
conditions = "WHERE IDprefixe=%d" % IDprefixe
DB = GestionDB.DB()
req = """SELECT MAX(numero)
FROM factures
%s;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if listeDonnees[0][0] == None:
numero = 1
else:
numero = listeDonnees[0][0] + 1
# Sauvegarde
DB = GestionDB.DB()
try:
index = 0
for nomTitulaires, IDcompte_payeur in listeComptes:
dictCompte = self.ctrl_factures.dictComptes[IDcompte_payeur]
texte = _(u"Génération de la facture %d sur %d...") % (
index + 1, len(listeComptes))
self.EcritStatusbar(texte)
dlgProgress.Update(index + 1, texte)
listePrestations = dictCompte["listePrestations"]
total = dictCompte["total"]
regle = dictCompte["ventilation"]
solde = total - regle
# Dates
date_edition = dictCompte["date_edition"]
date_echeance = dictCompte["date_echeance"]
# Liste des activités
texteActivites = ""
for IDactivite in dictCompte["liste_activites"]:
texteActivites += "%d;" % IDactivite
if len(dictCompte["liste_activites"]) > 0:
texteActivites = texteActivites[:-1]
# Liste des individus
texteIndividus = ""
for IDindividu in list(dictCompte["individus"].keys()):
texteIndividus += "%d;" % IDindividu
if len(list(dictCompte["individus"].keys())) > 0:
texteIndividus = texteIndividus[:-1]
# Sauvegarde de la facture
listeDonnees = [
("IDprefixe", IDprefixe),
("numero", numero),
("IDcompte_payeur", IDcompte_payeur),
("date_edition", str(date_edition)),
("date_echeance", date_echeance),
("activites", texteActivites),
("individus", texteIndividus),
("IDutilisateur", IDutilisateur),
("date_debut", str(dictCompte["date_debut"])),
("date_fin", str(dictCompte["date_fin"])),
("total", float(total)),
("regle", float(regle)),
("solde", float(solde)),
("IDlot", self.parent.dictParametres["IDlot"]),
("prestations",
";".join(self.parent.dictParametres["prestations"])),
("IDregie", self.parent.dictParametres["IDregie"]),
("mention1", self.parent.dictParametres["mention1"]),
("mention2", self.parent.dictParametres["mention2"]),
("mention3", self.parent.dictParametres["mention3"]),
]
IDfacture = DB.ReqInsert("factures", listeDonnees)
# Attribution des IDfacture à chaque prestation
for IDindividu, IDprestation in listePrestations:
if dictCompte["individus"][IDindividu]["select"] == True:
listeDonnees = [
("IDfacture", IDfacture),
]
DB.ReqMAJ("prestations", listeDonnees, "IDprestation",
IDprestation)
listeFacturesGenerees.append(IDfacture)
numero += 1
index += 1
DB.Close()
self.EcritStatusbar(u"")
dlgProgress.Destroy()
except Exception as err:
DB.Close()
dlgProgress.Destroy()
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(
self,
_(u"Désolé, le problème suivant a été rencontré : \n\n%s"
) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
self.EcritStatusbar(u"")
return False
self.EcritStatusbar(u"")
return listeFacturesGenerees
def OnBoutonOk(self, event):
# Récupération des années
if self.ctrl_annees.GetValue() == "":
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir une année !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
listeAnnees = []
for annee in self.ctrl_annees.GetValue().split(";"):
try:
listeAnnees.append(int(annee))
if int(annee) < 1900 or int(annee) > 3000:
raise Exception()
except:
dlg = wx.MessageDialog(
self, _(u"Les années saisies ne semblent pas valides !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Récupération jours fériés à créer
listeCoches = []
for index in range(0, self.ctrl_jours.GetCount()):
if self.ctrl_jours.IsChecked(index):
listeCoches.append(index)
if len(listeCoches) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement cocher au moins un jour férié à créer !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Récupération des jours déjà présents dans la base de données
DB = GestionDB.DB()
req = """SELECT IDferie, nom, jour, mois, annee
FROM jours_feries
WHERE type='variable' ; """
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeJoursExistants = []
for IDferie, nom, jour, mois, annee in listeDonnees:
try:
listeJoursExistants.append(datetime.date(annee, mois, jour))
except:
pass
def SauvegarderDate(nom="", date=None):
if date not in listeJoursExistants:
IDferie = DB.ReqInsert("jours_feries", [("type", "variable"),
("nom", nom),
("annee", date.year),
("mois", date.month),
("jour", date.day)])
# Calcul des jours fériés
for annee in listeAnnees:
# Dimanche de Paques
dimanche_paques = easter(annee)
# Lundi de Pâques
lundi_paques = dimanche_paques + relativedelta(days=+1)
if 0 in listeCoches:
SauvegarderDate(_(u"Lundi de Pâques"), lundi_paques)
# Ascension
ascension = dimanche_paques + relativedelta(days=+39)
if 1 in listeCoches:
SauvegarderDate(_(u"Jeudi de l'Ascension"), ascension)
# Pentecote
pentecote = dimanche_paques + relativedelta(days=+50)
if 2 in listeCoches:
SauvegarderDate(_(u"Lundi de Pentecôte"), pentecote)
DB.Close()
# Fermeture
self.EndModal(wx.ID_OK)
def __init__(self, parent):
HTL.HyperTreeList.__init__(self, parent, -1)
self.parent = parent
self.dictImpression = {}
# Paramètres
self.mode_affichage = "facture" # "facture", "regle", "nbre", "impaye"
self.key_colonne = "mois" # "mois", "annee"
self.key_ligne1 = "activite"
self.key_ligne2 = "label"
self.date_debut = None
self.date_fin = None
self.afficher_consommations = True
self.afficher_cotisations = True
self.afficher_autres = True
self.listeActivites = []
self.affichage_details_total = True
self.filtreCotisations = False
self.filtreCotisations_dateDebut = None
self.filtreCotisations_dateFin = None
self.filtreReglements = False
self.filtreReglements_dateDebut = None
self.filtreReglements_dateFin = None
self.filtreDepots = False
self.filtreDepots_dateDebut = None
self.filtreDepots_dateFin = None
self.labelParametres = ""
# Importation de données
DB = GestionDB.DB()
req = """SELECT IDcategorie_tarif, categories_tarifs.nom, activites.nom, activites.abrege
FROM categories_tarifs
LEFT JOIN activites ON activites.IDactivite = categories_tarifs.IDactivite
ORDER BY categories_tarifs.nom; """
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictCategoriesTarifs = {}
for IDcategorie_tarif, nomCategorie, nomActivite, abregeActivite in listeDonnees :
self.dictCategoriesTarifs[IDcategorie_tarif] = {
"nomCategorie" : nomCategorie,
"nomActivite" : nomActivite,
"abregeActivite" : abregeActivite,
}
req = """SELECT IDactivite, nom
FROM activites;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictActivites = {}
for IDactivite, nom in listeDonnees :
self.dictActivites[IDactivite] = {"nom" : nom}
req = """SELECT IDindividu, nom, prenom
FROM individus;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictIndividus = {}
for IDindividu, nom, prenom in listeDonnees :
if nom == None : nom = ""
if prenom == None : prenom = ""
nom_complet = u"%s %s" % (nom, prenom)
self.dictIndividus[IDindividu] = {"nom" : nom, "prenom": prenom, "nom_complet" : nom_complet}
DB.Close()
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# wx.TR_COLUMN_LINES | | wx.TR_HAS_BUTTONS
self.SetBackgroundColour(wx.WHITE)
if 'phoenix' in wx.PlatformInfo:
TR_COLUMN_LINES = HTL.TR_COLUMN_LINES
else :
TR_COLUMN_LINES = wx.TR_COLUMN_LINES
self.SetAGWWindowStyleFlag(wx.TR_HIDE_ROOT | wx.TR_ROW_LINES | TR_COLUMN_LINES | wx.TR_HAS_BUTTONS | wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.TR_FULL_ROW_HIGHLIGHT ) # HTL.TR_NO_HEADER
def Sauvegarde(self):
""" Sauvegarde dans la base """
DB = GestionDB.DB()
# Enregistrement des informations générales sur le contrat
listeDonnees = (
("IDindividu", self.GetValeur("IDindividu", None)),
("IDinscription", self.GetValeur("IDinscription", None)),
("IDactivite", self.GetValeur("IDactivite", None)),
("date_debut", self.GetValeur("date_debut", None)),
("date_fin", self.GetValeur("date_fin", None)),
("observations", self.GetValeur("observations", None)),
("type", "psu"),
("duree_absences_prevues",
UTILS_Dates.DeltaEnStr(self.GetValeur("duree_absences_prevues",
datetime.timedelta(0)),
separateur=":")),
("duree_heures_regularisation",
UTILS_Dates.DeltaEnStr(self.GetValeur(
"duree_heures_regularisation", datetime.timedelta(0)),
separateur=":")),
("arrondi_type", self.GetValeur("arrondi_type", None)),
("arrondi_delta", self.GetValeur("arrondi_delta", 30)),
("planning", self.GetValeur("planning", None)),
)
if self.IDcontrat == None:
self.IDcontrat = DB.ReqInsert("contrats", listeDonnees)
else:
DB.ReqMAJ("contrats", listeDonnees, "IDcontrat", self.IDcontrat)
# Enregistrement des consommations
# liste_IDconso = []
# for track in self.GetValeur("tracks_previsions", []):
# listeDonnees = (
# ("IDindividu", self.GetValeur("IDindividu", None)),
# ("IDinscription", self.GetValeur("IDinscription", None)),
# ("IDactivite", self.GetValeur("IDactivite", None)),
# ("date", track.date),
# ("IDunite", track.IDunite),
# ("IDgroupe", self.GetValeur("IDgroupe", None)),
# ("heure_debut", track.heure_debut),
# ("heure_fin", track.heure_fin),
# ("etat", track.etat),
# #("date_saisie", track.date_saisie),
# ("IDutilisateur", UTILS_Identification.GetIDutilisateur()),
# ("IDcategorie_tarif", self.GetValeur("IDcategorie_tarif", None)),
# ("IDcompte_payeur", self.GetValeur("IDcompte_payeur", None)),
# #("IDprestation", track.IDprestation),#TODO
# #("forfait", track.forfait),#TODO
# ("quantite", track.quantite),
# #("etiquettes", track.etiquettes),#TODO
# )
# if track.IDconso == None :
# IDconso = DB.ReqInsert("consommations", listeDonnees)
# else :
# IDconso = track.IDconso
# DB.ReqMAJ("consommations", listeDonnees, "IDconso", IDconso)
# liste_IDconso.append(IDconso)
# Version optimisée
listeChamps = [
"IDindividu",
"IDinscription",
"IDactivite",
"date",
"IDunite",
"IDgroupe",
"heure_debut",
"heure_fin",
"etat",
"IDutilisateur",
"IDcategorie_tarif",
"IDcompte_payeur",
"quantite",
]
liste_IDconso = []
listeAjouts = []
listeModifications = []
for track in self.GetValeur("tracks_previsions", []):
listeDonnees = [
self.GetValeur("IDindividu", None),
self.GetValeur("IDinscription", None),
self.GetValeur("IDactivite", None),
track.date,
track.IDunite,
self.GetValeur("IDgroupe", None),
track.heure_debut,
track.heure_fin,
track.etat,
UTILS_Identification.GetIDutilisateur(),
self.GetValeur("IDcategorie_tarif", None),
self.GetValeur("IDcompte_payeur", None),
track.quantite,
]
if track.IDconso == None:
listeAjouts.append(listeDonnees)
else:
IDconso = track.IDconso
listeDonnees.append(IDconso)
listeModifications.append(listeDonnees)
liste_IDconso.append(IDconso)
# Ajout optimisé des conso
if len(listeAjouts) > 0:
texteChampsTemp = ", ".join(listeChamps)
listeInterrogations = []
for champ in listeChamps:
listeInterrogations.append("?")
texteInterrogations = ", ".join(listeInterrogations)
DB.Executermany("INSERT INTO consommations (%s) VALUES (%s)" %
(texteChampsTemp, texteInterrogations),
listeAjouts,
commit=True)
# Modification optimisée des conso
if len(listeModifications) > 0:
listeChampsTemp = []
for champ in listeChamps:
listeChampsTemp.append(("%s=?" % champ))
DB.Executermany("UPDATE consommations SET %s WHERE IDconso=?" %
", ".join(listeChampsTemp),
listeModifications,
commit=True)
# Suppression des consommations supprimées
listeSuppressions = []
for IDconso in self.GetValeur("liste_IDconso", []):
if IDconso not in liste_IDconso:
listeSuppressions.append(IDconso)
if len(listeSuppressions) > 0:
if len(listeSuppressions) == 1:
conditionSuppression = "(%d)" % listeSuppressions[0]
else:
conditionSuppression = str(tuple(listeSuppressions))
DB.ExecuterReq("DELETE FROM consommations WHERE IDconso IN %s" %
conditionSuppression)
# Enregistrement des tarifs
liste_IDtarif = []
for track in self.GetValeur("tracks_tarifs", []):
listeDonnees = (
("IDcontrat", self.IDcontrat),
("date_debut", track.date_debut),
("revenu", track.revenu),
("quotient", track.quotient),
("taux", track.taux),
("tarif_base", track.tarif_base),
("tarif_depassement", track.tarif_depassement),
)
if track.IDcontrat_tarif == None:
IDcontrat_tarif = DB.ReqInsert("contrats_tarifs", listeDonnees)
else:
IDcontrat_tarif = track.IDcontrat_tarif
DB.ReqMAJ("contrats_tarifs", listeDonnees, "IDcontrat_tarif",
IDcontrat_tarif)
liste_IDtarif.append(IDcontrat_tarif)
# Suppression des tarifs supprimés
listeSuppressions = []
for IDcontrat_tarif in self.GetValeur("liste_IDtarif", []):
if IDcontrat_tarif not in liste_IDtarif:
listeSuppressions.append(IDcontrat_tarif)
if len(listeSuppressions) > 0:
if len(listeSuppressions) == 1:
conditionSuppression = "(%d)" % listeSuppressions[0]
else:
conditionSuppression = str(tuple(listeSuppressions))
DB.ExecuterReq(
"DELETE FROM contrats_tarifs WHERE IDcontrat_tarif IN %s" %
conditionSuppression)
# Enregistrement des mensualités
# liste_IDprestation = []
# for track in self.GetValeur("tracks_mensualites", []):
# listeDonnees = (
# ("IDcompte_payeur", self.GetValeur("IDcompte_payeur", None)),
# ("date", track.date_facturation),
# ("categorie", "consommation"),
# ("label", track.label_prestation),
# ("montant_initial", track.montant_mois),
# ("montant", track.montant_mois),
# ("IDactivite", self.GetValeur("IDactivite", None)),
# ("IDtarif", self.GetValeur("IDtarif", None)),
# ("IDfacture", track.IDfacture),
# ("IDfamille", self.GetValeur("IDfamille", None)),
# ("IDindividu", self.GetValeur("IDindividu", None)),
# ("forfait", None),
# ("temps_facture", UTILS_Dates.DeltaEnStr(track.heures_facturees, ":")),
# ("IDcategorie_tarif", self.GetValeur("IDcategorie_tarif", None)),
# ("forfait_date_debut", track.forfait_date_debut),
# ("forfait_date_fin", track.forfait_date_fin),
# ("IDcontrat", self.IDcontrat),
# )
# if track.IDprestation == None :
# IDprestation = DB.ReqInsert("prestations", listeDonnees)
# else :
# IDprestation = track.IDprestation
# DB.ReqMAJ("prestations", listeDonnees, "IDprestation", IDprestation)
# liste_IDprestation.append(IDprestation)
#
# # Suppression des prestations supprimées
# listeSuppressions = []
# for IDprestation in self.GetValeur("liste_IDprestation", []):
# if IDprestation not in liste_IDprestation :
# listeSuppressions.append(IDprestation)
#
# if len(listeSuppressions) > 0 :
# if len(listeSuppressions) == 1 :
# conditionSuppression = "(%d)" % listeSuppressions[0]
# else :
# conditionSuppression = str(tuple(listeSuppressions))
# DB.ExecuterReq("DELETE FROM prestations WHERE IDprestation IN %s" % conditionSuppression)
# DB.ExecuterReq("DELETE FROM ventilation WHERE IDprestation IN %s" % conditionSuppression)
# DB.ExecuterReq("DELETE FROM deductions WHERE IDprestation IN %s" % conditionSuppression)
DB.Commit()
DB.Close()
def OnBoutonOk(self, event):
# Vérification des données
if len(self.ctrl_nom.GetValue()) == 0:
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir un nom !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return
if self.mdpcrypt == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir un mot de passe !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Vérifie que le code d'accès n'est pas déjà utilisé
if self.IDutilisateur == None:
IDutilisateurTmp = 0
else:
IDutilisateurTmp = self.IDutilisateur
DB = GestionDB.DB()
req = """SELECT IDutilisateur, sexe, nom, prenom, mdp, mdpcrypt, profil, actif
FROM utilisateurs
WHERE mdpcrypt='%s' AND IDutilisateur<>%d
;""" % (self.mdpcrypt, IDutilisateurTmp)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) > 0:
dlg = wx.MessageDialog(
self,
_(u"Le code d'accès que vous avez saisi est déjà attribué !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Vérifie qu'il reste au moins un administrateur dans la base de données
if self.radio_droits_admin.GetValue() == False:
DB = GestionDB.DB()
req = """SELECT IDutilisateur, profil
FROM utilisateurs
WHERE profil='administrateur' AND IDutilisateur!=%d;""" % IDutilisateurTmp
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
dlg = wx.MessageDialog(
self,
_(u"Il doit rester au moins un administrateur dans le fichier !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Vérifie qu'il reste au moins un administrateur ACTIF dans la base de données
if self.ctrl_actif.GetValue() == False:
DB = GestionDB.DB()
req = """SELECT IDutilisateur, profil, actif
FROM utilisateurs
WHERE profil='administrateur' AND actif=1 AND IDutilisateur!=%d;""" % IDutilisateurTmp
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
dlg = wx.MessageDialog(
self,
_(u"Il doit rester au moins un administrateur ACTIF dans le fichier ! Cochez la case Actif."
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Droits
if self.radio_droits_modele.GetValue() == True:
if self.ctrl_modele_droits.GetID() == None:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucun modèle de droits !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Vérifie que le compte n'est pas inactif alors que le compte internet est actif
dictCompteInternet = self.ctrl_compte_internet.GetDonnees()
if dictCompteInternet[
"internet_actif"] == 1 and self.ctrl_actif.GetValue() == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez désactiver le compte internet si vous souhaitez désactiver cet utilisateur !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Sauvegarde
self.Sauvegarde()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
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 OnBoutonOk(self, event):
# Sélection des lignes
if self.radio_ligne_selectionnee.GetValue() == True:
tracks = self.listview.GetSelectedObjects()
if self.radio_lignes_affichees.GetValue() == True:
tracks = self.listview.GetFilteredObjects()
if self.radio_lignes_cochees.GetValue() == True:
tracks = self.listview.GetCheckedObjects()
# Récupération de toutes les adresses Emails
listeDonnees = []
listeAnomalies = []
if self.radio_individu.GetValue() == True:
DB = GestionDB.DB()
req = """SELECT IDindividu, nom, prenom, mail
FROM individus;"""
DB.ExecuterReq(req)
listeAdressesIndividus = DB.ResultatReq()
DB.Close()
dictAdressesIndividus = {}
for IDindividu, nom, prenom, mail in listeAdressesIndividus:
dictAdressesIndividus[IDindividu] = {
"mail": mail,
"nom": nom,
"prenom": prenom
}
for track in tracks:
if dictAdressesIndividus.has_key(track.IDindividu):
adresse = dictAdressesIndividus[track.IDindividu]["mail"]
nom, prenom = dictAdressesIndividus[
track.IDindividu]["nom"], dictAdressesIndividus[
track.IDindividu]["prenom"]
if prenom == None: prenom = ""
nomIndividu = u"%s %s" % (nom, prenom)
if adresse not in ("", None):
dictTemp = {
"adresse": adresse,
"pieces": [],
"champs": {}
}
if dictTemp not in listeDonnees:
listeDonnees.append(dictTemp)
else:
listeAnomalies.append(nomIndividu)
if self.radio_famille.GetValue() == True:
dict_titulaires = UTILS_Titulaires.GetTitulaires()
for track in tracks:
adresse = None
if dict_titulaires.has_key(track.IDfamille):
#adresse = UTILS_Envoi_email.GetAdresseFamille(track.IDfamille, choixMultiple=False, muet=True, nomTitulaires=track.nomTitulaires)
listeEmails = dict_titulaires[
track.IDfamille]["listeMails"]
if len(listeEmails) > 0:
adresse = listeEmails[0]
# Mémorisation des données
if adresse != None:
dictTemp = {
"adresse": adresse,
"pieces": [],
"champs": {}
}
if dictTemp not in listeDonnees:
listeDonnees.append(dictTemp)
else:
listeAnomalies.append(dict_titulaires[track.IDfamille]
["titulairesSansCivilite"])
# Annonce les anomalies trouvées
if len(listeAnomalies) > 0:
if self.radio_famille.GetValue() == True:
introduction = _(
u"%d des familles sélectionnées n'ont pas d'adresse Email :"
) % len(listeAnomalies)
conclusion = _(
u"Souhaitez-vous quand même continuer avec les %d autres familles ?"
) % len(listeDonnees)
else:
introduction = _(
u"%d des individus sélectionnés n'ont pas d'adresse Email :"
) % len(listeAnomalies)
conclusion = _(
u"Souhaitez-vous quand même continuer avec les %d autres individus ?"
) % len(listeDonnees)
dlg = DLG_Messagebox.Dialog(
self,
titre=_(u"Anomalies"),
introduction=introduction,
detail=u"\n".join(listeAnomalies),
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
# Dernière vérification avant transfert
if len(listeDonnees) == 0:
dlg = wx.MessageDialog(
self, _(u"Il ne reste finalement aucun email à envoyer !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Transfert des données vers DLG Mailer
from Dlg import DLG_Mailer
dlg = DLG_Mailer.Dialog(self)
dlg.SetDonnees(listeDonnees, modificationAutorisee=True)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def Validation(self):
# Vérifie qu'un nom a été saisi
if self.text_nom.GetValue() == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir un nom pour ce modèle !"
), "Erreur", wx.OK)
dlg.ShowModal()
dlg.Destroy()
self.text_nom.SetFocus()
return False
# Enregistrement des données
dictModeles = self.GetGrandParent().dictModeles
dictChamps = self.GetGrandParent().dictChamps
DB = GestionDB.DB()
# Enregistrement des données du MODELE
listeDonnees = [
("IDclassification", dictModeles["IDclassification"]),
("IDtype", dictModeles["IDtype"]),
("nom", self.text_nom.GetValue()),
("description", self.text_description.GetValue()),
]
if dictModeles["IDmodele"] == 0:
# Ajout
IDmodele = DB.ReqInsert("contrats_modeles", listeDonnees)
DB.Commit()
else:
# Modification
DB.ReqMAJ("contrats_modeles", listeDonnees, "IDmodele",
dictModeles["IDmodele"])
DB.Commit()
IDmodele = dictModeles["IDmodele"]
# Enregistrement des données des CHAMPS
# Crée une liste des champs existants déjà pour ce contrat
req = "SELECT IDval_champ, IDchamp FROM contrats_valchamps WHERE (IDmodele=%d AND type='modele') ;" % IDmodele
DB.ExecuterReq(req)
listeChampsDB = DB.ResultatReq()
nbreResultats = len(listeChampsDB)
# On regarde chaque champ un par un
for IDchamp, valeur in dictChamps.items():
listeDonnees = [
("IDchamp", IDchamp),
("type", "modele"),
("valeur", valeur),
("IDmodele", IDmodele),
("IDcontrat", 0),
]
# Recherche si le champ existe déjà dans la base
modif = False
for IDval_champDB, IDchampDB in listeChampsDB:
if IDchampDB == IDchamp:
# Le champ existe déjà, alors on le modifie :
DB.ReqMAJ("contrats_valchamps", listeDonnees,
"IDval_champ", IDval_champDB)
DB.Commit()
modif = True
if modif == False:
# Le champ n'existe pas dans la base, alors on le créée :
ID = DB.ReqInsert("contrats_valchamps", listeDonnees)
DB.Commit()
# On efface les champs déjà créés qui ne sont plus utilisés :
for IDval_champDB, IDchampDB in listeChampsDB:
trouve = False
for IDchamp, valeur in dictChamps.items():
if IDchampDB == IDchamp: trouve = True
if trouve == False:
# On l'efface :
DB.ReqDEL("contrats_valchamps", "IDval_champ", IDval_champDB)
# Fermeture de la DB
DB.Close()
# Recherche si un parent est à mettre à jour
if FonctionsPerso.FrameOuverte(
"panel_config_Modeles_Contrats") != None:
self.GetGrandParent().GetParent().MAJ_ListCtrl()
return True
def Supprimer(self, event):
item = self.GetSelection()
dictData = self.GetPyData(item)
if dictData == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner une étiquette à supprimer !"
), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
IDetiquette = dictData["IDetiquette"]
dictConsoAssociees = self.RechercheNbreConsoAssociees()
if dictConsoAssociees.has_key(IDetiquette):
if dictConsoAssociees[IDetiquette] > 0:
dlg = wx.MessageDialog(
self,
_(u"Cette étiquette a déjà été associée à %d consommation(s) !\n\nVous ne pouvez donc pas la supprimer."
% dictConsoAssociees[IDetiquette]), "Erreur de saisie",
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Confirmation de suppression des étiquettes enfants
listeTousEnfants = []
if self.GetChildrenCount(item, recursively=True) > 0:
# Récupère la liste des tous les items enfants (récursif)
self.GetItemsEnfants(listeTousEnfants, item)
# Va servir à vérifier les liens avec les autres tables :
for dictDataTemp in listeTousEnfants:
if dictConsoAssociees.has_key(dictDataTemp["IDetiquette"]):
if dictConsoAssociees[dictDataTemp["IDetiquette"]] > 0:
dlg = wx.MessageDialog(
self,
_(u"L'étiquette enfant '%s' qui dépend de l'étiquette sélectionnée a déjà été associée à %d consommation(s) !\n\nVous ne pouvez donc pas supprimer l'étiquette parent."
% (dictDataTemp["label"],
dictDataTemp["IDetiquette"])),
"Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Demande de confirmation
dlg = wx.MessageDialog(
self,
_(u"Attention, cette étiquette comporte des étiquettes enfants.\n\nSouhaitez-vous vraiment supprimer cette étiquette ? Les étiquettes enfants seront également supprimées !"
), _(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
# Confirmation de suppression
dlg = wx.MessageDialog(
self, _(u"Souhaitez-vous vraiment supprimer cette étiquette ?"),
_(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
DB = GestionDB.DB()
# Suppression de l'étiquette
DB.ReqDEL("etiquettes", "IDetiquette", dictData["IDetiquette"])
# Suppression des étiquettes enfants également
for dictTemp in listeTousEnfants:
DB.ReqDEL("etiquettes", "IDetiquette", dictTemp["IDetiquette"])
# Modification de l'ordre des étiquettes soeurs
itemParent = self.GetItemParent(item)
listeItemsSoeurs = []
self.GetItemsEnfants(liste=listeItemsSoeurs,
item=itemParent,
recursif=False)
ordre = 1
for dictDataTemp in listeItemsSoeurs:
if dictDataTemp["IDetiquette"] != dictData["IDetiquette"]:
DB.ReqMAJ("etiquettes", [
("ordre", ordre),
], "IDetiquette", dictDataTemp["IDetiquette"])
ordre += 1
DB.Close()
self.MAJ()
dlg.Destroy()
def GetTracks(self):
""" Récupération des données """
# Critères
listeID = None
self.criteres = ""
# Liste de filtres
if len(self.listeFiltres) > 0 :
listeID, criteres = self.GetListeFiltres(self.listeFiltres)
if criteres != "" :
if self.criteres == "" :
self.criteres = "WHERE " + criteres
else:
self.criteres += " AND " + criteres
# Importation des villes par défaut
DB = GestionDB.DB(nomFichier=Chemins.GetStaticPath("Databases/Geographie.dat"), suffixe=None)
req = """SELECT IDville, nom, cp
FROM villes %s ORDER BY nom; """ % self.criteres
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Importation des corrections de villes et codes postaux
DB = GestionDB.DB()
req = """SELECT IDcorrection, mode, IDville, nom, cp
FROM corrections_villes; """
DB.ExecuterReq(req)
listeCorrections = DB.ResultatReq()
DB.Close()
# Ajout des corrections
dictCorrections = {}
for IDcorrection, mode, IDville, nom, cp in listeCorrections :
dictCorrections[IDville] = {"mode":mode, "nom":nom, "cp":cp, "IDcorrection":IDcorrection}
if mode == "ajout" :
listeDonnees.append((100000+IDcorrection, nom, cp))
listeListeView = []
for IDville, nom, cp in listeDonnees :
mode = None
# Filtre de sélection
valide = True
if listeID != None :
if IDville not in listeID :
valide = False
# Traitement des corrections
if dictCorrections.has_key(IDville) :
mode = dictCorrections[IDville]["mode"]
if mode == "modif" :
nom = dictCorrections[IDville]["nom"]
cp = dictCorrections[IDville]["cp"]
IDville = 100000 + dictCorrections[IDville]["IDcorrection"]
if mode == "suppr" :
valide = False
if IDville > 100000 and mode == None :
mode = "ajout"
# Création des tracks
if valide == True :
track = Track((IDville, nom, cp, mode))
listeListeView.append(track)
if self.selectionID == IDville :
self.selectionTrack = track
return listeListeView
def Supprimer(self, event):
if len(self.Selection()) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucun utilisateur à supprimer dans la liste !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"parametrage_utilisateurs", "supprimer") == False:
return
IDutilisateur = self.Selection()[0].IDutilisateur
profil = self.Selection()[0].profil
# Vérifie que cet utilisateur n'est pas déjà attribué à d'autres tables de données
# Table Consommations
DB = GestionDB.DB()
req = """SELECT COUNT(IDconso)
FROM consommations
WHERE IDutilisateur=%d
;""" % IDutilisateur
DB.ExecuterReq(req)
nbreConso = int(DB.ResultatReq()[0][0])
DB.Close()
if nbreConso > 0:
dlg = wx.MessageDialog(
self,
_(u"Cet utilisateur a déjà été attribué à %d consommation(s).\n\nVous ne pouvez donc pas le supprimer !"
) % nbreConso, _(u"Suppression impossible"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Table Règlements
DB = GestionDB.DB()
req = """SELECT COUNT(IDreglement)
FROM reglements
WHERE IDutilisateur=%d
;""" % IDutilisateur
DB.ExecuterReq(req)
nbreReglements = int(DB.ResultatReq()[0][0])
DB.Close()
if nbreReglements > 0:
dlg = wx.MessageDialog(
self,
_(u"Cet utilisateur a déjà été attribué à %d règlement(s).\n\nVous ne pouvez donc pas le supprimer !"
) % nbreReglements, _(u"Suppression impossible"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Vérifie qu'il reste au moins un administrateur
if profil == "administrateur":
nbreAdmin = 0
for track in self.donnees:
if track.profil == "administrateur" and track.IDutilisateur != IDutilisateur:
nbreAdmin += 1
if nbreAdmin == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous ne pouvez pas supprimer le seul administrateur !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Suppression
dlg = wx.MessageDialog(
self, _(u"Souhaitez-vous vraiment supprimer cet utilisateur ?"),
_(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
DB = GestionDB.DB()
DB.ReqDEL("utilisateurs", "IDutilisateur", IDutilisateur)
DB.ReqDEL("droits", "IDutilisateur", IDutilisateur)
DB.Close()
self.MAJ()
dlg.Destroy()
def Supprimer(self, event):
item = self.GetSelection()
dictData = self.GetPyData(item)
if item == None or dictData == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner une page ou un bloc à supprimer !"
), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if 'phoenix' in wx.PlatformInfo:
dictData = self.GetItemData(item)
else:
dictData = self.GetPyData(item)
# Suppression d'une page
if dictData["type"] == "page":
# Confirmation de suppression des blocs
listeTousEnfants = []
if self.GetChildrenCount(item, recursively=True) > 0:
# Récupère la liste des tous les items enfants (récursif)
self.GetItemsEnfants(listeTousEnfants, item)
# Demande de confirmation
dlg = wx.MessageDialog(
self,
_(u"Attention, cette page comporte des blocs.\n\nSouhaitez-vous vraiment supprimer cette page ? Les blocs seront également supprimées !"
), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT
| wx.CANCEL | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
# Confirmation de suppression
dlg = wx.MessageDialog(
self, _(u"Souhaitez-vous vraiment supprimer cette page ?"),
_(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
DB = GestionDB.DB()
# Suppression de la page
DB.ReqDEL("portail_pages", "IDpage", dictData["ID"])
# Suppression des blocs également
for dictTemp in listeTousEnfants:
DB.ReqDEL("portail_blocs", "IDbloc", dictTemp["ID"])
DB.ReqDEL("portail_elements", "IDbloc", dictTemp["ID"])
# Modification de l'ordre des pages
itemParent = self.GetItemParent(item)
listeItemsSoeurs = []
self.GetItemsEnfants(liste=listeItemsSoeurs,
item=itemParent,
recursif=False)
ordre = 1
for dictDataTemp in listeItemsSoeurs:
if dictDataTemp["ID"] != dictData["ID"]:
DB.ReqMAJ("portail_pages", [
("ordre", ordre),
], "IDpage", dictDataTemp["ID"])
ordre += 1
DB.Close()
self.MAJ()
dlg.Destroy()
# Suppression d'un bloc
if dictData["type"] == "bloc":
# Confirmation de suppression
dlg = wx.MessageDialog(
self, _(u"Souhaitez-vous vraiment supprimer ce bloc ?"),
_(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
DB = GestionDB.DB()
# Suppression du bloc
DB.ReqDEL("portail_blocs", "IDbloc", dictData["ID"])
DB.ReqDEL("portail_elements", "IDbloc", dictData["ID"])
# Modification de l'ordre des blocs
itemParent = self.GetItemParent(item)
listeItemsSoeurs = []
self.GetItemsEnfants(liste=listeItemsSoeurs,
item=itemParent,
recursif=False)
ordre = 1
for dictDataTemp in listeItemsSoeurs:
if dictDataTemp["ID"] != dictData["ID"]:
DB.ReqMAJ("portail_blocs", [
("ordre", ordre),
], "IDbloc", dictDataTemp["ID"])
ordre += 1
DB.Close()
self.MAJ()
dlg.Destroy()
# Mémorise la date de la modification
self.MemoriseDateModification()
def Validation(self):
""" Validation des données saisies """
# Vérifie date début
date_debut = self.ctrl_date_debut.GetDate()
if self.ctrl_date_debut.FonctionValiderDate(
) == False or date_debut == None:
dlg = wx.MessageDialog(
self,
_(u"La date de début de période ne semble pas valide !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_debut.SetFocus()
return False
# Vérifie date fin
date_fin = self.ctrl_date_fin.GetDate()
if self.ctrl_date_fin.FonctionValiderDate(
) == False or date_fin == None:
dlg = wx.MessageDialog(
self, _(u"La date de fin de période ne semble pas valide !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return False
# Vérifie les deux dates
if date_debut > date_fin:
dlg = wx.MessageDialog(
self,
_(u"La date de début de période est supérieure à la date de fin !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return False
# Vérifie que la période sélectionnée n'est pas dans une période de gestion
gestion = UTILS_Gestion.Gestion(None)
if gestion.IsPeriodeinPeriodes("factures", date_debut,
date_fin) == False:
return False
# Vérifier si lot de factures
IDlot = self.ctrl_lot.GetID()
nomLot = self.ctrl_lot.GetNom()
if IDlot == None:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez pas sélectionné de lot de factures à associer.\n\nSouhaitez-vous quand même continuer ?"
), _(u"Confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
resultat = dlg.ShowModal()
dlg.Destroy()
if resultat != wx.ID_YES:
return False
# Préfixe de facture
IDprefixe = self.ctrl_prefixe.GetID()
prefixe = self.ctrl_prefixe.GetPrefixe()
# Prochain numéro de facture
if self.check_numero_auto.GetValue() == True:
# Numéro auto
prochain_numero = None
else:
# Numéro perso
try:
prochain_numero = int(self.ctrl_prochain_numero.GetValue())
except:
prochain_numero = None
if prochain_numero in (None, ""):
dlg = wx.MessageDialog(
self,
_(u"Le prochain numéro de facture ne semble pas valide !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_prochain_numero.SetFocus()
return False
if prochain_numero < self.prochain_numero_defaut:
dlg = wx.MessageDialog(
self,
_(u"Le prochain numéro de facture n'est pas valide : une facture générée porte déjà un numéro égal ou supérieur !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_prochain_numero.SetFocus()
return False
# Date d'émission
date_emission = self.ctrl_date_emission.GetDate()
if self.ctrl_date_emission.FonctionValiderDate(
) == False or date_emission == None:
dlg = wx.MessageDialog(
self, _(u"La date d'émission ne semble pas valide !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_emission.SetFocus()
return False
# Date d'échéance
date_echeance = self.ctrl_date_echeance.GetDate()
if date_echeance == None:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez pas saisi de date d'échéance. \n\nSouhaitez-vous quand même continuer ?"
), _(u"Confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
resultat = dlg.ShowModal()
dlg.Destroy()
if resultat != wx.ID_YES:
return False
# Vérifier si lot de factures
prestations = []
if self.check_consommations.GetValue() == True:
prestations.append("consommation")
if self.check_cotisations.GetValue() == True:
prestations.append("cotisation")
if self.check_locations.GetValue() == True:
prestations.append("location")
if self.check_autres.GetValue() == True: prestations.append("autre")
if len(prestations) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement cocher au moins un type de prestation à facturer !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Familles
if self.radio_familles_toutes.GetValue() == True:
IDcompte_payeur_unique = None
else:
IDcompte_payeur_unique = self.ctrl_famille.GetIDcompte_payeur()
if IDcompte_payeur_unique == None:
dlg = wx.MessageDialog(
self,
_(u"Vous avez sélectionné l'option 'famille unique' mais sans sélectionner de famille dans la liste proposée !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérifie les activités sélectionnées
listeActivites = self.ctrl_activites.GetActivites()
if len(listeActivites) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune activité.\n\nSouhaitez-vous quand même continuer ?"
), _(u"Avertissement"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
resultat = dlg.ShowModal()
dlg.Destroy()
if resultat != wx.ID_YES:
return False
# Date antérieure
date_anterieure = None
if self.check_prestations_anterieures.GetValue() == True:
date_anterieure = self.ctrl_date_anterieures.GetDate()
if self.ctrl_date_anterieures.FonctionValiderDate(
) == False or date_anterieure == None:
dlg = wx.MessageDialog(
self, _(u"La date antérieure ne semble pas valide !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_anterieures.SetFocus()
return False
# Vérification droits utilisateurs
for IDactivite in listeActivites:
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"facturation_factures",
"creer",
IDactivite=IDactivite,
afficheMessage=False) == False:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez pas l'autorisation de générer des factures pour l'ensemble des activités sélectionnées !"
), _(u"Action non autorisée"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérifie la compatibilité des régies des activités sélectionnées
IDregie = None
if len(listeActivites) >= 1:
listeAllRegies = []
for IDactivite in listeActivites:
DB = GestionDB.DB()
req = """SELECT regie
FROM activites
WHERE IDactivite = %d""" % IDactivite
DB.ExecuterReq(req)
listeresult = DB.ResultatReq()
result = listeresult[0]
listeAllRegies.append(result[0])
DB.Close()
listeRegies = list(set(listeAllRegies))
if len(listeRegies) > 1:
dlg = wx.MessageDialog(
self,
_(u"Vous ne pouvez pas générer des factures pour l'ensemble des activités sélectionnées !\n\nCertaines activités sont liées à des régies différentes"
), _(u"Régies différentes"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
else:
IDregie = listeRegies[0]
# Envoi des données à DLG_Factures_generation
self.parent.dictParametres = {
"date_debut": date_debut,
"date_fin": date_fin,
"IDlot": IDlot,
"nomLot": nomLot,
"date_emission": date_emission,
"date_echeance": date_echeance,
"prochain_numero": prochain_numero,
"prestations": prestations,
"IDcompte_payeur": IDcompte_payeur_unique,
"listeActivites": listeActivites,
"IDprefixe": IDprefixe,
"prefixe": prefixe,
"date_anterieure": date_anterieure,
"IDregie": IDregie,
}
return True
def Importation(self):
""" Importation des données """
dictDonnees = {}
if self.IDmodele == None or self.date_debut == None or self.date_fin == None:
return dictDonnees
DB = GestionDB.DB()
# Modèle
req = """SELECT modeles_commandes.nom, modeles_commandes.IDrestaurateur, parametres,
restaurateurs.nom, restaurateurs.tel, restaurateurs.mail
FROM modeles_commandes
LEFT JOIN restaurateurs ON restaurateurs.IDrestaurateur = modeles_commandes.IDrestaurateur
WHERE IDmodele=%d;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
nom_modele, IDrestaurateur, parametres, restaurateur_nom, restaurateur_tel, restaurateur_mail = listeDonnees[
0]
if type(parametres) in (str, unicode):
exec(u"parametres = %s" % parametres)
dictDonnees["modele_nom"] = nom_modele
dictDonnees["modele_parametres"] = parametres
dictDonnees["IDrestaurateur"] = IDrestaurateur
dictDonnees["restaurateur_nom"] = restaurateur_nom
dictDonnees["restaurateur_tel"] = restaurateur_tel
dictDonnees["restaurateur_mail"] = restaurateur_mail
# Colonnes
req = """SELECT IDcolonne, ordre, nom, largeur, categorie, parametres
FROM modeles_commandes_colonnes
WHERE IDmodele=%d
ORDER BY ordre;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["liste_colonnes"] = []
dictDonnees["dict_colonnes"] = {}
if len(listeDonnees) > 0:
index = 0
for IDcolonne, ordre, nom_colonne, largeur, categorie, parametres in listeDonnees:
if type(parametres) in (str, unicode):
exec(u"parametres = %s" % parametres)
dictColonne = {
"IDcolonne": IDcolonne,
"ordre": ordre,
"nom_colonne": nom_colonne,
"largeur": largeur,
"categorie": categorie,
"parametres": parametres
}
dictDonnees["liste_colonnes"].append(dictColonne)
dictDonnees["dict_colonnes"][index] = dictColonne
index += 1
# Recherche les activités concernées
listeUnites = []
for dictColonne in dictDonnees["liste_colonnes"]:
if dictColonne["parametres"].has_key("unites"):
for (IDgroupe, IDunite) in dictColonne["parametres"]["unites"]:
if IDunite not in listeUnites:
listeUnites.append(IDunite)
if len(listeUnites) == 0: conditionUnites = "()"
elif len(listeUnites) == 1: conditionUnites = "(%d)" % listeUnites[0]
else: conditionUnites = str(tuple(listeUnites))
# Ouvertures
req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe, date
FROM ouvertures
WHERE date>='%s' AND date<='%s' AND IDunite IN %s;""" % (
self.date_debut, self.date_fin, conditionUnites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["liste_ouvertures"] = []
dictDonnees["dict_ouvertures"] = {}
dictDonnees["liste_dates"] = []
for IDouverture, IDactivite, IDunite, IDgroupe, date in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
dictOuverture = {
"IDouverture": IDouverture,
"IDactivite": IDactivite,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"date": date
}
dictDonnees["liste_ouvertures"].append(dictOuverture)
# Mémorisation dans un dict
dictDonnees["dict_ouvertures"] = UTILS_Divers.DictionnaireImbrique(
dictionnaire=dictDonnees["dict_ouvertures"],
cles=[date, IDgroupe, IDunite],
valeur=True)
# Mémorisation des dates
if date not in dictDonnees["liste_dates"]:
dictDonnees["liste_dates"].append(date)
dictDonnees["liste_dates"].sort()
dictDonnees["liste_dates"].append(_(u"Total"))
# Consommations
req = """SELECT IDconso, date, IDgroupe, IDunite, IDindividu
FROM consommations
WHERE date>='%s' AND date<='%s' AND IDunite IN %s AND consommations.etat IN ('reservation', 'present')
;""" % (self.date_debut, self.date_fin, conditionUnites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["dict_conso"] = {}
dictDonnees["liste_individus"] = []
dictDonnees["dict_dates"] = {}
for IDconso, date, IDgroupe, IDunite, IDindividu in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dictDonnees["dict_conso"].has_key(date) == False:
dictDonnees["dict_conso"][date] = {}
if dictDonnees["dict_conso"][date].has_key(IDgroupe) == False:
dictDonnees["dict_conso"][date][IDgroupe] = {}
if dictDonnees["dict_conso"][date][IDgroupe].has_key(
IDunite) == False:
dictDonnees["dict_conso"][date][IDgroupe][IDunite] = 0
dictDonnees["dict_conso"][date][IDgroupe][IDunite] += 1
if IDindividu not in dictDonnees["liste_individus"]:
dictDonnees["liste_individus"].append(IDindividu)
if dictDonnees["dict_dates"].has_key(date) == False:
dictDonnees["dict_dates"][date] = {}
if dictDonnees["dict_dates"][date].has_key(IDindividu) == False:
dictDonnees["dict_dates"][date][IDindividu] = []
if IDgroupe not in dictDonnees["dict_dates"][date][IDindividu]:
dictDonnees["dict_dates"][date][IDindividu].append(IDgroupe)
if len(dictDonnees["liste_individus"]) == 0: conditionIndividus = "()"
elif len(dictDonnees["liste_individus"]) == 1:
conditionIndividus = "(%d)" % dictDonnees["liste_individus"][0]
else:
conditionIndividus = str(tuple(dictDonnees["liste_individus"]))
# Informations médicales
req = """SELECT IDprobleme, problemes_sante.IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical,
description_traitement, date_debut_traitement, date_fin_traitement,
individus.nom, individus.prenom
FROM problemes_sante
LEFT JOIN individus ON individus.IDindividu = problemes_sante.IDindividu
WHERE diffusion_listing_repas=1 AND problemes_sante.IDindividu IN %s
;""" % conditionIndividus
DB.ExecuterReq(req)
listeInformations = DB.ResultatReq()
dictInfosMedicales = {}
for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, individu_nom, individu_prenom in listeInformations:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
if dictInfosMedicales.has_key(IDindividu) == False:
dictInfosMedicales[IDindividu] = []
dictTemp = {
"IDprobleme": IDprobleme,
"IDcategorie": IDtype,
"intitule": intitule,
"date_debut": date_debut,
"date_fin": date_fin,
"description": description,
"traitement_medical": traitement_medical,
"description_traitement": description_traitement,
"date_debut_traitement": date_debut_traitement,
"date_fin_traitement": date_fin_traitement,
"individu_nom": individu_nom,
"individu_prenom": individu_prenom,
}
dictInfosMedicales[IDindividu].append(dictTemp)
dictDonnees["infos_medicales"] = dictInfosMedicales
# Messages
req = """SELECT IDmessage, IDcategorie, priorite,
messages.IDindividu, texte, individus.nom, individus.prenom
FROM messages
LEFT JOIN individus ON individus.IDindividu = messages.IDindividu
WHERE afficher_commande=1 AND messages.IDindividu IN %s
;""" % conditionIndividus
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictMessages = {}
for IDmessage, IDcategorie, priorite, IDindividu, texte, individu_nom, individu_prenom in listeDonnees:
dictTemp = {
"IDmessage": IDmessage,
"IDindividu": IDindividu,
"priorite": priorite,
"texte": texte,
"individu_nom": individu_nom,
"individu_prenom": individu_prenom
}
if dictMessages.has_key(IDindividu) == False:
dictMessages[IDindividu] = []
dictMessages[IDindividu].append(dictTemp)
dictDonnees["messages"] = dictMessages
# Repas
dictDonnees["valeurs"] = {}
if self.IDcommande != None:
req = """SELECT IDvaleur, date, IDcolonne, valeur
FROM commandes_valeurs
WHERE IDcommande=%d
;""" % self.IDcommande
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDvaleur, date, IDcolonne, valeur in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dictDonnees["valeurs"].has_key(date) == False:
dictDonnees["valeurs"][date] = {}
dictDonnees["valeurs"][date][IDcolonne] = {
"IDvaleur": IDvaleur,
"valeur": valeur
}
# Menus
if dictDonnees.has_key("IDrestaurateur"):
IDrestaurateur = dictDonnees["IDrestaurateur"]
if IDrestaurateur == None:
IDrestaurateur = 0
else:
IDrestaurateur = 0
req = """SELECT IDmenu, menus.IDcategorie, menus_categories.nom, date, texte
FROM menus
LEFT JOIN menus_categories ON menus_categories.IDcategorie = menus.IDcategorie
WHERE date>='%s' AND date<='%s' AND IDrestaurateur=%d
ORDER BY menus_categories.ordre;""" % (self.date_debut, self.date_fin,
IDrestaurateur)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dict_menus = {}
for IDmenu, IDcategorie, nom_categorie, date, texte in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dict_menus.has_key(date) == False:
dict_menus[date] = []
dict_menus[date].append({
"IDmenu": IDmenu,
"IDcategorie": IDcategorie,
"nom_categorie": nom_categorie,
"texte": texte
})
dictDonnees["dict_menus"] = dict_menus
DB.Close()
return dictDonnees
