AC2 - gp2 (Nad, Dalia)

app/__init__.py

@@ -5,7 +5,7 @@
 from dotenv import load_dotenv
 
 db = SQLAlchemy()
-migrate = Migrate()
+migrate = Migrate(compare_type=True)
 load_dotenv()
 
 def create_app(test_config=None):
@@ -32,5 +32,15 @@ def create_app(test_config=None):
     migrate.init_app(app, db)
 
     #Register Blueprints Here
+    from app.routes.customer_routes import customers_bp
+    app.register_blueprint(customers_bp)
+
+    from app.routes.video_routes import videos_bp
+    app.register_blueprint(videos_bp)
+
+    from app.routes.rental_routes import rentals_bp
+    app.register_blueprint(rentals_bp)
+
+    return app
 
     return app

app/models/customer.py

@@ -1,4 +1,22 @@
 from app import db
+import datetime
 
 class Customer(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=True)
+    name = db.Column(db.String, nullable=False)
+    postal_code = db.Column(db.String, nullable=False)
+    phone = db.Column(db.String, nullable=False)
+    registered_at = db.Column(db.DateTime, default=datetime.datetime.now().strftime("%a, %d %b %Y %X %z"))
+    videos_checked_out_count = db.Column(db.Integer, nullable=False, default=0)
+    videos = db.relationship("Video", secondary="rental", back_populates="customers")
+
+    def to_dict(self):
+        customer_dict = {
+            "id": self.id,
+            "name": self.name,
+            "postal_code": self.postal_code,
+            "phone": self.phone,
+            "registered_at": self.registered_at,
+            "videos_checked_out_count": self.videos_checked_out_count
+        }
+        return customer_dict

app/models/rental.py

@@ -1,4 +1,8 @@
 from app import db
+# from datetime import datetime, timedelta
 
 class Rental(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True)
+    customer_id = db.Column(db.Integer, db.ForeignKey("customer.id"), nullable=False)
+    video_id = db.Column(db.Integer, db.ForeignKey("video.id"), nullable=False)
+    due_date = db.Column(db.DateTime)

app/models/video.py

@@ -1,4 +1,21 @@
 from app import db
 
+
+def available_inventory_default(context):
+    return context.get_current_parameters()['total_inventory']
 class Video(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False)
+    title = db.Column(db.String, nullable=False)
+    total_inventory = db.Column(db.Integer, nullable=False)
+    available_inventory = db.Column(db.Integer, default=available_inventory_default)
+    release_date = db.Column(db.DateTime, nullable=False)
+    customers = db.relationship("Customer",secondary="rental",back_populates="videos")
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "title": self.title,
+            "total_inventory": self.total_inventory,
+            "release_date": self.release_date
+        }
+

app/routes/customer_routes.py

