L3GestionParking/src/m/Parking.py

"""
    Module qui implémente les classes representants un parking de DreamPark.
"""
import random
import string
import time
from datetime import datetime

from src.c.utils.connexionBDD import connexionBDD
from src.m.Voiture import Voiture



## Representation d'un parking de DreamPark
class Parking:
    parkings = []

    ## Retourne un objet parking correspondant à id
    # @param id id du Parking a retourner
    @staticmethod
    def get(id):
        if len(Parking.parkings) == 0:
            Parking.getAllActif()
        for p in Parking.parkings:
            if p.id == id:
                return p

    ## Retourne tout les Parking actif present dans la bd
    @staticmethod
    def getAllActif():
        if len(Parking.parkings) == 0:
            c = connexionBDD()
            r = c.execute("SELECT * FROM parking WHERE actif = 1")
            rows = r.fetchall()
            c.seDeconnecter()
            for row in rows:
                Parking(row["idParking"], row["nom"], None)
        return Parking.parkings

    ## Supprime un parking
    # @param parking L'objet parking a supprimer
    @staticmethod
    def remove(parking):
        Parking.parkings.remove(parking)
        c = connexionBDD()
        c.execute("UPDATE parking SET actif = 0 WHERE idParking='" + str(parking.id) + "'")
        c.seDeconnecter()

    ## Supprime les parkings present dans la mémoire vive (pas dans la bd)
    @staticmethod
    def removeAllRam():
        Parking.parkings = []

    ## Constructeur du Parking
    # @param id Si None : Cree un Parking dans la BD Sinon : tentative de récupération du Parking avec cet id dans la bd
    # @param nom : Si creation nom du parking
    # @param listeTypePlace : Si creation Liste des TypePlace du parking
    def __init__(self, id, nom=None, listeTypePlace=None):
        self.__nom = nom
        if id is None:
            c = connexionBDD()
            c.execute("INSERT INTO parking (nom) VALUES ('" + str(self.__nom) + "')", ())
            self.__id = c.lastId()
            # Crea des places
            n = 0
            placeParNiveau = {}
            for typePlace in listeTypePlace:
                try:
                    i = placeParNiveau[typePlace.niveau]
                except KeyError:
                    i = 0
                placeParNiveau[typePlace.niveau] = i + typePlace.nombre
                for i in range(placeParNiveau[typePlace.niveau]):
                    Place(None, self, typePlace, i, True, False)
        else:
            self.__id = id
        self.parkings.append(self)

    ## Propriete : id du Parking
    @property
    def id(self):
        return self.__id

    ## propriete : nom du Parking
    @property
    def nom(self):
        return self.__nom

    ## propriete : nombre de Place du Parking
    @property
    def nbPlaces(self):
        return Place.nbPlaceParking(self.__id)

    ## propriete : nombre de Place libres du Parking
    @property
    def nbPlacesLibresParking(self):
        return Place.nbPlaceLibreParking(self.__id)

    ## propriete : nombre de Place super abo
    @property
    def nbSuperAbo(self):
        return Place.nbSuperAbo(self.__id)

    ## propriete : listeTypePlace
    @property
    def listeTypePlace(self):
        c = connexionBDD()
        r = c.execute("SELECT idTypePlace FROM typePlace WHERE idTypePlace in (SELECT idTypePlace FROM place WHERE idParking = '" + str(self.__id) + "')")
        rows = r.fetchall()
        c.seDeconnecter()
        l = []
        for row in rows:
            l.append(TypePlace(row["idTypePlace"]))
        return l

    ## Recherche une place pour une voiture
    # @param voiture voiture pour laquel on recherche la place
    # @return Place Si touvé : Place sinon : None
    def recherchePlace(self, voiture):
        return Place.placeValide(self.__id, voiture)

    ## Ajout d'une place surmesure pour super abo
    # @param parking le parking ou il faut ajouter la place
    def addPlaceSuperAbo(self):
        return Place(None, self, None, None, False, True)

    ## Representation du Parking en chaine
    def __str__(self):
        return "[Parking : nom = " + self.__nom + "]"

