def create_movie(payload):
try:
# get params from request
body = request.get_json()
title = body.get('title')
relese_date = body.get('relese_date')
#
movie = Movie(title, relese_date)
print(movie.format())
movie.insert()
return jsonify({"success": True, "movie": movie.format()})
except BaseException:
abort(422)
def add_movie(payload):
# Extract relevant details from request.
req_data = request.get_json()
title = req_data['title']
release_date = req_data['release_date']
check_movie_values(title, release_date)
# Create new
new_movie = Movie(
title=title,
release_date=release_date,
)
# Save
try:
new_movie.insert()
except:
abort(500)
finally:
# Return
movie = new_movie.format()
return jsonify({
'success': True,
'movie': movie
})
def add_movie(token):
data = request.get_json()
movie_title = data.get('title', None)
movie_release_date = data.get('release_date', None)
if not movie_title or not movie_release_date:
abort(400)
existing_movie = Movie.query.filter(
Movie.title == movie_title,
Movie.release_date == movie_release_date).one_or_none()
if existing_movie:
abort(422)
try:
movie_data = Movie(title=movie_title, release_date=movie_release_date)
movie_data.insert()
return jsonify({
'success': True,
'movie': movie_data.format()
}), 201
except Exception as error:
print(error)
abort(422)
def add_new_movie(token):
# handle request data
data = request.get_json()
# if data is NONE
if data is None:
abort(400)
# get data from request body
try:
title, date = data["title"], data["release_date"]
# except return 400 error
except KeyError:
abort(400)
# validate request data, if TRUE:
if validate(title, date):
# check for movie exist
movie = Movie.query.filter_by(title=title).first()
# if movie is exist return json response with message
if movie:
return jsonify({
"mesage": "This film is already available",
"success": False
})
# build new movie data
new_movie = Movie(title=title, release_date=date)
# add new movie
new_movie.insert()
# build response data
response = {"success": True, "actor": new_movie.format()}
# return response
return jsonify(response), 200
return abort(400)
def new_movie(jwt):
try:
data = request.get_json('movie')
movie = Movie(title=data['title'],
release_date=data['release_date'])
movie.insert()
except Exception:
abort(400)
return jsonify({'success': True, 'movies': [movie.format()]})
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)
def add_movie(payload):
try:
body = request.get_json()
title_requested = body.get("title", None)
releaseDate_requested = body.get("release_date", None)
movie = Movie(title=title_requested,
release_date=releaseDate_requested)
movie.insert()
return jsonify({"success": True, "movie_created": movie.format()})
except:
abort(422)
def create_movie(jwt):
try:
data = request.get_json()
movie = Movie(title=data.get('title'),
release_date=data.get('release_date'))
movie.insert()
return jsonify({'success': True, 'movies': movie.format()}), 200
except BaseException:
abort(422)
def add_movie(jwt):
body = request.get_json()
req_title = body.get('title')
req_release_date = body.get('release_date')
release_date = datetime.datetime.strptime(req_release_date, "%Y-%m-%d")
if not req_title:
abort(422)
movie = Movie(title=req_title, release_date=release_date)
movie.insert()
return jsonify({
'success': True,
'movies': movie.format()
})
def create_movies(*args, **kwargs):
try:
body = request.get_json()
new_title = body.get('title')
new_release_date = body.get('release_date')
movie = Movie(title=new_title, release_date=new_release_date)
movie.insert()
return jsonify({
'success': True,
"message": "Movie Successfully Added!",
"movies": movie.format()
})
except AttributeError:
abort(422)
def add_movie(payload):
body = request.get_json()
if body is None:
abort(400)
title = body.get('title') or None
release = body.get('release') or None
if ((title is None) or (release is None)):
abort(400)
movie = Movie(title=title, release=release)
try:
movie.insert()
except Exception as e:
abort(422)
return jsonify({
'success': True,
'actor': movie.format()
}), 200
def add_movie():
body = request.get_json()
title = body.get('title')
release_date = body.get('release_date')
try:
movie = Movie(title=title, release_date=json.dumps(release_date))
movie.insert()
return jsonify({
"success": True,
"created": movie.id,
"movies": [movie.format()]
})
except Exception as e:
error = True
print(sys.exc_info())
print(e)
abort(422)
def post_movie(jwt):
# Declare and empty data dictionary to hold all retrieved variables
data = request.get_json()
# set movie variable equal to corresponding model class,
# ready for adding to the session
movie = data.get('movie')
movie = Movie(title=data.get('title'),
release_date=data.get('release_date'))
try:
movie.insert()
except Exception:
abort(400)
movies = Movie.query.all()
try:
movies = [movie.format() for movie in movies]
return jsonify({'success': True, 'movies': movies}), 200
except Exception:
abort(500)
def addMovie():
body = request.get_json()
try:
name = body.get('name', None)
desc = body.get('description', None)
movie_category_id = body.get('movie_category_id', None)
# Check of any missing parameter.
if name is None or desc is None or movie_category_id is None:
abort(400)
movie = Movie(
name=name,
description=desc,
movie_category_id=movie_category_id
)
movie.insert()
# it is a list of actors id that is assigned to the added movie
actors_id = body.get('actors_id', None)
if actors_id is not None and type(actors_id) is list:
# adding each actor to MovieActorAssign table
for actor_id in actors_id:
movie_actor_assign = MovieActorAssign(
movie_id=movie.id,
actor_id=actor_id
)
movie_actor_assign.insert()
return jsonify({
'success': True,
'movie_added': movie.format()
})
except Exception as e:
abort(422)
def create_movie(payload):
body = request.get_json()
title = body.get('title', None)
release_date = body.get('release_date', None)
try:
movie = Movie(
title=title,
release_date=release_date,
)
movie.insert()
selection = Movie.query.order_by(Movie.id).all()
movies = [movie.format() for movie in selection]
return jsonify({
'success': True,
'created': movie.id,
'movies': movies,
'totalMovies': len(Movie.query.all())
})
except Exception:
abort(422)
class CastingTestCase(unittest.TestCase):
"""This class represents the casting test case"""
def setUp(self):
"""Define test variables and initialize the app"""
self.app = create_app()
self.client = self.app.test_client
self.executive_producer_jwt = os.environ.get('EXECUTIVE_PRODUCER')
self.casting_manager_jwt = os.environ.get('CASTING_MANAGER')
self.casting_assistant_jwt = os.environ.get('CASTING_ASSISTANT')
self.executive_producer = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self.executive_producer_jwt)
}
self.casting_manager = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self.casting_manager_jwt)
}
self.casting_assistant = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self.casting_assistant_jwt)
}
self.new_actor = Actor(name="Test_Actor", age=45, gender='Male')
self.new_movie = Movie(title='Test_Movie', release_date='2016-12-06')
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
self.db.create_all
def tearDown(self):
"""Executed after reach test"""
pass
def test_get_actors(self):
res = self.client().get('/actors', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actors'])
def test_post_actors(self):
res = self.client().post('/actors',
json=self.new_actor.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['actors'])
def test_delete_actors(self):
actor = self.new_actor
actor.insert()
res = self.client().delete('/actors/{}'.format(actor.id),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['deleted'])
def test_patch_actors(self):
actor = self.new_actor
actor.insert()
patched_actor = self.new_actor
patched_actor.age = 34
res = self.client().patch('/actors/{}'.format(actor.id),
json=patched_actor.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['actors'])
def test_get_movies(self):
res = self.client().get('/movies', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['movies'])
def test_post_movies(self):
res = self.client().post('/movies',
json=self.new_movie.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['movies'])
def test_delete_movies(self):
movie = self.new_movie
movie.insert()
res = self.client().delete('/movies/{}'.format(movie.id),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['deleted'])
def test_patch_movies(self):
movie = self.new_movie
movie.insert()
patched_movie = movie
patched_movie.title = 'New Title'
res = self.client().patch('/movies/{}'.format(movie.id),
json=patched_movie.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['movies'])
# Errors
def test_401_get_actors(self):
res = self.client().get('/actors')
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
def test_401_get_movies(self):
res = self.client().get('/movies')
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
def test_400_post_actors(self):
res = self.client().post('/actors', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 400)
def test_404_delete_actors(self):
res = self.client().delete('/actors/234255',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
def test_404_patch_actors(self):
res = self.client().patch('/actors/5365436',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
def test_400_post_movies(self):
res = self.client().post('/movies', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 400)
def test_404_delete_movies(self):
res = self.client().delete('/movies/234255',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
def test_404_patch_movies(self):
res = self.client().patch('/movies/5365436',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
# Role Based Authentication
def test_get_actors_casting_assistant(self):
res = self.client().get('/actors', headers=self.casting_assistant)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actors'])
def test_post_actors_casting_assistant(self):
res = self.client().post('/actors',
json=self.new_actor.format(),
headers=self.casting_assistant)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
def test_post_actors_casting_manager(self):
res = self.client().post('/actors',
json=self.new_actor.format(),
headers=self.casting_manager)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['actors'])
def test_401_delete_movies_casting_manager(self):
movie = self.new_movie
movie.insert()
res = self.client().delete('/movies/{}'.format(movie.id),
headers=self.casting_manager)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
