def OnBoutonOk(self, event):
""" Aperçu PDF des cotisations """
# Validation des données saisies
tracks = self.ctrl_liste_cotisations.GetTracksCoches()
if len(tracks) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune cotisation à envoyer par Email !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Création des cotisations sélectionnées
listeIDcotisation = []
for track in tracks :
listeIDcotisation.append(track.IDcotisation)
cotisation = UTILS_Cotisations.Cotisation()
dictOptions = self.ctrl_options.GetOptions()
if dictOptions == False :
return
resultat = cotisation.Impression(listeCotisations=listeIDcotisation, nomDoc=None, afficherDoc=False, dictOptions=dictOptions, repertoire=dictOptions["repertoire"], repertoireTemp=True)
if resultat == False :
return
dictChampsFusion, dictPieces = resultat
def SupprimerFichiersTemp():
for IDcotisation, 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.nomsTitulaires)
# Mémorisation des données
if adresse not in (None, "", []) :
if dictPieces.has_key(track.IDcotisation) :
fichier = dictPieces[track.IDcotisation]
champs = dictChampsFusion[track.IDcotisation]
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 cotisation à 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="cotisation")
dlg.SetDonnees(listeDonnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Suppression des PDF temporaires
SupprimerFichiersTemp()
def Traitement_recus(self):
# Récupération des paramètres
IDreglement = int(self.dict_parametres["IDreglement"])
listeAdresses = UTILS_Envoi_email.GetAdresseFamille(self.track.IDfamille)
# Ouverture de la fenêtre d'édition d'un reçu
from Dlg import DLG_Impression_recu
dlg_impression = DLG_Impression_recu.Dialog(self.parent, IDreglement=IDreglement)
dlg_impression.listeAdresses = listeAdresses
# Traitement manuel
if self.mode == "manuel" :
self.EcritLog(_(u"Ouverture de la fenêtre d'édition d'un reçu."))
if self.dict_parametres["methode_envoi"] == "email" :
self.EcritLog(_(u"Veuillez envoyer ce reçu de règlement par Email."))
elif self.dict_parametres["methode_envoi"] == "courrier" :
self.EcritLog(_(u"Veuillez imprimer le reçu de règlement pour un envoi par courrier."))
else :
self.EcritLog(_(u"Veuillez imprimer le reçu de règlement pour un retrait sur site."))
dlg_impression.ShowModal()
dlg_impression.Destroy()
return True
# Traitement automatique
if self.mode == "automatique" :
nomDoc = FonctionsPerso.GenerationNomDoc("RECU", "pdf")
categorie = "recu_reglement"
# Affichage du PDF pour envoi par courrier ou retrait sur site
if self.dict_parametres["methode_envoi"] != "email" :
message = _(u"Le reçu de règlement va être généré au format PDF et ouvert dans votre lecteur de PDF.\n\n")
if self.dict_parametres["methode_envoi"] == "courrier" :
message += _(u"Veuillez l'imprimer et l'envoyer par courrier.")
else :
message += _(u"Veuillez l'imprimer et le conserver pour un retrait sur site.")
dlg = wx.MessageDialog(self.parent, message, _(u"Impression d'un reçu"), wx.OK|wx.OK_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse == wx.ID_CANCEL :
self.EcritLog(_(u"Interruption du traitement par l'utilisateur."))
return False
dictChamps = dlg_impression.CreationPDF(nomDoc=nomDoc, afficherDoc=True)
if dictChamps == False :
dlg_impression.Destroy()
self.EcritLog(_(u"[ERREUR] La génération du reçu au format PDF a rencontré une erreur."))
return False
self.EcritLog(_(u"La génération du reçu est terminée."))
if self.dict_parametres["methode_envoi"] == "courrier" :
self.EcritLog(_(u"Veuillez imprimer le reçu de règlement pour un envoi par courrier."))
else :
self.EcritLog(_(u"Veuillez imprimer le reçu de règlement pour un retrait sur site."))
# Envoi par Email
if self.dict_parametres["methode_envoi"] == "email" :
resultat = UTILS_Envoi_email.EnvoiEmailFamille(parent=dlg_impression, IDfamille=self.track.IDfamille, nomDoc=nomDoc, categorie=categorie, listeAdresses=listeAdresses, visible=False, log=self.track)
# Mémorisation de l'édition du reçu
dlg_impression.Sauvegarder(demander=False)
dlg_impression.Destroy()
return True
def Sauvegarde(listeFichiersLocaux=[], listeFichiersReseau=[], nom="", repertoire=None, motdepasse=None, listeEmails=None, dictConnexion=None):
""" Processus de de création du ZIP """
# Si aucun fichier à sauvegarder
if len(listeFichiersLocaux) == 0 and len(listeFichiersReseau) == 0 :
return False
# Initialisation de la barre de progression
nbreEtapes = 3
nbreEtapes += len(listeFichiersLocaux)
nbreEtapes += len(listeFichiersReseau)
if motdepasse != None : nbreEtapes += 1
if repertoire != None : nbreEtapes += 1
if listeEmails != None : nbreEtapes += 1
# Création du nom du fichier de destination
if motdepasse != None :
extension = EXTENSIONS["crypte"]
else:
extension = EXTENSIONS["decrypte"]
# Vérifie si fichier de destination existe déjà
if repertoire != None :
fichierDest = u"%s/%s.%s" % (repertoire, nom, extension)
if os.path.isfile(fichierDest) == True :
dlg = wx.MessageDialog(None, _(u"Un fichier de sauvegarde portant ce nom existe déjà. \n\nVoulez-vous le remplacer ?"), "Attention !", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_EXCLAMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
# Récupération des paramètres de l'adresse d'expéditeur par défaut
if listeEmails != None :
dictAdresse = UTILS_Envoi_email.GetAdresseExpDefaut()
if dictAdresse == None :
dlgErreur = wx.MessageDialog(None, _(u"Envoi par Email impossible :\n\nAucune adresse d'expéditeur n'a été définie. Veuillez la saisir dans le menu Paramétrage du logiciel..."), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# Fenêtre de progression
dlgprogress = wx.ProgressDialog(_(u"Sauvegarde"), _(u"Lancement de la sauvegarde..."), maximum=nbreEtapes, parent=None, style= wx.PD_SMOOTH | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL)
# Création du fichier ZIP temporaire
nomFichierTemp = u"%s.%s" % (nom, EXTENSIONS["decrypte"])
fichierZip = zipfile.ZipFile(UTILS_Fichiers.GetRepTemp(fichier=nomFichierTemp), "w", compression=zipfile.ZIP_DEFLATED)
numEtape = 1
dlgprogress.Update(numEtape, _(u"Création du fichier de compression..."));numEtape += 1
# Intégration des fichiers locaux
for nomFichier in listeFichiersLocaux :
dlgprogress.Update(numEtape, _(u"Compression du fichier %s...") % nomFichier);numEtape += 1
fichier = UTILS_Fichiers.GetRepData(nomFichier)
if os.path.isfile(fichier) == True :
fichierZip.write(fichier, nomFichier)
else :
dlgprogress.Destroy()
dlgErreur = wx.MessageDialog(None, _(u"Le fichier '%s' n'existe plus sur cet ordinateur. \n\nVeuillez ôter ce fichier de la procédure de sauvegarde automatique (Menu Fichier > Sauvegardes automatiques)") % nomFichier, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# Intégration des fichiers réseau
if len(listeFichiersReseau) > 0 and dictConnexion != None :
# Création du répertoire temporaire
repTemp = UTILS_Fichiers.GetRepTemp(fichier="savetemp")
if os.path.isdir(repTemp) == True :
shutil.rmtree(repTemp)
os.mkdir(repTemp)
# Recherche du répertoire d'installation de MySQL
repMySQL = GetRepertoireMySQL(dictConnexion)
if repMySQL == None :
dlgprogress.Destroy()
dlgErreur = wx.MessageDialog(None, _(u"Noethys n'a pas réussi à localiser MySQL sur votre ordinateur.\n\nNotez bien que MySQL doit être installé obligatoirement pour créer une sauvegarde réseau."), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# Création du fichier de login
nomFichierLoginTemp = repTemp + "/logintemp.cnf" #os.path.abspath(os.curdir) + "/" + repTemp + "/logintemp.cnf"
CreationFichierLoginTemp(host=dictConnexion["host"], port=dictConnexion["port"], user=dictConnexion["user"], password=dictConnexion["password"], nomFichier=nomFichierLoginTemp)
# Création du backup pour chaque fichier MySQL
for nomFichier in listeFichiersReseau :
dlgprogress.Update(numEtape, _(u"Compression du fichier %s...") % nomFichier);numEtape += 1
fichierSave = u"%s/%s.sql" % (repTemp, nomFichier)
args = u""""%sbin/mysqldump" --defaults-extra-file="%s" --single-transaction --opt --databases %s > "%s" """ % (repMySQL, nomFichierLoginTemp, nomFichier, fichierSave)
print(("Chemin mysqldump =", args))
if six.PY2:
args = args.encode('utf8')
proc = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE)
out, temp = proc.communicate()
if out not in ("", b""):
print((out,))
try :
if six.PY2:
out = str(out).decode("iso-8859-15")
except :
pass
dlgprogress.Destroy()
dlgErreur = wx.MessageDialog(None, _(u"Une erreur a été détectée dans la procédure de sauvegarde !\n\nErreur : %s") % out, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# Insère le fichier Sql dans le ZIP
try :
fichierZip.write(fichierSave.encode('utf8'), u"%s.sql" % nomFichier)
except Exception as err :
dlgprogress.Destroy()
print(("insertion sql dans zip : ", err,))
try :
if six.PY2:
err = str(err).decode("iso-8859-15")
except :
pass
dlgErreur = wx.MessageDialog(None, _(u"Une erreur est survenue dans la sauvegarde !\n\nErreur : %s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# Supprime le répertoire temp
shutil.rmtree(repTemp)
# Finalise le fichier ZIP
fichierZip.close()
# Cryptage du fichier
if motdepasse != None :
dlgprogress.Update(numEtape, _(u"Cryptage du fichier..."));numEtape += 1
fichierCrypte = u"%s.%s" % (nom, EXTENSIONS["crypte"])
motdepasse = base64.b64decode(motdepasse)
if six.PY3:
motdepasse = motdepasse.decode('utf8')
UTILS_Cryptage_fichier.CrypterFichier(UTILS_Fichiers.GetRepTemp(fichier=nomFichierTemp), UTILS_Fichiers.GetRepTemp(fichier=fichierCrypte), motdepasse, ancienne_methode=True)
nomFichierTemp = fichierCrypte
extension = EXTENSIONS["crypte"]
else:
extension = EXTENSIONS["decrypte"]
# Copie le fichier obtenu dans le répertoire donné
if repertoire != None :
dlgprogress.Update(numEtape, _(u"Création du fichier dans le répertoire cible..."));numEtape += 1
try :
shutil.copy2(UTILS_Fichiers.GetRepTemp(fichier=nomFichierTemp), fichierDest)
except :
print("Le repertoire de destination de sauvegarde n'existe pas.")
# Préparation du message
message = UTILS_Envoi_email.Message(destinataires=listeEmails, sujet=_(u"Sauvegarde Noethys : %s") % nom,
texte_html=_(u"Envoi de la sauvegarde de Noethys"),
fichiers=[UTILS_Fichiers.GetRepTemp(fichier=nomFichierTemp),])
# Envoi par Email
if listeEmails != None :
dlgprogress.Update(numEtape, _(u"Expédition de la sauvegarde par Email..."));numEtape += 1
try :
messagerie = UTILS_Envoi_email.Messagerie(backend=dictAdresse["moteur"], hote=dictAdresse["smtp"], port=dictAdresse["port"], utilisateur=dictAdresse["utilisateur"],
motdepasse=dictAdresse["motdepasse"], email_exp=dictAdresse["adresse"], use_tls=dictAdresse["startTLS"],
timeout=60*3, parametres=dictAdresse["parametres"])
messagerie.Connecter()
messagerie.Envoyer(message)
messagerie.Fermer()
except Exception as err:
dlgprogress.Destroy()
print((err,))
if six.PY2:
err = str(err).decode("iso-8859-15")
dlgErreur = wx.MessageDialog(None, _(u"Une erreur a été détectée dans l'envoi par Email !\n\nErreur : %s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# Suppression des répertoires et fichiers temporaires
dlgprogress.Update(numEtape, _(u"Suppression des fichiers temporaires..."));numEtape += 1
fichier = UTILS_Fichiers.GetRepTemp(fichier=u"%s.%s" % (nom, EXTENSIONS["decrypte"]))
if os.path.isfile(fichier) == True :
os.remove(fichier)
fichier = UTILS_Fichiers.GetRepTemp(fichier=u"%s.%s" % (nom, EXTENSIONS["crypte"]))
if os.path.isfile(fichier) == True :
os.remove(fichier)
# Fin du processus
dlgprogress.Update(numEtape, _(u"Sauvegarde terminée avec succès !"))
dlgprogress.Destroy()
return True
def Envoyer_mail(self, commentaires="", joindre_journal=False):
""" Envoi d'un mail avec pièce jointe """
from Utils import UTILS_Envoi_email
# Expéditeur
dictExp = self.GetAdresseExpDefaut()
if dictExp == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez d'abord saisir une adresse d'expéditeur depuis le menu Paramétrage > Adresses d'expédition d'Emails. Sinon, postez votre rapport de bug dans le forum de Teamworks."
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
moteur = dictExp["moteur"]
adresseExpediteur = dictExp["adresse"]
serveur = dictExp["smtp"]
port = dictExp["port"]
auth = dictExp["auth"]
startTLS = dictExp["startTLS"]
motdepasse = dictExp["motdepasse"]
utilisateur = dictExp["utilisateur"]
parametres = dictExp["parametres"]
if adresseExpediteur == None:
dlg = wx.MessageDialog(
self,
_(u"L'adresse d'expédition ne semble pas valide. Veuillez la vérifier."
), _(u"Envoi impossible"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Attacher le journal d'erreurs
fichiers = []
if joindre_journal == True:
customize = UTILS_Customize.Customize()
nom_journal = UTILS_Fichiers.GetRepUtilisateur(
customize.GetValeur("journal", "nom", "journal.log"))
fichiers.append(nom_journal)
# Préparation du message
IDrapport = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
texteRapport = self.ctrl_rapport.GetValue().replace("\n", "<br/>")
if len(commentaires) == 0:
commentaires = _(u"Aucun")
texte_html = _(
u"<u>Rapport de bug %s :</u><br/><br/>%s<br/><u>Commentaires :</u><br/><br/>%s"
) % (IDrapport, texteRapport, commentaires)
sujet = _(u"Rapport de bug Teamworks n°%s") % IDrapport
message = UTILS_Envoi_email.Message(destinataires=[
"noe" + "thys" + "@" + "gm" + "ail" + ".com",
],
sujet=sujet,
texte_html=texte_html,
fichiers=fichiers)
# Envoi du mail
try:
messagerie = UTILS_Envoi_email.Messagerie(
backend=moteur,
hote=serveur,
port=port,
utilisateur=utilisateur,
motdepasse=motdepasse,
email_exp=adresseExpediteur,
use_tls=startTLS,
parametres=parametres)
messagerie.Connecter()
messagerie.Envoyer(message)
messagerie.Fermer()
except Exception as err:
dlg = wx.MessageDialog(
self,
_(u"Le message n'a pas pu être envoyé. Merci de poster votre rapport de bug sur le forum de Teamworks.\n\nErreur : %s !"
) % err, _(u"Envoi impossible"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Message de confirmation
dlg = wx.MessageDialog(
self, _(u"Le rapport d'erreur a été envoyé avec succès."),
_(u"Rapport envoyé"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
return True
def Envoyer(self, listeDestinataires=[], adresseTest=None):
# Expéditeur
dictExp = self.ctrl_exp.GetDonnees()
if dictExp == None :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune adresse d'expéditeur !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
if self.IsShown() == False : self.ShowModal()
return
exp = dictExp["adresse"]
nomexp = dictExp["nom_adresse"]
serveur = dictExp["smtp"]
port = dictExp["port"]
connexionAuthentifiee = dictExp["auth"]
connexionStartTLS = dictExp["startTLS"]
motdepasse = dictExp["motdepasse"]
utilisateur = dictExp["utilisateur"]
# Accusé de réception
accuseReception = self.check_accuseReception.GetValue()
# Objet
sujet = self.ctrl_objet.GetValue()
if len(sujet) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un objet pour ce message !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
if self.IsShown() == False : self.ShowModal()
self.ctrl_objet.SetFocus()
return
# Destinataires
if len(listeDestinataires) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez sélectionner au moins un destinataire !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
if self.IsShown() == False : self.ShowModal()
return
nbreAnomalies = 0
for dest in listeDestinataires :
if dest.adresse == None :
nbreAnomalies += 1
if nbreAnomalies > 0 :
dlg = wx.MessageDialog(self, _(u"%d adresse(s) Email ne sont pas renseignées !") % nbreAnomalies, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Texte
if len(self.ctrl_editeur.GetValue()) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un texte !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
if self.IsShown() == False : self.ShowModal()
self.ctrl_editeur.SetFocus()
return
texteHTML, listeImages, handler = self.ctrl_editeur.GetHTML(imagesIncluses=True)
# Vérifie la fusion des mots-clés
if self.VerifieFusion(texteHTML, listeDestinataires) == False :
if self.IsShown() == False : self.ShowModal()
return
# Pièces jointes
listePiecesCommunes = self.ctrl_pieces.GetDonnees()
# Demande de confirmation
if adresseTest == None and self.afficher_confirmation_envoi == True :
dlg = wx.MessageDialog(self, _(u"Confirmez-vous l'envoi de ce message pour %d destinataires ?\n\nAttention, l'envoi peut prendre quelques minutes...") % len(listeDestinataires), _(u"Confirmation"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
if dlg.ShowModal() != wx.ID_YES :
dlg.Destroy()
if self.IsShown() == False : self.ShowModal()
return
dlg.Destroy()
# Envoi des mails
dlg = wx.ProgressDialog(_(u"Envoi des mails"), _(u"Veuillez patienter..."), maximum = len(listeDestinataires)+1, parent=self)
dlg.SetSize((370, 140))
dlg.CenterOnScreen()
index = 1
self.listeAnomalies = []
self.listeSucces = []
for track in listeDestinataires :
adresse = track.adresse
if adresseTest != None :
adresse = adresseTest
## adresse = FonctionsPerso.Supprime_accent2(adresse)
listePiecesPersonnelles = track.pieces
dictChamps = track.champs
# Pièces Personnelles + communes
listePieces = listePiecesPersonnelles
listePieces.extend(listePiecesCommunes)
# Traitement des champs pour la fusion
texte = copy.deepcopy(texteHTML)
for motcle, valeur in CTRL_Editeur_email.GetChampsStandards().iteritems() :
texte = texte.replace(motcle, valeur)
for motcle, valeur in dictChamps.iteritems() :
if valeur == None : valeur = u""
if type(valeur) == int : valeur = str(valeur)
if type(valeur) == bool : valeur = str(valeur)
if type(valeur) == datetime.date : valeur = UTILS_Dates.DateDDEnFr(valeur)
texte = texte.replace(motcle, valeur)
# Envoi du mail
try :
labelAdresse = adresse.decode("iso-8859-15")
except :
labelAdresse = adresse
label = _(u"Envoi %d/%d : %s...") % (index, len(listeDestinataires), labelAdresse)
self.EcritStatusBar(label)
dlg.Update(index, label)
try :
etat = UTILS_Envoi_email.Envoi_mail(
adresseExpediteur=exp,
nomadresseExpediteur=nomexp,
listeDestinataires=[adresse,],
listeDestinatairesCCI=[],
sujetMail=sujet,
texteMail=texte,
listeFichiersJoints=listePieces,
serveur=serveur,
port=port,
avecAuthentification=connexionAuthentifiee,
avecStartTLS=connexionStartTLS,
listeImages=listeImages,
motdepasse=motdepasse,
accuseReception=accuseReception,
utilisateur=utilisateur,
)
self.listeSucces.append(track)
# Mémorisation dans l'historique
self.MemorisationHistorique(adresse, sujet)
except Exception, err:
err = str(err).decode("iso-8859-15")
self.listeAnomalies.append((track, err))
print ("Erreur dans l'envoi d'un mail : %s...", err)
traceback.print_exc(file=sys.stdout)
if index == len(listeDestinataires) :
dlgErreur = wx.MessageDialog(self, _(u"%s\n\nL'erreur suivante a été détectée :\n%s.") % (label, err), _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
else :
dlgErreur = wx.MessageDialog(self, _(u"%s\n\nL'erreur suivante a été détectée :\n%s.\n\nSouhaitez-vous quand même continuer le processus ?") % (label, err), _(u"Erreur"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_ERROR)
if dlgErreur.ShowModal() != wx.ID_YES :
dlgErreur.Destroy()
# Arrêt du processus
dlg.Destroy()
handler.DeleteTemporaryImages()
self.EcritStatusBar(u"")
return
dlgErreur.Destroy()
if len(listeDestinataires) > 1 :
time.sleep(2) # Attente entre chaque envoi...
index += 1
def OnBoutonOk(self, event):
""" Aperçu PDF des factures """
# Validation des données saisies
tracks = self.ctrl_liste_factures.GetTracksCoches()
if len(tracks) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune facture à envoyer par Email !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Création des factures sélectionnées
listeIDfacture = []
for track in tracks :
# Avertissements
if track.etat == "annulation" :
dlg = wx.MessageDialog(self, _(u"La facture n°%s a été annulée.\n\nVous ne pouvez pas l'envoyer par Email !") % track.numero, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Ajout
listeIDfacture.append(track.IDfacture)
facturation = UTILS_Facturation.Facturation()
dictOptions = self.ctrl_options.GetOptions()
if dictOptions == False :
return
resultat = facturation.Impression(listeFactures=listeIDfacture, nomDoc=None, afficherDoc=False, dictOptions=dictOptions, repertoire=dictOptions["repertoire_copie"], repertoireTemp=True)
if resultat == False :
return
dictChampsFusion, dictPieces = resultat
def SupprimerFichiersTemp():
for IDfacture, fichier in dictPieces.iteritems() :
try :
os.remove(fichier)
except :
pass
# 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 :
liste_adresses = []
if track.email == True :
# Si Famille inscrite à l'envoi par Email :
for valeur in track.email_factures.split("##"):
IDindividu, categorie, adresse = valeur.split(";")
if IDindividu != "" :
if dictAdressesIndividus.has_key(int(IDindividu)) :
adresse = dictAdressesIndividus[int(IDindividu)][categorie]
liste_adresses.append(adresse)
else :
liste_adresses.append(adresse)
else :
# Si famille non inscrite à l'envoi par Email
adresse = UTILS_Envoi_email.GetAdresseFamille(track.IDfamille, choixMultiple=False, muet=True, nomTitulaires=track.nomsTitulaires)
liste_adresses.append(adresse)
# Mémorisation des données
for adresse in liste_adresses :
if adresse not in (None, "", []) :
if dictPieces.has_key(track.IDfacture) :
fichier = dictPieces[track.IDfacture]
champs = dictChampsFusion[track.IDfacture]
listeDonnees.append({"adresse" : adresse, "pieces" : [fichier,], "champs" : champs})
if track.email == False :
if track.nomsTitulaires not in listeEnvoiNonDemande :
listeEnvoiNonDemande.append(track.nomsTitulaires)
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
# Annonce les envois non demandés
if len(listeEnvoiNonDemande) > 0 :
texte = _(u"%d des familles sélectionnées n'ont pas demandé d'envoi par Email de leur facture :\n\n") % len(listeEnvoiNonDemande)
texte += _(u"Souhaitez-vous quand même leur envoyer une facture ?")
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 facture à 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="facture")
dlg.SetDonnees(listeDonnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Suppression des PDF temporaires
SupprimerFichiersTemp()
class Dialog(wx.Dialog, Base):
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, name="DLG_Envoi_sms", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER|wx.MAXIMIZE_BOX|wx.MINIMIZE_BOX)
Base.__init__(self)
self.parent = parent
titre = _(u"Envoi de SMS")
intro = _(u"Vous pouvez envoyer ici des SMS aux individus ou familles à condition que votre plateforme d'envoi ait été intégrée à cette fonctionnalité. Consultez la liste des prestataires pris en charge dans la liste déroulante Plateforme de la page des paramètres.")
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(self, titre=titre, texte=intro, hauteurHtml=30, nomImage="Images/32x32/Sms.png")
# Initialisation des pages
self.InitPages(self)
self.static_line = wx.StaticLine(self, -1)
self.bouton_aide = CTRL_Bouton_image.CTRL(self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_retour = CTRL_Bouton_image.CTRL(self, texte=_(u"Retour"), cheminImage="Images/32x32/Fleche_gauche.png")
self.bouton_suite = CTRL_Bouton_image.CTRL(self, texte=_(u"Suite"), cheminImage="Images/32x32/Fleche_droite.png", margesImage=(0, 0, 4, 0), positionImage=wx.RIGHT)
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.Onbouton_aide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.Onbouton_retour, self.bouton_retour)
self.Bind(wx.EVT_BUTTON, self.Onbouton_suite, self.bouton_suite)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.bouton_retour.Enable(False)
self.nbrePages = len(self.listePages)
self.pageVisible = 0
# Création des pages
self.Creation_Pages()
self.GetPage("parametres").MAJ()
def Creation_Pages(self):
""" Creation des pages """
self.dictPages = {}
index = 0
for dictPage in self.listePages :
self.sizer_pages.Add(dictPage["ctrl"], 1, wx.EXPAND, 0)
if index > 0 :
dictPage["ctrl"].Show(False)
index += 1
self.sizer_pages.Layout()
def __set_properties(self):
self.bouton_aide.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour obtenir de l'aide")))
self.bouton_retour.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour revenir à la page précédente")))
self.bouton_suite.SetToolTip(wx.ToolTip(_(u"Cliquez ici pour passer à l'étape suivante")))
self.bouton_annuler.SetToolTip(wx.ToolTip(_(u"Cliquez pour annuler")))
self.SetMinSize((770, 650))
def __do_layout(self):
grid_sizer_base = wx.FlexGridSizer(rows=4, cols=1, vgap=0, hgap=0)
# Bandeau
grid_sizer_base.Add(self.ctrl_bandeau, 1, wx.EXPAND, 0)
# Contenu
sizer_base = wx.BoxSizer(wx.VERTICAL)
sizer_pages = wx.BoxSizer(wx.VERTICAL)
grid_sizer_base.Add(sizer_pages, 1, wx.EXPAND, 0)
grid_sizer_base.Add(self.static_line, 0, wx.LEFT|wx.RIGHT|wx.EXPAND, 10)
# Boutons
grid_sizer_boutons = wx.FlexGridSizer(rows=1, cols=6, vgap=10, hgap=10)
grid_sizer_boutons.Add(self.bouton_aide, 0, 0, 0)
grid_sizer_boutons.Add((20, 20), 0, wx.EXPAND, 0)
grid_sizer_boutons.Add(self.bouton_retour, 0, 0, 0)
grid_sizer_boutons.Add(self.bouton_suite, 0, 0, 0)
grid_sizer_boutons.Add(self.bouton_annuler, 0, wx.LEFT, 10)
grid_sizer_boutons.AddGrowableCol(1)
grid_sizer_base.Add(grid_sizer_boutons, 1, wx.ALL|wx.EXPAND, 10)
grid_sizer_base.AddGrowableRow(1)
grid_sizer_base.AddGrowableCol(0)
self.SetSizer(grid_sizer_base)
grid_sizer_base.Fit(self)
self.Layout()
self.CenterOnScreen()
self.sizer_pages = sizer_pages
def Onbouton_aide(self, event):
from Utils import UTILS_Aide
UTILS_Aide.Aide("")
def AfficherPage(self, numPage=0):
# rend invisible la page affichée
page = self.listePages[self.pageVisible]["ctrl"]
page.Sauvegarde()
page.Show(False)
# Fait apparaître nouvelle page
self.pageVisible = numPage
page = self.listePages[self.pageVisible]["ctrl"]
page.MAJ()
page.Show(True)
self.sizer_pages.Layout()
def Onbouton_retour(self, event):
# Affiche nouvelle page
self.AfficherPage(self.pageVisible - 1)
# Si on quitte l'avant-dernière page, on active le bouton Suivant
if self.pageVisible == self.nbrePages-1:
self.bouton_suite.Enable(True)
self.bouton_suite.SetImage(Chemins.GetStaticPath("Images/32x32/Valider.png"))
self.bouton_suite.SetTexte(_(u"Valider"))
else:
self.bouton_suite.Enable(True)
self.bouton_suite.SetImage(Chemins.GetStaticPath("Images/32x32/Fleche_droite.png"))
self.bouton_suite.SetTexte(_(u"Suite"))
# Si on revient à la première page, on désactive le bouton Retour
if self.pageVisible == 0 :
self.bouton_retour.Enable(False)
def Onbouton_suite(self, event):
# Vérifie que les données de la page en cours sont valides
validation = self.ValidationPages()
if validation == False : return
# Si on est déjà sur la dernière page : on termine
if self.pageVisible == self.nbrePages-1 :
self.listePages[self.pageVisible]["ctrl"].Sauvegarde()
self.Terminer()
return
# Affiche nouvelle page
self.AfficherPage(self.pageVisible + 1)
# Si on arrive à la dernière page, on désactive le bouton Suivant
if self.pageVisible == self.nbrePages-1 :
self.bouton_suite.SetImage(Chemins.GetStaticPath("Images/32x32/Valider.png"))
self.bouton_suite.SetTexte(_(u"Envoyer"))
# Si on quitte la première page, on active le bouton Retour
if self.pageVisible > 0 :
self.bouton_retour.Enable(True)
def OnClose(self, event):
self.OnBoutonAnnuler()
def OnBoutonAnnuler(self, event=None):
self.Annuler()
def Annuler(self):
""" Annulation des modifications """
self.EndModal(wx.ID_CANCEL)
def ValidationPages(self) :
""" Validation des données avant changement de pages """
return self.listePages[self.pageVisible]["ctrl"].Validation()
def Terminer(self):
# Envoi du message
if self.Envoyer() != True :
return False
# Fermeture
self.EndModal(wx.ID_OK)
def Envoyer(self):
# Demande de confirmation
dlg = wx.MessageDialog(self, _(u"Confirmez-vous l'envoi du message vers %d numéros ?") % len(self.dictDonnees["liste_telephones"]), _(u"Confirmation"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
# CONTACT EVERYONE BY ORANGE BUSINESS
if self.dictDonnees["plateforme"] == "contact_everyone" :
# Récupération adresse d'expédition
IDadresse = self.dictDonnees["adresse_expedition_email"]
dictAdresse = UTILS_Envoi_email.GetAdresseExp(IDadresse=IDadresse)
# Génération de la pièce jointe
liste_lignes = []
for ligne in self.dictDonnees["message"].split("\n") :
liste_lignes.append(u"T-%s" % ligne)
for numero in self.dictDonnees["liste_telephones"] :
numero = numero.replace(".", "")
liste_lignes.append(u"#-%s" % numero)
texte = "\n".join(liste_lignes)
cheminFichier = UTILS_Fichiers.GetRepTemp(fichier="sms.txt")
fichier = open(cheminFichier, 'w')
fichier.write(texte.encode("iso-8859-15"))
fichier.close()
# Envoi de l'email
try :
etat = UTILS_Envoi_email.Envoi_mail(
adresseExpediteur=dictAdresse["adresse"],
listeDestinataires=[self.dictDonnees["orange_adresse_destination_email"],],
sujetMail=self.dictDonnees["objet"],
texteMail=_(u"Envoi de SMS"),
listeFichiersJoints=[cheminFichier,],
serveur=dictAdresse["smtp"],
port=dictAdresse["port"],
avecAuthentification=dictAdresse["auth"],
avecStartTLS=dictAdresse["startTLS"],
motdepasse=dictAdresse["motdepasse"],
utilisateur=dictAdresse["utilisateur"],
)
except Exception, err:
print (err,)
err = str(err).decode("iso-8859-15")
dlgErreur = wx.MessageDialog(None, _(u"Une erreur a été détectée dans l'envoi de l'Email !\n\nErreur : %s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
# CLEVER SMS
if self.dictDonnees["plateforme"] == "cleversms" :
# Récupération adresse d'expédition
IDadresse = self.dictDonnees["adresse_expedition_email"]
dictAdresse = UTILS_Envoi_email.GetAdresseExp(IDadresse=IDadresse)
# Génération de la pièce jointe
liste_lignes = []
message = self.dictDonnees["message"].replace("\n", "")
for numero in self.dictDonnees["liste_telephones"] :
numero = numero.replace(".", "")
liste_lignes.append(u"%s;%s" % (numero, message))
texte = "\n".join(liste_lignes)
cheminFichier = UTILS_Fichiers.GetRepTemp(fichier="sms.txt")
fichier = open(cheminFichier, 'w')
fichier.write(texte.encode("iso-8859-15"))
fichier.close()
# Envoi de l'email
try :
etat = UTILS_Envoi_email.Envoi_mail(
adresseExpediteur=dictAdresse["adresse"],
listeDestinataires=[self.dictDonnees["cleversms_adresse_destination_email"],],
sujetMail=self.dictDonnees["objet"],
texteMail=_(u"Envoi de SMS"),
listeFichiersJoints=[cheminFichier,],
serveur=dictAdresse["smtp"],
port=dictAdresse["port"],
avecAuthentification=dictAdresse["auth"],
avecStartTLS=dictAdresse["startTLS"],
motdepasse=dictAdresse["motdepasse"],
utilisateur=dictAdresse["utilisateur"],
)
except Exception, err:
print (err,)
err = str(err).decode("iso-8859-15")
dlgErreur = wx.MessageDialog(None, _(u"Une erreur a été détectée dans l'envoi de l'Email !\n\nErreur : %s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlgErreur.ShowModal()
dlgErreur.Destroy()
return False
def EnvoyerEmail(self, event):
""" Envoi par Email des codes internet """
# Validation des données saisies
tracks = self.ctrl_listview.GetTracksCoches()
if len(tracks) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune famille dans la liste !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Récupération des données
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, "", []):
champs = {
"{NOM_FAMILLE}": track.nomTitulaires,
"{IDENTIFIANT_INTERNET}": track.internet_identifiant,
"{MOTDEPASSE_INTERNET}": track.internet_mdp,
}
listeDonnees.append({
"adresse": adresse,
"pieces": [],
"champs": champs
})
else:
listeAnomalies.append(track.nomTitulaires)
# 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:
return
# Dernière vérification avant transfert
if len(listeDonnees) == 0:
dlg = wx.MessageDialog(
self,
_(u"Il ne reste finalement aucune donnée à envoyer par Email !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Transfert des données vers DLG Mailer
from Dlg import DLG_Mailer
dlg = DLG_Mailer.Dialog(self, categorie="portail")
dlg.SetDonnees(listeDonnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
def OnBoutonOk(self, event):
""" Aperçu PDF des inscriptions """
# Validation des données saisies
tracks = self.ctrl_liste_inscriptions.GetTracksCoches()
if len(tracks) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous n'avez sélectionné aucune inscription à envoyer par Email !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Création des inscriptions sélectionnées
listeIDinscription = []
for track in tracks:
listeIDinscription.append(track.IDinscription)
inscription = UTILS_Inscriptions.Inscription()
dictOptions = self.ctrl_options.GetOptions()
if dictOptions == False:
return
resultat = inscription.Impression(listeInscriptions=listeIDinscription,
nomDoc=None,
afficherDoc=False,
dictOptions=dictOptions,
repertoire=dictOptions["repertoire"],
repertoireTemp=True)
if resultat == False:
return
dictChampsFusion, dictPieces = resultat
def SupprimerFichiersTemp():
for IDinscription, fichier in dictPieces.items():
if os.path.isfile(fichier):
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.IDinscription in dictPieces:
for adresse in dict_adresses.get(track.IDfamille, []):
fichier = dictPieces[track.IDinscription]
champs = dictChampsFusion[track.IDinscription]
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="inscription")
dlg.SetDonnees(liste_donnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
# Suppression des PDF temporaires
SupprimerFichiersTemp()