def __init__(self, parent, IDcompte_payeur=None, IDreglement=None): wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL) self.parent = parent self.IDcompte_payeur = IDcompte_payeur self.IDreglement = IDreglement self.montant_reglement = FloatToDecimal(0.0) self.total_ventilation = FloatToDecimal(0.0) self.validation = True if "linux" in sys.platform: defaultFont = self.GetFont() defaultFont.SetPointSize(8) self.SetFont(defaultFont) # Regroupement self.label_regroupement = wx.StaticText(self, -1, _(u"Regrouper par :")) self.radio_periode = wx.RadioButton(self, -1, _(u"Mois"), style=wx.RB_GROUP) self.radio_facture = wx.RadioButton(self, -1, _(u"Facture")) self.radio_individu = wx.RadioButton(self, -1, _(u"Individu")) self.radio_date = wx.RadioButton(self, -1, _(u"Date")) # Commandes rapides self.label_hyperliens_1 = wx.StaticText(self, -1, _(u"Ventiler ")) self.hyper_automatique = Hyperlien( self, label=_(u"automatiquement"), infobulle=_( u"Cliquez ici pour ventiler automatiquement le crédit restant" ), URL="automatique") self.label_hyperliens_2 = wx.StaticText(self, -1, u" | ") self.hyper_tout = Hyperlien( self, label=_(u"tout"), infobulle=_(u"Cliquez ici pour tout ventiler"), URL="tout") self.label_hyperliens_3 = wx.StaticText(self, -1, u" | ") self.hyper_rien = Hyperlien( self, label=_(u"rien"), infobulle=_(u"Cliquez ici pour ne rien ventiler"), URL="rien") # Liste de la ventilation self.ctrl_ventilation = CTRL_Ventilation(self, IDcompte_payeur, IDreglement) # Etat de la ventilation self.imgOk = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok4.png"), wx.BITMAP_TYPE_PNG) self.imgErreur = wx.Bitmap( Chemins.GetStaticPath("Images/16x16/Interdit2.png"), wx.BITMAP_TYPE_PNG) self.imgAddition = wx.Bitmap( Chemins.GetStaticPath("Images/16x16/Addition.png"), wx.BITMAP_TYPE_PNG) self.ctrl_image = wx.StaticBitmap(self, -1, self.imgAddition) self.ctrl_info = wx.StaticText( self, -1, _(u"Vous pouvez encore ventiler 30.90 ¤")) self.ctrl_info.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD)) self.__do_layout() self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_periode) self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_facture) self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_individu) self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_date) # Init self.ctrl_ventilation.InitGrid()
def Importation(self): if self.IDreglement == None: IDreglement = 0 else: IDreglement = self.IDreglement # Importation des ventilations de ce règlement DB = GestionDB.DB() req = """SELECT IDventilation, IDprestation, montant FROM ventilation WHERE IDreglement=%d ;""" % IDreglement DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() self.dictVentilation = {} #self.dictVentilationInitiale = {} for IDventilation, IDprestation, montant in listeDonnees: self.dictVentilation[IDprestation] = FloatToDecimal(montant) self.dictVentilationInitiale[IDprestation] = IDventilation # Importation de la ventilation passée req = """SELECT IDprestation, SUM(montant) FROM ventilation WHERE IDcompte_payeur=%d GROUP BY IDprestation ;""" % self.IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictVentilationPassee = {} for IDprestation, montant in listeDonnees: dictVentilationPassee[IDprestation] = montant # Importation des données req = """ SELECT prestations.IDprestation, prestations.IDcompte_payeur, date, categorie, label, prestations.montant, prestations.IDactivite, activites.nom, prestations.IDtarif, noms_tarifs.nom, categories_tarifs.nom, prestations.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.date_edition, IDfamille, prestations.IDindividu, individus.nom, individus.prenom FROM prestations LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif LEFT JOIN categories_tarifs ON tarifs.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe WHERE prestations.IDcompte_payeur = %d GROUP BY prestations.IDprestation ORDER BY date ;""" % self.IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeLignesPrestations = [] for IDprestation, IDcompte_payeur, date, categorie, label, montant, IDactivite, nomActivite, IDtarif, nomTarif, nomCategorieTarif, IDfacture, IDprefixe, prefixe, num_facture, date_facture, IDfamille, IDindividu, nomIndividu, prenomIndividu in listeDonnees: montant = FloatToDecimal(montant) if dictVentilationPassee.has_key(IDprestation): montantVentilation = FloatToDecimal( dictVentilationPassee[IDprestation]) else: montantVentilation = FloatToDecimal(0.0) if num_facture == None: num_facture = 0 if (montant >= FloatToDecimal(0.0) and montantVentilation < montant ) or (montant < FloatToDecimal(0.0) and montantVentilation > montant) or IDprestation in self.dictVentilation.keys(): date = DateEngEnDateDD(date) if self.dictVentilation.has_key(IDprestation): montantVentilation = montantVentilation - self.dictVentilation[ IDprestation] dictTemp = { "IDprestation": IDprestation, "IDcompte_payeur": IDcompte_payeur, "date": date, "categorie": categorie, "label": label, "montant": montant, "IDactivite": IDactivite, "nomActivite": nomActivite, "IDtarif": IDtarif, "nomTarif": nomTarif, "nomCategorieTarif": nomCategorieTarif, "IDfacture": IDfacture, "IDprefixe": IDprefixe, "prefixe": prefixe, "num_facture": num_facture, "date_facture": date_facture, "IDfamille": IDfamille, "IDindividu": IDindividu, "nomIndividu": nomIndividu, "prenomIndividu": prenomIndividu, "ventilationPassee": montantVentilation, } ligne_prestation = Ligne_prestation(grid=self, donnees=dictTemp) listeLignesPrestations.append(ligne_prestation) return listeLignesPrestations
def MAJbarreInfos(self, erreur=None): total = FloatToDecimal(0.0) for ligne in self.listeLignesPrestations: total += ligne.ventilationActuelle self.parent.MAJbarreInfos(total, erreur)
def GetListePrestations(self, IDfamille=None, listeComptesPayeurs=[]): DB = GestionDB.DB() # Condition Famille if IDfamille == None or IDfamille == 0: conditionFamille = "IDfamille>0" else: conditionFamille = "IDfamille=%d" % IDfamille # Condition PERIODES conditions = self.GetSQLdates(self.listePeriodes) if len(conditions) > 0: conditionDates = " AND %s" % conditions else: conditionDates = "" # Condition COMPTES PAYEURS if len(listeComptesPayeurs) == 0: conditionComptes = "AND prestations.IDcompte_payeur > 0" elif len(listeComptesPayeurs) == 1: conditionComptes = "AND prestations.IDcompte_payeur IN (%d)" % listeComptesPayeurs[ 0] else: conditionComptes = "AND prestations.IDcompte_payeur IN %s" % str( tuple(listeComptesPayeurs)) # Filtres de l'utilisateur filtreSQL = self.GetFiltres() req = """ SELECT prestations.IDprestation, prestations.IDcompte_payeur, prestations.date, categorie, prestations.label, prestations.montant, prestations.IDactivite, activites.nom, activites.abrege, prestations.IDtarif, noms_tarifs.nom, categories_tarifs.nom, prestations.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.date_edition, prestations.forfait, prestations.IDcategorie_tarif, IDfamille, prestations.IDindividu, individus.nom, individus.prenom, SUM(deductions.montant) AS montant_deduction, COUNT(deductions.IDdeduction) AS nbre_deductions, reglement_frais FROM prestations LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif LEFT JOIN categories_tarifs ON prestations.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif LEFT JOIN deductions ON deductions.IDprestation = prestations.IDprestation LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe WHERE %s %s %s %s GROUP BY prestations.IDprestation ORDER BY prestations.date ;""" % (conditionFamille, conditionComptes, conditionDates, filtreSQL) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() req = """ SELECT ventilation.IDprestation, SUM(ventilation.montant) AS montant_ventilation FROM ventilation LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif LEFT JOIN categories_tarifs ON prestations.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture WHERE %s %s %s %s GROUP BY ventilation.IDprestation ;""" % (conditionFamille, conditionComptes, conditionDates, filtreSQL) DB.ExecuterReq(req) listeVentilation = DB.ResultatReq() dictVentilation = {} for IDprestation, montantVentilation in listeVentilation: dictVentilation[IDprestation] = montantVentilation DB.Close() listePrestations = [] listeIndividus = [] listeActivites = [] listeFactures = [] total = 0.0 for IDprestation, IDcompte_payeur, date, categorie, label, montant, IDactivite, nomActivite, nomAbregeActivite, IDtarif, nomTarif, nomCategorieTarif, IDfacture, IDprefixe, prefixe, num_facture, date_facture, forfait, IDcategorie_tarif, IDfamille, IDindividu, nomIndividu, prenomIndividu, montant_deduction, nbre_deductions, reglement_frais in listeDonnees: date = DateEngEnDateDD(date) if dictVentilation.has_key(IDprestation): montant_ventilation = FloatToDecimal( dictVentilation[IDprestation]) else: montant_ventilation = FloatToDecimal(0.0) if montant == None: montant = 0.0 dictTemp = { "IDprestation": IDprestation, "IDcompte_payeur": IDcompte_payeur, "date": date, "categorie": categorie, "label": label, "montant": FloatToDecimal(montant), "IDactivite": IDactivite, "nomActivite": nomActivite, "nomAbregeActivite": nomAbregeActivite, "IDtarif": IDtarif, "nomTarif": nomTarif, "nomCategorieTarif": nomCategorieTarif, "IDfacture": IDfacture, "IDprefixe": IDprefixe, "prefixe": prefixe, "num_facture": num_facture, "date_facture": date_facture, "forfait": forfait, "IDfamille": IDfamille, "IDindividu": IDindividu, "nomIndividu": nomIndividu, "prenomIndividu": prenomIndividu, "montant_ventilation": FloatToDecimal(montant_ventilation), "montant_deduction": FloatToDecimal(montant_deduction), "nbre_deductions": nbre_deductions, "reglement_frais": reglement_frais, } listePrestations.append(dictTemp) # Mémorisation des individus if IDindividu != None and prenomIndividu != None and ( prenomIndividu, IDindividu) not in listeIndividus: listeIndividus.append((prenomIndividu, IDindividu)) # Mémorisation des activités if IDactivite != None and nomActivite != None and ( nomActivite, IDactivite) not in listeActivites: listeActivites.append((nomActivite, IDactivite)) # Mémorisation des factures if IDfacture != None and (u"N° %d" % IDfacture, IDfacture) not in listeFactures: listeFactures.append((u"N° %d" % IDfacture, IDfacture)) # Mémorisation du total des prestations affichées total += montant return listePrestations, listeIndividus, listeActivites, listeFactures, total
def Importation_prestations(self): """ Importation des données """ DB = GestionDB.DB() # Récupèration de la ventilation des prestations de la période conditionDepots = "" if self.filtreDepots == True and self.filtreDepots_dateDebut != None and self.filtreDepots_dateFin != None: conditionDepots = " AND (depots.date>='%s' AND depots.date<='%s') " % ( self.filtreDepots_dateDebut, self.filtreDepots_dateFin) conditionReglements = "" if self.filtreReglements == True and self.filtreReglements_dateDebut != None and self.filtreReglements_dateFin != None: conditionReglements = " AND (reglements.date>='%s' AND reglements.date<='%s') " % ( self.filtreReglements_dateDebut, self.filtreReglements_dateFin) req = """SELECT ventilation.IDventilation, ventilation.IDreglement, ventilation.IDprestation, ventilation.montant, reglements.date, reglements.date_saisie, depots.date, prestations.date FROM ventilation LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation LEFT JOIN depots ON depots.IDdepot = reglements.IDdepot WHERE prestations.date>='%s' AND prestations.date <='%s' %s %s ORDER BY prestations.date; """ % (self.date_debut, self.date_fin, conditionDepots, conditionReglements) DB.ExecuterReq(req) listeVentilation = DB.ResultatReq() dictVentilation = {} for IDventilation, IDreglement, IDprestation, montantVentilation, dateReglement, dateSaisieReglement, dateDepotReglement, datePrestation in listeVentilation: if (IDprestation in dictVentilation) == False: dictVentilation[IDprestation] = 0.0 dictVentilation[IDprestation] += montantVentilation # Condition Afficher Cotisations et/ou Consommations ? listeAffichage = [] if self.afficher_cotisations == True: listeAffichage.append("cotisation") if self.afficher_locations == True: listeAffichage.append("location") if self.afficher_consommations == True: listeAffichage.append("consommation") if self.afficher_locations == True: listeAffichage.append("locations") if self.afficher_autres == True: listeAffichage.append("autre") if len(listeAffichage) == 0: conditionAfficher = "categorie='xxxxxxx' " elif len(listeAffichage) == 1: conditionAfficher = "categorie='%s'" % listeAffichage[0] else: conditionAfficher = "categorie IN %s" % str(tuple(listeAffichage)) # Condition Activités affichées if len(self.listeActivites) == 0: conditionActivites = "prestations.IDactivite=9999999" elif len(self.listeActivites) == 1: conditionActivites = "prestations.IDactivite=%d" % self.listeActivites[ 0] else: conditionActivites = "prestations.IDactivite IN %s" % str( tuple(self.listeActivites)) # Récupération de toutes les prestations de la période req = """SELECT IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDcompte_payeur, IDfamille FROM prestations WHERE date>='%s' AND date <='%s' AND %s AND (%s OR prestations.IDactivite IS NULL) ORDER BY date; """ % (self.date_debut, self.date_fin, conditionAfficher, conditionActivites) DB.ExecuterReq(req) listePrestations = DB.ResultatReq() DB.Close() dictResultats = { "familles": {}, "activites": {} } # Stocke la version ACTIVITES et la version FAMILLES listePeriodes = [] for IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDcompte_payeur, IDfamille in listePrestations: date = DateEngEnDateDD(date) annee = date.year mois = date.month if self.mode_periode == "mois": periode = (annee, mois) else: periode = annee if periode not in listePeriodes: listePeriodes.append(periode) if categorie == "location": IDactivite = 777777 if categorie == "cotisation": IDactivite = 888888 if IDactivite == None: IDactivite = 999999 if IDprestation in dictVentilation: solde = float( FloatToDecimal(montant) - FloatToDecimal(dictVentilation[IDprestation])) else: solde = montant if solde == None: solde = 0.0 # Regroupement par activités if (IDactivite in dictResultats["activites"]) == False: dictResultats["activites"][IDactivite] = { "total": 0, "periodes": {} } if (periode in dictResultats["activites"][IDactivite]["periodes"] ) == False: dictResultats["activites"][IDactivite]["periodes"][periode] = { "total": 0, "familles": {} } if (IDfamille in dictResultats["activites"][IDactivite]["periodes"] [periode]["familles"]) == False: dictResultats["activites"][IDactivite]["periodes"][periode][ "familles"][IDfamille] = 0 dictResultats["activites"][IDactivite]["total"] += solde dictResultats["activites"][IDactivite]["periodes"][periode][ "total"] += solde dictResultats["activites"][IDactivite]["periodes"][periode][ "familles"][IDfamille] += solde # Regroupement par familles if (IDfamille in dictResultats["familles"]) == False: dictResultats["familles"][IDfamille] = { "total": 0, "periodes": {} } if (periode in dictResultats["familles"][IDfamille]["periodes"] ) == False: dictResultats["familles"][IDfamille]["periodes"][periode] = { "total": 0, "activites": {} } if (IDactivite in dictResultats["familles"][IDfamille]["periodes"] [periode]["activites"]) == False: dictResultats["familles"][IDfamille]["periodes"][periode][ "activites"][IDactivite] = 0 dictResultats["familles"][IDfamille]["total"] += solde dictResultats["familles"][IDfamille]["periodes"][periode][ "total"] += solde dictResultats["familles"][IDfamille]["periodes"][periode][ "activites"][IDactivite] += solde return dictResultats, listePeriodes
def Calculer(self, mode_test=False, dict_valeurs={}): """ Calcul des totaux et des mensualités """ """ dict_valeurs : pour saisir des valeurs tests """ # Récupération des données date_debut = self.GetValeur("date_debut") if dict_valeurs.has_key("date_debut"): date_debut = dict_valeurs["date_debut"] date_fin = self.GetValeur("date_fin") if dict_valeurs.has_key("date_fin"): date_fin = dict_valeurs["date_fin"] tracks_previsions = self.GetValeur("tracks_previsions", []) tracks_tarifs = self.GetValeur("tracks_tarifs", []) duree_heures_regularisation = self.GetValeur( "duree_heures_regularisation", datetime.timedelta(0)) arrondi_type = self.GetValeur("arrondi_type", "duree") arrondi_delta = self.GetValeur("arrondi_delta", 30) # Absences duree_absences_prevues = self.GetValeur("duree_absences_prevues", datetime.timedelta(0)) duree_absences_prises = self.GetValeur("duree_absences_prises", datetime.timedelta(0)) duree_absences_solde = duree_absences_prevues - duree_absences_prises self.SetValeur("duree_absences_solde", duree_absences_solde) # Vérifie si dates du contrat valides avant les calculs if date_debut != None and date_fin != None and date_fin > date_debut: dates_valides = True else: dates_valides = False # Calcul du nbre de semaines et de mois if dates_valides: nbre_semaines = rrule.rrule(rrule.WEEKLY, dtstart=date_debut, until=date_fin).count() nbre_mois = rrule.rrule(rrule.MONTHLY, dtstart=date_debut, until=date_fin).count() else: nbre_semaines = 0 nbre_mois = 0 # Analyse des heures prévues duree_heures_brut = datetime.timedelta(0) listeDatesUniques = [] for track in tracks_previsions: duree_heures_brut += track.duree_arrondie if track.date not in listeDatesUniques: listeDatesUniques.append(track.date) # Calcul du nbre de dates uniques nbre_dates = len(listeDatesUniques) # Calcul des moyennes if nbre_dates == 0: moy_heures_jour = datetime.timedelta(0) moy_heures_semaine = datetime.timedelta(0) moy_heures_mois = datetime.timedelta(0) else: moy_heures_jour = duree_heures_brut / nbre_dates moy_heures_semaine = duree_heures_brut / nbre_semaines moy_heures_mois = duree_heures_brut / nbre_mois # Calcul du nbre d'heures du contrat duree_heures_contrat = duree_heures_brut - duree_absences_prevues + duree_heures_regularisation # Génération des dates de facturation if dates_valides: liste_mois = list( rrule.rrule(rrule.MONTHLY, bymonthday=1, dtstart=date_debut, until=date_fin)) else: liste_mois = [] nbre_mois_factures = len(liste_mois) # Ajout de la date de début du contrat if dates_valides and date_debut.day > 1: liste_mois.insert(0, date_debut) # Recherche s'il y a des mensualités déjà facturées # listePrestationsFacturees = [] # heuresFacturees = datetime.timedelta(seconds=0) # for dictPrestation in self.GetValeur("liste_prestations", []) : # if dictPrestation["IDfacture"] != None : # listePrestationsFacturees.append(dictPrestation) # heuresFacturees += dictPrestation["temps_facture"] # nbrePrestations = len(listePrestationsFacturees) # Conversion du nbre d'heures déjà facturées en entier # heuresFacturees = (nbre_heures_contrat.days*24) + (nbre_heures_contrat.seconds/3600) # Calcul du forfait mensuel # heures_restantes = nbre_heures_contrat - heuresFacturees # nbre_mois_restant = nbre_mois - nbrePrestations if nbre_mois_factures == 0: forfait_horaire_mensuel, reste_division = 0, 0 else: nbre_heures_contrat_float = UTILS_Dates.DeltaEnHeures( duree_heures_contrat) forfait_horaire_mensuel, reste_division = divmod( nbre_heures_contrat_float, nbre_mois_factures) forfait_horaire_dernier_mois = forfait_horaire_mensuel + reste_division forfait_horaire_mensuel = UTILS_Dates.FloatEnDelta( forfait_horaire_mensuel) forfait_horaire_dernier_mois = UTILS_Dates.FloatEnDelta( forfait_horaire_dernier_mois) # Calcul du forfait horaire mensuel # if nbre_mois == 0 : # forfait_horaire_mensuel, reste_division = 0, 0 # else : # forfait_horaire_mensuel, reste_division = divmod(nbre_heures_contrat, nbre_mois) # forfait_horaire_dernier_mois = forfait_horaire_mensuel + reste_division # Génération des mensualités tracks_mensualites = [] total_mensualites = FloatToDecimal(0.0) index = 0 for date in liste_mois: date_facturation = datetime.date(date.year, date.month, date.day) # Calcul des dates du forfait forfait_date_debut = date_facturation if index == len(liste_mois) - 1: dernierJour = date.day else: dernierJour = calendar.monthrange(date.year, date.month)[1] forfait_date_fin = datetime.date(date.year, date.month, dernierJour) # Calcul du forfait horaire mensuel if index == len(liste_mois) - 1: heures_prevues = forfait_horaire_dernier_mois else: heures_prevues = forfait_horaire_mensuel # Recherche du tarif du mois listeTarifs = [] for track in tracks_tarifs: listeTarifs.append((track.date_debut, track)) listeTarifs.sort() track_tarif = None for date_debut_tarif, track in listeTarifs: if track_tarif == None or date_facturation >= date_debut_tarif: track_tarif = track # Calcul du montant mensuel à facturer if track_tarif != None: tarif_base = track_tarif.tarif_base tarif_depassement = track_tarif.tarif_depassement taux = track_tarif.taux else: tarif_base = 0.0 tarif_depassement = 0.0 taux = 0.0 montant_prevu = FloatToDecimal( tarif_base * UTILS_Dates.DeltaEnFloat(heures_prevues)) total_mensualites += montant_prevu # Recherche d'une prestation existante IDprestation = None IDfacture = None num_facture = None heures_facturees = datetime.timedelta(seconds=0) montant_facture = FloatToDecimal(0.0) for dictPrestation in self.GetValeur("liste_prestations", []): if dictPrestation["date_facturation"] == date_facturation: IDprestation = dictPrestation["IDprestation"] IDfacture = dictPrestation["IDfacture"] num_facture = dictPrestation["num_facture"] montant_facture = dictPrestation["montant"] heures_facturees = dictPrestation["temps_facture"] # Mémorisation de la mensualité dictMensualite = { "IDprestation": IDprestation, "date_facturation": date_facturation, "taux": taux, "track_tarif": track_tarif, "tarif_base": tarif_base, "tarif_depassement": tarif_depassement, "heures_prevues": heures_prevues, "montant_prevu": montant_prevu, "heures_facturees": heures_facturees, "montant_facture": montant_facture, "IDfacture": IDfacture, "forfait_date_debut": forfait_date_debut, "forfait_date_fin": forfait_date_fin, "num_facture": num_facture, } tracks_mensualites.append(Track_mensualite(dictMensualite)) index += 1 # Vérifie si anomalies listeAnomalies = [] # Vérifie que les prestations facturées sont toujours l� # for dictPrestation in listePrestationsFacturees : # present = False # for track in tracks_mensualites : # if track.IDprestation == dictPrestation["IDprestation"] : # present = True # if present == False : # listeAnomalies.append(_(u"La prestation du %s ne peut pas être supprimée car elle apparaît déjà sur la facture n°%s." % (UTILS_Dates.DateDDEnFr(dictPrestation["date_facturation"]), dictPrestation["num_facture"]))) # Vérifie si les consommations sont bien sur la période du contrat nbreConsoHorsPeriode = 0 for track in tracks_previsions: if track.date < date_debut or track.date > date_fin: nbreConsoHorsPeriode += 1 if nbreConsoHorsPeriode > 0: listeAnomalies.append( _(u"%d consommations prévues sont en dehors de la période du contrat." % nbreConsoHorsPeriode)) # Si mode test, renvoie la liste des anomalies if mode_test == True: if len(listeAnomalies) > 0: import DLG_Messagebox introduction = _( u"Votre saisie ne peut pas être validée en raison des erreurs suivantes :" ) detail = "\n".join(listeAnomalies) conclusion = _(u"Veuillez modifier les données saisies.") dlg = DLG_Messagebox.Dialog(None, titre=_(u"Erreur"), introduction=introduction, detail=detail, conclusion=conclusion, icone=wx.ICON_INFORMATION, boutons=[ _(u"Ok"), ]) dlg.ShowModal() dlg.Destroy() return False else: return True # Envoi des données à clsbase dictValeurs = { "nbre_semaines": nbre_semaines, "nbre_mois": nbre_mois, "duree_heures_brut": duree_heures_brut, "nbre_dates": nbre_dates, "moy_heures_jour": moy_heures_jour, "moy_heures_semaine": moy_heures_semaine, "moy_heures_mois": moy_heures_mois, "duree_heures_contrat": duree_heures_contrat, "forfait_horaire_mensuel": forfait_horaire_mensuel, "forfait_horaire_dernier_mois": forfait_horaire_dernier_mois, "tracks_mensualites": tracks_mensualites, "nbre_mensualites": len(tracks_mensualites), "total_mensualites": total_mensualites, } self.SetValeurs(dictValeurs) return dictValeurs
def GetListeFactures(self): dictTitulaires = UTILS_Titulaires.GetTitulaires() DB = GestionDB.DB() # Conditions listeConditions = [] if self.IDcompte_payeur != None: listeConditions.append("prestations.IDcompte_payeur = %d" % self.IDcompte_payeur) # 1ère série de filtres if self.filtres != None: for filtre in self.filtres: # IDfacture_intervalle if filtre["type"] == "IDfacture_intervalle": listeConditions.append( "(factures.IDfacture>=%d AND factures.IDfacture<=%d)" % (filtre["IDfacture_min"], filtre["IDfacture_max"])) # IDfacture_liste if filtre["type"] == "IDfacture_liste": if len(filtre["liste"]) == 0: listeTemp = "()" elif len(filtre["liste"]) == 1: listeTemp = "(%d)" % filtre["liste"][0] else: listeTemp = str(tuple(filtre["liste"])) listeConditions.append("factures.IDfacture IN %s" % listeTemp) # Préfixe if filtre["type"] == "prefixe": if filtre["IDprefixe"] == None: listeConditions.append("factures.IDprefixe IS NULL") else: listeConditions.append("factures.IDprefixe=%d" % filtre["IDprefixe"]) # Lot de factures if filtre["type"] == "lot": listeConditions.append("factures.IDlot=%d" % filtre["IDlot"]) # Date d'émission if filtre["type"] == "date_emission": listeConditions.append( "(factures.date_edition>='%s' AND factures.date_edition<='%s')" % (filtre["date_min"], filtre["date_max"])) # Date d'échéance if filtre["type"] == "date_echeance": listeConditions.append( "(factures.date_echeance>='%s' AND factures.date_echeance<='%s')" % (filtre["date_min"], filtre["date_max"])) # numero_intervalle if filtre["type"] == "numero_intervalle": listeConditions.append( "(factures.numero>=%d AND factures.numero<=%d)" % (filtre["numero_min"], filtre["numero_max"])) # numero_liste if filtre["type"] == "numero_liste": if len(filtre["liste"]) == 0: listeTemp = "()" elif len(filtre["liste"]) == 1: listeTemp = "(%d)" % filtre["liste"][0] else: listeTemp = str(tuple(filtre["liste"])) listeConditions.append("factures.numero IN %s" % listeTemp) if len(listeConditions) > 0: conditions = "WHERE %s" % " AND ".join(listeConditions) else: conditions = "" # Récupération des totaux des prestations pour chaque facture req = """ SELECT prestations.IDfacture, SUM(prestations.montant) FROM prestations LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture %s GROUP BY prestations.IDfacture ;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictPrestations = {} for IDfacture, totalPrestations in listeDonnees: if IDfacture != None: dictPrestations[IDfacture] = totalPrestations # Récupération des factures req = """ SELECT factures.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.IDcompte_payeur, factures.date_edition, factures.date_echeance, factures.IDutilisateur, factures.date_debut, factures.date_fin, factures.total, factures.regle, factures.solde, comptes_payeurs.IDfamille, factures.IDlot, lots_factures.nom, factures.etat FROM factures LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur LEFT JOIN lots_factures ON lots_factures.IDlot = factures.IDlot LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe %s ORDER BY factures.date_edition ;""" % conditions.replace("prestations.IDcompte_payeur", "comptes_payeurs.IDcompte_payeur") DB.ExecuterReq(req) listeFactures = DB.ResultatReq() # Récupération de la ventilation req = """ SELECT prestations.IDfacture, SUM(ventilation.montant) FROM ventilation LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture %s GROUP BY prestations.IDfacture ;""" % conditions DB.ExecuterReq(req) listeVentilation = DB.ResultatReq() dictVentilation = {} for IDfacture, montantVentilation in listeVentilation: if IDfacture != None: dictVentilation[IDfacture] = montantVentilation # Infos Prélèvement + Envoi par Email des factures if self.IDcompte_payeur != None: conditions = "WHERE comptes_payeurs.IDcompte_payeur = %d" % self.IDcompte_payeur else: conditions = "" req = """ SELECT prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, comptes_payeurs.IDcompte_payeur, individus.nom, individus.prenom, titulaire_helios FROM familles LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille LEFT JOIN individus ON individus.IDindividu = prelevement_individu %s ;""" % conditions DB.ExecuterReq(req) listeInfosFamilles = DB.ResultatReq() dictInfosFamilles = {} for prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, IDcompte_payeur, nomPayeur, prenomPayeur, titulaire_helios in listeInfosFamilles: prelevement_date_mandat = UTILS_Dates.DateEngEnDateDD( prelevement_date_mandat) dictInfosFamilles[IDcompte_payeur] = { "prelevement_activation": prelevement_activation, "prelevement_etab": prelevement_etab, "prelevement_guichet": prelevement_guichet, "prelevement_numero": prelevement_numero, "prelevement_cle": prelevement_cle, "prelevement_banque": prelevement_banque, "prelevement_individu": prelevement_individu, "prelevement_nom": prelevement_nom, "prelevement_rue": prelevement_rue, "prelevement_cp": prelevement_cp, "prelevement_ville": prelevement_ville, "prelevement_cle_iban": prelevement_cle_iban, "prelevement_iban": prelevement_iban, "prelevement_bic": prelevement_bic, "prelevement_reference_mandat": prelevement_reference_mandat, "prelevement_date_mandat": prelevement_date_mandat, "email_factures": email_factures, "nomPayeur": nomPayeur, "prenomPayeur": prenomPayeur, "titulaire_helios": titulaire_helios, } DB.Close() listeResultats = [] for IDfacture, IDprefixe, prefixe, numero, IDcompte_payeur, date_edition, date_echeance, IDutilisateur, date_debut, date_fin, total, regle, solde, IDfamille, IDlot, nomLot, etat in listeFactures: if numero == None: numero = 0 date_edition = UTILS_Dates.DateEngEnDateDD(date_edition) date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) date_echeance = UTILS_Dates.DateEngEnDateDD(date_echeance) total = FloatToDecimal(total) if dictVentilation.has_key(IDfacture): totalVentilation = FloatToDecimal(dictVentilation[IDfacture]) else: totalVentilation = FloatToDecimal(0.0) if dictPrestations.has_key(IDfacture): totalPrestations = FloatToDecimal(dictPrestations[IDfacture]) else: totalPrestations = FloatToDecimal(0.0) solde_actuel = totalPrestations - totalVentilation if dictTitulaires.has_key(IDfamille) == True: titulaires = dictTitulaires[IDfamille][ "titulairesSansCivilite"] adresse_famille = dictTitulaires[IDfamille]["adresse"] dictTemp = { "IDfacture": IDfacture, "IDprefixe": IDprefixe, "prefixe": prefixe, "numero": numero, "IDcompte_payeur": IDcompte_payeur, "date_edition": date_edition, "date_echeance": date_echeance, "IDutilisateur": IDutilisateur, "date_debut": date_debut, "date_fin": date_fin, "total": total, "regle": regle, "solde": solde, "totalPrestations": totalPrestations, "totalVentilation": totalVentilation, "IDfamille": IDfamille, "titulaires": titulaires, "IDlot": IDlot, "nomLot": nomLot, "adresse_famille": adresse_famille, "etat": etat, } if dictInfosFamilles.has_key(IDcompte_payeur): dictTemp.update(dictInfosFamilles[IDcompte_payeur]) valide = True # 2ème série de filtres if self.filtres != None: for filtre in self.filtres: # IDfacture_intervalle if filtre["type"] == "solde_initial": if self.ComparateurFiltre( -solde, filtre["operateur"], filtre["montant"]) == False: valide = False if filtre["type"] == "solde_actuel": if self.ComparateurFiltre( -solde_actuel, filtre["operateur"], filtre["montant"]) == False: valide = False if filtre["type"] == "prelevement": if filtre["choix"] == True: if dictTemp["prelevement_activation"] == None: valide = False else: if dictTemp["prelevement_activation"] != None: valide = False if filtre["type"] == "email": if filtre["choix"] == True: if dictTemp["email_factures"] == None: valide = False else: if dictTemp["email_factures"] != None: valide = False if etat == "annulation" and self.afficherAnnulations == False: valide = False # Mémorisation des valeurs if valide == True: listeResultats.append(dictTemp) return listeResultats
def GetDoc(self): # Importation des données de la DB DB = GestionDB.DB() if self.IDfamille == None : conditions = "" req = """SELECT IDfamille, date_creation FROM familles;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() liste_IDfamille = [] for IDfamille, date_creation in listeDonnees : liste_IDfamille.append(IDfamille) else : conditions = "WHERE IDfamille=%d" % self.IDfamille liste_IDfamille = [self.IDfamille,] # Importation des pièces fournies req = """SELECT pieces.IDpiece, pieces.date_debut, pieces.date_fin, types_pieces.public, types_pieces.nom, individus.IDindividu, pieces.IDfamille, individus.prenom FROM pieces LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece LEFT JOIN individus ON individus.IDindividu = pieces.IDindividu ORDER BY date_debut;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictPieces = {"familles" : {}, "individus" : {}} for IDpiece, date_debut, date_fin, public, nom_piece, IDindividu, IDfamille, prenom in listeDonnees : dictPiece = {"IDpiece" : IDpiece, "nom_piece" : nom_piece, "date_debut" : UTILS_Dates.DateEngEnDateDD(date_debut), "date_fin": UTILS_Dates.DateEngEnDateDD(date_fin)} if public == "famille" : if dictPieces["familles"].has_key(IDfamille) == False : dictPieces["familles"][IDfamille] = [] dictPieces["familles"][IDfamille].append(dictPiece) if public == "individu" : if dictPieces["individus"].has_key(IDindividu) == False : dictPieces["individus"][IDindividu] = [] dictPieces["individus"][IDindividu].append(dictPiece) # Importation des cotisations champs_cotisations = [ ("IDcotisation", "cotisations.IDcotisation"), ("IDfamille", "cotisations.IDfamille"), ("IDindividu", "cotisations.IDindividu"), ("date_saisie", "cotisations.date_saisie"), ("date_creation_carte", "cotisations.date_creation_carte"), ("numero", "cotisations.numero"), ("date_debut", "cotisations.date_debut"), ("date_fin", "cotisations.date_fin"), ("observations", "cotisations.observations"), ("activites", "cotisations.activites"), ("type_cotisation", "types_cotisations.nom"), ("type", "types_cotisations.type"), ("nom_unite_cotisation", "unites_cotisations.nom"), ] req = """ SELECT %s FROM cotisations LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation LEFT JOIN unites_cotisations ON unites_cotisations.IDunite_cotisation = cotisations.IDunite_cotisation ORDER BY cotisations.date_debut ;""" % ", ".join([champ for nom, champ in champs_cotisations]) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictCotisations = {"familles" : {}, "individus" : {}} for donnees in listeDonnees : dictCotisation = {} for index in range(0, len(champs_cotisations)): dictCotisation[champs_cotisations[index][0]] = donnees[index] if dictCotisation["type"] == "famille" : IDfamille = dictCotisation["IDfamille"] if dictCotisations["familles"].has_key(IDfamille) == False : dictCotisations["familles"][IDfamille] = [] dictCotisations["familles"][IDfamille].append(dictCotisation) if dictCotisation["type"] == "individu" : IDindividu = dictCotisation["IDindividu"] if dictCotisations["individus"].has_key(IDindividu) == False : dictCotisations["individus"][IDindividu] = [] dictCotisations["individus"][IDindividu].append(dictCotisation) # Importation des prestations champs_prestations = [ ("IDprestation", "prestations.IDprestation"), ("date", "prestations.date"), ("label", "prestations.label"), ("montant", "prestations.montant"), ("numero_facture", "factures.numero"), ("activite", "activites.nom"), ("prenom", "individus.prenom"), ("IDfamille", "prestations.IDfamille"), ("IDindividu", "prestations.IDindividu"), ] req = """ SELECT %s FROM prestations LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture %s GROUP BY prestations.IDprestation ORDER BY prestations.date ;""" % (", ".join([champ for nom, champ in champs_prestations]), conditions) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictPrestations = {} for donnees in listeDonnees : dictPrestation = {} for index in range(0, len(champs_prestations)): dictPrestation[champs_prestations[index][0]] = donnees[index] if dictPrestation["numero_facture"] == None : dictPrestation["numero_facture"] = "" if dictPrestation["prenom"] == None : dictPrestation["prenom"] = "" IDfamille = dictPrestation["IDfamille"] if dictPrestations.has_key(IDfamille) == False : dictPrestations[IDfamille] = [] dictPrestations[IDfamille].append(dictPrestation) # Importation des consommations req = """ SELECT IDconso, date, activites.nom, consommations.etat, unites.nom, consommations.IDindividu, comptes_payeurs.IDfamille FROM consommations LEFT JOIN activites ON activites.IDactivite = consommations.IDactivite LEFT JOIN unites ON unites.IDunite = consommations.IDunite LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur %s GROUP BY consommations.IDconso ORDER BY date ;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictConsommations = {} for IDconso, date, nomActivite, etat, nomUnite, IDindividu, IDfamille in listeDonnees : dictConso = { "IDconso" : IDconso, "date" : date, "nomActivite" : nomActivite, "etat" : etat, "nomUnite" : nomUnite, } if dictConsommations.has_key(IDfamille) == False : dictConsommations[IDfamille] = {} if dictConsommations[IDfamille].has_key(IDindividu) == False : dictConsommations[IDfamille][IDindividu] = [] dictConsommations[IDfamille][IDindividu].append(dictConso) # Importation des factures # Récupération des totaux des prestations pour chaque facture req = """ SELECT prestations.IDfacture, SUM(prestations.montant) FROM prestations LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture GROUP BY prestations.IDfacture ;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictPrestationsFactures = {} for IDfacture, totalPrestations in listeDonnees : if IDfacture != None : dictPrestationsFactures[IDfacture] = totalPrestations # Récupération des factures req = """ SELECT factures.IDfacture, factures.numero, factures.date_edition, factures.date_debut, factures.date_fin, factures.total, factures.regle, factures.solde, comptes_payeurs.IDfamille FROM factures LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur %s ORDER BY factures.date_edition ;""" % conditions DB.ExecuterReq(req) listeFactures = DB.ResultatReq() # Récupération de la ventilation req = """ SELECT prestations.IDfacture, SUM(ventilation.montant) FROM ventilation LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture %s GROUP BY prestations.IDfacture ;""" % conditions.replace("IDfamille", "comptes_payeurs.IDfamille") DB.ExecuterReq(req) listeVentilation = DB.ResultatReq() dictVentilationFactures = {} for IDfacture, montantVentilation in listeVentilation : if IDfacture != None : dictVentilationFactures[IDfacture] = montantVentilation dictFactures = {} for IDfacture, numero, date_edition, date_debut, date_fin, total, regle, solde, IDfamille in listeFactures : if numero == None : numero = 0 total = FloatToDecimal(total) if dictVentilationFactures.has_key(IDfacture) : totalVentilation = FloatToDecimal(dictVentilationFactures[IDfacture]) else : totalVentilation = FloatToDecimal(0.0) if dictPrestationsFactures.has_key(IDfacture) : totalPrestations = FloatToDecimal(dictPrestationsFactures[IDfacture]) else : totalPrestations = FloatToDecimal(0.0) solde_actuel = totalPrestations - totalVentilation dictFacture = { "IDfacture" : IDfacture, "numero" : numero, "date_edition" : date_edition, "date_debut" : date_debut, "date_fin": date_fin, "montant" : float(totalPrestations), "montant_regle" : float(totalVentilation), "montant_solde" : float(solde_actuel), } if dictFactures.has_key(IDfamille) == False : dictFactures[IDfamille] = [] dictFactures[IDfamille].append(dictFacture) # Importation des règlements req = """SELECT reglements.IDreglement, comptes_payeurs.IDfamille, reglements.date, modes_reglements.label, emetteurs.nom, reglements.numero_piece, reglements.montant, payeurs.nom, reglements.observations, numero_quittancier, date_differe, date_saisie, depots.date FROM reglements LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = reglements.IDcompte_payeur LEFT JOIN modes_reglements ON reglements.IDmode=modes_reglements.IDmode LEFT JOIN emetteurs ON reglements.IDemetteur=emetteurs.IDemetteur LEFT JOIN payeurs ON reglements.IDpayeur=payeurs.IDpayeur LEFT JOIN depots ON reglements.IDdepot=depots.IDdepot %s GROUP BY reglements.IDreglement ORDER BY date_saisie ;""" % conditions.replace("IDfamille", "comptes_payeurs.IDfamille") DB.ExecuterReq(req) listeReglements = DB.ResultatReq() dictReglements = {} for IDreglement, IDfamille, date, mode, emetteur, numero, montant, payeur, observations, numero_quittancier, date_differe, date_saisie, date_encaissement in listeReglements : if numero == None : numero = "" if emetteur == None : emetteur = "" if observations == None: observations = "" if numero_quittancier == None: numero_quittancier = "" dictReglement = { "date" : date, "mode" : mode, "emetteur" : emetteur, "numero" : numero, "montant" : montant, "payeur": payeur, "observations" : observations, "numero_quittancier" : numero_quittancier, "date_differe" : date_differe, "date_saisie" : date_saisie, "date_encaissement": date_encaissement, } if dictReglements.has_key(IDfamille) == False : dictReglements[IDfamille] = [] dictReglements[IDfamille].append(dictReglement) DB.Close() # Récupération des infos individus infos = UTILS_Infos_individus.Informations() # Génération du XML doc = Document() # Racine Familles node_racine = doc.createElement("familles") doc.appendChild(node_racine) for IDfamille in liste_IDfamille : # Famille : Infos générales node_famille = doc.createElement("famille") node_famille.setAttribute("id", str(IDfamille)) node_racine.appendChild(node_famille) for key, valeur in infos.dictFamilles[IDfamille].iteritems(): if key.startswith("FAMILLE_"): node = doc.createElement(key.replace("FAMILLE_", "").lower()) node.setAttribute("valeur", unicode(valeur)) node_famille.appendChild(node) # Famille : Quotients if infos.dictFamilles[IDfamille].has_key("qf"): node_qf = doc.createElement(u"quotients_familiaux") node_famille.appendChild(node_qf) for dictQF in infos.dictFamilles[IDfamille]["qf"]: node = doc.createElement(u"quotient") node.setAttribute("date_debut", dictQF["date_debut"]) node.setAttribute("date_fin", dictQF["date_fin"]) node.setAttribute("quotient", str(dictQF["quotient"])) node.setAttribute("observations", dictQF["observations"]) node_qf.appendChild(node) # Famille : Messages if infos.dictFamilles[IDfamille].has_key("messages"): node_messages = doc.createElement(u"messages") node_famille.appendChild(node_messages) for dictMessage in infos.dictFamilles[IDfamille]["messages"]["liste"]: node = doc.createElement(u"message") node.setAttribute("categorie_nom", dictMessage["categorie_nom"]) node.setAttribute("date_saisie", dictMessage["date_saisie"]) node.setAttribute("date_parution", dictMessage["date_parution"]) node.setAttribute("nom", dictMessage["nom"]) node.setAttribute("texte", dictMessage["texte"]) node_messages.appendChild(node) # Famille : Questionnaires if infos.dictFamilles[IDfamille].has_key("questionnaires"): node_questionnaires = doc.createElement(u"questionnaires") node_famille.appendChild(node_questionnaires) for dictQuestionnaire in infos.dictFamilles[IDfamille]["questionnaires"]: node = doc.createElement(u"questionnaire") node.setAttribute("question", dictQuestionnaire["label"]) node.setAttribute("reponse", unicode(dictQuestionnaire["reponse"])) node_questionnaires.appendChild(node) # Famille : Pièces if dictPieces["familles"].has_key(IDfamille): node_pieces = doc.createElement(u"pieces") node_famille.appendChild(node_pieces) for dictPiece in dictPieces["familles"][IDfamille]: node = doc.createElement(u"piece") node.setAttribute("nom_piece", dictPiece["nom_piece"]) node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictPiece["date_debut"])) node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictPiece["date_fin"])) node_pieces.appendChild(node) # Famille : Cotisations if dictCotisations["familles"].has_key(IDfamille): node_cotisations = doc.createElement(u"cotisations") node_famille.appendChild(node_cotisations) for dictCotisation in dictCotisations["familles"][IDfamille]: node = doc.createElement(u"cotisation") node.setAttribute("date_saisie", UTILS_Dates.DateDDEnFr(dictCotisation["date_saisie"])) node.setAttribute("date_creation_carte", UTILS_Dates.DateDDEnFr(dictCotisation["date_creation_carte"])) node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictCotisation["date_debut"])) node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictCotisation["date_fin"])) node.setAttribute("numero", dictCotisation["numero"]) node.setAttribute("type_cotisation", dictCotisation["type_cotisation"]) node.setAttribute("nom_unite_cotisation", dictCotisation["nom_unite_cotisation"]) node.setAttribute("observations", dictCotisation["observations"]) node.setAttribute("activites", dictCotisation["activites"]) node_cotisations.appendChild(node) # Famille : Prestations if dictPrestations.has_key(IDfamille): node_prestations = doc.createElement(u"prestations") node_famille.appendChild(node_prestations) for dictPrestation in dictPrestations[IDfamille]: node = doc.createElement(u"prestation") node.setAttribute("date", UTILS_Dates.DateEngFr(dictPrestation["date"])) node.setAttribute("label", dictPrestation["label"]) node.setAttribute("devise", SYMBOLE) node.setAttribute("montant", u"%.2f" % dictPrestation["montant"]) node.setAttribute("numero_facture", str(dictPrestation["numero_facture"])) node.setAttribute("activite", dictPrestation["activite"]) node.setAttribute("prenom", dictPrestation["prenom"]) node_prestations.appendChild(node) # Famille : Factures if dictFactures.has_key(IDfamille): node_factures = doc.createElement(u"factures") node_famille.appendChild(node_factures) for dictFacture in dictFactures[IDfamille]: node = doc.createElement(u"facture") node.setAttribute("date_edition", UTILS_Dates.DateEngFr(dictFacture["date_edition"])) node.setAttribute("date_debut", UTILS_Dates.DateEngFr(dictFacture["date_debut"])) node.setAttribute("date_fin", UTILS_Dates.DateEngFr(dictFacture["date_fin"])) node.setAttribute("numero_facture", str(dictFacture["numero"])) node.setAttribute("devise", SYMBOLE) node.setAttribute("montant", u"%.2f" % dictFacture["montant"]) node.setAttribute("montant_regle", u"%.2f" % dictFacture["montant_regle"]) node.setAttribute("montant_solde", u"%.2f" % dictFacture["montant_solde"]) node_factures.appendChild(node) # Famille : Règlements if dictReglements.has_key(IDfamille): node_reglements = doc.createElement(u"reglements") node_famille.appendChild(node_reglements) for dictReglement in dictReglements[IDfamille]: node = doc.createElement(u"reglement") node.setAttribute("date", UTILS_Dates.DateEngFr(dictReglement["date"])) node.setAttribute("date_differe", UTILS_Dates.DateEngFr(dictReglement["date_differe"])) node.setAttribute("date_saisie", UTILS_Dates.DateEngFr(dictReglement["date_saisie"])) node.setAttribute("date_encaissement", UTILS_Dates.DateEngFr(dictReglement["date_encaissement"])) node.setAttribute("mode", dictReglement["mode"]) node.setAttribute("emetteur", dictReglement["emetteur"]) node.setAttribute("numero_piece", dictReglement["numero"]) node.setAttribute("devise", SYMBOLE) node.setAttribute("montant", u"%.2f" % dictReglement["montant"]) node.setAttribute("payeur", dictReglement["payeur"]) node.setAttribute("observations", dictReglement["observations"]) node.setAttribute("numero_quittancier", dictReglement["numero_quittancier"]) node_reglements.appendChild(node) # Individus node_individus = doc.createElement(u"individus") node_famille.appendChild(node_individus) if infos.dictRattachements["familles"].has_key(IDfamille): for dictRattachement in infos.dictRattachements["familles"][IDfamille]: IDindividu = dictRattachement["IDindividu"] node_individu = doc.createElement(u"individu") node_individu.setAttribute("id", str(IDindividu)) node_individus.appendChild(node_individu) # Individu : données générales for key, champ in infos.GetListeChampsIndividus(): valeur = infos.dictIndividus[IDindividu][key] if isinstance(valeur, (unicode, str)): node = doc.createElement(key.replace("INDIVIDU_", "").lower()) node.setAttribute("valeur", unicode(valeur)) node_individu.appendChild(node) # Individu : Messages if infos.dictIndividus[IDindividu].has_key("messages"): node_messages = doc.createElement(u"messages") node_individu.appendChild(node_messages) for dictMessage in infos.dictIndividus[IDindividu]["messages"]["liste"]: node = doc.createElement(u"message") node.setAttribute("categorie_nom", dictMessage["categorie_nom"]) node.setAttribute("date_saisie", dictMessage["date_saisie"]) node.setAttribute("date_parution", dictMessage["date_parution"]) node.setAttribute("nom", dictMessage["nom"]) node.setAttribute("texte", dictMessage["texte"]) node_messages.appendChild(node) # Individu : Infos médicales if infos.dictIndividus[IDindividu].has_key("medical"): node_medicales = doc.createElement(u"infos_medicales") node_individu.appendChild(node_medicales) for dictMedicale in infos.dictIndividus[IDindividu]["medical"]["liste"]: node = doc.createElement(u"info_medicale") node.setAttribute("intitule", dictMedicale["intitule"]) node.setAttribute("description", dictMedicale["description"]) node.setAttribute("description_traitement", dictMedicale["description_traitement"]) node.setAttribute("date_debut_traitement", dictMedicale["date_debut_traitement"]) node.setAttribute("date_fin_traitement", dictMedicale["date_fin_traitement"]) node_medicales.appendChild(node) # Individu : Inscriptions if infos.dictIndividus[IDindividu].has_key("inscriptions"): node_inscriptions = doc.createElement(u"inscriptions") node_individu.appendChild(node_inscriptions) for dictInscription in infos.dictIndividus[IDindividu]["inscriptions"]["liste"]: node = doc.createElement(u"inscription") node.setAttribute("activite", dictInscription["activite"]) node.setAttribute("groupe", dictInscription["groupe"]) node.setAttribute("categorie_tarif", dictInscription["categorie_tarif"]) node.setAttribute("parti", dictInscription["parti"]) node.setAttribute("date_inscription", dictInscription["date_inscription"]) node_inscriptions.appendChild(node) # Individu : Questionnaires if infos.dictIndividus[IDindividu].has_key("questionnaires"): node_questionnaires = doc.createElement(u"questionnaires") node_individu.appendChild(node_questionnaires) for dictQuestionnaire in infos.dictIndividus[IDindividu]["questionnaires"]: node = doc.createElement(u"questionnaire") node.setAttribute("question", dictQuestionnaire["label"]) node.setAttribute("reponse", unicode(dictQuestionnaire["reponse"])) node_questionnaires.appendChild(node) # Individu : Scolarité if infos.dictIndividus[IDindividu].has_key("scolarite"): node_scolarite = doc.createElement(u"scolarite") node_individu.appendChild(node_scolarite) for dictScolarite in infos.dictIndividus[IDindividu]["scolarite"]["liste"]: node = doc.createElement(u"etape") node.setAttribute("date_debut", dictScolarite["date_debut"]) node.setAttribute("date_fin", dictScolarite["date_fin"]) node.setAttribute("ecole_nom", dictScolarite["ecole_nom"]) node.setAttribute("classe_nom", dictScolarite["classe_nom"]) node.setAttribute("niveau_nom", dictScolarite["niveau_nom"]) node.setAttribute("niveau_abrege", dictScolarite["niveau_abrege"]) node_scolarite.appendChild(node) # Individu : Pièces if dictPieces["individus"].has_key(IDindividu): node_pieces = doc.createElement(u"pieces") node_individu.appendChild(node_pieces) for dictPiece in dictPieces["individus"][IDindividu]: node = doc.createElement(u"piece") node.setAttribute("nom_piece", dictPiece["nom_piece"]) node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictPiece["date_debut"])) node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictPiece["date_fin"])) node_pieces.appendChild(node) # Individu : Cotisations if dictCotisations["individus"].has_key(IDindividu): node_cotisations = doc.createElement(u"cotisations") node_individu.appendChild(node_cotisations) for dictCotisation in dictCotisations["individus"][IDindividu]: node = doc.createElement(u"cotisation") node.setAttribute("date_saisie", UTILS_Dates.DateDDEnFr(dictCotisation["date_saisie"])) node.setAttribute("date_creation_carte", UTILS_Dates.DateDDEnFr(dictCotisation["date_creation_carte"])) node.setAttribute("date_debut", UTILS_Dates.DateDDEnFr(dictCotisation["date_debut"])) node.setAttribute("date_fin", UTILS_Dates.DateDDEnFr(dictCotisation["date_fin"])) node.setAttribute("numero", dictCotisation["numero"]) node.setAttribute("type_cotisation", dictCotisation["type_cotisation"]) node.setAttribute("nom_unite_cotisation", dictCotisation["nom_unite_cotisation"]) node.setAttribute("observations", dictCotisation["observations"]) node.setAttribute("activites", dictCotisation["activites"]) node_cotisations.appendChild(node) # Individu : Consommations if dictConsommations.has_key(IDfamille): if dictConsommations[IDfamille].has_key(IDindividu): node_consommations = doc.createElement(u"consommations") node_individu.appendChild(node_consommations) for dictConso in dictConsommations[IDfamille][IDindividu]: node = doc.createElement(u"consommation") node.setAttribute("date", UTILS_Dates.DateEngFr(dictConso["date"])) node.setAttribute("activite", dictConso["nomActivite"]) node.setAttribute("etat", dictConso["etat"]) node.setAttribute("unite", dictConso["nomUnite"]) node_consommations.appendChild(node) # Renvoie le doc return doc
def __init__(self, parent, donnees, dictFacturation): self.IDcotisation = donnees[0] self.IDfamille = donnees[1] self.IDindividu = donnees[2] self.IDtype_cotisation = donnees[3] self.IDunite_cotisation = donnees[4] self.date_saisie = UTILS_Dates.DateEngEnDateDD(donnees[5]) self.IDutilisateur = donnees[6] self.date_creation_carte = donnees[7] self.numero = donnees[8] self.IDdepot_cotisation = donnees[9] self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[10]) self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[11]) self.IDprestation = donnees[12] self.nomTypeCotisation = donnees[13] self.typeTypeCotisation = donnees[14] self.typeHasCarte = donnees[15] self.nomUniteCotisation = donnees[16] self.IDcompte_payeur = donnees[17] self.observations = donnees[18] self.activites = donnees[19] if self.activites == None : self.activites = "" # Activites texte = "" if len(self.activites) > 0 : listeTemp = [] listeIDactivites = UTILS_Divers.ConvertChaineEnListe(self.activites) for IDactivite in listeIDactivites : if parent.dictActivites.has_key(IDactivite) : nomActivite = parent.dictActivites[IDactivite]["nom"] listeTemp.append(nomActivite) if len(listeTemp) > 0 : texte = ", ".join(listeTemp) self.activitesStr = texte # Nom cotisation self.nomCotisation = u"%s - %s" % (self.nomTypeCotisation, self.nomUniteCotisation) # Numéro de cotisation try : self.numero_int = int(self.numero) except : self.numero_int = None # Titulaires famille if parent.titulaires.has_key(self.IDfamille) : self.nomsTitulaires = parent.titulaires[self.IDfamille]["titulairesSansCivilite"] else : self.nomsTitulaires = "nom inconnu" # Type if self.typeTypeCotisation == "famille" : self.typeStr = _(u"Cotisation familiale") else: self.typeStr = _(u"Cotisation individuelle") # Validité dateDuJour = datetime.date.today() if dateDuJour >= self.date_debut and dateDuJour <= self.date_fin : self.valide = True else: self.valide = False # Dépôt if self.IDdepot_cotisation == None : self.depotStr = _(u"Non déposée") else: self.depotStr = _(u"Dépôt n°%d") % self.IDdepot_cotisation # Nom des titulaires de famille self.beneficiaires = "" self.rue = "" self.cp = "" self.ville = "" if self.IDfamille != None : self.beneficiaires = _(u"IDfamille n°%d") % self.IDfamille if parent.dictFamillesRattachees != None : if parent.dictFamillesRattachees.has_key(self.IDfamille) : self.beneficiaires = parent.dictFamillesRattachees[self.IDfamille]["nomsTitulaires"] else: self.beneficiaires = parent.titulaires[self.IDfamille]["titulairesSansCivilite"] self.rue = parent.titulaires[self.IDfamille]["adresse"]["rue"] self.cp = parent.titulaires[self.IDfamille]["adresse"]["cp"] self.ville = parent.titulaires[self.IDfamille]["adresse"]["ville"] if self.IDindividu != None and parent.individus.has_key(self.IDindividu) : self.beneficiaires = parent.individus[self.IDindividu]["nom_complet"] self.rue = parent.individus[self.IDindividu]["rue"] self.cp = parent.individus[self.IDindividu]["cp"] self.ville = parent.individus[self.IDindividu]["ville"] # Facturation self.montant = 0.0 self.ventilation = 0.0 self.dateReglement = None self.modeReglement = None if dictFacturation.has_key(self.IDprestation): self.montant = dictFacturation[self.IDprestation]["montant"] self.ventilation = dictFacturation[self.IDprestation]["ventilation"] self.dateReglement = dictFacturation[self.IDprestation]["dateReglement"] self.modeReglement = dictFacturation[self.IDprestation]["modeReglement"] self.solde = float(FloatToDecimal(self.montant) - FloatToDecimal(self.ventilation)) if self.solde > 0.0 : self.solde = -self.solde if self.montant == None : self.solde = 0.0
def Importation(self): DB = GestionDB.DB() if len(self.listeActivites) == 0: conditionActivites = "()" elif len(self.listeActivites) == 1: conditionActivites = "(%d)" % self.listeActivites[0] else: conditionActivites = str(tuple(self.listeActivites)) if self.affichage_caisse: conditionsCaisse = "AND aides.IDcaisse=%d" % self.affichage_caisse else: conditionsCaisse = "" # Déductions req = """SELECT IDdeduction, deductions.IDprestation, deductions.IDcompte_payeur, deductions.date, deductions.montant, deductions.label, deductions.IDaide, individus.nom, individus.prenom, individus.date_naiss, prestations.label, prestations.montant, prestations.montant_initial, prestations.IDfamille, prestations.IDactivite, activites.abrege, prestations.IDindividu, prestations.date, prestations.IDfacture, familles.IDcaisse, familles.num_allocataire, caisses.nom, aides.nom FROM deductions LEFT JOIN prestations ON prestations.IDprestation = deductions.IDprestation LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite LEFT JOIN familles ON familles.IDfamille = prestations.IDfamille LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse LEFT JOIN aides ON aides.IDaide = deductions.IDaide WHERE deductions.date>='%s' AND deductions.date<='%s' AND prestations.IDactivite IN %s %s;""" % (self.date_debut, self.date_fin, conditionActivites, conditionsCaisse) DB.ExecuterReq(req) listeDeductions = DB.ResultatReq() DB.Close() # Calcul des données dictResultats = {} listePrestations = [] for IDdeduction, IDprestation, IDcompte_payeur, date, montant, label, IDaide, nomIndividu, prenomIndividu, date_naiss, labelPrestation, montantPrestation, montantInitialPrestation, IDfamille, IDactivite, abregeActivite, IDindividu, datePrestation, IDfacture, IDcaisse, num_allocataire, nomCaisse, nomAide in listeDeductions: date = UTILS_Dates.DateEngEnDateDD(date) datePrestation = UTILS_Dates.DateEngEnDateDD(datePrestation) date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss) mois = date.month annee = date.year nom_complet_individu = u"%s %s" % (nomIndividu, prenomIndividu) montantInitialPrestation = FloatToDecimal(montantInitialPrestation) montant = FloatToDecimal(montant) montantPrestation = FloatToDecimal(montantPrestation) # Recherche du regroupement try : if self.affichage_regroupement == "jour" : regroupement = date if self.affichage_regroupement == "mois" : regroupement = (annee, mois) if self.affichage_regroupement == "annee" : regroupement = annee if self.affichage_regroupement == "montant_deduction": regroupement = montant if self.affichage_regroupement == "nom_aide" : regroupement = nomAide if self.affichage_regroupement == "nom_deduction": regroupement = label if self.affichage_regroupement == "ville_residence" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_VILLE"] if self.affichage_regroupement == "secteur" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_SECTEUR"] if self.affichage_regroupement == "famille" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM"] if self.affichage_regroupement == "individu": regroupement = IDindividu if self.affichage_regroupement == "regime" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_REGIME"] if self.affichage_regroupement == "caisse" : regroupement = self.dictInfosFamilles[IDfamille]["FAMILLE_NOM_CAISSE"] # QF if self.affichage_regroupement == "qf" : regroupement = None qf = self.dictInfosFamilles[IDfamille]["FAMILLE_QF_ACTUEL_INT"] for x in range(0, 10000, 100) : min, max = x, x+99 if qf >= min and qf <= max : regroupement = (min, max) # Questionnaires if self.affichage_regroupement.startswith("question_") and "famille" in self.affichage_regroupement: regroupement = self.dictInfosFamilles[IDfamille]["QUESTION_%s" % self.affichage_regroupement[17:]] except : regroupement = None if regroupement in ("", None): regroupement = _(u"- Non renseigné -") # Colonne if labelPrestation not in listePrestations: listePrestations.append(labelPrestation) # Regroupement if regroupement not in dictResultats: dictResultats[regroupement] = { "caisse": nomCaisse, "num_allocataire": num_allocataire, "prestations": {}, "montant_initial": FloatToDecimal(0), "montant_deduction": FloatToDecimal(0), "montant_final": FloatToDecimal(0), "liste_dates": [], "individu": nom_complet_individu, "famille": self.dictInfosFamilles[IDfamille]["FAMILLE_NOM"], } dictResultats[regroupement]["montant_initial"] += montantInitialPrestation dictResultats[regroupement]["montant_deduction"] += montant dictResultats[regroupement]["montant_final"] += montantPrestation if date not in dictResultats[regroupement]["liste_dates"]: dictResultats[regroupement]["liste_dates"].append(date) # Prestations if labelPrestation not in dictResultats[regroupement]["prestations"]: dictResultats[regroupement]["prestations"][labelPrestation] = { "nbre": 0, "liste_dates": [], "montant_initial": montantInitialPrestation, "montant_deduction": montant, "montant_final": montantPrestation, } dictResultats[regroupement]["prestations"][labelPrestation]["nbre"] += 1 if date not in dictResultats[regroupement]["prestations"][labelPrestation]["liste_dates"]: dictResultats[regroupement]["prestations"][labelPrestation]["liste_dates"].append(date) dictResultats[regroupement]["prestations"][labelPrestation]["montant_initial"] += montantInitialPrestation dictResultats[regroupement]["prestations"][labelPrestation]["montant_deduction"] += montant dictResultats[regroupement]["prestations"][labelPrestation]["montant_final"] += montantPrestation return dictResultats, listePrestations
def OnBoutonFichier(self, event): if self.ValidationSaisie() == False : return # Récupération des paramètres tracks = self.ctrl_factures.GetTracksCoches() date_emission = self.ctrl_date.GetDate() code_col = self.ctrl_code_coll.GetValue() code_nat = self.ctrl_code_nat.GetValue() code_rec = self.ctrl_code_rec.GetValue() exercice = self.ctrl_exercice.GetValue() num_role = self.ctrl_num_role.GetValue() listeLignes = [] for track in tracks : if track.prelevement == True : prelevement = True prelevement_etab = track.prelevement_etab prelevement_guichet = track.prelevement_guichet prelevement_compte = track.prelevement_numero prelevement_cle = track.prelevement_cle prelevement_titulaire = track.prelevement_payeur else : prelevement = False prelevement_etab = "" prelevement_guichet = "" prelevement_compte = "" prelevement_cle = "" prelevement_titulaire = "" if track.adresse_famille["rue"] != None : rue = track.adresse_famille["rue"] else : rue = u"" if track.adresse_famille["cp"] != None : cp = track.adresse_famille["cp"] else : cp = u"" if track.adresse_famille["ville"] != None : ville = track.adresse_famille["ville"] else : ville = u"" dictDonnees = { "ROLCOL" : code_col, # Code Collectivité "ROLNAT" : code_nat, # Nature du rôle "ROLEX" : exercice, # Exercice "ROLREC" : code_rec, # Code Recette "ROLROL" : num_role, # Numéro de rôle "date_edition" : date_emission, # Date d'édition "ROLDET" : track.numero, # Numéro de dette "ROLEAU" : int(str(FloatToDecimal(-track.solde)).replace(".", "")), # Montant de la facture en centimes "nom" : track.nomsTitulaires, # Nom du débiteur "rue" : rue, # Rue de résidence du débiteur "code_postal" : cp, # Code postal de la ville de résidence du débiteur "ville" : ville, # Nom de la ville de résidence du débiteur "objet" : _(u"Facture n°%s") % track.numero, # Objet de la recette (64 caract max) "prelevement" : prelevement, # Activation du prélèvement "prelevement_etab" : prelevement_etab, # Code établissement "prelevement_guichet" : prelevement_guichet, # Code Guichet "prelevement_compte" : prelevement_compte, # Numéro de compte "prelevement_cle" : prelevement_cle, # Clé RIB "prelevement_titulaire" : prelevement_titulaire, # Nom titulaire du compte } ligne = UTILS_Helios.GetLigne(dictDonnees) listeLignes.append(ligne) # Finalisation du texte texte = "".join(listeLignes) # Demande à l'utilisateur le nom de fichier et le répertoire de destination nomFichier = "Rolmre.txt" wildcard = "Fichier texte (*.txt)|*.txt|" \ "All files (*.*)|*.*" sp = wx.StandardPaths.Get() cheminDefaut = sp.GetDocumentsDir() dlg = wx.FileDialog( None, message = _(u"Veuillez sélectionner le répertoire de destination et le nom du fichier"), defaultDir=cheminDefaut, defaultFile = nomFichier, wildcard = wildcard, style = wx.SAVE ) dlg.SetFilterIndex(0) if dlg.ShowModal() == wx.ID_OK: cheminFichier = dlg.GetPath() dlg.Destroy() else: dlg.Destroy() return # Le fichier de destination existe déjà : if os.path.isfile(cheminFichier) == True : dlg = wx.MessageDialog(None, _(u"Un fichier portant ce nom existe déjà. \n\nVoulez-vous le remplacer ?"), "Attention !", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_EXCLAMATION) if dlg.ShowModal() == wx.ID_NO : return False dlg.Destroy() else: dlg.Destroy() # Création du fichier texte f = open(cheminFichier, "w") f.write(texte.encode("iso-8859-15")) f.close() # Confirmation de création du fichier et demande d'ouverture directe dans Excel txtMessage = _(u"Le fichier a été créé avec succès.\n\nSouhaitez-vous l'ouvrir dès maintenant ?") dlgConfirm = wx.MessageDialog(None, txtMessage, _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.ICON_QUESTION) reponse = dlgConfirm.ShowModal() dlgConfirm.Destroy() if reponse == wx.ID_NO: return else: FonctionsPerso.LanceFichierExterne(cheminFichier)
def Importation(onlyNonVentiles=True, IDcompte_payeur=None): DB = GestionDB.DB() if IDcompte_payeur != None: conditionCompte = "WHERE IDcompte_payeur=%d" % IDcompte_payeur else: conditionCompte = "" # Récupère les comptes payeurs req = """SELECT IDcompte_payeur, IDfamille FROM comptes_payeurs %s ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listeComptes = DB.ResultatReq() # Récupère la ventilation req = """SELECT IDcompte_payeur, SUM(montant) AS total_ventilations FROM ventilation %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listeVentilations = DB.ResultatReq() dictVentilations = {} for IDcompte_payeur, total_ventilations in listeVentilations: dictVentilations[IDcompte_payeur] = total_ventilations # Récupère les prestations req = """SELECT IDcompte_payeur, SUM(montant) AS total_prestations FROM prestations %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listePrestations = DB.ResultatReq() dictPrestations = {} for IDcompte_payeur, total_prestations in listePrestations: dictPrestations[IDcompte_payeur] = total_prestations # Récupère les règlements req = """SELECT IDcompte_payeur, SUM(montant) AS total_reglements FROM reglements %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listeReglements = DB.ResultatReq() dictReglements = {} for IDcompte_payeur, total_reglements in listeReglements: dictReglements[IDcompte_payeur] = total_reglements DB.Close() # Récupération des titulaires de familles dictTitulaires = UTILS_Titulaires.GetTitulaires() # Traitement des données listeListeView = [] for IDcompte_payeur, IDfamille in listeComptes: if dictVentilations.has_key(IDcompte_payeur): total_ventilations = FloatToDecimal( dictVentilations[IDcompte_payeur]) else: total_ventilations = FloatToDecimal(0.0) if dictPrestations.has_key(IDcompte_payeur): total_prestations = FloatToDecimal( dictPrestations[IDcompte_payeur]) else: total_prestations = FloatToDecimal(0.0) if dictReglements.has_key(IDcompte_payeur): total_reglements = FloatToDecimal(dictReglements[IDcompte_payeur]) else: total_reglements = FloatToDecimal(0.0) item = (IDcompte_payeur, IDfamille, total_ventilations, total_reglements, total_prestations) track = Track(dictTitulaires, item) if onlyNonVentiles == True: # Afficher seulement ceux qui sont mal ventilés if track.reste_a_ventiler > FloatToDecimal(0.0): listeListeView.append(track) else: # Afficher toute la liste listeListeView.append(track) return listeListeView
def VentilationAuto(IDcompte_payeur=None, IDreglement=None): """ Ventilation auto de tous les règlements d'un compte payeur ou d'un règlement spécifique """ DB = GestionDB.DB() if IDreglement != None: conditionReglement = "AND IDreglement=%d" % IDreglement else: conditionReglement = "" # Récupère la ventilation req = """SELECT IDventilation, IDreglement, IDprestation, montant FROM ventilation WHERE IDcompte_payeur=%d;""" % IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictVentilations = {} dictVentilationsReglement = {} dictVentilationsPrestation = {} for IDventilation, IDreglement, IDprestation, montant in listeDonnees: dictVentilations[IDventilation] = { "IDreglement": IDreglement, "IDprestation": IDprestation, "montant": FloatToDecimal(montant) } if dictVentilationsReglement.has_key(IDreglement) == False: dictVentilationsReglement[IDreglement] = [] dictVentilationsReglement[IDreglement].append(IDventilation) if dictVentilationsPrestation.has_key(IDprestation) == False: dictVentilationsPrestation[IDprestation] = [] dictVentilationsPrestation[IDprestation].append(IDventilation) # Récupère les prestations req = """SELECT IDprestation, date, montant FROM prestations WHERE IDcompte_payeur=%d ORDER BY date;""" % IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() listePrestations = [] for IDprestation, date, montant in listeDonnees: listePrestations.append({ "IDprestation": IDprestation, "date": date, "montant": FloatToDecimal(montant) }) # Vérifie qu'il n'y a pas de prestations négatives for dictPrestation in listePrestations: IDprestation = dictPrestation["IDprestation"] montantVentilation = FloatToDecimal(0.0) if dictVentilationsPrestation.has_key(IDprestation): for IDventilation in dictVentilationsPrestation[IDprestation]: montantVentilation += dictVentilations[IDventilation][ "montant"] ResteAVentiler = dictPrestation["montant"] - montantVentilation if ResteAVentiler < FloatToDecimal(0.0): dlg = wx.MessageDialog( None, _(u"Ventilation automatique impossible !\n\nLa ventilation automatique n'est pas compatible avec les prestations comportant un montant négatif ! Vous devez donc effectuer une ventilation manuelle." ), _(u"Information"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() DB.Close() return False # Récupère les règlements req = """SELECT IDreglement, date, montant FROM reglements WHERE IDcompte_payeur=%d %s ORDER BY date;""" % (IDcompte_payeur, conditionReglement) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() listeReglements = [] for IDreglement, date, montant in listeDonnees: listeReglements.append({ "IDreglement": IDreglement, "date": date, "montant": FloatToDecimal(montant) }) # Vérification de la ventilation de chaque règlement listeReglementsAVentiler = [] for dictReglement in listeReglements: IDreglement = dictReglement["IDreglement"] # Recherche s'il reste du crédit à ventiler dans ce règlement montantVentilation = FloatToDecimal(0.0) if dictVentilationsReglement.has_key(IDreglement): for IDventilation in dictVentilationsReglement[IDreglement]: montantVentilation += dictVentilations[IDventilation][ "montant"] credit = dictReglement["montant"] - montantVentilation if credit > FloatToDecimal(0.0): # Recherche s'il reste des prestations à ventiler pour cette famille listePrestationsAVentiler = [] for dictPrestation in listePrestations: IDprestation = dictPrestation["IDprestation"] montantVentilation = FloatToDecimal(0.0) if dictVentilationsPrestation.has_key(IDprestation): for IDventilation in dictVentilationsPrestation[ IDprestation]: montantVentilation += dictVentilations[IDventilation][ "montant"] ResteAVentiler = dictPrestation["montant"] - montantVentilation if ResteAVentiler > FloatToDecimal(0.0): # Calcul du montant qui peut être ventilé montant = ResteAVentiler if credit < montant: montant = credit if montant > FloatToDecimal(0.0): # Modification d'une ventilation existante ventilationTrouvee = False if dictVentilationsPrestation.has_key(IDprestation): for IDventilation in dictVentilationsPrestation[ IDprestation]: if dictVentilations[IDventilation][ "IDreglement"] == IDreglement: nouveauMontant = montant + montantVentilation DB.ReqMAJ("ventilation", [ ("montant", float(nouveauMontant)), ], "IDventilation", IDventilation) # Mémorisation du nouveau montant dictVentilations[IDventilation][ "montant"] = nouveauMontant ResteAVentiler -= montant credit -= montant ventilationTrouvee = True # Création d'une ventilation if ventilationTrouvee == False: listeDonnees = [ ("IDreglement", IDreglement), ("IDcompte_payeur", IDcompte_payeur), ("IDprestation", IDprestation), ("montant", float(montant)), ] IDventilation = DB.ReqInsert( "ventilation", listeDonnees) # Mémorisation de la nouvelle ventilation dictVentilations[IDventilation] = { "IDreglement": IDreglement, "IDprestation": IDprestation, "montant": montant } if dictVentilationsReglement.has_key( IDreglement) == False: dictVentilationsReglement[IDreglement] = [] dictVentilationsReglement[IDreglement].append( IDventilation) if dictVentilationsPrestation.has_key( IDprestation) == False: dictVentilationsPrestation[IDprestation] = [] dictVentilationsPrestation[IDprestation].append( IDventilation) ResteAVentiler -= montant credit -= montant DB.Close() return True
def GetTracks(self): """ Récupération des données """ # Récupération des conditions if len(self.listeActivites) == 0 : conditionActivites = "()" elif len(self.listeActivites) == 1 : conditionActivites = "(%d)" % self.listeActivites[0] else : conditionActivites = str(tuple(self.listeActivites)) if len(self.listeModes) == 0 : conditionModes = "()" elif len(self.listeModes) == 1 : conditionModes = "(%d)" % self.listeModes[0] else : conditionModes = str(tuple(self.listeModes)) if self.dateNaiss != None : conditionDateNaiss = "AND individus.date_naiss >= '%s' " % self.dateNaiss else: conditionDateNaiss = "" DB = GestionDB.DB() # Recherche de la ventilation req = """SELECT IDventilation, ventilation.IDreglement, IDprestation, ventilation.montant, reglements.IDmode FROM ventilation LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement WHERE reglements.IDmode IN %s ;""" % conditionModes DB.ExecuterReq(req) listeVentilation = DB.ResultatReq() dictVentilation = {} for IDventilation, IDreglement, IDprestation, montant, IDmode in listeVentilation : montant = FloatToDecimal(montant) if dictVentilation.has_key(IDprestation) == False : dictVentilation[IDprestation] = FloatToDecimal(0.0) dictVentilation[IDprestation] += montant # Recherche des prestations ## req = """SELECT prestations.label, prestations.IDactivite, activites.nom, COUNT(prestations.IDprestation), SUM(prestations.montant) ## FROM prestations ## LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite ## LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu ## WHERE prestations.IDactivite IN %s ## AND (prestations.date>='%s' AND prestations.date<='%s') ## AND prestations.categorie='consommation' ## %s ## GROUP BY prestations.label, prestations.IDactivite ## ;""" % (conditionActivites, self.date_debut, self.date_fin, conditionDateNaiss) req = """SELECT prestations.IDprestation, prestations.label, prestations.IDactivite, activites.nom, prestations.montant, prestations.IDcompte_payeur, prestations.IDfamille, individus.IDindividu, individus.nom, individus.prenom, individus.date_naiss, individus.IDcivilite FROM prestations LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu WHERE prestations.IDactivite IN %s AND individus.IDindividu IS NOT NULL AND (prestations.date>='%s' AND prestations.date<='%s') %s ;""" % (conditionActivites, self.date_debut, self.date_fin, conditionDateNaiss) DB.ExecuterReq(req) listePrestations = DB.ResultatReq() DB.Close() dictPrestations = {} for IDprestation, label, IDactivite, nomActivite, montant, IDcompte_payeur, IDfamille, IDindividu, nom, prenom, date_naiss, IDcivilite in listePrestations : valide = True if self.dateNaiss != None : if date_naiss < str(self.dateNaiss) : valide = False if valide == True : montant = FloatToDecimal(montant) if dictVentilation.has_key(IDprestation) : regle = dictVentilation[IDprestation] else : regle = FloatToDecimal(0.0) impaye = montant - regle # Mémorisation if dictPrestations.has_key(label) == False : dictPrestations[label] = { "nomActivite" : nomActivite, "IDactivite" : IDactivite, "nbre_total" : 0, "montant_total" : FloatToDecimal(0.0), "nbre_regle" : 0, "montant_regle" : FloatToDecimal(0.0), "nbre_impaye" : 0, "montant_impaye" : FloatToDecimal(0.0), "prestations" : [], } dictPrestations[label]["nbre_total"] += 1 dictPrestations[label]["montant_total"] += montant dictPrestations[label]["montant_regle"] += regle if regle > FloatToDecimal(0.0) : dictPrestations[label]["nbre_regle"] += 1 dictPrestations[label]["montant_impaye"] += impaye if impaye > FloatToDecimal(0.0) : dictPrestations[label]["nbre_impaye"] += 1 dictPrestations[label]["prestations"].append({ "IDprestation" : IDprestation, "IDcompte_payeur" : IDcompte_payeur, "IDfamille" : IDfamille, "IDindividu" : IDindividu, "nom" : nom, "prenom" : prenom, "date_naiss" : date_naiss, "IDcivilite" : IDcivilite, "montant" : montant, "regle" : regle, "impaye" : impaye}) # Regroupement des prestations par label listeListeView = [] for label, dictValeurs in dictPrestations.iteritems() : track = Track(label, dictValeurs) listeListeView.append(track) return listeListeView
def GetImageVentilation(track): if track.reste_a_ventiler > FloatToDecimal(0.0) : return self.imgVentilation
def GetTracks(self): # Récupération des données listeID = None DB = GestionDB.DB() req = """ SELECT IDprestation, prestations.IDindividu, IDfamille, IDcompte_payeur, date, montant, individus.nom, individus.prenom FROM prestations LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu WHERE date>='%s' AND date<='%s' AND IDactivite=%d AND categorie='consommation' GROUP BY IDprestation ;""" % (self.date_debut, self.date_fin, self.IDactivite) DB.ExecuterReq(req) listePrestations = DB.ResultatReq() # Recherche également les consommations req = """ SELECT IDconso, consommations.IDindividu, IDfamille, consommations.IDcompte_payeur, date, individus.nom, individus.prenom FROM consommations LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur WHERE date>='%s' AND date<='%s' AND IDactivite=%d ;""" % (self.date_debut, self.date_fin, self.IDactivite) DB.ExecuterReq(req) listeConsommations = DB.ResultatReq() DB.Close() dictResultats = {} # Traitement des prestations for IDprestation, IDindividu, IDfamille, IDcompte_payeur, date, montant, nomIndividu, prenomIndividu in listePrestations: date = UTILS_Dates.DateEngEnDateDD(date) montant = FloatToDecimal(montant) key = (IDindividu, IDfamille) if (key in dictResultats) == False: dictResultats[key] = { "IDindividu": IDindividu, "nomIndividu": nomIndividu, "prenomIndividu": prenomIndividu, "IDfamille": IDfamille, "IDcompte_payeur": IDcompte_payeur, "nbre_conso": 0, "prestations": [], "nbre_prestations": 0, "montant": FloatToDecimal(0.0) } dictResultats[key]["prestations"].append({ "IDprestation": IDprestation, "montant": montant }) dictResultats[key]["montant"] += montant dictResultats[key]["nbre_prestations"] += 1 # Traitement des consommations for IDconso, IDindividu, IDfamille, IDcompte_payeur, date, nomIndividu, prenomIndividu in listeConsommations: date = UTILS_Dates.DateEngEnDateDD(date) key = (IDindividu, IDfamille) if (key in dictResultats) == False: dictResultats[key] = { "IDindividu": IDindividu, "nomIndividu": nomIndividu, "prenomIndividu": prenomIndividu, "IDfamille": IDfamille, "IDcompte_payeur": IDcompte_payeur, "nbre_conso": 0, "prestations": [], "nbre_prestations": 0, "montant": FloatToDecimal(0.0) } dictResultats[key]["nbre_conso"] += 1 listeListeView = [] for key, dictTemp in dictResultats.items(): track = Track(self, dictTemp) listeListeView.append(track) return listeListeView
def Importation(date=None, afficherDebit=True, afficherCredit=True, afficherNul=True, afficherFactures=False): DB = GestionDB.DB() # Récupère les comptes payeurs req = """SELECT IDcompte_payeur, IDfamille FROM comptes_payeurs ORDER BY IDcompte_payeur ;""" DB.ExecuterReq(req) listeComptes = DB.ResultatReq() # Récupère la ventilation req = """SELECT IDcompte_payeur, SUM(montant) AS total_ventilations FROM ventilation GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" DB.ExecuterReq(req) listeVentilations = DB.ResultatReq() dictVentilations = {} for IDcompte_payeur, total_ventilations in listeVentilations : dictVentilations[IDcompte_payeur] = total_ventilations # Récupère les prestations if afficherFactures == True : condition = "AND IDfacture IS NOT NULL" else : condition = "" req = """SELECT IDcompte_payeur, SUM(montant) AS total_prestations FROM prestations WHERE date<='%s' %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % (date, condition) DB.ExecuterReq(req) listePrestations = DB.ResultatReq() dictPrestations = {} for IDcompte_payeur, total_prestations in listePrestations : dictPrestations[IDcompte_payeur] = total_prestations # Récupère les règlements req = """SELECT IDcompte_payeur, SUM(montant) AS total_reglements FROM reglements WHERE date<='%s' GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % date DB.ExecuterReq(req) listeReglements = DB.ResultatReq() dictReglements = {} for IDcompte_payeur, total_reglements in listeReglements : dictReglements[IDcompte_payeur] = total_reglements DB.Close() # Récupération des titulaires de familles dictTitulaires = UTILS_Titulaires.GetTitulaires(inclure_archives=True) # Traitement des données listeListeView = [] for IDcompte_payeur, IDfamille in listeComptes : if IDcompte_payeur in dictVentilations : total_ventilations = FloatToDecimal(dictVentilations[IDcompte_payeur]) else: total_ventilations = FloatToDecimal(0.0) if IDcompte_payeur in dictPrestations : total_prestations = FloatToDecimal(dictPrestations[IDcompte_payeur]) else: total_prestations = FloatToDecimal(0.0) if IDcompte_payeur in dictReglements : total_reglements = FloatToDecimal(dictReglements[IDcompte_payeur]) else: total_reglements = FloatToDecimal(0.0) # Calculs solde = total_reglements - total_prestations total_a_ventiler = min(total_reglements, total_prestations) reste_a_ventiler = total_a_ventiler - total_ventilations # Mémorisation item = {"IDcompte_payeur" : IDcompte_payeur, "IDfamille" : IDfamille, "total_ventilations" : total_ventilations, "total_reglements" : total_reglements, "total_prestations" : total_prestations, "solde" : solde, "total_a_ventiler" : total_a_ventiler, "reste_a_ventiler" : reste_a_ventiler} track = Track(dictTitulaires, item) valide = False if afficherDebit == True and solde < FloatToDecimal(0.0) : valide = True if afficherCredit == True and solde > FloatToDecimal(0.0) : valide = True if afficherNul == True and solde == FloatToDecimal(0.0) : valide = True if valide == True : listeListeView.append(track) return listeListeView
def GetTracks(self): listeListeView = [] if self.IDactivite == None: return listeListeView DB = GestionDB.DB() conditions = [] # Condition Activité if self.IDactivite != 0: conditions.append("inscriptions.IDactivite=%d" % self.IDactivite) # Condition Groupes if self.listeGroupes != None: if len(self.listeGroupes) == 0: conditionGroupes = "()" elif len(self.listeGroupes) == 1: conditionGroupes = "(%d)" % self.listeGroupes[0] else: conditionGroupes = str(tuple(self.listeGroupes)) conditions.append("inscriptions.IDgroupe IN %s" % conditionGroupes) # Condition Catégories if self.listeCategories != None: if len(self.listeCategories) == 0: conditionCategories = "()" elif len(self.listeCategories) == 1: conditionCategories = "(%d)" % self.listeCategories[0] else: conditionCategories = str(tuple(self.listeCategories)) conditions.append("inscriptions.IDcategorie_tarif IN %s" % conditionCategories) # Condition Partis if self.partis != True: conditions.append( "(inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s')" % datetime.date.today()) # Infos sur tous les individus GetDictInfosIndividus() # Récupération de la facturation dictFacturation = {} # Récupère les prestations condition = ("WHERE IDactivite=%d" % self.IDactivite) if self.IDactivite != 0 else "" req = """SELECT IDfamille, IDindividu, SUM(montant) FROM prestations %s GROUP BY IDfamille, IDindividu ;""" % condition DB.ExecuterReq(req) listePrestations = DB.ResultatReq() for IDfamille, IDindividu, total_prestations in listePrestations: if total_prestations == None: total_prestations = 0.0 dictFacturation[(IDfamille, IDindividu)] = { "prestations": total_prestations, "ventilation": 0.0 } # Récupère la ventilation condition = ("WHERE prestations.IDactivite=%d" % self.IDactivite) if self.IDactivite != 0 else "" req = """SELECT IDfamille, IDindividu, SUM(ventilation.montant) FROM ventilation LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation %s GROUP BY IDfamille, IDindividu ;""" % condition DB.ExecuterReq(req) listeVentilations = DB.ResultatReq() for IDfamille, IDindividu, total_ventilation in listeVentilations: if (IDfamille, IDindividu) in dictFacturation: dictFacturation[( IDfamille, IDindividu)]["ventilation"] = total_ventilation # Récupération des données sur les individus listeChamps2 = [] for dictChamp in LISTE_CHAMPS: champ = dictChamp["champ"] if champ != None: listeChamps2.append(champ) if len(conditions) > 0: conditions = "AND " + " AND ".join(conditions) else: conditions = "" req = """ SELECT %s FROM inscriptions LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu LEFT JOIN activites ON activites.IDactivite = inscriptions.IDactivite LEFT JOIN groupes ON groupes.IDgroupe = inscriptions.IDgroupe LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif LEFT JOIN categories_travail ON categories_travail.IDcategorie = individus.IDcategorie_travail WHERE inscriptions.statut='ok' %s GROUP BY individus.IDindividu, inscriptions.IDinscription ;""" % (",".join(listeChamps2), conditions) # LEFT JOIN prestations ON prestations.IDactivite = inscriptions.IDactivite a été supprimé pour accélérer le traitement DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() for valeurs in listeDonnees: dictTemp = {} dictTemp["IDindividu"] = valeurs[0] # Infos de la table Individus index = 0 for dictChamp in LISTE_CHAMPS: if dictChamp["champ"] != None: code = dictChamp["code"] dictTemp[code] = valeurs[index] index += 1 # Infos sur la civilité IDcivilite = dictTemp["IDcivilite"] if IDcivilite == None: IDcivilite = 1 dictTemp["genre"] = DICT_CIVILITES[IDcivilite]["sexe"] dictTemp["categorieCivilite"] = DICT_CIVILITES[IDcivilite][ "categorie"] dictTemp["civiliteLong"] = DICT_CIVILITES[IDcivilite][ "civiliteLong"] dictTemp["civiliteAbrege"] = DICT_CIVILITES[IDcivilite][ "civiliteAbrege"] dictTemp["nomImage"] = DICT_CIVILITES[IDcivilite]["nomImage"] # Age if dictTemp["date_naiss"] == None: dictTemp["age"] = None else: datenaissDD = datetime.date( year=int(dictTemp["date_naiss"][:4]), month=int(dictTemp["date_naiss"][5:7]), day=int(dictTemp["date_naiss"][8:10])) datedujour = datetime.date.today() age = (datedujour.year - datenaissDD.year) - int( (datedujour.month, datedujour.day) < (datenaissDD.month, datenaissDD.day)) dictTemp["age"] = age dictTemp["date_naiss"] = datenaissDD # Nom Complet nomComplet = dictTemp["nomIndividu"] if dictTemp["prenomIndividu"] != None: nomComplet += ", " + dictTemp["prenomIndividu"] dictTemp["nomComplet"] = nomComplet # Adresse auto ou manuelle adresse_auto = dictTemp["adresse_auto"] if adresse_auto != None and adresse_auto in DICT_INFOS_INDIVIDUS: dictTemp["rue_resid"] = DICT_INFOS_INDIVIDUS[adresse_auto][ "rue_resid"] dictTemp["cp_resid"] = DICT_INFOS_INDIVIDUS[adresse_auto][ "cp_resid"] dictTemp["ville_resid"] = DICT_INFOS_INDIVIDUS[adresse_auto][ "ville_resid"] # Facturation totalFacture = FloatToDecimal(0.0) totalRegle = FloatToDecimal(0.0) totalSolde = FloatToDecimal(0.0) key = (dictTemp["IDfamille"], dictTemp["IDindividu"]) if key in dictFacturation: totalFacture = FloatToDecimal( dictFacturation[key]["prestations"]) if totalFacture == None: totalFacture = FloatToDecimal(0.0) totalRegle = FloatToDecimal( dictFacturation[key]["ventilation"]) if totalRegle == None: totalRegle = FloatToDecimal(0.0) totalSolde = totalFacture - totalRegle dictTemp["totalFacture"] = totalFacture dictTemp["totalRegle"] = totalRegle dictTemp["totalSolde"] = totalSolde # Famille dictTemp["nomTitulaires"] = self.dict_titulaires[ dictTemp["IDfamille"]]["titulairesSansCivilite"] # self.rue = listview.dict_titulaires[self.IDfamille]["adresse"]["rue"] # self.cp = listview.dict_titulaires[self.IDfamille]["adresse"]["cp"] # self.ville = listview.dict_titulaires[self.IDfamille]["adresse"]["ville"] # Formatage sous forme de TRACK track = Track(self, dictTemp) listeListeView.append(track) return listeListeView
def Importation(self, DBtemp=None): """ Importation depuis la base """ dictValeurs = {} # Lecture de la base if DBtemp == None: DB = GestionDB.DB() else: DB = DBtemp # Informations générales sur le contrat if self.IDcontrat != None: req = """SELECT contrats.IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type, duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning, individus.nom, individus.prenom FROM contrats LEFT JOIN individus ON individus.IDindividu = contrats.IDindividu WHERE IDcontrat=%d ;""" % self.IDcontrat DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() if len(listeDonnees) > 0: IDindividu, IDinscription, date_debut, date_fin, observations, IDactivite, type_contrat, duree_absences_prevues, duree_heures_regularisation, arrondi_type, arrondi_delta, duree_tolerance_depassement, planning, individu_nom, individu_prenom = listeDonnees[ 0] self.IDinscription = IDinscription dictValeurs["IDinscription"] = self.IDinscription dictValeurs["date_debut"] = UTILS_Dates.DateEngEnDateDD( date_debut) dictValeurs["date_fin"] = UTILS_Dates.DateEngEnDateDD(date_fin) dictValeurs["observations"] = observations dictValeurs["IDactivite"] = IDactivite dictValeurs["type_contrat"] = type_contrat dictValeurs[ "duree_absences_prevues"] = UTILS_Dates.HeureStrEnDelta( duree_absences_prevues) dictValeurs[ "duree_heures_regularisation"] = UTILS_Dates.HeureStrEnDelta( duree_heures_regularisation) dictValeurs[ "duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta( duree_tolerance_depassement) dictValeurs["individu_nom"] = individu_nom dictValeurs["individu_prenom"] = individu_prenom dictValeurs["arrondi_type"] = arrondi_type dictValeurs["arrondi_delta"] = arrondi_delta dictValeurs["planning"] = planning if individu_prenom != None: dictValeurs["individu_nom_complet"] = u"%s %s" % ( individu_nom, individu_prenom) else: dictValeurs["individu_nom_complet"] = individu_nom # Importation des données de l'inscription if self.IDinscription != None: req = """SELECT IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti FROM inscriptions WHERE IDinscription=%d ;""" % self.IDinscription DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti = listeDonnees[ 0] dictValeurs["IDinscription"] = self.IDinscription dictValeurs["IDindividu"] = IDindividu dictValeurs["IDfamille"] = IDfamille dictValeurs["IDactivite"] = IDactivite dictValeurs["IDgroupe"] = IDgroupe dictValeurs["IDcategorie_tarif"] = IDcategorie_tarif dictValeurs["IDcompte_payeur"] = IDcompte_payeur dictValeurs["date_inscription"] = date_inscription dictValeurs["parti"] = parti # Infos sur le dernier contrat saisi req = """SELECT arrondi_type, arrondi_delta, duree_tolerance_depassement FROM contrats WHERE type='psu' AND IDactivite=%d ORDER BY IDcontrat DESC LIMIT 1 ;""" % IDactivite DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() if len(listeDonnees) > 0: arrondi_type, arrondi_delta, duree_tolerance_depassement = listeDonnees[ 0] dictValeurs["arrondi_type"] = arrondi_type dictValeurs["arrondi_delta"] = arrondi_delta dictValeurs[ "duree_tolerance_depassement"] = UTILS_Dates.HeureStrEnDelta( duree_tolerance_depassement) # Informations sur l'activité req = """SELECT psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt FROM activites WHERE IDactivite=%d ;""" % dictValeurs["IDactivite"] DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() psu_unite_prevision, psu_unite_presence, psu_tarif_forfait, psu_etiquette_rtt = listeDonnees[ 0] dictValeurs["IDunite_prevision"] = psu_unite_prevision dictValeurs["IDunite_presence"] = psu_unite_presence dictValeurs["IDtarif"] = psu_tarif_forfait dictValeurs["psu_etiquette_rtt"] = psu_etiquette_rtt dictValeurs["duree_absences_prises"] = datetime.timedelta(0) # Mémorise les données déjà importées self.SetValeurs(dictValeurs) # Echap sur nouveau contrat if self.IDcontrat == None: DB.Close() return # Lecture des consommations req = """SELECT IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, verrouillage, date_saisie, IDutilisateur, IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes FROM consommations WHERE IDinscription=%d AND date>='%s' AND date<='%s' ;""" % (self.IDinscription, dictValeurs["date_debut"], dictValeurs["date_fin"]) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() tracks_previsions = [] liste_IDconso = [] liste_conso = [] dict_conso = {} for IDconso, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, verrouillage, date_saisie, IDutilisateur, IDcategorie_tarif, IDprestation, forfait, quantite, etiquettes in listeDonnees: date = UTILS_Dates.DateEngEnDateDD(date) date_saisie = UTILS_Dates.DateEngEnDateDD(date_saisie) heure_debut_time = UTILS_Dates.HeureStrEnTime(heure_debut) heure_fin_time = UTILS_Dates.HeureStrEnTime(heure_fin) etiquettes = UTILS_Texte.ConvertStrToListe(etiquettes) dictConso = { "IDconso": IDconso, "date": date, "IDunite": IDunite, "IDgroupe": IDgroupe, "heure_debut": heure_debut, "heure_fin": heure_fin, "etat": etat, "verrouillage": verrouillage, "date_saisie": date_saisie, "IDutilisateur": IDutilisateur, "IDcategorie_tarif": IDcategorie_tarif, "IDprestation": IDprestation, "forfait": forfait, "quantite": quantite, "etiquettes": etiquettes, "heure_debut_time": heure_debut_time, "heure_fin_time": heure_fin_time, } track = Track_conso(self, dictConso) liste_conso.append(track) if dict_conso.has_key(date) == False: dict_conso[date] = [] dict_conso[date].append(track) if IDunite == self.GetValeur("IDunite_prevision", None): tracks_previsions.append(track) liste_IDconso.append(IDconso) if dictValeurs["psu_etiquette_rtt"] in etiquettes: dictValeurs["duree_absences_prises"] += track.duree_arrondie dictValeurs["liste_conso"] = liste_conso dictValeurs["dict_conso"] = dict_conso dictValeurs["tracks_previsions"] = tracks_previsions dictValeurs["liste_IDconso"] = liste_IDconso # Lecture des tarifs du contrat req = """SELECT IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement FROM contrats_tarifs WHERE IDcontrat=%d ;""" % self.IDcontrat DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() tracks_tarifs = [] liste_IDtarif = [] for IDcontrat_tarif, date_debut, revenu, quotient, taux, tarif_base, tarif_depassement in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) dictTarif = { "IDcontrat_tarif": IDcontrat_tarif, "date_debut": date_debut, "revenu": revenu, "quotient": quotient, "taux": taux, "tarif_base": tarif_base, "tarif_depassement": tarif_depassement, } tracks_tarifs.append(Track_tarif(dictTarif)) liste_IDtarif.append(IDcontrat_tarif) dictValeurs["tracks_tarifs"] = tracks_tarifs dictValeurs["liste_IDtarif"] = liste_IDtarif # Lecture des mensualités req = """SELECT IDprestation, date, label, montant_initial, prestations.montant, prestations.IDfacture, temps_facture, forfait_date_debut, forfait_date_fin, factures.numero FROM prestations LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture WHERE IDcontrat=%d ;""" % self.IDcontrat DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() liste_prestations = [] liste_IDprestation = [] for IDprestation, date_facturation, label, montant_initial, montant, IDfacture, temps_facture, forfait_date_debut, forfait_date_fin, num_facture in listeDonnees: date_facturation = UTILS_Dates.DateEngEnDateDD(date_facturation) forfait_date_debut = UTILS_Dates.DateEngEnDateDD( forfait_date_debut) forfait_date_fin = UTILS_Dates.DateEngEnDateDD(forfait_date_fin) montant_initial = FloatToDecimal(montant_initial) montant = FloatToDecimal(montant) temps_facture = UTILS_Dates.HeureStrEnDelta(temps_facture) dictMensualite = { "IDprestation": IDprestation, "date_facturation": date_facturation, "label": label, "montant_initial": montant_initial, "montant": montant, "IDfacture": IDfacture, "temps_facture": temps_facture, "forfait_date_debut": forfait_date_debut, "forfait_date_fin": forfait_date_fin, "num_facture": num_facture, } liste_prestations.append(dictMensualite) liste_IDprestation.append(IDprestation) dictValeurs["liste_prestations"] = liste_prestations dictValeurs["liste_IDprestation"] = liste_IDprestation # Fermeture de la base if DBtemp == None: DB.Close() # Mémorisation des données self.SetValeurs(dictValeurs)
def FormateMontant(montant): if montant in ("", None, FloatToDecimal(0.0)): return "" return u"%.2f %s" % (montant, SYMBOLE)
def __init__(self, donnees): self.IDfacture = donnees["IDfacture"] self.IDprefixe = donnees["IDprefixe"] self.prefixe = donnees["prefixe"] self.numero = donnees["numero"] if self.numero == None: self.numero = 0 self.numero_int = int(self.numero) if self.IDprefixe != None: self.numero = u"%s-%06d" % (self.prefixe, self.numero) else: self.numero = u"%06d" % self.numero self.IDcompte_payeur = donnees["IDcompte_payeur"] self.etat = donnees["etat"] self.date_edition = donnees["date_edition"] self.date_echeance = donnees["date_echeance"] self.IDutilisateur = donnees["IDutilisateur"] self.date_debut = donnees["date_debut"] self.date_fin = donnees["date_fin"] self.total = donnees["total"] self.regle = donnees["regle"] self.solde = donnees["solde"] if self.solde != FloatToDecimal(0.0): self.solde = -self.solde self.totalPrestations = donnees["totalPrestations"] self.totalVentilation = donnees["totalVentilation"] if self.totalVentilation == None: self.totalVentilation = FloatToDecimal(0.0) self.soldeActuel = self.totalVentilation - self.totalPrestations if self.etat == "annulation": self.soldeActuel = None self.IDfamille = donnees["IDfamille"] self.nomsTitulaires = donnees["titulaires"] self.IDlot = donnees["IDlot"] self.nomLot = donnees["nomLot"] self.adresse_famille = donnees["adresse_famille"] self.titulaire_helios = donnees["titulaire_helios"] # Prélèvement self.prelevement_activation = donnees["prelevement_activation"] self.prelevement_etab = donnees["prelevement_etab"] self.prelevement_guichet = donnees["prelevement_guichet"] self.prelevement_numero = donnees["prelevement_numero"] self.prelevement_cle = donnees["prelevement_cle"] self.prelevement_banque = donnees["prelevement_banque"] self.prelevement_individu = donnees["prelevement_individu"] self.prelevement_nom = donnees["prelevement_nom"] self.prelevement_rue = donnees["prelevement_rue"] self.prelevement_cp = donnees["prelevement_cp"] self.prelevement_ville = donnees["prelevement_ville"] self.prelevement_cle_iban = donnees["prelevement_cle_iban"] self.prelevement_iban = donnees["prelevement_iban"] self.prelevement_bic = donnees["prelevement_bic"] self.prelevement_reference_mandat = donnees[ "prelevement_reference_mandat"] self.prelevement_date_mandat = donnees["prelevement_date_mandat"] if self.prelevement_activation == 1: self.prelevement = True else: self.prelevement = False self.nomPayeur = donnees["nomPayeur"] self.prenomPayeur = donnees["prenomPayeur"] if self.nomPayeur == None: self.nomPayeur = u"" if self.prenomPayeur == None: self.prenomPayeur = u"" if self.prelevement_individu == None: self.prelevement_payeur = self.prelevement_nom else: self.prelevement_payeur = u"%s %s" % (self.nomPayeur, self.prenomPayeur) # Envoi par Email self.email_factures = donnees["email_factures"] if self.email_factures != None: self.email = True else: self.email = False
def FormateMontant(montant): if montant == None or montant == "" or montant == FloatToDecimal( 0.0): return "" return u"%.2f %s" % (montant, SYMBOLE)
def GetTotalRestePrestationsAVentiler(self): total = FloatToDecimal(0.0) for ligne in self.listeLignesPrestations : total += ligne.resteAVentiler return total
def GetTracks(self): """ Récupération des données """ listePrestations = self.listePrestations dictComptes = {} for track in listePrestations: # Recherche si un ajustement est demandé ajustement = FloatToDecimal(0.0) if track.ajustement not in ("", None): ajustement = FloatToDecimal(float(track.ajustement)) for dictPrestation in track.listePrestations: IDcompte_payeur = dictPrestation["IDcompte_payeur"] IDfamille = dictPrestation["IDfamille"] if dictComptes.has_key(IDcompte_payeur) == False: # Récupération des infos sur la famille dictInfosTitulaires = self.dictTitulaires[IDfamille] rue_resid = dictInfosTitulaires["adresse"]["rue"] cp_resid = dictInfosTitulaires["adresse"]["cp"] if cp_resid == None: cp_resid = u"" ville_resid = dictInfosTitulaires["adresse"]["ville"] if ville_resid == None: ville_resid = u"" dictComptes[IDcompte_payeur] = { "IDcompte_payeur": IDcompte_payeur, "IDfamille": IDfamille, "nomsTitulairesAvecCivilite": dictInfosTitulaires["titulairesAvecCivilite"], "nomsTitulairesSansCivilite": dictInfosTitulaires["titulairesSansCivilite"], "rue_resid": rue_resid, "cp_resid": cp_resid, "ville_resid": ville_resid, "prestations": [], "montant_total": FloatToDecimal(0.0), "montant_regle": FloatToDecimal(0.0), "montant_impaye": FloatToDecimal(0.0) } dictPrestation = copy.deepcopy(dictPrestation) # Applique les éventuels ajustements montant = dictPrestation["montant"] + ajustement if montant < FloatToDecimal(0.0): montant = FloatToDecimal(0.0) regle = dictPrestation["regle"] + ajustement if regle < FloatToDecimal(0.0): regle = FloatToDecimal(0.0) impaye = montant - regle if impaye < FloatToDecimal(0.0): impaye = FloatToDecimal(0.0) dictPrestation["montant"] = montant dictPrestation["regle"] = regle dictPrestation["impaye"] = impaye # Mémorise les données dictComptes[IDcompte_payeur]["prestations"].append( dictPrestation) dictComptes[IDcompte_payeur][ "montant_total"] += dictPrestation["montant"] dictComptes[IDcompte_payeur][ "montant_regle"] += dictPrestation["regle"] dictComptes[IDcompte_payeur][ "montant_impaye"] += dictPrestation["impaye"] # Regroupement des prestations par label listeListeView = [] for IDcompte_payeur, dictValeurs in dictComptes.iteritems(): track = Track(dictValeurs) listeListeView.append(track) return listeListeView
def MAJbarreInfos(self, total=FloatToDecimal(0.0), erreur=None): self.total_ventilation = total self.MAJinfos(erreur)
def FacturesErronees(self): labelProbleme = _(u"Factures erronées") labelCorrection = _(u"Recalculer le montant des factures") # Recherche des factures req = """SELECT factures.IDfacture, factures.numero, factures.IDcompte_payeur, comptes_payeurs.IDfamille, factures.total, factures.regle, factures.solde FROM factures LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur LEFT JOIN familles ON familles.IDfamille = comptes_payeurs.IDfamille WHERE factures.etat <> "annulation" ORDER BY factures.date_edition;""" self.DB.ExecuterReq(req) listeFactures = self.DB.ResultatReq() # Recherche des prestations req = """SELECT IDprestation, montant, IDfacture FROM prestations;""" self.DB.ExecuterReq(req) listePrestations = self.DB.ResultatReq() dictPrestationsFacture = {} for IDprestation, montant, IDfacture in listePrestations: if (IDfacture in dictPrestationsFacture) == False: dictPrestationsFacture[IDfacture] = [] dictPrestationsFacture[IDfacture].append({ "IDprestation": IDprestation, "montant": FloatToDecimal(montant) }) # Analyse listeTemp = [] for IDfacture, numeroFacture, IDcompte_payeur, IDfamille, totalFacture, regleFacture, soldeFacture in listeFactures: totalFacture = FloatToDecimal(totalFacture) regleFacture = FloatToDecimal(regleFacture) soldeFacture = FloatToDecimal(soldeFacture) if IDfacture in dictPrestationsFacture: listePrestationsFacture = dictPrestationsFacture[IDfacture] else: listePrestationsFacture = [] montantTotalPrestations = FloatToDecimal(0.0) for dictTemp in listePrestationsFacture: montantTotalPrestations += dictTemp["montant"] if montantTotalPrestations != FloatToDecimal(totalFacture): # Si la facture n'a pas de famille rattachée if IDfamille == None: label = _(u"Facture ID%d : Famille inconnue") % IDfacture listeTemp.append( FacturesAsupprimer(label=label, IDfacture=IDfacture)) elif len(listePrestationsFacture) == 0: label = _( u"Facture ID%d : Aucune prestation correspondante" ) % IDfacture listeTemp.append( FacturesAsupprimer(label=label, IDfacture=IDfacture)) elif montantTotalPrestations == FloatToDecimal(0.0): label = _( u"Facture ID%d : Montant de la facture égal à 0" ) % IDfacture listeTemp.append( FacturesAsupprimer(label=label, IDfacture=IDfacture)) else: label = _( u"Facture ID%d : Total à recalculer") % IDfacture listeTemp.append( FacturesRecalcul( label=label, IDfacture=IDfacture, totalFacture=totalFacture, regleFacture=regleFacture, soldeFacture=soldeFacture, montantTotalPrestations=montantTotalPrestations)) self.listeResultats.append((labelProbleme, labelCorrection, listeTemp))
def Remplissage(self): # Regroupement self.dictRegroupements = {} listeKeys = [] nbreLignes = 0 for ligne_prestation in self.listeLignesPrestations: if self.KeyRegroupement == "individu": key = ligne_prestation.IDindividu if key == 0 or key == None: label = _(u"Prestations diverses") else: label = ligne_prestation.nomCompletIndividu if self.KeyRegroupement == "facture": key = ligne_prestation.IDfacture label = ligne_prestation.label_facture if self.KeyRegroupement == "date": key = ligne_prestation.date label = ligne_prestation.date_complete if self.KeyRegroupement == "periode": key = ligne_prestation.periode label = ligne_prestation.periode_complete if self.dictRegroupements.has_key(key) == False: self.dictRegroupements[key] = { "label": label, "total": FloatToDecimal(0.0), "prestations": [], "ligne_regroupement": None } listeKeys.append(key) nbreLignes += 1 self.dictRegroupements[key]["prestations"].append(ligne_prestation) self.dictRegroupements[key]["total"] += ligne_prestation.montant nbreLignes += 1 # Tri des Keys listeKeys.sort() # Création des lignes self.AppendRows(nbreLignes) # Création des branches numLigne = 0 self.dictLignes = {} for key in listeKeys: # Niveau 1 : Regroupement dictRegroupement = self.dictRegroupements[key] ligne_regroupement = Ligne_regroupement(self, numLigne, dictRegroupement) self.dictLignes[numLigne] = ligne_regroupement self.dictRegroupements[key][ "ligne_regroupement"] = ligne_regroupement numLigne += 1 # Niveau 2 : Prestations for ligne_prestation in self.dictRegroupements[key]["prestations"]: ligne_prestation.Draw(numLigne, ligne_regroupement) ligne_prestation.MAJ(majTotaux=False) ligne_regroupement.listeLignesPrestations.append( ligne_prestation) self.dictLignes[numLigne] = ligne_prestation numLigne += 1 # MAJ de tous les totaux self.MAJtotaux()
def GetTracks(self): listeListeView = [] self.dictUnitesConso = {} if self.date_debut == None or self.date_fin == None : return listeListeView # Récupération des données DB = GestionDB.DB() # Liste des inscrits if len(self.categories_tarifs) == 0 : conditionCategorie = "inscriptions.IDcategorie_tarif=0" elif len(self.categories_tarifs) == 1 : conditionCategorie = "inscriptions.IDcategorie_tarif=%d" % self.categories_tarifs[0] else : conditionCategorie = "inscriptions.IDcategorie_tarif IN %s" % str(tuple(self.categories_tarifs)) req = """ SELECT individus.IDindividu, individus.nom, individus.prenom, inscriptions.IDfamille, inscriptions.IDcompte_payeur, inscriptions.IDcategorie_tarif, categories_tarifs.nom FROM inscriptions LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif WHERE inscriptions.statut='ok' AND inscriptions.IDactivite=%d AND inscriptions.date_desinscription IS NULL AND %s ;""" % (self.IDactivite, conditionCategorie) DB.ExecuterReq(req) listeInscrits = DB.ResultatReq() # Prestations req = """ SELECT IDindividu, IDfamille, SUM(prestations.montant) FROM prestations WHERE date>='%s' AND date<='%s' AND IDactivite=%d AND categorie='consommation' GROUP BY IDindividu, IDfamille ;""" % (self.date_debut, self.date_fin, self.IDactivite) DB.ExecuterReq(req) listePrestations = DB.ResultatReq() dictPrestations = {} for IDindividu, IDfamille, montant in listePrestations : montant = FloatToDecimal(montant) dictPrestations[(IDindividu, IDfamille)] = montant # Consommations req = """ SELECT IDconso, consommations.IDindividu, comptes_payeurs.IDfamille, consommations.IDcompte_payeur, consommations.date, consommations.IDunite, unites.nom, unites.abrege, unites.ordre FROM consommations LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur LEFT JOIN unites ON unites.IDunite = consommations.IDunite WHERE consommations.date>='%s' AND consommations.date<='%s' AND consommations.IDactivite=%d ;""" % (self.date_debut, self.date_fin, self.IDactivite) DB.ExecuterReq(req) listeConso = DB.ResultatReq() dictConso = {} for IDconso, IDindividu, IDfamille, IDcompte_payeur, date, IDunite, nomUnite, abregeUnite, ordreUnite in listeConso : # Mémorisation de l'unité de conso if self.dictUnitesConso.has_key(IDunite) == False : self.dictUnitesConso[IDunite] = {"nom" : nomUnite, "abrege" : abregeUnite, "ordre" : ordreUnite, "quantite" : 0} self.dictUnitesConso[IDunite]["quantite"] += 1 # Mémorisation de la conso key = (IDindividu, IDfamille) if dictConso.has_key(key) == False : dictConso[key] = {} if dictConso[key].has_key(IDunite) == False : dictConso[key][IDunite] = 0 dictConso[key][IDunite] += 1 DB.Close() # Parcours les inscrits for IDindividu, nom, prenom, IDfamille, IDcompte_payeur, IDcategorie_tarif, nomCategorieTarif in listeInscrits : # Recherche les prestations if dictPrestations.has_key((IDindividu, IDfamille)) : montant = dictPrestations[(IDindividu, IDfamille)] else : montant = FloatToDecimal(0.0) # Recherche les consommations if dictConso.has_key((IDindividu, IDfamille)) : dictConsoIndividu = dictConso[(IDindividu, IDfamille)] else : dictConsoIndividu = {} # Mémorisation dictTemp = { "IDindividu" : IDindividu, "nom" : nom, "prenom" : prenom, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "IDcategorie_tarif" : IDcategorie_tarif, "nomCategorieTarif" : nomCategorieTarif, "montant" : montant, "conso" : dictConsoIndividu, } track = Track(self, dictTemp) listeListeView.append(track) return listeListeView
def GetTotalVentile(self): total = FloatToDecimal(0.0) for ligne in self.listeLignesPrestations: total += ligne.ventilationActuelle return total
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), ] 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), ] 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)