MAj

src/m/Client.py

@@ -0,0 +1,85 @@
+import random
+import sqlite3
+import string
+
+__author__ = 'sidya'
+
+
+class Client():
+
+    clients = []
+
+    def __init__(self, nom, prenom, adresse, typeAbonnement):
+        while True :
+            id =''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(random.randint(1,10)))
+            if Client.get(id) is None:
+                break
+        self.__id = id
+        self.__nom = nom
+        self.__prenom = prenom
+        self.__typeAbonnement = typeAbonnement
+        self.__adresse = adresse
+        self.clients.append(self)
+
+
+    @property
+    def prenom(self):
+        return self.__prenom
+
+    @property
+    def nom(self):
+        return self.__nom
+
+    @property
+    def id(self):
+        return self.__id
+
+    @property
+    def adr(self):
+        return self.__adresse
+
+    @property
+    def abonnement(self):
+        return self.__typeAbonnement
+
+    @staticmethod
+    def get(id):
+        for client in Client.clients:
+            if client.id == id:
+                return client
+        return None
+
+    @staticmethod
+    def loadAll(connection):
+        with connection:
+            connection.row_factory = sqlite3.Row
+            cur = connection.cursor()
+            cur.execute("SELECT * FROM Client")
+            rows = cur.fetchall()
+            for row in rows:
+                Client(row["num"], row["nom"], row["prenom"], row["adr"], int(row["abo"]))
+        connection.close()
+
+    @staticmethod
+    def saveAll(connection):
+        cur = connection.cursor()
+        #reset table Client
+        cur.execute("DROP TABLE IF EXISTS Client")
+        cur.execute("""create table Client (num varchar(10) PRIMARY KEY, nom varchar(30), prenom varchar(30), adr varchar(50), abo int(1))""")
+        # insert clients
+        for c in Client.tous:
+            cur.execute("insert into Client values (?, ?, ?, ?, ?)", (c.id, c.nom, c.prenom, c.adr, c.abonnement))
+        connection.commit()
+        connection.close()
+
+    def maj(self, nom, prenom, adresse, typeAbonnement):
+        self.__nom = nom
+        self.__prenom = prenom
+        self.__typeAbonnement = typeAbonnement
+        self.__adresse = adresse
+
+    def __str__( self ):
+        return "( " + self.__id +", " + self.__nom+", " + self.__prenom+", " + self.__adresse +", " + str(self.__typeAbonnement) +" )"
+
+
+

src/m/ConnecxionBDD.py

@@ -0,0 +1,25 @@
+__author__ = 'sidya'
+
+class connexionBDD :
+    def __init__(self):
+        try:
+            self.__conn = sqlite3.connect("BD.sql3")
+            self.__cur = self.__conn.cursor()
+        except Exception as e :
+            pass # later
+
+    def seDeconnecter(self):
+        self.__cur.close()
+        self.__conn.close()
+
+    def execute(self, req):
+        try:
+            r = self.__cur.execute(req)
+            self.__conn.commit()
+        except Exception as e :
+            pass # later
+        return r
+
+
+    def lastId(self):
+        return self.__cur.lastrowid

src/m/ListeTypePlace.py

@@ -0,0 +1,23 @@
+__author__ = 'sidya'
+
+class ListeTypePlace:
+    """
+        Classe qui permet de définir une liste de type de place par niveau pour la création d'un parking
+    """
+
+    def __init__(self):
+        self.l = []
+
+    def add(self, h, l, nb):
+        self.l.append(TypePlace(h, l, nb))
+
+    @property
+    def nbPlaceTotal(self):
+        i = 0
+        for t in self.l:
+            i += t.nb
+        return i
+
+    @property
+    def liste(self):
+        return self.l

src/m/Parking.py

@@ -1,76 +1,64 @@
+
+from src.m.Place import Place
+
 __author__ = 'sidya'
 
-from src.m.Place import Place, ListeTypePlace
-
-
 class Parking:
     """
         Definie un parking
     """
