def update_batch(**path_data): request_data = load_request_data(definition.request_schema) response_data = definition.func( **merge_data(path_data, request_data)) return dump_response_data(definition.response_schema, response_data, operation.value.default_code)
def make_json_error(error): """ Handle errors by logging and """ message = extract_error_message(error) status_code = extract_status_code(error) context = extract_context(error) retryable = extract_retryable(error) headers = extract_headers(error) # Flask will not log user exception (fortunately), but will log an error # for exceptions that escape out of the application entirely (e.g. if the # error handler raises an error) error_logger.debug("Handling {} error: {}".format( status_code, message, )) # Serialize into JSON response response_data = { "code": status_code, "context": context, "message": message, "retryable": retryable, } # Don't pass in the error schema because it will suppress any extra fields return dump_response_data(None, response_data, status_code, headers)
def create(**path_data): request_data = load_request_data(definition.request_schema) response_data = require_response_data( definition.func(**merge_data(path_data, request_data))) return dump_response_data(definition.response_schema, response_data, Operation.CreateFor.value.default_code)
def create_collection(**path_data): request_data = load_request_data(definition.request_schema) # NB: if we don't filter the request body through an explicit page schema, # we will leak other request arguments into the pagination query strings page = self.page_cls.from_query_string(self.page_schema(), request_data) result = definition.func(**merge_data( path_data, merge_data( request_data, page.to_dict(func=identity), ), )) response_data, headers = page.to_paginated_list( result, ns, Operation.CreateCollection) definition.header_func(headers, response_data) response_format = self.negotiate_response_content( definition.response_formats) return dump_response_data( paginated_list_schema, response_data, headers=headers, response_format=response_format, )
def update(**path_data): # NB: using partial here means that marshmallow will not validate required fields request_data = load_request_data(definition.request_schema, partial=True) response_data = require_response_data( definition.func(**merge_data(path_data, request_data))) return dump_response_data(definition.response_schema, response_data)
def replace(**path_data): request_data = load_request_data(definition.request_schema) # Replace/put should create a resource if not already present, but we do not # enforce these semantics at the HTTP layer. If `func` returns falsey, we # will raise a 404. response_data = require_response_data( definition.func(**merge_data(path_data, request_data))) return dump_response_data(definition.response_schema, response_data)
def foo_command(): """ My doc string """ request_data = load_request_data(request_schema) response_data = dict( result=True, value=request_data["value"], ) return dump_response_data(response_schema, response_data, Operation.Command.value.default_code)
def foo_query(): """ My doc string """ request_data = load_query_string_data(request_schema) response_data = dict( result=True, value=request_data["value"], ) return dump_response_data(response_schema, response_data, Operation.Query.value.default_code)
def retrieve(**path_data): headers = dict() request_data = load_query_string_data(request_schema) response_data = require_response_data(definition.func(**merge_data(path_data, request_data))) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( definition.response_schema, response_data, headers=headers, response_format=response_format, )
def search(**path_data): page = self.page_cls.from_query_string(definition.request_schema) result = definition.func(**merge_data(path_data, page.to_dict(func=identity))) response_data, headers = page.to_paginated_list(result, ns, Operation.Search) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( paginated_list_schema, response_data, headers=headers, response_format=response_format, )
def update_batch(**path_data): headers = dict() request_data = load_request_data(definition.request_schema) response_data = definition.func(**merge_data(path_data, request_data)) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( definition.response_schema, response_data, status_code=operation.value.default_code, headers=headers, response_format=response_format, )
def create(**path_data): request_data = load_request_data(definition.request_schema) response_data = definition.func(**merge_data(path_data, request_data)) headers = encode_id_header(response_data) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( definition.response_schema, response_data, status_code=Operation.Create.value.default_code, headers=headers, response_format=response_format, )
def delete(**path_data): headers = dict() request_data = load_query_string_data(request_schema) response_data = require_response_data(definition.func(**merge_data(path_data, request_data))) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( "", None, status_code=Operation.Delete.value.default_code, headers=headers, response_format=response_format, )
def update(**path_data): headers = dict() # NB: using partial here means that marshmallow will not validate required fields request_data = load_request_data(definition.request_schema, partial=True) response_data = require_response_data(definition.func(**merge_data(path_data, request_data))) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( definition.response_schema, response_data, headers=headers, response_format=response_format, )
def count(**path_data): request_data = load_query_string_data(definition.request_schema) response_data = dict() count = definition.func(**merge_data(path_data, request_data)) headers = encode_count_header(count) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( None, None, headers=headers, response_format=response_format, )
def delete(**path_data): headers = dict() response_data = dict() require_response_data(definition.func(**path_data)) definition.header_func(headers, response_data) response_format = self.negotiate_response_content( definition.response_formats) return dump_response_data( "", None, status_code=Operation.DeleteFor.value.default_code, headers=headers, response_format=response_format, )
def replace(**path_data): headers = dict() request_data = load_request_data(definition.request_schema) # Replace/put should create a resource if not already present, but we do not # enforce these semantics at the HTTP layer. If `func` returns falsey, we # will raise a 404. response_data = require_response_data(definition.func(**merge_data(path_data, request_data))) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( definition.response_schema, response_data, headers=headers, response_format=response_format, )
def search(**path_data): request_data = load_query_string_data(definition.request_schema) page = Page.from_query_string(request_data) items, count, context = definition.func( **merge_data(path_data, request_data)) response_data = self.paginated_list_class( ns=ns, page=page, items=items, count=count, schema=definition.response_schema, operation=Operation.SearchFor, **context) return dump_response_data(paginated_list_schema, response_data)
def upload(**path_data): merged_data = merge_data(request.args.to_dict(), request.form.to_dict()) request_data = load_query_string_data(request_schema, merged_data) if not request.files: raise BadRequest("No files were uploaded") uploads = [ temporary_upload(name, fileobj) for name, fileobj in request.files.items() if not self.exclude_func(name, fileobj) ] with nested(*uploads) as files: response_data = definition.func(files, **merge_data(path_data, request_data)) if response_data is None: return "", 204 return dump_response_data(response_schema, response_data, operation.value.default_code)
def upload(**path_data): request_data = load_query_string_data(request_schema) if not request.files: raise BadRequest("No files were uploaded") uploads = [ temporary_upload(name, fileobj) for name, fileobj in request.files.items() if not self.exclude_func(name, fileobj) ] with nested(*uploads) as files: response_data = definition.func( files, **merge_data(path_data, request_data)) if response_data is None: return "", 204 return dump_response_data(response_schema, response_data, operation.value.default_code)
def search(**path_data): request_data = load_query_string_data(definition.request_schema) page = self.page_cls.from_query_string(request_data) return_value = definition.func( **merge_data(path_data, request_data)) if len(return_value) == 3: items, count, context = return_value else: context = {} items, count = return_value response_data = PaginatedList(ns=ns, page=page, items=items, count=count, schema=definition.response_schema, operation=Operation.Search, **context) return dump_response_data(paginated_list_schema, response_data)
def handle(self, error): """ Generates a response that follows connexion's error format i.e., "status": http status code, "title": Short description, "detail": "detail message", "type": "An absolute URI that identifies the problem type. When dereferenced, it SHOULD provide human-readable documentation for the problem type" Note: Heavily inspired by the microcosm_flask.errors module just needed a different format """ status = extract_status_code(error) title = self.extract_title(error) detail = extract_error_message(error) type_name = "about:blank" # To make sure that we have some stack trace for 500+ errors if status >= 500: self.logger.exception(error) self.logger.debug( "Handling error {} with status {}, title {}, detail {}, type_name {}" .format( error, status, title, detail, type_name, )) response_data = { "status": status, "title": title, "detail": detail, "type": type_name, } return dump_response_data(None, response_data, status)
def create_collection(**path_data): request_data = load_request_data(definition.request_schema) page = self.page_cls.from_query_string(self.page_schema(), {}) result = definition.func(**merge_data( path_data, merge_data( request_data, page.to_dict(func=identity), ), )) response_data, headers = page.to_paginated_list( result, ns, Operation.CreateCollection) definition.header_func(headers, response_data) response_format = self.negotiate_response_content( definition.response_formats) return dump_response_data( paginated_list_schema, response_data, headers=headers, response_format=response_format, )
def create_collection(**path_data): request_data = load_request_data(definition.request_schema) # NB: if we don't filter the request body through an explicit page schema, # we will leak other request arguments into the pagination query strings page = self.page_cls.from_query_string(self.page_schema(), request_data) result = definition.func(**merge_data( path_data, merge_data( request_data, page.to_dict(func=identity), ), )) response_data, headers = page.to_paginated_list(result, ns, Operation.CreateCollection) definition.header_func(headers, response_data) response_format = self.negotiate_response_content(definition.response_formats) return dump_response_data( paginated_list_schema, response_data, headers=headers, response_format=response_format, )
def count(**path_data): request_data = load_query_string_data(definition.request_schema) count = definition.func(**merge_data(path_data, request_data)) headers = encode_count_header(count) return dump_response_data(None, None, headers=headers)
def retrieve(**path_data): request_data = load_query_string_data(request_schema) response_data = require_response_data( definition.func(**merge_data(path_data, request_data))) return dump_response_data(definition.response_schema, response_data)
def retrieve(): logger_tree = build_logger_tree() return dump_response_data(response_schema, logger_tree)
def retrieve(**path_data): response_data = require_response_data(definition.func(**path_data)) return dump_response_data(definition.response_schema, response_data)