Added Camera MVC, CameraManufacturer MVC and CameraFormat MVC

server/Camera/controllers.py

@@ -0,0 +1,50 @@
+from flask import request, jsonify
+import uuid
+from ..app import db
+from .models import Camera
+
+def list_all_camera_controller():
+    cameras = Camera.query.all()
+    response = []
+    for camera in cameras: response.append(camera.toDict())
+    return jsonify(response)
+
+def create_camera_controller():
+    request_form = request.form.to_dict()
+    print(request_form)
+    new_camera = Camera(
+        name = request_form['name'],
+        shutterspeedstops = request_form['shutterspeedstops'],
+        shutterspeedmax = request_form['shutterspeedmax'],
+        fk_FilmFormat_id = request_form['filmformat'],
+        fk_CameraFormat_id = request_form['cameraformat'],
+        fk_CameraManufacturer_id = request_form['cameramanufacturer'],
+    )
+    db.session.add(new_camera)
+    db.session.commit()
+    response = Camera.query.all()
+    return(jsonify(request_form))
+
+def retrieve_camera_controller(camera_id):
+    response = Camera.query.get(camera_id).toDict()
+    print(response)
+    return jsonify(response)
+
+def update_camera_controller(camera_id):
+    request_form = request.form.to_dict()
+    camera = Camera.query.get(camera_id)
+    camera.name = request_form['name']
+    camera.shutterspeedstops =  request_form['shutterspeedstops']
+    camera.shutterspeedmax = request_form['shutterspeedmax']
+    camera.fk_FilmFormat_id = request_form['filmformat']
+    camera.fk_CameraFormat_id = request_form['cameraformat']
+    camera.fk_CameraManufacturer_id = request_form['cameramanufacturer']
+
+    db.session.commit()
+    response = Camera.query.get(camera_id).toDict()
+    return jsonify(response)
+
+def delete_camera_controller(camera_id):
+    Camera.query.filter_by(id=camera_id).delete()
+    db.session.commit()
+    return f"Camera with ID= {camera_id} was removed successfully"

server/Camera/models.py

@@ -0,0 +1,20 @@
+from sqlalchemy import inspect
+
+from ..app import db
+
+class Camera(db.Model):
+    id = db.Column(db.Integer(),primary_key=True,nullable=False,unique=True, autoincrement=True)
+    name = db.Column(db.String(255))
+    shutterspeedstops = db.Column(db.String(15))
+    shutterspeedmax = db.Column(db.String(15))
+    fk_FilmFormat_id = db.Column(db.Integer(),db.ForeignKey("film_format.id"))
+    filmformat = db.relationship("FilmFormat", back_populates='cameras')
+    fk_CameraFormat_id = db.Column(db.Integer(),db.ForeignKey("camera_format.id"))
+    cameraformat = db.relationship("CameraFormat", back_populates='cameras')
+    fk_CameraManufacturer_id = db.Column(db.Integer(),db.ForeignKey("camera_manufacturer.id"))
+    cameramanufacturer = db.relationship("CameraManufacturer", back_populates='cameras')
+    def toDict(self):
+        return {
+            c.key: getattr(self,c.key) for c in inspect(self).mapper.column_attrs
+        }
+        

server/Camera/urls.py

@@ -0,0 +1,15 @@
+from flask import request
+
+from ..app import app
+from .controllers import list_all_camera_controller,create_camera_controller,retrieve_camera_controller,update_camera_controller,delete_camera_controller
+
+@app.route("/Cameras",methods=["GET","POST"])
+def list_all_create_cameras():
+    if request.method == 'GET' : return list_all_camera_controller()
+    if request.method == 'POST' : return create_camera_controller()
+
+@app.route("/Cameras/<camera_id>",methods=["GET","PUT","DELETE"])
+def retrieve_update_delete_cameras(camera_id):
+    if request.method == 'GET' : return retrieve_camera_controller(camera_id)
+    if request.method == 'PUT' : return update_camera_controller(camera_id)
+    if request.method == "DELETE": return delete_camera_controller(camera_id)

server/CameraFormat/controllers.py

