Spruce: Sarah and Kaitlyn

Procfile

@@ -1,2 +1 @@
 web: gunicorn 'app:create_app()'
-

app/__init__.py

@@ -8,6 +8,7 @@
 migrate = Migrate()
 load_dotenv()
 
+
 def create_app(test_config=None):
     app = Flask(__name__)
     app.url_map.strict_slashes = False
@@ -21,7 +22,6 @@ def create_app(test_config=None):
         app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
             "SQLALCHEMY_TEST_DATABASE_URI")
 
-
     # import models for Alembic Setup
     from app.models.customer import Customer
     from app.models.video import Video
@@ -31,6 +31,14 @@ def create_app(test_config=None):
     db.init_app(app)
     migrate.init_app(app, db)
 
-    #Register Blueprints Here
+    # Register Blueprints Here
+    from .video_routes import videos_bp
+    app.register_blueprint(videos_bp)
+
+    from .customer_routes import customers_bp
+    app.register_blueprint(customers_bp)
+
+    from .rental_routes import rentals_bp
+    app.register_blueprint(rentals_bp)
 
-    return app
+    return app

app/customer_routes.py

@@ -0,0 +1,117 @@
+from flask import Blueprint, jsonify, request
+from app import db
+from app.models.video import Video
+from app.models.customer import Customer
+from app.models.rental import Rental
+import datetime
+
+customers_bp = Blueprint("customers_bp", __name__, url_prefix="/customers")
+
+
+@customers_bp.route("", methods=["GET"])
+def get_customers():
+    customers = Customer.query.all()
+    for customer in customers:
+        if customer.deleted_at:
+            customers.remove(customer)
+    customer_response = [customer.customer_dict() for customer in customers]
+    return jsonify(customer_response), 200
+
+
+@customers_bp.route("/<customer_id>", methods=["GET"])
+def get_customers_by_id(customer_id):
+    if not customer_id.isnumeric():
+        return jsonify(None), 400
+
+    customer = Customer.query.get(customer_id)
+    if not customer:
+        response_body = {"message": f"Customer {customer_id} was not found"}
+        return jsonify(response_body), 404
+    if customer.deleted_at:
+        return jsonify(None), 404
+    response_body = customer.customer_dict()
+    return jsonify(response_body), 200
+
+
+@customers_bp.route("", methods=["POST"])
+def post_customer():
+    request_body = request.get_json()
+    if "name" not in request_body:
+        response_body = {"details": "Request body must include name."}
+        return jsonify(response_body), 400
+    elif "postal_code" not in request_body:
+        response_body = {"details": "Request body must include postal_code."}
+        return jsonify(response_body), 400
+    elif "phone" not in request_body:
+        response_body = {
+            "details": "Request body must include phone."}
+        return jsonify(response_body), 400
+
+    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()
+    response_body = new_customer.customer_dict()
+    return jsonify(response_body), 201
+
+
+@customers_bp.route("/<customer_id>", methods=["PUT"])
+def put_customer_by_id(customer_id):
+
+    customer = Customer.query.get(customer_id)
+    if not customer:
+        return jsonify({"message": f"Customer {customer_id} was not found"}), 404
+    if customer.deleted_at:
+        return jsonify(None), 404
+
+    request_body = request.get_json()
+    if (
+        "name" not in request_body or
+        "postal_code" not in request_body or
+        "phone" not in request_body
+    ):
+        return jsonify({"details": "Invalid data"}), 400
+
+    customer.name = request_body["name"]
+    customer.postal_code = request_body["postal_code"]
+    customer.phone = request_body["phone"]
+
+    db.session.commit()
+
+    response_body = customer.customer_dict()
+    return jsonify(response_body), 200
+
+
+@customers_bp.route("/<customer_id>", methods=["DELETE"])
+def delete_customer(customer_id):
+    customer = Customer.query.get(customer_id)
+    if not customer:
+        return jsonify({"message": f"Customer {customer_id} was not found"}), 404
+
+    customer.deleted_at = datetime.datetime.now()
+
+    db.session.commit()
+
+    response_body = customer.customer_dict()
+    return jsonify(response_body), 200
+
+
+@customers_bp.route("/<customer_id>/rentals", methods=["GET"])
+def rentals_by_id(customer_id):
+    customer = Customer.query.get(customer_id)
+    if not customer:
+        response_body = {"message": f"Customer {customer_id} was not found"}
+        return jsonify(response_body), 404
+    if customer.deleted_at:
+        return jsonify(None), 404
+    rental_response = [rental.id for rental in customer.rentals]
+    if not rental_response:
+        return jsonify([]), 200
+
+    response_body = [
+        Video.query.get(video).create_dict() for video in rental_response
+    ]
+    return jsonify(response_body), 200

app/models/customer.py

@@ -1,4 +1,24 @@
+from sqlalchemy.sql.functions import func
 from app import db
 
