def GetUtilisateur(self):
IDutilisateur = UTILS_Identification.GetIDutilisateur()
if IDutilisateur != None:
dictUtilisateur = UTILS_Identification.GetAutreDictUtilisateur(
IDutilisateur)
if dictUtilisateur != None:
nomUtilisateur = u"%s %s" % (dictUtilisateur["nom"],
dictUtilisateur["prenom"])
else:
nomUtilisateur = u"n°%d" % self.IDutilisateur
else:
nomUtilisateur = _(u"Utilisateur inconnu")
return IDutilisateur, nomUtilisateur
def Sauvegarde(self):
""" Sauvegarde """
# Récupération des données
IDcategorie = self.ctrl_categorie.GetID()
texte = self.ctrl_texte.GetValue()
if self.ctrl_priorite.GetSelection() == 1 :
priorite = "HAUTE"
else:
priorite = "NORMALE"
afficher_accueil = int(self.ctrl_afficher_accueil.GetValue())
afficher_liste = int(self.ctrl_afficher_liste.GetValue())
afficher_factures = int(self.ctrl_afficher_factures.GetValue())
rappel = int(self.ctrl_rappel.GetValue())
date_parution = self.ctrl_parution.GetDate()
if self.mode == "famille" and self.nom == None : self.nom = self.GetNomFamille()
if self.mode == "individu" and self.nom == None : self.nom = self.GetNomIndividu()
IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Sauvegarde
DB = GestionDB.DB()
listeDonnees = [
("type", "INSTANTANE"),
("IDcategorie", IDcategorie),
("date_saisie", self.date_saisie),
("IDutilisateur", IDutilisateur),
("date_parution", date_parution),
("priorite", priorite),
("afficher_accueil", afficher_accueil),
("afficher_liste", afficher_liste),
("rappel", rappel),
("IDfamille", self.IDfamille),
("IDindividu", self.IDindividu),
("nom", self.nom),
("texte", texte),
("afficher_facture", afficher_factures),
]
if self.IDmessage == None :
nouveauMessage = True
self.IDmessage = DB.ReqInsert("messages", listeDonnees)
else:
nouveauMessage = False
DB.ReqMAJ("messages", listeDonnees, "IDmessage", self.IDmessage)
DB.Close()
# Mémorise l'action dans l'historique
if nouveauMessage == True :
type = _(u"Saisie")
IDcategorie = 24
else:
type = _(u"Modification")
IDcategorie = 25
if len(texte) > 450 : texte = texte[450:] + u"..."
UTILS_Historique.InsertActions([{
"IDindividu" : self.IDindividu,
"IDfamille" : self.IDfamille,
"IDcategorie" : IDcategorie,
"action" : _(u"%s du message ID%d : '%s'") % (type, self.IDmessage, texte)
},])
def MAJ_signataires(self):
ancienneValeur = None
propriete = self.GetPropertyByName("signataire")
index = propriete.GetValue()
if index != None and index in self.dictDonnees["signataires"]:
ancienneValeur = self.dictDonnees["signataires"][index]["ID"]
if len(self.listeActivites) == 0: conditionActivites = "()"
elif len(self.listeActivites) == 1:
conditionActivites = "(%d)" % self.listeActivites[0]
else:
conditionActivites = str(tuple(self.listeActivites))
DB = GestionDB.DB()
req = """SELECT IDresponsable, IDactivite, nom, fonction, defaut, sexe
FROM responsables_activite
WHERE IDactivite IN %s
ORDER BY nom;""" % conditionActivites
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
self.dictDonnees["signataires"] = {}
choix = wxpg.PGChoices()
selectionDefaut = None
index = 0
for IDresponsable, IDactivite, nom, fonction, defaut, sexe in listeDonnees:
self.dictDonnees["signataires"][index] = {
"ID": IDresponsable,
"IDactivite": IDactivite,
"nom": nom,
"fonction": fonction,
"defaut": defaut,
"sexe": sexe
}
if 'phoenix' in wx.PlatformInfo:
choix.Add(label=nom, value=index)
else:
choix.Add(nom, index)
if defaut == 1:
selectionDefaut = index
index += 1
propriete.SetChoices(choix)
self.RefreshProperty(propriete)
if selectionDefaut != None:
propriete.SetValue(selectionDefaut)
# Recherche le nom de l'utilisateur parmi la liste des signataires
dictUtilisateur = UTILS_Identification.GetDictUtilisateur()
for index, dictDonnees in self.dictDonnees["signataires"].items():
if ancienneValeur == dictDonnees["ID"]:
propriete.SetValue(index)
break
if dictUtilisateur != None:
texte1 = u"%s %s" % (dictUtilisateur["prenom"],
dictUtilisateur["nom"])
texte2 = u"%s %s" % (dictUtilisateur["nom"],
dictUtilisateur["prenom"])
if dictDonnees["nom"].lower() == texte1.lower(
) or dictDonnees["nom"].lower() == texte2.lower():
propriete.SetValue(index)
def VerificationConditions(self, dictSauvegarde={}):
""" Vérifie si conditions de la procédure sont valides """
jours_scolaires = dictSauvegarde["condition_jours_scolaires"]
jours_vacances = dictSauvegarde["condition_jours_vacances"]
heures = dictSauvegarde["condition_heure"]
poste = dictSauvegarde["condition_poste"]
derniere = dictSauvegarde["condition_derniere"]
utilisateur = dictSauvegarde["condition_utilisateur"]
dateDuJour = datetime.date.today()
# Jour
if jours_scolaires != None or jours_vacances != None:
jours_scolaires = ConvertChaineEnListe(jours_scolaires)
jours_vacances = ConvertChaineEnListe(jours_vacances)
valide = False
if jours_scolaires != None:
if self.EstEnVacances(dateDuJour) == False:
if dateDuJour.weekday() in jours_scolaires:
valide = True
if jours_vacances != None:
if self.EstEnVacances(dateDuJour) == True:
if dateDuJour.weekday() in jours_vacances:
valide = True
if valide == False:
return False
# Heure
if heures != None:
heureActuelle = time.strftime('%H:%M', time.localtime())
heure_min, heure_max = heures.split(";")
if heureActuelle < heure_min or heureActuelle > heure_max:
return False
# Poste
if poste != None:
listePostes = poste.split(";")
if socket.gethostname() not in listePostes:
return False
# Dernière sauvegarde
if derniere != None:
date_derniere = dictSauvegarde["date_derniere"]
if date_derniere != None:
date_derniere = UTILS_Dates.DateEngEnDateDD(date_derniere)
nbreJours = (dateDuJour - date_derniere).days
if nbreJours < int(derniere):
return False
# Utilisateur
if utilisateur != None:
listeUtilisateurs = ConvertChaineEnListe(utilisateur)
IDutilisateur = UTILS_Identification.GetIDutilisateur()
if IDutilisateur not in listeUtilisateurs:
return False
return True
def InsertActions(listeActions=[], DB=None):
""" dictAction = { IDutilisateur : None, IDfamille : None, IDindividu : None, IDcategorie : None, action : u"" } """
date = str(datetime.date.today())
heure = "%02d:%02d:%02d" % (datetime.datetime.now().hour, datetime.datetime.now().minute, datetime.datetime.now().second)
# Traitement des actions
listeAjouts = []
for dictAction in listeActions :
if "IDutilisateur" in dictAction :
IDutilisateur = dictAction["IDutilisateur"]
else :
IDutilisateur = UTILS_Identification.GetIDutilisateur()
if "IDfamille" in dictAction :
IDfamille = dictAction["IDfamille"]
else :
IDfamille = None
if "IDindividu" in dictAction :
IDindividu = dictAction["IDindividu"]
else :
IDindividu = None
if "IDcategorie" in dictAction :
IDcategorie = dictAction["IDcategorie"]
else :
IDcategorie = None
if "action" in dictAction :
action = dictAction["action"]
else :
action = u""
if len(action) >= 500 :
action = action[:495] + "..." # Texte limité à 499 caractères
listeAjouts.append((date, heure, IDutilisateur, IDfamille, IDindividu, IDcategorie, action))
# Enregistrement dans la base
if len(listeAjouts) > 0 :
req = u"INSERT INTO historique (date, heure, IDutilisateur, IDfamille, IDindividu, IDcategorie, action) VALUES (?, ?, ?, ?, ?, ?, ?)"
if DB == None :
DB = GestionDB.DB()
DB.Executermany(req, listeAjouts, commit=False)
DB.Commit()
DB.Close()
else :
DB.Executermany(req, listeAjouts, commit=False)
##if __name__ == '__main__':
## Start()
def GetChampsStandards():
dictTemp = {}
# Utilisateur en cours
dictUtilisateur = UTILS_Identification.GetDictUtilisateur()
if dictUtilisateur != None:
dictTemp["{UTILISATEUR_NOM_COMPLET}"] = u"%s %s" % (
dictUtilisateur["nom"], dictUtilisateur["prenom"])
dictTemp["{UTILISATEUR_NOM}"] = dictUtilisateur["nom"]
dictTemp["{UTILISATEUR_PRENOM}"] = dictUtilisateur["prenom"]
# Dates
dictTemp["{DATE_COURTE}"] = DateEngFr(str(datetime.date.today()))
dictTemp["{DATE_LONGUE}"] = DateComplete(datetime.date.today())
return dictTemp
def MAJ(self, listeActivites=[] ):
listeItems, indexDefaut = self.GetListeDonnees()
if len(listeItems) == 0 :
self.Enable(False)
else:
self.Enable(True)
self.SetItems(listeItems)
if indexDefaut != None :
self.Select(indexDefaut)
# Recherche le nom de l'utilisateur parmi la liste des signataires
dictUtilisateur = UTILS_Identification.GetDictUtilisateur()
for index, dictDonnees in self.dictDonnees.iteritems() :
if dictUtilisateur != None :
texte1 = u"%s %s" % (dictUtilisateur["prenom"], dictUtilisateur["nom"])
texte2 = u"%s %s" % (dictUtilisateur["nom"], dictUtilisateur["prenom"])
if dictDonnees["nom"].lower() == texte1.lower() or dictDonnees["nom"].lower() == texte2.lower() :
self.SetSelection(index)
def InsertActions(listeActions=[], DB=None):
""" dictAction = { IDutilisateur : None, IDfamille : None, IDindividu : None, IDcategorie : None, action : u"", IDdonnee: None } """
date = str(datetime.date.today())
heure = "%02d:%02d:%02d" % (datetime.datetime.now().hour,
datetime.datetime.now().minute,
datetime.datetime.now().second)
# Traitement des actions
listeAjouts = []
for dictAction in listeActions:
IDutilisateur = dictAction.get("IDutilisateur",
UTILS_Identification.GetIDutilisateur())
IDfamille = dictAction.get("IDfamille", None)
IDindividu = dictAction.get("IDindividu", None)
IDcategorie = dictAction.get("IDcategorie", None)
action = dictAction.get("action", u"")
if len(action) >= 500:
action = action[:495] + "..." # Texte limité à 499 caractères
IDdonnee = dictAction.get("IDdonnee", None)
listeAjouts.append((date, heure, IDutilisateur, IDfamille, IDindividu,
IDcategorie, action, IDdonnee))
# Enregistrement dans la base
if len(listeAjouts) > 0:
req = u"INSERT INTO historique (date, heure, IDutilisateur, IDfamille, IDindividu, IDcategorie, action, IDdonnee) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
if DB == None:
DB = GestionDB.DB()
try:
DB.Executermany(req, listeAjouts, commit=False)
except:
req = u"INSERT INTO historique (date, heure, IDutilisateur, IDfamille, IDindividu, IDcategorie, action) VALUES (?, ?, ?, ?, ?, ?, ?)"
DB.Executermany(req, listeAjouts[:-1], commit=False)
DB.Commit()
DB.Close()
else:
DB.Executermany(req, listeAjouts, commit=False)
DB.Commit()
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"RECU_REGLEMENT", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_edition = dictDonnees["date"]
try:
date_editionDD = DateEngEnDateDD(DateFrEng(date_edition))
except:
date_editionDD = ""
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille": self.IDfamille,
"{IDFAMILLE}": str(self.IDfamille),
"num_recu": dictDonnees["numero"],
"{DATE_EDITION}": dictDonnees["date"],
"{LIEU_EDITION}": dictDonnees["lieu"],
"{DESTINATAIRE_NOM}": dictDonnees["nom"],
"{DESTINATAIRE_RUE}": dictDonnees["rue"],
"{DESTINATAIRE_VILLE}": dictDonnees["ville"],
"{NUM_RECU}": dictDonnees["numero"],
"{DATE_EDITION}": date_edition,
"{DATE_EDITION_LONG}": DateComplete(date_editionDD),
"{DATE_EDITION_COURT}": date_edition,
"{ORGANISATEUR_NOM}": dictOrganisme["nom"],
"{ORGANISATEUR_RUE}": dictOrganisme["rue"],
"{ORGANISATEUR_CP}": dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}": dictOrganisme["ville"],
"{ORGANISATEUR_TEL}": dictOrganisme["tel"],
"{ORGANISATEUR_FAX}": dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}": dictOrganisme["mail"],
"{ORGANISATEUR_SITE}": dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}": dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}": dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}": dictOrganisme["code_ape"],
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{GENRE}", genreSignataire)
textIntro = textIntro.replace("{NOM}", nomSignataire)
textIntro = textIntro.replace("{FONCTION}", fonctionSignataire)
textIntro = textIntro.replace("{FAMILLE}", dictDonnees["nom"])
textIntro = textIntro.replace(
"{MONTANT}",
u"<b>%.2f %s</b>" % (self.dictReglement["montant"], SYMBOLE))
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Envoi des informations sur le règlement
for key, valeur in self.dictReglement.iteritems():
dictValeurs[key] = valeur
dictValeurs["{IDREGLEMENT}"] = str(dictValeurs["IDreglement"])
dictValeurs["{DATE_REGLEMENT}"] = DateEngFr(
dictValeurs["dateReglement"])
dictValeurs["{MODE_REGLEMENT}"] = dictValeurs["nomMode"]
if dictValeurs["nomEmetteur"] != None:
dictValeurs["{NOM_EMETTEUR}"] = dictValeurs["nomEmetteur"]
else:
dictValeurs["{NOM_EMETTEUR}"] = ""
dictValeurs["{NUM_PIECE}"] = dictValeurs["numPiece"]
dictValeurs["{MONTANT_REGLEMENT}"] = u"%.2f %s" % (
dictValeurs["montant"], SYMBOLE)
dictValeurs["{NOM_PAYEUR}"] = dictValeurs["nomPayeur"]
dictValeurs["{NUM_QUITTANCIER}"] = str(dictValeurs["numQuittancier"])
dictValeurs["{DATE_SAISIE}"] = DateEngFr(dictValeurs["date_saisie"])
dictValeurs["{OBSERVATIONS}"] = u"%s" % dictValeurs["observations"]
# Récupération liste des prestations
if self.ctrl_prestations.GetValue() == True:
dictValeurs["prestations"] = self.GetPrestations()
else:
dictValeurs["prestations"] = []
# Préparation des données pour une sauvegarde de l'attestation
self.dictSave = {}
self.dictSave["numero"] = dictDonnees["numero"]
self.dictSave["IDfamille"] = self.IDfamille
self.dictSave["date_edition"] = DateFrEng(dictDonnees["date"])
self.dictSave["IDutilisateur"] = UTILS_Identification.GetIDutilisateur(
)
self.dictSave["IDreglement"] = self.IDreglement
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
dictChampsFusion["{DATE_EDITION_RECU}"] = DateFrEng(
dictDonnees["date"])
dictChampsFusion["{NUMERO_RECU}"] = dictDonnees["numero"]
dictChampsFusion["{ID_REGLEMENT}"] = str(dictValeurs["{IDREGLEMENT}"])
dictChampsFusion["{DATE_REGLEMENT}"] = dictValeurs["{DATE_REGLEMENT}"]
dictChampsFusion["{MODE_REGLEMENT}"] = dictValeurs["{MODE_REGLEMENT}"]
dictChampsFusion["{NOM_EMETTEUR}"] = dictValeurs["{NOM_EMETTEUR}"]
dictChampsFusion["{NUM_PIECE}"] = dictValeurs["{NUM_PIECE}"]
dictChampsFusion["{MONTANT_REGLEMENT}"] = dictValeurs[
"{MONTANT_REGLEMENT}"]
dictChampsFusion["{NOM_PAYEUR}"] = dictValeurs["{NOM_PAYEUR}"]
dictChampsFusion["{NUM_QUITTANCIER}"] = dictValeurs[
"{NUM_QUITTANCIER}"]
dictChampsFusion["{DATE_SAISIE}"] = dictValeurs["{DATE_SAISIE}"]
# Fabrication du PDF
from Utils import UTILS_Impression_recu
UTILS_Impression_recu.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
def OnBoutonOk(self, event):
montant = self.ctrl_montant.GetMontant()
if montant == 0.0:
dlg = wx.MessageDialog(
self, _(u"Vous devez obligatoirement saisir un montant !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
if montant < 0.0:
dlg = wx.MessageDialog(
self, _(u"Le montant doit obligatoirement être positif !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
if self.solde != None and FloatToDecimal(montant) > FloatToDecimal(
self.solde):
dlg = wx.MessageDialog(
self,
_(u"Le montant du remboursement ne doit pas être supérieur au solde du compte !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_montant.SetFocus()
return
IDcompte = self.ctrl_compte.GetID()
if IDcompte == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un compte bancaire !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_compte.SetFocus()
IDpayeur = self.ctrl_payeur.GetID()
if IDpayeur == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un payeur !"),
_(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_payeur.SetFocus()
IDmode = self.ctrl_mode.GetID()
if IDmode == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un mode de règlement !"
), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_mode.SetFocus()
return
observations = self.ctrl_observations.GetValue()
DB = GestionDB.DB()
# Récupère IDfamille
req = """SELECT IDfamille
FROM comptes_payeurs
WHERE IDcompte_payeur=%d
""" % self.IDcompte_payeur
DB.ExecuterReq(req)
IDfamille = DB.ResultatReq()[0][0]
# Enregistrement de la prestation positive
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur),
("date", str(datetime.date.today())),
("categorie", "autre"),
("label", _(u"Remboursement")),
("montant_initial", montant),
("montant", montant),
("IDfamille", IDfamille),
("date_valeur", str(datetime.date.today())),
]
IDprestation_positive = DB.ReqInsert("prestations", listeDonnees)
# Ventiler la prestation positive avec l'avoir
VentilationAuto(self.IDcompte_payeur)
# Enregistrement de la prestation négative
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur),
("date", str(datetime.date.today())),
("categorie", "autre"),
("label", _(u"Remboursement")),
("montant_initial", -montant),
("montant", -montant),
("IDfamille", IDfamille),
("date_valeur", str(datetime.date.today())),
]
IDprestation_negative = DB.ReqInsert("prestations", listeDonnees)
# Enregistrement du règlement négatif
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur),
("date", str(datetime.date.today())),
("IDmode", IDmode),
("montant", -montant),
("IDpayeur", IDpayeur),
("observations", observations),
("IDcompte", IDcompte),
("date_saisie", str(datetime.date.today())),
("IDutilisateur", UTILS_Identification.GetIDutilisateur()),
]
IDreglement = DB.ReqInsert("reglements", listeDonnees)
# Ventilation de la prestation négative sur le règlement
listeDonnees = [
("IDreglement", IDreglement),
("IDcompte_payeur", self.IDcompte_payeur),
("IDprestation", IDprestation_negative),
("montant", -montant),
]
IDventilation = DB.ReqInsert("ventilation", listeDonnees)
DB.Close()
# Fermeture
self.EndModal(wx.ID_OK)
def SauvegardeFactures(self):
""" Sauvegarde des factures """
# Récupère Utilisateur en cours
IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Génération des factures
listeFacturesGenerees = []
# Tri par ordre alphabétique de la liste
listeComptes = []
for track in self.ctrl_factures.GetTracksCoches() :
listeComptes.append((track.nomSansCivilite, track.IDcompte_payeur))
listeComptes.sort()
# ProgressBar
dlgProgress = wx.ProgressDialog(_(u"Génération des factures"), _(u"Initialisation..."), maximum=len(listeComptes), parent=None, style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL)
# Sélection du prochain numéro de facture
numero = self.parent.dictParametres["prochain_numero"]
IDprefixe = self.parent.dictParametres["IDprefixe"]
if numero == None :
# Recherche du prochain numéro de facture si mode AUTO
if IDprefixe == None :
conditions = "WHERE IDprefixe IS NULL"
else :
conditions = "WHERE IDprefixe=%d" % IDprefixe
DB = GestionDB.DB()
req = """SELECT MAX(numero)
FROM factures
%s;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if listeDonnees[0][0] == None :
numero = 1
else:
numero = listeDonnees[0][0] + 1
# Sauvegarde
DB = GestionDB.DB()
try :
index = 0
for nomTitulaires, IDcompte_payeur in listeComptes :
dictCompte = self.ctrl_factures.dictComptes[IDcompte_payeur]
texte = _(u"Génération de la facture %d sur %d...") % (index+1, len(listeComptes))
self.EcritStatusbar(texte)
dlgProgress.Update(index+1, texte)
listePrestations = dictCompte["listePrestations"]
total = dictCompte["total"]
regle = dictCompte["ventilation"]
solde = total - regle
# Date échéance
date_echeance = dictCompte["date_echeance"]
# Liste des activités
texteActivites = ""
for IDactivite in dictCompte["liste_activites"] :
texteActivites += "%d;" % IDactivite
if len(dictCompte["liste_activites"]) > 0 :
texteActivites = texteActivites[:-1]
# Liste des individus
texteIndividus = ""
for IDindividu in list(dictCompte["individus"].keys()) :
texteIndividus += "%d;" % IDindividu
if len(list(dictCompte["individus"].keys())) > 0 :
texteIndividus = texteIndividus[:-1]
# Sauvegarde de la facture
listeDonnees = [
("IDprefixe", IDprefixe),
("numero", numero),
("IDcompte_payeur", IDcompte_payeur),
("date_edition", str(datetime.date.today())),
("date_echeance", date_echeance),
("activites", texteActivites),
("individus", texteIndividus),
("IDutilisateur", IDutilisateur),
("date_debut", str(dictCompte["date_debut"])),
("date_fin", str(dictCompte["date_fin"])),
("total", float(total)),
("regle", float(regle)),
("solde", float(solde)),
("IDlot", self.parent.dictParametres["IDlot"]),
("prestations", ";".join(self.parent.dictParametres["prestations"])),
("IDregie", self.parent.dictParametres["IDregie"]),
("mention1", self.parent.dictParametres["mention1"]),
("mention2", self.parent.dictParametres["mention2"]),
("mention3", self.parent.dictParametres["mention3"]),
]
IDfacture = DB.ReqInsert("factures", listeDonnees)
# Attribution des IDfacture à chaque prestation
for IDindividu, IDprestation in listePrestations :
if dictCompte["individus"][IDindividu]["select"] == True :
listeDonnees = [ ("IDfacture", IDfacture ), ]
DB.ReqMAJ("prestations", listeDonnees, "IDprestation", IDprestation)
listeFacturesGenerees.append(IDfacture)
numero += 1
index += 1
DB.Close()
self.EcritStatusbar(u"")
dlgProgress.Destroy()
except Exception as err:
DB.Close()
dlgProgress.Destroy()
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(self, _(u"Désolé, le problème suivant a été rencontré : \n\n%s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
self.EcritStatusbar(u"")
return False
self.EcritStatusbar(u"")
return listeFacturesGenerees
def Sauvegarder(self):
""" Sauvegarde des attestations """
# Demande la confirmation de sauvegarde
dlg = wx.MessageDialog(
self,
_(u"Souhaitez-vous mémoriser les attestations ?\n\n(Cliquez NON si c'était juste un test sinon cliquez OUI)"
), _(u"Sauvegarde"),
wx.YES_NO | wx.YES_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return
dlgAttente = wx.BusyInfo(_(u"Sauvegarde des attestations en cours..."),
None)
if 'phoenix' not in wx.PlatformInfo:
wx.Yield()
DB = GestionDB.DB()
try:
for IDcompte_payeur, dictCompte in self.donnees.items():
if dictCompte["select"] == True:
numero = dictCompte["num_attestation"]
IDfamille = dictCompte["IDfamille"]
listePrestations = dictCompte["listePrestations"]
total = dictCompte["total"]
regle = dictCompte["ventilation"]
solde = total - regle
# Liste des activités
texteActivites = ""
for IDactivite in self.listeActivites:
texteActivites += "%d;" % IDactivite
if len(self.listeActivites) > 0:
texteActivites = texteActivites[:-1]
# Liste des individus
texteIndividus = ""
for IDindividu in list(dictCompte["individus"].keys()):
texteIndividus += "%d;" % IDindividu
if len(list(dictCompte["individus"].keys())) > 0:
texteIndividus = texteIndividus[:-1]
IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Sauvegarde de la facture
listeDonnees = [
("numero", numero),
("IDfamille", IDfamille),
("date_edition", str(datetime.date.today())),
("activites", texteActivites),
("individus", texteIndividus),
("IDutilisateur", IDutilisateur),
("date_debut", str(self.date_debut)),
("date_fin", str(self.date_fin)),
("total", float(total)),
("regle", float(regle)),
("solde", float(solde)),
]
IDattestation = DB.ReqInsert("attestations", listeDonnees)
# Mémorisation de l'action dans l'historique
UTILS_Historique.InsertActions([
{
"IDfamille":
IDfamille,
"IDcategorie":
27,
"action":
_(u"Edition d'une attestation de présence pour la période du %s au %s pour un total de %.02f ¤ et un solde de %.02f ¤"
) %
(DateEngFr(str(self.date_debut)),
DateEngFr(str(self.date_fin)), total, solde),
},
])
DB.Close()
del dlgAttente
except Exception as err:
DB.Close()
del dlgAttente
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(
self,
_(u"Désolé, le problème suivant a été rencontré dans la sauvegarde des attestations : \n\n%s"
) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
# Mémorisation des paramètres
self.ctrl_parametres.MemoriserParametres()
def Sauvegarde(self):
""" Sauvegarde des données """
nom = self.ctrl_nom.GetValue()
if self.mode_modele == True and nom == "" :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement renseigner le nom du modèle !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_nom.SetFocus()
return False
date_debut = self.ctrl_date_debut.GetDate()
if date_debut == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement renseigner la date de début !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_debut.SetFocus()
return False
date_fin = self.ctrl_date_fin.GetDate()
if date_fin == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement renseigner la date de fin !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
self.ctrl_date_fin.SetFocus()
return False
if date_fin < date_debut :
dlg = wx.MessageDialog(self, _(u"La date de début ne doit pas être supérieure à la date de fin !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
IDtarif = self.ctrl_tarif.GetID()
if IDtarif == None :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner un tarif dans la liste proposée !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
observations = self.ctrl_observations.GetValue()
IDtarif = self.ctrl_tarif.GetID()
listePeriodes = self.ctrl_periodes.GetDonnees()
if len(listePeriodes) == 0 :
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir au moins une période !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérifie que les périodes sont bien dans la période de validité du contrat
for dictPeriode in listePeriodes :
if dictPeriode["date_debut"] < date_debut :
dlg = wx.MessageDialog(self, _(u"La période '%s' comporte une date de début antérieure à la date de début du contrat !") % dictPeriode["label_prestation"], _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
if dictPeriode["date_fin"] > date_fin :
dlg = wx.MessageDialog(self, _(u"La période '%s' comporte une date de fin supérieure à la date de fin du contrat !") % dictPeriode["label_prestation"], _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérifie que les consommations sont bien enregistrables
if self.mode_modele == False :
if self.VerifieConsommations(listePeriodes) == False :
return False
# ------------- SAUVEGARDE -------------------------------------------------------------------------------------------------------------------
if self.mode_modele == True :
# Sauvegarde du modèle de contrat
donneesStr = cPickle.dumps(listePeriodes)
DB = GestionDB.DB()
listeDonnees = [
("nom", nom ),
("IDactivite", self.IDactivite),
("date_debut", date_debut),
("date_fin", date_fin ),
("observations", observations),
("IDtarif", IDtarif),
]
if self.IDmodele == None :
self.IDmodele = DB.ReqInsert("modeles_contrats", listeDonnees)
else :
DB.ReqMAJ("modeles_contrats", listeDonnees, "IDmodele", self.IDmodele)
# Sauvegarde des données BLOB
DB.MAJimage(table="modeles_contrats", key="IDmodele", IDkey=self.IDmodele, blobImage=donneesStr, nomChampBlob="donnees")
DB.Close()
# --------------------------------------------------------------------------------------------------------------------------------
else :
# Sauvegarde du contrat
DB = GestionDB.DB()
# Sauvegarde des contrats
listeDonnees = [
("IDinscription", self.IDinscription ),
("IDindividu", self.IDindividu ),
("date_debut", date_debut ),
("date_fin", date_fin ),
("observations", observations),
("IDtarif", IDtarif),
]
if self.IDcontrat == None :
self.IDcontrat = DB.ReqInsert("contrats", listeDonnees)
else :
DB.ReqMAJ("contrats", listeDonnees, "IDcontrat", self.IDcontrat)
# Sauvegarde des périodes du contrat
listeID = []
index = 0
for dictPeriode in listePeriodes :
IDprestation = dictPeriode["IDprestation"]
# Sauvegarde de la prestation
listeDonnees = [
("IDcompte_payeur", self.IDcompte_payeur ),
("date", dictPeriode["date_prestation"] ),
("categorie", "consommation" ),
("label", dictPeriode["label_prestation"]),
("montant_initial", dictPeriode["montant_prestation"]),
("montant", dictPeriode["montant_prestation"]),
("IDactivite", self.IDactivite),
("IDtarif", IDtarif),
("IDfamille", self.IDfamille),
("IDindividu", self.IDindividu),
("IDcategorie_tarif", self.IDcategorie_tarif),
("forfait_date_debut", dictPeriode["date_debut"]),
("forfait_date_fin", dictPeriode["date_fin"]),
("IDcontrat", self.IDcontrat),
]
if IDprestation == None :
listeDonnees.append(("date_valeur", str(datetime.date.today())))
IDprestation = DB.ReqInsert("prestations", listeDonnees)
else :
DB.ReqMAJ("prestations", listeDonnees, "IDprestation", IDprestation)
listeID.append(IDprestation)
listePeriodes[index]["IDprestation"] = IDprestation
index += 1
# Suppression des périodes supprimées
for dictPeriode in self.listePeriodesInitiale :
if dictPeriode["IDprestation"] not in listeID and dictPeriode["IDprestation"] != None :
DB.ReqDEL("prestations", "IDprestation", dictPeriode["IDprestation"])
DB.ReqMAJ("consommations", [("IDprestation", None),], "IDprestation", dictPeriode["IDprestation"])
# Suppression des conso supprimées
for IDconso in self.listeSuppressionConso :
if IDconso != None :
DB.ReqDEL("consommations", "IDconso", IDconso)
# Saisie des consommations générées
listeAjouts = []
for dictPeriode in listePeriodes :
listeConso = dictPeriode["listeConso"]
for dictConso in listeConso :
if dictConso["IDconso"] == None :
dictConsoTemp = {
"IDindividu" : self.IDindividu,
"IDinscription" : self.IDinscription,
"IDactivite" : self.IDactivite,
"date" : dictConso["date"],
"IDunite" : dictConso["IDunite"],
"IDgroupe" : self.IDgroupe,
"heure_debut" : dictConso["heure_debut"],
"heure_fin" : dictConso["heure_fin"],
"etat" : dictConso["etat"],
"verrouillage" : 0,
"date_saisie" : datetime.date.today(),
"IDutilisateur" : UTILS_Identification.GetIDutilisateur(),
"IDcategorie_tarif" : self.IDcategorie_tarif,
"IDcompte_payeur" : self.IDcompte_payeur,
"IDprestation" : dictPeriode["IDprestation"],
"forfait" : None,
"quantite" : dictConso["quantite"],
}
listeAjouts.append(dictConsoTemp)
if len(listeAjouts) > 0 :
listeChamps = list(listeAjouts[0].keys())
listeDonnees = []
listeInterrogations = []
for champ in listeChamps :
listeInterrogations.append("?")
for dictConso in listeAjouts :
listeTemp = []
for champ in listeChamps :
listeTemp.append(dictConso[champ])
listeDonnees.append(listeTemp)
DB.Executermany("INSERT INTO consommations (%s) VALUES (%s)" % (", ".join(listeChamps), ", ".join(listeInterrogations)), listeDonnees, commit=True)
DB.Close()
def __init__(self,
parent,
IDcotisation=None,
IDfamille=None,
IDindividu=None,
dictFamillesRattachees={}):
wx.Dialog.__init__(self,
parent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
| wx.THICK_FRAME)
self.parent = parent
self.IDcotisation = IDcotisation
self.IDfamille = IDfamille
self.IDindividu = IDindividu
self.dictFamillesRattachees = dictFamillesRattachees
# Variables pour importation
self.IDprestation = None
self.date_saisie = datetime.date.today()
self.IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Cotisation
self.staticbox_cotisation_staticbox = wx.StaticBox(
self, -1, _(u"Cotisation"))
self.label_type = wx.StaticText(self, -1, _(u"Type :"))
self.ctrl_type = Choix_type(self)
self.label_unite = wx.StaticText(self, -1, _(u"Unité :"))
self.ctrl_unite = Choix_unite(self)
self.label_beneficiaire = wx.StaticText(self, -1, _(u"Bénéfic. :"))
self.ctrl_beneficiaire = Choix_beneficiaire(self)
self.label_validite = wx.StaticText(self, -1, _(u"Validité :"))
self.label_du = wx.StaticText(self, -1, u"du")
self.ctrl_date_debut = CTRL_Saisie_date.Date(self)
self.label_au = wx.StaticText(self, -1, _(u"au"))
self.ctrl_date_fin = CTRL_Saisie_date.Date(self)
self.label_activites = wx.StaticText(self, -1, _(u"Activités :"))
self.ctrl_activites = CTRL_Activites(self)
self.bouton_activites = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath(u"Images/16x16/Modifier.png"),
wx.BITMAP_TYPE_ANY))
self.label_observations = wx.StaticText(self, -1, _(u"Notes :"))
self.ctrl_observations = wx.TextCtrl(self, -1, "")
# Carte
self.staticbox_carte_staticbox = wx.StaticBox(self, -1,
_(u"Carte d'adhérent"))
self.label_creation = wx.StaticText(self, -1, _(u"Création :"))
self.ctrl_creation = wx.CheckBox(self, -1, "")
self.label_numero = wx.StaticText(self, -1, _(u"Numéro :"))
self.ctrl_numero = wx.TextCtrl(self, -1, u"")
self.label_date = wx.StaticText(self, -1, _(u"Date :"))
self.ctrl_date_creation = CTRL_Saisie_date.Date2(self)
self.ctrl_date_creation.SetDate(datetime.date.today())
self.label_depot = wx.StaticText(self, -1, _(u"Dépôt :"))
self.ctrl_depot = wx.TextCtrl(self, -1, u"")
# Prestation
self.staticbox_prestation_staticbox = wx.StaticBox(
self, -1, _(u"Facturation"))
self.label_facturer = wx.StaticText(self, -1, _(u"Facturer :"))
self.ctrl_facturer = wx.CheckBox(self, -1, "")
self.label_date_prestation = wx.StaticText(self, -1, _(u"Date :"))
self.ctrl_date_prestation = CTRL_Saisie_date.Date2(self)
self.ctrl_date_prestation.SetDate(datetime.date.today())
self.label_label = wx.StaticText(self, -1, _(u"Label :"))
self.ctrl_label = wx.TextCtrl(self, -1, u"")
self.label_payeur = wx.StaticText(self, -1, _(u"Payeur :"))
self.ctrl_payeur = Choix_payeur(self)
self.label_montant = wx.StaticText(self, -1, _(u"Montant :"))
self.ctrl_montant = CTRL_Saisie_euros.CTRL(self)
# Commandes
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_ok = CTRL_Bouton_image.CTRL(
self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_annuler = CTRL_Bouton_image.CTRL(
self,
id=wx.ID_CANCEL,
texte=_(u"Annuler"),
cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_CHOICE, self.OnChoixType, self.ctrl_type)
self.Bind(wx.EVT_CHOICE, self.OnChoixUnite, self.ctrl_unite)
self.Bind(wx.EVT_BUTTON, self.OnBoutonActivites, self.bouton_activites)
self.Bind(wx.EVT_CHECKBOX, self.OnChoixCreation, self.ctrl_creation)
self.Bind(wx.EVT_CHECKBOX, self.OnChoixFacturer, self.ctrl_facturer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
if self.IDcotisation == None:
self.SetTitle(_(u"Saisie d'une cotisation"))
self.SetProchainIDcotisation()
self.OnChoixCreation(None)
self.OnChoixFacturer(None)
self.OnChoixType(None)
self.OnChoixUnite(None)
else:
self.SetTitle(_(u"Modification d'une cotisation"))
self.Importation()
# Init contrôles
self.ctrl_depot.Enable(False)
self.bouton_ok.SetFocus()
def OnBoutonOk(self, event):
# compte
IDcompte = self.ctrl_compte.GetID()
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
# Mode
IDmode = self.ctrl_mode.GetID()
if IDmode == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un mode de règlement !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Emetteur
IDemetteur = self.ctrl_emetteur.GetID()
# Tracks
tracks = self.ctrl_prestations.GetTracksCoches()
if len(tracks) == 0:
dlg = wx.MessageDialog(
self,
_(u"Vous devez cocher au moins une ligne dans la liste !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Confirmation
montantTotal = decimal.Decimal(0.0)
for track in tracks:
montantTotal += track.impaye
dlg = wx.MessageDialog(
self,
_(u"Confirmez-vous la création automatique de %d règlements pour un total de %.2f %s ?"
) % (len(tracks), montantTotal, SYMBOLE),
_(u"Demande de confirmation"),
wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION)
reponse = dlg.ShowModal()
dlg.Destroy()
if reponse != wx.ID_YES:
return False
# ----------------------------- Création des règlements -----------------------------------------------------------
DB = GestionDB.DB()
# Recherche des payeurs
req = """SELECT IDpayeur, IDcompte_payeur, nom
FROM payeurs;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPayeurs = {}
for IDpayeur, IDcompte_payeur, nom in listeDonnees:
if dictPayeurs.has_key(IDcompte_payeur) == False:
dictPayeurs[IDcompte_payeur] = []
dictPayeurs[IDcompte_payeur].append({
"nom": nom,
"IDpayeur": IDpayeur
})
# Sauvegarde des règlements + ventilation
for track in tracks:
# Recherche du payeur
IDpayeur = None
if dictPayeurs.has_key(track.IDcompte_payeur):
IDpayeur = dictPayeurs[track.IDcompte_payeur][0]["IDpayeur"]
else:
nomTitulaire = u"%s %s" % (track.listeTitulaires[0]["nom"],
track.listeTitulaires[0]["prenom"])
IDpayeur = DB.ReqInsert(
"payeurs", [("IDcompte_payeur", track.IDcompte_payeur),
("nom", nomTitulaire)])
# Création des données à sauvegarder
listeDonnees = [
("IDcompte_payeur", track.IDcompte_payeur),
("date", str(datetime.date.today())),
("IDmode", IDmode),
("IDemetteur", IDemetteur),
("numero_piece", None),
("montant", float(track.impaye)),
("IDpayeur", IDpayeur),
("observations",
_(u"Règlement créé avec la fonction 'Solder les impayés'")
),
("numero_quittancier", None),
("IDcompte", IDcompte),
("date_differe", None),
("encaissement_attente", 0),
("date_saisie", str(datetime.date.today())),
("IDutilisateur", UTILS_Identification.GetIDutilisateur()),
]
# Ajout
IDreglement = DB.ReqInsert("reglements", listeDonnees)
# ----------- Sauvegarde de la ventilation ---------
for dictPrestation in track.listePrestations:
listeDonnees = [
("IDreglement", IDreglement),
("IDcompte_payeur", track.IDcompte_payeur),
("IDprestation", dictPrestation["IDprestation"]),
("montant", float(dictPrestation["impaye"])),
]
IDventilation = DB.ReqInsert("ventilation", listeDonnees)
DB.Close()
dlg = wx.MessageDialog(
self,
_(u"Les %d règlements ont été créés avec succès.") %
len(tracks), _(u"Confirmation"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
# Fermeture
self.EndModal(wx.ID_OK)
def SauvegardeReglements(self, date=None, IDcompte=None, IDmode=None):
""" A effectuer après la sauvegarde des prélèvements """
DB = GestionDB.DB()
# Recherche des payeurs
req = """SELECT IDpayeur, IDcompte_payeur, nom
FROM payeurs;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPayeurs = {}
for IDpayeur, IDcompte_payeur, nom in listeDonnees:
if dictPayeurs.has_key(IDcompte_payeur) == False:
dictPayeurs[IDcompte_payeur] = []
dictPayeurs[IDcompte_payeur].append({
"nom": nom,
"IDpayeur": IDpayeur
})
# Récupération des prestations à ventiler pour chaque facture
listeIDfactures = []
for track in self.GetObjects():
if track.IDfacture != None:
listeIDfactures.append(track.IDfacture)
if len(listeIDfactures) == 0: conditionFactures = "()"
elif len(listeIDfactures) == 1:
conditionFactures = "(%d)" % listeIDfactures[0]
else:
conditionFactures = str(tuple(listeIDfactures))
req = """SELECT
prestations.IDprestation, prestations.IDcompte_payeur, prestations.montant,
prestations.IDfacture, SUM(ventilation.montant) AS montant_ventilation
FROM prestations
LEFT JOIN ventilation ON prestations.IDprestation = ventilation.IDprestation
WHERE prestations.IDfacture IN %s
GROUP BY prestations.IDprestation
;""" % conditionFactures
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictFactures = {}
for IDprestation, IDcompte_payeur, montant, IDfacture, ventilation in listeDonnees:
if ventilation == None:
ventilation = 0.0
montant = decimal.Decimal(montant)
ventilation = decimal.Decimal(ventilation)
aventiler = montant - ventilation
if aventiler > decimal.Decimal(0.0):
if dictFactures.has_key(IDfacture) == False:
dictFactures[IDfacture] = []
dictFactures[IDfacture].append({
"IDprestation": IDprestation,
"IDcompte_payeur": IDcompte_payeur,
"montant": montant,
"ventilation": ventilation,
"aventiler": aventiler
})
# Sauvegarde des règlements + ventilation
listeSuppressionReglements = []
for track in self.GetObjects():
# Ajouts et modifications
if track.reglement == True:
# Recherche du payeur
IDpayeur = None
if dictPayeurs.has_key(track.IDcompte_payeur):
for dictPayeur in dictPayeurs[track.IDcompte_payeur]:
if dictPayeur["nom"] == track.titulaire:
IDpayeur = dictPayeur["IDpayeur"]
# Si pas de payeur correspond au titulaire du compte trouvé :
if IDpayeur == None:
IDpayeur = DB.ReqInsert(
"payeurs", [("IDcompte_payeur", track.IDcompte_payeur),
("nom", track.titulaire)])
# Création des données à sauvegarder
listeDonnees = [
("IDcompte_payeur", track.IDcompte_payeur),
("date", date),
("IDmode", IDmode),
("IDemetteur", None),
("numero_piece", None),
("montant", track.montant),
("IDpayeur", IDpayeur),
("observations", None),
("numero_quittancier", None),
("IDcompte", IDcompte),
("date_differe", None),
("encaissement_attente", 0),
("date_saisie", datetime.date.today()),
("IDutilisateur", UTILS_Identification.GetIDutilisateur()),
("IDprelevement", track.IDprelevement),
]
# Ajout
if track.IDreglement == None:
track.IDreglement = DB.ReqInsert("reglements",
listeDonnees)
# Modification
else:
DB.ReqMAJ("reglements", listeDonnees, "IDreglement",
track.IDreglement)
track.dateReglement = date
# ----------- Sauvegarde de la ventilation ---------
if dictFactures.has_key(track.IDfacture):
for dictFacture in dictFactures[track.IDfacture]:
listeDonnees = [
("IDreglement", track.IDreglement),
("IDcompte_payeur", track.IDcompte_payeur),
("IDprestation", dictFacture["IDprestation"]),
("montant", float(dictFacture["aventiler"])),
]
IDventilation = DB.ReqInsert("ventilation",
listeDonnees)
# Suppression de règlements et ventilation
else:
if track.IDreglement != None:
DB.ReqDEL("reglements", "IDreglement", track.IDreglement)
DB.ReqDEL("ventilation", "IDreglement", track.IDreglement)
# MAJ du track
self.RefreshObject(track)
DB.Close()
def SauvegardeRappels(self):
""" Sauvegarde des rappels """
dlgAttente = PBI.PyBusyInfo(
_(u"Génération des rappels en cours..."),
parent=None,
title=_(u"Veuillez patienter..."),
icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"),
wx.BITMAP_TYPE_ANY))
wx.Yield()
# Recherche numéro de facture suivant
DB = GestionDB.DB()
req = """SELECT MAX(numero) FROM rappels;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if listeDonnees[0][0] == None:
numero = 1
else:
numero = listeDonnees[0][0] + 1
# Récupère Utilisateur en cours
IDutilisateur = UTILS_Identification.GetIDutilisateur()
# Génération des rappels
listeRappelsGenerees = []
# Fusion des mots-clés
facturation = UTILS_Rappels.Facturation()
# Tri par ordre alphabétique de la liste
listeComptes = []
listeAnomalies = []
dictCoches = self.ctrl_rappels.GetCoches()
for IDcompte_payeur, dictCompte in self.ctrl_rappels.dictComptes.iteritems(
):
if dictCompte["select"] == True and dictCoches.has_key(
IDcompte_payeur):
# Insertion du document dans le dictCompte
dictDocument = self.ctrl_rappels.GetDictDocument(
IDcompte_payeur)
if dictDocument["IDtexte"] == 0:
listeAnomalies.append(IDcompte_payeur)
else:
dictCompte["IDtexte"] = dictDocument["IDtexte"]
dictCompte["titre"] = dictDocument["titre"]
dictCompte["texte"] = facturation.Fusion(
dictCompte["IDtexte"], dictCompte)
listeComptes.append((dictCompte["nomSansCivilite"],
IDcompte_payeur, dictCompte))
listeComptes.sort()
# Il reste des textes non attribués :
if len(listeAnomalies) > 0:
del dlgAttente
dlg = wx.MessageDialog(
self,
_(u"Il reste %d lettre(s) pour lesquelles vous n'avez pas attribué de texte !"
) % len(listeAnomalies), _(u"Erreur de saisie"),
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Sauvegarde
DB = GestionDB.DB()
try:
index = 0
for nomTitulaires, IDcompte_payeur, dictCompte in listeComptes:
self.EcritStatusbar(
_(u"Génération de la lettre de rappel %d sur %d...") %
(index + 1, len(listeComptes)))
# Liste des activités
texteActivites = ""
for IDactivite in self.parent.dictParametres["listeActivites"]:
texteActivites += "%d;" % IDactivite
if len(texteActivites) > 0:
texteActivites = texteActivites[:-1]
# Sauvegarde de la facture
listeDonnees = [
("numero", numero),
("IDcompte_payeur", IDcompte_payeur),
("date_edition", str(datetime.date.today())),
("date_reference",
self.parent.dictParametres["date_reference"]),
("IDtexte", dictCompte["IDtexte"]),
("activites", texteActivites),
("date_min", str(dictCompte["date_min"])),
("date_max", str(dictCompte["date_max"])),
("solde", float(dictCompte["solde_num"])),
("IDlot", self.parent.dictParametres["IDlot"]),
("prestations",
";".join(self.parent.dictParametres["prestations"])),
]
IDrappel = DB.ReqInsert("rappels", listeDonnees)
listeRappelsGenerees.append(IDrappel)
numero += 1
index += 1
DB.Close()
self.EcritStatusbar(u"")
del dlgAttente
except Exception, err:
DB.Close()
del dlgAttente
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(
self,
_(u"Désolé, le problème suivant a été rencontré : \n\n%s"
) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
self.EcritStatusbar(u"")
return False
def Sauvegarde(self):
""" Sauvegarde dans la base """
DB = GestionDB.DB()
# Enregistrement des informations générales sur le contrat
listeDonnees = (
("IDindividu", self.GetValeur("IDindividu", None)),
("IDinscription", self.GetValeur("IDinscription", None)),
("IDactivite", self.GetValeur("IDactivite", None)),
("date_debut", self.GetValeur("date_debut", None)),
("date_fin", self.GetValeur("date_fin", None)),
("observations", self.GetValeur("observations", None)),
("type", "psu"),
("duree_absences_prevues",
UTILS_Dates.DeltaEnStr(self.GetValeur("duree_absences_prevues",
datetime.timedelta(0)),
separateur=":")),
("duree_heures_regularisation",
UTILS_Dates.DeltaEnStr(self.GetValeur(
"duree_heures_regularisation", datetime.timedelta(0)),
separateur=":")),
("arrondi_type", self.GetValeur("arrondi_type", None)),
("arrondi_delta", self.GetValeur("arrondi_delta", 30)),
("planning", self.GetValeur("planning", None)),
)
if self.IDcontrat == None:
self.IDcontrat = DB.ReqInsert("contrats", listeDonnees)
else:
DB.ReqMAJ("contrats", listeDonnees, "IDcontrat", self.IDcontrat)
# Enregistrement des consommations
# liste_IDconso = []
# for track in self.GetValeur("tracks_previsions", []):
# listeDonnees = (
# ("IDindividu", self.GetValeur("IDindividu", None)),
# ("IDinscription", self.GetValeur("IDinscription", None)),
# ("IDactivite", self.GetValeur("IDactivite", None)),
# ("date", track.date),
# ("IDunite", track.IDunite),
# ("IDgroupe", self.GetValeur("IDgroupe", None)),
# ("heure_debut", track.heure_debut),
# ("heure_fin", track.heure_fin),
# ("etat", track.etat),
# #("date_saisie", track.date_saisie),
# ("IDutilisateur", UTILS_Identification.GetIDutilisateur()),
# ("IDcategorie_tarif", self.GetValeur("IDcategorie_tarif", None)),
# ("IDcompte_payeur", self.GetValeur("IDcompte_payeur", None)),
# #("IDprestation", track.IDprestation),#TODO
# #("forfait", track.forfait),#TODO
# ("quantite", track.quantite),
# #("etiquettes", track.etiquettes),#TODO
# )
# if track.IDconso == None :
# IDconso = DB.ReqInsert("consommations", listeDonnees)
# else :
# IDconso = track.IDconso
# DB.ReqMAJ("consommations", listeDonnees, "IDconso", IDconso)
# liste_IDconso.append(IDconso)
# Version optimisée
listeChamps = [
"IDindividu",
"IDinscription",
"IDactivite",
"date",
"IDunite",
"IDgroupe",
"heure_debut",
"heure_fin",
"etat",
"IDutilisateur",
"IDcategorie_tarif",
"IDcompte_payeur",
"quantite",
]
liste_IDconso = []
listeAjouts = []
listeModifications = []
for track in self.GetValeur("tracks_previsions", []):
listeDonnees = [
self.GetValeur("IDindividu", None),
self.GetValeur("IDinscription", None),
self.GetValeur("IDactivite", None),
track.date,
track.IDunite,
self.GetValeur("IDgroupe", None),
track.heure_debut,
track.heure_fin,
track.etat,
UTILS_Identification.GetIDutilisateur(),
self.GetValeur("IDcategorie_tarif", None),
self.GetValeur("IDcompte_payeur", None),
track.quantite,
]
if track.IDconso == None:
listeAjouts.append(listeDonnees)
else:
IDconso = track.IDconso
listeDonnees.append(IDconso)
listeModifications.append(listeDonnees)
liste_IDconso.append(IDconso)
# Ajout optimisé des conso
if len(listeAjouts) > 0:
texteChampsTemp = ", ".join(listeChamps)
listeInterrogations = []
for champ in listeChamps:
listeInterrogations.append("?")
texteInterrogations = ", ".join(listeInterrogations)
DB.Executermany("INSERT INTO consommations (%s) VALUES (%s)" %
(texteChampsTemp, texteInterrogations),
listeAjouts,
commit=True)
# Modification optimisée des conso
if len(listeModifications) > 0:
listeChampsTemp = []
for champ in listeChamps:
listeChampsTemp.append(("%s=?" % champ))
DB.Executermany("UPDATE consommations SET %s WHERE IDconso=?" %
", ".join(listeChampsTemp),
listeModifications,
commit=True)
# Suppression des consommations supprimées
listeSuppressions = []
for IDconso in self.GetValeur("liste_IDconso", []):
if IDconso not in liste_IDconso:
listeSuppressions.append(IDconso)
if len(listeSuppressions) > 0:
if len(listeSuppressions) == 1:
conditionSuppression = "(%d)" % listeSuppressions[0]
else:
conditionSuppression = str(tuple(listeSuppressions))
DB.ExecuterReq("DELETE FROM consommations WHERE IDconso IN %s" %
conditionSuppression)
# Enregistrement des tarifs
liste_IDtarif = []
for track in self.GetValeur("tracks_tarifs", []):
listeDonnees = (
("IDcontrat", self.IDcontrat),
("date_debut", track.date_debut),
("revenu", track.revenu),
("quotient", track.quotient),
("taux", track.taux),
("tarif_base", track.tarif_base),
("tarif_depassement", track.tarif_depassement),
)
if track.IDcontrat_tarif == None:
IDcontrat_tarif = DB.ReqInsert("contrats_tarifs", listeDonnees)
else:
IDcontrat_tarif = track.IDcontrat_tarif
DB.ReqMAJ("contrats_tarifs", listeDonnees, "IDcontrat_tarif",
IDcontrat_tarif)
liste_IDtarif.append(IDcontrat_tarif)
# Suppression des tarifs supprimés
listeSuppressions = []
for IDcontrat_tarif in self.GetValeur("liste_IDtarif", []):
if IDcontrat_tarif not in liste_IDtarif:
listeSuppressions.append(IDcontrat_tarif)
if len(listeSuppressions) > 0:
if len(listeSuppressions) == 1:
conditionSuppression = "(%d)" % listeSuppressions[0]
else:
conditionSuppression = str(tuple(listeSuppressions))
DB.ExecuterReq(
"DELETE FROM contrats_tarifs WHERE IDcontrat_tarif IN %s" %
conditionSuppression)
# Enregistrement des mensualités
# liste_IDprestation = []
# for track in self.GetValeur("tracks_mensualites", []):
# listeDonnees = (
# ("IDcompte_payeur", self.GetValeur("IDcompte_payeur", None)),
# ("date", track.date_facturation),
# ("categorie", "consommation"),
# ("label", track.label_prestation),
# ("montant_initial", track.montant_mois),
# ("montant", track.montant_mois),
# ("IDactivite", self.GetValeur("IDactivite", None)),
# ("IDtarif", self.GetValeur("IDtarif", None)),
# ("IDfacture", track.IDfacture),
# ("IDfamille", self.GetValeur("IDfamille", None)),
# ("IDindividu", self.GetValeur("IDindividu", None)),
# ("forfait", None),
# ("temps_facture", UTILS_Dates.DeltaEnStr(track.heures_facturees, ":")),
# ("IDcategorie_tarif", self.GetValeur("IDcategorie_tarif", None)),
# ("forfait_date_debut", track.forfait_date_debut),
# ("forfait_date_fin", track.forfait_date_fin),
# ("IDcontrat", self.IDcontrat),
# )
# if track.IDprestation == None :
# IDprestation = DB.ReqInsert("prestations", listeDonnees)
# else :
# IDprestation = track.IDprestation
# DB.ReqMAJ("prestations", listeDonnees, "IDprestation", IDprestation)
# liste_IDprestation.append(IDprestation)
#
# # Suppression des prestations supprimées
# listeSuppressions = []
# for IDprestation in self.GetValeur("liste_IDprestation", []):
# if IDprestation not in liste_IDprestation :
# listeSuppressions.append(IDprestation)
#
# if len(listeSuppressions) > 0 :
# if len(listeSuppressions) == 1 :
# conditionSuppression = "(%d)" % listeSuppressions[0]
# else :
# conditionSuppression = str(tuple(listeSuppressions))
# DB.ExecuterReq("DELETE FROM prestations WHERE IDprestation IN %s" % conditionSuppression)
# DB.ExecuterReq("DELETE FROM ventilation WHERE IDprestation IN %s" % conditionSuppression)
# DB.ExecuterReq("DELETE FROM deductions WHERE IDprestation IN %s" % conditionSuppression)
DB.Commit()
DB.Close()
