def AnnonceRappel(self):
# Affichage à 70 % de chance
if random.randrange(1, 100) > 70 :
return False
# Vérifie si case Ne plus Afficher cochée ou non
if UTILS_Parametres.Parametres(mode="get", categorie="ne_plus_afficher", nom="sauvegarde_automatique", valeur=False) == True :
return False
try :
image = wx.Bitmap(Chemins.GetStaticPath("Images/48x48/Sauvegarder.png"), wx.BITMAP_TYPE_ANY)
message1 = _(u"Vous n'avez paramétré aucune sauvegarde automatique.\n\nSouhaitez-vous le faire maintenant ?")
dlg = dialogs.MultiMessageDialog(self.parent, message1, caption=_(u"Rappel de sauvegarde"), msg2=None, style = wx.NO | wx.CANCEL | wx.YES | wx.YES_DEFAULT, icon=image, btnLabels={wx.ID_YES : _(u"Oui"), wx.ID_NO : _(u"Ne plus rappeler"), wx.ID_CANCEL : _(u"Pas maintenant")})
reponse = dlg.ShowModal()
dlg.Destroy()
except :
reponse = None
if reponse == wx.ID_YES :
from Dlg import DLG_Sauvegardes_auto
dlg = DLG_Sauvegardes_auto.Dialog(self.parent)
dlg.ShowModal()
dlg.Destroy()
return wx.ID_CANCEL
if reponse == wx.ID_NO :
UTILS_Parametres.Parametres(mode="set", categorie="ne_plus_afficher", nom="sauvegarde_automatique", valeur=True)
if reponse == wx.ID_CANCEL :
return True
return True
def Validation(self):
listeNonValides = []
for track in self.listview.GetCheckedObjects():
if track.mail in (None, ""):
nom = track.nom
if track.prenom not in (None, ""):
nom += u" " + track.prenom
listeNonValides.append(nom)
if len(listeNonValides) > 0:
image = wx.Bitmap(
Chemins.GetStaticPath("Images/32x32/Activite.png"),
wx.BITMAP_TYPE_ANY)
texteIntro = _(
u"Attention, les %d destinataires sélectionnés suivants n'ont pas d'adresse valide :"
) % len(listeNonValides)
texteDetail = "\n".join(listeNonValides)
dlg = dialogs.MultiMessageDialog(self,
texteIntro,
caption=_(u"Avertissement"),
msg2=texteDetail,
style=wx.ICON_EXCLAMATION | wx.OK
| wx.CANCEL,
icon=None,
btnLabels={
wx.ID_OK: _(u"Continuer"),
wx.ID_CANCEL: _(u"Annuler")
})
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse == wx.ID_CANCEL:
return False
return True
def OnBoutonOk(self, event):
# Validation des données
tracks = self.ctrl_factures.GetTracksCoches()
if len(tracks) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune facture à inclure dans votre lot !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
dictFactures = self.GetFactures()
listeErreursSoldes = []
listeErreursRIB = []
for track in tracks :
# Vérifie que la facture est bien impayée
if track.soldeActuel >= 0.0 :
listeErreursSoldes.append(track)
## # Vérifie que la famille a une autorisation de prélèvement
## if track.prelevement not in (True, 1) :
## listeErreursRIB.append(track)
# Recherche si la facture n'est pas déjà dans un autre prélèvement
listeAutresLots = []
if track.IDfacture in dictFactures :
for dictTemp in dictFactures[track.IDfacture] :
if dictTemp["IDlot"] != self.IDlot :
nomLot = dictTemp["nomLot"]
statut = dictTemp["statut"]
listeAutresLots.append(_(u"- %s (avec le statut '%s')") % (nomLot, statut.capitalize()))
if len(listeAutresLots) > 0 :
message1 = _(u"La facture n°%s est déjà présente dans les autres lots suivants. Souhaitez-vous tout de même l'inclure de votre lot actuel ?") % track.numero
message2 = "\n".join(listeAutresLots)
dlg = dialogs.MultiMessageDialog(self, message1, caption=_(u"Avertissement"), msg2=message2, style = wx.ICON_QUESTION |wx.NO | wx.CANCEL | wx.YES | wx.YES_DEFAULT, icon=None, btnLabels={wx.ID_YES : _(u"Oui"), wx.ID_NO : _(u"Non"), wx.ID_CANCEL : _(u"Annuler")})
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
if len(listeErreursSoldes) > 0 :
dlg = wx.MessageDialog(None, _(u"Vous avez sélectionné %d factures qui ont déjà été payées.\n\nSouhaitez-vous tout de même les inclure dans le lot ?") % len(listeErreursSoldes), _(u"Réinitialisation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return False
## if len(listeErreursRIB) > 0 :
## dlg = wx.MessageDialog(self, _(u"Vous avez sélectionné %d factures pour des familles qui n'ont pas d'autorisation de prélèvement !") % len(listeErreursRIB), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
## dlg.ShowModal()
## dlg.Destroy()
## return False
# Fermeture
self.EndModal(wx.ID_OK)
def AfficheDLGInterdiction():
import wx.lib.dialogs as dialogs
image = wx.Bitmap(Chemins.GetStaticPath("Images/32x32/Droits.png"),
wx.BITMAP_TYPE_ANY)
dlg = dialogs.MultiMessageDialog(
None,
_(u"Votre profil utilisateur ne vous permet pas d'accéder à cette fonctionnalité !"
),
caption=_(u"Accès non autorisé"),
style=wx.ICON_ERROR | wx.OK,
icon=image,
btnLabels={wx.ID_OK: _(u"Ok")})
dlg.ShowModal()
dlg.Destroy()
def VerifieConsommations(self, listePeriodes=[]):
# Récupération des unités
DB = GestionDB.DB()
req = """SELECT IDunite, nom, abrege, type, heure_debut, heure_fin
FROM unites
WHERE IDactivite=%d
ORDER BY ordre;""" % self.IDactivite
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictUnites = {}
for IDunite, nom, abrege, type, heure_debut, heure_fin in listeDonnees :
dictUnites[IDunite] = {"nom":nom, "abrege":abrege, "type":type, "heure_debut":heure_debut, "heure_fin":heure_fin, "unites_incompatibles" : []}
# Récupère les incompatibilités entre unités
req = """SELECT IDunite_incompat, IDunite, IDunite_incompatible
FROM unites_incompat;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDunite_incompat, IDunite, IDunite_incompatible in listeDonnees :
if IDunite in dictUnites : dictUnites[IDunite]["unites_incompatibles"].append(IDunite_incompatible)
if IDunite_incompatible in dictUnites : dictUnites[IDunite_incompatible]["unites_incompatibles"].append(IDunite)
# Récupération des ouvertures des unités
req = """SELECT IDouverture, IDunite, IDgroupe, date
FROM ouvertures
WHERE IDactivite=%d
ORDER BY date; """ % self.IDactivite
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOuvertures = {}
for IDouverture, IDunite, IDgroupe, date in listeDonnees :
date = UTILS_Dates.DateEngEnDateDD(date)
dictOuvertures[(date, IDunite, IDgroupe)] = IDouverture
# Récupération des consommations
req = """SELECT IDconso, date, IDunite, heure_debut, heure_fin, etat
FROM consommations
WHERE IDactivite=%d AND IDindividu=%d
ORDER BY date; """ % (self.IDactivite, self.IDindividu)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictConsommations = {}
for IDconso, date, IDunite, heure_debut, heure_fin, etat in listeDonnees :
date = UTILS_Dates.DateEngEnDateDD(date)
if IDconso not in self.listeSuppressionConso :
if (date in dictConsommations) == False :
dictConsommations[date] = []
dictConsommations[date].append({"IDconso" : IDconso, "IDunite" : IDunite, "heure_debut" : heure_debut, "heure_fin" : heure_fin, "etat" : etat})
DB.Close()
listeAnomalies = []
for dictPeriode in listePeriodes :
for dictConso in dictPeriode["listeConso"] :
if dictConso["IDconso"] == None :
dateFr = UTILS_Dates.DateDDEnFr(dictConso["date"])
valide = True
# Vérifie si unité ouverte
if ((dictConso["date"], dictConso["IDunite"], self.IDgroupe) in dictOuvertures) == False :
listeAnomalies.append(_(u"%s : Unité %s fermée pour le groupe %s") % (dateFr, dictUnites[dictConso["IDunite"]]["nom"], self.nomGroupe))
valide = False
# Recherche si pas d'incompatibilités avec les conso déjà saisies
if dictConso["date"] in dictConsommations :
for dictConsoTemp in dictConsommations[dictConso["date"]] :
nomUnite1 = dictUnites[dictConso["IDunite"]]["nom"]
nomUnite2 = dictUnites[dictConsoTemp["IDunite"]]["nom"]
if self.VerifieCompatibilitesUnites(dictUnites, dictConsoTemp["IDunite"], dictConso["IDunite"]) == False :
listeAnomalies.append(_(u"%s : Unité %s incompatible avec unité %s déjà présente") % (dateFr, nomUnite1, nomUnite2))
valide = False
if dictConso["IDunite"] == dictConsoTemp["IDunite"] :
if dictUnites[dictConso["IDunite"]]["type"] == "Multihoraire" :
if dictConso["heure_fin"] > dictConsoTemp["heure_debut"] and dictConso["heure_debut"] < dictConsoTemp["heure_fin"] :
listeAnomalies.append(_(u"%s : L'unité multihoraires %s chevauche une consommation d'une unité identique") % (dateFr, nomUnite1))
valide = False
else :
listeAnomalies.append(_(u"%s : Unité %s déjà présente") % (dateFr, nomUnite1))
valide = False
# Signalement des anomalies
if len(listeAnomalies) :
message1 = _(u"Validation du contrat impossible.\n\nLes %d anomalies suivantes ont été trouvées :") % len(listeAnomalies)
message2 = u"\n".join(listeAnomalies)
dlg = dialogs.MultiMessageDialog(self, message1, caption = _(u"Génération des consommations"), msg2=message2, style = wx.ICON_EXCLAMATION | wx.YES|wx.YES_DEFAULT, btnLabels={wx.ID_YES : _(u"Ok")})
reponse = dlg.ShowModal()
dlg.Destroy()
return False
return True
def OnBoutonFichier(self, event):
""" Génération d'un fichier normalisé """
# Validation des données
if self.ValidationDonnees() == False:
return False
# Vérifie que des pièces existent
if not (self.ctrl_pieces.GetObjects()):
dlg = wx.MessageDialog(
self, _(u"Vous devez ajouter au moins une pièce !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Récupération des infos sur la remise
remise_nom = DLG_Saisie_lot_tresor_public.Supprime_accent(
self.ctrl_nom.GetValue())
nom_fichier = remise_nom
nomOrganisateur = UTILS_Organisateur.GetNom()
# Génération des pièces jointes
dict_pieces_jointes = False
if self.ctrl_parametres.GetPropertyValue(
"inclure_pieces_jointes") == True:
dict_pieces_jointes = self.GenerationPiecesJointes()
if dict_pieces_jointes == False:
return False
# Récupération des transactions à effectuer
montantTotal = FloatToDecimal(0.0)
nbreTotal = 0
listeAnomalies = []
listePieces = []
for track in self.ctrl_pieces.GetObjects():
montant = FloatToDecimal(track.montant)
if track.analysePiece == False:
listeAnomalies.append(u"%s : %s" %
(track.libelle, track.analysePieceTexte))
# Objet de la pièce
objet_piece = self.ctrl_parametres.GetPropertyValue("objet_piece")
objet_piece = DLG_Saisie_lot_tresor_public.Supprime_accent(
objet_piece).upper()
objet_piece = objet_piece.replace("{NOM_ORGANISATEUR}",
nomOrganisateur)
objet_piece = objet_piece.replace("{NUM_FACTURE}",
str(track.numero))
objet_piece = objet_piece.replace("{LIBELLE_FACTURE}",
track.libelle)
objet_piece = objet_piece.replace(
"{MOIS}", str(self.ctrl_parametres.GetPropertyValue("mois")))
objet_piece = objet_piece.replace(
"{MOIS_LETTRES}",
DLG_Saisie_lot_tresor_public.GetMoisStr(
self.ctrl_parametres.GetPropertyValue("mois"),
majuscules=True,
sansAccents=True))
objet_piece = objet_piece.replace(
"{ANNEE}",
str(self.ctrl_parametres.GetPropertyValue("exercice")))
# Création du libellé du prélèvement
prelevement_libelle = self.ctrl_parametres.GetPropertyValue(
"prelevement_libelle")
prelevement_libelle = prelevement_libelle.replace(
"{NOM_ORGANISATEUR}", nomOrganisateur)
prelevement_libelle = prelevement_libelle.replace(
"{OBJET_PIECE}", objet_piece)
prelevement_libelle = prelevement_libelle.replace(
"{LIBELLE_FACTURE}", track.libelle)
prelevement_libelle = prelevement_libelle.replace(
"{NUM_FACTURE}", str(track.numero))
prelevement_libelle = prelevement_libelle.replace(
"{MOIS}", str(self.ctrl_parametres.GetPropertyValue("mois")))
prelevement_libelle = prelevement_libelle.replace(
"{MOIS_LETTRES}",
DLG_Saisie_lot_tresor_public.GetMoisStr(
self.ctrl_parametres.GetPropertyValue("mois"),
majuscules=True,
sansAccents=True))
prelevement_libelle = prelevement_libelle.replace(
"{ANNEE}",
str(self.ctrl_parametres.GetPropertyValue("exercice")))
dictPiece = {
"id_piece": str(track.IDfacture),
"objet_piece": objet_piece,
"num_dette": str(track.numero),
"montant": str(montant),
"sequence": track.prelevement_sequence,
"prelevement": track.prelevement,
"prelevement_date_mandat": str(track.prelevement_date_mandat),
"prelevement_rum": track.prelevement_rum,
"prelevement_bic": track.prelevement_bic,
"prelevement_iban": track.prelevement_iban,
"prelevement_titulaire": track.prelevement_titulaire,
"prelevement_libelle": prelevement_libelle,
"titulaire_civilite": track.titulaireCivilite,
"titulaire_nom": track.titulaireNom,
"titulaire_prenom": track.titulairePrenom,
"titulaire_rue": track.titulaireRue,
"titulaire_cp": track.titulaireCP,
"titulaire_ville": track.titulaireVille,
"idtiers_helios": track.idtiers_helios,
"natidtiers_helios": track.natidtiers_helios,
"reftiers_helios": track.reftiers_helios,
"cattiers_helios": track.cattiers_helios,
"natjur_helios": track.natjur_helios,
"IDfacture": track.IDfacture,
}
listePieces.append(dictPiece)
montantTotal += montant
nbreTotal += 1
# Mémorisation de tous les données
dictDonnees = {
"nom_fichier":
nom_fichier,
"date_emission":
UTILS_Dates.ConvertDateWXenDate(
self.ctrl_parametres.GetPropertyValue(
"date_emission")).strftime("%Y-%m-%d"),
"date_envoi":
UTILS_Dates.ConvertDateWXenDate(
self.ctrl_parametres.GetPropertyValue("date_envoi")).strftime(
"%Y-%m-%d"),
"date_prelevement":
UTILS_Dates.ConvertDateWXenDate(
self.ctrl_parametres.GetPropertyValue(
"date_prelevement")).strftime("%Y-%m-%d"),
"id_poste":
self.ctrl_parametres.GetPropertyValue("id_poste"),
"id_collectivite":
self.ctrl_parametres.GetPropertyValue("id_collectivite"),
"code_collectivite":
self.ctrl_parametres.GetPropertyValue("code_collectivite"),
"code_budget":
self.ctrl_parametres.GetPropertyValue("code_budget"),
"exercice":
str(self.ctrl_parametres.GetPropertyValue("exercice")),
"mois":
str(self.ctrl_parametres.GetPropertyValue("mois")),
"id_bordereau":
self.ctrl_parametres.GetPropertyValue("id_bordereau"),
"montant_total":
str(montantTotal),
"objet_dette":
self.ctrl_parametres.GetPropertyValue("objet_dette"),
"code_prodloc":
self.ctrl_parametres.GetPropertyValue("code_prodloc"),
"code_etab":
self.ctrl_parametres.GetPropertyValue("code_etab"),
"pieces":
listePieces,
"pieces_jointes":
dict_pieces_jointes,
}
if len(listeAnomalies) > 0:
import wx.lib.dialogs as dialogs
message = "\n".join(listeAnomalies)
dlg = dialogs.MultiMessageDialog(
self,
_(u"Le fichier ne peut être généré en raison des anomalies suivantes :"
),
caption=_(u"Génération impossible"),
msg2=message,
style=wx.ICON_ERROR | wx.OK,
icon=None,
btnLabels={wx.ID_OK: _(u"Fermer")})
dlg.ShowModal()
dlg.Destroy()
return
# Génération du fichier XML
doc = UTILS_Pes.GetXML(dictDonnees)
xml = doc.toprettyxml(encoding="utf-8")
# Validation XSD
valide = UTILS_Pes.ValidationXSD(xml)
if valide != True:
liste_erreurs = valide
dlg = DLG_Messagebox.Dialog(
self,
titre=_(u"Validation XSD"),
introduction=_(
u"Les %d anomalies suivantes ont été détectées :") %
len(liste_erreurs),
detail=u"\n".join(liste_erreurs),
conclusion=
_(u"Le fichier ne semble pas valide. Souhaitez-vous continuer quand même ?"
),
icone=wx.ICON_EXCLAMATION,
boutons=[_(u"Oui"), _(u"Non"),
_(u"Annuler")])
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse in (1, 2):
return False
# Demande à l'utilisateur le nom de fichier et le répertoire de destination
wildcard = "Fichier XML (*.xml)|*.xml| All files (*.*)|*.*"
sp = wx.StandardPaths.Get()
cheminDefaut = sp.GetDocumentsDir()
dlg = wx.FileDialog(
None,
message=
_(u"Veuillez sélectionner le répertoire de destination et le nom du fichier"
),
defaultDir=cheminDefaut,
defaultFile=nom_fichier,
wildcard=wildcard,
style=wx.FD_SAVE)
dlg.SetFilterIndex(0)
if dlg.ShowModal() == wx.ID_OK:
cheminFichier = dlg.GetPath()
dlg.Destroy()
else:
dlg.Destroy()
return
# Le fichier de destination existe déjà :
if os.path.isfile(cheminFichier) == True:
dlg = wx.MessageDialog(
None,
_(u"Un fichier portant ce nom existe déjà. \n\nVoulez-vous le remplacer ?"
), _(u"Attention !"),
wx.YES_NO | wx.NO_DEFAULT | wx.ICON_EXCLAMATION)
if dlg.ShowModal() == wx.ID_NO:
return False
dlg.Destroy()
else:
dlg.Destroy()
# Création du fichier texte
f = open(cheminFichier, "w")
try:
if six.PY2:
f.write(doc.toxml(encoding="ISO-8859-1"))
else:
#f.write(doc.toprettyxml(indent=" "))
f.write(doc.toxml())
finally:
f.close()
# Confirmation de création du fichier et demande d'ouverture directe
txtMessage = _(
u"Le fichier xml PES Recette ORMC a été créé avec succès.\n\nSouhaitez-vous visualiser son contenu maintenant ?"
)
dlgConfirm = wx.MessageDialog(
None, txtMessage, _(u"Confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
reponse = dlgConfirm.ShowModal()
dlgConfirm.Destroy()
if reponse == wx.ID_NO:
return
else:
FonctionsPerso.LanceFichierExterne(cheminFichier)
def ValidationDonnees(self):
""" Vérifie que les données saisies sont exactes """
# Généralités
nom = self.ctrl_nom.GetValue()
if nom == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir un nom de lot (Ex : 'Janvier 2013'...) !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
for caract in nom:
if caract in ("_", ):
dlg = wx.MessageDialog(
self,
_(u"Le caractère '%s' n'est pas autorisé dans le nom du lot !"
) % caract, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
# Vérifie que le nom n'est pas déjà attribué
if self.IDlot == None:
IDlotTemp = 0
else:
IDlotTemp = self.IDlot
DB = GestionDB.DB()
req = """SELECT IDlot, nom
FROM pes_lots
WHERE nom='%s' AND IDlot!=%d;""" % (nom, IDlotTemp)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) > 0:
dlg = wx.MessageDialog(
self,
_(u"Ce nom de lot a déjà été attribué à un autre lot.\n\nChaque lot doit avoir un nom unique. Changez le nom."
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
observations = self.ctrl_observations.GetValue()
if self.ctrl_verrouillage.GetValue() == True:
verrouillage = 1
else:
verrouillage = 0
# Récupération des données du CTRL Paramètres
exercice = self.ctrl_parametres.GetPropertyValue("exercice")
mois = self.ctrl_parametres.GetPropertyValue("mois")
objet_dette = self.ctrl_parametres.GetPropertyValue("objet_dette")
date_emission = self.ctrl_parametres.GetPropertyValue("date_emission")
date_prelevement = self.ctrl_parametres.GetPropertyValue(
"date_prelevement")
date_envoi = self.ctrl_parametres.GetPropertyValue("date_envoi")
id_bordereau = self.ctrl_parametres.GetPropertyValue("id_bordereau")
id_poste = self.ctrl_parametres.GetPropertyValue("id_poste")
id_collectivite = self.ctrl_parametres.GetPropertyValue(
"id_collectivite")
code_collectivite = self.ctrl_parametres.GetPropertyValue(
"code_collectivite")
code_budget = self.ctrl_parametres.GetPropertyValue("code_budget")
code_prodloc = self.ctrl_parametres.GetPropertyValue("code_prodloc")
code_etab = self.ctrl_parametres.GetPropertyValue("code_etab")
reglement_auto = int(
self.ctrl_parametres.GetPropertyValue("reglement_auto"))
IDcompte = self.ctrl_parametres.GetPropertyValue("IDcompte")
IDmode = self.ctrl_parametres.GetPropertyValue("IDmode")
# Vérification du compte à créditer
if reglement_auto == 1:
if IDcompte == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un compte à créditer !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if IDmode == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un mode de règlement pour le règlement automatique !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérification des paramètres du bordereau
listeVerifications = [
(exercice, "exercice", _(u"l'année de l'exercice")),
(mois, "mois", _(u"le mois")),
(objet_dette, "objet_dette", _(u"l'objet de la dette")),
(date_emission, "date_emission", _(u"la date d'émission")),
(date_prelevement, "date_prelevement",
_(u"la date souhaitée du prélèvement")),
(date_envoi, "date_envoi", _(u"la date d'envoi")),
(id_bordereau, "id_bordereau", _(u"l'ID bordereau")),
(id_poste, "id_poste", _(u"l'ID poste")),
(id_collectivite, "id_collectivite", _(u"l'ID collectivité")),
(code_collectivite, "code_collectivite",
_(u"le Code Collectivité")),
(code_budget, "code_budget", _(u"le Code Bugdet")),
(code_prodloc, "code_prodloc", _(u"le code Produit Local")),
(code_etab, "code_etab", _(u"le code Etablissement")),
]
for donnee, code, label in listeVerifications:
if donnee == None or donnee == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement saisir %s dans les paramètres du lot !"
) % label, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if code == "id_bordereau":
try:
test = int(donnee)
except:
dlg = wx.MessageDialog(
self,
_(u"Vous devez saisir une valeur numérique valide pour le paramètre de bordereau 'ID Bordereau' !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if code == "id_collectivite":
try:
test = int(donnee)
except:
dlg = wx.MessageDialog(
self,
_(u"Vous devez saisir une valeur numérique valide pour le paramètre de bordereau 'ID Collectivité' !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérification des pièces
listeErreurs = []
listeTemp1 = []
for track in self.ctrl_pieces.GetObjects():
if track.analysePiece == False:
listeErreurs.append(
_(u"- Facture n°%s : %s") %
(track.IDfacture, track.analysePieceTexte))
# Vérifie qu'un OOFF ou un FRST n'est pas attribué 2 fois à un seul mandat
if track.prelevement == 1:
if track.prelevement_sequence in ("OOFF", "FRST"):
key = (track.prelevement_IDmandat,
track.prelevement_sequence)
if key in listeTemp1:
if track.prelevement_sequence == "OOFF":
listeErreurs.append(
_(u"- Facture n°%s : Le mandat n°%s de type ponctuel a déjà été utilisé une fois !"
) %
(track.IDfacture, track.prelevement_IDmandat))
if track.prelevement_sequence == "FRST":
listeErreurs.append(
_(u"- Facture n°%s : Mandat n°%s déjà initialisé. La séquence doit être définie sur 'RCUR' !"
) %
(track.IDfacture, track.prelevement_IDmandat))
listeTemp1.append(key)
if len(listeErreurs) > 0:
message1 = _(
u"Le bordereau ne peut être validé en raison des erreurs suivantes :"
)
message2 = "\n".join(listeErreurs)
dlg = dialogs.MultiMessageDialog(self,
message1,
caption=_(u"Erreur"),
msg2=message2,
style=wx.ICON_EXCLAMATION | wx.OK,
icon=None,
btnLabels={wx.ID_OK: _(u"Ok")})
reponse = dlg.ShowModal()
dlg.Destroy()
return False
return True
def Inscrire(self, IDactivite=None, nomActivite="", IDgroupe=None, nomGroupe="", IDcategorie_tarif=None, nomCategorie=""):
""" Lance la procédure d'inscription """
tracks = self.GetCheckedObjects()
if len(tracks) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez cocher au moins un individu dans la liste !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
dlg = wx.MessageDialog(self, _(u"Souhaitez-vous vraiment inscrire %d individus à l'activité '%s' ?") % (len(tracks), nomActivite), _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES :
return
dlgprogress = wx.ProgressDialog(_(u"Veuillez patienter"), _(u"Lancement de la procédure..."), maximum=len(tracks), parent=None, style= wx.PD_SMOOTH | wx.PD_ESTIMATED_TIME | wx.PD_REMAINING_TIME | wx.PD_CAN_ABORT | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL)
listeAnomalies = []
listeValidees = []
index = 0
for track in tracks :
# Recherche du nom de l'individu
if track.prenom == None :
nomIndividu = track.nom
else :
nomIndividu = u"%s %s" % (track.nom, track.prenom)
keepGoing, skip = dlgprogress.Update(index, _(u"[%d/%d] Inscription de %s...") % (index, len(tracks), nomIndividu))
# Vérifie si individu déjà inscrit
if track.inscrit == "oui" :
listeAnomalies.append(_(u"%s (Famille de %s) : Individu déjà inscrit") % (nomIndividu, track.nomTitulaires))
index += 1
else :
# Sauvegarde
DB = GestionDB.DB()
listeDonnees = [
("IDindividu", track.IDindividu ),
("IDfamille", track.IDfamille ),
("IDactivite", IDactivite ),
("IDgroupe", IDgroupe),
("IDcategorie_tarif", IDcategorie_tarif),
("IDcompte_payeur", track.IDcompte_payeur),
("date_inscription", str(datetime.date.today()) ),
("parti", 0),
]
IDinscription = DB.ReqInsert("inscriptions", listeDonnees)
DB.Close()
# Mémorise l'action dans l'historique
UTILS_Historique.InsertActions([{
"IDindividu" : track.IDindividu,
"IDfamille" : track.IDfamille,
"IDcategorie" : 18,
"action" : _(u"Inscription à l'activité '%s' sur le groupe '%s' avec la tarification '%s'") % (nomActivite, nomGroupe, nomCategorie)
},])
# Saisie de forfaits auto
f = DLG_Appliquer_forfait.Forfaits(IDfamille=track.IDfamille, listeActivites=[IDactivite,], listeIndividus=[track.IDindividu,], saisieManuelle=False, saisieAuto=True)
f.Applique_forfait(selectionIDcategorie_tarif=IDcategorie_tarif, inscription=True, selectionIDactivite=IDactivite)
# Actualise l'affichage
self.dictInscriptions[(track.IDindividu, track.IDfamille, IDactivite)] = {"IDinscription" : IDinscription, "IDgroupe" : IDgroupe, "IDcategorie_tarif" : IDcategorie_tarif}
track.inscrit = "oui"
self.RefreshObject(track)
# Attente
listeValidees.append(track)
time.sleep(0.2)
index += 1
# Stoppe la procédure
if keepGoing == False :
break
# Fermeture dlgprogress
dlgprogress.Destroy()
# Messages de fin
if len(listeAnomalies) > 0 :
message1 = _(u"%d inscriptions ont été créées avec succès mais les %d anomalies suivantes ont été trouvées :") % (len(listeValidees), len(listeAnomalies))
message2 = u"\n".join(listeAnomalies)
dlg = dialogs.MultiMessageDialog(self, message1, caption = _(u"Inscription"), msg2=message2, style = wx.ICON_EXCLAMATION | wx.YES|wx.YES_DEFAULT, btnLabels={wx.ID_YES : _(u"Ok")})
reponse = dlg.ShowModal()
dlg.Destroy()
else :
dlg = wx.MessageDialog(self, _(u"%d inscriptions ont été créées avec succès !") % len(listeValidees), _(u"Fin"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
def Start(self):
# Annonce rappel de sauvegarde auto
if len(self.listeSauvegardes) == 0:
resultat = self.AnnonceRappel()
return resultat
# Lancement des sauvegardes
for dictSauvegarde in self.listeSauvegardes:
valide = True
resultat = False
# Création du nom de la sauvegarde
prefixe = dictSauvegarde["sauvegarde_nom"]
dictSauvegarde["sauvegarde_nom"] = u"%s_%s" % (
dictSauvegarde["sauvegarde_nom"],
datetime.datetime.now().strftime("%Y%m%d_%H%M"))
# Vérification des conditions
if valide == True:
valide = self.VerificationConditions(dictSauvegarde)
# Demande de confirmation
if valide == True and dictSauvegarde["option_demander"] == "1":
image = wx.Bitmap(
Chemins.GetStaticPath("Images/48x48/Sauvegarder.png"),
wx.BITMAP_TYPE_ANY)
message1 = _(
u"Souhaitez-vous lancer la procédure de sauvegarde '%s' ?"
) % dictSauvegarde["nom"]
dlg = dialogs.MultiMessageDialog(
self.parent,
message1,
caption=_(u"Sauvegarde automatique"),
msg2=None,
style=wx.NO | wx.CANCEL | wx.YES | wx.YES_DEFAULT,
icon=image,
btnLabels={
wx.ID_YES: _(u"Oui"),
wx.ID_NO: _(u"Non"),
wx.ID_CANCEL: _(u"Annuler")
})
reponse = dlg.ShowModal()
try:
dlg.Destroy()
except:
pass
if reponse == wx.ID_NO:
valide = False
if reponse == wx.ID_CANCEL:
return wx.ID_CANCEL
# Afficher interface
if valide == True and dictSauvegarde[
"option_afficher_interface"] == "1":
from Dlg import DLG_Sauvegarde
dlg = DLG_Sauvegarde.Dialog(self.parent,
dictDonnees=dictSauvegarde)
dlg.ShowModal()
resultat = dlg.GetResultat()
dlg.Destroy()
# Sauvegarde
if valide == True and dictSauvegarde[
"option_afficher_interface"] != "1":
resultat = self.Sauvegarde(dictSauvegarde)
if resultat == True and dictSauvegarde[
"option_confirmation"] == "1":
dlg = wx.MessageDialog(
self.parent,
_(u"La procédure de sauvegarde '%s' s'est terminée avec succès."
) % dictSauvegarde["nom"], _(u"Sauvegarde"),
wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
if resultat == False:
dlg = wx.MessageDialog(
self.parent,
_(u"Echec de la procédure de sauvegarde '%s' !") %
dictSauvegarde["nom"], _(u"Annulation"),
wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return wx.ID_CANCEL
# Sauvegarde de la date de la sauvegarde
if resultat == True:
DB = GestionDB.DB()
DB.ReqMAJ("sauvegardes_auto", [
("date_derniere", str(datetime.date.today())),
], "IDsauvegarde", dictSauvegarde["IDsauvegarde"])
DB.Close()
# Suppression des sauvegardes obsolètes
if dictSauvegarde["option_suppression"] != None and dictSauvegarde[
"sauvegarde_repertoire"] != None and os.path.isdir(
dictSauvegarde["sauvegarde_repertoire"]) == True:
nbreJours = int(dictSauvegarde["option_suppression"])
repertoire = dictSauvegarde["sauvegarde_repertoire"]
listeFichiersPresents = glob.glob(repertoire + "/*")
for fichier in listeFichiersPresents:
nomFichier = os.path.basename(fichier)
if (fichier.endswith(".nod") or fichier.endswith(".noc")
) and nomFichier.startswith(prefixe):
dateCreationFichier = datetime.date.fromtimestamp(
os.path.getctime(fichier))
nbreJoursFichier = (datetime.date.today() -
dateCreationFichier).days
if nbreJoursFichier >= nbreJours:
try:
os.remove(fichier)
except:
pass
return True
def Generation(self, listeConso=[], IDconso=None):
# Vérification de la validité des dates
listeAnomalies = []
nbreConsoValides = 0
listeConsoFinale = []
for dictConso in listeConso:
index = 0
dateFr = UTILS_Dates.DateDDEnFr(dictConso["date"])
valide = True
# Recherche si pas d'incompatibilités avec les conso déjà saisies
for track in self.GetTracks():
if dictConso["date"] == track.date:
nomUnite1 = self.dictUnites[dictConso["IDunite"]]["nom"]
nomUnite2 = self.dictUnites[track.IDunite]["nom"]
if self.VerifieCompatibilitesUnites(
track.IDunite, dictConso["IDunite"]) == False:
listeAnomalies.append(
_(u"%s : Unité %s incompatible avec unité %s déjà présente"
) % (dateFr, nomUnite1, nomUnite2))
valide = False
if dictConso["IDunite"] == track.IDunite:
if self.dictUnites[dictConso["IDunite"]][
"type"] == "Multihoraire":
if dictConso[
"heure_fin"] > track.heure_debut and dictConso[
"heure_debut"] < track.heure_fin:
listeAnomalies.append(
_(u"%s : L'unité multihoraires %s chevauche une consommation d'une unité identique"
) % (dateFr, nomUnite1))
valide = False
else:
listeAnomalies.append(
_(u"%s : Unité %s déjà présente") %
(dateFr, nomUnite1))
valide = False
# Vérifie si unité ouverte
IDgroupe = self.clsbase.GetValeur("IDgroupe")
if IDgroupe != None and self.dictOuvertures.has_key(
(dictConso["date"], dictConso["IDunite"], IDgroupe)) == False:
listeAnomalies.append(
_(u"%s : Unité %s fermée") %
(dateFr, self.dictUnites[dictConso["IDunite"]]["nom"]))
valide = False
# IDconso pour les modifications
if IDconso != None:
dictConso["IDconso"] = IDconso
# Insertion de la conso validée
if valide == True:
listeConsoFinale.append(dictConso)
nbreConsoValides += 1
index += 1
# Signalement des anomalies
if len(listeAnomalies):
message1 = _(
u"Les %d anomalies suivantes ont été trouvées.\n\nSouhaitez-vous tout de même générer les %d autres consommations ?"
) % (len(listeAnomalies), nbreConsoValides)
message2 = u"\n".join(listeAnomalies)
dlg = dialogs.MultiMessageDialog(self,
message1,
caption=_(u"Génération"),
msg2=message2,
style=wx.ICON_EXCLAMATION | wx.YES
| wx.CANCEL | wx.YES_DEFAULT,
btnLabels={
wx.ID_YES: _(u"Oui"),
wx.ID_CANCEL: _(u"Annuler")
})
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
if nbreConsoValides == 0:
dlg = wx.MessageDialog(
self, _(u"Il n'y a aucune consommation à générer !"),
_(u"Génération"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Demande de confirmation
if IDconso == None:
dlg = wx.MessageDialog(
self,
_(u"Confirmez-vous la génération de %d consommations ?") %
nbreConsoValides, _(u"Génération"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
return listeConsoFinale
def AjoutFactures(self, tracks=[]):
# Vérifie que cette facture n'est pas déjà présente dans le lot
listeFacturesPresentes = []
for track in self.GetObjects():
if track.IDfacture != None:
listeFacturesPresentes.append(track.IDfacture)
mandats = UTILS_Mandats.Mandats()
# MAJ de la liste affichée
dictTitulaires = UTILS_Titulaires.GetTitulaires()
listeNewTracks = []
listeMandatsNonValides = []
for track in tracks:
# Recherche un mandat valide pour la famille
IDmandat = mandats.RechercheMandatFamille(track.IDfamille)
if IDmandat == None:
if dictTitulaires.has_key(track.IDfamille):
nomTitulaires = dictTitulaires[
track.IDfamille]["titulairesSansCivilite"]
else:
nomTitulaires = _(u"Titulaires inconnus")
listeMandatsNonValides.append(
_(u"Famille %s (ID%d)") % (nomTitulaires, track.IDfamille))
else:
# Récupère les données du mandat
dictMandat = mandats.GetDictMandat(IDmandat)
IDbanque = dictMandat["IDbanque"]
iban = dictMandat["iban"]
bic = dictMandat["bic"]
IDmandat = dictMandat["IDmandat"]
mandat_rum = dictMandat["rum"]
mandat_date = dictMandat["date"]
titulaire = dictMandat["titulaire"]
# Recherche de la séquence
analyse = mandats.AnalyseMandat(IDmandat)
sequence = analyse["prochaineSequence"]
# Mémorisation du track
if track.IDfacture != None:
typeTrack = "facture"
libelle = _(u"FACT%s") % track.numero
else:
typeTrack = "manuel"
libelle = track.libelle
dictTemp = {
"IDprelevement": None,
"IDfamille": track.IDfamille,
"prelevement_banque": IDbanque,
"prelevement_iban": iban,
"prelevement_bic": bic,
"IDmandat": IDmandat,
"prelevement_reference_mandat": mandat_rum,
"prelevement_date_mandat": mandat_date,
"titulaire": titulaire,
"type": typeTrack,
"IDfacture": track.IDfacture,
"sequence": sequence,
"libelle": libelle,
"montant": -track.solde,
"statut": "attente",
"IDlot": self.IDlot,
"nomBanque": "",
"etat": "ajout",
"IDreglement": None,
"dateReglement": None,
"IDdepot": None,
"IDcompte_payeur": track.IDcompte_payeur,
}
if track.IDfacture not in listeFacturesPresentes:
listeNewTracks.append(Track(dictTemp, dictTitulaires))
if len(listeMandatsNonValides) > 0:
message1 = _(
u"Les prélèvements suivants n'ont pas été intégrés car les mandats SEPA des familles sont indisponibles ou non valides :"
)
message2 = "\n".join(listeMandatsNonValides)
dlg = dialogs.MultiMessageDialog(self,
message1,
caption=_(u"Avertissement"),
msg2=message2,
style=wx.ICON_EXCLAMATION | wx.OK,
icon=None,
btnLabels={wx.ID_OK: _(u"Ok")})
reponse = dlg.ShowModal()
dlg.Destroy()
self.AddObjects(listeNewTracks)
self.MAJtotaux()
def Generation(self):
# Récupération des paramètres
date_debut = self.ctrl_date_debut.GetDate()
date_fin = self.ctrl_date_fin.GetDate()
donneesPlanning = self.GetDonnees()
listePeriodes = copy.deepcopy(self.listePeriodes)
listeConso = []
for dictPlanning in donneesPlanning:
# Recherche des dates
listeDates = []
date = date_debut
semaines = dictPlanning["semaines"]
numSemaine = copy.copy(semaines)
dateTemp = date
while date < (date_fin + datetime.timedelta(days=1)):
# Vérifie période et jour
valide = False
if self.EstEnVacances(date):
if date.weekday() in dictPlanning["jours_vacances"]:
valide = True
else:
if date.weekday() in dictPlanning["jours_scolaires"]:
valide = True
# Vérifie si férié
if dictPlanning["feries"] == False and self.EstFerie(
date) == True:
valide = False
# Calcul le numéro de semaine
if len(listeDates) > 0:
if date.weekday() < dateTemp.weekday():
numSemaine += 1
# Fréquence semaines
if semaines in (2, 3, 4):
if numSemaine % semaines != 0:
valide = False
# Semaines paires et impaires
if valide == True and semaines in (5, 6):
numSemaineAnnee = date.isocalendar()[1]
if numSemaineAnnee % 2 == 0 and semaines == 6:
valide = False
if numSemaineAnnee % 2 != 0 and semaines == 5:
valide = False
# Ajout de la date à la liste
if valide == True:
listeDates.append(date)
dateTemp = date
date += datetime.timedelta(days=1)
# Mémorisation des consommations
for date in listeDates:
for dictUnite in dictPlanning["unites"]:
IDunite = dictUnite["IDunite"]
options = dictUnite["options"]
if options.has_key("heure_debut"):
heure_debut = options["heure_debut"]
else:
heure_debut = self.dictUnites[IDunite]["heure_debut"]
if options.has_key("heure_fin"):
heure_fin = options["heure_fin"]
else:
heure_fin = self.dictUnites[IDunite]["heure_fin"]
if options.has_key("quantite"):
quantite = options["quantite"]
else:
quantite = None
dictConso = {
"IDconso": None,
"date": date,
"IDunite": IDunite,
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"quantite": quantite,
"etat": "reservation",
}
listeConso.append(dictConso)
# Insertion des conso à générer dans la liste des périodes
listeAnomalies = []
nbreConsoValides = 0
for dictConso in listeConso:
# Recherche de la période à associer
index = 0
for dictPeriode in listePeriodes:
if dictConso["date"] >= dictPeriode["date_debut"] and dictConso[
"date"] <= dictPeriode["date_fin"]:
dateFr = UTILS_Dates.DateDDEnFr(dictConso["date"])
valide = True
# Recherche si pas d'incompatibilités avec les conso déjà saisies
for dictConsoTemp in dictPeriode["listeConso"]:
if dictConso["date"] == dictConsoTemp["date"]:
nomUnite1 = self.dictUnites[
dictConso["IDunite"]]["nom"]
nomUnite2 = self.dictUnites[
dictConsoTemp["IDunite"]]["nom"]
if self.VerifieCompatibilitesUnites(
dictConsoTemp["IDunite"],
dictConso["IDunite"]) == False:
listeAnomalies.append(
_(u"%s : Unité %s incompatible avec unité %s déjà présente"
) % (dateFr, nomUnite1, nomUnite2))
valide = False
if dictConso["IDunite"] == dictConsoTemp[
"IDunite"]:
if self.dictUnites[dictConso["IDunite"]][
"type"] == "Multihoraire":
if dictConso["heure_fin"] > dictConsoTemp[
"heure_debut"] and dictConso[
"heure_debut"] < dictConsoTemp[
"heure_fin"]:
listeAnomalies.append(
_(u"%s : L'unité multihoraires %s chevauche une consommation d'une unité identique"
) % (dateFr, nomUnite1))
valide = False
else:
listeAnomalies.append(
_(u"%s : Unité %s déjà présente") %
(dateFr, nomUnite1))
valide = False
# Vérifie si unité ouverte
if self.IDgroupe != None and self.dictOuvertures.has_key(
(dictConso["date"], dictConso["IDunite"],
self.IDgroupe)) == False:
listeAnomalies.append(
_(u"%s : Unité %s fermée") %
(dateFr,
self.dictUnites[dictConso["IDunite"]]["nom"]))
valide = False
# Insertion de la conso validée dans la période
if valide == True:
listePeriodes[index]["listeConso"].append(dictConso)
nbreConsoValides += 1
index += 1
# Signalement des anomalies
if len(listeAnomalies):
message1 = _(
u"Les %d anomalies suivantes ont été trouvées.\n\nSouhaitez-vous tout de même générer les %d autres consommations ?"
) % (len(listeAnomalies), nbreConsoValides)
message2 = u"\n".join(listeAnomalies)
dlg = dialogs.MultiMessageDialog(self,
message1,
caption=_(u"Génération"),
msg2=message2,
style=wx.ICON_EXCLAMATION | wx.YES
| wx.CANCEL | wx.YES_DEFAULT,
btnLabels={
wx.ID_YES: _(u"Oui"),
wx.ID_CANCEL: _(u"Annuler")
})
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
if nbreConsoValides == 0:
dlg = wx.MessageDialog(
self, _(u"Il n'y a aucune consommation valide à générer !"),
_(u"Génération"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Demande de confirmation
dlg = wx.MessageDialog(
self,
_(u"Confirmez-vous la génération de %d consommations ?") %
nbreConsoValides, _(u"Génération"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
self.listePeriodes = listePeriodes
return True
