def __set_properties(self):
self.bouton_ajouter.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour ajouter un lot")))
self.bouton_modifier.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour modifier le lot dans la liste")))
self.bouton_supprimer.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour supprimer le lot sélectionné dans la liste")))
self.bouton_aide.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour obtenir de l'aide")))
self.bouton_fermer.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour fermer")))
self.SetMinSize((500, 600))
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
# Création du imageList avec une taille personnalisée
dictImages = {}
imageList = wx.ImageList(TAILLE_IMAGE[0], TAILLE_IMAGE[1])
for track in self.donnees :
indexImg = imageList.Add(track.bmp)
self.SetImageLists(imageList, imageList)
def GetImage(track):
return track.index
liste_Colonnes = [
ColumnDefn(_(u"ID"), "left", 0, "IDinscription"),
ColumnDefn(_(u"Photo"), 'center', TAILLE_IMAGE[0]+1, "", imageGetter=GetImage),
ColumnDefn(_(u"Individu"), 'center', 100, "nomIndividu", isSpaceFilling=True),
]
self.SetColumns(liste_Colonnes)
self.SetEmptyListMsg(_(u"Aucun visage détecté"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, face="Tekton"))
## self.SetSortColumn(self.columns[0])
self.SetObjects(self.donnees)
def OnBoutonOk(self, event):
# Vérification des données saisies
if self.ctrl_etat_avant.GetValeur() == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner un état à convertir !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if self.ctrl_etat_apres.GetValeur() == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner l'état souhaité !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if self.ctrl_etat_avant.GetValeur() == self.ctrl_etat_apres.GetValeur() :
dlg = wx.MessageDialog(self, _(u"Les deux états sélectionnés doivent être différents !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Mémorisation des paramètres
etat_avant = self.ctrl_etat_avant.GetValeur()
UTILS_Parametres.Parametres(mode="set", categorie="conversion_etat", nom="etat_avant", valeur=etat_avant)
etat_apres = self.ctrl_etat_apres.GetValeur()
UTILS_Parametres.Parametres(mode="set", categorie="conversion_etat", nom="etat_apres", valeur=etat_apres)
if self.radio_lignes_affichees.GetValue() == True :
UTILS_Parametres.Parametres(mode="set", categorie="conversion_etat", nom="option_lignes", valeur="lignes_affichees")
if self.radio_lignes_selectionnees.GetValue() == True :
UTILS_Parametres.Parametres(mode="set", categorie="conversion_etat", nom="option_lignes", valeur="lignes_selectionnees")
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def __init__(self, parent, size=(550, 335), listeBoutons=[], type=None):
wx.Dialog.__init__(self, parent, -1, title=_(u"Sélection du type de document"))
self.parent = parent
self.choix = None
self.type = type
self.listeBoutons = listeBoutons
self.label_intro = wx.StaticText(self, -1, _(u"Veuillez sélectionner le type de document à éditer :"))
# Création des boutons de commandes
index = 1
for image, infobulle in self.listeBoutons :
exec("self.bouton_" + str(index) + " = wx.BitmapButton(self, " + str(index) + ", wx.Bitmap(image, wx.BITMAP_TYPE_ANY))")
exec("self.bouton_" + str(index) + ".SetToolTip(wx.ToolTip(infobulle))")
exec("self.Bind(wx.EVT_BUTTON, self.OnBoutonClic, self.bouton_" + str(index) + ")")
index += 1
self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage=Chemins.GetStaticPath("Images/32x32/Aide.png"))
self.bouton_annuler = CTRL_Bouton_image.CTRL(self, id=wx.ID_CANCEL, texte=_(u"Annuler"), cheminImage=Chemins.GetStaticPath("Images/32x32/Annuler.png"))
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
def OnBoutonFichier(self, event):
""" Charger un fichier """
nbreIdentifiees = len(self.GetPhotosIdentifiees())
if nbreIdentifiees > 0 :
dlg = wx.MessageDialog(None, _(u"Souhaitez-vous vraiment charger une nouvelle image ?\n\nAttention, les %d photo(s) identifiée(s) non enregistrées seront annulées.") % nbreIdentifiees, _(u"Avertissement"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
wildcard = "Toutes les images|*.bmp; *.gif; *.jpg; *.png|Image JPEG (*.jpg)|*.jpg|Image PNG (*.png)|*.png|Image GIF (*.gif)|*.gif|Tous les fichiers (*.*)|*.*"
sp = wx.StandardPaths.Get()
cheminDefaut = sp.GetDocumentsDir()
dlg = wx.FileDialog(
self, message=_(u"Choisissez une image"),
defaultDir=cheminDefaut,
defaultFile="",
wildcard=wildcard,
style=wx.OPEN
)
nomFichier = None
if dlg.ShowModal() == wx.ID_OK:
nomFichier = dlg.GetPath()
dlg.Destroy()
else :
dlg.Destroy()
return
self.AnalysePhoto(nomFichier)
def OnContextMenu(self, event):
"""Ouverture du menu contextuel """
item = self.GetSelection()
dictItem = self.GetMainWindow().GetItemPyData(item)
# Création du menu contextuel
menuPop = UTILS_Adaptations.Menu()
# Item Monter
item = wx.MenuItem(menuPop, 10, _(u"Monter"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Fleche_haut.png"), wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.Monter, id=10)
# Item Descendre
item = wx.MenuItem(menuPop, 20, _(u"Descendre"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Fleche_bas.png"), wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.Descendre, id=20)
menuPop.AppendSeparator()
# Item Descendre
item = wx.MenuItem(menuPop, 30, _(u"Réinitialiser"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Actualiser.png"), wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.Reinit, id=30)
# Finalisation du menu
self.PopupMenu(menuPop)
menuPop.Destroy()
def __init__(self, parent):
HTL.HyperTreeList.__init__(self, parent, -1)
self.parent = parent
self.dictParametres = {}
self.listeActivites = []
# Importation des données
self.Importation()
# Création des colonnes
listeColonnes = [
( _(u"Activité / Unité"), 180, wx.ALIGN_LEFT),
( _(u"Abrégé"), 50, wx.ALIGN_LEFT),
( _(u"Type"), 100, wx.ALIGN_LEFT),
( _(u"Affichage"), LARGEUR_COLONNE_AFFICHAGE, wx.ALIGN_LEFT),
## ( _(u"Ordre"), 40, wx.ALIGN_CENTER),
]
numColonne = 0
for label, largeur, alignement in listeColonnes :
self.AddColumn(label)
self.SetColumnWidth(numColonne, largeur)
self.SetColumnAlignment(numColonne, alignement)
numColonne += 1
self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnContextMenu)
self.SetBackgroundColour(wx.WHITE)
if 'phoenix' in wx.PlatformInfo:
TR_COLUMN_LINES = HTL.TR_COLUMN_LINES
else :
TR_COLUMN_LINES = wx.TR_COLUMN_LINES
self.SetAGWWindowStyleFlag(wx.TR_ROW_LINES | TR_COLUMN_LINES |wx.TR_HIDE_ROOT | wx.TR_HAS_BUTTONS | wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.TR_FULL_ROW_HIGHLIGHT ) # HTL.TR_NO_HEADER
self.EnableSelectionVista(True)
def OnDoubleClick(self, event):
item = self.GetSelection()
dictItem = self.GetMainWindow().GetItemPyData(item)
if dictItem == None :
dlg = wx.MessageDialog(self, _(u"Double-cliquez sur le nom de l'individu pour accéder à sa fiche famille !"), _(u"Astuce"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
listeFamilles = dictItem["listeFamilles"]
if len(listeFamilles) == 1 :
# Si individu rattaché à une seule famille
self.OuvrirFicheFamille(listeFamilles[0])
else:
# Si individu rattaché à plusieurs familles
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeFamilles)
listeNoms = []
for IDfamille in listeFamilles :
nomsTitulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"]
listeNoms.append(nomsTitulaires)
dlg = wx.SingleChoiceDialog(self, _(u"Cet individu est rattaché à %d familles.\nLa fiche de quelle famille souhaitez-vous ouvrir ?") % len(listeFamilles), _(u"Rattachements multiples"), listeNoms, wx.CHOICEDLG_STYLE)
IDfamilleSelection = None
if dlg.ShowModal() == wx.ID_OK:
indexSelection = dlg.GetSelection()
IDfamille = listeFamilles[indexSelection]
dlg.Destroy()
else:
dlg.Destroy()
return
self.OuvrirFicheFamille(IDfamille)
def __init__(self, parent):
HTL.HyperTreeList.__init__(self, parent, -1)
self.parent = parent
# Adapte taille Police pour Linux
from Utils import UTILS_Linux
UTILS_Linux.AdaptePolice(self)
# Création des colonnes
listeColonnes = [
( _(u"Individu/Date"), 230, wx.ALIGN_LEFT),
( _(u"Unité"), 170, wx.ALIGN_LEFT),
( _(u"Activité"), 170, wx.ALIGN_LEFT),
( _(u"Etat"), 90, wx.ALIGN_LEFT),
]
numColonne = 0
for label, largeur, alignement in listeColonnes :
self.AddColumn(label)
self.SetColumnWidth(numColonne, largeur)
self.SetColumnAlignment(numColonne, alignement)
numColonne += 1
self.SetBackgroundColour(wx.WHITE)
if 'phoenix' in wx.PlatformInfo:
TR_COLUMN_LINES = HTL.TR_COLUMN_LINES
else :
TR_COLUMN_LINES = wx.TR_COLUMN_LINES
self.SetAGWWindowStyleFlag(wx.TR_HIDE_ROOT | wx.TR_HAS_VARIABLE_ROW_HEIGHT | TR_COLUMN_LINES | wx.TR_FULL_ROW_HIGHLIGHT ) # HTL.TR_NO_HEADER
self.EnableSelectionVista(True)
# Binds
self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnContextMenu)
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnDoubleClick)
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
self.parent = parent
intro = _(u"Vous pouvez ici saisir, modifier ou supprimer des périodes de vacances. Cliquez sur 'Importer depuis Internet' pour télécharger automatiquement les périodes depuis le site de l'Education Nationale.")
titre = _(u"Gestion des périodes de vacances")
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(self, titre=titre, texte=intro, hauteurHtml=30, nomImage=Chemins.GetStaticPath("Images/32x32/Calendrier.png"))
self.ctrl_listview = OL_Vacances.ListView(self, id=-1, style=wx.LC_REPORT|wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL|wx.LC_HRULES|wx.LC_VRULES)
self.ctrl_listview.MAJ()
self.ctrl_recherche = OL_Vacances.CTRL_Outils(self, listview=self.ctrl_listview)
self.bouton_ajouter = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ajouter.png"), wx.BITMAP_TYPE_ANY))
self.bouton_modifier = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Modifier.png"), wx.BITMAP_TYPE_ANY))
self.bouton_supprimer = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer.png"), wx.BITMAP_TYPE_ANY))
self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_importation = CTRL_Bouton_image.CTRL(self, texte=_(u"Importer depuis internet"), cheminImage="Images/32x32/Fleche_bas.png")
self.bouton_fermer = CTRL_Bouton_image.CTRL(self, id=wx.ID_CANCEL, texte=_(u"Fermer"), cheminImage="Images/32x32/Fermer.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.Ajouter, self.bouton_ajouter)
self.Bind(wx.EVT_BUTTON, self.Modifier, self.bouton_modifier)
self.Bind(wx.EVT_BUTTON, self.Supprimer, self.bouton_supprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonImportation, self.bouton_importation)
def Modifier(self, event=None):
if len(self.Selection()) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucun filtre à modifier dans la liste !"),
_(u"Erreur de saisie"),
wx.OK | wx.ICON_EXCLAMATION,
)
dlg.ShowModal()
dlg.Destroy()
return
track = self.Selection()[0]
from Dlg import DLG_Saisie_filtre_listes
dlg = DLG_Saisie_filtre_listes.Dialog(self, ctrl_listview=self.ctrl_listview)
dlg.SetCode(track.code)
dlg.SetValeur(track.choix, track.criteres)
if dlg.ShowModal() == wx.ID_OK:
dictTemp = {
"code": dlg.GetCode(),
"typeDonnee": dlg.GetTypeDonnee(),
"choix": dlg.GetValeur()[0],
"criteres": dlg.GetValeur()[1],
"titre": dlg.GetTitre(),
}
self.listeFiltres[track.index] = dictTemp
self.MAJ()
dlg.Destroy()
def Importation(self):
# Récupération des données
DB = GestionDB.DB()
req = """SELECT IDdeplacement, date, objet, ville_depart, ville_arrivee, distance, aller_retour, tarif_km, IDremboursement FROM deplacements WHERE IDpersonne=%d ORDER BY date; """ % self.IDpersonne
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
self.nbreLignes = len(listeDonnees)
# Création du dictionnaire de données
self.donnees = {}
index = 0
for IDdeplacement, date, objet, ville_depart, ville_arrivee, distance, aller_retour, tarif_km, IDremboursement in listeDonnees :
# Formatage Trajet
if aller_retour == "True" :
trajet = ville_depart + " <--> " + ville_arrivee
else:
trajet = ville_depart + " -> " + ville_arrivee
# Formatage Remboursement
if IDremboursement != None and IDremboursement != 0 and IDremboursement != "" :
remboursement = u"N°" + str(IDremboursement)
else :
remboursement = ""
# Formatage distance
dist = str(distance) + _(u" Km")
# Formatage montant
montant = float(distance) * float(tarif_km)
montantStr = u"%.2f ¤" % montant
# Formatage tarif/Km
tarif_km = str(tarif_km) + _(u" ¤/km")
self.donnees[IDdeplacement] = (IDdeplacement, date, objet, trajet, dist, tarif_km, montantStr, remboursement)
index += 1
def Remplissage(self):
# Récupération des données dans la base de données
self.Importation()
# Création des colonnes
self.nbreColonnes = 5
self.InsertColumn(0, u"")
self.SetColumnWidth(0, 0)
self.InsertColumn(1, u"N°")
self.SetColumnWidth(1, 30)
self.InsertColumn(2, _(u"Date"))
self.SetColumnWidth(2, 80)
self.InsertColumn(3, _(u"Montant"))
self.SetColumnWidth(3, 70)
self.InsertColumn(4, _(u"Déplacements rattachés"))
self.SetColumnWidth(4, 200)
#These two should probably be passed to init more cleanly
#setting the numbers of items = number of elements in the dictionary
self.itemDataMap = self.donnees
self.itemIndexMap = list(self.donnees.keys())
self.SetItemCount(self.nbreLignes)
#mixins
listmix.ListCtrlAutoWidthMixin.__init__(self)
listmix.ColumnSorterMixin.__init__(self, self.nbreColonnes)
#sort by genre (column 1), A->Z ascending order (1)
self.SortListItems(2, 1)
def OnBoutonOk(self, event=None):
# Validation label prestation
if len(self.ctrl_label.GetValue()) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez saisir un label pour cette prestation !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_label.SetFocus()
return False
if self.ctrl_date_prestation.GetDate() == None :
dlg = wx.MessageDialog(self, _(u"Vous devez saisir une date pour cette prestation !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_prestation.SetFocus()
return False
if self.ctrl_montant.GetMontant() == None :
dlg = wx.MessageDialog(self, _(u"Vous devez saisir un montant pour cette prestation !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return False
# Ferme la fenêtre
self.EndModal(wx.ID_OK)
def __init__(self, parent, id=-1, IDpersonne=0):
wx.Panel.__init__(self, parent, id, name="page_frais", style=wx.TAB_TRAVERSAL)
self.parent = parent
self.IDpersonne = IDpersonne
# Widgets
self.staticBox_deplacements = wx.StaticBox(self, -1, _(u"Déplacements"))
self.ctrl_deplacements = ListCtrl_deplacements(self, -1)
self.ctrl_deplacements.SetMinSize((20, 20))
self.bouton_deplacements_ajouter = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ajouter.png"), wx.BITMAP_TYPE_PNG))
self.bouton_deplacements_modifier = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Modifier.png"), wx.BITMAP_TYPE_PNG))
self.bouton_deplacements_supprimer = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer.png"), wx.BITMAP_TYPE_PNG))
self.bouton_deplacements_imprimer = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Imprimante.png"), wx.BITMAP_TYPE_PNG))
self.staticBox_remboursements = wx.StaticBox(self, -1, _(u"Remboursements"))
self.ctrl_remboursements = ListCtrl_remboursements(self, -1)
self.ctrl_remboursements.SetMinSize((20, 20))
self.bouton_remboursements_ajouter = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ajouter.png"), wx.BITMAP_TYPE_PNG))
self.bouton_remboursements_modifier = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Modifier.png"), wx.BITMAP_TYPE_PNG))
self.bouton_remboursements_supprimer = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer.png"), wx.BITMAP_TYPE_PNG))
self.__set_properties()
self.__do_layout()
# Binds
self.Bind(wx.EVT_BUTTON, self.OnBoutonAjoutDeplacement, self.bouton_deplacements_ajouter)
self.Bind(wx.EVT_BUTTON, self.OnBoutonModifDeplacement, self.bouton_deplacements_modifier)
self.Bind(wx.EVT_BUTTON, self.OnBoutonSupprDeplacement, self.bouton_deplacements_supprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonImprimerDeplacement, self.bouton_deplacements_imprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAjoutRemboursement, self.bouton_remboursements_ajouter)
self.Bind(wx.EVT_BUTTON, self.OnBoutonModifRemboursement, self.bouton_remboursements_modifier)
self.Bind(wx.EVT_BUTTON, self.OnBoutonSupprRemboursement, self.bouton_remboursements_supprimer)
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
def FormateMontant(montant):
if montant == None : return u""
return u"%.2f %s" % (montant, SYMBOLE)
def FormateDate(date):
return UTILS_Dates.DateDDEnFr(date)
liste_Colonnes = [
ColumnDefn(u"", "left", 0, "IDtarif", typeDonnee="entier"),
ColumnDefn(_(u"Du"), 'left', 80, "date_debut", typeDonnee="date", stringConverter=FormateDate),
ColumnDefn(_(u"au"), 'left', 80, "date_fin", typeDonnee="date", stringConverter=FormateDate),
ColumnDefn(_(u"Label"), "left", 220, "label", typeDonnee="texte"),
ColumnDefn(_(u"Montant"), "right", 80, "montant", typeDonnee="montant", stringConverter=FormateMontant),
]
self.SetColumns(liste_Colonnes)
self.SetEmptyListMsg(_(u"Aucun tarif"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
def __set_properties(self):
self.SetTitle(_(u"Saisie d'une prestation"))
self.ctrl_tarifs.SetToolTip(wx.ToolTip(_(u"Sélectionnez un tarif à appliquer")))
self.bouton_aide.SetToolTip(wx.ToolTip(_(u"Cliquez ici obtenir de l'aide")))
self.bouton_ok.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour valider")))
self.bouton_annuler.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour annuler")))
self.SetMinSize((560, 450))
def OnBoutonOk(self, event):
# Vérification des données saisies
if self.ctrl_unite_origine.GetValeur() == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner une unité à recopier !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if self.ctrl_unite_destination.GetValeur() == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner l'unité vers laquelle recopier !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if self.ctrl_unite_origine.GetValeur() == self.ctrl_unite_destination.GetValeur() :
dlg = wx.MessageDialog(self, _(u"Les deux unités sélectionnées doivent être différentes !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Mémorisation des paramètres
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="unite_origine", valeur=self.ctrl_unite_origine.GetValeur())
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="unite_destination", valeur=self.ctrl_unite_destination.GetValeur())
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="param_horaires", valeur=self.check_param_horaires.GetValue())
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="param_quantite", valeur=self.check_param_quantite.GetValue())
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="param_etiquettes", valeur=self.check_param_etiquettes.GetValue())
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="param_etat", valeur=self.check_param_etat.GetValue())
if self.radio_lignes_affichees.GetValue() == True :
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="option_lignes", valeur="lignes_affichees")
if self.radio_lignes_selectionnees.GetValue() == True :
UTILS_Parametres.Parametres(mode="set", categorie="recopiage_conso", nom="option_lignes", valeur="lignes_selectionnees")
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def __set_properties(self):
self.SetTitle(_(u"Sélection des destinataires"))
self.bouton_aide.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour obtenir de l'aide")))
self.bouton_detail.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour afficher la liste des adresses valides")))
self.bouton_ok.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour valider")))
self.bouton_annuler.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour annuler")))
self.SetMinSize((700, 550))
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
self.parent = parent
intro = _(u"Vous pouvez ici consulter et imprimer la liste des cotisations encore à fournir à la date de référence donnée pour la ou les activités sélectionnées. Commencez par saisir une date de référence puis sélectionnez un ou plusieurs groupes d'activités ou certaines activités en particulier avant de cliquer sur le bouton 'Rafraîchir la liste' pour afficher les résultats.")
titre = _(u"Liste des cotisations manquantes")
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(self, titre=titre, texte=intro, hauteurHtml=30, nomImage="Images/32x32/Cotisation.png")
self.ctrl_parametres = Parametres(self)
self.ctrl_listview = OL_Cotisations_manquantes.ListView(self, id=-1, style=wx.LC_REPORT|wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL|wx.LC_HRULES|wx.LC_VRULES)
self.ctrl_listview.SetMinSize((100, 100))
self.ctrl_recherche = OL_Cotisations_manquantes.CTRL_Outils(self, listview=self.ctrl_listview)
self.bouton_apercu = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Apercu.png"), wx.BITMAP_TYPE_ANY))
self.bouton_imprimer = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Imprimante.png"), wx.BITMAP_TYPE_ANY))
self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_fermer = CTRL_Bouton_image.CTRL(self, id=wx.ID_CANCEL, texte=_(u"Fermer"), cheminImage="Images/32x32/Fermer.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.Apercu, self.bouton_apercu)
self.Bind(wx.EVT_BUTTON, self.Imprimer, self.bouton_imprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.MAJ(None)
def __set_properties(self):
self.SetTitle(_(u"Liste des cotisations manquantes"))
self.bouton_apercu.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour créer un aperçu de la liste")))
self.bouton_imprimer.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour imprimer la liste")))
self.bouton_aide.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour obtenir de l'aide")))
self.bouton_fermer.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour fermer")))
self.SetMinSize((950, 700))
def __init__(self, parent):
wx.Panel.__init__(self, parent, id=-1, name="panel_parametres", style=wx.TAB_TRAVERSAL)
self.parent = parent
# Période
self.staticbox_periode_staticbox = wx.StaticBox(self, -1, _(u"Date de référence"))
self.ctrl_date = CTRL_Saisie_date.Date(self)
self.ctrl_date.SetDate(datetime.date.today())
self.bouton_date = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Calendrier.png"), wx.BITMAP_TYPE_ANY))
# Activités
self.staticbox_activites_staticbox = wx.StaticBox(self, -1, _(u"Activités"))
self.ctrl_activites = CTRL_Selection_activites.CTRL(self)
self.ctrl_activites.SetMinSize((-1, 90))
# Inscrits / Présents
self.staticbox_presents_staticbox = wx.StaticBox(self, -1, _(u"Options"))
self.ctrl_options = Options(self)
# Boutons afficher
self.bouton_afficher = CTRL_Bouton_image.CTRL(self, texte=_(u"Rafraîchir la liste"), cheminImage="Images/32x32/Actualiser.png")
self.bouton_afficher.SetMinSize((-1, 50))
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAfficher, self.bouton_afficher)
self.Bind(wx.EVT_BUTTON, self.OnBoutonDate, self.bouton_date)
def Validation(self):
# Validation de la saisie
nbreCoches = len(self.ctrl_factures.GetTracksCoches())
if nbreCoches == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune facture à générer !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Demande de confirmation
if nbreCoches == 1 :
texte = _(u"Confirmez-vous la génération de 1 facture ?")
else :
texte = _(u"Confirmez-vous la génération de %d factures ?") % nbreCoches
dlg = wx.MessageDialog(self, texte, _(u"Confirmation"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
# Génération des factures
listeFacturesGenerees = self.SauvegardeFactures()
if listeFacturesGenerees == False :
return False
# Envoi des factures générées
self.parent.listeFacturesGenerees = listeFacturesGenerees
return True
def GetLabelParametres(self):
listeParametres = []
# Dates et Mode
date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate()
date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate()
if date_debut == None : date_debut = "---"
if date_fin == None : date_fin= "---"
listeParametres.append(_(u"Période du %s au %s") % (DateEngFr(str(date_debut)), DateEngFr(str(date_fin))))
# Affichage
listeAffichage = []
for filtre in self.ctrl_parametres.GetFiltres() :
if filtre == "consommation" : listeAffichage.append("Consommations")
if filtre == "cotisation" : listeAffichage.append("Cotisations")
if filtre == "autre" : listeAffichage.append("Autres")
if filtre == "avoir" : listeAffichage.append("Avoirs")
affichage = ", ".join(listeAffichage)
listeParametres.append(_(u"Eléments affichés : %s") % affichage)
# Activités
activites = self.ctrl_parametres.GetLabelActivites()
listeParametres.append(_(u"Activités : %s") % activites)
labelParametres = " | ".join(listeParametres)
return labelParametres
def Supprimer(self, event):
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("parametrage_restaurateurs", "supprimer") == False : return
if len(self.Selection()) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucun restaurateur dans la liste"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
IDrestaurateur = self.Selection()[0].IDrestaurateur
# Vérifie que ce restaurateur n'a pas déjà été attribué à une unité de consommation
DB = GestionDB.DB()
req = """SELECT COUNT(IDunite)
FROM unites
WHERE IDrestaurateur=%d
;""" % IDrestaurateur
DB.ExecuterReq(req)
nbreUnites = int(DB.ResultatReq()[0][0])
DB.Close()
if nbreUnites > 0 :
dlg = wx.MessageDialog(self, _(u"Ce restaurateur a déjà été attribué à %d unité(s) de consommation.\n\nVous ne pouvez donc pas le supprimer !") % nbreUnites, _(u"Suppression impossible"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Confirmation de suppression
dlg = wx.MessageDialog(self, _(u"Souhaitez-vous vraiment supprimer ce restaurateur ?"), _(u"Suppression"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION)
if dlg.ShowModal() == wx.ID_YES :
DB = GestionDB.DB()
DB.ReqDEL("restaurateurs", "IDrestaurateur", IDrestaurateur)
DB.Close()
self.MAJ()
dlg.Destroy()
def OnBoutonOk(self, event):
# Vérification des données
nom = self.ctrl_nom.GetValue()
if nom == "" :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un nom pour ce modèle !"), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return
# Description
description = self.ctrl_description.GetValue()
# Adresse Exp
IDadresse = self.ctrl_exp.GetID()
if IDadresse == None :
dlg = wx.MessageDialog(self, _(u"Etes-vous sûr de ne pas vouloir sélectionner d'adresse d'expéditeur pour ce modèle ?"), _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
if dlg.ShowModal() != wx.ID_YES :
dlg.Destroy()
return
dlg.Destroy()
# Objet
objet = self.ctrl_objet.GetValue()
if objet == "" :
dlg = wx.MessageDialog(self, _(u"Etes-vous sûr de ne pas vouloir saisir d'objet de message pour ce modèle ?"), _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
if dlg.ShowModal() != wx.ID_YES :
dlg.Destroy()
return
dlg.Destroy()
# Récupération du texte
texteStr = self.ctrl_editeur.GetValue()
texteXML = self.ctrl_editeur.GetXML()
if len(texteStr) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un texte !"), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_editeur.SetFocus()
return
# Sauvegarde
DB = GestionDB.DB()
listeDonnees = [
("categorie", self.categorie),
("nom", nom),
("description", description),
("objet", objet),
("texte_xml", texteXML),
("IDadresse", IDadresse),
("defaut", self.defaut),
]
if self.IDmodele == None :
self.IDmodele = DB.ReqInsert("modeles_emails", listeDonnees)
else:
DB.ReqMAJ("modeles_emails", listeDonnees, "IDmodele", self.IDmodele)
DB.Close()
# Fermeture fenêtre
self.EndModal(wx.ID_OK)
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, name="DLG_Console_sql", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX|wx.THICK_FRAME)
self.parent = parent
# Bandeau
intro = _(u"Cette console SQL intégrée à Noethys peut être utilisée pour effectuer des opérations avancées sur la base de données.")
titre = _(u"Console SQL")
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(self, titre=titre, texte=intro, hauteurHtml=30, nomImage="Images/32x32/Sql.png")
# Contenu
self.db = GestionDB.DB()
self.ctrl = py.shell.Shell(self)
# Commandes
self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_fermer = CTRL_Bouton_image.CTRL(self, texte=_(u"Fermer"), cheminImage="Images/32x32/Fermer.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonFermer, self.bouton_fermer)
self.Bind(wx.EVT_CLOSE, self.OnBoutonFermer)
# Initialisation
wx.CallAfter(self.Initialisation)
def GetPresents(self):
if self.radio_inscrits.GetValue() == True :
# Tous les inscrits
return None
else:
# Uniquement les présents
date_debut = self.ctrl_date_debut.GetDate()
if self.ctrl_date_debut.FonctionValiderDate() == False or date_debut == None :
dlg = wx.MessageDialog(self, _(u"La date de début ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_debut.SetFocus()
return False
date_fin = self.ctrl_date_fin.GetDate()
if self.ctrl_date_fin.FonctionValiderDate() == False or date_fin == None :
dlg = wx.MessageDialog(self, _(u"La date de fin ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return False
if date_debut > date_fin :
dlg = wx.MessageDialog(self, _(u"La date de début est supérieure à la date de fin !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return False
return (date_debut, date_fin)
def __set_properties(self):
self.SetTitle(_(u"Supprimer une fiche"))
self.bouton_detacher.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour détacher la fiche")))
self.bouton_supprimer.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour supprimer la fiche")))
self.bouton_aide.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour obtenir de l'aide")))
self.bouton_annuler.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour annuler")))
self.SetMinSize((400, 240))
def OnBoutonAfficher(self, event):
""" Validation des données saisies """
# Vérifie date de référence
date_reference = self.ctrl_date.GetDate()
if self.ctrl_date.FonctionValiderDate() == False or date_reference == None :
dlg = wx.MessageDialog(self, _(u"La date de référence ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date.SetFocus()
return False
# Vérifie les activités sélectionnées
listeActivites = self.ctrl_activites.GetActivites()
if len(listeActivites) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune activité !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Uniquement les familles concernées
concernes = self.ctrl_options.GetConcernes()
# Vérifie Inscrits / Présents
presents = self.ctrl_options.GetPresents()
if presents == False : return
# Envoi des données
self.parent.MAJ(date_reference=date_reference, listeActivites=listeActivites, presents=presents, concernes=concernes)
return True
def OnContextMenu(self, event):
"""Ouverture du menu contextuel """
# Création du menu contextuel
menuPop = UTILS_Adaptations.Menu()
if len(self.Selection()) == 0:
noSelection = True
else:
noSelection = False
# Création du menu contextuel
menuPop = UTILS_Adaptations.Menu()
## # Item Assistant
## item = wx.MenuItem(menuPop, 100, _(u"Générer automatiquement des consommations"))
## bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Magique.png"), wx.BITMAP_TYPE_PNG)
## item.SetBitmap(bmp)
## menuPop.AppendItem(item)
## self.Bind(wx.EVT_MENU, self.Generer, id=100)
##
## menuPop.AppendSeparator()
##
## # Item Modifier
## item = wx.MenuItem(menuPop, 10, _(u"Ajouter"))
## bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ajouter.png"), wx.BITMAP_TYPE_PNG)
## item.SetBitmap(bmp)
## menuPop.AppendItem(item)
## self.Bind(wx.EVT_MENU, self.Ajouter, id=10)
##
## # Item Ajouter
## item = wx.MenuItem(menuPop, 20, _(u"Modifier"))
## bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Modifier.png"), wx.BITMAP_TYPE_PNG)
## item.SetBitmap(bmp)
## menuPop.AppendItem(item)
## self.Bind(wx.EVT_MENU, self.Modifier, id=20)
## if noSelection == True : item.Enable(False)
# Item Supprimer
item = wx.MenuItem(menuPop, 30, _(u"Supprimer"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.Supprimer, id=30)
if noSelection == True: item.Enable(False)
menuPop.AppendSeparator()
# Item Tout cocher
item = wx.MenuItem(menuPop, 70, _(u"Tout cocher"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Cocher.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.CocheTout, id=70)
# Item Tout décocher
item = wx.MenuItem(menuPop, 80, _(u"Tout décocher"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Decocher.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.CocheRien, id=80)
menuPop.AppendSeparator()
# Item Apercu avant impression
item = wx.MenuItem(menuPop, 40, _(u"Aperçu avant impression"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Apercu.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.Apercu, id=40)
# Item Imprimer
item = wx.MenuItem(menuPop, 50, _(u"Imprimer"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Imprimante.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.Imprimer, id=50)
menuPop.AppendSeparator()
# Item Export Texte
item = wx.MenuItem(menuPop, 600, _(u"Exporter au format Texte"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Texte2.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.ExportTexte, id=600)
# Item Export Excel
item = wx.MenuItem(menuPop, 700, _(u"Exporter au format Excel"))
bmp = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Excel.png"),
wx.BITMAP_TYPE_PNG)
item.SetBitmap(bmp)
menuPop.AppendItem(item)
self.Bind(wx.EVT_MENU, self.ExportExcel, id=700)
self.PopupMenu(menuPop)
menuPop.Destroy()
def ExportExcel(self, event):
from Utils import UTILS_Export
UTILS_Export.ExportExcel(self, titre=_(u"Liste des individus à inscrire"))
def Imprimer(self, event):
from Utils import UTILS_Printer
prt = UTILS_Printer.ObjectListViewPrinter(self, titre=_(u"Liste des individus à inscrire"), format="A", orientation=wx.PORTRAIT)
prt.Print()
def FormateAge(age):
if age == None : return ""
return _(u"%d ans") % age
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
def FormateDate(date):
return UTILS_Dates.DateDDEnFr(date)
def FormateAge(age):
if age == None : return ""
return _(u"%d ans") % age
def FormateInscrit(inscrit):
if inscrit == "oui" :
return "Oui"
else :
return ""
liste_Colonnes = [
ColumnDefn(_(u"IDindividu"), "left", 0, "IDindividu", typeDonnee="entier"),
ColumnDefn(_(u"Inscrit"), 'left', 50, "inscrit", typeDonnee="texte", stringConverter=FormateInscrit),
ColumnDefn(_(u"Nom"), 'left', 120, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Prénom"), "left", 120, "prenom", typeDonnee="texte"),
ColumnDefn(_(u"Date naiss."), "left", 80, "date_naiss", typeDonnee="date", stringConverter=FormateDate),
ColumnDefn(_(u"Age"), "left", 60, "age", typeDonnee="entier", stringConverter=FormateAge),
ColumnDefn(_(u"Famille"), "left", 280, "nomTitulaires", typeDonnee="texte"),
ColumnDefn(_(u"Rue"), "left", 200, "rue", typeDonnee="texte"),
ColumnDefn(_(u"CP"), "left", 50, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), "left", 150, "ville", typeDonnee="texte"),
ColumnDefn(_(u"Secteur"), "left", 150, "nomSecteur", typeDonnee="texte"),
]
self.SetColumns(liste_Colonnes)
self.CreateCheckStateColumn(0)
self.SetEmptyListMsg(_(u"Aucun individu"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[3])
self.SetObjects(self.donnees)
def Supprimer(self, event):
if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune consommation à supprimer dans la liste !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
if len(self.GetTracksCoches()) > 0:
# Suppression multiple
listeSelections = self.GetTracksCoches()
dlg = wx.MessageDialog(
self,
_(u"Souhaitez-vous vraiment supprimer les consommations cochées ?"
), _(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
else:
# Suppression unique
listeSelections = self.Selection()
dlg = wx.MessageDialog(
self,
_(u"Souhaitez-vous vraiment supprimer la consommation sélectionnée ?"
), _(u"Suppression"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
# Suppression
listeSuppressions = []
for track in listeSelections:
if track.etat in ("present", "absenti", "absentj"):
dlg = wx.MessageDialog(
self,
_(u"Vous ne pouvez pas supprimer la consommation '%s' du %s car elle est déjà pointée !"
) % (track.nomUnite, UTILS_Dates.DateDDEnFr(track.date)),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
listeSuppressions.append(track.index)
if track.IDconso != None:
self.GetGrandParent().GetGrandParent().GetParent(
).listeSuppressionConso.append(track.IDconso)
nouvelleListe = []
index = 0
for dictConso in self.listeDonnees:
if index not in listeSuppressions:
nouvelleListe.append(dictConso)
index += 1
self.listeDonnees = nouvelleListe
self.MAJ()
def ExportExcel(self, event):
from Utils import UTILS_Export
UTILS_Export.ExportExcel(self,
titre=_(u"Liste des consommations"),
autoriseSelections=False)
def ExportExcel(self, event):
from Utils import UTILS_Export
UTILS_Export.ExportExcel(self, titre=_(u"Liste des opérations"))
def Mesurer_distance(self, event):
# Recherche la destination
categories = self.notebook.GetPage(
"criteres").ctrl_categories.listeDonnees
produits = self.notebook.GetPage("criteres").ctrl_produits.listeDonnees
# Si aucune catégorie sélectionnée
if len(categories) == 0 and len(produits) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous devez d'abord sélectionner renseigner une catégorie ou un produit dans les critères !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Si une seule catégorie sélectionnée
if len(categories) == 1:
IDcategorie = categories[0][0]
else:
IDcategorie = None
# Si un seul produit sélectionné
if len(produits) == 1:
IDproduit = produits[0][0]
else:
IDproduit = None
if len(categories) > 1 or len(produits) > 1:
liste_donnees = []
liste_labels = []
for donnees in categories:
liste_donnees.append(("categories", donnees[0], donnees))
liste_labels.append(u"%s (categorie de produits)" % donnees[1])
for donnees in produits:
liste_donnees.append(("produits", donnees[0], donnees))
liste_labels.append(u"%s (produit)" % donnees[1])
dlg = wx.SingleChoiceDialog(
self, _(u"Sélectionnez la donnée qui vous intéresse :"),
_(u"Sélection d'une donnée"), liste_labels,
wx.CHOICEDLG_STYLE)
if dlg.ShowModal() == wx.ID_OK:
dlg.Destroy()
donnees = liste_donnees[dlg.GetSelection()]
if donnees[0] == "categories":
IDcategorie = donnees[1]
if donnees[0] == "produits":
IDproduit = donnees[1]
IDcategorie = donnees[2][2]
else:
dlg.Destroy()
return False
# DLG Mesure de la distance
from Dlg import DLG_Mesure_distance
dictParametres = {
"IDfamille": self.ctrl_loueur.GetIDfamille(),
"IDcategorie": IDcategorie,
"IDproduit": IDproduit,
}
dlg = DLG_Mesure_distance.Dialog(self, dictParametres=dictParametres)
dlg.ShowModal()
dlg.Destroy()
def MAJInformations(self):
""" MAJ du texte Informations """
dictDonnees = {
"nbreOperationsRapprochees": 0,
"nbreOperationsDebit": 0,
"totalOperationsDebit": 0.0,
"nbreOperationsCredit": 0,
"totalOperationsCredit": 0.0,
"modes": {},
}
for track in self.GetTracksCoches():
dictDonnees["nbreOperationsRapprochees"] += 1
if track.typeOperation == "debit":
dictDonnees["nbreOperationsDebit"] += 1
dictDonnees["totalOperationsDebit"] += track.montant
else:
dictDonnees["nbreOperationsCredit"] += 1
dictDonnees["totalOperationsCredit"] += track.montant
if track.IDmode != None:
if dictDonnees["modes"].has_key(track.IDmode) == False:
dictDonnees["modes"][track.IDmode] = {
"nom": track.nomMode,
"nbre": 0,
"total": 0.0
}
dictDonnees["modes"][track.IDmode]["nbre"] += 1
dictDonnees["modes"][track.IDmode]["total"] += track.montant
# Nbre opérations rapprochées
if dictDonnees["nbreOperationsRapprochees"] == 0:
texte = _(u"Aucune opération rapprochée")
elif dictDonnees["nbreOperationsRapprochees"] == 1:
texte = _(u"1 opération rapprochée")
else:
texte = _(u"%d opérations rapprochées"
) % dictDonnees["nbreOperationsRapprochees"]
# Opérations au débit
if dictDonnees["nbreOperationsDebit"] > 0:
if dictDonnees["nbreOperationsDebit"] == 1:
texte += _(u"<BR>1 opération au débit : %.2f %s") % (
dictDonnees["totalOperationsDebit"], SYMBOLE)
else:
texte += _(u"<BR>%d opérations au débit : %.2f %s") % (
dictDonnees["nbreOperationsDebit"],
dictDonnees["totalOperationsDebit"], SYMBOLE)
# Opérations au crédit
if dictDonnees["nbreOperationsCredit"] > 0:
if dictDonnees["nbreOperationsCredit"] == 1:
texte += _(u"<BR>1 opération au crédit : %.2f %s") % (
dictDonnees["totalOperationsCredit"], SYMBOLE)
else:
texte += _(u"<BR>%d opérations au crédit : %.2f %s") % (
dictDonnees["nbreOperationsCredit"],
dictDonnees["totalOperationsCredit"], SYMBOLE)
# Modes
for IDmode, donnees in dictDonnees["modes"].iteritems():
if donnees["nbre"] == 1:
texte += _(u"<BR>1 opération de type '%s' : %.2f %s") % (
donnees["nom"], donnees["total"], SYMBOLE)
else:
texte += _(u"<BR>%d opérations de type '%s' : %.2f %s") % (
donnees["nbre"], donnees["nom"], donnees["total"], SYMBOLE)
try:
self.GetParent().SetInformations(texte)
except:
print(texte, )
def __init__(self, parent):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.parent = parent
# Propositions
self.label_propositions = wx.StaticText(self, -1,
_(u"Produits proposés :"))
self.ctrl_propositions = OL_Produits.ListView(
self,
id=-1,
afficher_detail_location=False,
style=wx.LC_REPORT | wx.SUNKEN_BORDER | wx.LC_SINGLE_SEL
| wx.LC_HRULES | wx.LC_VRULES)
self.ctrl_propositions.SetMinSize((100, 50))
self.ctrl_propositions.afficher_uniquement_disponibles = True
# Options
self.radio_produits_disponibles = wx.RadioButton(
self, -1, _(u"Les produits disponibles"), style=wx.RB_GROUP)
self.radio_produits_possibles = wx.RadioButton(
self, -1, _(u"Les produits potentiels"))
self.radio_produits_disponibles.SetToolTip(
wx.ToolTip(
_(u"Afficher les produits disponibles répondant aux critères"
)))
self.radio_produits_possibles.SetToolTip(
wx.ToolTip(
_(u"Afficher tous les produits répondant aux critères donnés"
)))
# Bouton Attribuer
self.bouton_attribuer = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Attribuer le produit sélectionné"),
cheminImage="Images/32x32/Location.png")
self.bouton_attribuer.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour attribuer le produit sélectionné dans la liste"
)))
# Binds
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioProduits,
self.radio_produits_disponibles)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioProduits,
self.radio_produits_possibles)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAttribuer, self.bouton_attribuer)
# Layout
grid_sizer_base = wx.FlexGridSizer(rows=3, cols=1, vgap=5, hgap=5)
grid_sizer_base.Add(self.label_propositions, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL, 0)
grid_sizer_base.Add(self.ctrl_propositions, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL | wx.EXPAND, 0)
grid_sizer_commandes = wx.FlexGridSizer(rows=1, cols=4, vgap=5, hgap=5)
grid_sizer_commandes.Add(self.radio_produits_disponibles, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL, 0)
grid_sizer_commandes.Add(self.radio_produits_possibles, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL, 0)
grid_sizer_commandes.Add((10, 10), 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL, 0)
grid_sizer_commandes.Add(self.bouton_attribuer, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL, 0)
grid_sizer_commandes.AddGrowableCol(2)
grid_sizer_base.Add(grid_sizer_commandes, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ALL | wx.EXPAND, 0)
grid_sizer_base.AddGrowableCol(0)
grid_sizer_base.AddGrowableRow(1)
self.SetSizer(grid_sizer_base)
grid_sizer_base.Fit(self)
self.Layout()
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
def rowFormatter(listItem, track):
if track.date > datetime.date.today():
listItem.SetTextColour((180, 180, 180))
def FormateDate(date):
return UTILS_Dates.DateDDEnFr(date)
def FormateMontant(montant):
if montant == None: return u""
return u"%.2f %s" % (montant, SYMBOLE)
liste_Colonnes = [
ColumnDefn(u"", "left", 0, "IDoperation", typeDonnee="entier"),
ColumnDefn(_(u"Date"),
'left',
80,
"date",
typeDonnee="date",
stringConverter=FormateDate),
ColumnDefn(_(u"Libellé"),
'left',
180,
"libelle",
typeDonnee="texte",
isSpaceFilling=True),
ColumnDefn(_(u"Tiers"),
'left',
130,
"nomTiers",
typeDonnee="texte"),
ColumnDefn(_(u"Mode"), 'left', 90, "nomMode", typeDonnee="texte"),
ColumnDefn(_(u"N° Chèque"),
'left',
80,
"num_piece",
typeDonnee="texte"),
ColumnDefn(_(u"Débit"),
"right",
80,
"debit",
typeDonnee="montant",
stringConverter=FormateMontant),
ColumnDefn(_(u"Crédit"),
"right",
80,
"credit",
typeDonnee="montant",
stringConverter=FormateMontant),
]
self.rowFormatter = rowFormatter
self.SetColumns(liste_Colonnes)
self.CreateCheckStateColumn(0)
self.SetEmptyListMsg(_(u"Aucune opération"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[2])
self.SetObjects(self.donnees)
def OnBoutonOk(self, event):
# Date et heure de la demande
date_demande = self.ctrl_date_demande.GetDate()
if date_demande == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date pour cette demande !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_demande.SetFocus()
return
heure_demande = self.ctrl_heure_demande.GetHeure()
if heure_demande == None or self.ctrl_heure_demande.Validation(
) == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une heure pour cette demande !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_demande.SetFocus()
return
date_demande = datetime.datetime(year=date_demande.year,
month=date_demande.month,
day=date_demande.day,
hour=int(heure_demande[:2]),
minute=int(heure_demande[3:]))
# Loueur
IDfamille = self.ctrl_loueur.GetIDfamille()
if IDfamille == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un loueur pour cette demande !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Observations
observations = self.ctrl_observations.GetValue()
# Critères
categories = UTILS_Texte.ConvertListeToStr(
self.notebook.GetPage(
"criteres").ctrl_categories.GetListeCategories())
produits = UTILS_Texte.ConvertListeToStr(
self.notebook.GetPage("criteres").ctrl_produits.GetListeProduits())
# Statut
statut = self.ctrl_statut.GetCodePageActive()
motif_refus = self.ctrl_statut.GetPageByCode(
"refusee").ctrl_motif.GetValue()
IDlocation = self.ctrl_attribution.GetIDlocation(
) # self.ctrl_statut.GetPageByCode("attribuee").GetIDlocation()
if IDlocation != None:
statut = "attribuee"
# Sauvegarde
DB = GestionDB.DB()
listeDonnees = [
("date", date_demande),
("IDfamille", IDfamille),
("observations", observations),
("categories", categories),
("produits", produits),
("statut", statut),
("motif_refus", motif_refus),
("IDlocation", IDlocation),
]
if self.IDdemande == None:
self.IDdemande = DB.ReqInsert("locations_demandes", listeDonnees)
else:
DB.ReqMAJ("locations_demandes", listeDonnees, "IDdemande",
self.IDdemande)
# Sauvegarde des filtres
listeID = []
for dictFiltre in self.notebook.GetPage(
"criteres").ctrl_filtres.GetDonnees():
listeID.append(dictFiltre["IDfiltre"])
listeDonnees = [
("IDquestion", dictFiltre["IDquestion"]),
("categorie", "location_demande"),
("choix", dictFiltre["choix"]),
("criteres", dictFiltre["criteres"]),
("IDdonnee", self.IDdemande),
]
# Sauvegarde dans DB
if dictFiltre["IDfiltre"] == None:
IDfiltre = DB.ReqInsert("questionnaire_filtres", listeDonnees)
else:
DB.ReqMAJ("questionnaire_filtres", listeDonnees, "IDfiltre",
dictFiltre["IDfiltre"])
for dictInitialFiltre in self.listeInitialeFiltres:
if dictInitialFiltre["IDfiltre"] not in listeID:
DB.ReqDEL("questionnaire_filtres", "IDfiltre",
dictInitialFiltre["IDfiltre"])
# Sauvegarde du questionnaire
self.notebook.GetPage("questionnaire").ctrl_questionnaire.Sauvegarde(
DB=DB, IDdonnee=self.IDdemande)
# Fermeture de la base
DB.Close()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def __init__(self, parent, IDdemande=None, IDfamille=None):
wx.Dialog.__init__(self,
parent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.parent = parent
self.IDdemande = IDdemande
self.listeInitialeFiltres = []
if self.IDdemande == None:
self.SetTitle(_(u"Saisie d'une demande"))
else:
self.SetTitle(_(u"Modification d'une demande"))
# Généralités
self.staticbox_generalites_staticbox = wx.StaticBox(
self, -1, _(u"Généralités"))
self.label_loueur = wx.StaticText(self, -1, _(u"Loueur :"))
self.ctrl_loueur = CTRL_Loueur(self)
self.ctrl_loueur.SetFont(
wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_BOLD, False, 'Arial'))
self.bouton_loueur = wx.Button(self, -1, _(u"Sélectionner"))
self.label_date_demande = wx.StaticText(self, -1, _(u"Date :"))
self.ctrl_date_demande = CTRL_Saisie_date.Date2(self)
self.ctrl_heure_demande = CTRL_Saisie_heure.Heure(self)
self.label_observations = wx.StaticText(self, -1, _(u"Notes :"))
self.ctrl_observations = wx.TextCtrl(self,
-1,
u"",
style=wx.TE_MULTILINE)
# Notebook
self.notebook = Notebook(self, IDdemande=IDdemande)
# Statut
self.staticbox_statut_staticbox = wx.StaticBox(self, -1, _(u"Statut"))
self.ctrl_statut = CTRL_Statut(self)
self.ctrl_statut.SetMinSize((50, 100))
# Attribution
self.ctrl_attribution = CTRL_Attribution(self)
self.ctrl_attribution.SetMinSize((50, 50))
# Boutons
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_outils = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Outils"),
cheminImage="Images/32x32/Configuration.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.OnBoutonLoueur, self.bouton_loueur)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOutils, self.bouton_outils)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
# Init contrôles
maintenant = datetime.datetime.now()
self.ctrl_date_demande.SetDate(
datetime.datetime.strftime(maintenant, "%Y-%m-%d"))
self.ctrl_heure_demande.SetHeure(
datetime.datetime.strftime(maintenant, "%H:%M"))
if IDfamille != None:
self.ctrl_loueur.SetIDfamille(IDfamille)
self.bouton_loueur.Show(False)
self.Importation()
self.notebook.GetPage("questionnaire").ctrl_questionnaire.MAJ()
def MAJ_page(self, page=None):
dlgAttente = wx.BusyInfo(_(u"Veuillez patienter..."), self.parent)
page.MAJ()
del dlgAttente
def __init__(self, parent, IDdemande=None):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.parent = parent
self.IDdemande = IDdemande
self.label_categories = wx.StaticText(self, -1, _(u"Catégories :"))
self.ctrl_categories = CTRL_Categories(self)
self.bouton_categories = wx.Button(self, -1, _(u"Sélectionner"))
self.label_produits = wx.StaticText(self, -1, _(u"Produits :"))
self.ctrl_produits = CTRL_Produits(self)
self.bouton_produits = wx.Button(self, -1, _(u"Sélectionner"))
self.label_filtres = wx.StaticText(self,
-1,
_(u"Questions :"),
style=wx.ALIGN_RIGHT)
self.ctrl_filtres = OL_Filtres_questionnaire.ListView(
self,
listeDonnees=[],
listeTypes=[
"produit",
],
CallFonctionOnMAJ=self.MAJListePropositions,
id=-1,
style=wx.LC_REPORT | wx.LC_NO_HEADER | wx.SUNKEN_BORDER
| wx.LC_SINGLE_SEL | wx.LC_HRULES | wx.LC_VRULES)
self.ctrl_filtres.SetMinSize((400, 50))
self.bouton_ajouter = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Ajouter.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_modifier = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Modifier.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_supprimer = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Supprimer.png"),
wx.BITMAP_TYPE_ANY))
# Properties
self.ctrl_categories.SetToolTip(
wx.ToolTip(_(u"Cliquez ici pour sélectionner des catégories")))
self.bouton_categories.SetToolTip(
wx.ToolTip(_(u"Choix de catégories")))
self.ctrl_produits.SetToolTip(
wx.ToolTip(_(u"Cliquez ici pour sélectionner des produits")))
self.bouton_produits.SetToolTip(wx.ToolTip(_(u"Choix de catégories")))
self.bouton_ajouter.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour saisir un filtre sur les questionnaires"))
)
self.bouton_modifier.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour modifier le filtre sélectionné")))
self.bouton_supprimer.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour supprimer le filtre sélectionné")))
# Binds
self.Bind(wx.EVT_BUTTON, self.Ajouter_filtre, self.bouton_ajouter)
self.Bind(wx.EVT_BUTTON, self.Modifier_filtre, self.bouton_modifier)
self.Bind(wx.EVT_BUTTON, self.Supprimer_filtre, self.bouton_supprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonCategories,
self.bouton_categories)
self.Bind(wx.EVT_BUTTON, self.OnBoutonProduits, self.bouton_produits)
# Layout
sizer_base = wx.BoxSizer(wx.VERTICAL)
grid_sizer_criteres = wx.FlexGridSizer(rows=3,
cols=2,
vgap=10,
hgap=10)
grid_sizer_criteres.Add(self.label_categories, 0,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL, 0)
grid_sizer_categories = wx.FlexGridSizer(1, 2, 5, 5)
grid_sizer_categories.Add(self.ctrl_categories, 0, wx.EXPAND, 0)
grid_sizer_categories.Add(self.bouton_categories, 0, 0, 0)
grid_sizer_categories.AddGrowableCol(0)
grid_sizer_criteres.Add(grid_sizer_categories, 1, wx.EXPAND, 0)
grid_sizer_criteres.Add(self.label_produits, 0,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL, 0)
grid_sizer_produits = wx.FlexGridSizer(1, 2, 5, 5)
grid_sizer_produits.Add(self.ctrl_produits, 0, wx.EXPAND, 0)
grid_sizer_produits.Add(self.bouton_produits, 0, 0, 0)
grid_sizer_produits.AddGrowableCol(0)
grid_sizer_criteres.Add(grid_sizer_produits, 1, wx.EXPAND, 0)
grid_sizer_criteres.Add(self.label_filtres, 0, wx.ALIGN_RIGHT, 0)
grid_sizer_filtres = wx.FlexGridSizer(rows=1, cols=2, vgap=5, hgap=5)
grid_sizer_filtres.Add(self.ctrl_filtres, 1, wx.EXPAND, 0)
grid_sizer_boutons = wx.FlexGridSizer(rows=3, cols=1, vgap=5, hgap=5)
grid_sizer_boutons.Add(self.bouton_ajouter, 0, wx.ALL, 0)
grid_sizer_boutons.Add(self.bouton_modifier, 0, wx.ALL, 0)
grid_sizer_boutons.Add(self.bouton_supprimer, 0, wx.ALL, 0)
grid_sizer_filtres.Add(grid_sizer_boutons, 1, wx.ALL, 0)
grid_sizer_filtres.AddGrowableCol(0)
grid_sizer_filtres.AddGrowableRow(0)
grid_sizer_criteres.Add(grid_sizer_filtres, 1, wx.EXPAND, 0)
grid_sizer_criteres.AddGrowableCol(1)
grid_sizer_criteres.AddGrowableRow(2)
sizer_base.Add(grid_sizer_criteres, 1, wx.ALL | wx.EXPAND, 10)
self.SetSizer(sizer_base)
sizer_base.Fit(self)
self.Layout()
def __init__(self, parent, mode="familles"):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.parent = parent
self.mode = mode
if self.mode == "familles":
texte1 = _(u"Toutes les familles")
texte2 = _(u"Les familles inactives depuis plus de")
texte3 = _(u"Les familles actives depuis")
else:
texte1 = _(u"Tous les individus")
texte2 = _(u"Les individus inactifs depuis plus de")
texte3 = _(u"Les individus actifs depuis")
self.radio_tous = wx.RadioButton(self, -1, texte1, style=wx.RB_GROUP)
self.radio_sans_activite = wx.RadioButton(self, -1, texte2)
self.ctrl_date_sans_activite = wx.Choice(
self, -1, choices=[x[2] for x in CHOIX_DELAIS])
self.ctrl_date_sans_activite.Select(5)
self.radio_avec_activite = wx.RadioButton(self, -1, texte3)
self.ctrl_date_avec_activite = wx.Choice(
self, -1, choices=[x[2] for x in CHOIX_DELAIS])
self.ctrl_date_avec_activite.Select(5)
self.listviewAvecFooter = OL_Archivage.ListviewAvecFooter(
self, kwargs={"mode": self.mode})
self.listviewAvecFooter.SetMinSize((50, 300))
self.ctrl_listview = self.listviewAvecFooter.GetListview()
self.ctrl_recherche = OL_Archivage.CTRL_Outils(
self, listview=self.ctrl_listview, afficherCocher=True)
self.ctrl_recherche.bouton_filtrer.SetBackgroundColour(wx.WHITE)
self.ctrl_recherche.bouton_cocher.SetBackgroundColour(wx.WHITE)
self.bouton_ouvrir_fiche = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Famille.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_apercu = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Apercu.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_imprimer = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Imprimante.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_texte = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Texte2.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_excel = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Excel.png"),
wx.BITMAP_TYPE_ANY))
# Properties
self.bouton_ouvrir_fiche.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour ouvrir la fiche famille correspondante")))
self.bouton_apercu.SetToolTip(
wx.ToolTip(_(u"Cliquez ici pour créer un aperçu de la liste")))
self.bouton_imprimer.SetToolTip(
wx.ToolTip(_(u"Cliquez ici pour imprimer la liste")))
self.bouton_texte.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour exporter la liste au format Texte")))
self.bouton_excel.SetToolTip(
wx.ToolTip(
_(u"Cliquez ici pour exporter la liste au format Excel")))
# Binds
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioSelection, self.radio_tous)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioSelection,
self.radio_sans_activite)
self.Bind(wx.EVT_CHOICE, self.OnRadioSelection,
self.ctrl_date_sans_activite)
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioSelection,
self.radio_avec_activite)
self.Bind(wx.EVT_CHOICE, self.OnRadioSelection,
self.ctrl_date_avec_activite)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.OuvrirFicheFamille,
self.bouton_ouvrir_fiche)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.Apercu, self.bouton_apercu)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.Imprimer,
self.bouton_imprimer)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.ExportTexte,
self.bouton_texte)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.ExportExcel,
self.bouton_excel)
# Layout
sizer_base = wx.BoxSizer(wx.VERTICAL)
grid_sizer_base = wx.FlexGridSizer(rows=2, cols=2, vgap=5, hgap=5)
grid_sizer_haut = wx.FlexGridSizer(rows=1, cols=6, vgap=5, hgap=5)
grid_sizer_haut.Add(self.radio_tous, 0, wx.EXPAND, 0)
grid_sizer_haut.Add(self.radio_sans_activite, 0, wx.EXPAND, 0)
grid_sizer_haut.Add(self.ctrl_date_sans_activite, 0, wx.EXPAND, 0)
grid_sizer_haut.Add((5, 5), 0, wx.EXPAND, 0)
grid_sizer_haut.Add(self.radio_avec_activite, 0, wx.EXPAND, 0)
grid_sizer_haut.Add(self.ctrl_date_avec_activite, 0, wx.EXPAND, 0)
grid_sizer_base.Add(grid_sizer_haut, 0, wx.EXPAND, 0)
grid_sizer_base.Add((10, 10), 1, wx.EXPAND, 0)
# Liste + Barre de recherche
grid_sizer_gauche = wx.FlexGridSizer(rows=3, cols=1, vgap=10, hgap=10)
grid_sizer_gauche.Add(self.listviewAvecFooter, 0, wx.EXPAND, 0)
grid_sizer_gauche.Add(self.ctrl_recherche, 0, wx.EXPAND, 0)
grid_sizer_gauche.AddGrowableRow(0)
grid_sizer_gauche.AddGrowableCol(0)
grid_sizer_base.Add(grid_sizer_gauche, 1, wx.EXPAND, 0)
# Commandes
grid_sizer_droit = wx.FlexGridSizer(rows=10, cols=1, vgap=5, hgap=5)
grid_sizer_droit.Add(self.bouton_ouvrir_fiche, 0, 0, 0)
grid_sizer_droit.Add((5, 5), 0, 0, 0)
grid_sizer_droit.Add(self.bouton_apercu, 0, 0, 0)
grid_sizer_droit.Add(self.bouton_imprimer, 0, 0, 0)
grid_sizer_droit.Add((5, 5), 0, 0, 0)
grid_sizer_droit.Add(self.bouton_texte, 0, 0, 0)
grid_sizer_droit.Add(self.bouton_excel, 0, 0, 0)
grid_sizer_base.Add(grid_sizer_droit, 1, wx.EXPAND, 0)
grid_sizer_base.AddGrowableRow(1)
grid_sizer_base.AddGrowableCol(0)
sizer_base.Add(grid_sizer_base, 1, wx.ALL | wx.EXPAND, 10)
self.SetSizer(sizer_base)
self.Layout()
# Init
self.OnRadioSelection()
self.ctrl_listview.MAJ()
def __init__(self, parent, track=None):
if parent == None:
dlgparent = None
else:
dlgparent = parent.parent
wx.Dialog.__init__(self,
dlgparent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
| wx.THICK_FRAME)
self.parent = parent
self.track = track
self.reponse = ""
# Bandeau
intro = _(
u"Vous pouvez gérer ici la demande de façon manuelle. Commencez par cliquer sur le bouton 'Appliquer la demande' pour voir apparaître les modifications demandées dans la grille des conso. Vous pouvez alors effectuer manuellement d'éventuelles modifications avant de valider."
)
titre = _(u"Traitement manuel des réservations")
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Calendrier_modifier.png")
# Facturation
self.box_facturation_staticbox = wx.StaticBox(self, wx.ID_ANY,
_(u"Facturation"))
self.ctrl_facturation = CTRL_Grille_facturation.CTRL(self)
self.ctrl_facturation.SetMinSize((275, 100))
# Détail demande
self.box_demande_staticbox = wx.StaticBox(self, wx.ID_ANY,
_(u"Détail de la demande"))
self.ctrl_demande = CTRL_Html(self,
couleurFond=self.GetBackgroundColour())
self.ctrl_demande.SetMinSize((275, 100))
# Grille
self.box_grille_staticbox = wx.StaticBox(
self, wx.ID_ANY, _(u"Grille des consommations"))
self.ctrl_grille = DLG_Badgeage_grille.CTRL(
self, panel_facturation=self.ctrl_facturation)
# Journal
self.box_journal_staticbox = wx.StaticBox(self, wx.ID_ANY,
_(u"Journal d'évènements"))
self.ctrl_log = CTRL_Log(self)
self.ctrl_log.SetMinSize((100, 80))
self.bouton_traiter = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Appliquer la demande"),
cheminImage="Images/32x32/Fleche_bas.png")
self.bouton_reinit = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Annuler les modifications"),
cheminImage="Images/32x32/Actualiser.png")
# Boutons
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_outils = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Outils"),
cheminImage="Images/32x32/Configuration.png")
self.bouton_ok = CTRL_Bouton_image.CTRL(
self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_fermer = CTRL_Bouton_image.CTRL(
self, texte=_(u"Annuler"), cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonTraiter, self.bouton_traiter)
self.Bind(wx.EVT_BUTTON, self.OnBoutonReinit, self.bouton_reinit)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
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.OnBoutonFermer, self.bouton_fermer)
self.Bind(wx.EVT_CLOSE, self.OnBoutonFermer)
# Init
if self.parent != None:
self.parent.Init_grille(ctrl_grille=self.ctrl_grille)
self.ctrl_demande.SetTexte(
self.parent.parent.ctrl_description.GetTexte())
def GetTracks(self):
""" Récupération des données """
# Récupération du IDfichier
IDfichier = FonctionsPerso.GetIDfichier()
# Lecture des fichiers du répertoire SYNC
listeFichiers = os.listdir(UTILS_Fichiers.GetRepSync())
listeListeView = []
for nomFichier in listeFichiers:
if nomFichier.startswith("actions_%s" % IDfichier) and (
nomFichier.endswith(".dat") or
(nomFichier.endswith(".archive")
and self.inclure_archives == True)):
nomFichierCourt = nomFichier.replace(".dat", "").replace(
".archive", "")
# Taille fichier
tailleFichier = os.path.getsize(
UTILS_Fichiers.GetRepSync(nomFichier))
# Horodatage
horodatage = nomFichierCourt.split("_")[2]
horodatage = UTILS_Dates.HorodatageEnDatetime(horodatage)
# Lecture du contenu du fichier
DB = GestionDB.DB(
suffixe=None,
nomFichier=UTILS_Fichiers.GetRepSync(nomFichier),
modeCreation=False)
req = """SELECT IDparametre, nom, valeur
FROM parametres;"""
DB.ExecuterReq(req)
listeParametres = DB.ResultatReq()
dictParametres = {}
for IDparametre, nom, valeur in listeParametres:
dictParametres[nom] = valeur
if dictParametres.has_key("nom_appareil") == False:
dictParametres["nom_appareil"] = "Appareil inconnu"
if dictParametres.has_key("ID_appareil") == False:
dictParametres["ID_appareil"] = "IDAppareil inconnu"
liste_details_actions = []
req = """SELECT IDconso, horodatage, action
FROM consommations;"""
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
if len(listeConsommations) > 0:
liste_details_actions.append(
_(u"%d actions sur les consommations") %
len(listeConsommations))
req = """SELECT IDmemo, horodatage, action
FROM memo_journee;"""
DB.ExecuterReq(req)
listeMemosJournees = DB.ResultatReq()
if len(listeMemosJournees) > 0:
liste_details_actions.append(
_(u"%d actions sur les mémos journaliers") %
len(listeMemosJournees))
DB.Close()
detail_actions = ", ".join(liste_details_actions)
if detail_actions == "":
detail_actions = _(u"Aucune action")
dictTemp = {
"nom_fichier": nomFichier,
"taille_fichier": tailleFichier,
"nom_appareil": dictParametres["nom_appareil"],
"ID_appareil": dictParametres["ID_appareil"],
"horodatage": horodatage,
"detail_actions": detail_actions
}
listeListeView.append(Track(dictTemp))
return listeListeView
def __init__(self, parent):
wx.Notebook.__init__(self, parent, id=-1)
self.parent = parent
self.donnees = {}
self.SetPadding((10, 8))
self.listePages = [
{
"code":
"familles",
"label":
_(u"Familles"),
"page":
Page_Familles_individus(self, "familles"),
"image":
wx.Bitmap(Chemins.GetStaticPath(u"Images/32x32/Famille.png"),
wx.BITMAP_TYPE_PNG)
},
{
"code":
"individus",
"label":
_(u"Individus"),
"page":
Page_Familles_individus(self, "individus"),
"image":
wx.Bitmap(Chemins.GetStaticPath(u"Images/32x32/Personnes.png"),
wx.BITMAP_TYPE_PNG)
},
{
"code":
"listes_diffusion",
"label":
_(u"Listes de diffusion"),
"page":
Page_Listes_diffusion(self),
"image":
wx.Bitmap(
Chemins.GetStaticPath(u"Images/32x32/Questionnaire.png"),
wx.BITMAP_TYPE_PNG)
},
{
"code":
"saisie_manuelle",
"label":
_(u"Saisie manuelle"),
"page":
Page_Saisie_manuelle(self),
"image":
wx.Bitmap(Chemins.GetStaticPath(u"Images/32x32/Contrat.png"),
wx.BITMAP_TYPE_PNG)
},
]
# Images
self.imageList = wx.ImageList(32, 32)
for dictPage in self.listePages:
self.imageList.Add(dictPage["image"])
self.AssignImageList(self.imageList)
# Création des pages
index = 0
for dictPage in self.listePages:
self.AddPage(dictPage["page"], dictPage["label"], imageId=index)
index += 1
self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnPageChanged)
def __set_properties(self):
self.bouton_ajouter.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour ajouter un groupe")))
self.bouton_modifier.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour modifier le groupe selectionné dans la liste")))
self.bouton_supprimer.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour supprimer le groupe selectionné dans la liste")))
self.bouton_monter.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour monter le groupe sélectionné dans la liste")))
self.bouton_descendre.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour descendre le groupe sélectionné dans la liste")))
# Licence: Licence GNU GPL
#------------------------------------------------------------------------
import Chemins
from Utils import UTILS_Adaptations
from Utils.UTILS_Traduction import _
import wx
from Ctrl import CTRL_Bouton_image
import datetime
import GestionDB
from Ctrl import CTRL_Bandeau
from Ol import OL_Archivage
from dateutil import relativedelta
CHOIX_DELAIS = [
("mois", 1, _(u"1 mois")),
("mois", 2, _(u"2 mois")),
("mois", 3, _(u"3 mois")),
("mois", 6, _(u"6 mois")),
("annees", 1, _(u"1 an")),
("annees", 2, _(u"2 ans")),
("annees", 3, _(u"3 ans")),
("annees", 4, _(u"4 ans")),
("annees", 5, _(u"5 ans")),
("annees", 6, _(u"6 ans")),
]
class Page(wx.Panel):
def __init__(self, parent, mode="familles"):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
def __set_properties(self):
self.bouton_aide.SetToolTip(
wx.ToolTip(_(u"Cliquez ici pour obtenir de l'aide")))
self.bouton_fermer.SetToolTip(wx.ToolTip(
_(u"Cliquez ici pour fermer")))
self.SetMinSize((940, 700))
def ExportExcel(self, event):
from Utils import UTILS_Export
UTILS_Export.ExportExcel(
self, titre=_(u"Liste des fichiers à synchroniser"))
def InitObjectListView(self):
# Création du imageList
for categorie, civilites in Civilites.LISTE_CIVILITES:
for IDcivilite, CiviliteLong, CiviliteAbrege, nomImage, genre in civilites:
indexImg = self.AddNamedImages(
nomImage,
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/%s" % nomImage),
wx.BITMAP_TYPE_PNG))
def GetImageCivilite(track):
return track.nomImage
def FormateDate(dateStr):
if dateStr == "" or dateStr == None: return ""
date = str(
datetime.date(year=int(dateStr[:4]),
month=int(dateStr[5:7]),
day=int(dateStr[8:10])))
text = str(date[8:10]) + "/" + str(date[5:7]) + "/" + str(date[:4])
return text
def FormateAge(age):
if age == None: return ""
return _(u"%d ans") % age
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
liste_Colonnes = [
ColumnDefn(u"",
"left",
22,
"IDindividu",
typeDonnee="entier",
imageGetter=GetImageCivilite),
ColumnDefn(_(u"Nom"), 'left', 100, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Prénom"),
"left",
100,
"prenom",
typeDonnee="texte"),
ColumnDefn(_(u"Date naiss."),
"left",
72,
"date_naiss",
typeDonnee="date",
stringConverter=FormateDate),
ColumnDefn(_(u"Age"),
"left",
50,
"age",
typeDonnee="entier",
stringConverter=FormateAge),
]
self.SetColumns(liste_Colonnes)
self.SetEmptyListMsg(_(u"Aucun individu"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
return False
# Validation
return True
def Sauvegarde(self):
pass
class MyFrame(wx.Frame):
def __init__(self, *args, **kwds):
wx.Frame.__init__(self, *args, **kwds)
panel = wx.Panel(self, -1)
sizer_1 = wx.BoxSizer(wx.VERTICAL)
sizer_1.Add(panel, 1, wx.ALL|wx.EXPAND)
self.SetSizer(sizer_1)
self.ctrl= Panel(panel, IDactivite=37)
sizer_2 = wx.BoxSizer(wx.VERTICAL)
sizer_2.Add(self.ctrl, 1, wx.ALL|wx.EXPAND, 4)
panel.SetSizer(sizer_2)
self.Layout()
self.CentreOnScreen()
if __name__ == '__main__':
app = wx.App(0)
#wx.InitAllImageHandlers()
frame_1 = MyFrame(None, -1, _(u"TEST"), size=(700, 500))
app.SetTopWindow(frame_1)
frame_1.Show()
app.MainLoop()
def InitObjectListView(self):
# Création du imageList
for categorie, civilites in Civilites.LISTE_CIVILITES:
for IDcivilite, CiviliteLong, CiviliteAbrege, nomImage, genre in civilites:
indexImg = self.AddNamedImages(
nomImage,
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/%s" % nomImage),
wx.BITMAP_TYPE_PNG))
def GetImageCivilite(track):
return track.nomImage
def FormateDate(dateStr):
if dateStr == "" or dateStr == None: return ""
date = str(
datetime.date(year=int(dateStr[:4]),
month=int(dateStr[5:7]),
day=int(dateStr[8:10])))
text = str(date[8:10]) + "/" + str(date[5:7]) + "/" + str(date[:4])
return text
def FormateAge(age):
if age == None: return ""
return _(u"%d ans") % age
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
if self.categorie == "individus":
# INDIVIDUS
liste_Colonnes = [
ColumnDefn(u"",
"left",
22,
"IDindividu",
typeDonnee="entier",
imageGetter=GetImageCivilite),
ColumnDefn(_(u"Nom"), 'left', 100, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Prénom"),
"left",
100,
"prenom",
typeDonnee="texte"),
ColumnDefn(_(u"Date naiss."),
"left",
72,
"date_naiss",
typeDonnee="date",
stringConverter=FormateDate),
ColumnDefn(_(u"Age"),
"left",
50,
"age",
typeDonnee="entier",
stringConverter=FormateAge),
ColumnDefn(_(u"Rue"),
"left",
150,
"rue_resid",
typeDonnee="texte"),
ColumnDefn(_(u"C.P."),
"left",
50,
"cp_resid",
typeDonnee="texte"),
ColumnDefn(_(u"Ville"),
"left",
120,
"ville_resid",
typeDonnee="texte"),
## ColumnDefn(_(u"Tél. domicile"), "left", 100, "tel_domicile"),
## ColumnDefn(_(u"Tél. mobile"), "left", 100, "tel_mobile"),
ColumnDefn(_(u"Email"),
"left",
150,
"mail",
typeDonnee="texte"),
## ColumnDefn(_(u"Profession"), "left", 150, "profession"),
## ColumnDefn(_(u"Employeur"), "left", 150, "employeur"),
## ColumnDefn(_(u"Tél pro."), "left", 100, "travail_tel"),
## ColumnDefn(_(u"Email pro."), "left", 150, "travail_mail"),
]
else:
# FAMILLES
liste_Colonnes = [
ColumnDefn(_(u"ID"),
"left",
0,
"IDfamille",
typeDonnee="entier"),
ColumnDefn(_(u"Famille"),
'left',
200,
"nomTitulaires",
typeDonnee="texte"),
ColumnDefn(_(u"Rue"), "left", 160, "rue", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 45, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"),
"left",
120,
"ville",
typeDonnee="texte"),
ColumnDefn(_(u"Email"),
"left",
100,
"mail",
typeDonnee="texte"),
ColumnDefn(_(u"Régime"),
"left",
130,
"regime",
typeDonnee="texte"),
ColumnDefn(_(u"Caisse"),
"left",
130,
"caisse",
typeDonnee="texte"),
ColumnDefn(_(u"Numéro Alloc."),
"left",
120,
"numAlloc",
typeDonnee="texte"),
]
# Ajout des questions des questionnaires
for dictQuestion in self.LISTE_QUESTIONS:
nomChamp = "question_%d" % dictQuestion["IDquestion"]
#typeDonnee = UTILS_Infos_individus.GetTypeChamp(nomChamp)
filtre = dictQuestion["filtre"]
if filtre == "texte": typeDonnee = "texte"
elif filtre == "entier": typeDonnee = "entier"
elif filtre == "montant": typeDonnee = "montant"
elif filtre == "choix": typeDonnee = "texte"
elif filtre == "coche": typeDonnee = "texte"
elif filtre == "date": typeDonnee = "date"
else: typeDonnee = "texte"
liste_Colonnes.append(
ColumnDefn(dictQuestion["label"],
"left",
150,
"question_%d" % dictQuestion["IDquestion"],
typeDonnee=typeDonnee))
self.SetColumns(liste_Colonnes)
self.CreateCheckStateColumn(0)
if self.categorie == "individus":
self.SetEmptyListMsg(_(u"Aucun individu"))
else:
self.SetEmptyListMsg(_(u"Aucune famille"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[2])
self.SetObjects(self.donnees)
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.parent = parent
intro = _(
u"Vous pouvez ici saisir, modifier ou supprimer des activités. Une activité peut être un Accueil de Loisirs, un séjour de vacances, une cantine scolaire, une garderie périscolaire, une crèche, une activité sportive ou culturelle, etc..."
)
titre = _(u"Gestion des activités")
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Activite.png")
self.ctrl_listview = OL_Activites.ListView(
self,
id=-1,
style=wx.LC_REPORT | wx.SUNKEN_BORDER | wx.LC_SINGLE_SEL
| wx.LC_HRULES | wx.LC_VRULES)
self.ctrl_listview.MAJ()
self.ctrl_recherche = OL_Activites.CTRL_Outils(
self, listview=self.ctrl_listview)
self.bouton_ajouter = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ajouter.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_modifier = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Modifier.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_supprimer = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_dupliquer = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Dupliquer.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_importer = wx.BitmapButton(
self, -1,
wx.Bitmap(
Chemins.GetStaticPath(u"Images/16x16/Document_import.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_exporter = wx.BitmapButton(
self, -1,
wx.Bitmap(
Chemins.GetStaticPath(u"Images/16x16/Document_export.png"),
wx.BITMAP_TYPE_ANY))
self.ctrl_activites_ouvertes = wx.CheckBox(
self, -1, _(u"Afficher uniquement les activités ouvertes"))
self.ctrl_activites_ouvertes.SetFont(
wx.Font(8, wx.FONTFAMILY_DEFAULT, wx.NORMAL, wx.NORMAL))
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_fermer = CTRL_Bouton_image.CTRL(
self,
id=wx.ID_CANCEL,
texte=_(u"Fermer"),
cheminImage="Images/32x32/Fermer.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.Ajouter, self.bouton_ajouter)
self.Bind(wx.EVT_BUTTON, self.Modifier, self.bouton_modifier)
self.Bind(wx.EVT_BUTTON, self.Supprimer, self.bouton_supprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonDupliquer, self.bouton_dupliquer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonImporter, self.bouton_importer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonExporter, self.bouton_exporter)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_CHECKBOX, self.OnCocheActivitesOuvertes,
self.ctrl_activites_ouvertes)
def GetListeFamilles(listview=None,
listeActivites=None,
presents=None,
IDfamille=None,
infosIndividus=None):
""" Récupération des infos familles """
# Conditions Activites
if listeActivites == None or listeActivites == []:
conditionActivites = ""
else:
if len(listeActivites) == 1:
conditionActivites = " AND inscriptions.IDactivite=%d" % listeActivites[
0]
else:
conditionActivites = " AND inscriptions.IDactivite IN %s" % str(
tuple(listeActivites))
# Conditions Présents
conditionPresents = ""
jointurePresents = ""
if presents != None:
conditionPresents = " AND (consommations.date>='%s' AND consommations.date<='%s')" % (
str(presents[0]), str(presents[1]))
jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu"
# Condition Famille donnée
conditionFamilles = ""
if IDfamille != None:
conditionFamilles = " AND familles.IDfamille=%d" % IDfamille
# Récupération des régimes et num d'alloc pour chaque famille
DB = GestionDB.DB()
req = """
SELECT
familles.IDfamille, regimes.nom, caisses.nom, num_allocataire
FROM familles
LEFT JOIN inscriptions ON inscriptions.IDfamille = familles.IDfamille
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
%s
AND inscriptions.IDfamille = familles.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime
WHERE (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') %s %s %s
GROUP BY familles.IDfamille
;""" % (jointurePresents, datetime.date.today(), conditionActivites,
conditionPresents, conditionFamilles)
DB.ExecuterReq(req)
listeFamilles = DB.ResultatReq()
DB.Close()
# Formatage des données
listeListeView = []
titulaires = UTILS_Titulaires.GetTitulaires()
for IDfamille, nomRegime, nomCaisse, numAlloc in listeFamilles:
dictTemp = {}
if IDfamille != None and titulaires.has_key(IDfamille):
nomTitulaires = titulaires[IDfamille]["titulairesSansCivilite"]
rue = titulaires[IDfamille]["adresse"]["rue"]
cp = titulaires[IDfamille]["adresse"]["cp"]
ville = titulaires[IDfamille]["adresse"]["ville"]
listeMails = titulaires[IDfamille]["listeMails"]
else:
nomTitulaires = _(u"Aucun titulaire")
rue = u""
cp = u""
ville = u""
listeMails = []
dictTemp = {
"IDfamille": IDfamille,
"titulaires": nomTitulaires,
"nomRegime": nomRegime,
"nomCaisse": nomCaisse,
"numAlloc": numAlloc,
"rue": rue,
"cp": cp,
"ville": ville,
"listeMails": listeMails,
}
# Formatage sous forme de TRACK
track = TrackFamille(listview, dictTemp, infosIndividus)
listeListeView.append(track)
return listeListeView
def ExportExcel(self, event):
from Utils import UTILS_Export
UTILS_Export.ExportExcel(self,
titre=_(u"Liste des %s") % self.categorie)