## Representation d'une place de DreamPark
class Place:
    ## Contructeur de Place
    # @param id Si None : creation de la Place dans la bd Sinon : tentative de récupération de la Place avec cet id dans la bd
    # @param parking Si creation : le Parking ou est creer la Place
    # @param typePlace Si creation : le TypePlace de Place
    # @param numero Si creation : le numero de Place
    # @param estLibre Si creation : Si la Place est libre ou non
    # @param estSuperAbo Si creation : Si la Place est superAbo ou non
    def __init__(self, id, parking=None, typePlace=None, numero=None, estLibre=True, estSuperAbo=False):
        if id is None:
            self.__parking = parking
            self.__typePlace = typePlace
            self.__numero = numero
            self.__estLibre = estLibre
            self.__estSuperAbo = estSuperAbo
            if self.__typePlace is None:
                t = "NULL"
            else:
                t = self.__typePlace.id
            c = connexionBDD()
            c.execute("INSERT INTO place (idParking, idTypePlace, numero, estLibre, estSuperAbo) "
                      "VALUES (?,?,?,?,?)",
                      (self.__parking.id, t,
                       self.__numero, int(self.__estLibre), int(self.__estSuperAbo)))
            self.__id = c.lastId()
            c.seDeconnecter()
        else:
            c = connexionBDD()
            r = c.execute("SELECT * FROM place WHERE idPlace='" + str(id) + "'")
            row = r.fetchone()
            if row is None:
                raise IndexError("Invalid id")
            c.seDeconnecter()
            self.__parking = Parking.get(row["idParking"])
            self.__typePlace = TypePlace(row["idTypePlace"])
            self.__numero = row["numero"]
            self.__estLibre = row["estLibre"]
            self.__estSuperAbo = row["estSuperAbo"]
            self.__id = id



    ## Rend la Place la indisponible
    def prendre(self):
        if (self.__estLibre == False):
            raise Exception("Place déjà prise")
        self.__estLibre = False
        c = connexionBDD()
        c.execute("UPDATE place SET estLibre = 0 WHERE idPlace ='" + str(self.__id) + "'")
        c.seDeconnecter()

    ## Rend la Place disponible
    def liberer(self):
        if (self.__estLibre == True):
            raise Exception("Impossible de liberer une place vide")
        self.__estLibre = True
        c = connexionBDD()
        c.execute("UPDATE place SET estLibre = 1 WHERE idPlace ='" + str(self.__id) + "'")
        c.seDeconnecter()

    ## Suppression place de la bd
    def supprimer(self):
        c = connexionBDD()
        c.execute("DELETE FROM place idPlace ='" + str(self.__id) + "'")
        c.seDeconnecter()

    ## propriete : id de la Place
    @property
    def id(self):
        return self.__id

    ## propriete : identification etage : numero de la Place
    @property
    def identification(self):
        return str(chr(self.__typePlace.niveau + ord('A')) + ":" + str(self.__numero))

    ## propriete : True si la place est Place
    @property
    def estlibre(self):
        return self.__estLibre

    ## propriete : typePlace de la Place
    @property
    def typePlace(self):
        return self.__typePlace

    ## propriete : typePlace de la Place
    @property
    def estSuperAbo(self):
        return self.__estSuperAbo

    ## Retourne les nombre de place du Parking d'id idParking
    # @param idParking l'id du Parking
    # @return le nombre de Place
    @staticmethod
    def nbPlaceParking(idParking):
        c = connexionBDD()
        r = c.execute("SELECT COUNT(*) FROM place WHERE idParking = " + str(idParking))
        row = r.fetchone()
        c.seDeconnecter()
        return row[0]

    ## Retourne les nombre de place libre du Parking d'id idParking
    # @param idParking l'id du Parking
    # @return le nombre de Place libre
    @staticmethod
    def nbPlaceLibreParking(idParking):
        c = connexionBDD()
        r = c.execute("SELECT COUNT(*) FROM place WHERE idParking = " + str(idParking) + " AND estLibre = 1")
        row = r.fetchone()
        c.seDeconnecter()
        return row[0]

    ## Retourne les nombre de place superAbo du Parking d'id idParking
    # @param idParking l'id du Parking
    # @return le nombre de Place superAbo
    @staticmethod
    def nbSuperAbo(idParking):
        c = connexionBDD()
        r = c.execute("SELECT COUNT(*) FROM place WHERE idParking = " + str(idParking) + " AND estSuperAbo = 1")
        row = r.fetchone()
        c.seDeconnecter()
        return row[0]

    ## Retourne si une Place valide pour une Voiture dans un parking
    # @param idParking id du Parking ou est recherché la place
    # @param voiture Voiture pour laquelle est recherché la place
    # @return Si non trouve : None. Sinon : Place une place valide
    @staticmethod
    def placeValide(idPArking, voiture):
        c = connexionBDD()
        r = c.execute("SELECT * FROM place WHERE idParking= ? AND estLibre = 1 "
                      "AND idTypePlace =(SELECT idTypePlace FROM typePlace "
                      "WHERE hauteur>? AND longueur>? ORDER BY longueur) ",
                      (str(idPArking), str(voiture.hauteur), str(voiture.longueur)))
        row = r.fetchone()
        c.seDeconnecter()
        if row is None:
            return None
        else:
            return Place(row["idPlace"], row["idParking"], row["idTypePlace"],
                         row["numero"], bool(row["estLibre"]), bool(row["estSuperAbo"]))


    ## Representation d'une Place en chaine
    def __str__(self):
        return "[Place : " +\
               "Parking = " + str(self.__parking) + ","+\
               "typePlace = " + str(self.__typePlace) + ","+\
               "numero = " + str(self.__numero) + ","+\
               "estLibre = " + str(self.__estLibre) + ","+\
               "estSuperAbo = " + str(self.__estSuperAbo) + "]"


