From 6048115de142fecec574b2e9f94253f89420bcdc Mon Sep 17 00:00:00 2001 From: Joanna Dudley Date: Fri, 22 Apr 2022 13:57:15 -0400 Subject: [PATCH 01/11] Created Planet class and list of planets. --- app/routes.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/app/routes.py b/app/routes.py index 8e9dfe684..b4e3673c9 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,2 +1,15 @@ from flask import Blueprint +class Planets: + def __init__(self, id, name, description, has_moons): + self.id = id + self.name = name + self.desciption = description + self.has_moons = has_moons + +planets = [ + Planets(1, "Arrakis", "A desert planet, source of Spice.", True), + Planets(2, "Bela Tegeuse", "The fifth planet of Keuntsing.", False), + Planets(3, "Tupile", "Sanctuary planet for defeated houses of the Imperium.", True), + Planets(4, "Ix", "Supreme machine culture.", False) +] \ No newline at end of file From f93a6d1365384ad1c515f071b0d35c14b5f4de06 Mon Sep 17 00:00:00 2001 From: Joanna Dudley Date: Fri, 22 Apr 2022 14:08:46 -0400 Subject: [PATCH 02/11] Created get_all_planets endpoint. --- app/__init__.py | 3 +++ app/routes.py | 29 ++++++++++++++++++++++------- 2 files changed, 25 insertions(+), 7 deletions(-) diff --git a/app/__init__.py b/app/__init__.py index 70b4cabfe..ab9eee40e 100644 --- a/app/__init__.py +++ b/app/__init__.py @@ -4,4 +4,7 @@ def create_app(test_config=None): app = Flask(__name__) + from .routes import planets_bp + app.register_blueprint(planets_bp) + return app diff --git a/app/routes.py b/app/routes.py index b4e3673c9..1d97dde0b 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,6 +1,7 @@ -from flask import Blueprint +from crypt import methods +from flask import Blueprint, jsonify -class Planets: +class Planet: def __init__(self, id, name, description, has_moons): self.id = id self.name = name @@ -8,8 +9,22 @@ def __init__(self, id, name, description, has_moons): self.has_moons = has_moons planets = [ - Planets(1, "Arrakis", "A desert planet, source of Spice.", True), - Planets(2, "Bela Tegeuse", "The fifth planet of Keuntsing.", False), - Planets(3, "Tupile", "Sanctuary planet for defeated houses of the Imperium.", True), - Planets(4, "Ix", "Supreme machine culture.", False) -] \ No newline at end of file + Planet(1, "Arrakis", "A desert planet, source of Spice.", True), + Planet(2, "Bela Tegeuse", "The fifth planet of Keuntsing.", False), + Planet(3, "Tupile", "Sanctuary planet for defeated houses of the Imperium.", True), + Planet(4, "Ix", "Supreme machine culture.", False) +] + +planets_bp = Blueprint("Planets", __name__, url_prefix="/planets") + +@planets_bp.route("", methods=("GET",)) +def get_all_planets(): + all_planets = [ + dict( + id = planet.id, + name = planet.name, + description = planet.desciption, + has_moons = planet.has_moons + )for planet in planets + ] + return jsonify(all_planets) \ No newline at end of file From 2eed63818b8db0392ee4a68375971599e12df144 Mon Sep 17 00:00:00 2001 From: Shari Fedak <90287794+sharifedak12@users.noreply.github.com> Date: Mon, 25 Apr 2022 15:03:17 -0400 Subject: [PATCH 03/11] passed wave 2 --- app/routes.py | 37 ++++++++++++++++++++++++++++--------- 1 file changed, 28 insertions(+), 9 deletions(-) diff --git a/app/routes.py b/app/routes.py index 1d97dde0b..6b82bd26d 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,5 +1,4 @@ -from crypt import methods -from flask import Blueprint, jsonify +from flask import Blueprint, jsonify, abort, make_response class Planet: def __init__(self, id, name, description, has_moons): @@ -8,6 +7,13 @@ def __init__(self, id, name, description, has_moons): self.desciption = description self.has_moons = has_moons + def to_dict(self): + return dict( + id=self.id, + name=self.name, + description=self.desciption, + has_moons=self.has_moons) + planets = [ Planet(1, "Arrakis", "A desert planet, source of Spice.", True), Planet(2, "Bela Tegeuse", "The fifth planet of Keuntsing.", False), @@ -20,11 +26,24 @@ def __init__(self, id, name, description, has_moons): @planets_bp.route("", methods=("GET",)) def get_all_planets(): all_planets = [ - dict( - id = planet.id, - name = planet.name, - description = planet.desciption, - has_moons = planet.has_moons - )for planet in planets + planet.to_dict() + for planet in planets ] - return jsonify(all_planets) \ No newline at end of file + return jsonify(all_planets) + +@planets_bp.route("/", methods=("GET",)) +def handle_planet(id): + planet = validate_planet(id) + return jsonify(planet.to_dict()) + +def validate_planet(planet_id): + try: + planet_id = int(planet_id) + except ValueError: + abort(make_response(jsonify(dict(details=f"Planet {planet_id} is invalid!")),400)) + + for planet in planets: + if planet.id == planet_id: + return planet + + abort(make_response(jsonify(dict(details=f"Planet {planet_id} not found.")),404)) \ No newline at end of file From 5df62bd0be0ff8972fe8f2edab8aacf8afa8ecff Mon Sep 17 00:00:00 2001 From: Joanna Dudley Date: Fri, 29 Apr 2022 14:04:35 -0400 Subject: [PATCH 04/11] attempting to initialize database - getting import error --- app/__init__.py | 11 +++++++++++ app/routes.py | 15 ++------------- models/__init__.py | 0 models/planet.py | 14 ++++++++++++++ touch | 0 5 files changed, 27 insertions(+), 13 deletions(-) create mode 100644 models/__init__.py create mode 100644 models/planet.py create mode 100644 touch diff --git a/app/__init__.py b/app/__init__.py index ab9eee40e..aa4c56989 100644 --- a/app/__init__.py +++ b/app/__init__.py @@ -1,10 +1,21 @@ from flask import Flask +from flask_sqlalchemy import SQLAlchemy +from flask_migrate import Migrate +db = SQLAlchemy() +migrate = Migrate() def create_app(test_config=None): app = Flask(__name__) + app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False + app.config['SQLALCHEMY_DATABASE_URI'] ='postgresql+psycopg2://postgres:postgres@localhost:5432/solar_system_development' + + db.init_app(app) + migrate.init_app(app,db) + from .routes import planets_bp app.register_blueprint(planets_bp) + return app diff --git a/app/routes.py b/app/routes.py index 6b82bd26d..963bb627e 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,18 +1,7 @@ from flask import Blueprint, jsonify, abort, make_response +from app import db +from ..models.planet import Planet -class Planet: - def __init__(self, id, name, description, has_moons): - self.id = id - self.name = name - self.desciption = description - self.has_moons = has_moons - - def to_dict(self): - return dict( - id=self.id, - name=self.name, - description=self.desciption, - has_moons=self.has_moons) planets = [ Planet(1, "Arrakis", "A desert planet, source of Spice.", True), diff --git a/models/__init__.py b/models/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/models/planet.py b/models/planet.py new file mode 100644 index 000000000..9ac4735ce --- /dev/null +++ b/models/planet.py @@ -0,0 +1,14 @@ +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) + desciption = db.Column(db.String, nullable=False) + has_moons = db.Column(db.Boolean, nullable=False) + + def to_dict(self): + return dict( + id=self.id, + name=self.name, + description=self.desciption, + has_moons=self.has_moons) diff --git a/touch b/touch new file mode 100644 index 000000000..e69de29bb From 9465d47fac9cc56bf2e335bc43da602f1b4a8281 Mon Sep 17 00:00:00 2001 From: Joanna Dudley Date: Fri, 29 Apr 2022 14:21:06 -0400 Subject: [PATCH 05/11] Created Planet model, database configured successfully --- {models => app/models}/__init__.py | 0 {models => app/models}/planet.py | 0 app/routes.py | 54 +++++------ migrations/README | 1 + migrations/alembic.ini | 45 +++++++++ migrations/env.py | 96 +++++++++++++++++++ migrations/script.py.mako | 24 +++++ .../9557fc207db6_created_planet_model.py | 34 +++++++ 8 files changed, 227 insertions(+), 27 deletions(-) rename {models => app/models}/__init__.py (100%) rename {models => app/models}/planet.py (100%) create mode 100644 migrations/README create mode 100644 migrations/alembic.ini create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/9557fc207db6_created_planet_model.py diff --git a/models/__init__.py b/app/models/__init__.py similarity index 100% rename from models/__init__.py rename to app/models/__init__.py diff --git a/models/planet.py b/app/models/planet.py similarity index 100% rename from models/planet.py rename to app/models/planet.py diff --git a/app/routes.py b/app/routes.py index 963bb627e..f3f0a561b 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,38 +1,38 @@ from flask import Blueprint, jsonify, abort, make_response from app import db -from ..models.planet import Planet +from app.models.planet import Planet -planets = [ - Planet(1, "Arrakis", "A desert planet, source of Spice.", True), - Planet(2, "Bela Tegeuse", "The fifth planet of Keuntsing.", False), - Planet(3, "Tupile", "Sanctuary planet for defeated houses of the Imperium.", True), - Planet(4, "Ix", "Supreme machine culture.", False) -] +# planets = [ +# Planet(1, "Arrakis", "A desert planet, source of Spice.", True), +# Planet(2, "Bela Tegeuse", "The fifth planet of Keuntsing.", False), +# Planet(3, "Tupile", "Sanctuary planet for defeated houses of the Imperium.", True), +# Planet(4, "Ix", "Supreme machine culture.", False) +# ] planets_bp = Blueprint("Planets", __name__, url_prefix="/planets") -@planets_bp.route("", methods=("GET",)) -def get_all_planets(): - all_planets = [ - planet.to_dict() - for planet in planets - ] - return jsonify(all_planets) +# @planets_bp.route("", methods=("GET",)) +# def get_all_planets(): +# all_planets = [ +# planet.to_dict() +# for planet in planets +# ] +# return jsonify(all_planets) -@planets_bp.route("/", methods=("GET",)) -def handle_planet(id): - planet = validate_planet(id) - return jsonify(planet.to_dict()) +# @planets_bp.route("/", methods=("GET",)) +# def handle_planet(id): +# planet = validate_planet(id) +# return jsonify(planet.to_dict()) -def validate_planet(planet_id): - try: - planet_id = int(planet_id) - except ValueError: - abort(make_response(jsonify(dict(details=f"Planet {planet_id} is invalid!")),400)) +# def validate_planet(planet_id): +# try: +# planet_id = int(planet_id) +# except ValueError: +# abort(make_response(jsonify(dict(details=f"Planet {planet_id} is invalid!")),400)) - for planet in planets: - if planet.id == planet_id: - return planet +# for planet in planets: +# if planet.id == planet_id: +# return planet - abort(make_response(jsonify(dict(details=f"Planet {planet_id} not found.")),404)) \ No newline at end of file +# abort(make_response(jsonify(dict(details=f"Planet {planet_id} not found.")),404)) \ No newline at end of file diff --git a/migrations/README b/migrations/README new file mode 100644 index 000000000..98e4f9c44 --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/migrations/alembic.ini b/migrations/alembic.ini new file mode 100644 index 000000000..f8ed4801f --- /dev/null +++ b/migrations/alembic.ini @@ -0,0 +1,45 @@ +# A generic, single database configuration. + +[alembic] +# template used to generate migration files +# file_template = %%(rev)s_%%(slug)s + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARN +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARN +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 000000000..8b3fb3353 --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,96 @@ +from __future__ import with_statement + +import logging +from logging.config import fileConfig + +from sqlalchemy import engine_from_config +from sqlalchemy import pool +from flask import current_app + +from alembic import context + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +fileConfig(config.config_file_name) +logger = logging.getLogger('alembic.env') + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +config.set_main_option( + 'sqlalchemy.url', + str(current_app.extensions['migrate'].db.engine.url).replace('%', '%%')) +target_metadata = current_app.extensions['migrate'].db.metadata + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline(): + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, target_metadata=target_metadata, literal_binds=True + ) + + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online(): + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + + # this callback is used to prevent an auto-migration from being generated + # when there are no changes to the schema + # reference: http://alembic.zzzcomputing.com/en/latest/cookbook.html + def process_revision_directives(context, revision, directives): + if getattr(config.cmd_opts, 'autogenerate', False): + script = directives[0] + if script.upgrade_ops.is_empty(): + directives[:] = [] + logger.info('No changes in schema detected.') + + connectable = engine_from_config( + config.get_section(config.config_ini_section), + prefix='sqlalchemy.', + poolclass=pool.NullPool, + ) + + with connectable.connect() as connection: + context.configure( + connection=connection, + target_metadata=target_metadata, + process_revision_directives=process_revision_directives, + **current_app.extensions['migrate'].configure_args + ) + + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 000000000..2c0156303 --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,24 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision = ${repr(up_revision)} +down_revision = ${repr(down_revision)} +branch_labels = ${repr(branch_labels)} +depends_on = ${repr(depends_on)} + + +def upgrade(): + ${upgrades if upgrades else "pass"} + + +def downgrade(): + ${downgrades if downgrades else "pass"} diff --git a/migrations/versions/9557fc207db6_created_planet_model.py b/migrations/versions/9557fc207db6_created_planet_model.py new file mode 100644 index 000000000..8345d0d0e --- /dev/null +++ b/migrations/versions/9557fc207db6_created_planet_model.py @@ -0,0 +1,34 @@ +"""Created Planet model + +Revision ID: 9557fc207db6 +Revises: +Create Date: 2022-04-29 14:16:42.315886 + +""" +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision = '9557fc207db6' +down_revision = None +branch_labels = None +depends_on = None + + +def upgrade(): + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('planet', + sa.Column('id', sa.Integer(), autoincrement=True, nullable=False), + sa.Column('name', sa.String(), nullable=False), + sa.Column('desciption', sa.String(), nullable=False), + sa.Column('has_moons', sa.Boolean(), nullable=False), + sa.PrimaryKeyConstraint('id') + ) + # ### end Alembic commands ### + + +def downgrade(): + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('planet') + # ### end Alembic commands ### From b4304c3264125679aab4b7b9bbffb91853144e6a Mon Sep 17 00:00:00 2001 From: Joanna Dudley Date: Fri, 29 Apr 2022 14:30:22 -0400 Subject: [PATCH 06/11] Created get_all_planets and discover_planet endpoints --- app/routes.py | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/app/routes.py b/app/routes.py index f3f0a561b..304c1a5d3 100644 --- a/app/routes.py +++ b/app/routes.py @@ -1,4 +1,4 @@ -from flask import Blueprint, jsonify, abort, make_response +from flask import Blueprint, jsonify, abort, make_response, request from app import db from app.models.planet import Planet @@ -12,13 +12,28 @@ planets_bp = Blueprint("Planets", __name__, url_prefix="/planets") -# @planets_bp.route("", methods=("GET",)) -# def get_all_planets(): -# all_planets = [ -# planet.to_dict() -# for planet in planets -# ] -# return jsonify(all_planets) +@planets_bp.route("", methods=["GET"]) +def get_all_planets(): + planets = Planet.query.all() + all_planets = [ + planet.to_dict() + for planet in planets + ] + return jsonify(all_planets) + +@planets_bp.route("", methods=["POST"]) +def discover_planet(): + request_body = request.get_json() + new_planet = Planet(name=request_body["name"], + description=request_body["description"], + has_moons=request_body["has_moons"]) + + db.session.add(new_planet) + db.session.commit() + + return make_response(f"Planet {new_planet.name} successfully added to the Planets Database.", 201) + + # @planets_bp.route("/", methods=("GET",)) # def handle_planet(id): From 1c2964ed3a2ff40a4ec734b8139bf5fcb4018ab6 Mon Sep 17 00:00:00 2001 From: Shari Fedak <90287794+sharifedak12@users.noreply.github.com> Date: Fri, 29 Apr 2022 15:53:38 -0400 Subject: [PATCH 07/11] fixed typo in planet model, created new migration --- app/models/planet.py | 6 ++-- .../d67fb4735306_fixed_column_name.py | 30 +++++++++++++++++++ 2 files changed, 33 insertions(+), 3 deletions(-) create mode 100644 migrations/versions/d67fb4735306_fixed_column_name.py diff --git a/app/models/planet.py b/app/models/planet.py index 9ac4735ce..56db2daab 100644 --- a/app/models/planet.py +++ b/app/models/planet.py @@ -3,12 +3,12 @@ class Planet(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String, nullable=False) - desciption = db.Column(db.String, nullable=False) + description = db.Column(db.String, nullable=False) has_moons = db.Column(db.Boolean, nullable=False) def to_dict(self): return dict( id=self.id, name=self.name, - description=self.desciption, - has_moons=self.has_moons) + description=self.description, + has_moons=self.has_moons) \ No newline at end of file diff --git a/migrations/versions/d67fb4735306_fixed_column_name.py b/migrations/versions/d67fb4735306_fixed_column_name.py new file mode 100644 index 000000000..0ad9a6eb0 --- /dev/null +++ b/migrations/versions/d67fb4735306_fixed_column_name.py @@ -0,0 +1,30 @@ +"""fixed column name + +Revision ID: d67fb4735306 +Revises: 9557fc207db6 +Create Date: 2022-04-29 15:49:55.683954 + +""" +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision = 'd67fb4735306' +down_revision = '9557fc207db6' +branch_labels = None +depends_on = None + + +def upgrade(): + # ### commands auto generated by Alembic - please adjust! ### + op.add_column('planet', sa.Column('description', sa.String(), nullable=False)) + op.drop_column('planet', 'desciption') + # ### end Alembic commands ### + + +def downgrade(): + # ### commands auto generated by Alembic - please adjust! ### + op.add_column('planet', sa.Column('desciption', sa.VARCHAR(), autoincrement=False, nullable=False)) + op.drop_column('planet', 'description') + # ### end Alembic commands ### From 85106acf6c3c5c0e2b7d5b41502eccf3b1d6133c Mon Sep 17 00:00:00 2001 From: Shari Fedak <90287794+sharifedak12@users.noreply.github.com> Date: Tue, 3 May 2022 14:02:53 -0400 Subject: [PATCH 08/11] passed wave 4 --- app/routes.py | 63 ++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 50 insertions(+), 13 deletions(-) diff --git a/app/routes.py b/app/routes.py index 304c1a5d3..0a8e9d92e 100644 --- a/app/routes.py +++ b/app/routes.py @@ -33,21 +33,58 @@ def discover_planet(): return make_response(f"Planet {new_planet.name} successfully added to the Planets Database.", 201) +def get_planet_record_by_id(id): + try: + id = int(id) + except ValueError: + abort(make_response(jsonify(dict(details=f"Invalid id: {id}")),400)) + planet = Planet.query.get(id) + if planet: + return planet + else: + abort(make_response(jsonify(dict(details=f"Planet id: {id} not found")),404)) +@planets_bp.route("/", methods=["GET"]) +def read_one_planet(planet_id): + planet = get_planet_record_by_id(planet_id) + return jsonify(planet.to_dict()) -# @planets_bp.route("/", methods=("GET",)) -# def handle_planet(id): -# planet = validate_planet(id) -# return jsonify(planet.to_dict()) +@planets_bp.route("/", methods=["PUT"]) +def replace_planet_by_id(planet_id): + planet = get_planet_record_by_id(planet_id) -# def validate_planet(planet_id): -# try: -# planet_id = int(planet_id) -# except ValueError: -# abort(make_response(jsonify(dict(details=f"Planet {planet_id} is invalid!")),400)) + request_body = request.get_json() + + planet.name = request_body["name"] + planet.description = request_body["description"] + planet.has_mooons = request_body["has_moons"] + + db.session.commit() + + return make_response(jsonify(planet.to_dict())) + +@planets_bp.route("/", methods=["PATCH"]) +def update_planet_by_id(planet_id): + planet = get_planet_record_by_id(planet_id) -# for planet in planets: -# if planet.id == planet_id: -# return planet + request_body = request.get_json() + planet_keys = request_body.keys() -# abort(make_response(jsonify(dict(details=f"Planet {planet_id} not found.")),404)) \ No newline at end of file + if "name" in planet_keys: + planet.name = request_body["name"] + if "description" in planet_keys: + planet.description = request_body["description"] + if "has_moons" in planet_keys: + planet.has_moons = request_body["has_moons"] + + db.session.commit() + return make_response(jsonify(planet.to_dict())) + +@planets_bp.route("/", methods=["DELETE"]) +def delete_planet(planet_id): + planet = get_planet_record_by_id(planet_id) + + db.session.delete(planet) + db.session.commit() + + return make_response(jsonify(dict(details=f"Planet {planet.name} successfully deleted from the Planets Database."))) \ No newline at end of file From 683864c485b20450767efe1a9aaae395448a297a Mon Sep 17 00:00:00 2001 From: Joanna Dudley Date: Wed, 4 May 2022 15:08:39 -0400 Subject: [PATCH 09/11] Refactored routes.py and Planet class, added query param option to get_all_planets function. --- app/models/planet.py | 24 ++++++++++- app/routes.py | 99 ++++++++++++++++++++++++++------------------ 2 files changed, 81 insertions(+), 42 deletions(-) diff --git a/app/models/planet.py b/app/models/planet.py index 56db2daab..99e014899 100644 --- a/app/models/planet.py +++ b/app/models/planet.py @@ -6,9 +6,29 @@ class Planet(db.Model): description = db.Column(db.String, nullable=False) has_moons = db.Column(db.Boolean, nullable=False) - def to_dict(self): + # Instance methods: + + def self_to_dict(self): return dict( id=self.id, name=self.name, description=self.description, - has_moons=self.has_moons) \ No newline at end of file + has_moons=self.has_moons) + + def update_self(self, data_dict): + for key in data_dict.keys(): + if hasattr(self, key): + setattr(self, key, data_dict[key]) + else: + raise ValueError(key) + + + # Class methods + + @classmethod + def create_from_dict(cls, data_dict): + return cls( + name=data_dict["name"], + description = data_dict["description"], + has_moons = data_dict["has_moons"] + ) diff --git a/app/routes.py b/app/routes.py index 0a8e9d92e..e7dbdf84c 100644 --- a/app/routes.py +++ b/app/routes.py @@ -12,73 +12,92 @@ planets_bp = Blueprint("Planets", __name__, url_prefix="/planets") -@planets_bp.route("", methods=["GET"]) -def get_all_planets(): - planets = Planet.query.all() - all_planets = [ - planet.to_dict() - for planet in planets - ] - return jsonify(all_planets) +# Helper Functions: -@planets_bp.route("", methods=["POST"]) -def discover_planet(): - request_body = request.get_json() - new_planet = Planet(name=request_body["name"], - description=request_body["description"], - has_moons=request_body["has_moons"]) +def error_message(message, status_code): + abort(make_response(jsonify(dict(details=message)), status_code)) - db.session.add(new_planet) - db.session.commit() +def success_message(message, status_code=200): + return make_response(jsonify(dict(details=message)), status_code) - return make_response(f"Planet {new_planet.name} successfully added to the Planets Database.", 201) +def return_database_info(return_value): + return make_response(jsonify(return_value)) def get_planet_record_by_id(id): try: id = int(id) except ValueError: - abort(make_response(jsonify(dict(details=f"Invalid id: {id}")),400)) + error_message(f"Invalid id: {id}", 400) planet = Planet.query.get(id) if planet: return planet else: - abort(make_response(jsonify(dict(details=f"Planet id: {id} not found")),404)) + error_message(f"Planet id: {id} not found", 404) + +def discover_planet_safely(data_dict): + try: + return Planet.create_from_dict(data_dict) + except KeyError as err: + error_message(f"Missing key: {err}", 400) + + +def update_planet_safely(planet, data_dict): + try: + planet.update_self(data_dict) + except ValueError as err: + error_message(f"Invalid key: {err}. Planet not updated.", 400) + except KeyError as err: + error_message(f"Missing key: {err}. Planet not updated.", 400) + + + + +# Route Functions: + +@planets_bp.route("", methods=["GET"]) +def get_all_planets(): + moon_param = request.args.get("has_moons") + + if moon_param: + planets = Planet.query.filter_by(has_moons=moon_param) + else: + planets = Planet.query.all() + + all_planets = [ + planet.self_to_dict() + for planet in planets + ] + return return_database_info(all_planets) + @planets_bp.route("/", methods=["GET"]) def read_one_planet(planet_id): planet = get_planet_record_by_id(planet_id) - return jsonify(planet.to_dict()) + return return_database_info(planet.self_to_dict()) -@planets_bp.route("/", methods=["PUT"]) -def replace_planet_by_id(planet_id): - planet = get_planet_record_by_id(planet_id) +@planets_bp.route("", methods=["POST"]) +def discover_planet(): request_body = request.get_json() + new_planet = Planet.create_from_dict(request_body) - planet.name = request_body["name"] - planet.description = request_body["description"] - planet.has_mooons = request_body["has_moons"] - + db.session.add(new_planet) db.session.commit() - return make_response(jsonify(planet.to_dict())) + return success_message(f"Planet {new_planet.name} successfully added to the Planets Database.", 201) + -@planets_bp.route("/", methods=["PATCH"]) +@planets_bp.route("/", methods=["PUT", "PATCH"]) def update_planet_by_id(planet_id): planet = get_planet_record_by_id(planet_id) request_body = request.get_json() - planet_keys = request_body.keys() - - if "name" in planet_keys: - planet.name = request_body["name"] - if "description" in planet_keys: - planet.description = request_body["description"] - if "has_moons" in planet_keys: - planet.has_moons = request_body["has_moons"] + update_planet_safely(planet, request_body) + + db.session.commit() + + return return_database_info(planet.self_to_dict()) - db.session.commit() - return make_response(jsonify(planet.to_dict())) @planets_bp.route("/", methods=["DELETE"]) def delete_planet(planet_id): @@ -87,4 +106,4 @@ def delete_planet(planet_id): db.session.delete(planet) db.session.commit() - return make_response(jsonify(dict(details=f"Planet {planet.name} successfully deleted from the Planets Database."))) \ No newline at end of file + return success_message(f"Planet {planet.name} successfully deleted from the Planets Database.") \ No newline at end of file From a94109b133e2b737c6f7e882e528d7bd4e051afb Mon Sep 17 00:00:00 2001 From: Shari Fedak <90287794+sharifedak12@users.noreply.github.com> Date: Thu, 5 May 2022 15:27:37 -0400 Subject: [PATCH 10/11] Implemented ENV and wrote tests --- app/__init__.py | 21 +++++++++--- app/routes.py | 7 ++-- app/tests/__init__.py | 0 app/tests/conftest.py | 38 +++++++++++++++++++++ app/tests/test_routes.py | 73 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 132 insertions(+), 7 deletions(-) create mode 100644 app/tests/__init__.py create mode 100644 app/tests/conftest.py create mode 100644 app/tests/test_routes.py diff --git a/app/__init__.py b/app/__init__.py index aa4c56989..831d45bf9 100644 --- a/app/__init__.py +++ b/app/__init__.py @@ -1,21 +1,32 @@ 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): app = Flask(__name__) - app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False - app.config['SQLALCHEMY_DATABASE_URI'] ='postgresql+psycopg2://postgres:postgres@localhost:5432/solar_system_development' + if not test_config: + app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False + app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get( + "SQLALCHEMY_DATABASE_URI") + else: + app.config["TESTING"] = True + app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False + app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get( + "SQLALCHEMY_TEST_DATABASE_URI") db.init_app(app) - migrate.init_app(app,db) + migrate.init_app(app, db) + + from app.models.planet import Planet from .routes import planets_bp app.register_blueprint(planets_bp) - - return app + return app \ No newline at end of file diff --git a/app/routes.py b/app/routes.py index e7dbdf84c..50ae75cc8 100644 --- a/app/routes.py +++ b/app/routes.py @@ -37,8 +37,10 @@ def get_planet_record_by_id(id): def discover_planet_safely(data_dict): try: return Planet.create_from_dict(data_dict) + except ValueError as err: + error_message(f"Invalid key:{err}. Planet not added to database.", 400) except KeyError as err: - error_message(f"Missing key: {err}", 400) + error_message(f"Missing key: {err}. Planet not added to database.", 400) def update_planet_safely(planet, data_dict): @@ -106,4 +108,5 @@ def delete_planet(planet_id): db.session.delete(planet) db.session.commit() - return success_message(f"Planet {planet.name} successfully deleted from the Planets Database.") \ No newline at end of file + return success_message(f"Planet {planet.name} successfully deleted from the Planets Database.") + diff --git a/app/tests/__init__.py b/app/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/app/tests/conftest.py b/app/tests/conftest.py new file mode 100644 index 000000000..7c6e67962 --- /dev/null +++ b/app/tests/conftest.py @@ -0,0 +1,38 @@ +import pytest +from app import create_app +from app import db +from app.models.planet import Planet +from flask.signals import request_finished + + +@pytest.fixture +def app(): + app = create_app({"TESTING": True}) + + @request_finished.connect_via(app) + def expire_session(sender, response, **extra): + db.session.remove() + + with app.app_context(): + db.create_all() + yield app + + with app.app_context(): + db.drop_all() + + +@pytest.fixture +def client(app): + return app.test_client() + +@pytest.fixture +def sample_data_with_two_planets(app): + ocean_planet = Planet(name="Ocean Planet", + description="It's wet!", + has_moons=True) + jungle_planet = Planet(name="Jungle Planet", + description="Full of big cats. And trees!", + has_moons=False) + + db.session.add_all([ocean_planet, jungle_planet]) + db.session.commit() \ No newline at end of file diff --git a/app/tests/test_routes.py b/app/tests/test_routes.py new file mode 100644 index 000000000..f3b72db52 --- /dev/null +++ b/app/tests/test_routes.py @@ -0,0 +1,73 @@ +def test_get_all_returns_200_and_empty_array(client): + response = client.get("/planets") + response_body = response.get_json() + + assert response.status_code == 200 + assert response_body == [] + + +def test_get_one_planet(client, sample_data_with_two_planets): + # Act + response = client.get("/planets/1") + response_body = response.get_json() + + # Assert + assert response.status_code == 200 + assert response_body == {"id":1, + "name":"Ocean Planet", + "description":"It's wet!", + "has_moons":True} + +def test_get_one_planet_without_data_returns_404(client): + # Act + response = client.get("/planets/1") + response_body = response.get_json() + + # Assert + assert response.status_code == 404 + assert response_body == {"details":"Planet id: 1 not found"} + +def test_get_all_planets(client, sample_data_with_two_planets): + # Act + response = client.get("/planets") + response_body = response.get_json() + + # Assert + assert response.status_code == 200 + assert response_body == [{"id":1, + "name":"Ocean Planet", + "description":"It's wet!", + "has_moons":True}, + {"id":2, + "name":"Jungle Planet", + "description":"Full of big cats. And trees!", + "has_moons":False}] + +def test_create_a_planet(client): + # Act + response = client.post("/planets", json={ + "name":"Ice Planet", + "description":"Right next to Canada", + "has_moons":True + }) + response_body = response.get_json() + + # Assert + assert response.status_code == 201 + assert response_body == {"details":"Planet Ice Planet successfully added to the Planets Database."} + +def test_update_planet_patches_properly(client, sample_data_with_two_planets): + pre_patch_response = client.get("/planets/1") + pre_patch_response_body = pre_patch_response.get_json() + + response = client.patch("/planets/1", json={"description":"It's wet and full of fish."}) + response_body= response.get_json() + + assert response.status_code == 200 + assert response_body["description"] == "It's wet and full of fish." + assert response_body["name"] == pre_patch_response_body["name"] + assert response_body["has_moons"] == pre_patch_response_body["has_moons"] + assert response_body["id"] == pre_patch_response_body["id"] + assert response_body["description"] != pre_patch_response_body["description"] + + From f003f26718d7b43bfafbead6316aae14ca2c810e Mon Sep 17 00:00:00 2001 From: Shari Fedak <90287794+sharifedak12@users.noreply.github.com> Date: Thu, 5 May 2022 15:58:18 -0400 Subject: [PATCH 11/11] With advanced queries and error handling! --- app/models/planet.py | 12 +++++++++++- app/routes.py | 14 ++++++++------ 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/app/models/planet.py b/app/models/planet.py index 99e014899..f028c8c64 100644 --- a/app/models/planet.py +++ b/app/models/planet.py @@ -6,6 +6,11 @@ class Planet(db.Model): description = db.Column(db.String, nullable=False) has_moons = db.Column(db.Boolean, nullable=False) + required_attributes = { + "name":True, + "description":True, + "has_moons":True + } # Instance methods: def self_to_dict(self): @@ -27,8 +32,13 @@ def update_self(self, data_dict): @classmethod def create_from_dict(cls, data_dict): - return cls( + if data_dict.keys() == cls.required_attributes.keys(): + return cls( name=data_dict["name"], description = data_dict["description"], has_moons = data_dict["has_moons"] ) + else: + remaining_keys= set(data_dict.keys())-set(cls.required_attributes.keys()) + response=list(remaining_keys) + raise ValueError(response) \ No newline at end of file diff --git a/app/routes.py b/app/routes.py index 50ae75cc8..89a492322 100644 --- a/app/routes.py +++ b/app/routes.py @@ -38,18 +38,18 @@ def discover_planet_safely(data_dict): try: return Planet.create_from_dict(data_dict) except ValueError as err: - error_message(f"Invalid key:{err}. Planet not added to database.", 400) + error_message(f"Invalid key(s):{err}. Planet not added to database.", 400) except KeyError as err: - error_message(f"Missing key: {err}. Planet not added to database.", 400) + error_message(f"Missing key(s): {err}. Planet not added to database.", 400) def update_planet_safely(planet, data_dict): try: planet.update_self(data_dict) except ValueError as err: - error_message(f"Invalid key: {err}. Planet not updated.", 400) + error_message(f"Invalid key(s): {err}. Planet not updated.", 400) except KeyError as err: - error_message(f"Missing key: {err}. Planet not updated.", 400) + error_message(f"Missing key(s): {err}. Planet not updated.", 400) @@ -59,9 +59,11 @@ def update_planet_safely(planet, data_dict): @planets_bp.route("", methods=["GET"]) def get_all_planets(): moon_param = request.args.get("has_moons") - + description_param = request.args.get("description") if moon_param: planets = Planet.query.filter_by(has_moons=moon_param) + if description_param: + planets = Planet.query.filter(Planet.description.like('%'+description_param+'%')).all() else: planets = Planet.query.all() @@ -81,7 +83,7 @@ def read_one_planet(planet_id): @planets_bp.route("", methods=["POST"]) def discover_planet(): request_body = request.get_json() - new_planet = Planet.create_from_dict(request_body) + new_planet = discover_planet_safely(request_body) db.session.add(new_planet) db.session.commit()