-    def __init__(self, nbNiv, typePlacesParNiv,nom):
-        self.typePlacesParNiv = typePlacesParNiv
+    def __init__(self, typePlaces, nom):
+        """
+        Creer objet parking
+        :param typePlaces: ListeTypePlace
+        :param nom: str
+        :return:
+        """
+        self.__typePlaces = typePlaces
         self.__nom = nom
-        self.__nbPlacesParNiveau = typePlacesParNiv.nbPlaceTotal
         self.__prix = 10
-        self.__nbNiveaux = nbNiv
         self.__Places = {}
-        for n in range(0, nbNiv):
-            l = []
-            for t in typePlacesParNiv.liste:
-                for i in range(0, t.nb):
-                    l.append(Place(i + 1, n, t.longueur, t.hauteur))
-            self.__Places[n] = l
+        l = []
+        for t in typePlaces.liste:
+            for i in range(0, t.nb):
+                l.append(Place(i + 1, 1, t.longueur, t.hauteur))
+        self.__Places = l
+
 
     @property
     def nom(self):
         return self.__nom
 
     @property
-    def nbPlacesParNiveau(self):
-        return self.__nbPlacesParNiveau
+    def nbPlaces(self):
+        return self.__typePlaces.nbPlaceTotal
+
 
     @property
-    def nbNiveau(self):
-        return self.__nbNiveaux
-
-    def recherchePlace(self, voiture):
-        place = None
-        for i in range(0, self.__nbNiveaux):
-            if place != None:
-                break
-            l = [p for p in self.__Places[i].estLibre]
-            for p in l:
-                if p.dimValide(voiture.hauteur, voiture.longueur):
-                    pass
-                    place = p
-                    break
-        return place
-
-    def nbPlacesLibresNiveau(self, niveau):
+    def nbPlacesLibresParking(self):
         i = 0
-        for p in self.__Places[niveau]:
+        for p in self.__Places:
             if p.estLibre:
                 i += 1
         return i
 
-    @property
-    def nbPlacesLibresParking(self):
-        nbP = 0
-        for i in range(0,self.__nbNiveaux) :
-            nbP += self.nbPlacesLibresNiveau(i)
-        return nbP
+    def recherchePlace(self, voiture):
+        """
+        Permet de rechercher une place valide pour une voiture
+        :param voiture: Voiture
+        :return: Place
+        """
+        place = None
+        for p in self.__Places:
+            if p.estLibre and p.dimValide(voiture.hauteur, voiture.longueur) :
+                pass
+                place = p
+                break
+        return place
+
 
     def addAbonnement(self, Abonnement):
         pass
 
     def __str__(self):
         return "Parking :  niveau : " + str(self.__nbNiveaux)
-
-
-if __name__ == "__main__":
-    l = ListeTypePlace()
-    l.add(10, 11, 5)
-    l.add(7, 12, 5)
-    p = Parking(5, l)
-    print(p)
-    print(p.nbPlacesLibresNiveau(1))

src/m/Place.py

@@ -1,105 +1,82 @@
-import sys
 import datetime
+import random
+import string
 
 __author__ = 'sidya'
 
 
 class Place:
     """
-        Representation d'une place dans un parking
+    Representation d'une place
     """
-    def __init__(self, numero, niveau, longueur, hauteur):
+    def __init__(self, numero, niveau, longueur,hauteur):
+        """
+        Creer une place.
+        Les dimensions doivent etre données en cm (longueur, hauteur)
+        :param numero: int
+        :param niveau: int
+        :param longueur: int
+        :param hauteur: int
+        :return:
+        """
         self.__numero = numero
         self.__niveau = niveau
         self.__longueur = longueur
         self.__hauteur = hauteur
         self.__estLibre = True
-        self.__estReserver = False
+        self.__estSuperAbo = False
         self.__Placement = None
+
     @property
     def estLibre(self):
         return self.__estLibre
 
     @property
     def estReserver(self):
