reformat

src/m/Abonnement.py

@@ -1,10 +1,13 @@
 from src.m.connexionBDD import connexionBDD
+
+
 class Abonnement:
     def __init__(self, libelle, prix, estPackGar):
         self.libelle = libelle
         self.prix = prix
         self.estPackGar = estPackGar
+
     def addContrat(self, contrat):
         connexion = connexionBDD()
-       # indId= connexion.cur.execute("SELECT abonnement.idAbonnement FROM abonnement WHERE libelle = ? AND prix = ? AND estPackGar=?;"(self.libelle, self.prix, self.estPackGar))
-       # idAbonnement = int(''.join(map(str,indId)))
+        # indId= connexion.cur.execute("SELECT abonnement.idAbonnement FROM abonnement WHERE libelle = ? AND prix = ? AND estPackGar=?;"(self.libelle, self.prix, self.estPackGar))
+        # idAbonnement = int(''.join(map(str,indId)))

src/m/Client.py

@@ -6,12 +6,12 @@ __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)))
+        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
@@ -63,9 +63,10 @@ class Client():
     @staticmethod
     def saveAll(connection):
         cur = connection.cursor()
-        #reset table Client
+        # 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))""")
+        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))
@@ -78,8 +79,9 @@ class Client():
         self.__typeAbonnement = typeAbonnement
         self.__adresse = adresse
 
-    def __str__( self ):
-        return "( " + self.__id +", " + self.__nom+", " + self.__prenom+", " + self.__adresse +", " + str(self.__typeAbonnement) +" )"
+    def __str__(self):
+        return "( " + self.__id + ", " + self.__nom + ", " + self.__prenom + ", " + self.__adresse + ", " + str(
+            self.__typeAbonnement) + " )"
 
 
 

src/m/ConnecxionBDD.py

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

src/m/Contrat.py

@@ -1,15 +1,23 @@
 from src.m.connexionBDD import connexionBDD
+
+
 class Contrat:
     def __init__(self, dateDebut, dateFin):
         self.dateDebut = dateDebut
         self.dateFin = dateFin
+
     def enregistrerContrat(self):
-            connection = connexionBDD()
-            connection.cur.execute("INSERT INTO contrat (idContrat,dateDebut,dateFin, estEncours) VALUES (NULL,?,?,1);",( self.dateDebut, self.dateFin,1) )
-            connection.seDeconnecter()
+        connection = connexionBDD()
+        connection.cur.execute("INSERT INTO contrat (idContrat,dateDebut,dateFin, estEncours) VALUES (NULL,?,?,1);",
+                               ( self.dateDebut, self.dateFin, 1))
+        connection.seDeconnecter()
+
     def rompreContrat(self, idCLient):
-         connection = connexionBDD()
-         indContrat  =connection.cur.execute("SELECT Contrat.idContrat FROM contrat where idClient =? AND dateDebut = ? AND dateFin=? ;"(idCLient, self.dateDebut, self.dateFin))
-         idContrat= int(''.join(map(str,indContrat)))
-         connection.cur.execute("Update contrat where idContrat=? set estEnCours =0;",( idContrat) )
-         connection.seDeconnecter()
+        connection = connexionBDD()
+        indContrat = connection.cur.execute(
+            "SELECT Contrat.idContrat FROM contrat where idClient =? AND dateDebut = ? AND dateFin=? ;"(idCLient,
+                                                                                                        self.dateDebut,
+                                                                                                        self.dateFin))
+        idContrat = int(''.join(map(str, indContrat)))
+        connection.cur.execute("Update contrat where idContrat=? set estEnCours =0;", ( idContrat))
+        connection.seDeconnecter()

src/m/Entretien.py

@@ -1,13 +1,19 @@
 from src.m.Service import Service
 from src.m.connexionBDD import connexionBDD
+
+
 class Entretien(Service):
-      def __init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport, categorie, idClient):
-        super(Service, self).__init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport, categorie)
+    def __init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport,
+                 categorie, idClient):
+        super(Service, self).__init__(self, jourService, moisService, anneeService, jourDemande, moisDemande,
+                                      anneeDemande, rapport, categorie)
         self.categorie = 2
         self.etat = 0
-        self.idService=self.enregistrerService(self,idClient,self.categorie,self.etat)
-     def effectuerEntretien(self):
-        self.etat = 1
-        connexion  = connexionBDD()
-        connexion.cur.execute("UPDATE service SET etat= 1 WHERE idService = ?", (self.idService))
-        connexion.seDeconnecter()
+        self.idService = self.enregistrerService(self, idClient, self.categorie, self.etat)
+
+
+def effectuerEntretien(self):
+    self.etat = 1
+    connexion = connexionBDD()
+    connexion.cur.execute("UPDATE service SET etat= 1 WHERE idService = ?", (self.idService))
+    connexion.seDeconnecter()

