def Effacer_familles(self):
""" Effacer les familles """
# Sélection des individus
liste_individus = self.SelectionIndividus(
intro=_(u"Cochez les individus à effacer :"))
if liste_individus == False:
return False
# Demande de confirmation
dlg = wx.MessageDialog(
None,
_(u"Confirmez-vous l'effacement de %d fiches familles et de %d fiches individuelles ?\n\nAttention, cette action est irréversible !"
) % (len(self.liste_familles), len(liste_individus)),
_(u"Confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
# Attente
dlgAttente = wx.BusyInfo(
_(u"Veuillez patienter durant l'effacement..."), None)
# Récupère les comptes_payeurs
req = """SELECT IDfamille, IDcompte_payeur
FROM comptes_payeurs
WHERE IDfamille IN %s;""" % GestionDB.ConvertConditionChaine(
self.liste_familles)
self.DB.ExecuterReq(req)
listeDonnees = self.DB.ResultatReq()
liste_comptes_payeurs = []
for IDfamille, IDcompte_payeur in listeDonnees:
liste_comptes_payeurs.append(IDcompte_payeur)
# Familles
liste_valeurs = [
("IDcaisse", None),
("num_allocataire", None),
("allocataire", None),
("internet_actif", 0),
("memo", None),
("prelevement_activation", None),
("prelevement_etab", None),
("prelevement_guichet", None),
("prelevement_numero", None),
("prelevement_cle", None),
("prelevement_banque", None),
("prelevement_individu", None),
("prelevement_nom", None),
("prelevement_rue", None),
("prelevement_cp", None),
("prelevement_ville", None),
("prelevement_cle_iban", None),
("prelevement_iban", None),
("prelevement_bic", None),
("prelevement_reference_mandat", None),
("prelevement_date_mandat", None),
("prelevement_memo", None),
("email_factures", None),
("email_recus", None),
("email_depots", None),
("titulaire_helios", None),
("code_comptable", None),
("idtiers_helios", None),
("natidtiers_helios", None),
("reftiers_helios", None),
("cattiers_helios", None),
("natjur_helios", None),
("autorisation_cafpro", None),
("autre_adresse_facturation", None),
("etat", "efface"),
]
self.Modifier(listeID=self.liste_familles,
nom_table="familles",
champ_condition="IDfamille",
liste_valeurs=liste_valeurs)
# Historique
self.Supprimer(listeID=self.liste_familles,
nom_table="historique",
champ_condition="IDfamille")
# Liens
self.Supprimer(listeID=self.liste_familles,
nom_table="liens",
champ_condition="IDfamille")
# Messages
self.Supprimer(listeID=self.liste_familles,
nom_table="messages",
champ_condition="IDfamille")
# Payeurs
liste_valeurs = [
("nom", _(u"Payeur effacé")),
]
self.Modifier(listeID=liste_comptes_payeurs,
nom_table="payeurs",
champ_condition="IDcompte_payeur",
liste_valeurs=liste_valeurs)
# Pièces
self.Supprimer(listeID=self.liste_familles,
nom_table="pieces",
champ_condition="IDfamille")
# Questionnaires
self.Supprimer(listeID=self.liste_familles,
nom_table="questionnaire_reponses",
champ_condition="IDfamille")
# Quotients
self.Supprimer(listeID=self.liste_familles,
nom_table="quotients",
champ_condition="IDfamille")
# Rappels
self.Supprimer(listeID=liste_comptes_payeurs,
nom_table="rappels",
champ_condition="IDcompte_payeur")
# Rattachements
#self.Supprimer(listeID=self.liste_familles, nom_table="rattachements", champ_condition="IDfamille")
# Recus
self.Supprimer(listeID=self.liste_familles,
nom_table="recus",
champ_condition="IDfamille")
# Individus
self.Effacer_individus(liste_individus=liste_individus)
# Détruit dlgAttente
del dlgAttente
# Fin de procédure
dlg = wx.MessageDialog(None, _(u"L'effacement a été effectué !"),
_(u"Information"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
return True
def SelectionIndividus(self, intro=""):
# Récupère les individus
req = """SELECT IDindividu, nom, prenom
FROM individus;"""
self.DB.ExecuterReq(req)
listeDonnees = self.DB.ResultatReq()
dict_individus = {}
for IDindividu, nom, prenom in listeDonnees:
if prenom == None:
prenom = ""
nom_complet = u"%s %s" % (nom, prenom)
dict_individus[IDindividu] = {
"nom_complet": nom_complet,
"nom": nom,
"prenom": prenom
}
# Récupère les individus rattachés
req = """SELECT IDrattachement, IDindividu, IDfamille, IDcategorie
FROM rattachements;"""
self.DB.ExecuterReq(req)
listeDonnees = self.DB.ResultatReq()
dict_rattachements_familles = {}
dict_rattachements_individus = {}
liste_individus_concernes = []
for IDrattachement, IDindividu, IDfamille, IDcategorie in listeDonnees:
if dict_rattachements_familles.has_key(IDfamille) == False:
dict_rattachements_familles[IDfamille] = []
dict_rattachements_familles[IDfamille].append(
(IDindividu, IDcategorie))
if dict_rattachements_individus.has_key(IDindividu) == False:
dict_rattachements_individus[IDindividu] = []
dict_rattachements_individus[IDindividu].append(
(IDfamille, IDcategorie))
if (IDfamille in self.liste_familles
or IDindividu in self.liste_individus
) and IDindividu not in liste_individus_concernes:
liste_individus_concernes.append(IDindividu)
# Recherche les prestations futures
req = """SELECT IDindividu, IDfamille, COUNT(IDprestation)
FROM prestations
WHERE date>='%s' AND IDindividu IN %s
GROUP BY IDindividu, IDfamille;""" % (
datetime.date.today(),
GestionDB.ConvertConditionChaine(liste_individus_concernes))
self.DB.ExecuterReq(req)
listePrestations = self.DB.ResultatReq()
dictPrestations = {}
for IDindividu, IDfamille, nbrePrestations in listePrestations:
if nbrePrestations > 0:
dictPrestations[(IDindividu, IDfamille)] = nbrePrestations
# Variables
liste_familles_temp = []
liste_individus_temp = []
# Version FAMILLES
if self.liste_familles != []:
# Sélection des individus
for IDfamille in self.liste_familles:
nomTitulaires = self.dict_titulaires[IDfamille][
"titulairesSansCivilite"]
liste_rattaches = []
if dict_rattachements_familles.has_key(IDfamille):
for IDindividu, IDcategorie in dict_rattachements_familles[
IDfamille]:
nom_complet = dict_individus[IDindividu]["nom_complet"]
nom_categorie = GetNomCategorie(
IDcategorie).capitalize()
infos = []
# Recherche si l'individu est rattaché à d'autres familles non inclues
if dict_rattachements_individus.has_key(IDindividu):
for IDfamilleTemp, IDcategorieTemp in dict_rattachements_individus[
IDindividu]:
if IDfamilleTemp not in self.liste_familles:
infos.append(
_(u"Rattaché également à la famille de %s en tant que %s"
) %
(self.dict_titulaires[IDfamilleTemp]
["titulairesSansCivilite"],
GetNomCategorie(IDcategorieTemp)))
if dictPrestations.has_key((IDindividu, IDfamille)):
infos.append(
_(u"Des prestations futures sont déjà enregistrées"
))
liste_rattaches.append({
"IDcategorie": IDcategorie,
"nom_complet": nom_complet,
"IDindividu": IDindividu,
"nom_categorie": nom_categorie,
"infos": infos
})
liste_rattaches = sorted(
liste_rattaches,
key=operator.itemgetter("IDcategorie"))
liste_rattaches.sort()
liste_familles_temp.append({
"nomTitulaires": nomTitulaires,
"IDfamille": IDfamille,
"liste_rattaches": liste_rattaches
})
liste_familles_temp = sorted(
liste_familles_temp, key=operator.itemgetter("nomTitulaires"))
liste_familles_temp.sort()
# Version INDIVIDUS
if self.liste_individus != []:
# Sélection des individus
for IDindividu in self.liste_individus:
nom_complet = dict_individus[IDindividu]["nom_complet"]
liste_rattaches = []
if dict_rattachements_individus.has_key(IDindividu):
for IDfamille, IDcategorie in dict_rattachements_individus[
IDindividu]:
nomTitulaires = self.dict_titulaires[IDfamille][
"titulairesSansCivilite"]
nom_categorie = GetNomCategorie(
IDcategorie).capitalize()
infos = []
if dictPrestations.has_key((IDindividu, IDfamille)):
infos.append(
_(u"Des prestations futures sont déjà enregistrées"
))
liste_rattaches.append({
"IDcategorie": IDcategorie,
"nomTitulaires": nomTitulaires,
"IDfamille": IDfamille,
"nom_categorie": nom_categorie,
"infos": infos
})
liste_rattaches = sorted(
liste_rattaches,
key=operator.itemgetter("IDcategorie"))
liste_rattaches.sort()
liste_individus_temp.append({
"nom_complet": nom_complet,
"IDindividu": IDindividu,
"liste_rattaches": liste_rattaches
})
liste_individus_temp = sorted(
liste_individus_temp, key=operator.itemgetter("nom_complet"))
liste_individus_temp.sort()
# Affiche dlg de sélection
dlg = DLG_Selection(None,
intro=intro,
liste_familles=liste_familles_temp,
liste_individus=liste_individus_temp)
listeIndividusCoches = False
if dlg.ShowModal() == wx.ID_OK:
listeIndividusCoches = dlg.GetCoches()
dlg.Destroy()
return listeIndividusCoches
def Supprimer(self, listeID=[], nom_table="", champ_condition=""):
self.DB.ExecuterReq("DELETE FROM %s WHERE %s IN %s" %
(nom_table, champ_condition,
GestionDB.ConvertConditionChaine(listeID)))
self.DB.Commit()
def MAJ(self, forcerActualisation=False):
# Recherche des données
condition = ""
listeFiltreGroupesActivites = None
DB = GestionDB.DB()
# Recherche des paramètres
parametres = UTILS_Config.GetParametre("nbre_inscrits_parametre_activites", defaut=None)
if parametres != None :
code, liste = parametres.split("###")
if liste != "" :
listeID = []
for ID in liste.split(";") :
listeID.append(int(ID))
if code == "liste_groupes_activites" :
listeFiltreGroupesActivites = listeID
req = """SELECT IDtype_groupe_activite, IDactivite
FROM groupes_activites
WHERE IDtype_groupe_activite IN %s
;""" % GestionDB.ConvertConditionChaine(listeID)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActivites = []
for IDtype_groupe_activite, IDactivite in listeDonnees :
listeActivites.append(IDactivite)
condition = "WHERE activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(listeActivites)
if code == "liste_activites" :
condition = "WHERE activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(listeID)
# Tri
tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3)
if tri == 0 :
tri = "activites.nom"
elif tri == 1 :
tri = "activites.date_debut"
elif tri == 2 :
tri = "activites.date_fin"
elif tri == 3 :
tri = "activites.abrege"
else :
tri = "activites.nom"
# Sens
sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1)
if sens == 0 :
sens = ""
else :
sens = "DESC"
# Seuil d'alerte
self.seuil_alerte = UTILS_Config.GetParametre("nbre_inscrits_parametre_alerte", 5)
# Regroupement par groupe d'activités
self.regroupement_groupe_activites = UTILS_Config.GetParametre("nbre_inscrits_parametre_regroup", 0)
# Récupération des groupes
condition_partis = ""
if UTILS_Config.GetParametre("nbre_inscrits_parametre_partis", 1) == 1 :
if condition == "" :
condition_partis = "WHERE (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s'" % datetime.date.today()
else :
condition_partis = "AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s'" % datetime.date.today()
req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.abrege, groupes.nbre_inscrits_max,
COUNT(inscriptions.IDinscription) as nbre_inscriptions
FROM groupes
LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite
LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe
%s %s
GROUP BY groupes.IDgroupe
ORDER BY groupes.ordre
;""" % (condition, condition_partis)
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
dictGroupes = {}
for IDgroupe, IDactivite, nom, abrege, nbre_inscrits_max, nbre_inscrits in listeGroupes :
if nbre_inscrits == None : nbre_inscrits = 0
if nom == None : nom = _(u"Sans nom !")
if abrege == None : abrege = ""
if nbre_inscrits_max != None :
nbre_places_libres = nbre_inscrits_max - nbre_inscrits
else :
nbre_places_libres = None
if dictGroupes.has_key(IDactivite) == False :
dictGroupes[IDactivite] = []
dictGroupes[IDactivite].append({"IDgroupe" : IDgroupe, "nom" : nom, "abrege" : abrege, "nbre_inscrits_max" : nbre_inscrits_max, "nbre_inscrits" : nbre_inscrits, "nbre_places_libres" : nbre_places_libres, "IDactivite" : IDactivite})
# Récupération des activités
activite_ouverte = UTILS_Config.GetParametre("nbre_inscrits_parametre_ouvert", 1)
if activite_ouverte == 1 :
if condition == "" :
condition = "WHERE activites.date_fin>='%s'" % str(datetime.date.today())
else :
condition += " AND activites.date_fin>='%s'" % str(datetime.date.today())
req = """SELECT activites.IDactivite, activites.nom, activites.abrege, activites.nbre_inscrits_max
FROM activites
%s
GROUP BY activites.IDactivite
ORDER BY %s %s
;""" % (condition, tri, sens)
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
listeActivitesTemp = []
listeIDactivite = []
for IDactivite, nom, abrege, nbre_inscrits_max in listeActivites :
if nom == None : nom = _(u"Sans nom !")
if abrege == None : abrege = ""
liste_groupes = []
if dictGroupes.has_key(IDactivite) :
liste_groupes = dictGroupes[IDactivite]
nbre_inscrits = 0
liste_infos = [nom,]
for dictGroupe in liste_groupes :
nbre_inscrits += dictGroupe["nbre_inscrits"]
liste_infos.append(dictGroupe["nom"])
if nbre_inscrits_max != None :
nbre_places_libres = nbre_inscrits_max - nbre_inscrits
else :
nbre_places_libres = None
listeActivitesTemp.append({"IDactivite" : IDactivite, "nom" : nom, "abrege" : abrege, "nbre_inscrits_max" : nbre_inscrits_max, "nbre_inscrits" : nbre_inscrits, "nbre_places_libres" : nbre_places_libres, "liste_groupes" : liste_groupes, "infos" : " ".join(liste_infos)})
listeIDactivite.append(IDactivite)
# Pour éviter l'actualisation de l'affichage si aucune modification des données
if self.listeActivites != listeActivitesTemp or forcerActualisation == True :
self.listeActivites = listeActivitesTemp
else :
DB.Close()
return
# Récupération des groupes d'activités
if self.regroupement_groupe_activites == 1 :
req = """SELECT groupes_activites.IDtype_groupe_activite, nom, IDactivite
FROM groupes_activites
LEFT JOIN types_groupes_activites ON types_groupes_activites.IDtype_groupe_activite = groupes_activites.IDtype_groupe_activite
WHERE IDactivite IN %s
;""" % GestionDB.ConvertConditionChaine(listeIDactivite)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictGroupeParActivite = {}
dictGroupesActivites = {}
for IDtype_groupe_activite, nom, IDactivite in listeDonnees :
if not dictGroupeParActivite.has_key(IDactivite) :
dictGroupeParActivite[IDactivite] = []
dictGroupeParActivite[IDactivite].append(IDtype_groupe_activite)
if not dictGroupesActivites.has_key(IDtype_groupe_activite) :
dictGroupesActivites[IDtype_groupe_activite] = nom
liste_groupes_activites = []
for IDtype_groupe_activite, nom in dictGroupesActivites.iteritems() :
if listeFiltreGroupesActivites == None or IDtype_groupe_activite in listeFiltreGroupesActivites :
liste_groupes_activites.append((nom.upper(), IDtype_groupe_activite))
liste_groupes_activites.sort()
else :
liste_groupes_activites = [(None, None),]
DB.Close()
# MAJ du contrôle
self.DeleteChildren(self.root)
# Préparation pour impression
self.dictImpression["contenu"] = []
self.dictImpression["coloration"] = []
for nom, IDtype_groupe_activite in liste_groupes_activites :
if nom == None :
niveau_parent = self.root
else :
niveau_regroup = self.AppendItem(self.root, nom)
self.SetItemBackgroundColour(niveau_regroup, "#DDDDDD")
self.dictImpression["contenu"].append([nom,])
self.dictImpression["coloration"].append((len(self.dictImpression["contenu"])-1, "regroup"))
niveau_parent = niveau_regroup
for dictActivite in self.listeActivites :
if self.filtre == None or (self.filtre.lower() in dictActivite["infos"].lower()) :
IDactivite = dictActivite["IDactivite"]
if self.regroupement_groupe_activites == 0 or (self.regroupement_groupe_activites == 1 and dictGroupeParActivite.has_key(IDactivite) and IDtype_groupe_activite in dictGroupeParActivite[IDactivite]) :
# Ligne Activité
label = u" " + dictActivite["nom"]
niveau_activite = self.AppendItem(niveau_parent, label)
font = self.GetFont()
font.SetWeight(wx.BOLD)
self.SetItemFont(niveau_activite, font)
self.SetPyData(niveau_activite, dictActivite)
# Abrégé
self.SetItemText(niveau_activite, dictActivite["abrege"], 1)
# Valeurs
nbre_inscrits = dictActivite["nbre_inscrits"]
if nbre_inscrits == None :
texte_inscrits = ""
else :
texte_inscrits = str(nbre_inscrits)
self.SetItemText(niveau_activite, texte_inscrits, 2)
nbre_inscrits_max = dictActivite["nbre_inscrits_max"]
if nbre_inscrits_max == None :
texte_inscrits_max = ""
else :
texte_inscrits_max = str(nbre_inscrits_max)
self.SetItemText(niveau_activite, texte_inscrits_max, 3)
nbre_places_libres = dictActivite["nbre_places_libres"]
if nbre_places_libres == None :
texte_places_libres = ""
else :
texte_places_libres = str(nbre_places_libres)
self.SetItemText(niveau_activite, texte_places_libres, 4)
# Couleur de la ligne
couleur_fond = self.GetCouleurLigne(nbre_places_libres)
if couleur_fond != None :
self.SetItemBackgroundColour(niveau_activite, couleur_fond)
# Mémorisation ligne activité pour impression
self.dictImpression["contenu"].append([label, dictActivite["abrege"], texte_inscrits, texte_inscrits_max, texte_places_libres])
self.dictImpression["coloration"].append((len(self.dictImpression["contenu"])-1, "activite"))
# Ligne Groupe
for dictGroupe in dictActivite["liste_groupes"] :
label = u" " + dictGroupe["nom"]
niveau_groupe = self.AppendItem(niveau_activite, label)
self.SetPyData(niveau_groupe, dictGroupe)
# Abrégé
self.SetItemText(niveau_groupe, dictGroupe["abrege"], 1)
nbre_inscrits = dictGroupe["nbre_inscrits"]
if nbre_inscrits == None :
texte_inscrits = ""
else :
texte_inscrits = str(nbre_inscrits)
self.SetItemText(niveau_groupe, texte_inscrits, 2)
nbre_inscrits_max = dictGroupe["nbre_inscrits_max"]
if nbre_inscrits_max == None :
texte_inscrits_max = ""
else :
texte_inscrits_max = str(nbre_inscrits_max)
self.SetItemText(niveau_groupe, texte_inscrits_max, 3)
nbre_places_libres = dictGroupe["nbre_places_libres"]
if nbre_places_libres == None :
texte_places_libres = ""
else :
texte_places_libres = str(nbre_places_libres)
self.SetItemText(niveau_groupe, texte_places_libres, 4)
# Couleur de la ligne
couleur_fond = self.GetCouleurLigne(nbre_places_libres)
if couleur_fond != None :
self.SetItemBackgroundColour(niveau_groupe, couleur_fond)
# Mémorisation ligne activité pour impression
self.dictImpression["contenu"].append([u" %s" % label, dictGroupe["abrege"], texte_inscrits, texte_inscrits_max, texte_places_libres])
self.ExpandAllChildren(self.root)
def GetTracks(self):
""" Récupération des données """
# Récupération des données dans la base
listeChamps = ("individus.IDindividu", "IDcivilite", "nom", "prenom",
"num_secu", "IDnationalite", "date_naiss",
"IDpays_naiss", "cp_naiss", "ville_naiss",
"adresse_auto", "rue_resid", "cp_resid", "ville_resid",
"IDcategorie_travail", "profession", "employeur",
"travail_tel", "travail_fax", "travail_mail",
"tel_domicile", "tel_mobile", "tel_fax", "mail", "etat")
conditions = "etat IS NULL"
if "archives" in self.dictParametres and self.dictParametres[
"archives"] == True:
conditions += " OR etat='archive'"
if "effaces" in self.dictParametres and self.dictParametres[
"effaces"] == True:
conditions += " OR etat='efface'"
db = GestionDB.DB()
req = """SELECT %s FROM individus WHERE %s;""" % (
",".join(listeChamps), conditions)
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
# Récupération du dictionnaire des civilités
dictCivilites = Civilites.GetDictCivilites()
# Création du dictionnaire des données
dictIndividus = {}
for valeurs in listeDonnees:
IDindividu = valeurs[0]
dictTemp = {}
# Infos de la table Individus
for index in range(0, len(listeChamps)):
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
if dictTemp["IDcivilite"] != None and dictTemp["IDcivilite"] != "":
dictTemp["genre"] = dictCivilites[
dictTemp["IDcivilite"]]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[
dictTemp["IDcivilite"]]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[
dictTemp["IDcivilite"]]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[
dictTemp["IDcivilite"]]["civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[
dictTemp["IDcivilite"]]["nomImage"]
else:
dictTemp["genre"] = ""
dictTemp["categorieCivilite"] = ""
dictTemp["civiliteLong"] = ""
dictTemp["civiliteAbrege"] = ""
dictTemp["nomImage"] = None
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
try:
datenaissDD = UTILS_Dates.DateEngEnDateDD(
dictTemp["date_naiss"])
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
except:
dictTemp["age"] = None
dictIndividus[IDindividu] = dictTemp
# Vérifie si le dictIndividus est différent du précédent pour empêcher l'actualisation de la liste
if dictIndividus == self.dictIndividus and self.forceActualisation == False:
return None
else:
self.dictIndividus = dictIndividus
filtre = None
# Si filtre activités
if len(self.dictParametres["activites"]) > 0:
conditionActivites = GestionDB.ConvertConditionChaine(
self.dictParametres["activites"])
db = GestionDB.DB()
req = """SELECT individus.IDindividu, nom
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
WHERE inscriptions.statut='ok' AND inscriptions.IDactivite IN %s
;""" % conditionActivites
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
filtre = []
for ID, nom in listeDonnees:
filtre.append(ID)
# Si filtre Groupes d'activités
if len(self.dictParametres["groupes_activites"]) > 0:
conditionGroupesActivites = GestionDB.ConvertConditionChaine(
self.dictParametres["groupes_activites"])
db = GestionDB.DB()
req = """SELECT individus.IDindividu, nom
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
LEFT JOIN groupes_activites ON groupes_activites.IDactivite = inscriptions.IDactivite
WHERE inscriptions.statut='ok' AND groupes_activites.IDtype_groupe_activite IN %s
;""" % conditionGroupesActivites
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
filtre = []
for ID, nom in listeDonnees:
filtre.append(ID)
# Création des Tracks
listeListeView = []
self.dictTracks = {}
for IDindividu, dictTemp in dictIndividus.items():
if filtre == None or IDindividu in filtre:
track = Track(dictTemp, dictIndividus)
listeListeView.append(track)
self.dictTracks[IDindividu] = track
return listeListeView
def MAJ(self, forcerActualisation=False):
condition = ""
DB = GestionDB.DB()
# Recherche des paramètres
parametres = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_activites", defaut=None)
if parametres != None:
code, liste = parametres.split("###")
if liste != "":
listeID = []
for ID in liste.split(";"):
listeID.append(int(ID))
if code == "liste_groupes_activites":
req = """SELECT IDtype_groupe_activite, IDactivite
FROM groupes_activites
WHERE IDtype_groupe_activite IN %s
;""" % GestionDB.ConvertConditionChaine(listeID)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActivites = []
for IDtype_groupe_activite, IDactivite in listeDonnees:
listeActivites.append(IDactivite)
condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeActivites)
if code == "liste_activites":
condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeID)
# Tri
tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3)
if tri == 0:
tri = "activites.nom"
elif tri == 1:
tri = "activites.date_debut"
elif tri == 2:
tri = "activites.date_fin"
else:
tri = "activites.nom"
# Sens
sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1)
if sens == 0:
sens = ""
else:
sens = "DESC"
# Seuil d'alerte
self.seuil_alerte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_alerte", 5)
# Récupération des groupes
req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.nbre_inscrits_max,
COUNT(inscriptions.IDinscription) as nbre_inscriptions
FROM groupes
LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite
LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe
WHERE inscriptions.statut='ok' %s
GROUP BY groupes.IDgroupe
ORDER BY groupes.ordre
;""" % condition
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
dictGroupes = {}
for IDgroupe, IDactivite, nom, nbre_inscrits_max, nbre_inscrits in listeGroupes:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nbre_inscrits == None: nbre_inscrits = 0
if nom == None: nom = _(u"Sans nom !")
if (IDactivite in dictGroupes) == False:
dictGroupes[IDactivite] = []
dictGroupes[IDactivite].append({
"IDgroupe": IDgroupe,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"IDactivite": IDactivite
})
# Récupération des activités
activite_ouverte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_ouvert", 1)
if activite_ouverte == 1:
if condition == "":
condition = "WHERE activites.date_fin>='%s'" % str(
datetime.date.today())
else:
condition += " AND activites.date_fin>='%s'" % str(
datetime.date.today())
req = """SELECT activites.IDactivite, activites.nom, activites.nbre_inscrits_max
FROM activites
%s
GROUP BY activites.IDactivite
;""" % condition
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
DB.Close()
listeActivitesTemp = []
for IDactivite, nom, nbre_inscrits_max in listeActivites:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nom == None: nom = _(u"Sans nom !")
liste_groupes = []
if IDactivite in dictGroupes:
liste_groupes = dictGroupes[IDactivite]
nbre_inscrits = 0
liste_infos = [
nom,
]
for dictGroupe in liste_groupes:
nbre_inscrits += dictGroupe["nbre_inscrits"]
liste_infos.append(dictGroupe["nom"])
listeActivitesTemp.append({
"IDactivite": IDactivite,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"liste_groupes": liste_groupes,
"infos": " ".join(liste_infos)
})
# Pour éviter l'actualisation de l'affichage si aucune modification des données
if self.listeActivites != listeActivitesTemp or forcerActualisation == True:
self.listeActivites = listeActivitesTemp
else:
return
# MAJ du contrôle
self.Freeze()
self.DeleteAllItems()
self.dictRenderers = {}
index = 0
for dictActivite in self.listeActivites:
if self.filtre == None or (self.filtre.lower()
in dictActivite["infos"].lower()):
couleur_fond = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(214, 250, 199))
# Colonne Activité
label = u" " + dictActivite["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictActivite)
self.SetItemBackgroundColour(index, couleur_fond)
item = self.GetItem(index, 0)
font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
font.SetWeight(wx.BOLD)
item.SetFont(font)
self.SetItem(item)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="activite",
couleur_fond=couleur_fond,
nbre_inscrits=dictActivite["nbre_inscrits"],
nbre_inscrits_max=dictActivite["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
for dictGroupe in dictActivite["liste_groupes"]:
label = u" " + dictGroupe["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictGroupe)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="groupe",
nbre_inscrits=dictGroupe["nbre_inscrits"],
nbre_inscrits_max=dictGroupe["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
# Ajuste la taille des colonnes
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
self.SetColumnWidth(1, ULC.ULC_AUTOSIZE_FILL)
# Actualiser l'affichage pour éviter bug de positionnement
try:
self.DoLayout()
except:
pass
self.Thaw()
