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 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 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 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 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 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 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 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()
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)