def post(self): """Creates a new object. Returns: A JSON representation of the saved object. """ try: args = parser.parse(self.searchargs, request) schema = self.resource_object.get_realschema(args)(strict=True) return parser.parse(schema, request).save() except GenericYetiError as err: return err, 400
def get(self, product_id=None): if not product_id: args = { 'type': fields.List(fields.Int()), 'product_id': fields.List(fields.Int()) } try: args = parser.parse(args, request) except HTTPException: return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST if args.get('product_id', None): products = [] for p_id in args['product_id']: element = Product.query.filter_by(id=p_id).first() if not element: resp = {"error": "Does not exist."} status_code = status.HTTP_400_BAD_REQUEST break products.append(element) else: resp = ProductFromListSchema(many=True).dump( obj=products).data status_code = status.HTTP_200_OK return resp, status_code try: products = Product.query.filter(Product.type.in_( args['type'])).all() except KeyError: return {"error": "Missing type id."}, 400 resp = ProductSchema(many=True).dump(obj=products).data return resp, status.HTTP_200_OK args = {'download': fields.Boolean()} try: args = parser.parse(args, request) except HTTPException: return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST if args.get('download', None): file_data = Product.query.get(product_id) response = send_file(BytesIO(file_data.photo), attachment_filename='image.png', as_attachment=True) return response try: product = Product.query.get(product_id) except DataError: return {"error": "Invalid url."}, status.HTTP_400_BAD_REQUEST if product is None: return {"error": "Does not exist."}, status.HTTP_400_BAD_REQUEST product = ProductSchema().dump(obj=product).data return product, status.HTTP_200_OK
def post(self): args = parser.parse(self.post_args, request) username, password = args['username'], args['password'] user = db.session.query(User) \ .filter(User.username == username) \ .filter(User.deleted.isnot(True)) \ .options(joinedload(User.roles)) \ .one_or_none() if user is None: raise exc.NotFound('User with this username does not exist') is_password_valid = User.check_password(user.password_md5, password) if not is_password_valid: current_app.logger.warning(f'user_email={args["username"]} ' f'has failed to log in') raise exc.Forbidden('Invalid password') current_app.logger.debug(f'user_email={args["username"]} has logged in') token = generate_refresh_token(user) refresh_token = RefreshToken(token=token, user_id=user.id) db.session.add(refresh_token) db.session.commit() user_serializer = UserAuthSerializer() user.refresh_token = token user_data = user_serializer.dump(user) return jsonify(user_data.data)
def subject_create(): teachers = Teacher.query.all() teacher_list = dict() if teachers: teacher_list = [{ 'id': teacher.id, 'fio': teacher.name } for teacher in teachers] if request.method == 'POST': data = parser.parse(subects_create_post, request) subject = Subject() if data: for item in data.items(): if item[0] == 'name': subject.name = item[1] if item[0] == 'desc': subject.desc = item[1] if item[0] == 'teacher_id': teacher = Teacher.query.get(item[1]) if not teacher: return redirect(url_for('bp_web.subjects')) subject.teacher = teacher session.add(subject) session.commit() return redirect(url_for('bp_web.subjects')) return render_template('subjects_edit.html', teacher_list=teacher_list)
def get(self, problem_id: int): args = parser.parse(get_args, request) query = self._build_query_by_args(args, problem_id) query = query.options( Load(Problem).load_only('id', 'name'), Load(SimpleUser).load_only('id', 'firstname', 'lastname')) per_page_count = args.get('count') page = args.get('page') result = query.paginate(page=page, per_page=per_page_count, error_out=False, max_per_page=100) runs = [] for run, user, problem in result.items: run.user = user run.problem = problem runs.append(run) metadata = {'count': result.total, 'page_count': result.pages} schema = RunSchema(many=True) data = schema.dump(runs) return flask_jsonify({ 'result': 'success', 'data': data.data, 'metadata': metadata })
def login(): """Allows users to login""" args = parser.parse(user_args, request) user = User.query.filter_by(username=args["username"]).first() if user is None: user = User(username=str(args["username"]), email=str(args["email"])) user.set_password(args["password"]) db.session.add(user) db.session.commit() login_user(user, remember=True) return jsonify({ "msg": f"Successfully created user with username {user.username}", "User": user.asdict(), }) login_user(user, remember=True) if not current_user.check_password(args["password"]): return jsonify("The password you entered was invalid.") if current_user.is_authenticated: return redirect("/mood")
def filter(self): """Search the database for object with specific fields.""" try: args = parser.parse(self.searchargs, request) return self.resource_object.filter(args) except ValidationError as err: return err, 400
def get(self, run_id: int): args = parser.parse(self.get_args, request) is_admin = args.get('is_admin') user_id = args.get('user_id') run_q = db.session.query(Run) if not is_admin: run_q = run_q.filter(Run.user_id == user_id) run = run_q.filter(Run.id == run_id).one_or_none() if run is None: raise NotFound(f'Run with id #{run_id} is not found') language_id = run.ejudge_language_id source = run.source or b'' for encoding in POSSIBLE_SOURCE_ENCODINGS: try: source = source.decode(encoding) break except UnicodeDecodeError: pass return jsonify({'source': source, 'language_id': language_id})
def inner(self, *args, **kwargs): _default_size = default_size(self) \ if callable(default_size) else default_size _max_results = max_results(self) \ if callable(max_results) else max_results try: req = parser.parse( { 'page': fields.Int(validate=validate.Range(min=1), ), 'from': fields.Int( load_from='from', validate=validate.Range(min=1), ), 'size': fields.Int(validate=validate.Range(min=1), missing=_default_size), }, locations=['querystring'], validate=_validate_pagination_args, error_status_code=400, ) # For validation errors, webargs raises an enhanced BadRequest except BadRequest as err: raise SearchPaginationRESTError( description='Invalid pagination parameters.', errors=err.data.get('messages')) # Default if neither page nor from is specified if not (req.get('page') or req.get('from')): req['page'] = 1 if req.get('page'): req.update( dict(from_idx=(req['page'] - 1) * req['size'], to_idx=req['page'] * req['size'], links=dict( prev={'page': req['page'] - 1}, self={'page': req['page']}, next={'page': req['page'] + 1}, ))) elif req.get('from'): req.update( dict(from_idx=req['from'] - 1, to_idx=req['from'] - 1 + req['size'], links=dict( prev={'from': max(1, req['from'] - req['size'])}, self={'from': req['from']}, next={'from': req['from'] + req['size']}, ))) if req['to_idx'] > _max_results: raise SearchPaginationRESTError(description=( 'Maximum number of {} results have been reached.'.format( _max_results))) return f(self, pagination=req, *args, **kwargs)
def post(self): args = parser.parse(device_args, request) device = Devices.query.filter_by(device_name=args['device_name']).first() if device is not None: return conflict("Device with name {n} already exists".format(n=args['device_name'])), 409 try: device_id = str(uuid.uuid4()) location = None temperature_sensor = False humidity_sensor = False uptime = 1 if 'location' in args: location = args['location'] if 'temperature_sensor' in args: temperature_sensor = True if 'humidity_sensor' in args: humidity_sensor = True if 'uptime' in args: uptime = long(args['uptime']) else: uptime = long(0) device = Devices(device_id=device_id, device_name=args['device_name'], location=location, temperature_sensor=temperature_sensor, humidity_sensor=humidity_sensor, uptime=uptime) db.session.add(device) db.session.commit() return "Location: " + device.url, 200 except Exception as e: return internal_error("Server Error " + str(e)), 500
def patch(self, game_id): """ Obtains a game from the database """ json_data = request.get_json(force=True) args = parser.parse(get_args, request) session = DbSessionHolder().get_session() if game_id is None: return make_response(jsonify({"error": "You need to specify the game ID."}), status.HTTP_400_BAD_REQUEST) try: game_data = add_game_code_id_to_guess(session, int(game_id), json_data["game_code_uri"], args["expand_resources"]) if game_data is None: return make_response(jsonify({"error": "Game not found."}), status.HTTP_404_NOT_FOUND) return make_response(jsonify(game_data), status.HTTP_200_OK) except Exception, e: return make_response(jsonify({"error": str(e)}), status.HTTP_500_INTERNAL_SERVER_ERROR)
def new_employee(): employee = parser.parse(EmployeeSchema(strict=True)) db.session.add(employee) db.session.commit() return (build_result(employee, EmployeeSchema()), 201, { 'Location': url_for('.get_employee', id=employee.id) })
def post(self): args = parser.parse(signup_args, request) if User.objects(username=args['email']): return api_abort(422, "Eamil已注册") elif User.objects(username=args['username']): return api_abort(422, "用户名已存在") try: u = User( email=args["email"].lower(), username=args["username"], # TODO: nginx avatar='http://192.168.1.106:8000/avatar/r{0}.png'.format( random.randint(1, 10))) u.set_password(args["password"]) u.save() if os.getenv('FLASK_ENV') == 'development': # 发送 email uid = User.objects(email=args['email']).first().id send_confirm_email(args['email'], args['username'], generate_token(uid)) return '', 201 except Exception as e: current_app.logger.error(e) return api_abort(500)
def get(self, basket_id=None): if not basket_id: args = { 'user_id': fields.Int(required=True), 'state': fields.Boolean() } try: args = parser.parse(args, request) except HTTPException: return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST try: baskets = Basket.query.filter( Basket.user_id == args['user_id']).filter( Basket.state == args['state']).all() except KeyError: return { "error": "user_id and state is required" }, status.HTTP_400_BAD_REQUEST resp = BasketSchema(many=True).dump(obj=baskets).data return resp, status.HTTP_200_OK try: basket = Basket.query.get(basket_id) except DataError: return {"error": "Invalid url."}, status.HTTP_400_BAD_REQUEST if basket is None: return {"error": "Does not exist."}, status.HTTP_400_BAD_REQUEST basket = BasketSchema().dump(obj=basket).data return basket, status.HTTP_200_OK
def post_lead(): json = parser.parse({ 'email': fields.Email(required=True), 'first_name': fields.Str(required=False), }, request) lead = Lead.create(**json) return Response(lead).to_dict()
def login(self): """ Authentication """ args = parser.parse(self.login_args).get('user') user = User.authenticate(args['email'], args['password']) return user_schema.jsonify({'user': user})
def test_get_multiple(self, mock_request): mock_request.method = 'GET' mock_request.args = MultiDict({ 'f': 'value', 'net': 'CH', 'sta': 'DAVOX,BALST', 'start': '2017-01-01', 'end': '2017-01-07' }) reference_sncls = [ sncl.StreamEpoch.from_sncl(network='CH', station='DAVOX', location='*', channel='*', starttime=datetime.datetime(2017, 1, 1), endtime=datetime.datetime(2017, 1, 7)), sncl.StreamEpoch.from_sncl(network='CH', station='BALST', location='*', channel='*', starttime=datetime.datetime(2017, 1, 1), endtime=datetime.datetime(2017, 1, 7)) ] test_args = parser.parse(self.TestSchema(), mock_request, locations=('query', )) self.assertEqual(dict(test_args), {'f': 'value'}) sncls = fdsnws.fdsnws_parser.parse( schema.ManyStreamEpochSchema(context={'request': mock_request}), mock_request, locations=('query', ))['stream_epochs'] self.assertEqual(sncls, reference_sncls)
def post(self): arg_fields = { 'email': String(required=True), 'username': String(required=True, max=32), 'plaintext_password': String(required=True), 'local_tz': String(required=True, validate=validate.OneOf(pytz.all_timezones)), } args = parser.parse(arg_fields) try: user_info = UserFacade().create_user(args['email'], args['plaintext_password'], args['local_tz'], args['username']) except Exception as e: logging.error( 'Random exception encountered registering user {0}'.format(e)) raise EndpointException('Failed to register user.') logging.info('Successfully created new user at {0}'.format( args['email'])) return jsonify(UserMarshal().dump(user_info).data)
def patch(self, bucket_id, item_id): """Patch a bucket list item.""" args = parser.parse(ItemOperations.update_items_args, request) done = args.get("done") # get item item = self.profile.get_item(item_id=item_id, buc_id=bucket_id) bucket = self.profile.get_bucket(bucket_id=bucket_id) if not item or not bucket and item.bucket_id != bucket.id: return {"message": "Item not found in bucket"}, 404 # editted edit = self.profile.edit_asset(item=True, done=done, asset_id=item_id, buc_id=bucket_id) if not edit: return {"message": "Unable to edit item"}, 422 # get item return { "message": "Patched Item succesfully", "item": item.to_dict() }, 200
def put(self, id): data = parser.parse(self.__class__._schema, request) with db.session.no_autoflush: record = self.__class__.update_or_create(data, id) return self.__class__._schema().dump(record)
def create_note(): user = get_user() note = parser.parse(NoteSchema(), request, locations=['json']) note.author = user db.session.add(note) db.session.commit() return jsonify(NoteSchema().dump(note).data)
def course_theme_edit(course_theme_id): course_theme = CourseTheme.query.get(course_theme_id) if not course_theme: return redirect(url_for('bp_web.course_themes')) if request.method == 'POST': data = parser.parse(course_theme_create_post, request) if data: for item in data.items(): if item[0] == 'name': course_theme.name = item[1] session.commit() return redirect(url_for('bp_web.course_themes')) course_theme_data = { 'id': course_theme.id, 'name': course_theme.name, 'course_numbers_list': dict() } if course_theme.course_number: course_theme_data['course_numbers_list'] = [{ 'id': course_number.id, 'number': course_number.number } for course_number in course_theme.course_number] return render_template('course_themes_edit.html', course_theme_data=course_theme_data)
def post(self, user_id): arg_fields = { 'nonce': String(required=False), 'first_name': String(required=False), 'last_name': String(required=False), } args = parser.parse(arg_fields) if args.get('nonce') is not None: first_name = args.get('first_name') last_name = args.get('last_name') self._validate_first_and_last_name(first_name, last_name) new_sub = self.sub_facade.create_new_subscription_with_customer( user_id, args['nonce'], first_name, last_name, ) else: new_sub = self.sub_facade.create_new_subscription(user_id, ) logging.info('Successfully created subscription for user {0}'.format( user_id, )) return jsonify(SubscriptionMarshal().dump(new_sub).data)
def insert_item_from_user(): try: args = parser.parse(CREATE_INV_ITEM, request) id_user = decode(request.headers['Authorization'], SECRET_KEY, algorithms='HS256')['id_user'] lista_item_ids = [ x.id_item for x in ListItems.get_full_item_list() ] if args['id_item'] not in lista_item_ids: return View.error(404, 'Item not found in') item = InventoryItems.insert_item_from_user( id_user, args['id_bin'], args['id_item']) prox_item = ListItems.get_item(args['id_item']) ListUsers.update_user_points(id_user, prox_item.points) result = { 'id_user': item.id_user, 'id_bin': item.id_bin, 'id_item': item.id_item } except ValidationError as err: return View.error(400, str(err)) return View.success(result)
def course_group_create(course_theme_id, course_number_id): course_theme = CourseTheme.query.get(course_theme_id) if not course_theme: return redirect( url_for('bp_web.course_theme_edit', course_theme_id=course_theme_id)) course_number = course_theme.course_number_lazy.filter_by( id=course_number_id).first() if not course_number: return redirect( url_for('bp_web.course_theme_edit', course_theme_id=course_theme_id)) course_group = CourseGroup() data = parser.parse(course_group_create_post, request) if data: for item in data.items(): if item[0] == 'gid': course_group.gid = int(item[1]) course_group.course_number = course_number session.add(course_group) session.commit() return redirect( url_for('bp_web.course_number_edit', course_theme_id=course_theme_id, course_number_id=course_number_id))
def add_new_meta_result(): args = { 'page_type': Arg(str, required=True), 'url': Arg(str, default=None), 'page_param': Arg(str, default=None), 'h1': Arg(str, default=None), 'meta_title': Arg(str, default=None), 'meta_description': Arg(str, default=None), 'meta_keywords': Arg(str, default=None), 'og_tags': Arg(str, default='{}'), 'twitter_cards': Arg(str, default='{}'), 'gplus_tags': Arg(str, default='{}') } data = parser.parse(args, request) r = requests.post(api_base_url + '/seo/meta_data/add_meta_data', data) message = "Error while adding meta data for " + data['page_type'] + ". Review the content and other parameters once, contact admin if that doesn't help!" message_color = "red" if json.loads(r.text)['result'] and json.loads(r.text)['result'] == 'Success': message = "Meta data for " + data['page_type'] + " has been added successfully!" message_color = "green" return render_template('result.html', message=message, message_color=message_color)
def put(self, bucket_id): """Update this bucket list.""" args = parser.parse(BucketListOperations.update_bucket_args, request) name = args["name"] if not validat_str(name): return { "message": "bucket name can only contain letters numbers and space" }, 400 edit = self.profile.edit_asset(item=False, name=name, asset_id=bucket_id) if edit is None: return {"message": "Bucket not found"}, 404 if not edit: return {"message": "Bucket not edited"}, 422 else: data = self.profile.bucket_lists.get(bucket_id).to_dict() return make_response( { "message": "Updated bucket succesfully", "bucket": data }, 201)
def post(self): """Create a new bucket list.""" args = parser.parse(BucketList.create_bucket_args, request) # validate name name = args["name"] if not validat_str(name): return { "message": "bucket name can only contain letters numbers and space" }, 400 # query if bucket exists if self.profile.get_bucket(name): return {"message": "Bucket: " + name + " exists"}, 400 # create bucket if not self.profile.add_bucket(name): return {"message": "Server was unable to process request"}, 500 # get bucket data = self.profile.get_bucket(name).to_dict() return make_response( { "message": "bucket created succesfully", "user": self.username, "bucket": data }, 201)
def get(self, order_id=None): if not order_id: args = { 'user_id': fields.Int() } try: args = parser.parse(args, request) except HTTPException: return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST try: orders = Order.query.filter(Order.user_id == args['user_id']).all() except KeyError: return {"error": "user_id is required"}, status.HTTP_400_BAD_REQUEST for order in orders: payment = Payment.query.get(order.payment) order.payment_info = payment resp = OrderSchema(many=True).dump(obj=orders).data return resp, status.HTTP_200_OK try: order = Order.query.get(order_id) except DataError: return {"error": "Invalid url."}, status.HTTP_400_BAD_REQUEST if order is None: return {"error": "Does not exist."}, status.HTTP_400_BAD_REQUEST payment = Payment.query.get(order.payment) order.payment_info = payment order = OrderSchema().dump(obj=order).data return order, status.HTTP_200_OK
def post(self, user_id): arg_fields = { 'first_name': String(required=True), 'last_name': String(required=True), 'street_address': String(required=True), 'locality': String(required=True), 'region': String(required=True), 'postal_code': String(required=True), 'country_code_alpha2': String(required=True, validate=validate.Length(2)), 'is_default': Boolean(required=True, default=False, missing=False), 'extended_address': String() } args = parser.parse(arg_fields) address = AddressDAO().create_address(user_id, **args) logging.info( 'Successfully created new address {0} for user {1}.'.format( address, user_id)) return jsonify(AddressMarshal().dump(address).data)
def post(self, bucket_id): """Create a new item in bucket list.""" args = parser.parse(Item.create_items_args, request) name = args["name"] description = args.get("description", "Let's Do this") # validate name if not validat_str(name): return { "message": "bucket name can only contain letters numbers and space" }, 400 # get bucket bucket = self.profile.bucket_lists.get(bucket_id) if bucket is None: return {"message": "Bucket not found"}, 404 # get item item = self.profile.get_item(name=name) if item: return {"message": "Item " + name + " exists"}, 400 # create item if not self.profile.add_item( name=name, description=description, buc_id=bucket_id): return {"message": "Server error: Creating item failed"}, 500 # get item data = self.profile.get_item(name=name).to_dict() return { "message": "Item created succesfully", "bucket_id": bucket_id, "item": data }, 201
def rel_me_auth(): if request.method == "GET": if "payload" not in session: return render_template("login.html") me = session["payload"]["me"] else: args = parser.parse({"me": fields.URL(required=True)}, request, location="form") me = args["me"] # find supported profiles and use the first one profiles = find_profiles(me) if not profiles: abort( 400, { "messages": [ f'Could not find a rel="me" link in {me} pointing to a valid profile ({", ".join(PROVIDERS)})' ] }, ) profile = list(profiles)[0] session["tentative_me"] = me session["profiles"] = profiles return redirect(url_for(f"{profile}.login"))
def update_employes(id): employee = Employee.query.get_or_404(id) args = parser.parse(EmployeeSchema(strict=True, partial=True, context={'employee_id': employee.id})) for key, value in args.items(): setattr(employee, key, value) db.session.commit() return build_result(employee, EmployeeSchema())
def user_merge(): args = parser.parse({ 'user_key': wf.Str(missing=None), 'user_keys': wf.DelimitedList(wf.Str(), delimiter=',', required=True), }) user_db_keys = [ndb.Key(urlsafe=k) for k in args['user_keys']] user_dbs = ndb.get_multi(user_db_keys) if len(user_dbs) < 2: flask.abort(400) user_dbs.sort(key=lambda user_db: user_db.created) merged_user_db = user_dbs[0] auth_ids = [] permissions = [] is_admin = False is_active = False for user_db in user_dbs: auth_ids.extend(user_db.auth_ids) permissions.extend(user_db.permissions) is_admin = is_admin or user_db.admin is_active = is_active or user_db.active if user_db.key.urlsafe() == args['user_key']: merged_user_db = user_db auth_ids = sorted(list(set(auth_ids))) permissions = sorted(list(set(permissions))) merged_user_db.permissions = permissions merged_user_db.admin = is_admin merged_user_db.active = is_active merged_user_db.verified = False form_obj = copy.deepcopy(merged_user_db) form_obj.user_key = merged_user_db.key.urlsafe() form_obj.user_keys = ','.join(args['user_keys']) form = UserMergeForm(obj=form_obj) if form.validate_on_submit(): form.populate_obj(merged_user_db) merged_user_db.auth_ids = auth_ids merged_user_db.put() deprecated_keys = [k for k in user_db_keys if k != merged_user_db.key] merge_user_dbs(merged_user_db, deprecated_keys) return flask.redirect( flask.url_for('user_update', user_id=merged_user_db.key.id()), ) return flask.render_template( 'user/user_merge.html', title='Merge Users', html_class='user-merge', user_dbs=user_dbs, merged_user_db=merged_user_db, form=form, auth_ids=auth_ids, api_url=flask.url_for('api.admin.user.list'), )
def get(self, bucket_id, **kwargs): """Get list of objects in the bucket. .. http:get:: /files/(uuid:bucket_id) Returns a JSON list with all the objects in the bucket. **Request**: .. sourcecode:: http GET /files/0ecc3794-2b57-4834-be61-cb9c3ef60562 HTTP/1.1 Accept: application/json Content-Type: application/json Host: localhost:5000 :reqheader Content-Type: application/json :query boolean versions: 1 (or true) in order to list all the versions of the files. 0 (or false) for the most recent versions of each file. **Response**: .. sourcecode:: http HTTP/1.0 200 OK Content-Length: 334 Content-Type: application/json [ { "checksum": "xxx", "size": 110, "url": "http://localhost:5000/files/c361fd5e.../f.pdf", "uuid": "c361fd5e-5036-4387-8249-5fcc5a37e128" }, { "checksum": "xxx", "size": 330, "url": "http://localhost:5000/files/0ff1def.../f2.rst", "uuid": "0ff1def0-5f09-4ba0-8ee8-ff42f99985ae" } ] :resheader Content-Type: application/json :statuscode 200: no error :statuscode 403: access denied :statuscode 404: page not found """ args = parser.parse(self.get_args, request) if bucket_id and Bucket.get(bucket_id): object_list = [] for obj in Object.get_by_bucket( bucket_id, versions=args.get('versions', False) ).all(): object_list.append(obj.serialize()) return {'json': object_list} abort(404, 'The specified bucket does not exist or has been deleted.')
def wrapped(*args, **kwargs): req_args = webargs_parser.parse({ 'submission': webargs_fields.Int(), 'submission_id': webargs_fields.Int() }) submission_id = req_args.get('submission', req_args.get('submission_id')) if submission_id is None: raise ResponseException("submission_id is required", StatusCode.CLIENT_ERROR) return fn(submission_id, *args, **kwargs)
def validate_employee_data(): try: e = parser.parse(EmployeeSchema(strict=True)) err = {'error': None} except UnprocessableEntity as ex: err = {'error': "Validation Error"} if hasattr(ex, 'data') and 'messages' in ex.data: err.update({'messages': ex.data['messages']}) return err, 200
def jsonpify(*args, **kwargs): params = parser.parse({'callback': wf.Str(missing=None)}) if params['callback']: content = '%s(%s)' % ( params['callback'], flask.jsonify(*args, **kwargs).data, ) mimetype = 'application/javascript' return flask.current_app.response_class(content, mimetype=mimetype) return flask.jsonify(*args, **kwargs)
def post(self): try: args = parser.parse(reading_args) log_id = post_reading(args, HUMIDITY) return "Location: " + url_for("HumidityReadingsView:get", log_id=log_id, _external=True), 200 except InvalidRequestException as ire: return handle_bad_request(ire.message), 422 except NotFoundError as nfe: return not_found(nfe.message), 404 except Exception as e: print traceback.format_exc() return internal_error(), 500
def delete(self): args = parser.parse(device_name_args, request) device_name = args['device_name'] if device_name is not None and len(device_name) > 0: try: device = Devices.query.filter_by(device_name=device_name).first() if device is None: return not_found("Device Not Found " + device_name), 404 db.session.delete(device) db.session.commit() return "Device Deleted.", 200 except Exception as e: return internal_error("Server Error " + str(e)), 500
def get_next_url(next_url=''): args = parser.parse({ 'next': wf.Str(missing=None), 'next_url': wf.Str(missing=None) }) next_url = next_url or args['next'] or args['next_url'] if next_url: do_not_redirect_urls = [flask.url_for(u) for u in [ 'signin', 'signup', 'user_forgot', 'user_reset', ]] if any(url in next_url for url in do_not_redirect_urls): return flask.url_for('welcome') return is_trusted_url(next_url) return is_trusted_url(flask.request.referrer)
def param(name, cast=None): def switch(case): return { int: wf.Int(missing=None), bool: wf.Bool(missing=None), list: wf.DelimitedList(wf.Str(), delimiter=',', missing=[]), }.get(case) if cast is None or cast is ndb.Key: cast_ = wf.Str(missing=None) else: cast_ = switch(cast) or cast args = parser.parse({name: cast_}) return ndb.Key(urlsafe=args[name]) if cast is ndb.Key else args[name]
def get_dbs(cls, query=None, ancestor=None, order=None, limit=None, cursor=None, **kwargs): args = parser.parse({ 'cursor': wf.Str(missing=None), 'limit': wf.Int(missing=None, validate=validate.Range(min=-1)), 'order': wf.Str(missing=None), }) return util.get_dbs( query or cls.query(ancestor=ancestor), limit=limit or args['limit'], cursor=cursor or args['cursor'], order=order or args['order'], **kwargs )
def add_question(): args = { 'question': Arg(str, required=True), 'option_one': Arg(str, required=True), 'option_two': Arg(str, required=True), 'option_three': Arg(str), 'option_four': Arg(str) } data = parser.parse(args, request) res = interface.insert_question(data['question'],data['option_one'],data['option_two'],data['option_three'],data['option_four']) if res: a = {'data':res} return jsonify(a) return 'failed'
def index(self): ## retrieve all items from db and dump it them to a list of json strings print "in get function" args = parser.parse(index_args, request) app.logger.debug('GET request for all {}'.format(self.desc)) app.logger.debug('Arguments passed in: {}'.format(args)) objs = self.obj.query.all() if objs: obj_dict_list, errors = self.schema(many=True).dump(objs) if errors: return jsonify(errors), 500 return jsonify(obj_dict_list) else: return jsonify({'message' : 'No {}s found'.format(self.desc)})
def get_next_url(next_url=''): args = parser.parse({ 'next': wf.Str(missing=None), 'next_url': wf.Str(missing=None) }) next_url = next_url or args['next'] or args['next_url'] do_not_redirect_urls = [flask.url_for(u) for u in [ 'signin', 'signup', 'user_forgot', 'user_reset', ]] if next_url: if any(url in next_url for url in do_not_redirect_urls): return flask.url_for('welcome') return next_url referrer = flask.request.referrer if referrer and referrer.startswith(flask.request.host_url): return referrer return flask.url_for('welcome')
def order_create(): if request.method == 'GET': return render_template('order/create.html', model={}) # POST validator = Order.get_input_validator() try: args = parser.parse(validator, request) except Exception as e: return render_template('order/create.html', error=str(e.data['exc'].arg_name), model=request.form) o = Order() o.author = args['author'] o.name = args['name'] o.year = args['year'] o.user_login = current_user.login o.save() return redirect(url_for('orders'))
def keywordtool_api(): apikey = '579a5b85df0459956f0be0875d99083fc0740958' args = { 'keyword': Arg(str, default=None) } result = None sorted_list = None data = parser.parse(args, request) if data['keyword']: api = 'http://api.keywordtool.io/v1/search/google?apikey=%s&country=in&language=en&metrics=true&keyword=%s' % (apikey, data['keyword']) r = requests.post(api) result = json.loads(r.text)['results'] sorted_list = sorted(result) return render_template('keyword_data.html', data=result, sorted_list=sorted_list)
def get_dbs( cls, admin=None, active=None, verified=None, permissions=None, **kwargs ): args = parser.parse({ 'admin': wf.Bool(missing=None), 'active': wf.Bool(missing=None), 'verified': wf.Bool(missing=None), 'permissions': wf.DelimitedList(wf.Str(), delimiter=',', missing=[]), }) return super(User, cls).get_dbs( admin=admin or args['admin'], active=active or args['active'], verified=verified or args['verified'], permissions=permissions or args['permissions'], **kwargs )
def create_question(course, year, period): args = parser.parse(POST_PARAMS, request) paper = model.Paper.find(db.session, course, year, period) question = model.Question(paper, index=args["index"]) if "content" in args: question.set_content(g.user, args["content"]) db.session.add(question) db.session.commit() db.session.refresh(question) # Load the paper getattr(question, "paper") getattr(question, "comment_count") getattr(question, "similar_count") return respond({ "question": question })
def get(self, bucket_id, filename, **kwargs): """Get object. .. http:get:: /files/(uuid:bucket_id)/(string:filename) Sends file to the client. **Request**: .. sourcecode:: http GET /files/4b60f39d-b960-442f-be68-b4b8b04c38a9/f.pdf HTTP/1.1 Accept: application/json Connection: keep-alive Content-Type: application/json Host: localhost:5000 :reqheader Content-Type: application/json :query uuid version_id: uuid of a specific version of a file. **Response**: .. sourcecode:: http HTTP/1.0 200 OK Content-Type: application/pdf ETag: "flask-1449350517.0-15192-1285496294" Downloading to "f.pdf" :resheader Content-Type: application/json :statuscode 200: no error :statuscode 403: access denied :statuscode 404: page not found """ args = parser.parse(self.get_args, request) obj = Object.get( bucket_id, filename, version_id=args.get('version_id', None)) if obj: storage = StorageFactory.get(obj.location) return storage.send_file(obj.filename) abort(404, 'This object file does not exist or has been deleted.')
def add_new_content_result(): args = { 'url': Arg(str, required=True), 'short_description': Arg(str, default=None), 'content_header': Arg(str, default=None), 'content': Arg(str, required=True) } data = parser.parse(args, request) r = requests.post(api_base_url + '/seo/content/add_content', data) message = "Error while adding content for " + data['url'] + ". Review the content and other parameters once, contact admin if that doesn't help!" message_color = "red" if json.loads(r.text)['result'] and json.loads(r.text)['result'] == 'Success': message = "Content for " + data['url'] + " has been added successfully!" message_color = "green" return render_template('result.html', message=message, message_color=message_color)
def post(self): args = parser.parse({ 'username': wf.Str(missing=None), 'email': wf.Str(missing=None), 'password': wf.Str(missing=None), }) handler = args['username'] or args['email'] password = args['password'] if not handler or not password: return flask.abort(400) user_db = model.User.get_by( 'email' if '@' in handler else 'username', handler.lower() ) if user_db and user_db.password_hash == util.password_hash(user_db, password): auth.signin_user_db(user_db) return helpers.make_response(user_db, model.User.FIELDS) return flask.abort(401)
def post(self): args = parser.parse(reading_args) # if reading_search(args['device_id'], args['timestamp']): # return conflict("Record already exists for device {d} at time {t}".format(d=args['device_id'], # t=args['timestamp'])), 409 log_id = uuid.uuid4() humidity = args['humidity'] if 'humidity' in args else 0.0 reading = Readings(log_id=log_id, temperature=args['temperature'], humidity=humidity, device_id=args['device_id'], timestamp=args['timestamp'] ) # result_json = reading_schema.dump(reading).data save_reading(reading) # collection = create_collection('1.0', request.url, result) return "Location: " + reading.url, 200
def user_list(): args = parser.parse({ 'email': wf.Str(missing=None), 'permissions': wf.DelimitedList(wf.Str(), delimiter=',', missing=[]), }) user_dbs, cursors = model.User.get_dbs( email=args['email'], prev_cursor=True, ) permissions = list(UserUpdateForm._permission_choices) permissions += args['permissions'] return flask.render_template( 'user/user_list.html', html_class='user-list', title='User List', user_dbs=user_dbs, next_url=util.generate_next_url(cursors['next']), prev_url=util.generate_next_url(cursors['prev']), api_url=flask.url_for('api.admin.user.list'), permissions=sorted(set(permissions)), )
def wrapped(*args, **kwargs): req_args = webargs_parser.parse({ 'existing_submission_id': webargs_fields.Int(missing=None), 'cgac_code': webargs_fields.String(missing=None), 'frec_code': webargs_fields.String(missing=None) }) # Ensure there is either an existing_submission_id, a cgac_code, or a frec_code if req_args['existing_submission_id'] is None and req_args['cgac_code'] is None and \ req_args['frec_code'] is None: raise ResponseException('Missing required parameter: cgac_code, frec_code, or existing_submission_id', StatusCode.CLIENT_ERROR) # Use codes based on existing Submission if existing_submission_id is provided, otherwise use CGAC or FREC if req_args['existing_submission_id'] is not None: check_existing_submission_perms(perm, req_args['existing_submission_id']) else: # Check permissions for the agency if not current_user_can(perm, cgac_code=req_args['cgac_code'], frec_code=req_args['frec_code']): raise ResponseException("User does not have permissions to write to that agency", StatusCode.PERMISSION_DENIED) return fn(*args, **kwargs)
def book_create(): if request.method == "GET": return render_template("book/create.html") validator = Book.get_input_validator() try: args = parser.parse(validator, request) except Exception as e: return render_template("book/create.html", error=str(e.data["exc"].arg_name)) book = Book() book.author = args["author"] book.name = args["name"] book.year = args["year"] # file file = request.files["file"] extension = file.filename.split(".")[-1] or "" book.file = book.id + "." + extension file.save(os.path.join(app.config["UPLOAD_FOLDER"], book.file)) # book.added_by_login = current_user.login book.save() return redirect(url_for("main"))
def google_suggest_api(): google_suggest_domain = [ 'http://google.com/complete/search', 'http://suggestqueries.google.com/complete/search', 'http://clients1.google.com/complete/search' ] args = { 'keyword': Arg(str, default=None) } result = None data = parser.parse(args, request) keyword = data['keyword'] if keyword: domain_picked = random.choice(google_suggest_domain) api = '%s?client=firefox&q=%s&hl=en&gl=in' % (domain_picked, keyword) r = requests.get(api) result = json.loads(r.text)[1] return render_template('google_suggest.html', keyword=keyword, data=result)
def edit_comment(entity, comment): with query(model.Entity): entity = db.session.query(model.Entity).filter(model.Entity.id == entity).one() comment = db.session.query(model.Comment).filter(model.Comment.id == comment).one() # Ensure the user is the author if not g.user.id == comment.user.id: raise Unauthorized() if request.method == "DELETE": comment.content = "" comment.deleted = True elif request.method == "PUT": args = parser.parse({ "content": fields.Str(required=True) }) comment.content = args["content"] # Fix up the cache if entity.type == "question": db.session.refresh(entity) question = entity paper = entity.paper course = paper.course invalidate_view("question.do_question", course=course.code, year=paper.year_start, period=paper.period, question=".".join(map(str, question.path))) # Invalidate the comment cache for specific entity invalidate_view("comment.get_comments", entity=entity.id) db.session.add(comment) db.session.commit() db.session.refresh(comment) getattr(comment, "children") return respond({ "entity": entity, "comment": comment })
def multipart_uploadpart(self, multipart, content_md5=None, content_length=None): """Upload a part.""" if content_length != multipart.chunk_size: raise MultipartInvalidChunkSize() # Extract part number from request. data = None for schema in current_files_rest.uploadparts_schema_factory: try: data = parser.parse(schema) if data: break except UnprocessableEntity: pass if not data or data.get('part_number') is None: raise MultipartInvalidPartNumber() part_number = data['part_number'] # Create part try: p = Part.get_or_create(multipart, part_number) p.set_contents(request.stream) db.session.commit() except Exception: # We remove the Part since incomplete data may have been written to # disk (e.g. client closed connection etc.) db.session.rollback() Part.delete(multipart, part_number) raise return self.make_response( data=p, context={ 'class': Part, }, etag=p.checksum )