Ocelots - Diana Arreola, Supriya Chavan, Yuan Du

app/__init__.py

@@ -32,5 +32,13 @@ 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

app/models/customer.py

@@ -1,4 +1,29 @@
 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, 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.date.today()))
+    videos_checked_out_count = db.Column(db.Integer, default=0)
+    rentals = db.relationship("Rental", back_populates="customer")
+
+    def to_dict(self):
+        return {
+                "id": self.id,
+                "name": self.name,
+                "postal_code": self.postal_code,
+                "phone": self.phone,
+                "registered_at": self.registered_at
+            }
+
+    @classmethod
+    def from_dict(cls, customer_data):
+        new_customer = Customer(name = customer_data["name"],
+                    postal_code = customer_data["postal_code"],
+                    phone = customer_data["phone"],
+                    registered_at = customer_data["registered_at"]
+                    )
+        return new_customer

app/models/rental.py

@@ -1,4 +1,30 @@
 from app import db
+import datetime
 
 class Rental(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True,nullable=False)
+    due_date = db.Column(db.DateTime, default=(datetime.date.today()+datetime.timedelta(days=7)))
+    check_out_status = db.Column(db.Boolean,default = 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)
+    customer = db.relationship("Customer", back_populates="rentals")
+    video = db.relationship("Video", back_populates="rentals")
+
+    def to_dict(self):
+        rental_dict = {}
+        rental_dict["id"] = self.id
+        rental_dict["customer_id"] = self.customer_id
+        rental_dict["video_id"] = self.video_id
+        rental_dict["due_date"] = self.due_date
+        rental_dict["check_out_status"] = self.check_out_status
+        return rental_dict
+
+    @classmethod
+    def from_dict(cls, rental_data):
+        new_rental = Rental(
+            customer_id = rental_data["customer_id"],
+            video_id = rental_data["video_id"]
+        )
+        return new_rental
+
+

app/models/video.py

