def __init__(self):
self.__num = Acces.numero_acces
Acces.numero_acces += 1
self.camera = Camera()
self.teleporteur = Teleporteur()
self.__borne = Borne()
self.__pannaux = PannauxAffichage()
self.__liste_abo = {}
self.__liste_client = {}
self.__liste_ticket = {}
self.__parking = 0
self.prix_parking = 0.0
self.__placements = 0
class Acces:
numero_acces = 0
def __init__(self):
self.__num = Acces.numero_acces
Acces.numero_acces += 1
self.camera = Camera()
self.teleporteur = Teleporteur()
self.__borne = Borne()
self.__pannaux = PannauxAffichage()
self.__liste_abo = {}
self.__liste_client = {}
self.__liste_ticket = {}
self.__parking = 0
self.prix_parking = 0.0
self.__placements = 0
@property
def liste_abo(self): return self.__liste_abo
@liste_abo.setter
def liste_abo(self, id, carte): self.__liste_abo[id] = carte
@property
def liste_ticket(self): return self.__liste_ticket
@property
def liste_client(self): return self.__liste_client
@liste_client.setter
def liste_client(self,client): self.__liste_client[client.identifiant] = client
@property
def placements(self): return self.__placements
@property
def pannaux(self): return self.__pannaux
@pannaux.setter
def pannaux(self,pannaux): self.__pannaux = pannaux
@property
def borne(self): return self.__borne
@borne.setter
def borne(self,borne): self.__borne = borne
def delete_carte(self,id):
del self.liste_abo[id]
@property
def parking(self): return self.__parking;
@parking.setter
def set_parking(self,nouv):
self.__parking = nouv
self.prix_parking = nouv.prix
self.__placements = set(nouv.placements)
def garer(self,voiture):
place = self.__parking.garer_voiture(voiture)
self.__pannaux.mise_a_jour()
return place
def sauvegarder_donnees_placements(self):
placements = set(self.__parking.placements+ list(self.placements)) #on concatène ceux que l'on a déjà à ceux qui viennent d'être potentiellement créés dans le parking ET on les place dans un set afin de supprimer les doublons
with open('placements.pickle','wb') as fichier:
pickle.dump(placements,fichier)
with open('prix_parking.pickle','wb') as fichier:
pickle.dump(self.prix_parking,fichier)
with open('liste_ticket.pickle','wb') as fichier:
pickle.dump(self.__liste_ticket,fichier)
with open('liste_client.pickle','wb') as fichier:
pickle.dump(self.__liste_client,fichier)
with open('liste_abo.pickle','wb') as fichier:
pickle.dump(self.__liste_abo,fichier)
def charger_donnees_placements(self):
with open('placements.pickle','rb') as fichier:
placements = pickle.load(fichier)
self.__placements = placements
with open('prix_parking.pickle','rb') as fichier:
self.prix_parking = pickle.load(fichier)
with open('liste_ticket.pickle','rb') as fichier:
self.__liste_ticket = pickle.load(fichier)
with open('liste_client.pickle','rb') as fichier:
self.__liste_client = pickle.load(fichier)
with open('liste_abo.pickle','rb') as fichier:
self.__liste_abo = pickle.load(fichier)
def statistiques(self):
liste_voiture = []
for placement in self.__placements: #boucle permettant d'obtenir une liste des voitures sans doublons
if placement.voiture not in liste_voiture:
liste_voiture.append(placement.voiture)
liste_statistique = []
for voiture in liste_voiture: #boucle permettant d'obtenir un tuple de la forme : (voiture, nbre de fois où elle est venue)
nb_occur = 0
for placement in self.__placements:
if placement.voiture == voiture:
nb_occur += 1
liste_statistique.append((voiture,nb_occur))
self.stats = liste_statistique #affecte à notre objet Gestionnaire un attribut qui représentera un tableau de tuple tel que (voiture, nb_fois)
def placement_temporaire(self,code):
ticket = self.liste_ticket[code]
return Placement(ticket.place,ticket.client.voiture)
def calculer_prix(self,placement_donne):
#on considère que le placement donné en paramètre nous est donné via le ticket ou la carte, on a donc juste un duo de la forme (place, voiture)
le_placement = Placement()
trouve = False
for placement in self.__placements:
if not placement.est_en_cours:
if placement_donne.voiture.hauteur == placement.voiture.hauteur and placement_donne.voiture.longueur == placement.voiture.longueur:
le_placement = placement
trouve = True
if trouve:
nb_heures = datetime.datetime.now() - le_placement.date_arrivee
nb_heures = (nb_heures.total_seconds()//3600) #nombre d'heures entre début et "maintenant"
return self.prix_parking + (self.prix_parking * nb_heures )+ ((self.prix_parking + self.prix_parking ) * 0.20)
def date_entree(self,placement_donne):
le_placement = Placement()
trouve = False
for placement in self.__placements:
if placement.est_en_cours:
if placement_donne.voiture.hauteur == placement.voiture.hauteur and placement_donne.voiture.longueur == placement.voiture.longueur:
le_placement = placement
print("j'ai trouver BOOOYAAAAAAAH")
trouve = True
if trouve:
return le_placement.date_arrivee.strftime("%d/%m/%Y %H:%M:%S")
else :
return 1
def date_fin(self,placement_donne):
le_placement = Placement()
trouve = False
for placement in self.__placements:
if not placement.est_en_cours:
if placement_donne.voiture.hauteur == placement.voiture.hauteur and placement_donne.voiture.longueur == placement.voiture.longueur:
le_placement = placement
trouve = True
if trouve:
return le_placement.date_fin.strftime("%d/%m/%Y %H:%M:%S")
#méthodes de souscription, et de gestion des abonnement
def souscrire_abo(self,client):
'''
Méthode de souscription à un abonnement.
:param client: Client souhaitant souscrire à un abonnement
:return: True si la souscription à été effectuer, False si non.
'''
if(client.est_abonne):
return False
else:
#ma_carte = CarteAbonnement(client)
client.est_abonne = True
self.liste_client[client.identifiant] = client
#ma_carte.service = True
#self.__gest.liste_abo[client.identifiant] = ma_carte
return True
def editer_carte(self,client):
'''
Méthode d'édition d'une carte d'abonnement, en fonction du type d'abonnement d'un client.
:param client: Client dont la carte dois être éditer.
'''
if(client.est_abonne and client.est_super_abonne):
ma_carte = CarteAbonnement(client)
ma_carte.service = True
ma_carte.garantie = True
self.liste_abo[client.identifiant] = ma_carte
print("abonnement + super abonnement")
print(ma_carte.service)
print(ma_carte.garantie)
elif(client.est_abonne):
ma_carte = CarteAbonnement(client)
ma_carte.service = True
self.liste_abo[client.identifiant] = ma_carte
print("services")
print(ma_carte.service)
elif(client.est_super_abonne):
ma_carte = CarteAbonnement(client)
ma_carte.garantie = True
self.liste_abo[client.identifiant] = ma_carte
print("garantie")
print(ma_carte.garantie)
else:
ma_carte = CarteAbonnement(client)
self.liste_abo[client.identifiant] = ma_carte
#def mise_a_jour_carte(self,client):
def souscrire_super_abo(self,client):
'''
Méthode de souscription à un abonnement
:param client: Client souhaitant souscrire à un abonnement
:return: True si la souscription à eut lieu, False si non.
'''
if (client.est_super_abonne == False):
client.est_super_abonne = True
self.liste_client[client.identifiant] = client
return True
else:
return False
def resilier_abo(self,client):
'''
Méthode de résiliation d'un abonnement
:param client: Client dont l'abonnement dois être résilier
:return: True si l'abonnement est résilier, False si non.
'''
if(client.est_abonne==False):
return False
else:
client.est_abonne = False
return True
def resilier_super_abo(self,client):
'''
Méthode de résiliation d'un super abonnement.
:param client: Client dont l'abonnement dois être résilier
:return: True si la résiliation à eut lieu, False si non.
'''
if(client.est_super_abonne == False):
return False
else:
client.est_super_abonne = False
return True
def desactiver_carte(self,client):
'''
Permet la supression d'une carte d'abonnement.
Seuls les clients disposant d'un abonnement doivent posséder une carte.
Après résiliation, la carte d'abonnement sera supprimer.
:param client: Client possédant une carte d'abonnement
'''
try:
carte = self.liste_abo[client.identifiant]
if(carte.garantie):
carte.garantie = False
else:
carte.service = False
self.delete_carte(carte.id)
except KeyError:
print("Identifiant client inconnue à la liste d'abonnement. Merci de vérifier l'identifiant client.")
#Ajout d'un client dans la liste de clients
def enregistrer_client(self,client):
'''
Pour un client donnée, ajoute ce dernier à la liste des clients et retourne l'objet client.
:param client: Client à ajouter
:return: L'objet client ajouter à la liste
'''
self.liste_client[client.identifiant] = client
return client
def crea_client(self):
'''
Creation d'un nouveau client.
:return: un objet Client (construteur par défaut)
'''
mon_client = Client()
return mon_client
#gestion des ticket
def imprimer_ticket(self,place,client):
'''
Création d'un nouveau ticket pour une place et un client donné.
:param place: Place correspondant à la place occuper par le véhicule client
:param client:Client dont lé véhicule est garé
:return:Ticket créer, en fonction de la place et du client
'''
ticket = Ticket(place,client)
client.ticket = ticket
return ticket
def stocker_ticket(self,ticket):
'''
Permet de stocker le ticket dans la liste du gestionnaire.
:param ticket: Ticket devant être stocker dans la liste
:return:
'''
self.liste_ticket[ticket.code] = ticket
def __eq__(self, other):
return self.placements == other.placements and self.prix_parking == other.prix_parking
def prendre_mesures(self,voiture):
tuple_mesures = self.camera.prendre_mesures(voiture)
return tuple_mesures
def teleporter(self,voiture,parking):
self.teleporteur.teleporter(voiture,parking)
print("Test")
print(gestion2.stats)
print("Test 2 ")
print(gestion.stats)
print(set(gestion.stats) == set(gestion2.stats))
print("Calcul du prix de la voiture 3 ")
print(gestion2.calculer_prix(Placement(1,voiture3)))
parking2 = Parking()
'''
if __name__=='__main__':
gest = Gestionnaire()
parking = Parking()
gest.set_parking = parking
app = QtGui.QApplication(sys.argv)
borne = Borne(gest)
borne.showMaximized()
pan = PannauxAffichage(gest)
pan.show()
app.exec_()
