AC2-Ocelots:Catherine_Bandarchuk(co-worker: Yuan Du -Anna) - Solar_system_API

Procfile

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

app/__init__.py

@@ -1,7 +1,34 @@
 from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_migrate import Migrate
+from dotenv import load_dotenv
+import os
 
+db = SQLAlchemy()
+migrate = Migrate()
+load_dotenv()
 
-def create_app(test_config=None):
+def create_app(test_config = None):
     app = Flask(__name__)
+    app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+
+    if test_config:
+        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("SQLALCHEMY_TEST_DATABASE_URI")
+        app.config["Testing"] = True
+    else:
+        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("SQLALCHEMY_DATABASE_URI")
+
+    from app.models.planet import Planet
 
-    return app
+    db.init_app(app)
+    migrate.init_app(app, db)
+
+    from app.models.planet import Planet
+    from app.models.moon import Moon
+
+    from .routes.planet_routes import planets_bp
+    app.register_blueprint(planets_bp)
+
+    from .routes.moon_routes import moons_bp
+    app.register_blueprint(moons_bp)
+    return app

app/models/moon.py

@@ -0,0 +1,24 @@
+from app import db
+
+class Moon(db.Model):
+    id = db.Column(db.Integer, primary_key = True, autoincrement = True)
+    name = db.Column(db.String, nullable = False)
+    size = db.Column(db.Float, nullable = False)
+    description = db.Column(db.String, nullable = False)
+    planet_id = db.Column(db.Integer, db.ForeignKey("planet.id"))
+    planet = db.relationship("Planet", back_populates="moons")
+
+    def to_dict(self):
+        moon_as_dict = {}
+        moon_as_dict["id"] = self.id
+        moon_as_dict["name"] = self.name
+        moon_as_dict["size"] = self.size
+        moon_as_dict["description"] = self.description
+        return moon_as_dict
+
+    @classmethod
+    def from_dict(cls,moon_data):
+        new_moon = Moon(name=moon_data["name"],
+                        size=float(moon_data["size"]),
+                        description=moon_data["description"])
+        return new_moon

app/models/planet.py

@@ -0,0 +1,28 @@
+from app import db
+
+class Planet(db.Model):
+    id = db.Column(db.Integer, primary_key = True, autoincrement = True)
+    name = db.Column(db.String, nullable = False)
+    length_of_year = db.Column(db.Integer, nullable = False)   
+    description = db.Column(db.String, nullable = False)
+    moons = db.relationship("Moon", back_populates="planet")
+
+    def to_dict(self):
+        planet_as_dict = {}
+        planet_as_dict["id"] = self.id
+        planet_as_dict["name"] = self.name
+        planet_as_dict["length_of_year"] = self.length_of_year
+        planet_as_dict["description"] = self.description
+
+        moon_names = []
+        for moon in self.moons:
+            moon_names.append(moon.name)
+        planet_as_dict["moons"] = moon_names
+        return planet_as_dict
+
+    @classmethod
+    def from_dict(cls,planet_data):
+        new_planet = Planet(name=planet_data["name"],
+                        length_of_year=planet_data["length_of_year"],
+                        description=planet_data["description"])
+        return new_planet

app/routes/moon_routes.py

