def GetListeDonnees(self): self.dictDonnees = {} if self.IDactivite == None: return [] db = GestionDB.DB() req = """SELECT IDmodele, modeles_contrats.nom, modeles_contrats.IDactivite, modeles_contrats.date_debut, modeles_contrats.date_fin, IDtarif, donnees FROM modeles_contrats LEFT JOIN activites ON activites.IDactivite = modeles_contrats.IDactivite WHERE modeles_contrats.IDactivite=%d ORDER BY modeles_contrats.date_debut;""" % self.IDactivite db.ExecuterReq(req) listeDonnees = db.ResultatReq() db.Close() listeItems = [] index = 0 for IDmodele, nom, IDactivite, date_debut, date_fin, IDtarif, donnees in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) donnees = cPickle.loads(str(donnees)) self.dictDonnees[index] = { "ID": IDmodele, "nom ": nom, "IDactivite": IDactivite, "date_debut": date_debut, "date_fin": date_fin, "IDtarif": IDtarif, "donnees": donnees } label = _(u"%s - du %s au %s") % ( nom, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) listeItems.append(label) index += 1 return listeItems
def Suite(self): # Recherche des activites ressemblantes pour le recopiage de tarification DB = GestionDB.DB() req = """SELECT activites.IDactivite, activites.nom, activites.date_debut, activites.date_fin FROM activites LEFT JOIN tarifs ON tarifs.IDactivite = activites.IDactivite WHERE type='FORFAIT' AND forfait_saisie_auto=1 AND forfait_suppression_auto=1 AND activites.date_debut IS NOT NULL and activites.date_fin IS NOT NULL GROUP BY activites.IDactivite ORDER BY activites.date_debut DESC;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) > 0: liste_activites = [ (None, _(u"Non")), ] for IDactivite, nom, date_debut, date_fin in listeDonnees: if date_debut != None: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) if date_fin != None: date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) label = u"%s - Du %s au %s" % ( nom, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) liste_activites.append((IDactivite, label)) self.parent.dict_valeurs[ "activites_ressemblantes"] = liste_activites return Page_recopier_tarifs self.parent.dict_valeurs["recopier_tarifs"] = None return Page_categories_tarifs
def Importation(self): """ Importation """ # Condition dates condition = " (deductions.date>='%s' and deductions.date<='%s') " % (self.date_debut, self.date_fin) # Conditions Activités if self.listeActivites == "toutes" or self.listeActivites == None : conditionActivites = "" else : if len(self.listeActivites) == 0 : conditionActivites = "AND prestations.IDactivite IN ()" elif len(self.listeActivites) == 1 : conditionActivites = "AND prestations.IDactivite IN (%d)" % self.listeActivites[0] else : conditionActivites = "AND prestations.IDactivite IN %s" % str(tuple(self.listeActivites)) # Filtres listeFiltres = [] texteFiltres = "" if "consommation" in self.filtres : listeFiltres.append("(prestations.categorie='consommation' %s)" % conditionActivites) if "cotisation" in self.filtres : listeFiltres.append("(prestations.categorie='cotisation')") if "location" in self.filtres : listeFiltres.append("(prestations.categorie='location')") if "autre" in self.filtres : listeFiltres.append("(prestations.categorie='autre')") if len(listeFiltres) > 0 : texteFiltres = "AND (%s)" % " OR ".join(listeFiltres) else : texteFiltres = " AND deductions.IDdeduction=0" db = GestionDB.DB() req = """SELECT IDdeduction, deductions.IDprestation, deductions.IDcompte_payeur, deductions.date, deductions.montant, deductions.label, 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 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 WHERE %s %s;""" % (condition, texteFiltres) db.ExecuterReq(req) listeDonnees = db.ResultatReq() db.Close() listeDeductions = [] 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 in listeDonnees : date = UTILS_Dates.DateEngEnDateDD(date) datePrestation = UTILS_Dates.DateEngEnDateDD(datePrestation) date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss) dictTemp = { "IDdeduction" : IDdeduction, "IDprestation" : IDprestation, "IDcompte_payeur" : IDcompte_payeur, "date" : date, "montant" : montant, "label" : label, "IDaide" : IDaide, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "date_naiss" : date_naiss, "labelPrestation" : labelPrestation, "montantPrestation" : montantPrestation, "montantInitialPrestation" : montantInitialPrestation, "IDfamille" : IDfamille, "IDactivite" : IDactivite, "abregeActivite" : abregeActivite, "IDindividu" : IDindividu, "datePrestation" : datePrestation, "IDfacture" : IDfacture, "IDcaisse" : IDcaisse, "num_allocataire" : num_allocataire, "nomCaisse" : nomCaisse, } listeDeductions.append(dictTemp) return listeDeductions
def GetListeDonnees(self): listeItems = [ _(u"Tous les exercices"), ] self.dictDonnees = { 0: { "ID": None, "date_debut": None, "date_fin": None }, } DB = GestionDB.DB() req = """SELECT IDexercice, nom, date_debut, date_fin, defaut FROM compta_exercices ORDER BY date_debut; """ DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() index = 1 for IDexercice, nom, date_debut, date_fin, defaut in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) self.dictDonnees[index] = { "ID": IDexercice, "date_debut": date_debut, "date_fin": date_fin } label = nom listeItems.append(label) if defaut == 1: self.IDdefaut = IDexercice index += 1 return listeItems
def Importation_tarifs(self, IDcategorie_tarif=0): if IDcategorie_tarif == None : return [] DB = GestionDB.DB() # Recherche les tarifs dictIndividus = {} req = """SELECT IDtarif, tarifs.IDactivite, tarifs.IDnom_tarif, noms_tarifs.nom, date_debut, date_fin, methode, categories_tarifs, groupes FROM tarifs LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif ORDER BY noms_tarifs.nom, date_debut;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeTarifs = [] for IDtarif, IDactivite, IDnom_tarif, nomTarif, date_debut, date_fin, methode, categories_tarifs, groupes in listeDonnees : date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) listeCategoriesTarifs = UTILS_Texte.ConvertStrToListe(categories_tarifs) dictTemp = { "IDtarif" : IDtarif, "IDactivite" : IDactivite, "IDnom_tarif" : IDnom_tarif, "nomTarif" : nomTarif, "date_debut" : date_debut, "date_fin" : date_fin, "methode" : methode, "categories_tarifs":categories_tarifs, "groupes":groupes, } if listeCategoriesTarifs != None : if IDcategorie_tarif in listeCategoriesTarifs : listeTarifs.append(dictTemp) return listeTarifs
def SetListeDonnees(self): self.listeNoms = [_(u"Toutes")] self.listeID = [ None, ] DB = GestionDB.DB() req = """SELECT IDcontrat, date_debut, date_fin FROM contrats;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: return dictAnnees = {} for IDcontrat, date_debut, date_fin in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) if (date_debut.year in dictAnnees) == False: dictAnnees[date_debut.year] = 0 dictAnnees[date_debut.year] += 1 if (date_fin.year in dictAnnees) == False: dictAnnees[date_fin.year] = 0 dictAnnees[date_fin.year] += 1 listeAnnees = list(dictAnnees.keys()) listeAnnees.sort() for annee in listeAnnees: nbreReglements = dictAnnees[annee] #self.listeNoms.append(u"%s (%d)" % (annee, nbreReglements)) self.listeNoms.append(str(annee)) self.listeID.append(annee) self.SetItems(self.listeNoms) self.SetSelection(len(listeAnnees))
def Importation(self): DB = GestionDB.DB() req = """SELECT IDactivite, IDgroupe, IDcategorie_tarif, date_inscription, date_desinscription, statut FROM inscriptions WHERE IDinscription=%d;""" % self.IDinscription DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) > 0: IDactivite, IDgroupe, IDcategorie_tarif, date_inscription, date_desinscription, statut = listeDonnees[ 0] self.SetIDactivite(IDactivite) self.ctrl_groupes.SetID(IDgroupe) self.IDgroupe = IDgroupe self.ctrl_categories.SetID(IDcategorie_tarif) self.date_inscription = UTILS_Dates.DateEngEnDateDD( date_inscription) if date_desinscription != None: date_desinscription = UTILS_Dates.DateEngEnDateDD( date_desinscription) self.ctrl_check_depart.SetValue(True) self.ctrl_date_depart.SetDate(date_desinscription) if statut != None: self.parent.parent.ctrl_statut.SetID(statut) self.ancien_statut = statut
def __init__(self, parent, donnees): self.parent = parent self.IDconso = donnees[0] self.date = UTILS_Dates.DateEngEnDateDD(donnees[1]) self.etat = donnees[2] self.date_saisie = UTILS_Dates.DateEngEnDateDD(donnees[3]) self.quantite = donnees[4] self.nom = donnees[5] self.prenom = donnees[6] self.nom_unite = donnees[7] self.nom_activite = donnees[8] self.nom_groupe = donnees[9] self.IDfamille = donnees[10] self.heure_debut = donnees[11] self.heure_fin = donnees[12] self.forfait = donnees[13] self.nom_evenement = donnees[14] self.IDprestation = donnees[15] self.label_prestation = donnees[16] self.montant_prestation = donnees[17] # Récupération du nom des titulaires try : self.nomTitulaires = self.parent.dict_titulaires[self.IDfamille]["titulairesSansCivilite"] except : self.nomTitulaires = _(" ")
def Importation(self): DB = GestionDB.DB() req = """SELECT date_debut, date_fin, observations, verrou_consommations, verrou_prestations, verrou_factures, verrou_reglements, verrou_depots, verrou_cotisations FROM periodes_gestion WHERE IDperiode=%d;""" % self.IDperiode DB.ExecuterReq(req) listeTemp = DB.ResultatReq() DB.Close() if len(listeTemp) == 0: return date_debut, date_fin, observations, verrou_consommations, verrou_prestations, verrou_factures, verrou_reglements, verrou_depots, verrou_cotisations = listeTemp[ 0] date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) self.ctrl_date_debut.SetDate(date_debut) self.ctrl_date_fin.SetDate(date_fin) self.ctrl_observations.SetValue(observations) # Verrous liste_verrous = [] if verrou_consommations == 1: liste_verrous.append("consommations") if verrou_prestations == 1: liste_verrous.append("prestations") if verrou_factures == 1: liste_verrous.append("factures") if verrou_reglements == 1: liste_verrous.append("reglements") if verrou_depots == 1: liste_verrous.append("depots") if verrou_cotisations == 1: liste_verrous.append("cotisations") self.ctrl_verrou.SetCoches(liste_verrous)
def __init__(self, donnees): self.IDperiode = donnees[0] self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[1]) self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[2]) self.observations = donnees[3] self.verrou_consommations = donnees[4] self.verrou_prestations = donnees[5] self.verrou_factures = donnees[6] self.verrou_reglements = donnees[7] self.verrou_depots = donnees[8] self.verrou_cotisations = donnees[9] # Texte verrous liste_categories = [] if self.verrou_consommations == 1: liste_categories.append(_(u"consommations")) if self.verrou_prestations == 1: liste_categories.append(_(u"prestations")) if self.verrou_factures == 1: liste_categories.append(_(u"factures")) if self.verrou_reglements == 1: liste_categories.append(_(u"règlements")) if self.verrou_depots == 1: liste_categories.append(_(u"dépôts")) if self.verrou_cotisations == 1: liste_categories.append(_(u"cotisations")) self.texte_verrous = ", ".join(liste_categories).capitalize()
def GetTexteDernierQF(self): DB = GestionDB.DB() req = """ SELECT date_debut, date_fin, quotient, revenu, types_quotients.nom FROM quotients LEFT JOIN types_quotients ON types_quotients.IDtype_quotient = quotients.IDtype_quotient WHERE IDfamille=%d ORDER BY date_fin DESC """ % self.IDfamille DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() texte = _(u"Aucun précédent QF") if len(listeDonnees) > 0: date_debut, date_fin, quotient, revenu, nom_quotient = listeDonnees[ 0] date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) if revenu == 0.0: revenu = None if quotient != None and revenu == None: texte = _(u"Dernier quotient familial : %d du %s au %s (%s)" ) % (quotient, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin), nom_quotient) elif quotient == None and revenu != None: texte = _(u"Dernier revenu : %d du %s au %s (%s)") % ( revenu, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin), nom_quotient) elif quotient != None and revenu != None: texte = _(u"Dernier quotient/revenu : %s/%s du %s au %s (%s)" ) % (quotient, revenu, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin), nom_quotient) return texte
def GetTracks(self): """ Récupération des données """ if self.IDmodele == None: IDmodele = 0 else: IDmodele = self.IDmodele DB = GestionDB.DB() req = """SELECT IDcommande, nom, date_debut, date_fin FROM commandes WHERE IDmodele=%d ORDER BY date_debut;""" % IDmodele DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeModeles = [] for IDcommande, nom, date_debut, date_fin in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) listeModeles.append({ "IDcommande": IDcommande, "nom": nom, "date_debut": date_debut, "date_fin": date_fin }) listeListeView = [] for item in listeModeles: track = Track(item) listeListeView.append(track) return listeListeView
def GetTracks(self): """ Récupération des données """ dictTitulaires = UTILS_Titulaires.GetTitulaires() DB = GestionDB.DB() # Lecture Actions liste_conditions = [] if self.cacher_traitees == True: liste_conditions.append("etat <> 'validation'") if self.IDfamille != None: liste_conditions.append("IDfamille=%d" % self.IDfamille) if len(liste_conditions) > 0: conditions = "WHERE %s" % " AND ".join(liste_conditions) else: conditions = "" req = """SELECT IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, portail_actions.IDperiode, reponse, email_date, portail_periodes.nom, portail_periodes.date_debut, portail_periodes.date_fin, portail_periodes.IDmodele FROM portail_actions LEFT JOIN portail_periodes ON portail_periodes.IDperiode = portail_actions.IDperiode %s;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeActions = [] for IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, IDperiode, reponse, email_date, periode_nom, periode_date_debut, periode_date_fin, periode_IDmodele in listeDonnees: traitement_date = UTILS_Dates.DateEngEnDateDD(traitement_date) email_date = UTILS_Dates.DateEngEnDateDD(email_date) horodatage = UTILS_Dates.DateEngEnDateDDT(horodatage) periode_date_debut = UTILS_Dates.DateEngEnDateDD( periode_date_debut) periode_date_fin = UTILS_Dates.DateEngEnDateDD(periode_date_fin) listeActions.append({ "IDaction": IDaction, "horodatage": horodatage, "IDfamille": IDfamille, "IDindividu": IDindividu, "categorie": categorie, "action": action, "description": description, "commentaire": commentaire, "parametres": parametres, "etat": etat, "traitement_date": traitement_date, "IDperiode": IDperiode, "reponse": reponse, "email_date": email_date, "periode_nom": periode_nom, "periode_date_debut": periode_date_debut, "periode_date_fin": periode_date_fin, "periode_IDmodele": periode_IDmodele, }) listeListeView = [] for action in listeActions: listeListeView.append(Track(self, action, dictTitulaires)) return listeListeView
def GetDates(jours={}, date_min=None, date_max=None): # Importation des vacances DB = GestionDB.DB() req = """SELECT date_debut, date_fin FROM vacances WHERE date_debut<='%s' AND date_fin>='%s' ORDER BY date_debut;""" % (date_max, date_min) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeVacances = [] for date_debut, date_fin in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) listeVacances.append((date_debut, date_fin)) listeDates = [] for periode in ("scolaires", "vacances"): liste_jours = ConvertNumEnDateutil(jours[periode]) if len(liste_jours) > 0: listeDatesTemp = list( rrule.rrule(rrule.WEEKLY, wkst=rrule.MO, byweekday=liste_jours, dtstart=date_min, until=date_max)) for date in listeDatesTemp: date = date.date() isVacances = IsVacances(listeVacances, date) if periode == "scolaires" and isVacances == False: listeDates.append(date) if periode == "vacances" and isVacances == True: listeDates.append(date) listeDates.sort() return listeDates
def __init__(self, donnees, dictTitulaires): self.IDpiece = donnees[0] self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[1]) self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[2]) self.public = donnees[3] self.nomPiece = donnees[4] self.IDindividu = donnees[5] self.IDfamille = donnees[6] self.individu_nom = donnees[7] self.individu_prenom = donnees[8] # Nom Individu si pièce individuelle if self.individu_prenom == None : self.individu_nom_complet = self.individu_nom else : self.individu_nom_complet = u"%s %s" % (self.individu_nom, self.individu_prenom) # Nom Famille si pièce familiale if self.IDfamille != None : self.nom_titulaires = dictTitulaires[self.IDfamille]["titulairesSansCivilite"] else : self.nom_titulaires = "" # Type de pièce if self.public == "famille" : self.nomPublic = _(u"Familiale") else : self.nomPublic = _(u"Individuelle")
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 dictResultats.has_key(key) == 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 dictResultats.has_key(key) == 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.iteritems() : track = Track(self, dictTemp) listeListeView.append(track) return listeListeView
def __init__(self, donnees): self.IDperiode = donnees[0] self.IDactivite = donnees[1] self.nom = donnees[2] # Période self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[3]) self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[4]) self.periode = u"%s;%s" % (self.date_fin, self.date_debut) # Affichage self.affichage = bool(donnees[5]) self.affichage_date_debut = donnees[6] if isinstance(self.affichage_date_debut, str) or isinstance(self.affichage_date_debut, unicode) : self.affichage_date_debut = datetime.datetime.strptime(self.affichage_date_debut, "%Y-%m-%d %H:%M:%S") self.affichage_date_fin = donnees[7] if isinstance(self.affichage_date_fin, str) or isinstance(self.affichage_date_fin, unicode) : self.affichage_date_fin = datetime.datetime.strptime(self.affichage_date_fin, "%Y-%m-%d %H:%M:%S") if self.affichage == True : if self.affichage_date_debut == None : self.affichage_periode = True #_(u"Toujours afficher") self.affichage_actuel = True else : self.affichage_periode = (self.affichage_date_fin, self.affichage_date_debut) if self.affichage_date_debut <= datetime.datetime.now() and self.affichage_date_fin >= datetime.datetime.now() : self.affichage_actuel = True else : self.affichage_actuel = False else : self.affichage_periode = False #_(u"Ne pas afficher") self.affichage_actuel = False
def __init__(self, parent, donnees): self.IDinscription = donnees[0] self.IDindividu = donnees[1] self.IDfamille = donnees[2] self.IDactivite = donnees[3] self.IDgroupe = donnees[4] self.IDcategorie_tarif = donnees[5] self.date_inscription = donnees[6] self.nom_activite = donnees[7] self.nom_groupe = donnees[8] self.nom_categorie = donnees[9] self.date_desinscription = UTILS_Dates.DateEngEnDateDD(donnees[10]) self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[11]) self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[12]) self.psu_activation = donnees[13] ## self.logo_activite = donnees[13] ## self.bmp = self.GetImage() # Nom des titulaires de famille self.nomTitulaires = _(u"IDfamille n°%d") % self.IDfamille if parent.dictFamillesRattachees != None: if parent.dictFamillesRattachees.has_key(self.IDfamille): self.nomTitulaires = parent.dictFamillesRattachees[ self.IDfamille]["nomsTitulaires"] # Validité de la pièce if (datetime.date.today() <= self.date_fin and (self.date_desinscription is None or self.date_desinscription >= datetime.date.today())): self.valide = True else: self.valide = False
def Importation(self): listeActivites = [] dictActivites = {} if len(self.listePeriodes) == 0: return listeActivites, dictActivites # Condition Périodes conditionsPeriodes = GetSQLdates(self.listePeriodes) # Récupération des activités disponibles la période sélectionnée DB = GestionDB.DB() req = """SELECT activites.IDactivite, nom, abrege, date_debut, date_fin FROM activites LEFT JOIN ouvertures ON ouvertures.IDactivite = activites.IDactivite WHERE %s GROUP BY activites.IDactivite ORDER BY date_fin DESC;""" % conditionsPeriodes DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() for IDactivite, nom, abrege, date_debut, date_fin in listeDonnees: if date_debut != None: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) if date_fin != None: date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) dictTemp = { "nom": nom, "abrege": abrege, "date_debut": date_debut, "date_fin": date_fin, "tarifs": {} } dictActivites[IDactivite] = dictTemp listeActivites.append((nom, IDactivite)) listeActivites.sort() return listeActivites, dictActivites
def Init_grille(self, ctrl_grille=None): # Récupération des paramètres IDactivite = int(self.dict_parametres["IDactivite"]) date_debut_periode = UTILS_Dates.DateEngEnDateDD(self.dict_parametres["date_debut_periode"]) date_fin_periode = UTILS_Dates.DateEngEnDateDD(self.dict_parametres["date_fin_periode"]) # Init de la grille des conso ctrl_grille.InitGrille(IDindividu=self.track.IDindividu, IDfamille=self.track.IDfamille, IDactivite=IDactivite, periode=(date_debut_periode, date_fin_periode))
def Verification(self, categorie=None, donnees=None, silencieux=False): liste_problemes = [] # Formate les données reçues if type(donnees) in (datetime.date, str, unicode) : listeDonnees = [{"date" : donnees},] elif type(donnees) == dict : listeDonnees = [donnees,] elif donnees == None : listeDonnees = [] else : listeDonnees = donnees if type(categorie) == list : listeCategories = categorie else: listeCategories = [categorie,] # Spécial consommations if "consommations" in listeCategories : listeCategories.append("prestations") # Analyse des données for donnees in listeDonnees : # Recherche le format de la donnée if type(donnees) == datetime.date: date = donnees elif type(donnees) in (str, unicode): date = UTILS_Dates.DateEngEnDateDD(donnees) elif type(donnees) == dict: date = donnees["date"] if type(date) in (str, unicode): date = UTILS_Dates.DateEngEnDateDD(date) # Vérifie que la date n'est pas dans une période de gestion for periode in self.liste_periodes : if date >= periode.date_debut and date <= periode.date_fin : # Vérifie que la catégorie est verrouillée verrou = False for categorie in listeCategories: if hasattr(periode, "verrou_%s" % categorie) : if getattr(periode, "verrou_%s" % categorie) == 1 : verrou = True if verrou == True : liste_problemes.append("- Probleme le " + str(date)) break if len(liste_problemes) > 0 : if silencieux == False : dlg = DLG_Verrouillage(self.parent)#, liste_problemes=liste_problemes) dlg.ShowModal() dlg.Destroy() return False return True
def Importation(self): dictActivites = {} dictUnites = {} # Conditions conditions = [] if self.parent.check_repas.GetValue() == True: conditions.append("AND unites.repas=1") # Récupération des activités et des unités DB = GestionDB.DB() req = """SELECT activites.IDactivite, activites.nom, activites.abrege, activites.date_debut, activites.date_fin, groupes.IDgroupe, groupes.nom, unites.IDunite, unites.nom, unites.ordre FROM activites LEFT JOIN groupes ON groupes.IDactivite = activites.IDactivite LEFT JOIN unites ON unites.IDactivite = activites.IDactivite WHERE unites.IDunite IS NOT NULL %s GROUP BY groupes.IDgroupe, unites.IDunite ORDER BY activites.date_fin, groupes.ordre, unites.ordre;""" % " ".join( conditions) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() for IDactivite, nom, abrege, date_debut, date_fin, IDgroupe, nomGroupe, IDunite, nomUnite, ordreUnite in listeDonnees: if date_debut != None: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) if date_fin != None: date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) # Mémorisation de l'activité, du groupe et de l'unité if (IDactivite in dictActivites) == False: dictActivites[IDactivite] = { "nom": nom, "abrege": abrege, "date_debut": date_debut, "date_fin": date_fin, "groupes": {} } if (IDgroupe in dictActivites[IDactivite]["groupes"]) == False: dictActivites[IDactivite]["groupes"][IDgroupe] = { "IDgroupe": IDgroupe, "nom": nomGroupe, "unites": [] } dictActivites[IDactivite]["groupes"][IDgroupe]["unites"].append({ "IDunite": IDunite, "nom": nomUnite, "ordre": ordreUnite }) return dictActivites, dictUnites
def Importation(self): if self.IDactivite == None: return [] DB = GestionDB.DB() # Recherche des catégories de tarifs dictCategoriesTarifs = {} req = """SELECT IDcategorie_tarif, nom FROM categories_tarifs;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() for IDcategorie_tarif, nom in listeDonnees: dictCategoriesTarifs[IDcategorie_tarif] = nom # Recherche les tarifs dictIndividus = {} req = """SELECT IDtarif, tarifs.IDactivite, tarifs.IDnom_tarif, noms_tarifs.nom, date_debut, date_fin, methode, categories_tarifs, groupes, description FROM tarifs LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif WHERE type='CREDIT' AND forfait_beneficiaire='individu' AND tarifs.IDactivite=%d ORDER BY noms_tarifs.nom, date_debut;""" % self.IDactivite DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeTarifs = [] for IDtarif, IDactivite, IDnom_tarif, nomTarif, date_debut, date_fin, methode, categories_tarifs, groupes, description in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) listeCategoriesTarifs = ConvertStrToListe(categories_tarifs) listeNomsCategories = [] for IDcategorie_tarif in listeCategoriesTarifs: nomCategorieTarif = _(u"Categorie de tarif inconnue") if dictCategoriesTarifs.has_key(IDcategorie_tarif): nomCategorieTarif = dictCategoriesTarifs[IDcategorie_tarif] listeNomsCategories.append(nomCategorieTarif) dictTemp = { "IDtarif": IDtarif, "IDactivite": IDactivite, "IDnom_tarif": IDnom_tarif, "nomTarif": nomTarif, "date_debut": date_debut, "date_fin": date_fin, "methode": methode, "categories_tarifs": categories_tarifs, "groupes": groupes, "listeNomsCategories": listeNomsCategories, "nomPrecisTarif": description, "listeCategoriesTarifs": listeCategoriesTarifs, } listeTarifs.append(dictTemp) return listeTarifs
def __init__(self, donnees): self.IDperiode = donnees[0] self.IDactivite = donnees[1] self.nom = donnees[2] # Période self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[3]) self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[4]) self.periode = u"%s;%s" % (self.date_fin, self.date_debut) # Affichage self.affichage = bool(donnees[5]) self.affichage_date_debut = donnees[6] if isinstance(self.affichage_date_debut, str) or isinstance( self.affichage_date_debut, six.text_type): try: self.affichage_date_debut = datetime.datetime.strptime( self.affichage_date_debut, "%Y-%m-%d %H:%M:%S") except: temp = datetime.datetime.strptime(self.affichage_date_debut, "%Y-%m-%d") self.affichage_date_debut = datetime.datetime(year=temp.year, month=temp.month, day=temp.day, hour=0, minute=0) self.affichage_date_fin = donnees[7] if isinstance(self.affichage_date_fin, str) or isinstance( self.affichage_date_fin, six.text_type): try: self.affichage_date_fin = datetime.datetime.strptime( self.affichage_date_fin, "%Y-%m-%d %H:%M:%S") except: temp = datetime.datetime.strptime(self.affichage_date_fin, "%Y-%m-%d") self.affichage_date_fin = datetime.datetime(year=temp.year, month=temp.month, day=temp.day, hour=23, minute=59) if self.affichage == True: if self.affichage_date_debut == None: self.affichage_periode = True #_(u"Toujours afficher") self.affichage_actuel = True else: self.affichage_periode = (self.affichage_date_fin, self.affichage_date_debut) if self.affichage_date_debut <= datetime.datetime.now( ) and self.affichage_date_fin >= datetime.datetime.now(): self.affichage_actuel = True else: self.affichage_actuel = False else: self.affichage_periode = False #_(u"Ne pas afficher") self.affichage_actuel = False
def GetQuotientsFamiliaux(self): listeQF = [] DB = GestionDB.DB() req = """SELECT IDquotient, IDfamille, date_debut, date_fin, quotient, IDtype_quotient FROM quotients WHERE IDfamille=%d ORDER BY date_debut;""" % self.IDfamille DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() for IDquotient, IDfamille, date_debut, date_fin, quotient, IDtype_quotient in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) listeQF.append((date_debut, date_fin, quotient, IDtype_quotient)) return listeQF
def GetPrelevementsMandats(self): """ Récupère les prélèvements existants pour chaque mandat """ DB = GestionDB.DB() # Prélèvements req = """SELECT IDprelevement, IDfamille, IDmandat, statut, lots_prelevements.date FROM prelevements LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot WHERE IDmandat IS NOT NULL ORDER BY lots_prelevements.date ;""" DB.ExecuterReq(req) listePrelevements = DB.ResultatReq() # Pièces PES ORMC req = """SELECT IDpiece, IDfamille, prelevement_IDmandat, prelevement_statut, pes_lots.date_prelevement FROM pes_pieces LEFT JOIN pes_lots ON pes_lots.IDlot = pes_pieces.IDlot WHERE prelevement_IDmandat IS NOT NULL AND prelevement=1 ORDER BY pes_lots.date_prelevement ;""" DB.ExecuterReq(req) listePieces = DB.ResultatReq() DB.Close() dictPrelevements = {} for listeDonnees in (listePrelevements, listePieces) : for IDprelevement, IDfamille, IDmandat, statut, date in listeDonnees : date = UTILS_Dates.DateEngEnDateDD(date) if (IDmandat in dictPrelevements) == False : dictPrelevements[IDmandat] = [] dictPrelevements[IDmandat].append({"IDprelevement":IDprelevement, "IDfamille":IDfamille, "IDmandat":IDmandat, "statut":statut, "date":date}) return dictPrelevements
def SetListeDonnees(self): self.listeNoms = [_(u"Toutes les années")] self.listeID = [ None, ] DB = GestionDB.DB() req = """SELECT date, COUNT(IDconso) FROM consommations GROUP BY date ;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: return dictAnnees = {} for date, nbre_conso in listeDonnees: dateDD = UTILS_Dates.DateEngEnDateDD(date) if dateDD != None: if (dateDD.year in dictAnnees) == False: dictAnnees[dateDD.year] = 0 dictAnnees[dateDD.year] += nbre_conso listeAnnees = list(dictAnnees.keys()) listeAnnees.sort() for annee in listeAnnees: nbreConso = dictAnnees[annee] self.listeNoms.append(u"%s (%d consommations)" % (annee, nbreConso)) self.listeID.append(annee) self.SetItems(self.listeNoms) self.SetSelection(len(listeAnnees))
def SetListeDonnees(self): self.listeNoms = [_(u"Toutes")] self.listeID = [ None, ] DB = GestionDB.DB() req = """SELECT IDprestation, date FROM prestations;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: return dictAnnees = {} for IDreglement, date in listeDonnees: dateDD = UTILS_Dates.DateEngEnDateDD(date) if dateDD != None: if dictAnnees.has_key(dateDD.year) == False: dictAnnees[dateDD.year] = 0 dictAnnees[dateDD.year] += 1 listeAnnees = dictAnnees.keys() listeAnnees.sort() for annee in listeAnnees: nbreReglements = dictAnnees[annee] #self.listeNoms.append(u"%s (%d)" % (annee, nbreReglements)) self.listeNoms.append(str(annee)) self.listeID.append(annee) self.SetItems(self.listeNoms) self.SetSelection(len(listeAnnees))
def Importation_depots(self): """ Importation des données """ DB = GestionDB.DB() if len(self.listeDepots) == 0 : conditionDepots = "()" elif len(self.listeDepots) == 1 : conditionDepots = "(%d)" % self.listeDepots[0] else : conditionDepots = str(tuple(self.listeDepots)) req = """SELECT depots.IDdepot, depots.date, nom, verrouillage, depots.IDcompte, SUM(reglements.montant) FROM depots LEFT JOIN reglements ON reglements.IDdepot = depots.IDdepot WHERE depots.IDdepot IN %s GROUP BY depots.IDdepot ORDER BY depots.date ;""" % conditionDepots DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictDepots = {} for IDdepot, date, nom, verrouillage, IDcompte, montantTotal in listeDonnees : date = UTILS_Dates.DateEngEnDateDD(date) if montantTotal == None : montantTotal = 0.0 dictDepots[IDdepot] = {"date":date, "nom":nom, "verrouillage":verrouillage, "IDcompte":IDcompte, "montantTotal":montantTotal} DB.Close() return dictDepots
def GetFacturesPrelevees(self): """ Recherche si la facture est déjà présente dans un autre lot de prélèvement """ DB = GestionDB.DB() req = """SELECT IDprelevement, prelevements.IDlot, IDfacture, statut, lots_prelevements.date, lots_prelevements.nom FROM prelevements LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot ;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() dictFacturesPrelevees = {} for IDprelevement, IDlot, IDfacture, statut, datePrelevement, nomPrelevement in listeDonnees: datePrelevement = UTILS_Dates.DateEngEnDateDD(datePrelevement) if dictFacturesPrelevees.has_key(IDfacture) == False: dictFacturesPrelevees[IDfacture] = [] dictFacturesPrelevees[IDfacture].append({ "IDprelevement": IDprelevement, "IDlot": IDlot, "statut": statut, "datePrelevement": datePrelevement, "nomPrelevement": nomPrelevement }) return dictFacturesPrelevees