def new_movie(movie_name, year, description, cover_picture, genre, cast, directors, created_by='Pankaj Gupta'): try: movie = Movies(Movie_name=movie_name, Created_by=created_by, Year=year, Description=description, Cover_picture=cover_picture, Genre=genre, Cast=cast, Directors=directors) movie.save() return {'Success':True} except: raise InvalidQueryError("Check for movie details")
def edit_movie(movie_id, movie_name=None, created_by=None, year=None, description=None, cover_picture=None, genre=None, rating=None, reviews_rating=None, user_rating=None, social_rating=None, deleted=None, cast=None, directors=None): try: movie = Movies.objects(id=movie_id) if movie_name: movie.update(Movie_name=movie_name) if created_by: movie.update(Created_by=created_by) if year: movie.update(Year=year) if description: movie.update(Description=description) if cover_picture: movie.update(Cover_picture=cover_picture) if rating: movie.update(Rating=rating) if reviews_rating: movie.update(Reviews_rating=reviews_rating) if user_rating: movie.update(User_rating=user_rating) if social_rating: movie.update(Social_rating=social_rating) if deleted: movie.update(Deleted=deleted) if cast: movie.update(Cast=cast) return {'Success':True} except: raise DoesNotExist("Movie does not exist")
def add_movie(payload): body = request.get_json() print(body) release_date = request.get_json()['release_date'] actor_id = request.get_json()['actor_id'] movie = Movies(title=title, release_date=release_date, actor_id=actor_id) movie.insert() return jsonify({ 'title': movie.title, 'release_date': movie.release_date, 'actor_id': movie.actor_id })
def test_edit_movie_unauthorized(self): new_movie = Movies(title='getting in the world!', release='2005') new_movie.insert() movie_id = new_movie.id res = self.client().patch( '/movies/{}'.format(movie_id), json={ 'title': 'getting in the world!', 'release': '1999' }, headers={'Authorization': 'Bearer ' + low_token}) data = json.loads(res.data) self.assertEqual(res.status_code, 401) self.assertEqual(data['success'], False) self.assertEqual(data['message'], unauthorized)
def post_movies(token): try: body = request.get_json() new_title = body.get('title', None) new_date = body.get('release_date', None) movie = Movies(title=new_title, release_date=new_date) movie.insert() movie = movie.format() return jsonify({ 'success': True, 'created': movie, }) except: abort(422)
def add_movie(jwt): body = request.get_json() new_title = body.get('title', None) new_release_date = body.get('release_date', None) try: movie = Movies(title=new_title, release_date=new_release_date) movie.insert() return jsonify({ 'success': True, 'created': movie.id, }) except: abort(422)
def test_edit_movies(self): # create new movie to update it move = Movies(title='test', release_date='test') move.insert() # get inserted movie id m_id = move.id update_movie = { 'title': 'update title', } res = self.client().patch( '/movies/{}'.format(m_id), headers={"Authorization": "Bearer " + Executive_Producer}, json=update_movie) data = json.loads(res.data) # check state and sucsses true self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True)
def add_movie(): form = MovieUploadForm() form.category.choices = get_category_list() if form.validate_on_submit(): movie = form.movie.data thumbnail = form.thumbnail.data if movie and thumbnail: movie_data = movie.read(MOBICLIP_HEADER_SIZE) thumbnail_data = thumbnail.read() if validate_mobiclip(movie_data): # Get the Mobiclip's length from header. length = get_mobiclip_length(movie_data) # Read the remaining file data. remaining = movie.read() movie_data += remaining # Insert this movie to the database. # For right now, we will assume defaults. db_movie = Movies( title=form.title.data, length=length, aspect=True, genre=0, sp_page_id=0, ds_dist=False, staff=False, ) db.session.add(db_movie) db.session.commit() db.session.add( CategoryMovies(category_id=form.category.data, movie_id=db_movie.movie_id)) db.session.commit() # Now that we've inserted the movie, we can properly move it. save_movie_data(db_movie.movie_id, thumbnail_data, movie_data) # Finally, allow it for indexing. es.index( index="tv_index", body={ "title": form.title.data, "movie_id": db_movie.movie_id }, ) return redirect("/theunderground/movies") else: flash("Invalid movie!") else: flash("Error uploading movie!") return render_template("movie_add.html", form=form)
def update_movie(payload, id): try: movie = Movies.query.filter_by(id=id).first() uptated_title = request.args.get("title") uptated_release_date = request.args.get("release_date") uptated_actor_id = request.args.get("actor_id") uptaded_movie = Movies(title=uptated_title, release_date=uptated_release_date, actor_id=uptated_actor_id) uptaded_movie.update() return jsonify({'code': 'success'}) except Exception: abort(422)
def add_movies(jwt): data = request.get_json() if 'title' not in data: abort(422) if 'release_date' not in data: abort(422) new_title = data.get('title') new_release_date = data.get('release_date') try: new_movie = Movies(title=new_title, release_date=new_release_date) new_movie.insert() except: abort(422) return jsonify({'success': True, 'movie': new_movie.format()}), 200
def submit_movies(jwt): body = request.get_json() new_name = body.get('name', None) new_release_date = body.get('release_date', None) if new_name is None or new_release_date is None: abort(400) try: movies = Movies(name=new_name, release_date=new_release_date) movies.insert() return jsonify({'success': True, 'movies': movies.format()}), 200 except: abort(422)
def new_movie(payload): body = request.get_json() title = body.get('title', None) release_date = body.get('release_date', None) if 'title' not in body or 'release_date' not in body: abort(400) if not title or not release_date: abort(422) movie = Movies(title=title, release_date=release_date) movie.insert() return jsonify({ 'success': True, 'movie': movie.format(), 'total_movies': len(Movies.query.all()) })
def insert_Movies(payload): """ Insert movie information """ body = request.get_json() try: movie = Movies(name=body["name"], length=body["length"], genre=body["genre"]) actors = Actors.query.filter( Actors.id == body["actor_ID"]).one_or_none() if actors is None: abort(404) movie.Actors = [actors] movie.insert() return jsonify({"success": True}) except Exception: abort(404)
def update_vote_average_count(id_movie, user_review, vote): vote = float(vote) get_vote = Movies.select( Movies.vote_average).where(Movies.id == id_movie).limit(1).get() get_average = Movies.select( Movies.vote_count).where(Movies.id == id_movie).limit(1).get() new_vote = ((get_vote.vote_average * get_average.vote_count) + 1) / (get_average.vote_count + 1) updating_vote = Movies.update(vote_average=new_vote).where( Movies.id == id_movie) updating_vote.execute() Movies.update(vote_count=get_average.vote_count + 1).where(Movies.id == id_movie).execute() Reviews.create(review=user_review, score=vote, user_id=session['id'], movie_id=id_movie) return 'Done'
def db_setup(): with open("movie_plots.csv", newline='') as csvfile: movies = csv.reader(csvfile, delimiter=',') movies = list(movies) for movie in movies: newentery = Movies(movie[0], movie[1], movie[2], movie[3], movie[4], movie[5], movie[6], movie[7]) db.session.add(newentery) db.session.commit()
def create_movies(payload): body = request.get_json() title = body.get('title', None) release_date = body.get('release_date', None) if title is None \ or release_date is None: abort(400) try: movie = Movies(title=title, release_date=release_date) movie.insert() return jsonify({ 'success': True, 'created': movie.id, 'message': 'Movie created' }), 201 except Exception as error: print(error) abort(422)
def post_movie(jwt): data = request.get_json() title = data.get('title', None) release_date = data.get('release_date', None) if title is None or release_date is None: abort(400) movie = Movies(title=title, release_date=release_date) try: movie.insert() return jsonify({ 'success': True, 'movie': movie.format() }), 201 except Exception: abort(500)
def create_movies(payload): req = request.get_json() new_title = req.get('title') new_release_date = req.get('release_date') try: new_movie = Movies(title=new_title, release_date=new_release_date) new_movie.insert() return jsonify({ 'success': True, 'new_movie': [new_movie.format()] }), 200 except BaseException: abort(405) finally: db.session.close()
def new_movie_review(movie_id, body, review_author='Pankaj Gupta'): try: comments_analysis.update_movie_review(movie_id=movie_id,sentence=body,review_author=review_author) rating = reviews_rating(movie_id=movie_id) movie = Movies.objects(id=movie_id) movie.update(Rating=rating) movie.update(Reviews_rating=rating) return {"Success":True} except: raise DoesNotExist("Movie does not exist.")
def get_movies(): movies = Movies.query.all() list_of_movies = [] for movie in movies: list_of_movies.append(movie.format()) try: if request.get_json() is None: abort(422) else: data = request.get_json() new_title = data.get('title', None) new_release_date = data.get('release_date', None) new_genre = data.get('genre', None) new_movie = Movies(name = new_title, age = new_release_date, gender = new_genre) Movies.insert(new_actor) list_of_movies = Movies.query.all() return jsonify({'success': True, 'movies': list_of_movies}) return jsonify({'success': True, 'movies': list_of_movies})
def post_movie(jwt): # get the json object form the request body body = request.get_json() # get the title and relased date from the body request title = body.get('title', None) relase_date = body.get('relase_date', None) try: # insert the data from request and try to insert new record in # database movie = Movies(title=title, relase_date=relase_date) movie.insert() return jsonify({"success": True, "new movie": movie.format()}) except BaseException: abort(422)
def add_movie(token): try: new_movie = request.get_json() title = new_movie.get('title') genre = new_movie.get('genre') release_date = new_movie.get('release_date') movie_add = Movies( title=title, genre=genre, release_date=release_date ) movie_add.insert() return jsonify({ 'success': True, 'message': 'The Movie is successfully created' }) except Exception: abort(422)
def setUp(self): self.app = create_app() self.client = self.app.test_client self.database_path = database_path = "sqlite:///capstone_test.db" self.db = setup_db(self.app, self.database_path) self.cur_actor = { 'id': 1, 'name': 'Aleks', 'age': 30, 'gender': 'male' } self.cur_movie = { 'id': 1, 'title': 'Rocky 14', 'releasedate': '11-06-2020' } self.cur_actor = Actors(name='Aleks', age=30, gender='male') self.cur_actor.insert() self.cur_movie = Movies(title='Rocky 14', releasedate='11-06-2020') self.cur_movie.insert() self.new_actor = { 'name': 'lithika', 'age': 10, 'gender': 'female' } self.new_movie = { 'title': 'Frozen II', 'releasedate': '12-06-2019' } self.update_actor = { 'name': 'Sam' } self.update_movie = { 'title': 'Cars' }
def post_movie(payload): form = request.get_json() title = form.get('title') release_date = form.get('release_date') if title is None or release_date is None: abort(422) try: movie = Movies(title=title, release_date=release_date).insert() all_movies = Movies.query.all() movies = [movie.format() for movie in all_movies] return jsonify({'success': True, 'movies': movies}), (200) except Exception: abort(422)
def setUp(self): """Define test variables and initialize app.""" self.app = create_app() self.client = self.app.test_client self.database_name = "casting_test" self.database_path = "postgres://{}/{}".format('localhost:5432', self.database_name) self.headers = { 'Content-Type': 'application/json', 'Authorization': 'Bearer', 'Token': token} self.actor = Actors( name='Amy', age='50', gender='Female' ) self.movie = Movies( title='Grinch', release_date='25' ) self.new_actor = { 'name': 'Jason', 'age': '32', 'gender': 'Male' } self.new_movie = { 'title': 'Holiday', 'release_date': '28' } with self.app.app_context(): self.db = SQLAlchemy() self.db.init_app(self.app) # create all tables self.db.create_all() self.actor.insert() self.movie.insert()
def add_movie(request): """Adds a new movie to the database""" title = request.POST.get('title', '') year = request.POST.get('year', '') genre = request.POST.get('genre', '') new_movie = Movies(title=title, year=year, genre=genre) new_movie.save() # Generate New Record HTML; send back to Front-end new_record = Movies.objects.all().order_by('-id')[0] movie = {'id': new_record.id, 'title': new_record.title, 'year': new_record.year, 'genre': new_record.genre, 'space_free_title': new_record.space_free_title} new_record_HTML = render(request, 'new_row.html', {'movie': movie}) # return as json return HttpResponse(json.dumps({'result': 'Movie added!', 'html': str(new_record_HTML.content), 'movie_id': new_record.id}))
def add_movie(jwt): get_input = request.get_json() release_date = get_input["release_date"] title = get_input["title"] new_movie = Movies(title=title, release_date=release_date) if new_movie.title == '' or new_movie.release_date == '': abort(400) try: new_movie.insert() return jsonify({"success": True, "movie": new_movie.format()}), 201 except Exception as e: print(e) abort(422)
def setUp(self): self.app = create_app() self.client = self.app.test_client self.database_name = "capstone_test" self.database_path = "postgres://{}:{}@{}/{}".format( 'postgres', '6541', 'localhost:5432', self.database_name) setup_db(self.app, self.database_path) self.type = None self.json_create_actor = Actor("Ahmed", "22", "male", self.type).format() self.json_edit_actor_with_new_age = Actor("Ahmed", "29", "male", self.type).format() self.json_create_movie = Movies("oil", "2015-08-07 05:00:01").format() self.json_edit_movie = Movies("oil", "2020-08-09 05:00:01").format() # binds the app to the current context with self.app.app_context(): self.db = SQLAlchemy() self.db.init_app(self.app) # create all tables self.db.create_all()
def add_movie(token): body = request.get_json() if body: new_title = body.get('title', None) new_release_date = body.get('release_date', None) if (new_title) and (new_release_date): new_movie = Movies(title=new_title, release_date=new_release_date) try: new_movie.insert() succcess = True except: abort(422) return jsonify({'success': True, 'movie id': new_movie.id}) else: abort(400) else: abort(422)
def create_movie(jwt): # get json object body = request.get_json() new_title = body.get('title') new_date = body.get('date') # check whether user input is complete if new_title is None: abort(400) if new_date is None: abort(400) try: # add row in data base movie = Movies(title=new_title, date=new_date) movie.insert() # return json response return jsonify({"success": True, "movie_id": movie.id}), 201 except Exception: abort(422)
def add_movie(token): try: body = request.get_json() print(body) new_title = body.get('title') print(new_title) new_release_date = body.get('release_date') print(new_release_date) movie = Movies(title=new_title, release_date=new_release_date) Movies.insert(movie) return jsonify({ 'success': True, 'movie_added': Movies.format(movie) }) except Exception: abort(422)
def new_movie(movie_name, year, description, cover_picture, genre, cast, directors, created_by='Pankaj Gupta'): try: movie = Movies(Movie_name=movie_name, Created_by=created_by, Year=year, Description=description, Cover_picture=cover_picture, Genre=genre, Cast=cast, Directors=directors) movie.save() return {'Success': True} except: raise InvalidQueryError("Check for movie details")
def new_movie_review(movie_id, body, review_author='Pankaj Gupta'): try: comments_analysis.update_movie_review(movie_id=movie_id, sentence=body, review_author=review_author) rating = reviews_rating(movie_id=movie_id) movie = Movies.objects(id=movie_id) movie.update(Rating=rating) movie.update(Reviews_rating=rating) return {"Success": True} except: raise DoesNotExist("Movie does not exist.")
def create_question(): body = request.get_json() title = body.get('title', '') rating = body.get('rating', '') if ((title == '') or (rating == '')): abort(422) try: movie_insert = Movies(title=title, rating=rating) movie_insert.insert() return jsonify({ 'success': True, 'inserted': movie_insert.id, 'message': 'movie created' }), 201 except: abort(422)
def get_recommendation(user_id): user = User.objects(id=user_id).first() user_interest = user.Interest movies = Movies.objects(Genre__in=user_interest).order_by('-Rating') movie_list=[] for movie in movies: movie_detail={} movie_detail["Movie_name"]=movie.Movie_name movie_detail["Rating"]=movie.Rating movie_detail["Genre"]=movie.Genre movie_list.append(movie_detail) return {"movie_list":movie_list,"user_interest":user.Interest}
def get_movie_details(movie_id, offset, limit): try: movie = Movies.objects(id=movie_id).first() return { 'id': movie_id, 'movie_name': movie.Movie_name, 'genre': movie.Genre, 'description': movie.Description, 'cover_picture': movie.Cover_picture, 'rating': movie.Rating, 'cast': movie.Cast, 'directors': movie.Directors } except: raise DoesNotExist("Movie does not exist")