-        return self.__estReserver
+        return self.__estSuperAbo
 
     def dimValide(self, h, l):
+        """
+        Retourn si un element de hauteur (cm) h et de longueur(cm) l passe dans la place
+        :param h: int
+        :param l: int
+        :return: bool
+        """
         return h < self.__hauteur and l < self.__longueur
 
-    def reserver(self):
-        if (self.__estReserver == True) :
+    def superAbo(self):
+        """
+        Renvoit si la place est une place superAbo
+        :return: bool
+        """
+        if (self.__estSuperAbo == True):
             raise Exception("Place déjà reservé")
-        self.__estReserver = True
+        self.__estSuperAbo = True
 
-    def nonReserver(self) :
-        if (self.__estReserver == False):
-            raise Exception("Impossible de mettre une place en non si elle n'est pas reservé de base")
-        self.__estReserver = False
 
-    def prendre(self, Placement):
-        if (self.__Libre == True) :
+    def prendre(self):
+        """
+        Rend la place indisponible
+        :param Placement:
+        :return:
+        """
+        if (self.__estLibre == False):
             raise Exception("Place déjà prise")
         self.__estLibre = False
-        self.__Placement = Placement
 
-    def liberer(self) :
-        if (self.__estLibre == False):
+    def liberer(self):
+        """
+        Libere une place non dispo
+        :return:
+        """
+        if (self.__estLibre == True):
             raise Exception("Impossible de liberer une place vide")
         self.__estLibre = True
 
 
-class TypePlace:
-    """
-        Classe qui permet de définir un type de place
-    """
-    def __init__(self, h, l, nb):
-        self.__hauteur = h
-        self.__longueur = l
-        self.__nb = nb
-
-    @property
-    def hauteur(self):
-        return self.__hauteur
-
-    @property
-    def longueur(self):
-        return self.__longueur
-
-    @property
-    def nb(self):
-        return self.__nb
-
-
-class ListeTypePlace:
-    """
-        Classe qui permet de définir une liste de type de place par niveau pour la création d'un parking
-    """
-    def __init__(self):
-        self.l = []
-
-    def add(self, h, l, nb):
-        self.l.append(TypePlace(h, l, nb))
-
-    @property
-    def nbPlaceTotal(self):
-        i = 0
-        for t in self.l:
-            i += t.nb
-        return i
-
-    @property
-    def liste(self):
-        return self.l
 
 
 
 
-class Placement:
-    def __init__(self,debut,fin):
-        self.debut = debut
-        self.fin = fin
 
-    @property
-    def estEnCours(self):
-        return datetime.datetime < self.fin
+

src/m/Placement.py

@@ -0,0 +1,50 @@
+import datetime
+import random
+import string
+
+__author__ = 'sidya'
+
+class Placement:
+    placements = []
+    def __init__(self,voiture, place):
+        """
+        Creer un placement
+        :param voiture: Voiture
+        :param place: Place
+        :return:
+        """
+        while True :
+            id =''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(random.randint(1,10)))
+            if Placement.get(id) is None:
+                break
+        self.__id = id
+        self.__voiture = voiture
+        self.__place = place
+        self.__debut = datetime.datetime
+        self.__fin = None
+        place.prendre()
+        self.placements.append(self)
+
+    def end(self):
+        self.__fin = datetime.datetime
+        self.__place.liberer()
+
+    @property
+    def id(self):
+        return self.__id
+
+    @staticmethod
+    def get(id):
+        """
+        Recupere le Placement d'id id
+        :param id: str
+        :return: Placement or None
+        """
+        for p in Placement.placements:
+            if p.__id == id:
+                return p
+        return None
+
+    @property
+    def estEnCours(self):
+        return datetime.datetime < self.__fin

src/m/TypeAbonnement.py

@@ -0,0 +1,5 @@
+__author__ = 'sidya'
+
+class TypeAbonnement :
+    ABONNE = 0
+    SUPER_ABONNE = 1

src/m/TypePlace.py

