def create_movie():
try:
data = request.get_json()
movie = Movie(data.get('title'), data.get('release_date'))
movie.create()
return jsonify({'success': True, 'created': movie.id}), 201
except:
print(sys.exc_info())
abort(422)
def create(self):
if request.method == 'POST':
if request.form.get('message'):
Movie.create(
title=request.form['title'],
release=request.form['release'],
description=request.form['description'],
poster=request.form['poster']
)
next = request.form.get('next') or self.dashboard_url()
return redirect(next)
def test_executive_should_get_all_movies(self):
movie = Movie(
title="Test Title",
release_date="2012-04-23 18:25:43.511")
movie.create()
res = self.client().get(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
movies = Movie.query.all()
self.assertEqual(len(data['movies']), len(movies))
def add_movie(jwt):
"""Creates a 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(movie_title: str, year: str = "", depth: int = 0) -> bool:
"""
Search for and add a movie. Called recursively with a refined
search if results aren't found on the first try.
:param movie_title: Title of the movie
:param year: Narrow down the search with a release year
:param depth: Current level of recursion
:return:
"""
url = IMDB_API_URL + '&t={}&y='.format(movie_title, year)
r = requests.get(url).json()
if r.get('Response') == 'False':
depth += 1
if depth < 3:
# Recurse
return True, add_movie(custom_google_search(
movie_title + " " + year, "add"),
depth=depth)
return False, custom_google_search(movie_title + " " + year)
try:
for genre in r['Genre'].split(', '):
if genre not in genres:
genres.append(genre)
return True, Movie.create(name=r['Title'],
genre=r['Genre'],
imdb_id=r['imdbID'])
except IntegrityError:
return False, {'text': "This movie has already been added!"}
def add_movie():
"""
Add new movie
"""
data = get_request_data()
''
if 'name' in data.keys():
name = data['name']
if 'genre' in data.keys():
genre = data['genre']
if 'year' in data.keys():
year = data['year']
# use this for 200 response code
data_movie = {'name': name, 'genre': genre, 'year': year}
try:
new_record = Movie.create(**data_movie)
new_movie = {
k: v
for k, v in new_record.__dict__.items()
if k in MOVIE_FIELDS
}
return make_response(jsonify(new_movie), 200)
except:
err = 'Cant create movie'
return make_response(jsonify(error=err), 400)
else:
err = 'No year specified'
return make_response(jsonify(error=err), 400)
else:
err = 'No genre specified'
return make_response(jsonify(error=err), 400)
else:
err = 'No name specified'
return make_response(jsonify(error=err), 400)
def add_movie():
"""
Add new movie
"""
data = get_request_data()
new_record = Movie.create(**data)
new_movie = {
k: v
for k, v in new_record.__dict__.items() if k in MOVIE_FIELDS
}
return make_response(jsonify(new_movie), 200)
class TestCapstone(unittest.TestCase):
def setUp(self):
self.app = APP
self.client = self.app.test_client
database_name = "capstone_test"
database_username = "******"
database_password = "******"
self.database_path = "postgresql://{}:{}@{}/{}".format(
database_username,
database_password,
'localhost:5432',
database_name)
setup_db(self.app, self.database_path)
with self.app.app_context():
db.drop_all()
db.create_all()
self.executive_token = os.getenv("EXECUTIVE_TOKEN")
self.director_token = os.getenv("DIRECTOR_TOKEN")
self.assistant_token = os.getenv("ASSISTANT_TOKEN")
self.existing_actor = Actor(name="Brad", age=45, gender="M")
self.existing_actor.create()
self.existing_movie = Movie(
title="Once Upon",
release_date="2019-10-04 19:09:33.77486")
self.existing_movie.create()
def tearDown(self):
with self.app.app_context():
db.session.rollback()
db.session.close()
def test_precreated_actor_exists(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
self.assertIsNotNone(actor)
def test_precreated_movie_exists(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.77486").first()
self.assertIsNotNone(movie)
def test_assistant_should_get_all_actors(self):
actor = Actor(name="Abls", age=123, gender="M")
actor.create()
res = self.client().get(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.assistant_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
actors = Actor.query.all()
self.assertEqual(len(data['actors']), len(actors))
def test_director_should_get_all_actors(self):
actor = Actor(name="Abls", age=123, gender="M")
actor.create()
res = self.client().get(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.director_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
actors = Actor.query.all()
self.assertEqual(len(data['actors']), len(actors))
def test_executive_should_get_all_actors(self):
actor = Actor(name="Abls", age=123, gender="M")
actor.create()
res = self.client().get(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
actors = Actor.query.all()
self.assertEqual(len(data['actors']), len(actors))
def test_assistant_should_get_all_movies(self):
movie = Movie(
title="Test Title",
release_date="2012-04-23 18:25:43.511")
movie.create()
res = self.client().get(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.assistant_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
movies = Movie.query.all()
self.assertEqual(len(data['movies']), len(movies))
def test_director_should_get_all_movies(self):
movie = Movie(
title="Test Title",
release_date="2012-04-23 18:25:43.511")
movie.create()
res = self.client().get(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.director_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
movies = Movie.query.all()
self.assertEqual(len(data['movies']), len(movies))
def test_executive_should_get_all_movies(self):
movie = Movie(
title="Test Title",
release_date="2012-04-23 18:25:43.511")
movie.create()
res = self.client().get(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
movies = Movie.query.all()
self.assertEqual(len(data['movies']), len(movies))
def test_assistant_cant_create_actor(self):
res = self.client().post(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.assistant_token)},
json=sample_actor)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
def test_director_should_create_actor(self):
res = self.client().post(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.director_token)},
json=sample_actor)
data = json.loads(res.data)
self.assertEqual(res.status_code, 201)
self.assertTrue(data['success'])
def test_executive_should_create_actor(self):
res = self.client().post(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)},
json=sample_actor)
data = json.loads(res.data)
self.assertEqual(res.status_code, 201)
self.assertTrue(data['success'])
createdId = data['created']
actor = Actor.query.get(createdId)
self.assertIsNotNone(actor)
self.assertEqual(actor.id, createdId)
def test_incorrect_create_actor(self):
res = self.client().post(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)})
self.assertEqual(res.status_code, 400)
data = json.loads(res.data)
self.assertFalse(data['success'])
def test_assistant_cant_create_movie(self):
res = self.client().post(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.assistant_token)},
json=sample_movie)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
def test_director_cant_create_movie(self):
res = self.client().post(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.director_token)},
json=sample_movie)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
def test_executive_should_create_movie(self):
res = self.client().post(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)},
json=sample_movie)
data = json.loads(res.data)
self.assertEqual(res.status_code, 201)
self.assertTrue(data['success'])
createdId = data['created']
movie = Movie.query.get(createdId)
self.assertIsNotNone(movie)
self.assertEqual(movie.id, createdId)
def test_incorrect_create_movie(self):
res = self.client().post(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)})
self.assertEqual(res.status_code, 400)
data = json.loads(res.data)
self.assertFalse(data['success'])
def test_assistant_cant_patch_actor(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
res = self.client().patch(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.assistant_token)},
json=dict(
id=actor.id))
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
def test_director_should_patch_actor(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
res = self.client().patch(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.director_token)},
json=dict(
id=actor.id,
name="NewName",
age=22,
gender="F"))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
patched_actor = data['patched']
self.assertEqual(actor.id, patched_actor.get('id'))
self.assertEqual("NewName", patched_actor.get('name'))
self.assertEqual(22, patched_actor.get('age'))
self.assertEqual("F", patched_actor.get('gender'))
def test_executive_should_patch_actor(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
res = self.client().patch(
'/actors',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)},
json=dict(
id=actor.id,
name="NewName",
age=22,
gender="F"))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
patched_actor = data['patched']
self.assertEqual(actor.id, patched_actor.get('id'))
self.assertEqual("NewName", patched_actor.get('name'))
self.assertEqual(22, patched_actor.get('age'))
self.assertEqual("F", patched_actor.get('gender'))
def test_assistant_cant_patch_movie(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.77486").first()
new_title = "New Title"
new_release_date = "2020-11-04 19:09:33.77486"
res = self.client().patch(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.assistant_token)},
json=dict(
id=movie.id,
title=new_title,
release_date=new_release_date))
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertFalse(data['success'])
def test_director_should_patch_movie(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.774860").first()
new_title = "New Title"
new_release_date = "2020-11-04 19:09:33.774860"
res = self.client().patch(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.director_token)},
json=dict(
id=movie.id,
title=new_title,
release_date=new_release_date))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
newMovie = Movie.query.get(movie.id)
self.assertEqual(newMovie.title, new_title)
self.assertEqual(newMovie.release_date.strftime(
"%Y-%m-%d %H:%M:%S.%f"), new_release_date)
def test_executive_should_patch_movie(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.774860").first()
new_title = "New Title"
new_release_date = "2020-11-04 19:09:33.774860"
res = self.client().patch(
'/movies',
headers={
"Authorization": "Bearer {}".format(
self.executive_token)},
json=dict(
id=movie.id,
title=new_title,
release_date=new_release_date))
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
newMovie = Movie.query.get(movie.id)
self.assertEqual(newMovie.title, new_title)
self.assertEqual(newMovie.release_date.strftime(
"%Y-%m-%d %H:%M:%S.%f"), new_release_date)
def test_assistant_cant_delete_actor(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
self.assertIsNotNone(actor)
res = self.client().delete('/actors/{}'.format(
actor.id),
headers={"Authorization": "Bearer {}".format(
self.assistant_token)})
self.assertEqual(res.status_code, 401)
def test_director_cant_delete_actor(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
self.assertIsNotNone(actor)
res = self.client().delete('/actors/{}'.format(
actor.id),
headers={"Authorization": "Bearer {}".format(
self.director_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['deleted']['id'], actor.id)
def test_executive_should_delete_actor(self):
actor = Actor.query.filter_by(name="Brad", age=45, gender="M").first()
self.assertIsNotNone(actor)
res = self.client().delete('/actors/{}'.format(
actor.id),
headers={"Authorization": "Bearer {}".format(
self.executive_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['deleted']['id'], actor.id)
def test_assistant_cant_delete_movie(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.77486").first()
self.assertIsNotNone(movie)
res = self.client().delete('/movies/{}'.format(
movie.id),
headers={"Authorization": "Bearer {}".format(
self.assistant_token)})
self.assertEqual(res.status_code, 401)
def test_director_cant_delete_movie(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.77486").first()
self.assertIsNotNone(movie)
res = self.client().delete('/movies/{}'.format(
movie.id),
headers={"Authorization": "Bearer {}".format(
self.director_token)})
self.assertEqual(res.status_code, 401)
def test_executive_should_delete_movie(self):
movie = Movie.query.filter_by(
title="Once Upon",
release_date="2019-10-04 19:09:33.77486").first()
self.assertIsNotNone(movie)
res = self.client().delete('/movies/{}'.format(
movie.id),
headers={"Authorization": "Bearer {}".format(
self.executive_token)})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['deleted']['id'], movie.id)
def test_nonexisting_route(self):
res = self.client().get('/nonexisting')
self.assertEqual(res.status_code, 404)
def main(plex_id=None, force=False):
logger = logging.getLogger("plex-imdb-updater")
db.create_connection("db.sqlite")
# Connect to the Plex server
logger.info("Connecting to the Plex server at '{base_url}'...".format(base_url=PLEX_URL))
try:
plex = PlexServer(PLEX_URL, PLEX_TOKEN)
except:
logger.error("No Plex server found at: {base_url}".format(base_url=PLEX_URL))
return
libraries = []
# Get list of movies from the Plex server
for library_name in LIBRARY_NAMES:
logger.info("Retrieving a list of movies/shows from the '{library}' library in Plex...".format(library=library_name))
try:
libraries.append(plex.library.section(library_name))
except:
logger.warning("The '{library}' library does not exist in Plex.".format(library=library_name))
continue
if not DRY_RUN:
conn_db = sqlite3.connect(PLEX_DATABASE_FILE)
conn_db.isolation_level = None
database = conn_db.cursor()
else:
database = None
success = 0
failed = 0
for library in libraries:
pbar = tqdm(library.all(), postfix=["", ""])
pbar.set_description("Processing " + library.title)
for plex_object in pbar:
pbar.postfix[0] = plex_object.title
pbar.postfix[1] = "Processing"
# first do a check if we specified a plex id
if plex_id is not None and str(plex_object.ratingKey) != plex_id:
continue
# check if movie or show library
if plex_object.TYPE is "movie":
is_movie_library = True
if not force and not should_update_media(plex_object.TYPE, plex_object):
continue
else:
is_movie_library = False
if not force and not should_update_media(plex_object.TYPE, plex_object):
continue
# resolve plex object to right identifiers
imdb_id, tmdb_id, tvdb_id = resolve_ids(is_movie_library, plex_object, force, pbar)
# if no imdb_id is found for plex guid, reset all ratings
if not imdb_id:
logger.debug("Missing IMDB ID. Skipping media object '{pm.title}'.".format(pm=plex_object))
if not DRY_RUN:
db.reset_rating(database, plex_object)
db.set_locked_fields(database, plex_object)
failed = failed + 1
continue
logger.debug("Getting ratings for imdb id '{imdb_id}'".format(imdb_id=imdb_id))
rating = None
imdb_object = None
# Check if we need to update this
if force or should_update_media(plex_object.TYPE, plex_object):
# first trying to get it from OMDB
if config.OMDB_API_KEY:
imdb_object = omdb.get_imdb_rating_from_omdb(imdb_id, pbar)
if imdb_object is not None:
logger.debug("{im}\t{pm.title}\tOMDB".format(pm=plex_object, im=imdb_object["imdb_rating"]))
rating = imdb_object["imdb_rating"]
# if no rating yet, try to get it directly from IMDB
if (imdb_object is None or rating is None) and imdb.title_exists(imdb_id):
imdb_object = imdb.get_title_ratings(imdb_id)
if imdb_object is not None and "rating" in imdb_object:
logger.debug("{im}\t{pm.title}\tIMDB".format(pm=plex_object, im=imdb_object["rating"]))
rating = imdb_object["rating"]
# reset in database if nothing could be fetched
if rating is None and not DRY_RUN:
logger.warning("Media not found on IMDB. Skipping '{pm.title} ({imdb_id})'.".format(
pm=plex_object, imdb_id=imdb_id))
if not DRY_RUN:
db.reset_rating(database, plex_object)
db.set_locked_fields(database, plex_object)
failed = failed + 1
continue
if is_movie_library:
# do update in local library for future reference
db_movie = Movie.select().where(Movie.plex_id == plex_object.ratingKey)
if db_movie.exists():
db.update_db_rating(db_movie.get(), rating)
else:
Movie.create(
title=plex_object.title,
plex_id=plex_object.ratingKey,
imdb_id=imdb_id,
rating=rating,
tmdb_id=tmdb_id,
release_date=plex_object.originallyAvailableAt
)
else:
# do update in local library for future reference
db_show = Show.select().where(Show.plex_id == plex_object.ratingKey)
if db_show.exists():
db.update_db_rating(db_show.get(), rating)
else:
Show.create(
title=plex_object.title,
plex_id=plex_object.ratingKey,
imdb_id=imdb_id,
rating=rating,
release_date=plex_object.originallyAvailableAt,
tvdb_id=tvdb_id
)
if not DRY_RUN:
# if not dry run, do a update in Plex' DB
db.set_rating_and_imdb_image(database, plex_object, rating)
db.set_locked_fields(database, plex_object)
# now try to fetch seasons
if not is_movie_library:
for season in plex_object.seasons():
# don't do anything with specials
if season.index is 0:
logger.debug("Skipping specials")
continue
# check if enabled in settings
if EPISODE_RATINGS:
logger.debug("Getting episodes for {p.title} for season {season}".format(
p=plex_object, season=season.index))
imdb_episodes = None
for episode in season.episodes():
update_success = update_episode_rating(database, episode, imdb_episodes, imdb_id,
plex_object, season)
if update_success:
success = success + 1
else:
failed = failed + 1
if not DRY_RUN:
while len(plex.sessions()) is not 0:
logger.info("Plex Media Server in use... waiting 10 seconds before commiting changes")
sleep(10)
conn_db.commit()
if not DRY_RUN:
database.close()
logger.info("Finished updating. {success} updated and {failed} failed".format(success=success, failed=failed))
