def OnBoutonApercu(self, event):
""" Aperçu PDF des locations """
# Validation des données saisies
tracks = self.ctrl_liste_locations.GetTracksCoches()
if len(tracks) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune location à imprimer !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
listeIDlocation = []
for track in tracks:
listeIDlocation.append(track.IDlocation)
# Récupération des options
dictOptions = self.ctrl_options.GetOptions()
if dictOptions == False:
return False
# Impression des locations sélectionnées
x = UTILS_Locations.Location()
x.Impression(listeLocations=listeIDlocation,
afficherDoc=True,
dictOptions=dictOptions,
repertoire=dictOptions["repertoire"])
def SetDictPropositions(self, dictPropositions={}, IDdemande=False):
listeID = []
self.dictPositions = {}
for IDdemandeTemp, liste_produits in dictPropositions.iteritems():
if IDdemande == False or IDdemande == IDdemandeTemp:
for dictProduit in liste_produits:
if dictProduit[
"disponible"] > 0 or self.afficher_uniquement_disponibles == False:
listeID.append(dictProduit["IDproduit"])
self.dictPositions[
dictProduit["IDproduit"]] = dictProduit["position"]
# Affiche meilleure position
position = UTILS_Locations.GetMeilleurePosition(
dictPropositions=dictPropositions, IDdemande=IDdemande)
if position == 1:
texte_position = u"1er"
elif position > 1:
texte_position = u"%dème" % position
else:
texte_position = u""
# Met à jour la liste des propositions
self.SetFiltreIDproduit(listeID)
# Création d'un label
if len(listeID) == 0:
texte = _(u"Aucun produit proposé.")
elif len(listeID) == 1:
texte = _(u"1 produit proposé (meilleure position : %s) :"
) % texte_position
else:
texte = _(u"%d produits proposés (meilleure position : %s) :") % (
len(listeID), texte_position)
return texte
def MAJListePropositions(self):
# Récupération de la liste des filtres actuelle
dictFiltres = {self.IDdemande: []}
for track in self.ctrl_filtres.GetTracks():
dictFiltres[self.IDdemande].append({
"IDfiltre": track.IDfiltre,
"IDquestion": track.IDquestion,
"choix": track.choix,
"criteres": track.criteres,
"controle": track.controle
})
# Récupération des paramètres de la demande
dictDemande = {
"IDdemande": self.IDdemande,
"categories": self.ctrl_categories.GetListeCategories(),
"produits": self.ctrl_produits.GetListeProduits()
}
# Recherche les produits disponibles à proposer
dictPropositions = UTILS_Locations.GetPropositionsLocations(
dictFiltresSelection=dictFiltres,
dictDemandeSelection=dictDemande,
uniquement_disponibles=False)
texte = self.GetGrandParent().ctrl_statut.GetPageByCode(
"attente").ctrl_propositions.SetDictPropositions(
dictPropositions, IDdemande=self.IDdemande)
self.GetGrandParent().ctrl_statut.GetPageByCode(
"attente").label_propositions.SetLabel(texte)
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 CreationPDF(self, nomDoc="", afficherDoc=True):
""" Création du PDF pour Email """
IDlocation = self.Selection()[0].IDlocation
from Utils import UTILS_Locations
location = UTILS_Locations.Location()
resultat = location.Impression(listeLocations=[IDlocation,], nomDoc=nomDoc, afficherDoc=False)
if resultat == False :
return False
dictChampsFusion, dictPieces = resultat
return dictChampsFusion[IDlocation]
def ImprimerPDF(self, event):
if len(self.Selection()) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune location à imprimer !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
IDlocation = self.Selection()[0].IDlocation
from Utils import UTILS_Locations
location = UTILS_Locations.Location()
location.Impression(listeLocations=[IDlocation,])
def OnBoutonOk(self, event):
""" Aperçu PDF des locations """
# Validation des données saisies
tracks = self.ctrl_liste_locations.GetTracksCoches()
if len(tracks) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune location à envoyer par Email !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Création des locations sélectionnées
listeIDlocation = []
for track in tracks :
listeIDlocation.append(track.IDlocation)
location = UTILS_Locations.Location()
dictOptions = self.ctrl_options.GetOptions()
if dictOptions == False :
return
resultat = location.Impression(listeLocations=listeIDlocation, nomDoc=None, afficherDoc=False, dictOptions=dictOptions, repertoire=dictOptions["repertoire"], repertoireTemp=True)
if resultat == False :
return
dictChampsFusion, dictPieces = resultat
def SupprimerFichiersTemp():
for IDlocation, fichier in dictPieces.items() :
os.remove(fichier)
# Récupération des adresses Emails
dict_adresses = UTILS_Envoi_email.GetAdressesFamilles([track.IDfamille for track in tracks])
if dict_adresses == False:
return False
liste_donnees = []
for track in tracks:
if track.IDlocation in dictPieces:
for adresse in dict_adresses.get(track.IDfamille, []):
fichier = dictPieces[track.IDlocation]
champs = dictChampsFusion[track.IDlocation]
liste_donnees.append({"adresse" : adresse, "pieces" : [fichier,], "champs" : champs})
# Transfert des données vers DLG Mailer
from Dlg import DLG_Mailer
dlg = DLG_Mailer.Dialog(self, categorie="location")
dlg.SetDonnees(liste_donnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Suppression des PDF temporaires
SupprimerFichiersTemp()
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 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 Verif_dispo_produit(track,
IDlocation_exception=None,
IDlocation_portail_exception=None):
# Vérifie que la quantité demandée est disponible
dictPeriodes = UTILS_Locations.GetStockDisponible(
IDproduit=track.IDproduit,
date_debut=track.date_debut,
date_fin=track.date_fin,
IDlocation_exception=IDlocation_exception,
IDlocation_portail_exception=IDlocation_portail_exception)
liste_periode_non_dispo = []
for periode, valeurs in dictPeriodes.items():
if valeurs["disponible"] < track.quantite:
debut = datetime.datetime.strftime(periode[0], "%d/%m/%Y-%Hh%M")
if periode[1].year == 2999:
fin = _(u"Illimité")
else:
fin = datetime.datetime.strftime(periode[1], "%d/%m/%Y-%Hh%M")
liste_periode_non_dispo.append(
_(u"Stock disponible du %s au %s : %d produits") %
(debut, fin, valeurs["disponible"]))
return liste_periode_non_dispo
def _load_data(self):
""" Importation des données """
self.preferred_period = None
self.categories = []
self.events = []
# Période préférée
dateDuJour = datetime.datetime.today()
dateDebut = dateDuJour - datetime.timedelta(6)
dateFin = dateDuJour + datetime.timedelta(1)
self.preferred_period = TL.TimePeriod(dateDebut, dateFin)
# Récupération des events LOCATIONS
DB = GestionDB.DB()
req = """SELECT IDlocation, IDfamille, date_debut, date_fin, quantite
FROM locations
WHERE IDproduit=%d;""" % self.IDproduit
DB.ExecuterReq(req)
listeLocations = DB.ResultatReq()
DB.Close()
listeIDfamille = []
for IDlocation, IDfamille, date_debut, date_fin, quantite in listeLocations:
listeIDfamille.append(IDfamille)
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille)
categorie = TL.Category(_(u"Location"), (156, 205, 255), True)
for IDlocation, IDfamille, date_debut, date_fin, quantite in listeLocations:
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
if date_fin == None:
date_fin = datetime.datetime(2999, 1, 1)
if quantite == None:
quantite = 1
if IDfamille in dictTitulaires:
nomTitulaires = dictTitulaires[IDfamille][
"titulairesSansCivilite"]
else:
nomTitulaires = _(u"Famille inconnue")
texte = u"%s - Quantité : %d" % (nomTitulaires, quantite)
date_debut_str = datetime.datetime.strftime(
date_debut, "%d/%m/%Y-%Hh%M")
if date_fin.year == 2999:
date_fin_str = _(u"Illimité")
else:
date_fin_str = datetime.datetime.strftime(
date_fin, "%d/%m/%Y-%Hh%M")
description = _(
u"Loueur : %s\nQuantité : %d\nDébut : %s\nFin : %s") % (
nomTitulaires, quantite, date_debut_str, date_fin_str)
icon = None
evt = TL.Event(date_debut, date_fin, texte, categorie)
if description != None: evt.set_data("description", description)
if icon != None: evt.set_data("icon", icon)
self.events.append(evt)
# Récupération des events STOCK DISPONIBLE
dictPeriodes = UTILS_Locations.GetStockDisponible(
IDproduit=self.IDproduit, date_debut=None, date_fin=None)
categorie_disponible = TL.Category(_(u"Stock disponible"),
(233, 255, 156), True)
categorie_loue = TL.Category(_(u"Quantité louée"), (204, 227, 250),
True)
for periode, valeurs in dictPeriodes.items():
date_debut = periode[0]
evt = TL.Event(date_debut, date_debut, str(valeurs["loue"]),
categorie_loue)
self.events.append(evt)
evt = TL.Event(date_debut, date_debut, str(valeurs["disponible"]),
categorie_disponible)
self.events.append(evt)
def __init__(self, listview=None, donnees=None):
self.IDdemande = donnees[0]
self.date = donnees[1]
self.IDfamille = donnees[2]
self.observations = donnees[3]
# Catégories
self.categories = UTILS_Texte.ConvertStrToListe(donnees[4], siVide=[])
liste_labels = []
for IDcategorie in self.categories :
if IDcategorie in listview.dictCategories :
liste_labels.append(listview.dictCategories[IDcategorie])
self.texte_categories = ", ".join(liste_labels)
# Produits
self.produits = UTILS_Texte.ConvertStrToListe(donnees[5], siVide=[])
liste_labels = []
for IDproduit in self.produits :
if IDproduit in listview.dictProduits :
liste_labels.append(listview.dictProduits[IDproduit])
self.texte_produits = ", ".join(liste_labels)
# Statut
self.statut = donnees[6]
# Position
self.position = None
# Vérifie s'il y a des propositions de produits
if self.statut == "refusee" :
self.texte_statut = _(u"Refusée")
elif self.statut == "attribuee" :
self.texte_statut = _(u"Demande satisfaite")
elif self.statut == "attente" :
if self.IDdemande in listview.dictPropositions :
# Recherche disponibilités
listeProduitsProposes = listview.dictPropositions[self.IDdemande]
if len(listeProduitsProposes) == 0 :
self.texte_statut = _(u"En attente")
elif len(listeProduitsProposes) == 1 :
self.texte_statut = _(u"1 produit disponible")
else :
self.texte_statut = _(u"%d produits disponibles") % len(listeProduitsProposes)
self.statut = "disponibilite"
# Recherche meilleure position
self.position = UTILS_Locations.GetMeilleurePosition(dictPropositions=listview.dictPropositions, IDdemande=self.IDdemande)
else :
self.texte_statut = _(u"En attente")
# Formatage date
if isinstance(self.date, str) or isinstance(self.date, six.text_type) :
self.date = datetime.datetime.strptime(self.date, "%Y-%m-%d %H:%M:%S")
# Récupération des réponses des questionnaires
for dictQuestion in listview.liste_questions :
setattr(self, "question_%d" % dictQuestion["IDquestion"], listview.GetReponse(dictQuestion["IDquestion"], self.IDdemande))
# Famille
if listview.IDfamille == None :
self.nomTitulaires = listview.dict_titulaires[self.IDfamille]["titulairesSansCivilite"]
self.rue = listview.dict_titulaires[self.IDfamille]["adresse"]["rue"]
self.cp = listview.dict_titulaires[self.IDfamille]["adresse"]["cp"]
self.ville = listview.dict_titulaires[self.IDfamille]["adresse"]["ville"]
def OnBoutonOk(self, event):
# Loueur
IDfamille = self.ctrl_loueur.GetIDfamille()
if IDfamille == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un loueur pour ce produit !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Produit
IDproduit = self.ctrl_produit.GetIDproduit()
if IDproduit == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un produit !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Observations
observations = self.ctrl_observations.GetValue()
# Date de début
date_debut = self.ctrl_date_debut.GetDate()
if date_debut == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de début de location !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_debut.SetFocus()
return
heure_debut = self.ctrl_heure_debut.GetHeure()
if heure_debut == None or self.ctrl_heure_debut.Validation() == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une heure de début valide !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_debut.SetFocus()
return
date_debut = datetime.datetime(year=date_debut.year,
month=date_debut.month,
day=date_debut.day,
hour=int(heure_debut[:2]),
minute=int(heure_debut[3:]))
# Date de fin
if self.check_date_fin.GetValue() == True:
date_fin = self.ctrl_date_fin.GetDate()
if date_fin == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de fin de location !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return
heure_fin = self.ctrl_heure_fin.GetHeure()
if heure_fin == None or self.ctrl_heure_fin.Validation() == False:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une heure de fin valide !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_heure_fin.SetFocus()
return
date_fin = datetime.datetime(year=date_fin.year,
month=date_fin.month,
day=date_fin.day,
hour=int(heure_fin[:2]),
minute=int(heure_fin[3:]))
else:
date_fin = None
if date_fin != None and date_debut > date_fin:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir une date de fin supérieure à la date de début !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return
# Quantité
quantite = int(self.ctrl_quantite.GetValue())
# Vérifie que la quantité demandée est disponible
dictPeriodes = UTILS_Locations.GetStockDisponible(
IDproduit=IDproduit,
date_debut=date_debut,
date_fin=date_fin,
IDlocation_exception=self.IDlocation)
liste_periode_non_dispo = []
for periode, valeurs in dictPeriodes.iteritems():
if valeurs["disponible"] < quantite:
debut = datetime.datetime.strftime(periode[0],
"%d/%m/%Y-%Hh%M")
if periode[1].year == 2999:
fin = _(u"Illimité")
else:
fin = datetime.datetime.strftime(periode[1],
"%d/%m/%Y-%Hh%M")
liste_periode_non_dispo.append(
_(u"Stock disponible du %s au %s : %d produits") %
(debut, fin, valeurs["disponible"]))
if len(liste_periode_non_dispo) > 0:
introduction = _(
u"La quantité souhaitée n'est pas disponible sur les périodes suivantes :"
)
conclusion = _(u"Vous ne pouvez pas valider la location.")
dlg = DLG_Messagebox.Dialog(
None,
titre=_(u"Information"),
introduction=introduction,
detail=u"\n".join(liste_periode_non_dispo),
conclusion=conclusion,
icone=wx.ICON_EXCLAMATION,
boutons=[
_(u"Ok"),
])
dlg.ShowModal()
dlg.Destroy()
return
# Périodes de gestion
liste_prestations = self.ctrl_parametres.GetPageAvecCode(
"facturation").GetDonnees()["prestations"]
gestion = UTILS_Gestion.Gestion(None)
for track_prestation in liste_prestations:
if gestion.Verification("prestations",
track_prestation.date) == False:
return False
# Sauvegarde
DB = GestionDB.DB()
# Sauvegarde de la location
listeDonnees = [
("IDfamille", IDfamille),
("IDproduit", IDproduit),
("observations", observations),
("date_debut", date_debut),
("date_fin", date_fin),
("quantite", quantite),
]
if self.IDlocation == None:
listeDonnees.append(("date_saisie", datetime.date.today()))
self.IDlocation = DB.ReqInsert("locations", listeDonnees)
else:
DB.ReqMAJ("locations", listeDonnees, "IDlocation", self.IDlocation)
# Sauvegarde des prestations
listeID = []
for track_prestation in liste_prestations:
IDprestation = track_prestation.IDprestation
listeDonnees = [
("IDcompte_payeur", self.ctrl_loueur.GetIDcomptePayeur()),
("date", track_prestation.date),
("categorie", "location"),
("label", track_prestation.label),
("montant_initial", track_prestation.montant),
("montant", track_prestation.montant),
("IDfamille", self.ctrl_loueur.GetIDfamille()),
("IDindividu", None),
("code_compta", None),
("tva", None),
("IDdonnee", self.IDlocation),
]
if IDprestation == None:
listeDonnees.append(
("date_valeur", str(datetime.date.today())))
IDprestation = DB.ReqInsert("prestations", listeDonnees)
else:
if track_prestation.dirty == True:
DB.ReqMAJ("prestations", listeDonnees, "IDprestation",
IDprestation)
listeID.append(IDprestation)
# Suppression des prestations obsolètes
for IDprestation in self.liste_initiale_IDprestation:
if IDprestation not in listeID:
DB.ReqDEL("prestations", "IDprestation", IDprestation)
DB.ReqDEL("ventilation", "IDprestation", IDprestation)
# Sauvegarde du questionnaire
self.ctrl_parametres.GetPageAvecCode(
"questionnaire").ctrl_questionnaire.Sauvegarde(
DB=DB, IDdonnee=self.IDlocation)
DB.Close()
# Fermeture de la fenêtre
self.EndModal(wx.ID_OK)
def OnBoutonOk(self, event):
""" Aperçu PDF des locations """
# Validation des données saisies
tracks = self.ctrl_liste_locations.GetTracksCoches()
if len(tracks) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune location à envoyer par Email !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Création des locations sélectionnées
listeIDlocation = []
for track in tracks:
listeIDlocation.append(track.IDlocation)
location = UTILS_Locations.Location()
dictOptions = self.ctrl_options.GetOptions()
if dictOptions == False:
return
resultat = location.Impression(listeLocations=listeIDlocation,
nomDoc=None,
afficherDoc=False,
dictOptions=dictOptions,
repertoire=dictOptions["repertoire"],
repertoireTemp=True)
if resultat == False:
return
dictChampsFusion, dictPieces = resultat
def SupprimerFichiersTemp():
for IDlocation, fichier in dictPieces.iteritems():
os.remove(fichier)
# Récupération de toutes les adresses Emails
DB = GestionDB.DB()
req = """SELECT IDindividu, mail, travail_mail
FROM individus;"""
DB.ExecuterReq(req)
listeAdressesIndividus = DB.ResultatReq()
DB.Close()
dictAdressesIndividus = {}
for IDindividu, mail, travail_mail in listeAdressesIndividus:
dictAdressesIndividus[IDindividu] = {
"perso": mail,
"travail": travail_mail
}
# Récupération des données adresse + champs + pièces
listeDonnees = []
listeAnomalies = []
listeEnvoiNonDemande = []
for track in tracks:
adresse = UTILS_Envoi_email.GetAdresseFamille(
track.IDfamille,
choixMultiple=False,
muet=True,
nomTitulaires=track.nomTitulaires)
# Mémorisation des données
if adresse not in (None, "", []):
if dictPieces.has_key(track.IDlocation):
fichier = dictPieces[track.IDlocation]
champs = dictChampsFusion[track.IDlocation]
listeDonnees.append({
"adresse": adresse,
"pieces": [
fichier,
],
"champs": champs
})
else:
listeAnomalies.append(track.nomsTitulaires)
# Annonce les anomalies trouvées
if len(listeAnomalies) > 0:
texte = _(
u"%d des familles sélectionnées n'ont pas d'adresse Email.\n\n"
) % len(listeAnomalies)
texte += _(
u"Souhaitez-vous quand même continuer avec les %d autres familles ?"
) % len(listeDonnees)
dlg = wx.MessageDialog(
self, texte, _(u"Avertissement"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
SupprimerFichiersTemp()
return
# Dernière vérification avant transfert
if len(listeDonnees) == 0:
dlg = wx.MessageDialog(
self,
_(u"Il ne reste finalement aucune location à envoyer par Email !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
SupprimerFichiersTemp()
return
# Transfert des données vers DLG Mailer
import DLG_Mailer
dlg = DLG_Mailer.Dialog(self, categorie="location")
dlg.SetDonnees(listeDonnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Suppression des PDF temporaires
SupprimerFichiersTemp()