def __init__(self, parent, dictOptions={}, tracks=[]):
wx.Dialog.__init__(self, parent, -1, style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
self.parent = parent
self.tracks = tracks
# Bandeau
titre = _(u"Impression d'un récapitulatif des factures")
intro = _(u"Vous pouvez ici modifier les paramètres d'impression du document. Cliquez sur le bouton 'Mémoriser les paramètres' pour réutiliser les mêmes paramètres pour les impressions suivantes.")
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(self, titre=titre, texte=intro, hauteurHtml=30, nomImage="Images/32x32/Imprimante.png")
# Récupération des questionnaires
self.Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
# Récupération des infos de base familles
# self.infosIndividus = UTILS_Infos_individus.Informations()
# self.dictInfosFamilles = self.infosIndividus.GetDictValeurs(mode="famille", ID=None, formatChamp=True)
# Paramètres
self.ctrl_parametres = CTRL(self, dictOptions=dictOptions)
# 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/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
self.bouton_ok.SetFocus()
def GetQuestionnaires(self):
""" Recherche les questions des questionnaires """
Questionnaires = UTILS_Questionnaires.Questionnaires()
listeQuestions = []
for dictQuestion in Questionnaires.GetQuestions(None) :
listeQuestions.append(dictQuestion)
return listeQuestions
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
liste_Colonnes = [
ColumnDefn(u"", "left", 0, "IDcategorie", typeDonnee="entier"),
ColumnDefn(_(u"Nom"), 'left', 200, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Notes"),
"left",
200,
"observations",
typeDonnee="texte"),
]
# Ajout des questions des questionnaires
liste_Colonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
self.SetColumns(liste_Colonnes)
if self.selection_multiple == True:
self.CreateCheckStateColumn(0)
self.SetEmptyListMsg(_(u"Aucune catégorie de produits"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
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
liste_Colonnes = [
ColumnDefn(u"", "left", 0, "IDfamille", typeDonnee="entier"),
ColumnDefn(_(u"Nom"),
'left',
270,
"nomTitulaires",
typeDonnee="texte"),
ColumnDefn(_(u"Rue"), 'left', 200, "rue", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), 'left', 70, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), 'left', 150, "ville", typeDonnee="texte"),
]
# Ajout des questions des questionnaires
liste_Colonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
self.SetColumns(liste_Colonnes)
self.SetEmptyListMsg(_(u"Aucune famille"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
def __init__(self, parent):
wx.Choice.__init__(self, parent, -1)
self.parent = parent
self.listeDonnees = [
{"label": _(u"Jour"), "code": "jour"},
{"label": _(u"Mois"), "code": "mois"},
{"label": _(u"Année"), "code": "annee"},
{"label": _(u"Activité"), "code": "activite"},
{"label": _(u"Catégorie de tarif"), "code": "categorie_tarif"},
{"label": _(u"Ville de résidence"), "code": "ville_residence"},
{"label": _(u"Secteur géographique"), "code": "secteur"},
{"label": _(u"Age"), "code": "age"},
{"label": _(u"Ville de naissance"), "code": "ville_naissance"},
{"label": _(u"Ecole"), "code": "nom_ecole"},
{"label": _(u"Classe"), "code": "nom_classe"},
{"label": _(u"Niveau scolaire"), "code": "nom_niveau_scolaire"},
{"label": _(u"Régime social"), "code": "regime"},
{"label": _(u"Caisse d'allocations"), "code": "caisse"},
{"label": _(u"Quotient familial - Tranches tarifs"), "code": "qf_tarifs"},
{"label": _(u"Quotient familial - Tranches de 100"), "code": "qf_100"},
]
# Intégration des questionnaires
q = UTILS_Questionnaires.Questionnaires()
for public in ("famille", "individu"):
for dictTemp in q.GetQuestions(public):
label = _(u"Question %s. : %s") % (public[:3], dictTemp["label"])
code = "question_%s_%d" % (public, dictTemp["IDquestion"])
self.listeDonnees.append({"label": label, "code": code})
self.MAJ()
def GetQuestionnaire(self,
IDquestion=None,
IDfamille=None,
IDindividu=None):
if IDquestion in (None, "", 0):
return None
q = UTILS_Questionnaires.Questionnaires()
reponse = q.GetReponse(IDquestion, IDfamille, IDindividu)
return reponse
def InitModel(self):
# Initialisation des questionnaires
categorie = "location"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(type=categorie)
# MAJ du listview
self.donnees = self.GetTracks()
def __init__(self, parent):
wx.Choice.__init__(self, parent, -1)
self.parent = parent
self.listeDonnees = [
{
"label": _(u"Jour"),
"code": "jour"
},
{
"label": _(u"Mois"),
"code": "mois"
},
{
"label": _(u"Année"),
"code": "annee"
},
{
"label": _(u"Catégorie"),
"code": "categorie"
},
{
"label": _(u"Ville de résidence"),
"code": "ville_residence"
},
{
"label": _(u"Secteur géographique"),
"code": "secteur"
},
{
"label": _(u"Famille"),
"code": "famille"
},
{
"label": _(u"Régime social"),
"code": "regime"
},
{
"label": _(u"Caisse d'allocations"),
"code": "caisse"
},
{
"label": _(u"Quotient familial"),
"code": "qf"
},
]
# Intégration des questionnaires
q = UTILS_Questionnaires.Questionnaires()
for public in ("famille", ):
for dictTemp in q.GetQuestions(public):
label = _(u"Question %s. : %s") % (public[:3],
dictTemp["label"])
code = "question_%s_%d" % (public, dictTemp["IDquestion"])
self.listeDonnees.append({"label": label, "code": code})
self.MAJ()
def GetTracks(self):
""" Récupération des données """
listeID = None
# Importation des titulaires
if self.afficher_locations == True :
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation des questionnaires
categorie = "produit"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(type=categorie)
DB = GestionDB.DB()
# Importation des locations en cours
self.dictLocations = UTILS_Locations.GetProduitsLoues(DB=DB)
# Importation des produits
if self.filtreListeID == None :
condition = ""
else :
if len(self.filtreListeID) == 0: condition = "WHERE produits.IDproduit IN ()"
elif len(self.filtreListeID) == 1: condition = "WHERE produits.IDproduit IN (%d)" % self.filtreListeID[0]
else: condition = "WHERE produits.IDproduit IN %s" % str(tuple(self.filtreListeID))
req = """SELECT IDproduit, produits.nom, produits.observations, produits_categories.nom, quantite
FROM produits
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
%s;""" % condition
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for item in listeDonnees :
track = Track(parent=self, donnees=item)
valide = True
if listeID != None :
if item[0] not in listeID :
valide = False
# Mémorisation position
if self.dictPositions != None and track.IDproduit in self.dictPositions:
track.position = self.dictPositions[track.IDproduit]
# Coche afficher uniquement les disponibles
if self.coche_uniquement_disponibles == True and track.disponible == 0 :
valide = False
if valide == True :
listeListeView.append(track)
if self.selectionID == item[0] :
self.selectionTrack = track
return listeListeView
def __init__(self):
""" Récupération de toutes les données de base """
DB = GestionDB.DB()
# Récupération des infos sur l'organisme
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
self.dictOrganisme["nom"] = nom
self.dictOrganisme["rue"] = rue
self.dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
self.dictOrganisme["ville"] = ville
self.dictOrganisme["tel"] = tel
self.dictOrganisme["fax"] = fax
self.dictOrganisme["mail"] = mail
self.dictOrganisme["site"] = site
self.dictOrganisme["num_agrement"] = num_agrement
self.dictOrganisme["num_siret"] = num_siret
self.dictOrganisme["code_ape"] = code_ape
DB.Close()
# Get noms Titulaires et individus
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
self.dictIndividus = UTILS_Titulaires.GetIndividus()
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
# Récupération des questionnaires
self.Questionnaires_familles = UTILS_Questionnaires.ChampsEtReponses(
type="famille")
self.Questionnaires_locations = UTILS_Questionnaires.ChampsEtReponses(
type="location")
self.Questionnaires_produits = UTILS_Questionnaires.ChampsEtReponses(
type="produit")
def SetListe(self):
# Initialisation des questionnaires
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(type="location", avec_filtre=False)
self.Clear()
self.dictDonnees = {}
index = 0
for dictQuestion in self.liste_questions:
if dictQuestion["controle"] == "documents" :
self.Append(dictQuestion["label"])
self.dictDonnees[index] = dictQuestion["IDquestion"]
index += 1
self.SetSelection(0)
def MAJ(self):
liste_champs = []
# Recherche adresse du loueur
if "IDfamille" in self.dictParametres and self.dictParametres["IDfamille"] != None :
IDfamille = self.dictParametres["IDfamille"]
dict_titulaires = UTILS_Titulaires.GetTitulaires([IDfamille,])
rue = dict_titulaires[IDfamille]["adresse"]["rue"]
cp = dict_titulaires[IDfamille]["adresse"]["cp"]
ville = dict_titulaires[IDfamille]["adresse"]["ville"]
liste_champs.append({"code" : "adresse_famille", "label" : _(u"Lieu de résidence du loueur"), "adresse" : "%s %s %s" % (rue, cp, ville)})
# Questionnaire produits
if "IDproduit" in self.dictParametres and self.dictParametres["IDproduit"] != None :
IDproduit = self.dictParametres["IDproduit"]
questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="produit")
for dictQuestion in questionnaires.GetDonnees(ID=IDproduit):
liste_champs.append({"code" : dictQuestion["champ"], "label" : _(u"%s (produit)") % dictQuestion["label"], "adresse" : dictQuestion["reponse"]})
# Questionnaire catégories de produits
if "IDcategorie" in self.dictParametres and self.dictParametres["IDcategorie"] != None:
IDcategorie = self.dictParametres["IDcategorie"]
questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="categorie_produit")
for dictQuestion in questionnaires.GetDonnees(ID=IDcategorie):
liste_champs.append({"code": dictQuestion["champ"], "label": _(u"%s (catégorie de produits)") % dictQuestion["label"], "adresse": dictQuestion["reponse"]})
# Remplissage du ctrl
listeItems = []
self.dictDonnees = {}
index = 0
for dictValeurs in liste_champs :
self.dictDonnees[index] = dictValeurs
listeItems.append(dictValeurs["label"])
index += 1
if len(listeItems) == 0 :
self.Enable(False)
self.SetItems(listeItems)
def __init__(self, *args, **kwds):
# Récupération des paramètres perso
self.categorie = kwds.pop("categorie", "individus")
self.IDindividu = kwds.pop("IDindividu", None)
self.IDfamille = kwds.pop("IDfamille", None)
self.listeActivites = None
self.presents = None
# Infos organisme
self.dictOrganisme = GetInfosOrganisme()
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
# Initialisation du listCtrl
FastObjectListView.__init__(self, *args, **kwds)
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def __init__(self, *args, **kwds):
# Récupération des paramètres perso
self.categorie = kwds.pop("categorie", "individu")
self.afficher_colonne_numero = False
self.dictNumeros = {"famille": {}, "individu": {}}
self.donnees = []
# Infos organisme
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
# Initialisation du listCtrl
self.nom_fichier_liste = __file__
FastObjectListView.__init__(self, *args, **kwds)
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated)
def InitModel(self):
# Initialisation des questionnaires
categorie = "location_demande"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(type=categorie)
# Importation des titulaires de dossier
if self.IDfamille == None:
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Importation des propositions de locations
self.dictPropositions = UTILS_Locations.GetPropositionsLocations()
# MAJ du listview
self.donnees = self.GetTracks()
def Importation(self):
""" Importation des données """
DB = GestionDB.DB()
req = """SELECT produits.nom, produits.observations, produits.image, produits.IDcategorie, produits.quantite,
produits_categories.nom
FROM produits
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
WHERE IDproduit=%d;""" % self.IDproduit
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
nomProduit, observations, image, IDcategorie, quantite, nomCategorie = listeDonnees[
0]
if len(observations) > 0:
texte_observations = _(u"<BR>Notes : %s") % observations
else:
texte_observations = ""
if quantite == None:
quantite = 1
# Questionnaire
questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="produit")
liste_questions_temp = []
for dictQuestion in questionnaires.GetDonnees(ID=self.IDproduit):
liste_questions_temp.append(
u"%s : %s" % (dictQuestion["label"], dictQuestion["reponse"]))
# Caractéristiques
texte = _(u"""
<FONT SIZE=5><B>%s</B><BR></FONT>
<BR>
Catégorie : %s <BR>
Stock initial : %d <BR>
%s
%s
""") % (nomProduit, nomCategorie, quantite, texte_observations,
"<BR>".join(liste_questions_temp))
self.ctrl_produit.SetPage(texte)
# Logo
if image != None:
self.ctrl_logo.ChargeFromBuffer(image)
def MAJ(self):
import GestionDB
from Utils import UTILS_Questionnaires
from Utils import UTILS_Locations
from Utils import UTILS_Titulaires
# Importation des titulaires
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation des questionnaires
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(
type="produit")
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(
type="produit")
DB = GestionDB.DB()
# Importation des locations en cours
self.dictLocations = UTILS_Locations.GetProduitsLoues(DB=DB)
# Importation des caractéristiques du modèle
req = """SELECT categorie, IDdonnee
FROM documents_modeles
WHERE IDmodele=%d;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.categorie, self.IDdonnee = listeDonnees[0]
# Importation des produits
req = """SELECT IDproduit, produits.nom, produits.observations, produits_categories.nom, produits.quantite
FROM produits
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
WHERE produits.IDcategorie=%d;""" % self.IDdonnee
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
self.dictTracks = {}
for item in listeDonnees:
track = Track(parent=self, donnees=item)
self.dictTracks[track.IDproduit] = track
return self.dictTracks
def __init__(self, parent):
wx.Choice.__init__(self, parent, -1)
self.parent = parent
self.listeDonnees = [
{"label" : _(u"Jour"), "code" : "jour"},
{"label" : _(u"Mois"), "code" : "mois"},
{"label" : _(u"Année"), "code" : "annee"},
{"label" : _(u"Activité"), "code" : "activite"},
{"label" : _(u"Groupe"), "code" : "groupe"},
{"label" : _(u"Evènement"), "code": "evenement"},
{"label" : _(u"Evènement (avec date)"), "code": "evenement_date"},
{"label" : _(u"Etiquette"), "code": "etiquette"},
{"label" : _(u"Catégorie de tarif"), "code" : "categorie_tarif"},
{"label" : _(u"Ville de résidence"), "code" : "ville_residence"},
{"label" : _(u"Secteur géographique"), "code" : "secteur"},
{"label" : _(u"Genre (M/F)"), "code" : "genre"},
{"label" : _(u"Age"), "code" : "age"},
{"label" : _(u"Ville de naissance"), "code" : "ville_naissance"},
{"label" : _(u"Ecole"), "code" : "nom_ecole"},
{"label" : _(u"Classe"), "code" : "nom_classe"},
{"label" : _(u"Niveau scolaire"), "code" : "nom_niveau_scolaire"},
{"label" : _(u"Famille"), "code" : "famille"},
{"label" : _(u"Individu"), "code" : "individu"},
{"label" : _(u"Régime social"), "code" : "regime"},
{"label" : _(u"Caisse d'allocations"), "code" : "caisse"},
{"label" : _(u"Quotient familial"), "code" : "qf"},
{"label" : _(u"Catégorie de travail"), "code" : "categorie_travail"},
{"label" : _(u"Catégorie de travail du père"), "code" : "categorie_travail_pere"},
{"label" : _(u"Catégorie de travail de la mère"), "code" : "categorie_travail_mere"},
]
# Intégration des questionnaires
q = UTILS_Questionnaires.Questionnaires()
for public in ("famille", "individu") :
for dictTemp in q.GetQuestions(public) :
label = _(u"Question %s. : %s") % (public[:3], dictTemp["label"])
code = "question_%s_%d" % (public, dictTemp["IDquestion"])
self.listeDonnees.append({"label" : label, "code" : code})
self.MAJ()
def InitModel(self):
# Initialisation des questionnaires
categorie = "inscription"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(
type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(
type=categorie)
# Importation des données
self.donnees = self.GetTracks()
# Infos individus
self.infosIndividus = UTILS_Infos_individus.Informations()
for track in self.donnees:
self.infosIndividus.SetAsAttributs(parent=track,
mode="individu",
ID=track.IDindividu)
for track in self.donnees:
self.infosIndividus.SetAsAttributs(parent=track,
mode="famille",
ID=track.IDfamille)
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"RECU_REGLEMENT", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_edition = dictDonnees["date"]
try:
date_editionDD = DateEngEnDateDD(DateFrEng(date_edition))
except:
date_editionDD = ""
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille": self.IDfamille,
"{IDFAMILLE}": str(self.IDfamille),
"num_recu": dictDonnees["numero"],
"{DATE_EDITION}": dictDonnees["date"],
"{LIEU_EDITION}": dictDonnees["lieu"],
"{DESTINATAIRE_NOM}": dictDonnees["nom"],
"{DESTINATAIRE_RUE}": dictDonnees["rue"],
"{DESTINATAIRE_VILLE}": dictDonnees["ville"],
"{NUM_RECU}": dictDonnees["numero"],
"{DATE_EDITION}": date_edition,
"{DATE_EDITION_LONG}": DateComplete(date_editionDD),
"{DATE_EDITION_COURT}": date_edition,
"{ORGANISATEUR_NOM}": dictOrganisme["nom"],
"{ORGANISATEUR_RUE}": dictOrganisme["rue"],
"{ORGANISATEUR_CP}": dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}": dictOrganisme["ville"],
"{ORGANISATEUR_TEL}": dictOrganisme["tel"],
"{ORGANISATEUR_FAX}": dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}": dictOrganisme["mail"],
"{ORGANISATEUR_SITE}": dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}": dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}": dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}": dictOrganisme["code_ape"],
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{GENRE}", genreSignataire)
textIntro = textIntro.replace("{NOM}", nomSignataire)
textIntro = textIntro.replace("{FONCTION}", fonctionSignataire)
textIntro = textIntro.replace("{FAMILLE}", dictDonnees["nom"])
textIntro = textIntro.replace(
"{MONTANT}",
u"<b>%.2f %s</b>" % (self.dictReglement["montant"], SYMBOLE))
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Envoi des informations sur le règlement
for key, valeur in self.dictReglement.iteritems():
dictValeurs[key] = valeur
dictValeurs["{IDREGLEMENT}"] = str(dictValeurs["IDreglement"])
dictValeurs["{DATE_REGLEMENT}"] = DateEngFr(
dictValeurs["dateReglement"])
dictValeurs["{MODE_REGLEMENT}"] = dictValeurs["nomMode"]
if dictValeurs["nomEmetteur"] != None:
dictValeurs["{NOM_EMETTEUR}"] = dictValeurs["nomEmetteur"]
else:
dictValeurs["{NOM_EMETTEUR}"] = ""
dictValeurs["{NUM_PIECE}"] = dictValeurs["numPiece"]
dictValeurs["{MONTANT_REGLEMENT}"] = u"%.2f %s" % (
dictValeurs["montant"], SYMBOLE)
dictValeurs["{NOM_PAYEUR}"] = dictValeurs["nomPayeur"]
dictValeurs["{NUM_QUITTANCIER}"] = str(dictValeurs["numQuittancier"])
dictValeurs["{DATE_SAISIE}"] = DateEngFr(dictValeurs["date_saisie"])
dictValeurs["{OBSERVATIONS}"] = u"%s" % dictValeurs["observations"]
# Récupération liste des prestations
if self.ctrl_prestations.GetValue() == True:
dictValeurs["prestations"] = self.GetPrestations()
else:
dictValeurs["prestations"] = []
# Préparation des données pour une sauvegarde de l'attestation
self.dictSave = {}
self.dictSave["numero"] = dictDonnees["numero"]
self.dictSave["IDfamille"] = self.IDfamille
self.dictSave["date_edition"] = DateFrEng(dictDonnees["date"])
self.dictSave["IDutilisateur"] = UTILS_Identification.GetIDutilisateur(
)
self.dictSave["IDreglement"] = self.IDreglement
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
dictChampsFusion["{DATE_EDITION_RECU}"] = DateFrEng(
dictDonnees["date"])
dictChampsFusion["{NUMERO_RECU}"] = dictDonnees["numero"]
dictChampsFusion["{ID_REGLEMENT}"] = str(dictValeurs["{IDREGLEMENT}"])
dictChampsFusion["{DATE_REGLEMENT}"] = dictValeurs["{DATE_REGLEMENT}"]
dictChampsFusion["{MODE_REGLEMENT}"] = dictValeurs["{MODE_REGLEMENT}"]
dictChampsFusion["{NOM_EMETTEUR}"] = dictValeurs["{NOM_EMETTEUR}"]
dictChampsFusion["{NUM_PIECE}"] = dictValeurs["{NUM_PIECE}"]
dictChampsFusion["{MONTANT_REGLEMENT}"] = dictValeurs[
"{MONTANT_REGLEMENT}"]
dictChampsFusion["{NOM_PAYEUR}"] = dictValeurs["{NOM_PAYEUR}"]
dictChampsFusion["{NUM_QUITTANCIER}"] = dictValeurs[
"{NUM_QUITTANCIER}"]
dictChampsFusion["{DATE_SAISIE}"] = dictValeurs["{DATE_SAISIE}"]
# Fabrication du PDF
from Utils import UTILS_Impression_recu
UTILS_Impression_recu.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
def InitObjectListView(self):
def FormateDate(dateStr):
if dateStr == "" or dateStr == None: return ""
date = str(
datetime.date(year=int(dateStr[:4]),
month=int(dateStr[5:7]),
day=int(dateStr[8:10])))
text = str(date[8:10]) + "/" + str(date[5:7]) + "/" + str(date[:4])
return text
def FormateAge(age):
if age == None: return ""
return _(u"%d ans") % age
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
if self.categorie == "individu":
# INDIVIDUS
liste_Colonnes = [
ColumnDefn(u"ID", "left", 0, "IDindividu",
typeDonnee="entier"),
ColumnDefn(_(u"Nom"), 'left', 100, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Prénom"),
"left",
100,
"prenom",
typeDonnee="texte"),
ColumnDefn(_(u"Date naiss."),
"left",
72,
"date_naiss",
typeDonnee="date",
stringConverter=FormateDate),
ColumnDefn(_(u"Age"),
"left",
50,
"age",
typeDonnee="entier",
stringConverter=FormateAge),
ColumnDefn(_(u"Famille"),
'left',
200,
"nomTitulaires",
typeDonnee="texte"),
ColumnDefn(_(u"Rue"),
"left",
150,
"rue_resid",
typeDonnee="texte"),
ColumnDefn(_(u"C.P."),
"left",
50,
"cp_resid",
typeDonnee="texte"),
ColumnDefn(_(u"Ville"),
"left",
120,
"ville_resid",
typeDonnee="texte"),
]
else:
# FAMILLES
liste_Colonnes = [
ColumnDefn(_(u"ID"),
"left",
0,
"IDfamille",
typeDonnee="entier"),
ColumnDefn(_(u"Famille"),
'left',
200,
"nomTitulaires",
typeDonnee="texte"),
ColumnDefn(_(u"Rue"), "left", 160, "rue", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 45, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"),
"left",
120,
"ville",
typeDonnee="texte"),
ColumnDefn(_(u"Email"),
"left",
100,
"mail",
typeDonnee="texte"),
ColumnDefn(_(u"Régime"),
"left",
130,
"regime",
typeDonnee="texte"),
ColumnDefn(_(u"Caisse"),
"left",
130,
"caisse",
typeDonnee="texte"),
ColumnDefn(_(u"Numéro Alloc."),
"left",
120,
"numAlloc",
typeDonnee="texte"),
]
if self.afficher_colonne_numero == True:
liste_Colonnes.insert(
1,
ColumnDefn(_(u"Numéro"),
"left",
90,
"numero",
typeDonnee="texte"))
# Ajout des questions des questionnaires
liste_Colonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.LISTE_QUESTIONS))
self.SetColumns(liste_Colonnes)
self.CreateCheckStateColumn(0)
if self.categorie == "individu":
self.SetEmptyListMsg(_(u"Aucun individu"))
else:
self.SetEmptyListMsg(_(u"Aucune famille"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
if self.afficher_colonne_numero == True:
self.SetSortColumn(self.columns[3])
else:
self.SetSortColumn(self.columns[2])
self.SetObjects(self.donnees)
def InitObjectListView(self):
# Création du imageList
for categorie, civilites in Civilites.LISTE_CIVILITES:
for IDcivilite, CiviliteLong, CiviliteAbrege, nomImage, genre in civilites:
indexImg = self.AddNamedImages(
nomImage,
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/%s" % nomImage),
wx.BITMAP_TYPE_PNG))
self.imgVert = self.AddNamedImages(
"vert",
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_vert.png"),
wx.BITMAP_TYPE_PNG))
self.imgRouge = self.AddNamedImages(
"rouge",
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_rouge.png"),
wx.BITMAP_TYPE_PNG))
self.imgOrange = self.AddNamedImages(
"orange",
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_orange.png"),
wx.BITMAP_TYPE_PNG))
def GetImageCivilite(track):
return track.nomImage
def GetImageVentilation(track):
if track.totalFacture == track.totalRegle:
return self.imgVert
if track.totalRegle == FloatToDecimal(
0.0) or track.totalRegle == None:
return self.imgRouge
if track.totalRegle < track.totalFacture:
return self.imgOrange
return self.imgRouge
def FormateDate(dateDD):
if dateDD == None: return ""
return UTILS_Dates.DateEngFr(str(dateDD))
def FormateMontant(montant):
if montant == None or montant == "": return ""
return u"%.2f %s" % (montant, SYMBOLE)
def FormateSolde(montant):
if montant == None: FloatToDecimal(0.0)
if montant == FloatToDecimal(0.0):
return u"%.2f %s" % (montant, SYMBOLE)
elif montant > FloatToDecimal(0.0):
return u"- %.2f %s" % (montant, SYMBOLE)
else:
return u"+ %.2f %s" % (montant, SYMBOLE)
def FormateAge(age):
if age == None: return ""
return _(u"%d ans") % age
def rowFormatter(listItem, track):
if track.valide == False:
listItem.SetTextColour(wx.Colour(150, 150, 150))
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = "#FFFFFF" # Vert
# Création des colonnes
listeColonnes = []
for dictChamp in LISTE_CHAMPS:
if dictChamp["afficher"] == True:
# stringConverter
if "stringConverter" in dictChamp:
stringConverter = dictChamp["stringConverter"]
if stringConverter == "date": stringConverter = FormateDate
elif stringConverter == "age": stringConverter = FormateAge
elif stringConverter == "montant":
stringConverter = FormateMontant
elif stringConverter == "solde":
stringConverter = FormateSolde
else:
stringConverter = None
else:
stringConverter = None
# Image Getter
if "imageGetter" in dictChamp:
imageGetter = dictChamp["imageGetter"]
if imageGetter == "civilite":
imageGetter = GetImageCivilite
elif imageGetter == "ventilation":
imageGetter = GetImageVentilation
else:
imageGetter = None
else:
imageGetter = None
# Création de la colonne
colonne = ColumnDefn(dictChamp["label"],
dictChamp["align"],
dictChamp["largeur"],
dictChamp["code"],
typeDonnee=dictChamp["typeDonnee"],
stringConverter=stringConverter,
imageGetter=imageGetter)
listeColonnes.append(colonne)
# Ajout des questions des questionnaires
listeColonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
# Ajout des infos individus
listeChamps = UTILS_Infos_individus.GetNomsChampsPossibles(
mode="individu+famille")
for titre, exemple, code in listeChamps:
if u"n°" not in titre and "_x_" not in code:
typeDonnee = UTILS_Infos_individus.GetTypeChamp(code)
code = code.replace("{", "").replace("}", "")
listeColonnes.append(
ColumnDefn(titre,
"left",
100,
code,
typeDonnee=typeDonnee,
visible=False))
#self.SetColumns(listeColonnes)
self.SetColumns2(colonnes=listeColonnes,
nomListe="OL_Liste_inscriptions")
# Regroupement
if self.regroupement != None:
#self.SetColonneTri(self.regroupement)
self.SetAlwaysGroupByColumn(self.regroupement)
self.SetShowGroups(True)
self.useExpansionColumn = False
else:
self.SetShowGroups(False)
self.useExpansionColumn = False
# Case à cocher
if self.checkColonne == True:
self.CreateCheckStateColumn(0)
if len(self.columns) > 0:
self.SetSortColumn(self.columns[1])
else:
if len(self.columns) > 0:
self.SetSortColumn(self.columns[0])
self.SetShowItemCounts(True)
self.SetEmptyListMsg(_(u"Aucune inscription"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetObjects(self.donnees)
def Remplissage(self):
# Regroupement
self.Append(wxpg.PropertyCategory(_(u"Regroupement")))
# Regroupement principal
liste_regroupements = [
("aucun", _(u"Aucun")),
("jour", _(u"Jour")),
("mois", _(u"Mois")),
("annee", _(u"Année")),
("activite", _(u"Activité")),
("groupe", _(u"Groupe")),
("evenement", _(u"Evènement")),
("evenement_date", _(u"Evènement (avec date)")),
("etiquette", _(u"Etiquette")),
("unite_conso", _(u"Unité de consommation")),
("categorie_tarif", _(u"Catégorie de tarif")),
("ville_residence", _(u"Ville de résidence")),
("secteur", _(u"Secteur géographique")),
("genre", _(u"Genre (M/F)")),
("age", _(u"Age")),
("ville_naissance", _(u"Ville de naissance")),
("nom_ecole", _(u"Ecole")),
("nom_classe", _(u"Classe")),
("nom_niveau_scolaire", _(u"Niveau scolaire")),
("individu", _(u"Individu")),
("famille", _(u"Famille")),
("regime", _(u"Régime social")),
("caisse", _(u"Caisse d'allocations")),
("qf_perso", _(u"Quotient familial (tranches personnalisées)")),
("qf_tarifs", _(u"Quotient familial (tranches paramétrées)")),
("qf_100", _(u"Quotient familial (tranches de 100)")),
("categorie_travail", _(u"Catégorie de travail")),
("categorie_travail_pere", _(u"Catégorie de travail du père")),
("categorie_travail_mere",
_(u"Catégorie de travail de la mère")),
]
# Intégration des questionnaires
q = UTILS_Questionnaires.Questionnaires()
for public in ("famille", "individu"):
for dictTemp in q.GetQuestions(public):
label = _(u"Question %s. : %s") % (public[:3],
dictTemp["label"])
code = "question_%s_%d" % (public, dictTemp["IDquestion"])
liste_regroupements.append((code, label))
propriete = CTRL_Propertygrid.Propriete_choix(
label=_(u"Regroupement principal"),
name="regroupement_principal",
liste_choix=liste_regroupements,
valeur="aucun")
propriete.SetEditor("EditeurChoix")
propriete.SetHelpString(
_(u"Sélectionnez un niveau de regroupement principal"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Tranches d'âge
propriete = CTRL_Propertygrid.Propriete_liste(
label=_(u"Regroupement par tranches d'âge"),
name="regroupement_age",
liste_selections=[])
propriete.SetHelpString(
_(u"Saisissez les tranches d'âge souhaitées séparées par des virgules. Exemple : '3, 6, 12'"
))
propriete.SetAttribute("obligatoire", False)
self.Append(propriete)
# Tranches de QF perso
propriete = CTRL_Propertygrid.Propriete_liste(
label=_(u"Regroupement par tranches de QF"),
name="tranches_qf_perso",
liste_selections=[])
propriete.SetHelpString(
_(u"Attention, à utiliser avec le regroupement principal 'Quotient familial (tranches personnalisées)'. Saisissez les tranches de QF souhaitées séparées par des virgules. Exemple : '650, 800, 1200'"
))
propriete.SetAttribute("obligatoire", False)
self.Append(propriete)
# Afficher les périodes détaillées
propriete = wxpg.BoolProperty(
label=_(u"Regroupement par périodes détaillées"),
name="periodes_detaillees",
value=False)
propriete.SetHelpString(
_(u"Cochez cette case pour afficher les périodes détaillées"))
propriete.SetAttribute("UseCheckbox", True)
self.Append(propriete)
# Données
self.Append(wxpg.PropertyCategory(_(u"Données")))
propriete = CTRL_Propertygrid.Propriete_choix(
label=_(u"Format des données"),
name="format_donnees",
liste_choix=[("horaire", _(u"Horaire")),
("decimal", _(u"Décimal"))],
valeur="horaire")
propriete.SetEditor("EditeurChoix")
propriete.SetHelpString(
_(u"Sélectionnez le format d'affichage des données"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Afficher l'avertissement 'familles sans régime'
propriete = wxpg.BoolProperty(
label=_(u"Avertissement si régime famille inconnu"),
name="afficher_regime_inconnu",
value=True)
propriete.SetHelpString(
_(u"Cochez cette case pour afficher un avertissement si le régime d'une ou plusieurs familles est inconnu"
))
propriete.SetAttribute("UseCheckbox", True)
self.Append(propriete)
# Associer régime inconnu
DB = GestionDB.DB()
req = """SELECT IDregime, nom FROM regimes ORDER BY nom;"""
DB.ExecuterReq(req)
liste_regimes = DB.ResultatReq()
DB.Close()
liste_regimes.insert(0, ("non", _(u"Non")))
propriete = CTRL_Propertygrid.Propriete_choix(
label=_(u"Associer régime inconnu à un régime"),
name="associer_regime_inconnu",
liste_choix=liste_regimes,
valeur="non")
propriete.SetEditor("EditeurChoix")
propriete.SetHelpString(
_(u"Sélectionnez le régime dans lequel vous souhaitez inclure les familles au régime inconnu"
))
propriete.SetAttribute("obligatoire", False)
self.Append(propriete)
# Plafond journalier par individu
propriete = wxpg.IntProperty(
label=_(u"Plafond journalier par individu (en minutes)"),
name="plafond_journalier_individu",
value=0)
propriete.SetHelpString(
_(u"Saisissez un plafond journalier (en minutes) par individu, toutes activités confondues (0 = désactivé). Exemple : une valeur de 120 (minutes) plafonnera le temps retenu pour chaque individu à hauteur de 2 heures."
))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Filtres
self.Append(wxpg.PropertyCategory(_(u"Filtres")))
# Jours hors vacances
liste_jours = [(0, _(u"Lundi")), (1, _(u"Mardi")), (2, _(u"Mercredi")),
(3, _(u"Jeudi")), (4, _(u"Vendredi")),
(5, _(u"Samedi")), (6, _(u"Dimanche"))]
propriete = CTRL_Propertygrid.Propriete_multichoix(
label=_(u"Jours hors vacances"),
name="jours_hors_vacances",
liste_choix=liste_jours,
liste_selections=[0, 1, 2, 3, 4, 5, 6])
propriete.SetHelpString(
_(u"Sélectionnez les jours hors vacances à inclure dans les calculs. Cliquez sur le bouton à droite du champ de saisie pour accéder à la fenêtre de sélection."
))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Jours de vacances
propriete = CTRL_Propertygrid.Propriete_multichoix(
label=_(u"Jours de vacances"),
name="jours_vacances",
liste_choix=liste_jours,
liste_selections=[0, 1, 2, 3, 4, 5, 6])
propriete.SetHelpString(
_(u"Sélectionnez les jours de vacances à inclure dans les calculs. Cliquez sur le bouton à droite du champ de saisie pour accéder à la fenêtre de sélection."
))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Etat des consommations
self.liste_codes_etats = [
"reservation", "present", "absentj", "absenti"
]
liste_etats = [(0, _(u"Pointage en attente")), (1, _(u"Présent")),
(2, _(u"Absence justifiée")),
(3, _(u"Absence injustifiée"))]
propriete = CTRL_Propertygrid.Propriete_multichoix(
label=_(u"Etat des consommations"),
name="etat_consommations",
liste_choix=liste_etats,
liste_selections=[0, 1, 2, 3])
propriete.SetHelpString(
_(u"Sélectionnez les états de consommations à inclure dans les calculs. Cliquez sur le bouton à droite du champ de saisie pour accéder à la fenêtre de sélection."
))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Affichage
self.Append(wxpg.PropertyCategory(_(u"Affichage")))
# Orientation page
propriete = CTRL_Propertygrid.Propriete_choix(
label=_(u"Orientation de la page"),
name="orientation",
liste_choix=[("portrait", _(u"Portrait")),
("paysage", _(u"Paysage"))],
valeur="portrait")
propriete.SetEditor("EditeurChoix")
propriete.SetHelpString(_(u"Sélectionnez l'orientation de la page"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Couleur Ligne tranche d'âge
propriete = wxpg.ColourProperty(
label=_(u"Couleur de la ligne tranche d'âge"),
name="couleur_ligne_age",
value=wx.Colour(192, 192, 192))
propriete.SetHelpString(
_(u"Sélectionnez la couleur de la ligne tranche d'âge"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Couleur Ligne total
propriete = wxpg.ColourProperty(label=_(u"Couleur de la ligne total"),
name="couleur_ligne_total",
value=wx.Colour(234, 234, 234))
propriete.SetHelpString(
_(u"Sélectionnez la couleur de la ligne total"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Couleur case regroupement principal
propriete = wxpg.ColourProperty(
label=_(u"Couleur de la case regroupement principal"),
name="couleur_case_regroupement",
value=wx.Colour(0, 0, 0))
propriete.SetHelpString(
_(u"Sélectionnez la couleur de la case regroupement principal"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
# Couleur texte regroupement principal
propriete = wxpg.ColourProperty(
label=_(u"Couleur du texte regroupement principal"),
name="couleur_texte_regroupement",
value=wx.Colour(255, 255, 255))
propriete.SetHelpString(
_(u"Sélectionnez la couleur du texte regroupement principal"))
propriete.SetAttribute("obligatoire", True)
self.Append(propriete)
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
# Préparation de la listeImages
self.AddNamedImages(
"indisponible",
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit.png"),
wx.BITMAP_TYPE_PNG))
self.AddNamedImages(
"disponible",
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok4.png"),
wx.BITMAP_TYPE_PNG))
def GetImageDisponible(track):
if track.disponible > 0:
return "disponible"
else:
return "indisponible"
def FormateDate(date):
if date == None:
return _(u"")
else:
return datetime.datetime.strftime(date, "%d/%m/%Y - %Hh%M")
def FormatePosition(position):
if position == None:
return _(u"")
elif position == 1:
return _(u"1er")
else:
return _(u"%dème") % position
def FormateDisponible(disponible):
if disponible == 1:
return _(u"1 disponible")
if disponible > 1:
return _(u"%d disponibles") % disponible
return _("Non")
dict_colonnes = {
"IDproduit":
ColumnDefn(u"", "left", 0, "IDproduit", typeDonnee="entier"),
"nom":
ColumnDefn(_(u"Nom"), 'left', 170, "nom", typeDonnee="texte"),
"nomCategorie":
ColumnDefn(_(u"Catégorie"),
'left',
170,
"nomCategorie",
typeDonnee="texte"),
"quantite":
ColumnDefn(_(u"Stock initial"),
"left",
70,
"quantite",
typeDonnee="entier"),
"disponible":
ColumnDefn(_(u"Disponibilité"),
"left",
110,
"disponible",
typeDonnee="texte",
stringConverter=FormateDisponible,
imageGetter=GetImageDisponible),
"nomTitulaires":
ColumnDefn(_(u"Loueur"),
"left",
200,
"nomTitulaires",
typeDonnee="texte"),
"date_debut":
ColumnDefn(_(u"Début"),
"left",
120,
"date_debut",
typeDonnee="texte",
stringConverter=FormateDate),
"date_fin":
ColumnDefn(_(u"Fin"),
"left",
120,
"date_fin",
typeDonnee="texte",
stringConverter=FormateDate),
"position":
ColumnDefn(u"Position",
"left",
80,
"position",
typeDonnee="entier",
stringConverter=FormatePosition),
}
if self.afficher_locations == True:
if self.afficher_detail_location == True:
liste_temp = [
"IDproduit", "nom", "nomCategorie", "quantite",
"disponible", "nomTitulaires", "date_debut", "date_fin"
]
else:
liste_temp = [
"IDproduit", "nom", "nomCategorie", "quantite",
"disponible"
]
else:
liste_temp = ["IDproduit", "nom", "nomCategorie", "quantite"]
if self.dictPositions != None:
liste_temp.append("position")
liste_Colonnes = []
for code in liste_temp:
liste_Colonnes.append(dict_colonnes[code])
# Ajout des questions des questionnaires
liste_Colonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
self.SetColumns(liste_Colonnes)
if self.selection_multiple == True:
self.CreateCheckStateColumn(0)
self.SetEmptyListMsg(_(u"Aucun produit"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
def InitObjectListView(self):
# Création du imageList
for categorie, civilites in Civilites.LISTE_CIVILITES :
for IDcivilite, CiviliteLong, CiviliteAbrege, nomImage, genre in civilites :
indexImg = self.AddNamedImages(nomImage, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/%s" % nomImage), wx.BITMAP_TYPE_PNG))
def GetImageCivilite(track):
return track.nomImage
def FormateDate(dateStr):
if dateStr == "" or dateStr == None : return ""
date = str(datetime.date(year=int(dateStr[:4]), month=int(dateStr[5:7]), day=int(dateStr[8:10])))
text = str(date[8:10]) + "/" + str(date[5:7]) + "/" + str(date[:4])
return text
def FormateAge(age):
if age == None : return ""
return _(u"%d ans") % age
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
if self.categorie == "individus" :
# INDIVIDUS
liste_Colonnes = [
ColumnDefn(u"", "left", 22, "IDindividu", typeDonnee="entier", imageGetter=GetImageCivilite),
ColumnDefn(_(u"Nom"), 'left', 100, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Prénom"), "left", 100, "prenom", typeDonnee="texte"),
ColumnDefn(_(u"Date naiss."), "left", 72, "date_naiss", typeDonnee="date", stringConverter=FormateDate),
ColumnDefn(_(u"Age"), "left", 50, "age", typeDonnee="entier", stringConverter=FormateAge),
ColumnDefn(_(u"Rue"), "left", 150, "rue_resid", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 50, "cp_resid", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), "left", 120, "ville_resid", typeDonnee="texte"),
ColumnDefn(_(u"Secteur"), "left", 120, "secteur", typeDonnee="texte"),
## ColumnDefn(_(u"Tél. domicile"), "left", 100, "tel_domicile"),
## ColumnDefn(_(u"Tél. mobile"), "left", 100, "tel_mobile"),
ColumnDefn(_(u"Email"), "left", 150, "mail", typeDonnee="texte"),
## ColumnDefn(_(u"Profession"), "left", 150, "profession"),
## ColumnDefn(_(u"Employeur"), "left", 150, "employeur"),
## ColumnDefn(_(u"Tél pro."), "left", 100, "travail_tel"),
## ColumnDefn(_(u"Email pro."), "left", 150, "travail_mail"),
]
else:
# FAMILLES
liste_Colonnes = [
ColumnDefn(_(u"ID"), "left", 0, "IDfamille", typeDonnee="entier"),
ColumnDefn(_(u"Famille"), 'left', 200, "nomTitulaires", typeDonnee="texte"),
ColumnDefn(_(u"Rue"), "left", 160, "rue", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 45, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), "left", 120, "ville", typeDonnee="texte"),
ColumnDefn(_(u"Secteur"), "left", 120, "secteur", typeDonnee="texte"),
ColumnDefn(_(u"Email"), "left", 100, "mail", typeDonnee="texte"),
ColumnDefn(_(u"Régime"), "left", 130, "regime", typeDonnee="texte"),
ColumnDefn(_(u"Caisse"), "left", 130, "caisse", typeDonnee="texte"),
ColumnDefn(_(u"Numéro Alloc."), "left", 120, "numAlloc", typeDonnee="texte"),
]
# Ajout des questions des questionnaires
liste_Colonnes.extend(UTILS_Questionnaires.GetColonnesForOL(self.LISTE_QUESTIONS))
self.SetColumns(liste_Colonnes)
self.CreateCheckStateColumn(0)
if self.categorie == "individus" :
self.SetEmptyListMsg(_(u"Aucun individu"))
else:
self.SetEmptyListMsg(_(u"Aucune famille"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[2])
self.SetObjects(self.donnees)
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.parent = parent
# Généralités
self.staticbox_generalites_staticbox = wx.StaticBox(self, -1, _(u"Généralités"))
self.label_nom = wx.StaticText(self, -1, _(u"Nom :"))
self.ctrl_nom = wx.TextCtrl(self, -1, "")
self.label_donnee = wx.StaticText(self, -1, _(u"Donnée :"))
liste_choix = [
("aucun", _(u"Aucune")),
("genre", _(u"Genre (M/F)")),
("date_naiss", _(u"Date de naissance")),
("ville_naissance", _(u"Ville de naissance")),
("medecin_nom", _(u"Nom du médecin")),
("tel_mobile", _(u"Tél. mobile")),
("tel_domicile", _(u"Tél. domicile")),
("mail", _(u"Email")),
("ville_residence", _(u"Ville de résidence")),
("secteur", _(u"Secteur géographique")),
("nom_ecole", _(u"Ecole")),
("nom_classe", _(u"Classe")),
("nom_niveau_scolaire", _(u"Niveau scolaire")),
("famille", _(u"Famille")),
("regime", _(u"Régime social")),
("caisse", _(u"Caisse d'allocations")),
]
# Intégration des questionnaires
q = UTILS_Questionnaires.Questionnaires()
for public in ("famille", "individu") :
for dictTemp in q.GetQuestions(public) :
label = _(u"Question %s. : %s") % (public[:3], dictTemp["label"])
code = "question_%s_%d" % (public, dictTemp["IDquestion"])
liste_choix.append((code, label))
self.ctrl_donnee = CTRL_Choix(self, liste_choix)
# Options
self.staticbox_options_staticbox = wx.StaticBox(self, -1, _(u"Options"))
self.label_largeur = wx.StaticText(self, -1, _(u"Largeur :"))
liste_choix = [("automatique", _(u"Automatique")),]
for x in range(5, 205, 5):
liste_choix.append((str(x), "%d pixels" % x))
self.ctrl_largeur = CTRL_Choix(self, liste_choix)
# 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"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_annuler = CTRL_Bouton_image.CTRL(self, id=wx.ID_CANCEL, texte=_(u"Annuler"), cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
# Init
self.SetTitle(_(u"Saisie d'une colonne"))
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"INSCRIPTION", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_editionDD = datetime.date.today()
# Adresse
self.IDindividu = self.dictInscription["IDINDIVIDU"]
individus = UTILS_Titulaires.GetIndividus()
self.dictInscription["INDIVIDU_RUE"] = individus[
self.IDindividu]["rue"]
self.dictInscription["INDIVIDU_CP"] = individus[self.IDindividu]["cp"]
self.dictInscription["INDIVIDU_VILLE"] = individus[
self.IDindividu]["ville"]
# Nom Titulaires
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[
self.IDfamille,
])
self.dictInscription["FAMILLE_NOM"] = dictTitulaires[
self.IDfamille]["titulairesSansCivilite"]
# Civilité
dictCivilites = Civilites.GetDictCivilites()
if self.dictInscription["IDCIVILITE"] == None or self.dictInscription[
"IDCIVILITE"] == "":
IDcivilite = 1
else:
IDcivilite = self.dictInscription["IDCIVILITE"]
self.dictInscription["INDIVIDU_GENRE"] = dictCivilites[IDcivilite][
"sexe"]
self.dictInscription["INDIVIDU_CIVILITE_LONG"] = dictCivilites[
IDcivilite]["civiliteLong"]
self.dictInscription["INDIVIDU_CIVILITE_COURT"] = dictCivilites[
IDcivilite]["civiliteAbrege"]
# Date de naissance
if self.dictInscription["INDIVIDU_DATE_NAISS"] == None:
self.dictInscription["INDIVIDU_AGE"] = None
else:
datenaissDD = datetime.date(
year=int(self.dictInscription["INDIVIDU_DATE_NAISS"][:4]),
month=int(self.dictInscription["INDIVIDU_DATE_NAISS"][5:7]),
day=int(self.dictInscription["INDIVIDU_DATE_NAISS"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
self.dictInscription["INDIVIDU_AGE"] = age
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille":
self.IDfamille,
"{IDFAMILLE}":
str(self.IDfamille),
"{DATE_EDITION}":
DateEngFr(str(date_editionDD)),
"{DATE_EDITION_LONG}":
DateComplete(date_editionDD),
"{DATE_EDITION_COURT}":
DateEngFr(str(date_editionDD)),
"{ORGANISATEUR_NOM}":
dictOrganisme["nom"],
"{ORGANISATEUR_RUE}":
dictOrganisme["rue"],
"{ORGANISATEUR_CP}":
dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}":
dictOrganisme["ville"],
"{ORGANISATEUR_TEL}":
dictOrganisme["tel"],
"{ORGANISATEUR_FAX}":
dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}":
dictOrganisme["mail"],
"{ORGANISATEUR_SITE}":
dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}":
dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}":
dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}":
dictOrganisme["code_ape"],
"{IDINSCRIPTION}":
FormateStr(self.dictInscription["IDINSCRIPTION"]),
"{DATE_INSCRIPTION}":
FormateDate(self.dictInscription["DATE_INSCRIPTION"]),
"{EST_PARTI}":
FormateBool(self.dictInscription["EST_PARTI"]),
"{IDACTIVITE}":
FormateStr(self.dictInscription["IDACTIVITE"]),
"{ACTIVITE_NOM_LONG}":
FormateStr(self.dictInscription["ACTIVITE_NOM_LONG"]),
"{ACTIVITE_NOM_COURT}":
FormateStr(self.dictInscription["ACTIVITE_NOM_COURT"]),
"{IDGROUPE}":
FormateStr(self.dictInscription["IDGROUPE"]),
"{GROUPE_NOM_LONG}":
FormateStr(self.dictInscription["GROUPE_NOM_LONG"]),
"{GROUPE_NOM_COURT}":
FormateStr(self.dictInscription["GROUPE_NOM_COURT"]),
"{IDCATEGORIETARIF}":
FormateStr(self.dictInscription["IDCATEGORIETARIF"]),
"{NOM_CATEGORIE_TARIF}":
FormateStr(self.dictInscription["NOM_CATEGORIE_TARIF"]),
"{IDINDIVIDU}":
FormateStr(self.dictInscription["IDINDIVIDU"]),
"{INDIVIDU_CIVILITE_LONG}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_LONG"]),
"{INDIVIDU_CIVILITE_COURT}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_COURT"]),
"{INDIVIDU_GENRE}":
FormateStr(self.dictInscription["INDIVIDU_GENRE"]),
"{INDIVIDU_NOM}":
FormateStr(self.dictInscription["INDIVIDU_NOM"]),
"{INDIVIDU_PRENOM}":
FormateStr(self.dictInscription["INDIVIDU_PRENOM"]),
"{INDIVIDU_DATE_NAISS}":
FormateDate(self.dictInscription["INDIVIDU_DATE_NAISS"]),
"{INDIVIDU_AGE}":
FormateStr(self.dictInscription["INDIVIDU_AGE"]),
"{INDIVIDU_CP_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_CP_NAISS"]),
"{INDIVIDU_VILLE_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_VILLE_NAISS"]),
"{INDIVIDU_RUE}":
FormateStr(self.dictInscription["INDIVIDU_RUE"]),
"{INDIVIDU_CP}":
FormateStr(self.dictInscription["INDIVIDU_CP"]),
"{INDIVIDU_VILLE}":
FormateStr(self.dictInscription["INDIVIDU_VILLE"]),
"{INDIVIDU_PROFESSION}":
FormateStr(self.dictInscription["INDIVIDU_PROFESSION"]),
"{INDIVIDU_EMPLOYEUR}":
FormateStr(self.dictInscription["INDIVIDU_EMPLOYEUR"]),
"{INDIVIDU_TEL_DOMICILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_DOMICILE"]),
"{INDIVIDU_TEL_MOBILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_MOBILE"]),
"{INDIVIDU_FAX}":
FormateStr(self.dictInscription["INDIVIDU_FAX"]),
"{INDIVIDU_EMAIL}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL"]),
"{INDIVIDU_TEL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_TEL_PRO"]),
"{INDIVIDU_FAX_PRO}":
FormateStr(self.dictInscription["INDIVIDU_FAX_PRO"]),
"{INDIVIDU_EMAIL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL_PRO"]),
"{FAMILLE_NOM}":
FormateStr(self.dictInscription["FAMILLE_NOM"]),
"{FAMILLE_CAISSE}":
FormateStr(self.dictInscription["FAMILLE_CAISSE"]),
"{FAMILLE_REGIME}":
FormateStr(self.dictInscription["FAMILLE_REGIME"]),
"{FAMILLE_NUMALLOC}":
FormateStr(self.dictInscription["FAMILLE_NUMALLOC"]),
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
dictValeurs.update(
self.infosIndividus.GetDictValeurs(
mode="individu",
ID=self.dictInscription["IDINDIVIDU"],
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{SIGNATAIRE_GENRE}",
genreSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_NOM}", nomSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_FONCTION}",
fonctionSignataire)
for key, valeur in dictValeurs.items():
if key.startswith("{"):
if valeur == None: valeur = ""
if type(valeur) == int: valeur = str(valeur)
textIntro = textIntro.replace(key, valeur)
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Tableau
dictValeurs["tableau"] = self.ctrl_tableau.GetValue()
for key, valeur in dictValeurs.items():
if valeur == None: valeur = ""
dictChampsFusion[key] = valeur
# Préparation des données pour une sauvegarde dans l'historique
self.dictSave = {}
self.dictSave["activite"] = self.dictInscription["ACTIVITE_NOM_LONG"]
self.dictSave["groupe"] = self.dictInscription["GROUPE_NOM_LONG"]
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Fabrication du PDF
from Utils import UTILS_Impression_inscription
UTILS_Impression_inscription.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
def FormateDate(date):
if date == None:
return _(u"Non définie")
else:
return datetime.datetime.strftime(date, "%d/%m/%Y - %Hh%M")
dict_colonnes = {
"IDlocation":
ColumnDefn(u"", "left", 0, "IDlocation", typeDonnee="entier"),
"date_debut":
ColumnDefn(_(u"Début"),
"left",
130,
"date_debut",
typeDonnee="date",
stringConverter=FormateDate),
"date_fin":
ColumnDefn(_(u"Fin"),
"left",
130,
"date_fin",
typeDonnee="date",
stringConverter=FormateDate),
"nomProduit":
ColumnDefn(_(u"Nom du produit"),
'left',
200,
"nomProduit",
typeDonnee="texte"),
"nomCategorie":
ColumnDefn(_(u"Catégorie du produit"),
'left',
200,
"nomCategorie",
typeDonnee="texte"),
"quantite":
ColumnDefn(u"Qté", "left", 60, "quantite", typeDonnee="entier"),
"nomTitulaires":
ColumnDefn(_(u"Nom"),
'left',
270,
"nomTitulaires",
typeDonnee="texte"),
"rue":
ColumnDefn(_(u"Rue"), 'left', 200, "rue", typeDonnee="texte"),
"cp":
ColumnDefn(_(u"C.P."), 'left', 70, "cp", typeDonnee="texte"),
"ville":
ColumnDefn(_(u"Ville"), 'left', 150, "ville", typeDonnee="texte"),
}
liste_temp = [
"IDlocation", "date_debut", "date_fin", "nomProduit",
"nomCategorie", "quantite", "nomTitulaires", "rue", "cp", "ville"
]
if self.IDfamille != None:
liste_temp = [
"IDlocation", "date_debut", "date_fin", "nomProduit",
"nomCategorie", "quantite"
]
if self.IDproduit != None:
liste_temp = [
"IDlocation", "date_debut", "date_fin", "quantite",
"nomTitulaires", "rue", "cp", "ville"
]
liste_Colonnes = []
for code in liste_temp:
liste_Colonnes.append(dict_colonnes[code])
# Ajout des questions des questionnaires
liste_Colonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
self.SetColumns(liste_Colonnes)
if self.checkColonne == True:
self.CreateCheckStateColumn(1)
self.SetSortColumn(self.columns[2])
else:
self.SetSortColumn(self.columns[1])
self.SetEmptyListMsg(_(u"Aucune location"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetObjects(self.donnees)
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
self.AddNamedImages(
"attention",
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Reservation.png"),
wx.BITMAP_TYPE_PNG))
self.AddNamedImages(
"pasok",
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Refus.png"),
wx.BITMAP_TYPE_PNG))
def FormateDate(date):
if date == None:
return _(u"Non définie")
else:
return datetime.datetime.strftime(date, "%d/%m/%Y - %Hh%M")
def FormateJoursRestants(temps_restant):
if temps_restant == None:
return ""
else:
return int(temps_restant)
def GetImageReste(track):
if track.temps_restant != None:
if track.temps_restant < 0:
return "pasok"
elif track.temps_restant < track.duree * 10 // 100:
return "attention"
return None
dict_colonnes = {
"IDlocation":
ColumnDefn(u"", "left", 0, "IDlocation", typeDonnee="entier"),
"date_debut":
ColumnDefn(_(u"Début"),
"left",
130,
"date_debut",
typeDonnee="date",
stringConverter=FormateDate),
"date_fin":
ColumnDefn(_(u"Fin"),
"left",
130,
"date_fin",
typeDonnee="date",
stringConverter=FormateDate),
"nomProduit":
ColumnDefn(_(u"Nom du produit"),
'left',
200,
"nomProduit",
typeDonnee="texte"),
"nomCategorie":
ColumnDefn(_(u"Catégorie du produit"),
'left',
200,
"nomCategorie",
typeDonnee="texte"),
"quantite":
ColumnDefn(u"Qté", "left", 60, "quantite", typeDonnee="entier"),
"nomTitulaires":
ColumnDefn(_(u"Loueur"),
'left',
270,
"nomTitulaires",
typeDonnee="texte"),
"rue":
ColumnDefn(_(u"Rue"), 'left', 200, "rue", typeDonnee="texte"),
"cp":
ColumnDefn(_(u"C.P."), 'left', 70, "cp", typeDonnee="texte"),
"ville":
ColumnDefn(_(u"Ville"), 'left', 150, "ville", typeDonnee="texte"),
"nbre_jours_restants":
ColumnDefn(u"Jours restants",
"left",
60,
"temps_restant",
typeDonnee="entier",
imageGetter=GetImageReste,
stringConverter=FormateJoursRestants),
}
liste_temp = [
"IDlocation", "date_debut", "date_fin", "nomProduit",
"nomCategorie", "quantite", "nomTitulaires", "rue", "cp", "ville",
"nbre_jours_restants"
]
if self.IDfamille != None:
liste_temp = [
"IDlocation", "date_debut", "date_fin", "nomProduit",
"nomCategorie", "quantite", "nbre_jours_restants"
]
if self.IDproduit != None:
liste_temp = [
"IDlocation", "date_debut", "date_fin", "quantite",
"nomTitulaires", "rue", "cp", "ville", "nbre_jours_restants"
]
liste_Colonnes = []
for code in liste_temp:
liste_Colonnes.append(dict_colonnes[code])
# Ajout des questions des questionnaires
liste_Colonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
# self.SetColumns(liste_Colonnes)
self.SetColumns2(colonnes=liste_Colonnes, nomListe="OL_Locations")
if self.checkColonne == True:
self.CreateCheckStateColumn(1)
self.SetSortColumn(self.columns[2])
else:
self.SetSortColumn(self.columns[1])
self.SetEmptyListMsg(_(u"Aucune location"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetObjects(self.donnees)
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
# Préparation de la listeImages
self.AddNamedImages("attente", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit.png"), wx.BITMAP_TYPE_PNG))
self.AddNamedImages("refusee", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer_2.png"), wx.BITMAP_TYPE_PNG))
self.AddNamedImages("attribuee", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok4.png"), wx.BITMAP_TYPE_PNG))
self.AddNamedImages("disponibilite", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok4_orange.png"), wx.BITMAP_TYPE_PNG))
def GetImageStatut(track):
if track.statut == "attente" :
return "attente"
elif track.statut == "refusee" :
return "refusee"
elif track.statut == "attribuee" :
return "attribuee"
elif track.statut == "disponibilite" :
return "disponibilite"
else :
return None
def FormateDate(date):
if date == None :
return _(u"Non définie")
else :
return datetime.datetime.strftime(date, "%d/%m/%Y - %Hh%M")
def FormatePosition(position):
if position == None :
return _(u"")
elif position == 1 :
return _(u"1er")
else :
return _(u"%dème") % position
liste_Colonnes = [
ColumnDefn(u"", "left", 0, "IDdemande", typeDonnee="entier"),
ColumnDefn(_(u"Date"), "left", 130, "date", typeDonnee="date", stringConverter=FormateDate),
]
if self.IDfamille == None :
liste_Colonnes.extend([
ColumnDefn(_(u"Nom du demandeur"), 'left', 210, "nomTitulaires", typeDonnee="texte"),
# ColumnDefn(_(u"Rue"), 'left', 200, "rue", typeDonnee="texte"),
# ColumnDefn(_(u"C.P."), 'left', 70, "cp", typeDonnee="texte"),
# ColumnDefn(_(u"Ville"), 'left', 150, "ville", typeDonnee="texte"),
])
liste_Colonnes.extend([
ColumnDefn(_(u"Statut de la demande"), 'left', 170, "texte_statut", typeDonnee="texte", imageGetter=GetImageStatut),
ColumnDefn(_(u"Position"), 'left', 80, "position", typeDonnee="entier", stringConverter=FormatePosition),
ColumnDefn(_(u"Catégories demandées"), 'left', 200, "texte_categories", typeDonnee="texte"),
ColumnDefn(_(u"Produits demandés"), 'left', 200, "texte_produits", typeDonnee="texte"),
ColumnDefn(_(u"Notes"), 'left', 200, "observations", typeDonnee="texte"),
])
# Ajout des questions des questionnaires
liste_Colonnes.extend(UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
self.SetColumns(liste_Colonnes)
if self.checkColonne == True :
self.CreateCheckStateColumn(1)
self.SetSortColumn(self.columns[2])
else :
self.SetSortColumn(self.columns[1])
# Regroupement
# if hasattr(self, "ctrl_regroupement") :
# self.ctrl_regroupement.MAJ(listview=self)
# if self.regroupement != None:
# self.SetAlwaysGroupByColumn(self.regroupement)
# self.SetShowGroups(True)
# self.useExpansionColumn = False
# self.SetShowItemCounts(True)
# else:
# self.SetShowGroups(False)
# self.useExpansionColumn = False
self.SetEmptyListMsg(_(u"Aucune demande de location"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