@@ -0,0 +1,40 @@
+from flask import request, jsonify
+import uuid
+from ..app import db
+from .models import CameraFormat
+
+def list_all_cameraformat_controller():
+    cameraformats = CameraFormat.query.all()
+    response = []
+    for cameraformat in cameraformats: response.append(cameraformat.toDict())
+    return jsonify(response)
+
+def create_cameraformat_controller():
+    request_form = request.form.to_dict()
+    print(request_form)
+    new_cameraformat = CameraFormat(
+        name = request_form['name'],
+    )
+    db.session.add(new_cameraformat)
+    db.session.commit()
+    response = CameraFormat.query.all()
+    return(jsonify(request_form))
+
+def retrieve_cameraformat_controller(cameraformat_id):
+    response = CameraFormat.query.get(cameraformat_id).toDict()
+    print(response)
+    return jsonify(response)
+
+def update_cameraformat_controller(cameraformat_id):
+    request_form = request.form.to_dict()
+    cameraformat = CameraFormat.query.get(cameraformat_id)
+    cameraformat.name = request_form['name']
+
+    db.session.commit()
+    response = CameraFormat.query.get(cameraformat_id).toDict()
+    return jsonify(response)
+
+def delete_cameraformat_controller(cameraformat_id):
+    CameraFormat.query.filter_by(id=cameraformat_id).delete()
+    db.session.commit()
+    return f"Cameraformat with ID= {cameraformat_id} was removed successfully"

server/CameraFormat/models.py

@@ -0,0 +1,13 @@
+from sqlalchemy import inspect
+
+from ..app import db
+
+class CameraFormat(db.Model):
+    id = db.Column(db.Integer(),primary_key=True,nullable=False,unique=True, autoincrement=True)
+    name = db.Column(db.String(255))
+    cameras = db.relationship("Camera",back_populates='cameraformat')
+    def toDict(self):
+        return {
+            c.key: getattr(self,c.key) for c in inspect(self).mapper.column_attrs
+        }
+        

server/CameraFormat/urls.py

@@ -0,0 +1,15 @@
+from flask import request
+
+from ..app import app
+from .controllers import list_all_cameraformat_controller,create_cameraformat_controller,retrieve_cameraformat_controller,update_cameraformat_controller,delete_cameraformat_controller
+
+@app.route("/CameraFormat",methods=["GET","POST"])
+def list_all_create_cameraformats():
+    if request.method == 'GET' : return list_all_cameraformat_controller()
+    if request.method == 'POST' : return create_cameraformat_controller()
+
+@app.route("/CameraFormat/<cameraformat_id>",methods=["GET","PUT","DELETE"])
+def retrieve_update_delete_cameraformats(cameraformat_id):
+    if request.method == 'GET' : return retrieve_cameraformat_controller(cameraformat_id)
+    if request.method == 'PUT' : return update_cameraformat_controller(cameraformat_id)
+    if request.method == "DELETE": return delete_cameraformat_controller(cameraformat_id)

server/CameraManufacturer/controllers.py

@@ -0,0 +1,40 @@
+from flask import request, jsonify
+import uuid
+from ..app import db
+from .models import CameraManufacturer
+
+def list_all_cameramanufacturers_controller():
+    filmmanufacturers = CameraManufacturer.query.all()
+    response = []
+    for filmmanufacturer in filmmanufacturers: response.append(filmmanufacturer.toDict())
+    return jsonify(response)
+
+def create_cameramanufacturer_controller():
+    request_form = request.form.to_dict()
+    print(request_form)
+    new_cameramanufacturer = CameraManufacturer(
+        name = request_form['name'],
+    )
+    db.session.add(new_cameramanufacturer)
+    db.session.commit()
+    response = CameraManufacturer.query.all()
+    return(jsonify(request_form))
+
+def retrieve_cameramanufacturer_controller(cameramanufacturer_id):
+    response = CameraManufacturer.query.get(cameramanufacturer_id).toDict()
+    print(response)
+    return jsonify(response)
+
+def update_cameramanufacturer_controller(cameramanufacturer_id):
+    request_form = request.form.to_dict()
+    cameramanufacturer = CameraManufacturer.query.get(cameramanufacturer_id)
+    cameramanufacturer.name = request_form['name']
+
+    db.session.commit()
+    response = CameraManufacturer.query.get(cameramanufacturer_id).toDict()
+    return jsonify(response)
+
+def delete_cameramanufacturer_controller(cameramanufacturer_id):
+    CameraManufacturer.query.filter_by(id=cameramanufacturer_id).delete()
+    db.session.commit()
+    return f"CameraManufacturer with ID={cameramanufacturer_id} was removed successfully"

