def post_movies(paylode):
body = request.get_json()
if not body:
abort(400)
title = body.get('title', None)
release_date = body.get('release_date', None)
if not title or not release_date:
abort(400)
try:
movie = Movie(title=title, release_date=release_date)
movie.insert()
formated_movie = [movie.format()]
return jsonify({'success': True, 'movies': formated_movie})
except:
abort(422)
def add_movie(token):
try:
body = request.get_json()
title = body.get('title')
release_date = body.get('release_date')
if body is None:
abort(422)
if not title or not release_date:
abort(422)
movie = Movie(title=title, release_date=release_date)
movie.insert()
return jsonify({'success': True, 'created': movie.id}), 201
except:
abort(400)
def create_movie(jwt):
form = request.get_json()
if not form.get('title') or not form.get('release_date'):
abort(400)
release_date = datetime.strptime(form.get('release_date'), '%Y-%m-%d')
movie = Movie(form.get('title'), release_date)
if form.get('actors'):
for actor_id in form.get('actors'):
actor = Actor.query.get(actor_id)
if actor:
movie.movies.append(actor)
movie.insert()
# TODO: Check if inserted
return jsonify({'success': True, 'movie': movie.full_details()}), 201
def home():
# if user is not logged in redirect to log in page
if 'email' not in session:
return redirect(url_for('login'))
# if user is is logged in rdirect to home page
form = SearchMovie()
my_movie = []
my_movie_dictExact = []
#when search button is clicked
if request.method == 'POST':
# if form validation fails , show error and redirect to home page again
if form.validate() == False:
return render_template("home.html",
form=form,
moviename=my_movie,
movienameExact=my_movie_dictExact)
else:
#get entered movie name and its year
moviename = form.movie_name.data
year = form.year.data
#pass it to Movie model to get exact movie and search result
m = Movie()
my_movie_dictSearch = m.querySearch(moviename)
my_movie_dictExact = m.queryExact(moviename, year)
#dict value 0 will return movies dictionary
my_movie = my_movie_dictSearch.values()[0]
# render result on home page
return render_template('home.html',
form=form,
moviename=my_movie,
movienameExact=my_movie_dictExact)
elif request.method == 'GET':
return render_template("home.html",
form=form,
moviename=my_movie,
movienameExact=my_movie_dictExact)
def dashboard(pag):
form = New_movie()
form_search = Search_form()
if request.method == 'POST':
if form.validate_on_submit():
# Movemos la imagen a static
file = request.files['image']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
hora_unix = int(time.time())
ruta = str(hora_unix) + filename
file.save(os.path.join(app.config['UPLOAD_FOLDER'], ruta))
else:
flash('Debe ser una imagen.')
# Guardamos la info en la base de datos
my_movie = Movie(request.form['name'], request.form['year'],
request.form['score'], ruta, session['user'])
db.session.add(my_movie)
try:
db.session.commit()
flash('Añadido correctamente', 'success')
except:
db.session.rollback()
else:
#mostramos errores
errores = form.errors.items()
for campo, mensajes in errores:
for mensaje in mensajes:
flash(mensaje, 'danger')
movies = Movie.query.limit(LIMITE_PELICULAS * pag).offset(
LIMITE_PELICULAS * (pag - 1)).all()
num_movies = Movie.query.count()
num_paginas = math.ceil(num_movies / LIMITE_PELICULAS)
# Obtenemos el usuario
my_user = User.query.filter_by(id=session['user']).first()
return render_template('items/dashboard.html',
form=form,
movies=movies,
num_paginas=num_paginas,
LIMITE_PELICULAS=LIMITE_PELICULAS,
form_search=form_search,
user=my_user)
def post_movies(jwt):
data = request.get_json()
title = data.get("title")
release_date = datetime.strptime(data.get("release_date"), "%Y-%m-%d")
try:
movie = Movie(title=title, release_date=release_date)
movie.insert()
return json.dumps(
{
"success": True,
"movies": [movie.format() for movie in Movie.query.all()]
},
default=str), 200
except:
return json.dumps({"success": False, "error": "An error occured"}), 500
def add_movie(jwt):
body = request.get_json()
title = body.get('title')
release_year = body.get('release_year')
if not (title and release_year):
abort(422)
try:
movie = Movie(title=title, release_year=release_year)
movie.insert()
return jsonify({
'success': True,
'movie_id': movie.id
})
except BaseException:
abort(422)
def post(self):
title = self.request.get("title")
rating = self.request.get("rating")
thumbnail = self.request.get("thumbnail")
description = self.request.get("description")
if "<script>" in title or "<script>" in description or "<script>" in rating:
title = title.replace("<script>", "")
title = title.replace("</script>", "")
thumbnail = description.replace("<script>", "")
thumbnail = description.replace("</script>", "")
description = description.replace("<script>", "")
description = description.replace("</script>", "")
rating = rating.replace("<script>", "")
rating = rating.replace("</script>", "")
movie = Movie(title=title, rating=rating, thumbnail=thumbnail, description=description)
movie.put()
return self.redirect_to("list")
def insert_movies(payload):
body = request.get_json()
if not body:
abort(400, {'message': 'no details provided in body'})
title = body.get('title')
release_date = body.get('release_date')
if not title:
abort(422, {'message': 'title not provided.'})
if not release_date:
abort(422, {'message': 'Release_date not provided'})
new_movie = (Movie(title=title, release_date=release_date))
new_movie.insert()
return jsonify({'success': True, 'movie_id': new_movie.id})
def test_patch_movieـauthorized(self):
movie = Movie(name=self.sample_movie['name'],
release_date=self.sample_movie['release_date'],
image_link=self.sample_movie['image_link'],
film_summary=self.sample_movie['film_summary'])
movie.insert()
movie_id = movie.id
c = self.client()
c.set_cookie('localhost:5000', 'user_token',
self.casting_director_token)
response = c.post(
f'/movies/{movie_id}/patch',
data=dict(name="yo",
release_date="ho",
image_link="wo",
film_summary="no"),
)
self.assertEqual(response.status_code, 202)
def testGetMoviesSuccess(self):
# Ensures there is at least one movie in the database to get.
movie = Movie('Spirited Away', datetime.datetime(2001, 7, 20))
movie.add()
movies = format(Movie.query.all())
numOfMovies = len(movies)
response = self.client().get('/movies',
headers=self.headers)
data = json.loads(response.data.decode())
# Checks the ids in the response against the ids in the database.
sameIds = all([data['movies'][i]['id'] ==
movies[i].id for i in range(0, numOfMovies)])
self.assertEqual(response.status_code, 200)
self.assertTrue(isinstance(data['movies'], list))
self.assertTrue(sameIds)
self.assertEqual(len(data['movies']), numOfMovies)
def add_new_movie(jwt):
body = request.get_json()
if not ('title' in body and 'release_date' in body):
abort(422)
title = body.get('title')
release_date = body.get('release_date')
try:
movie = Movie(title=title, release_date=release_date)
movie.insert()
movies = Movie.query.all()
formatted_movies = [movie.format() for movie in movies]
return jsonify({
"success": True,
"movies": [movie.format()],
"created": movie.id,
"total_movies": len(formatted_movies)
})
except:
abort(422)
def create_new_movie(payload):
body = request.get_json()
if body is None:
abort(422)
new_title = body.get('title', None)
new_release_date = body.get('release_date', None)
movie = Movie(title=new_title, release_date=new_release_date)
try:
movie.insert()
except BaseException:
abort(400)
return jsonify({
'success': True,
'created_movie_id': movie.id,
'created_movie_title': movie.title
}), 200
def post_new_movie(token):
body = request.get_json()
title = body.get('title', None)
release_date = body.get('release_date', None)
year = body.get('year', None)
director = body.get('director', None)
movie = Movie(title=title,
release_date=release_date,
year=year,
director=director)
movie.insert()
new_movie = Movie.query.get(movie.id)
new_movie = new_movie.format()
return jsonify({
'success': True,
'created': movie.id,
'new_movie': new_movie
})
def post_movie(jwt):
data = request.get_json()
if data is None:
abort(400)
title = data.get('title', None)
release_date = data.get('release_date', None)
if title is None or release_date is None:
abort(400)
movie = Movie(title=title, release_date=release_date)
try:
movie.insert()
return jsonify({'success': True, 'movie': movie.format()}), 201
except Exception:
abort(500)
def add_movie():
# look inside the request to figure out what the user typed
new_movie_name = request.form['new-movie']
# if the user typed nothing at all, redirect and tell them the error
if (not new_movie_name) or (new_movie_name.strip() == ""):
error = "Please specify the movie you want to add."
return redirect("/?error=" + error)
# if the user wants to add a terrible movie, redirect and tell them the error
if new_movie_name in terrible_movies:
error = "Trust me, you don't want to add '{0}' to your Watchlist".format(new_movie_name)
return redirect("/?error=" + error)
user = User.query.filter_by(email=session["user"]).first()
movie = Movie(new_movie_name, user)
db.session.add(movie)
db.session.commit()
return render_template('add-confirmation.html', movie=movie)
def post_movie(token):
if request.data:
new_movie = json.loads(request.data.decode('utf-8'))
if 'title' not in new_movie:
abort(422, "Title Required")
if 'release_date' not in new_movie:
abort(422, "Release_date Required")
title = new_movie['title']
release_date = new_movie['release_date']
movie = Movie(title=title, release_date=release_date)
movie.insert()
selection = Movie.query.order_by(Movie.id).all()
movies = [m.format() for m in selection]
return jsonify({
'success': True,
'movies': movies,
'total_movies': len(movies)
})
else:
abort(400, "Bad Request")
def add_movie(jwt):
body = request.get_json()
print(body)
if not ('title' in body and 'release_date' in body):
abort(422)
title = body.get('title')
release_date = body.get('release_date')
try:
movie = Movie(title=title, release_date=release_date)
movie.insert()
return jsonify({
"success": True,
"movie": movie.format_wo_actors()
})
except Exception as e:
print(e)
abort(422)
def test_get_movies(self):
# Add new Movie to the database
movie = Movie(
title=self.new_movie['title'],
release_date=self.new_movie['release_date'])
movie.insert()
# Send the request and load response data
response = self.client().get(
'/movies',
headers={'Authorization': f'Bearer {producer_jwt}'})
data = json.loads(response.data)
# check status code and success message
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get('success'), True)
# Check if data included
self.assertIsNotNone(data.get('movies'))
self.assertEqual(len(data.get('movies')), 1)
def post_movie(payload):
try:
data = request.get_json()
new_movie = Movie(
title = data.get('title', None),
release_date = data.get('release_date', None)
)
new_movie.insert()
print('Movie: ' + new_movie.title)
selection = Movie.query.all()
movies = []
return jsonify ({
'success': True
#'movie':[new_movie.format()]
}), 200
except Exception as e:
print(e)
abort(422)
def create_movie(jwt):
title = request.form.get('title')
release_date = request.form.get('release_date')
image_url = request.form.get('image_url')
try:
new_movie = Movie(title=title,
release_date=release_date,
image_url=image_url)
new_movie.insert()
flash(f'{title} has been created', 'success')
return redirect(url_for('get_movies'))
except:
flash(
f'{title} has not been created successfully ! check your inputs formats (for example).',
'danger')
return redirect(url_for('get_movies'))
def create_movie(payload):
body = request.get_json()
movie_title = body.get('title', None)
movie_release_date = body.get('release_date', None)
try:
if None in (movie_title, movie_release_date):
abort(400)
movie = Movie(title=movie_title,
release_date=datetime.strptime
(movie_release_date, '%Y-%m-%d'))
movie.insert()
return jsonify({'success': True, 'movies': [movie.format()]})
except Exception:
abort(422)
def create_movie(jwt):
try:
if request.method != 'POST':
abort(405)
data = request.get_json()
title = data.get('title')
release_date = data.get('release_date')
new_movie = Movie(title=title, release_date=release_date)
new_movie.insert()
except Exception:
db.session.rollback()
abort(422)
finally:
return jsonify({
'success': True,
'new_movie': new_movie.format()
}), 200
db.session.close()
def test_update_movie_executive_producer_success(self):
movie = Movie()
movie.title = 'Action Filled Movie'
movie.genre = 'Action'
movie.insert()
update_movie = {'genre': 'Adventure'}
res = self.client().patch('/movies/' + str(movie.id),
headers={
"Authorization":
"Bearer {}".format(
self.executive_producer)
},
json=update_movie)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(data['movie'][0]['genre'], 'Adventure')
self.assertEqual(res.status_code, 200)
def insert_movies(payload):
body = request.get_json()
if not body:
abort(400,
{'message': 'request does not contain a valid JSON body.'})
title = body.get('title', None)
release_date = body.get('release_date', None)
if not title:
abort(422, {'message': 'no title provided.'})
if not release_date:
abort(422, {'message': 'no "release_date" provided.'})
new_movie = (Movie(title=title, release_date=release_date))
new_movie.insert()
return jsonify({'success': True, 'created': new_movie.id})
def create_movie(payload):
"""
Add new movie to database
:return newly added movie
"""
body = request.get_json(request)
title = body.get('title')
release_date = body.get('release_date')
if title is None or release_date is None:
abort(400)
try:
new_movie = Movie(title=title, release_date=release_date)
new_movie.insert()
new_movie_formated = new_movie.format()
# Return newly created movie
return jsonify({'success': True, 'movie': new_movie_formated}), 201
except Exception:
abort(422)
def test_delete_movie_by_producer(self):
a = Movie(
title="End Game", release_date="2020-09-10"
)
a.insert()
movie_id = str(a.format()['id'])
res = self.client().delete(
'/api/movies/' + movie_id,
headers={"Authorization": "Bearer " + producer_role_token}
)
data = json.loads(res.data)
movie = Movie.query.filter(
Movie.id == movie_id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['id'], a.format()['id'])
self.assertEqual(movie, None)
def post_movie(self):
body = request.get_json()
new_title = body.get('title')
new_release_year = body.get('release_year')
if ((new_title is None)) or (new_release_year is None):
abort(422)
try:
movie = Movie(title=new_title, release_year=new_release_year)
movie.insert()
new_movie = movie.format()
return jsonify({
'success': True,
'movie': new_movie,
}), 200
except Exception:
abort(422)
def create_movie(payload):
body = request.get_json()
movie_title = body.get('title', None)
movie_release_date = body.get('release_date', None)
movie_actors = body.get('actors', None)
search = body.get('search', None)
if search:
movies = Movie.query.filter(Movie.title.ilike(f'%{search}%')).all()
current_movies = paginate_movies(request, movies)
return jsonify({
'success': True,
'movies': current_movies,
'total_movies': len(movies)
})
else:
if (movie_title is None) or (movie_release_date is None):
abort(400)
movie = Movie(release_date=movie_release_date, title=movie_title)
try:
if movie_actors:
for actor_id in movie_actors:
actor = Actor.query.filter(
Actor.id == actor_id).one_or_none()
if not actor:
abort(400)
movie.actors.append(actor)
movie.insert()
movies = Movie.query.order_by(Movie.id).all()
current_movies = paginate_movies(request, movies)
return jsonify({
'success': True,
'created': movie.id,
'movies': current_movies,
'total_movies': len(movies)
})
except Exception:
abort(500)
def scrape_imdb():
items = pd.read_csv(os.path.join(settings.BASE_DIR, "movies.csv"),
usecols=[0, 1],
index_col=0)
links = pd.read_csv(os.path.join(settings.BASE_DIR, "links.csv"),
index_col=0,
usecols=[0, 1],
dtype={'imdbId': str})
merged_df = pd.merge(items,
links,
left_index=True,
right_index=True,
how='inner')
for idx, row in merged_df.iterrows():
if int(row['title'][-5:].rstrip(')')) >= 2010:
try:
if not os.path.exists(
os.path.join(settings.BASE_DIR,
"movie_posters/%s.jpg" % str(idx))):
html = urlopen(BASEURL % row['imdbId'])
soup = BeautifulSoup(html.read())
if float(
soup.findAll("span", {"itemprop": "ratingValue"
})[0].text) > 8.0:
image_url = soup.findAll(
"div",
{"class": "poster"})[0].findAll("img")[0]["src"]
print image_url
urlretrieve(
image_url,
os.path.join(settings.BASE_DIR,
"movie_posters/%s.jpg" % str(idx)))
m = Movie(movielens_id=idx,
name=row['title'],
url=BASEURL % row['imdbId'],
image="%s.jpg" % str(idx))
m.save()
except:
print "couldn't fetch from " + BASEURL % row['imdbId']
