def MAJ(self):
self.IDconso = self.dictValeurs["IDconso"]
self.date = self.dictValeurs["date"]
self.IDunite = self.dictValeurs["IDunite"]
self.heure_debut = self.dictValeurs["heure_debut"]
self.heure_fin = self.dictValeurs["heure_fin"]
self.quantite = self.dictValeurs["quantite"]
self.etat = self.dictValeurs["etat"]
self.etiquettes = self.dictValeurs["etiquettes"]
self.nomUnite = "TEST" #self.parent.dictUnites[self.IDunite]["nom"]
self.texteDetail = ""
if self.heure_debut != None and self.heure_fin != None:
self.texteDetail = "%s - %s" % (self.heure_debut.replace(
":", "h"), self.heure_fin.replace(":", "h"))
if self.quantite != None:
self.texteDetail += _(u" Qté=%d") % self.quantite
if self.etat == "reservation":
self.texteEtat = _(u"Réservation")
elif self.etat == "present":
self.texteEtat = _(u"Présent")
elif self.etat == "attente":
self.texteEtat = _(u"Attente")
elif self.etat == "absenti":
self.texteEtat = _(u"Absence injustifiée")
elif self.etat == "absentj":
self.texteEtat = _(u"Absence justifiée")
elif self.etat == "refus":
self.texteEtat = _(u"Refus")
else:
self.texteEtat = ""
# Calcule des horaires
self.heure_debut_time = UTILS_Dates.HeureStrEnTime(self.heure_debut)
self.heure_fin_time = UTILS_Dates.HeureStrEnTime(self.heure_fin)
# Calcule la durée réelle
self.duree_reelle = UTILS_Dates.SoustractionHeures(
self.heure_fin_time, self.heure_debut_time)
self.duree_reelle_str = UTILS_Dates.DeltaEnStr(self.duree_reelle,
separateur="h")
# Calcule la durée arrondie
arrondi_type = self.clsbase.GetValeur("arrondi_type", None)
arrondi_delta = self.clsbase.GetValeur("arrondi_delta", 15)
self.duree_arrondie = UTILS_Dates.CalculerArrondi(
arrondi_type=arrondi_type,
arrondi_delta=arrondi_delta,
heure_debut=self.heure_debut_time,
heure_fin=self.heure_fin_time)
self.duree_arrondie_str = UTILS_Dates.DeltaEnStr(self.duree_arrondie,
separateur="h")
) % nomUniteIncompatible
# Définit le mode
self.mode = mode
# Si la conso n'existe pas déjà :
if case.IsCaseDisponible(heure_debut, heure_fin) == True:
if typeUnite == "Quantite":
quantiteTmp = 1
else:
quantiteTmp = None
if quantite != None:
quantiteTmp = quantite
if typeUnite == "Multihoraires":
barre = case.SaisieBarre(
UTILS_Dates.HeureStrEnTime(heure_debut),
UTILS_Dates.HeureStrEnTime(heure_fin))
case.ModifieEtat(barre.conso, etat)
else:
case.OnClick(saisieHeureDebut=heure_debut,
saisieHeureFin=heure_fin,
saisieQuantite=quantiteTmp,
modeSilencieux=True)
case.ModifieEtat(None, etat)
# Si la conso existe déjà :
else:
# Type Horaire
if typeUnite == "Horaire":
case.OnClick(saisieHeureDebut=heure_debut,
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 inscriptions.statut='ok' AND 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, consommations.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 (date in dict_conso) == 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 Draw(self, grid, attr, dc, rect, row, col, isSelected):
# Préparation du buffer Image
dcGrid = dc
if 'phoenix' in wx.PlatformInfo:
bmp = wx.Bitmap(rect.GetWidth(), rect.GetHeight())
else:
bmp = wx.EmptyBitmap(rect.GetWidth(), rect.GetHeight())
image = wx.MemoryDC()
image.SelectObject(bmp)
gc = wx.GraphicsContext.Create(image)
gc.PushState()
rectCase = wx.Rect(0, 0, rect.GetWidth(), rect.GetHeight())
x, y, largeur, hauteur = rectCase.x, rectCase.y, rectCase.width, rectCase.height
# Dessin du fond
if self.case.ouvert == True:
self.couleurFond = wx.Colour(255, 255, 255)
else:
self.couleurFond = CTRL_Grille.COULEUR_FERME
gc.SetBrush(wx.Brush(self.couleurFond, wx.SOLID))
gc.SetPen(wx.TRANSPARENT_PEN)
gc.DrawRectangle(x, y, largeur, hauteur)
if self.case.ouvert == True:
# Dessin de la bordure 3D pour faire effet Case grid
self.DrawBorder(grid, gc, rectCase)
# Dessin du remplissage
dictInfosPlaces = self.case.GetInfosPlaces()
if dictInfosPlaces != None:
for IDunite_remplissage, valeurs in dictInfosPlaces.iteritems(
):
heure_min = UTILS_Dates.HeureStrEnTime(
grid.dictRemplissage[IDunite_remplissage]["heure_min"])
if heure_min < self.case.heure_min:
heure_min = self.case.heure_min
heure_max = UTILS_Dates.HeureStrEnTime(
grid.dictRemplissage[IDunite_remplissage]["heure_max"])
if heure_max > self.case.heure_max:
heure_max = self.case.heure_max
nbrePlacesRestantes = valeurs["nbrePlacesRestantes"]
nbrePlacesInitial = valeurs["nbrePlacesInitial"]
nbrePlacesPrises = valeurs["nbrePlacesPrises"]
seuil_alerte = valeurs["seuil_alerte"]
nbreAttente = valeurs["nbreAttente"]
couleur = None
if nbrePlacesRestantes > seuil_alerte:
couleur = CTRL_Grille.COULEUR_DISPONIBLE
if nbrePlacesRestantes > 0 and nbrePlacesRestantes <= seuil_alerte:
couleur = CTRL_Grille.COULEUR_ALERTE
if nbrePlacesRestantes <= 0:
couleur = CTRL_Grille.COULEUR_COMPLET
if nbrePlacesInitial > 0 and couleur != None:
gc.SetBrush(wx.Brush(couleur, wx.SOLID))
gc.SetPen(wx.TRANSPARENT_PEN)
posG = self.case.HeureEnPos(heure_min)
posD = self.case.HeureEnPos(heure_max) - posG
gc.DrawRectangle(
posG + PADDING_MULTIHORAIRES["horizontal"], 1,
posD, rectCase.height - 2)
# Dessin des graduations
gc.SetPen(wx.Pen((230, 230, 230), 1, wx.SOLID))
# graduationStep = 25
# listeGraduations = range(UTILS_Dates.HeuresEnDecimal(self.case.heure_min), UTILS_Dates.HeuresEnDecimal(self.case.heure_max)+graduationStep, graduationStep)
# nbreGraduations = len(listeGraduations)
# if nbreGraduations <= 1 :
# nbreGraduations = 2
# step = 1.0 * (rect.width - PADDING_MULTIHORAIRES["horizontal"] * 2) / (nbreGraduations - 1)
# if step > 3.0 :
# x = PADDING_MULTIHORAIRES["horizontal"]
# for temp in listeGraduations :
# gc.StrokeLine(x, 1, x, rect.height-2)
# x += step
h = datetime.timedelta(minutes=0)
for x in range(0, 96):
htime = UTILS_Dates.DeltaEnTime(h)
if htime >= self.case.heure_min and htime <= self.case.heure_max:
x = self.case.HeureEnPos(
h) + PADDING_MULTIHORAIRES["horizontal"]
gc.StrokeLine(x, 1, x, rect.height - 2)
h += datetime.timedelta(minutes=15)
# Dessin des barres
for barre in self.case.listeBarres:
conso = barre.conso
# Calcul des coordonnées de la barre
barre.UpdateRect()
rectBarre = barre.GetRect("case")
# get Couleur barre
couleurBarre = self.GetCouleurBarre(conso)
# Dessin du cadre
if 'phoenix' in wx.PlatformInfo:
gc.SetFont(attr.GetFont(), wx.Colour(0, 0, 0))
else:
gc.SetFont(attr.GetFont())
gc.SetBrush(
wx.Brush((couleurBarre.Red(), couleurBarre.Green(),
couleurBarre.Blue(), 180),
wx.SOLID)) # 128 = demi-transparence
couleurTexte = UTILS_Couleurs.ModifierLuminosite(couleurBarre, -50)
couleur = (couleurTexte[0], couleurTexte[1], couleurTexte[2], 255)
if barre.readOnly == True:
gc.SetPen(wx.TRANSPARENT_PEN)
else:
gc.SetPen(wx.Pen(couleur, 1,
wx.SOLID)) # 128 = demi-transparence
gc.DrawRoundedRectangle(rectBarre.x, rectBarre.y, rectBarre.width,
rectBarre.height, 5)
# Dessin des horaires
heure_debut_x, heure_debut_y, heure_debut_largeur, heure_debut_hauteur = self.DrawTexte(
gc,
rectBarre,
barre.heure_debut.strftime("%Hh%M"),
couleur=couleurTexte,
position="gauche")
heure_fin_x, heure_fin_y, heure_fin_largeur, heure_fin_hauteur = self.DrawTexte(
gc,
rectBarre,
barre.heure_fin.strftime("%Hh%M"),
couleur=couleurTexte,
position="droite")
# Dessin du cadenas VERROUILLAGE
if conso.verrouillage == 1:
imageTemp = wx.Bitmap(
Chemins.GetStaticPath("Images/Special/Cadenas_ferme.png"),
wx.BITMAP_TYPE_ANY)
largeurBmp, hauteurBmp = imageTemp.GetSize()
gc.DrawBitmap(imageTemp, 2, rect.height - 10, largeurBmp,
hauteurBmp)
# Dessin de l'image FORFAIT CREDIT
if conso.etat in (
"reservation", "present", "absenti", "absentj"
) and conso.IDprestation in grid.dictForfaits.keys():
couleurForfait = grid.dictForfaits[
conso.IDprestation]["couleur"]
gc.SetBrush(wx.Brush(couleurForfait, wx.SOLID))
gc.SetPen(wx.TRANSPARENT_PEN)
path = gc.CreatePath()
path.AddLineToPoint(8, 0)
path.AddLineToPoint(1, 8)
path.AddLineToPoint(1, 0)
gc.DrawPath(path)
# Dessin des images
listeImages = []
# Dessin de l'image PRESENT (Coche verte)
if conso.etat == "present":
listeImages.append(
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok5.png"),
wx.BITMAP_TYPE_ANY))
# Dessin de l'image ABSENT JUSTIFIEE (Croix rouge)
if conso.etat == "absentj":
listeImages.append(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/absentj.png"),
wx.BITMAP_TYPE_ANY))
# Dessin de l'image ABSENT INJUSTIFIEE (Croix rouge)
if conso.etat == "absenti":
listeImages.append(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/absenti.png"),
wx.BITMAP_TYPE_ANY))
# Dessin de l'image SANS PRESTATION (Alerte)
if conso.etat in (
"reservation", "present", "absenti", "absentj"
) and conso.IDprestation == None and grid.afficheSansPrestation == True:
listeImages.append(
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Gratuit.png"),
wx.BITMAP_TYPE_ANY))
paddingImage = 3
if heure_fin_x == 0:
heure_fin_x = rectBarre.x + rectBarre.width
xImage = heure_fin_x - paddingImage # heure_debut_x + heure_debut_largeur + paddingImage
if rectBarre.width > len(listeImages) * 19:
for imageTemp in listeImages:
largeurBmp, hauteurBmp = imageTemp.GetSize()
gc.DrawBitmap(imageTemp, xImage - largeurBmp,
rectBarre.y + 1, largeurBmp, hauteurBmp)
xImage -= largeurBmp + paddingImage
# Ecrit le nom du groupe
if CTRL_Grille.AFFICHE_NOM_GROUPE == True and rectBarre.height > 22:
if conso.IDgroupe != None and conso.IDgroupe != 0 and conso.etat in (
"reservation", "present", "absenti", "absentj",
"attente", "refus"):
couleurTexteGroupe = UTILS_Couleurs.ModifierLuminosite(
couleurBarre, -30)
gc.SetFont(
wx.Font(6, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False, 'Arial'),
couleurTexteGroupe)
nomGroupe = grid.dictGroupes[conso.IDgroupe]["nom"]
largeurNomGroupe, hauteurNomGroupe = gc.GetTextExtent(
nomGroupe)
nbreGroupesActivite = grid.dictGroupes[
conso.IDgroupe]["nbreGroupesActivite"]
if rectBarre.width > largeurNomGroupe and nbreGroupesActivite > 1:
gc.DrawText(nomGroupe, rectBarre.x + 4,
rectBarre.y + rectBarre.height - 10)
# Ecrit les étiquettes
nbreEtiquettes = len(conso.etiquettes)
if conso.etat != None and nbreEtiquettes > 0:
index = 0
for IDetiquette in conso.etiquettes:
if grid.dictEtiquettes.has_key(IDetiquette):
dictEtiquette = grid.dictEtiquettes[IDetiquette]
# Dessine l'étiquette
gc.SetBrush(
wx.Brush(dictEtiquette["couleur"], wx.SOLID))
gc.SetPen(wx.TRANSPARENT_PEN)
gc.DrawEllipse(rectBarre.x + rectBarre.width - 7 -
(5 * index),
rectBarre.y + rectBarre.height - 7, 4,
4) # En haut à droite
index += 1
# Dessin du cadenas VERROUILLAGE
if self.case.verrouillage == 1:
gc.SetBrush(wx.Brush((100, 100, 100), wx.SOLID))
gc.SetPen(wx.TRANSPARENT_PEN)
gc.DrawRectangle(*rectCase)
tailleImage = 8
paddingImage = 3
bmp = wx.Bitmap(
Chemins.GetStaticPath("Images/Special/Cadenas_ferme.png"),
wx.BITMAP_TYPE_ANY)
largeurBmp, hauteurBmp = bmp.GetSize()
gc.DrawBitmap(bmp, rectCase[0] + tailleImage - paddingImage,
rectCase[1] + paddingImage, largeurBmp, hauteurBmp)
gc.PopState()
# Envoi du buffer au DC
dcGrid.Blit(rect.x, rect.y, rect.GetWidth(), rect.GetHeight(), image,
0, 0)
nomUniteIncompatible = self.grille.dictUnites[incompatibilite]["nom"]
return _(u"Action impossible car il existe déjà le %s une réservation sur l'unité '%s'.") % (UTILS_Dates.DateDDEnFr(date), nomUniteIncompatible)
# Définit le mode
self.mode = mode
# Si la conso n'existe pas déjà :
if case.IsCaseDisponible(heure_debut, heure_fin) == True :
if typeUnite == "Quantite" :
quantiteTmp = 1
else :
quantiteTmp = None
if quantite != None :
quantiteTmp = quantite
if typeUnite == "Multihoraires" :
barre = case.SaisieBarre(UTILS_Dates.HeureStrEnTime(heure_debut), UTILS_Dates.HeureStrEnTime(heure_fin))
if mode == "reservation" :
case.ModifieEtat(barre.conso, etat)
else :
case.OnClick(saisieHeureDebut=heure_debut, saisieHeureFin=heure_fin, saisieQuantite=quantiteTmp, modeSilencieux=True)
if mode == "reservation" :
case.ModifieEtat(None, etat)
# Si la conso existe déjà :
else :
# Type Horaire
if typeUnite == "Horaire" :
case.OnClick(saisieHeureDebut=heure_debut, saisieHeureFin=heure_fin, modeSilencieux=True)
case.ModifieEtat(None, etat)
