From d585c90a4e1128551dc8ab497834425f1d98c830 Mon Sep 17 00:00:00 2001 From: steev Date: Wed, 8 Jan 2025 22:42:09 +0100 Subject: [PATCH] fix: :bug: fixed driver and vehicle apis, swapped dbms to postgres and refactored project structure --- api/router.py | 8 - app.py | 179 +++++++++++------- class/driverHandler.py | 46 ----- class/model/geoObjects.py | 62 ------ compose.yaml | 42 ++-- {class/errors => errors}/NotFoundException.py | 0 errors/__init__.py | 0 modules/__init__.py | 0 modules/driverHandler.py | 58 ++++++ modules/geoObjects.py | 76 ++++++++ {class => modules}/gpxInterpreter.py | 2 +- {class => modules}/vehicleHandler.py | 22 +-- 12 files changed, 280 insertions(+), 215 deletions(-) delete mode 100644 api/router.py delete mode 100644 class/driverHandler.py delete mode 100644 class/model/geoObjects.py rename {class/errors => errors}/NotFoundException.py (100%) create mode 100644 errors/__init__.py create mode 100644 modules/__init__.py create mode 100644 modules/driverHandler.py create mode 100644 modules/geoObjects.py rename {class => modules}/gpxInterpreter.py (99%) rename {class => modules}/vehicleHandler.py (65%) diff --git a/api/router.py b/api/router.py deleted file mode 100644 index d3885cc..0000000 --- a/api/router.py +++ /dev/null @@ -1,8 +0,0 @@ -from flask import send_from_directory, request - - -def serve_vue_app(app): - return send_from_directory(app.static_folder, 'index.html') - -def upload_file(request): - file = request.files['file'] \ No newline at end of file diff --git a/app.py b/app.py index 3a5de65..9742607 100644 --- a/app.py +++ b/app.py @@ -1,155 +1,204 @@ -from driverHandler import DriverHandler -from gpxInterpreter import GPXHandler -from vehicleHandler import VehicleHandler +import sys +import os +import logging +from flask import Flask, jsonify, send_from_directory, request from dotenv import load_dotenv -from flask import Flask, app, send_from_directory, request -from sqlalchemy import NullPool, create_engine from sqlalchemy.orm import sessionmaker, Session -from geoObjects import createTables +from modules.driverHandler import DriverHandler +from modules.gpxInterpreter import GPXHandler +from modules.vehicleHandler import VehicleHandler +from modules.geoObjects import create_table, db_connect +from flask_cors import CORS, cross_origin -__session: Session -FlaskApp: app -__gpxHandler: GPXHandler -__driverHandler: DriverHandler -__vehicleHandler: VehicleHandler +root = logging.getLogger() +root.setLevel(logging.DEBUG) + +handler = logging.StreamHandler(sys.stdout) +handler.setLevel(logging.DEBUG) +formatter = logging.Formatter( + '%(asctime)s - %(name)s - %(levelname)s - %(message)s') +handler.setFormatter(formatter) +root.addHandler(handler) + +print("load environment") +load_dotenv() -def entryPoint(): - print("load environment") - load_dotenv() +print("create flask application") +app = Flask(__name__, static_folder='web/dist') +cors = CORS(app) # allow CORS for all domains on all routes. +app.config['CORS_HEADERS'] = 'Content-Type' +app.logger.setLevel(logging.DEBUG) - print("create flask application") - FlaskApp = Flask(__name__, static_folder='web/dist') +print("initialize database") +engine = db_connect() +SessionFactory = sessionmaker(bind=engine) +session = SessionFactory() +create_table(engine) - def db_connect(connectionPath): - return create_engine(connectionPath, poolclass=NullPool) - - __session = sessionmaker(bind=db_connect())() - - # handler classes - # handles parsing files and interacting with database - __gpxHandler = GPXHandler(__session) - __driverHandler = DriverHandler(__session) - __vehicleHandler = VehicleHandler(__session) - - # creating tables - createTables(__session) - - app.run(debug=True) - -# TODO: move functional parts out to api package if not handled by other classes +print("initialize handlers") +gpxHandler = GPXHandler(session) +driverHandler = DriverHandler(session) +vehicleHandler = VehicleHandler(session) -@FlaskApp.route('/') +@app.route('/') +@cross_origin() def serve_vue_app(): - return send_from_directory(FlaskApp.static_folder, 'index.html') + return send_from_directory(app.static_folder, 'index.html') -@FlaskApp.route("/track", method=['GET']) + +@app.route("/track", methods=['GET']) +@cross_origin() def getTrack(): - + if "start" in request.args and "end" in request.args or "track" in request.args: if "start" in request.args and "end" in request.args: # get tracks by filter + start = request.args["start"] + end = request.args["end"] try: - return __gpxHandler.getTracksInTime(request.args["start"], request.args["end"]), 200 + return gpxHandler.getTracksInTime(start, request.args["end"]), 200 except Exception as e: + app.logger.debug(f"failed to search tracks error { + e} values: start={start}, end={end}") return f"error {e}", 500 - + elif "track" in request.args: # get track by id + track = int(request.args["track"]) try: - return __gpxHandler.getTrack(int(request.args["track"])), 200 + return gpxHandler.getTrack(track), 200 except Exception as e: + app.logger.debug(f"fetching track { + track} failed with error {e}") return f"error {e}", 500 - + pass else: - # gets all tracks as list - return __gpxHandler.getTracks() + try: + # gets all tracks as list + return gpxHandler.getTracks() + except Exception as e: + app.logger.debug(f"fetching all tracks failed with error {e}") + return f"error {e}", 500 -@FlaskApp.route("/driver", methods=['GET', 'POST']) + +@app.route("/driver", methods=['GET', 'POST']) +@cross_origin() def handleDriverRoute(): if request.method == "GET": if 'driver' in request.args: try: - __driverHandler.getVehicle(int(request.args["driver"])) - # return drivers, 200 + driver = driverHandler.getDriver(int(request.args["driver"])) + return driver, 200 except Exception as e: + app.logger.debug(f"getting driver failed with error {e}") return "error" + " " + str(e), 500 else: try: - __driverHandler.getVehicles() - # return drivers, 200 + drivers = driverHandler.getDrivers() + return drivers, 200 except Exception as e: + app.logger.debug(f"getting drivers failed with error {e}") return "error" + " " + str(e), 500 elif request.method == "POST": - if "name" not in request.args: + + # grabbing json from request + data = request.get_json() + app.logger.debug(f"json request payload: {data}") + + if "name" not in data: + app.logger.debug(f"no driver name was found in request") return "missing name", 400 + app.logger.debug(f"driver name has passed check {data["name"]}") + # handle creating vehicle try: - __driverHandler.createVehicle(request.args["name"]) - # TODO: return id, 200 + app.logger.debug(f"json request name: {data["name"]}") + driver = driverHandler.createDriver(data["name"]) + return jsonify({"name": driver.name, "id": driver.id}), 200 + except Exception as e: + app.logger.debug(f"creating drivers failed with error {e}") return "error" + " " + str(e), 500 -@FlaskApp.route("/vehicle", methods=['GET', 'POST']) + +@app.route("/vehicle", methods=['GET', 'POST']) +@cross_origin() def handleVehicleRoute(): if request.method == "GET": if 'vehicle' in request.args: + app.logger.debug(f"no vehicle id was found in request") + vehicle = int(request.args["vehicle"]) try: - __vehicleHandler.getVehicle(int(request.args["driver"])) - # return drivers, 200 + foundVehicle = vehicleHandler.getVehicle(vehicle) + return foundVehicle, 200 except Exception as e: + app.logger.debug(f"getting vehicle {vehicle} failed with error {e}") return "error" + " " + str(e), 500 else: try: - __vehicleHandler.getVehicles() - # return drivers, 200 + foundVehicles = vehicleHandler.getVehicles() + return foundVehicles, 200 except Exception as e: + app.logger.debug(f"getting all vehicles failed with error {e}") return "error" + " " + str(e), 500 elif request.method == "POST": - if "name" not in request.args: + data = request.get_json() + app.logger.debug(f"json request payload: {data}") + + if "name" not in data: return "missing name", 400 - if "type" not in request.args: - return "missing type", 400 + name = data["name"] # handle creating vehicle try: - __vehicleHandler.createVehicle( - request.args["name"], request.args["type"]) + vehicle = vehicleHandler.createVehicle(name) + return jsonify({"id": vehicle.id, "name": vehicle.name}), 200 + except Exception as e: + app.logger.debug(f"creating vehicle with name {name} failed with error {e}") return "error" + " " + str(e), 500 -@FlaskApp.route('/upload', methods=['POST']) + +@app.route('/upload', methods=['POST']) +@cross_origin() def uploadFile(): if 'file' not in request.files: + app.logger.debug("no file was found in clients request") return "no file provided", 400 if request.args["routeName"] == '': - return "no routename provided", 400 + app.logger.debug("client did not provide any name for uploaded route") + return "no route name provided", 400 file = request.files['file'] if file.filename == '': + app.logger.debug("filename was found empty") return "no file selected", 400 try: - __gpxHandler.parse(file, request.args["routeName"]) + app.logger.debug(f"attempting to parse file: {file.name}") + gpxHandler.parse(file, request.args["routeName"]) return "file stored succesfull", 200 except Exception as e: + app.logger.debug(f"storing gpx file failed with error {e}") return "error" + " " + str(e), 500 if __name__ == '__main__': - entryPoint() + app.run(debug=True) + app.logger.debug("flask app started") diff --git a/class/driverHandler.py b/class/driverHandler.py deleted file mode 100644 index 89243a9..0000000 --- a/class/driverHandler.py +++ /dev/null @@ -1,46 +0,0 @@ -from sqlalchemy.orm import Session - -from 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): - - # makes sure that a name always is provided - if not name: - raise ValueError("name is empty") - - self.__dbSession.add(Driver(name=name)) - self.__dbSession.commit() - pass - - # handles getting a driver by its id from the database - def getDriver(self, driverID: int): - driver = self.__dbSession.query(Driver).filter_by(id=driverID).first() - - return { - "id": driver.id, - "name": driver.name - } - - # handles getting all drivers from the database - def getDrivers(self): - 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 diff --git a/class/model/geoObjects.py b/class/model/geoObjects.py deleted file mode 100644 index 8a9ceef..0000000 --- a/class/model/geoObjects.py +++ /dev/null @@ -1,62 +0,0 @@ -from sqlalchemy import Column, Date, DateTime, Float, ForeignKey, Integer, String -from sqlalchemy.ext.declarative import declarative_base -from sqlalchemy.pool import NullPool -from sqlalchemy.orm import relationship - -Base = declarative_base() - -def getBase(): - # i dont know if i ever need this but if i might here it is - return Base - -def createTables(engine): - Base.metadata.create_all(engine) - - engine.add(Driver(name="default")) - engine.add(Vehicle(name="default")) - engine.commit() - -class Track(Base): - __tablename__ = 'track' - id = Column(Integer, primary_key=True, autoincrement=True) - trackName = Column(String(200), nullable=True) - vehicle = Column(Integer, ForeignKey('vehicle.id'), nullable=False, default=1) - driver = 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) - - waypoints = relationship('Waypoint', backref='track', lazy=True) - driver = relationship('Driver', backref='track') - vehicle = relationship('Vehicle', backref='track') - - pass - -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 = Column(Integer, ForeignKey('track.id'), nullable=False) - pass - -class Driver(Base): - __tablename__ = 'driver' - id = Column(Integer, primary_key=True, autoincrement=True) - name = Column(String, nullable=False) - - track = relationship("Track", back_populates='driver') - pass - -class Vehicle(Base): - __tablename__ = 'vehicle' - id = Column(Integer, primary_key=True, autoincrement=True) - name = Column(String, nullable=False) - - track = relationship('Track', back_populates='vehicle') - pass \ No newline at end of file diff --git a/compose.yaml b/compose.yaml index 6f180e4..a7448a3 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,27 +1,25 @@ +# Use postgres/example user/password credentials services: db: image: postgres - environment: - - POSTGRES_USER=zahlenraten - - POSTGRES_PASSWORD=CYrcTzCEKyDtq&N0M - - POSTGRES_DB=game + restart: always ports: - - "5432:5432" - volumes: - - pgdata:/var/lib/postgresql/data - - ./init.sql:/docker-entrypoint-initdb.d/init.sql - networks: - - backend + - 5432:5432 + # set shared memory limit when using docker-compose + shm_size: 128mb + # or set shared memory limit when deploy via swarm stack + #volumes: + # - type: tmpfs + # target: /dev/shm + # tmpfs: + # size: 134217728 # 128*2^20 bytes = 128Mb + environment: + POSTGRES_USER: example + POSTGRES_PASSWORD: example + POSTGRES_DB: geotrack - GeoTrack: - build: . - ports: - - "8000:5000" - networks: - - backend - -networks: - backend: - -volumes: - pgdata: + adminer: + image: adminer + restart: always + ports: + - 8080:8080 diff --git a/class/errors/NotFoundException.py b/errors/NotFoundException.py similarity index 100% rename from class/errors/NotFoundException.py rename to errors/NotFoundException.py diff --git a/errors/__init__.py b/errors/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/modules/__init__.py b/modules/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/modules/driverHandler.py b/modules/driverHandler.py new file mode 100644 index 0000000..9dcd6bb --- /dev/null +++ b/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}") \ No newline at end of file diff --git a/modules/geoObjects.py b/modules/geoObjects.py new file mode 100644 index 0000000..1977748 --- /dev/null +++ b/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') diff --git a/class/gpxInterpreter.py b/modules/gpxInterpreter.py similarity index 99% rename from class/gpxInterpreter.py rename to modules/gpxInterpreter.py index eac76bc..f194798 100644 --- a/class/gpxInterpreter.py +++ b/modules/gpxInterpreter.py @@ -6,7 +6,7 @@ from geojson import Feature, LineString from geopy.distance import geodesic from errors.NotFoundException import NotFoundError -from geoObjects import Track, Waypoint +from modules.geoObjects import Track, Waypoint class GPXHandler: __dbSession: Session diff --git a/class/vehicleHandler.py b/modules/vehicleHandler.py similarity index 65% rename from class/vehicleHandler.py rename to modules/vehicleHandler.py index 31db030..c844a96 100644 --- a/class/vehicleHandler.py +++ b/modules/vehicleHandler.py @@ -1,29 +1,29 @@ from sqlalchemy.orm import Session -from geoObjects import Vehicle +from modules.geoObjects import Vehicle class VehicleHandler: - __dbSession: Session + dbSession: Session def __init__(self, session:Session): - self.__dbSession = session + self.dbSession = session pass # handles creating a vehicle and storing it in the database - def createVehicle(self, name:str, type:str): + def createVehicle(self, name:str) -> Vehicle: if not name: raise ValueError("name is empty") - if not type: - raise ValueError("vehicle is empty") + vehicle = Vehicle(name=name) - self.__dbSession.add(Vehicle(name, type)) - self.__dbSession.commit() - pass + 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() + vehicle = self.dbSession.query(Vehicle).filter_by(id=vehicleID).first() return { "id": vehicle.id, @@ -32,7 +32,7 @@ class VehicleHandler: # handles getting all vehicles from database def getVehicles(self): - vehicles = self.__dbSession.query(Vehicle).all() + vehicles = self.dbSession.query(Vehicle).all() driverList = [ {