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