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))