def add_movie(token): data = request.get_json() movie_title = data.get('title', None) movie_release_date = data.get('release_date', None) if not movie_title or not movie_release_date: abort(400) existing_movie = Movie.query.filter( Movie.title == movie_title, Movie.release_date == movie_release_date).one_or_none() if existing_movie: abort(422) try: movie_data = Movie(title=movie_title, release_date=movie_release_date) movie_data.insert() return jsonify({ 'success': True, 'movie': movie_data.format() }), 201 except Exception as error: print(error) abort(422)
def dashboard(): if request.method=="POST": name = request.form['moviename'] searchstring = name.split(" ") genre = request.form['genre'] result = [] if genre.lower() == 'all': if name=="": r = requests.get(apiurl+'/api/movies') result = r.json() else: result = Movie.objects(name=name).to_json() result = json.loads(result) else: print(genre.capitalize()) genre = genre.capitalize() if name=="": result = Movie.objects(genres__in=[genre]).to_json() else: result = Movie.objects(name=name, genres__in=[genre]).to_json() print(result) result = json.loads(result) return render_template('dashboard.html',movies=result) r = requests.get(apiurl+'/api/movies') if (r.json()): return render_template('dashboard.html', movies=r.json()) else: msg = 'No articles found' return render_template('dashboard.html', msg=msg)
def create_movies(jwt): ''' Creates a movie in the database. Requieres [create:movies] permission. ''' body = request.get_json() title = body.get('title', None) released = body.get('released', None) picture_link = body.get('picture_link', None) synopsis = body.get('synopsis', None) if title is None: abort(400) elif released is None: abort(400) elif synopsis is None: abort(400) try: movie = Movie(title=title, released=released, picture_link=picture_link, synopsis=synopsis) movie.insert() return jsonify({'success': True, 'created': movie.id}) except Exception as e: print(e) abort(422)
def setUp(self): """Define test variables and initialize app.""" self.app = app self.client = self.app.test_client self.database_name = "capstone_test" self.database = f"postgresql://*****:*****@localhost/" self.database_path = self.database + self.database_name # setup_db(self.app, self.database_path) # binds the app to the current context with self.app.app_context(): self.app.config["SQLALCHEMY_DATABASE_URI"] = self.database_path self.app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False self.db = db self.db.app = self.app # self.db.init_app(self.app) # create all tables self.db.drop_all() self.db.create_all() with self.app.app_context(): for i in range(10): new_actor = Actor(name='ahmed', age=30, gender='male') new_movie = Movie(title='new movie', start_time='2015-5-6') new_actor.insert() new_movie.insert()
def test_401_delete_movie_casting_director(self): movie = Movie(title='first Name') movie.insert() res = self.client().delete('/movie/' + str(movie.id), headers=settingup_auth('casting_director')) self.assertEqual(res.status_code, 401)
def test_401_patch_movie_casting_assistant(self): movie = Movie(title='first Name') movie.insert() res = self.client().patch('/movies/' + str(movie.id), json={'title': 'updated_movie'}, headers=setup_auth('casting_assistant')) self.assertEqual(res.status_code, 401)
def setUp(self): """Define test variables and initialize the app""" self.app = create_app() self.client = self.app.test_client self.executive_producer_jwt = os.environ.get('EXECUTIVE_PRODUCER') self.casting_manager_jwt = os.environ.get('CASTING_MANAGER') self.casting_assistant_jwt = os.environ.get('CASTING_ASSISTANT') self.executive_producer = { "Content-Type": "application/json", "Authorization": "Bearer {}".format(self.executive_producer_jwt) } self.casting_manager = { "Content-Type": "application/json", "Authorization": "Bearer {}".format(self.casting_manager_jwt) } self.casting_assistant = { "Content-Type": "application/json", "Authorization": "Bearer {}".format(self.casting_assistant_jwt) } self.new_actor = Actor(name="Test_Actor", age=45, gender='Male') self.new_movie = Movie(title='Test_Movie', release_date='2016-12-06') # 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 add_movie(payload): # Extract relevant details from request. req_data = request.get_json() title = req_data['title'] release_date = req_data['release_date'] check_movie_values(title, release_date) # Create new new_movie = Movie( title=title, release_date=release_date, ) # Save try: new_movie.insert() except: abort(500) finally: # Return movie = new_movie.format() return jsonify({ 'success': True, 'movie': movie })
def add_new_movie(token): # handle request data data = request.get_json() # if data is NONE if data is None: abort(400) # get data from request body try: title, date = data["title"], data["release_date"] # except return 400 error except KeyError: abort(400) # validate request data, if TRUE: if validate(title, date): # check for movie exist movie = Movie.query.filter_by(title=title).first() # if movie is exist return json response with message if movie: return jsonify({ "mesage": "This film is already available", "success": False }) # build new movie data new_movie = Movie(title=title, release_date=date) # add new movie new_movie.insert() # build response data response = {"success": True, "actor": new_movie.format()} # return response return jsonify(response), 200 return abort(400)
def test_401_delete_movie_fail(self): movie = Movie(title='first Name') movie.insert() res = self.client().delete('/movies/' + str(movie.id), headers=setup_auth('')) self.assertEqual(res.status_code, 401)
def create_movie(): title, release = get_validated_body_movie() try: movie = Movie(title=title, release=release) movie.insert() except Exception: abort(500, "Internal Error") return jsonify({"success": True, "movie": movie.json()}), 200
def new_movie(jwt): try: data = request.get_json('movie') movie = Movie(title=data['title'], release_date=data['release_date']) movie.insert() except Exception: abort(400) return jsonify({'success': True, 'movies': [movie.format()]})
def post(self): user_id = get_jwt_identity() body = request.get_json() user = User.objects.get(id=user_id) movie = Movie(**body, added_by=user) movie.save() user.update(push__movies=movie) user.save() return {'id': str(id)}, 200
def test_016_delete_movie_by_ID(self): new_movie = Movie(title='one for delete', release='2020') new_movie.insert() response = self.client().delete( '/movies/{}'.format(new_movie.id), headers={"Authorization": "Bearer {}".format(self.producer_token)}) data = json.loads(response.data) self.assertEqual(response.status_code, 200) self.assertEqual(data['success'], True)
def create_movie(payload): print('payload', payload) body = request.get_json() req_title = body.get('title') req_date = datetime.fromtimestamp(body.get('date') / 1000.0) movie = Movie(title=req_title, date=req_date) movie.insert() return jsonify({'success': True, 'movie': movie.long()})
def fill_database(): actor_data_1 = Actor(name='new actor_1', age=99, gender="men") actor_data_2 = Actor(name='new actor_2', age=99, gender="men") movie_data_1 = Movie(title='forsaj 9', release_date="2021") movie_data_2 = Movie(title="forsaj 10", release_date="2022") all_data = [actor_data_1, actor_data_2, movie_data_1, movie_data_2] for data in all_data: data.insert()
def post(self): #Create user_id = get_jwt_identity() body = request.get_json() #movie = Movie(**body).save() user = User.objects.get(id=user_id) movie = Movie(**body, added_by=user) movie.save() id = movie.id return {'id': str(id)}, 200
def test_08_delete_movie_by_ID(self): new_movie = Movie(title='one for delete', release='2020') new_movie.insert() response = self.client().delete( '/movies/{}'.format(new_movie.id), headers={"Authorization": "Bearer {}".format(self.director_token)}) data = json.loads(response.data) self.assertEqual(response.status_code, 401) self.assertEqual(data['success'], False) self.assertEqual(data['message'], 'Permission Not found')
def post_movie(payload): data = request.get_json() try: movie = Movie(title=data['title'], release_date=datetime.strptime( data['release_date'], '%Y-%m-%d')) movie.insert() return jsonify({'success': True, 'movie': movie.format()}), 200 except: abort(422)
def add_movie(payload): try: body = request.get_json() title_requested = body.get("title", None) releaseDate_requested = body.get("release_date", None) movie = Movie(title=title_requested, release_date=releaseDate_requested) movie.insert() return jsonify({"success": True, "movie_created": movie.format()}) except: abort(422)
def test_401_delete_movie_executive_producer(self): movie = Movie(title='first Name') movie.insert() res = self.client().delete('/movies/' + str(movie.id), headers=setup_auth('executive_producer')) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertEqual(int(data['deleted']), movie.id)
def test_404_patch_movie_fail(self): movie = Movie(title='first Name') movie.insert() res = self.client().patch('/movies/100000', json={}, headers=setup_auth('executive_producer')) data = json.loads(res.data) self.assertEqual(res.status_code, 404) self.assertEqual(data['success'], False) self.assertEqual(data['message'], 'resource not found')
def create_movie(jwt): data = request.get_json() title = data.get('title') release_date = data.get('release_date') try: movie = Movie(title=title, release_date=release_date) movie.insert() return jsonify({ 'success': True, }) except Exception: abort(422)
def test_update_movie_casting_director(self): movie = Movie(title='first Name') movie.insert() res = self.client().patch('/movie/' + str(movie.id), json={'title': 'updated_movie'}, headers=settingup_auth('casting_director')) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertEqual(data['movie']['title'], 'updated_movie')
def test_patch_movie_executive_producer(self): movie = Movie(title='first Name') movie.insert() res = self.client().patch('/movies/' + str(movie.id), json={'title': 'updated_movie'}, headers=setup_auth('executive_producer')) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertEqual(data['movie']['id'], movie.id) self.assertEqual(data['movie']['title'], 'updated_movie')
def create_movie(jwt): try: data = request.get_json() movie = Movie(title=data.get('title'), release_date=data.get('release_date')) movie.insert() return jsonify({'success': True, 'movies': movie.format()}), 200 except BaseException: abort(422)
def test_delete_movie(self): new_movie = Movie( title="Friends", release_date=datetime.strptime("2023-01-01", '%Y-%m-%d') ) new_movie.insert() res = self.client().delete(f'/movies/{new_movie.id}', headers={ 'Authorization': executive_producer_token }) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True)
def add_movie(): body = request.get_json() try: new_movie = Movie(body['title'], body['release_date']) new_movie.create() return jsonify({ "success": True, "status_code": 200, "movie": new_movie.formatted() }) except exc.SQLAlchemyError: abort(409)
def add_movie(payload): try: add_title = request.get_json().get('title', None) add_release = request.get_json().get('release', None) new_movie = Movie(title=add_title, release=add_release) new_movie.insert() response = { 'success': True, 'status_code': 200, 'create': new_movie.id } return jsonify(response) except Exception: abort(422)
def create_new_movie(jwt): body = request.get_json() if 'title' not in body: abort(404) title = body.get('title', None) release_date = body.get('release_date', None) try: new_movie = Movie(title=title, release_date=release_date) new_movie.insert() return jsonify({ 'success': True, 'movie': [new_movie.get_movie()] }) except Exception: abort(422)