def __init__(self, parent, IDpersonne=None):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.IDpersonne = IDpersonne
# Choix décoration
self.label_decoration = wx.StaticText(self, -1, _(u"Cadre de décoration :"), style=wx.ALIGN_RIGHT)
listeCadres = FonctionsPerso.GetListeCadresPhotos()
self.combobox_decoration = wx.Choice(self, -1, choices=listeCadres)
# Recherche du cadre de décoration attribué à la personne
cadrePhoto, textePhoto = CTRL_Photo.GetCadreEtTexte(self.IDpersonne)
if cadrePhoto != None and cadrePhoto != "" :
self.combobox_decoration.SetStringSelection(cadrePhoto)
else:
self.combobox_decoration.SetSelection(0)
# Saisie du texte personnalisé
self.label_texte_perso = wx.StaticText(self, -1, _(u"Texte personnalisé :"), style=wx.ALIGN_RIGHT)
self.texte_perso = wx.TextCtrl(self, -1, textePhoto)
# Layout
grid_sizer_base = wx.FlexGridSizer(rows=1, cols=4, vgap=10, hgap=10)
grid_sizer_base.Add(self.label_decoration, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 0)
grid_sizer_base.Add(self.combobox_decoration, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 0)
grid_sizer_base.Add(self.label_texte_perso, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 0)
grid_sizer_base.Add(self.texte_perso, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL|wx.EXPAND, 0)
grid_sizer_base.AddGrowableCol(3)
self.SetSizer(grid_sizer_base)
self.Layout()
# Binds
self.Bind(wx.EVT_CHOICE, self.OnChoixDecoration, self.combobox_decoration)
self.Bind(wx.EVT_TEXT, self.OnTextePerso, self.texte_perso)
def Initialisation(self):
# Importation des individus
listeActivites = self.interface.dictProcedure["parametres"][
"activites"]
if listeActivites != None:
if len(listeActivites) == 0: conditionActivites = "()"
elif len(listeActivites) == 1:
conditionActivites = "(%d)" % listeActivites[0]
else:
conditionActivites = str(tuple(listeActivites))
req = """SELECT individus.IDindividu, IDcivilite, nom, prenom
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
WHERE inscriptions.statut='ok' AND inscriptions.IDactivite IN %s
AND (date_desinscription IS NULL OR date_desinscription>='%s')
GROUP BY individus.IDindividu
ORDER BY nom, prenom;""" % (conditionActivites,
self.interface.date)
else:
req = """SELECT IDindividu, IDcivilite, nom, prenom FROM individus ORDER BY nom, prenom;"""
DB = GestionDB.DB()
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
DB.Close()
# liste images
self.dictPhotos = {}
taillePhoto = 64
il = wx.ImageList(taillePhoto, taillePhoto, True)
for IDindividu, IDcivilite, nom, prenom in listeIndividus:
nomFichier = Chemins.GetStaticPath(
"Images/128x128/%s" % DICT_CIVILITES[IDcivilite]["nomImage"])
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu,
nomFichier=nomFichier,
taillePhoto=(taillePhoto,
taillePhoto),
qualite=100)
img = il.Add(bmp)
self.dictPhotos[IDindividu] = img
self.AssignImageList(il, wx.IMAGE_LIST_SMALL)
self.InsertColumn(0,
_(u"Nom de l'individu"),
width=400,
format=ULC.ULC_FORMAT_LEFT)
# Création des items
index = 0
for IDindividu, IDcivilite, nom, prenom in listeIndividus:
label = u" %s %s" % (nom, prenom)
self.InsertImageStringItem(index, label,
self.dictPhotos[IDindividu])
self.SetItemData(index, IDindividu)
self.SetItemFont(index, wx.Font(12, wx.SWISS, wx.NORMAL,
wx.NORMAL))
index += 1
self.Bind(ULC.EVT_LIST_ITEM_ACTIVATED, self.Valider)
def __init__(self, parent):
wx.Panel.__init__(self, parent, -1, name="panel_resume")
self.parent = parent
self.barreTitre_resume = FonctionsPerso.BarreTitre(
self, _(u"Détail de la sélection"),
_(u"Détail de la sélection"))
# Contrôles
self.bitmap_photo = CTRL_Photo.CTRL_Photo(self, style=wx.SUNKEN_BORDER)
self.bitmap_photo.SetPhoto(
IDindividu=None,
nomFichier=Chemins.GetStaticPath("Images/128x128/Personne.png"),
taillePhoto=(128, 128))
self.resume_L1 = wx.StaticText(self, -1, "")
self.resume_L2 = wx.StaticText(self, -1, "")
self.resume_L3 = wx.StaticText(self, -1, "")
self.resume_L4 = wx.StaticText(self, -1, "")
self.resume_L5 = wx.StaticText(self, -1, "")
self.resume_L6 = wx.StaticText(self, -1, "")
#self.tree_ctrl_resume = TreeCtrlCategories(self)
# Propriétés
self.SetBackgroundColour((214, 223, 247))
self.resume_L1.SetFont(
wx.Font(14, wx.DEFAULT, wx.NORMAL, wx.BOLD, 0, ""))
# Layout
grid_sizer_base = wx.FlexGridSizer(rows=2, cols=1, vgap=0, hgap=0)
grid_sizer_base.Add(self.barreTitre_resume, 0, wx.EXPAND, 0)
grid_sizer_resume = wx.FlexGridSizer(rows=1, cols=3, vgap=0, hgap=0)
grid_sizer_texte = wx.FlexGridSizer(rows=9, cols=1, vgap=0, hgap=0)
grid_sizer_resume.Add(self.bitmap_photo, 0, wx.ALL | wx.EXPAND, 10)
grid_sizer_texte.Add(self.resume_L1, 0, 0, 0)
grid_sizer_texte.Add((5, 5), 0, wx.EXPAND, 0)
grid_sizer_texte.Add(self.resume_L2, 0, 0, 0)
grid_sizer_texte.Add((5, 5), 0, wx.EXPAND, 0)
grid_sizer_texte.Add(self.resume_L3, 0, 0, 0)
grid_sizer_texte.Add(self.resume_L4, 0, 0, 0)
grid_sizer_texte.Add((5, 5), 0, wx.EXPAND, 0)
grid_sizer_texte.Add(self.resume_L5, 0, 0, 0)
grid_sizer_texte.Add(self.resume_L6, 0, 0, 0)
grid_sizer_resume.Add(grid_sizer_texte, 1, wx.ALL | wx.EXPAND, 10)
#grid_sizer_resume.Add(self.tree_ctrl_resume, 1, wx.ALL|wx.EXPAND, 10)
grid_sizer_resume.AddGrowableCol(1)
grid_sizer_base.Add(grid_sizer_resume, 0, wx.EXPAND, 0)
grid_sizer_base.AddGrowableRow(1)
grid_sizer_base.AddGrowableCol(0)
self.SetSizer(grid_sizer_base)
self.Bind(wx.EVT_SIZE, self.OnSize)
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.MAXIMIZE_BOX
| wx.MINIMIZE_BOX)
self.parent = parent
self.dictDonnees = {}
# Nom
self.staticbox_generalites_staticbox = wx.StaticBox(
self, -1, _(u"Généralités"))
self.label_nom = wx.StaticText(self, -1, _(u"Nom de l'individu :"))
self.ctrl_nom = wx.TextCtrl(self, -1, "")
self.ctrl_nom.SetMinSize((200, -1))
self.label_description = wx.StaticText(self, -1, _(u"Description :"))
self.ctrl_description = wx.TextCtrl(self, -1, "")
# Photo
self.staticbox_photo_staticbox = wx.StaticBox(self, -1, _(u"Photo"))
self.ctrl_photo = CTRL_Photo.CTRL_Photo(self,
modeBase64=True,
style=wx.SUNKEN_BORDER)
self.ctrl_photo.SetMinSize((128, 128))
# Commandes
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_ok = CTRL_Bouton_image.CTRL(
self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_annuler = CTRL_Bouton_image.CTRL(
self,
id=wx.ID_CANCEL,
texte=_(u"Annuler"),
cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
def Impression(self, listeActivites, listePeriodes):
# Création du PDF
self.taille_page = A4
self.orientation = "PORTRAIT"
if self.orientation == "PORTRAIT" :
self.hauteur_page = self.taille_page[1]
self.largeur_page = self.taille_page[0]
else:
self.hauteur_page = self.taille_page[0]
self.largeur_page = self.taille_page[1]
# Création des conditions pour les requêtes SQL
conditionsPeriodes = GetSQLdates(listePeriodes)
if len(listeActivites) == 0 : conditionActivites = "()"
elif len(listeActivites) == 1 : conditionActivites = "(%d)" % listeActivites[0]
else : conditionActivites = str(tuple(listeActivites))
# Récupération des individus grâce à leurs consommations
self.EcritStatusBar(_(u"Recherche des individus..."))
DB = GestionDB.DB()
req = """SELECT individus.IDindividu, IDcivilite, nom, prenom, date_naiss
FROM consommations
LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
WHERE etat IN ("reservation", "present")
AND IDactivite IN %s AND %s
GROUP BY individus.IDindividu
ORDER BY nom, prenom
;""" % (conditionActivites, conditionsPeriodes)
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
DB.Close()
if len(listeIndividus) == 0 :
dlg = wx.MessageDialog(self, _(u"Aucun individu n'a été trouvé avec les paramètres spécifiés !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.EcritStatusBar(u"")
return
dictIndividus = {}
listeIDindividus = []
dictAnniversaires = {}
self.EcritStatusBar(_(u"Recherche des dates de naissance..."))
for IDindividu, IDcivilite, nom, prenom, date_naiss in listeIndividus :
if date_naiss != None :
date_naiss = DateEngEnDateDD(date_naiss)
age = GetAge(date_naiss)
jour = date_naiss.day
mois = date_naiss.month
# Mémorisation de l'individu
dictIndividus[IDindividu] = {
"IDcivilite" : IDcivilite, "nom" : nom, "prenom" : prenom,
"age" : age, "date_naiss" : date_naiss,
}
# Mémorisation du IDindividu
if dictAnniversaires.has_key(mois) == False :
dictAnniversaires[mois] = {}
if dictAnniversaires[mois].has_key(jour) == False :
dictAnniversaires[mois][jour] = []
dictAnniversaires[mois][jour].append(IDindividu)
if IDindividu not in listeIDindividus :
listeIDindividus.append(IDindividu)
# Récupération des photos individuelles
dictPhotos = {}
taillePhoto = 128
if self.ctrl_photos.GetSelection() == 0 : tailleImageFinal = 16
if self.ctrl_photos.GetSelection() == 1 : tailleImageFinal = 32
if self.ctrl_photos.GetSelection() == 2 : tailleImageFinal = 64
if self.check_photos.GetValue() == True :
index = 0
for IDindividu in listeIDindividus :
self.EcritStatusBar(_(u"Recherche des photos... %d/%d") % (index, len(listeIDindividus)))
IDcivilite = dictIndividus[IDindividu]["IDcivilite"]
nomFichier = Chemins.GetStaticPath("Images/128x128/%s" % DICT_CIVILITES[IDcivilite]["nomImage"])
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu, nomFichier=nomFichier, taillePhoto=(taillePhoto, taillePhoto), qualite=100)
# Création de la photo dans le répertoire Temp
nomFichier = UTILS_Fichiers.GetRepTemp(fichier="photoTmp%d.jpg" % IDindividu)
bmp.SaveFile(nomFichier, type=wx.BITMAP_TYPE_JPEG)
img = Image(nomFichier, width=tailleImageFinal, height=tailleImageFinal)
dictPhotos[IDindividu] = img
index += 1
# ---------------- Création du PDF -------------------
self.EcritStatusBar(_(u"Création du PDF..."))
# Initialisation du PDF
nomDoc = FonctionsPerso.GenerationNomDoc("ANNIVERSAIRES", "pdf")
if sys.platform.startswith("win") : nomDoc = nomDoc.replace("/", "\\")
doc = BaseDocTemplate(nomDoc, pagesize=(self.largeur_page, self.hauteur_page), topMargin=30, bottomMargin=30, showBoundary=False)
doc.addPageTemplates(MyPageTemplate(pageSize=(self.largeur_page, self.hauteur_page)))
story = []
# Mois
listeMois = dictAnniversaires.keys()
listeMois.sort()
for numMois in listeMois :
# Mémorise le numéro de mois pour le titre de la page
nomMois = LISTE_NOMS_MOIS[numMois-1]
story.append(DocAssign("numMois", numMois))
# Jours
dictJours = dictAnniversaires[numMois]
listeJours = dictJours.keys()
listeJours.sort()
for numJour in listeJours :
# Initialisation du tableau
dataTableau = []
largeursColonnes = []
# Recherche des entêtes de colonnes :
if self.check_photos.GetValue() == True :
largeursColonnes.append(tailleImageFinal+6)
# Colonne nom de l'individu
largeursColonnes.append(LARGEUR_COLONNE-sum(largeursColonnes))
# Label numéro de jour
ligne = []
ligne.append(str(numJour))
if self.check_photos.GetValue() == True :
ligne.append(u"")
dataTableau.append(ligne)
# Individus
listeIndividus = dictAnniversaires[numMois][numJour]
for IDindividu in listeIndividus :
ligne = []
# Photo
if self.check_photos.GetValue() == True and IDindividu in dictPhotos :
img = dictPhotos[IDindividu]
ligne.append(img)
# Nom
nom = dictIndividus[IDindividu]["nom"]
prenom = dictIndividus[IDindividu]["prenom"]
ligne.append(u"%s %s" % (nom, prenom))
# Ajout de la ligne individuelle dans le tableau
dataTableau.append(ligne)
couleurFondJour = (0.8, 0.8, 1) # Vert -> (0.5, 1, 0.2)
couleurFondTableau = (1, 1, 1)
style = TableStyle([
('VALIGN', (0,0), (-1,-1), 'MIDDLE'), # Centre verticalement toutes les cases
('BACKGROUND', (0,0), (-1,-1), couleurFondTableau), # Donne la couleur de fond du titre de groupe
('FONT',(0,0),(-1,-1), "Helvetica", 7), # Donne la police de caract. + taille de police
('GRID', (0,0), (-1,-1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau
('ALIGN', (0,1), (-1,-1), 'CENTRE'), # Centre les cases
('SPAN',(0,0),(-1,0)), # Fusionne les lignes du haut pour faire le titre du groupe
('FONT',(0,0),(0,0), "Helvetica-Bold", 10), # Donne la police de caract. + taille de police du titre de groupe
('BACKGROUND', (0,0), (-1,0), couleurFondJour), # Donne la couleur de fond du titre de groupe
])
# Création du tableau
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0, 10))
# Saut de page après un mois
story.append(PageBreak())
# Enregistrement du PDF
doc.build(story)
# Affichage du PDF
FonctionsPerso.LanceFichierExterne(nomDoc)
self.EcritStatusBar(u"")
def __init__(self, parent, IDindividu=None, dictInfosNouveau={}):
wx.Dialog.__init__(self,
parent,
id=-1,
name="fiche_individu",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.IDindividu = IDindividu
self.dictInfosNouveau = dictInfosNouveau
self.nouvelleFiche = False
# Adapte taille Police pour Linux
from Utils import UTILS_Linux
UTILS_Linux.AdaptePolice(self)
if IDindividu == None and len(self.dictInfosNouveau) > 0:
self.nouvelleFiche = True
# Création de l'IDindividu
self.CreateIDindividu()
# Création du rattachement à la famille
self.RattacherIndividu(self.dictInfosNouveau["IDfamille"],
self.dictInfosNouveau["IDcategorie"],
self.dictInfosNouveau["titulaire"])
# Recherche des familles rattachées
if self.IDindividu != None:
self.dictFamillesRattachees = self.GetFamillesRattachees()
else:
self.dictFamillesRattachees = {}
self.ctrl_ID = wx.StaticText(
self, -1,
_(u"Rattaché à aucune famille | ID : %d") % self.IDindividu)
self.ctrl_ligne = wx.StaticLine(self, -1)
self.ctrl_nom = wx.StaticText(self, -1, _(u"NOM, Prénom"))
self.ctrl_datenaiss = wx.StaticText(self, -1,
_(u"Date de naissance inconnue"))
self.ctrl_adresse = wx.StaticText(self, -1,
_(u"Lieu de résidence inconnu"))
couleurFond = self.ctrl_adresse.GetBackgroundColour(
) #wx.SystemSettings.GetColour(30)
self.ctrl_liens = CTRL_header_rattachement(
self, couleurFond=couleurFond
) #wx.StaticText(self, -1, _(u"Aucun rattachement"))
self.ctrl_photo = CTRL_Photo.CTRL_Photo(self, style=wx.SUNKEN_BORDER)
self.ctrl_photo.SetPhoto(
IDindividu=None,
nomFichier=Chemins.GetStaticPath("Images/128x128/Personne.png"),
taillePhoto=(128, 128),
qualite=100)
self.ctrl_notebook = Notebook(
self,
IDindividu=self.IDindividu,
dictFamillesRattachees=self.dictFamillesRattachees)
self.bouton_ok = CTRL_Bouton_image.CTRL(
self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_annuler = CTRL_Bouton_image.CTRL(
self, texte=_(u"Annuler"), cheminImage="Images/32x32/Annuler.png")
self.bouton_options = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Options"),
cheminImage="Images/32x32/Configuration2.png")
self.bouton_outils = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Outils"),
cheminImage="Images/32x32/Configuration.png")
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOptions, self.bouton_options)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOutils, self.bouton_outils)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
self.Bind(wx.EVT_CLOSE, self.OnClose)
# Importation des données
## if self.nouvelleFiche == False :
## listePages = ("identite", "coords")
## for codePage in listePages :
## self.ctrl_notebook.GetPage(codePage).MAJ()
self.ctrl_notebook.GetPageAvecCode("identite").MAJ()
self.ctrl_notebook.GetPageAvecCode("coords").MAJ()
# Saisie des infos par défaut pour la nouvelle fiche
if self.nouvelleFiche == True:
pageIdentite = self.ctrl_notebook.GetPageAvecCode("identite")
pageIdentite.SetValeursDefaut(
self.dictInfosNouveau["nom"],
self.dictInfosNouveau["prenom"],
self.dictInfosNouveau["IDcategorie"],
)
pageIdentite.majEffectuee = True
# Si c'est un nouveau contact, on se met sur adresse manuelle
if self.dictInfosNouveau["IDcategorie"] == 3:
pageCoords = self.ctrl_notebook.GetPageAvecCode("coords")
pageCoords.radio_adresse_manuelle.SetValue(True)
pageCoords.OnRadioAdresse(None)
# On met à jour les pages spéciales autre que "Identité"
## listePages = ("liens", "coords")
## for codePage in listePages :
## page = self.ctrl_notebook.GetPageAvecCode(codePage)
## page.MAJ()
## page.majEffectuee = True
# Mise à jour du header
self.MAJtexteRattachementHeader()
# MAJ de l'onglet Informations
self.ctrl_notebook.GetPageAvecCode("informations").MAJ()
def OnBoutonOk(self, event):
dictParametres = self.ctrl_notebook.GetParametres()
# Récupération et vérification des données
listeActivites = dictParametres["liste_activites"]
if len(listeActivites) == 0 :
self.ctrl_notebook.AffichePage("generalites")
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement cocher au moins une activité !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Récupération et vérification des données
listeGroupes = dictParametres["liste_groupes"]
if len(dictParametres["liste_groupes"]) == 0 :
self.ctrl_notebook.AffichePage("generalites")
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement cocher au moins un groupe !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérification qu'il y a des colonnes
if not dictParametres["colonnes"]:
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement créer au moins une colonne !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Recherche les catégories utilisées
liste_categories_utilisees = []
for nom_categorie, categories in dictParametres["colonnes"]:
for IDcategorie in UTILS_Texte.ConvertStrToListe(categories):
if IDcategorie not in liste_categories_utilisees :
liste_categories_utilisees.append(IDcategorie)
# Création du PDF
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
from reportlab.platypus.flowables import ParagraphAndImage, Image
from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.lib.styles import ParagraphStyle
self.taille_page = A4
if dictParametres["orientation"] == "portrait" :
self.hauteur_page = self.taille_page[1]
self.largeur_page = self.taille_page[0]
else:
self.hauteur_page = self.taille_page[0]
self.largeur_page = self.taille_page[1]
# Création des conditions pour les requêtes SQL
conditionsPeriodes = GetSQLdates(dictParametres["liste_periodes"])
if len(listeActivites) == 0 : conditionActivites = "()"
elif len(listeActivites) == 1 : conditionActivites = "(%d)" % listeActivites[0]
else : conditionActivites = str(tuple(listeActivites))
if len(listeGroupes) == 0 : conditionGroupes = "()"
elif len(listeGroupes) == 1 : conditionGroupes = "(%d)" % listeGroupes[0]
else : conditionGroupes = str(tuple(listeGroupes))
# Récupération des noms des groupes
dictGroupes = dictParametres["dict_groupes"]
dictActivites = dictParametres["dict_activites"]
DB = GestionDB.DB()
# ------------ MODE PRESENTS ---------------------------------
if dictParametres["mode"] == "presents" :
# Récupération de la liste des groupes ouverts sur cette période
req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe
FROM ouvertures
WHERE ouvertures.IDactivite IN %s AND %s
AND IDgroupe IN %s
; """ % (conditionActivites, conditionsPeriodes, conditionGroupes)
DB.ExecuterReq(req)
listeOuvertures = DB.ResultatReq()
dictOuvertures = {}
for IDouverture, IDactivite, IDunite, IDgroupe in listeOuvertures :
if (IDactivite in dictOuvertures) == False :
dictOuvertures[IDactivite] = []
if IDgroupe not in dictOuvertures[IDactivite] :
dictOuvertures[IDactivite].append(IDgroupe)
# Récupération des individus grâce à leurs consommations
req = """SELECT individus.IDindividu, IDactivite, IDgroupe,
IDcivilite, nom, prenom, date_naiss
FROM consommations
LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
WHERE consommations.etat IN ("reservation", "present")
AND IDactivite IN %s AND %s
GROUP BY individus.IDindividu, IDactivite, IDgroupe
ORDER BY nom, prenom
;""" % (conditionActivites, conditionsPeriodes)
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
# ------------ MODE INSCRITS ---------------------------------
if dictParametres["mode"] == "inscrits" :
dictOuvertures = {}
for IDgroupe, dictGroupe in dictGroupes.items() :
IDactivite = dictGroupe["IDactivite"]
if (IDactivite in dictOuvertures) == False :
dictOuvertures[IDactivite] = []
if IDgroupe not in dictOuvertures[IDactivite] :
dictOuvertures[IDactivite].append(IDgroupe)
# Récupération des individus grâce à leurs consommations
req = """SELECT individus.IDindividu, IDactivite, IDgroupe,
IDcivilite, nom, prenom, date_naiss
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
WHERE inscriptions.statut='ok' AND IDactivite IN %s
GROUP BY individus.IDindividu, IDactivite, IDgroupe
ORDER BY nom, prenom
;""" % conditionActivites
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
# Analyse des individus
dictIndividus = {}
listeIDindividus = []
for IDindividu, IDactivite, IDgroupe, IDcivilite, nom, prenom, date_naiss in listeIndividus:
if date_naiss != None: date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss)
age = self.GetAge(date_naiss)
# Mémorisation de l'individu
dictIndividus[IDindividu] = {
"IDcivilite": IDcivilite, "nom": nom, "prenom": prenom,
"age": age, "date_naiss": date_naiss, "IDgroupe": IDgroupe, "IDactivite": IDactivite,
}
# Mémorisation du IDindividu
if IDindividu not in listeIDindividus:
listeIDindividus.append(IDindividu)
# Dict Informations médicales
req = """SELECT IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical,
description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction
FROM problemes_sante
WHERE diffusion_listing_enfants=1
;"""
DB.ExecuterReq(req)
listeInformations = DB.ResultatReq()
DB.Close()
dictInfosMedicales = {}
for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction in listeInformations :
if (IDindividu in dictInfosMedicales) == 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, "eviction" : eviction,
"date_debut_eviction" : date_debut_eviction, "date_fin_eviction" : date_fin_eviction,
}
dictInfosMedicales[IDindividu].append(dictTemp)
# Récupération des photos individuelles
dictPhotos = {}
taillePhoto = 128
if dictParametres["afficher_photos"] == "petite" : tailleImageFinal = 16
if dictParametres["afficher_photos"] == "moyenne" : tailleImageFinal = 32
if dictParametres["afficher_photos"] == "grande" : tailleImageFinal = 64
if dictParametres["afficher_photos"] != "non" :
for IDindividu in listeIDindividus :
IDcivilite = dictIndividus[IDindividu]["IDcivilite"]
nomFichier = Chemins.GetStaticPath("Images/128x128/%s" % DICT_CIVILITES[IDcivilite]["nomImage"])
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu, nomFichier=nomFichier, taillePhoto=(taillePhoto, taillePhoto), qualite=100)
# Création de la photo dans le répertoire Temp
nomFichier = UTILS_Fichiers.GetRepTemp(fichier="photoTmp%d.jpg" % IDindividu)
bmp.SaveFile(nomFichier, type=wx.BITMAP_TYPE_JPEG)
img = Image(nomFichier, width=tailleImageFinal, height=tailleImageFinal)
dictPhotos[IDindividu] = img
# ---------------- Création du PDF -------------------
# Initialisation du PDF
nomDoc = FonctionsPerso.GenerationNomDoc("LISTE_INFORMATIONS_MEDICALES", "pdf")
if sys.platform.startswith("win") : nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc, pagesize=(self.largeur_page, self.hauteur_page), topMargin=30, bottomMargin=30)
story = []
largeurContenu = self.largeur_page - 75
# Création du titre du document
def Header():
dataTableau = []
largeursColonnes = ( (largeurContenu-100, 100) )
dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today()))
dataTableau.append( (_(u"Informations médicales"), _(u"%s\nEdité le %s") % (UTILS_Organisateur.GetNom(), dateDuJour)) )
style = TableStyle([
('BOX', (0,0), (-1,-1), 0.25, colors.black),
('VALIGN', (0,0), (-1,-1), 'TOP'),
('ALIGN', (0,0), (0,0), 'LEFT'),
('FONT',(0,0),(0,0), "Helvetica-Bold", 16),
('ALIGN', (1,0), (1,0), 'RIGHT'),
('FONT',(1,0),(1,0), "Helvetica", 6),
])
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0,20))
# Insère un header
Header()
# Activités
for IDactivite in listeActivites :
# Groupes
if IDactivite in dictOuvertures :
nbreGroupes = len(dictOuvertures[IDactivite])
indexGroupe = 1
for IDgroupe in dictOuvertures[IDactivite] :
nomGroupe = dictGroupes[IDgroupe]["nom"]
if isinstance(dictActivites[IDactivite], dict):
nomActivite = dictActivites[IDactivite]["nom"]
else:
nomActivite = dictActivites[IDactivite]
# Initialisation du tableau
dataTableau = []
largeursColonnes = []
labelsColonnes = []
# Recherche des entêtes de colonnes :
if dictParametres["afficher_photos"] != "non" :
labelsColonnes.append(_(u"Photo"))
largeursColonnes.append(tailleImageFinal+6)
labelsColonnes.append(_(u"Nom - prénom"))
if dictParametres["largeur_colonne_nom"] == "automatique" :
largeursColonnes.append(120)
else :
largeursColonnes.append(int(dictParametres["largeur_colonne_nom"]))
if dictParametres["afficher_age"] == True :
labelsColonnes.append(_(u"Âge"))
if dictParametres["largeur_colonne_age"] == "automatique":
largeursColonnes.append(20)
else:
largeursColonnes.append(int(dictParametres["largeur_colonne_age"]))
# Calcule la largeur restante
largeurRestante = largeurContenu - sum(largeursColonnes)
# Calcul des largeurs de colonnes
largeurColonnes = largeurRestante * 1.0 / len(dictParametres["colonnes"])
for nom_categorie, categories in dictParametres["colonnes"]:
labelsColonnes.append(nom_categorie)
largeursColonnes.append(largeurColonnes)
# Création de l'entete de groupe
ligne = [u"%s - %s" % (nomActivite, nomGroupe),]
for x in range(0, len(labelsColonnes)-1):
ligne.append("")
dataTableau.append(ligne)
# Création des entêtes
ligne = []
for label in labelsColonnes :
ligne.append(label)
dataTableau.append(ligne)
# --------- Création des lignes -----------
# Création d'une liste temporaire pour le tri
listeIndividus = []
if IDactivite in dictOuvertures :
if IDgroupe in dictOuvertures[IDactivite] :
for IDindividu in listeIDindividus :
dictIndividu = dictIndividus[IDindividu]
if dictIndividu["IDgroupe"] == IDgroupe :
valeursTri = (IDindividu, dictIndividu["nom"], dictIndividu["prenom"], dictIndividu["age"])
# + Sélection uniquement des individus avec infos
if dictParametres["individus_avec_infos"] == False or (dictParametres["individus_avec_infos"] == True and IDindividu in dictInfosMedicales ) :
listeIndividus.append(valeursTri)
if dictParametres["tri"] == "nom" : paramTri = 1 # Nom
if dictParametres["tri"] == "prenom" : paramTri = 2 # Prénom
if dictParametres["tri"] == "age" : paramTri = 3 # Age
if dictParametres["ordre"] == "croissant" :
ordreDecroissant = False
else:
ordreDecroissant = True
listeIndividus = sorted(listeIndividus, key=operator.itemgetter(paramTri), reverse=ordreDecroissant)
# Récupération des lignes individus
for IDindividu, nom, prenom, age in listeIndividus :
dictIndividu = dictIndividus[IDindividu]
ligne = []
# Photo
if dictParametres["afficher_photos"] != "non" and IDindividu in dictPhotos :
img = dictPhotos[IDindividu]
ligne.append(img)
# Nom
ligne.append(u"%s %s" % (nom, prenom))
# Age
if dictParametres["afficher_age"] == True :
if age != None :
ligne.append(age)
else:
ligne.append("")
# Informations médicales
paraStyle = ParagraphStyle(name="infos",
fontName="Helvetica",
fontSize=7,
leading=8,
spaceAfter=2,
)
# Création des colonnes
has_infos = False
for nom_categorie, categories in dictParametres["colonnes"]:
liste_categories = UTILS_Texte.ConvertStrToListe(categories)
case = []
# Recherche s'il y a une info médicale dans cette case
if IDindividu in dictInfosMedicales:
for infoMedicale in dictInfosMedicales[IDindividu] :
IDcategorie = infoMedicale["IDcategorie"]
if IDcategorie in liste_categories or (0 in liste_categories and IDcategorie not in liste_categories_utilisees) :
intitule = infoMedicale["intitule"]
description = infoMedicale["description"]
traitement = infoMedicale["traitement_medical"]
description_traitement = infoMedicale["description_traitement"]
date_debut_traitement = infoMedicale["date_debut_traitement"]
date_fin_traitement = infoMedicale["date_fin_traitement"]
# Intitulé et description
if description != None and description != "":
texteInfos = u"<b>%s</b> : %s" % (intitule, description)
else:
texteInfos = u"%s" % intitule
if len(texteInfos) > 0 and texteInfos[-1] != ".": texteInfos += u"."
# Traitement médical
if traitement == 1 and description_traitement != None and description_traitement != "":
texteDatesTraitement = u""
if date_debut_traitement != None and date_fin_traitement != None:
texteDatesTraitement = _(u" du %s au %s") % (UTILS_Dates.DateEngFr(date_debut_traitement), UTILS_Dates.DateEngFr(date_fin_traitement))
if date_debut_traitement != None and date_fin_traitement == None:
texteDatesTraitement = _(u" à partir du %s") % UTILS_Dates.DateEngFr(date_debut_traitement)
if date_debut_traitement == None and date_fin_traitement != None:
texteDatesTraitement = _(u" jusqu'au %s") % UTILS_Dates.DateEngFr(date_fin_traitement)
texteInfos += _(u"Traitement%s : %s.") % (texteDatesTraitement, description_traitement)
# Création du paragraphe
case.append(Paragraph(texteInfos, paraStyle))
has_infos = True
# Ajoute la case à la ligne
ligne.append(case)
# Ajout de la ligne individuelle dans le tableau
if dictParametres["individus_avec_infos"] == False or (dictParametres["individus_avec_infos"] == True and has_infos == True):
dataTableau.append(ligne)
# Création des lignes vierges
for x in range(0, dictParametres["nbre_lignes_vierges"]):
ligne = []
for col in labelsColonnes :
ligne.append("")
dataTableau.append(ligne)
# Style du tableau
couleur_fond_entetes = UTILS_Divers.ConvertCouleurWXpourPDF(dictParametres["couleur_fond_entetes"])
style = TableStyle([
('VALIGN', (0,0), (-1,-1), 'MIDDLE'), # Centre verticalement toutes les cases
('FONT',(0,0),(-1,-1), "Helvetica", 7), # Donne la police de caract. + taille de police
('GRID', (0,0), (-1,-1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau
('ALIGN', (0,1), (-2,-1), 'CENTRE'), # Centre les cases
('ALIGN', (0,1), (-1,1), 'CENTRE'), # Ligne de labels colonne alignée au centre
('FONT',(0,1),(-1,1), "Helvetica", 6), # Donne la police de caract. + taille de police des labels
('SPAN',(0,0),(-1,0)), # Fusionne les lignes du haut pour faire le titre du groupe
('FONT',(0,0),(0,0), "Helvetica-Bold", 10), # Donne la police de caract. + taille de police du titre de groupe
('BACKGROUND', (0,0), (-1,0), couleur_fond_entetes), # Donne la couleur de fond du titre de groupe
])
# Création du tableau
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0,20))
# Saut de page après un groupe
if dictParametres["saut_page_groupe"] == True :
story.append(PageBreak())
# Insère un header
if indexGroupe < nbreGroupes :
Header()
indexGroupe += 1
# Enregistrement du PDF
doc.build(story)
# Affichage du PDF
FonctionsPerso.LanceFichierExterne(nomDoc)
def OnBoutonOk(self, event):
# Récupération et vérification des données
listePeriodes = self.ctrl_calendrier.GetDatesSelections()
listeActivites = self.ctrl_activites.GetListeActivites()
if len(listeActivites) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement cocher au moins une activité !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
listeGroupes = self.ctrl_groupes.GetListeGroupes()
if len(listeGroupes) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement cocher au moins un groupe !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Création du PDF
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
from reportlab.platypus.flowables import ParagraphAndImage, Image
from reportlab.rl_config import defaultPageSize
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import inch, cm
from reportlab.lib.utils import ImageReader
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
self.taille_page = A4
self.orientation = "PAYSAGE"
if self.orientation == "PORTRAIT":
self.hauteur_page = self.taille_page[1]
self.largeur_page = self.taille_page[0]
else:
self.hauteur_page = self.taille_page[0]
self.largeur_page = self.taille_page[1]
# Création des conditions pour les requêtes SQL
conditionsPeriodes = GetSQLdates(listePeriodes)
if len(listeActivites) == 0: conditionActivites = "()"
elif len(listeActivites) == 1:
conditionActivites = "(%d)" % listeActivites[0]
else:
conditionActivites = str(tuple(listeActivites))
if len(listeGroupes) == 0: conditionGroupes = "()"
elif len(listeGroupes) == 1:
conditionGroupes = "(%d)" % listeGroupes[0]
else:
conditionGroupes = str(tuple(listeGroupes))
# Récupération des noms des groupes
dictGroupes = self.ctrl_groupes.GetDictGroupes()
# Récupération des noms d'activités
dictActivites = self.ctrl_activites.GetDictActivites()
# Récupération de la liste des groupes ouverts sur cette période
DB = GestionDB.DB()
req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe
FROM ouvertures
WHERE ouvertures.IDactivite IN %s AND %s
AND IDgroupe IN %s
; """ % (conditionActivites, conditionsPeriodes, conditionGroupes)
DB.ExecuterReq(req)
listeOuvertures = DB.ResultatReq()
dictOuvertures = {}
for IDouverture, IDactivite, IDunite, IDgroupe in listeOuvertures:
if dictOuvertures.has_key(IDactivite) == False:
dictOuvertures[IDactivite] = []
if IDgroupe not in dictOuvertures[IDactivite]:
dictOuvertures[IDactivite].append(IDgroupe)
# Récupération des individus grâce à leurs consommations
DB = GestionDB.DB()
req = """SELECT individus.IDindividu, IDactivite, IDgroupe, etat,
IDcivilite, nom, prenom, date_naiss
FROM consommations
LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
WHERE etat IN ("reservation", "present")
AND IDactivite IN %s AND %s
GROUP BY individus.IDindividu
ORDER BY nom, prenom
;""" % (conditionActivites, conditionsPeriodes)
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
dictIndividus = {}
listeIDindividus = []
for IDindividu, IDactivite, IDgroupe, etat, IDcivilite, nom, prenom, date_naiss in listeIndividus:
if date_naiss != None: date_naiss = DateEngEnDateDD(date_naiss)
age = self.GetAge(date_naiss)
# Mémorisation de l'individu
dictIndividus[IDindividu] = {
"IDcivilite": IDcivilite,
"nom": nom,
"prenom": prenom,
"age": age,
"date_naiss": date_naiss,
"IDgroupe": IDgroupe,
"IDactivite": IDactivite,
}
# Mémorisation du IDindividu
if IDindividu not in listeIDindividus:
listeIDindividus.append(IDindividu)
# Dict Informations médicales
req = """SELECT IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical,
description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction
FROM problemes_sante
WHERE diffusion_listing_enfants=1
;"""
DB.ExecuterReq(req)
listeInformations = DB.ResultatReq()
DB.Close()
dictInfosMedicales = {}
for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction in listeInformations:
if dictInfosMedicales.has_key(IDindividu) == False:
dictInfosMedicales[IDindividu] = []
dictTemp = {
"IDprobleme": IDprobleme,
"IDtype": 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,
"eviction": eviction,
"date_debut_eviction": date_debut_eviction,
"date_fin_eviction": date_fin_eviction,
}
dictInfosMedicales[IDindividu].append(dictTemp)
# Récupération des photos individuelles
dictPhotos = {}
taillePhoto = 128
if self.ctrl_taille_photos.GetSelection() == 0: tailleImageFinal = 16
if self.ctrl_taille_photos.GetSelection() == 1: tailleImageFinal = 32
if self.ctrl_taille_photos.GetSelection() == 2: tailleImageFinal = 64
if self.checkbox_photos.GetValue() == True:
for IDindividu in listeIDindividus:
IDcivilite = dictIndividus[IDindividu]["IDcivilite"]
nomFichier = Chemins.GetStaticPath(
"Images/128x128/%s" %
DICT_CIVILITES[IDcivilite]["nomImage"])
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu,
nomFichier=nomFichier,
taillePhoto=(taillePhoto,
taillePhoto),
qualite=100)
# Création de la photo dans le répertoire Temp
nomFichier = UTILS_Fichiers.GetRepTemp(
fichier="photoTmp%d.jpg" % IDindividu)
bmp.SaveFile(nomFichier, type=wx.BITMAP_TYPE_JPEG)
img = Image(nomFichier,
width=tailleImageFinal,
height=tailleImageFinal)
dictPhotos[IDindividu] = img
# ---------------- Création du PDF -------------------
# Initialisation du PDF
nomDoc = FonctionsPerso.GenerationNomDoc(
"LISTE_INFORMATIONS_MEDICALES", "pdf")
if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc,
pagesize=(self.largeur_page,
self.hauteur_page),
topMargin=30,
bottomMargin=30)
story = []
largeurContenu = self.largeur_page - 75 #520
# Création du titre du document
def Header():
dataTableau = []
largeursColonnes = ((largeurContenu - 100, 100))
dateDuJour = DateEngFr(str(datetime.date.today()))
dataTableau.append(
(_(u"Informations médicales"), _(u"%s\nEdité le %s") %
(UTILS_Organisateur.GetNom(), dateDuJour)))
style = TableStyle([
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('ALIGN', (0, 0), (0, 0), 'LEFT'),
('FONT', (0, 0), (0, 0), "Helvetica-Bold", 16),
('ALIGN', (1, 0), (1, 0), 'RIGHT'),
('FONT', (1, 0), (1, 0), "Helvetica", 6),
])
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0, 20))
# Insère un header
Header()
# Activités
for IDactivite in listeActivites:
nomActivite = dictActivites[IDactivite]["nom"]
# Groupes
if dictOuvertures.has_key(IDactivite):
nbreGroupes = len(dictOuvertures[IDactivite])
indexGroupe = 1
for IDgroupe in dictOuvertures[IDactivite]:
nomGroupe = dictGroupes[IDgroupe]["nom"]
# Initialisation du tableau
dataTableau = []
largeursColonnes = []
labelsColonnes = []
# Recherche des entêtes de colonnes :
if self.checkbox_photos.GetValue() == True:
labelsColonnes.append(_(u"Photo"))
largeursColonnes.append(tailleImageFinal + 6)
labelsColonnes.append(_(u"Nom - prénom"))
largeursColonnes.append(120)
if self.checkbox_age.GetValue() == True:
labelsColonnes.append(_(u"Âge"))
largeursColonnes.append(20)
# Calcule la largeur restante
largeurRestante = largeurContenu - sum(largeursColonnes)
labelsColonnes.append(_(u"Informations alimentaires"))
largeursColonnes.append(largeurRestante / 2.0)
labelsColonnes.append(_(u"Informations diverses"))
largeursColonnes.append(largeurRestante / 2.0)
# Création de l'entete de groupe
ligne = [
nomGroupe,
]
for x in range(0, len(labelsColonnes) - 1):
ligne.append("")
dataTableau.append(ligne)
# Création des entêtes
ligne = []
for label in labelsColonnes:
ligne.append(label)
dataTableau.append(ligne)
# --------- Création des lignes -----------
# Création d'une liste temporaire pour le tri
listeIndividus = []
if dictOuvertures.has_key(IDactivite):
if IDgroupe in dictOuvertures[IDactivite]:
for IDindividu in listeIDindividus:
dictIndividu = dictIndividus[IDindividu]
if dictIndividu["IDgroupe"] == IDgroupe:
valeursTri = (IDindividu,
dictIndividu["nom"],
dictIndividu["prenom"],
dictIndividu["age"])
# + Sélection uniquement des individus avec infos
if self.checkbox_nonvides.GetValue(
) == False or (
self.checkbox_nonvides.GetValue()
== True and dictInfosMedicales.
has_key(IDindividu)):
listeIndividus.append(valeursTri)
if self.ctrl_tri.GetSelection() == 0: paramTri = 1 # Nom
if self.ctrl_tri.GetSelection() == 1:
paramTri = 2 # Prénom
if self.ctrl_tri.GetSelection() == 2: paramTri = 3 # Age
if self.ctrl_ordre.GetSelection() == 0:
ordreDecroissant = False
else:
ordreDecroissant = True
listeIndividus = sorted(listeIndividus,
key=operator.itemgetter(paramTri),
reverse=ordreDecroissant)
# Récupération des lignes individus
for IDindividu, nom, prenom, age in listeIndividus:
dictIndividu = dictIndividus[IDindividu]
ligne = []
# Photo
if self.checkbox_photos.GetValue(
) == True and IDindividu in dictPhotos:
img = dictPhotos[IDindividu]
ligne.append(img)
# Nom
ligne.append(u"%s %s" % (nom, prenom))
# Age
if self.checkbox_age.GetValue() == True:
if age != None:
ligne.append(age)
else:
ligne.append("")
# Informations médicales
paraStyle = ParagraphStyle(
name="infos",
fontName="Helvetica",
fontSize=7,
leading=8,
spaceAfter=2,
)
listeInfosAlim = []
listeInfosDivers = []
if dictInfosMedicales.has_key(IDindividu):
for infoMedicale in dictInfosMedicales[IDindividu]:
intitule = infoMedicale["intitule"]
description = infoMedicale["description"]
traitement = infoMedicale["traitement_medical"]
description_traitement = infoMedicale[
"description_traitement"]
date_debut_traitement = infoMedicale[
"date_debut_traitement"]
date_fin_traitement = infoMedicale[
"date_fin_traitement"]
IDtype = infoMedicale["IDtype"]
# Intitulé et description
if description != None and description != "":
texteInfos = u"<b>%s</b> : %s" % (
intitule, description)
else:
texteInfos = u"%s" % intitule
if len(texteInfos
) > 0 and texteInfos[-1] != ".":
texteInfos += u"."
# Traitement médical
if traitement == 1 and description_traitement != None and description_traitement != "":
texteDatesTraitement = u""
if date_debut_traitement != None and date_fin_traitement != None:
texteDatesTraitement = _(
u" du %s au %s"
) % (DateEngFr(date_debut_traitement),
DateEngFr(date_fin_traitement))
if date_debut_traitement != None and date_fin_traitement == None:
texteDatesTraitement = _(
u" à partir du %s") % DateEngFr(
date_debut_traitement)
if date_debut_traitement == None and date_fin_traitement != None:
texteDatesTraitement = _(
u" jusqu'au %s") % DateEngFr(
date_fin_traitement)
texteInfos += _(u"Traitement%s : %s.") % (
texteDatesTraitement,
description_traitement)
# Création du paragraphe
img = DICT_TYPES_INFOS[IDtype]["img"]
p = ParagraphAndImage(
Paragraph(texteInfos, paraStyle),
Image(Chemins.GetStaticPath(
"Images/16x16/%s" % img),
width=8,
height=8),
xpad=1,
ypad=0,
side="left")
if infoMedicale["IDtype"] == 2:
listeInfosAlim.append(p)
else:
listeInfosDivers.append(p)
ligne.append(listeInfosAlim)
ligne.append(listeInfosDivers)
# Ajout de la ligne individuelle dans le tableau
dataTableau.append(ligne)
# Création des lignes vierges
if self.checkbox_lignes_vierges.GetValue() == True:
for x in range(
0,
self.ctrl_nbre_lignes.GetSelection() + 1):
ligne = []
for col in labelsColonnes:
ligne.append("")
dataTableau.append(ligne)
# Style du tableau
colPremiere = 1
if self.checkbox_photos.GetValue() == True:
colPremiere += 1
if self.checkbox_age.GetValue() == True:
colPremiere += 1
couleurFond = (0.8, 0.8, 1) # Vert -> (0.5, 1, 0.2)
style = TableStyle([
('VALIGN', (0, 0), (-1, -1),
'MIDDLE'), # Centre verticalement toutes les cases
('FONT', (0, 0), (-1, -1), "Helvetica",
7), # Donne la police de caract. + taille de police
('GRID', (0, 0), (-1, -1), 0.25, colors.black
), # Crée la bordure noire pour tout le tableau
('ALIGN', (0, 1), (-2, -1),
'CENTRE'), # Centre les cases
('ALIGN', (0, 1), (-1, 1), 'CENTRE'
), # Ligne de labels colonne alignée au centre
(
'FONT', (0, 1), (-1, 1), "Helvetica", 6
), # Donne la police de caract. + taille de police des labels
(
'SPAN', (0, 0), (-1, 0)
), # Fusionne les lignes du haut pour faire le titre du groupe
(
'FONT', (0, 0), (0, 0), "Helvetica-Bold", 10
), # Donne la police de caract. + taille de police du titre de groupe
('BACKGROUND', (0, 0), (-1, 0), couleurFond
), # Donne la couleur de fond du titre de groupe
])
# Création du tableau
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0, 20))
# Saut de page après un groupe
if self.checkbox_page_groupe.GetValue() == True:
story.append(PageBreak())
# Insère un header
if indexGroupe < nbreGroupes:
Header()
indexGroupe += 1
# Enregistrement du PDF
doc.build(story)
# Affichage du PDF
FonctionsPerso.LanceFichierExterne(nomDoc)
self.MemoriserParametres()
def __init__(self,
parent,
IDfamille=None,
dictIndividus={},
listeSelectionIndividus=[],
selectionTous=False):
ULC.UltimateListCtrl.__init__(self,
parent,
-1,
agwStyle=wx.LC_ICON | wx.LC_ALIGN_LEFT)
self.parent = parent
self.IDfamille = IDfamille
self.dictIndividus = dictIndividus
## self.EnableSelectionVista(True)
self.SetFirstGradientColour(None)
self.SetSecondGradientColour(None) #"#316AC5")
self.EnableSelectionGradient(True)
# Création de la liste d'individus à afficher
listeIndividus = []
for IDindividu, dictIndividu in self.dictIndividus.items():
nbreInscriptions = len(dictIndividu["inscriptions"])
age = dictIndividu["age"]
prenom = dictIndividu["prenom"]
if nbreInscriptions > 0:
listeIndividus.append((prenom, IDindividu))
listeIndividus.sort()
# liste images
self.dictPhotos = {}
taillePhoto = 64
il = wx.ImageList(taillePhoto, taillePhoto, True)
for age, IDindividu in listeIndividus:
dictIndividu = self.dictIndividus[IDindividu]
IDcivilite = dictIndividu["IDcivilite"]
nom = dictIndividu["nom"]
prenom = dictIndividu["prenom"]
nomFichier = Chemins.GetStaticPath(
"Images/128x128/%s" % DICT_CIVILITES[IDcivilite]["nomImage"])
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu,
nomFichier=nomFichier,
taillePhoto=(taillePhoto,
taillePhoto),
qualite=100)
img = il.Add(bmp)
self.dictPhotos[IDindividu] = img
self.AssignImageList(il, wx.IMAGE_LIST_NORMAL)
# Création des items
index = 0
for age, IDindividu in listeIndividus:
dictIndividu = self.dictIndividus[IDindividu]
IDcivilite = dictIndividu["IDcivilite"]
nom = dictIndividu["nom"]
prenom = dictIndividu["prenom"]
label = prenom
if label == "":
label = " "
self.InsertImageStringItem(index, label,
self.dictPhotos[IDindividu])
self.SetItemData(index, IDindividu)
if IDindividu in listeSelectionIndividus or selectionTous == True:
self.Select(index)
self.SetDisabledTextColour(wx.Colour(255, 0, 0))
index += 1
## self.Bind(ULC.EVT_LIST_ITEM_LEFT_CLICK, self.OnSelect)
## self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnSelect)
## self.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnDeselect)
self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
def __init__(self, listePersonnes=[], dictAffichage={}):
""" Imprime les photos """
self.listePersonnes = listePersonnes
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
from reportlab.rl_config import defaultPageSize
from reportlab.lib.units import inch, cm
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4, portrait, landscape
from reportlab.lib.utils import ImageReader
self.hauteur_page = defaultPageSize[1]
self.largeur_page = defaultPageSize[0]
self.inch = inch
modesPage = {
0 : { "orientation" : "portrait", "tailleImageTmp" : 3000, "tailleImageFinal" : 450, "nbreColonnes" : 1, "padding" : 20, "taille_nom" : 34, "taille_texte" : 18 },
1 : { "orientation" : "paysage", "tailleImageTmp" : 2000, "tailleImageFinal" : 310, "nbreColonnes" : 2, "padding" : 20, "taille_nom" : 20, "taille_texte" : 12 },
2 : { "orientation" : "portrait", "tailleImageTmp" : 2000, "tailleImageFinal" : 230, "nbreColonnes" : 2, "padding" : 10, "taille_nom" : 18, "taille_texte" : 10 },
3 : { "orientation" : "portrait", "tailleImageTmp" : 2000, "tailleImageFinal" : 150, "nbreColonnes" : 3, "padding" : 5, "taille_nom" : 14, "taille_texte" : 8 },
4 : { "orientation" : "portrait", "tailleImageTmp" : 2000, "tailleImageFinal" : 110, "nbreColonnes" : 4, "padding" : 5, "taille_nom" : 10, "taille_texte" : 7 },
5 : { "orientation" : "portrait", "tailleImageTmp" : 2000, "tailleImageFinal" : 90, "nbreColonnes" : 5, "padding" : 4, "taille_nom" : 9, "taille_texte" : 6 },
}
modePage = dictAffichage["disposition_page"]
nbreCopies = dictAffichage["nbre_copies"]
parametres = modesPage[modePage]
tailleImageTmp = parametres["tailleImageTmp"]
tailleImageFinal = parametres["tailleImageFinal"]
nbreColonnes = parametres["nbreColonnes"]
orientation = parametres["orientation"]
padding = parametres["padding"]
taille_nom = parametres["taille_nom"]
taille_texte = parametres["taille_texte"]
# Initialisation du PDF
if orientation == "portrait" :
taillePage = portrait(A4)
else:
taillePage = landscape(A4)
nomDoc = UTILS_Fichiers.GetRepTemp("photoPersonnes.pdf")
if "win" in sys.platform : nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc, pagesize=taillePage)
story = []
# Style du tableau
styleTemp = [
#('GRID', (0,0), (-1,-1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau
('VALIGN', (0,0), (-1,-1), 'TOP'), # Centre verticalement toutes les cases
('ALIGN', (0,0), (-1,-1), 'CENTRE'), # Colonne ID centrée
]
## if dictAffichage["couleur_fond"] != None :
## styleTemp.append(('BACKGROUND', (0, 0), (-1, -1), colors.black))
# Nbre de copies
if nbreCopies > 1 :
self.listePersonnesTmp = []
for donnees in self.listePersonnes :
for x in range(0, nbreCopies) :
self.listePersonnesTmp.append(donnees)
self.listePersonnes = self.listePersonnesTmp
self.listePersonnesTmp = []
dictPhotos = {}
for IDpersonne, nom, prenom, bmp in self.listePersonnes :
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDpersonne, taillePhoto=(tailleImageTmp, tailleImageTmp), qualite=100)
if bmp != None :
# Création de la photo dans le répertoire Temp
nomFichier = UTILS_Fichiers.GetRepTemp("photoTmp%d.jpg" % IDpersonne)
bmp.SaveFile(nomFichier, type=wx.BITMAP_TYPE_JPEG)
img = Image(nomFichier, width=tailleImageFinal, height=tailleImageFinal)
dictPhotos[IDpersonne] = img
self.listePersonnesTmp.append((IDpersonne, nom, prenom))
if len(self.listePersonnesTmp) == 0 :
dlg = wx.MessageDialog(None, _(u"Il n'existe aucune photo pour la ou les personnes sélectionnées !"), _(u"Mot de passe erroné"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return
# Création des largeurs de colonnes
largeursColonnes = []
for numCol in range(0, nbreColonnes) :
largeursColonnes.append(tailleImageFinal + (padding*2))
# Calcul du nbre de lignes du tableau
nbreLignes = (len(self.listePersonnesTmp) * 1.0) / nbreColonnes
if int(nbreLignes) != nbreLignes :
nbreLignes = int(nbreLignes) + 1
else:
nbreLignes = int(nbreLignes)
# Création du tableau vide
dataTableau = []
for numLigne in range(0, nbreLignes*3):
ligne = []
for numCol in range(0, nbreColonnes):
ligne.append("")
dataTableau.append(ligne)
# Remplissage du tableau
index = 0
numCol = 0
numLigne = 0
for IDpersonne, nom, prenom in self.listePersonnesTmp :
dataTableau[numLigne][numCol] = dictPhotos[IDpersonne]
dataTableau[numLigne+1][numCol] = prenom
dataTableau[numLigne+2][numCol] = FonctionsPerso.RecupTextePhotoPersonne(IDpersonne)
# Style des photos
styleTemp.append(('TOPPADDING', (0, numLigne), (-1, numLigne), padding))
styleTemp.append(('BOTTOMPADDING', (0, numLigne), (-1, numLigne), padding))
# Style du nom
styleTemp.append(('FONT',(0, numLigne+1),(-1, numLigne+1), "Helvetica-Bold", taille_nom))
# Style du texte personnalisé
styleTemp.append(('FONT',(0, numLigne+2),(-1, numLigne+2), "Helvetica", taille_texte))
styleTemp.append(('BOTTOMPADDING', (0, numLigne+2), (-1, numLigne+2), padding))
# Style de la bordure de la carte
if dictAffichage["bordure"] == True :
styleTemp.append(('BOX', (numCol, numLigne), (numCol, numLigne+2), 0.25, colors.black))
index += 1
if numCol < nbreColonnes-1 :
numCol += 1
else:
numCol = 0
numLigne += 3
style = TableStyle(styleTemp)
# Création du tableau
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0,20))
# Enregistrement du PDF
doc.build(story)
# Affichage du PDF
FonctionsPerso.LanceFichierExterne(nomDoc)
def RecuperePhoto(self, IDpersonne):
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDpersonne, taillePhoto=(self.tailleImages, self.tailleImages), qualite=50)
if bmp == None :
# Crée une image vide
bmp = self.CreationPhotoVide(self.tailleImages)
return bmp
def __init__(self, parent, titre=_(u"Fiche individuelle"), IDpersonne=0):
wx.Dialog.__init__(self,
parent,
-1,
name="FicheIndividuelle",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.IDpersonne = IDpersonne
self.contratEnCours = None
self.AnnulationImpossible = False
self.barre_problemes = None
self.photo = None
import locale
self.locale = wx.Locale(wx.LANGUAGE_FRENCH)
try:
locale.setlocale(locale.LC_ALL, 'FR')
except:
pass
self.panel_1 = wx.Panel(self, -1)
self.label_hd_CatId = wx.StaticText(self.panel_1, -1, u"")
self.static_line_1 = wx.StaticLine(self.panel_1, -1)
self.label_hd_nomPrenom = wx.StaticText(self.panel_1, -1,
_(u"NOM, Prénom"))
self.label_hd_adresse = wx.StaticText(
self.panel_1, -1,
_(u"Résidant 42 rue des oiseaux 29870 LANNILIS"))
self.label_hd_naiss = wx.StaticText(
self.panel_1, -1, _(u"Date et lieu de naissance inconnus"))
self.bitmap_photo = CTRL_Photo.CTRL_Photo(self.panel_1,
style=wx.SUNKEN_BORDER)
self.bitmap_photo.SetPhoto(
IDindividu=None,
nomFichier=Chemins.GetStaticPath("Images/128x128/Personne.png"),
taillePhoto=(128, 128),
qualite=100)
self.bitmap_button_aide = CTRL_Bouton_image.CTRL(
self.panel_1,
texte=_(u"Aide"),
cheminImage=Chemins.GetStaticPath("Images/32x32/Aide.png"))
self.bitmap_button_Ok = CTRL_Bouton_image.CTRL(
self.panel_1,
texte=_(u"Ok"),
cheminImage=Chemins.GetStaticPath("Images/32x32/Valider.png"))
self.bitmap_button_annuler = CTRL_Bouton_image.CTRL(
self.panel_1,
texte=_(u"Annuler"),
cheminImage=Chemins.GetStaticPath("Images/32x32/Annuler.png"))
# NoteBook
self.notebook = Notebook(self.panel_1, IDpersonne=self.IDpersonne)
if self.nouvelleFiche == True:
self.notebook.AfficheAutresPages(False)
# Recherche s'il y a un contrat en cours ou à venir pour savoir s'il faut afficher la barre des problèmes
if self.IDpersonne in FonctionsPerso.Recherche_ContratsEnCoursOuAVenir(
):
self.barre_problemes = True
else:
self.barre_problemes = False
# Récupération de la liste des problèmes de la personne
self.bitmap_problemes_G = wx.StaticBitmap(
self.panel_1, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/Special/Problemes_G.png"),
wx.BITMAP_TYPE_PNG))
self.bitmap_problemes_D = wx.StaticBitmap(
self.panel_1, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/Special/Problemes_D.png"),
wx.BITMAP_TYPE_PNG))
self.txtDefilant = Ticker(self.panel_1,
size=(-1, 18),
fgcolor=(255, 255, 255),
bgcolor=(255, 60, 60))
self.txtPbPersonne = self.Recup_txt_pb_personne()
self.txtDefilant.SetText(self.txtPbPersonne)
# Mise à jour des infos du bandeau supérieur de la fiche
self.MaJ_header()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bitmap_button_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bitmap_button_Ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler,
self.bitmap_button_annuler)
self.txtDefilant.Bind(wx.EVT_MOTION, self.OnMotionTxtDefilant)
self.txtDefilant.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveTxtDefilant)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.__set_properties()
self.__do_layout()
self.Affichage_barre_problemes()