@@ -0,0 +1,69 @@
+from app import db
+from app.models.moon import Moon
+from app.models.planet import Planet
+from flask import Blueprint, jsonify, abort, make_response, request
+from .validate_routes import validate_model, validate_moon_user_input, validate_planet_user_input
+
+moons_bp = Blueprint("moons_bp", __name__, url_prefix = "/moons")
+
+# Get all moons info 
+# /moons
+# Return JSON list
+@moons_bp.route("", methods = ["GET"])
+def get_all_moons_query():
+    moon_query = Moon.query
+    # Filtering by moon name (return all records which name contains planet_name_query)
+    moon_name_query = request.args.get("name")
+
+    if moon_name_query:
+        moon_query = moon_query.filter(Moon.name.ilike(f"%{moon_name_query}%"))
+
+    # Sorting by moon name
+    sort_by_name_query = request.args.get("sort_by_name")
+
+    if sort_by_name_query == "desc":
+        moon_query = moon_query.order_by(Moon.name.desc()).all()
+    elif sort_by_name_query == "asc":
+        moon_query = moon_query.order_by(Moon.name).all() 
+
+    # Sorting by moon size
+    moon_sort_size_query = request.args.get("sort_by_size")
+
+    if moon_sort_size_query == "desc":
+        moon_query = moon_query.order_by(Moon.size.desc()).all()
+    elif sort_by_name_query == "asc":
+        moon_query = moon_query.order_by(Moon.size).all()
+
+    # Build response
+    moon_response = []
+    for moon in moon_query:
+        moon_response.append(moon.to_dict())
+
+    return jsonify(moon_response), 200
+
+# Read one moon
+# Return one moon info in JSON format    
+@moons_bp.route("/<moon_id>",methods=["GET"] )
+def get_one_moon(moon_id):
+    moon = validate_model(Moon, moon_id)
+    return moon.to_dict()
+
+# Create one moon
+@moons_bp.route("", methods = ["POST"])
+def create_moon():
+    moon_value = validate_moon_user_input(request.get_json())
+    new_moon = Moon.from_dict(moon_value)
+
+    db.session.add(new_moon)
+    db.session.commit()
+    return make_response(jsonify(f"Moon {new_moon.name} successfully created"), 201)    
+
+# Delete moon by id
+@moons_bp.route("/<moon_id>",methods=["DELETE"])
+def delete_moon(moon_id):
+    moon = validate_model(Moon, moon_id)
+
+    db.session.delete(moon)
+    db.session.commit()
+
+    return make_response(jsonify(f"Moon {moon.id} successfully deleted"), 200)

app/routes/planet_routes.py

@@ -0,0 +1,150 @@
+from app import db
+from app.models.planet import Planet
+from app.models.moon import Moon
+from .validate_routes import validate_model, validate_moon_user_input, validate_planet_user_input
+from flask import Blueprint, jsonify, abort, make_response, request
+
+planets_bp = Blueprint("planets_bp", __name__, url_prefix = "/planets")
+
+# Creating new planet
+@planets_bp.route("", methods = ["POST"])
+def create_planet():
+    planet_value = validate_planet_user_input(request.get_json())
+    new_planet = Planet.from_dict(planet_value)
+
+    db.session.add(new_planet)
+    db.session.commit()
+
+    return make_response(jsonify(f"Planet {new_planet.name} successfully created"), 201)    
+
+# Get all planets info
+# Return JSON list
+@planets_bp.route("", methods = ["GET"])
+def get_all_planets_query():
+    planet_query = Planet.query
+
+    # Filtering by name (return all records which name contains planet_name_query)
+    planet_name_query = request.args.get("name")
+
+    if planet_name_query:
+        planet_query = planet_query.filter(Planet.name.ilike(f"%{planet_name_query}%"))
+
+    # Sort
+    sort_query = request.args.get("sort")
+
+    if sort_query == "name":
+        planet_query = planet_query.order_by(Planet.name).all()
+
+    if sort_query == "length_of_year":
+        planet_query = planet_query.order_by(Planet.length_of_year).all() 
+
+    planet_response = []
+    for planet in planet_query:
+        planet_response.append(planet.to_dict())
+
+    return jsonify(planet_response), 200
+
+# Read one planet 
+# Return one planet info in JSON format    
+@planets_bp.route("/<planet_id>",methods=["GET"] )
+def get_one_planet(planet_id):
+    planet = validate_model(Planet, planet_id)
+    return planet.to_dict()
+
+# Update one planet
+@planets_bp.route("/<planet_id>",methods=["PUT"] )
+def update_planet(planet_id):
+    planet = validate_model(Planet, planet_id)
+    request_body = validate_planet_user_input(request.get_json())
+
+    planet.name = request_body["name"]
+    planet.length_of_year = request_body["length_of_year"]
+    planet.description = request_body["description"]
+
+    db.session.commit()
+    message = f"Planet {planet_id} successfully updated"
+    return make_response(jsonify(message), 200)   
+
+# Delete one planet and all the moons dependent of the planet
+@planets_bp.route("/<planet_id>",methods=["DELETE"])
+def delete_planet(planet_id):
+    planet = validate_model(Planet, planet_id)
+
+    if len(planet.moons)>0:
+        i = 0
+        while i < len(planet.moons):
+            moon_id = planet.moons[i].id
+            moon = validate_model(Moon, moon_id)
+            db.session.delete(moon)
+            db.session.commit()
+            i += 1
+
+    db.session.delete(planet)
+    db.session.commit()
+
+    return make_response(jsonify(f"Planet {planet.id} successfully deleted"), 200)
+
+# Add moon info to the planet using planet id 
+@planets_bp.route("/<planet_id>/moons", methods=["POST"])
+def add_new_moon_to_planet(planet_id):
+    planet = validate_model(Planet, planet_id)
+    moon_value = validate_moon_user_input(request.get_json())
+
+    moon = Moon.from_dict(moon_value)
+    moon.planet_id = planet.id  
+
+    db.session.add(moon)
+    db.session.commit()
+
+    message = f"Moon {moon.name} added to the planet {planet.name}."
+    return make_response(jsonify(message), 201)
+
+# Get all moons info for chosen planet (by planet id)
+@planets_bp.route("/<planet_id>/moons", methods=["GET"])
+def get_all_moons_for_planet(planet_id):
+    planet = validate_model(Planet, planet_id)
+
+    moons_response = []
+    for moon in planet.moons:
+        moons_response.append(moon.to_dict())
+
+    return jsonify(moons_response)
+
+# Get moon by id 
+# Return one moon info in JSON format    
+@planets_bp.route("/<planet_id>/moons/<moon_id>",methods=["GET"] )
+def get_one_moon_of_planet(planet_id, moon_id):
+    planet = validate_model(Planet, planet_id)   
+    moon = validate_model(Moon, moon_id)
+    return moon.to_dict()
+
+# Update moon info (by moon_id) of the planet using planet_id
+@planets_bp.route("/<planet_id>/moons/<moon_id>", methods=["POST"])
+def update_moon_of_planet(planet_id, moon_id):
+
+    planet = validate_model(Planet, planet_id)
+    moon = validate_model(Moon, moon_id)
+
+    request_body = validate_moon_user_input(request.get_json())
+
+    moon.name = request_body["name"]
+    moon.size = request_body["size"]
+    moon.description = request_body["description"]
+
+    db.session.commit()
+
+    message = f"Moon {moon.id} of the planet {planet.name} successfully updated."
+    return make_response(jsonify(message), 201)
+
+# Delete moon of the specific planet (using planet_id and moon_id)
+@planets_bp.route("/<planet_id>/moons/<moon_id>", methods=["DELETE"])
+def delete_moon_of_planet(planet_id, moon_id):
+
+    planet = validate_model(Planet, planet_id)
+    moon = validate_model(Moon, moon_id)
+
+    db.session.delete(moon)
+    db.session.commit()
+
+    message = f"Moon {moon.id} of the planet {planet.name} successfully deleted."
+    return make_response(jsonify(message), 201)

