def MemoriseConfig(self):
dictParametres = {
"periode": self.ctrl_periode.GetModePeriode(),
"case_largeur": self.ctrl_tableau.slider_largeur.GetValue(),
}
UTILS_Config.SetParametre("dlg_locations_tableau", dictParametres)
def Sauvegarde(self):
if self.radio_france.GetValue() == True :
mask = "#####"
else:
mask = u""
UTILS_Config.SetParametre("mask_cp", mask)
def Sauvegarde(self):
UTILS_Config.SetParametre("adresse_autocomplete", self.check_autoComplete.GetValue())
#------------------------------------------------------------------------
import Chemins
from Utils.UTILS_Traduction import _
import wx
from Ctrl import CTRL_Bouton_image
import datetime
import decimal
import copy
import sys
import traceback
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"))
from Utils.UTILS_Decimal import FloatToDecimal as FloatToDecimal
from Data import DATA_Civilites as Civilites
DICT_CIVILITES = Civilites.GetDictCivilites()
import GestionDB
import FonctionsPerso
from Utils import UTILS_Titulaires
from Utils import UTILS_Questionnaires
from Utils import UTILS_Impression_cotisation
from Utils import UTILS_Dates
def Importation(self):
self.ctrl_singulier.SetValue(UTILS_Config.GetParametre("monnaie_singulier", _(u"Euro")))
self.ctrl_pluriel.SetValue(UTILS_Config.GetParametre("monnaie_pluriel", _(u"Euros")))
self.ctrl_division.SetValue(UTILS_Config.GetParametre("monnaie_division", _(u"Centime")))
self.ctrl_symbole.SetValue(UTILS_Config.GetParametre("monnaie_symbole", u"¤"))
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
-1,
name="DLG_Depots",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
| wx.THICK_FRAME)
self.parent = parent
# Bandeau
intro = _(
u"Vous pouvez ici saisir, modifier ou supprimer des dépôts bancaires. "
)
titre = _(u"Gestion des dépôts")
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Banque.png")
# Reglements disponibles
self.staticbox_reglements = wx.StaticBox(self, -1,
_(u"Règlements disponibles"))
self.listviewAvecFooter1 = OL_Reglements_depots.ListviewAvecFooter(
self,
kwargs={
"inclus": False,
"selectionPossible": False,
"size": (-1, 180)
})
self.ctrl_reglements = self.listviewAvecFooter1.GetListview()
self.ctrl_reglements.SetMinSize((100, 150))
# Dépôts
self.staticbox_depots = wx.StaticBox(self, -1, _(u"Dépôts"))
self.listviewAvecFooter2 = OL_Depots.ListviewAvecFooter(self,
kwargs={})
self.ctrl_depots = self.listviewAvecFooter2.GetListview()
self.ctrl_recherche = OL_Depots.CTRL_Outils(self,
listview=self.ctrl_depots)
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_imprimer = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Imprimante.png"),
wx.BITMAP_TYPE_ANY))
# Options
self.check_images = wx.CheckBox(
self, -1, _(u"Afficher les images des modes et émetteurs"))
self.check_images.SetValue(
UTILS_Config.GetParametre("depots_afficher_images", defaut=True))
# 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,
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_CHECKBOX, self.OnCheckImages, self.check_images)
self.Bind(wx.EVT_BUTTON, self.OnBoutonImprimer, self.bouton_imprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
# Init
self.MAJreglements()
self.ctrl_depots.MAJ()
def __init__(self, parent, IDfamille=None, AfficherMessagesOuverture=True):
wx.Dialog.__init__(self, parent, id=-1, name="fiche_famille", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
self.parent = parent
self.IDfamille = IDfamille
self.nouvelleFiche = False
if IDfamille == None :
self.CreateIDfamille()
self.nouvelleFiche = True
# Adapte taille Police pour Linux
from Utils import UTILS_Linux
UTILS_Linux.AdaptePolice(self)
# Composition
self.sizer_composition_staticbox = wx.StaticBox(self, -1, _(u"Composition de la famille"))
self.ctrl_composition = CTRL_Composition.Notebook(self, IDfamille=self.IDfamille)
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_calendrier = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Calendrier.png"), wx.BITMAP_TYPE_ANY))
self.bouton_liens_famille = wx.BitmapButton(self, -1, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Composition.png"), wx.BITMAP_TYPE_ANY))
# Notebook
self.notebook = Notebook(self, IDfamille=self.IDfamille)
# Boutons de commande
self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_options = CTRL_Bouton_image.CTRL(self, texte=_(u"Options"), cheminImage="Images/32x32/Configuration2.png")
self.bouton_outils = CTRL_Bouton_image.CTRL(self, texte=_(u"Outils"), cheminImage="Images/32x32/Configuration.png")
self.bouton_consommations = CTRL_Bouton_image.CTRL(self, texte=_(u"Consommations"), cheminImage="Images/32x32/Calendrier.png")
self.bouton_saisie_reglement = CTRL_Bouton_image.CTRL(self, texte=_(u"Saisir un règlement"), cheminImage="Images/32x32/Reglement.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, texte=_(u"Annuler"), cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAjouterIndividu, self.bouton_ajouter)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOptions, self.bouton_options)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOutils, self.bouton_outils)
self.Bind(wx.EVT_BUTTON, self.OnBoutonLiens, self.bouton_liens_famille)
self.Bind(wx.EVT_BUTTON, self.OnBoutonCalendrier, self.bouton_calendrier)
self.Bind(wx.EVT_BUTTON, self.OnBoutonConsommations, self.bouton_consommations)
self.Bind(wx.EVT_BUTTON, self.OnBoutonSaisieReglement, self.bouton_saisie_reglement)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAjouter, self.bouton_ajouter)
self.Bind(wx.EVT_BUTTON, self.OnBoutonModifier, self.bouton_modifier)
self.Bind(wx.EVT_BUTTON, self.OnBoutonSupprimer, self.bouton_supprimer)
self.notebook.SetFocus()
# Si c'est une nouvelle fiche, on propose immédiatement la création d'un individu
if self.nouvelleFiche == True :
wx.CallAfter(self.CreerPremierIndividu)
# Cache le bouton de saisie d'un règlement si l'onglet Règlements est caché
if ("reglements" in self.notebook.dictPages) == False :
self.bouton_saisie_reglement.Show(False)
# MAJ de l'onglet Informations
self.notebook.GetPageAvecCode("informations").MAJ()
# MAJ CTRL composition
code = UTILS_Config.GetParametre("affichage_composition_famille", defaut="graphique")
self.ctrl_composition.AffichePage(code)
self.ctrl_composition.MAJ()
# Affiche les messages à l'ouverture de la fiche famille
if AfficherMessagesOuverture == True :
self.AfficheMessagesOuverture()
def ImportationParametres(self):
dictDefaut = self.GetParametres()
dictParametres = UTILS_Config.GetParametres(dictDefaut)
self.SetParametres(dictParametres)
def MemoriseParametres(self):
# Paramètres
dictParametres = self.ctrl_parametres.GetParametres()
UTILS_Config.SetParametres(dictParametres)
# Mode favori
UTILS_Config.SetParametre("synchro_mode_favori", self.ctrl_mode.GetMode())
def SetVoixActuelle(self, id=None):
""" Mémorise la voix actuelle """
## UTILS_Parametres.Parametres(mode="set", categorie="vocal", nom="voix", valeur=id)
UTILS_Config.SetParametre("vocal_voix", id)
self.engine.setProperty('voice', id)
self.defaut = id
def MemoriserParametres(self):
## UTILS_Config.SetParametre("impression_rappels_coupon", int(self.checkbox_coupon.GetValue()))
if self.checkbox_repertoire.GetValue() == True :
UTILS_Config.SetParametre("impression_cotisations_repertoire", self.ctrl_repertoire.GetValue())
else :
UTILS_Config.SetParametre("impression_cotisations_repertoire", "")
def MemoriserParametres(self):
if self.ctrl_memoriser.GetValue() == True:
UTILS_Config.SetParametre("impression_etiquettes_largeurpage",
self.ctrl_largeur_page.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_hauteurpage",
self.ctrl_hauteur_page.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_margehaut",
self.ctrl_marge_haut.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_margebas",
self.ctrl_marge_bas.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_margegauche",
self.ctrl_marge_gauche.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_margedroite",
self.ctrl_marge_droite.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_espacev",
self.ctrl_espace_vertic.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_espaceh",
self.ctrl_espace_horiz.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_contour",
self.check_contour.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_reperes",
self.check_reperes.GetValue())
UTILS_Config.SetParametre("impression_etiquettes_memoriser",
self.ctrl_memoriser.GetValue())
def __init__(self,
parent,
categorie="individu",
IDindividu=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.categorie = categorie
# DLG Attente
dlgAttente = PBI.PyBusyInfo(
_(u"Veuillez patienter durant l'initialisation de l'éditeur..."),
parent=None,
title=_(u"Patientez"),
icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"),
wx.BITMAP_TYPE_ANY))
wx.Yield()
# Si on vient d'une fiche famille ou d'une fiche individuelle
if IDindividu != None: self.categorie = "individu"
if IDfamille != None: self.categorie = "famille"
# Bandeau
titre = _(u"Edition d'étiquettes et de badges")
intro = _(
u"Vous pouvez ici imprimer rapidement des planches d'étiquettes ou de badges au format PDF. Commencez par sélectionner la catégorie de données et un modèle, puis définissez le gabarit de la page avant de cocher les données à afficher."
)
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Etiquette.png")
# Modèle
self.box_modele_staticbox = wx.StaticBox(self, -1, _(u"Modèle"))
self.label_categorie = wx.StaticText(self, -1, _(u"Catégorie :"))
self.ctrl_categorie = CTRL_Categorie(self)
self.label_modele = wx.StaticText(self, -1, _(u"Modèle :"))
self.ctrl_modele = CTRL_Choix_modele.CTRL_Choice(
self, categorie=self.categorie)
self.bouton_modele = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Mecanisme.png"),
wx.BITMAP_TYPE_ANY))
# Gabarit
self.box_gabarit_staticbox = wx.StaticBox(self, -1,
_(u"Gabarit (en mm)"))
self.label_largeur_page = wx.StaticText(self, -1, _(u"Largeur page :"))
self.ctrl_largeur_page = wx.SpinCtrl(self, -1, u"", min=1, max=1000)
self.label_marge_haut = wx.StaticText(self, -1, _(u"Marge haut :"))
self.ctrl_marge_haut = wx.SpinCtrl(self, -1, u"", min=0, max=1000)
self.label_hauteur_page = wx.StaticText(self, -1, _(u"Hauteur page :"))
self.ctrl_hauteur_page = wx.SpinCtrl(self, -1, u"", min=1, max=1000)
self.label_marge_bas = wx.StaticText(self, -1, _(u"Marge bas :"))
self.ctrl_marge_bas = wx.SpinCtrl(self, -1, u"", min=0, max=1000)
self.label_espace_vertic = wx.StaticText(self, -1,
_(u"Espace vertic. :"))
self.ctrl_espace_vertic = wx.SpinCtrl(self, -1, u"", min=0, max=1000)
self.label_marge_gauche = wx.StaticText(self, -1, _(u"Marge gauche :"))
self.ctrl_marge_gauche = wx.SpinCtrl(self, -1, u"", min=0, max=1000)
self.label_espace_horiz = wx.StaticText(self, -1,
_(u"Espace horiz. :"))
self.ctrl_espace_horiz = wx.SpinCtrl(self, -1, u"", min=0, max=1000)
self.label_marge_droite = wx.StaticText(self, -1, _(u"Marge droite :"))
self.ctrl_marge_droite = wx.SpinCtrl(self, -1, u"", min=0, max=1000)
# Aperçu
self.box_apercu_staticbox = wx.StaticBox(self, -1,
_(u"Aperçu du gabarit"))
self.ctrl_apercu = CTRL_Apercu(self)
# Options
self.box_options_staticbox = wx.StaticBox(self, -1, _(u"Options"))
self.label_nbre_copies = wx.StaticText(self, -1, _(u"Nbre copies :"))
self.ctrl_nbre_copies = wx.SpinCtrl(self,
-1,
u"",
size=(50, -1),
min=1,
max=1000)
self.check_contour = wx.CheckBox(self, -1, _(u"Contours"))
self.check_reperes = wx.CheckBox(self, -1, _(u"Repères"))
# Données
self.box_donnees_staticbox = wx.StaticBox(self, -1, _(u"Données"))
self.ctrl_donnees = Panel_Donnees(self,
IDindividu=IDindividu,
IDfamille=IDfamille)
## self.ctrl_donnees = OL_Etiquettes.ListView(self, id=-1, style=wx.LC_REPORT|wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL|wx.LC_HRULES|wx.LC_VRULES)
## self.ctrl_donnees.SetMinSize((10, 10))
## self.ctrl_recherche = OL_Etiquettes.CTRL_Outils(self, listview=self.ctrl_donnees, afficherCocher=True)
# 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, texte=_(u"Fermer"), cheminImage="Images/32x32/Fermer.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_CHOICE, self.OnChoixCategorie, self.ctrl_categorie)
self.Bind(wx.EVT_CHOICE, self.OnChoixModele, self.ctrl_modele)
self.Bind(wx.EVT_BUTTON, self.OnBoutonModele, self.bouton_modele)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixTaille, self.ctrl_largeur_page)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixMargeH, self.ctrl_marge_haut)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixTaille, self.ctrl_hauteur_page)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixMargeB, self.ctrl_marge_bas)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixEspaceV,
self.ctrl_espace_vertic)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixMargeG, self.ctrl_marge_gauche)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixEspaceH, self.ctrl_espace_horiz)
self.Bind(wx.EVT_SPINCTRL, self.OnChoixMargeD, self.ctrl_marge_droite)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
# Init contrôles
largeurPage = UTILS_Config.GetParametre(
"impression_etiquettes_largeurpage", defaut=210)
hauteurPage = UTILS_Config.GetParametre(
"impression_etiquettes_hauteurpage", defaut=297)
margeHaut = UTILS_Config.GetParametre(
"impression_etiquettes_margehaut", defaut=10)
margeBas = UTILS_Config.GetParametre("impression_etiquettes_margebas",
defaut=10)
margeGauche = UTILS_Config.GetParametre(
"impression_etiquettes_margegauche", defaut=10)
margeDroite = UTILS_Config.GetParametre(
"impression_etiquettes_margedroite", defaut=10)
espaceV = UTILS_Config.GetParametre("impression_etiquettes_espacev",
defaut=5)
espaceH = UTILS_Config.GetParametre("impression_etiquettes_espaceh",
defaut=5)
contour = UTILS_Config.GetParametre("impression_etiquettes_contour",
defaut=True)
reperes = UTILS_Config.GetParametre("impression_etiquettes_reperes",
defaut=True)
memoriser = UTILS_Config.GetParametre(
"impression_etiquettes_memoriser", defaut=1)
self.ctrl_largeur_page.SetValue(largeurPage)
self.ctrl_hauteur_page.SetValue(hauteurPage)
self.ctrl_marge_haut.SetValue(margeHaut)
self.ctrl_marge_bas.SetValue(margeBas)
self.ctrl_marge_gauche.SetValue(margeGauche)
self.ctrl_marge_droite.SetValue(margeDroite)
self.ctrl_espace_vertic.SetValue(espaceV)
self.ctrl_espace_horiz.SetValue(espaceH)
self.check_contour.SetValue(contour)
self.check_reperes.SetValue(reperes)
self.ctrl_memoriser.SetValue(memoriser)
self.ctrl_categorie.SetCategorie(self.categorie)
# Init Aperçu
self.ctrl_apercu.SetTaillePage((largeurPage, hauteurPage))
self.ctrl_apercu.SetMargeHaut(margeHaut)
self.ctrl_apercu.SetMargeGauche(margeGauche)
self.ctrl_apercu.SetMargeBas(margeBas)
self.ctrl_apercu.SetMargeDroite(margeDroite)
self.ctrl_apercu.SetEspaceVertical(espaceV)
self.ctrl_apercu.SetEspaceHorizontal(espaceH)
self.ctrl_apercu.SetModele(self.ctrl_modele.GetID())
self.ctrl_apercu.MAJ()
if IDindividu != None or IDfamille != None:
self.ctrl_categorie.Enable(False)
del dlgAttente
self.ctrl_donnees.SetSelection(categorie=self.categorie)
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)
self.SetImageLists(imageList, imageList)
DB.Close()
def GetImage(track):
return dictImages[track.IDmode]
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"Quittancier"),
'left',
65,
"numero_quittancier",
typeDonnee="texte"),
ColumnDefn(_(u"Payeur"),
'left',
160,
"nom_payeur",
typeDonnee="texte"),
ColumnDefn(_(u"Montant"),
'right',
80,
"montant",
typeDonnee="montant",
stringConverter=FormateMontant),
#ColumnDefn(_(u"Ventilé"), 'right', 80, "montant_ventilation", stringConverter=FormateMontant, imageGetter=GetImageVentilation),
ColumnDefn(_(u"Avis"),
'left',
35,
"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"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, face="Tekton"))
## self.SetSortColumn(self.columns[self.numColonneTri])
self.SortBy(self.numColonneTri, ascending=self.ordreAscendant)
self.SetObjects(self.donnees)
def Run(self, afficherDlgAttente=False):
dictParametres = self.GetParametres()
# Ouverture dlg d'attente
if afficherDlgAttente == True:
dlgAttente = wx.BusyInfo(
_(u"Génération du fichier de données..."), None)
try:
# Génération du nom de fichier
self.nomFichier = UTILS_Fichiers.GetRepTemp(
fichier=u"data_%s" % dictParametres["IDfichier"])
# Vérifie si le fichier existe déj�
nomFichierTemp = self.nomFichier + ".dat"
if os.path.isfile(nomFichierTemp):
os.remove(nomFichierTemp)
# Création des tables
dbdest = GestionDB.DB(suffixe=None,
nomFichier=nomFichierTemp,
modeCreation=True)
dbdest.CreationTables(dicoDB=self.dictTables)
# Enregistrement des paramètres
listeParametres = [
("IDfichier", dictParametres["IDfichier"]),
("horodatage", dictParametres["horodatage"]),
("type", "donnees"),
]
self.Enregistrer(dbdest,
nomTable="parametres",
listeChamps=["nom", "valeur"],
listeDonnees=listeParametres)
# Données du dictIndividus
from Utils import UTILS_Infos_individus
infos = UTILS_Infos_individus.Informations()
dictValeurs = infos.GetDictValeurs(mode="individu",
formatChamp=False)
listeDonnees = []
for ID, dictTemp in dictValeurs.items():
for champ, valeur in dictTemp.items():
if type(valeur) in (str, six.text_type) and valeur not in (
"", None):
listeDonnees.append((ID, champ, valeur))
self.Enregistrer(dbdest,
nomTable="informations",
listeChamps=["IDindividu", "champ", "valeur"],
listeDonnees=listeDonnees)
# Données individus
db = GestionDB.DB(suffixe="PHOTOS")
req = """SELECT IDindividu, photo FROM photos;"""
db.ExecuterReq(req)
listePhotos = db.ResultatReq()
db.Close()
dictPhotos = {}
for IDindividu, photo in listePhotos:
dictPhotos[IDindividu] = photo
db = GestionDB.DB()
req = """SELECT IDindividu, IDcivilite, nom, prenom FROM individus;"""
db.ExecuterReq(req)
listeIndividus = db.ResultatReq()
db.Close()
listeDonnees = []
for IDindividu, IDcivilite, nom, prenom in listeIndividus:
if IDindividu in dictPhotos:
photo = sqlite3.Binary(dictPhotos[IDindividu])
else:
photo = None
listeDonnees.append(
(IDindividu, IDcivilite, nom, prenom, photo))
self.Enregistrer(dbdest,
nomTable="individus",
listeChamps=[
"IDindividu", "IDcivilite", "nom", "prenom",
"photo"
],
listeDonnees=listeDonnees)
# Données Titulaires de dossier
dictTitulaires = UTILS_Titulaires.GetTitulaires()
listeDonnees = []
for IDfamille, dictTemp in dictTitulaires.items():
nom = dictTitulaires[IDfamille]["titulairesSansCivilite"]
listeDonnees.append((IDfamille, nom))
self.Enregistrer(dbdest,
nomTable="titulaires",
listeChamps=["IDfamille", "nom"],
listeDonnees=listeDonnees)
# Données organisateur
db = GestionDB.DB()
req = """SELECT IDorganisateur, nom, logo FROM organisateur;"""
db.ExecuterReq(req)
listeTemp = db.ResultatReq()
db.Close()
listeDonnees = []
for IDorganisateur, nom, logo in listeTemp:
if logo != None:
logo = sqlite3.Binary(logo)
listeDonnees.append((IDorganisateur, nom, logo))
self.Enregistrer(dbdest,
nomTable="organisateur",
listeChamps=["IDorganisateur", "nom", "logo"],
listeDonnees=listeDonnees)
# Tables à copier en intégralité
listeTables = [
"vacances",
"jours_feries",
"activites",
"groupes",
"unites",
"unites_groupes",
"unites_incompat",
"unites_remplissage",
"unites_remplissage_unites",
"ouvertures",
"remplissage",
"inscriptions",
"consommations",
"memo_journee",
"comptes_payeurs",
"familles",
"utilisateurs",
"nomade_archivage",
"niveaux_scolaires",
"ecoles",
"classes",
"scolarite",
]
self.CopieTables(dbdest, listeTables)
# Cloture de la base
dbdest.connexion.commit()
dbdest.Close()
# Compression
fichierZip = zipfile.ZipFile(self.nomFichier + EXTENSION_DECRYPTE,
"w",
compression=zipfile.ZIP_DEFLATED)
fichierZip.write(self.nomFichier + ".dat", "database.dat")
fichierZip.close()
os.remove(self.nomFichier + ".dat")
# Cryptage
cryptage_actif = UTILS_Config.GetParametre(
"synchro_cryptage_activer", defaut=False)
cryptage_mdp = base64.b64decode(
UTILS_Config.GetParametre("synchro_cryptage_mdp", defaut=""))
if cryptage_actif == True and cryptage_mdp != "":
UTILS_Cryptage_fichier.CrypterFichier(
self.nomFichier + EXTENSION_DECRYPTE,
self.nomFichier + EXTENSION_CRYPTE, cryptage_mdp)
os.remove(self.nomFichier + EXTENSION_DECRYPTE)
nomFichierFinal = self.nomFichier + EXTENSION_CRYPTE
else:
nomFichierFinal = self.nomFichier + EXTENSION_DECRYPTE
except Exception as err:
print("Erreur dans UTILS_Export_nomade.Run :", err)
traceback.print_exc(file=sys.stdout)
if afficherDlgAttente == True:
del dlgAttente
dlg = wx.MessageDialog(
None,
_(u"Désolé, l'erreur suivante a été rencontrée : ") +
str(err), "Erreur ", wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return None
if afficherDlgAttente == True:
del dlgAttente
return nomFichierFinal
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"
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_activite, 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 ActualiseParametresAffichage(self):
parametres = UTILS_Config.GetParametre("liste_individus_parametres",
defaut="")
self.ctrl_listview.SetParametres(parametres)
def MAJ(self, forcerActualisation=False):
condition = ""
DB = GestionDB.DB()
# Recherche des paramètres
parametres = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_activites", defaut=None)
if parametres != None:
code, liste = parametres.split("###")
if liste != "":
listeID = []
for ID in liste.split(";"):
listeID.append(int(ID))
if code == "liste_groupes_activites":
req = """SELECT IDtype_groupe_activite, IDactivite
FROM groupes_activites
WHERE IDtype_groupe_activite IN %s
;""" % GestionDB.ConvertConditionChaine(listeID)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActivites = []
for IDtype_groupe_activite, IDactivite in listeDonnees:
listeActivites.append(IDactivite)
condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeActivites)
if code == "liste_activites":
condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine(
listeID)
# Tri
tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3)
if tri == 0:
tri = "activites.nom"
elif tri == 1:
tri = "activites.date_debut"
elif tri == 2:
tri = "activites.date_fin"
else:
tri = "activites.nom"
# Sens
sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1)
if sens == 0:
sens = ""
else:
sens = "DESC"
# Seuil d'alerte
self.seuil_alerte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_alerte", 5)
# Récupération des groupes
req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.nbre_inscrits_max,
COUNT(inscriptions.IDinscription) as nbre_inscriptions
FROM groupes
LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite
LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe
WHERE inscriptions.statut='ok' %s
GROUP BY groupes.IDgroupe
ORDER BY groupes.ordre
;""" % condition
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
dictGroupes = {}
for IDgroupe, IDactivite, nom, nbre_inscrits_max, nbre_inscrits in listeGroupes:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nbre_inscrits == None: nbre_inscrits = 0
if nom == None: nom = _(u"Sans nom !")
if (IDactivite in dictGroupes) == False:
dictGroupes[IDactivite] = []
dictGroupes[IDactivite].append({
"IDgroupe": IDgroupe,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"IDactivite": IDactivite
})
# Récupération des activités
activite_ouverte = UTILS_Config.GetParametre(
"nbre_inscrits_parametre_ouvert", 1)
if activite_ouverte == 1:
if condition == "":
condition = "WHERE activites.date_fin>='%s'" % str(
datetime.date.today())
else:
condition += " AND activites.date_fin>='%s'" % str(
datetime.date.today())
req = """SELECT activites.IDactivite, activites.nom, activites.nbre_inscrits_max
FROM activites
%s
GROUP BY activites.IDactivite
;""" % condition
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
DB.Close()
listeActivitesTemp = []
for IDactivite, nom, nbre_inscrits_max in listeActivites:
if nbre_inscrits_max == None: nbre_inscrits_max = 0
if nom == None: nom = _(u"Sans nom !")
liste_groupes = []
if IDactivite in dictGroupes:
liste_groupes = dictGroupes[IDactivite]
nbre_inscrits = 0
liste_infos = [
nom,
]
for dictGroupe in liste_groupes:
nbre_inscrits += dictGroupe["nbre_inscrits"]
liste_infos.append(dictGroupe["nom"])
listeActivitesTemp.append({
"IDactivite": IDactivite,
"nom": nom,
"nbre_inscrits_max": nbre_inscrits_max,
"nbre_inscrits": nbre_inscrits,
"liste_groupes": liste_groupes,
"infos": " ".join(liste_infos)
})
# Pour éviter l'actualisation de l'affichage si aucune modification des données
if self.listeActivites != listeActivitesTemp or forcerActualisation == True:
self.listeActivites = listeActivitesTemp
else:
return
# MAJ du contrôle
self.Freeze()
self.DeleteAllItems()
self.dictRenderers = {}
index = 0
for dictActivite in self.listeActivites:
if self.filtre == None or (self.filtre.lower()
in dictActivite["infos"].lower()):
couleur_fond = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(214, 250, 199))
# Colonne Activité
label = u" " + dictActivite["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictActivite)
self.SetItemBackgroundColour(index, couleur_fond)
item = self.GetItem(index, 0)
font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
font.SetWeight(wx.BOLD)
item.SetFont(font)
self.SetItem(item)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="activite",
couleur_fond=couleur_fond,
nbre_inscrits=dictActivite["nbre_inscrits"],
nbre_inscrits_max=dictActivite["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
for dictGroupe in dictActivite["liste_groupes"]:
label = u" " + dictGroupe["nom"]
self.InsertStringItem(index, label)
self.SetItemPyData(index, dictGroupe)
# Colonne Gauge
renderer = Renderer_gauge(self)
renderer.SetValeurs(
mode="groupe",
nbre_inscrits=dictGroupe["nbre_inscrits"],
nbre_inscrits_max=dictGroupe["nbre_inscrits_max"])
self.dictRenderers[index] = renderer
self.SetItemCustomRenderer(index, 1, renderer)
index += 1
# Ajuste la taille des colonnes
self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
self.SetColumnWidth(1, ULC.ULC_AUTOSIZE_FILL)
# Actualiser l'affichage pour éviter bug de positionnement
try:
self.DoLayout()
except:
pass
self.Thaw()
def OnCheckImages(self, event):
UTILS_Config.SetParametre("depots_afficher_images",
self.check_images.GetValue())
self.MAJreglements()
def Sauvegarde(self):
UTILS_Config.SetParametre("rapports_bugs", self.check.GetValue())
def __init__(self, parent, IDfamille=None, selectionIndividus=[], selectionTous=False):
wx.Dialog.__init__(self, parent, -1, name="grille", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
self.parent = parent
self.IDfamille = IDfamille
# Adapte taille Police pour Linux
from Utils import UTILS_Linux
UTILS_Linux.AdaptePolice(self)
self._mgr = aui.AuiManager()
self._mgr.SetManagedWindow(self)
self.SetTitle(_(u"Grille des consommations"))
# Récupère les perspectives
cfg = UTILS_Config.FichierConfig()
self.userConfig = cfg.GetDictConfig()
if self.userConfig.has_key("grille_perspectives") == True :
self.perspectives = self.userConfig["grille_perspectives"]
else:
self.perspectives = []
if self.userConfig.has_key("grille_perspective_active") == True :
self.perspective_active = self.userConfig["grille_perspective_active"]
else:
self.perspective_active = None
# Création du notebook
self.panel_grille = PanelGrille(self, "individu", self.IDfamille)
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_periode = CTRL_Grille_periode.CTRL(self)
dictDonnees = UTILS_Config.GetParametre("dict_selection_periodes_activites")
self.panel_periode.SetDictDonnees(dictDonnees)
self._mgr.AddPane(self.panel_periode, aui.AuiPaneInfo().
Name("periode").Caption(_(u"Sélection de la période")).
Top().Layer(1).BestSize(wx.Size(230,144)).Position(1).CloseButton(False).Fixed().MaximizeButton(False))
self.panel_individus = CTRL_Grille_individus.CTRL(self, self.IDfamille, self.dictIndividus, selectionIndividus, selectionTous)
self._mgr.AddPane(self.panel_individus, aui.AuiPaneInfo().
Name("individus").Caption(_(u"Sélection des individus")).
Top().Layer(1).BestSize(wx.Size(180,140)).Position(2).CloseButton(False).MaximizeButton(False).MinSize((10, 100)))
self.panel_activites = CTRL_Grille_activite2.CTRL(self, self.dictIndividus, self.dictActivites, self.dictGroupes, self.listeSelectionIndividus)
self._mgr.AddPane(self.panel_activites, aui.AuiPaneInfo().
Name("activites").Caption(_(u"Sélection des activités")).
Top().Layer(1).Position(3).CloseButton(False).MaximizeButton(False).MinSize((160, 100)))
self.panel_facturation = CTRL_Grille_facturation.CTRL(self)
self._mgr.AddPane(self.panel_facturation, aui.AuiPaneInfo().
Name("facturation").Caption(_(u"Facturation")).
Right().Layer(0).BestSize(wx.Size(275,140)).Position(3).CloseButton(False).MaximizeButton(False).MinSize((275, 100)))
self.panel_etiquettes = CTRL_Etiquettes.CTRL(self, activeMenu=False, onCheck=self.panel_grille.grille.MAJ_affichage)
self._mgr.AddPane(self.panel_etiquettes, aui.AuiPaneInfo().
Name("etiquettes").Caption(_(u"Etiquettes")).
Right().Layer(0).Position(3).CloseButton(False).BestSize(wx.Size(275, 100)).MaximizeButton(False).MinSize((275, 100)))
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(4).BestSize(wx.Size(275,140)).CloseButton(False).MaximizeButton(False).MinSize((275, 100)))
self._mgr.GetPane("forfaits").dock_proportion = 50000
self.panel_commandes = Commandes(self)
self._mgr.AddPane(self.panel_commandes, aui.AuiPaneInfo().
Name("commandes").Caption(_(u"Commandes")).
Bottom().Layer(0).CaptionVisible(False).CloseButton(False).MaximizeButton(False).MinSize((-1, 50)))
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._mgr.AddPane(self.panel_legende, aui.AuiPaneInfo().
Name("legende").Caption(_(u"Légende")).
Left().Layer(0).Position(2).CloseButton(False).BestSize(wx.Size(170, 100)).MaximizeButton(False).MinSize((170, 100)))
self._mgr.GetPane("legende").dock_proportion = 60000
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._mgr.AddPane(self.panel_raccourcis, aui.AuiPaneInfo().
Name("raccourcis").Caption(_(u"Touches raccourcis")).
Left().Layer(0).Position(2).CloseButton(False).BestSize(wx.Size(170, 100)).MaximizeButton(False).MinSize((170, 100)))
self._mgr.GetPane("raccourcis").dock_proportion = 30000
# 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)
self._mgr.Update()
self.Bind(wx.EVT_CLOSE, self.OnClose)
# Détermine la taille de la fenêtre
self.SetMinSize((600, 670))
taille_fenetre = UTILS_Config.GetParametre("taille_fenetre_grille")
if taille_fenetre == None :
self.SetSize((900, 670))
if taille_fenetre == (0, 0) :
self.Maximize(True)
else:
self.SetSize(taille_fenetre)
self.CenterOnScreen()
# Initialisation des contrôles
self.panel_periode.SetVisibleSelection()
self.SetListesPeriodes(self.panel_periode.GetDatesSelections())
self.SetListeSelectionIndividus(self.panel_individus.GetSelections())
self.SetListeSelectionActivites(self.panel_activites.ctrl_activites.GetIDcoches())
self.MAJ_grille()
# 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()
# Contre le bug de maximize
wx.CallAfter(self._mgr.Update)
wx.CallAfter(self.panel_grille.grille.SetFocus)
def Importation(self):
valeur = UTILS_Config.GetParametre("propose_maj", True)
self.check.SetValue(valeur)
import Chemins
from Utils.UTILS_Traduction import _
import wx
from Ctrl import CTRL_Bouton_image
import datetime
import decimal
from Ctrl import CTRL_Bandeau
from Ctrl import CTRL_Saisie_date
import GestionDB
from Ol import OL_Recalculer_prestations
from Utils import UTILS_Identification
from Utils import UTILS_Config
SYMBOLE = UTILS_Config.GetParametre("monnaie_symbole", u"¤")
import DLG_Badgeage_grille
from threading import Thread
import time
class Abort(Exception):
pass
class Traitement(Thread):
def __init__(self,
parent,
IDactivite=None,
date_debut=None,
def Sauvegarde(self):
UTILS_Config.SetParametre("propose_maj", self.check.GetValue())
def Importation(self):
mask = UTILS_Config.GetParametre("mask_cp", "#####")
if mask == "" :
self.radio_libre.SetValue(True)
else:
self.radio_france.SetValue(True)
def Importation(self):
nbre = UTILS_Config.GetParametre("nbre_derniers_fichiers", 10)
self.ctrl_nbre.SetValue(nbre)
def Importation(self):
autoComplete = UTILS_Config.GetParametre("adresse_autocomplete", True)
self.check_autoComplete.SetValue(autoComplete)
def Importation(self):
valeur = UTILS_Config.GetParametre("autodeconnect", None)
self.SetValeur(valeur)
def Importation(self):
valeur = UTILS_Config.GetParametre("rapports_bugs", True)
self.check.SetValue(valeur)
def __init__(self, parent, ctrl_tableau=None):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.parent = parent
self.ctrl_tableau = ctrl_tableau
# Période
self.staticBox_periode = wx.StaticBox(self, -1,
_(u"Sélection de la période"))
self.ctrl_periode = CTRL_Selection_periode_simple.CTRL(
self, callback=self.OnChangePeriode)
# Catégories de produits
self.staticBox_categories = wx.StaticBox(self, -1,
_(u"Catégories de produits"))
self.ctrl_categories = CTRL_Categories(self)
# Options
self.staticbox_parametres_staticbox = wx.StaticBox(
self, -1, _(u"Paramètres"))
self.ctrl_parametres = CTRL_Parametres(self)
self.ctrl_parametres.SetMinSize((400, 80))
self.bouton_reinitialisation = CTRL_Propertygrid.Bouton_reinitialisation(
self, self.ctrl_parametres)
self.bouton_sauvegarde = CTRL_Propertygrid.Bouton_sauvegarde(
self, self.ctrl_parametres)
# Binds
self.Bind(wx.EVT_CHECKLISTBOX, self.OnCheckCategories,
self.ctrl_categories)
# Layout
grid_sizer_base = wx.FlexGridSizer(1, 4, 10, 10)
# Période
staticBox_periode = wx.StaticBoxSizer(self.staticBox_periode,
wx.HORIZONTAL)
staticBox_periode.Add(self.ctrl_periode, 1, wx.EXPAND | wx.ALL, 5)
grid_sizer_base.Add(staticBox_periode, 1, wx.EXPAND, 0)
# Catégories
staticBox_categories = wx.StaticBoxSizer(self.staticBox_categories,
wx.HORIZONTAL)
staticBox_categories.Add(self.ctrl_categories, 1, wx.EXPAND | wx.ALL,
5)
grid_sizer_base.Add(staticBox_categories, 1, wx.EXPAND, 0)
# Paramètres
box_parametres = wx.StaticBoxSizer(self.staticbox_parametres_staticbox,
wx.VERTICAL)
grid_sizer_parametres = wx.FlexGridSizer(rows=1,
cols=2,
vgap=5,
hgap=5)
grid_sizer_parametres.Add(self.ctrl_parametres, 1, wx.EXPAND, 0)
grid_sizer_boutons = wx.FlexGridSizer(rows=3, cols=1, vgap=5, hgap=5)
grid_sizer_boutons.Add(self.bouton_reinitialisation, 0, 0, 0)
grid_sizer_boutons.Add(self.bouton_sauvegarde, 0, 0, 0)
grid_sizer_parametres.Add(grid_sizer_boutons, 0, 0, 0)
grid_sizer_parametres.AddGrowableRow(0)
grid_sizer_parametres.AddGrowableCol(0)
box_parametres.Add(grid_sizer_parametres, 1, wx.EXPAND | wx.ALL, 5)
grid_sizer_base.Add(box_parametres, 1, wx.EXPAND | wx.ALL, 0)
grid_sizer_base.AddGrowableCol(1)
self.SetSizer(grid_sizer_base)
self.Layout()
# Configuration
dict_parametres = UTILS_Config.GetParametre("dlg_locations_tableau",
{})
if "periode" in dict_parametres:
self.ctrl_periode.SetModePeriode(dict_parametres["periode"])
if "case_largeur" in dict_parametres:
self.ctrl_tableau.slider_largeur.SetValue(
dict_parametres["case_largeur"])
self.ctrl_tableau.OnSliderLargeur()