+
 class Customer(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    customer_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    name = db.Column(db.String)
+    postal_code = db.Column(db.String)
+    phone = db.Column(db.String)
+    register_at = db.Column(
+        db.DateTime(timezone=True), server_default=func.now()
+    )
+    videos_checked_out = db.Column(db.Integer, default=0)
+    deleted_at = db.Column(db.DateTime, nullable=True)
+    rentals = db.relationship("Rental", backref="customer")
+
+    def customer_dict(self):
+        return {
+            "id": self.customer_id,
+            "name": self.name,
+            "postal_code": self.postal_code,
+            "phone": self.phone,
+            "register_at": self.register_at.strftime("%a, %d %b %Y %X %z")
+        }

app/models/rental.py

@@ -1,4 +1,36 @@
 from app import db
+from sqlalchemy.sql.functions import func
+import datetime
+from app.models.video import Video
+from app.models.customer import Customer
+
 
 class Rental(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
+    # __tablename__ = "rentals"
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    video_id = db.Column(db.Integer, db.ForeignKey('video.id'), primary_key=True, nullable=False)
+    customer_id = db.Column(db.Integer, db.ForeignKey('customer.customer_id'), primary_key=True, nullable=False)
+    due_date = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow() + datetime.timedelta(days=7))
+
+    def rental_dict(self):
+        video = Video.query.get(self.video_id)
+        available_inventory = video.total_inventory - len(video.rentals)
+        customer = Customer.query.get(self.customer_id)
+
+        return {
+            "video_id": self.video_id,
+            "customer_id": self.customer_id,
+            "videos_checked_out_count": len(customer.rentals),
+            "available_inventory": available_inventory
+        }
+
+    # Using static method decorator. The method references Rental but doesn't
+    # depend on any instance or behavior of the Rental model, but adds functionality to this model. 
+    @staticmethod
+    def checkin_dict(customer, video):
+        return {
+            "video_id": video.id,
+            "customer_id": customer.customer_id,
+            "videos_checked_out_count": len(customer.rentals),
+            "available_inventory": video.total_inventory - len(video.rentals)
+        }

app/models/video.py

@@ -1,4 +1,40 @@
 from app import db
+from flask import request
+
 
 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.Date, nullable=False)
+    total_inventory = db.Column(db.Integer, nullable=False)
+    deleted_at = db.Column(db.DateTime, nullable=True)
+    rentals = db.relationship("Rental", backref="video")
+
+    def create_dict(self):
+        return {
+            "id": self.id,
+            "title": self.title,
+            "release_date": self.release_date,
+            "total_inventory": self.total_inventory
+        }
+
+    def update(self, form_data):
+        self.title = form_data["title"]
+        self.release_date = form_data["release_date"]
+        self.total_inventory = form_data["total_inventory"]
+
+        db.session.commit()
+
+    @classmethod
+    def from_json(cls):
+        request_body = request.get_json()
+
+        new_video = Video(
+            title=request_body["title"],
+            release_date=request_body["release_date"],
+            total_inventory=request_body["total_inventory"]
+        )
+        db.session.add(new_video)
+        db.session.commit()
+
+        return new_video

app/rental_routes.py

@@ -0,0 +1,79 @@
+from flask import Blueprint, jsonify, request
+from app import db
+from app.models.video import Video
+from app.models.customer import Customer
+from app.models.rental import Rental
+
+rentals_bp = Blueprint("rentals_bp", __name__, url_prefix="/rentals")
+
+
+@rentals_bp.route("/check-out", methods=["POST"])
+def check_out():
+    request_body = request.get_json()
+    if "customer_id" not in request_body:
+        response_body = {"details": "Request body must include customer_id."}
+        return jsonify(response_body), 400
+    elif "video_id" not in request_body:
+        response_body = {"details": "Request body must include video_id."}
+        return jsonify(response_body), 400
+
+    video_id = request_body["video_id"]
+    customer_id = request_body["customer_id"]
+    video = Video.query.get(video_id)
+    if not video:
+        return jsonify(None), 404
+    video_inventory = video.total_inventory - len(video.rentals)
+    if video_inventory == 0:
+        response_body = {"message": "Could not perform checkout"}
+        return jsonify(response_body), 400
+
+    customer = Customer.query.get(customer_id)
+    if not customer:
+        return jsonify(None), 404
+
+    new_rental = Rental(
+        video_id=request_body["video_id"],
+        customer_id=request_body["customer_id"]
+    )
+
+    db.session.add(new_rental)
+    customer.videos_checked_out = len(customer.rentals)
+    db.session.commit()
+    response_body = new_rental.rental_dict()
+    return jsonify(response_body), 200
+
+
+@rentals_bp.route("/check-in", methods=["POST"])
+def check_in():
+    # TODO: make a helper function(s) to make this check and query. Repeating logic from checkout endpoint. 
+    request_body = request.get_json()
+    if "customer_id" not in request_body:
+        response_body = {"details": "Request body must include customer_id."}
+        return jsonify(response_body), 400
+    elif "video_id" not in request_body:
+        response_body = {"details": "Request body must include video_id."}
+        return jsonify(response_body), 400
+
+    video_id = request_body["video_id"]
+    video = Video.query.get(video_id)
+    customer_id = request_body["customer_id"]
+    customer = Customer.query.get(customer_id)
+
+    # Separate checks beacuse they return different status codes. 
+    if not (video and customer):
+        response_body = {"message": f"No outstanding rentals for customer {customer_id} and video {video_id}"}
+        return jsonify(response_body), 404
+
+    if customer.videos_checked_out == 0:
+        response_body = {"message": f"No outstanding rentals for customer {customer_id} and video {video_id}"}
+        return jsonify(response_body), 400
+
+    # finding rental associated with specfic the custoemr_id and video_id and 
+    # deleting their rental record of the sepcified video.
+    Rental.query.filter_by(customer_id=customer_id, video_id=video_id).delete()
+    db.session.commit()
+    # creating checkin dictionary for the response body of a successful request.
+    # Updates the videos_checked_out_count and available inventory. 
+    customer.videos_checked_out = len(customer.rentals)
+    response_body = Rental.checkin_dict(customer, video)
+    return jsonify(response_body), 200