app/routes/validate_routes.py

@@ -0,0 +1,56 @@
+from app import db
+from app.models.planet import Planet
+from app.models.moon import Moon
+from flask import Blueprint, jsonify, abort, make_response, request
+
+# Validating the id of the instance: id needs to be int and exists the instance with the id.
+# Returning the valid Class instance if valid id
+# Work for Planet and Moon classes
+def validate_model(cls, model_id):
+    try:
+        model_id = int(model_id)
+    except:
+        abort(make_response(jsonify(f"{cls.__name__} {model_id} invalid"), 400))
+
+    class_obj = cls.query.get(model_id)
+
+    if not class_obj:
+        abort(make_response(jsonify(f"{cls.__name__} {model_id} not found"), 404))
+
+    return class_obj
+
+# Validating the user input to create or update the table planet
+# Returning the valid JSON if valid input
+def validate_planet_user_input(planet_value):
+
+    if "name" not in planet_value \
+        or not isinstance(planet_value["name"], str) \
+        or planet_value["name"] == "" \
+        or "length_of_year" not in planet_value \
+        or not isinstance(planet_value["length_of_year"], int) \
+        or planet_value["length_of_year"] <=0 \
+        or "description" not in planet_value \
+        or not isinstance(planet_value["description"], str) \
+        or planet_value["description"] == "":
+
+            return abort(make_response(jsonify("Invalid request"), 400))  
+
+    return planet_value
+
+# Validating the user input to create or update the table moon
+# Returning the valid JSON if valid input
+def validate_moon_user_input(moon_value):
+
+    if "name" not in moon_value \
+        or not isinstance(moon_value["name"], str) \
+        or moon_value["name"] == "" \
+        or "size" not in moon_value \
+        or not (isinstance(moon_value["size"], float) or isinstance(moon_value["size"], int)) \
+        or moon_value["size"] <=0 \
+        or "description" not in moon_value \
+        or not isinstance(moon_value["description"], str) \
+        or moon_value["description"] == "":
+
+            return abort(make_response(jsonify("Invalid request"), 400))  
+
+    return moon_value

migrations/README

@@ -0,0 +1 @@
+Single-database configuration for Flask.