def MemoriseConfig(self):
     dictParametres = {
         "periode": self.ctrl_periode.GetModePeriode(),
         "case_largeur": self.ctrl_tableau.slider_largeur.GetValue(),
     }
     UTILS_Config.SetParametre("dlg_locations_tableau", dictParametres)
Exemple #2
0
 def Sauvegarde(self):
     if self.radio_france.GetValue() == True :
         mask = "#####"
     else:
         mask = u""
     UTILS_Config.SetParametre("mask_cp", mask)
Exemple #3
0
 def Sauvegarde(self):
     UTILS_Config.SetParametre("adresse_autocomplete", self.check_autoComplete.GetValue())
Exemple #4
0
#------------------------------------------------------------------------

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
Exemple #5
0
 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"¤"))
Exemple #6
0
    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()
Exemple #7
0
    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())
Exemple #10
0
 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)
Exemple #14
0
    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)
Exemple #15
0
    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
Exemple #16
0
    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)
Exemple #18
0
    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()
Exemple #19
0
 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())
Exemple #21
0
    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())
Exemple #25
0
 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)
Exemple #27
0
 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)
Exemple #29
0
 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()