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