def GetListeDonnees(self):
self.dictDonnees = {}
if self.IDactivite == None:
return []
db = GestionDB.DB()
req = """SELECT IDmodele, modeles_contrats.nom, modeles_contrats.IDactivite, modeles_contrats.date_debut, modeles_contrats.date_fin, IDtarif, donnees
FROM modeles_contrats
LEFT JOIN activites ON activites.IDactivite = modeles_contrats.IDactivite
WHERE modeles_contrats.IDactivite=%d
ORDER BY modeles_contrats.date_debut;""" % self.IDactivite
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
listeItems = []
index = 0
for IDmodele, nom, IDactivite, date_debut, date_fin, IDtarif, donnees in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
donnees = cPickle.loads(str(donnees))
self.dictDonnees[index] = {
"ID": IDmodele,
"nom ": nom,
"IDactivite": IDactivite,
"date_debut": date_debut,
"date_fin": date_fin,
"IDtarif": IDtarif,
"donnees": donnees
}
label = _(u"%s - du %s au %s") % (
nom, UTILS_Dates.DateDDEnFr(date_debut),
UTILS_Dates.DateDDEnFr(date_fin))
listeItems.append(label)
index += 1
return listeItems
def Suite(self):
# Recherche des activites ressemblantes pour le recopiage de tarification
DB = GestionDB.DB()
req = """SELECT activites.IDactivite, activites.nom, activites.date_debut, activites.date_fin
FROM activites
LEFT JOIN tarifs ON tarifs.IDactivite = activites.IDactivite
WHERE type='FORFAIT' AND forfait_saisie_auto=1 AND forfait_suppression_auto=1 AND activites.date_debut IS NOT NULL and activites.date_fin IS NOT NULL
GROUP BY activites.IDactivite
ORDER BY activites.date_debut DESC;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) > 0:
liste_activites = [
(None, _(u"Non")),
]
for IDactivite, nom, date_debut, date_fin in listeDonnees:
if date_debut != None:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
if date_fin != None:
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
label = u"%s - Du %s au %s" % (
nom, UTILS_Dates.DateDDEnFr(date_debut),
UTILS_Dates.DateDDEnFr(date_fin))
liste_activites.append((IDactivite, label))
self.parent.dict_valeurs[
"activites_ressemblantes"] = liste_activites
return Page_recopier_tarifs
self.parent.dict_valeurs["recopier_tarifs"] = None
return Page_categories_tarifs
def Importation(self):
""" Importation """
# Condition dates
condition = " (deductions.date>='%s' and deductions.date<='%s') " % (self.date_debut, self.date_fin)
# Conditions Activités
if self.listeActivites == "toutes" or self.listeActivites == None :
conditionActivites = ""
else :
if len(self.listeActivites) == 0 : conditionActivites = "AND prestations.IDactivite IN ()"
elif len(self.listeActivites) == 1 : conditionActivites = "AND prestations.IDactivite IN (%d)" % self.listeActivites[0]
else : conditionActivites = "AND prestations.IDactivite IN %s" % str(tuple(self.listeActivites))
# Filtres
listeFiltres = []
texteFiltres = ""
if "consommation" in self.filtres :
listeFiltres.append("(prestations.categorie='consommation' %s)" % conditionActivites)
if "cotisation" in self.filtres :
listeFiltres.append("(prestations.categorie='cotisation')")
if "location" in self.filtres :
listeFiltres.append("(prestations.categorie='location')")
if "autre" in self.filtres :
listeFiltres.append("(prestations.categorie='autre')")
if len(listeFiltres) > 0 :
texteFiltres = "AND (%s)" % " OR ".join(listeFiltres)
else :
texteFiltres = " AND deductions.IDdeduction=0"
db = GestionDB.DB()
req = """SELECT
IDdeduction, deductions.IDprestation, deductions.IDcompte_payeur, deductions.date, deductions.montant, deductions.label, 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
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
WHERE %s %s;""" % (condition, texteFiltres)
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
listeDeductions = []
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 in listeDonnees :
date = UTILS_Dates.DateEngEnDateDD(date)
datePrestation = UTILS_Dates.DateEngEnDateDD(datePrestation)
date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss)
dictTemp = {
"IDdeduction" : IDdeduction, "IDprestation" : IDprestation, "IDcompte_payeur" : IDcompte_payeur,
"date" : date, "montant" : montant, "label" : label, "IDaide" : IDaide,
"nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "date_naiss" : date_naiss,
"labelPrestation" : labelPrestation, "montantPrestation" : montantPrestation, "montantInitialPrestation" : montantInitialPrestation,
"IDfamille" : IDfamille, "IDactivite" : IDactivite, "abregeActivite" : abregeActivite, "IDindividu" : IDindividu, "datePrestation" : datePrestation, "IDfacture" : IDfacture,
"IDcaisse" : IDcaisse, "num_allocataire" : num_allocataire, "nomCaisse" : nomCaisse,
}
listeDeductions.append(dictTemp)
return listeDeductions
def GetListeDonnees(self):
listeItems = [
_(u"Tous les exercices"),
]
self.dictDonnees = {
0: {
"ID": None,
"date_debut": None,
"date_fin": None
},
}
DB = GestionDB.DB()
req = """SELECT IDexercice, nom, date_debut, date_fin, defaut
FROM compta_exercices
ORDER BY date_debut; """
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
index = 1
for IDexercice, nom, date_debut, date_fin, defaut in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
self.dictDonnees[index] = {
"ID": IDexercice,
"date_debut": date_debut,
"date_fin": date_fin
}
label = nom
listeItems.append(label)
if defaut == 1:
self.IDdefaut = IDexercice
index += 1
return listeItems
def Importation_tarifs(self, IDcategorie_tarif=0):
if IDcategorie_tarif == None : return []
DB = GestionDB.DB()
# Recherche les tarifs
dictIndividus = {}
req = """SELECT IDtarif, tarifs.IDactivite,
tarifs.IDnom_tarif, noms_tarifs.nom,
date_debut, date_fin, methode, categories_tarifs, groupes
FROM tarifs
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
ORDER BY noms_tarifs.nom, date_debut;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeTarifs = []
for IDtarif, IDactivite, IDnom_tarif, nomTarif, date_debut, date_fin, methode, categories_tarifs, groupes in listeDonnees :
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
listeCategoriesTarifs = UTILS_Texte.ConvertStrToListe(categories_tarifs)
dictTemp = {
"IDtarif" : IDtarif, "IDactivite" : IDactivite,
"IDnom_tarif" : IDnom_tarif, "nomTarif" : nomTarif, "date_debut" : date_debut,
"date_fin" : date_fin, "methode" : methode, "categories_tarifs":categories_tarifs, "groupes":groupes,
}
if listeCategoriesTarifs != None :
if IDcategorie_tarif in listeCategoriesTarifs :
listeTarifs.append(dictTemp)
return listeTarifs
def SetListeDonnees(self):
self.listeNoms = [_(u"Toutes")]
self.listeID = [
None,
]
DB = GestionDB.DB()
req = """SELECT IDcontrat, date_debut, date_fin
FROM contrats;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
dictAnnees = {}
for IDcontrat, date_debut, date_fin in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
if (date_debut.year in dictAnnees) == False:
dictAnnees[date_debut.year] = 0
dictAnnees[date_debut.year] += 1
if (date_fin.year in dictAnnees) == False:
dictAnnees[date_fin.year] = 0
dictAnnees[date_fin.year] += 1
listeAnnees = list(dictAnnees.keys())
listeAnnees.sort()
for annee in listeAnnees:
nbreReglements = dictAnnees[annee]
#self.listeNoms.append(u"%s (%d)" % (annee, nbreReglements))
self.listeNoms.append(str(annee))
self.listeID.append(annee)
self.SetItems(self.listeNoms)
self.SetSelection(len(listeAnnees))
def Importation(self):
DB = GestionDB.DB()
req = """SELECT IDactivite, IDgroupe, IDcategorie_tarif, date_inscription, date_desinscription, statut
FROM inscriptions
WHERE IDinscription=%d;""" % self.IDinscription
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) > 0:
IDactivite, IDgroupe, IDcategorie_tarif, date_inscription, date_desinscription, statut = listeDonnees[
0]
self.SetIDactivite(IDactivite)
self.ctrl_groupes.SetID(IDgroupe)
self.IDgroupe = IDgroupe
self.ctrl_categories.SetID(IDcategorie_tarif)
self.date_inscription = UTILS_Dates.DateEngEnDateDD(
date_inscription)
if date_desinscription != None:
date_desinscription = UTILS_Dates.DateEngEnDateDD(
date_desinscription)
self.ctrl_check_depart.SetValue(True)
self.ctrl_date_depart.SetDate(date_desinscription)
if statut != None:
self.parent.parent.ctrl_statut.SetID(statut)
self.ancien_statut = statut
def __init__(self, parent, donnees):
self.parent = parent
self.IDconso = donnees[0]
self.date = UTILS_Dates.DateEngEnDateDD(donnees[1])
self.etat = donnees[2]
self.date_saisie = UTILS_Dates.DateEngEnDateDD(donnees[3])
self.quantite = donnees[4]
self.nom = donnees[5]
self.prenom = donnees[6]
self.nom_unite = donnees[7]
self.nom_activite = donnees[8]
self.nom_groupe = donnees[9]
self.IDfamille = donnees[10]
self.heure_debut = donnees[11]
self.heure_fin = donnees[12]
self.forfait = donnees[13]
self.nom_evenement = donnees[14]
self.IDprestation = donnees[15]
self.label_prestation = donnees[16]
self.montant_prestation = donnees[17]
# Récupération du nom des titulaires
try :
self.nomTitulaires = self.parent.dict_titulaires[self.IDfamille]["titulairesSansCivilite"]
except :
self.nomTitulaires = _(" ")
def Importation(self):
DB = GestionDB.DB()
req = """SELECT date_debut, date_fin, observations,
verrou_consommations, verrou_prestations, verrou_factures, verrou_reglements, verrou_depots, verrou_cotisations
FROM periodes_gestion WHERE IDperiode=%d;""" % self.IDperiode
DB.ExecuterReq(req)
listeTemp = DB.ResultatReq()
DB.Close()
if len(listeTemp) == 0: return
date_debut, date_fin, observations, verrou_consommations, verrou_prestations, verrou_factures, verrou_reglements, verrou_depots, verrou_cotisations = listeTemp[
0]
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
self.ctrl_date_debut.SetDate(date_debut)
self.ctrl_date_fin.SetDate(date_fin)
self.ctrl_observations.SetValue(observations)
# Verrous
liste_verrous = []
if verrou_consommations == 1: liste_verrous.append("consommations")
if verrou_prestations == 1: liste_verrous.append("prestations")
if verrou_factures == 1: liste_verrous.append("factures")
if verrou_reglements == 1: liste_verrous.append("reglements")
if verrou_depots == 1: liste_verrous.append("depots")
if verrou_cotisations == 1: liste_verrous.append("cotisations")
self.ctrl_verrou.SetCoches(liste_verrous)
def __init__(self, donnees):
self.IDperiode = donnees[0]
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[1])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[2])
self.observations = donnees[3]
self.verrou_consommations = donnees[4]
self.verrou_prestations = donnees[5]
self.verrou_factures = donnees[6]
self.verrou_reglements = donnees[7]
self.verrou_depots = donnees[8]
self.verrou_cotisations = donnees[9]
# Texte verrous
liste_categories = []
if self.verrou_consommations == 1:
liste_categories.append(_(u"consommations"))
if self.verrou_prestations == 1:
liste_categories.append(_(u"prestations"))
if self.verrou_factures == 1: liste_categories.append(_(u"factures"))
if self.verrou_reglements == 1:
liste_categories.append(_(u"règlements"))
if self.verrou_depots == 1: liste_categories.append(_(u"dépôts"))
if self.verrou_cotisations == 1:
liste_categories.append(_(u"cotisations"))
self.texte_verrous = ", ".join(liste_categories).capitalize()
def GetTexteDernierQF(self):
DB = GestionDB.DB()
req = """
SELECT date_debut, date_fin, quotient, revenu, types_quotients.nom
FROM quotients
LEFT JOIN types_quotients ON types_quotients.IDtype_quotient = quotients.IDtype_quotient
WHERE IDfamille=%d
ORDER BY date_fin DESC
""" % self.IDfamille
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
texte = _(u"Aucun précédent QF")
if len(listeDonnees) > 0:
date_debut, date_fin, quotient, revenu, nom_quotient = listeDonnees[
0]
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
if revenu == 0.0:
revenu = None
if quotient != None and revenu == None:
texte = _(u"Dernier quotient familial : %d du %s au %s (%s)"
) % (quotient, UTILS_Dates.DateDDEnFr(date_debut),
UTILS_Dates.DateDDEnFr(date_fin), nom_quotient)
elif quotient == None and revenu != None:
texte = _(u"Dernier revenu : %d du %s au %s (%s)") % (
revenu, UTILS_Dates.DateDDEnFr(date_debut),
UTILS_Dates.DateDDEnFr(date_fin), nom_quotient)
elif quotient != None and revenu != None:
texte = _(u"Dernier quotient/revenu : %s/%s du %s au %s (%s)"
) % (quotient, revenu,
UTILS_Dates.DateDDEnFr(date_debut),
UTILS_Dates.DateDDEnFr(date_fin), nom_quotient)
return texte
def GetTracks(self):
""" Récupération des données """
if self.IDmodele == None:
IDmodele = 0
else:
IDmodele = self.IDmodele
DB = GestionDB.DB()
req = """SELECT IDcommande, nom, date_debut, date_fin
FROM commandes
WHERE IDmodele=%d
ORDER BY date_debut;""" % IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeModeles = []
for IDcommande, nom, date_debut, date_fin in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
listeModeles.append({
"IDcommande": IDcommande,
"nom": nom,
"date_debut": date_debut,
"date_fin": date_fin
})
listeListeView = []
for item in listeModeles:
track = Track(item)
listeListeView.append(track)
return listeListeView
def GetTracks(self):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Lecture Actions
liste_conditions = []
if self.cacher_traitees == True:
liste_conditions.append("etat <> 'validation'")
if self.IDfamille != None:
liste_conditions.append("IDfamille=%d" % self.IDfamille)
if len(liste_conditions) > 0:
conditions = "WHERE %s" % " AND ".join(liste_conditions)
else:
conditions = ""
req = """SELECT IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, portail_actions.IDperiode, reponse, email_date,
portail_periodes.nom, portail_periodes.date_debut, portail_periodes.date_fin, portail_periodes.IDmodele
FROM portail_actions
LEFT JOIN portail_periodes ON portail_periodes.IDperiode = portail_actions.IDperiode
%s;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeActions = []
for IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, IDperiode, reponse, email_date, periode_nom, periode_date_debut, periode_date_fin, periode_IDmodele in listeDonnees:
traitement_date = UTILS_Dates.DateEngEnDateDD(traitement_date)
email_date = UTILS_Dates.DateEngEnDateDD(email_date)
horodatage = UTILS_Dates.DateEngEnDateDDT(horodatage)
periode_date_debut = UTILS_Dates.DateEngEnDateDD(
periode_date_debut)
periode_date_fin = UTILS_Dates.DateEngEnDateDD(periode_date_fin)
listeActions.append({
"IDaction": IDaction,
"horodatage": horodatage,
"IDfamille": IDfamille,
"IDindividu": IDindividu,
"categorie": categorie,
"action": action,
"description": description,
"commentaire": commentaire,
"parametres": parametres,
"etat": etat,
"traitement_date": traitement_date,
"IDperiode": IDperiode,
"reponse": reponse,
"email_date": email_date,
"periode_nom": periode_nom,
"periode_date_debut": periode_date_debut,
"periode_date_fin": periode_date_fin,
"periode_IDmodele": periode_IDmodele,
})
listeListeView = []
for action in listeActions:
listeListeView.append(Track(self, action, dictTitulaires))
return listeListeView
def GetDates(jours={}, date_min=None, date_max=None):
# Importation des vacances
DB = GestionDB.DB()
req = """SELECT date_debut, date_fin
FROM vacances
WHERE date_debut<='%s' AND date_fin>='%s'
ORDER BY date_debut;""" % (date_max, date_min)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeVacances = []
for date_debut, date_fin in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
listeVacances.append((date_debut, date_fin))
listeDates = []
for periode in ("scolaires", "vacances"):
liste_jours = ConvertNumEnDateutil(jours[periode])
if len(liste_jours) > 0:
listeDatesTemp = list(
rrule.rrule(rrule.WEEKLY,
wkst=rrule.MO,
byweekday=liste_jours,
dtstart=date_min,
until=date_max))
for date in listeDatesTemp:
date = date.date()
isVacances = IsVacances(listeVacances, date)
if periode == "scolaires" and isVacances == False:
listeDates.append(date)
if periode == "vacances" and isVacances == True:
listeDates.append(date)
listeDates.sort()
return listeDates
def __init__(self, donnees, dictTitulaires):
self.IDpiece = donnees[0]
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[1])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[2])
self.public = donnees[3]
self.nomPiece = donnees[4]
self.IDindividu = donnees[5]
self.IDfamille = donnees[6]
self.individu_nom = donnees[7]
self.individu_prenom = donnees[8]
# Nom Individu si pièce individuelle
if self.individu_prenom == None :
self.individu_nom_complet = self.individu_nom
else :
self.individu_nom_complet = u"%s %s" % (self.individu_nom, self.individu_prenom)
# Nom Famille si pièce familiale
if self.IDfamille != None :
self.nom_titulaires = dictTitulaires[self.IDfamille]["titulairesSansCivilite"]
else :
self.nom_titulaires = ""
# Type de pièce
if self.public == "famille" :
self.nomPublic = _(u"Familiale")
else :
self.nomPublic = _(u"Individuelle")
def GetTracks(self):
# Récupération des données
listeID = None
DB = GestionDB.DB()
req = """
SELECT
IDprestation, prestations.IDindividu, IDfamille, IDcompte_payeur, date, montant,
individus.nom, individus.prenom
FROM prestations
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
WHERE date>='%s' AND date<='%s' AND IDactivite=%d AND categorie='consommation'
GROUP BY IDprestation
;""" % (self.date_debut, self.date_fin, self.IDactivite)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Recherche également les consommations
req = """
SELECT IDconso, consommations.IDindividu, IDfamille, consommations.IDcompte_payeur, date,
individus.nom, individus.prenom
FROM consommations
LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur
WHERE date>='%s' AND date<='%s' AND IDactivite=%d
;""" % (self.date_debut, self.date_fin, self.IDactivite)
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
DB.Close()
dictResultats = {}
# Traitement des prestations
for IDprestation, IDindividu, IDfamille, IDcompte_payeur, date, montant, nomIndividu, prenomIndividu in listePrestations :
date = UTILS_Dates.DateEngEnDateDD(date)
montant = FloatToDecimal(montant)
key = (IDindividu, IDfamille)
if dictResultats.has_key(key) == False :
dictResultats[key] = {"IDindividu" : IDindividu, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "nbre_conso" : 0, "prestations" : [], "nbre_prestations" : 0, "montant" : FloatToDecimal(0.0)}
dictResultats[key]["prestations"].append({"IDprestation" : IDprestation, "montant" : montant})
dictResultats[key]["montant"] += montant
dictResultats[key]["nbre_prestations"] += 1
# Traitement des consommations
for IDconso, IDindividu, IDfamille, IDcompte_payeur, date, nomIndividu, prenomIndividu in listeConsommations :
date = UTILS_Dates.DateEngEnDateDD(date)
key = (IDindividu, IDfamille)
if dictResultats.has_key(key) == False :
dictResultats[key] = {"IDindividu" : IDindividu, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "nbre_conso" : 0, "prestations" : [], "nbre_prestations" : 0, "montant" : FloatToDecimal(0.0)}
dictResultats[key]["nbre_conso"] += 1
listeListeView = []
for key, dictTemp in dictResultats.iteritems() :
track = Track(self, dictTemp)
listeListeView.append(track)
return listeListeView
def __init__(self, donnees):
self.IDperiode = donnees[0]
self.IDactivite = donnees[1]
self.nom = donnees[2]
# Période
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[3])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[4])
self.periode = u"%s;%s" % (self.date_fin, self.date_debut)
# Affichage
self.affichage = bool(donnees[5])
self.affichage_date_debut = donnees[6]
if isinstance(self.affichage_date_debut, str) or isinstance(self.affichage_date_debut, unicode) :
self.affichage_date_debut = datetime.datetime.strptime(self.affichage_date_debut, "%Y-%m-%d %H:%M:%S")
self.affichage_date_fin = donnees[7]
if isinstance(self.affichage_date_fin, str) or isinstance(self.affichage_date_fin, unicode) :
self.affichage_date_fin = datetime.datetime.strptime(self.affichage_date_fin, "%Y-%m-%d %H:%M:%S")
if self.affichage == True :
if self.affichage_date_debut == None :
self.affichage_periode = True #_(u"Toujours afficher")
self.affichage_actuel = True
else :
self.affichage_periode = (self.affichage_date_fin, self.affichage_date_debut)
if self.affichage_date_debut <= datetime.datetime.now() and self.affichage_date_fin >= datetime.datetime.now() :
self.affichage_actuel = True
else :
self.affichage_actuel = False
else :
self.affichage_periode = False #_(u"Ne pas afficher")
self.affichage_actuel = False
def __init__(self, parent, donnees):
self.IDinscription = donnees[0]
self.IDindividu = donnees[1]
self.IDfamille = donnees[2]
self.IDactivite = donnees[3]
self.IDgroupe = donnees[4]
self.IDcategorie_tarif = donnees[5]
self.date_inscription = donnees[6]
self.nom_activite = donnees[7]
self.nom_groupe = donnees[8]
self.nom_categorie = donnees[9]
self.date_desinscription = UTILS_Dates.DateEngEnDateDD(donnees[10])
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[11])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[12])
self.psu_activation = donnees[13]
## self.logo_activite = donnees[13]
## self.bmp = self.GetImage()
# Nom des titulaires de famille
self.nomTitulaires = _(u"IDfamille n°%d") % self.IDfamille
if parent.dictFamillesRattachees != None:
if parent.dictFamillesRattachees.has_key(self.IDfamille):
self.nomTitulaires = parent.dictFamillesRattachees[
self.IDfamille]["nomsTitulaires"]
# Validité de la pièce
if (datetime.date.today() <= self.date_fin
and (self.date_desinscription is None
or self.date_desinscription >= datetime.date.today())):
self.valide = True
else:
self.valide = False
def Importation(self):
listeActivites = []
dictActivites = {}
if len(self.listePeriodes) == 0:
return listeActivites, dictActivites
# Condition Périodes
conditionsPeriodes = GetSQLdates(self.listePeriodes)
# Récupération des activités disponibles la période sélectionnée
DB = GestionDB.DB()
req = """SELECT activites.IDactivite, nom, abrege, date_debut, date_fin
FROM activites
LEFT JOIN ouvertures ON ouvertures.IDactivite = activites.IDactivite
WHERE %s
GROUP BY activites.IDactivite
ORDER BY date_fin DESC;""" % conditionsPeriodes
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
for IDactivite, nom, abrege, date_debut, date_fin in listeDonnees:
if date_debut != None:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
if date_fin != None:
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
dictTemp = {
"nom": nom,
"abrege": abrege,
"date_debut": date_debut,
"date_fin": date_fin,
"tarifs": {}
}
dictActivites[IDactivite] = dictTemp
listeActivites.append((nom, IDactivite))
listeActivites.sort()
return listeActivites, dictActivites
def Init_grille(self, ctrl_grille=None):
# Récupération des paramètres
IDactivite = int(self.dict_parametres["IDactivite"])
date_debut_periode = UTILS_Dates.DateEngEnDateDD(self.dict_parametres["date_debut_periode"])
date_fin_periode = UTILS_Dates.DateEngEnDateDD(self.dict_parametres["date_fin_periode"])
# Init de la grille des conso
ctrl_grille.InitGrille(IDindividu=self.track.IDindividu, IDfamille=self.track.IDfamille, IDactivite=IDactivite, periode=(date_debut_periode, date_fin_periode))
def Verification(self, categorie=None, donnees=None, silencieux=False):
liste_problemes = []
# Formate les données reçues
if type(donnees) in (datetime.date, str, unicode) :
listeDonnees = [{"date" : donnees},]
elif type(donnees) == dict :
listeDonnees = [donnees,]
elif donnees == None :
listeDonnees = []
else :
listeDonnees = donnees
if type(categorie) == list :
listeCategories = categorie
else:
listeCategories = [categorie,]
# Spécial consommations
if "consommations" in listeCategories :
listeCategories.append("prestations")
# Analyse des données
for donnees in listeDonnees :
# Recherche le format de la donnée
if type(donnees) == datetime.date:
date = donnees
elif type(donnees) in (str, unicode):
date = UTILS_Dates.DateEngEnDateDD(donnees)
elif type(donnees) == dict:
date = donnees["date"]
if type(date) in (str, unicode):
date = UTILS_Dates.DateEngEnDateDD(date)
# Vérifie que la date n'est pas dans une période de gestion
for periode in self.liste_periodes :
if date >= periode.date_debut and date <= periode.date_fin :
# Vérifie que la catégorie est verrouillée
verrou = False
for categorie in listeCategories:
if hasattr(periode, "verrou_%s" % categorie) :
if getattr(periode, "verrou_%s" % categorie) == 1 :
verrou = True
if verrou == True :
liste_problemes.append("- Probleme le " + str(date))
break
if len(liste_problemes) > 0 :
if silencieux == False :
dlg = DLG_Verrouillage(self.parent)#, liste_problemes=liste_problemes)
dlg.ShowModal()
dlg.Destroy()
return False
return True
def Importation(self):
dictActivites = {}
dictUnites = {}
# Conditions
conditions = []
if self.parent.check_repas.GetValue() == True:
conditions.append("AND unites.repas=1")
# Récupération des activités et des unités
DB = GestionDB.DB()
req = """SELECT
activites.IDactivite, activites.nom, activites.abrege, activites.date_debut, activites.date_fin,
groupes.IDgroupe, groupes.nom,
unites.IDunite, unites.nom, unites.ordre
FROM activites
LEFT JOIN groupes ON groupes.IDactivite = activites.IDactivite
LEFT JOIN unites ON unites.IDactivite = activites.IDactivite
WHERE unites.IDunite IS NOT NULL %s
GROUP BY groupes.IDgroupe, unites.IDunite
ORDER BY activites.date_fin, groupes.ordre, unites.ordre;""" % " ".join(
conditions)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
for IDactivite, nom, abrege, date_debut, date_fin, IDgroupe, nomGroupe, IDunite, nomUnite, ordreUnite in listeDonnees:
if date_debut != None:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
if date_fin != None:
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
# Mémorisation de l'activité, du groupe et de l'unité
if (IDactivite in dictActivites) == False:
dictActivites[IDactivite] = {
"nom": nom,
"abrege": abrege,
"date_debut": date_debut,
"date_fin": date_fin,
"groupes": {}
}
if (IDgroupe in dictActivites[IDactivite]["groupes"]) == False:
dictActivites[IDactivite]["groupes"][IDgroupe] = {
"IDgroupe": IDgroupe,
"nom": nomGroupe,
"unites": []
}
dictActivites[IDactivite]["groupes"][IDgroupe]["unites"].append({
"IDunite":
IDunite,
"nom":
nomUnite,
"ordre":
ordreUnite
})
return dictActivites, dictUnites
def Importation(self):
if self.IDactivite == None:
return []
DB = GestionDB.DB()
# Recherche des catégories de tarifs
dictCategoriesTarifs = {}
req = """SELECT IDcategorie_tarif, nom
FROM categories_tarifs;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDcategorie_tarif, nom in listeDonnees:
dictCategoriesTarifs[IDcategorie_tarif] = nom
# Recherche les tarifs
dictIndividus = {}
req = """SELECT IDtarif, tarifs.IDactivite,
tarifs.IDnom_tarif, noms_tarifs.nom,
date_debut, date_fin, methode, categories_tarifs, groupes, description
FROM tarifs
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
WHERE type='CREDIT' AND forfait_beneficiaire='individu' AND tarifs.IDactivite=%d
ORDER BY noms_tarifs.nom, date_debut;""" % self.IDactivite
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeTarifs = []
for IDtarif, IDactivite, IDnom_tarif, nomTarif, date_debut, date_fin, methode, categories_tarifs, groupes, description in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
listeCategoriesTarifs = ConvertStrToListe(categories_tarifs)
listeNomsCategories = []
for IDcategorie_tarif in listeCategoriesTarifs:
nomCategorieTarif = _(u"Categorie de tarif inconnue")
if dictCategoriesTarifs.has_key(IDcategorie_tarif):
nomCategorieTarif = dictCategoriesTarifs[IDcategorie_tarif]
listeNomsCategories.append(nomCategorieTarif)
dictTemp = {
"IDtarif": IDtarif,
"IDactivite": IDactivite,
"IDnom_tarif": IDnom_tarif,
"nomTarif": nomTarif,
"date_debut": date_debut,
"date_fin": date_fin,
"methode": methode,
"categories_tarifs": categories_tarifs,
"groupes": groupes,
"listeNomsCategories": listeNomsCategories,
"nomPrecisTarif": description,
"listeCategoriesTarifs": listeCategoriesTarifs,
}
listeTarifs.append(dictTemp)
return listeTarifs
def __init__(self, donnees):
self.IDperiode = donnees[0]
self.IDactivite = donnees[1]
self.nom = donnees[2]
# Période
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[3])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[4])
self.periode = u"%s;%s" % (self.date_fin, self.date_debut)
# Affichage
self.affichage = bool(donnees[5])
self.affichage_date_debut = donnees[6]
if isinstance(self.affichage_date_debut, str) or isinstance(
self.affichage_date_debut, six.text_type):
try:
self.affichage_date_debut = datetime.datetime.strptime(
self.affichage_date_debut, "%Y-%m-%d %H:%M:%S")
except:
temp = datetime.datetime.strptime(self.affichage_date_debut,
"%Y-%m-%d")
self.affichage_date_debut = datetime.datetime(year=temp.year,
month=temp.month,
day=temp.day,
hour=0,
minute=0)
self.affichage_date_fin = donnees[7]
if isinstance(self.affichage_date_fin, str) or isinstance(
self.affichage_date_fin, six.text_type):
try:
self.affichage_date_fin = datetime.datetime.strptime(
self.affichage_date_fin, "%Y-%m-%d %H:%M:%S")
except:
temp = datetime.datetime.strptime(self.affichage_date_fin,
"%Y-%m-%d")
self.affichage_date_fin = datetime.datetime(year=temp.year,
month=temp.month,
day=temp.day,
hour=23,
minute=59)
if self.affichage == True:
if self.affichage_date_debut == None:
self.affichage_periode = True #_(u"Toujours afficher")
self.affichage_actuel = True
else:
self.affichage_periode = (self.affichage_date_fin,
self.affichage_date_debut)
if self.affichage_date_debut <= datetime.datetime.now(
) and self.affichage_date_fin >= datetime.datetime.now():
self.affichage_actuel = True
else:
self.affichage_actuel = False
else:
self.affichage_periode = False #_(u"Ne pas afficher")
self.affichage_actuel = False
def GetQuotientsFamiliaux(self):
listeQF = []
DB = GestionDB.DB()
req = """SELECT IDquotient, IDfamille, date_debut, date_fin, quotient, IDtype_quotient
FROM quotients
WHERE IDfamille=%d
ORDER BY date_debut;""" % self.IDfamille
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
for IDquotient, IDfamille, date_debut, date_fin, quotient, IDtype_quotient in listeDonnees:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
listeQF.append((date_debut, date_fin, quotient, IDtype_quotient))
return listeQF
def GetPrelevementsMandats(self):
""" Récupère les prélèvements existants pour chaque mandat """
DB = GestionDB.DB()
# Prélèvements
req = """SELECT IDprelevement, IDfamille, IDmandat, statut, lots_prelevements.date
FROM prelevements
LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot
WHERE IDmandat IS NOT NULL
ORDER BY lots_prelevements.date
;"""
DB.ExecuterReq(req)
listePrelevements = DB.ResultatReq()
# Pièces PES ORMC
req = """SELECT IDpiece, IDfamille, prelevement_IDmandat, prelevement_statut, pes_lots.date_prelevement
FROM pes_pieces
LEFT JOIN pes_lots ON pes_lots.IDlot = pes_pieces.IDlot
WHERE prelevement_IDmandat IS NOT NULL AND prelevement=1
ORDER BY pes_lots.date_prelevement
;"""
DB.ExecuterReq(req)
listePieces = DB.ResultatReq()
DB.Close()
dictPrelevements = {}
for listeDonnees in (listePrelevements, listePieces) :
for IDprelevement, IDfamille, IDmandat, statut, date in listeDonnees :
date = UTILS_Dates.DateEngEnDateDD(date)
if (IDmandat in dictPrelevements) == False :
dictPrelevements[IDmandat] = []
dictPrelevements[IDmandat].append({"IDprelevement":IDprelevement, "IDfamille":IDfamille, "IDmandat":IDmandat, "statut":statut, "date":date})
return dictPrelevements
def SetListeDonnees(self):
self.listeNoms = [_(u"Toutes les années")]
self.listeID = [
None,
]
DB = GestionDB.DB()
req = """SELECT date, COUNT(IDconso)
FROM consommations
GROUP BY date
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
dictAnnees = {}
for date, nbre_conso in listeDonnees:
dateDD = UTILS_Dates.DateEngEnDateDD(date)
if dateDD != None:
if (dateDD.year in dictAnnees) == False:
dictAnnees[dateDD.year] = 0
dictAnnees[dateDD.year] += nbre_conso
listeAnnees = list(dictAnnees.keys())
listeAnnees.sort()
for annee in listeAnnees:
nbreConso = dictAnnees[annee]
self.listeNoms.append(u"%s (%d consommations)" %
(annee, nbreConso))
self.listeID.append(annee)
self.SetItems(self.listeNoms)
self.SetSelection(len(listeAnnees))
def SetListeDonnees(self):
self.listeNoms = [_(u"Toutes")]
self.listeID = [
None,
]
DB = GestionDB.DB()
req = """SELECT IDprestation, date
FROM prestations;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
dictAnnees = {}
for IDreglement, date in listeDonnees:
dateDD = UTILS_Dates.DateEngEnDateDD(date)
if dateDD != None:
if dictAnnees.has_key(dateDD.year) == False:
dictAnnees[dateDD.year] = 0
dictAnnees[dateDD.year] += 1
listeAnnees = dictAnnees.keys()
listeAnnees.sort()
for annee in listeAnnees:
nbreReglements = dictAnnees[annee]
#self.listeNoms.append(u"%s (%d)" % (annee, nbreReglements))
self.listeNoms.append(str(annee))
self.listeID.append(annee)
self.SetItems(self.listeNoms)
self.SetSelection(len(listeAnnees))
def Importation_depots(self):
""" Importation des données """
DB = GestionDB.DB()
if len(self.listeDepots) == 0 : conditionDepots = "()"
elif len(self.listeDepots) == 1 : conditionDepots = "(%d)" % self.listeDepots[0]
else : conditionDepots = str(tuple(self.listeDepots))
req = """SELECT depots.IDdepot, depots.date, nom, verrouillage, depots.IDcompte,
SUM(reglements.montant)
FROM depots
LEFT JOIN reglements ON reglements.IDdepot = depots.IDdepot
WHERE depots.IDdepot IN %s
GROUP BY depots.IDdepot
ORDER BY depots.date
;""" % conditionDepots
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDepots = {}
for IDdepot, date, nom, verrouillage, IDcompte, montantTotal in listeDonnees :
date = UTILS_Dates.DateEngEnDateDD(date)
if montantTotal == None : montantTotal = 0.0
dictDepots[IDdepot] = {"date":date, "nom":nom, "verrouillage":verrouillage, "IDcompte":IDcompte, "montantTotal":montantTotal}
DB.Close()
return dictDepots
def GetFacturesPrelevees(self):
""" Recherche si la facture est déjà présente dans un autre lot de prélèvement """
DB = GestionDB.DB()
req = """SELECT IDprelevement, prelevements.IDlot, IDfacture, statut, lots_prelevements.date, lots_prelevements.nom
FROM prelevements
LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
dictFacturesPrelevees = {}
for IDprelevement, IDlot, IDfacture, statut, datePrelevement, nomPrelevement in listeDonnees:
datePrelevement = UTILS_Dates.DateEngEnDateDD(datePrelevement)
if dictFacturesPrelevees.has_key(IDfacture) == False:
dictFacturesPrelevees[IDfacture] = []
dictFacturesPrelevees[IDfacture].append({
"IDprelevement":
IDprelevement,
"IDlot":
IDlot,
"statut":
statut,
"datePrelevement":
datePrelevement,
"nomPrelevement":
nomPrelevement
})
return dictFacturesPrelevees