server/CameraManufacturer/models.py

@@ -0,0 +1,14 @@
+from sqlalchemy import inspect
+
+from ..app import db
+
+class CameraManufacturer(db.Model):
+    id = db.Column(db.Integer(),primary_key=True,nullable=False,unique=True, autoincrement=True)
+    name = db.Column(db.String(255))
+    films = db.relationship("Camera",back_populates='cameramanufacturer')
+    
+    def toDict(self):
+        return {
+            c.key: getattr(self,c.key) for c in inspect(self).mapper.column_attrs
+        }
+        

server/CameraManufacturer/urls.py

@@ -0,0 +1,15 @@
+from flask import request
+
+from ..app import app
+from .controllers import list_all_cameramanufacturers_controller,create_cameramanufacturer_controller,retrieve_cameramanufacturer_controller,update_cameramanufacturer_controller,delete_cameramanufacturer_controller
+
+@app.route("/CameraManufacturer",methods=["GET","POST"])
+def list_all_create_filmmanufacturers():
+    if request.method == 'GET' : return list_all_cameramanufacturers_controller()
+    if request.method == 'POST' : return create_cameramanufacturer_controller()
+
+@app.route("/CameraManufacturer/<cameramanufacturer_id>",methods=["GET","PUT","DELETE"])
+def retrieve_update_delete_FilmManufacturers(cameramanufacturer_id):
+    if request.method == 'GET' : return retrieve_cameramanufacturer_controller(cameramanufacturer_id)
+    if request.method == 'PUT' : return update_cameramanufacturer_controller(cameramanufacturer_id)
+    if request.method == "DELETE": return delete_cameramanufacturer_controller(cameramanufacturer_id)

server/Film/models.py

@@ -9,7 +9,9 @@ class Film(db.Model):
     ISO = db.Column(db.String(10))
     Push_Pull = db.Column(db.String(10))
     fk_FilmManufacturer_id = db.Column(db.Integer(),db.ForeignKey("film_manufacturer.id"))
+    fk_FilmFormat_id = db.Column(db.Integer(),db.ForeignKey("film_format.id"))
     filmmanufacturer = db.relationship("FilmManufacturer",back_populates='films')
+    filmformat = db.relationship("FilmFormat", back_populates='films' )
     def toDict(self):
         return {
             c.key: getattr(self,c.key) for c in inspect(self).mapper.column_attrs

server/FilmFormat/models.py

@@ -5,7 +5,8 @@ from ..app import db
 class FilmFormat(db.Model):
     id = db.Column(db.Integer(),primary_key=True,nullable=False,unique=True, autoincrement=True)
     name = db.Column(db.String(255))
-    
+    films = db.relationship("Film",back_populates='filmformat')
+    cameras = db.relationship("Camera",back_populates='filmformat')
     def toDict(self):
         return {
             c.key: getattr(self,c.key) for c in inspect(self).mapper.column_attrs

server/app.py

@@ -8,14 +8,14 @@ from .config import config
 
 
 db = SQLAlchemy()
-migrate = Migrate()
+migrate = Migrate(render_as_batch=True)
 
 def create_app(config_mode):
     app = Flask(__name__)
     app.config.from_object(config[config_mode])
 
     db.init_app(app)
-    migrate.init_app(app,db,render_as_batch=True)
+    migrate.init_app(app,db,)
     
     with app.app_context():
         @event.listens_for(db.engine, 'connect')
@@ -39,6 +39,8 @@ from .Film import urls
 from .FilmManufacturer import urls
 from .FilmFormat import urls
 from .Location import urls
+from .Camera import urls
+from .CameraFormat import urls
 
 
 if __name__ == "__main__":