src/m/ListeTypePlace.py

@@ -2,6 +2,7 @@ from src.m.TypePlace import TypePlace
 
 __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

src/m/Livraison.py

@@ -1,23 +1,29 @@
+import calendar
+
 from src.m.Service import Service
 from src.m.connexionBDD import connexionBDD
-import calendar
+
+
 class Livraison(Service):
-    def __init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport, categorie, idClient):
-        super(Service, self).__init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport, categorie)
+    def __init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport,
+                 categorie, idClient):
+        super(Service, self).__init__(self, jourService, moisService, anneeService, jourDemande, moisDemande,
+                                      anneeDemande, rapport, categorie)
         self.categorie = 3
         self.etat = 0
-        #3.Obtenir l'idVoiturier: en recherchant celui qui est disponible le jour en question
-        self.idService=self.enregistrerService(self, idClient, self.categorie, self.etat)
-        jour= calendar.weekday(self.dateService._day, self.dateService._month, self.dateService._year)
-        connexion  = connexionBDD()
-        indiceVoiturier= connexion.cur.execute("SELECT voiturier.idVoiturier FROM voiturier WHERE voiturier.joursDisponible = ?; ", (jour) )
-        idVoiturier = int(''.join(map(str,indiceVoiturier )))
+        # 3.Obtenir l'idVoiturier: en recherchant celui qui est disponible le jour en question
+        self.idService = self.enregistrerService(self, idClient, self.categorie, self.etat)
+        jour = calendar.weekday(self.dateService._day, self.dateService._month, self.dateService._year)
+        connexion = connexionBDD()
+        indiceVoiturier = connexion.cur.execute(
+            "SELECT voiturier.idVoiturier FROM voiturier WHERE voiturier.joursDisponible = ?; ", (jour))
+        idVoiturier = int(''.join(map(str, indiceVoiturier)))
         connexion.cur.execute("UPDATE service SET idVoiturier= ? WHERE idService = ?", (idVoiturier, self.idService))
         connexion.seDeconnecter()
 
     def effectuerLivraison(self):
         self.etat = 1
-        connexion  = connexionBDD()
+        connexion = connexionBDD()
         connexion.cur.execute("UPDATE service SET etat= 1 WHERE idService = ?", (self.idService))
         connexion.seDeconnecter()
 

src/m/Maintenance.py

@@ -1,14 +1,18 @@
 from src.m.Service import Service
 from src.m.connexionBDD import connexionBDD
+
+
 class Maintenance(Service):
-    def __init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport, categorie, idClient):
-        super(Service, self).__init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport, categorie)
+    def __init__(self, jourService, moisService, anneeService, jourDemande, moisDemande, anneeDemande, rapport,
+                 categorie, idClient):
+        super(Service, self).__init__(self, jourService, moisService, anneeService, jourDemande, moisDemande,
+                                      anneeDemande, rapport, categorie)
         self.categorie = 1
         self.etat = 0
-        self.idService=self.enregistrerService(self, idClient, self.categorie, self.etat)
+        self.idService = self.enregistrerService(self, idClient, self.categorie, self.etat)
 
     def effectuerMaintenance(self):
         self.etat = 1
-        connexion  = connexionBDD()
+        connexion = connexionBDD()
         connexion.cur.execute("UPDATE service SET etat= 1 WHERE idService = ?", (self.idService))
 

src/m/Parking.py

@@ -1,12 +1,13 @@
-
 from src.m.Place import Place
 
 __author__ = 'sidya'
 
+
 class Parking:
     """
         Definie un parking
     """
+
     def __init__(self, typePlaces, nom):
         """
         Creer objet parking
@@ -50,7 +51,7 @@ class Parking:
         """
         place = None
         for p in self.__Places:
-            if p.estLibre and p.dimValide(voiture.getHauteur, voiture.getLongueur) :
+            if p.estLibre and p.dimValide(voiture.getHauteur, voiture.getLongueur):
                 pass
                 place = p
                 break

src/m/Place.py

@@ -1,7 +1,3 @@
-import datetime
-import random
-import string
-
 __author__ = 'sidya'
 
 
