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 dashboard():
if request.method=="POST":
name = request.form['moviename']
searchstring = name.split(" ")
genre = request.form['genre']
result = []
if genre.lower() == 'all':
if name=="":
r = requests.get(apiurl+'/api/movies')
result = r.json()
else:
result = Movie.objects(name=name).to_json()
result = json.loads(result)
else:
print(genre.capitalize())
genre = genre.capitalize()
if name=="":
result = Movie.objects(genres__in=[genre]).to_json()
else:
result = Movie.objects(name=name, genres__in=[genre]).to_json()
print(result)
result = json.loads(result)
return render_template('dashboard.html',movies=result)
r = requests.get(apiurl+'/api/movies')
if (r.json()):
return render_template('dashboard.html', movies=r.json())
else:
msg = 'No articles found'
return render_template('dashboard.html', msg=msg)
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 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 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 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 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 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_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 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 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 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(self):
user_id = get_jwt_identity()
body = request.get_json()
user = User.objects.get(id=user_id)
movie = Movie(**body, added_by=user)
movie.save()
user.update(push__movies=movie)
user.save()
return {'id': str(id)}, 200
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 fill_database():
actor_data_1 = Actor(name='new actor_1', age=99, gender="men")
actor_data_2 = Actor(name='new actor_2', age=99, gender="men")
movie_data_1 = Movie(title='forsaj 9', release_date="2021")
movie_data_2 = Movie(title="forsaj 10", release_date="2022")
all_data = [actor_data_1, actor_data_2, movie_data_1, movie_data_2]
for data in all_data:
data.insert()
def post(self): #Create
user_id = get_jwt_identity()
body = request.get_json()
#movie = Movie(**body).save()
user = User.objects.get(id=user_id)
movie = Movie(**body, added_by=user)
movie.save()
id = movie.id
return {'id': str(id)}, 200
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 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_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_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 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 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 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():
body = request.get_json()
try:
new_movie = Movie(body['title'], body['release_date'])
new_movie.create()
return jsonify({
"success": True,
"status_code": 200,
"movie": new_movie.formatted()
})
except exc.SQLAlchemyError:
abort(409)
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 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)
