def GetProduitsLoues(DB=None, date_reference=datetime.datetime.now()):
""" Recherche les produits loués à la date de référence """
if DB == None:
DBT = GestionDB.DB()
else:
DBT = DB
# Recherche les locations à la date de référence
req = """SELECT IDlocation, IDproduit, IDfamille, date_debut, date_fin
FROM locations
WHERE date_debut<='%s' AND (date_fin IS NULL OR date_fin>='%s')
;""" % (date_reference, date_reference)
DBT.ExecuterReq(req)
listeLocations = DBT.ResultatReq()
dictLocations = {}
for IDlocation, IDproduit, IDfamille, date_debut, date_fin in listeLocations:
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
if dictLocations.has_key(IDproduit) == False:
dictLocations[IDproduit] = []
dictLocations[IDproduit] = {
"IDlocation": IDlocation,
"IDfamille": IDfamille,
"date_debut": date_debut,
"date_fin": date_fin
}
if DB == None:
DBT.Close()
return dictLocations
def Importation(self):
""" Importation des données """
db = GestionDB.DB()
req = """SELECT IDfamille, IDproduit, observations, date_debut, date_fin
FROM locations WHERE IDlocation=%d;""" % self.IDlocation
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
if len(listeDonnees) == 0 : return
IDfamille, IDproduit, observations, date_debut, date_fin = listeDonnees[0]
# Généralités
self.ctrl_loueur.SetIDfamille(IDfamille)
self.ctrl_produit.SetIDproduit(IDproduit)
self.ctrl_observations.SetValue(observations)
# Date de début
if date_debut != None :
self.ctrl_date_debut.SetDate(datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date_debut), "%Y-%m-%d"))
self.ctrl_heure_debut.SetHeure(datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date_debut), "%H:%M"))
# Date de fin
if date_fin != None :
self.ctrl_date_fin.SetDate(datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date_fin), "%Y-%m-%d"))
self.ctrl_heure_fin.SetHeure(datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date_fin), "%H:%M"))
self.check_date_fin.SetValue(True)
def SetDate(self, date):
if type(date) == datetime.datetime or (type(date) in (str, six.text_type) and ":" in date):
self.ctrl_date.SetDate(datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date), "%Y-%m-%d"))
if self.heure == True :
self.ctrl_heure.SetHeure(datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date), "%H:%M"))
else :
self.ctrl_date.SetDate(date)
def GetTracks(self):
""" Récupération des données """
DB = GestionDB.DB()
req = """SELECT IDreservation, date_debut, date_fin, IDlocation, portail_reservations_locations.IDproduit, etat, resultat, produits.nom
FROM portail_reservations_locations
LEFT JOIN produits ON produits.IDproduit = portail_reservations_locations.IDproduit
WHERE IDaction=%d ORDER BY date_debut;""" % self.track_demande.IDaction
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
# Importe locations existantes
liste_IDlocation = []
for item in listeDonnees:
if "-" not in item[3]:
liste_IDlocation.append(int(item[3]))
else:
liste_IDlocation.append(item[3])
if len(liste_IDlocation) == 0:
condition = "()"
elif len(liste_IDlocation) == 1:
if type(liste_IDlocation[0]) == int:
condition = "(%d)" % liste_IDlocation[0]
else:
condition = "('%s')" % liste_IDlocation[0]
else:
condition = str(tuple(liste_IDlocation))
req = """SELECT IDlocation, date_debut, date_fin, locations.IDproduit, produits.nom, IDlocation_portail
FROM locations
LEFT JOIN produits ON produits.IDproduit = locations.IDproduit
WHERE IDlocation IN %s OR IDlocation_portail IN %s;""" % (condition,
condition)
DB.ExecuterReq(req)
listeExistantes = DB.ResultatReq()
DB.Close()
self.dict_locations_existantes = {}
for IDlocation, date_debut, date_fin, IDproduit, nom_produit, IDlocation_portail in listeExistantes:
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
dict_temp = {
"IDlocation": IDlocation,
"date_debut": date_debut,
"date_fin": date_fin,
"IDproduit": IDproduit,
"nom_produit": nom_produit
}
self.dict_locations_existantes[six.text_type(
IDlocation)] = dict_temp
if IDlocation_portail:
self.dict_locations_existantes[IDlocation_portail] = dict_temp
# Mémorisation des tracks
listeListeView = []
for item in listeDonnees:
listeListeView.append(Track(self, item))
return listeListeView
def Importation(self):
""" Importation des données """
DB = GestionDB.DB()
# Importation de la location
req = """SELECT IDfamille, IDproduit, observations, date_debut, date_fin, quantite
FROM locations WHERE IDlocation=%d;""" % self.IDlocation
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) == 0 :
DB.Close()
return
IDfamille, IDproduit, observations, date_debut, date_fin, quantite = listeDonnees[0]
# Généralités
self.ctrl_loueur.SetIDfamille(IDfamille)
self.ctrl_produit.SetIDproduit(IDproduit)
if observations == None :
observations = ""
self.ctrl_observations.SetValue(observations)
# Date de début
if date_debut != None:
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
self.SetDebut(date_debut)
# Date de fin
if date_fin != None :
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
self.SetFin(date_fin)
# Quantité
if quantite != None :
self.ctrl_quantite.SetValue(quantite)
# Importation des prestations
req = """SELECT
IDprestation, date, label, montant, IDfacture
FROM prestations
WHERE categorie="location" and IDdonnee=%d;""" % self.IDlocation
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
DB.Close()
liste_tracks_prestations = []
for IDprestation, date, label, montant, IDfacture in listePrestations :
date = UTILS_Dates.DateEngEnDateDD(date)
dictPrestation = {
"IDprestation" : IDprestation, "date" : date, "label" : label,
"montant": montant, "IDfacture" : IDfacture,
}
track_prestation = OL_Locations_prestations.Track_prestation(dictPrestation)
liste_tracks_prestations.append(track_prestation)
self.liste_initiale_IDprestation.append(IDprestation)
self.ctrl_parametres.GetPageAvecCode("facturation").SetDonnees({"prestations" : liste_tracks_prestations})
def Importation(self):
""" Importation des données """
db = GestionDB.DB()
req = """SELECT portail_inscriptions_affichage, portail_inscriptions_date_debut,
portail_inscriptions_date_fin, portail_reservations_affichage, portail_unites_multiples,
portail_reservations_limite, portail_reservations_absenti
FROM activites
WHERE IDactivite=%d;""" % self.IDactivite
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
if len(listeDonnees) == 0: return
portail_inscriptions_affichage, portail_inscriptions_date_debut, portail_inscriptions_date_fin, portail_reservations_affichage, portail_unites_multiples, portail_reservations_limite, portail_reservations_absenti = listeDonnees[
0]
# Inscriptions
if portail_inscriptions_affichage == 1:
if portail_inscriptions_date_debut != None:
self.radio_inscriptions_dates.SetValue(True)
self.ctrl_inscriptions_date_debut.SetDate(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(
portail_inscriptions_date_debut), "%Y-%m-%d"))
self.ctrl_inscriptions_heure_debut.SetHeure(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(
portail_inscriptions_date_debut), "%H:%M"))
self.ctrl_inscriptions_date_fin.SetDate(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(
portail_inscriptions_date_fin), "%Y-%m-%d"))
self.ctrl_inscriptions_heure_fin.SetHeure(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(
portail_inscriptions_date_fin), "%H:%M"))
else:
self.radio_inscriptions_oui.SetValue(True)
else:
self.radio_inscriptions_non.SetValue(True)
# Réservations
if portail_reservations_affichage == 1:
self.radio_reservations_oui.SetValue(True)
else:
self.radio_reservations_non.SetValue(True)
if portail_unites_multiples != None:
self.page_unites.check_unites_multiples.SetValue(
portail_unites_multiples)
# Options
self.page_options.SetDateLimite(portail_reservations_limite)
self.page_options.SetAbsenti(portail_reservations_absenti)
def SetIDlocation(self, IDlocation):
self.IDlocation = IDlocation
# Importation des données de la location
DB = GestionDB.DB()
req = """SELECT IDfamille, locations.IDproduit, locations.observations, date_debut, date_fin,
produits.nom, produits_categories.nom
FROM locations
LEFT JOIN produits ON produits.IDproduit = locations.IDproduit
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
WHERE IDlocation=%d;""" % self.IDlocation
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
IDfamille, IDproduit, observations, date_debut, date_fin, nomProduit, nomCategorie = listeDonnees[
0]
date_debut_temp = datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(date_debut), "%d/%m/%Y")
heure_debut_temp = datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(date_debut), "%Hh%M")
texte_debut = _(u"%s à %s") % (date_debut_temp, heure_debut_temp)
if date_fin != None:
date_fin_temp = datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(date_fin), "%d/%m/%Y")
heure_fin_temp = datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(date_fin), "%Hh%M")
texte_fin = _(u"%s à %s") % (date_fin_temp, heure_fin_temp)
else:
texte_fin = _(u"Non définie")
if len(observations) > 0:
texte_observations = _(u"<BR>Notes : %s") % observations
else:
texte_observations = ""
texte = _(u"""
<FONT SIZE=5><B>Demande satisfaite</B><BR></FONT>
<BR>
Produit : <b>%s</b><BR>
Catégorie : %s <BR>
<BR>
Début de location : %s <BR>
Fin de location : %s <BR>
%s
""") % (nomProduit, nomCategorie, texte_debut, texte_fin,
texte_observations)
self.SetTexte(texte)
def __init__(self, donnees=None):
self.IDconso = donnees[0]
self.date = donnees[1]
self.heure_debut = donnees[2]
self.heure_fin = donnees[3]
self.badgeage_debut = UTILS_Dates.DateEngEnDateDDT(donnees[4])
self.badgeage_fin = UTILS_Dates.DateEngEnDateDDT(donnees[5])
self.IDindividu = donnees[6]
self.nom = donnees[7]
self.prenom = donnees[8]
self.nom_unite = donnees[9]
if self.prenom == None: self.prenom = ""
self.nom_individu = u"%s %s" % (self.nom, self.prenom)
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 Importation(self):
""" Importation des données """
if self.IDperiode == None:
return
DB = GestionDB.DB()
req = """SELECT IDactivite, nom, date_debut, date_fin, affichage, affichage_date_debut, affichage_date_fin, IDmodele, introduction, prefacturation
FROM portail_periodes
WHERE IDperiode=%d;""" % self.IDperiode
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
IDactivite, nom, date_debut, date_fin, affichage, affichage_date_debut, affichage_date_fin, IDmodele, introduction, prefacturation = listeDonnees[
0]
affichage_date_debut = UTILS_Dates.DateEngEnDateDDT(
affichage_date_debut)
affichage_date_fin = UTILS_Dates.DateEngEnDateDDT(affichage_date_fin)
self.IDactivite = IDactivite
self.ctrl_nom.SetValue(nom)
if introduction != None:
self.ctrl_intro.SetValue(introduction)
self.ctrl_date_debut.SetDate(date_debut)
self.ctrl_date_fin.SetDate(date_fin)
if affichage == 1 and affichage_date_debut == None:
self.radio_oui.SetValue(True)
elif affichage == 1 and affichage_date_debut != None:
self.radio_dates.SetValue(True)
self.ctrl_affichage_date_debut.SetDate(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_debut),
"%Y-%m-%d"))
self.ctrl_affichage_date_fin.SetDate(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_fin),
"%Y-%m-%d"))
self.ctrl_affichage_heure_debut.SetHeure(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_debut),
"%H:%M"))
self.ctrl_affichage_heure_fin.SetHeure(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_fin), "%H:%M"))
else:
self.radio_non.SetValue(True)
if IDmodele not in (None, ""):
self.radio_modele_choix.SetValue(True)
self.ctrl_modele_email.SetID(IDmodele)
if prefacturation == 1:
self.ctrl_prefacturation.SetValue(True)
def Importation(self):
""" Importation des données """
if self.IDmessage == None:
return
DB = GestionDB.DB()
req = """SELECT IDmessage, titre, texte, affichage_date_debut, affichage_date_fin
FROM portail_messages
WHERE IDmessage=%d;""" % self.IDmessage
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0: return
IDmessage, titre, texte, affichage_date_debut, affichage_date_fin = listeDonnees[
0]
affichage_date_debut = UTILS_Dates.DateEngEnDateDDT(
affichage_date_debut)
affichage_date_fin = UTILS_Dates.DateEngEnDateDDT(affichage_date_fin)
self.ctrl_titre.SetValue(titre)
self.ctrl_texte.SetValue(texte)
if affichage_date_debut == None or affichage_date_fin == None:
self.radio_oui.SetValue(True)
else:
self.radio_dates.SetValue(True)
self.ctrl_affichage_date_debut.SetDate(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_debut),
"%Y-%m-%d"))
self.ctrl_affichage_date_fin.SetDate(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_fin),
"%Y-%m-%d"))
self.ctrl_affichage_heure_debut.SetHeure(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_debut),
"%H:%M"))
self.ctrl_affichage_heure_fin.SetHeure(
datetime.datetime.strftime(
UTILS_Dates.DateEngEnDateDDT(affichage_date_fin), "%H:%M"))
def _load_data(self):
""" Importation des données """
self.preferred_period = None
self.categories = []
self.events = []
# Période préférée
dateDuJour = datetime.datetime.today()
dateDebut = dateDuJour - datetime.timedelta(6)
dateFin = dateDuJour + datetime.timedelta(1)
self.preferred_period = TL.TimePeriod(dateDebut, dateFin)
# Récupération des events LOCATIONS
DB = GestionDB.DB()
req = """SELECT IDlocation, IDfamille, date_debut, date_fin, locations.quantite,
produits.IDproduit, produits.nom
FROM locations
LEFT JOIN produits ON produits.IDproduit = locations.IDproduit
ORDER BY locations.IDproduit;"""
DB.ExecuterReq(req)
listeLocations = DB.ResultatReq()
DB.Close()
# Préparation des données
listeIDfamille = []
dictProduits = {}
for IDlocation, IDfamille, date_debut, date_fin, quantite, IDproduit, nom_produit in listeLocations:
listeIDfamille.append(IDfamille)
if dictProduits.has_key(IDproduit) == False:
r = random.randint(128, 255)
v = random.randint(128, 255)
b = random.randint(128, 255)
categorie = TL.Category(nom_produit, wx.Colour(r, v, b), True)
dictProduits[IDproduit] = categorie
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille)
# Création des events
for IDlocation, IDfamille, date_debut, date_fin, quantite, IDproduit, nom_produit in listeLocations:
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
if date_fin == None:
date_fin = datetime.datetime(2999, 1, 1)
if quantite == None:
quantite = 1
if dictTitulaires.has_key(IDfamille):
nomTitulaires = dictTitulaires[IDfamille][
"titulairesSansCivilite"]
else:
nomTitulaires = _(u"Famille inconnue")
texte = nomTitulaires
if quantite > 1:
texte += _(u" - Quantité : %d") % quantite
date_debut_str = datetime.datetime.strftime(
date_debut, "%d/%m/%Y-%Hh%M")
if date_fin.year == 2999:
date_fin_str = _(u"Illimité")
else:
date_fin_str = datetime.datetime.strftime(
date_fin, "%d/%m/%Y-%Hh%M")
description = _(
u"Loueur : %s\nProduit : %s\nQuantité : %d\nDébut : %s\nFin : %s"
) % (nomTitulaires, nom_produit, quantite, date_debut_str,
date_fin_str)
icon = None
event = TL.Event(date_debut, date_fin, texte,
dictProduits[IDproduit])
event.set_data("IDproduit", IDproduit)
if description != None: event.set_data("description", description)
if icon != None: event.set_data("icon", icon)
self.events.append(event)
def Importation(self):
""" Importation des données """
if self.IDdemande != None:
DB = GestionDB.DB()
req = """SELECT date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation
FROM locations_demandes WHERE IDdemande=%d;""" % self.IDdemande
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation = listeDonnees[
0]
req = """SELECT IDfiltre, IDquestion, categorie, choix, criteres FROM questionnaire_filtres WHERE categorie='location_demande' AND IDdonnee=%d;""" % self.IDdemande
DB.ExecuterReq(req)
listeFiltres = DB.ResultatReq()
DB.Close()
else:
date = None
IDfamille = None
observations = ""
categories = ""
produits = ""
statut = "attente"
motif_refus = ""
IDlocation = None
listeFiltres = []
# Généralités
if date != None:
self.ctrl_date_demande.SetDate(
datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date),
"%Y-%m-%d"))
self.ctrl_heure_demande.SetHeure(
datetime.datetime.strftime(UTILS_Dates.DateEngEnDateDDT(date),
"%H:%M"))
if IDfamille != None:
self.ctrl_loueur.SetIDfamille(IDfamille)
if observations != None:
self.ctrl_observations.SetValue(observations)
# Critères
self.notebook.GetPage("criteres").ctrl_categories.SetListeCategories(
UTILS_Texte.ConvertStrToListe(categories))
self.notebook.GetPage("criteres").ctrl_produits.SetListeProduits(
UTILS_Texte.ConvertStrToListe(produits))
# Filtres
listeDonnees = []
for IDfiltre, IDquestion, categorie, choix, criteres in listeFiltres:
listeDonnees.append({
"IDfiltre": IDfiltre,
"IDquestion": IDquestion,
"choix": choix,
"criteres": criteres
})
self.notebook.GetPage("criteres").ctrl_filtres.SetDonnees(listeDonnees)
self.listeInitialeFiltres = copy.deepcopy(listeDonnees)
# Statut
self.ctrl_statut.SetPageByCode(statut)
if motif_refus != None:
self.ctrl_statut.GetPageByCode("refusee").ctrl_motif.SetValue(
motif_refus)
self.ctrl_statut.Show(True)
self.ctrl_attribution.Show(False)
if IDlocation != None:
#self.ctrl_statut.GetPageByCode("attribuee").SetIDlocation(IDlocation)
#self.ctrl_statut.GetChoiceCtrl().Enable(False)
self.SetAttribution(IDlocation)
def FormateHorodatage(horodatage):
return UTILS_Dates.DateEngEnDateDDT(horodatage).strftime("%d/%m/%Y %H:%M:%S")
def __init__(self, parent, donnees):
self.IDreservation = donnees[0]
self.date_debut = UTILS_Dates.DateEngEnDateDDT(donnees[1])
self.date_fin = UTILS_Dates.DateEngEnDateDDT(donnees[2])
self.IDlocation = donnees[3]
self.IDproduit = donnees[4]
self.etat = donnees[5]
self.resultat = donnees[6]
self.nom_produit = donnees[7]
self.quantite = 1
self.action_possible = False
self.date_debut_txt = self.date_debut.strftime("%d/%m/%Y-%H:%M")
# Formate état
if self.etat == "ajouter":
self.action = u"Ajouter %s de %s à %s" % (
self.nom_produit, self.date_debut.strftime("%d/%m/%Y-%H:%M"),
self.date_fin.strftime("%d/%m/%Y-%H:%M"))
liste_periodes_non_dispo = Verif_dispo_produit(self)
if len(liste_periodes_non_dispo) > 0:
self.action_possible = False
self.statut = _(
u"Produit non disponible sur la période demandée")
else:
self.action_possible = True
self.statut = _(u"Ajout possible")
if self.etat == "modifier":
if self.IDlocation in parent.dict_locations_existantes:
# Recherche la location à modifier
temp = parent.dict_locations_existantes[self.IDlocation]
self.action = u"Modifier %s de %s à %s > %s de %s à %s" % (
temp["nom_produit"],
temp["date_debut"].strftime("%d/%m/%Y-%H:%M"),
temp["date_fin"].strftime("%d/%m/%Y-%H:%M"),
self.nom_produit,
self.date_debut.strftime("%d/%m/%Y-%H:%M"),
self.date_fin.strftime("%d/%m/%Y-%H:%M"))
self.action_possible = True
self.statut = _(u"Modification possible")
# Vérifie disponibilité produit
if "-" in self.IDlocation:
liste_periodes_non_dispo = Verif_dispo_produit(
self, IDlocation_portail_exception=self.IDlocation)
else:
liste_periodes_non_dispo = Verif_dispo_produit(
self, IDlocation_exception=int(self.IDlocation))
if len(liste_periodes_non_dispo) > 0:
self.action_possible = False
self.statut = _(
u"Produit non disponible sur la période demandée")
else:
self.action_possible = False
self.statut = _(u"La location à modifier est inexistante")
self.action = _(u"Modifier : Location initiale inexistante !")
if self.etat == "supprimer":
self.action = u"Supprimer %s de %s à %s" % (
self.nom_produit, self.date_debut.strftime("%d/%m/%Y-%H:%M"),
self.date_fin.strftime("%d/%m/%Y-%H:%M"))
# Recherche la location à supprimer
if self.IDlocation in parent.dict_locations_existantes:
self.action_possible = True
self.statut = _(u"Suppression possible")
else:
self.action_possible = False
self.statut = _(u"La location à supprimer est inexistante")
if self.resultat == "ok":
self.action_possible = False
if self.etat == "ajouter": self.statut = _(u"Ajout effectué")
if self.etat == "modifier":
self.statut = _(u"Modification effectuée")
if self.etat == "supprimer":
self.statut = _(u"Suppression effectuée")
def GetStockDisponible(DB=None,
IDproduit=None,
date_debut=None,
date_fin=None,
IDlocation_exception=None):
""" Recherche si un produit est disponible sur une période donnée """
if DB == None:
DBT = GestionDB.DB()
else:
DBT = DB
if IDlocation_exception == None:
IDlocation_exception = 0
if date_debut == None:
date_debut = datetime.datetime(1900, 1, 1)
if date_fin == None:
date_fin = datetime.datetime(2999, 1, 1)
# Recherche le stock initial
req = """SELECT IDproduit, quantite
FROM produits
WHERE IDproduit=%d;""" % IDproduit
DBT.ExecuterReq(req)
listeDonnees = DBT.ResultatReq()
stock_initial = listeDonnees[0][1]
if stock_initial == None:
stock_initial = 1
# Recherche les locations du produit sur la période
req = """SELECT IDlocation, IDfamille, date_debut, date_fin, quantite
FROM locations
WHERE locations.IDproduit=%d AND date_debut<='%s' AND (date_fin IS NULL OR date_fin>='%s') AND IDlocation<>%d
;""" % (IDproduit, date_fin, date_debut, IDlocation_exception)
DBT.ExecuterReq(req)
listeDonnees = DBT.ResultatReq()
listeLocations = []
listeDates = [date_debut, date_fin]
for IDlocation, IDfamille, debut, fin, quantite in listeDonnees:
debut = UTILS_Dates.DateEngEnDateDDT(debut)
fin = UTILS_Dates.DateEngEnDateDDT(fin)
if quantite == None:
quantite = 1
listeLocations.append({
"IDlocation": IDlocation,
"IDfamille": IDfamille,
"date_debut": debut,
"date_fin": fin,
"quantite": quantite
})
if debut not in listeDates and debut > date_debut:
listeDates.append(debut)
if fin not in listeDates and fin != None and fin < date_fin:
listeDates.append(fin)
if DB == None:
DBT.Close()
# Analyse des périodes de disponibilités
listeDates.sort()
dictPeriodes = {}
for index in range(0, len(listeDates) - 1):
debut, fin = (listeDates[index], listeDates[index + 1])
disponible = int(stock_initial)
loue = 0
for dictLocation in listeLocations:
if dictLocation["date_debut"] < fin and (
dictLocation["date_fin"] == None
or dictLocation["date_fin"] > debut):
disponible -= dictLocation["quantite"]
loue += dictLocation["quantite"]
dictPeriodes[(debut, fin)] = {"loue": loue, "disponible": disponible}
return dictPeriodes
def _load_data(self):
""" Importation des données """
self.preferred_period = None
self.categories = []
self.events = []
# Période préférée
dateDuJour = datetime.datetime.today()
dateDebut = dateDuJour - datetime.timedelta(6)
dateFin = dateDuJour + datetime.timedelta(1)
self.preferred_period = TL.TimePeriod(dateDebut, dateFin)
# Récupération des events LOCATIONS
DB = GestionDB.DB()
req = """SELECT IDlocation, IDfamille, date_debut, date_fin, quantite
FROM locations
WHERE IDproduit=%d;""" % self.IDproduit
DB.ExecuterReq(req)
listeLocations = DB.ResultatReq()
DB.Close()
listeIDfamille = []
for IDlocation, IDfamille, date_debut, date_fin, quantite in listeLocations:
listeIDfamille.append(IDfamille)
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille)
categorie = TL.Category(_(u"Location"), (156, 205, 255), True)
for IDlocation, IDfamille, date_debut, date_fin, quantite in listeLocations:
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
if date_fin == None:
date_fin = datetime.datetime(2999, 1, 1)
if quantite == None:
quantite = 1
if IDfamille in dictTitulaires:
nomTitulaires = dictTitulaires[IDfamille][
"titulairesSansCivilite"]
else:
nomTitulaires = _(u"Famille inconnue")
texte = u"%s - Quantité : %d" % (nomTitulaires, quantite)
date_debut_str = datetime.datetime.strftime(
date_debut, "%d/%m/%Y-%Hh%M")
if date_fin.year == 2999:
date_fin_str = _(u"Illimité")
else:
date_fin_str = datetime.datetime.strftime(
date_fin, "%d/%m/%Y-%Hh%M")
description = _(
u"Loueur : %s\nQuantité : %d\nDébut : %s\nFin : %s") % (
nomTitulaires, quantite, date_debut_str, date_fin_str)
icon = None
evt = TL.Event(date_debut, date_fin, texte, categorie)
if description != None: evt.set_data("description", description)
if icon != None: evt.set_data("icon", icon)
self.events.append(evt)
# Récupération des events STOCK DISPONIBLE
dictPeriodes = UTILS_Locations.GetStockDisponible(
IDproduit=self.IDproduit, date_debut=None, date_fin=None)
categorie_disponible = TL.Category(_(u"Stock disponible"),
(233, 255, 156), True)
categorie_loue = TL.Category(_(u"Quantité louée"), (204, 227, 250),
True)
for periode, valeurs in dictPeriodes.items():
date_debut = periode[0]
evt = TL.Event(date_debut, date_debut, str(valeurs["loue"]),
categorie_loue)
self.events.append(evt)
evt = TL.Event(date_debut, date_debut, str(valeurs["disponible"]),
categorie_disponible)
self.events.append(evt)
def Importation(self):
DB = GestionDB.DB()
if len(self.listeCategories) == 0: conditionCategories = "()"
elif len(self.listeCategories) == 1: conditionCategories = "(%d)" % self.listeCategories[0]
else: conditionCategories = str(tuple(self.listeCategories))
# Consommations
req = """SELECT IDlocation, IDfamille, date_debut, date_fin, locations.IDproduit, produits.nom, produits.IDcategorie, produits_categories.nom
FROM locations
LEFT JOIN produits ON produits.IDproduit = locations.IDproduit
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
WHERE date_debut>='%s' AND date_debut<='%s'
AND produits.IDcategorie IN %s
;""" % (self.date_debut, self.date_fin, conditionCategories)
DB.ExecuterReq(req)
listeLocations = DB.ResultatReq()
DB.Close()
# Calcul des données
dictResultats = {}
listeProduits = []
for IDlocation, IDfamille, date_debut, date_fin, IDproduit, nom_produit, IDcategorie, nom_categorie in listeLocations :
date_debut = UTILS_Dates.DateEngEnDateDDT(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDDT(date_fin)
mois = date_debut.month
annee = date_debut.year
# Recherche du regroupement
try :
if self.affichage_regroupement == "jour" : regroupement = date_debut.date()
if self.affichage_regroupement == "mois" : regroupement = (annee, mois)
if self.affichage_regroupement == "annee" : regroupement = annee
if self.affichage_regroupement == "categorie" : regroupement = nom_categorie
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 == "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é -")
if self.affichage_donnees == "quantite":
valeur = 1
defaut = 0
else:
defaut = datetime.timedelta(hours=0, minutes=0)
valeur = datetime.timedelta(hours=0, minutes=0)
if date_fin:
valeur = date_fin - date_debut
else:
if date_debut < datetime.datetime.now():
valeur = datetime.datetime.now() - date_debut
# En cas de regroupements multiples :
if type(regroupement) == list:
listeRegroupements = regroupement
else :
listeRegroupements = [regroupement,]
for regroupement in listeRegroupements :
if (IDproduit in dictResultats) == False :
dictResultats[IDproduit] = {}
if (regroupement in dictResultats[IDproduit]) == False :
dictResultats[IDproduit][regroupement] = defaut
dictResultats[IDproduit][regroupement] += valeur
if (nom_produit, IDproduit) not in listeProduits:
listeProduits.append((nom_produit, IDproduit))
listeProduits.sort()
return dictResultats, listeProduits