@@ -9,7 +5,8 @@ class Place:
     """
     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)

src/m/Placement.py

@@ -4,17 +4,20 @@ import string
 
 __author__ = 'sidya'
 
+
 class Placement:
     placements = []
-    def __init__(self,voiture, place):
+
+    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)))
+        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

src/m/Service.py

@@ -24,7 +24,7 @@ class Service:
             connection = connexionBDD()
             # 1.obtenir id service (fonction max de sqlite ne marche pas bien...elle ne prend en compte que le premier chiffre. Ex: max(56,9)= 9... )
             connection.cur.execute("SELECT count(service.idSercice) FROM service;")
-            #entrée dans la base de donnée
+            # entrée dans la base de donnée
             indiceidSer = connection.cur.execute("SELECT count(service.idService) FROM service;")
             idService = int(''.join(map(str, indiceidSer))) + 1
             #2. obtenir l'idClient: définir une variable globale lors de l'execution du "jeu"

src/m/TypeAbonnement.py

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

src/m/TypePlace.py

@@ -1,9 +1,11 @@
 __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

src/m/Voiture.py

@@ -1,5 +1,3 @@
-
-
 class Voiture():
     def __init__(self, longueur, hauteur, imma):
         self._hauteur = hauteur
@@ -23,6 +21,6 @@ class Voiture():
     def estDansParking(self):
         return self._estDansParking == True
 
-    #def addPlacement(self, placement):
+        # def addPlacement(self, placement):
 
 

src/m/Voiturier.py

@@ -1,23 +1,28 @@
 import time
+
 from src.m.connexionBDD import connexionBDD
+
+
 class Voiturier:
     def __init__(self, id, nom, prenom):
-        self.numero= id
+        self.numero = id
         self.nom = nom
         self.prenom = prenom
 
     def enregistrerVoiturier(self, nom, prenom, dateEmbauche):
         connexion = connexionBDD()
-         #entrée dans la base de donnée
-        indiceidVoiturier= connexion.cur.execute("SELECT count(voiturier.idVoiturier) FROM voiturier;")+1
-        idVoiturier = int(''.join(map(str,indiceidVoiturier))) +1
-        connexion.cur.execute("INSERT INTO voiturier (idVoiturier,nom, prenom, dateEmbauche) VALUES (?,?,?,?);",(self.idVoiturier,nom, prenom, dateEmbauche) )
+        # entrée dans la base de donnée
+        indiceidVoiturier = connexion.cur.execute("SELECT count(voiturier.idVoiturier) FROM voiturier;") + 1
+        idVoiturier = int(''.join(map(str, indiceidVoiturier))) + 1
+        connexion.cur.execute("INSERT INTO voiturier (idVoiturier,nom, prenom, dateEmbauche) VALUES (?,?,?,?);",
+                              (self.idVoiturier, nom, prenom, dateEmbauche))
         connexion.seDeconnecter()
 
     def livrerVoiture(self):
         dateJour = time.strptime()
         connexion = connexionBDD()
-        indiceLivraison= connexion.cur.execute("SELECT count(voiturier.idVoiturier) FROM voiturier;")
-        idLivraison= int(''.join(map(str,indiceLivraison))) +1
-        connexion.cur.execute("INSERT INTO livraison (idLivraison,dateLivraison, idVoiturier) VALUES (?,?,?,?);",(idLivraison, dateJour, self.idVoiturier) )
+        indiceLivraison = connexion.cur.execute("SELECT count(voiturier.idVoiturier) FROM voiturier;")
+        idLivraison = int(''.join(map(str, indiceLivraison))) + 1
+        connexion.cur.execute("INSERT INTO livraison (idLivraison,dateLivraison, idVoiturier) VALUES (?,?,?,?);",
+                              (idLivraison, dateJour, self.idVoiturier))
         connexion.seDeconnecter()

src/m/connexionBDD.py

@@ -1,9 +1,12 @@
 import sqlite3
+
+
 class connexionBDD:
     def __init__(self):
         self.chemin = "BDDprojetPython.sq3"
-        self.conn =sqlite3.connect(self.chemin)
-        self.cur =self.conn.cursor()
+        self.conn = sqlite3.connect(self.chemin)
+        self.cur = self.conn.cursor()
+
     def seDeconnecter(self):
-       self.cur.close()
-       self.conn.close()
+        self.cur.close()
+        self.conn.close()

src/m/test/testClient.py

@@ -1,14 +1,14 @@
 __author__ = 'nadiel'
 
-import nose
-class testClient :
-    #def testsAbonner:
+
+class testClient:
+    # def testsAbonner:
 
     def testnouvelleVoiture(self):
-        assert()
+        assert ()
         #v = Voiture()
 
 
-    #def testTailleMax(self):
-     #   c = Camera()
-      #  assert (c.capturerHauteur()>1.5)
+        #def testTailleMax(self):
+        #   c = Camera()
+        #  assert (c.capturerHauteur()>1.5)

src/m/test/testService.py

@@ -1,5 +1,7 @@
 class testService:
-     """Fonction qui vérifie si la date insérée cest dans un format correcte (année est égale à l'année courante, 01≤jour≤31 et 01≤mois≤12); renvoie une erreur sinon"""
-    def testFormatDate(self, jourInsere, moisInsere, anneeInsere):
+    """Fonction qui vérifie si la date insérée cest dans un format correcte (année est égale à l'année courante, 01≤jour≤31 et 01≤mois≤12); renvoie une erreur sinon"""
+
+
+def testFormatDate(self, jourInsere, moisInsere, anneeInsere):