def movies_patch(payload, movie_id):
'''
Updates a movie
'''
try:
data = request.get_json()
movie = Movie.query.filter(Movie.id == movie_id).first()
release_date = data.get('release_date', None)
title = data.get('title', None)
actor_id = data.get('actor_id', None)
if release_date:
date_f = '%a, %b %d %Y'
movie.release_date = datetime.strptime(release_date, date_f)
if title:
movie.title = title
if actor_id:
movie.actor_id = actor_id
movie.update()
except Exception:
abort(404, "Movie not found")
else:
return jsonify({'success': True, 'movie': Movie.format(movie)})
def create_movie():
'''
REQUIRES AUTH to CREATE NEW movie object.
- post:movies
'''
body = request.get_json()
new_title = body.get('title')
new_year = body.get('year')
new_month = body.get('month')
new_day = body.get('day')
new_genre = body.get('genre')
if new_title is None or new_genre is None:
abort(400)
try:
movie = Movie(title=new_title,
year=new_year,
month=new_month,
day=new_day,
genre=new_genre)
movie.insert()
new_movie = movie.format()
return jsonify({'success': True, 'movie': new_movie}), 200
except Exception as E:
abort(422)
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(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 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 post_movie():
movie = None
body = request.get_json()
if body is None:
abort(400)
if 'title' in body and 'release_date' in body:
title = body['title']
release_date = body['release_date']
else:
abort(400)
try:
m = Movie(title, release_date)
m.insert()
movie = [m.format()]
if movie is None:
raise Exception('unprocessable')
except Exception as e:
print(sys.exc_info())
abort(422)
return jsonify({
'success': True,
'movies': movie
})
def create_movie(payload):
try:
# Get new movie data from request.
body = request.get_json()
req_title = body.get('title', None)
req_release_date = body.get('release_date', None)
# Validate that all fields are present, if not, abort.
if (req_title is None) or (req_release_date is None):
return abort(422)
# Validate that the birth date is the proper format, if not, abort.
if not date_valid(req_release_date):
return abort(422)
# Format and create the movie object.
movie = Movie(title=req_title, release_date=req_release_date)
# Abort if the movie is already present in the database.
if movie.is_duplicate():
abort(422)
# Otherwise, create a row in the database for the movie.
movie.insert()
return jsonify({'success': True, "movie": movie.format()})
except AuthError:
abort(422)
def create_movie():
try:
body = request.get_json()
title = body.get('title', None)
start_time = body.get('start_time', None)
if title == '' or start_time == '':
return jsonify({
"success": False,
"error": 422,
"message": "unprocessable"
}), 422
movie = Movie(title=title, start_time=start_time)
movie.insert()
formated_movies = {}
movies = Movie.query.all()
for movie in movies:
formated_movies[movie.id] = movie.format()
return jsonify({
'success': True,
'movies': formated_movies
})
except BaseException:
return jsonify({
"success": False,
"error": 500,
"message": "internal server error"
}), 500
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(payload):
body = request.get_json()
title = body.get('title')
release_date = body.get('release_date')
movie = Movie(title=title, release_date=release_date)
movie.insert()
return jsonify({'success': True, 'movies': movie.format()})
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 add_movie(payload):
body = request.get_json()
try:
title = body.get('title', None)
releaseDate1 = body.get('releaseDate', None)
releaseDate = parse(releaseDate1).date()
actors_names = body.get('actors_names', None)
new_movie = Movie(title=title, releaseDate=releaseDate)
for name in actors_names:
actor = Actor.query.filter(Actor.name == name).one_or_none()
if actor is not None:
new_movie.actors.append(actor)
else:
print(
name +
' is not in the database. Please add it to actors database first'
)
abort(404)
new_movie.insert()
cast = [actor.format() for actor in new_movie.actors]
return jsonify({
'success': True,
'added movie': new_movie.format(),
'cast': cast
})
except Exception:
abort(422)
def create_movie(jwt):
###
"""
Create a new movie.
"""
###
try:
if request.method != 'POST':
abort(405)
data = request.get_json()
title = data.get('title')
release_date = data.get('release_date')
new_movie = Movie(title=title, release_date=release_date)
new_movie.insert()
except Exception:
db.session.rollback()
abort(422)
finally:
return jsonify({
'success': True,
'new_movie': new_movie.format()
}), 200
db.session.close()
def create_movie():
"""Add a new movie to the database
Payload parameters:
title -- the name of the movie (required)
release_date -- the date that the movie will be released in YYYY-MM-DD format (optional)
Returns an object, with the newly persisted movie if successful.
"""
data = request.get_json()
if not data or not data.get('title'):
abort(400, description='`title` attribute must be provided.')
if data.get('release_date') and convert_date_to_dateobj(
data['release_date']) == None:
abort(400, description='`release_date` must be in format YYYY-MM-DD')
movie = Movie(title=data['title'])
if data.get('release_date'):
movie.release_date = data['release_date']
movie.insert()
return jsonify({'success': True, 'movie': movie.format()})
def create_movie(payload):
body = request.get_json()
title = body.get('title', '')
if not title:
abort(422)
movie = Movie(title=title)
movie.insert()
return jsonify({'success': True, 'movie': movie.format()}), 201
def get_movies():
all_movies = Movie.query.all()
movies = [Movie.format(movie) for movie in all_movies]
res = jsonify({
'success': True,
'movies': movies
})
return res
def add_movie(payload):
body = request.get_json()
title = body.get('title', None)
release_date = body.get('release_date', None)
# try:
entry = Movie(title=title, release_date=release_date)
entry.insert()
return jsonify({'success': True, 'movies': entry.format()})
def add_movie():
try:
data = json.loads(request.data)
movie = Movie(**data)
movie.insert()
return jsonify({'success': True, 'movie': movie.format()}), 201
except Exception as error:
raise error
def post_movies(jwt):
data = request.get_json()
if 'title' and 'release_date' not in data:
abort(422)
new_movie = Movie(title=data['title'], release_date=data['release_date'])
new_movie.insert()
return jsonify({'success': True, 'added_movie': [new_movie.format()]})
def post_movies(payload):
title = request.get_json().get('title', 'untitled')
release_date = request.get_json().get('release_date', None)
movie = Movie(title, release_date)
movie.add()
return jsonify({
'success': True,
'movie': movie.format()
})
def create_new_movie():
'''
Create a new Movie
---
tags:
- Movies
parameters:
- name: Movie
in: body
schema:
type: object
properties:
title:
type: string
release_date:
type: date
synopsis:
type: string
rating:
type: number
responses:
201:
description: Returns the new Movie
'''
try:
body = request.get_json()
if body is None:
abort(400)
user_input = {
"title": body.get('title', None),
"release_date": body.get('release_date', None),
"synopsis": body.get('synopsis', None),
"rating": body.get('rating', None),
}
movie = Movie(title=user_input['title'],
release_date=user_input['release_date'],
synopsis=user_input['synopsis'],
rating=user_input['rating'])
db.session.add(movie)
db.session.commit()
return jsonify({
"success": True,
"result": movie.format(),
"timestamp": time.time()
}), 201
except AuthError:
abort(401)
except Exception as err:
db.session.rollback()
return jsonify({"success": False, "error": str(err)}), 500
finally:
db.session.close()
def create_movies():
try:
body = request.get_json()
movie = Movie(title=body["title"],
release_date=body["release_date"])
movie.insert()
except Exception as er:
print(er)
abort(400)
return jsonify({"success": True, "movies": movie.format()})
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 post_movie(payload):
try:
title = request.get_json()['title']
releasedate = request.get_json()['releasedate']
newmovie = Movie(title=title, releasedate=releasedate)
newmovie.insert()
return jsonify({'success': True, 'movie': newmovie.format()})
except Exception:
abort(400)
def add_movie(payload):
data = request.get_json()
if any(x not in data for x in ['title', 'release']):
abort(422)
movie = Movie(**data)
movie.insert()
return jsonify({'success': True, 'movie': movie.format()}), 200
def create_movie(token):
body = request.get_json()
movie = Movie(title=body.get('title', None),
release_date=body.get('release_date', None))
movie.insert()
return jsonify({
'success': True,
'movie': movie.format(),
})
def add_movie(self):
try:
data = request.get_json()
movie = Movie(title=data['title'],
release_date=data['release_date'])
movie.insert()
return jsonify({'success': True, 'movie': movie.format()})
except Exception as e:
# print("exception is ",e)
abort(422)
def get_movie(payload, movie_id):
try:
movie = Movie.query.filter(Movie.id == movie_id).one_or_none()
return jsonify({
'status_code': 200,
'success': True,
'movie': Movie.format(movie),
}), 200
except:
abort(404)
def create_movie(payload):
body = request.get_json()
title = body.get("title")
release_date = body.get("release_date")
if not title or not release_date:
abort(400)
movie = Movie(title=title, release_date=release_date)
movie.insert()
return jsonify({"movie": movie.format(), "success": True})
def post_movie(payload):
try:
data = request.get_json()
title = data["title"]
release_date = data["release_date"]
movie = Movie(title=title, release_date=release_date)
movie.insert()
formatted_movie = movie.format()
return jsonify({'success': True, 'movie': formatted_movie})
except Exception:
abort(422)
