def Importation(onlyNonVentiles=True, IDcompte_payeur=None):
DB = GestionDB.DB()
if IDcompte_payeur != None:
conditionCompte = "WHERE IDcompte_payeur=%d" % IDcompte_payeur
else:
conditionCompte = ""
# Récupère les comptes payeurs
req = """SELECT IDcompte_payeur, IDfamille
FROM comptes_payeurs
%s
ORDER BY IDcompte_payeur
;""" % conditionCompte
DB.ExecuterReq(req)
listeComptes = DB.ResultatReq()
# Mémorise les IDfamille
listeIDfamille = [IDfamille for temp, IDfamille in listeComptes]
# Récupère la ventilation
req = """SELECT IDcompte_payeur, SUM(montant) AS total_ventilations
FROM ventilation
%s
GROUP BY IDcompte_payeur
ORDER BY IDcompte_payeur
;""" % conditionCompte
DB.ExecuterReq(req)
listeVentilations = DB.ResultatReq()
dictVentilations = {}
for IDcompte_payeur, total_ventilations in listeVentilations:
dictVentilations[IDcompte_payeur] = total_ventilations
# Récupère les prestations
req = """SELECT IDcompte_payeur, SUM(montant) AS total_prestations
FROM prestations
%s
GROUP BY IDcompte_payeur
ORDER BY IDcompte_payeur
;""" % conditionCompte
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
dictPrestations = {}
for IDcompte_payeur, total_prestations in listePrestations:
dictPrestations[IDcompte_payeur] = total_prestations
# Récupère les règlements
req = """SELECT IDcompte_payeur, SUM(montant) AS total_reglements
FROM reglements
%s
GROUP BY IDcompte_payeur
ORDER BY IDcompte_payeur
;""" % conditionCompte
DB.ExecuterReq(req)
listeReglements = DB.ResultatReq()
dictReglements = {}
for IDcompte_payeur, total_reglements in listeReglements:
dictReglements[IDcompte_payeur] = total_reglements
DB.Close()
# Récupération des titulaires de familles
dictTitulaires = UTILS_Titulaires.GetTitulaires(
listeIDfamille=listeIDfamille)
# Traitement des données
listeListeView = []
for IDcompte_payeur, IDfamille in listeComptes:
if IDcompte_payeur in dictVentilations:
total_ventilations = FloatToDecimal(
dictVentilations[IDcompte_payeur])
else:
total_ventilations = FloatToDecimal(0.0)
if IDcompte_payeur in dictPrestations:
total_prestations = FloatToDecimal(
dictPrestations[IDcompte_payeur])
else:
total_prestations = FloatToDecimal(0.0)
if IDcompte_payeur in dictReglements:
total_reglements = FloatToDecimal(dictReglements[IDcompte_payeur])
else:
total_reglements = FloatToDecimal(0.0)
item = (IDcompte_payeur, IDfamille, total_ventilations,
total_reglements, total_prestations)
track = Track(dictTitulaires, item)
if onlyNonVentiles == True:
# Afficher seulement ceux qui sont mal ventilés
if track.reste_a_ventiler > FloatToDecimal(0.0):
listeListeView.append(track)
else:
# Afficher toute la liste
listeListeView.append(track)
return listeListeView
def GetListeFamilles(listview=None,
listeActivites=None,
presents=None,
IDfamille=None,
infosIndividus=None):
""" Récupération des infos familles """
# Conditions Activites
if listeActivites == None or listeActivites == []:
conditionActivites = ""
else:
if len(listeActivites) == 1:
conditionActivites = " AND inscriptions.IDactivite=%d" % listeActivites[
0]
else:
conditionActivites = " AND inscriptions.IDactivite IN %s" % str(
tuple(listeActivites))
# Conditions Présents
conditionPresents = ""
jointurePresents = ""
if presents != None:
conditionPresents = " AND (consommations.date>='%s' AND consommations.date<='%s' AND consommations.etat IN ('reservation', 'present'))" % (
str(presents[0]), str(presents[1]))
jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu"
# Condition Famille donnée
conditionFamilles = ""
if IDfamille != None:
conditionFamilles = " AND familles.IDfamille=%d" % IDfamille
# Récupération des régimes et num d'alloc pour chaque famille
DB = GestionDB.DB()
req = """
SELECT
familles.IDfamille, regimes.nom, caisses.nom, num_allocataire
FROM familles
LEFT JOIN inscriptions ON inscriptions.IDfamille = familles.IDfamille
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
%s
AND inscriptions.IDfamille = familles.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime
WHERE familles.etat IS NULL AND inscriptions.statut='ok' AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') %s %s %s
GROUP BY familles.IDfamille
;""" % (jointurePresents, datetime.date.today(), conditionActivites,
conditionPresents, conditionFamilles)
DB.ExecuterReq(req)
listeFamilles = DB.ResultatReq()
DB.Close()
# Formatage des données
listeListeView = []
titulaires = UTILS_Titulaires.GetTitulaires()
for IDfamille, nomRegime, nomCaisse, numAlloc in listeFamilles:
dictTemp = {}
if IDfamille != None and IDfamille in titulaires:
nomTitulaires = titulaires[IDfamille]["titulairesSansCivilite"]
rue = titulaires[IDfamille]["adresse"]["rue"]
cp = titulaires[IDfamille]["adresse"]["cp"]
ville = titulaires[IDfamille]["adresse"]["ville"]
listeMails = titulaires[IDfamille]["listeMails"]
secteur = titulaires[IDfamille]["adresse"]["nomSecteur"]
else:
nomTitulaires = _(u"Aucun titulaire")
rue = u""
cp = u""
ville = u""
listeMails = []
dictTemp = {
"IDfamille": IDfamille,
"titulaires": nomTitulaires,
"nomRegime": nomRegime,
"nomCaisse": nomCaisse,
"numAlloc": numAlloc,
"secteur": secteur,
"rue": rue,
"cp": cp,
"ville": ville,
"listeMails": listeMails,
}
# Formatage sous forme de TRACK
track = TrackFamille(listview, dictTemp, infosIndividus)
listeListeView.append(track)
return listeListeView
def SetListeDonnees(self, IDcompte_payeur=None):
self.listeNoms = []
self.dictAdresses = {}
self.dictDonnees = {}
# Si on vient d'une fiche familiale : On affiche uniquement la famille en cours
DB = GestionDB.DB()
req = """SELECT IDrattachement, rattachements.IDindividu, rattachements.IDfamille, IDcategorie, titulaire, nom, prenom, IDcivilite,
adresse_auto, rue_resid, cp_resid, ville_resid
FROM rattachements
LEFT JOIN individus ON individus.IDindividu = rattachements.IDindividu
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = rattachements.IDfamille
WHERE comptes_payeurs.IDcompte_payeur=%d and titulaire=1 and IDcategorie=1
ORDER BY IDrattachement;""" % IDcompte_payeur
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeTitulaires = []
for IDrattachement, IDindividu, IDfamille, IDcategorie, titulaire, nom, prenom, IDcivilite, adresse_auto, rue_resid, cp_resid, ville_resid in listeDonnees:
# Recherche du nom des titulaires
civilite = self.GetCivilite(IDcivilite)
nomIndividu = u"%s%s %s" % (civilite, nom, prenom)
listeTitulaires.append((IDindividu, nomIndividu))
# Recherche de l'adresse
adresseComplete = u""
if rue_resid != None: adresseComplete += rue_resid
if cp_resid != None: adresseComplete += u" " + cp_resid
if ville_resid != None: adresseComplete += u" " + ville_resid
self.dictAdresses[IDindividu] = {
"adresse_auto": adresse_auto,
"adresseComplete": adresseComplete
}
nbreTitulaires = len(listeTitulaires)
if nbreTitulaires == 0:
nomTitulaires = _(u"Pas de titulaires !")
if nbreTitulaires == 1:
nomTitulaires = listeTitulaires[0][1]
if nbreTitulaires == 2:
nomTitulaires = _(u"%s et %s") % (listeTitulaires[0][1],
listeTitulaires[1][1])
if nbreTitulaires > 2:
nomTitulaires = ""
for IDindividu, nomTitulaire in listeTitulaires[:-2]:
nomTitulaires += u"%s, " % nomTitulaire
nomTitulaires += listeTitulaires[-1][1]
self.listeNoms.append(nomTitulaires)
self.dictDonnees[0] = IDindividu
index = 1
for IDindividu, nomTitulaire in listeTitulaires:
if nomTitulaire != nomTitulaires:
self.listeNoms.append(nomTitulaire)
self.dictDonnees[index] = IDindividu
index += 1
# Remplissage du contrôle
self.SetItems(self.listeNoms)
if len(self.listeNoms) > 0:
self.Select(0)
def MAJ(self, forcerActualisation=False):
condition = ""
DB = GestionDB.DB()
# Recherche des paramètres
parametres = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_activites", defaut=None)
if parametres != None:
code, liste = parametres.split("###")
if liste != "":
listeID = []
for ID in liste.split(";"):
listeID.append(int(ID))
if code == "liste_groupes_activites":
req = """SELECT IDtype_groupe_activite, IDactivite
FROM groupes_activites
WHERE IDtype_groupe_activite IN %s
;""" % GestionDB.ConvertConditionChaine(listeID)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActivites = []
for IDtype_groupe_activite, IDactivite in listeDonnees:
listeActivites.append(IDactivite)
condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeActivites)
if code == "liste_activites":
condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeID)
# Tri
tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3)
if tri == 0:
tri = "activites.nom"
elif tri == 1:
tri = "activites.date_debut"
elif tri == 2:
tri = "activites.date_fin"
else:
tri = "activites.nom"
# Sens
sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1)
if sens == 0:
sens = ""
else:
sens = "DESC"
# Seuil d'alerte
self.seuil_alerte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_alerte", 5)
# Récupération des groupes
req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.nbre_inscrits_max,
COUNT(inscriptions.IDinscription) as nbre_inscriptions
FROM groupes
LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite
LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe
WHERE inscriptions.statut='ok' %s
GROUP BY groupes.IDgroupe
ORDER BY groupes.ordre
;""" % condition
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
dictGroupes = {}
for IDgroupe, IDactivite, nom, nbre_inscrits_max, nbre_inscrits in listeGroupes:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nbre_inscrits == None: nbre_inscrits = 0
if nom == None: nom = _(u"Sans nom !")
if dictGroupes.has_key(IDactivite) == False:
dictGroupes[IDactivite] = []
dictGroupes[IDactivite].append({
"IDgroupe": IDgroupe,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"IDactivite": IDactivite
})
# Récupération des activités
activite_ouverte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_ouvert", 1)
if activite_ouverte == 1:
if condition == "":
condition = "WHERE activites.date_fin>='%s'" % str(
datetime.date.today())
else:
condition += " AND activites.date_fin>='%s'" % str(
datetime.date.today())
req = """SELECT activites.IDactivite, activites.nom, activites.nbre_inscrits_max
FROM activites
%s
GROUP BY activites.IDactivite
;""" % condition
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
DB.Close()
listeActivitesTemp = []
for IDactivite, nom, nbre_inscrits_max in listeActivites:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nom == None: nom = _(u"Sans nom !")
liste_groupes = []
if dictGroupes.has_key(IDactivite):
liste_groupes = dictGroupes[IDactivite]
nbre_inscrits = 0
liste_infos = [
nom,
]
for dictGroupe in liste_groupes:
nbre_inscrits += dictGroupe["nbre_inscrits"]
liste_infos.append(dictGroupe["nom"])
listeActivitesTemp.append({
"IDactivite": IDactivite,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"liste_groupes": liste_groupes,
"infos": " ".join(liste_infos)
})
# Pour éviter l'actualisation de l'affichage si aucune modification des données
if self.listeActivites != listeActivitesTemp or forcerActualisation == True:
self.listeActivites = listeActivitesTemp
else:
return
# MAJ du contrôle
self.Freeze()
self.DeleteAllItems()
self.dictRenderers = {}
index = 0
for dictActivite in self.listeActivites:
if self.filtre == None or (self.filtre.lower()
in dictActivite["infos"].lower()):
couleur_fond = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(214, 250, 199))
# Colonne Activité
label = u" " + dictActivite["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictActivite)
self.SetItemBackgroundColour(index, couleur_fond)
item = self.GetItem(index, 0)
font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
font.SetWeight(wx.BOLD)
item.SetFont(font)
self.SetItem(item)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="activite",
couleur_fond=couleur_fond,
nbre_inscrits=dictActivite["nbre_inscrits"],
nbre_inscrits_max=dictActivite["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
for dictGroupe in dictActivite["liste_groupes"]:
label = u" " + dictGroupe["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictGroupe)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="groupe",
nbre_inscrits=dictGroupe["nbre_inscrits"],
nbre_inscrits_max=dictGroupe["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
# Ajuste la taille des colonnes
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
self.SetColumnWidth(1, ULC.ULC_AUTOSIZE_FILL)
# Actualiser l'affichage pour éviter bug de positionnement
try:
self.DoLayout()
except:
pass
self.Thaw()
def EnvoiEmail(self, event=None):
""" Envoi par Email des attestations fiscales """
# Validation des données saisies
tracks = self.ctrl_attestations.GetTracksCoches()
if len(tracks) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune attestation à imprimer !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Création des cotisations sélectionnées
dictOptions = self.GetOptions()
if dictOptions == False :
return False
x = UTILS_Attestations_fiscales.Attestations_fiscales()
resultat = x.Impression(tracks=tracks, nomDoc=None, afficherDoc=False, dictOptions=dictOptions, repertoire=dictOptions["repertoire"], repertoireTemp=True)
if resultat == False :
return False
dictChampsFusion, dictPieces = resultat
def SupprimerFichiersTemp():
for IDcompte_payeur, fichier in dictPieces.iteritems() :
os.remove(fichier)
# Récupération de toutes les adresses Emails
DB = GestionDB.DB()
req = """SELECT IDindividu, mail, travail_mail
FROM individus;"""
DB.ExecuterReq(req)
listeAdressesIndividus = DB.ResultatReq()
DB.Close()
dictAdressesIndividus = {}
for IDindividu, mail, travail_mail in listeAdressesIndividus :
dictAdressesIndividus[IDindividu] = {"perso" : mail, "travail" : travail_mail}
# Récupération des données adresse + champs + pièces
listeDonnees = []
listeAnomalies = []
listeEnvoiNonDemande = []
for track in tracks :
adresse = UTILS_Envoi_email.GetAdresseFamille(track.IDfamille, choixMultiple=False, muet=True, nomTitulaires=track.nomsTitulaires)
# Mémorisation des données
if adresse not in (None, "", []) :
if dictPieces.has_key(track.IDcompte_payeur) :
fichier = dictPieces[track.IDcompte_payeur]
champs = dictChampsFusion[track.IDcompte_payeur]
listeDonnees.append({"adresse" : adresse, "pieces" : [fichier,], "champs" : champs})
else :
listeAnomalies.append(track.nomsTitulaires)
# Annonce les anomalies trouvées
if len(listeAnomalies) > 0 :
texte = _(u"%d des familles sélectionnées n'ont pas d'adresse Email.\n\n") % len(listeAnomalies)
texte += _(u"Souhaitez-vous quand même continuer avec les %d autres familles ?") % len(listeDonnees)
dlg = wx.MessageDialog(self, texte, _(u"Avertissement"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_EXCLAMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
SupprimerFichiersTemp()
return
# Dernière vérification avant transfert
if len(listeDonnees) == 0 :
dlg = wx.MessageDialog(self, _(u"Il ne reste finalement aucune attestation fiscale à envoyer par Email !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
SupprimerFichiersTemp()
return
# Transfert des données vers DLG Mailer
import DLG_Mailer
dlg = DLG_Mailer.Dialog(self, categorie="attestation_fiscale")
dlg.SetDonnees(listeDonnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Suppression des PDF temporaires
SupprimerFichiersTemp()
def GetListeRappels(self):
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Conditions
listeConditions = []
if self.IDcompte_payeur != None:
listeConditions.append("rappels.IDcompte_payeur = %d" %
self.IDcompte_payeur)
# 1ère série de filtres
if self.filtres != None:
for filtre in self.filtres:
# IDrappel_intervalle
if filtre["type"] == "IDrappel_intervalle":
listeConditions.append(
"(rappels.IDrappel>=%d AND rappels.IDrappel<=%d)" %
(filtre["IDrappel_min"], filtre["IDrappel_max"]))
# IDrappel_liste
if filtre["type"] == "IDrappel_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("rappels.IDrappel IN %s" %
listeTemp)
# Lot de rappels
if filtre["type"] == "lot":
listeConditions.append("rappels.IDlot=%d" %
filtre["IDlot"])
# Date d'émission
if filtre["type"] == "date_emission":
listeConditions.append(
"(rappels.date_edition>='%s' AND rappels.date_edition<='%s')"
% (filtre["date_min"], filtre["date_max"]))
# Date de référence
if filtre["type"] == "date_reference":
listeConditions.append(
"(rappels.date_reference>='%s' AND rappels.date_reference<='%s')"
% (filtre["date_min"], filtre["date_max"]))
# numero_intervalle
if filtre["type"] == "numero_intervalle":
listeConditions.append(
"(rappels.numero>=%d AND rappels.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("rappels.numero IN %s" % listeTemp)
if len(listeConditions) > 0:
conditions = "WHERE %s" % " AND ".join(listeConditions)
else:
conditions = ""
# Récupération des rappels
req = """
SELECT rappels.IDrappel, rappels.numero, rappels.IDcompte_payeur,
rappels.date_edition, rappels.date_reference, rappels.IDutilisateur,
rappels.date_min, rappels.date_max, rappels.solde,
comptes_payeurs.IDfamille, rappels.IDlot, lots_rappels.nom,
textes_rappels.IDtexte, textes_rappels.label
FROM rappels
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = rappels.IDcompte_payeur
LEFT JOIN lots_rappels ON lots_rappels.IDlot = rappels.IDlot
LEFT JOIN textes_rappels ON textes_rappels.IDtexte = rappels.IDtexte
%s
ORDER BY rappels.date_edition
;""" % conditions
DB.ExecuterReq(req)
listeRappels = DB.ResultatReq()
# 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, email_factures,
comptes_payeurs.IDcompte_payeur
FROM familles
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille
%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, email_factures, IDcompte_payeur in listeInfosFamilles:
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,
"email_factures": email_factures,
}
DB.Close()
listeResultats = []
for IDrappel, numero, IDcompte_payeur, date_edition, date_reference, IDutilisateur, date_min, date_max, solde, IDfamille, IDlot, nomLot, IDtexte, labeltexte in listeRappels:
if numero == None: numero = 0
date_edition = UTILS_Dates.DateEngEnDateDD(date_edition)
date_min = UTILS_Dates.DateEngEnDateDD(date_min)
date_max = UTILS_Dates.DateEngEnDateDD(date_max)
date_reference = UTILS_Dates.DateEngEnDateDD(date_reference)
titulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"]
dictTemp = {
"IDrappel": IDrappel,
"numero": numero,
"IDcompte_payeur": IDcompte_payeur,
"date_edition": date_edition,
"date_reference": date_reference,
"IDutilisateur": IDutilisateur,
"date_min": date_min,
"date_max": date_max,
"solde": solde,
"IDfamille": IDfamille,
"titulaires": titulaires,
"IDlot": IDlot,
"nomLot": nomLot,
"IDtexte": IDtexte,
"labelTexte": labeltexte,
}
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:
# IDrappel_intervalle
if filtre["type"] == "solde":
if self.ComparateurFiltre(-solde, filtre["operateur"],
filtre["montant"]) == False:
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
# Mémorisation des valeurs
if valide == True:
listeResultats.append(dictTemp)
return listeResultats
def ArchiverFichiers(self):
""" Archivage des fichiers traités """
archiver = False
# Récupère stats
nbreTotal = 0
nbreTraites = 0
nbreNonTraites = 0
nbreOk = 0
nbreErreurs = 0
for track in self.ctrl_donnees.donnees:
nbreTotal += 1
if track.statut != None: nbreTraites += 1
if track.statut == None: nbreNonTraites += 1
if track.statut == "ok": nbreOk += 1
if track.statut == "erreur": nbreErreurs += 1
#print nbreTotal, nbreTraites, nbreNonTraites, nbreOk, nbreErreurs
# Si aucun traités
if nbreTraites == 0:
return True
# Si des erreurs ont été trouvées
if nbreErreurs > 0 or nbreNonTraites > 0:
if nbreErreurs > 0 and nbreNonTraites == 0:
intro = _(
u"%d erreurs ont été trouvées lors de l'importation. "
) % nbreErreurs
if nbreErreurs == 0 and nbreNonTraites > 0:
intro = _(
u"%d actions n'ont pas été traitées. ") % nbreNonTraites
if nbreErreurs > 0 and nbreNonTraites > 0:
intro = _(
u"%d actions n'ont pas été traitées et %d erreurs ont été trouvées. "
) % (nbreErreurs, nbreNonTraites)
dlg = wx.MessageDialog(
self,
_(u"%s\n\nConfirmez-vous tout de même l'archivage des fichiers de synchronisation traités ?\n(Si vous choisissez Non, les fichiers seront conservés)"
) % intro, _(u"Archivage"),
wx.YES_NO | wx.CANCEL | wx.YES_DEFAULT | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse == wx.ID_CANCEL:
return False
if reponse == wx.ID_YES:
archiver = True
# Si tous ont été traités avec succès
if nbreOk == nbreTotal:
archiver = True
# Archivage
if archiver == True:
# Récupération de la liste des fichiers
if self.listeFichiers == None:
listeFichiers = self.ctrl_donnees.listeFichiersTrouves
else:
listeFichiers = self.listeFichiers
DB = GestionDB.DB()
for nomFichier in listeFichiers:
# Renommage et archivage
if nomFichier.endswith(".archive") == False:
# Renommage
nomTemp = UTILS_Fichiers.GetRepSync(
nomFichier.replace(".dat", ".archive"))
if os.path.isfile(nomTemp) == True:
os.remove(nomTemp)
os.rename(UTILS_Fichiers.GetRepSync(nomFichier), nomTemp)
# Mémorisation de l'archivage dans la base
nomFichierTemp = nomFichier.replace(".dat", "").replace(
".archive", "")
ID_appareil = self.ctrl_donnees.dictIDappareil[
nomFichierTemp]
IDarchive = DB.ReqInsert("nomade_archivage",
[("nom_fichier", nomFichierTemp),
("ID_appareil", ID_appareil),
("date", datetime.date.today())])
DB.Close()
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
# Date échéance
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(datetime.date.today())),
("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"]),
]
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 Supprimer(self, event):
## if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("parametrage_categories_comptables", "supprimer") == False : return
if len(self.Selection()) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune opération à supprimer dans la liste !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
track = self.Selection()[0]
if track.IDvirement == None and track.IDreleve != None:
dlg = wx.MessageDialog(
self,
_(u"Vous ne pouvez pas supprimer une opération pointée sur un relevé bancaire !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if track.IDvirement != None:
# Vérifie que les 2 opérations du virement ne sont pas sur un relevé
DB = GestionDB.DB()
req = """SELECT IDoperation, compta_operations.IDreleve, compta_releves.nom, comptes_bancaires.nom
FROM compta_operations
LEFT JOIN compta_releves ON compta_releves.IDreleve = compta_releves.IDreleve
LEFT JOIN comptes_bancaires ON comptes_bancaires.IDcompte = compta_releves.IDcompte_bancaire
WHERE IDvirement=%d
;""" % track.IDvirement
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
for IDoperation, IDreleve, nomReleve, nomCompte in listeDonnees:
if IDreleve != None:
dlg = wx.MessageDialog(
self,
_(u"Vous ne pouvez pas supprimer ce virement car il a déjà été pointé sur le relevé '%s' du compte '%s' !"
) % (nomReleve, nomCompte), _(u"Erreur de saisie"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Suppression
dlg = wx.MessageDialog(
self, _(u"Souhaitez-vous vraiment supprimer cette opération ?"),
_(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES:
DB = GestionDB.DB()
if track.IDvirement == None:
DB.ReqDEL("compta_operations", "IDoperation",
track.IDoperation)
DB.ReqDEL("compta_ventilation", "IDoperation",
track.IDoperation)
else:
DB.ReqDEL("compta_virements", "IDvirement", track.IDvirement)
DB.ReqDEL("compta_operations", "IDvirement", track.IDvirement)
DB.Close()
self.MAJ()
dlg.Destroy()
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, mdpcrypt, profil, actif
FROM utilisateurs
WHERE actif=1;"""
resultat = DB.ExecuterReq(req)
if resultat == 1 :
listeDonnees = DB.ResultatReq()
else :
# Fonction provisoire pour pouvoir ouvrir Noethys avant la version 1.1.8.7.
req = """SELECT IDutilisateur, sexe, nom, prenom, mdp, profil, actif
FROM utilisateurs
WHERE actif=1;"""
DB.ExecuterReq(req)
listeDonneesTemp = DB.ResultatReq()
listeDonnees = []
for IDutilisateur, sexe, nom, prenom, mdp, profil, actif in listeDonneesTemp :
if mdp < 60 :
mdpcrypt = SHA256.new(mdp.encode('utf-8')).hexdigest()
else :
mdpcrypt = mdp
listeDonnees.append((IDutilisateur, sexe, nom, prenom, mdp, mdpcrypt, profil, actif))
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, mdpcrypt, 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, "mdpcrypt" : mdpcrypt, "profil":profil, "actif":actif, "image":image, "droits":droits }
listeUtilisateurs.append(dictTemp)
DB.Close()
return listeUtilisateurs
def OnBoutonOk(self, event):
dictOptions = self.ctrl_parametres.GetOptions()
if dictOptions == False:
return
# Récupération des paramètres
listeIDfactures = []
montantTotal = 0.0
for track in self.tracks:
listeIDfactures.append(track.IDfacture)
montantTotal += -track.solde
if len(listeIDfactures) == 0: conditionFactures = "()"
elif len(listeIDfactures) == 1:
conditionFactures = "(%d)" % listeIDfactures[0]
else:
conditionFactures = str(tuple(listeIDfactures))
DB = GestionDB.DB()
req = """
SELECT prestations.IDprestation, prestations.IDfacture, prestations.label, prestations.montant,
prestations.IDindividu, individus.nom, individus.prenom,
prestations.IDactivite, activites.nom
FROM prestations
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
WHERE prestations.IDfacture IN %s
GROUP BY prestations.IDprestation
ORDER BY prestations.date
;""" % conditionFactures
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Récupération des prélèvements
req = """SELECT
prelevements.IDprelevement, prelevements.prelevement_iban,
prelevements.IDfacture, lots_prelevements.date,
prelevement_reference_mandat, titulaire
FROM prelevements
LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot
WHERE prelevements.IDfacture IN %s
;""" % conditionFactures
DB.ExecuterReq(req)
listePrelevements = DB.ResultatReq()
# Pièces PES ORMC
req = """SELECT
pes_pieces.IDpiece, pes_pieces.prelevement_iban, pes_pieces.IDfacture,
pes_lots.date_prelevement, pes_pieces.prelevement_IDmandat, pes_pieces.prelevement_titulaire
FROM pes_pieces
LEFT JOIN pes_lots ON pes_lots.IDlot = pes_pieces.IDlot
WHERE pes_pieces.prelevement_IDmandat IS NOT NULL AND pes_pieces.prelevement=1 AND pes_pieces.IDfacture IN %s
;""" % conditionFactures
DB.ExecuterReq(req)
listePieces = DB.ResultatReq()
dictPrelevements = {}
for listeDonneesPrel in (listePrelevements, listePieces):
for IDprelevement, iban, IDfacture, datePrelevement, rum, titulaire in (
listeDonneesPrel):
datePrelevement = UTILS_Dates.DateEngFr(datePrelevement)
dictPrelevements[IDfacture] = {
"IDprelevement": IDprelevement,
"datePrelevement": datePrelevement,
"iban": iban,
"rum": rum,
"titulaire": titulaire
}
DB.Close()
# Calcul totaux prélèvements
nbrFactPrelev = len(dictPrelevements)
montantTotalPrelev = 0.0
for track in self.tracks:
if dictPrelevements.has_key(track.IDfacture):
montantTotalPrelev += -track.solde
dictPrestations = {}
dictIndividus = {}
dictActivites = {}
dictTotaux = {}
for IDprestation, IDfacture, label, montant, IDindividu, nom, prenom, IDactivite, nomActivite in listePrestations:
if dictActivites != None and dictActivites.has_key(
IDactivite) == False:
dictActivites[IDactivite] = nomActivite
if IDindividu != None and dictIndividus.has_key(
IDindividu) == False and prenom != None:
dictIndividus[IDindividu] = u"%s %s" % (nom, prenom)
if dictPrestations.has_key(IDfacture) == False:
dictPrestations[IDfacture] = {}
if dictPrestations[IDfacture].has_key(IDindividu) == False:
dictPrestations[IDfacture][IDindividu] = {}
if dictPrestations[IDfacture][IDindividu].has_key(label) == False:
dictPrestations[IDfacture][IDindividu][label] = {
"quantite": 0,
"montant": 0.0,
"IDactivite": IDactivite
}
if dictTotaux.has_key(IDactivite) == False:
dictTotaux[IDactivite] = {}
if dictTotaux[IDactivite].has_key(label) == False:
dictTotaux[IDactivite][label] = {"quantite": 0, "montant": 0.0}
dictTotaux[IDactivite][label]["quantite"] += 1
dictTotaux[IDactivite][label]["montant"] += montant
dictPrestations[IDfacture][IDindividu][label]["quantite"] += 1
dictPrestations[IDfacture][IDindividu][label]["montant"] += montant
# Création du PDF
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
from reportlab.platypus.flowables import ParagraphAndImage, Image
from reportlab.rl_config import defaultPageSize
from reportlab.lib.units import inch, cm
from reportlab.lib.utils import ImageReader
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
self.hauteur_page = defaultPageSize[1]
self.largeur_page = defaultPageSize[0]
# Initialisation du PDF
PAGE_WIDTH, PAGE_HEIGHT = defaultPageSize
nomDoc = FonctionsPerso.GenerationNomDoc("RECAP_FACTURES", "pdf")
if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc, topMargin=30, bottomMargin=30)
story = []
largeurContenu = 520
# Création du titre du document
def Header():
dataTableau = []
largeursColonnes = ((420, 100))
dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today()))
dataTableau.append(
(dictOptions["titre_texte"], _(u"%s\nEdité le %s") %
(UTILS_Organisateur.GetNom(), dateDuJour)))
style = TableStyle([
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('ALIGN', (0, 0), (0, 0),
ConvertAlignement1(dictOptions["titre_alignement"])),
('FONT', (0, 0), (0, 0), "Helvetica-Bold",
dictOptions["titre_taille_texte"]),
('ALIGN', (1, 0), (1, 0), 'RIGHT'),
('FONT', (1, 0), (1, 0), "Helvetica", 6),
])
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0, 20))
# Insère un header
Header()
couleurFond1 = ConvertCouleurWXpourPDF(dictOptions["couleur_fond_1"])
couleurFond2 = ConvertCouleurWXpourPDF(dictOptions["couleur_fond_2"])
styleIntroduction = ParagraphStyle(
name="introduction",
fontName="Helvetica",
alignment=ConvertAlignement2(dictOptions["intro_alignement"]),
fontSize=dictOptions["intro_taille_texte"],
spaceAfter=0,
leading=8,
spaceBefore=0)
styleConclusion = ParagraphStyle(
name="conclusion",
fontName="Helvetica",
alignment=ConvertAlignement2(dictOptions["conclusion_alignement"]),
fontSize=dictOptions["conclusion_taille_texte"],
spaceAfter=0,
leading=8,
spaceBefore=0)
styleLabel = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=1,
fontSize=5,
spaceAfter=0,
leading=8,
spaceBefore=0)
styleTexte = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=0,
fontSize=7,
spaceAfter=0,
leading=8,
spaceBefore=0)
styleTexte2 = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=1,
fontSize=7,
spaceAfter=0,
leading=8,
spaceBefore=0)
styleMontant = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=2,
fontSize=7,
spaceAfter=0,
leading=8,
spaceBefore=0)
# Intro
story.append(Paragraph(dictOptions["intro_texte"], styleIntroduction))
story.append(Spacer(0, 20))
# Factures
if dictOptions["type_document"] in (0, 1):
for track in self.tracks:
numero = track.numero
if track.etat == "annulation":
numero = u"%s (Annulée)" % numero
solde = track.solde
if solde != 0.0:
solde = -solde
# Numéro de facture
dataTableau = []
largeursColonnes = [100, 100, largeurContenu - 100 - 100]
dataTableau.append((
_(u"Facture n°%s") % numero,
u"%.2f %s" % (solde, SYMBOLE),
_(u"Edité le %s | Echéance le %s | Période du %s au %s")
% (UTILS_Dates.DateDDEnFr(track.date_edition),
UTILS_Dates.DateDDEnFr(track.date_echeance),
UTILS_Dates.DateDDEnFr(track.date_debut),
UTILS_Dates.DateDDEnFr(track.date_fin)),
))
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('FONT', (0, 0), (1, -1), "Helvetica-Bold", 7),
('FONT', (2, -1), (2, -1), "Helvetica", 6),
('BACKGROUND', (0, 0), (-1, -1), couleurFond1),
('ALIGN', (2, -1), (2, -1), 'RIGHT'),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
# Famille
if track.prelevement == True:
if dictPrelevements.has_key(track.IDfacture):
textePrelevement = _(
u"IBAN : %s | RUM : %s | Titulaire : %s | Le : %s "
) % (dictPrelevements[track.IDfacture]["iban"],
dictPrelevements[track.IDfacture]["rum"],
dictPrelevements[track.IDfacture]["titulaire"],
dictPrelevements[
track.IDfacture]["datePrelevement"])
else:
textePrelevement = _(
u"N° Compte : %s | Etab : %s | Guichet : %s | Clé : %s | Titulaire : %s"
) % (track.prelevement_numero, track.prelevement_etab,
track.prelevement_guichet, track.prelevement_cle,
track.prelevement_payeur)
else:
textePrelevement = u""
if track.adresse_famille["rue"] != None:
rue = track.adresse_famille["rue"]
else:
rue = u""
if track.adresse_famille["cp"] != None:
cp = track.adresse_famille["cp"]
else:
cp = u""
if track.adresse_famille["ville"] != None:
ville = track.adresse_famille["ville"]
else:
ville = u""
dataTableau = [
(Paragraph(_(u"Famille"),
styleLabel), Paragraph(_(u"Adresse"),
styleLabel),
Paragraph(_(u"Prélèvement bancaire"), styleLabel)),
]
largeursColonnes = [180, 140, largeurContenu - 320]
dataTableau.append((
Paragraph(track.nomsTitulaires, styleTexte),
(Paragraph(rue, styleTexte),
Paragraph(u"%s %s" % (cp, ville), styleTexte)),
Paragraph(textePrelevement, styleTexte),
))
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 0), (-1, 0), 0),
('BOTTOMPADDING', (0, 0), (-1, 0), -1),
('FONT', (0, -1), (-1, -1), "Helvetica", 7),
('GRID', (0, 0), (-1, 0), 0.25, colors.black),
('BOX', (0, 1), (-1, 1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
# Détail des prestations
if dictOptions[
"type_document"] == 0 and dictPrestations.has_key(
track.IDfacture):
dataTableau = [
(Paragraph(_(u"Individu"), styleLabel),
Paragraph(_(u"Activité"), styleLabel),
Paragraph(_(u"Prestation"), styleLabel),
Paragraph(_(u"Quantité"), styleLabel),
Paragraph(_(u"Montant total"), styleLabel)),
]
largeursColonnes = [130, 120, 185, 35, 50]
for IDindividu, dictLabels in dictPrestations[
track.IDfacture].iteritems():
if dictIndividus.has_key(IDindividu):
labelIndividu = dictIndividus[IDindividu]
else:
labelIndividu = u""
listeActivites = []
listeLabels = []
listeQuantites = []
listeMontants = []
for labelPrestation, dictTemp in dictLabels.iteritems(
):
if dictTemp[
"IDactivite"] != None and dictActivites.has_key(
dictTemp["IDactivite"]):
labelActivite = dictActivites[
dictTemp["IDactivite"]]
else:
labelActivite = u""
listeActivites.append(
Paragraph(labelActivite[:35], styleTexte2))
listeLabels.append(
Paragraph(labelPrestation[:40], styleTexte2))
listeQuantites.append(
Paragraph(str(dictTemp["quantite"]),
styleTexte2))
listeMontants.append(
Paragraph(
u"%.2f %s" %
(dictTemp["montant"], SYMBOLE),
styleMontant))
dataTableau.append((
Paragraph(labelIndividu, styleTexte2),
listeActivites,
listeLabels,
listeQuantites,
listeMontants,
))
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 0), (-1, 0), 0),
('BOTTOMPADDING', (0, 0), (-1, 0), -1),
('FONT', (0, -1), (-1, -1), "Helvetica", 7),
('GRID', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
story.append(Spacer(0, 10))
# Totaux
dataTableau = [
(_(u"Totaux par activités et prestations"), "", "", ""),
(Paragraph(_(u"Activités"),
styleLabel), Paragraph(_(u"Prestations"), styleLabel),
Paragraph(_(u"Quantité"),
styleLabel), Paragraph(_(u"Montant"), styleLabel)),
]
largeursColonnes = [195, 240, 35, 50]
for IDactivite, dictLabels in dictTotaux.iteritems():
if IDactivite == None:
nomActivite = _(u"Prestations familiales")
else:
nomActivite = dictActivites[IDactivite]
listeLabels = []
listeQuantites = []
listeMontants = []
quantiteActivite = 0
totalActivite = 0.0
for label, dictTemp in dictLabels.iteritems():
listeLabels.append(Paragraph(label, styleTexte2))
listeQuantites.append(
Paragraph(str(dictTemp["quantite"]), styleTexte2))
listeMontants.append(
Paragraph(u"%.2f %s" % (dictTemp["montant"], SYMBOLE),
styleMontant))
quantiteActivite += dictTemp["quantite"]
totalActivite += dictTemp["montant"]
listeLabels.append(
Paragraph(_(u"<b><i>Total de l'activité</i></b>"),
styleTexte2))
listeQuantites.append(
Paragraph("<b><i>%d</i></b>" % quantiteActivite, styleTexte2))
listeMontants.append(
Paragraph(u"<b><i>%.2f %s</i></b>" % (totalActivite, SYMBOLE),
styleMontant))
dataTableau.append((
Paragraph(nomActivite, styleTexte2),
listeLabels,
listeQuantites,
listeMontants,
))
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 1), (-1, 1), 0),
('BOTTOMPADDING', (0, 1), (-1, 1), -1),
('FONT', (1, -1), (-1, -1), "Helvetica", 7),
('FONT', (0, 0), (0, 0), "Helvetica-Bold", 7),
('BOX', (0, 0), (-1, 0), 0.25, colors.black),
('GRID', (0, 1), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond1),
('BACKGROUND', (0, 1), (-1, 1), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
story.append(Spacer(0, 10))
# Texte de conclusion
conclusion_texte = dictOptions["conclusion_texte"]
conclusion_texte = conclusion_texte.replace("{NBRE_FACTURES}",
str(len(self.tracks)))
conclusion_texte = conclusion_texte.replace(
"{TOTAL_FACTURES}", u"%.2f %s" % (montantTotal, SYMBOLE))
conclusion_texte = conclusion_texte.replace("{NBRE_FACT_PRELEV}",
str(nbrFactPrelev))
conclusion_texte = conclusion_texte.replace(
"{TOTAL_FACT_PRELEV}", u"%.2f %s" % (montantTotalPrelev, SYMBOLE))
story.append(Paragraph(conclusion_texte, styleConclusion))
# Enregistrement et ouverture du PDF
try:
doc.build(story)
except Exception, err:
print "Erreur dans ouverture PDF :", err
if "Permission denied" in err:
dlg = wx.MessageDialog(
None,
_(u"Noethys ne peut pas créer le PDF.\n\nVeuillez vérifier qu'un autre PDF n'est pas déjà ouvert en arrière-plan..."
), _(u"Erreur d'édition"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
def MAJ(self):
""" Importation des données """
if self.majEffectuee == True:
return
self.IDindividu = self.GetGrandParent().IDindividu
if self.IDindividu == None:
return
# MAJ intiale des contrôles
DB = GestionDB.DB()
self.ctrl_adresse_auto.MAJ(DB=DB)
self.ctrl_secteur.MAJ(DB=DB)
self.ctrl_categorie.MAJ(DB=DB)
self.listesDiffusionInitiale = []
self.dictDiffusionInitiale = {}
self.ctrl_listesdiff.MAJ(DB=DB)
if self.ctrl_adresse_auto.GetNbreItems() == 0:
self.ctrl_adresse_auto.Enable(False)
self.radio_adresse_auto.Enable(False)
self.radio_adresse_manuelle.SetValue(True)
# Si pas nouvelle fiche -> Importationd des données
if self.GetGrandParent().nouvelleFiche == False:
# Listes de diffusion
req = """SELECT IDabonnement, IDliste
FROM abonnements WHERE IDindividu=%d;""" % self.IDindividu
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeIDliste = []
for IDabonnement, IDliste in listeDonnees:
listeIDliste.append(IDliste)
self.listesDiffusionInitiale.append(IDliste)
self.dictDiffusionInitiale[IDliste] = IDabonnement
self.ctrl_listesdiff.SetIDcoches(listeIDliste)
# Adresse
req = """SELECT adresse_auto, rue_resid, cp_resid, ville_resid, IDcategorie_travail, profession, employeur,
travail_tel, travail_fax, travail_mail, tel_domicile, tel_mobile, tel_fax, mail, IDsecteur,
travail_tel_sms, tel_domicile_sms, tel_mobile_sms
FROM individus WHERE IDindividu=%d;""" % self.IDindividu
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
individu = listeDonnees[0]
if individu[0] != None:
self.radio_adresse_auto.SetValue(True)
self.ctrl_adresse_auto.SetID(individu[0])
else:
self.radio_adresse_manuelle.SetValue(True)
try:
self.ctrl_rue.SetValue(individu[1])
except:
pass
self.ctrl_ville.SetValueCP(individu[2])
self.ctrl_ville.SetValueVille(individu[3])
self.ctrl_secteur.SetID(individu[14])
# Activité professionnelle
self.ctrl_categorie.SetID(individu[4])
try:
self.ctrl_profession.SetValue(individu[5])
except:
pass
try:
self.ctrl_employeur.SetValue(individu[6])
except:
pass
self.ctrl_travail_tel.SetNumero(individu[7])
self.ctrl_travail_fax.SetNumero(individu[8])
self.ctrl_travail_mail.SetMail(individu[9])
# Coords
self.ctrl_tel_domicile.SetNumero(individu[10])
self.ctrl_tel_mobile.SetNumero(individu[11])
self.ctrl_tel_fax.SetNumero(individu[12])
self.ctrl_mail.SetMail(individu[13])
self.bouton_tel_travail_sms.SetEtat(individu[15])
self.bouton_tel_domicile_sms.SetEtat(individu[16])
self.bouton_tel_mobile_sms.SetEtat(individu[17])
# Verrouillage utilisateurs
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"individus_coordonnees", "modifier",
afficheMessage=False) == False:
for ctrl in self.GetChildren():
ctrl.Enable(False)
# MAJ controles
self.OnRadioAdresse(None)
DB.Close()
self.majEffectuee = True
def OnBoutonOk(self, event):
# Récupération et vérification des données saisies
categorie = self.ctrl_categorie.GetCategorie()
label = self.ctrl_label.GetValue()
if label == "" :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un intitulé !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_label.SetFocus()
return
IDactivite = self.ctrl_activite.GetID()
IDcategorie_tarif = self.ctrl_categorie_tarif.GetID()
IDtarif = self.ctrl_tarif.GetID()
code_comptable = self.ctrl_code_comptable.GetValue()
if code_comptable == "" :
code_comptable = None
tva = self.ctrl_tva.GetValue()
if tva == 0.0 :
tva = None
if self.radio_type_familiale.GetValue() == True :
public = "famille"
else :
public = "individu"
# Tarification
IDtype_quotient = self.ctrl_tarification.GetTypeQuotient()
# Validation de la tarification
if self.ctrl_tarification.Validation() == False :
return False
# Sauvegarde de la prestation
listeDonnees = [
("categorie", categorie),
("label", label),
("IDactivite", IDactivite),
("IDtarif", IDtarif),
("IDcategorie_tarif", IDcategorie_tarif),
("code_compta", code_comptable),
("tva", tva),
("public", public),
("IDtype_quotient", IDtype_quotient),
]
DB = GestionDB.DB()
if self.IDmodele == None :
self.IDmodele = DB.ReqInsert("modeles_prestations", listeDonnees)
else:
DB.ReqMAJ("modeles_prestations", listeDonnees, "IDmodele", self.IDmodele)
# Sauvegarde des lignes de tarifs
self.ctrl_tarification.Sauvegarde()
listeFinaleID = []
for track_ligne in self.track_tarif.lignes:
track_ligne.IDmodele = self.IDmodele
listeDonnees = track_ligne.Get_listedonnees_pour_db()
if track_ligne.IDligne == None:
# Ci-dessous pour parer bug de Last_row_id de Sqlite
if DB.isNetwork == False:
req = """SELECT max(IDligne) FROM tarifs_lignes;"""
DB.ExecuterReq(req)
listeTemp = DB.ResultatReq()
if listeTemp[0][0] == None:
newID = 1
else:
newID = listeTemp[0][0] + 1
listeDonnees.append(("IDligne", newID))
DB.ReqInsert("tarifs_lignes", listeDonnees)
else:
# Version MySQL
DB.ReqInsert("tarifs_lignes", listeDonnees)
else:
# Modification
DB.ReqMAJ("tarifs_lignes", listeDonnees, "IDligne", track_ligne.IDligne)
listeFinaleID.append(track_ligne.IDligne)
# Suppression des lignes supprimées
for IDligne in self.listeInitialeIDlignes:
if IDligne not in listeFinaleID:
DB.ReqDEL("tarifs_lignes", "IDligne", IDligne)
DB.Close()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def OnBoutonOk(self, event):
# Récupération et vérification des données saisies
dictModele = self.ctrl_modele.GetDictValeurs()
if dictModele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle dans la liste !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
categorie = dictModele["categorie"]
label = dictModele["label"]
IDactivite = dictModele["IDactivite"]
IDcategorie_tarif = dictModele["IDcategorie_tarif"]
IDtarif = dictModele["IDtarif"]
code_comptable = dictModele["code_compta"]
if code_comptable == "":
code_comptable = None
tva = dictModele["tva"]
if tva == 0.0:
tva = None
montant = self.ctrl_montant.GetMontant()
if montant == None:
dlg = wx.MessageDialog(
self,
_(u"Le montant que vous avez saisi ne semble pas valide !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
if self.ctrl_individu.IsEnabled() == True:
IDindividu = self.ctrl_individu.GetID()
if IDindividu == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un individu !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_individu.SetFocus()
return
else:
IDindividu = None
date = self.ctrl_date.GetDate()
if self.ctrl_date.Validation() == False:
dlg = wx.MessageDialog(self, _(u"La date ne semble pas valide !"),
_(u"Erreur de saisie"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date.SetFocus()
return
# Récupération du IDcompte_payeur
DB = GestionDB.DB()
req = "SELECT IDcompte_payeur FROM familles WHERE IDfamille=%d" % self.IDfamille
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
IDcompte_payeur = listeDonnees[0][0]
# Sauvegarde de la prestation
listeDonnees = [
("IDcompte_payeur", IDcompte_payeur),
("date", date),
("categorie", categorie),
("label", label),
("montant_initial", montant),
("montant", montant),
("IDactivite", IDactivite),
("IDtarif", IDtarif),
("IDfamille", self.IDfamille),
("IDindividu", IDindividu),
("temps_facture", None),
("IDcategorie_tarif", IDcategorie_tarif),
("code_compta", code_comptable),
("tva", tva),
]
listeDonnees.append(("date_valeur", str(datetime.date.today())))
self.IDprestation = DB.ReqInsert("prestations", listeDonnees)
DB.Close()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def OnBoutonOk(self, event):
date_debut = self.ctrl_date_debut.GetDate()
date_fin = self.ctrl_date_fin.GetDate()
IDniveau = self.ctrl_niveau.GetNiveau()
listeIndividus = self.ctrl_individus.GetCoches()
# Vérification de la saisie
if date_debut == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir une date de début de période !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_debut.SetFocus()
return
if date_fin == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir une date de fin de période !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return
if IDniveau == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner un niveau scolaire !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_niveau.SetFocus()
return
if len(listeIndividus) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucun individu !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Demande de confirmation d'enregistrement
dlg = wx.MessageDialog(self, _(u"Confirmez-vous l'inscription de %d individus ?") % len(listeIndividus), _(u"Confirmation"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
if dlg.ShowModal() != wx.ID_YES :
dlg.Destroy()
return
dlg.Destroy()
# Fenêtre d'attente
dlgAttente = PBI.PyBusyInfo(_(u"Veuillez patienter durant la procédure d'inscription..."), parent=None, title=_(u"Inscriptions scolaires"), icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"), wx.BITMAP_TYPE_ANY))
wx.Yield()
# Récupère infos pour historique
DB = GestionDB.DB()
req = """SELECT ecoles.nom, classes.nom, classes.date_debut, classes.date_fin
FROM classes
LEFT JOIN ecoles ON ecoles.IDecole = classes.IDecole
WHERE classes.IDclasse=%d
;""" % self.IDclasse
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
nomEcole = listeDonnees[0][0]
nomClasse = listeDonnees[0][1]
date_debut_classe = listeDonnees[0][2]
date_fin_classe = listeDonnees[0][3]
nomClasse = _(u"%s (Du %s au %s)") % (nomClasse, DateEngFr(date_debut_classe), DateEngFr(date_fin_classe))
nomNiveau = self.ctrl_niveau.GetStringSelection()
# Init Sauvegarde
listeProblemes = []
nbreValides = 0
DB = GestionDB.DB()
for IDindividu in listeIndividus :
# Vérifie que l'individu n'est pas déjà inscrit dans une classe sur cette période
donneesScolarite = self.parent.GetScolariteIndividu(IDindividu)
valide = True
for track in donneesScolarite :
if date_debut <= track.dateFinDD and date_fin >= track.dateDebutDD :
date_debut_temp = DateEngFr(track.date_debut)
date_fin_temp = DateEngFr(track.date_fin)
nomEcole_temp = track.nomEcole
nomClasse_temp = track.nomClasse
nomIndividu_temp = u"%s %s" % (track.prenom, track.nom)
listeProblemes.append(_(u"- %s (déjà dans la classe de %s du %s au %s)\n") % (nomIndividu_temp, nomClasse_temp, date_debut_temp, date_fin_temp))
valide = False
break
if valide == True :
nbreValides += 1
# Sauvegarde
listeDonnees = [
("IDindividu", IDindividu),
("date_debut", date_debut),
("date_fin", date_fin),
("IDecole", self.IDecole),
("IDclasse", self.IDclasse),
("IDniveau", IDniveau),
]
IDscolarite = DB.ReqInsert("scolarite", listeDonnees)
# Mémorisation dans l'historique
UTILS_Historique.InsertActions([{
"IDindividu" : IDindividu,
"IDfamille" : None,
"IDcategorie" : 30,
"action" : _(u"Inscription scolaire du %s au %s. Ecole : '%s'. Classe : '%s'. Niveau : '%s'") % (DateEngFr(str(date_debut)), DateEngFr(str(date_fin)), nomEcole, nomClasse, nomNiveau)
},])
DB.Close()
del dlgAttente
# Informations
if len(listeProblemes) > 0 :
message = _(u"%d inscriptions ont été enregistrées sauf pour les individus suivants :\n\n%s") % (nbreValides, "".join(listeProblemes))
else:
message = _(u"%d inscriptions ont été enregistrées avec succès.") % nbreValides
dlg = wx.MessageDialog(self, message, _(u"Information"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
# Fermeture
self.EndModal(wx.ID_OK)
def GetTracks(self):
""" Récupération des données """
if self.IDcompte_bancaire != None:
conditions = "WHERE compta_operations.IDcompte_bancaire=%d" % self.IDcompte_bancaire
else:
conditions = ""
db = GestionDB.DB()
req = """SELECT
IDoperation, type, date, libelle, compta_operations.IDtiers, compta_operations.IDmode, num_piece, ref_piece, compta_operations.IDcompte_bancaire, compta_operations.IDreleve, montant, compta_operations.observations, compta_operations.IDvirement,
compta_tiers.nom, modes_reglements.label, comptes_bancaires.nom, compta_releves.nom
FROM compta_operations
LEFT JOIN compta_tiers ON compta_tiers.IDtiers = compta_operations.IDtiers
LEFT JOIN modes_reglements ON modes_reglements.IDmode = compta_operations.IDmode
LEFT JOIN comptes_bancaires ON comptes_bancaires.IDcompte = compta_operations.IDcompte_bancaire
LEFT JOIN compta_releves ON compta_releves.IDreleve = compta_operations.IDreleve
%s
ORDER BY date, IDoperation
;""" % conditions
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
listeListeView = []
solde = 0.0
soldePointe = 0.0
soldeJour = 0.0
for IDoperation, typeOperation, date, libelle, IDtiers, IDmode, num_piece, ref_piece, IDcompte_bancaire, IDreleve, montant, observations, IDvirement, nomTiers, nomMode, nomCompte, nomReleve in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if typeOperation == "debit":
montantTemp = -montant
else:
montantTemp = +montant
solde += montantTemp
if IDreleve != None:
soldePointe += montantTemp
if date <= datetime.date.today():
soldeJour += montantTemp
dictTemp = {
"IDoperation": IDoperation,
"typeOperation": typeOperation,
"date": date,
"libelle": libelle,
"IDtiers": IDtiers,
"IDmode": IDmode,
"num_piece": num_piece,
"ref_piece": ref_piece,
"IDcompte_bancaire": IDcompte_bancaire,
"IDreleve": IDreleve,
"montant": montant,
"observations": observations,
"IDvirement": IDvirement,
"nomTiers": nomTiers,
"nomMode": nomMode,
"nomCompte": nomCompte,
"nomReleve": nomReleve,
"solde": solde,
}
track = Track(dictTemp)
listeListeView.append(track)
self.ctrl_soldes.label_solde_jour.SetLabel(
_(u"Solde du jour : %.2f %s") % (soldeJour, SYMBOLE))
self.ctrl_soldes.label_solde_pointe.SetLabel(
_(u"Solde pointé : %.2f %s") % (soldePointe, SYMBOLE))
self.ctrl_soldes.label_solde.SetLabel(
_(u"Solde final : %.2f %s") % (solde, SYMBOLE))
self.ctrl_soldes.Layout()
return listeListeView
def Supprimer(self, event):
if self.IDcompte_payeur == None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"facturation_rappels", "supprimer") == False:
return
if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune lettre de rappel à supprimer dans la liste !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if len(self.GetTracksCoches()) > 0:
# Suppression multiple
listeSelections = self.GetTracksCoches()
dlg = wx.MessageDialog(
self,
_(u"Souhaitez-vous vraiment supprimer les %d lettres de rappel cochées ?"
) % len(listeSelections), _(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
else:
# Suppression unique
listeSelections = self.Selection()
dlg = wx.MessageDialog(
self,
_(u"Souhaitez-vous vraiment supprimer la lettre de rappel n°%d ?"
) % listeSelections[0].numero, _(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
# Suppression des lettres de rappel
listeIDrappels = []
for track in listeSelections:
listeIDrappels.append(track.IDrappel)
dlgAttente = PBI.PyBusyInfo(
_(u"Suppression des lettres de rappel en cours..."),
parent=None,
title=_(u"Veuillez patienter..."),
icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"),
wx.BITMAP_TYPE_ANY))
wx.Yield()
DB = GestionDB.DB()
for IDrappel in listeIDrappels:
DB.ReqDEL("rappels", "IDrappel", IDrappel)
DB.Close()
del dlgAttente
# MAJ du listeView
self.MAJ()
# Confirmation de suppression
dlg = wx.MessageDialog(
self,
_(u"%d lettres(s) de rappel supprimée(s) avec succès.") %
len(listeSelections), _(u"Suppression"),
wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def OnBoutonOk(self, event):
# Validation
nom = self.ctrl_nom.GetValue()
if nom == "" :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un nom pour ce modèle !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
IDrestaurateur = self.ctrl_restaurateur.GetID()
if IDrestaurateur == None :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucun restaurateur.\n\nEtes-vous sûr de vouloir continuer ?"), _(u"Information"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
if self.ctrl_colonnes.Validation() == False :
return False
colonnes = self.ctrl_colonnes.GetColonnes()
# Récupération des données
dictDonnees = self.GetDonnees()
# Sauvegarde
DB = GestionDB.DB()
# Sauvegarde du modèle
listeDonnees = [
("nom", nom),
("IDrestaurateur", IDrestaurateur),
("parametres", None),
]
if self.premierModele == True :
listeDonnees.append(("defaut", 1))
if self.IDmodele == None :
self.IDmodele = DB.ReqInsert("modeles_commandes", listeDonnees)
else:
DB.ReqMAJ("modeles_commandes", listeDonnees, "IDmodele", self.IDmodele)
# Sauvegarde des colonnes
index = 0
listeIDcolonne = []
dictCorrespondancesID = {}
for dictColonne in colonnes :
IDcolonne = dictColonne["IDcolonne"]
listeDonnees = [
("IDmodele", self.IDmodele),
("ordre", index),
("nom", dictColonne["nom"]),
("largeur", dictColonne["largeur"]),
("categorie", dictColonne["categorie"]),
("parametres", six.text_type(dictColonne["parametres"])),
]
if IDcolonne == None or IDcolonne < 0 :
newIDcolonne = DB.ReqInsert("modeles_commandes_colonnes", listeDonnees)
dictCorrespondancesID[IDcolonne] = int(newIDcolonne) # Convertit l'IDnégatif en IDpositif
dictColonne["IDcolonne"] = newIDcolonne
else:
DB.ReqMAJ("modeles_commandes_colonnes", listeDonnees, "IDcolonne", IDcolonne)
listeIDcolonne.append(IDcolonne)
index += 1
# Echange l'IDnégatif contre IDpositif dans les paramètres des colonnes de total
if len(dictCorrespondancesID) > 0 :
for dictColonne in colonnes:
if dictColonne["categorie"] == "numerique_total" and ("colonnes" in dictColonne["parametres"]) == True :
listeID = dictColonne["parametres"]["colonnes"]
listeNewID = []
for IDcolonne in listeID:
if IDcolonne < 0 :
IDcolonne = dictCorrespondancesID[IDcolonne]
listeNewID.append(IDcolonne)
if listeID != listeNewID :
dictColonne["parametres"]["colonnes"] = listeNewID
listeDonnees = [("parametres", six.text_type(dictColonne["parametres"])),]
DB.ReqMAJ("modeles_commandes_colonnes", listeDonnees, "IDcolonne", dictColonne["IDcolonne"])
# Suppression des colonnes obsolètes
for IDcolonne in self.listeIDcolonnesImportees :
if IDcolonne not in listeIDcolonne :
DB.ReqDEL("modeles_commandes_colonnes", "IDcolonne", IDcolonne)
DB.ReqDEL("commandes_valeurs", "IDcolonne", IDcolonne)
# Clôture de la base
DB.Close()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
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,
"mention1": self.ctrl_mention1.GetValue(),
"mention2": self.ctrl_mention2.GetValue(),
"mention3": self.ctrl_mention3.GetValue(),
}
return True
def Supprimer(self, event):
item = self.GetSelection()
dictData = self.GetPyData(item)
if dictData == None or dictData["IDetiquette"] == 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 IDetiquette in dictConsoAssociees:
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 dictDataTemp["IDetiquette"] in dictConsoAssociees:
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 run(self):
nbre_tracks = len(self.parent.listeTracks)
try:
listeAnomalies = []
for track in self.parent.listeTracks:
# Affichage
texteIntro = u"[%d/%d] %s" % (
self.index + 1, len(self.parent.listeTracks), track.detail)
self.parent.label_intro.SetLabel(texteIntro)
self.parent.ctrl_gauge.SetValue(self.index + 1)
# ------------------- Traitement d'une consommation -------------------
if track.categorie == "consommation":
# Initialisation de la grille
self.parent.ctrl_grille.InitGrille(
IDindividu=track.IDindividu,
IDfamille=track.IDfamille,
IDactivite=track.IDactivite,
date=track.date)
wx.Yield()
if track.etat == "reservation":
mode, etat = "reservation", "reservation"
if track.etat == "attente":
mode, etat = "attente", "reservation"
if track.etat == "refus":
mode, etat = "refus", "reservation"
if track.etat == "present":
mode, etat = "reservation", "present"
if track.etat == "absenti":
mode, etat = "reservation", "absenti"
if track.etat == "absentj":
mode, etat = "reservation", "absentj"
if track.action == "ajouter" or track.action == "modifier":
resultat = self.parent.ctrl_grille.SaisieConso(
IDunite=track.IDunite,
mode=mode,
etat=etat,
heure_debut=track.heure_debut,
heure_fin=track.heure_fin,
quantite=track.quantite)
if track.action == "supprimer":
resultat = self.parent.ctrl_grille.SupprimeConso(
IDunite=track.IDunite, date=track.date)
# Sauvegarde de la grille des conso + Ecrit log
if resultat == True:
self.parent.ctrl_grille.Sauvegarde()
self.parent.parent.EcritLog(track.detail + u" -> ok")
self.parent.parent.SetStatut(track, "ok")
else:
texte = track.detail + u" -> " + resultat
self.parent.parent.EcritLog(texte)
self.parent.parent.SetStatut(track, "erreur")
listeAnomalies.append(texte)
# ------------------- Traitement d'un mémo journalier -------------------
if track.categorie == "memo_journee":
DB = GestionDB.DB()
req = """SELECT IDmemo, IDindividu, date, texte FROM memo_journee WHERE IDindividu=%d AND date='%s';""" % (
track.IDindividu, track.date)
DB.ExecuterReq(req)
listeMemos = DB.ResultatReq()
if len(listeMemos) > 1:
IDmemo = listeMemos[0][0]
else:
IDmemo = None
listeDonnees = [
("IDindividu", track.IDindividu),
("date", str(track.date)),
("texte", track.texte),
]
if track.action == "ajouter" or track.action == "modifier":
if IDmemo != None:
DB.ReqMAJ("memo_journee", listeDonnees, "IDmemo",
IDmemo)
else:
DB.ReqInsert("memo_journee", listeDonnees)
if track.action == "supprimer" and IDmemo != None:
DB.ReqDEL("memo_journee", "IDmemo", IDmemo)
DB.Close()
self.parent.parent.EcritLog(track.detail + u" -> ok")
self.parent.parent.SetStatut(track, "ok")
# Arrête le traitement si bouton arrêter enfoncé
if self.stop:
raise Abort
time.sleep(0.2)
self.index += 1
# Si fin
self.succes = True
raise Abort
except Abort, KeyBoardInterrupt:
if self.succes == True:
self.parent.label_intro.SetLabel(_(u"Traitement terminé"))
self.parent.parent.EcritLog(_(u"Traitement terminé"))
self.parent.Fermer(forcer=True)
else:
#print "arrete a l'index", self.index
self.parent.label_intro.SetLabel(
_(u"Traitement interrompu par l'utilisateur"))
self.parent.parent.EcritLog(
_(u"Traitement interrompu par l'utilisateur"))
self.parent.bouton_fermer.SetBitmap(
wx.Bitmap(
Chemins.GetStaticPath(
u"Images/BoutonsImages/Fermer_L72.png"),
wx.BITMAP_TYPE_ANY))
def OnBoutonOk(self, event):
# Validation des données
if self.ValidationDonnees() == False:
return
if self.ctrl_verrouillage.GetValue() == False:
dlg = wx.MessageDialog(
self,
_(u"Pour clôturer le traitement d'un lot, vous devez valider ou refuser les pièces puis verrouiller le lot.\n\nSouhaitez-vous le faire maintenant ?"
), _(u"Information"),
wx.YES_NO | wx.CANCEL | wx.NO_DEFAULT | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_NO:
return
# Récupération des données
nom = self.ctrl_nom.GetValue()
observations = self.ctrl_observations.GetValue()
if self.ctrl_verrouillage.GetValue() == True:
verrouillage = 1
else:
verrouillage = 0
exercice = self.ctrl_parametres.GetPropertyValue("exercice")
mois = self.ctrl_parametres.GetPropertyValue("mois")
objet_dette = self.ctrl_parametres.GetPropertyValue("objet_dette")
if 'phoenix' in wx.PlatformInfo:
date_emission = self.ctrl_parametres.GetPropertyValue(
"date_emission").FormatISODate()
date_prelevement = self.ctrl_parametres.GetPropertyValue(
"date_prelevement").FormatISODate()
date_envoi = self.ctrl_parametres.GetPropertyValue(
"date_envoi").FormatISODate()
else:
date_emission = self.ctrl_parametres.GetPropertyValue(
"date_emission").strftime("%Y-%m-%d")
date_prelevement = self.ctrl_parametres.GetPropertyValue(
"date_prelevement").strftime("%Y-%m-%d")
date_envoi = self.ctrl_parametres.GetPropertyValue(
"date_envoi").strftime("%Y-%m-%d")
try:
id_bordereau = self.ctrl_parametres.GetPropertyValue(
"id_bordereau")
except:
id_bordereau = None
id_poste = self.ctrl_parametres.GetPropertyValue("id_poste")
try:
id_collectivite = self.ctrl_parametres.GetPropertyValue(
"id_collectivite")
except:
id_collectivite = None
code_collectivite = self.ctrl_parametres.GetPropertyValue(
"code_collectivite")
code_budget = self.ctrl_parametres.GetPropertyValue("code_budget")
code_prodloc = self.ctrl_parametres.GetPropertyValue("code_prodloc")
try:
code_etab = self.ctrl_parametres.GetPropertyValue("code_etab")
except:
code_etab = None
reglement_auto = int(
self.ctrl_parametres.GetPropertyValue("reglement_auto"))
IDcompte = self.ctrl_parametres.GetPropertyValue("IDcompte")
IDmode = self.ctrl_parametres.GetPropertyValue("IDmode")
prelevement_libelle = self.ctrl_parametres.GetPropertyValue(
"prelevement_libelle")
objet_piece = self.ctrl_parametres.GetPropertyValue("objet_piece")
# Sauvegarde du lot
listeDonnees = [
("nom", nom),
("verrouillage", verrouillage),
("observations", observations),
("reglement_auto", reglement_auto),
("IDcompte", IDcompte),
("IDmode", IDmode),
("exercice", exercice),
("mois", mois),
("objet_dette", objet_dette),
("date_emission", date_emission),
("date_prelevement", date_prelevement),
("date_envoi", date_envoi),
("id_bordereau", id_bordereau),
("id_poste", id_poste),
("id_collectivite", id_collectivite),
("code_collectivite", code_collectivite),
("code_budget", code_budget),
("code_prodloc", code_prodloc),
("code_etab", code_etab),
("prelevement_libelle", prelevement_libelle),
("objet_piece", objet_piece),
("format", self.format),
]
DB = GestionDB.DB()
if self.IDlot == None:
# Ajout
self.IDlot = DB.ReqInsert("pes_lots", listeDonnees)
else:
# Modification
DB.ReqMAJ("pes_lots", listeDonnees, "IDlot", self.IDlot)
DB.Close()
# Sauvegarde des prélèvements du lot
self.ctrl_pieces.Sauvegarde(IDlot=self.IDlot,
datePrelevement=date_prelevement,
IDcompte=IDcompte,
IDmode=IDmode)
# Mémorisation des préférences
self.Memorisation_parametres()
# Fermeture
self.EndModal(wx.ID_OK)
def Sauvegarder(self):
""" Sauvegarde des attestations """
# Demande la confirmation de sauvegarde
dlg = wx.MessageDialog(self, _(u"Souhaitez-vous mémoriser les attestations ?\n\n(Cliquez NON si c'était juste un test sinon cliquez OUI)"), _(u"Sauvegarde"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return
dlgAttente = wx.BusyInfo(_(u"Sauvegarde des attestations en cours..."), None)
wx.Yield()
DB = GestionDB.DB()
try :
for IDcompte_payeur, dictCompte in self.donnees.iteritems() :
if dictCompte["select"] == True :
numero = dictCompte["num_attestation"]
IDfamille = dictCompte["IDfamille"]
listePrestations = dictCompte["listePrestations"]
total = dictCompte["total"]
regle = dictCompte["ventilation"]
solde = total - regle
# Liste des activités
texteActivites = ""
for IDactivite in self.listeActivites :
texteActivites += "%d;" % IDactivite
if len(self.listeActivites) > 0 :
texteActivites = texteActivites[:-1]
# Liste des individus
texteIndividus = ""
for IDindividu in dictCompte["individus"].keys() :
texteIndividus += "%d;" % IDindividu
if len(dictCompte["individus"].keys()) > 0 :
texteIndividus = texteIndividus[:-1]
IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Sauvegarde de la facture
listeDonnees = [
("numero", numero),
("IDfamille", IDfamille),
("date_edition", str(datetime.date.today())),
("activites", texteActivites),
("individus", texteIndividus),
("IDutilisateur", IDutilisateur),
("date_debut", str(self.date_debut)),
("date_fin", str(self.date_fin)),
("total", float(total)),
("regle", float(regle)),
("solde", float(solde)),
]
IDattestation = DB.ReqInsert("attestations", listeDonnees)
# Mémorisation de l'action dans l'historique
UTILS_Historique.InsertActions([{
"IDfamille" : IDfamille,
"IDcategorie" : 27,
"action" : _(u"Edition d'une attestation de présence pour la période du %s au %s pour un total de %.02f ¤ et un solde de %.02f ¤") % (DateEngFr(str(self.date_debut)), DateEngFr(str(self.date_fin)), total, solde),
},])
DB.Close()
del dlgAttente
except Exception, err:
DB.Close()
del dlgAttente
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(self, _(u"Désolé, le problème suivant a été rencontré dans la sauvegarde des attestations : \n\n%s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
def Importation(self):
""" Importation des données """
if self.IDlot == None:
# Données du dernier lot
DB = GestionDB.DB()
req = """SELECT reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options
FROM pes_lots
WHERE format='%s'
ORDER BY IDlot;""" % self.format
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
return
reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options = listeDonnees[
-1]
nom = u""
verrouillage = False
observations = u""
else:
# Importation
DB = GestionDB.DB()
req = """SELECT nom, verrouillage, observations, reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options
FROM pes_lots
WHERE IDlot=%d
;""" % self.IDlot
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
return
nom, verrouillage, observations, reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options = listeDonnees[
0]
# Attribution des données aux contrôles
self.ctrl_nom.SetValue(nom)
self.ctrl_verrouillage.SetValue(verrouillage)
self.ctrl_observations.SetValue(observations)
if reglement_auto == 1:
self.ctrl_pieces.reglement_auto = True
if prelevement_libelle in ("", None):
prelevement_libelle = u"{NOM_ORGANISATEUR} - {LIBELLE_FACTURE}"
if objet_piece in ("", None):
objet_piece = _(u"FACTURE NUM{NUM_FACTURE} {MOIS_LETTRES} {ANNEE}")
listeValeurs = [
("exercice", exercice),
("mois", mois),
("objet_dette", objet_dette),
("date_emission", UTILS_Dates.DateEngEnDateDD(date_emission)),
("date_prelevement",
UTILS_Dates.DateEngEnDateDD(date_prelevement)),
("date_envoi", UTILS_Dates.DateEngEnDateDD(date_envoi)),
("id_bordereau", id_bordereau),
("id_poste", id_poste),
("id_collectivite", id_collectivite),
("code_collectivite", code_collectivite),
("code_budget", code_budget),
("code_prodloc", code_prodloc),
("code_etab", code_etab),
("reglement_auto", reglement_auto),
("IDcompte", IDcompte),
("IDmode", IDmode),
("prelevement_libelle", prelevement_libelle),
("objet_piece", objet_piece),
]
for code, valeur in listeValeurs:
try:
self.ctrl_parametres.SetPropertyValue(code, valeur)
except:
pass
def GetListeIndividus(listview=None,
listeActivites=None,
presents=None,
IDindividu=None,
infosIndividus=None):
# Conditions Activites
if listeActivites == None or listeActivites == []:
conditionActivites = ""
else:
if len(listeActivites) == 1:
conditionActivites = " AND inscriptions.IDactivite=%d AND inscriptions.statut='ok' AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') " % (
listeActivites[0], datetime.date.today())
else:
conditionActivites = " AND inscriptions.IDactivite IN %s AND inscriptions.statut='ok' AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') " % (
str(tuple(listeActivites)), datetime.date.today())
# Conditions Présents
conditionPresents = ""
jointurePresents = ""
if presents != None:
conditionPresents = " AND (consommations.date>='%s' AND consommations.date<='%s' AND consommations.etat IN ('reservation', 'present'))" % (
str(presents[0]), str(presents[1]))
jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu"
# Condition Individu donné
conditionIndividus = ""
if IDindividu != None:
conditionIndividus = " AND individus.IDindividu=%d" % IDindividu
# Récupération des individus
listeChamps = (
"individus.IDindividu",
"IDcivilite",
"individus.nom",
"prenom",
"num_secu",
"IDnationalite",
"date_naiss",
"IDpays_naiss",
"cp_naiss",
"ville_naiss",
"adresse_auto",
"rue_resid",
"cp_resid",
"ville_resid",
"IDcategorie_travail",
"profession",
"employeur",
"travail_tel",
"travail_fax",
"travail_mail",
"tel_domicile",
"tel_mobile",
"tel_fax",
"mail",
"secteurs.nom",
)
DB = GestionDB.DB()
req = """
SELECT %s
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
LEFT JOIN secteurs ON secteurs.IDsecteur = individus.IDsecteur
%s
WHERE individus.IDindividu>0 AND individus.deces != 1 AND individus.etat IS NULL %s %s %s
GROUP BY individus.IDindividu
;""" % (",".join(listeChamps), jointurePresents, conditionActivites,
conditionPresents, conditionIndividus)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
# Récupération des adresses auto
GetDictInfosIndividus()
listeListeView = []
for valeurs in listeDonnees:
dictTemp = {}
dictTemp["IDindividu"] = valeurs[0]
# Infos de la table Individus
for index in range(0, len(listeChamps)):
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
if dictTemp["IDcivilite"] == None or dictTemp["IDcivilite"] == "":
IDcivilite = 1
else:
IDcivilite = dictTemp["IDcivilite"]
dictTemp["genre"] = dictCivilites[IDcivilite]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[IDcivilite]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[IDcivilite]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[IDcivilite][
"civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[IDcivilite]["nomImage"]
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]),
month=int(dictTemp["date_naiss"][5:7]),
day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
# Formatage sous forme de TRACK
track = TrackIndividu(listview, dictTemp, infosIndividus)
listeListeView.append(track)
return listeListeView
def ValidationDonnees(self):
""" Vérifie que les données saisies sont exactes """
# Généralités
nom = self.ctrl_nom.GetValue()
if nom == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir un nom de lot (Ex : 'Janvier 2013'...) !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
for caract in nom:
if caract in ("_", ):
dlg = wx.MessageDialog(
self,
_(u"Le caractère '%s' n'est pas autorisé dans le nom du lot !"
) % caract, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
# Vérifie que le nom n'est pas déjà attribué
if self.IDlot == None:
IDlotTemp = 0
else:
IDlotTemp = self.IDlot
DB = GestionDB.DB()
req = """SELECT IDlot, nom
FROM pes_lots
WHERE nom='%s' AND IDlot!=%d;""" % (nom, IDlotTemp)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) > 0:
dlg = wx.MessageDialog(
self,
_(u"Ce nom de lot a déjà été attribué à un autre lot.\n\nChaque lot doit avoir un nom unique. Changez le nom."
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
observations = self.ctrl_observations.GetValue()
if self.ctrl_verrouillage.GetValue() == True:
verrouillage = 1
else:
verrouillage = 0
# Récupération des données du CTRL Paramètres
exercice = self.ctrl_parametres.GetPropertyValue("exercice")
mois = self.ctrl_parametres.GetPropertyValue("mois")
objet_dette = self.ctrl_parametres.GetPropertyValue("objet_dette")
date_emission = self.ctrl_parametres.GetPropertyValue("date_emission")
date_prelevement = self.ctrl_parametres.GetPropertyValue(
"date_prelevement")
date_envoi = self.ctrl_parametres.GetPropertyValue("date_envoi")
id_bordereau = self.ctrl_parametres.GetPropertyValue("id_bordereau")
id_poste = self.ctrl_parametres.GetPropertyValue("id_poste")
id_collectivite = self.ctrl_parametres.GetPropertyValue(
"id_collectivite")
code_collectivite = self.ctrl_parametres.GetPropertyValue(
"code_collectivite")
code_budget = self.ctrl_parametres.GetPropertyValue("code_budget")
code_prodloc = self.ctrl_parametres.GetPropertyValue("code_prodloc")
code_etab = self.ctrl_parametres.GetPropertyValue("code_etab")
reglement_auto = int(
self.ctrl_parametres.GetPropertyValue("reglement_auto"))
IDcompte = self.ctrl_parametres.GetPropertyValue("IDcompte")
IDmode = self.ctrl_parametres.GetPropertyValue("IDmode")
# Vérification du compte à créditer
if reglement_auto == 1:
if IDcompte == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un compte à créditer !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if IDmode == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un mode de règlement pour le règlement automatique !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérification des paramètres du bordereau
listeVerifications = [
(exercice, "exercice", _(u"l'année de l'exercice")),
(mois, "mois", _(u"le mois")),
(objet_dette, "objet_dette", _(u"l'objet de la dette")),
(date_emission, "date_emission", _(u"la date d'émission")),
(date_prelevement, "date_prelevement",
_(u"la date souhaitée du prélèvement")),
(date_envoi, "date_envoi", _(u"la date d'envoi")),
(id_bordereau, "id_bordereau", _(u"l'ID bordereau")),
(id_poste, "id_poste", _(u"l'ID poste")),
(id_collectivite, "id_collectivite", _(u"l'ID collectivité")),
(code_collectivite, "code_collectivite",
_(u"le Code Collectivité")),
(code_budget, "code_budget", _(u"le Code Bugdet")),
(code_prodloc, "code_prodloc", _(u"le code Produit Local")),
(code_etab, "code_etab", _(u"le code Etablissement")),
]
for donnee, code, label in listeVerifications:
if donnee == None or donnee == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir %s dans les paramètres du lot !"
) % label, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if code == "id_bordereau":
try:
test = int(donnee)
except:
dlg = wx.MessageDialog(
self,
_(u"Vous devez saisir une valeur numérique valide pour le paramètre de bordereau 'ID Bordereau' !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if code == "id_collectivite":
try:
test = int(donnee)
except:
dlg = wx.MessageDialog(
self,
_(u"Vous devez saisir une valeur numérique valide pour le paramètre de bordereau 'ID Collectivité' !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérification des pièces
listeErreurs = []
listeTemp1 = []
for track in self.ctrl_pieces.GetObjects():
if track.analysePiece == False:
listeErreurs.append(
_(u"- Facture n°%s : %s") %
(track.IDfacture, track.analysePieceTexte))
# Vérifie qu'un OOFF ou un FRST n'est pas attribué 2 fois à un seul mandat
if track.prelevement == 1:
if track.prelevement_sequence in ("OOFF", "FRST"):
key = (track.prelevement_IDmandat,
track.prelevement_sequence)
if key in listeTemp1:
if track.prelevement_sequence == "OOFF":
listeErreurs.append(
_(u"- Facture n°%s : Le mandat n°%s de type ponctuel a déjà été utilisé une fois !"
) %
(track.IDfacture, track.prelevement_IDmandat))
if track.prelevement_sequence == "FRST":
listeErreurs.append(
_(u"- Facture n°%s : Mandat n°%s déjà initialisé. La séquence doit être définie sur 'RCUR' !"
) %
(track.IDfacture, track.prelevement_IDmandat))
listeTemp1.append(key)
if len(listeErreurs) > 0:
message1 = _(
u"Le bordereau ne peut être validé en raison des erreurs suivantes :"
)
message2 = "\n".join(listeErreurs)
dlg = dialogs.MultiMessageDialog(self,
message1,
caption=_(u"Erreur"),
msg2=message2,
style=wx.ICON_EXCLAMATION | wx.OK,
icon=None,
btnLabels={wx.ID_OK: _(u"Ok")})
reponse = dlg.ShowModal()
dlg.Destroy()
return False
return True
def Importation(self):
""" Importation des donnees de la base """
# Récupération des paramètres ORGANISME
nom_organisme = UTILS_Parametres.Parametres(mode="get",
categorie="don_oeuvres",
nom="nom_organisme",
valeur=u"")
adresse_organisme = UTILS_Parametres.Parametres(
mode="get",
categorie="don_oeuvres",
nom="adresse_organisme",
valeur=u"")
objet_organisme = UTILS_Parametres.Parametres(mode="get",
categorie="don_oeuvres",
nom="objet_organisme",
valeur=u"")
type_organisme = UTILS_Parametres.Parametres(mode="get",
categorie="don_oeuvres",
nom="type_organisme",
valeur=u"")
self.ctrl_nom_beneficiaire.SetValue(nom_organisme)
self.ctrl_adresse_beneficiaire.SetValue(adresse_organisme)
self.ctrl_objet.SetValue(objet_organisme)
self.ctrl_type.SetValue(type_organisme)
# Importation de la cotisation
DB = GestionDB.DB()
req = """SELECT
IDfamille, IDindividu, cotisations.IDtype_cotisation, IDunite_cotisation,
date_saisie, date_creation_carte, numero,
date_debut, date_fin, IDprestation, types_cotisations.type, cotisations.observations
FROM cotisations
LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation
WHERE IDcotisation=%d;""" % self.IDcotisation
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) == 0:
DB.Close()
return
IDfamille, IDindividu, IDtype_cotisation, IDunite_cotisation, date_saisie, date_creation_carte, numero, date_debut, date_fin, IDprestation, typeCotisation, observations = listeDonnees[
0]
self.numero = numero
if self.numero == None:
self.numero = ""
self.IDfamille = IDfamille
# Prestation
if IDprestation == None:
self.montant = 0.00
else:
# Importation des données de la prestation
req = """SELECT
IDcompte_payeur, label, montant
FROM prestations
WHERE IDprestation=%d;""" % IDprestation
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
if len(listePrestations) == 0:
DB.Close()
return
IDcompte_payeur, label, montant = listePrestations[0]
# Remplit les noms des payeurs
self.ctrl_nom_auto.SetListeDonnees(IDcompte_payeur)
self.OnChoixNom(None)
if montant != None:
self.montant = float(montant)
# Importation des données sur le (ou les) règlement
req = """SELECT
reglements.IDreglement, reglements.date, reglements.IDmode, reglements.montant,
ventilation.montant
FROM reglements
LEFT JOIN ventilation ON ventilation.IDreglement = reglements.IDreglement
WHERE ventilation.IDprestation=%d;""" % IDprestation
DB.ExecuterReq(req)
listeReglements = DB.ResultatReq()
listeDates = []
listeModes = []
totalVentilation = 0.0
for IDreglement, date, IDmode, montant_reglement, montant_ventilation in listeReglements:
listeDates.append(date)
listeModes.append((montant_reglement, IDmode))
totalVentilation += montant_ventilation
listeDates.sort()
listeModes.sort()
if len(listeDates) > 0:
self.ctrl_date_versement.SetDate(listeDates[-1])
if len(listeModes) > 0:
IDmode = listeModes[-1][1]
self.ctrl_mode_auto.SetID(IDmode)
self.totalVentilation = totalVentilation
DB.Close()
def GetListeDonnees(self):
if self.IDecole == None or self.date_debut == None or self.date_fin == None :
return []
DB = GestionDB.DB()
req = """SELECT IDclasse, nom, date_debut, date_fin, niveaux
FROM classes
WHERE IDecole=%d
AND date_debut<='%s' AND date_fin>='%s'
ORDER BY nom; """ % (self.IDecole, self.date_debut, self.date_fin)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Tri des classes par niveau scolaire
listeClasses = []
for IDclasse, nom, date_debut, date_fin, niveaux in listeDonnees :
# Formatage des dates de la saison
date_debut = DateEngEnDateDD(date_debut)
date_fin = DateEngEnDateDD(date_fin)
saison = (date_debut, date_fin)
# Formatage du nom
nom = _(u"%s (Du %s au %s)") % (nom, DateEngFr(str(date_debut)), DateEngFr(str(date_fin)))
# Formatage des niveaux
listeNiveaux = []
listeOrdresNiveaux = []
txtNiveaux = u""
if niveaux != None and niveaux != "" and niveaux != " " :
listeTemp = niveaux.split(";")
txtTemp = []
for niveau in listeTemp :
IDniveau = int(niveau)
if self.parent.dictNiveaux.has_key(IDniveau) :
nomNiveau = self.parent.dictNiveaux[IDniveau]["abrege"]
ordreNiveau = self.parent.dictNiveaux[IDniveau]["ordre"]
listeNiveaux.append(IDniveau)
txtTemp.append(nomNiveau)
listeOrdresNiveaux.append(ordreNiveau)
txtNiveaux = ", ".join(txtTemp)
donnees = (listeOrdresNiveaux, nom, txtNiveaux, listeNiveaux, IDclasse)
listeClasses.append(donnees)
listeClasses.sort()
# Création des items de liste
if len(listeClasses) > 0 :
listeItems = [_(u"-- Toutes les classes --")]
self.dictClasses = {0 : None}
index = 1
for listeOrdresNiveaux, nom, txtNiveaux, listeNiveaux, IDclasse in listeClasses :
listeItems.append(nom)
self.dictClasses[index] = {"IDclasse" : IDclasse, "nom" : nom, "listeOrdresNiveaux" : listeOrdresNiveaux,
"txtNiveaux" : txtNiveaux, "listeNiveaux" : listeNiveaux,}
index += 1
else:
listeItems = []
self.dictClasses = {}
return listeItems
def OnTextePerso(self, event):
# Sauvegarde du texte perso
texte = self.texte_perso.GetValue()
DB = GestionDB.DB()
DB.ReqMAJ("personnes", [("texte_photo", texte),], "IDpersonne", self.IDpersonne)
DB.Close()
def VentilationAuto(IDcompte_payeur=None, IDreglement=None):
""" Ventilation auto de tous les règlements d'un compte payeur ou d'un règlement spécifique """
DB = GestionDB.DB()
if IDreglement != None:
conditionReglement = "AND IDreglement=%d" % IDreglement
else:
conditionReglement = ""
# Récupère la ventilation
req = """SELECT IDventilation, IDreglement, IDprestation, montant
FROM ventilation
WHERE IDcompte_payeur=%d;""" % IDcompte_payeur
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictVentilations = {}
dictVentilationsReglement = {}
dictVentilationsPrestation = {}
for IDventilation, IDreglement, IDprestation, montant in listeDonnees:
dictVentilations[IDventilation] = {
"IDreglement": IDreglement,
"IDprestation": IDprestation,
"montant": FloatToDecimal(montant)
}
if (IDreglement in dictVentilationsReglement) == False:
dictVentilationsReglement[IDreglement] = []
dictVentilationsReglement[IDreglement].append(IDventilation)
if (IDprestation in dictVentilationsPrestation) == False:
dictVentilationsPrestation[IDprestation] = []
dictVentilationsPrestation[IDprestation].append(IDventilation)
# Récupère les prestations
req = """SELECT IDprestation, date, montant
FROM prestations
WHERE IDcompte_payeur=%d
ORDER BY date;""" % IDcompte_payeur
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listePrestations = []
for IDprestation, date, montant in listeDonnees:
listePrestations.append({
"IDprestation": IDprestation,
"date": date,
"montant": FloatToDecimal(montant)
})
# Vérifie qu'il n'y a pas de prestations négatives
for dictPrestation in listePrestations:
IDprestation = dictPrestation["IDprestation"]
montantVentilation = FloatToDecimal(0.0)
if IDprestation in dictVentilationsPrestation:
for IDventilation in dictVentilationsPrestation[IDprestation]:
montantVentilation += dictVentilations[IDventilation][
"montant"]
ResteAVentiler = dictPrestation["montant"] - montantVentilation
if ResteAVentiler < FloatToDecimal(0.0):
dlg = wx.MessageDialog(
None,
_(u"Ventilation automatique impossible !\n\nLa ventilation automatique n'est pas compatible avec les prestations comportant un montant négatif ! Vous devez donc effectuer une ventilation manuelle."
), _(u"Information"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
DB.Close()
return False
# Récupère les règlements
req = """SELECT IDreglement, date, montant
FROM reglements
WHERE IDcompte_payeur=%d %s
ORDER BY date;""" % (IDcompte_payeur, conditionReglement)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeReglements = []
for IDreglement, date, montant in listeDonnees:
listeReglements.append({
"IDreglement": IDreglement,
"date": date,
"montant": FloatToDecimal(montant)
})
# Vérification de la ventilation de chaque règlement
listeReglementsAVentiler = []
for dictReglement in listeReglements:
IDreglement = dictReglement["IDreglement"]
# Recherche s'il reste du crédit à ventiler dans ce règlement
montantVentilation = FloatToDecimal(0.0)
if IDreglement in dictVentilationsReglement:
for IDventilation in dictVentilationsReglement[IDreglement]:
montantVentilation += dictVentilations[IDventilation][
"montant"]
credit = dictReglement["montant"] - montantVentilation
if credit > FloatToDecimal(0.0):
# Recherche s'il reste des prestations à ventiler pour cette famille
listePrestationsAVentiler = []
for dictPrestation in listePrestations:
IDprestation = dictPrestation["IDprestation"]
montantVentilation = FloatToDecimal(0.0)
if IDprestation in dictVentilationsPrestation:
for IDventilation in dictVentilationsPrestation[
IDprestation]:
montantVentilation += dictVentilations[IDventilation][
"montant"]
ResteAVentiler = dictPrestation["montant"] - montantVentilation
if ResteAVentiler > FloatToDecimal(0.0):
# Calcul du montant qui peut être ventilé
montant = ResteAVentiler
if credit < montant:
montant = credit
if montant > FloatToDecimal(0.0):
# Modification d'une ventilation existante
ventilationTrouvee = False
if IDprestation in dictVentilationsPrestation:
for IDventilation in dictVentilationsPrestation[
IDprestation]:
if dictVentilations[IDventilation][
"IDreglement"] == IDreglement:
nouveauMontant = montant + montantVentilation
DB.ReqMAJ("ventilation", [
("montant", float(nouveauMontant)),
], "IDventilation", IDventilation)
# Mémorisation du nouveau montant
dictVentilations[IDventilation][
"montant"] = nouveauMontant
ResteAVentiler -= montant
credit -= montant
ventilationTrouvee = True
# Création d'une ventilation
if ventilationTrouvee == False:
listeDonnees = [
("IDreglement", IDreglement),
("IDcompte_payeur", IDcompte_payeur),
("IDprestation", IDprestation),
("montant", float(montant)),
]
IDventilation = DB.ReqInsert(
"ventilation", listeDonnees)
# Mémorisation de la nouvelle ventilation
dictVentilations[IDventilation] = {
"IDreglement": IDreglement,
"IDprestation": IDprestation,
"montant": montant
}
if (IDreglement
in dictVentilationsReglement) == False:
dictVentilationsReglement[IDreglement] = []
dictVentilationsReglement[IDreglement].append(
IDventilation)
if (IDprestation
in dictVentilationsPrestation) == False:
dictVentilationsPrestation[IDprestation] = []
dictVentilationsPrestation[IDprestation].append(
IDventilation)
ResteAVentiler -= montant
credit -= montant
DB.Close()
return True
