def wsgi_app(self, environ, start_response): """Execute this instance as a WSGI application. See the PEP for the meaning of parameters. The separation of __call__ and wsgi_app eases the insertion of middlewares. """ urls = self._url_map.bind_to_environ(environ) try: endpoint, args = urls.match() except HTTPException as exc: return exc assert endpoint == "rpc" remote_service = ServiceCoord(args['service'], args['shard']) if remote_service not in self._service.remote_services: return NotFound() if self._auth is not None and not self._auth( args['service'], args['shard'], args['method']): return Forbidden() request = Request(environ) request.encoding_errors = "strict" # TODO Check content_encoding and content_md5. if request.mimetype != "application/json": return UnsupportedMediaType() if request.accept_mimetypes.quality("application/json") <= 0: return NotAcceptable() try: data = json.load(request.stream) except ValueError: return BadRequest() if not self._service.remote_services[remote_service].connected: return ServiceUnavailable() result = self._service.remote_services[remote_service].execute_rpc( args['method'], data) result.wait(timeout=60) response = Response() response.status_code = 200 response.mimetype = "application/json" response.data = json.dumps({ "data": result.value, "error": None if result.successful() else "%s" % result.exception }) return response
def retrieve(id_type: str, identifier: str, version: Optional[str] = None, content_fmt: str = SupportedFormats.PLAIN) -> Response: """Retrieve full-text content for an arXiv paper.""" if identifier is None: raise BadRequest('identifier missing in request') available = ['application/json', 'text/plain'] content_type = best_match(available, 'application/json') # Authorization is required to work with submissions. authorizer: Optional[Authorizer] = None if id_type == SupportedBuckets.SUBMISSION: authorizer = make_authorizer(scopes.READ_COMPILE) data, code, headers = controllers.retrieve(identifier, id_type, version, content_fmt=content_fmt, authorizer=authorizer) if content_type == 'text/plain': response_data = Response(data['content'], content_type='text/plain') elif content_type == 'application/json': if 'content' in data: data['content'] = data['content'] response_data = jsonify(data) else: raise NotAcceptable('unsupported content type') response: Response = make_response(response_data, code, headers) return response
def wsgi_app(self, environ, start_response): route = self.router.bind_to_environ(environ) try: endpoint, args = route.match() except HTTPException as exc: return exc(environ, start_response) assert endpoint == "sublist" request = Request(environ) request.encoding_errors = "strict" if request.accept_mimetypes.quality("application/json") <= 0: raise NotAcceptable() result = list() for task_id in iterkeys(self.task_store._store): result.extend(itervalues( self.scoring_store.get_submissions(args["user_id"], task_id))) result.sort(key=lambda x: (x.task, x.time)) result = list(a.__dict__ for a in result) response = Response() response.status_code = 200 response.mimetype = "application/json" response.data = json.dumps(result) return response(environ, start_response)
def validate_file_with_ap(body: dict, data_file: FileStorage) -> tuple: """ API method to handle file validation. :param data_file: The file to be validated :param body: a dictionary with the json fields: :application_profile - application profile name :return: validation task id :rtype: dict, int """ logger.debug('start validate file endpoint') application_profile = body.get('application_profile') apm = ApplicationProfileManager(application_profile=application_profile) try: schema_files = apm.list_ap_files_paths() except LookupError as e: logger.exception(str(e)) raise NotAcceptable(str(e)) # 500 filenames = [Path(shape_path).name for shape_path in schema_files] filenames.append(data_file.filename) check_for_file_exceptions(schema_files, filenames) saved_location, save_file_to_validate, _ = save_data_for_validation(file_to_validate=data_file, shacl_shapes=[], location=config.RDF_VALIDATOR_FILE_DB) task = async_validate_file.delay(str(uuid4()), save_file_to_validate, schema_files, saved_location, application_profile) logger.debug('finish request to validate file endpoint') return {'task_id': task.id}, 200
def make_response(self, data, *args, **kwargs): """Looks up the representation transformer for the requested media type, invoking the transformer to create a response object. This defaults to default_mediatype if no transformer is found for the requested mediatype. If default_mediatype is None, a 406 Not Acceptable response will be sent as per RFC 2616 section 14.1 :param data: Python object containing response data to be transformed """ default_mediatype = kwargs.pop('fallback_mediatype', None) or self.default_mediatype mediatype = request.accept_mimetypes.best_match( self.representations, default=default_mediatype, ) if mediatype is None: raise NotAcceptable() if mediatype in self.representations: resp = self.representations[mediatype](data, *args, **kwargs) resp.headers['Access-Control-Allow-Origin'] = current_app.config['ACCESS_CONTROL_ALLOW_ORIGIN_HEADER'] resp.headers['Access-Control-Allow-Headers'] = current_app.config['ACCESS_CONTROL_ALLOW_HEADERS'] resp.headers['Access-Control-Allow-Methods'] = current_app.config['ACCESS_CONTROL_ALLOW_METHODS'] resp.headers['Content-Type'] = mediatype return resp elif mediatype == 'text/plain': resp = original_flask_make_response(str(data), *args, **kwargs) resp.headers['Access-Control-Allow-Origin'] = current_app.config['ACCESS_CONTROL_ALLOW_ORIGIN_HEADER'] resp.headers['Access-Control-Allow-Headers'] = current_app.config['ACCESS_CONTROL_ALLOW_HEADERS'] resp.headers['Access-Control-Allow-Methods'] = current_app.config['ACCESS_CONTROL_ALLOW_METHODS'] resp.headers['Content-Type'] = 'text/plain' return resp else: raise InternalServerError()
def validate_sparql_endpoint_with_ap(body) -> tuple: """ API method to handle SPARQL endpoint validation. :param body: a dictionary with the json fields: :sparql_endpoint_url - The endpoint to validate :graphs - An optional list of named graphs to restrict the scope of the validation :application_profile - application profile name :return: validation task id :rtype: dict, int """ logger.debug('start validate sparql endpoint') application_profile = body.get('application_profile') sparql_endpoint_url = body.get('sparql_endpoint_url') graphs = body.get('graphs') apm = ApplicationProfileManager(application_profile=application_profile) try: schema_files = apm.list_ap_files_paths() except LookupError as e: logger.exception(str(e)) raise NotAcceptable(str(e)) # 500 filenames = [Path(shape_path).name for shape_path in schema_files] check_for_file_exceptions(schema_files, filenames) saved_location, _, _ = save_data_for_validation(file_to_validate=None, shacl_shapes=[], location=config.RDF_VALIDATOR_FILE_DB) task = async_validate_url.delay(str(uuid4()), sparql_endpoint_url, graphs, schema_files, saved_location, application_profile) logger.debug('finish request to validate sparql endpoint') return {'task_id': task.id}, 200
def authenticate(): """Authenticate a user.""" if not request_wants_json(): raise NotAcceptable() username = request.json.get("username", None) password = request.json.get("password", None) print("AUTH for: {}/{}".format(username, password)) if not username or not password: return jsonify(bad_creds) user = User.query.filter_by(login=username).first() print("AUTH got user: {}".format(user)) if user.check_password(password): print("AUTH check password hash ok") access_token = create_access_token(identity={ 'sub': user.login, 'auth': [a.name for a in user.authorities], 'exp': 1563635440 }) return jsonify(access_token=access_token), 200 return jsonify(bad_creds), 401
def prep_response(self, request, path, data, contenttype, params): if path and os.path.exists(path): status = 200 # FIXME: These are not terribly well designed flow control # mechanisms if path.endswith("page_error.png"): status = 500 elif path.endswith(".404"): status = 404 fp = wrap_file(request.environ, open(path, 'rb')) headers = Headers({"Content-length": os.path.getsize(path)}) elif data: fp = wrap_file(request.environ, BytesIO(data)) status = 200 headers = Headers({"Content-length": len(data)}) else: msg = "No acceptable media could be found for requested type(s) %s" % request.headers.get( "Accept") if path: # then os.path.exists(path) must be false msg += " (%s does not exist)" % path raise NotAcceptable(msg) return Response(fp, status, headers, mimetype=contenttype, direct_passthrough=True)
def select_representation( representations, accept='*/*', accept_language=None, accept_charset=None): max_quality = tuple() best = None for representation in representations: try: quality = representation.quality(accept=accept, accept_language=accept_language, accept_charset=accept_charset) except NotAcceptable: continue if not isinstance(quality, tuple): quality = (quality,) # Later bindings take precedence if quality >= max_quality: best = representation max_quality = quality if best is None: raise NotAcceptable() return best
def make_response(self, *args, **kwargs): """Looks up the representation transformer for the requested media type, invoking the transformer to create a response object. This defaults to default_mediatype if no transformer is found for the requested mediatype. If default_mediatype is None, a 406 Not Acceptable response will be sent as per RFC 2616 section 14.1 :param data: Python object containing response data to be transformed """ if len(args) > 1 and args[1] == 204: # 204, no content, force text/plain so we don't add any data during transform mediatype = 'text/plain' else: default_mediatype = kwargs.pop('fallback_mediatype', None) or self.default_mediatype mediatype = request.accept_mimetypes.best_match( self.representations, default=default_mediatype, ) if mediatype is None: raise NotAcceptable() if mediatype in self.representations: resp = self.representations[mediatype](*args, **kwargs) resp.headers['Content-Type'] = mediatype return resp elif mediatype == 'text/plain': resp = original_flask_make_response(*args) resp.headers['Content-Type'] = 'text/plain' return resp else: raise InternalServerError()
def make_response(self, request, data, *args, **kwargs): """Looks up the representation transformer for the requested media type, invoking the transformer to create a response object. This defaults to default_mediatype if no transformer is found for the requested mediatype. If default_mediatype is None, a 406 Not Acceptable response will be sent as per RFC 2616 section 14.1 :param data: Python object containing response data to be transformed """ default_mediatype = kwargs.pop("fallback_mediatype", None) or self.default_mediatype mediatype = parse_accept_header(request.headers.get( 'accept', None)).best_match(self.representations, default=default_mediatype) if not mediatype: raise NotAcceptable("Not Acceptable") if mediatype in self.representations: resp = self.representations[mediatype](request.app, data, *args, **kwargs) resp.headers["Content-type"] = mediatype return resp elif mediatype == "text/plain": resp = text(str(data), *args, **kwargs) return resp else: raise ServerError(None)
def make_response(self, data, *args, **kwargs): """ Looks up the representation transformer for the requested media type, invoking the transformer to create a response object. This defaults to default_mediatype if no transformer is found for the requested mediatype. If default_mediatype is None, a 406 Not Acceptable response will be sent as per RFC 2616 section 14.1 :param data: Python object containing response data to be transformed """ default_mediatype = (kwargs.pop("fallback_mediatype", None) or self.default_mediatype) mediatype = request.accept_mimetypes.best_match( self.representations, default=default_mediatype, ) if mediatype is None: raise NotAcceptable() if mediatype in self.representations: resp = self.representations[mediatype](data, *args, **kwargs) resp.headers["Content-Type"] = mediatype return resp elif mediatype == "text/plain": resp = original_flask_make_response(str(data), *args, **kwargs) resp.headers["Content-Type"] = "text/plain" return resp else: raise InternalServerError()
def get_all(): """Return all users.""" if not request_wants_json(): raise NotAcceptable() items = User.query.all() return jsonify(UserSchema(many=True).dump(items).data)
def get_list(self, request, response): if request.accept_mimetypes.quality("application/json") <= 0: raise NotAcceptable() response.status_code = 200 response.headers[b'Timestamp'] = b"%0.6f" % time.time() response.mimetype = "application/json" response.data = json.dumps(self.store.retrieve_list())
def wrapper(*args, **kwargs): acceptables = acceptable_media_types(request) acceptable = choose_media_type(acceptables, media_types) if acceptable is None: raise NotAcceptable() if not to is None: kwargs.update({to: acceptable}) return fn(*args, **kwargs)
def HistoryHandler(request, response): if request.accept_mimetypes.quality("application/json") <= 0: raise NotAcceptable() result = list(Scoring.store.get_global_history()) response.status_code = 200 response.mimetype = "application/json" response.data = json.dumps(result)
def wsgi_app(self, environ, start_response): request = Request(environ) urls = self.url_map.bind_to_environ(environ) try: # Define view endpoint, args = urls.match() if endpoint not in self.view_map: raise NotFound("Endpoint not found in view_map.") view = self.view_map[endpoint] method = request.method.lower() if method not in view['methods']: raise MethodNotAllowed() resource = view['resource_' + method] or view['resource'] accept = view['accept_' + method] or view['accept'] or ['text/html'] acl = view['acl_' + method] data = None query = None accepted = request.accept_mimetypes.best_match(accept) if not accepted: raise NotAcceptable() if resource: resource = resource(request) resource.load(args, query) if acl and not resource.check_acl(acl): raise Forbidden() if not resource.check_exists(): raise NotFound() if method == 'put' or method == 'post': resource.save(data) elif method == 'delete': resource.delete() resource = None accepted_handler = self.mimetype_map[accepted] \ if accepted in self.mimetype_map \ else self.mimetype_map['*/*'] mimetype_handler = accepted_handler(self) response = Response(mimetype_handler(request, view, resource)) response.headers['Content-Type'] = accepted if method == 'post' and resource: response.status_code = 201 response.headers['Location'] = resource.resource_url() return response(environ, start_response) except HTTPException as e: return e(environ, start_response)
def _api_check_access(self, _id, log_entry): # If multiwebsite we need to set a different domain for the search request.website = request.env['website'].search([], limit=1) api_partner = request.env['ir.config_parameter'].sudo().get_param( 'rest_api_dismac.api_partner', False) if not _id: _logger.error(_("REST API called without order id.")) log_entry.sudo().update({ 'error': True, 'error_msg': _("REST API called without order id.") }) raise BadRequest(_("REST API called without order id.")) sale_order = request.env['sale.order'].sudo().search([('id', '=', _id) ]) if not sale_order: _logger.error(_("REST API could not find that order number.")) log_entry.sudo().update({ 'error': True, 'error_msg': _("REST API could not find that order number.") }) raise NotFound(_("REST API could not find that order number.")) else: log_entry.sudo().update({'order_id': _id}) if sale_order.state != 'sale': _logger.error(_("REST API access not allowed to this order.")) log_entry.sudo().update({ 'error': True, 'error_msg': _("REST API access not allowed to this order.") }) raise NotAcceptable( _("REST API access not allowed to this order.")) api_partner_obj = request.env['res.partner'].browse(int(api_partner)) if not (api_partner_obj == sale_order.partner_id or api_partner_obj == sale_order.partner_id.parent_id): _logger.error(_("REST API access not allowed to this order.")) log_entry.sudo().update({ 'error': True, 'error_msg': _("REST API access not allowed to this order.") }) raise NotFound(_("REST API access not allowed to this order.")) return True
def register_user(): """Register a new user.""" if not request_wants_json(): raise NotAcceptable() try: user = UserSchema().load(request.json) except ValueError as e: raise InternalServerError else: user.save() return '', 201
def _log_index(self, req, logs): if not req.accept_mimetypes.provided: response_type = 'text/html' else: response_type = req.accept_mimetypes.best_match(['text/html', 'application/atom+xml']) if not response_type: raise NotAcceptable() if response_type == 'text/html': return self._html_log_index(logs) elif response_type == 'application/atom+xml': return self._atom_log_index(logs)
def delete(self, id): if request.headers.get("Accept") != 'application/json': raise NotAcceptable("Invalid Accept") try: event = Event.query.filter_by(id=id).one() except NoResultFound: raise BadRequest("Invalid ID supplied") db.session.delete(event) db.session.commit() return make_response(json.dumps({"Deleted": "OK"}), 204)
def query(req): cars = [dict(car) for car in User.query()] result = dumps(cars) # logging.info(cars) if req.headers['Accept'] != 'application/json': raise NotAcceptable() return Response( result, mimetype='application/json', status=200, )
def mimetype_to_type(mime_type: str) -> str: """ Translate MIME type to output type. For unknown types, raise HTTP Not Acceptable. :param mime_type: The MIME type string. :return: The image type string. """ try: return mimetype_type_map[mime_type] except KeyError: raise NotAcceptable( description=f"Output type not acceptable: {mime_type}")
def get(self, id): if request.headers.get("Accept") != 'application/json': raise NotAcceptable("Invalid Accept") if len(id) != 36: raise BadRequest("Invalid ID supplied") try: event = Event.query.filter_by(id=id).one() except NoResultFound: raise NotFound("Event not found") return event.to_dict()
def index(self): ''' Open an SSE stream. ''' if request.headers.get('Accept') == 'text/event-stream': redis = app.database.get_redis(dict(g.config.items('redis'))) pubsub = redis.pubsub(ignore_subscribe_messages=True) pubsub.subscribe(*self.__class__.CHANNELS) return Response(self._stream(pubsub), content_type='text/event-stream') else: message = 'This endpoint is only for use with server-sent ' \ 'events (SSE).' raise NotAcceptable(message)
def stop_running_task(task_id: str) -> tuple: """ Revoke a task :param task_id: Id of task to revoke """ try: tasks = flatten_active_tasks(retrieve_active_tasks()) task = next(task for task in tasks if task["id"] == task_id) kill_task(task, config.RDF_VALIDATOR_REPORTS_DB) except: raise NotAcceptable('task already finished executing or does not exist') # 406 return {'message': f'task {task_id} set for revoking.'}, 200
def SubListHandler(request, response, user_id): if request.accept_mimetypes.quality("application/json") <= 0: raise NotAcceptable() result = list() for task_id in Task.store._store.iterkeys(): result.extend(Scoring.store.get_submissions(user_id, task_id).values()) result.sort(key=lambda x: (x.task, x.time)) result = list(a.__dict__ for a in result) response.status_code = 200 response.mimetype = "application/json" response.data = json.dumps(result)
def get(self, request, response, key): # Limit charset of keys. if re.match("^[A-Za-z0-9_]+$", key) is None: return NotFound() if key not in self.store: raise NotFound() if request.accept_mimetypes.quality("application/json") <= 0: raise NotAcceptable() response.status_code = 200 response.headers[b'Timestamp'] = b"%0.6f" % time.time() response.mimetype = "application/json" response.data = json.dumps(self.store.retrieve(key))
def type_to_mimetype(output_type: str) -> str: """ Translate output type to MIME type. For unknown types, raise HTTP Not Acceptable. :param output_type: The output type string. :return: The MIME type string. """ try: return mimetype_type_map.lookup(output_type) except KeyError: raise NotAcceptable( description=f"Output type not acceptable: {output_type}")
def __call__(self, *args, **kwargs): # find the correct version / tagged view and call it. version, flag = parse_accept_headers(self.service.vendor, request.accept_mimetypes.values()) if version is None: version = EndpointMap.DefaultView view = self.endpoint_map.get_view(version, flag) if view: return view(*args, **kwargs) else: description = "Could not find view for version '%s'" % version if flag is not None: description += " and flag '%s'" % flag raise NotAcceptable(description)