def test_delete_movie_executive_producer_success(self):
total_movies_before = len(Movie.query.all())
movie = Movie()
movie.title = 'Action Filled Movie'
movie.genre = 'Action'
movie.insert()
total_movies_after = len(Movie.query.all())
self.assertEqual(total_movies_after, total_movies_before + 1)
res = self.client().delete('/movies/' + str(movie.id),
headers={
"Authorization":
"Bearer {}".format(
self.executive_producer)
})
data = json.loads(res.data)
total_movies_after = len(Movie.query.all())
self.assertEqual(data['success'], True)
self.assertEqual(data['delete'], movie.id)
self.assertEqual(res.status_code, 200)
self.assertEqual(total_movies_after, total_movies_before)
def create_movies(payload):
"""
Creates a new movie
"""
request_data = request.get_json()
title = request_data.get('title')
description = request_data.get('description')
category = request_data.get('category')
if title is None:
abort(422)
new_movie = Movie(title=title,
description=description,
category=category)
Movie.insert(new_movie)
return jsonify({
'success': True,
'message': 'the movie ' + title + ' was successfully listed',
'movie': new_movie.format()
}), 201
def add_movie(payload):
body = request.get_json()
if not body:
abort(400)
if not ('title' in body and 'release_date' in body):
abort(400)
title = body['title']
release_date = body['release_date']
if 'actors' in body:
actors = body['actors']
actors_list = []
for i in range(len(actors)):
actor = Actor.query.filter(Actor.name == actors[i]).first()
if not (actor is None):
actors_list.append(actor)
try:
movie = Movie(title=title, release_date=release_date)
if 'actors' in body:
movie.actors = actors_list
movie.insert()
except Exception:
print(sys.exc_info())
abort(422)
else:
return jsonify({'success': True, 'movie': title}), 201
def test_patch_movie(self, headers):
a = Actor(name='Lars Larsson', age=38, gender=Gender('M'))
a.insert()
m = Movie(title='Genesis II', date_release='20200320', actors=[a])
m.insert()
#
# change date_release
#
res = self.client().patch(f'/movies/{m.id}', headers=headers,
data=json.dumps({
'title': 'Genesis II',
'date_release': '20200328',
'actors_id': [a.id]
}),
content_type='application/json')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(m.id, data['movie_id'])
#
# check date is changed
#
m1 = Movie.query.filter(Movie.id == m.id).one_or_none()
self.assertEqual(m1.date_release, datetime.datetime.strptime('20200328', '%Y%m%d').date())
def test_get_movies(self):
movie = Movie(title='test movies one', release_data='5/4/2020')
movie.insert()
res = self.client().get('/movies', headers=self.casting_assistant)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def add_new_movie():
success = True
title = request.json.get('title', None)
if title is None:
abort(400, 'Missing field \'title\'.')
release_date = request.json.get('release_date', None)
if release_date is None:
abort(400, 'Missing field \'release_date\'.')
existing_movie = Movie.query.filter(Movie.title.ilike(title)).first()
if existing_movie is not None:
abort(409, 'The movie already exists.')
try:
new_movie = Movie(title=title, release_date=release_date)
new_movie.insert()
except Exception as e:
db.session.rollback()
success = False
finally:
db.session.close()
if success:
return jsonify({'success': True}), 201
else:
abort(500, 'Adding the movie to the database was unsuccessful.')
def add_movie(token):
try:
# Get the movies data
data = request.get_json()
# Abort 404 if there is no movie data
if data is None:
abort(404)
# Assign individual data from json data into variables
new_title = data.get('title')
new_release_date = data.get('release_date')
new_image_link = data.get('image_link')
# Validate to ensure no data is empty
if (len(new_title) == 0 or new_release_date == 0):
abort(400)
# Create a new movie instance
new_movie = Movie(title=new_title,
release_date=new_release_date,
image_link=new_image_link)
# Insert the movie to the database
new_movie.insert()
# Get all the new movies
new_movie = Movie.query.order_by(Movie.id).all()
current_movies = [movie.format() for movie in new_movie]
# Return a success message
return jsonify({
'success': True,
'movies': current_movies,
'total_movies': len(new_movie)
}), 200
except BaseException:
abort(400)
def add_movie(jwt):
if not request.method == 'POST':
abort(405)
try:
body = request.get_json()
data = {
'title': body['title'],
'release_date': body['release_date']
}
except:
abort(422)
try:
movie = Movie(**data)
movie.insert()
return jsonify(data)
except:
db.session.rollback()
abort(422)
finally:
db.session.close()
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 post_movies(jwt):
'''
This endpoint is to post a new movie
Parameters:
jwt: Decoded jwt token which contains the permissions of the user
Responses:
200: New movie is created and returns an array of movies
paginated to 10 movies per page
422: Unprocessable request or invalid data in token
Permissions:
This endpoint is accessable only to Executive Producers
'''
try:
data = request.get_json()
if 'title' not in data or 'release_date' not in data:
abort(422)
new_title = data['title']
new_release_date = data['release_date']
movie = Movie(title=new_title, release_date=new_release_date)
movie.insert()
movies = Movie.query.all()
current_movies = paginate_result(request, movies)
if len(movies) > 0 and len(current_movies) == 0:
abort(404)
return jsonify({
'success': True,
'created_movie_id': movie.id,
'movies': current_movies,
'total_movies': len(movies)
})
except Exception as e:
print(e)
abort(422)
def setUp(self):
'''Executes before each test. Set variables and init app.'''
self.app = create_app()
self.client = self.app.test_client
self.database_url = os.environ['DATABASE_URL']
setup_db(self.app, self.database_url)
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
self.db.create_all()
new_actor = Actor(name='Test_Name', age=31, gender='f')
new_actor.insert()
new_actor = Actor.query.filter(
Actor.name.ilike('%Test_Name%')).one_or_none()
global actor_id
actor_id = new_actor.id
new_movie = Movie(title='Test_Title', release_date='2012-02-14')
new_movie.insert()
new_movie = Movie.query.filter(
Movie.title.ilike('%Test_Title%')).one_or_none()
global movie_id
movie_id = new_movie.id
def post_movie(jwt):
if not request.json:
abort(400)
try:
new_movie = Movie()
if "title" in request.json:
title = request.json["title"]
new_movie.title = title
if "release_date" in request.json:
date_arr = [
int(val) for val in request.json["release_date"].split("-")
]
release_date = datetime.datetime(*date_arr)
new_movie.release_date = release_date
new_movie.insert()
return (jsonify({
"success": True,
"movie": new_movie.format()
}), 200)
except:
print(sys.exc_info())
abort(422)
def create_movie(jwt):
data = request.get_json()
new_title = data.get('title', None)
new_genres = data.get('genres', None)
new_weblink = data.get('website_link', None)
new_fblink = data.get('facebook_link', None)
new_reldate = data.get('release_date', None)
new_desc = data.get('mv_desc', None)
new_imglink = data.get('image_link', None)
new_seekact = data.get('seeking_actors', None)
new_seekdesc = data.get('seeking_description', None)
if new_title is None or new_genres is None or new_reldate is None:
abort(400)
else:
try:
q = Movie(title=new_title,
genres=new_genres,
mv_desc=new_desc,
seeking_actors=new_seekact,
seeking_description=new_seekdesc,
image_link=new_imglink,
website_link=new_weblink,
facebook_link=new_fblink,
release_date=new_reldate)
q.insert()
return jsonify({"success": True, "created": q.id})
except Exception as e:
print(str(e))
abort(422)
def add_movie(token):
body = request.get_json()
'''
Check if all information are included in the request
'''
if is_none(body.get('title'), body.get('release_date')):
abort(401) # bad request
try:
'''
Create new Movie
'''
new_movie = Movie(title=body['title'],
release_date=body['release_date'])
new_movie.insert()
return jsonify({
'success': True,
'movie': new_movie.format(),
"movie's_actors": new_movie.get_actors()
})
except Exception:
abort(422) # unprocessable
def post_movie():
"""POST "/movies" endpoint.
Add a new movie. Receives a json object with the members: title, release_date.
:returns: A JSON object with the member `id`: the id of the newly created movie.
:raises HTTPException: An appropriate HTTP exception.
"""
data = request.get_json()
if not data:
abort(400)
title = data.get('title', None)
release_date = data.get('release_date', None)
# Raise bad request error if title or release_date data is not sent
if title is None or release_date is None:
abort(400)
# Raise unprocessable error if any error occurs during adding the new movie to the database
try:
# Convert date in "yyyy-mm-dd" format to a date object
release_date = dt.date.fromisoformat(release_date)
new_movie = Movie(title, release_date)
new_movie.insert()
return jsonify({
'id': new_movie.id
})
except Exception as e:
print(e)
abort(422)
def create_movie(token):
# getting the json body and splitting the elemtents
body = request.get_json()
new_title = body.get('title')
new_release_date = body.get('release_date')
# if the required data is not in the body then its abort due to bad
# request
if not ('title' in body and 'release_date' in body):
abort(400)
# create the new movie assigning new data to columns
movie = Movie(title=new_title, release_date=new_release_date)
movie.insert()
movies = Movie.query.order_by(Movie.id).all()
current_movies = pagination(request, movies, 'movies')
return jsonify({
'success': True,
'created': movie.id,
'movies': current_movies,
'total_movies': len(movies)
}), 200
def create_movie(payload):
"""Inserts a new row in the Movie table.
Requires the 'post:movies' permission in the JWT Bearer authentication.
JSON request body must be valid against the post_movie.json schema.
Args:
payload: A validated JWT for the Casting Agency app.
Returns:
A JSON response indicating success and the ID of the created Movie.
"""
request_body = request.get_json()
title = request_body['title']
release_date = request_body['releaseDate']
new_movie = Movie(
title=title,
release_date=release_date
)
new_movie.insert()
return jsonify({
'success': True,
'created': new_movie.id
}), 201
def post_movie(jwt):
try:
body = request.get_json()
new_movie_title = body.get("title", None)
new_movie_release_date = body.get("release_date", None)
new_movie_cast_filled = body.get("cast_filled", None)
movie_new = Movie(
title=new_movie_title,
release_date=new_movie_release_date,
cast_filled=new_movie_cast_filled,
)
movie_new.insert()
movie = (Movie.query.filter(
Movie.title == new_movie_title).one_or_none().format())
response = {
"success": True,
"id": movie["id"],
"title": movie["title"],
"release_date": movie["release_date"],
"cast_filled": movie["cast_filled"],
}
return (jsonify(response), 201)
except:
abort(422)
def add_new_movie(jwt):
'''
Inserts new movie instance based on fields given in the request.
If required fields are missing "400: ???" error given.
Returns the id of the movie sucessfully inserted.
'''
new_title = request.json.get('title', None)
new_release_date = request.json.get('release_date', None)
if (new_title is None) or (new_release_date is None):
abort(400)
else:
new_movie = Movie(title=new_title, release_date=new_release_date)
try:
new_movie.insert()
except Exception:
abort(422)
created_movie = Movie.query.filter(
Movie.title == new_title,
Movie.release_date == new_release_date).one_or_none()
if created_movie is None:
abort(404)
else:
return jsonify({'success': True, 'movie_id': created_movie.id})
def test_update_movie_executive_producer(self):
movie = Movie.query.filter_by(id=2).first()
movieUpdate = {
'title': "movie_updated",
'movie_genrs': movie.movie_genrs,
'release_date': movie.release_date
}
# movie.update()
res = self.client().patch('/movies/' + str(movie.id),
json=movieUpdate,
headers=settingup_auth('executive_producer'))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['edited'], 2)
# self.assertEqual(data['movie']['title'], 'updated_movie')
# def test_401_update_movie_casting_assistant(self):
movie = Movie(title='first Name')
movie.insert()
res = self.client().patch('/movies/' + str(movie.id),
json={'title': 'updated_movie'},
headers=settingup_auth('casting_assistant'))
self.assertEqual(res.status_code, 401)
def test_get_movies_200(self):
movie = Movie(title='Hello', release_date='2012-01-15')
movie.insert()
response = self.client().get('/movies', headers=self.assistant)
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(data['success'], True)
def create_movie(payload):
body = request.get_json()
new_movie = body.get('movie', None)
genres = body.get('genres', None)
age_rating = body.get('age_rating', None)
try:
movie = Movie(movie=new_movie,
genres=genres,
age_rating=age_rating)
movie.insert()
movies = Movie.query.all()
formated_movies = [movie.format for movie in movies]
return jsonify({
'success': True,
'created': movie.id,
'total_movies': len(movies)
})
except BaseException as e:
print(e)
abort(422)
def create_movie():
"""Route handler for the endpoint for creating a new movie.
Returns:
response: A json object representing info about the created movie
"""
try:
movie = Movie(
title=request.json.get("title"),
release_date=request.json.get("release_date"),
poster=request.json.get("poster"),
actors=get_actors_from_names(request.json.get("actors")),
)
movie.insert()
response = jsonify({
"success": True,
"created_movie_id": movie.id,
"old_movie": None,
"new_movie": movie.format(),
})
except AttributeError:
abort(400)
return response
def create_movie(jwt):
error = False
data = request.data
data_dictionary = json.loads(data)
release_date = data_dictionary['release_date']
regex_release_date = '^(0?[1-9]|[12][0-9]|3[01])[\/\-](0?[1-9]|1[012])[\/\-]\d{4}$'
match = re.search(regex_release_date, release_date)
if not match:
return jsonify({
'succes':
False,
'error':
422,
'message':
'Please insert a valid date in this format dd/mm/yyy'
}), 422
try:
title = data_dictionary['title']
movie = Movie(title=title, release_date=release_date)
movie.insert()
except:
error = True
Movie.rollback()
print(sys.exc_info())
if error:
abort(422)
else:
return jsonify({'success': True, 'movie': movie.format()})
def tearDown(self):
"""Executed after reach test"""
db_drop_and_create_all()
actor = Actor(**self.new_actor)
actor.insert()
movie = Movie(**self.new_movie)
movie.insert()
def test_patch_role_to_provide_actor_id(self):
new_movie = Movie(**AppTestCase.test_movie)
new_movie.insert()
movie_id = new_movie.id
new_role = Role(movie_id=movie_id, **AppTestCase.test_role)
new_role.insert()
role_id = new_role.id
new_actor = Actor(**AppTestCase.test_actor)
new_actor.insert()
actor_id = new_actor.id
res = self.client().patch(f'/roles/{role_id}',
json={'actor_id': actor_id},
headers=HEADER)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
self.assertEqual(data['id'], role_id)
role = Role.query.get(role_id)
self.assertEqual(role.actor_id, actor_id)
new_movie.delete()
new_actor.delete()
def create_movie_submit():
error = False
form = MovieForm()
if form.validate_on_submit():
try:
movie = Movie(
title=form.title.data,
release=form.release.data,
image_link=form.image_link.data,
# website=form.website.data,
# facebook_link=form.facebook_link.data,
)
movie.insert()
except:
error = True
print(sys.exc_info())
movie.rollback()
finally:
movie.close()
if error:
flash(
'An error occurred. Movie '
+ request.form['title']
+ ' could not be listed.'
)
else:
flash('Movie ' + request.form['title'] + ' was successfully listed!')
else:
flash('One or more fields are not valid.')
# flash(actor.facebook_link.data + ': ' + str(actor.errors['facebook_link']))
return render_template('forms/new_movie.html', form=form)
return redirect(url_for('movies'))
def test_patch_role_by_invalid_age_interval(self):
new_movie = Movie(**AppTestCase.test_movie)
new_movie.insert()
movie_id = new_movie.id
new_role = Role(movie_id=movie_id, **AppTestCase.test_role)
new_role.insert()
role_id = new_role.id
change_data = {
'min_age': 25,
'max_age': 20,
}
res = self.client().patch(f'/roles/{role_id}',
json=change_data,
headers=HEADER)
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertFalse(data['success'])
err_message = 'Min age can not be greater than max age'
self.assertEqual(data['message'], err_message)
new_movie.delete()
def post_new_movie(self):
body = request.get_json()
if ((body.get('title') is None) or (body.get('release_date') is None)):
abort(422)
else:
new_title = body.get('title')
new_release_date = body.get('release_date')
try:
movie = Movie(title=new_title, release_date=new_release_date)
movie.insert()
new_movie = Movie.query.get(movie.id)
return jsonify({
'success': True,
'created': movie.id,
'new_movie': new_movie.format()
})
except Exception:
abort(422)
def post_to_movies(payload):
body = request.get_json()
print(body)
new_title = body.get('title', None)
new_release_date = body.get('release_date', None)
try:
movie = Movie(
title=new_title,
release_date=new_release_date,
)
movie.insert()
movie_list = format_list(Movie.query.all())
return jsonify({
'success': True,
'created_id': movie.id,
'movie_list': movie_list,
'number_of_movies': len(movie_list)
})
except BaseException:
abort(422)
