import Chemins
from Utils.UTILS_Traduction import _
import wx
from Ctrl import CTRL_Bouton_image
import os
import datetime
import six
import decimal
from Dlg import DLG_Selection_liste
import FonctionsPerso
from Ctrl import CTRL_Bandeau
from Utils import UTILS_Fichiers
from Utils import UTILS_Dates
from Utils import UTILS_Config
SYMBOLE = UTILS_Config.GetParametre("monnaie_symbole", u"¤")
from Utils import UTILS_Interface
from Ctrl.CTRL_ObjectListView import FastObjectListView, ColumnDefn, Filter, CTRL_Outils
def GetValeursListview(listview=None, format="texte"):
""" Récupère les valeurs affichées sous forme de liste """
""" format = "texte" ou "original" """
# Récupère les labels de colonnes
listeColonnes = []
for colonne in listview.columns:
listeColonnes.append(
(colonne.title, colonne.align, colonne.width, colonne.valueGetter))
# Récupère les valeurs
def GetRepertoireMySQL(dictValeurs={}):
""" Récupère le répertoire d'installation MySQL
dictValeurs = valeurs de connexion
"""
# Récupération du chemin de MySQL à partir de la base de données
## import MySQLdb
## connexion = MySQLdb.connect(host=dictValeurs["hote"],user=dictValeurs["utilisateur"], passwd=dictValeurs["mdp"], port=dictValeurs["port"], use_unicode=True)
## connexion.set_character_set('utf8')
## cursor = connexion.cursor()
## cursor.execute("SELECT @@basedir;")
## donnees = cursor.fetchall()
## if len(donnees) == 0 :
## return None
## return donnees[0][0]
# 1- Recherche automatique
if "linux" in sys.platform:
if os.path.isfile(u"/usr/bin/mysqldump") and os.path.isfile(
u"/usr/bin/mysql"):
return u"/usr/"
else:
# Vérifie le chemin Canon (x86)
chemin = "C:/Program Files (x86)/Canon/Easy-WebPrint EX/"
if os.path.isfile(chemin + "bin/mysql.exe"):
return chemin
# Vérifie le chemin Canon
chemin = "C:/Program Files/Canon/Easy-WebPrint EX/"
if os.path.isfile(chemin + "bin/mysql.exe"):
return chemin
# Vérifie le chemin MySQL classique
try:
listeFichiers1 = os.listdir(u"C:/")
for fichier1 in listeFichiers1:
if "Program" in fichier1:
listeFichiers2 = os.listdir(u"C:/%s" % fichier1)
for fichier2 in listeFichiers2:
if "MySQL" in fichier2:
listeFichiers3 = os.listdir(u"C:/%s/%s" %
(fichier1, fichier2))
listeFichiers3.sort(reverse=True)
for fichier3 in listeFichiers3:
if "MySQL Server" in fichier3:
chemin = u"C:/%s/%s/%s/" % (
fichier1, fichier2, fichier3)
if os.path.isfile(chemin +
"bin/mysql.exe"):
return chemin
except:
pass
# 2- Recherche dans le fichier Config
try:
chemin = UTILS_Config.GetParametre("sauvegarde_cheminmysql",
defaut=None)
if chemin != None:
if os.path.isdir(chemin):
return chemin
except:
pass
# 3- Demande le chemin à l'utilisateur
try:
if "linux" in sys.platform:
message = _(
u"Pour effectuer la sauvegarde de fichiers réseau, mysqlclient doit être installé. Sélectionnez ici le répertoire où se trouve 'mysqldump' sur votre ordinateur."
)
else:
message = _(
u"Pour effectuer la sauvegarde de fichiers réseau, Noethys \ndoit utiliser les outils de MySQL. Sélectionnez ici le répertoire qui se nomme 'MySQL Server...' sur votre ordinateur."
)
dlg = wx.DirDialog(None,
message,
style=wx.DD_DEFAULT_STYLE | wx.DD_DIR_MUST_EXIST)
if dlg.ShowModal() == wx.ID_OK:
chemin = dlg.GetPath() + u"/"
dlg.Destroy()
else:
dlg.Destroy()
return None
except:
pass
try:
if os.path.isdir(chemin + _(u"bin/")):
UTILS_Config.SetParametre("sauvegarde_cheminmysql", chemin)
return chemin
except:
pass
return None
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
-1,
name="DLG_Impression_infos_medicales",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
| wx.THICK_FRAME)
self.parent = parent
intro = _(
u"Vous pouvez ici imprimer une liste au format PDF des informations médicales des individus présents sur la période de votre choix. Pour une liste standard, sélectionnez simplement une période puis cliquez sur 'Aperçu'."
)
titre = _(u"Impression de la liste des informations médicales")
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Imprimante.png")
# Calendrier
self.staticbox_date_staticbox = wx.StaticBox(self, -1, _(u"Période"))
self.ctrl_calendrier = CTRL_Grille_periode.CTRL(self)
self.ctrl_calendrier.SetMinSize((230, 150))
# Activités
self.staticbox_activites_staticbox = wx.StaticBox(
self, -1, _(u"Activités"))
self.ctrl_activites = CTRL_Activites(self)
self.ctrl_activites.SetMinSize((10, 50))
# Groupes
self.staticbox_groupes_staticbox = wx.StaticBox(
self, -1, _(u"Groupes"))
self.ctrl_groupes = CTRL_Groupes(self)
# Options
self.staticbox_options_staticbox = wx.StaticBox(
self, -1, _(u"Options"))
self.label_modele = wx.StaticText(self, -1, _(u"Modèle :"))
self.ctrl_modele = wx.Choice(self,
-1,
choices=[
_(u"Modèle par défaut"),
])
self.ctrl_modele.Select(0)
self.label_tri = wx.StaticText(self, -1, _(u"Tri :"))
self.ctrl_tri = wx.Choice(self,
-1,
choices=["Nom",
_(u"Prénom"),
_(u"Age")])
self.ctrl_tri.Select(0)
self.ctrl_ordre = wx.Choice(self,
-1,
choices=["Croissant",
_(u"Décroissant")])
self.ctrl_ordre.Select(0)
self.checkbox_lignes_vierges = wx.CheckBox(
self, -1, _(u"Afficher des lignes vierges :"))
self.checkbox_lignes_vierges.SetValue(True)
self.ctrl_nbre_lignes = wx.Choice(self,
-1,
choices=[
"1", "2", "3", "4", "5", "6",
"7", "8", "9", "10", "11", "12",
"13", "14", "15"
])
self.ctrl_nbre_lignes.Select(2)
self.checkbox_page_groupe = wx.CheckBox(
self, -1, _(u"Insérer un saut de page après chaque groupe"))
self.checkbox_page_groupe.SetValue(True)
self.checkbox_nonvides = wx.CheckBox(
self, -1, _(u"Afficher uniquement les individus avec infos"))
self.checkbox_nonvides.SetValue(False)
self.checkbox_age = wx.CheckBox(self, -1,
_(u"Afficher l'âge des individus"))
self.checkbox_age.SetValue(True)
self.checkbox_photos = wx.CheckBox(self, -1,
_(u"Afficher les photos :"))
self.checkbox_photos.SetValue(False)
self.ctrl_taille_photos = wx.Choice(self,
-1,
choices=[
_(u"Petite taille"),
_(u"Moyenne taille"),
_(u"Grande taille")
])
self.ctrl_taille_photos.SetSelection(1)
# Mémorisation des paramètres
self.ctrl_memoriser = wx.CheckBox(self, -1,
_(u"Mémoriser les paramètres"))
font = self.GetFont()
font.SetPointSize(7)
self.ctrl_memoriser.SetFont(font)
self.ctrl_memoriser.SetValue(True)
# Boutons
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"Aperçu"), cheminImage="Images/32x32/Apercu.png")
self.bouton_annuler = 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_CHECKBOX, self.OnCheckLignesVierges,
self.checkbox_lignes_vierges)
self.Bind(wx.EVT_CHECKBOX, self.OnCheckPhotos, self.checkbox_photos)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
# Récupération des paramètres dans le CONFIG
param_tri = UTILS_Config.GetParametre("impression_infos_med_tri",
defaut=0)
self.ctrl_tri.Select(param_tri)
param_ordre = UTILS_Config.GetParametre("impression_infos_med_ordre",
defaut=0)
self.ctrl_ordre.Select(param_ordre)
param_lignes_vierges = UTILS_Config.GetParametre(
"impression_infos_med_lignes_vierges", defaut=1)
self.checkbox_lignes_vierges.SetValue(param_lignes_vierges)
if param_lignes_vierges == 1:
param_nbre_lignes_vierges = UTILS_Config.GetParametre(
"impression_infos_med_nbre_lignes_vierges", defaut=2)
self.ctrl_nbre_lignes.Select(param_nbre_lignes_vierges)
param_page_groupe = UTILS_Config.GetParametre(
"impression_infos_med_page_groupe", defaut=1)
self.checkbox_page_groupe.SetValue(param_page_groupe)
param_nonvides = UTILS_Config.GetParametre(
"impression_infos_med_nonvides", defaut=0)
self.checkbox_nonvides.SetValue(param_nonvides)
param_age = UTILS_Config.GetParametre("impression_infos_med_age",
defaut=1)
self.checkbox_age.SetValue(param_age)
param_photos = UTILS_Config.GetParametre("impression_infos_med_photos",
defaut=1)
self.checkbox_photos.SetValue(param_photos)
param_taille_photos = UTILS_Config.GetParametre(
"impression_infos_med_taille_photos", defaut=1)
self.ctrl_taille_photos.SetSelection(param_taille_photos)
param_memoriser = UTILS_Config.GetParametre(
"impression_infos_med_memoriser", defaut=1)
self.ctrl_memoriser.SetValue(param_memoriser)
# Init Contrôles
self.OnCheckLignesVierges(None)
self.OnCheckPhotos(None)
self.bouton_ok.SetFocus()
self.ctrl_calendrier.SetVisibleSelection()
self.SetListesPeriodes(self.ctrl_calendrier.GetDatesSelections())
self.grid_sizer_base.Fit(self)
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
-1,
name="DLG_Enregistrement",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
| wx.THICK_FRAME)
self.parent = parent
self.derniereValidation = (None, None)
# Bandeau
titre = _(u"Enregistrement")
intro = _(
u"Vous pouvez saisir ici votre code d'enregistrement personnel afin d'activer votre abonnement Classic ou Premium. Effectuez ce paramétrage sur chacun de vos postes."
)
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Cle.png")
# Saisie code
self.staticbox_code_staticbox = wx.StaticBox(
self, -1, _(u"Code d'enregistrement"))
self.label_identifiant = wx.StaticText(self, -1, _(u"Identifiant :"))
self.ctrl_identifiant = wx.TextCtrl(self, -1, "")
self.label_code = wx.StaticText(self, -1, _(u"Code :"))
self.ctrl_code = masked.TextCtrl(self,
-1,
"",
mask="AAAA-AAAA-AAAA-AAAA-AAAA",
formatcodes="F!")
self.ctrl_code.SetMinSize((190, -1))
self.bouton_validite = wx.Button(self, -1,
_(u"Vérifier la validité"))
self.ctrl_image = wx.StaticBitmap(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/absenti.png"),
wx.BITMAP_TYPE_ANY))
self.label_validite = wx.StaticText(self, -1,
_(u"Veuillez saisir un code."))
# HTML
self.ctrl_html = MyHtml(self, texte=TEXTE, hauteur=30)
# Boutons
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.OnBoutonValidite, self.bouton_validite)
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.OnClose)
# Init contrôles
identifiant = UTILS_Config.GetParametre("enregistrement_identifiant",
defaut=None)
code = UTILS_Config.GetParametre("enregistrement_code", defaut=None)
if identifiant != None and code != None:
self.ctrl_identifiant.SetValue(identifiant)
self.ctrl_code.SetValue(code)
self.VerifieEtat(identifiant, code)
# Vérifie droits utilisateurs
if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel(
"parametrage_enregistrement", "modifier",
afficheMessage=False) == False:
self.ctrl_identifiant.Enable(False)
self.ctrl_code.Enable(False)
self.bouton_validite.Enable(False)
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
# Bandeau
intro = _(
u"Vous pouvez ici synchroniser les données avec Nomadhys, l'application nomade pour Noethys. Choisissez une méthode de synchronisation (Serveur direct WIFI/Internet ou FTP ou Manuel) puis renseignez les paramètres. Cliquez sur le bouton 'Lire les données' pour importer les données."
)
titre = _(u"Synchroniser Nomadhys")
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Nomadhys.png")
# Paramètres
self.box_parametres = wx.StaticBox(self, -1, _(u"Paramètres"))
self.ctrl_parametres = Notebook(self)
# Transfert
self.box_transfert = wx.StaticBox(self, -1, _(u"Transfert manuel"))
self.ctrl_mode = CTRL_Mode(self)
self.bouton_envoyer = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Envoyer"),
cheminImage="Images/32x32/Fleche_haut.png")
self.bouton_recevoir = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Recevoir"),
cheminImage="Images/32x32/Fleche_bas.png")
# Lecture
self.box_lecture = wx.StaticBox(self, -1,
_(u"Importation des données"))
self.ctrl_fichiers = OL_Synchronisation_fichiers.ListView(
self,
id=-1,
style=wx.LC_REPORT | wx.SUNKEN_BORDER | wx.LC_SINGLE_SEL
| wx.LC_HRULES | wx.LC_VRULES)
self.ctrl_recherche = OL_Synchronisation_fichiers.CTRL_Outils(
self, listview=self.ctrl_fichiers, afficherCocher=True)
self.check_archives = wx.CheckBox(self, -1,
_(u"Afficher les archives"))
self.bouton_actualiser = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Rafraîchir la liste"),
cheminImage="Images/32x32/Actualiser.png")
self.bouton_lecture = wx.BitmapButton(
self, -1,
wx.Bitmap(
Chemins.GetStaticPath("Images/BoutonsImages/Lire_donnees.png"),
wx.BITMAP_TYPE_ANY))
# Boutons
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_googleplay = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Télécharger Nomadhys"),
cheminImage="Images/32x32/Googleplay.png")
self.bouton_outils = CTRL_Bouton_image.CTRL(
self,
texte=_(u"Outils"),
cheminImage="Images/32x32/Configuration.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_CHECKBOX, self.OnCheckArchives, self.check_archives)
self.Bind(wx.EVT_BUTTON, self.OnBoutonEnvoyer, self.bouton_envoyer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonRecevoir, self.bouton_recevoir)
self.Bind(wx.EVT_BUTTON, self.OnBoutonActualiser,
self.bouton_actualiser)
self.Bind(wx.EVT_BUTTON, self.OnBoutonLecture, self.bouton_lecture)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonGoogleplay,
self.bouton_googleplay)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOutils, self.bouton_outils)
self.Bind(wx.EVT_BUTTON, self.OnBoutonFermer, self.bouton_fermer)
self.Bind(wx.EVT_CLOSE, self.OnClose)
# Init
self.SuppressionArchives()
self.ctrl_parametres.ImportationParametres()
self.ctrl_mode.SetMode(
UTILS_Config.GetParametre("synchro_mode_favori", defaut="ftp"))
self.ctrl_fichiers.MAJ()
wx.CallAfter(self.AfficheAvertissement)
import Chemins
from Utils.UTILS_Traduction import _
import wx
import CTRL_Bouton_image
import wx.lib.agw.hypertreelist as HTL
from wx.lib.agw.customtreectrl import EVT_TREE_ITEM_CHECKED
import datetime
import copy
import sys
import traceback
import decimal
import wx.lib.agw.pybusyinfo as PBI
from Utils import UTILS_Config
SYMBOLE = UTILS_Config.GetParametre("monnaie_symbole", u"¤")
MONNAIE_SINGULIER = UTILS_Config.GetParametre("monnaie_singulier", _(u"Euro"))
MONNAIE_DIVISION = UTILS_Config.GetParametre("monnaie_division", _(u"Centime"))
import GestionDB
import FonctionsPerso
from Utils import UTILS_Impression_rappel
from Dlg import DLG_Apercu_rappel
from Utils import UTILS_Rappels
from Utils import UTILS_Dates
from Dlg.DLG_Saisie_texte_rappel import MOTSCLES
class CTRL_document(wx.Choice):
def __init__(self,
def MAJ(self, forcerActualisation=False):
# Recherche des données
condition = ""
listeFiltreGroupesActivites = None
DB = GestionDB.DB()
# Recherche des paramètres
parametres = UTILS_Config.GetParametre("nbre_inscrits_parametre_activites", defaut=None)
if parametres != None :
code, liste = parametres.split("###")
if liste != "" :
listeID = []
for ID in liste.split(";") :
listeID.append(int(ID))
if code == "liste_groupes_activites" :
listeFiltreGroupesActivites = listeID
req = """SELECT IDtype_groupe_activite, IDactivite
FROM groupes_activites
WHERE IDtype_groupe_activite IN %s
;""" % GestionDB.ConvertConditionChaine(listeID)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActivites = []
for IDtype_groupe_activite, IDactivite in listeDonnees :
listeActivites.append(IDactivite)
condition = "WHERE activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(listeActivites)
if code == "liste_activites" :
condition = "WHERE activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(listeID)
# Tri
tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3)
if tri == 0 :
tri = "activites.nom"
elif tri == 1 :
tri = "activites.date_debut"
elif tri == 2 :
tri = "activites.date_fin"
elif tri == 3 :
tri = "activites.abrege"
else :
tri = "activites.nom"
# Sens
sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1)
if sens == 0 :
sens = ""
else :
sens = "DESC"
# Seuil d'alerte
self.seuil_alerte = UTILS_Config.GetParametre("nbre_inscrits_parametre_alerte", 5)
# Regroupement par groupe d'activités
self.regroupement_groupe_activites = UTILS_Config.GetParametre("nbre_inscrits_parametre_regroup", 0)
# Récupération des groupes
req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.abrege, groupes.nbre_inscrits_max,
COUNT(inscriptions.IDinscription) as nbre_inscriptions
FROM groupes
LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite
LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe
%s
GROUP BY groupes.IDgroupe
ORDER BY groupes.ordre
;""" % condition
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
dictGroupes = {}
for IDgroupe, IDactivite, nom, abrege, nbre_inscrits_max, nbre_inscrits in listeGroupes :
if nbre_inscrits == None : nbre_inscrits = 0
if nom == None : nom = _(u"Sans nom !")
if abrege == None : abrege = ""
if nbre_inscrits_max != None :
nbre_places_libres = nbre_inscrits_max - nbre_inscrits
else :
nbre_places_libres = None
if dictGroupes.has_key(IDactivite) == False :
dictGroupes[IDactivite] = []
dictGroupes[IDactivite].append({"IDgroupe" : IDgroupe, "nom" : nom, "abrege" : abrege, "nbre_inscrits_max" : nbre_inscrits_max, "nbre_inscrits" : nbre_inscrits, "nbre_places_libres" : nbre_places_libres, "IDactivite" : IDactivite})
# Récupération des activités
activite_ouverte = UTILS_Config.GetParametre("nbre_inscrits_parametre_ouvert", 1)
if activite_ouverte == 1 :
if condition == "" :
condition = "WHERE activites.date_fin>='%s'" % str(datetime.date.today())
else :
condition += " AND activites.date_fin>='%s'" % str(datetime.date.today())
req = """SELECT activites.IDactivite, activites.nom, activites.abrege, activites.nbre_inscrits_max
FROM activites
%s
GROUP BY activites.IDactivite
ORDER BY %s %s
;""" % (condition, tri, sens)
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
listeActivitesTemp = []
listeIDactivite = []
for IDactivite, nom, abrege, nbre_inscrits_max in listeActivites :
if nom == None : nom = _(u"Sans nom !")
if abrege == None : abrege = ""
liste_groupes = []
if dictGroupes.has_key(IDactivite) :
liste_groupes = dictGroupes[IDactivite]
nbre_inscrits = 0
liste_infos = [nom,]
for dictGroupe in liste_groupes :
nbre_inscrits += dictGroupe["nbre_inscrits"]
liste_infos.append(dictGroupe["nom"])
if nbre_inscrits_max != None :
nbre_places_libres = nbre_inscrits_max - nbre_inscrits
else :
nbre_places_libres = None
listeActivitesTemp.append({"IDactivite" : IDactivite, "nom" : nom, "abrege" : abrege, "nbre_inscrits_max" : nbre_inscrits_max, "nbre_inscrits" : nbre_inscrits, "nbre_places_libres" : nbre_places_libres, "liste_groupes" : liste_groupes, "infos" : " ".join(liste_infos)})
listeIDactivite.append(IDactivite)
# Pour éviter l'actualisation de l'affichage si aucune modification des données
if self.listeActivites != listeActivitesTemp or forcerActualisation == True :
self.listeActivites = listeActivitesTemp
else :
DB.Close()
return
# Récupération des groupes d'activités
if self.regroupement_groupe_activites == 1 :
req = """SELECT groupes_activites.IDtype_groupe_activite, nom, IDactivite
FROM groupes_activites
LEFT JOIN types_groupes_activites ON types_groupes_activites.IDtype_groupe_activite = groupes_activites.IDtype_groupe_activite
WHERE IDactivite IN %s
;""" % GestionDB.ConvertConditionChaine(listeIDactivite)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictGroupeParActivite = {}
dictGroupesActivites = {}
for IDtype_groupe_activite, nom, IDactivite in listeDonnees :
if not dictGroupeParActivite.has_key(IDactivite) :
dictGroupeParActivite[IDactivite] = []
dictGroupeParActivite[IDactivite].append(IDtype_groupe_activite)
if not dictGroupesActivites.has_key(IDtype_groupe_activite) :
dictGroupesActivites[IDtype_groupe_activite] = nom
liste_groupes_activites = []
for IDtype_groupe_activite, nom in dictGroupesActivites.iteritems() :
if listeFiltreGroupesActivites == None or IDtype_groupe_activite in listeFiltreGroupesActivites :
liste_groupes_activites.append((nom.upper(), IDtype_groupe_activite))
liste_groupes_activites.sort()
else :
liste_groupes_activites = [(None, None),]
DB.Close()
# MAJ du contrôle
self.DeleteChildren(self.root)
# Préparation pour impression
self.dictImpression["contenu"] = []
self.dictImpression["coloration"] = []
for nom, IDtype_groupe_activite in liste_groupes_activites :
if nom == None :
niveau_parent = self.root
else :
niveau_regroup = self.AppendItem(self.root, nom)
self.SetItemBackgroundColour(niveau_regroup, "#DDDDDD")
self.dictImpression["contenu"].append([nom,])
self.dictImpression["coloration"].append((len(self.dictImpression["contenu"])-1, "regroup"))
niveau_parent = niveau_regroup
for dictActivite in self.listeActivites :
if self.filtre == None or (self.filtre.lower() in dictActivite["infos"].lower()) :
IDactivite = dictActivite["IDactivite"]
if self.regroupement_groupe_activites == 0 or (self.regroupement_groupe_activites == 1 and dictGroupeParActivite.has_key(IDactivite) and IDtype_groupe_activite in dictGroupeParActivite[IDactivite]) :
# Ligne Activité
label = u" " + dictActivite["nom"]
niveau_activite = self.AppendItem(niveau_parent, label)
font = self.GetFont()
font.SetWeight(wx.BOLD)
self.SetItemFont(niveau_activite, font)
self.SetPyData(niveau_activite, dictActivite)
# Abrégé
self.SetItemText(niveau_activite, dictActivite["abrege"], 1)
# Valeurs
nbre_inscrits = dictActivite["nbre_inscrits"]
if nbre_inscrits == None :
texte_inscrits = ""
else :
texte_inscrits = str(nbre_inscrits)
self.SetItemText(niveau_activite, texte_inscrits, 2)
nbre_inscrits_max = dictActivite["nbre_inscrits_max"]
if nbre_inscrits_max == None :
texte_inscrits_max = ""
else :
texte_inscrits_max = str(nbre_inscrits_max)
self.SetItemText(niveau_activite, texte_inscrits_max, 3)
nbre_places_libres = dictActivite["nbre_places_libres"]
if nbre_places_libres == None :
texte_places_libres = ""
else :
texte_places_libres = str(nbre_places_libres)
self.SetItemText(niveau_activite, texte_places_libres, 4)
# Couleur de la ligne
couleur_fond = self.GetCouleurLigne(nbre_places_libres)
if couleur_fond != None :
self.SetItemBackgroundColour(niveau_activite, couleur_fond)
# Mémorisation ligne activité pour impression
self.dictImpression["contenu"].append([label, dictActivite["abrege"], texte_inscrits, texte_inscrits_max, texte_places_libres])
self.dictImpression["coloration"].append((len(self.dictImpression["contenu"])-1, "activite"))
# Ligne Groupe
for dictGroupe in dictActivite["liste_groupes"] :
label = u" " + dictGroupe["nom"]
niveau_groupe = self.AppendItem(niveau_activite, label)
self.SetPyData(niveau_groupe, dictGroupe)
# Abrégé
self.SetItemText(niveau_groupe, dictGroupe["abrege"], 1)
nbre_inscrits = dictGroupe["nbre_inscrits"]
if nbre_inscrits == None :
texte_inscrits = ""
else :
texte_inscrits = str(nbre_inscrits)
self.SetItemText(niveau_groupe, texte_inscrits, 2)
nbre_inscrits_max = dictGroupe["nbre_inscrits_max"]
if nbre_inscrits_max == None :
texte_inscrits_max = ""
else :
texte_inscrits_max = str(nbre_inscrits_max)
self.SetItemText(niveau_groupe, texte_inscrits_max, 3)
nbre_places_libres = dictGroupe["nbre_places_libres"]
if nbre_places_libres == None :
texte_places_libres = ""
else :
texte_places_libres = str(nbre_places_libres)
self.SetItemText(niveau_groupe, texte_places_libres, 4)
# Couleur de la ligne
couleur_fond = self.GetCouleurLigne(nbre_places_libres)
if couleur_fond != None :
self.SetItemBackgroundColour(niveau_groupe, couleur_fond)
# Mémorisation ligne activité pour impression
self.dictImpression["contenu"].append([u" %s" % label, dictGroupe["abrege"], texte_inscrits, texte_inscrits_max, texte_places_libres])
self.ExpandAllChildren(self.root)
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, name="DLG_Gestionnaire_conso", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX|wx.THICK_FRAME)
self.parent = parent
self._mgr = aui.AuiManager()
self._mgr.SetManagedWindow(self)
# Détermine la taille de la fenêtre
self.SetMinSize((700, 600))
taille_fenetre = UTILS_Config.GetParametre("taille_fenetre_tableau_presences")
if taille_fenetre == None :
self.SetSize((900, 600))
if taille_fenetre == (0, 0) :
self.Maximize(True)
else:
self.SetSize(taille_fenetre)
self.CenterOnScreen()
# Récupère les perspectives
cfg = UTILS_Config.FichierConfig()
self.userConfig = cfg.GetDictConfig()
if self.userConfig.has_key("gestionnaire_perspectives") == True :
self.perspectives = self.userConfig["gestionnaire_perspectives"]
else:
self.perspectives = []
if self.userConfig.has_key("gestionnaire_perspective_active") == True :
self.perspective_active = self.userConfig["gestionnaire_perspective_active"]
else:
self.perspective_active = None
# Création du notebook
self.panel_grille = PanelGrille(self)
self.dictActivites = self.panel_grille.grille.dictActivites
self.dictIndividus = self.panel_grille.grille.dictIndividus
self.dictGroupes = self.panel_grille.grille.dictGroupes
self.listeSelectionIndividus = self.panel_grille.grille.listeSelectionIndividus
# Création des panels amovibles
self.panel_commandes = Commandes(self)
self._mgr.AddPane(self.panel_commandes, aui.AuiPaneInfo().
Name("commandes").Caption(_(u"Commandes")).
Bottom().Layer(0).Position(1).CaptionVisible(False).CloseButton(False).MaximizeButton(False).MinSize((-1, 50)))
self.panel_totaux = CTRL_Grille_totaux.CTRL(self, grille=self.panel_grille.grille)
self._mgr.AddPane(self.panel_totaux, aui.AuiPaneInfo().
Name("totaux").Caption(_(u"Totaux")).
Bottom().Layer(0).Position(0).Row(1).CloseButton(False).MaximizeButton(False).MinSize((160, 100)))
self.panel_calendrier = CTRL_Grille_calendrier.CTRL(self)
self._mgr.AddPane(self.panel_calendrier, aui.AuiPaneInfo().
Name("calendrier").Caption(_(u"Sélection de la date")).
Left().Layer(1).BestSize(wx.Size(195, 180)).Position(1).CloseButton(False).Fixed().MaximizeButton(False))
self.panel_activites = CTRL_Grille_activite3.CTRL(self)
self._mgr.AddPane(self.panel_activites, aui.AuiPaneInfo().
Name("activites").Caption(_(u"Sélection des activités")).
Left().Layer(1).Position(1).CloseButton(False).MaximizeButton(False).BestSize(wx.Size(-1,50)))
pi = self._mgr.GetPane("activites")
pi.dock_proportion = 100000 # Proportion
self.panel_legende = OL_Legende_grille.ListView(self, id=-1, name="OL_legende", style=wx.LC_REPORT|wx.LC_NO_HEADER | wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL)
self.panel_legende.SetSize((50, 50))
self._mgr.AddPane(self.panel_legende, aui.AuiPaneInfo().
Name("legende").Caption(_(u"Légende")).
Left().Layer(1).Position(2).CloseButton(False).MaximizeButton(False).MinSize((160, 100)).MaxSize((-1, 120)) )
self.panel_raccourcis = OL_Raccourcis_grille.ListView(self, id=-1, name="OL_raccourcis", style=wx.LC_REPORT|wx.LC_NO_HEADER | wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL)
self.panel_raccourcis.SetSize((50, 50))
self._mgr.AddPane(self.panel_raccourcis, aui.AuiPaneInfo().
Name("raccourcis").Caption(_(u"Touches raccourcis")).
Left().Layer(1).Position(3).CloseButton(False).MaximizeButton(False).MinSize((160, 100)).MaxSize((-1, 120)) )
self._mgr.GetPane("raccourcis").dock_proportion = 60000
self.panel_etiquettes = CTRL_Etiquettes.CTRL(self, activeMenu=False)
self._mgr.AddPane(self.panel_etiquettes, aui.AuiPaneInfo().
Name("etiquettes").Caption(_(u"Etiquettes")).
Right().Layer(0).Position(0).CloseButton(False).BestSize(wx.Size(275, 100)).MaximizeButton(False).MinSize((275, 100)))
self._mgr.GetPane("etiquettes").Hide()
self.panel_forfaits = CTRL_Grille_forfaits.CTRL(self, grille=self.panel_grille.grille)
self._mgr.AddPane(self.panel_forfaits, aui.AuiPaneInfo().
Name("forfaits").Caption(_(u"Forfaits crédits")).
Right().Layer(0).Position(1).BestSize(wx.Size(275,140)).Position(4).CloseButton(False).MaximizeButton(False).MinSize((275, 100)))
self._mgr.GetPane("forfaits").Hide()
# Création du panel central
self._mgr.AddPane(self.panel_grille, aui.AuiPaneInfo().Name("grille").
CenterPane())
self._mgr.GetPane("grille").Show()
# Sauvegarde de la perspective par défaut
self.perspective_defaut = self._mgr.SavePerspective()
# Récupération de la perspective chargée
if self.perspective_active != None :
self._mgr.LoadPerspective(self.perspectives[self.perspective_active]["perspective"])
else:
self._mgr.LoadPerspective(self.perspective_defaut)
# Affichage du panneau du panneau Forfait Credits
if self.panel_grille.grille.tarifsForfaitsCreditsPresents == True :
self._mgr.GetPane("forfaits").Show()
else:
self._mgr.GetPane("forfaits").Hide()
# Affichage du panneau du panneau Etiquettes
if self.panel_grille.grille.afficherListeEtiquettes == True :
self._mgr.GetPane("etiquettes").Show()
else:
self._mgr.GetPane("etiquettes").Hide()
self._mgr.Update()
self.SetTitle(_(u"Gestionnaire des consommations"))
self.Bind(wx.EVT_CLOSE, self.OnClose)
# Initialisation des contrôles
date = self.panel_calendrier.GetDate()
## self.SetDate(date)
# Init
self.panel_activites.SetCocherParDefaut(UTILS_Config.GetParametre("gestionnaire_conso_cocher_activites", defaut=True))
# Affichage du panneau du panneau Forfait Credits
## if self.panel_grille.grille.tarifsForfaitsCreditsPresents == True :
## self._mgr.GetPane("forfaits").Show()
## else:
## self._mgr.GetPane("forfaits").Hide()
## self._mgr.Update()
# Contre le bug de maximize
wx.CallAfter(self._mgr.Update)
def MAJ(self, forcerActualisation=False):
condition = ""
DB = GestionDB.DB()
# Recherche des paramètres
parametres = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_activites", defaut=None)
if parametres != None:
code, liste = parametres.split("###")
if liste != "":
listeID = []
for ID in liste.split(";"):
listeID.append(int(ID))
if code == "liste_groupes_activites":
req = """SELECT IDtype_groupe_activite, IDactivite
FROM groupes_activites
WHERE IDtype_groupe_activite IN %s
;""" % GestionDB.ConvertConditionChaine(listeID)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActivites = []
for IDtype_groupe_activite, IDactivite in listeDonnees:
listeActivites.append(IDactivite)
condition = "WHERE activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeActivites)
if code == "liste_activites":
condition = "WHERE activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeID)
# Tri
tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3)
if tri == 0:
tri = "activites.nom"
elif tri == 1:
tri = "activites.date_debut"
elif tri == 2:
tri = "activites.date_fin"
else:
tri = "activites.nom"
# Sens
sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1)
if sens == 0:
sens = ""
else:
sens = "DESC"
# Seuil d'alerte
self.seuil_alerte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_alerte", 5)
# Récupération des groupes
req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.nbre_inscrits_max,
COUNT(inscriptions.IDinscription) as nbre_inscriptions
FROM groupes
LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite
LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe
%s
GROUP BY groupes.IDgroupe
ORDER BY groupes.ordre
;""" % condition
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
dictGroupes = {}
for IDgroupe, IDactivite, nom, nbre_inscrits_max, nbre_inscrits in listeGroupes:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nbre_inscrits == None: nbre_inscrits = 0
if nom == None: nom = _(u"Sans nom !")
if dictGroupes.has_key(IDactivite) == False:
dictGroupes[IDactivite] = []
dictGroupes[IDactivite].append({
"IDgroupe": IDgroupe,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"IDactivite": IDactivite
})
# Récupération des activités
activite_ouverte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_ouvert", 1)
if activite_ouverte == 1:
if condition == "":
condition = "WHERE activites.date_fin>='%s'" % str(
datetime.date.today())
else:
condition += " AND activites.date_fin>='%s'" % str(
datetime.date.today())
req = """SELECT activites.IDactivite, activites.nom, activites.nbre_inscrits_max
FROM activites
%s
GROUP BY activites.IDactivite
;""" % condition
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
DB.Close()
listeActivitesTemp = []
for IDactivite, nom, nbre_inscrits_max in listeActivites:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nom == None: nom = _(u"Sans nom !")
liste_groupes = []
if dictGroupes.has_key(IDactivite):
liste_groupes = dictGroupes[IDactivite]
nbre_inscrits = 0
liste_infos = [
nom,
]
for dictGroupe in liste_groupes:
nbre_inscrits += dictGroupe["nbre_inscrits"]
liste_infos.append(dictGroupe["nom"])
listeActivitesTemp.append({
"IDactivite": IDactivite,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"liste_groupes": liste_groupes,
"infos": " ".join(liste_infos)
})
# Pour éviter l'actualisation de l'affichage si aucune modification des données
if self.listeActivites != listeActivitesTemp or forcerActualisation == True:
self.listeActivites = listeActivitesTemp
else:
return
# MAJ du contrôle
self.Freeze()
self.DeleteAllItems()
self.dictRenderers = {}
index = 0
for dictActivite in self.listeActivites:
if self.filtre == None or (self.filtre.lower()
in dictActivite["infos"].lower()):
couleur_fond = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(214, 250, 199))
# Colonne Activité
label = u" " + dictActivite["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictActivite)
self.SetItemBackgroundColour(index, couleur_fond)
item = self.GetItem(index, 0)
font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
font.SetWeight(wx.BOLD)
item.SetFont(font)
self.SetItem(item)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="activite",
couleur_fond=couleur_fond,
nbre_inscrits=dictActivite["nbre_inscrits"],
nbre_inscrits_max=dictActivite["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
for dictGroupe in dictActivite["liste_groupes"]:
label = u" " + dictGroupe["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictGroupe)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="groupe",
nbre_inscrits=dictGroupe["nbre_inscrits"],
nbre_inscrits_max=dictGroupe["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
# Ajuste la taille des colonnes
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
self.SetColumnWidth(1, ULC.ULC_AUTOSIZE_FILL)
# Actualiser l'affichage pour éviter bug de positionnement
try:
self.DoLayout()
except:
pass
self.Thaw()
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
# Règle la taille des images
self.afficheImages = UTILS_Config.GetParametre(
"depots_afficher_images", defaut=True)
if self.afficheImages == True:
taille = self.tailleImagesMaxi
else:
taille = self.tailleImagesMini
# Image list
dictImages = {"standard": {}, "modes": {}, "emetteurs": {}}
imageList = wx.ImageList(taille[0], taille[1])
# Images standard
dictImages["standard"]["vert"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_vert.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["orange"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath(
"Images/16x16/Ventilation_orange.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["rouge"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath(
"Images/16x16/Ventilation_rouge.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["ok"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["erreur"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["attente"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Attente.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["avis_depot_oui"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Emails_exp.png"),
wx.BITMAP_TYPE_PNG), taille))
dictImages["standard"]["avis_depot_non"] = imageList.Add(
self.ConvertTailleImage(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Emails_exp_gris.png"),
wx.BITMAP_TYPE_PNG), taille))
# Images Modes
if self.afficheImages == True:
DB = GestionDB.DB()
req = """SELECT modes_reglements.IDmode, modes_reglements.image FROM modes_reglements"""
DB.ExecuterReq(req)
listeModes = DB.ResultatReq()
for IDmode, buffer in listeModes:
bmp = self.GetImagefromBuffer(buffer, taille)
dictImages["modes"][IDmode] = imageList.Add(bmp)
# Images Emetteurs
req = """SELECT emetteurs.IDemetteur, emetteurs.image FROM emetteurs"""
DB.ExecuterReq(req)
listeEmetteurs = DB.ResultatReq()
for IDemetteur, buffer in listeEmetteurs:
bmp = self.GetImagefromBuffer(buffer, taille)
dictImages["emetteurs"][IDemetteur] = imageList.Add(bmp)
DB.Close()
self.SetImageLists(imageList, imageList)
# Flèches tri
bmp_haut = self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Fleche_haut_2.png"),
wx.BITMAP_TYPE_PNG), taille)
bmp_bas = self.ConvertTailleImage(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Fleche_bas_2.png"),
wx.BITMAP_TYPE_PNG), taille)
self.RegisterSortIndicators(bmp_haut, bmp_bas)
def GetImageMode(track):
if dictImages["modes"].has_key(track.IDmode):
return dictImages["modes"][track.IDmode]
else:
return None
def GetImageEmetteur(track):
if dictImages["emetteurs"].has_key(track.IDemetteur):
return dictImages["emetteurs"][track.IDemetteur]
else:
return None
def GetImageVentilation(track):
if track.montant_ventilation == None:
return dictImages["standard"]["rouge"]
resteAVentiler = decimal.Decimal(str(
track.montant)) - decimal.Decimal(
str(track.montant_ventilation))
if resteAVentiler == decimal.Decimal(str("0.0")):
return dictImages["standard"]["vert"]
if resteAVentiler > decimal.Decimal(str("0.0")):
return dictImages["standard"]["orange"]
if resteAVentiler < decimal.Decimal(str("0.0")):
return dictImages["standard"]["rouge"]
def GetImageDepot(track):
if track.IDdepot == None:
if track.encaissement_attente == 1:
return dictImages["standard"]["attente"]
else:
return dictImages["standard"]["erreur"]
else:
return dictImages["standard"]["ok"]
def GetImageDiffere(track):
if track.date_differe == None:
return None
if track.date_differe <= datetime.date.today():
return dictImages["standard"]["ok"]
else:
return dictImages["standard"]["erreur"]
def GetImageAttente(track):
if track.encaissement_attente == True:
return dictImages["standard"]["attente"]
return None
def GetImageAvisDepot(track):
if track.avis_depot != None:
return dictImages["standard"]["avis_depot_oui"]
if track.email_depots != None:
return dictImages["standard"]["avis_depot_non"]
return None
def FormateDateLong(dateDD):
return DateComplete(dateDD)
def FormateDateCourt(dateDD):
if dateDD == None:
return ""
else:
return DateEngFr(str(dateDD))
def FormateMontant(montant):
if montant == None: return u""
return u"%.2f %s" % (montant, SYMBOLE)
def FormateAttente(attente):
if attente == True:
return _(u"Attente !")
return ""
def rowFormatter(listItem, track):
# Si Observations
if track.observations != "":
listItem.SetTextColour((0, 102, 205))
# Si en attente
if track.encaissement_attente == True:
listItem.SetTextColour((255, 0, 0))
# Si date différé est supérieure à la date d'aujourd'hui
if track.date_differe != None:
if track.date_differe > datetime.date.today():
listItem.SetTextColour((255, 0, 0))
liste_Colonnes = [
ColumnDefn(_(u"ID"), "left", 0, "IDreglement",
typeDonnee="entier"),
ColumnDefn(_(u"Date"),
'left',
80,
"date",
typeDonnee="date",
stringConverter=FormateDateCourt),
ColumnDefn(_(u"Mode"),
'left',
120,
"nom_mode",
typeDonnee="texte",
imageGetter=GetImageMode),
ColumnDefn(_(u"Emetteur"),
'left',
145,
"nom_emetteur",
typeDonnee="texte",
imageGetter=GetImageEmetteur),
ColumnDefn(_(u"Numéro"),
'left',
60,
"numero_piece",
typeDonnee="texte"),
ColumnDefn(_(u"Famille"),
'left',
160,
"nomTitulaires",
typeDonnee="texte"),
ColumnDefn(_(u"Payeur"),
'left',
160,
"nom_payeur",
typeDonnee="texte"),
ColumnDefn(_(u"Montant"),
'right',
80,
"montant",
typeDonnee="montant",
stringConverter=FormateMontant),
ColumnDefn(_(u"Avis"),
'left',
110,
"avis_depot",
typeDonnee="date",
stringConverter=FormateDateCourt,
imageGetter=GetImageAvisDepot),
ColumnDefn(_(u"Compte"),
'left',
100,
"nom_compte",
typeDonnee="texte"),
ColumnDefn(_(u"Différé"),
'left',
85,
"date_differe",
typeDonnee="date",
stringConverter=FormateDateCourt
), #, imageGetter=GetImageDiffere),
ColumnDefn(_(u"Attente"),
'left',
65,
"encaissement_attente",
typeDonnee="texte",
stringConverter=FormateAttente
), #, imageGetter=GetImageAttente),
ColumnDefn(_(u"Quittancier"),
'left',
75,
"numero_quittancier",
typeDonnee="texte"),
ColumnDefn(_(u"Observations"),
'left',
200,
"observations",
typeDonnee="texte"),
]
self.rowFormatter = rowFormatter
self.SetColumns(liste_Colonnes)
if self.inclus == True:
self.SetEmptyListMsg(_(u"Aucun règlement dans ce dépôt"))
else:
self.SetEmptyListMsg(_(u"Aucun règlement disponible"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
## self.SetSortColumn(self.columns[self.numColonneTri])
self.SortBy(self.numColonneTri, ascending=self.ordreAscendant)
self.SetObjects(self.donnees)
