fix: 🐛 fixed driver and vehicle apis, swapped dbms to postgres and refactored project structure

modules/driverHandler.py

@@ -0,0 +1,58 @@
+from sqlalchemy.orm import Session
+
+from modules.geoObjects import Driver
+
+
+class DriverHandler:
+    dbSession: Session
+
+    def __init__(self, session: Session):
+        self.dbSession = session
+        pass
+
+    # handles creating a driver in the database
+    def createDriver(self, name: str) -> Driver:
+        try:
+            # makes sure that a name always is provided
+            if not name:
+                raise ValueError("name is empty")
+
+            driver = Driver(name=name)
+            
+            self.dbSession.add(driver)
+            self.dbSession.commit()
+            
+            return driver
+        except Exception as e:
+            raise RuntimeError(f"failed to create driver with errors{e}")
+        
+    # handles getting a driver by its id from the database
+    def getDriver(self, driverID: int):
+        try:
+            driver = self.dbSession.query(Driver).filter_by(id=driverID).first()
+            
+            return {
+                "id": driver.id,
+                "name": driver.name
+            }
+        except Exception as e:
+            raise RuntimeError(f"failed to get driver with errors{e}")
+        
+    # handles getting all drivers from the database
+    def getDrivers(self):
+        try:
+            drivers = self.dbSession.query(Driver).all()
+    
+            driverList = [
+                {
+                    "id": driver.id,
+                    "name": driver.name
+                }
+                # iterates all drivers and appends them to the list
+                for driver in drivers
+            ]
+
+            return driverList
+        
+        except Exception as e:
+            raise RuntimeError(f"failed to get drivers with errors{e}")

modules/geoObjects.py

@@ -0,0 +1,76 @@
+from sqlalchemy                 import create_engine, Column, Table, ForeignKey, Index, UniqueConstraint, MetaData, SmallInteger, Integer, String, Date, DateTime, Float, Boolean, Text, Numeric, DateTime
+from sqlalchemy.orm             import relationship, sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.pool            import NullPool
+from sqlalchemy.exc import OperationalError
+
+Base = declarative_base()
+
+# Funktion zur Herstellung einer Verbindung zur Datenbank
+def db_connect():
+    try:
+        engine = create_engine("postgresql://example:example@localhost/geotrack", poolclass=NullPool)
+        # Überprüfe die Verbindung
+        with engine.connect() as connection:
+            print("Verbindung zur Datenbank erfolgreich!")
+        return engine
+    except OperationalError as e:
+        print(f"Fehler bei der Verbindung zur Datenbank: {e}")
+        return None
+
+# Funktion zur Erstellung der Tabellen
+def create_table(engine):
+    try:
+        if engine is not None:
+            Base.metadata.create_all(engine)
+            print("Tabellen wurden erfolgreich erstellt!")
+        else:
+            print("Keine Verbindung zur Datenbank verfügbar.")
+    except Exception as e:
+        print(f"Fehler bei der Tabellenerstellung: {e}")
+    
+class Track(Base):
+    __tablename__ = 'track'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    trackName = Column(String(200), nullable=True)
+    vehicle_id = Column(Integer, ForeignKey('vehicle.id'), nullable=False, default=1)
+    driver_id = Column(Integer, ForeignKey('driver.id'), nullable=False, default=1)
+    date = Column(Date, nullable=True)
+    distance = Column(Float, nullable=False, default=0)
+    speed = Column(Float, nullable=False, default=0)
+    start = Column(DateTime, nullable=False)
+    end = Column(DateTime, nullable=False)
+    
+    # Beziehungen zu anderen Tabellen
+    waypoints = relationship('Waypoint', backref='track', lazy=True)
+    driver = relationship('Driver', back_populates='tracks')
+    vehicle = relationship('Vehicle', back_populates='tracks')
+
+
+class Waypoint(Base):
+    __tablename__ = 'waypoint'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    lat = Column(Float, nullable=False)
+    lon = Column(Float, nullable=False)
+    ele = Column(Float, nullable=False)
+    speed = Column(Float, nullable=True)
+    time = Column(DateTime, nullable=True)
+    track_id = Column(Integer, ForeignKey('track.id'), nullable=False)
+
+
+class Driver(Base):
+    __tablename__ = 'driver'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False)
+    
+    # Beziehung zu Track, zurück über 'tracks' auf Track-Seite
+    tracks = relationship("Track", back_populates='driver')
+
+
+class Vehicle(Base):
+    __tablename__ = 'vehicle'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False)
+    
+    # Beziehung zu Track, zurück über 'tracks' auf Track-Seite
+    tracks = relationship('Track', back_populates='vehicle')

modules/gpxInterpreter.py

