def movies_vote(self, request):
"""Exposes an API endpoint to insert the new votes from the user
Args:
request: A list of the movies the user currently likes and cast a vote.
Returns:
A void message if everthing goes well or an error.
"""
#get jwt and validates if user exists
selected_user = self.validate_jwtoken(self.request_state)
list_of_voted_movies_query = MovieRankingUser.query(MovieRankingUser.user==selected_user.key).fetch()
for user_movie_relation in list_of_voted_movies_query:
current_movie = Movie.query(Movie.key==user_movie_relation.movie).get()
current_counter = current_movie.number_of_users_who_voted
current_movie.number_of_users_who_voted = current_counter - 1
current_movie.put()
user_movie_relation.key.delete()
for voted_movie in request.voted_movies:
current_movie = Movie.get_by_id(voted_movie.movie_identifier)
current_counter = current_movie.number_of_users_who_voted
current_movie.number_of_users_who_voted = current_counter + 1
new_movie_user_vote = MovieRankingUser(user=selected_user.key,movie=current_movie.key)
current_movie.put()
new_movie_user_vote.put()
return VoteResponse(status_msg='Vote casted with success.')
def get(self, name):
if not users.get_current_user():
self.redirect(users.create_login_url(self.request.uri))
results = search_metacritic(name, 'movie')
output = []
for result in results:
query = Img.all()
query.filter('url =', result[1])
img = query.fetch(1)[0]
query = Movie.all()
query.filter('cover =', img)
if not query.count():
movie = Movie(name=str(result[0]),cover=img,score=str(result[2]))
movie.put()
else:
movie = query.fetch(1)[0]
output.append([img.key().id(), result[0], movie.key().id()])
template_values = {'results': output}
path = os.path.join(os.path.dirname(__file__), 'search.html')
self.response.out.write(template.render(path, template_values))
def users_get(self, request):
"""Exposes an API endpoint to obtain the details of the User
Args:
request: Void message request, because the info comes from the JWT
Returns:
An Instance containing the User Details.
"""
#get jwt and validates if user exists
selected_user = self.validate_jwtoken(self.request_state)
list_of_voted_movies_query = MovieRankingUser.query(MovieRankingUser.user==selected_user.key).fetch()
list_of_voted_movies = []
list_of_voted_movie_keys_to_exclude = []
for user_movie_relation in list_of_voted_movies_query:
current_movie = Movie.query(Movie.key==user_movie_relation.movie).get()
list_of_voted_movies.append(current_movie.to_message())
#puts the voted movie keys in a list to exclude
list_of_voted_movie_keys_to_exclude.append(current_movie.key)
#all movies in the system
total_list_of_movies = Movie.query().order(Movie.title)
#removes the voted movies from the total
list_of_not_voted_movies_query = [res for res in total_list_of_movies.fetch() if res.key not in list_of_voted_movie_keys_to_exclude]
#transforms the movies to messages
list_of_not_voted_movies = [system_movie.to_message() for system_movie in list_of_not_voted_movies_query]
return selected_user.to_message(votes_movies=list_of_voted_movies, not_votes_movies=list_of_not_voted_movies)
def start_tr(self, attrs):
if self.break_tag == True:
return
if self.start_tag == True and self.tbody_tag == True:
movie = Movie()
movie.movie_status = 'new'
movie.movie_magnet_count = 0
self.movies.append(movie)
def getDetails(identifiers): try: movie=Movie.objects.get(sourceID=identifiers.sourceID,source=identifiers.source) except: movie=Movie() if identifiers.source=='rottenTomatoes': movie=fetchDetailsRottenTomatoes(identifiers) elif identifiers.source=='theMovieDB': movie=fetchDetailsTheMovieDB(identifiers) movie.save() return movie
def saveMovie (request):
channel=Channel.objects.get(id=1)
html = urllib.urlopen('http://sh.meituan.com/dianying').read()
soup = BeautifulSoup(html)
for movie in soup.find_all('ul', class_='reco-slides__slides')[0].find_all('li')[0].find_all('a',class_='btn'):
name = movie['title']
href = movie['href']
code = href[href.rfind('/') + 1:href.find('#')]
m = Movie(name=name,code=code,channel=channel)
m.save()
return HttpResponse("save success! ")
def post(self):
title = self.request.get("title")
url = self.request.get("url")
rate = self.request.get("rate")
movie = Movie(title=title,url=url,rate=rate)
movie.put()
params = {"title":title,"url":url,"movie":movie,"rate":rate}
self.render_template("film_izpis.html",params=params)
def post(self):
title = self.request.get("title")
url = self.request.get("url")
rate = self.request.get("rate")
movie = Movie(title=title,url=url,rate=rate)
movie.put()
self.write(title)
self.write(url)
self.write(rate)
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 add_movie():
title = request.form.get('title')
imdb_id = request.form.get('imdb_id')
if title is not None and imdb_id is not None:
url = "http://www.imdb.com/title/" + imdb_id
img_src = get_img_url(url)
movie = Movie(title=title, imdb_id=imdb_id, url=url, img_src=img_src, votes=0)
Session().add(movie)
Session().commit()
return flask.jsonify(movie.as_dict()), 201
else:
return "Invalid request", 400
def retrieve_movie_from_id(movie_id):
"""
Retrieve movie info from IMDB by movie id.
:param movie_id: original title of the film to retrieve info
:type movie_id: string
:return: Movie's key
:rtype: ndb.Key
:raise RetrieverError: if there is an error from MYAPIFILMS
"""
logging.info('Retrieving %s', movie_id)
url = BASE_URL_MYAPIFILMS + 'imdb?idIMDB=' + movie_id + '&format=JSON&aka=1&business=0&seasons=0&seasonYear=0&technical=0&filter=N&exactFilter=0&limit=1&lang=en-us&actors=S&biography=0&trailer=1&uniqueName=0&filmography=0&bornDied=0&starSign=0&actorActress=0&actorTrivia=0&movieTrivia=0&awards=0&token=307cccfe-d20b-4b69-b976-d6a024538864'
json_page = get(url).encode('utf-8')
json_data = json.loads(json_page)
movie = Movie(id=json_data['idIMDB'],
plot=json_data['plot'],
poster=clear_url(json_data['urlPoster']) if ('urlPoster' in json_data and json_data['urlPoster'] != "") else None,
rated=json_data['rated'],
simple_plot=json_data['simplePlot'],
genres=json_data['genres'])
try:
trailer_url = json_data['trailer']['videoURL']
movie.trailer = trailer_url
except KeyError:
movie.trailer = None
movie.original_title = json_data['title']
akas = json_data['akas']
for aka in akas:
if aka['country'] == 'Italy':
movie.title = aka['title']
run_times = json_data['runtime']
if len(run_times) == 0:
movie.run_times = None
else:
movie.run_times = run_times[0]
year = json_data['year']
if len(year) > 4:
year = year[-4:]
movie.year = year
key = movie.put()
actors_list = json_data['actors']
directors_list = json_data['directors']
writers_list = json_data['writers']
retrieve_artists(movie, actors_list, directors_list, writers_list)
logging.info('Retrieved %s', movie_id)
return key
def get_movie(request, pk):
"""
function to handle request for a particular movie
GET => uesd to query
POST w/o id, to insert and return inserted value
POST w/ id, to update existing record
:param request: incomming http request
:param pk: primary key of the movie requested
:return:
"""
#check the incomming method
try:
if request.method == "GET":
if pk != '':
_movie = Movie.objects.get(pk=pk).json()
response = HttpResponse(_movie, content_type="application/json")
return response
else:
response = search_movie(request)
return response
raise Movie.MultipleObjectsReturned()
elif request.method == 'POST':
#check if user is authenticated to touch it
#if pk='', insert, else overwrite
if pk == '' and has_perm(request, 'IMDB.create_movie'):
_m = Movie()
elif pk != '' and has_perm(request, 'IMDB.change_movie'):
_m = get_object_or_404(Movie, pk=pk)
else:
raise PermissionDenied()
_m.add_using_json(request.body)
_m.save()
return HttpResponse(_m.json(), content_type="application/json", status=201)
elif request.method == 'DELETE':
if pk != '':
if has_perm(request, 'delete_movie'):
_m = get_object_or_404(Movie, pk=pk)
_m.delete()
return HttpResponse('delete successful', content_type="application/json", status=200)
else:
raise PermissionDenied()
else:
raise Movie.MultipleObjectsReturned()
else:
raise Movie.MultipleObjectsReturned() #avoiding modification to the entire series
except IntegrityError as ie:
return HttpResponseBadRequest("{'status':400,'message':'Bad Request -- Integrity violation:" + ie.message + "'}",
content_type="application/json")
except KeyError as k:
return HttpResponseBadRequest("{'status':400,'message':'Bad Request -- Key violation:" + k.message + "'}",
content_type="application/json")
except Movie.MultipleObjectsReturned as e:
return HttpResponseNotFound(json.dumps({'status': 404, 'message': 'movie not found'}),
content_type="application/json")
except (Movie.DoesNotExist, Http404):
return HttpResponseNotFound(json.dumps({'status': 404, 'message': 'movie not found'}),
content_type="application/json")
except PermissionDenied as p:
return HttpResponseForbidden(json.dumps({'status': 403, 'message': 'Permission Denied{0:s}'.format(p.message)}),
content_type="application/json")
def add_movie_tastes(user_id, movie_id, taste):
taste = float(taste)
user = User.get_by_id(user_id)
movie = Movie.get_by_id(movie_id)
for actor in movie.actors:
artist = Artist.get_by_id(actor.id())
user.add_taste_artist(artist, ACTOR_WEIGHT * taste)
for director in movie.directors:
artist = Artist.get_by_id(director.id())
user.add_taste_artist(artist, DIRECTOR_WEIGHT * taste)
for writer in movie.writers:
artist = Artist.get_by_id(writer.id())
user.add_taste_artist(artist, WRITER_WEIGHT * taste)
for genre in movie.genres:
user.add_taste_genre(genre, GENRE_WEIGHT * taste)
user.remove_proposal()
user.put()
taskqueue.add(url='/api/proposal/' + user.key.id(), method='GET')
return 'OK'
def test_serialize_unicode(self):
"""Tests that unicode makes the roundtrip intact"""
actor_name = u"Za\u017c\u00f3\u0142\u0107"
movie_title = u'G\u0119\u015bl\u0105 ja\u017a\u0144'
ac = Actor(name=actor_name)
mv = Movie(title=movie_title, actor=ac)
ac.save()
mv.save()
serial_str = serializers.serialize(self.serializer_name, [mv])
self.assertEqual(self._get_field_values(serial_str, "title")[0], movie_title)
self.assertEqual(self._get_field_values(serial_str, "actor")[0], actor_name)
obj_list = list(serializers.deserialize(self.serializer_name, serial_str))
mv_obj = obj_list[0].object
self.assertEqual(mv_obj.title, movie_title)
def post_comment():
title = request.form['title']
contents = request.form['contents']
if contents:
m = Movie.get_or_create(title)
m.add_comment(Comment(user_id=g.user.id, contents=contents))
return redirect(url_for("show_movie", title=title))
def save(guess, user_id, movie_id):
user = User.from_id(user_id)
rating = Movie.from_id(movie_id).rating
guess_id = None
connection = connect()
try:
with connection.cursor() as cursor:
sql = """INSERT INTO `guesses` (guess, user_id, movie_id, diff)
VALUES (%s, %s, %s, %s)"""
cursor.execute(
sql,
(
guess,
user_id,
movie_id,
Guess.calculate_score(rating, guess)
)
)
guess_id = cursor.lastrowid
sql = """SELECT SUM(`diff`) AS score
FROM `guesses` WHERE `user_id`=%s"""
cursor.execute(sql, (user_id))
result = cursor.fetchone()
user.score = result[u'score']
connection.commit()
finally:
connection.close()
user.update()
return Guess.from_id(guess_id)
def add_movie():
input_title = flask.request.values['title']
if not input_title:
flask.flash('Blank movie title.', 'danger')
else:
imdb = imdbpie.Imdb()
# first we check if input_title is an id or URL:
movie_id = imdb.validate_id(input_title)
if not movie_id:
title = imdb.find_by_title(input_title)
if title:
movie_id = title[0]['imdb_id']
if movie_id:
movie_info = imdb.find_movie_by_id(movie_id)
new_movie = Movie.create_scheduled(
title=movie_info.title,
year=movie_info.year,
imdb_id=movie_info.imdb_id,
imdb_rating=movie_info.rating,
imdb_cover_url=movie_info.data['image']['url']
)
flask.flash('Movie "{}" was added.'.format(new_movie['title']), 'success')
return flask.redirect(flask.url_for('admin'))
def get_tastes_movies_list(user, page=0):
"""
Get a readable taste movies list.
:param user: user
:type user: Models.User
:return: list of tastes
{"code": 0, "data": {"tastes": [{"idIMDB": id,"originalTitle": original_title, "poster": poster_url}],
"type": type, "userId": user_id}
:rtype: JSON
"""
tastes_movies_id = user.tastes_movies
movies = []
for taste_movie_id in tastes_movies_id:
taste_movie = TasteMovie.get_by_id(taste_movie_id.id()) # Get taste
if taste_movie.taste >= 1 and taste_movie.added:
movie_id = taste_movie.movie.id() # Get movie id from taste
movie = Movie.get_by_id(movie_id) # Get movie by id
movies.append({"idIMDB": movie_id,
"originalTitle": movie.original_title.encode('utf-8') if movie.original_title is not None else None,
"title": movie.title.encode('utf-8') if movie.title is not None else None,
"tasted": 1,
"poster": movie.poster})
return jsonify(code=0, data={"userId": user.key.id(), "type": "movie", "tastes": movies})
def load_sample_data():
file_path = os.path.abspath('/home/jiteshvp/Dev/ShopSense/InterviewExercise/data/imdb.json')
with open(file_path, 'r') as f:
_decoded_json = json.load(f)
for _json_movie in _decoded_json:
_movie = Movie(
popularity=unicode_lower_strip(_json_movie['99popularity']),
director=unicode_lower_strip(_json_movie['director']),
movie_name=unicode_lower_strip(_json_movie['name'])
)
try:
_movie.save()
for _json_genre in _json_movie['genre']:
(_genre, _was_created) = Genre.objects.get_or_create(genre_label=unicode_lower_strip(_json_genre))
_movie.genre.add(_genre)
_movie.save()
except Exception as e:
pass
def insert_movie(the_movie):
movie = Movie.from_tmdb(the_movie, True)
db_session.add(movie)
try:
db_session.commit()
return movie.movieid
except:
db_session.rollback()
raise
def getMovies():
movies = []
sel_mov = Movie.select()
for mov in sel_mov:
movies.append(mov.__dict__['_data'])
return jsonify(movies)
def untaste_movie(user_id, movie_id):
movie = Movie.get_by_id(movie_id)
user = User.get_by_id(user_id)
for actor in movie.actors:
artist = Artist.get_by_id(actor.id())
taste_artist = TasteArtist.get_by_id(actor.id() + user.key.id())
if taste_artist is not None:
taste_artist.update_taste(-ACTOR_WEIGHT)
else:
user.add_taste_artist(artist, -ACTOR_WEIGHT)
if taste_artist.taste == 0:
user.remove_taste_artist(artist)
for director in movie.directors:
artist = Artist.get_by_id(director.id())
taste_artist = TasteArtist.get_by_id(director.id() + user.key.id())
if taste_artist is not None:
taste_artist.update_taste(-DIRECTOR_WEIGHT)
else:
user.add_taste_artist(artist, -DIRECTOR_WEIGHT)
if taste_artist.taste == 0:
user.remove_taste_artist(artist)
for writer in movie.writers:
artist = Artist.get_by_id(writer.id())
taste_artist = TasteArtist.get_by_id(writer.id() + user.key.id())
if taste_artist is not None:
taste_artist.update_taste(-WRITER_WEIGHT)
else:
user.add_taste_artist(artist, -WRITER_WEIGHT)
if taste_artist.taste == 0:
user.remove_taste_artist(artist)
for genre in movie.genres:
taste_genre = TasteGenre.get_by_id(genre + user.key.id())
if taste_genre is not None:
taste_genre.update_taste(-GENRE_WEIGHT)
else:
user.add_taste_genre(genre, -GENRE_WEIGHT)
if taste_genre.taste == 0:
user.remove_taste_genre(genre)
user.remove_proposal()
user.put()
taskqueue.add(url='/api/proposal/' + user.key.id(), method='GET')
return 'OK'
def post(self):
url = urlfetch.fetch('http://www.imdb.com/chart/top')
doc = lxml.html.fromstring(url.content)
movienumber = 1
for row in doc.cssselect('tr'):
if (row.get('class') == 'odd' or row.get('class') == 'even'):
movie = Movie(id=movienumber)
for column in row.cssselect('td'):
if column.get('class') == 'posterColumn':
for img in column.cssselect('img'):
movie.movieimg = img.get('src')
if column.get('class') == 'titleColumn':
for title in column.cssselect('a'):
movie.movietitle = title.text.encode('utf-8')
movie.put()
movienumber += 1
self.redirect('/movielist')
def addmovie(request):
if request.method=='POST':
form = MovieInfoForm(request.POST,request.FILES)
if not form.is_valid():
return render(request,'webuser/addmovie.html',{'form':form})
else:
moviename = form.cleaned_data.get('moviename')
movieaddress = form.cleaned_data.get('movieaddress')
downloadlink = form.cleaned_data.get('downloadlink')
style = form.cleaned_data.get('style')
language = form.cleaned_data.get('language')
image = request.FILES['image']
movie = Movie(moviename=moviename,movieaddress=movieaddress,downloadlink=downloadlink,
style=style,language=language,image=image,original=str(user.webuser.id))
movie.save()
messages.add_message(request,messages.SUCCESS,u'电影添加成功.')
else:
form = MovieInfoForm();
return render(request,'webuser/addmovie.html',{'form':form})
def handle_data(self, text):
if self.break_tag == True:
return
if self.start_tag != True or self.tbody_tag != True:
return
if self.is_a != True and self.is_td != True:
return
movie = self.movies[-1]
if self.td_index == 0:
movie.movie_number = text
print(' processing movie: ' + movie.movie_number)
if movie.movie_multi_a > 1 and Movie.select().where(Movie.movie_number == movie.movie_number).count() >= 1:
print(' unique check failed(multi): ' + movie.movie_number)
movie.movie_status = 'exist'
elif self.td_index == 1:
movie.movie_name = text
elif self.td_index == 2:
movie.movie_duration = text
elif self.td_index == 3:
try:
movie.movie_release_date = datetime.strptime(text, "%Y-%m-%d").date()
except ValueError:
movie.movie_release_date = dt.datetime.fromtimestamp(0).date()
if movie.movie_release_date == self.last_time:
if Movie.select().where(Movie.movie_number == movie.movie_number).count() >= 1:
print(' unique check failed(last time): ' + movie.movie_number)
del self.movies[-1]
self.break_tag = True
if len(self.movies) == 0:
print('******************** no movie update ********************')
elif movie.movie_release_date < self.last_time:
print(' unique check failed(last time): ' + movie.movie_number)
del self.movies[-1]
self.break_tag = True
if len(self.movies) == 0:
print('******************** no movie update ********************')
elif self.td_index == 4:
movie.movie_press = text
def get_or_retrieve_by_id(id_imdb):
"""
This function check if the id is a valid IMDb id and in this case get or retrieve the correct entity.
:param id_imdb: a valid IMDb id
:type id_imdb: string
:return: A model instance
:rtype Artist or Movie model
"""
artist = re.compile('nm\d{7}$')
movie = re.compile('tt\d{7}$')
if artist.match(id_imdb): # It is an artist's id
artist = Artist.get_by_id(id_imdb) # Find artist by id
if artist is None:
try:
artist_key = retrieve_artist_from_id(id_imdb) # Retrieve if is not in the datastore
except RetrieverError as retriever_error:
raise InternalServerError(retriever_error)
artist = Artist.get_by_id(artist_key.id()) # Get artist by id
return artist
elif movie.match(id_imdb): # It is a movie's id
movie = Movie.get_by_id(id_imdb) # Find movie by id
if movie is None:
try:
movie_key = retrieve_movie_from_id(id_imdb) # Retrieve if is not in the datastore
except RetrieverError as retriever_error:
raise InternalServerError(retriever_error)
movie = Movie.get_by_id(movie_key.id()) # Get movie by id
return movie
else:
new_movie = Movie().get_by_id(id_imdb)
if new_movie != None:
return new_movie
else:
raise InternalServerError(id_imdb + " is not a valid IMDb id or film.TV id")
def proposal(user_id):
"""
Return the movies proposal for the user.
:param user_id: email of the user
:type user_id: string
:return: list of proposal
{"code": 0, "data": {"proposal": [{"channel": channel, "id_IMDB": id_IMDB, "original_title": original_title,
"poster": poster, "simple_plot": simple_plot, "time": time}], "user_id": user_id}}
:rtype: JSON
"""
if request.method == 'GET':
user = modelUser.get_by_id(user_id) # Get user
if user is not None:
proposals = user.proposal
if proposals is None:
proposals = []
tv_type_list = user.tv_type
movies = taste_based_movie_selection(user, result_movies_schedule_list(tv_type_list))
for movie in movies:
logging.info("Scelto: %s", (
str(movie[0]["originalTitle"]) if movie[0]["originalTitle"] is not None else str(
movie[0]["title"])))
movie_data_store = Movie.query(ndb.OR(Movie.original_title == movie[0]["originalTitle"],
Movie.title == movie[0][
"title"])).get() # Find movie by title
proposals.append({"idIMDB": movie_data_store.key.id(),
"originalTitle": movie[0]["originalTitle"] if movie[0][
"originalTitle"] is not None else
movie[0]["title"],
"poster": movie_data_store.poster,
"title": movie[0]["title"] if movie[0]["title"] is not None else movie[0][
"originalTitle"],
"channel": movie[0]["channel"],
"channelNumber": channel_number(movie[0]["channel"]),
"time": movie[0]["time"],
"runTimes": movie_data_store.run_times,
"simplePlot": movie_data_store.simple_plot,
"italianPlot": movie_data_store.plot_it})
if movie_data_store is not None:
pass
user.proposal = proposals
user.put()
return jsonify(code=0, data={"userId": user.key.id(), "proposal": proposals})
else:
raise InternalServerError(user_id + ' is not subscribed')
else:
raise MethodNotAllowed
def import_xml(file_name):
import xml.etree.cElementTree as et
root = et.ElementTree(file=file_name).getroot()
theaters = root.findall('theaters')[0]
movies = root.findall('movies')[0]
show_times = root.findall('showTimes')[0]
for theater in theaters:
cinema = Cinema(theater.find('name').text,
theater.find('telephone').text,
theater.find('address').find('streetAddress').find('street').text,
theater.find('address').find('city').text,
theater.find('address').find('state').text,
theater.find('address').find('postalCode').text,
theater.find('address').find('country').text,
float(theater.find('longitude').text) if theater.find('longitude').text is not None else None,
float(theater.find('latitude').text) if theater.find('latitude').text is not None else None)
cinema.id = theater.attrib['theaterId']
db.session.add(cinema)
for movie in movies:
mov = Movie(movie.find('officialTitle').text,
movie.find('sinopsis').text if movie.find('sinopsis') is not None else None,
movie.find('format').text,
int(movie.find('runningTime').text) if movie.find('runningTime').text is not None else None,
movie.find('imdb').text if movie.find('imdb') is not None else None,
movie.find('version').text == 'Z',
movie.find('ratings').find('rating').text,
movie.find('cartel').text.split('.')[0] + '.jpg')
mov.id = movie.attrib['movieId']
db.session.add(mov)
for show_time in show_times:
for time in show_time.find('times').findall('time'):
if Movie.query.get(show_time.attrib['movieId']) and Cinema.query.get(show_time.attrib['theaterId']):
showtime = ShowTime(show_time.attrib['theaterId'],
show_time.attrib['movieId'],
time.text[0:2] + ':' + time.text[2:4])
db.session.merge(showtime)
db.session.commit()
def post(self):
if self.request.get("secret") == "e8aAqE7pFcKjuTnAoTe4":
m = Movie(key_name=self.request.get("nzblink"))
m.rlsname = self.request.get("rlsname")
m.imdblink = self.request.get("imdblink")
m.imdbid = re.search("tt\d{7}", m.imdblink).group(0)
m.nzblink = self.request.get("nzblink")
m.nzbdate = datetime.strptime(self.request.get("nzbdate"), "%Y-%m-%d %H:%M:%S")
info = ImdbInfo.get_by_key_name(m.imdbid)
if info:
m.imdbinfo = info
m.put()
self.redirect("/api/dummy/")
else:
self.response.set_status(403)
self.response.out.write("Password is not correct")
def callback_post():
LOGGER.info('Logging Request: METHOD: ' + request.method + ' => ROUTE: /api/movies')
response.set_header('Date', DATETIMESTAMP)
try:
accept = request.headers.get('Accept')
response.set_header('Content-Type', determine_response_content_type(accept))
if 'application/json' not in request.headers.get(
'Content-Type') and 'application/vnd.collection+json' not in request.headers.get('Content-Type'):
LOGGER.error('Unsupported media type sent')
response.status = 415
response_body = ErrorCJ(ROOT, 'Invalid Content-Type', 415,
'application/json and application/vnd.collection+json supported')
return response_body.to_json()
request_json = json_loads(request._get_body_string())
if not request_json:
raise Exception
# debug
# print request_json
# connect to mongodb
mongoengine.connect('api')
movie_dict = dict()
for item in request_json["template"]["data"]:
movie_dict[item["name"]] = item["value"]
# new movie
movie = Movie()
movie.sysid = str(uuid.uuid4()).replace("-", "")
movie.created_on = datetime.datetime.now
movie.updated_on = datetime.datetime.now
movie.decode(movie_dict)
movie.save()
# send the response
response.set_header('Location', ROOT + 'movies/' + movie.sysid)
response.status = 201
movie = None
return
except Exception as e:
LOGGER.error('Unexpected exception ' + str(e))
response.status = 500
response_body = ErrorCJ(ROOT, 'Error Title', 500, str(e))
return response_body.to_json()
def add_movie(payload):
error = 0
try:
body = request.get_json()
name = body.get('name', '')
image_link = body.get('image_link')
if (name == ''):
error = 400
description = 'Please provide a name in your post request'
elif (Movie.query.filter_by(name=name).first()):
error = 400
description = 'A movie with this name already exists'
else:
Movie(name=name, image_link=image_link).add()
return jsonify({
'success': True,
})
except:
db.session.rollback()
error = 422
description = 'Something went wrong!'
finally:
if (error):
abort(error, description=description)
def post_movie(jwt):
request_data = request.get_json()
if (request_data is None):
abort(400, description="Empty Body Request")
# check if there is request data and it contains the right data
if ('title' in request_data and 'date' in request_data):
title = request_data['title']
try:
date = datetime.datetime.strptime(request_data['date'],
"%m/%d/%Y")
except ValueError as e:
abort(400, description=str(e))
try:
newMovie = Movie(title=title, release_date=date)
db.session.add(newMovie)
db.session.commit()
except Exception as e:
db.session.rollback()
abort(500, description=str(e))
else:
abort(400,
description=
'request body did not include either or title and date')
return 'done'
def create_movie():
"""Method filling the form and sending the data to database"""
title = request.form['title']
description = request.form['description']
tagline = request.form['tagline']
fees_in_world = request.form['fees_in_world']
budget = request.form['budget']
country = request.form['country']
premiere = request.form['premiere']
year = request.form['year']
try:
movie = Movie(title=title,
description=description,
tagline=tagline,
fees_in_world=fees_in_world,
budget=budget,
country=country,
premiere=premiere,
year=year)
db.session.add(movie)
db.session.commit()
except:
print('Something wrong. Please, fill all fields and try again.')
return redirect(url_for('movies.index'))
def test_create_role(self):
new_movie = Movie(**AppTestCase.test_movie)
new_movie.insert()
movie_id = new_movie.id
valid_test_role = AppTestCase.test_role.copy()
valid_test_role['movie_id'] = movie_id
res = self.client().post('/roles',
json=valid_test_role,
headers=HEADER)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
role = Role.query.filter(Role.name == 'test_role').one_or_none()
self.assertEqual(data['id'], role.id)
new_movie.delete()
def add_new_movie(self):
body = request.get_json()
title = body.get('title', None)
release_date = body.get('release_date', None)
actors = Actor.query.filter(Actor.id.in_(body.get('actors',
None))).all()
print(actors)
movie = Movie(title=title, release_date=release_date)
movie.actors = actors
movie.insert()
movies = Movie.query.all()
formatted_movies = [movie.format() for movie in movies]
return jsonify({
'success': True,
'movies': formatted_movies,
'total_movies': len(formatted_movies),
'created': movie.id
})
def post(self):
"""Create new movie"""
data = request.get_json()
# 1. validate genre, return 404 if invalid
genre = Genre.query.get(data["genre"])
if genre is None:
# return 404
return {"message": "The given genre ID does not exist."}, 404
# 2. create new movie instance
movie = Movie()
movie.title = data["title"]
movie.year = data["year"]
# movie.genre_id = data["genre"]
movie.genre = genre
# 3. add instance to session, and commit
db.session.add(movie)
db.session.commit()
# 4. return new created movie
return {"movie": movie.to_json()}, 201
def post_movies(jwt):
body = request.get_json()
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()
new_movie.title = title
new_movie.release_date = release_date
new_movie.insert()
except Exception as e:
print(e)
return jsonify({
'success': True,
'created_movie': new_movie.format()
}), 200
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 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 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 create_movie(token):
body = request.get_json()
new_title = body.get('title', None)
new_release_date = body.get('release_date', None)
new_actors = Actor.query.filter(Actor.id.in_(
body.get('actors', None))).all()
try:
movie = Movie(title=new_title,
release_date=new_release_date
)
movie.actors = new_actors
movie.insert()
movies = Movie.query.order_by(Movie.id).all()
formatted_movies = [movie.format() for movie in movies]
return jsonify({
"success": True,
"movies": formatted_movies
})
except Exception:
abort(422)
def create_movies():
body = request.get_json()
movie_title = body.get('title', None)
movie_release_date = body.get('release_date', None)
try:
movie = Movie(
title=movie_title,
release_date=movie_release_date
)
movie.insert()
movies = Movie.query.order_by(Movie.id).all()
return jsonify({
"movies": paginate_response(request, movies),
"total_movies": len(movies),
"success": True
})
except Exception as e:
print(e)
abort(422)
movie.rollback()
def test_patch_role_to_provide_actor_id(self):
new_movie = Movie(**AppTestCase.test_movie)
new_movie.insert()
movie_id = new_movie.id
new_role = Role(movie_id=movie_id, **AppTestCase.test_role)
new_role.insert()
role_id = new_role.id
new_actor = Actor(**AppTestCase.test_actor)
new_actor.insert()
actor_id = new_actor.id
res = self.client().patch(f'/roles/{role_id}',
json={'actor_id': actor_id},
headers=HEADER)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['description'], 'Permission not found.')
new_movie.delete()
new_actor.delete()
def test_get_roles_by_min_age(self):
new_movie = Movie(**AppTestCase.test_movie)
new_movie.insert()
movie_id = new_movie.id
new_actor = Actor(**AppTestCase.test_actor)
new_actor.insert()
new_role = Role(movie_id=movie_id, **AppTestCase.test_role)
new_role.actor = new_actor
new_role.insert()
min_age = 20
res = self.client().get(f'/roles?min_age={min_age}')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['success'])
for role in data['roles']:
self.assertTrue(role['min_age'] >= min_age)
new_movie.delete()
new_actor.delete()
def post(self):
title = self.request.get('movie_title')
runtime = int(self.request.get('movie_runtime'))
rating = float(self.request.get('movie_rating'))
my_movie = Movie(title=title, runtime_mins=runtime, rating=rating)
def add_movie(request):
newmovie = Movie(title=request.POST['movie_title'])
# when making new objects, always remember to save them
newmovie.save()
return HttpResponseRedirect('/movies')
def add_dummy_data():
'''Seed Database'''
db_drop_and_create_all()
actor1 = Actor(name="Sam Jones", age=25, gender='m')
actor2 = Actor(name="Cynthia Jones", age=22, gender='f')
actor3 = Actor(name="Vanna White", age=32, gender='f')
movie1 = Movie(title="The Movie", year=2015)
movie2 = Movie(title="The Movie 2", year=2016)
movie3 = Movie(title="The Movie 3", year=2017)
actor1.insert()
actor2.insert()
actor3.insert()
movie1.insert()
movie2.insert()
movie3.insert()
db.session.commit()
db.session.close()
return jsonify({"success": 200, "message": "db populated successfully"})
def setUp(self):
'''
Set up method that will run before every Test
'''
self.new_movie = Movie(1234,'Python Must Be Crazy','A thrilling new Python Series','/khsjha27hbs',8.5,129993)
def get_genres():
for movie in Movie.select():
for genre in movie.genre.split(', '):
if genre not in genres:
genres.append(genre)
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 movies_in_genre(genre):
search = "%{}%".format(genre)
return Movie.filter(Movie.genre**search).order_by(Movie.name)
class CapstoneTestCase(unittest.TestCase):
def setUp(self):
self.app = create_app()
self.client = self.app.test_client
self.database_path = database_path
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
self.db.create_all()
def tearDown(self):
"""Executed after reach test"""
pass
'''
Endpoint Test
'''
def test_get_actors(self):
res = self.client().get('/actors', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_get_movies(self):
res = self.client().get('/movies', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_post_actor(self):
res = self.client().post('/actors', headers={'Authorization': f'Bearer {executive_producer}'}, json={"name": "test", "age": 1, "gender": "male"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_error_post_actor(self):
res = self.client().post('/actors', headers={'Authorization': f'Bearer {executive_producer}'}, json={})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['error'], 422)
def test_post_movie(self):
res = self.client().post('/movies', headers={'Authorization': f'Bearer {executive_producer}'}, json={"title": "test", "release_date": "2021-11-11"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_error_post_movie(self):
res = self.client().post('/movies', headers={'Authorization': f'Bearer {executive_producer}'}, json={})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['error'], 422)
def test_patch_actor(self):
self.actor = Actor(name="test", age=1, gender="male")
self.actor.insert()
res = self.client().patch(f'/actors/{self.actor.id}', headers={'Authorization': f'Bearer {executive_producer}'}, json={"name": "test1"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.actor.delete()
def test_error_patch_actor(self):
res = self.client().patch('/actors/999', headers={'Authorization': f'Bearer {executive_producer}'}, json={"name": "test1"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['error'], 404)
def test_patch_movie(self):
self.movie = Movie(title="test", release_date="2021-11-11")
self.movie.insert()
res = self.client().patch(f'/movies/{self.movie.id}', headers={'Authorization': f'Bearer {executive_producer}'}, json={"title": "test1"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.movie.delete()
def test_error_patch_movie(self):
res = self.client().patch('/movies/999', headers={'Authorization': f'Bearer {executive_producer}'}, json={"title": "test1"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['error'], 404)
def test_delete_actor(self):
self.actor = Actor(name="test", age=1, gender="male")
self.actor.insert()
res = self.client().delete(f'/actors/{self.actor.id}', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def test_error_delete_actor(self):
res = self.client().delete('/actors/999', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['error'], 404)
def test_delete_movie(self):
self.movie = Movie(title="test", release_date="2021-11-11")
self.movie.insert()
res = self.client().delete(f'/movies/{self.movie.id}', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.movie.delete()
def test_error_delete_movie(self):
res = self.client().patch('/movies/999', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['error'], 404)
'''
RBAC Test
'''
# view actors
def test_casting_assistant(self):
res = self.client().get('/actors', headers={'Authorization': f'Bearer {casting_assistant}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
# add actor
def test_error_casting_assistant(self):
res = self.client().post('/actors', headers={'Authorization': f'Bearer {casting_assistant}'}, json={"name": "test", "age": 1, "gender": "male"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['success'], False)
# add actor
def test_casting_director(self):
res = self.client().post('/actors', headers={'Authorization': f'Bearer {casting_director}'}, json={"name": "test", "age": 1, "gender": "male"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
# add movie
def test_error_casting_director(self):
res = self.client().post('/movies', headers={'Authorization': f'Bearer {casting_director}'}, json={"title": "test", "release_date": "2021-11-11"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['success'], False)
# add movie
def test_executive_producer(self):
res = self.client().post('/movies', headers={'Authorization': f'Bearer {executive_producer}'}, json={"title": "test", "release_date": "2021-11-11"})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
# delete movie
def test_executive_producer_2(self):
self.movie = Movie(title="test", release_date="2021-11-11")
self.movie.insert()
res = self.client().delete(f'/movies/{self.movie.id}', headers={'Authorization': f'Bearer {executive_producer}'})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.movie.delete()
async def index_movie():
movies = []
for movie in db.movies.find():
movies.append(Movie(**movie))
return {'movies': movies}
async def add_movie(movie: Movie):
if hasattr(movie, 'id'):
delattr(movie, 'id')
ret = db.movies.insert_one(movie.dict(by_alias=True))
movie.id = ret.inserted_id
return {'movie': movie}
def getMovies(self):
from models import Movie
return Movie.getMoviesByActor(self)
class AgencyTestCase(unittest.TestCase):
"""This class represents the Casting Agency test case"""
# Create test data for actor and movie
actor_test_update = Actor(name='actor update test', age=30, gender='male')
actor_test_update.insert()
actor_test_delete = Actor(name='actor delete test', age=30, gender='male')
actor_test_delete.insert()
release_date_test = datetime.strptime('1999-01-01', '%Y-%m-%d')
movie_test_update = Movie(title='movie update test',
release_date=release_date_test)
movie_test_update.insert()
movie_test_delete = Movie(title='movie delete test',
release_date=release_date_test)
movie_test_delete.insert()
def setUp(self):
"""Define test variables and initialize app."""
self.app = create_app()
self.client = self.app.test_client
self.database_path = os.environ['DATABASE_URL']
setup_db(self.app, self.database_path)
self.jwt_all_permissions = os.environ['JWT_TOKEN']
self.jwt_casting_assistant = os.environ['JWT_CASTING_ASSIST']
self.jwt_casting_director = os.environ['JWT_CASTING_DIRECTOR']
self.jwt_executive_producer = os.environ['JWT_EXECUTIVE_PRODUCER']
self.new_movie = {
'title': 'test movie',
'release_date': '1999-01-01',
}
self.new_actor = {
'name': 'test actor',
'age': '25',
'gender': 'male',
}
self.new_movie_missing_attribute = {
'title': 'test movie',
}
self.new_actor_missing_attribute = {
'name': 'test actor',
'age': '25',
}
self.update_movie_date = {
'release_date': '1999-01-01',
}
self.update_actor_age = {
'age': 35,
}
# 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()
@classmethod
def tearDownClass(cls):
# Remove test data for actor and movie after all tests
movie_update_test = Movie.query.filter(
Movie.title == 'movie update test').one_or_none()
if movie_update_test:
movie_update_test.delete()
movie_delete_test = Movie.query.filter(
Movie.title == 'movie update test').one_or_none()
if movie_delete_test:
movie_delete_test.delete()
actor_test_update = Actor.query.filter(
Actor.name == 'actor update test').one_or_none()
if actor_test_update:
actor_test_update.delete()
actor_test_delete = Actor.query.filter(
Actor.name == 'actor update test').one_or_none()
if actor_test_delete:
actor_test_delete.delete()
# Test GET movies
def test_get_movies(self):
res = self.client().get('/movies',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movies'])
self.assertTrue(len(data['movies']))
# Test GET actors
def test_get_actors(self):
res = self.client().get('/actors',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actors'])
self.assertTrue(len(data['actors']))
# Test POST new movie
def test_create_new_movie(self):
res = self.client().post('/movies',
json=self.new_movie,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
new_movie = Movie.query.filter(
Movie.id == data['movie_id']).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movie_id'])
self.assertTrue(new_movie)
# Test POST new actor
def test_create_new_actor(self):
res = self.client().post('/actors',
json=self.new_actor,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
new_actor = Actor.query.filter(
Actor.id == data['actor_id']).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actor_id'])
self.assertTrue(new_actor)
# Test PATCH movie
def test_update_movie(self):
movie_update = Movie.query.filter(
Movie.title == 'movie update test').one_or_none()
res = self.client().patch('/movies/' + str(movie_update.id),
json=self.update_movie_date,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
# check if movie was updated
movie = Movie.query.filter(Movie.id == movie_update.id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['movie_id'], movie_update.id)
self.assertEqual(movie.release_date, movie_update.release_date)
# Error update movie without parameters
def test_422_if_movie_missing_parameters(self):
movie_update = Movie.query.filter(
Movie.title == 'movie update test').one_or_none()
res = self.client().patch('/movies/' + str(movie_update.id),
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Unprocessable entity')
# Test PATCH actor
def test_update_actor(self):
actor_update = Actor.query.filter(
Actor.name == 'actor update test').one_or_none()
res = self.client().patch('/actors/' + str(actor_update.id),
json=self.update_actor_age,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
# check if actor was updated
actor = Actor.query.filter(Actor.id == actor_update.id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['actor_id'], actor_update.id)
self.assertEqual(actor.age, self.update_actor_age['age'])
# Error update actor without parameters
def test_422_if_actor_missing_parameters(self):
actor_update = Actor.query.filter(
Actor.name == 'actor update test').one_or_none()
res = self.client().patch('/actors/' + str(actor_update.id),
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 422)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Unprocessable entity')
# Error create actor missing gender
def test_400_for_failed_created_actor(self):
res = self.client().post('/actors',
json=self.new_actor_missing_attribute,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 400)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Bad request')
# Error create movie missing release date
def test_400_for_failed_created_movie(self):
res = self.client().post('/movies',
json=self.new_movie_missing_attribute,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 400)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Bad request')
# Error delete movie not found
def test_404_if_movie_does_not_exist(self):
res = self.client().delete('/movies/999',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Resource not found')
# Error delete actor not found
def test_404_if_actor_does_not_exist(self):
res = self.client().delete('/actors/999',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 404)
self.assertEqual(data['success'], False)
self.assertEqual(data['message'], 'Resource not found')
# Test DELETE movie
def test_delete_movie(self):
movie_delete = Movie.query.filter(
Movie.title == 'movie delete test').one_or_none()
res = self.client().delete('/movies/' + str(movie_delete.id),
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
movie = Movie.query.filter(Movie.id == movie_delete.id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['movie_id'], movie_delete.id)
self.assertEqual(movie, None)
# Test DELETE actor
def test_delete_actor(self):
actor_delete = Actor.query.filter(
Actor.name == 'actor delete test').one_or_none()
res = self.client().delete('/actors/' + str(actor_delete.id),
headers={
"Authorization":
"Bearer {}".format(
self.jwt_all_permissions)
})
data = json.loads(res.data)
actor = Actor.query.filter(Actor.id == actor_delete.id).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(data['actor_id'], actor_delete.id)
self.assertEqual(actor, None)
# Tests RBAC
# Test Casting Assitant
def test_create_new_actor_casting_assistant(self):
res = self.client().post('/actors',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_casting_assistant)
},
json=self.new_actor)
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['message'], {
'code': 'unauthorized',
'description': 'Permission not found.'
})
def test_get_movies_casting_assistant(self):
res = self.client().get('/movies',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_casting_assistant)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movies'])
self.assertTrue(len(data['movies']))
# Tests Casting Director
def test_create_new_actor_casting_director(self):
res = self.client().post('/actors',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_casting_director)
},
json=self.new_actor)
data = json.loads(res.data)
new_actor = Actor.query.filter(
Actor.id == data['actor_id']).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actor_id'])
self.assertTrue(new_actor)
def test_create_new_movie_casting_director(self):
res = self.client().post('/movies',
json=self.new_movie,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_casting_director)
})
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['message'], {
'code': 'unauthorized',
'description': 'Permission not found.'
})
# Test Executive Producer
def test_create_new_actor_executive_producer(self):
res = self.client().post('/actors',
headers={
"Authorization":
"Bearer {}".format(
self.jwt_executive_producer)
},
json=self.new_actor)
data = json.loads(res.data)
new_actor = Actor.query.filter(
Actor.id == data['actor_id']).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actor_id'])
self.assertTrue(new_actor)
def test_create_new_movie_executive_producer(self):
res = self.client().post('/movies',
json=self.new_movie,
headers={
"Authorization":
"Bearer {}".format(
self.jwt_executive_producer)
})
data = json.loads(res.data)
new_movie = Movie.query.filter(
Movie.id == data['movie_id']).one_or_none()
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['movie_id'])
self.assertTrue(new_movie)
# Add Movie Ratings
for i, r in enumerate(ratings):
new_r = MPAARatings(rating=r)
session.add(new_r)
session.commit()
# genre query object
gq = session.query(Genre)
# Add Movies
m1 = Movie(
title="The Dark Knight",
poster_image_url=
"https://upload.wikimedia.org/wikipedia/en/8/8a/Dark_Knight.jpg",
trailer_youtube_url="https://www.youtube.com/watch?v=EXeTwQWrcwY",
storyline=
"When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.",
mpaa_rating_id=3,
duration=152,
release_date=datetime.date(2008, 7, 18),
imdb_id="tt0468569",
rotten_id="the_dark_knight")
# Add Genres
m1.genres.append(gq.filter_by(genre='Action').one())
m1.genres.append(gq.filter_by(genre='Crime').one())
m1.genres.append(gq.filter_by(genre='Drama').one())
m2 = Movie(
title="Watchmen",
poster_image_url=
"https://upload.wikimedia.org/wikipedia/en/b/bc/Watchmen_film_poster.jpg",
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'Alex Wang'
from models import User, Movie, Review, History
from transwarp import db
import time, uuid
if __name__ == '__main__':
print User().__sql__()
print Movie().__sql__()
print Review().__sql__()
print History().__sql__()
'''
db.create_engine('root', 'wxy6772102', 'imdb')
db.update('drop table if exists histories')
db.update(History().__sql__())
id = '0014781867782440246055d8b314bb1be953e2843a5af0a000'
m = Movie.get(id)
m.score = 0
m.num_review = 0
m.update()
user_name = 'alex'
content = 'hello'
r = Review(user_name=user_name, content=content)
import fresh_tomatoes as ft
from models import Movie
avengers_movie = Movie(
"Avengers",
"http://image.tmdb.org/t/p/w342/7WsyChQLEftFiDOVTGkv3hFpyyt.jpg",
"https://www.youtube.com/watch?v=6ZfuNTqbHE8")
zootopia_movie = Movie(
"Zootopia",
"http://image.tmdb.org/t/p/w342/sM33SANp9z6rXW8Itn7NnG1GOEs.jpg",
"https://www.youtube.com/watch?v=jWM0ct-OLsM")
coco_movie = Movie(
"Coco", "http://image.tmdb.org/t/p/w342/eKi8dIrr8voobbaGzDpe8w0PVbC.jpg",
"https://www.youtube.com/watch?v=Ga6RYejo6Hk")
rampage_movie = Movie(
"Rampage",
"http://image.tmdb.org/t/p/w342/30oXQKwibh0uANGMs0Sytw3uN22.jpg",
"https://www.youtube.com/watch?v=coOKvrsmQiI")
movies_list = [avengers_movie, zootopia_movie, coco_movie, rampage_movie]
ft.open_movies_page(movies_list)
from datetime import datetime
from models import db_drop_and_create_all, setup_db, Actor, Movie
movie1 = Movie(title='How to Steal a Million',
year=datetime.strptime('1966/01/01', "%Y/%m/%d"))
movie2 = Movie(title='How to Marry a Millionaire',
year=datetime.strptime('1953/01/01', "%Y/%m/%d"))
movie3 = Movie(title='Sunset Boulevard',
year=datetime.strptime('1950/01/01', "%Y/%m/%d"))
movie4 = Movie(title='The Misfits',
year=datetime.strptime('1961/01/01', "%Y/%m/%d"))
movie5 = Movie(title='All About Eve',
year=datetime.strptime('1950/01/01', "%Y/%m/%d"))
movie6 = Movie(title='Gentlemen Prefer Blondes',
year=datetime.strptime('1953/01/01', "%Y/%m/%d"))
movie7 = Movie(title='The Seven Year Itch',
year=datetime.strptime('1955/01/01', "%Y/%m/%d"))
movie8 = Movie(title='Pillow Talk',
year=datetime.strptime('1959/01/01', "%Y/%m/%d"))
movie9 = Movie(title='High Society',
year=datetime.strptime('1956/01/01', "%Y/%m/%d"))
movie10 = Movie(title='The King and I',
year=datetime.strptime('1956/01/01', "%Y/%m/%d"))
movie1.insert()
movie2.insert()
movie3.insert()
movie4.insert()
movie5.insert()
movie6.insert()
movie7.insert()
