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 test_401_delete_movie_casting_director(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().delete('/movie/' + str(movie.id),
headers=settingup_auth('casting_director'))
self.assertEqual(res.status_code, 401)
def setUp(self):
"""Define test variables and initialize app."""
self.app = app
self.client = self.app.test_client
self.database_name = "capstone_test"
self.database = f"postgresql://*****:*****@localhost/"
self.database_path = self.database + self.database_name
# setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.app.config["SQLALCHEMY_DATABASE_URI"] = self.database_path
self.app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
self.db = db
self.db.app = self.app
# self.db.init_app(self.app)
# create all tables
self.db.drop_all()
self.db.create_all()
with self.app.app_context():
for i in range(10):
new_actor = Actor(name='ahmed', age=30, gender='male')
new_movie = Movie(title='new movie', start_time='2015-5-6')
new_actor.insert()
new_movie.insert()
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 test_401_patch_movie_casting_assistant(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().patch('/movies/' + str(movie.id),
json={'title': 'updated_movie'},
headers=setup_auth('casting_assistant'))
self.assertEqual(res.status_code, 401)
def test_401_delete_movie_fail(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().delete('/movies/' + str(movie.id),
headers=setup_auth(''))
self.assertEqual(res.status_code, 401)
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 create_movies(jwt):
'''
Creates a movie in the database.
Requieres [create:movies] permission.
'''
body = request.get_json()
title = body.get('title', None)
released = body.get('released', None)
picture_link = body.get('picture_link', None)
synopsis = body.get('synopsis', None)
if title is None:
abort(400)
elif released is None:
abort(400)
elif synopsis is None:
abort(400)
try:
movie = Movie(title=title,
released=released,
picture_link=picture_link,
synopsis=synopsis)
movie.insert()
return jsonify({'success': True, 'created': movie.id})
except Exception as e:
print(e)
abort(422)
def create_movie():
title, release = get_validated_body_movie()
try:
movie = Movie(title=title, release=release)
movie.insert()
except Exception:
abort(500, "Internal Error")
return jsonify({"success": True, "movie": movie.json()}), 200
def insertion():
movie = Movie(id=1, title='test1', release_date='01/01/2010')
movie.insert()
actor = Actor(id=1, name='azedine', age='23', gender='man')
actor.insert()
movie = Movie(id=2, title='test2', release_date='02/02/2010')
movie.insert()
actor = Actor(id=2, name='aziz', age='34', gender='female')
actor.insert()
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 test_016_delete_movie_by_ID(self):
new_movie = Movie(title='one for delete', release='2020')
new_movie.insert()
response = self.client().delete(
'/movies/{}'.format(new_movie.id),
headers={"Authorization": "Bearer {}".format(self.producer_token)})
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(data['success'], True)
def create_movie(payload):
print('payload', payload)
body = request.get_json()
req_title = body.get('title')
req_date = datetime.fromtimestamp(body.get('date') / 1000.0)
movie = Movie(title=req_title, date=req_date)
movie.insert()
return jsonify({'success': True, 'movie': movie.long()})
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 test_08_delete_movie_by_ID(self):
new_movie = Movie(title='one for delete', release='2020')
new_movie.insert()
response = self.client().delete(
'/movies/{}'.format(new_movie.id),
headers={"Authorization": "Bearer {}".format(self.director_token)})
data = json.loads(response.data)
self.assertEqual(response.status_code, 401)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Permission Not found')
def test_401_delete_movie_executive_producer(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().delete('/movies/' + str(movie.id),
headers=setup_auth('executive_producer'))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(int(data['deleted']), movie.id)
def test_404_patch_movie_fail(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().patch('/movies/100000',
json={},
headers=setup_auth('executive_producer'))
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'resource not found')
def create_movie(jwt):
data = request.get_json()
title = data.get('title')
release_date = data.get('release_date')
try:
movie = Movie(title=title, release_date=release_date)
movie.insert()
return jsonify({
'success': True,
})
except Exception:
abort(422)
def test_patch_movie_executive_producer(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().patch('/movies/' + str(movie.id),
json={'title': 'updated_movie'},
headers=setup_auth('executive_producer'))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['movie']['id'], movie.id)
self.assertEqual(data['movie']['title'], 'updated_movie')
def test_update_movie_casting_director(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().patch('/movie/' + str(movie.id),
json={'title': 'updated_movie'},
headers=settingup_auth('casting_director'))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['movie']['title'], 'updated_movie')
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 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 test_delete_movie(self):
new_movie = Movie(
title="Friends",
release_date=datetime.strptime("2023-01-01", '%Y-%m-%d')
)
new_movie.insert()
res = self.client().delete(f'/movies/{new_movie.id}', headers={
'Authorization': executive_producer_token
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def add_movie(payload):
try:
add_title = request.get_json().get('title', None)
add_release = request.get_json().get('release', None)
new_movie = Movie(title=add_title, release=add_release)
new_movie.insert()
response = {
'success': True,
'status_code': 200,
'create': new_movie.id
}
return jsonify(response)
except Exception:
abort(422)
def post_movie(payload):
try:
body = request.get_json()
if 'title' not in body:
raise
new_movie = Movie(title=body.get('title'),
release_date=body.get('release_date'))
new_movie.insert()
return jsonify({'success': True, 'id': new_movie.id})
except Exception:
db.session.rollback()
abort(400)
finally:
db.session.close()
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)
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_movie(payload):
body = request.get_json()
new_title = body.get('title', None)
new_year_released = body.get('year_released', None)
if (not new_title) or (not new_year_released):
abort(400)
new_movie = Movie(title=new_title, year_released=new_year_released)
new_movie.insert()
movie_list = Movie.query.filter(Movie.title == new_title).all()
movie = [m.long() for m in movie_list]
return jsonify({'success': True, 'movies': movie})
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)
