def Validation(self):
creditAVentiler = FloatToDecimal(self.montant_reglement) - FloatToDecimal(self.total_ventilation)
if self.validation == "ok" :
return True
if self.validation == "addition" :
totalRestePrestationsAVentiler = FloatToDecimal(self.ctrl_ventilation.GetTotalRestePrestationsAVentiler())
if creditAVentiler > totalRestePrestationsAVentiler :
creditAVentiler = totalRestePrestationsAVentiler
if creditAVentiler > FloatToDecimal(0.0) :
dlg = wx.MessageDialog(self, _(u"Vous devez encore ventiler %.2f %s.\n\nEtes-vous sûr de quand même vouloir valider et fermer ?") % (creditAVentiler, SYMBOLE), _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_EXCLAMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
if self.validation == "trop" :
dlg = wx.MessageDialog(self, _(u"Vous avez ventilé %.2f %s en trop !") % (-creditAVentiler, SYMBOLE), _(u"Erreur de saisie"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
if self.validation == "erreur" :
dlg = wx.MessageDialog(self, _(u"La ventilation n'est pas valide. Veuillez la vérifier..."), _(u"Erreur de saisie"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
return True
def SetMontantReglement(self, montant=FloatToDecimal(0.0)):
if montant == None : return
if type(montant) != decimal.Decimal :
montant = FloatToDecimal(montant)
self.montant_reglement = montant
self.ctrl_ventilation.montant_reglement = montant
self.MAJinfos()
def GetPrestations(self):
DB = GestionDB.DB()
# Recherche de la ventilation
req = """SELECT IDprestation, SUM(ventilation.montant) AS total_ventilation
FROM ventilation
WHERE ventilation.IDreglement=%d
GROUP BY IDprestation;""" % self.IDreglement
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_prestations = []
dict_ventilation = {}
for IDprestation, total_ventilation in listeDonnees:
liste_prestations.append(IDprestation)
dict_ventilation[IDprestation] = total_ventilation
# Recherche des prestations
if len(liste_prestations) == 0: condition_prestations = "()"
elif len(liste_prestations) == 1:
condition_prestations = "(%d)" % liste_prestations[0]
else:
condition_prestations = str(tuple(liste_prestations))
req = """SELECT IDprestation, date, categorie, label,
activites.IDactivite, activites.nom, activites.abrege,
individus.nom, individus.prenom,
montant
FROM prestations
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
WHERE IDprestation IN %s
GROUP BY IDprestation
ORDER BY date;""" % condition_prestations
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listePrestations = []
for IDprestation, date, categorie, label, IDactivite, nomActivite, abregeActivite, nomIndividu, prenomIndividu, montant in listeDonnees:
dateDD = DateEngEnDateDD(date)
if nomActivite == None: nomActivite = ""
if abregeActivite == None: abregeActivite = ""
if prenomIndividu == None: prenomIndividu = u""
montant = FloatToDecimal(montant)
ventilation = FloatToDecimal(dict_ventilation[IDprestation])
dictTemp = {
"IDprestation": IDprestation,
"date": dateDD,
"categorie": categorie,
"label": label,
"IDactivite": IDactivite,
"nomActivite": nomActivite,
"abregeActivite": abregeActivite,
"prenomIndividu": prenomIndividu,
"montant": montant,
"ventilation": ventilation,
}
listePrestations.append(dictTemp)
return listePrestations
def GetImageSoldeActuel(track):
if track.etat == "annulation" :
return self.imgAnnulation
if track.soldeActuel == FloatToDecimal(0.0) :
return self.imgVert
if track.soldeActuel < FloatToDecimal(0.0) and track.soldeActuel != -track.total :
return self.imgOrange
return self.imgRouge
def FormateSolde(montant):
if montant == None: FloatToDecimal(0.0)
if montant == FloatToDecimal(0.0):
return u"%.2f %s" % (montant, SYMBOLE)
elif montant > FloatToDecimal(0.0):
return u"- %.2f %s" % (montant, SYMBOLE)
else:
return u"+ %.2f %s" % (montant, SYMBOLE)
def MAJ(self, majTotaux=True):
""" MAJ les données et l'affichage de la ligne """
# MAJ des données
if type(self.ventilationActuelle) != decimal.Decimal:
self.ventilationActuelle = FloatToDecimal(self.ventilationActuelle)
self.resteAVentiler = self.montant - self.ventilationPassee - self.ventilationActuelle
# Coche
if self.ventilationActuelle != FloatToDecimal(0.0):
etat = True
else:
etat = False
self.grid.SetCellValue(self.numLigne, 0, str(int(etat)))
# Label
self.grid.SetCellValue(self.numLigne, 1, DateComplete(self.date))
# Individu
self.grid.SetCellValue(self.numLigne, 2, self.prenomIndividu)
# Label de la prestation
self.grid.SetCellValue(self.numLigne, 3, self.label)
# Facture
self.grid.SetCellValue(self.numLigne, 4, self.label_facture)
# Montant de la prestation
self.grid.SetCellValue(self.numLigne, 5, six.text_type(self.montant))
# Montant déjà ventilé
self.grid.SetCellValue(self.numLigne, 6,
six.text_type(self.resteAVentiler))
if self.resteAVentiler == 0.0 and self.GetEtat() == True:
self.grid.SetCellBackgroundColour(self.numLigne, 6, COULEUR_TOTAL)
elif self.resteAVentiler == self.montant:
self.grid.SetCellBackgroundColour(self.numLigne, 6, COULEUR_NUL)
else:
self.grid.SetCellBackgroundColour(self.numLigne, 6,
COULEUR_PARTIEL)
# Montant ventilé
self.grid.SetCellValue(self.numLigne, 7,
six.text_type(self.ventilationActuelle))
self.grid.SetReadOnly(self.numLigne, 7, not self.GetEtat())
if self.GetEtat() == True:
self.grid.SetCellBackgroundColour(self.numLigne, 7,
COULEUR_CASE_MODIFIABLE_ACTIVE)
else:
self.grid.SetCellBackgroundColour(
self.numLigne, 7, COULEUR_CASE_MODIFIABLE_INACTIVE)
# MAJ de la ligne de regroupement
if majTotaux == True:
self.ligneRegroupement.MAJ()
self.grid.MAJbarreInfos()
def FormateSolde(montant):
if montant == None :
return u""
if montant == 0.0 :
return u"%.2f %s" % (montant, SYMBOLE)
if montant > FloatToDecimal(0.0) :
return u"+ %.2f %s" % (montant, SYMBOLE)
if montant < FloatToDecimal(0.0) :
return u"- %.2f %s" % (-montant, SYMBOLE)
def ColoreLabelVentilationAuto(self):
aVentiler = FloatToDecimal(0.0)
for ligne in self.ctrl_ventilation.listeLignesPrestations :
aVentiler += FloatToDecimal(ligne.montant) - FloatToDecimal(ligne.ventilationPassee)
if self.montant_reglement == aVentiler :
couleur = wx.Colour(0, 200, 0)
else :
couleur = "BLUE"
self.hyper_automatique.SetColours(couleur, couleur, couleur)
self.hyper_automatique.UpdateLink()
def VentilationAuto(self):
""" Procédure de ventilation automatique """
# Vérifie qu'il n'y a pas de prestations négatives
for ligne in self.ctrl_ventilation.listeLignesPrestations :
if FloatToDecimal(ligne.montant) < 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()
return False
# Ventilation automatique
totalVentilation = FloatToDecimal(self.ctrl_ventilation.GetTotalVentile())
resteVentilation = self.montant_reglement - totalVentilation
if self.montant_reglement == FloatToDecimal(0.0) :
dlg = wx.MessageDialog(self, _(u"Vous avez déjà saisir un montant pour ce règlement !"), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
if resteVentilation <= FloatToDecimal(0.0) :
dlg = wx.MessageDialog(self, _(u"Vous avez déjà ventilé tout le crédit disponible !"), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
for ligne in self.ctrl_ventilation.listeLignesPrestations :
aVentiler = resteVentilation
if aVentiler > FloatToDecimal(ligne.resteAVentiler) :
aVentiler = FloatToDecimal(ligne.resteAVentiler)
if aVentiler > FloatToDecimal(0.0) :
montant = aVentiler + ligne.ventilationActuelle
ligne.SetEtat(etat=True, montant=montant, majTotaux=False)
resteVentilation -= FloatToDecimal(aVentiler)
self.ctrl_ventilation.MAJtotaux()
def MAJ(self):
# Calcul des heures à facturer
self.heures_a_facturer = self.heures_prevues - self.heures_absences_deductibles + self.heures_regularisation + self.duree_solde_rtt
self.montant_a_facturer = FloatToDecimal(
self.tarif_base * UTILS_Dates.DeltaEnFloat(self.heures_a_facturer))
# Calcul des dépassements
self.montant_depassements = FloatToDecimal(
self.tarif_depassement *
UTILS_Dates.DeltaEnFloat(self.heures_depassements))
self.montant_a_facturer += self.montant_depassements
self.heures_a_facturer += self.heures_depassements
def __init__(self, parent, IDcompte_payeur=None, IDreglement=None):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.parent = parent
self.IDcompte_payeur = IDcompte_payeur
self.IDreglement = IDreglement
self.montant_reglement = FloatToDecimal(0.0)
self.total_ventilation = FloatToDecimal(0.0)
self.validation = True
if "linux" in sys.platform :
defaultFont = self.GetFont()
defaultFont.SetPointSize(8)
self.SetFont(defaultFont)
# Regroupement
self.label_regroupement = wx.StaticText(self, -1, _(u"Regrouper par :"))
self.radio_periode = wx.RadioButton(self, -1, _(u"Mois"), style = wx.RB_GROUP)
self.radio_facture = wx.RadioButton(self, -1, _(u"Facture"))
self.radio_individu = wx.RadioButton(self, -1, _(u"Individu"))
self.radio_date = wx.RadioButton(self, -1, _(u"Date"))
# Commandes rapides
self.label_hyperliens_1 = wx.StaticText(self, -1, _(u"Ventiler "))
self.hyper_automatique = Hyperlien(self, label=_(u"automatiquement"), infobulle=_(u"Cliquez ici pour ventiler automatiquement le crédit restant"), URL="automatique")
self.label_hyperliens_2 = wx.StaticText(self, -1, u" | ")
self.hyper_tout = Hyperlien(self, label=_(u"tout"), infobulle=_(u"Cliquez ici pour tout ventiler"), URL="tout")
self.label_hyperliens_3 = wx.StaticText(self, -1, u" | ")
self.hyper_rien = Hyperlien(self, label=_(u"rien"), infobulle=_(u"Cliquez ici pour ne rien ventiler"), URL="rien")
# Liste de la ventilation
self.ctrl_ventilation = CTRL_Ventilation(self, IDcompte_payeur, IDreglement)
# Etat de la ventilation
self.imgOk = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok4.png"), wx.BITMAP_TYPE_PNG)
self.imgErreur = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit2.png"), wx.BITMAP_TYPE_PNG)
self.imgAddition = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Addition.png"), wx.BITMAP_TYPE_PNG)
self.ctrl_image = wx.StaticBitmap(self, -1, self.imgAddition)
self.ctrl_info = wx.StaticText(self, -1, _(u"Vous pouvez encore ventiler 30.90 ¤"))
self.ctrl_info.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
self.__do_layout()
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_periode)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_facture)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_individu)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_date)
# Init
self.ctrl_ventilation.InitGrid()
def SetSolde(self, montant=FloatToDecimal(0.0)):
""" MAJ integrale du controle avec MAJ des donnees """
if montant > FloatToDecimal(0.0):
label = u"+ %.2f %s" % (montant, SYMBOLE)
self.SetBackgroundColour("#C4BCFC") # Bleu
elif montant == FloatToDecimal(0.0):
label = u"0.00 %s" % SYMBOLE
self.SetBackgroundColour("#5DF020") # Vert
else:
label = u"- %.2f %s" % (-montant, SYMBOLE)
self.SetBackgroundColour("#F81515") # Rouge
self.ctrl_solde.SetLabel(label)
self.Layout()
self.Refresh()
def __init__(self, grid=None, donnees={}):
self.grid = grid
self.type_ligne = "prestation"
# Récupération des données
self.IDprestation = donnees["IDprestation"]
self.IDcompte_payeur = donnees["IDcompte_payeur"]
self.date = donnees["date"]
self.date_complete = DateComplete(self.date)
self.mois = self.date.month
self.annee = self.date.year
self.periode = (self.annee, self.mois)
self.periode_complete = PeriodeComplete(self.mois, self.annee)
self.categorie = donnees["categorie"]
self.label = donnees["label"]
self.montant = donnees["montant"]
self.IDactivite = donnees["IDactivite"]
self.nomActivite = donnees["nomActivite"]
self.IDtarif = donnees["IDtarif"]
self.nomTarif = donnees["nomTarif"]
self.nomCategorieTarif = donnees["nomCategorieTarif"]
self.IDfacture = donnees["IDfacture"]
if self.IDfacture == None or self.IDfacture == "":
self.label_facture = _(u"Non facturé")
else:
IDprefixe = donnees["IDprefixe"]
prefixe = donnees["prefixe"]
num_facture = donnees["num_facture"]
if IDprefixe != None:
numeroStr = u"%s-%06d" % (prefixe, num_facture)
else:
numeroStr = u"%06d" % num_facture
date_facture = donnees["date_facture"]
self.label_facture = u"n°%s" % numeroStr
self.IDfamille = donnees["IDfamille"]
self.IDindividu = donnees["IDindividu"]
self.nomIndividu = donnees["nomIndividu"]
self.prenomIndividu = donnees["prenomIndividu"]
if self.prenomIndividu == None:
self.prenomIndividu = u""
if self.nomIndividu != None:
self.nomCompletIndividu = u"%s %s" % (self.nomIndividu,
self.prenomIndividu)
else:
self.nomCompletIndividu = u""
self.ventilationPassee = donnees["ventilationPassee"]
if self.ventilationPassee == None:
self.ventilationPassee = FloatToDecimal(0.0)
self.ventilationActuelle = FloatToDecimal(0.0)
self.resteAVentiler = self.montant - self.ventilationPassee - self.ventilationActuelle
def MAJ(self):
# Calcul des totaux
total_prestation = FloatToDecimal(0.0)
total_aVentiler = FloatToDecimal(0.0)
total_ventilationActuelle = FloatToDecimal(0.0)
for ligne in self.listeLignesPrestations :
total_prestation += ligne.montant
total_aVentiler += ligne.resteAVentiler
total_ventilationActuelle += ligne.ventilationActuelle
# Affichage des totaux
self.grid.SetCellValue(self.numLigne, 5, six.text_type(total_prestation))
self.grid.SetCellValue(self.numLigne, 6, six.text_type(total_aVentiler))
self.grid.SetCellValue(self.numLigne, 7, six.text_type(total_ventilationActuelle))
def GetTracks(self):
# Récupération des données
listeID = None
DB = GestionDB.DB()
req = """
SELECT
IDprestation, prestations.IDindividu, IDfamille, IDcompte_payeur, date, montant,
individus.nom, individus.prenom
FROM prestations
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
WHERE date>='%s' AND date<='%s' AND IDactivite=%d AND categorie='consommation'
GROUP BY IDprestation
;""" % (self.date_debut, self.date_fin, self.IDactivite)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Recherche également les consommations
req = """
SELECT IDconso, consommations.IDindividu, IDfamille, consommations.IDcompte_payeur, date,
individus.nom, individus.prenom
FROM consommations
LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur
WHERE date>='%s' AND date<='%s' AND IDactivite=%d
;""" % (self.date_debut, self.date_fin, self.IDactivite)
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
DB.Close()
dictResultats = {}
# Traitement des prestations
for IDprestation, IDindividu, IDfamille, IDcompte_payeur, date, montant, nomIndividu, prenomIndividu in listePrestations :
date = UTILS_Dates.DateEngEnDateDD(date)
montant = FloatToDecimal(montant)
key = (IDindividu, IDfamille)
if dictResultats.has_key(key) == False :
dictResultats[key] = {"IDindividu" : IDindividu, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "nbre_conso" : 0, "prestations" : [], "nbre_prestations" : 0, "montant" : FloatToDecimal(0.0)}
dictResultats[key]["prestations"].append({"IDprestation" : IDprestation, "montant" : montant})
dictResultats[key]["montant"] += montant
dictResultats[key]["nbre_prestations"] += 1
# Traitement des consommations
for IDconso, IDindividu, IDfamille, IDcompte_payeur, date, nomIndividu, prenomIndividu in listeConsommations :
date = UTILS_Dates.DateEngEnDateDD(date)
key = (IDindividu, IDfamille)
if dictResultats.has_key(key) == False :
dictResultats[key] = {"IDindividu" : IDindividu, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "nbre_conso" : 0, "prestations" : [], "nbre_prestations" : 0, "montant" : FloatToDecimal(0.0)}
dictResultats[key]["nbre_conso"] += 1
listeListeView = []
for key, dictTemp in dictResultats.iteritems() :
track = Track(self, dictTemp)
listeListeView.append(track)
return listeListeView
def Remplissage(self):
# Regroupement
self.dictRegroupements = {}
listeKeys = []
nbreLignes = 0
for ligne_prestation in self.listeLignesPrestations :
if self.KeyRegroupement == "individu" :
key = ligne_prestation.IDindividu
if key == 0 or key == None :
label = _(u"Prestations diverses")
else:
label = ligne_prestation.nomCompletIndividu
if self.KeyRegroupement == "facture" :
key = ligne_prestation.IDfacture
label = ligne_prestation.label_facture
if self.KeyRegroupement == "date" :
key = ligne_prestation.date
label = ligne_prestation.date_complete
if self.KeyRegroupement == "periode" :
key = ligne_prestation.periode
label = ligne_prestation.periode_complete
if (key in self.dictRegroupements) == False :
self.dictRegroupements[key] = { "label" : label, "total" : FloatToDecimal(0.0), "prestations" : [], "ligne_regroupement" : None}
listeKeys.append(key)
nbreLignes += 1
self.dictRegroupements[key]["prestations"].append(ligne_prestation)
self.dictRegroupements[key]["total"] += ligne_prestation.montant
nbreLignes += 1
# Tri des Keys
listeKeys.sort()
# Création des lignes
self.AppendRows(nbreLignes)
# Création des branches
numLigne = 0
self.dictLignes = {}
for key in listeKeys :
# Niveau 1 : Regroupement
dictRegroupement = self.dictRegroupements[key]
ligne_regroupement = Ligne_regroupement(self, numLigne, dictRegroupement)
self.dictLignes[numLigne] = ligne_regroupement
self.dictRegroupements[key]["ligne_regroupement"] = ligne_regroupement
numLigne += 1
# Niveau 2 : Prestations
for ligne_prestation in self.dictRegroupements[key]["prestations"] :
ligne_prestation.Draw(numLigne, ligne_regroupement)
ligne_prestation.MAJ(majTotaux=False)
ligne_regroupement.listeLignesPrestations.append(ligne_prestation)
self.dictLignes[numLigne] = ligne_prestation
numLigne += 1
# MAJ de tous les totaux
self.MAJtotaux()
def ApplyEdit(self, row, col, grid):
valeur = self._tc.GetMontant()
grid.GetTable().SetValue(row, col, str(valeur))
self.startValue = ''
self._tc.SetValue('')
# MAJ de la ligne
self.ligne.ventilationActuelle = FloatToDecimal(valeur)
self.ligne.MAJ()
def FormateSolde(montant):
if montant == None or montant == 0.0 or montant == FloatToDecimal(
0.0):
return u""
if montant >= decimal.Decimal(str("0.0")):
return u"+ %.2f %s" % (montant, SYMBOLE)
else:
return u"- %.2f %s" % (-montant, SYMBOLE)
def CocherPayes(self, event=None):
for track in self.donnees:
if track.montant_impaye == FloatToDecimal(0.0):
self.Check(track)
else:
self.Uncheck(track)
self.RefreshObject(track)
self.MAJLabelListe()
def GetImageVentilation(track):
if track.montant == track.montant_ventilation:
return self.imgVert
if track.montant_ventilation == FloatToDecimal(
0.0) or track.montant_ventilation == None:
return self.imgRouge
if track.montant_ventilation < track.montant:
return self.imgOrange
return self.imgRouge
def GetImageVentilation(track):
if track.totalFacture == track.totalRegle:
return self.imgVert
if track.totalRegle == FloatToDecimal(
0.0) or track.totalRegle == None:
return self.imgRouge
if track.totalRegle < track.totalFacture:
return self.imgOrange
return self.imgRouge
def MAJinfos(self, erreur=None):
""" Recherche l'état """
if self.montant_reglement == FloatToDecimal(0.0):
self.validation = "erreur"
self.ctrl_image.SetBitmap(self.imgErreur)
self.ctrl_info.SetLabel(
_(u"Vous devez déjà saisir un montant pour ce règlement !"))
return
## if self.montant_reglement < FloatToDecimal(0.0) :
## self.validation = "ok"
## self.ctrl_image.SetBitmap(self.imgOk)
## self.ctrl_info.SetLabel(_(u"Ventilation non obligatoire"))
## return
if erreur == True:
self.validation = "erreur"
self.ctrl_image.SetBitmap(self.imgErreur)
self.ctrl_info.SetLabel(
_(u"Vous avez saisi un montant non valide !"))
return
creditAVentiler = FloatToDecimal(
self.montant_reglement) - FloatToDecimal(self.total_ventilation)
totalRestePrestationsAVentiler = FloatToDecimal(
self.ctrl_ventilation.GetTotalRestePrestationsAVentiler())
if creditAVentiler > totalRestePrestationsAVentiler:
creditAVentiler = totalRestePrestationsAVentiler
# Recherche de l'état
if creditAVentiler == FloatToDecimal(0.0):
self.validation = "ok"
label = _(u"Le règlement a été correctement ventilé !")
elif creditAVentiler > FloatToDecimal(0.0):
self.validation = "addition"
label = _(u"Vous devez encore ventiler %.2f %s !") % (
creditAVentiler, SYMBOLE)
elif creditAVentiler < FloatToDecimal(0.0):
self.validation = "trop"
label = _(u"Vous avez ventilé %.2f %s en trop !") % (
-creditAVentiler, SYMBOLE)
# Affiche l'image
if self.validation == "ok": self.ctrl_image.SetBitmap(self.imgOk)
if self.validation == "addition":
self.ctrl_image.SetBitmap(self.imgAddition)
if self.validation == "trop": self.ctrl_image.SetBitmap(self.imgErreur)
# MAJ le label d'infos
if label != self.ctrl_info.GetLabel():
self.ctrl_info.SetLabel(label)
# Colore Label Ventilation Auto
self.ColoreLabelVentilationAuto()
def GetImageVentilation(track):
if track.montant < FloatToDecimal(0.0) :
return None
if track.montant_ventilation == None :
return self.imgRouge
resteAVentiler = FloatToDecimal(track.montant) - FloatToDecimal(track.montant_ventilation)
if resteAVentiler == FloatToDecimal(0.0) :
return self.imgVert
if resteAVentiler > FloatToDecimal(0.0) :
return self.imgOrange
if resteAVentiler < FloatToDecimal(0.0) :
return self.imgRouge
def EndEdit(self, row, col, grid, oldVal):
changed = False
valeur = self._tc.GetMontant()
# Validation du montant saisi
if self._tc.Validation() == False :
valeur = None
# Vérifie si montant saisi pas supérieur à montant à ventilé
if valeur != None :
resteAVentiler = self.ligne.montant - self.ligne.ventilationPassee - FloatToDecimal(valeur)
if resteAVentiler < 0 :
dlg = wx.MessageDialog(grid, _(u"Le montant saisi ne peut pas être supérieur au montant à ventiler !"), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
valeur = None
# Renvoie la valeur
if valeur != oldVal:
return valeur
else:
return None
def __init__(self, parent, IDcompte_payeur=None, IDreglement=None):
gridlib.Grid.__init__(self, parent, -1, style=wx.WANTS_CHARS)
self.parent = parent
self.IDcompte_payeur = IDcompte_payeur
self.IDreglement = IDreglement
self.listeTracks = []
self.dictVentilation = {}
self.dictVentilationInitiale = {}
self.ventilationValide = True
self.montant_reglement = FloatToDecimal(0.0)
self.dictLignes = {}
# Options
self.bloquer_ventilation = False
# Key de regroupement
self.KeyRegroupement = "periode" # individu, facture, date, periode
# Binds
self.Bind(gridlib.EVT_GRID_CELL_LEFT_CLICK, self.OnLeftClick)
## self.Bind(gridlib.EVT_GRID_CELL_RIGHT_CLICK, self.OnRightClick)
self.GetGridWindow().Bind(wx.EVT_MOTION, self.OnMouseOver)
def OnBoutonOk(self, event):
dictOptions = self.ctrl_parametres.GetOptions()
if dictOptions == False:
return
# Récupération des paramètres
listeIDfactures = []
montantTotal = FloatToDecimal(0.0)
for track in self.tracks:
listeIDfactures.append(track.IDfacture)
montantTotal += track.total
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 track.IDfacture in dictPrelevements:
montantTotalPrelev += -track.solde
dictPrestations = {}
dictIndividus = {}
dictActivites = {}
dictTotaux = {}
for IDprestation, IDfacture, label, montant, IDindividu, nom, prenom, IDactivite, nomActivite in listePrestations:
if dictActivites != None and (IDactivite
in dictActivites) == False:
dictActivites[IDactivite] = nomActivite
if IDindividu != None and (
IDindividu in dictIndividus) == False and prenom != None:
dictIndividus[IDindividu] = u"%s %s" % (nom, prenom)
if (IDfacture in dictPrestations) == False:
dictPrestations[IDfacture] = {}
if (IDindividu in dictPrestations[IDfacture]) == False:
dictPrestations[IDfacture][IDindividu] = {}
if (label in dictPrestations[IDfacture][IDindividu]) == False:
dictPrestations[IDfacture][IDindividu][label] = {
"quantite": 0,
"montant": 0.0,
"IDactivite": IDactivite
}
if (IDactivite in dictTotaux) == False:
dictTotaux[IDactivite] = {}
if (label in dictTotaux[IDactivite]) == 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 track.IDfacture in dictPrelevements:
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 = []
dataTableau.append(
(Paragraph(_(u"Famille"),
styleLabel), Paragraph(_(u"Adresse"),
styleLabel),
Paragraph(_(u"Prélèvement bancaire"), styleLabel)))
dataTableau.append(
(Paragraph(track.nomsTitulaires,
styleTexte), (Paragraph(rue, styleTexte),
Paragraph(u"%s %s" % (cp, ville),
styleTexte)),
Paragraph(textePrelevement, styleTexte)))
largeursColonnes = [180, 140, largeurContenu - 320]
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)
# Récupération des champs personnalisés
dataTableau = []
label_1, label_2, label_3, question_1, question_2, question_3 = "", "", "", "", "", ""
for dictReponse in self.Questionnaires.GetDonnees(
track.IDfamille):
if dictReponse["champ"] == dictOptions["question_1"]:
label_1, question_1 = dictReponse[
"label"], dictReponse["reponse"]
if dictReponse["champ"] == dictOptions["question_2"]:
label_2, question_2 = dictReponse[
"label"], dictReponse["reponse"]
if dictReponse["champ"] == dictOptions["question_3"]:
label_3, question_3 = dictReponse[
"label"], dictReponse["reponse"]
if len(label_1) > 0 or len(label_2) > 0 or len(label_3) > 0:
dataTableau.append(
(Paragraph(label_1,
styleLabel), Paragraph(label_2, styleLabel),
Paragraph(label_3, styleLabel)))
dataTableau.append((Paragraph(question_1, styleTexte),
Paragraph(question_2, styleTexte),
Paragraph(question_3, styleTexte)))
largeursColonnes = [
largeurContenu / 3.0, largeurContenu / 3.0,
largeurContenu / 3.0
]
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 track.IDfacture in dictPrestations:
# Préparation des champs individuels supplémentaires
liste_champs_ind = []
for key in ("champ_ind_1", "champ_ind_2", "champ_ind_3"):
if dictOptions[key] not in ("non", "", None):
liste_champs_ind.append(dictOptions[key])
if len(liste_champs_ind) == 0:
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]
else:
# On rajoute la colonne Infos individuelles :
dataTableau = [
(Paragraph(_(u"Individu"), styleLabel),
Paragraph(_(u"Informations"), styleLabel),
Paragraph(_(u"Activité"), styleLabel),
Paragraph(_(u"Prestation"), styleLabel),
Paragraph(_(u"Quantité"), styleLabel),
Paragraph(_(u"Montant total"), styleLabel)),
]
largeursColonnes = [120, 110, 100, 105, 35, 50]
for IDindividu, dictLabels in dictPrestations[
track.IDfacture].items():
if IDindividu in dictIndividus:
labelIndividu = dictIndividus[IDindividu]
else:
labelIndividu = u""
listeActivites = []
listeLabels = []
listeQuantites = []
listeMontants = []
for labelPrestation, dictTemp in dictLabels.items():
if dictTemp["IDactivite"] != None and dictTemp[
"IDactivite"] in dictActivites:
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))
ligne = [
Paragraph(labelIndividu, styleTexte2),
listeActivites,
listeLabels,
listeQuantites,
listeMontants,
]
# Récupération des infos individuelles
if len(liste_champs_ind) > 0:
liste_textes_ind = []
for key in liste_champs_ind:
# Ecole
if "ecole" in key or "classe" in key or "niveau" in key:
if "date_debut" in key:
date_reference = track.date_debut
else:
date_reference = track.date_fin
infosIndividus = UTILS_Infos_individus.Informations(
date_reference=date_reference,
qf=False,
inscriptions=False,
messages=False,
infosMedicales=False,
cotisationsManquantes=False,
piecesManquantes=False,
questionnaires=False,
scolarite=True)
dictInfosIndividus = infosIndividus.GetDictValeurs(
mode="individu",
ID=IDindividu,
formatChamp=False)
texte = ""
if "ecole" in key and "SCOLARITE_NOM_ECOLE" in dictInfosIndividus:
texte = dictInfosIndividus[
"SCOLARITE_NOM_ECOLE"]
if "classe" in key and "SCOLARITE_NOM_CLASSE" in dictInfosIndividus:
texte = dictInfosIndividus[
"SCOLARITE_NOM_CLASSE"]
if "niveau" in key and "SCOLARITE_NOM_NIVEAU" in dictInfosIndividus:
texte = dictInfosIndividus[
"SCOLARITE_NOM_NIVEAU"]
liste_textes_ind.append(
Paragraph(texte, styleTexte2))
ligne.insert(1, liste_textes_ind)
# Insertion de la ligne dans le tableau
dataTableau.append(ligne)
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.items():
if IDactivite == None:
nomActivite = _(u"Prestations diverses")
else:
nomActivite = dictActivites[IDactivite]
listeLabels = []
listeQuantites = []
listeMontants = []
quantiteActivite = 0
totalActivite = 0.0
for label, dictTemp in dictLabels.items():
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 as 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
FonctionsPerso.LanceFichierExterne(nomDoc)
def __init__(self, donnees):
self.IDfacture = donnees["IDfacture"]
self.IDprefixe = donnees["IDprefixe"]
self.prefixe = donnees["prefixe"]
self.numero = donnees["numero"]
if self.numero == None : self.numero = 0
self.numero_int = int(self.numero)
if self.IDprefixe != None :
self.numero = u"%s-%06d" % (self.prefixe, self.numero)
else :
self.numero = u"%06d" % self.numero
self.IDcompte_payeur = donnees["IDcompte_payeur"]
self.etat = donnees["etat"]
self.date_edition = donnees["date_edition"]
self.date_echeance = donnees["date_echeance"]
self.IDutilisateur = donnees["IDutilisateur"]
self.date_debut = donnees["date_debut"]
self.date_fin = donnees["date_fin"]
self.total = donnees["total"]
self.regle = donnees["regle"]
self.solde = donnees["solde"]
if self.solde != FloatToDecimal(0.0) :
self.solde = -self.solde
self.totalPrestations = donnees["totalPrestations"]
self.totalVentilation = donnees["totalVentilation"]
if self.totalVentilation == None :
self.totalVentilation = FloatToDecimal(0.0)
self.soldeActuel = self.totalVentilation - self.totalPrestations
if self.etat == "annulation" :
self.soldeActuel = None
self.IDfamille = donnees["IDfamille"]
self.nomsTitulaires = donnees["titulaires"]
self.IDlot = donnees["IDlot"]
self.nomLot = donnees["nomLot"]
self.adresse_famille = donnees["adresse_famille"]
self.titulaire_helios = donnees["titulaire_helios"]
# Prélèvement
self.prelevement_activation = donnees["prelevement_activation"]
self.prelevement_etab = donnees["prelevement_etab"]
self.prelevement_guichet = donnees["prelevement_guichet"]
self.prelevement_numero = donnees["prelevement_numero"]
self.prelevement_cle = donnees["prelevement_cle"]
self.prelevement_banque = donnees["prelevement_banque"]
self.prelevement_individu = donnees["prelevement_individu"]
self.prelevement_nom = donnees["prelevement_nom"]
self.prelevement_rue = donnees["prelevement_rue"]
self.prelevement_cp = donnees["prelevement_cp"]
self.prelevement_ville = donnees["prelevement_ville"]
self.prelevement_cle_iban = donnees["prelevement_cle_iban"]
self.prelevement_iban = donnees["prelevement_iban"]
self.prelevement_bic = donnees["prelevement_bic"]
self.prelevement_reference_mandat = donnees["prelevement_reference_mandat"]
self.prelevement_date_mandat = donnees["prelevement_date_mandat"]
if self.prelevement_activation == 1 :
self.prelevement = True
else :
self.prelevement = False
self.nomPayeur = donnees["nomPayeur"]
self.prenomPayeur = donnees["prenomPayeur"]
if self.nomPayeur == None : self.nomPayeur = u""
if self.prenomPayeur == None : self.prenomPayeur = u""
if self.prelevement_individu == None :
self.prelevement_payeur = self.prelevement_nom
else :
self.prelevement_payeur = u"%s %s" % (self.nomPayeur, self.prenomPayeur)
# Envoi par Email
self.email_factures = donnees["email_factures"]
if self.email_factures != None :
self.email = True
else :
self.email = False
def GetListeFactures(self):
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Conditions
listeConditions = []
if self.IDcompte_payeur != None :
listeConditions.append("prestations.IDcompte_payeur = %d" % self.IDcompte_payeur)
# 1ère série de filtres
if self.filtres != None :
for filtre in self.filtres :
# IDfacture_intervalle
if filtre["type"] == "IDfacture_intervalle" :
listeConditions.append( "(factures.IDfacture>=%d AND factures.IDfacture<=%d)" % (filtre["IDfacture_min"], filtre["IDfacture_max"]) )
# IDfacture_liste
if filtre["type"] == "IDfacture_liste" :
if len(filtre["liste"]) == 0 : listeTemp = "()"
elif len(filtre["liste"]) == 1 : listeTemp = "(%d)" % filtre["liste"][0]
else : listeTemp = str(tuple(filtre["liste"]))
listeConditions.append( "factures.IDfacture IN %s" % listeTemp)
# Préfixe
if filtre["type"] == "prefixe" :
if filtre["IDprefixe"] == None :
listeConditions.append( "factures.IDprefixe IS NULL")
else :
listeConditions.append( "factures.IDprefixe=%d" % filtre["IDprefixe"])
# Lot de factures
if filtre["type"] == "lot" :
listeConditions.append( "factures.IDlot=%d" % filtre["IDlot"])
# Date d'émission
if filtre["type"] == "date_emission" :
listeConditions.append( "(factures.date_edition>='%s' AND factures.date_edition<='%s')" % (filtre["date_min"], filtre["date_max"]) )
# Date d'échéance
if filtre["type"] == "date_echeance" :
listeConditions.append( "(factures.date_echeance>='%s' AND factures.date_echeance<='%s')" % (filtre["date_min"], filtre["date_max"]) )
# numero_intervalle
if filtre["type"] == "numero_intervalle" :
listeConditions.append( "(factures.numero>=%d AND factures.numero<=%d)" % (filtre["numero_min"], filtre["numero_max"]) )
# numero_liste
if filtre["type"] == "numero_liste" :
if len(filtre["liste"]) == 0 : listeTemp = "()"
elif len(filtre["liste"]) == 1 : listeTemp = "(%d)" % filtre["liste"][0]
else : listeTemp = str(tuple(filtre["liste"]))
listeConditions.append( "factures.numero IN %s" % listeTemp)
if len(listeConditions) > 0 :
conditions = "WHERE %s" % " AND ".join(listeConditions)
else :
conditions = ""
# Récupération des totaux des prestations pour chaque facture
req = """
SELECT
prestations.IDfacture, SUM(prestations.montant)
FROM prestations
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestations = {}
for IDfacture, totalPrestations in listeDonnees :
if IDfacture != None :
dictPrestations[IDfacture] = totalPrestations
# Récupération des factures
req = """
SELECT factures.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.IDcompte_payeur,
factures.date_edition, factures.date_echeance, factures.IDutilisateur,
factures.date_debut, factures.date_fin, factures.total, factures.regle, factures.solde,
comptes_payeurs.IDfamille, factures.IDlot, lots_factures.nom, factures.etat
FROM factures
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur
LEFT JOIN lots_factures ON lots_factures.IDlot = factures.IDlot
LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe
%s
ORDER BY factures.date_edition
;""" % conditions.replace("prestations.IDcompte_payeur", "comptes_payeurs.IDcompte_payeur")
DB.ExecuterReq(req)
listeFactures = DB.ResultatReq()
# Récupération de la ventilation
req = """
SELECT prestations.IDfacture, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDfacture, montantVentilation in listeVentilation :
if IDfacture != None :
dictVentilation[IDfacture] = montantVentilation
# Infos Prélèvement + Envoi par Email des factures
if self.IDcompte_payeur != None :
conditions = "WHERE comptes_payeurs.IDcompte_payeur = %d" % self.IDcompte_payeur
else:
conditions = ""
req = """
SELECT
prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque,
prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville,
prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat,
email_factures,
comptes_payeurs.IDcompte_payeur,
individus.nom, individus.prenom,
titulaire_helios
FROM familles
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille
LEFT JOIN individus ON individus.IDindividu = prelevement_individu
%s
;""" % conditions
DB.ExecuterReq(req)
listeInfosFamilles = DB.ResultatReq()
dictInfosFamilles = {}
for prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, IDcompte_payeur, nomPayeur, prenomPayeur, titulaire_helios in listeInfosFamilles :
prelevement_date_mandat = UTILS_Dates.DateEngEnDateDD(prelevement_date_mandat)
dictInfosFamilles[IDcompte_payeur] = {
"prelevement_activation" : prelevement_activation, "prelevement_etab" : prelevement_etab, "prelevement_guichet" : prelevement_guichet,
"prelevement_numero" : prelevement_numero, "prelevement_cle" : prelevement_cle, "prelevement_banque" : prelevement_banque,
"prelevement_individu" : prelevement_individu, "prelevement_nom" : prelevement_nom, "prelevement_rue" : prelevement_rue,
"prelevement_cp" : prelevement_cp, "prelevement_ville" : prelevement_ville,
"prelevement_cle_iban" : prelevement_cle_iban, "prelevement_iban" : prelevement_iban, "prelevement_bic" : prelevement_bic,
"prelevement_reference_mandat" : prelevement_reference_mandat, "prelevement_date_mandat" : prelevement_date_mandat,
"email_factures" : email_factures, "nomPayeur" : nomPayeur, "prenomPayeur" : prenomPayeur, "titulaire_helios" : titulaire_helios,
}
DB.Close()
listeResultats = []
for IDfacture, IDprefixe, prefixe, numero, IDcompte_payeur, date_edition, date_echeance, IDutilisateur, date_debut, date_fin, total, regle, solde, IDfamille, IDlot, nomLot, etat in listeFactures :
if numero == None : numero = 0
date_edition = UTILS_Dates.DateEngEnDateDD(date_edition)
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
date_echeance = UTILS_Dates.DateEngEnDateDD(date_echeance)
total = FloatToDecimal(total)
if IDfacture in dictVentilation :
totalVentilation = FloatToDecimal(dictVentilation[IDfacture])
else :
totalVentilation = FloatToDecimal(0.0)
if IDfacture in dictPrestations :
totalPrestations = FloatToDecimal(dictPrestations[IDfacture])
else :
totalPrestations = FloatToDecimal(0.0)
solde_actuel = totalPrestations - totalVentilation
if (IDfamille in dictTitulaires) == True :
titulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"]
adresse_famille = dictTitulaires[IDfamille]["adresse"]
dictTemp = {
"IDfacture" : IDfacture, "IDprefixe" : IDprefixe, "prefixe" : prefixe, "numero" : numero, "IDcompte_payeur" : IDcompte_payeur, "date_edition" : date_edition, "date_echeance" : date_echeance,
"IDutilisateur" : IDutilisateur, "date_debut" : date_debut, "date_fin" : date_fin, "total" : total, "regle" : regle, "solde" : solde,
"totalPrestations" : totalPrestations, "totalVentilation" : totalVentilation, "IDfamille" : IDfamille, "titulaires" : titulaires, "IDlot" : IDlot, "nomLot" : nomLot,
"adresse_famille" : adresse_famille, "etat" : etat,
}
if IDcompte_payeur in dictInfosFamilles :
dictTemp.update(dictInfosFamilles[IDcompte_payeur])
valide = True
# 2ème série de filtres
if self.filtres != None :
for filtre in self.filtres :
# IDfacture_intervalle
if filtre["type"] == "solde_initial" :
if self.ComparateurFiltre(-solde, filtre["operateur"], filtre["montant"]) == False :
valide = False
if filtre["type"] == "solde_actuel" :
if self.ComparateurFiltre(-solde_actuel, filtre["operateur"], filtre["montant"]) == False :
valide = False
if filtre["type"] == "prelevement" :
if filtre["choix"] == True :
if dictTemp["prelevement_activation"] == None : valide = False
else :
if dictTemp["prelevement_activation"] != None : valide = False
if filtre["type"] == "email" :
if filtre["choix"] == True :
if dictTemp["email_factures"] == None : valide = False
else :
if dictTemp["email_factures"] != None : valide = False
if etat == "annulation" and self.afficherAnnulations == False :
valide = False
# Mémorisation des valeurs
if valide == True :
listeResultats.append(dictTemp)
return listeResultats
def OnBoutonOk(self, event):
montant = self.ctrl_montant.GetMontant()
if montant == 0.0:
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir un montant !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
if montant < 0.0:
dlg = wx.MessageDialog(
self, _(u"Le montant doit obligatoirement être positif !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
if self.solde != None and FloatToDecimal(montant) > FloatToDecimal(
self.solde):
dlg = wx.MessageDialog(
self,
_(u"Le montant du remboursement ne doit pas être supérieur au solde du compte !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
IDcompte = self.ctrl_compte.GetID()
if IDcompte == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un compte bancaire !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_compte.SetFocus()
IDpayeur = self.ctrl_payeur.GetID()
if IDpayeur == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un payeur !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_payeur.SetFocus()
IDmode = self.ctrl_mode.GetID()
if IDmode == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un mode de règlement !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_mode.SetFocus()
return
observations = self.ctrl_observations.GetValue()
DB = GestionDB.DB()
# Récupère IDfamille
req = """SELECT IDfamille
FROM comptes_payeurs
WHERE IDcompte_payeur=%d
""" % self.IDcompte_payeur
DB.ExecuterReq(req)
IDfamille = DB.ResultatReq()[0][0]
# Enregistrement de la prestation positive
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur),
("date", str(datetime.date.today())),
("categorie", "autre"),
("label", _(u"Remboursement")),
("montant_initial", montant),
("montant", montant),
("IDfamille", IDfamille),
("date_valeur", str(datetime.date.today())),
]
IDprestation_positive = DB.ReqInsert("prestations", listeDonnees)
# Ventiler la prestation positive avec l'avoir
VentilationAuto(self.IDcompte_payeur)
# Enregistrement de la prestation négative
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur),
("date", str(datetime.date.today())),
("categorie", "autre"),
("label", _(u"Remboursement")),
("montant_initial", -montant),
("montant", -montant),
("IDfamille", IDfamille),
("date_valeur", str(datetime.date.today())),
]
IDprestation_negative = DB.ReqInsert("prestations", listeDonnees)
# Enregistrement du règlement négatif
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur),
("date", str(datetime.date.today())),
("IDmode", IDmode),
("montant", -montant),
("IDpayeur", IDpayeur),
("observations", observations),
("IDcompte", IDcompte),
("date_saisie", str(datetime.date.today())),
("IDutilisateur", UTILS_Identification.GetIDutilisateur()),
]
IDreglement = DB.ReqInsert("reglements", listeDonnees)
# Ventilation de la prestation négative sur le règlement
listeDonnees = [
("IDreglement", IDreglement),
("IDcompte_payeur", self.IDcompte_payeur),
("IDprestation", IDprestation_negative),
("montant", -montant),
]
IDventilation = DB.ReqInsert("ventilation", listeDonnees)
DB.Close()
# Fermeture
self.EndModal(wx.ID_OK)
def FormateMontant(montant):
if montant in ("", None, FloatToDecimal(0.0)):
return ""
return u"%.2f %s" % (montant, SYMBOLE)
