Updated enumeration code

Author: rofrano

service/models.py

@@ -1,4 +1,4 @@
-# Copyright 2016, 2021 John Rofrano. All Rights Reserved.
+# Copyright 2016, 2024 John Rofrano. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the 'License');
 # you may not use this file except in compliance with the License.
@@ -26,11 +26,13 @@
 name (string) - the name of the pet
 category (string) - the category the pet belongs to (i.e., dog, cat)
 available (boolean) - True for pets that are available for adoption
+gender (enum) - the gender of the pet
+birthday (date) - the day the pet was born
 
 """
 import logging
-from enum import Enum
 from datetime import date
+from enum import Enum
 from flask_sqlalchemy import SQLAlchemy
 
 logger = logging.getLogger("flask.app")
@@ -70,6 +72,9 @@ class Pet(db.Model):
         db.Enum(Gender), nullable=False, server_default=(Gender.UNKNOWN.name)
     )
     birthday = db.Column(db.Date(), nullable=False, default=date.today())
+    # Database auditing fields
+    created_at = db.Column(db.DateTime, default=db.func.now(), nullable=False)
+    last_updated = db.Column(db.DateTime, default=db.func.now(), onupdate=db.func.now(), nullable=False)
 
     ##################################################
     # INSTANCE METHODS
@@ -78,9 +83,9 @@ class Pet(db.Model):
     def __repr__(self):
         return f"<Pet {self.name} id=[{self.id}]>"
 
-    def create(self):
+    def create(self) -> None:
         """
-        Creates a Pet to the database
+        Saves a Pet to the database
         """
         logger.info("Creating %s", self.name)
         # id must be none to generate next primary key
@@ -93,7 +98,7 @@ def create(self):
             logger.error("Error creating record: %s", self)
             raise DataValidationError(e) from e
 
-    def update(self):
+    def update(self) -> None:
         """
         Updates a Pet to the database
         """
@@ -107,8 +112,10 @@ def update(self):
             logger.error("Error updating record: %s", self)
             raise DataValidationError(e) from e
 
-    def delete(self):
-        """Removes a Pet from the data store"""
+    def delete(self) -> None:
+        """
+        Removes a Pet from the database
+        """
         logger.info("Deleting %s", self.name)
         try:
             db.session.delete(self)
@@ -126,7 +133,7 @@ def serialize(self) -> dict:
             "category": self.category,
             "available": self.available,
             "gender": self.gender.name,  # convert enum to string
-            "birthday": self.birthday.isoformat(),
+            "birthday": self.birthday.isoformat()
         }
 
     def deserialize(self, data: dict):
@@ -145,14 +152,13 @@ def deserialize(self, data: dict):
                     "Invalid type for boolean [available]: "
                     + str(type(data["available"]))
                 )
-            self.gender = getattr(Gender, data["gender"])  # create enum from string
+            # self.gender = getattr(Gender, data["gender"])  # create enum from string
+            self.gender = Gender[data["gender"].upper()]  # create enum from string
             self.birthday = date.fromisoformat(data["birthday"])
         except AttributeError as error:
             raise DataValidationError("Invalid attribute: " + error.args[0]) from error
         except KeyError as error:
-            raise DataValidationError(
-                "Invalid pet: missing " + error.args[0]
-            ) from error
+            raise DataValidationError("Invalid pet: missing " + error.args[0]) from error
         except TypeError as error:
             raise DataValidationError(
                 "Invalid pet: body of request contained bad or no data " + str(error)
@@ -222,6 +228,8 @@ def find_by_availability(cls, available: bool = True) -> list:
         :rtype: list
 
         """
+        if not isinstance(available, bool):
+            raise TypeError("Invalid availability, must be of type boolean")
         logger.info("Processing available query for %s ...", available)
         return cls.query.filter(cls.available == available)
 
@@ -236,5 +244,7 @@ def find_by_gender(cls, gender: Gender = Gender.UNKNOWN) -> list:
         :rtype: list
 
         """
+        if not isinstance(gender, Gender):
+            raise TypeError("Invalid gender, must be type Gender")
         logger.info("Processing gender query for %s ...", gender.name)
         return cls.query.filter(cls.gender == gender)

service/routes.py

@@ -21,7 +21,7 @@
 
 from flask import jsonify, request, url_for, abort
 from flask import current_app as app  # Import Flask application
-from service.models import Pet
+from service.models import Pet, Gender
 from service.common import status  # HTTP Status Codes
 
 
@@ -61,14 +61,29 @@ def list_pets():
 
     pets = []
 
-    # See if any query filters were passed in
+    # Parse any arguments from the query string
     category = request.args.get("category")
     name = request.args.get("name")
+    available = request.args.get("available")
+    gender = request.args.get("gender")
+
     if category:
+        app.logger.info("Find by category: %s", category)
         pets = Pet.find_by_category(category)
     elif name:
+        app.logger.info("Find by name: %s", name)
         pets = Pet.find_by_name(name)
+    elif available:
+        app.logger.info("Find by available: %s", available)
+        # create bool from string
+        available_value = available.lower() in ["true", "yes", "1"]
+        pets = Pet.find_by_availability(available_value)
+    elif gender:
+        app.logger.info("Find by gender: %s", gender)
+        # create enum from string
+        pets = Pet.find_by_gender(Gender[gender.upper()])
     else:
+        app.logger.info("Find all")
         pets = Pet.all()
 
     results = [pet.serialize() for pet in pets]
@@ -86,11 +101,12 @@ def get_pets(pet_id):
 
     This endpoint will return a Pet based on it's id
     """
-    app.logger.info("Request for pet with id: %s", pet_id)
+    app.logger.info("Request to Retrieve a pet with id [%s]", pet_id)
 