@@ -0,0 +1,22 @@
+__author__ = 'sidya'
+
+class TypePlace:
+    """
+        Classe qui permet de définir un type de place
+    """
+    def __init__(self, h, l, nb):
+        self.__hauteur = h
+        self.__longueur = l
+        self.__nb = nb
+
+    @property
+    def hauteur(self):
+        return self.__hauteur
+
+    @property
+    def longueur(self):
+        return self.__longueur
+
+    @property
+    def nb(self):
+        return self.__nb

src/m/Voiture.py

@@ -0,0 +1,23 @@
+__author__ = 'sidya'
+
+class Voiture:
+    def __init__(self, longueur, hauteur, imma):
+        self.__longueur = longueur
+        self.__hauteur = hauteur
+        self.__imma = imma
+        self.__estDansParking = False
+
+    @property
+    def longueur(self):
+        return self.__longueur
+
+    @property
+    def hauteur(self):
+        return self.__hauteur
+
+    def __str__(self):
+        return "Voiture : hauteur " + str(self.__longueur) + ", largeur" + str(self.hauteur) + ", Imma : " + self.__imma +", est dans parking :" + str(self.__estDansParking)
+
+
+
+

src/m/place.py

@@ -1,59 +0,0 @@
-from src.m.placement import Placement
-class Place:
-    def __init__(self):
-        self._numero
-        self._niveau
-        self._longueur
-        self._estLibre
-        self.hauteur
-
-    @property
-    def numero(self):
-        return self._numero
-    @property
-    def niveau(self):
-        return self._niveau
-    @property
-    def longueur(self):
-        return self.longueur
-    @property
-<<<<<<< Updated upstream
-    def nbPlaceTotal(self):
-        i = 0
-        for t in self.l:
-            i += t.nb
-        return i
-
-    @property
-    def liste(self):
-        return self.l
-
-
-
-
-class Placement:
-    def __init__(self,debut,fin):
-        self.debut = debut
-        self.fin = fin
-
-=======
-    def estLibre(self):
-        return self.estLibre
->>>>>>> Stashed changes
-    @property
-    def hauteur(self):
-        return self.hauteur
-    @numero.setter
-    def setNumero(self, value):
-        self._numero = value
-    @niveau.setter
-    def setNiveau(self, value):
-        self._numero = value
-    @longueur.setter
-    def setLongueur(self, value):
-        self._longueur = value
-    def addPlacement(self, jourDeb, moisDeb, anneeDeb, jourFin, moisFin, anneeFin):
-       newplace = Placement()
-       newplace.setDateDebut(jourDeb, moisDeb, anneeDeb)
-       newplace.setDateFin(jourFin, moisFin, anneeFin)
-       newplace.setEstEnCours(True)

src/m/table.sql

@@ -0,0 +1,27 @@
+CREATE TABLE parking (
+    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    nom VARCHAR(30),
+    );
+
+CREATE TABLE place (
+    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    idParking INT UNSIGNED FOREIGN KEY,
+    idType INT UNSIGNED FOREIGN KEY,
+    niveau INT UNSIGNED,
+    numero INT UNSIGNED
+);
+
+CREATE TABLE typePlace (
+    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+    longueur INT UNSIGNED,
+    hauteur INT UNSIGNED,
+    largeur INT UNSIGNED,
+    estLibre INT(1),
+    estSuperAbo int(1)
+);
+
+
+
+CREATE TABLE placement (
+
+);

src/m/test/TestParking.py

@@ -1,4 +1,16 @@
 __author__ = 'sidya'
 
-class TestParking :
-    pass
+from nose.tools import assert_equal
+
+from src.m.Parking import Parking
+
+
+class TestParking:
+    def recherchePlace(self):
+        """
+            Test d'attribution des places
+        """
+        p = Parking()
+        assert_equal()
+
+

src/m/test/TestPlace.py

@@ -1,5 +1,5 @@
 __author__ = 'sidya'
 
 
-class TestPlace :
+class TestPlace:
     pass