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 Importation(self):
if self.IDreglement == None:
IDreglement = 0
else:
IDreglement = self.IDreglement
# Importation des ventilations de ce règlement
DB = GestionDB.DB()
req = """SELECT IDventilation, IDprestation, montant
FROM ventilation
WHERE IDreglement=%d
;""" % IDreglement
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictVentilation = {}
#self.dictVentilationInitiale = {}
for IDventilation, IDprestation, montant in listeDonnees:
self.dictVentilation[IDprestation] = FloatToDecimal(montant)
self.dictVentilationInitiale[IDprestation] = IDventilation
# Importation de la ventilation passée
req = """SELECT IDprestation, SUM(montant)
FROM ventilation
WHERE IDcompte_payeur=%d
GROUP BY IDprestation
;""" % self.IDcompte_payeur
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictVentilationPassee = {}
for IDprestation, montant in listeDonnees:
dictVentilationPassee[IDprestation] = montant
# Importation des données
req = """
SELECT prestations.IDprestation, prestations.IDcompte_payeur, date, categorie, label, prestations.montant,
prestations.IDactivite, activites.nom,
prestations.IDtarif, noms_tarifs.nom, categories_tarifs.nom,
prestations.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.date_edition,
IDfamille, prestations.IDindividu,
individus.nom, individus.prenom
FROM prestations
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
LEFT JOIN categories_tarifs ON tarifs.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif
LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture
LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe
WHERE prestations.IDcompte_payeur = %d
GROUP BY prestations.IDprestation
ORDER BY date
;""" % self.IDcompte_payeur
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeLignesPrestations = []
for IDprestation, IDcompte_payeur, date, categorie, label, montant, IDactivite, nomActivite, IDtarif, nomTarif, nomCategorieTarif, IDfacture, IDprefixe, prefixe, num_facture, date_facture, IDfamille, IDindividu, nomIndividu, prenomIndividu in listeDonnees:
montant = FloatToDecimal(montant)
if dictVentilationPassee.has_key(IDprestation):
montantVentilation = FloatToDecimal(
dictVentilationPassee[IDprestation])
else:
montantVentilation = FloatToDecimal(0.0)
if num_facture == None: num_facture = 0
if (montant >= FloatToDecimal(0.0) and montantVentilation < montant
) or (montant < FloatToDecimal(0.0) and montantVentilation >
montant) or IDprestation in self.dictVentilation.keys():
date = DateEngEnDateDD(date)
if self.dictVentilation.has_key(IDprestation):
montantVentilation = montantVentilation - self.dictVentilation[
IDprestation]
dictTemp = {
"IDprestation": IDprestation,
"IDcompte_payeur": IDcompte_payeur,
"date": date,
"categorie": categorie,
"label": label,
"montant": montant,
"IDactivite": IDactivite,
"nomActivite": nomActivite,
"IDtarif": IDtarif,
"nomTarif": nomTarif,
"nomCategorieTarif": nomCategorieTarif,
"IDfacture": IDfacture,
"IDprefixe": IDprefixe,
"prefixe": prefixe,
"num_facture": num_facture,
"date_facture": date_facture,
"IDfamille": IDfamille,
"IDindividu": IDindividu,
"nomIndividu": nomIndividu,
"prenomIndividu": prenomIndividu,
"ventilationPassee": montantVentilation,
}
ligne_prestation = Ligne_prestation(grid=self,
donnees=dictTemp)
listeLignesPrestations.append(ligne_prestation)
return listeLignesPrestations
def MAJbarreInfos(self, erreur=None):
total = FloatToDecimal(0.0)
for ligne in self.listeLignesPrestations:
total += ligne.ventilationActuelle
self.parent.MAJbarreInfos(total, erreur)
def GetListePrestations(self, IDfamille=None, listeComptesPayeurs=[]):
DB = GestionDB.DB()
# Condition Famille
if IDfamille == None or IDfamille == 0:
conditionFamille = "IDfamille>0"
else:
conditionFamille = "IDfamille=%d" % IDfamille
# Condition PERIODES
conditions = self.GetSQLdates(self.listePeriodes)
if len(conditions) > 0:
conditionDates = " AND %s" % conditions
else:
conditionDates = ""
# Condition COMPTES PAYEURS
if len(listeComptesPayeurs) == 0:
conditionComptes = "AND prestations.IDcompte_payeur > 0"
elif len(listeComptesPayeurs) == 1:
conditionComptes = "AND prestations.IDcompte_payeur IN (%d)" % listeComptesPayeurs[
0]
else:
conditionComptes = "AND prestations.IDcompte_payeur IN %s" % str(
tuple(listeComptesPayeurs))
# Filtres de l'utilisateur
filtreSQL = self.GetFiltres()
req = """
SELECT prestations.IDprestation, prestations.IDcompte_payeur, prestations.date, categorie,
prestations.label, prestations.montant,
prestations.IDactivite, activites.nom, activites.abrege,
prestations.IDtarif, noms_tarifs.nom, categories_tarifs.nom,
prestations.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.date_edition,
prestations.forfait, prestations.IDcategorie_tarif,
IDfamille, prestations.IDindividu,
individus.nom, individus.prenom,
SUM(deductions.montant) AS montant_deduction,
COUNT(deductions.IDdeduction) AS nbre_deductions,
reglement_frais
FROM prestations
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
LEFT JOIN categories_tarifs ON prestations.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif
LEFT JOIN deductions ON deductions.IDprestation = prestations.IDprestation
LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture
LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe
WHERE %s %s %s %s
GROUP BY prestations.IDprestation
ORDER BY prestations.date
;""" % (conditionFamille, conditionComptes, conditionDates, filtreSQL)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
req = """
SELECT ventilation.IDprestation, SUM(ventilation.montant) AS montant_ventilation
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
LEFT JOIN categories_tarifs ON prestations.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif
LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture
WHERE %s %s %s %s
GROUP BY ventilation.IDprestation
;""" % (conditionFamille, conditionComptes, conditionDates, filtreSQL)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDprestation, montantVentilation in listeVentilation:
dictVentilation[IDprestation] = montantVentilation
DB.Close()
listePrestations = []
listeIndividus = []
listeActivites = []
listeFactures = []
total = 0.0
for IDprestation, IDcompte_payeur, date, categorie, label, montant, IDactivite, nomActivite, nomAbregeActivite, IDtarif, nomTarif, nomCategorieTarif, IDfacture, IDprefixe, prefixe, num_facture, date_facture, forfait, IDcategorie_tarif, IDfamille, IDindividu, nomIndividu, prenomIndividu, montant_deduction, nbre_deductions, reglement_frais in listeDonnees:
date = DateEngEnDateDD(date)
if dictVentilation.has_key(IDprestation):
montant_ventilation = FloatToDecimal(
dictVentilation[IDprestation])
else:
montant_ventilation = FloatToDecimal(0.0)
if montant == None:
montant = 0.0
dictTemp = {
"IDprestation": IDprestation,
"IDcompte_payeur": IDcompte_payeur,
"date": date,
"categorie": categorie,
"label": label,
"montant": FloatToDecimal(montant),
"IDactivite": IDactivite,
"nomActivite": nomActivite,
"nomAbregeActivite": nomAbregeActivite,
"IDtarif": IDtarif,
"nomTarif": nomTarif,
"nomCategorieTarif": nomCategorieTarif,
"IDfacture": IDfacture,
"IDprefixe": IDprefixe,
"prefixe": prefixe,
"num_facture": num_facture,
"date_facture": date_facture,
"forfait": forfait,
"IDfamille": IDfamille,
"IDindividu": IDindividu,
"nomIndividu": nomIndividu,
"prenomIndividu": prenomIndividu,
"montant_ventilation": FloatToDecimal(montant_ventilation),
"montant_deduction": FloatToDecimal(montant_deduction),
"nbre_deductions": nbre_deductions,
"reglement_frais": reglement_frais,
}
listePrestations.append(dictTemp)
# Mémorisation des individus
if IDindividu != None and prenomIndividu != None and (
prenomIndividu, IDindividu) not in listeIndividus:
listeIndividus.append((prenomIndividu, IDindividu))
# Mémorisation des activités
if IDactivite != None and nomActivite != None and (
nomActivite, IDactivite) not in listeActivites:
listeActivites.append((nomActivite, IDactivite))
# Mémorisation des factures
if IDfacture != None and (u"N° %d" % IDfacture,
IDfacture) not in listeFactures:
listeFactures.append((u"N° %d" % IDfacture, IDfacture))
# Mémorisation du total des prestations affichées
total += montant
return listePrestations, listeIndividus, listeActivites, listeFactures, total
def Importation_prestations(self):
""" Importation des données """
DB = GestionDB.DB()
# Récupèration de la ventilation des prestations de la période
conditionDepots = ""
if self.filtreDepots == True and self.filtreDepots_dateDebut != None and self.filtreDepots_dateFin != None:
conditionDepots = " AND (depots.date>='%s' AND depots.date<='%s') " % (
self.filtreDepots_dateDebut, self.filtreDepots_dateFin)
conditionReglements = ""
if self.filtreReglements == True and self.filtreReglements_dateDebut != None and self.filtreReglements_dateFin != None:
conditionReglements = " AND (reglements.date>='%s' AND reglements.date<='%s') " % (
self.filtreReglements_dateDebut, self.filtreReglements_dateFin)
req = """SELECT
ventilation.IDventilation, ventilation.IDreglement, ventilation.IDprestation, ventilation.montant,
reglements.date, reglements.date_saisie, depots.date,
prestations.date
FROM ventilation
LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN depots ON depots.IDdepot = reglements.IDdepot
WHERE prestations.date>='%s' AND prestations.date <='%s' %s %s
ORDER BY prestations.date; """ % (self.date_debut, self.date_fin,
conditionDepots, conditionReglements)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDventilation, IDreglement, IDprestation, montantVentilation, dateReglement, dateSaisieReglement, dateDepotReglement, datePrestation in listeVentilation:
if (IDprestation in dictVentilation) == False:
dictVentilation[IDprestation] = 0.0
dictVentilation[IDprestation] += montantVentilation
# Condition Afficher Cotisations et/ou Consommations ?
listeAffichage = []
if self.afficher_cotisations == True:
listeAffichage.append("cotisation")
if self.afficher_locations == True: listeAffichage.append("location")
if self.afficher_consommations == True:
listeAffichage.append("consommation")
if self.afficher_locations == True: listeAffichage.append("locations")
if self.afficher_autres == True: listeAffichage.append("autre")
if len(listeAffichage) == 0: conditionAfficher = "categorie='xxxxxxx' "
elif len(listeAffichage) == 1:
conditionAfficher = "categorie='%s'" % listeAffichage[0]
else:
conditionAfficher = "categorie IN %s" % str(tuple(listeAffichage))
# Condition Activités affichées
if len(self.listeActivites) == 0:
conditionActivites = "prestations.IDactivite=9999999"
elif len(self.listeActivites) == 1:
conditionActivites = "prestations.IDactivite=%d" % self.listeActivites[
0]
else:
conditionActivites = "prestations.IDactivite IN %s" % str(
tuple(self.listeActivites))
# Récupération de toutes les prestations de la période
req = """SELECT IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDcompte_payeur, IDfamille
FROM prestations
WHERE date>='%s' AND date <='%s'
AND %s AND (%s OR prestations.IDactivite IS NULL)
ORDER BY date; """ % (self.date_debut, self.date_fin,
conditionAfficher, conditionActivites)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
DB.Close()
dictResultats = {
"familles": {},
"activites": {}
} # Stocke la version ACTIVITES et la version FAMILLES
listePeriodes = []
for IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDcompte_payeur, IDfamille in listePrestations:
date = DateEngEnDateDD(date)
annee = date.year
mois = date.month
if self.mode_periode == "mois":
periode = (annee, mois)
else:
periode = annee
if periode not in listePeriodes:
listePeriodes.append(periode)
if categorie == "location":
IDactivite = 777777
if categorie == "cotisation":
IDactivite = 888888
if IDactivite == None:
IDactivite = 999999
if IDprestation in dictVentilation:
solde = float(
FloatToDecimal(montant) -
FloatToDecimal(dictVentilation[IDprestation]))
else:
solde = montant
if solde == None:
solde = 0.0
# Regroupement par activités
if (IDactivite in dictResultats["activites"]) == False:
dictResultats["activites"][IDactivite] = {
"total": 0,
"periodes": {}
}
if (periode in dictResultats["activites"][IDactivite]["periodes"]
) == False:
dictResultats["activites"][IDactivite]["periodes"][periode] = {
"total": 0,
"familles": {}
}
if (IDfamille in dictResultats["activites"][IDactivite]["periodes"]
[periode]["familles"]) == False:
dictResultats["activites"][IDactivite]["periodes"][periode][
"familles"][IDfamille] = 0
dictResultats["activites"][IDactivite]["total"] += solde
dictResultats["activites"][IDactivite]["periodes"][periode][
"total"] += solde
dictResultats["activites"][IDactivite]["periodes"][periode][
"familles"][IDfamille] += solde
# Regroupement par familles
if (IDfamille in dictResultats["familles"]) == False:
dictResultats["familles"][IDfamille] = {
"total": 0,
"periodes": {}
}
if (periode in dictResultats["familles"][IDfamille]["periodes"]
) == False:
dictResultats["familles"][IDfamille]["periodes"][periode] = {
"total": 0,
"activites": {}
}
if (IDactivite in dictResultats["familles"][IDfamille]["periodes"]
[periode]["activites"]) == False:
dictResultats["familles"][IDfamille]["periodes"][periode][
"activites"][IDactivite] = 0
dictResultats["familles"][IDfamille]["total"] += solde
dictResultats["familles"][IDfamille]["periodes"][periode][
"total"] += solde
dictResultats["familles"][IDfamille]["periodes"][periode][
"activites"][IDactivite] += solde
return dictResultats, listePeriodes
def Calculer(self, mode_test=False, dict_valeurs={}):
""" Calcul des totaux et des mensualités """
""" dict_valeurs : pour saisir des valeurs tests """
# Récupération des données
date_debut = self.GetValeur("date_debut")
if dict_valeurs.has_key("date_debut"):
date_debut = dict_valeurs["date_debut"]
date_fin = self.GetValeur("date_fin")
if dict_valeurs.has_key("date_fin"):
date_fin = dict_valeurs["date_fin"]
tracks_previsions = self.GetValeur("tracks_previsions", [])
tracks_tarifs = self.GetValeur("tracks_tarifs", [])
duree_heures_regularisation = self.GetValeur(
"duree_heures_regularisation", datetime.timedelta(0))
arrondi_type = self.GetValeur("arrondi_type", "duree")
arrondi_delta = self.GetValeur("arrondi_delta", 30)
# Absences
duree_absences_prevues = self.GetValeur("duree_absences_prevues",
datetime.timedelta(0))
duree_absences_prises = self.GetValeur("duree_absences_prises",
datetime.timedelta(0))
duree_absences_solde = duree_absences_prevues - duree_absences_prises
self.SetValeur("duree_absences_solde", duree_absences_solde)
# Vérifie si dates du contrat valides avant les calculs
if date_debut != None and date_fin != None and date_fin > date_debut:
dates_valides = True
else:
dates_valides = False
# Calcul du nbre de semaines et de mois
if dates_valides:
nbre_semaines = rrule.rrule(rrule.WEEKLY,
dtstart=date_debut,
until=date_fin).count()
nbre_mois = rrule.rrule(rrule.MONTHLY,
dtstart=date_debut,
until=date_fin).count()
else:
nbre_semaines = 0
nbre_mois = 0
# Analyse des heures prévues
duree_heures_brut = datetime.timedelta(0)
listeDatesUniques = []
for track in tracks_previsions:
duree_heures_brut += track.duree_arrondie
if track.date not in listeDatesUniques:
listeDatesUniques.append(track.date)
# Calcul du nbre de dates uniques
nbre_dates = len(listeDatesUniques)
# Calcul des moyennes
if nbre_dates == 0:
moy_heures_jour = datetime.timedelta(0)
moy_heures_semaine = datetime.timedelta(0)
moy_heures_mois = datetime.timedelta(0)
else:
moy_heures_jour = duree_heures_brut / nbre_dates
moy_heures_semaine = duree_heures_brut / nbre_semaines
moy_heures_mois = duree_heures_brut / nbre_mois
# Calcul du nbre d'heures du contrat
duree_heures_contrat = duree_heures_brut - duree_absences_prevues + duree_heures_regularisation
# Génération des dates de facturation
if dates_valides:
liste_mois = list(
rrule.rrule(rrule.MONTHLY,
bymonthday=1,
dtstart=date_debut,
until=date_fin))
else:
liste_mois = []
nbre_mois_factures = len(liste_mois)
# Ajout de la date de début du contrat
if dates_valides and date_debut.day > 1:
liste_mois.insert(0, date_debut)
# Recherche s'il y a des mensualités déjà facturées
# listePrestationsFacturees = []
# heuresFacturees = datetime.timedelta(seconds=0)
# for dictPrestation in self.GetValeur("liste_prestations", []) :
# if dictPrestation["IDfacture"] != None :
# listePrestationsFacturees.append(dictPrestation)
# heuresFacturees += dictPrestation["temps_facture"]
# nbrePrestations = len(listePrestationsFacturees)
# Conversion du nbre d'heures déjà facturées en entier
# heuresFacturees = (nbre_heures_contrat.days*24) + (nbre_heures_contrat.seconds/3600)
# Calcul du forfait mensuel
# heures_restantes = nbre_heures_contrat - heuresFacturees
# nbre_mois_restant = nbre_mois - nbrePrestations
if nbre_mois_factures == 0:
forfait_horaire_mensuel, reste_division = 0, 0
else:
nbre_heures_contrat_float = UTILS_Dates.DeltaEnHeures(
duree_heures_contrat)
forfait_horaire_mensuel, reste_division = divmod(
nbre_heures_contrat_float, nbre_mois_factures)
forfait_horaire_dernier_mois = forfait_horaire_mensuel + reste_division
forfait_horaire_mensuel = UTILS_Dates.FloatEnDelta(
forfait_horaire_mensuel)
forfait_horaire_dernier_mois = UTILS_Dates.FloatEnDelta(
forfait_horaire_dernier_mois)
# Calcul du forfait horaire mensuel
# if nbre_mois == 0 :
# forfait_horaire_mensuel, reste_division = 0, 0
# else :
# forfait_horaire_mensuel, reste_division = divmod(nbre_heures_contrat, nbre_mois)
# forfait_horaire_dernier_mois = forfait_horaire_mensuel + reste_division
# Génération des mensualités
tracks_mensualites = []
total_mensualites = FloatToDecimal(0.0)
index = 0
for date in liste_mois:
date_facturation = datetime.date(date.year, date.month, date.day)
# Calcul des dates du forfait
forfait_date_debut = date_facturation
if index == len(liste_mois) - 1:
dernierJour = date.day
else:
dernierJour = calendar.monthrange(date.year, date.month)[1]
forfait_date_fin = datetime.date(date.year, date.month,
dernierJour)
# Calcul du forfait horaire mensuel
if index == len(liste_mois) - 1:
heures_prevues = forfait_horaire_dernier_mois
else:
heures_prevues = forfait_horaire_mensuel
# Recherche du tarif du mois
listeTarifs = []
for track in tracks_tarifs:
listeTarifs.append((track.date_debut, track))
listeTarifs.sort()
track_tarif = None
for date_debut_tarif, track in listeTarifs:
if track_tarif == None or date_facturation >= date_debut_tarif:
track_tarif = track
# Calcul du montant mensuel à facturer
if track_tarif != None:
tarif_base = track_tarif.tarif_base
tarif_depassement = track_tarif.tarif_depassement
taux = track_tarif.taux
else:
tarif_base = 0.0
tarif_depassement = 0.0
taux = 0.0
montant_prevu = FloatToDecimal(
tarif_base * UTILS_Dates.DeltaEnFloat(heures_prevues))
total_mensualites += montant_prevu
# Recherche d'une prestation existante
IDprestation = None
IDfacture = None
num_facture = None
heures_facturees = datetime.timedelta(seconds=0)
montant_facture = FloatToDecimal(0.0)
for dictPrestation in self.GetValeur("liste_prestations", []):
if dictPrestation["date_facturation"] == date_facturation:
IDprestation = dictPrestation["IDprestation"]
IDfacture = dictPrestation["IDfacture"]
num_facture = dictPrestation["num_facture"]
montant_facture = dictPrestation["montant"]
heures_facturees = dictPrestation["temps_facture"]
# Mémorisation de la mensualité
dictMensualite = {
"IDprestation": IDprestation,
"date_facturation": date_facturation,
"taux": taux,
"track_tarif": track_tarif,
"tarif_base": tarif_base,
"tarif_depassement": tarif_depassement,
"heures_prevues": heures_prevues,
"montant_prevu": montant_prevu,
"heures_facturees": heures_facturees,
"montant_facture": montant_facture,
"IDfacture": IDfacture,
"forfait_date_debut": forfait_date_debut,
"forfait_date_fin": forfait_date_fin,
"num_facture": num_facture,
}
tracks_mensualites.append(Track_mensualite(dictMensualite))
index += 1
# Vérifie si anomalies
listeAnomalies = []
# Vérifie que les prestations facturées sont toujours l�
# for dictPrestation in listePrestationsFacturees :
# present = False
# for track in tracks_mensualites :
# if track.IDprestation == dictPrestation["IDprestation"] :
# present = True
# if present == False :
# listeAnomalies.append(_(u"La prestation du %s ne peut pas être supprimée car elle apparaît déjà sur la facture n°%s." % (UTILS_Dates.DateDDEnFr(dictPrestation["date_facturation"]), dictPrestation["num_facture"])))
# Vérifie si les consommations sont bien sur la période du contrat
nbreConsoHorsPeriode = 0
for track in tracks_previsions:
if track.date < date_debut or track.date > date_fin:
nbreConsoHorsPeriode += 1
if nbreConsoHorsPeriode > 0:
listeAnomalies.append(
_(u"%d consommations prévues sont en dehors de la période du contrat."
% nbreConsoHorsPeriode))
# Si mode test, renvoie la liste des anomalies
if mode_test == True:
if len(listeAnomalies) > 0:
import DLG_Messagebox
introduction = _(
u"Votre saisie ne peut pas être validée en raison des erreurs suivantes :"
)
detail = "\n".join(listeAnomalies)
conclusion = _(u"Veuillez modifier les données saisies.")
dlg = DLG_Messagebox.Dialog(None,
titre=_(u"Erreur"),
introduction=introduction,
detail=detail,
conclusion=conclusion,
icone=wx.ICON_INFORMATION,
boutons=[
_(u"Ok"),
])
dlg.ShowModal()
dlg.Destroy()
return False
else:
return True
# Envoi des données à clsbase
dictValeurs = {
"nbre_semaines": nbre_semaines,
"nbre_mois": nbre_mois,
"duree_heures_brut": duree_heures_brut,
"nbre_dates": nbre_dates,
"moy_heures_jour": moy_heures_jour,
"moy_heures_semaine": moy_heures_semaine,
"moy_heures_mois": moy_heures_mois,
"duree_heures_contrat": duree_heures_contrat,
"forfait_horaire_mensuel": forfait_horaire_mensuel,
"forfait_horaire_dernier_mois": forfait_horaire_dernier_mois,
"tracks_mensualites": tracks_mensualites,
"nbre_mensualites": len(tracks_mensualites),
"total_mensualites": total_mensualites,
}
self.SetValeurs(dictValeurs)
return dictValeurs
def GetListeFactures(self):
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Conditions
listeConditions = []
if self.IDcompte_payeur != None:
listeConditions.append("prestations.IDcompte_payeur = %d" %
self.IDcompte_payeur)
# 1ère série de filtres
if self.filtres != None:
for filtre in self.filtres:
# IDfacture_intervalle
if filtre["type"] == "IDfacture_intervalle":
listeConditions.append(
"(factures.IDfacture>=%d AND factures.IDfacture<=%d)" %
(filtre["IDfacture_min"], filtre["IDfacture_max"]))
# IDfacture_liste
if filtre["type"] == "IDfacture_liste":
if len(filtre["liste"]) == 0: listeTemp = "()"
elif len(filtre["liste"]) == 1:
listeTemp = "(%d)" % filtre["liste"][0]
else:
listeTemp = str(tuple(filtre["liste"]))
listeConditions.append("factures.IDfacture IN %s" %
listeTemp)
# Préfixe
if filtre["type"] == "prefixe":
if filtre["IDprefixe"] == None:
listeConditions.append("factures.IDprefixe IS NULL")
else:
listeConditions.append("factures.IDprefixe=%d" %
filtre["IDprefixe"])
# Lot de factures
if filtre["type"] == "lot":
listeConditions.append("factures.IDlot=%d" %
filtre["IDlot"])
# Date d'émission
if filtre["type"] == "date_emission":
listeConditions.append(
"(factures.date_edition>='%s' AND factures.date_edition<='%s')"
% (filtre["date_min"], filtre["date_max"]))
# Date d'échéance
if filtre["type"] == "date_echeance":
listeConditions.append(
"(factures.date_echeance>='%s' AND factures.date_echeance<='%s')"
% (filtre["date_min"], filtre["date_max"]))
# numero_intervalle
if filtre["type"] == "numero_intervalle":
listeConditions.append(
"(factures.numero>=%d AND factures.numero<=%d)" %
(filtre["numero_min"], filtre["numero_max"]))
# numero_liste
if filtre["type"] == "numero_liste":
if len(filtre["liste"]) == 0: listeTemp = "()"
elif len(filtre["liste"]) == 1:
listeTemp = "(%d)" % filtre["liste"][0]
else:
listeTemp = str(tuple(filtre["liste"]))
listeConditions.append("factures.numero IN %s" % listeTemp)
if len(listeConditions) > 0:
conditions = "WHERE %s" % " AND ".join(listeConditions)
else:
conditions = ""
# Récupération des totaux des prestations pour chaque facture
req = """
SELECT
prestations.IDfacture, SUM(prestations.montant)
FROM prestations
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestations = {}
for IDfacture, totalPrestations in listeDonnees:
if IDfacture != None:
dictPrestations[IDfacture] = totalPrestations
# Récupération des factures
req = """
SELECT factures.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.IDcompte_payeur,
factures.date_edition, factures.date_echeance, factures.IDutilisateur,
factures.date_debut, factures.date_fin, factures.total, factures.regle, factures.solde,
comptes_payeurs.IDfamille, factures.IDlot, lots_factures.nom, factures.etat
FROM factures
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur
LEFT JOIN lots_factures ON lots_factures.IDlot = factures.IDlot
LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe
%s
ORDER BY factures.date_edition
;""" % conditions.replace("prestations.IDcompte_payeur",
"comptes_payeurs.IDcompte_payeur")
DB.ExecuterReq(req)
listeFactures = DB.ResultatReq()
# Récupération de la ventilation
req = """
SELECT prestations.IDfacture, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDfacture, montantVentilation in listeVentilation:
if IDfacture != None:
dictVentilation[IDfacture] = montantVentilation
# Infos Prélèvement + Envoi par Email des factures
if self.IDcompte_payeur != None:
conditions = "WHERE comptes_payeurs.IDcompte_payeur = %d" % self.IDcompte_payeur
else:
conditions = ""
req = """
SELECT
prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque,
prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville,
prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat,
email_factures,
comptes_payeurs.IDcompte_payeur,
individus.nom, individus.prenom,
titulaire_helios
FROM familles
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille
LEFT JOIN individus ON individus.IDindividu = prelevement_individu
%s
;""" % conditions
DB.ExecuterReq(req)
listeInfosFamilles = DB.ResultatReq()
dictInfosFamilles = {}
for prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, IDcompte_payeur, nomPayeur, prenomPayeur, titulaire_helios in listeInfosFamilles:
prelevement_date_mandat = UTILS_Dates.DateEngEnDateDD(
prelevement_date_mandat)
dictInfosFamilles[IDcompte_payeur] = {
"prelevement_activation": prelevement_activation,
"prelevement_etab": prelevement_etab,
"prelevement_guichet": prelevement_guichet,
"prelevement_numero": prelevement_numero,
"prelevement_cle": prelevement_cle,
"prelevement_banque": prelevement_banque,
"prelevement_individu": prelevement_individu,
"prelevement_nom": prelevement_nom,
"prelevement_rue": prelevement_rue,
"prelevement_cp": prelevement_cp,
"prelevement_ville": prelevement_ville,
"prelevement_cle_iban": prelevement_cle_iban,
"prelevement_iban": prelevement_iban,
"prelevement_bic": prelevement_bic,
"prelevement_reference_mandat": prelevement_reference_mandat,
"prelevement_date_mandat": prelevement_date_mandat,
"email_factures": email_factures,
"nomPayeur": nomPayeur,
"prenomPayeur": prenomPayeur,
"titulaire_helios": titulaire_helios,
}
DB.Close()
listeResultats = []
for IDfacture, IDprefixe, prefixe, numero, IDcompte_payeur, date_edition, date_echeance, IDutilisateur, date_debut, date_fin, total, regle, solde, IDfamille, IDlot, nomLot, etat in listeFactures:
if numero == None: numero = 0
date_edition = UTILS_Dates.DateEngEnDateDD(date_edition)
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
date_echeance = UTILS_Dates.DateEngEnDateDD(date_echeance)
total = FloatToDecimal(total)
if dictVentilation.has_key(IDfacture):
totalVentilation = FloatToDecimal(dictVentilation[IDfacture])
else:
totalVentilation = FloatToDecimal(0.0)
if dictPrestations.has_key(IDfacture):
totalPrestations = FloatToDecimal(dictPrestations[IDfacture])
else:
totalPrestations = FloatToDecimal(0.0)
solde_actuel = totalPrestations - totalVentilation
if dictTitulaires.has_key(IDfamille) == True:
titulaires = dictTitulaires[IDfamille][
"titulairesSansCivilite"]
adresse_famille = dictTitulaires[IDfamille]["adresse"]
dictTemp = {
"IDfacture": IDfacture,
"IDprefixe": IDprefixe,
"prefixe": prefixe,
"numero": numero,
"IDcompte_payeur": IDcompte_payeur,
"date_edition": date_edition,
"date_echeance": date_echeance,
"IDutilisateur": IDutilisateur,
"date_debut": date_debut,
"date_fin": date_fin,
"total": total,
"regle": regle,
"solde": solde,
"totalPrestations": totalPrestations,
"totalVentilation": totalVentilation,
"IDfamille": IDfamille,
"titulaires": titulaires,
"IDlot": IDlot,
"nomLot": nomLot,
"adresse_famille": adresse_famille,
"etat": etat,
}
if dictInfosFamilles.has_key(IDcompte_payeur):
dictTemp.update(dictInfosFamilles[IDcompte_payeur])
valide = True
# 2ème série de filtres
if self.filtres != None:
for filtre in self.filtres:
# IDfacture_intervalle
if filtre["type"] == "solde_initial":
if self.ComparateurFiltre(
-solde, filtre["operateur"],
filtre["montant"]) == False:
valide = False
if filtre["type"] == "solde_actuel":
if self.ComparateurFiltre(
-solde_actuel, filtre["operateur"],
filtre["montant"]) == False:
valide = False
if filtre["type"] == "prelevement":
if filtre["choix"] == True:
if dictTemp["prelevement_activation"] == None:
valide = False
else:
if dictTemp["prelevement_activation"] != None:
valide = False
if filtre["type"] == "email":
if filtre["choix"] == True:
if dictTemp["email_factures"] == None:
valide = False
else:
if dictTemp["email_factures"] != None:
valide = False
if etat == "annulation" and self.afficherAnnulations == False:
valide = False
# Mémorisation des valeurs
if valide == True:
listeResultats.append(dictTemp)
return listeResultats
def GetDoc(self):
# Importation des données de la DB
DB = GestionDB.DB()
if self.IDfamille == None :
conditions = ""
req = """SELECT IDfamille, date_creation FROM familles;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_IDfamille = []
for IDfamille, date_creation in listeDonnees :
liste_IDfamille.append(IDfamille)
else :
conditions = "WHERE IDfamille=%d" % self.IDfamille
liste_IDfamille = [self.IDfamille,]
# Importation des pièces fournies
req = """SELECT pieces.IDpiece, pieces.date_debut, pieces.date_fin,
types_pieces.public, types_pieces.nom,
individus.IDindividu, pieces.IDfamille, individus.prenom
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
LEFT JOIN individus ON individus.IDindividu = pieces.IDindividu
ORDER BY date_debut;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPieces = {"familles" : {}, "individus" : {}}
for IDpiece, date_debut, date_fin, public, nom_piece, IDindividu, IDfamille, prenom in listeDonnees :
dictPiece = {"IDpiece" : IDpiece, "nom_piece" : nom_piece,
"date_debut" : UTILS_Dates.DateEngEnDateDD(date_debut),
"date_fin": UTILS_Dates.DateEngEnDateDD(date_fin)}
if public == "famille" :
if dictPieces["familles"].has_key(IDfamille) == False :
dictPieces["familles"][IDfamille] = []
dictPieces["familles"][IDfamille].append(dictPiece)
if public == "individu" :
if dictPieces["individus"].has_key(IDindividu) == False :
dictPieces["individus"][IDindividu] = []
dictPieces["individus"][IDindividu].append(dictPiece)
# Importation des cotisations
champs_cotisations = [
("IDcotisation", "cotisations.IDcotisation"),
("IDfamille", "cotisations.IDfamille"),
("IDindividu", "cotisations.IDindividu"),
("date_saisie", "cotisations.date_saisie"),
("date_creation_carte", "cotisations.date_creation_carte"),
("numero", "cotisations.numero"),
("date_debut", "cotisations.date_debut"),
("date_fin", "cotisations.date_fin"),
("observations", "cotisations.observations"),
("activites", "cotisations.activites"),
("type_cotisation", "types_cotisations.nom"),
("type", "types_cotisations.type"),
("nom_unite_cotisation", "unites_cotisations.nom"),
]
req = """
SELECT %s
FROM cotisations
LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation
LEFT JOIN unites_cotisations ON unites_cotisations.IDunite_cotisation = cotisations.IDunite_cotisation
ORDER BY cotisations.date_debut
;""" % ", ".join([champ for nom, champ in champs_cotisations])
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictCotisations = {"familles" : {}, "individus" : {}}
for donnees in listeDonnees :
dictCotisation = {}
for index in range(0, len(champs_cotisations)):
dictCotisation[champs_cotisations[index][0]] = donnees[index]
if dictCotisation["type"] == "famille" :
IDfamille = dictCotisation["IDfamille"]
if dictCotisations["familles"].has_key(IDfamille) == False :
dictCotisations["familles"][IDfamille] = []
dictCotisations["familles"][IDfamille].append(dictCotisation)
if dictCotisation["type"] == "individu" :
IDindividu = dictCotisation["IDindividu"]
if dictCotisations["individus"].has_key(IDindividu) == False :
dictCotisations["individus"][IDindividu] = []
dictCotisations["individus"][IDindividu].append(dictCotisation)
# Importation des prestations
champs_prestations = [
("IDprestation", "prestations.IDprestation"),
("date", "prestations.date"),
("label", "prestations.label"),
("montant", "prestations.montant"),
("numero_facture", "factures.numero"),
("activite", "activites.nom"),
("prenom", "individus.prenom"),
("IDfamille", "prestations.IDfamille"),
("IDindividu", "prestations.IDindividu"),
]
req = """
SELECT %s
FROM prestations
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture
%s
GROUP BY prestations.IDprestation
ORDER BY prestations.date
;""" % (", ".join([champ for nom, champ in champs_prestations]), conditions)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestations = {}
for donnees in listeDonnees :
dictPrestation = {}
for index in range(0, len(champs_prestations)):
dictPrestation[champs_prestations[index][0]] = donnees[index]
if dictPrestation["numero_facture"] == None : dictPrestation["numero_facture"] = ""
if dictPrestation["prenom"] == None : dictPrestation["prenom"] = ""
IDfamille = dictPrestation["IDfamille"]
if dictPrestations.has_key(IDfamille) == False :
dictPrestations[IDfamille] = []
dictPrestations[IDfamille].append(dictPrestation)
# Importation des consommations
req = """
SELECT IDconso, date, activites.nom, consommations.etat,
unites.nom, consommations.IDindividu, comptes_payeurs.IDfamille
FROM consommations
LEFT JOIN activites ON activites.IDactivite = consommations.IDactivite
LEFT JOIN unites ON unites.IDunite = consommations.IDunite
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur
%s
GROUP BY consommations.IDconso
ORDER BY date
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictConsommations = {}
for IDconso, date, nomActivite, etat, nomUnite, IDindividu, IDfamille in listeDonnees :
dictConso = {
"IDconso" : IDconso, "date" : date, "nomActivite" : nomActivite,
"etat" : etat, "nomUnite" : nomUnite,
}
if dictConsommations.has_key(IDfamille) == False :
dictConsommations[IDfamille] = {}
if dictConsommations[IDfamille].has_key(IDindividu) == False :
dictConsommations[IDfamille][IDindividu] = []
dictConsommations[IDfamille][IDindividu].append(dictConso)
# Importation des factures
# 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
GROUP BY prestations.IDfacture
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestationsFactures = {}
for IDfacture, totalPrestations in listeDonnees :
if IDfacture != None :
dictPrestationsFactures[IDfacture] = totalPrestations
# Récupération des factures
req = """
SELECT factures.IDfacture, factures.numero, factures.date_edition, factures.date_debut,
factures.date_fin, factures.total, factures.regle, factures.solde, comptes_payeurs.IDfamille
FROM factures
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur
%s
ORDER BY factures.date_edition
;""" % conditions
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.replace("IDfamille", "comptes_payeurs.IDfamille")
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilationFactures = {}
for IDfacture, montantVentilation in listeVentilation :
if IDfacture != None :
dictVentilationFactures[IDfacture] = montantVentilation
dictFactures = {}
for IDfacture, numero, date_edition, date_debut, date_fin, total, regle, solde, IDfamille in listeFactures :
if numero == None : numero = 0
total = FloatToDecimal(total)
if dictVentilationFactures.has_key(IDfacture) :
totalVentilation = FloatToDecimal(dictVentilationFactures[IDfacture])
else :
totalVentilation = FloatToDecimal(0.0)
if dictPrestationsFactures.has_key(IDfacture) :
totalPrestations = FloatToDecimal(dictPrestationsFactures[IDfacture])
else :
totalPrestations = FloatToDecimal(0.0)
solde_actuel = totalPrestations - totalVentilation
dictFacture = {
"IDfacture" : IDfacture, "numero" : numero, "date_edition" : date_edition, "date_debut" : date_debut,
"date_fin": date_fin, "montant" : float(totalPrestations), "montant_regle" : float(totalVentilation),
"montant_solde" : float(solde_actuel),
}
if dictFactures.has_key(IDfamille) == False :
dictFactures[IDfamille] = []
dictFactures[IDfamille].append(dictFacture)
# Importation des règlements
req = """SELECT
reglements.IDreglement, comptes_payeurs.IDfamille,
reglements.date, modes_reglements.label, emetteurs.nom,
reglements.numero_piece, reglements.montant, payeurs.nom,
reglements.observations, numero_quittancier, date_differe,
date_saisie, depots.date
FROM reglements
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = reglements.IDcompte_payeur
LEFT JOIN modes_reglements ON reglements.IDmode=modes_reglements.IDmode
LEFT JOIN emetteurs ON reglements.IDemetteur=emetteurs.IDemetteur
LEFT JOIN payeurs ON reglements.IDpayeur=payeurs.IDpayeur
LEFT JOIN depots ON reglements.IDdepot=depots.IDdepot
%s
GROUP BY reglements.IDreglement
ORDER BY date_saisie
;""" % conditions.replace("IDfamille", "comptes_payeurs.IDfamille")
DB.ExecuterReq(req)
listeReglements = DB.ResultatReq()
dictReglements = {}
for IDreglement, IDfamille, date, mode, emetteur, numero, montant, payeur, observations, numero_quittancier, date_differe, date_saisie, date_encaissement in listeReglements :
if numero == None : numero = ""
if emetteur == None : emetteur = ""
if observations == None: observations = ""
if numero_quittancier == None: numero_quittancier = ""
dictReglement = {
"date" : date, "mode" : mode, "emetteur" : emetteur, "numero" : numero, "montant" : montant,
"payeur": payeur, "observations" : observations, "numero_quittancier" : numero_quittancier,
"date_differe" : date_differe, "date_saisie" : date_saisie, "date_encaissement": date_encaissement,
}
if dictReglements.has_key(IDfamille) == False :
dictReglements[IDfamille] = []
dictReglements[IDfamille].append(dictReglement)
DB.Close()
# Récupération des infos individus
infos = UTILS_Infos_individus.Informations()
# Génération du XML
doc = Document()
# Racine Familles
node_racine = doc.createElement("familles")
doc.appendChild(node_racine)
for IDfamille in liste_IDfamille :
# Famille : Infos générales
node_famille = doc.createElement("famille")
node_famille.setAttribute("id", str(IDfamille))
node_racine.appendChild(node_famille)
for key, valeur in infos.dictFamilles[IDfamille].iteritems():
if key.startswith("FAMILLE_"):
node = doc.createElement(key.replace("FAMILLE_", "").lower())
node.setAttribute("valeur", unicode(valeur))
node_famille.appendChild(node)
# Famille : Quotients
if infos.dictFamilles[IDfamille].has_key("qf"):
node_qf = doc.createElement(u"quotients_familiaux")
node_famille.appendChild(node_qf)
for dictQF in infos.dictFamilles[IDfamille]["qf"]:
node = doc.createElement(u"quotient")
node.setAttribute("date_debut", dictQF["date_debut"])
node.setAttribute("date_fin", dictQF["date_fin"])
node.setAttribute("quotient", str(dictQF["quotient"]))
node.setAttribute("observations", dictQF["observations"])
node_qf.appendChild(node)
# Famille : Messages
if infos.dictFamilles[IDfamille].has_key("messages"):
node_messages = doc.createElement(u"messages")
node_famille.appendChild(node_messages)
for dictMessage in infos.dictFamilles[IDfamille]["messages"]["liste"]:
node = doc.createElement(u"message")
node.setAttribute("categorie_nom", dictMessage["categorie_nom"])
node.setAttribute("date_saisie", dictMessage["date_saisie"])
node.setAttribute("date_parution", dictMessage["date_parution"])
node.setAttribute("nom", dictMessage["nom"])
node.setAttribute("texte", dictMessage["texte"])
node_messages.appendChild(node)
# Famille : Questionnaires
if infos.dictFamilles[IDfamille].has_key("questionnaires"):
node_questionnaires = doc.createElement(u"questionnaires")
node_famille.appendChild(node_questionnaires)
for dictQuestionnaire in infos.dictFamilles[IDfamille]["questionnaires"]:
node = doc.createElement(u"questionnaire")
node.setAttribute("question", dictQuestionnaire["label"])
node.setAttribute("reponse", unicode(dictQuestionnaire["reponse"]))
node_questionnaires.appendChild(node)
# Famille : Pièces
if dictPieces["familles"].has_key(IDfamille):
node_pieces = doc.createElement(u"pieces")
node_famille.appendChild(node_pieces)
for dictPiece in dictPieces["familles"][IDfamille]:
node = doc.createElement(u"piece")
node.setAttribute("nom_piece", dictPiece["nom_piece"])
node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictPiece["date_debut"]))
node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictPiece["date_fin"]))
node_pieces.appendChild(node)
# Famille : Cotisations
if dictCotisations["familles"].has_key(IDfamille):
node_cotisations = doc.createElement(u"cotisations")
node_famille.appendChild(node_cotisations)
for dictCotisation in dictCotisations["familles"][IDfamille]:
node = doc.createElement(u"cotisation")
node.setAttribute("date_saisie", UTILS_Dates.DateDDEnFr(dictCotisation["date_saisie"]))
node.setAttribute("date_creation_carte", UTILS_Dates.DateDDEnFr(dictCotisation["date_creation_carte"]))
node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictCotisation["date_debut"]))
node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictCotisation["date_fin"]))
node.setAttribute("numero", dictCotisation["numero"])
node.setAttribute("type_cotisation", dictCotisation["type_cotisation"])
node.setAttribute("nom_unite_cotisation", dictCotisation["nom_unite_cotisation"])
node.setAttribute("observations", dictCotisation["observations"])
node.setAttribute("activites", dictCotisation["activites"])
node_cotisations.appendChild(node)
# Famille : Prestations
if dictPrestations.has_key(IDfamille):
node_prestations = doc.createElement(u"prestations")
node_famille.appendChild(node_prestations)
for dictPrestation in dictPrestations[IDfamille]:
node = doc.createElement(u"prestation")
node.setAttribute("date", UTILS_Dates.DateEngFr(dictPrestation["date"]))
node.setAttribute("label", dictPrestation["label"])
node.setAttribute("devise", SYMBOLE)
node.setAttribute("montant", u"%.2f" % dictPrestation["montant"])
node.setAttribute("numero_facture", str(dictPrestation["numero_facture"]))
node.setAttribute("activite", dictPrestation["activite"])
node.setAttribute("prenom", dictPrestation["prenom"])
node_prestations.appendChild(node)
# Famille : Factures
if dictFactures.has_key(IDfamille):
node_factures = doc.createElement(u"factures")
node_famille.appendChild(node_factures)
for dictFacture in dictFactures[IDfamille]:
node = doc.createElement(u"facture")
node.setAttribute("date_edition", UTILS_Dates.DateEngFr(dictFacture["date_edition"]))
node.setAttribute("date_debut", UTILS_Dates.DateEngFr(dictFacture["date_debut"]))
node.setAttribute("date_fin", UTILS_Dates.DateEngFr(dictFacture["date_fin"]))
node.setAttribute("numero_facture", str(dictFacture["numero"]))
node.setAttribute("devise", SYMBOLE)
node.setAttribute("montant", u"%.2f" % dictFacture["montant"])
node.setAttribute("montant_regle", u"%.2f" % dictFacture["montant_regle"])
node.setAttribute("montant_solde", u"%.2f" % dictFacture["montant_solde"])
node_factures.appendChild(node)
# Famille : Règlements
if dictReglements.has_key(IDfamille):
node_reglements = doc.createElement(u"reglements")
node_famille.appendChild(node_reglements)
for dictReglement in dictReglements[IDfamille]:
node = doc.createElement(u"reglement")
node.setAttribute("date", UTILS_Dates.DateEngFr(dictReglement["date"]))
node.setAttribute("date_differe", UTILS_Dates.DateEngFr(dictReglement["date_differe"]))
node.setAttribute("date_saisie", UTILS_Dates.DateEngFr(dictReglement["date_saisie"]))
node.setAttribute("date_encaissement", UTILS_Dates.DateEngFr(dictReglement["date_encaissement"]))
node.setAttribute("mode", dictReglement["mode"])
node.setAttribute("emetteur", dictReglement["emetteur"])
node.setAttribute("numero_piece", dictReglement["numero"])
node.setAttribute("devise", SYMBOLE)
node.setAttribute("montant", u"%.2f" % dictReglement["montant"])
node.setAttribute("payeur", dictReglement["payeur"])
node.setAttribute("observations", dictReglement["observations"])
node.setAttribute("numero_quittancier", dictReglement["numero_quittancier"])
node_reglements.appendChild(node)
# Individus
node_individus = doc.createElement(u"individus")
node_famille.appendChild(node_individus)
if infos.dictRattachements["familles"].has_key(IDfamille):
for dictRattachement in infos.dictRattachements["familles"][IDfamille]:
IDindividu = dictRattachement["IDindividu"]
node_individu = doc.createElement(u"individu")
node_individu.setAttribute("id", str(IDindividu))
node_individus.appendChild(node_individu)
# Individu : données générales
for key, champ in infos.GetListeChampsIndividus():
valeur = infos.dictIndividus[IDindividu][key]
if isinstance(valeur, (unicode, str)):
node = doc.createElement(key.replace("INDIVIDU_", "").lower())
node.setAttribute("valeur", unicode(valeur))
node_individu.appendChild(node)
# Individu : Messages
if infos.dictIndividus[IDindividu].has_key("messages"):
node_messages = doc.createElement(u"messages")
node_individu.appendChild(node_messages)
for dictMessage in infos.dictIndividus[IDindividu]["messages"]["liste"]:
node = doc.createElement(u"message")
node.setAttribute("categorie_nom", dictMessage["categorie_nom"])
node.setAttribute("date_saisie", dictMessage["date_saisie"])
node.setAttribute("date_parution", dictMessage["date_parution"])
node.setAttribute("nom", dictMessage["nom"])
node.setAttribute("texte", dictMessage["texte"])
node_messages.appendChild(node)
# Individu : Infos médicales
if infos.dictIndividus[IDindividu].has_key("medical"):
node_medicales = doc.createElement(u"infos_medicales")
node_individu.appendChild(node_medicales)
for dictMedicale in infos.dictIndividus[IDindividu]["medical"]["liste"]:
node = doc.createElement(u"info_medicale")
node.setAttribute("intitule", dictMedicale["intitule"])
node.setAttribute("description", dictMedicale["description"])
node.setAttribute("description_traitement", dictMedicale["description_traitement"])
node.setAttribute("date_debut_traitement", dictMedicale["date_debut_traitement"])
node.setAttribute("date_fin_traitement", dictMedicale["date_fin_traitement"])
node_medicales.appendChild(node)
# Individu : Inscriptions
if infos.dictIndividus[IDindividu].has_key("inscriptions"):
node_inscriptions = doc.createElement(u"inscriptions")
node_individu.appendChild(node_inscriptions)
for dictInscription in infos.dictIndividus[IDindividu]["inscriptions"]["liste"]:
node = doc.createElement(u"inscription")
node.setAttribute("activite", dictInscription["activite"])
node.setAttribute("groupe", dictInscription["groupe"])
node.setAttribute("categorie_tarif", dictInscription["categorie_tarif"])
node.setAttribute("parti", dictInscription["parti"])
node.setAttribute("date_inscription", dictInscription["date_inscription"])
node_inscriptions.appendChild(node)
# Individu : Questionnaires
if infos.dictIndividus[IDindividu].has_key("questionnaires"):
node_questionnaires = doc.createElement(u"questionnaires")
node_individu.appendChild(node_questionnaires)
for dictQuestionnaire in infos.dictIndividus[IDindividu]["questionnaires"]:
node = doc.createElement(u"questionnaire")
node.setAttribute("question", dictQuestionnaire["label"])
node.setAttribute("reponse", unicode(dictQuestionnaire["reponse"]))
node_questionnaires.appendChild(node)
# Individu : Scolarité
if infos.dictIndividus[IDindividu].has_key("scolarite"):
node_scolarite = doc.createElement(u"scolarite")
node_individu.appendChild(node_scolarite)
for dictScolarite in infos.dictIndividus[IDindividu]["scolarite"]["liste"]:
node = doc.createElement(u"etape")
node.setAttribute("date_debut", dictScolarite["date_debut"])
node.setAttribute("date_fin", dictScolarite["date_fin"])
node.setAttribute("ecole_nom", dictScolarite["ecole_nom"])
node.setAttribute("classe_nom", dictScolarite["classe_nom"])
node.setAttribute("niveau_nom", dictScolarite["niveau_nom"])
node.setAttribute("niveau_abrege", dictScolarite["niveau_abrege"])
node_scolarite.appendChild(node)
# Individu : Pièces
if dictPieces["individus"].has_key(IDindividu):
node_pieces = doc.createElement(u"pieces")
node_individu.appendChild(node_pieces)
for dictPiece in dictPieces["individus"][IDindividu]:
node = doc.createElement(u"piece")
node.setAttribute("nom_piece", dictPiece["nom_piece"])
node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictPiece["date_debut"]))
node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictPiece["date_fin"]))
node_pieces.appendChild(node)
# Individu : Cotisations
if dictCotisations["individus"].has_key(IDindividu):
node_cotisations = doc.createElement(u"cotisations")
node_individu.appendChild(node_cotisations)
for dictCotisation in dictCotisations["individus"][IDindividu]:
node = doc.createElement(u"cotisation")
node.setAttribute("date_saisie", UTILS_Dates.DateDDEnFr(dictCotisation["date_saisie"]))
node.setAttribute("date_creation_carte", UTILS_Dates.DateDDEnFr(dictCotisation["date_creation_carte"]))
node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictCotisation["date_debut"]))
node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictCotisation["date_fin"]))
node.setAttribute("numero", dictCotisation["numero"])
node.setAttribute("type_cotisation", dictCotisation["type_cotisation"])
node.setAttribute("nom_unite_cotisation", dictCotisation["nom_unite_cotisation"])
node.setAttribute("observations", dictCotisation["observations"])
node.setAttribute("activites", dictCotisation["activites"])
node_cotisations.appendChild(node)
# Individu : Consommations
if dictConsommations.has_key(IDfamille):
if dictConsommations[IDfamille].has_key(IDindividu):
node_consommations = doc.createElement(u"consommations")
node_individu.appendChild(node_consommations)
for dictConso in dictConsommations[IDfamille][IDindividu]:
node = doc.createElement(u"consommation")
node.setAttribute("date", UTILS_Dates.DateEngFr(dictConso["date"]))
node.setAttribute("activite", dictConso["nomActivite"])
node.setAttribute("etat", dictConso["etat"])
node.setAttribute("unite", dictConso["nomUnite"])
node_consommations.appendChild(node)
# Renvoie le doc
return doc
def __init__(self, parent, donnees, dictFacturation):
self.IDcotisation = donnees[0]
self.IDfamille = donnees[1]
self.IDindividu = donnees[2]
self.IDtype_cotisation = donnees[3]
self.IDunite_cotisation = donnees[4]
self.date_saisie = UTILS_Dates.DateEngEnDateDD(donnees[5])
self.IDutilisateur = donnees[6]
self.date_creation_carte = donnees[7]
self.numero = donnees[8]
self.IDdepot_cotisation = donnees[9]
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[10])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[11])
self.IDprestation = donnees[12]
self.nomTypeCotisation = donnees[13]
self.typeTypeCotisation = donnees[14]
self.typeHasCarte = donnees[15]
self.nomUniteCotisation = donnees[16]
self.IDcompte_payeur = donnees[17]
self.observations = donnees[18]
self.activites = donnees[19]
if self.activites == None :
self.activites = ""
# Activites
texte = ""
if len(self.activites) > 0 :
listeTemp = []
listeIDactivites = UTILS_Divers.ConvertChaineEnListe(self.activites)
for IDactivite in listeIDactivites :
if parent.dictActivites.has_key(IDactivite) :
nomActivite = parent.dictActivites[IDactivite]["nom"]
listeTemp.append(nomActivite)
if len(listeTemp) > 0 :
texte = ", ".join(listeTemp)
self.activitesStr = texte
# Nom cotisation
self.nomCotisation = u"%s - %s" % (self.nomTypeCotisation, self.nomUniteCotisation)
# Numéro de cotisation
try :
self.numero_int = int(self.numero)
except :
self.numero_int = None
# Titulaires famille
if parent.titulaires.has_key(self.IDfamille) :
self.nomsTitulaires = parent.titulaires[self.IDfamille]["titulairesSansCivilite"]
else :
self.nomsTitulaires = "nom inconnu"
# Type
if self.typeTypeCotisation == "famille" :
self.typeStr = _(u"Cotisation familiale")
else:
self.typeStr = _(u"Cotisation individuelle")
# Validité
dateDuJour = datetime.date.today()
if dateDuJour >= self.date_debut and dateDuJour <= self.date_fin :
self.valide = True
else:
self.valide = False
# Dépôt
if self.IDdepot_cotisation == None :
self.depotStr = _(u"Non déposée")
else:
self.depotStr = _(u"Dépôt n°%d") % self.IDdepot_cotisation
# Nom des titulaires de famille
self.beneficiaires = ""
self.rue = ""
self.cp = ""
self.ville = ""
if self.IDfamille != None :
self.beneficiaires = _(u"IDfamille n°%d") % self.IDfamille
if parent.dictFamillesRattachees != None :
if parent.dictFamillesRattachees.has_key(self.IDfamille) :
self.beneficiaires = parent.dictFamillesRattachees[self.IDfamille]["nomsTitulaires"]
else:
self.beneficiaires = parent.titulaires[self.IDfamille]["titulairesSansCivilite"]
self.rue = parent.titulaires[self.IDfamille]["adresse"]["rue"]
self.cp = parent.titulaires[self.IDfamille]["adresse"]["cp"]
self.ville = parent.titulaires[self.IDfamille]["adresse"]["ville"]
if self.IDindividu != None and parent.individus.has_key(self.IDindividu) :
self.beneficiaires = parent.individus[self.IDindividu]["nom_complet"]
self.rue = parent.individus[self.IDindividu]["rue"]
self.cp = parent.individus[self.IDindividu]["cp"]
self.ville = parent.individus[self.IDindividu]["ville"]
# Facturation
self.montant = 0.0
self.ventilation = 0.0
self.dateReglement = None
self.modeReglement = None
if dictFacturation.has_key(self.IDprestation):
self.montant = dictFacturation[self.IDprestation]["montant"]
self.ventilation = dictFacturation[self.IDprestation]["ventilation"]
self.dateReglement = dictFacturation[self.IDprestation]["dateReglement"]
self.modeReglement = dictFacturation[self.IDprestation]["modeReglement"]
self.solde = float(FloatToDecimal(self.montant) - FloatToDecimal(self.ventilation))
if self.solde > 0.0 :
self.solde = -self.solde
if self.montant == None :
self.solde = 0.0
def Importation(self):
DB = GestionDB.DB()
if len(self.listeActivites) == 0: conditionActivites = "()"
elif len(self.listeActivites) == 1: conditionActivites = "(%d)" % self.listeActivites[0]
else: conditionActivites = str(tuple(self.listeActivites))
if self.affichage_caisse:
conditionsCaisse = "AND aides.IDcaisse=%d" % self.affichage_caisse
else:
conditionsCaisse = ""
# Déductions
req = """SELECT
IDdeduction, deductions.IDprestation, deductions.IDcompte_payeur, deductions.date, deductions.montant, deductions.label, deductions.IDaide,
individus.nom, individus.prenom, individus.date_naiss,
prestations.label, prestations.montant, prestations.montant_initial, prestations.IDfamille, prestations.IDactivite, activites.abrege, prestations.IDindividu, prestations.date, prestations.IDfacture,
familles.IDcaisse, familles.num_allocataire, caisses.nom, aides.nom
FROM deductions
LEFT JOIN prestations ON prestations.IDprestation = deductions.IDprestation
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
LEFT JOIN familles ON familles.IDfamille = prestations.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN aides ON aides.IDaide = deductions.IDaide
WHERE deductions.date>='%s' AND deductions.date<='%s' AND prestations.IDactivite IN %s
%s;""" % (self.date_debut, self.date_fin, conditionActivites, conditionsCaisse)
DB.ExecuterReq(req)
listeDeductions = DB.ResultatReq()
DB.Close()
# Calcul des données
dictResultats = {}
listePrestations = []
for IDdeduction, IDprestation, IDcompte_payeur, date, montant, label, IDaide, nomIndividu, prenomIndividu, date_naiss, labelPrestation, montantPrestation, montantInitialPrestation, IDfamille, IDactivite, abregeActivite, IDindividu, datePrestation, IDfacture, IDcaisse, num_allocataire, nomCaisse, nomAide in listeDeductions:
date = UTILS_Dates.DateEngEnDateDD(date)
datePrestation = UTILS_Dates.DateEngEnDateDD(datePrestation)
date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss)
mois = date.month
annee = date.year
nom_complet_individu = u"%s %s" % (nomIndividu, prenomIndividu)
montantInitialPrestation = FloatToDecimal(montantInitialPrestation)
montant = FloatToDecimal(montant)
montantPrestation = FloatToDecimal(montantPrestation)
# Recherche du regroupement
try :
if self.affichage_regroupement == "jour" : regroupement = date
if self.affichage_regroupement == "mois" : regroupement = (annee, mois)
if self.affichage_regroupement == "annee" : regroupement = annee
if self.affichage_regroupement == "montant_deduction": regroupement = montant
if self.affichage_regroupement == "nom_aide" : regroupement = nomAide
if self.affichage_regroupement == "nom_deduction": regroupement = label
if self.affichage_regroupement == "ville_residence" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_VILLE"]
if self.affichage_regroupement == "secteur" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_SECTEUR"]
if self.affichage_regroupement == "famille" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM"]
if self.affichage_regroupement == "individu": regroupement = IDindividu
if self.affichage_regroupement == "regime" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_REGIME"]
if self.affichage_regroupement == "caisse" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_CAISSE"]
# QF
if self.affichage_regroupement == "qf" :
regroupement = None
qf = self.dictInfosFamilles[IDfamille]["FAMILLE_QF_ACTUEL_INT"]
for x in range(0, 10000, 100) :
min, max = x, x+99
if qf >= min and qf <= max :
regroupement = (min, max)
# Questionnaires
if self.affichage_regroupement.startswith("question_") and "famille" in self.affichage_regroupement:
regroupement = self.dictInfosFamilles[IDfamille]["QUESTION_%s" % self.affichage_regroupement[17:]]
except :
regroupement = None
if regroupement in ("", None):
regroupement = _(u"- Non renseigné -")
# Colonne
if labelPrestation not in listePrestations:
listePrestations.append(labelPrestation)
# Regroupement
if regroupement not in dictResultats:
dictResultats[regroupement] = {
"caisse": nomCaisse, "num_allocataire": num_allocataire, "prestations": {},
"montant_initial": FloatToDecimal(0), "montant_deduction": FloatToDecimal(0), "montant_final": FloatToDecimal(0),
"liste_dates": [], "individu": nom_complet_individu, "famille": self.dictInfosFamilles[IDfamille]["FAMILLE_NOM"],
}
dictResultats[regroupement]["montant_initial"] += montantInitialPrestation
dictResultats[regroupement]["montant_deduction"] += montant
dictResultats[regroupement]["montant_final"] += montantPrestation
if date not in dictResultats[regroupement]["liste_dates"]:
dictResultats[regroupement]["liste_dates"].append(date)
# Prestations
if labelPrestation not in dictResultats[regroupement]["prestations"]:
dictResultats[regroupement]["prestations"][labelPrestation] = {
"nbre": 0, "liste_dates": [], "montant_initial": montantInitialPrestation,
"montant_deduction": montant, "montant_final": montantPrestation,
}
dictResultats[regroupement]["prestations"][labelPrestation]["nbre"] += 1
if date not in dictResultats[regroupement]["prestations"][labelPrestation]["liste_dates"]:
dictResultats[regroupement]["prestations"][labelPrestation]["liste_dates"].append(date)
dictResultats[regroupement]["prestations"][labelPrestation]["montant_initial"] += montantInitialPrestation
dictResultats[regroupement]["prestations"][labelPrestation]["montant_deduction"] += montant
dictResultats[regroupement]["prestations"][labelPrestation]["montant_final"] += montantPrestation
return dictResultats, listePrestations
def OnBoutonFichier(self, event):
if self.ValidationSaisie() == False :
return
# Récupération des paramètres
tracks = self.ctrl_factures.GetTracksCoches()
date_emission = self.ctrl_date.GetDate()
code_col = self.ctrl_code_coll.GetValue()
code_nat = self.ctrl_code_nat.GetValue()
code_rec = self.ctrl_code_rec.GetValue()
exercice = self.ctrl_exercice.GetValue()
num_role = self.ctrl_num_role.GetValue()
listeLignes = []
for track in tracks :
if track.prelevement == True :
prelevement = True
prelevement_etab = track.prelevement_etab
prelevement_guichet = track.prelevement_guichet
prelevement_compte = track.prelevement_numero
prelevement_cle = track.prelevement_cle
prelevement_titulaire = track.prelevement_payeur
else :
prelevement = False
prelevement_etab = ""
prelevement_guichet = ""
prelevement_compte = ""
prelevement_cle = ""
prelevement_titulaire = ""
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""
dictDonnees = {
"ROLCOL" : code_col, # Code Collectivité
"ROLNAT" : code_nat, # Nature du rôle
"ROLEX" : exercice, # Exercice
"ROLREC" : code_rec, # Code Recette
"ROLROL" : num_role, # Numéro de rôle
"date_edition" : date_emission, # Date d'édition
"ROLDET" : track.numero, # Numéro de dette
"ROLEAU" : int(str(FloatToDecimal(-track.solde)).replace(".", "")), # Montant de la facture en centimes
"nom" : track.nomsTitulaires, # Nom du débiteur
"rue" : rue, # Rue de résidence du débiteur
"code_postal" : cp, # Code postal de la ville de résidence du débiteur
"ville" : ville, # Nom de la ville de résidence du débiteur
"objet" : _(u"Facture n°%s") % track.numero, # Objet de la recette (64 caract max)
"prelevement" : prelevement, # Activation du prélèvement
"prelevement_etab" : prelevement_etab, # Code établissement
"prelevement_guichet" : prelevement_guichet, # Code Guichet
"prelevement_compte" : prelevement_compte, # Numéro de compte
"prelevement_cle" : prelevement_cle, # Clé RIB
"prelevement_titulaire" : prelevement_titulaire, # Nom titulaire du compte
}
ligne = UTILS_Helios.GetLigne(dictDonnees)
listeLignes.append(ligne)
# Finalisation du texte
texte = "".join(listeLignes)
# Demande à l'utilisateur le nom de fichier et le répertoire de destination
nomFichier = "Rolmre.txt"
wildcard = "Fichier texte (*.txt)|*.txt|" \
"All files (*.*)|*.*"
sp = wx.StandardPaths.Get()
cheminDefaut = sp.GetDocumentsDir()
dlg = wx.FileDialog(
None, message = _(u"Veuillez sélectionner le répertoire de destination et le nom du fichier"), defaultDir=cheminDefaut,
defaultFile = nomFichier,
wildcard = wildcard,
style = wx.SAVE
)
dlg.SetFilterIndex(0)
if dlg.ShowModal() == wx.ID_OK:
cheminFichier = dlg.GetPath()
dlg.Destroy()
else:
dlg.Destroy()
return
# Le fichier de destination existe déjà :
if os.path.isfile(cheminFichier) == True :
dlg = wx.MessageDialog(None, _(u"Un fichier portant ce nom existe déjà. \n\nVoulez-vous le remplacer ?"), "Attention !", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_EXCLAMATION)
if dlg.ShowModal() == wx.ID_NO :
return False
dlg.Destroy()
else:
dlg.Destroy()
# Création du fichier texte
f = open(cheminFichier, "w")
f.write(texte.encode("iso-8859-15"))
f.close()
# Confirmation de création du fichier et demande d'ouverture directe dans Excel
txtMessage = _(u"Le fichier a été créé avec succès.\n\nSouhaitez-vous l'ouvrir dès maintenant ?")
dlgConfirm = wx.MessageDialog(None, txtMessage, _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.ICON_QUESTION)
reponse = dlgConfirm.ShowModal()
dlgConfirm.Destroy()
if reponse == wx.ID_NO:
return
else:
FonctionsPerso.LanceFichierExterne(cheminFichier)
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()
# 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()
# Traitement des données
listeListeView = []
for IDcompte_payeur, IDfamille in listeComptes:
if dictVentilations.has_key(IDcompte_payeur):
total_ventilations = FloatToDecimal(
dictVentilations[IDcompte_payeur])
else:
total_ventilations = FloatToDecimal(0.0)
if dictPrestations.has_key(IDcompte_payeur):
total_prestations = FloatToDecimal(
dictPrestations[IDcompte_payeur])
else:
total_prestations = FloatToDecimal(0.0)
if dictReglements.has_key(IDcompte_payeur):
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 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 dictVentilationsReglement.has_key(IDreglement) == False:
dictVentilationsReglement[IDreglement] = []
dictVentilationsReglement[IDreglement].append(IDventilation)
if dictVentilationsPrestation.has_key(IDprestation) == 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 dictVentilationsPrestation.has_key(IDprestation):
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 dictVentilationsReglement.has_key(IDreglement):
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 dictVentilationsPrestation.has_key(IDprestation):
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 dictVentilationsPrestation.has_key(IDprestation):
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 dictVentilationsReglement.has_key(
IDreglement) == False:
dictVentilationsReglement[IDreglement] = []
dictVentilationsReglement[IDreglement].append(
IDventilation)
if dictVentilationsPrestation.has_key(
IDprestation) == False:
dictVentilationsPrestation[IDprestation] = []
dictVentilationsPrestation[IDprestation].append(
IDventilation)
ResteAVentiler -= montant
credit -= montant
DB.Close()
return True
def GetTracks(self):
""" Récupération des données """
# Récupération des conditions
if len(self.listeActivites) == 0 : conditionActivites = "()"
elif len(self.listeActivites) == 1 : conditionActivites = "(%d)" % self.listeActivites[0]
else : conditionActivites = str(tuple(self.listeActivites))
if len(self.listeModes) == 0 : conditionModes = "()"
elif len(self.listeModes) == 1 : conditionModes = "(%d)" % self.listeModes[0]
else : conditionModes = str(tuple(self.listeModes))
if self.dateNaiss != None :
conditionDateNaiss = "AND individus.date_naiss >= '%s' " % self.dateNaiss
else:
conditionDateNaiss = ""
DB = GestionDB.DB()
# Recherche de la ventilation
req = """SELECT IDventilation, ventilation.IDreglement, IDprestation, ventilation.montant, reglements.IDmode
FROM ventilation
LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
WHERE reglements.IDmode IN %s
;""" % conditionModes
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDventilation, IDreglement, IDprestation, montant, IDmode in listeVentilation :
montant = FloatToDecimal(montant)
if dictVentilation.has_key(IDprestation) == False :
dictVentilation[IDprestation] = FloatToDecimal(0.0)
dictVentilation[IDprestation] += montant
# Recherche des prestations
## req = """SELECT prestations.label, prestations.IDactivite, activites.nom, COUNT(prestations.IDprestation), SUM(prestations.montant)
## FROM prestations
## LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
## LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
## WHERE prestations.IDactivite IN %s
## AND (prestations.date>='%s' AND prestations.date<='%s')
## AND prestations.categorie='consommation'
## %s
## GROUP BY prestations.label, prestations.IDactivite
## ;""" % (conditionActivites, self.date_debut, self.date_fin, conditionDateNaiss)
req = """SELECT prestations.IDprestation, prestations.label, prestations.IDactivite, activites.nom, prestations.montant,
prestations.IDcompte_payeur, prestations.IDfamille,
individus.IDindividu, individus.nom, individus.prenom, individus.date_naiss, individus.IDcivilite
FROM prestations
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
WHERE prestations.IDactivite IN %s AND individus.IDindividu IS NOT NULL
AND (prestations.date>='%s' AND prestations.date<='%s')
%s
;""" % (conditionActivites, self.date_debut, self.date_fin, conditionDateNaiss)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
DB.Close()
dictPrestations = {}
for IDprestation, label, IDactivite, nomActivite, montant, IDcompte_payeur, IDfamille, IDindividu, nom, prenom, date_naiss, IDcivilite in listePrestations :
valide = True
if self.dateNaiss != None :
if date_naiss < str(self.dateNaiss) :
valide = False
if valide == True :
montant = FloatToDecimal(montant)
if dictVentilation.has_key(IDprestation) :
regle = dictVentilation[IDprestation]
else :
regle = FloatToDecimal(0.0)
impaye = montant - regle
# Mémorisation
if dictPrestations.has_key(label) == False :
dictPrestations[label] = {
"nomActivite" : nomActivite, "IDactivite" : IDactivite,
"nbre_total" : 0, "montant_total" : FloatToDecimal(0.0),
"nbre_regle" : 0, "montant_regle" : FloatToDecimal(0.0),
"nbre_impaye" : 0, "montant_impaye" : FloatToDecimal(0.0),
"prestations" : [],
}
dictPrestations[label]["nbre_total"] += 1
dictPrestations[label]["montant_total"] += montant
dictPrestations[label]["montant_regle"] += regle
if regle > FloatToDecimal(0.0) :
dictPrestations[label]["nbre_regle"] += 1
dictPrestations[label]["montant_impaye"] += impaye
if impaye > FloatToDecimal(0.0) :
dictPrestations[label]["nbre_impaye"] += 1
dictPrestations[label]["prestations"].append({
"IDprestation" : IDprestation, "IDcompte_payeur" : IDcompte_payeur, "IDfamille" : IDfamille,
"IDindividu" : IDindividu, "nom" : nom, "prenom" : prenom, "date_naiss" : date_naiss, "IDcivilite" : IDcivilite,
"montant" : montant, "regle" : regle, "impaye" : impaye})
# Regroupement des prestations par label
listeListeView = []
for label, dictValeurs in dictPrestations.iteritems() :
track = Track(label, dictValeurs)
listeListeView.append(track)
return listeListeView
def GetImageVentilation(track):
if track.reste_a_ventiler > FloatToDecimal(0.0) :
return self.imgVentilation
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 (key in dictResultats) == 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 (key in dictResultats) == 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.items():
track = Track(self, dictTemp)
listeListeView.append(track)
return listeListeView
def Importation(date=None, afficherDebit=True, afficherCredit=True, afficherNul=True, afficherFactures=False):
DB = GestionDB.DB()
# Récupère les comptes payeurs
req = """SELECT IDcompte_payeur, IDfamille
FROM comptes_payeurs
ORDER BY IDcompte_payeur
;"""
DB.ExecuterReq(req)
listeComptes = DB.ResultatReq()
# Récupère la ventilation
req = """SELECT IDcompte_payeur, SUM(montant) AS total_ventilations
FROM ventilation
GROUP BY IDcompte_payeur
ORDER BY IDcompte_payeur
;"""
DB.ExecuterReq(req)
listeVentilations = DB.ResultatReq()
dictVentilations = {}
for IDcompte_payeur, total_ventilations in listeVentilations :
dictVentilations[IDcompte_payeur] = total_ventilations
# Récupère les prestations
if afficherFactures == True :
condition = "AND IDfacture IS NOT NULL"
else :
condition = ""
req = """SELECT IDcompte_payeur, SUM(montant) AS total_prestations
FROM prestations
WHERE date<='%s' %s
GROUP BY IDcompte_payeur
ORDER BY IDcompte_payeur
;""" % (date, condition)
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
WHERE date<='%s'
GROUP BY IDcompte_payeur
ORDER BY IDcompte_payeur
;""" % date
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(inclure_archives=True)
# 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)
# Calculs
solde = total_reglements - total_prestations
total_a_ventiler = min(total_reglements, total_prestations)
reste_a_ventiler = total_a_ventiler - total_ventilations
# Mémorisation
item = {"IDcompte_payeur" : IDcompte_payeur, "IDfamille" : IDfamille,
"total_ventilations" : total_ventilations, "total_reglements" : total_reglements,
"total_prestations" : total_prestations, "solde" : solde,
"total_a_ventiler" : total_a_ventiler, "reste_a_ventiler" : reste_a_ventiler}
track = Track(dictTitulaires, item)
valide = False
if afficherDebit == True and solde < FloatToDecimal(0.0) :
valide = True
if afficherCredit == True and solde > FloatToDecimal(0.0) :
valide = True
if afficherNul == True and solde == FloatToDecimal(0.0) :
valide = True
if valide == True :
listeListeView.append(track)
return listeListeView
def GetTracks(self):
listeListeView = []
if self.IDactivite == None:
return listeListeView
DB = GestionDB.DB()
conditions = []
# Condition Activité
if self.IDactivite != 0:
conditions.append("inscriptions.IDactivite=%d" % self.IDactivite)
# Condition Groupes
if self.listeGroupes != None:
if len(self.listeGroupes) == 0: conditionGroupes = "()"
elif len(self.listeGroupes) == 1:
conditionGroupes = "(%d)" % self.listeGroupes[0]
else:
conditionGroupes = str(tuple(self.listeGroupes))
conditions.append("inscriptions.IDgroupe IN %s" % conditionGroupes)
# Condition Catégories
if self.listeCategories != None:
if len(self.listeCategories) == 0: conditionCategories = "()"
elif len(self.listeCategories) == 1:
conditionCategories = "(%d)" % self.listeCategories[0]
else:
conditionCategories = str(tuple(self.listeCategories))
conditions.append("inscriptions.IDcategorie_tarif IN %s" %
conditionCategories)
# Condition Partis
if self.partis != True:
conditions.append(
"(inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s')"
% datetime.date.today())
# Infos sur tous les individus
GetDictInfosIndividus()
# Récupération de la facturation
dictFacturation = {}
# Récupère les prestations
condition = ("WHERE IDactivite=%d" %
self.IDactivite) if self.IDactivite != 0 else ""
req = """SELECT IDfamille, IDindividu, SUM(montant)
FROM prestations
%s
GROUP BY IDfamille, IDindividu
;""" % condition
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
for IDfamille, IDindividu, total_prestations in listePrestations:
if total_prestations == None:
total_prestations = 0.0
dictFacturation[(IDfamille, IDindividu)] = {
"prestations": total_prestations,
"ventilation": 0.0
}
# Récupère la ventilation
condition = ("WHERE prestations.IDactivite=%d" %
self.IDactivite) if self.IDactivite != 0 else ""
req = """SELECT IDfamille, IDindividu, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
%s
GROUP BY IDfamille, IDindividu
;""" % condition
DB.ExecuterReq(req)
listeVentilations = DB.ResultatReq()
for IDfamille, IDindividu, total_ventilation in listeVentilations:
if (IDfamille, IDindividu) in dictFacturation:
dictFacturation[(
IDfamille, IDindividu)]["ventilation"] = total_ventilation
# Récupération des données sur les individus
listeChamps2 = []
for dictChamp in LISTE_CHAMPS:
champ = dictChamp["champ"]
if champ != None:
listeChamps2.append(champ)
if len(conditions) > 0:
conditions = "AND " + " AND ".join(conditions)
else:
conditions = ""
req = """
SELECT %s
FROM inscriptions
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
LEFT JOIN activites ON activites.IDactivite = inscriptions.IDactivite
LEFT JOIN groupes ON groupes.IDgroupe = inscriptions.IDgroupe
LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif
LEFT JOIN categories_travail ON categories_travail.IDcategorie = individus.IDcategorie_travail
WHERE inscriptions.statut='ok' %s
GROUP BY individus.IDindividu, inscriptions.IDinscription
;""" % (",".join(listeChamps2), conditions)
# LEFT JOIN prestations ON prestations.IDactivite = inscriptions.IDactivite a été supprimé pour accélérer le traitement
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
for valeurs in listeDonnees:
dictTemp = {}
dictTemp["IDindividu"] = valeurs[0]
# Infos de la table Individus
index = 0
for dictChamp in LISTE_CHAMPS:
if dictChamp["champ"] != None:
code = dictChamp["code"]
dictTemp[code] = valeurs[index]
index += 1
# Infos sur la civilité
IDcivilite = dictTemp["IDcivilite"]
if IDcivilite == None:
IDcivilite = 1
dictTemp["genre"] = DICT_CIVILITES[IDcivilite]["sexe"]
dictTemp["categorieCivilite"] = DICT_CIVILITES[IDcivilite][
"categorie"]
dictTemp["civiliteLong"] = DICT_CIVILITES[IDcivilite][
"civiliteLong"]
dictTemp["civiliteAbrege"] = DICT_CIVILITES[IDcivilite][
"civiliteAbrege"]
dictTemp["nomImage"] = DICT_CIVILITES[IDcivilite]["nomImage"]
# Age
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
dictTemp["date_naiss"] = datenaissDD
# Nom Complet
nomComplet = dictTemp["nomIndividu"]
if dictTemp["prenomIndividu"] != None:
nomComplet += ", " + dictTemp["prenomIndividu"]
dictTemp["nomComplet"] = nomComplet
# Adresse auto ou manuelle
adresse_auto = dictTemp["adresse_auto"]
if adresse_auto != None and adresse_auto in DICT_INFOS_INDIVIDUS:
dictTemp["rue_resid"] = DICT_INFOS_INDIVIDUS[adresse_auto][
"rue_resid"]
dictTemp["cp_resid"] = DICT_INFOS_INDIVIDUS[adresse_auto][
"cp_resid"]
dictTemp["ville_resid"] = DICT_INFOS_INDIVIDUS[adresse_auto][
"ville_resid"]
# Facturation
totalFacture = FloatToDecimal(0.0)
totalRegle = FloatToDecimal(0.0)
totalSolde = FloatToDecimal(0.0)
key = (dictTemp["IDfamille"], dictTemp["IDindividu"])
if key in dictFacturation:
totalFacture = FloatToDecimal(
dictFacturation[key]["prestations"])
if totalFacture == None: totalFacture = FloatToDecimal(0.0)
totalRegle = FloatToDecimal(
dictFacturation[key]["ventilation"])
if totalRegle == None: totalRegle = FloatToDecimal(0.0)
totalSolde = totalFacture - totalRegle
dictTemp["totalFacture"] = totalFacture
dictTemp["totalRegle"] = totalRegle
dictTemp["totalSolde"] = totalSolde
# Famille
dictTemp["nomTitulaires"] = self.dict_titulaires[
dictTemp["IDfamille"]]["titulairesSansCivilite"]
# self.rue = listview.dict_titulaires[self.IDfamille]["adresse"]["rue"]
# self.cp = listview.dict_titulaires[self.IDfamille]["adresse"]["cp"]
# self.ville = listview.dict_titulaires[self.IDfamille]["adresse"]["ville"]
# Formatage sous forme de TRACK
track = Track(self, dictTemp)
listeListeView.append(track)
return listeListeView
def Importation(self, DBtemp=None):
""" Importation depuis la base """
dictValeurs = {}
# Lecture de la base
if DBtemp == None:
DB = GestionDB.DB()
else:
DB = DBtemp
# Informations générales sur le contrat
if self.IDcontrat != None:
req = """SELECT contrats.IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type,
duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning,
individus.nom, individus.prenom
FROM contrats
LEFT JOIN individus ON individus.IDindividu = contrats.IDindividu
WHERE IDcontrat=%d
;""" % self.IDcontrat
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type_contrat, duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning, individu_nom, individu_prenom = listeDonnees[
0]
self.IDinscription = IDinscription
dictValeurs["IDinscription"] = self.IDinscription
dictValeurs["date_debut"] = UTILS_Dates.DateEngEnDateDD(
date_debut)
dictValeurs["date_fin"] = UTILS_Dates.DateEngEnDateDD(date_fin)
dictValeurs["observations"] = observations
dictValeurs["IDactivite"] = IDactivite
dictValeurs["type_contrat"] = type_contrat
dictValeurs[
"duree_absences_prevues"] = UTILS_Dates.HeureStrEnDelta(
duree_absences_prevues)
dictValeurs[
"duree_heures_regularisation"] = UTILS_Dates.HeureStrEnDelta(
duree_heures_regularisation)
dictValeurs[
"duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta(
duree_tolerance_depassement)
dictValeurs["individu_nom"] = individu_nom
dictValeurs["individu_prenom"] = individu_prenom
dictValeurs["arrondi_type"] = arrondi_type
dictValeurs["arrondi_delta"] = arrondi_delta
dictValeurs["planning"] = planning
if individu_prenom != None:
dictValeurs["individu_nom_complet"] = u"%s %s" % (
individu_nom, individu_prenom)
else:
dictValeurs["individu_nom_complet"] = individu_nom
# Importation des données de l'inscription
if self.IDinscription != None:
req = """SELECT IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti
FROM inscriptions
WHERE IDinscription=%d
;""" % self.IDinscription
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti = listeDonnees[
0]
dictValeurs["IDinscription"] = self.IDinscription
dictValeurs["IDindividu"] = IDindividu
dictValeurs["IDfamille"] = IDfamille
dictValeurs["IDactivite"] = IDactivite
dictValeurs["IDgroupe"] = IDgroupe
dictValeurs["IDcategorie_tarif"] = IDcategorie_tarif
dictValeurs["IDcompte_payeur"] = IDcompte_payeur
dictValeurs["date_inscription"] = date_inscription
dictValeurs["parti"] = parti
# Infos sur le dernier contrat saisi
req = """SELECT arrondi_type, arrondi_delta, duree_tolerance_depassement
FROM contrats
WHERE type='psu' AND IDactivite=%d
ORDER BY IDcontrat DESC LIMIT 1
;""" % IDactivite
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
arrondi_type, arrondi_delta, duree_tolerance_depassement = listeDonnees[
0]
dictValeurs["arrondi_type"] = arrondi_type
dictValeurs["arrondi_delta"] = arrondi_delta
dictValeurs[
"duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta(
duree_tolerance_depassement)
# Informations sur l'activité
req = """SELECT psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt
FROM activites
WHERE IDactivite=%d
;""" % dictValeurs["IDactivite"]
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt = listeDonnees[
0]
dictValeurs["IDunite_prevision"] = psu_unite_prevision
dictValeurs["IDunite_presence"] = psu_unite_presence
dictValeurs["IDtarif"] = psu_tarif_forfait
dictValeurs["psu_etiquette_rtt"] = psu_etiquette_rtt
dictValeurs["duree_absences_prises"] = datetime.timedelta(0)
# Mémorise les données déjà importées
self.SetValeurs(dictValeurs)
# Echap sur nouveau contrat
if self.IDcontrat == None:
DB.Close()
return
# Lecture des consommations
req = """SELECT IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, verrouillage, date_saisie, IDutilisateur,
IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes
FROM consommations
WHERE IDinscription=%d AND date>='%s' AND date<='%s'
;""" % (self.IDinscription, dictValeurs["date_debut"],
dictValeurs["date_fin"])
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
tracks_previsions = []
liste_IDconso = []
liste_conso = []
dict_conso = {}
for IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, verrouillage, date_saisie, IDutilisateur, IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
date_saisie = UTILS_Dates.DateEngEnDateDD(date_saisie)
heure_debut_time = UTILS_Dates.HeureStrEnTime(heure_debut)
heure_fin_time = UTILS_Dates.HeureStrEnTime(heure_fin)
etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes)
dictConso = {
"IDconso": IDconso,
"date": date,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"etat": etat,
"verrouillage": verrouillage,
"date_saisie": date_saisie,
"IDutilisateur": IDutilisateur,
"IDcategorie_tarif": IDcategorie_tarif,
"IDprestation": IDprestation,
"forfait": forfait,
"quantite": quantite,
"etiquettes": etiquettes,
"heure_debut_time": heure_debut_time,
"heure_fin_time": heure_fin_time,
}
track = Track_conso(self, dictConso)
liste_conso.append(track)
if dict_conso.has_key(date) == False:
dict_conso[date] = []
dict_conso[date].append(track)
if IDunite == self.GetValeur("IDunite_prevision", None):
tracks_previsions.append(track)
liste_IDconso.append(IDconso)
if dictValeurs["psu_etiquette_rtt"] in etiquettes:
dictValeurs["duree_absences_prises"] += track.duree_arrondie
dictValeurs["liste_conso"] = liste_conso
dictValeurs["dict_conso"] = dict_conso
dictValeurs["tracks_previsions"] = tracks_previsions
dictValeurs["liste_IDconso"] = liste_IDconso
# Lecture des tarifs du contrat
req = """SELECT IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement
FROM contrats_tarifs
WHERE IDcontrat=%d
;""" % self.IDcontrat
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
tracks_tarifs = []
liste_IDtarif = []
for IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
dictTarif = {
"IDcontrat_tarif": IDcontrat_tarif,
"date_debut": date_debut,
"revenu": revenu,
"quotient": quotient,
"taux": taux,
"tarif_base": tarif_base,
"tarif_depassement": tarif_depassement,
}
tracks_tarifs.append(Track_tarif(dictTarif))
liste_IDtarif.append(IDcontrat_tarif)
dictValeurs["tracks_tarifs"] = tracks_tarifs
dictValeurs["liste_IDtarif"] = liste_IDtarif
# Lecture des mensualités
req = """SELECT IDprestation, date, label, montant_initial, prestations.montant, prestations.IDfacture, temps_facture,
forfait_date_debut, forfait_date_fin, factures.numero
FROM prestations
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
WHERE IDcontrat=%d
;""" % self.IDcontrat
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_prestations = []
liste_IDprestation = []
for IDprestation, date_facturation, label, montant_initial, montant, IDfacture, temps_facture, forfait_date_debut, forfait_date_fin, num_facture in listeDonnees:
date_facturation = UTILS_Dates.DateEngEnDateDD(date_facturation)
forfait_date_debut = UTILS_Dates.DateEngEnDateDD(
forfait_date_debut)
forfait_date_fin = UTILS_Dates.DateEngEnDateDD(forfait_date_fin)
montant_initial = FloatToDecimal(montant_initial)
montant = FloatToDecimal(montant)
temps_facture = UTILS_Dates.HeureStrEnDelta(temps_facture)
dictMensualite = {
"IDprestation": IDprestation,
"date_facturation": date_facturation,
"label": label,
"montant_initial": montant_initial,
"montant": montant,
"IDfacture": IDfacture,
"temps_facture": temps_facture,
"forfait_date_debut": forfait_date_debut,
"forfait_date_fin": forfait_date_fin,
"num_facture": num_facture,
}
liste_prestations.append(dictMensualite)
liste_IDprestation.append(IDprestation)
dictValeurs["liste_prestations"] = liste_prestations
dictValeurs["liste_IDprestation"] = liste_IDprestation
# Fermeture de la base
if DBtemp == None:
DB.Close()
# Mémorisation des données
self.SetValeurs(dictValeurs)
def FormateMontant(montant):
if montant in ("", None, FloatToDecimal(0.0)):
return ""
return u"%.2f %s" % (montant, SYMBOLE)
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 FormateMontant(montant):
if montant == None or montant == "" or montant == FloatToDecimal(
0.0):
return ""
return u"%.2f %s" % (montant, SYMBOLE)
def GetTotalRestePrestationsAVentiler(self):
total = FloatToDecimal(0.0)
for ligne in self.listeLignesPrestations :
total += ligne.resteAVentiler
return total
def GetTracks(self):
""" Récupération des données """
listePrestations = self.listePrestations
dictComptes = {}
for track in listePrestations:
# Recherche si un ajustement est demandé
ajustement = FloatToDecimal(0.0)
if track.ajustement not in ("", None):
ajustement = FloatToDecimal(float(track.ajustement))
for dictPrestation in track.listePrestations:
IDcompte_payeur = dictPrestation["IDcompte_payeur"]
IDfamille = dictPrestation["IDfamille"]
if dictComptes.has_key(IDcompte_payeur) == False:
# Récupération des infos sur la famille
dictInfosTitulaires = self.dictTitulaires[IDfamille]
rue_resid = dictInfosTitulaires["adresse"]["rue"]
cp_resid = dictInfosTitulaires["adresse"]["cp"]
if cp_resid == None: cp_resid = u""
ville_resid = dictInfosTitulaires["adresse"]["ville"]
if ville_resid == None: ville_resid = u""
dictComptes[IDcompte_payeur] = {
"IDcompte_payeur":
IDcompte_payeur,
"IDfamille":
IDfamille,
"nomsTitulairesAvecCivilite":
dictInfosTitulaires["titulairesAvecCivilite"],
"nomsTitulairesSansCivilite":
dictInfosTitulaires["titulairesSansCivilite"],
"rue_resid":
rue_resid,
"cp_resid":
cp_resid,
"ville_resid":
ville_resid,
"prestations": [],
"montant_total":
FloatToDecimal(0.0),
"montant_regle":
FloatToDecimal(0.0),
"montant_impaye":
FloatToDecimal(0.0)
}
dictPrestation = copy.deepcopy(dictPrestation)
# Applique les éventuels ajustements
montant = dictPrestation["montant"] + ajustement
if montant < FloatToDecimal(0.0):
montant = FloatToDecimal(0.0)
regle = dictPrestation["regle"] + ajustement
if regle < FloatToDecimal(0.0):
regle = FloatToDecimal(0.0)
impaye = montant - regle
if impaye < FloatToDecimal(0.0):
impaye = FloatToDecimal(0.0)
dictPrestation["montant"] = montant
dictPrestation["regle"] = regle
dictPrestation["impaye"] = impaye
# Mémorise les données
dictComptes[IDcompte_payeur]["prestations"].append(
dictPrestation)
dictComptes[IDcompte_payeur][
"montant_total"] += dictPrestation["montant"]
dictComptes[IDcompte_payeur][
"montant_regle"] += dictPrestation["regle"]
dictComptes[IDcompte_payeur][
"montant_impaye"] += dictPrestation["impaye"]
# Regroupement des prestations par label
listeListeView = []
for IDcompte_payeur, dictValeurs in dictComptes.iteritems():
track = Track(dictValeurs)
listeListeView.append(track)
return listeListeView
def MAJbarreInfos(self, total=FloatToDecimal(0.0), erreur=None):
self.total_ventilation = total
self.MAJinfos(erreur)
def FacturesErronees(self):
labelProbleme = _(u"Factures erronées")
labelCorrection = _(u"Recalculer le montant des factures")
# Recherche des factures
req = """SELECT factures.IDfacture, factures.numero, factures.IDcompte_payeur, comptes_payeurs.IDfamille,
factures.total, factures.regle, factures.solde
FROM factures
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur
LEFT JOIN familles ON familles.IDfamille = comptes_payeurs.IDfamille
WHERE factures.etat <> "annulation"
ORDER BY factures.date_edition;"""
self.DB.ExecuterReq(req)
listeFactures = self.DB.ResultatReq()
# Recherche des prestations
req = """SELECT IDprestation, montant, IDfacture
FROM prestations;"""
self.DB.ExecuterReq(req)
listePrestations = self.DB.ResultatReq()
dictPrestationsFacture = {}
for IDprestation, montant, IDfacture in listePrestations:
if (IDfacture in dictPrestationsFacture) == False:
dictPrestationsFacture[IDfacture] = []
dictPrestationsFacture[IDfacture].append({
"IDprestation":
IDprestation,
"montant":
FloatToDecimal(montant)
})
# Analyse
listeTemp = []
for IDfacture, numeroFacture, IDcompte_payeur, IDfamille, totalFacture, regleFacture, soldeFacture in listeFactures:
totalFacture = FloatToDecimal(totalFacture)
regleFacture = FloatToDecimal(regleFacture)
soldeFacture = FloatToDecimal(soldeFacture)
if IDfacture in dictPrestationsFacture:
listePrestationsFacture = dictPrestationsFacture[IDfacture]
else:
listePrestationsFacture = []
montantTotalPrestations = FloatToDecimal(0.0)
for dictTemp in listePrestationsFacture:
montantTotalPrestations += dictTemp["montant"]
if montantTotalPrestations != FloatToDecimal(totalFacture):
# Si la facture n'a pas de famille rattachée
if IDfamille == None:
label = _(u"Facture ID%d : Famille inconnue") % IDfacture
listeTemp.append(
FacturesAsupprimer(label=label, IDfacture=IDfacture))
elif len(listePrestationsFacture) == 0:
label = _(
u"Facture ID%d : Aucune prestation correspondante"
) % IDfacture
listeTemp.append(
FacturesAsupprimer(label=label, IDfacture=IDfacture))
elif montantTotalPrestations == FloatToDecimal(0.0):
label = _(
u"Facture ID%d : Montant de la facture égal à 0"
) % IDfacture
listeTemp.append(
FacturesAsupprimer(label=label, IDfacture=IDfacture))
else:
label = _(
u"Facture ID%d : Total à recalculer") % IDfacture
listeTemp.append(
FacturesRecalcul(
label=label,
IDfacture=IDfacture,
totalFacture=totalFacture,
regleFacture=regleFacture,
soldeFacture=soldeFacture,
montantTotalPrestations=montantTotalPrestations))
self.listeResultats.append((labelProbleme, labelCorrection, listeTemp))
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 self.dictRegroupements.has_key(key) == 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 GetTracks(self):
listeListeView = []
self.dictUnitesConso = {}
if self.date_debut == None or self.date_fin == None :
return listeListeView
# Récupération des données
DB = GestionDB.DB()
# Liste des inscrits
if len(self.categories_tarifs) == 0 : conditionCategorie = "inscriptions.IDcategorie_tarif=0"
elif len(self.categories_tarifs) == 1 : conditionCategorie = "inscriptions.IDcategorie_tarif=%d" % self.categories_tarifs[0]
else : conditionCategorie = "inscriptions.IDcategorie_tarif IN %s" % str(tuple(self.categories_tarifs))
req = """
SELECT
individus.IDindividu, individus.nom, individus.prenom, inscriptions.IDfamille, inscriptions.IDcompte_payeur, inscriptions.IDcategorie_tarif, categories_tarifs.nom
FROM inscriptions
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif
WHERE inscriptions.statut='ok' AND inscriptions.IDactivite=%d AND inscriptions.date_desinscription IS NULL AND %s
;""" % (self.IDactivite, conditionCategorie)
DB.ExecuterReq(req)
listeInscrits = DB.ResultatReq()
# Prestations
req = """
SELECT IDindividu, IDfamille, SUM(prestations.montant)
FROM prestations
WHERE date>='%s' AND date<='%s' AND IDactivite=%d AND categorie='consommation'
GROUP BY IDindividu, IDfamille
;""" % (self.date_debut, self.date_fin, self.IDactivite)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
dictPrestations = {}
for IDindividu, IDfamille, montant in listePrestations :
montant = FloatToDecimal(montant)
dictPrestations[(IDindividu, IDfamille)] = montant
# Consommations
req = """
SELECT
IDconso, consommations.IDindividu, comptes_payeurs.IDfamille, consommations.IDcompte_payeur, consommations.date, consommations.IDunite,
unites.nom, unites.abrege, unites.ordre
FROM consommations
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur
LEFT JOIN unites ON unites.IDunite = consommations.IDunite
WHERE consommations.date>='%s' AND consommations.date<='%s' AND consommations.IDactivite=%d
;""" % (self.date_debut, self.date_fin, self.IDactivite)
DB.ExecuterReq(req)
listeConso = DB.ResultatReq()
dictConso = {}
for IDconso, IDindividu, IDfamille, IDcompte_payeur, date, IDunite, nomUnite, abregeUnite, ordreUnite in listeConso :
# Mémorisation de l'unité de conso
if self.dictUnitesConso.has_key(IDunite) == False :
self.dictUnitesConso[IDunite] = {"nom" : nomUnite, "abrege" : abregeUnite, "ordre" : ordreUnite, "quantite" : 0}
self.dictUnitesConso[IDunite]["quantite"] += 1
# Mémorisation de la conso
key = (IDindividu, IDfamille)
if dictConso.has_key(key) == False :
dictConso[key] = {}
if dictConso[key].has_key(IDunite) == False :
dictConso[key][IDunite] = 0
dictConso[key][IDunite] += 1
DB.Close()
# Parcours les inscrits
for IDindividu, nom, prenom, IDfamille, IDcompte_payeur, IDcategorie_tarif, nomCategorieTarif in listeInscrits :
# Recherche les prestations
if dictPrestations.has_key((IDindividu, IDfamille)) :
montant = dictPrestations[(IDindividu, IDfamille)]
else :
montant = FloatToDecimal(0.0)
# Recherche les consommations
if dictConso.has_key((IDindividu, IDfamille)) :
dictConsoIndividu = dictConso[(IDindividu, IDfamille)]
else :
dictConsoIndividu = {}
# Mémorisation
dictTemp = {
"IDindividu" : IDindividu, "nom" : nom, "prenom" : prenom, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur,
"IDcategorie_tarif" : IDcategorie_tarif, "nomCategorieTarif" : nomCategorieTarif, "montant" : montant, "conso" : dictConsoIndividu,
}
track = Track(self, dictTemp)
listeListeView.append(track)
return listeListeView
def GetTotalVentile(self):
total = FloatToDecimal(0.0)
for ligne in self.listeLignesPrestations:
total += ligne.ventilationActuelle
return total
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),
]
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),
]
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)
