feat: ✨ implemented api, implemented creating driver and vehicle entity, added db models for entities

app.py

@@ -1,59 +1,144 @@
+from driverHandler import DriverHandler
 from gpxInterpreter import GPXHandler
+from vehicleHandler import VehicleHandler
 from dotenv import load_dotenv
-from flask import Flask, send_from_directory, jsonify, request
-from sqlalchemy                 import create_engine
-from sqlalchemy.orm             import sessionmaker
+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
 
-Session: Session
-app: any
+__session: Session
+FlaskApp: app
+__gpxHandler: GPXHandler
+__driverHandler: DriverHandler
+__vehicleHandler: VehicleHandler
 
-def entry():
+
+def entryPoint():
     print("load environment")
     load_dotenv()
 
     print("create flask application")
-    app = Flask(__name__, static_folder='web/dist')
-
-    # TODO: all the sqlalchemy stuff should be moved out of app.py
-    Base = declarative_base()
+    FlaskApp = Flask(__name__, static_folder='web/dist')
 
     def db_connect(connectionPath):
         return create_engine(connectionPath, poolclass=NullPool)
 
-    Base.metadata.create_all(db_connect)
-    session = sessionmaker(bind=db_connect())()
+    __session = sessionmaker(bind=db_connect())()
 
-    # handler class for all gpx files
+    # handler classes
     # handles parsing files and interacting with database
-    gpxHandler = GPXHandler(session)
+    __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
-@app.route('/')
-def serve_vue_app():
-    return send_from_directory(app.static_folder, 'index.html')
 
-@app.route("/route", method=['GET'])
+
+@FlaskApp.route('/')
+def serve_vue_app():
+    return send_from_directory(FlaskApp.static_folder, 'index.html')
+
+
+@FlaskApp.route("/route", method=['GET'])
 def getRoute():
-    # TODO: will contact gpx handler to get geoJSON from 
+    # TODO: will contact gpx handler to get geoJSON from
     return "not implemented", 500
-    
-@app.route('/upload', methods=['POST'])
+
+
+@FlaskApp.route("/driver", methods=['GET', 'POST'])
+def handleDriverRoute():
+
+    if request.method == "GET":
+        if 'driver' in request.args:
+
+            try:
+                __driverHandler.getVehicle(int(request.args["driver"]))
+                # return drivers, 200
+            except Exception as e:
+                return "error" + " " + str(e), 500
+
+        else:
+
+            try:
+                __driverHandler.getVehicles()
+                # return drivers, 200
+            except Exception as e:
+                return "error" + " " + str(e), 500
+
+    elif request.method == "POST":
+        if "name" not in request.args:
+            return "missing name", 400
+
+        # handle creating vehicle
+        try:
+            __driverHandler.createVehicle(request.args["name"])
+        except Exception as e:
+            return "error" + " " + str(e), 500
+
+    return "not implemented", 500
+
+
+@FlaskApp.route("/vehicle", methods=['GET', 'POST'])
+def handleVehicleRoute():
+
+    if request.method == "GET":
+        if 'vehicle' in request.args:
+
+            try:
+                __vehicleHandler.getVehicle(int(request.args["driver"]))
+                # return drivers, 200
+            except Exception as e:
+                return "error" + " " + str(e), 500
+
+        else:
+
+            try:
+                __vehicleHandler.getVehicles()
+                # return drivers, 200
+            except Exception as e:
+                return "error" + " " + str(e), 500
+
+    elif request.method == "POST":
+        if "name" not in request.args:
+            return "missing name", 400
+
+        if "type" not in request.args:
+            return "missing type", 400
+
+        # handle creating vehicle
+        try:
+            __vehicleHandler.createVehicle(
+                request.args["name"], request.args["type"])
+        except Exception as e:
+            return "error" + " " + str(e), 500
+
+    return "not implemented", 500
+
+
+@FlaskApp.route('/upload', methods=['POST'])
 def uploadFile():
     if 'file' not in request.files:
         return "no file provided", 400
 
+    if request.args["routeName"] == '':
+        return "no routename provided", 400
+
     file = request.files['file']
     if file.filename == '':
         return "no file selected", 400
 
     try:
-        gpx_handler = GPXHandler(file.stream)
-        gpx_handler.parse()
+        __gpxHandler.parse(file, request.args["routeName"])
         return "file stored succesfull", 200
     except Exception as e:
         return "error" + " " + str(e), 500
 
+
 if __name__ == '__main__':
-    entry()
+    entryPoint()