def delete_all_movies(payload):
try:
db_drop_and_create_all()
return jsonify({"success": True, "deleted": "All Movies"})
except Exception:
abort(422)
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
setup_db(self.app)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
db_drop_and_create_all()
def setUp(self):
self.app = create_app()
self.client = self.app.test_client
self.database_path = os.environ.get(
'DATABASE_URL', "postgres://{}:{}@{}/{}".format(
database_credentials["username"],
database_credentials["password"], database_credentials["port"],
database_credentials["development_database"]))
setup_db(self.app, self.database_path)
db_drop_and_create_all()
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
# create all tables
self.db.create_all()
import json
from flask_cors import CORS
from database.models import db_drop_and_create_all, setup_db, Drink
from auth.auth import AuthError, requires_auth
from werkzeug.datastructures import ImmutableMultiDict
app = Flask(__name__)
setup_db(app)
CORS(app)
# '''
# @TODO uncomment the following line to initialize the datbase
# !! NOTE THIS WILL DROP ALL RECORDS AND START YOUR DB FROM SCRATCH
# !! NOTE THIS MUST BE UNCOMMENTED ON FIRST RUN
# '''
db_drop_and_create_all()
@app.route('/drinks')
def get_drinks():
drink_selection = Drink.query.all()
all_drinks = [drink.short() for drink in drink_selection]
if not all_drinks:
abort(404)
return jsonify({
'success': True,
'drinks': all_drinks
}), 200
def create_app(test_config=None):
app = Flask(__name__)
setup_db(app)
CORS(app)
# DROP ALL RECORDS AND START YOUR DB FROM SCRATCH
db_drop_and_create_all()
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Headers',
'Content-Type, Authorization, true')
response.headers.add('Access-Control-Allow-Methods',
'GET, PATCH, POST, DELETE, OPTIONS')
return response
@app.route('/')
def hi():
return jsonify({
'success': True,
'message': 'Welcome to API'
})
@app.route('/actor', methods=['GET'])
@requires_auth('get:actor')
def get_all_actors(jwt):
data = Actor.query.all()
actor = list(map(Actor.get_actor, data))
if actor is None or len(actor) == 0:
abort(404)
return jsonify({
'success': True,
'actor': actor
})
@app.route('/actor', methods=['POST'])
@requires_auth('post:actor')
def create_actor(jwt):
body = request.get_json()
if body is None:
abort(404)
name = body.get('name', None)
age = body.get('age', None)
gender = body.get('gender', None)
try:
new_actor = Actor(name=name, age=age, gender=gender)
new_actor.insert()
return jsonify({
'success': True,
'actors': [new_actor.get_actor()]
})
except Exception:
abort(404)
@app.route('/actor/<int:actor_id>', methods=['PATCH'])
@requires_auth('patch:actor')
def update_one_actor(jwt, actor_id):
actor = Actor.query.filter(Actor.id == actor_id).one_or_none()
if actor is None:
abort(404)
body = request.get_json()
if body is None:
abort(404)
updated_name = body.get('name', None)
updated_age = body.get('age', None)
updated_gender = body.get('gender', None)
if updated_name is not None:
actor.name = updated_name
if updated_age is not None:
actor.age = updated_age
if updated_gender is not None:
actor.gender = updated_gender
try:
actor.update()
return jsonify({
'success': True,
'actor': [actor.get_actor()]
})
except Exception:
abort(422)
@app.route('/actor/<actor_id>', methods=['DELETE'])
@requires_auth('delete:actor')
def drop_one_actor(jwt, actor_id):
selected_actor = Actor.query.filter(Actor.id == actor_id).one_or_none()
if selected_actor is None:
abort(404)
try:
selected_actor.delete()
return jsonify({
"success": True,
"deleted": actor_id
})
except Exception:
abort(422)
@app.route('/movie', methods=['GET'])
@requires_auth('get:movie')
def get_all_movie(jwt):
data = Movie.query.all()
movie = list(map(Movie.get_movie, data))
if movie is None or len(movie) == 0:
abort(404)
return jsonify({
'success': True,
'movie': movie
})
@app.route('/movie', methods=['POST'])
@requires_auth('post:movie')
def create_new_movie(jwt):
body = request.get_json()
if 'title' not in body:
abort(404)
title = body.get('title', None)
release_date = body.get('release_date', None)
try:
new_movie = Movie(title=title, release_date=release_date)
new_movie.insert()
return jsonify({
'success': True,
'movie': [new_movie.get_movie()]
})
except Exception:
abort(422)
@app.route('/movie/<int:movie_id>', methods=['PATCH'])
@requires_auth('patch:movie')
def update_movie(jwt, movie_id):
movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
if movie is None:
abort(404)
body = request.get_json()
if body is None:
abort(404)
updated_title = body.get('title', None)
updated_release_date = body.get('release_date', None)
if updated_title is not None:
movie.title = updated_title
if updated_release_date is not None:
movie.release_date = updated_release_date
try:
movie.update()
return jsonify({
'success': True,
'movie': movie.get_movie()
})
except Exception:
abort(422)
@app.route('/movie/<movie_id>', methods=['DELETE'])
@requires_auth('delete:movie')
def drop_one_movie(jwt, movie_id):
selected_movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
if selected_movie is None:
abort(404)
try:
selected_movie.delete()
return jsonify({
"success": True,
"deleted": movie_id
})
except Exception:
abort(422)
@app.route('/show')
def get_all_show():
data = Show.query.all()
show = list(map(Show.get_show, data))
if show is None or len(show) == 0:
abort(404)
return jsonify({
'success': True,
'show': show
})
@app.route('/show', methods=['POST'])
def create_new_show():
body = request.get_json()
if body is None:
abort(404)
actor_id = body.get('actor_id', None)
movie_id = body.get('movie_id', None)
try:
new_show = Show(actor_id=actor_id, movie_id=movie_id)
new_show.insert()
return jsonify({
'success': True,
'new show': [new_show.get_show()]
})
except Exception:
abort(422)
@app.errorhandler(404)
def not_found(error):
return jsonify({
"success": False,
"error": 404,
"message": "resource not found"
}), 404
@app.errorhandler(400)
def bad_request(error):
return jsonify({
"success": False,
"error": 400,
"message": "bad request"
}), 400
@app.errorhandler(405)
def not_allowed(error):
return jsonify({
"success": False,
"error": 405,
"message": "method not allowed"
}), 405
@app.errorhandler(422)
def unprocessable(error):
return jsonify({
"success": False,
"error": 422,
"message": "unprocessable"
}), 422
@app.errorhandler(AuthError)
def auth_error(error):
return jsonify({
"success": False,
"error": error.status_code,
"code": error.error['code'],
"message": error.error['description']
}), error.status_code
return app
def create_app():
app = Flask(__name__, static_url_path="", template_folder=STATIC_DIRECTORY, static_folder=STATIC_DIRECTORY)
setup_db(app)
# Use this to re-initialize database:
db_drop_and_create_all()
@app.errorhandler(404)
def static_handler(e):
try:
render = render_template("index.html")
except TemplateNotFound as exception:
return e
return render, 200
@app.route("/api/todo", methods=["GET"])
def get_all_todo():
todo_list = [todo.dictionary() for todo in TodoItem.query.all()]
return jsonify(todo_list), 200
@app.route("/api/todo", methods=["POST"])
def add_todo():
description = request.json.get("description", None)
if not description:
raise BadRequest("Required body parameter \"description\" not found.")
todo = TodoItem(description=description, done=False)
todo.insert()
return jsonify(todo.dictionary()), 201
@app.route("/api/todo", methods=["PUT"])
def update_todo():
todo_id = request.json.get("id", None)
if not todo_id:
raise BadRequest("Required body parameter \"id\" not found.")
description = request.json.get("description", None)
done = request.json.get("done", None)
todo = TodoItem.get(todo_id)
todo.description = description if description else todo.description
todo.done = done
todo.update()
return jsonify(todo.dictionary()), 200
@app.route("/api/todo", methods=["DELETE"])
def delete_todo():
todo_id = request.args.get("id", None)
if not todo_id:
raise BadRequest("Required query parameter \"id\" not found.")
todo = TodoItem.get(todo_id)
todo.delete()
return jsonify({}), 200
@app.errorhandler(InternalServerError)
def server_error(error):
return jsonify(code="SERVER_ERROR", message="An internal server error occurred."), error.code
@app.errorhandler(BadRequest)
def bad_request_error(error):
return jsonify(code="BAD_REQUEST", message=error.description), error.code
return app
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__)
CORS(app, resources={r"/api/*": {"origins": "*"}})
setup_db(app)
db_drop_and_create_all()
# CORS headers
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Headers',
'Content-Type, Authorization')
response.headers.add('Access-Control-Allow-Methods',
'GET, PATCH, POST, DELETE, OPTIONS')
return response
@app.route('/')
def index():
return f'hello capstone!'
# Retrive All Shows
@app.route('/shows')
def retrive_all_shows():
data = Show.query.all()
shows = list(map(Show.get_show, data))
if shows is None or len(shows) == 0:
abort(404)
return jsonify({'success': True, 'shows': shows})
# Add Shows
@app.route('/shows', methods=['POST'])
def add_new_show():
body = request.get_json()
if body is None:
abort(404)
actor_id = body.get('actor_id', None)
movie_id = body.get('movie_id', None)
try:
new_show = Show(actor_id=actor_id, movie_id=movie_id)
new_show.insert()
return jsonify({
'success': True,
'new show': [new_show.get_show()]
})
except Exception:
abort(422)
# Actors
# Retrive All Actors.
@app.route('/actors')
@requires_auth('get:actors')
def retrive_actors(payload):
actors = Actor.query.all()
if not actors:
abort(404)
formatActors = [actor.format() for actor in actors]
return jsonify({'success': True, 'Actors': formatActors})
# Add Actors.
@app.route('/actors', methods=['POST'])
@requires_auth('post:actors')
def add_actors(payload):
body = request.get_json()
if body is None:
abort(404)
name = body.get('name', None)
age = body.get('age', None)
gender = body.get('gender', None)
try:
new_actor = Actor(name=name, age=age, gender=gender)
new_actor.insert()
return jsonify({
'success': True,
'actors': [new_actor.get_actor()]
})
except Exception:
abort(422)
# Retrive Actors.
@app.route('/actors/<int:actor_id>/movies')
def retrive_movies_of_an_actor(actor_id):
data = Show.query.filter(Show.actor_id == actor_id).all()
data = db.session.execute('''select movie_id from shows where
actor_id=''' + str(actor_id)).fetchall()
for d in data:
movies = Movie.query.get(d.movie_id)
print(movies)
if movies is None or len(movies) == 0:
abort(404)
return jsonify({'success': True, 'movies': movies})
# Actors
# Delete an Actor.
@app.route('/actors/<int:actor_id>', methods=['DELETE'])
@requires_auth(permission='delete:actors')
def delete_actor_by_id(payload, actor_id):
try:
actor = Actor.query.filter(Actor.id == actor_id).one_or_none()
if actor is None:
abort(404)
actor.delete()
return jsonify({'success': True, 'delete': actor_id}), 200
except:
abort(422)
# Retrive All Movies.
@app.route('/movies', methods=['GET'])
@requires_auth('get:movies')
def retrive_movies(payload):
movies = Movie.query.all()
if not movies:
abort(404)
formatMovies = [movie.format() for movie in movies]
return jsonify({'success': True, 'movies': formatMovies})
# Add Movie.
@app.route('/movies', methods=['POST'])
@requires_auth('post:movies')
def add_movie(payload):
body = request.get_json()
if 'title' not in body:
abort(404)
title = body.get('title', None)
release_date = body.get('release_date', None)
try:
new_movie = Movie(title=title, release_date=release_date)
new_movie.insert()
return jsonify({
'success': True,
'movies': [new_movie.get_movie()]
})
except Exception:
abort(422)
# Edit Movie.
@app.route('/movies/<int:movie_id>', methods=['PATCH'])
@requires_auth('patch:movies')
def edit_movie(payload, movie_id):
body = request.get_json()
try:
movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
if movie is None:
abort(404)
if 'title' in body:
movie.title = body.get('title', None)
if 'release_data' in body:
movie.release_data = body.get('release_data', None)
movie.update()
format_movie = [movie.format()]
return jsonify({'success': True, 'movie': format_movie}), 200
except Exception:
abort(422)
# Delete Movie.
@app.route('/movies/<movie_id>', methods=['DELETE'])
@requires_auth('delete:movies')
def delete_movie(payload, movie_id):
try:
movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
if movie is None:
abort(404)
movie.delete()
return jsonify({'success': True, 'delete': movie_id}), 200
except:
abort(422)
# Error Handling.
@app.errorhandler(404)
def not_found(error):
return jsonify({
"success": False,
"error": 404,
"message": "resource not found"
}), 404
@app.errorhandler(400)
def bad_request(error):
return jsonify({
"success": False,
"error": 400,
"message": "bad request"
}), 400
@app.errorhandler(405)
def method_not_allowed(error):
return jsonify({
"success": False,
"error": 405,
"message": "method not allowed"
}), 405
@app.errorhandler(422)
def unprocessable(error):
return jsonify({
"success": False,
"error": 422,
"message": "unprocessable"
}), 422
@app.errorhandler(AuthError)
def auth_error(error):
return jsonify({
"success": False,
"error": error.status_code,
"message": error.error['description']
}), error.status_code
return app
def test_0_refresh_db(self):
db_drop_and_create_all()
def create_tables():
db_drop_and_create_all()
def create_app(test_config=None):
# create and configure the app
APP = Flask(__name__)
setup_db(APP)
# CORS(app)
# APP = create_app()
# if __name__ == '__main__':
# APP.run(host='127.0.0.1', port=5000, debug=True)
db_drop_and_create_all()
@APP.route('/token')
def get_token():
return jsonify({'success': True}), 200
@APP.route('/actors', methods=['GET'])
def get_actors():
# query all listed actors
actors = Actor.query.all()
formatted_actors = [actor.format() for actor in actors]
# return results with the success code
return jsonify({'success': True, 'actors': formatted_actors}), 200
@APP.route('/movies', methods=['GET'])
def get_movies():
# query all listed actors
movies = Movie.query.all()
formatted_movies = [movie.format() for movie in movies]
# return results with the success code
return jsonify({'success': True, 'movies': formatted_movies}), 200
@APP.route('/actors/<int:id>', methods=['DELETE'])
@requires_auth('delete:actor')
def delete_actor(payload, id):
# code
actor = Actor.query.filter(Actor.id == id).one_or_none()
if not actor:
abort(404)
try:
actor.delete()
except BaseException:
abort(400)
return jsonify({'success': True, 'delete': id}), 200
@APP.route('/movies/<int:id>', methods=['DELETE'])
@requires_auth('delete:movie')
def delete_movie(payload, id):
# code
movie = Movie.query.filter(Movie.id == id).one_or_none()
if not movie:
abort(404)
try:
movie.delete()
except BaseException:
abort(400)
return jsonify({'success': True, 'delete': id}), 200
@APP.route('/actors', methods=['POST'])
@requires_auth('post:actor')
def post_actor(payload):
data = request.get_json()
try:
actor = Actor(name=data['name'],
gender=data['gender'],
age=data['age'])
actor.insert()
return jsonify({'success': True, 'actor': actor.format()}), 200
except:
abort(422)
@APP.route('/movies', methods=['POST'])
@requires_auth('post:movie')
def post_movie(payload):
data = request.get_json()
try:
movie = Movie(title=data['title'],
release_date=datetime.strptime(
data['release_date'], '%Y-%m-%d'))
movie.insert()
return jsonify({'success': True, 'movie': movie.format()}), 200
except:
abort(422)
@APP.route('/actors/<int:id>', methods=['PATCH'])
@requires_auth('patch:actor')
def modify_actor(payload, id):
actor = Actor.query.get(id)
if actor is None:
abort(404)
data = request.get_json()
if 'name' in data:
actor.name = data['name']
if 'gender' in data:
actor.gender = data['gender']
if 'age' in data:
actor.age = data['age']
try:
actor.update()
except BaseException:
abort(400)
return jsonify({'success': True, 'actor': actor.format()}), 200
@APP.route('/movies/<int:id>', methods=['PATCH'])
@requires_auth('patch:movie')
def modify_movie(payload, id):
movie = Movie.query.get(id)
if movie is None:
abort(404)
data = request.get_json()
if 'title' in data:
movie.title = data['title']
if 'release_date' in data:
movie.release_date = datetime.strptime(data['release_date'],
'%Y-%m-%d')
try:
movie.update()
except BaseException:
abort(400)
return jsonify({'success': True, 'movie': movie.format()}), 200
# error handling
@APP.errorhandler(422)
def unprocessable(error):
return jsonify({
"success": False,
"error": 422,
"message": "unprocessable"
}), 422
@APP.errorhandler(404)
def not_found(error):
return jsonify({
"success": False,
"error": 404,
"message": "Resource Not Found"
}), 404
'''
error handler for AuthError
'''
@APP.errorhandler(AuthError)
def auth_error(error):
return jsonify({
"success": False,
"error": error.status_code,
"message": error.error['description']
}), error.status_code
@APP.errorhandler(401)
def unauthorized(error):
return jsonify({
"success": False,
"error": 401,
"message": 'Unauthorized'
}), 401
@APP.errorhandler(400)
def bad_request(error):
return jsonify({
"success": False,
"error": 400,
"message": 'Bad Request'
}), 400
return APP
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__)
setup_db(app)
db_drop_and_create_all()
CORS(app)
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Headers',
'Content-Type,Authorization,true')
response.headers.add('Access-Control-Allow-Methods',
'GET,PATCH,POST,DELETE,OPTIONS')
return response
def get_error_message(error, default_text):
try:
return error.description['message']
except:
return default_text
def paginate_results(request, selection):
page = request.args.get('page', 1, type=int)
start = (page - 1) * ROWS_PER_PAGE
end = start + ROWS_PER_PAGE
objects_formatted = [object_name.format() for object_name in selection]
return objects_formatted[start:end]
#----------------------------------------------------------------------------#
# Endpoint /actors GET/POST/DELETE/PATCH
#----------------------------------------------------------------------------#
@app.route('/actors', methods=['GET'])
@requires_auth('get:actors')
def get_actors(payload):
selection = Actor.query.all()
actors_paginated = paginate_results(request, selection)
if len(actors_paginated) == 0:
abort(404, {'message': 'no actors found in database.'})
return jsonify({'success': True, 'actors': actors_paginated})
@app.route('/actors', methods=['POST'])
@requires_auth('post:actors')
def insert_actors(payload):
body = request.get_json()
if not body:
abort(400,
{'message': 'request does not contain a valid JSON body.'})
name = body.get('name', None)
age = body.get('age', None)
gender = body.get('gender', 'Other')
if not name:
abort(422, {'message': 'no name provided.'})
if not age:
abort(422, {'message': 'no age provided.'})
new_actor = (Actor(name=name, age=age, gender=gender))
new_actor.insert()
return jsonify({'success': True, 'created': new_actor.id})
@app.route('/actors/<actor_id>', methods=['PATCH'])
@requires_auth('patch:actors')
def edit_actors(payload, actor_id):
body = request.get_json()
if not actor_id:
abort(400,
{'message': 'please append an actor id to the request url.'})
if not body:
abort(400,
{'message': 'request does not contain a valid JSON body.'})
actor_to_update = Actor.query.filter(
Actor.id == actor_id).one_or_none()
if not actor_to_update:
abort(
404, {
'message':
'Actor with id {} not found in database.'.format(actor_id)
})
name = body.get('name', actor_to_update.name)
age = body.get('age', actor_to_update.age)
gender = body.get('gender', actor_to_update.gender)
actor_to_update.name = name
actor_to_update.age = age
actor_to_update.gender = gender
actor_to_update.update()
return jsonify({
'success': True,
'updated': actor_to_update.id,
'actor': [actor_to_update.format()]
})
@app.route('/actors/<actor_id>', methods=['DELETE'])
@requires_auth('delete:actors')
def delete_actors(payload, actor_id):
if not actor_id:
abort(400,
{'message': 'please append an actor id to the request url.'})
actor_to_delete = Actor.query.filter(
Actor.id == actor_id).one_or_none()
if not actor_to_delete:
abort(
404, {
'message':
'Actor with id {} not found in database.'.format(actor_id)
})
actor_to_delete.delete()
return jsonify({'success': True, 'deleted': actor_id})
#----------------------------------------------------------------------------#
# Endpoint /movies GET/POST/DELETE/PATCH
#----------------------------------------------------------------------------#
@app.route('/movies', methods=['GET'])
@requires_auth('get:movies')
def get_movies(payload):
selection = Movie.query.all()
movies_paginated = paginate_results(request, selection)
if len(movies_paginated) == 0:
abort(404, {'message': 'no movies found in database.'})
return jsonify({'success': True, 'movies': movies_paginated})
@app.route('/movies', methods=['POST'])
@requires_auth('post:movies')
def insert_movies(payload):
body = request.get_json()
if not body:
abort(400,
{'message': 'request does not contain a valid JSON body.'})
title = body.get('title', None)
release_date = body.get('release_date', None)
if not title:
abort(422, {'message': 'no title provided.'})
if not release_date:
abort(422, {'message': 'no "release_date" provided.'})
new_movie = (Movie(title=title, release_date=release_date))
new_movie.insert()
return jsonify({'success': True, 'created': new_movie.id})
@app.route('/movies/<movie_id>', methods=['PATCH'])
@requires_auth('patch:movies')
def edit_movies(payload, movie_id):
body = request.get_json()
if not movie_id:
abort(400,
{'message': 'please append an movie id to the request url.'})
if not body:
abort(400,
{'message': 'request does not contain a valid JSON body.'})
movie_to_update = Movie.query.filter(
Movie.id == movie_id).one_or_none()
if not movie_to_update:
abort(
404, {
'message':
'Movie with id {} not found in database.'.format(movie_id)
})
title = body.get('title', movie_to_update.title)
release_date = body.get('release_date', movie_to_update.release_date)
movie_to_update.title = title
movie_to_update.release_date = release_date
movie_to_update.update()
return jsonify({
'success': True,
'edited': movie_to_update.id,
'movie': [movie_to_update.format()]
})
@app.route('/movies/<movie_id>', methods=['DELETE'])
@requires_auth('delete:movies')
def delete_movies(payload, movie_id):
if not movie_id:
abort(400,
{'message': 'please append an movie id to the request url.'})
movie_to_delete = Movie.query.filter(
Movie.id == movie_id).one_or_none()
if not movie_to_delete:
abort(
404, {
'message':
'Movie with id {} not found in database.'.format(movie_id)
})
movie_to_delete.delete()
return jsonify({'success': True, 'deleted': movie_id})
#----------------------------------------------------------------------------#
# Error Handlers
#----------------------------------------------------------------------------#
@app.errorhandler(422)
def unprocessable(error):
return jsonify({
"success": False,
"error": 422,
"message": get_error_message(error, "unprocessable")
}), 422
@app.errorhandler(400)
def bad_request(error):
return jsonify({
"success": False,
"error": 400,
"message": get_error_message(error, "bad request")
}), 400
@app.errorhandler(404)
def ressource_not_found(error):
return jsonify({
"success":
False,
"error":
404,
"message":
get_error_message(error, "resource not found")
}), 404
@app.errorhandler(AuthError)
def authentification_failed(AuthError):
return jsonify({
"success": False,
"error": AuthError.status_code,
"message": AuthError.error['description']
}), AuthError.status_code
return app