+    # Attempt to find the Pet and abort if not found
     pet = Pet.find(pet_id)
     if not pet:
-        error(status.HTTP_404_NOT_FOUND, f"Pet with id '{pet_id}' was not found.")
+        abort(status.HTTP_404_NOT_FOUND, f"Pet with id '{pet_id}' was not found.")
 
     app.logger.info("Returning pet: %s", pet.name)
     return jsonify(pet.serialize()), status.HTTP_200_OK
@@ -102,21 +118,25 @@ def get_pets(pet_id):
 @app.route("/pets", methods=["POST"])
 def create_pets():
     """
-    Creates a Pet
-
+    Create a Pet
     This endpoint will create a Pet based the data in the body that is posted
     """
-    app.logger.info("Request to create a pet")
+    app.logger.info("Request to Create a Pet...")
     check_content_type("application/json")
 
     pet = Pet()
-    pet.deserialize(request.get_json())
+    # Get the data from the request and deserialize it
+    data = request.get_json()
+    app.logger.info("Processing: %s", data)
+    pet.deserialize(data)
+
+    # Save the new Pet to the database
     pet.create()
-    message = pet.serialize()
-    location_url = url_for("get_pets", pet_id=pet.id, _external=True)
+    app.logger.info("Pet with new id [%s] saved!", pet.id)
 
-    app.logger.info("Pet with ID: %d created.", pet.id)
-    return jsonify(message), status.HTTP_201_CREATED, {"Location": location_url}
+    # Return the location of the new Pet
+    location_url = url_for("get_pets", pet_id=pet.id, _external=True)
+    return jsonify(pet.serialize()), status.HTTP_201_CREATED, {"Location": location_url}
 
 
 ######################################################################
@@ -129,15 +149,20 @@ def update_pets(pet_id):
 
     This endpoint will update a Pet based the body that is posted
     """
-    app.logger.info("Request to update pet with id: %d", pet_id)
+    app.logger.info("Request to Update a pet with id [%s]", pet_id)
     check_content_type("application/json")
 
+    # Attempt to find the Pet and abort if not found
     pet = Pet.find(pet_id)
     if not pet:
-        error(status.HTTP_404_NOT_FOUND, f"Pet with id: '{pet_id}' was not found.")
+        abort(status.HTTP_404_NOT_FOUND, f"Pet with id '{pet_id}' was not found.")
+
+    # Update the Pet with the new data
+    data = request.get_json()
+    app.logger.info("Processing: %s", data)
+    pet.deserialize(data)
 
-    pet.deserialize(request.get_json())
-    pet.id = pet_id
+    # Save the updates to the database
     pet.update()
 
     app.logger.info("Pet with ID: %d updated.", pet.id)
@@ -154,37 +179,36 @@ def delete_pets(pet_id):
 
     This endpoint will delete a Pet based the id specified in the path
     """
-    app.logger.info("Request to delete pet with id: %d", pet_id)
+    app.logger.info("Request to Delete a pet with id [%s]", pet_id)
 
+    # Delete the Pet if it exists
     pet = Pet.find(pet_id)
     if pet:
+        app.logger.info("Pet with ID: %d found.", pet.id)
         pet.delete()
 
     app.logger.info("Pet with ID: %d delete complete.", pet_id)
-    return "", status.HTTP_204_NO_CONTENT
+    return {}, status.HTTP_204_NO_CONTENT
 
 
 ######################################################################
 # PURCHASE A PET
 ######################################################################
 @app.route("/pets/<int:pet_id>/purchase", methods=["PUT"])
 def purchase_pets(pet_id):
-    """
-    Purchasing a Pet
-
-    This endpoint will purchase a pet makes it unavailable
-    """
+    """Purchasing a Pet makes it unavailable"""
     app.logger.info("Request to purchase pet with id: %d", pet_id)
 
+    # Attempt to find the Pet and abort if not found
     pet = Pet.find(pet_id)
     if not pet:
-        error(status.HTTP_404_NOT_FOUND, f"Pet with id '{pet_id}' was not found.")
+        abort(status.HTTP_404_NOT_FOUND, f"Pet with id '{pet_id}' was not found.")
 
     # you can only purchase pets that are available
     if not pet.available:
-        error(
+        abort(
             status.HTTP_409_CONFLICT,
-            f"Pet with ID: '{pet_id}' is not available.",
+            f"Pet with id '{pet_id}' is not available.",
         )
 
     # At this point you would execute code to purchase the pet
@@ -205,11 +229,11 @@ def purchase_pets(pet_id):
 ######################################################################
 # Checks the ContentType of a request
 ######################################################################
-def check_content_type(content_type):
+def check_content_type(content_type) -> None:
     """Checks that the media type is correct"""
     if "Content-Type" not in request.headers:
         app.logger.error("No Content-Type specified.")
-        error(
+        abort(
             status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
             f"Content-Type must be {content_type}",
         )
@@ -218,16 +242,7 @@ def check_content_type(content_type):
         return
 
     app.logger.error("Invalid Content-Type: %s", request.headers["Content-Type"])
-    error(
+    abort(
         status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
         f"Content-Type must be {content_type}",
     )
-
-
-######################################################################
-# Logs error messages before aborting
-######################################################################
-def error(status_code, reason):
-    """Logs the error and then aborts"""
-    app.logger.error(reason)
-    abort(status_code, reason)

tests/test_models.py

@@ -214,7 +214,7 @@ def test_deserialize_bad_gender(self):
         """It should not deserialize a bad gender attribute"""
         test_pet = PetFactory()
         data = test_pet.serialize()
-        data["gender"] = "male"  # wrong case
+        data["gender"] = "XXX"  # invalid gender
         pet = Pet()
         self.assertRaises(DataValidationError, pet.deserialize, data)