@@ -0,0 +1,157 @@
+from app import db
+from app.models.customer import Customer
+from app.models.rental import Rental
+from app.models.video import Video
+from app.routes.helpers import validate_model, validate_request_body
+from flask import Blueprint, jsonify, request, make_response, abort
+import datetime
+
+
+customers_bp = Blueprint("customers_bp", __name__, url_prefix="/customers")
+
+
+@customers_bp.route("", methods=["GET"])
+def get_all_customers():
+    customer_query = Customer.query
+
+    sort_param = request.args.get("sort")
+    if sort_param:
+        if sort_param == "name":
+            customer_query = customer_query.order_by(Customer.name)
+        elif sort_param == "registered_at":
+            customer_query = customer_query.order_by(Customer.registered_at)
+        elif sort_param == "postal_code":
+            customer_query = customer_query.order_by(Customer.postal_code)
+        else:
+            customer_query = customer_query.order_by(Customer.id)
+    else:
+        customer_query = customer_query.order_by(Customer.id)   
+
+    count_param = request.args.get("count")
+    page_num_param = request.args.get("page_num")
+
+    pagination = False
+    count = None
+    page_num = None
+    if count_param and count_param.isdigit():
+        count = int(count_param)
+        pagination = True
+
+    if page_num_param and page_num_param.isdigit():
+        page_num = int(page_num_param)
+        pagination = True
+
+    customers = []
+    if pagination:
+        if page_num is None:
+            page_num = 1
+
+        page = customer_query.paginate(per_page=count,page=page_num)
+        customers = page.items
+    else:
+        customers = customer_query.all()
+
+    customers_response = [customer.to_dict() for customer in customers]
+
+    return make_response(jsonify(customers_response), 200)
+
+
+@customers_bp.route("/<customer_id>", methods=["GET"])
+def get_one_customer(customer_id):
+    customer = validate_model(Customer, customer_id)
+    customer_data = customer.to_dict()
+
+    return make_response(jsonify(customer_data), 200)
+
+
+@customers_bp.route("", methods=["POST"])
+def add_one_customer():
+    request_body = request.get_json()
+    required_attributes = ["name", "postal_code", "phone"]
+
+    validate_request_body(request_body, required_attributes)
+
+    new_customer = Customer(name=request_body["name"], 
+            postal_code=request_body["postal_code"],
+            phone=request_body["phone"])
+
+    db.session.add(new_customer)
+    db.session.commit()
+    db.session.refresh(new_customer, ["id"])
+
+    return make_response(jsonify({"id":new_customer.id}), 201)
+
+
+@customers_bp.route("/<customer_id>", methods=["DELETE"])
+def delete_one_customer(customer_id):
+    customer = validate_model(Customer, customer_id)
+    db.session.delete(customer)
+    db.session.commit()
+
+    return make_response(jsonify({"id":int(customer_id)}), 200)
+
+
+@customers_bp.route("/<customer_id>", methods=["PUT"])
+def update_one_customer(customer_id):
+    customer = validate_model(Customer, customer_id)
+    request_body = request.get_json()
+    required_attributes = ["name", "phone", "postal_code"]
+
+    validate_request_body(request_body, required_attributes)
+
+    customer.name = request_body["name"]
+    customer.phone = request_body["phone"]
+    customer.postal_code = request_body["postal_code"]
+    db.session.commit()
+    response_body = request_body
+    response_body['registered_at'] = customer.registered_at
+
+    return make_response(jsonify(response_body), 200)
+
+
+@customers_bp.route("/<customer_id>/rentals", methods=["GET"])
+def get_customer_checked_out_videos(customer_id):
+    validate_model(Customer, customer_id)
+
+    possible_query_params = {"sort" : "", 
+            "count": 0, 
+            "page_num": 0}
+
+    for query_param in possible_query_params:
+        if query_param in request.args:
+            possible_query_params[query_param] = request.args.get(query_param)
+
+    join_query = db.session.query(Rental, Video)\
+            .join(Video, Rental.video_id==Video.id)\
+            .filter(Rental.customer_id == customer_id)
+
+    sort_params = ["title", "release_date"]
+    for param in sort_params:
+        if possible_query_params["sort"] == param:
+            join_query = join_query.order_by(param)
+
+    if possible_query_params["count"] and \
+            possible_query_params["count"].isdigit():
+        possible_query_params["count"] = int(possible_query_params["count"])
+        if possible_query_params["page_num"] and \
+                possible_query_params["page_num"].isdigit():
+            possible_query_params["page_num"] = \
+                    int(possible_query_params["page_num"])
+        else:
+            possible_query_params["page_num"] = 1
+        join_query = join_query.paginate(
+                page=possible_query_params["page_num"], 
+                per_page=possible_query_params["count"]).items
+    else:
+        join_query = join_query.all()
+
+    response_body = []
+    for row in join_query:
+        response_body.append({
+            "id": row.Video.id,
+            "title": row.Video.title,
+            "total_inventory": row.Video.total_inventory,
+            "release_date": row.Video.release_date
+        })
+
+    return make_response(jsonify(response_body),200)

