def Importation(self):
# Conditions Activités
if self.liste_activites == None:
conditionActivites = "IDactivite > 0"
else:
if len(self.liste_activites) == 0:
conditionActivites = "IDactivite IN ()"
elif len(self.liste_activites) == 1:
conditionActivites = "IDactivite=%d" % self.liste_activites[0]
else:
conditionActivites = "IDactivite IN %s" % str(
tuple(self.liste_activites))
# Importation des inscriptions en attente
DB = GestionDB.DB()
req = """
SELECT IDinscription, date_inscription, categories_tarifs.nom,
inscriptions.IDindividu, individus.nom, individus.prenom,
inscriptions.IDactivite, activites.nom, inscriptions.IDgroupe, groupes.nom,
inscriptions.IDcompte_payeur, inscriptions.IDfamille
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
WHERE inscriptions.statut='%s' AND inscriptions.%s
ORDER BY IDinscription
;""" % (self.mode, conditionActivites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictInscriptions = {}
dictGroupes = {}
for IDinscription, date_inscription, nomCategorie, IDindividu, nomIndividu, prenomIndividu, IDactivite, nomActivite, IDgroupe, nomGroupe, IDcompte_payeur, IDfamille in listeDonnees:
date_inscription = UTILS_Dates.DateEngEnDateDD(date_inscription)
if prenomIndividu == None: prenomIndividu = ""
nom_individu = u"%s %s" % (nomIndividu, prenomIndividu)
UTILS_Divers.DictionnaireImbrique(dictionnaire=dictInscriptions,
cles=[IDactivite, IDgroupe],
valeur=[])
dictTemp = {
"IDinscription": IDinscription,
"IDindividu": IDindividu,
"nom_individu": nom_individu,
"date_inscription": date_inscription,
"IDactivite": IDactivite,
"IDgroupe": IDgroupe,
"IDcompte_payeur": IDcompte_payeur,
"IDfamille": IDfamille,
"nomCategorie": nomCategorie,
}
dictInscriptions[IDactivite][IDgroupe].append(dictTemp)
# Mémorisation des groupes
if (IDgroupe in dictGroupes) == False:
dictGroupes[IDgroupe] = nomGroupe
# Recherche des places disponibles
# Recherche des inscriptions existantes
req = """SELECT IDgroupe, COUNT(IDinscription)
FROM inscriptions
WHERE inscriptions.%s AND inscriptions.statut='ok'
GROUP BY IDgroupe;""" % conditionActivites
DB.ExecuterReq(req)
listeInscriptions = DB.ResultatReq()
dictInscrits = {}
for IDgroupe, nbre_inscrits in listeInscriptions:
dictInscrits[IDgroupe] = nbre_inscrits
dictActivites = {}
req = """SELECT IDactivite, nom, abrege, date_debut, date_fin, nbre_inscrits_max
FROM activites
WHERE activites.%s;""" % conditionActivites
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
for IDactivite, nom, abrege, date_debut, date_fin, nbre_inscrits_max in listeActivites:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
dictActivites[IDactivite] = {
"nom": nom,
"abrege": abrege,
"date_debut": date_debut,
"date_fin": date_fin,
"nbre_inscrits_max": nbre_inscrits_max,
"groupes": {}
}
# Recherche des groupes
req = """SELECT IDgroupe, IDactivite, nom, nbre_inscrits_max
FROM groupes
WHERE groupes.%s
ORDER BY ordre;""" % conditionActivites
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
for IDgroupe, IDactivite, nom, nbre_inscrits_max in listeGroupes:
# Recherche le nombre d'inscrits sur chaque groupe
if IDgroupe in dictInscrits:
nbre_inscrits = dictInscrits[IDgroupe]
else:
nbre_inscrits = 0
# Recherche du nombre de places disponibles sur le groupe
if nbre_inscrits_max not in (None, 0):
nbre_places_disponibles = nbre_inscrits_max - nbre_inscrits
else:
nbre_places_disponibles = None
# Mémorise le groupe
dictActivites[IDactivite]["groupes"][IDgroupe] = {
"nom": nom,
"nbre_places_disponibles": nbre_places_disponibles,
"nbre_inscrits": nbre_inscrits,
"nbre_inscrits_max": nbre_inscrits_max
}
for IDactivite in list(dictActivites.keys()):
# Recherche le nombre d'inscrits total de l'activité
dictActivites[IDactivite]["nbre_inscrits"] = 0
for IDgroupe in dictActivites[IDactivite]["groupes"]:
if IDgroupe in dictInscrits:
dictActivites[IDactivite]["nbre_inscrits"] += dictInscrits[
IDgroupe]
# Recherche du nombre de places disponibles sur l'activité
if dictActivites[IDactivite]["nbre_inscrits_max"] not in (None, 0):
dictActivites[IDactivite][
"nbre_places_disponibles"] = dictActivites[IDactivite][
"nbre_inscrits_max"] - dictActivites[IDactivite][
"nbre_inscrits"]
else:
dictActivites[IDactivite]["nbre_places_disponibles"] = None
DB.Close()
return dictInscriptions, dictActivites, dictGroupes
def Importation(self):
""" Importation des données """
dictDonnees = {}
if self.IDmodele == None or self.date_debut == None or self.date_fin == None:
return dictDonnees
DB = GestionDB.DB()
# Modèle
req = """SELECT modeles_commandes.nom, modeles_commandes.IDrestaurateur, parametres,
restaurateurs.nom, restaurateurs.tel, restaurateurs.mail
FROM modeles_commandes
LEFT JOIN restaurateurs ON restaurateurs.IDrestaurateur = modeles_commandes.IDrestaurateur
WHERE IDmodele=%d;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
nom_modele, IDrestaurateur, parametres, restaurateur_nom, restaurateur_tel, restaurateur_mail = listeDonnees[
0]
if type(parametres) in (str, unicode):
exec(u"parametres = %s" % parametres)
dictDonnees["modele_nom"] = nom_modele
dictDonnees["modele_parametres"] = parametres
dictDonnees["IDrestaurateur"] = IDrestaurateur
dictDonnees["restaurateur_nom"] = restaurateur_nom
dictDonnees["restaurateur_tel"] = restaurateur_tel
dictDonnees["restaurateur_mail"] = restaurateur_mail
# Colonnes
req = """SELECT IDcolonne, ordre, nom, largeur, categorie, parametres
FROM modeles_commandes_colonnes
WHERE IDmodele=%d
ORDER BY ordre;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["liste_colonnes"] = []
dictDonnees["dict_colonnes"] = {}
if len(listeDonnees) > 0:
index = 0
for IDcolonne, ordre, nom_colonne, largeur, categorie, parametres in listeDonnees:
if type(parametres) in (str, unicode):
exec(u"parametres = %s" % parametres)
dictColonne = {
"IDcolonne": IDcolonne,
"ordre": ordre,
"nom_colonne": nom_colonne,
"largeur": largeur,
"categorie": categorie,
"parametres": parametres
}
dictDonnees["liste_colonnes"].append(dictColonne)
dictDonnees["dict_colonnes"][index] = dictColonne
index += 1
# Recherche les activités concernées
listeUnites = []
for dictColonne in dictDonnees["liste_colonnes"]:
if dictColonne["parametres"].has_key("unites"):
for (IDgroupe, IDunite) in dictColonne["parametres"]["unites"]:
if IDunite not in listeUnites:
listeUnites.append(IDunite)
if len(listeUnites) == 0: conditionUnites = "()"
elif len(listeUnites) == 1: conditionUnites = "(%d)" % listeUnites[0]
else: conditionUnites = str(tuple(listeUnites))
# Ouvertures
req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe, date
FROM ouvertures
WHERE date>='%s' AND date<='%s' AND IDunite IN %s;""" % (
self.date_debut, self.date_fin, conditionUnites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["liste_ouvertures"] = []
dictDonnees["dict_ouvertures"] = {}
dictDonnees["liste_dates"] = []
for IDouverture, IDactivite, IDunite, IDgroupe, date in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
dictOuverture = {
"IDouverture": IDouverture,
"IDactivite": IDactivite,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"date": date
}
dictDonnees["liste_ouvertures"].append(dictOuverture)
# Mémorisation dans un dict
dictDonnees["dict_ouvertures"] = UTILS_Divers.DictionnaireImbrique(
dictionnaire=dictDonnees["dict_ouvertures"],
cles=[date, IDgroupe, IDunite],
valeur=True)
# Mémorisation des dates
if date not in dictDonnees["liste_dates"]:
dictDonnees["liste_dates"].append(date)
dictDonnees["liste_dates"].sort()
dictDonnees["liste_dates"].append(_(u"Total"))
# Consommations
req = """SELECT IDconso, date, IDgroupe, IDunite, IDindividu
FROM consommations
WHERE date>='%s' AND date<='%s' AND IDunite IN %s AND consommations.etat IN ('reservation', 'present')
;""" % (self.date_debut, self.date_fin, conditionUnites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["dict_conso"] = {}
dictDonnees["liste_individus"] = []
dictDonnees["dict_dates"] = {}
for IDconso, date, IDgroupe, IDunite, IDindividu in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dictDonnees["dict_conso"].has_key(date) == False:
dictDonnees["dict_conso"][date] = {}
if dictDonnees["dict_conso"][date].has_key(IDgroupe) == False:
dictDonnees["dict_conso"][date][IDgroupe] = {}
if dictDonnees["dict_conso"][date][IDgroupe].has_key(
IDunite) == False:
dictDonnees["dict_conso"][date][IDgroupe][IDunite] = 0
dictDonnees["dict_conso"][date][IDgroupe][IDunite] += 1
if IDindividu not in dictDonnees["liste_individus"]:
dictDonnees["liste_individus"].append(IDindividu)
if dictDonnees["dict_dates"].has_key(date) == False:
dictDonnees["dict_dates"][date] = {}
if dictDonnees["dict_dates"][date].has_key(IDindividu) == False:
dictDonnees["dict_dates"][date][IDindividu] = []
if IDgroupe not in dictDonnees["dict_dates"][date][IDindividu]:
dictDonnees["dict_dates"][date][IDindividu].append(IDgroupe)
if len(dictDonnees["liste_individus"]) == 0: conditionIndividus = "()"
elif len(dictDonnees["liste_individus"]) == 1:
conditionIndividus = "(%d)" % dictDonnees["liste_individus"][0]
else:
conditionIndividus = str(tuple(dictDonnees["liste_individus"]))
# Informations médicales
req = """SELECT IDprobleme, problemes_sante.IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical,
description_traitement, date_debut_traitement, date_fin_traitement,
individus.nom, individus.prenom
FROM problemes_sante
LEFT JOIN individus ON individus.IDindividu = problemes_sante.IDindividu
WHERE diffusion_listing_repas=1 AND problemes_sante.IDindividu IN %s
;""" % conditionIndividus
DB.ExecuterReq(req)
listeInformations = DB.ResultatReq()
dictInfosMedicales = {}
for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, individu_nom, individu_prenom in listeInformations:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
if dictInfosMedicales.has_key(IDindividu) == False:
dictInfosMedicales[IDindividu] = []
dictTemp = {
"IDprobleme": IDprobleme,
"IDcategorie": IDtype,
"intitule": intitule,
"date_debut": date_debut,
"date_fin": date_fin,
"description": description,
"traitement_medical": traitement_medical,
"description_traitement": description_traitement,
"date_debut_traitement": date_debut_traitement,
"date_fin_traitement": date_fin_traitement,
"individu_nom": individu_nom,
"individu_prenom": individu_prenom,
}
dictInfosMedicales[IDindividu].append(dictTemp)
dictDonnees["infos_medicales"] = dictInfosMedicales
# Messages
req = """SELECT IDmessage, IDcategorie, priorite,
messages.IDindividu, texte, individus.nom, individus.prenom
FROM messages
LEFT JOIN individus ON individus.IDindividu = messages.IDindividu
WHERE afficher_commande=1 AND messages.IDindividu IN %s
;""" % conditionIndividus
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictMessages = {}
for IDmessage, IDcategorie, priorite, IDindividu, texte, individu_nom, individu_prenom in listeDonnees:
dictTemp = {
"IDmessage": IDmessage,
"IDindividu": IDindividu,
"priorite": priorite,
"texte": texte,
"individu_nom": individu_nom,
"individu_prenom": individu_prenom
}
if dictMessages.has_key(IDindividu) == False:
dictMessages[IDindividu] = []
dictMessages[IDindividu].append(dictTemp)
dictDonnees["messages"] = dictMessages
# Repas
dictDonnees["valeurs"] = {}
if self.IDcommande != None:
req = """SELECT IDvaleur, date, IDcolonne, valeur
FROM commandes_valeurs
WHERE IDcommande=%d
;""" % self.IDcommande
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDvaleur, date, IDcolonne, valeur in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dictDonnees["valeurs"].has_key(date) == False:
dictDonnees["valeurs"][date] = {}
dictDonnees["valeurs"][date][IDcolonne] = {
"IDvaleur": IDvaleur,
"valeur": valeur
}
# Menus
if dictDonnees.has_key("IDrestaurateur"):
IDrestaurateur = dictDonnees["IDrestaurateur"]
if IDrestaurateur == None:
IDrestaurateur = 0
else:
IDrestaurateur = 0
req = """SELECT IDmenu, menus.IDcategorie, menus_categories.nom, date, texte
FROM menus
LEFT JOIN menus_categories ON menus_categories.IDcategorie = menus.IDcategorie
WHERE date>='%s' AND date<='%s' AND IDrestaurateur=%d
ORDER BY menus_categories.ordre;""" % (self.date_debut, self.date_fin,
IDrestaurateur)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dict_menus = {}
for IDmenu, IDcategorie, nom_categorie, date, texte in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dict_menus.has_key(date) == False:
dict_menus[date] = []
dict_menus[date].append({
"IDmenu": IDmenu,
"IDcategorie": IDcategorie,
"nom_categorie": nom_categorie,
"texte": texte
})
dictDonnees["dict_menus"] = dict_menus
DB.Close()
return dictDonnees