## Representation d'un TypePlace de DreamPark
class TypePlace:
    ## Constructeur de TypePlace
    # @param id Si None : creation du TypePlace dans la bd Sinon : tentative de récupération du TypePlace avec cet id dans la bd
    # @param longueur Longueur de la Place en cm
    # @param hauteur Hauteur de la Place en cm
    # @param nombre Nombre de Place de ce type
    # @param prix Le prix pur ce type de Place
    # @param niveau Le niveau ou se trouve les Place
    def __init__(self, id, longueur=None, hauteur=None, nombre=None, prix=None, niveau=None):
        if id is None:
            self.__longueur = longueur
            self.__hauteur = hauteur
            self.__nombre = nombre
            self.__prix = prix
            self.__niveau = niveau
            c = connexionBDD()
            c.execute("INSERT INTO typePlace (longueur,hauteur,nombre, prix, niveau) VALUES (?,?,?,?,?)",
                      (self.__longueur, self.__hauteur, self.__nombre, self.__prix, self.__niveau))
            self.__id = c.lastId()
            c.seDeconnecter()
        else:
            c = connexionBDD()
            r = c.execute("SELECT * FROM typePlace WHERE idTypePlace='" + str(id) + "'")
            row = r.fetchone()
            if row is None:
                raise IndexError("Invalid id")
            c.seDeconnecter()
            self.__longueur = row["longueur"]
            self.__hauteur = row["hauteur"]
            self.__nombre = row["nombre"]
            self.__prix = row["prix"]
            self.__niveau = row["niveau"]
            self.__id = id

    ## propriete : id du Typeplace
    @property
    def id(self):
        return self.__id

    ## propriete : longueur du Typeplace
    @property
    def longueur(self):
        return self.__longueur

    ## propriete : hauteur du Typeplace
    @property
    def hauteur(self):
        return self.__hauteur

    ## propriete : nombre du Typeplace
    @property
    def nombre(self):
        return self.__nombre

    ## propriete : prix du Typeplace
    @property
    def prix(self):
        return self.__prix

    ## propriete : niveau du Typeplace
    @property
    def niveau(self):
        return self.__niveau

    ## Representation du TypePlace en chaine
    def __str__(self):
        return "[TypePlace : " \
               "id = " + str(self.__id) + ","+\
               "longueur = " + str(self.__longueur) + ","+\
               "hauteur = " + str(self.__hauteur) + ","+\
               "nombre = " + str(self.__nombre) + "," +\
               "prix = " + str(self.__prix) + ","+\
               "niveau = " + str(self.__niveau) + "]"

## Representation d'un Placement de DreamPark
class Placement:
    ## Constructeur Placement
    # @param id Si None : creation du Placement dans la bd Sinon : tentative de récupération du Placement avec cet id dans la bd
    # @param voiture Si creation : Voiture lié au Placement
    # @param place Si creation : Place  lié au Placement
    def __init__(self, id, voiture=None, place=None):
        if id is None:
            self.__voiture = voiture
            self.__place = place
            self.__debut = time.time()
            self.__fin = None
            while True:
                id = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in
                             range(random.randint(1, 10)))
                try:
                    Placement(id)
                except IndexError:
                    break
            c = connexionBDD()
            c.execute("INSERT INTO placement (idPlacement,idVoiture,idPlace, debut, fin) VALUES (?,?,?,?,?)",
                      (str(id), str(self.__voiture.id), str(self.__place.id), str(self.__debut), "NULL"))
            self.__id = id
            c.seDeconnecter()
        else:
            c = connexionBDD()
            r = c.execute("SELECT * FROM placement WHERE idPlacement='" + str(id) + "'")
            row = r.fetchone()
            if row is None:
                raise IndexError("Invalid id")
            c.seDeconnecter()
            self.__voiture = Voiture(row["idVoiture"])
            self.__place = Place(row["idPlace"])
            self.__id = id
            self.__debut = row["debut"]
            self.__fin = row["fin"]

    ## Propriete : id du Placement
    @property
    def id(self):
        return self.__id

    ## Propriete : place liée du Placement
    @property
    def place(self):
        return self.__place

    ## Propriete : voiture liée du Placement
    @property
    def voiture(self):
        return self.__voiture

    ## Retourne la durée moyenne des placement
    # @return duree moyenne placement
    @staticmethod
    def dureeMoyPlacement():
        c = connexionBDD()
        r= c.execute("SELECT AVG(FIN - DEBUT) AS duree FROM placement")
        nb = r.fetchone()[0]
        c.seDeconnecter()
        return nb

    ## Fin du placement (depart voiture)
    def end(self):
        self.__fin = time.time()
        c = connexionBDD()
        c.execute("UPDATE placement SET fin='" + str(self.__fin) + "' WHERE idPlacement='" + str(self.__id) + "'")
        c.seDeconnecter()
        self.__place.liberer()

    ## Representation du Placement en chaine
    def __str__(self):
        return "[Placement : " \
               "id = " + str(self.__id) + "," +\
               "Voiture = " + str(self.__voiture) + ","+\
               "Place = " + str(self.__place) + "," +\
               "Debut = " + str( self.__debut) + "," +\
               "Fin = " + str(self.__fin) + "]"