app/routes/helpers.py

@@ -0,0 +1,25 @@
+from flask import abort, make_response,jsonify
+
+def validate_model(model, id):
+    try:
+        int(id)
+    except:
+        abort(make_response({"message": f"{id} is an invalid {model.__name__} id"}, 400))
+
+    model_instance = model.query.get(id)
+
+    if not model_instance:
+        abort(make_response({"message": f"{model.__name__} {id} was not found"}, 404))
+
+    return model_instance
+
+def validate_request_body(request_body,required_data):
+    if not request_body:
+        msg = "An empty or invalid json object was sent."
+        abort(make_response(jsonify({"details":msg}),400))
+
+    for data in required_data:
+        if data not in request_body: 
+            msg = f"Request body must include {data}. Request failed"
+            abort(make_response(jsonify({"details":msg}),400))
+

app/routes/rental_routes.py

@@ -0,0 +1,75 @@
+from flask import Blueprint, request, make_response, jsonify, abort
+from app.routes.customer_routes import validate_model, validate_request_body
+from app.models.customer import Customer
+from app.models.video import Video
+from app.models.rental import Rental
+from app import db
+from datetime import datetime, timedelta
+
+MAX_DAYS_RENTALS = 7
+
+rentals_bp = Blueprint("rentals_bp", __name__, url_prefix="/rentals")
+
+@rentals_bp.route("/check-out", methods=["POST"])
+def checkout_video_to_customer():
+    request_body = request.get_json()
+    required_data = ["customer_id", "video_id"]
+
+    validate_request_body(request_body, required_data)
+
+    valid_customer = validate_model(Customer, request_body["customer_id"])
+    valid_video = validate_model(Video, request_body["video_id"])
+
+    if valid_video.available_inventory < 1:
+        abort(make_response(jsonify({"message":"Could not perform checkout"}), 400))
+
+    if valid_video in valid_customer.videos:
+        abort(make_response(jsonify({"message":"This customer already has this video checked out"}), 400))
+
+    new_rental = Rental(
+            customer_id=valid_customer.id, 
+            video_id=valid_video.id,
+            due_date=datetime.now() + timedelta(days=MAX_DAYS_RENTALS))
+    valid_video.available_inventory -= 1
+    valid_customer.videos_checked_out_count += 1
+    db.session.add(new_rental)
+    db.session.commit()
+
+    response_body = {
+        "customer_id" : valid_customer.id,
+        "video_id" : valid_video.id,
+        "due_date" : new_rental.due_date,
+        "videos_checked_out_count" : valid_customer.videos_checked_out_count,
+        "available_inventory" : valid_video.available_inventory
+    }
+
+    return make_response(jsonify(response_body), 200)
+
+@rentals_bp.route("/check-in", methods=["POST"])
+def check_in_video():
+    request_body = request.get_json(silent=True)
+    required_data = ["customer_id", "video_id"]
+
+    validate_request_body(request_body,required_data)
+
+    customer = validate_model(Customer,request_body["customer_id"])
+    video = validate_model(Video,request_body["video_id"])
+    rental = Rental.query.filter_by(video_id=video.id, customer_id=customer.id).first()
+
+    if not rental:
+        msg = f"No outstanding rentals for customer {customer.id} and video {video.id}"
+        abort(make_response(jsonify({"message":msg}),400))
+
+    video.available_inventory += 1
+    customer.videos_checked_out_count -= 1
+
+    db.session.delete(rental)
+    db.session.commit()
+
+    response_data = {}
+    response_data["video_id"] = video.id
+    response_data["customer_id"] = customer.id
+    response_data["videos_checked_out_count"] = customer.videos_checked_out_count
+    response_data["available_inventory"] = video.available_inventory
+
+    return make_response(jsonify(response_data),200)