@@ -0,0 +1,143 @@
+import datetime
+import gpxpy
+import gpxpy.gpx
+from sqlalchemy.orm import Session
+from geojson import Feature, LineString
+from geopy.distance import geodesic
+
+from errors.NotFoundException import NotFoundError
+from modules.geoObjects import Track, Waypoint
+
+class GPXHandler:
+    __dbSession: Session
+    
+    def __init__(self, session:Session):
+        self.__dbSession = session
+        pass
+    
+    # handles converting a gpx file into usable data
+    def parse(self, file, driver, vehicle):
+        self.__gpx = gpxpy.parse(file)
+
+        if not driver:
+            raise ValueError("no driver found")
+
+        if not vehicle:
+            raise ValueError("no vehicle found")
+        
+        if not file:
+            raise ValueError("no file found")
+
+        for track in self.__gpx.tracks:
+            # sets track name
+            # if no name is found at a track default to using date
+            trackName = track.name or f"Track-{datetime.now().isoformat()}" # todo using time.now might end up being misleading and to be reworked
+            
+            # initializes track values
+            self.__startTime, 
+            self.__endTime, 
+            self.__trackDistance, 
+            self.__waypoints = None, None, 0, []
+
+            # grab all waypoints from a track
+            for segment in track.segments:
+                for point in segment.points:
+                    self.__waypoints.append(point)
+                    if start_time is None or point.time < start_time:
+                        start_time = point.time
+                    if end_time is None or point.time > end_time:
+                        end_time = point.time
+                        
+            # calculate distance between 2 waypoints
+            for i in range(1, len(self.__waypoints)):
+                total_distance += self.__waypoints[i - 1].distance_3d(self.__waypoints[i])
+        
+            # push values to the database
+            track = Track(
+                trackName=trackName,
+                vehicle=vehicle.id,
+                driver=driver.id,
+                date=start_time.date() if start_time else None,
+                distance=total_distance,
+                speed=0,
+                start=start_time,
+                end=end_time
+            )
+                    
+            self.__dbSession.add(track)
+            self.__dbSession.commit()
+        
+            for point in self.__waypoints:
+                waypoint = Waypoint(
+                    lat=point.latitude,
+                    lon=point.longitude,
+                    ele=point.elevation,
+                    speed=None,
+                    time=point.time,
+                    track=track.id
+                )
+                self.__dbSession.add(waypoint)
+
+            self.__dbSession.commit()
+        
+    # handles a route from db and converting it into geoJSON
+    def getTrack(self, trackID):
+        track = self.__dbSession.query(Track).filter_by(id=trackID).first()
+        if not track:
+            raise NotFoundError(f"track with id {trackID} not found")
+
+        # fetches waypoints for a given track and converts them into geoJSON
+        waypoints = self.__dbSession.query(Waypoint).filter_by(track=track.id).all()
+        coordinates = [(wp.lon, wp.lat) for wp in waypoints]
+        feature = Feature(geometry=LineString(coordinates))
+        return feature
+    
+    # grabs only the tracks from the database and returns them as json object
+    def getTracks(self):
+        tracks = self.__dbSession.query(Track).all()
+
+        track_list = [
+            {
+                "id": track.id,
+                "name": track.trackName,
+                # "driver": {
+                #     "id": track.driver.id,
+                #     "name": track.driver.name
+                # } if track.driver else None,
+                # "vehicle": {
+                #     "id": track.vehicle.id,
+                #     "name": track.vehicle.name
+                # } if track.vehicle else None,
+                # "distance": track.distance,
+                # "start_time": track.start.isoformat() if track.start else None,
+                # "end_time": track.end.isoformat() if track.end else None,
+            }
+            for track in tracks # iterates all tracks and appends them to the list
+        ]
+
+        return track_list
+
+    
+    def getTracksInTime(self, start, end):
+        tracks = self.__dbSession.query(Track).filter(Track.start.between(start, end)).all()
+        
+        track_list = [
+            {
+                "id": track.id,
+                "name": track.trackName,
+                "driver": {
+                    "id": track.driver.id,
+                    "name": track.driver.name
+                } if track.driver else None,
+                "vehicle": {
+                    "id": track.vehicle.id,
+                    "name": track.vehicle.name
+                } if track.vehicle else None,
+                "distance": track.distance,
+                "start_time": track.start.isoformat() if track.start else None,
+                "end_time": track.end.isoformat() if track.end else None,
+            }
+            for track in tracks # iterates all tracks and appends them to the list
+        ]
+
+        return track_list

modules/vehicleHandler.py

@@ -0,0 +1,46 @@
+from sqlalchemy.orm import Session
+
+from modules.geoObjects import Vehicle
+
+class VehicleHandler:
+    dbSession: Session
+    
+    def __init__(self, session:Session):
+        self.dbSession = session
+        pass
+    
+    # handles creating a vehicle and storing it in the database
+    def createVehicle(self, name:str) -> Vehicle:
+        if not name:
+            raise ValueError("name is empty")
+        
+        vehicle = Vehicle(name=name)
+        
+        self.dbSession.add(vehicle)
+        self.dbSession.commit()
+        
+        return vehicle
+    
+    # handles getting a vehicle identified with its id from the database
+    def getVehicle(self, vehicleID:int):
+        vehicle = self.dbSession.query(Vehicle).filter_by(id=vehicleID).first()
+        
+        return {
+            "id": vehicle.id,
+            "name": vehicle.name
+        }
+    
+    # handles getting all vehicles from database
+    def getVehicles(self):
+        vehicles = self.dbSession.query(Vehicle).all()
+
+        driverList = [
+            {
+                "id": vehicle.id,
+                "name": vehicle.name
+            }
+            # iterates all drivers and appends them to the list
+            for vehicle in vehicles
+        ]
+
+        return driverList