@@ -1,4 +1,26 @@
 from app import db
 
 class Video(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    title = db.Column(db.String, nullable=False)
+    release_date = db.Column(db.String, nullable=False)
+    total_inventory = db.Column(db.Integer, nullable=False)
+    videos_checked_out_count = db.Column(db.Integer)
+    rentals = db.relationship("Rental", back_populates="video")
+
+    def to_dict(self):
+        return {
+                "id": self.id,
+                "title": self.title,
+                "release_date": self.release_date,
+                "total_inventory": self.total_inventory
+
+            }
+
+    @classmethod
+    def from_dict(cls, video_data):
+        new_video = Video(title=video_data["title"],
+                    release_date=video_data["release_date"],
+                    total_inventory=video_data["total_inventory"]
+                            )
+        return new_video

app/routes/customer_routes.py

@@ -0,0 +1,172 @@
+from flask import Blueprint, jsonify, abort, make_response, request 
+from app import db
+from datetime import datetime
+from app.models.customer import Customer
+from app.models.rental import Rental
+from app.models.video import Video
+from app.routes.routes_helper import validate_model, validate_num_queries
+
+customers_bp = Blueprint("customers_bp", __name__, url_prefix="/customers")
+
+# CREATE New Customer -- POST
+@customers_bp.route("", methods=["POST"])
+def create_customer():
+    request_body = request.get_json()
+
+    try:
+        new_customer = Customer(name=request_body["name"],
+                    postal_code=request_body["postal_code"],
+                    phone=request_body["phone"]
+                    # registered_at=datetime.now()
+                    )
+    except KeyError as key_error:
+        abort(make_response({"details":f"Request body must include {key_error.args[0]}."}, 400))
+
+    db.session.add(new_customer)
+    db.session.commit()
+
+    customer_response = new_customer.to_dict()
+    return jsonify(customer_response), 201
+
+@customers_bp.route("", methods=["GET"])
+def read_all_customers():
+    customer_query = Customer.query
+    # customers = customer_query.all()
+
+    sort_query = request.args.get("sort")
+    if sort_query:
+        if sort_query == "name":
+            customer_query = customer_query.order_by(Customer.name.asc())
+        elif sort_query == "postal_code":
+            customer_query = customer_query.order_by(Customer.postal_code.asc())
+        elif sort_query == "registered_at":
+            customer_query = customer_query.order_by(Customer.registered_at.asc())
+        else:
+            customer_query = customer_query.order_by(Customer.id.asc())
+
+    count_query = request.args.get("count")  # check if count and page/ if only count, display all pages
+    page_num_query = request.args.get("page_num")
+
+    if validate_num_queries(count_query) and validate_num_queries(page_num_query):
+        # need to check if count_query and page_num wuery are valid nums
+
+        page = customer_query.paginate(page=int(page_num_query), per_page=int(count_query), error_out=False)
+        customers = customer_query.all()
+
+        customers_response = []
+
+        for items in page.items:
+            customers_response.append(items.to_dict())
+        return jsonify(customers_response), 200
+
+    if validate_num_queries(count_query) and not validate_num_queries(page_num_query):
+        page = customer_query.paginate(per_page=int(count_query), error_out=False)
+        customers = customer_query.all()
+        customers_response = []
+
+        for items in page.items:
+            customers_response.append(items.to_dict())
+        return jsonify(customers_response), 200
+
+
+    customers = customer_query.all()
+    customers_response = []
+    for customer in customers:
+        customers_response.append(customer.to_dict())
+    return jsonify(customers_response), 200
+
+@customers_bp.route("/<customer_id>", methods=["GET"])
+def read_one_customer(customer_id):
+    customer = validate_model(Customer, customer_id)
+    return customer.to_dict()
+
+@customers_bp.route("/<customer_id>", methods=["PUT"])
+def update_customer(customer_id):
+    customer = validate_model(Customer, customer_id)
+
+    request_body = request.get_json()
+    # customer = Customer.from_dict(request_body)
+    try:
+        customer.name = request_body["name"]
+        customer.postal_code = request_body["postal_code"]
+        customer.phone = request_body["phone"]
+    except KeyError as key_error:
+        abort(make_response({"details":f"Request body must include {key_error.args[0]}."}, 400))
+
+    db.session.commit()
+    customer_response = customer.to_dict()
+
+    return jsonify(customer_response),200
+
+@customers_bp.route("/<customer_id>", methods=["DELETE"])
+def delete_customer(customer_id):
+    customer = validate_model(Customer, customer_id)
+
+    customer_rentals = db.session.query(Rental).filter_by(customer_id=customer.id).all()
+
+    if customer_rentals:
+        for rental in customer_rentals:
+            db.session.delete(rental)
+        db.session.commit()
+
+    db.session.delete(customer)
+    db.session.commit()
+
+    customer_response = customer.to_dict()
+    return jsonify(customer_response),200
+
+## `GET /customers/<id>/rentals` GET /customers/<id>/rentals
+@customers_bp.route("/<id>/rentals", methods=["GET"])
+def read_all_customer_rentals(id):
+    customer = validate_model(Customer, id)
+    video_query = Rental.query.filter_by(customer_id=customer.id).join(Video)
+
+    sort_query = request.args.get("sort")
+    if sort_query:
+        if sort_query == "title":
+            video_query = video_query.order_by(Video.title.asc())  # Rental.video.title.asc()
+        else:
+            video_query = video_query.order_by(Video.id.asc()) 
+
+    count_query = request.args.get("count")  # check if count and page/ if only count, display all pages
+    page_num_query = request.args.get("page_num")
+
+    if validate_num_queries(count_query) and validate_num_queries(page_num_query):
+        # need to check if count_query and page_num wuery are valid nums
+
+        page = video_query.paginate(page=int(page_num_query), per_page=int(count_query), error_out=False)
+        video_query = video_query.all()
+
+        video_result = []
+
+        for items in page.items:
+            video_result.append(items.video.to_dict())
+        return jsonify(video_result), 200
+
+    if validate_num_queries(count_query) and not validate_num_queries(page_num_query):
+        page = video_query.paginate(per_page=int(count_query), error_out=False)
+        video_query = video_query.all()
+        video_result = []
+
+        for items in page.items:
+            video_result.append(items.video.to_dict())
+        return jsonify(video_result), 200
+
+    video_result = []
+    video_query = video_query.all()
+    for video in video_query:
+        video_result.append(video.video.to_dict())
+
+    return jsonify(video_result), 200
+
+@customers_bp.route("/<id>/history", methods=["GET"])
+def read_a_customers_all_rental_history(id):
+    customer = validate_model(Customer, id)
+    customer_rental = Rental.query.filter_by(customer_id=customer.id,check_out_status = False).join(Video).all()
+
+    customer_history_res =[]
+    for video in customer_rental:
+        customer_history_res.append(video.video.to_dict())
+    return jsonify(customer_history_res), 200
+
+

app/routes/rental_routes.py

@@ -0,0 +1,85 @@
+from flask import Blueprint, jsonify, abort, make_response, request 
+from app import db
+from app.models.rental import Rental
+from app.models.customer import Customer
+from app.models.video import Video
+from app.routes.routes_helper import validate_model
+
+rentals_bp = Blueprint("rentals_bp", __name__, url_prefix="/rentals")
+
+## `POST /rentals/check-out`
+@rentals_bp.route("/check-out", methods=["POST"])
+def create_rental():
+    request_body = request.get_json()
+
+    try:
+        customer = validate_model(Customer, request_body["customer_id"])
+        video = validate_model(Video, request_body["video_id"])
+
+        videos_checked_out = db.session.query(Rental).filter_by(video_id=video.id).all()  # look into count method
+        available_inventory = 0
+
+        if not videos_checked_out:
+            available_inventory = video.total_inventory
+        else:
+            available_inventory = video.total_inventory - len(videos_checked_out)
+
+        if available_inventory == 0:
+            abort(make_response({"message":f"Could not perform checkout"}, 400))
+
+        new_rental = Rental(customer_id=request_body["customer_id"],
+                video_id=request_body["video_id"]
+                )
+
+        customer.videos_checked_out_count += 1
+    except KeyError as key_error:
+        abort(make_response({"message":f"Could not perform checkout bc {key_error.args[0]}"}, 400))
+
+    db.session.add(new_rental)
+    db.session.add(customer)
+    db.session.commit()
+
+    rental_response = new_rental.to_dict()
+    rental_response["videos_checked_out_count"] = customer.videos_checked_out_count
+    available_inventory -= 1
+    rental_response["available_inventory"] = available_inventory
+
+    return jsonify(rental_response), 200
+
+
+#`POST /rentals/check-in`
+@rentals_bp.route("/check-in", methods=["POST"])
+def delete_and_update_one_rental():
+    request_body = request.get_json()
+
+    try:
+        customer = validate_model(Customer, request_body["customer_id"])
+        video = validate_model(Video, request_body["video_id"])
+
+        rental = db.session.query(Rental).filter_by(video_id=video.id, customer_id=customer.id).first() # if customer has more than two rentals
+        # checked_in_rental = validate_model(Rental, {"id": rental.id, "customer_id": rental.customer_id, "video_id": rental.video_id})
+
+        if not rental:
+            abort(make_response({"message": f"No outstanding rentals for customer {customer.id} and video {video.id}"}, 400))
+
+        if rental.check_out_status == False:
+            abort(make_response({"message":f"Could not perform checkout bc already checked out"}, 400))
+
+        videos_checked_out = db.session.query(Rental).filter_by(video_id=video.id).all()  # look into count method, refactor duplicate code
+        available_inventory = video.total_inventory - len(videos_checked_out)
+
+        customer.videos_checked_out_count -= 1
+        available_inventory += 1
+        rental.check_out_status = False
+
+    except KeyError as key_error:
+        abort(make_response({"message":f"Could not perform checkout bc {key_error.args[0]}"}, 400))
+
+    db.session.add(rental)
+    db.session.commit()
+
+    rental_response = rental.to_dict()
+    rental_response["videos_checked_out_count"] = customer.videos_checked_out_count
+    rental_response["available_inventory"] = available_inventory
+
+    return jsonify(rental_response), 200

app/routes/routes_helper.py

@@ -0,0 +1,22 @@
+from flask import abort, make_response
+
+def validate_model(cls, model_id):
+    try:
+        model_id = int(model_id)
+    except:
+        abort(make_response({"message":f"{cls.__name__} {model_id} invalid"}, 400))
+
+    model = cls.query.get(model_id)
+
+    if not model:
+        abort(make_response({"message":f"{cls.__name__} {model_id} was not found"}, 404))
+
+    return model
+
+    #  return True if its a valid number, return False it's not a number
+def validate_num_queries(query_param):
+    try:
+        query_int = int(query_param)
+    except:
+        return False
+    return True