Example #1
0
    def dispatch_request(self, *args, **kwargs):

        # Taken from flask
        #noinspection PyUnresolvedReferences
        meth = getattr(self, request.method.lower(), None)
        if meth is None and request.method == 'HEAD':
            meth = getattr(self, 'get', None)
        assert meth is not None, 'Unimplemented method %r' % request.method

        for decorator in self.method_decorators:
            meth = decorator(meth)

        resp = meth(*args, **kwargs)

        if isinstance(resp, ResponseBase):  # There may be a better way to test
            return resp

        representations = self.representations or {}

        #noinspection PyUnresolvedReferences
        mediatype = request.accept_mimetypes.best_match(representations, default=None)
        if mediatype in representations:
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp
        elif request.content_type in representations:
            mediatype = request.content_type
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp

        return resp
Example #2
0
        def wrapper(*args, **kwargs):
            resp = f(*args, **kwargs)

            if isinstance(resp, tuple):
                data, code, headers = unpack(resp)
                return self.field.format(data), code, headers
            return self.field.format(resp)
Example #3
0
 def wrapper(*args, **kwargs):
     objects = f(*args, **kwargs)
     if objects[1] != 200:
         return objects
     if isinstance(objects, tuple):
         data, code, header = unpack(objects)
     else:
         data = objects
     if isinstance(data, dict) or isinstance(data, OrderedDict):
         data = self.prepare_objetcs(data)
         kwargs = self.prepare_kwargs(kwargs, data)
         kwargs["templated"] = True
         for link in self.links:
             kwargs["rel"] = link
             data["links"].append(
                 create_external_link("v1.{}".format(link), **kwargs))
         for link, uri in self.links_uri.items():
             kwargs["rel"] = link
             if uri is not None:
                 kwargs["uri"] = uri
             data["links"].append(
                 create_external_link("v1.{}".format(link), **kwargs))
     if isinstance(objects, tuple):
         return data, code, header
     else:
         return data
Example #4
0
 def wrapper(*args, **kwargs):
     resp = f(*args, **kwargs)
     if isinstance(resp, tuple):
         data, code, headers = unpack(resp)
         return marshal(data, self.fields, self.envelope), code, headers
     else:
         return marshal(resp, self.fields, self.envelope)
Example #5
0
    def access(self, func, price, *args, **kwargs):
        if self.channel_manager.node_online() is False:
            return "Ethereum node is not responding", 502
        if self.channel_manager.get_eth_balance() < config.PROXY_BALANCE_LIMIT:
            return "Channel manager ETH balance is below limit", 502
        try:
            data = RequestData(request.headers, request.cookies)
        except ValueError as e:
            return str(e), 409
        accepts_html = r'text/html' in request.headers.get('Accept', '')
        if callable(price):
            price = price(request.path)

        # payment required
        paywall, headers = self.paywall_check(price, data)
        if paywall and accepts_html is True:
            reply_data = func.__self__.get_paywall(request.path)
            return self.reply_webui(reply_data, headers)
        elif paywall:
            return self.reply_payment_required(price,
                                               reply_data='',
                                               headers=headers,
                                               gen_ui=accepts_html)

        # all ok, return actual content
        resp = func(request.path, *args, **kwargs)
        if isinstance(resp, Response):
            return resp
        else:
            data, code, resource_headers = unpack(resp)
            resource_headers.update(headers)
            return make_response(str(data), code, resource_headers)
Example #6
0
        def wrapper(*args, **kwargs):
            if hasattr(request, '__skip_marshalling'):
                return f(*args, **kwargs)

            fields_to_include = self._get_fields_to_include()
            if self._is_include_parameter_in_request():
                # only pushing "_include" into kwargs when the request
                # contained this parameter, to keep things cleaner (identical
                # behavior for passing "_include" which contains all fields)
                kwargs['_include'] = fields_to_include.keys()

            response = f(*args, **kwargs)

            if isinstance(response, ListResponse):
                wrapped_items = self.wrap_with_response_object(response.items)
                response.items = marshal(wrapped_items, fields_to_include)
                return marshal(response, ListResponse.resource_fields)
            # SQLAlchemy returns a class that subtypes tuple, but acts
            # differently (it's taken care of in `wrap_with_response_object`)
            if isinstance(response, tuple) and \
                    not isinstance(response, sql_alchemy_collection):
                data, code, headers = unpack(response)
                data = self.wrap_with_response_object(data)
                return marshal(data, fields_to_include), code, headers
            else:
                response = self.wrap_with_response_object(response)
                return marshal(response, fields_to_include)
    def dispatch_request(self, *args, **kwargs):
        """Overridden to support list and create method names, and improved
        decorator handling for methods
        """
        method = self._get_method_for_request()

        try:
            resp = method(*args, **kwargs)
        except Exception:
            if apm.is_initialized:
                apm.capture_exception()
            resp = ({
                'message': 'Server Error'
            }, HTTPStatus.INTERNAL_SERVER_ERROR, {})
            traceback.print_exc()
        if isinstance(resp, Response):
            return resp

        representations = self.representations or OrderedDict()
        mediatype = request.accept_mimetypes.best_match(representations,
                                                        default=None)
        if mediatype in representations:
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp

        return resp
Example #8
0
        def wrapper(*args, **kwargs):
            objects = f(*args, **kwargs)
            if isinstance(objects, tuple):
                data, code, header = unpack(objects)
            else:
                data = objects

            if self.resource.region:
                collection = {
                    "notes": {
                        "type": "notes",
                        "del": ["value"]
                    },
                    "exceptions": {
                        "type": "exceptions",
                        "del": ["date", "except_type"]
                    }
                }
                # Add notes exceptions
                for col in collection:
                    if not col in data or not isinstance(data[col], list):
                        data[col] = []
                        res = []
                        note = self.complete(data, collection[col])
                        [res.append(item) for item in note if not item in res]
                        data[col].extend(res)

            if isinstance(objects, tuple):
                return data, code, header
            else:
                return data
Example #9
0
    def dispatch_request(self, *args, **kwargs):

        # Taken from flask
        # noinspection PyUnresolvedReferences

        action = kwargs.get('action')
        if action:
            del kwargs['action']
        meth = partial(self._route, request.method.lower(), action)

        for decorator in self.method_decorators:
            meth = decorator(meth)

        resp = meth(*args, **kwargs)

        if isinstance(resp, ResponseBase):  # There may be a better way to test
            return resp

        representations = self.representations or OrderedDict()

        # noinspection PyUnresolvedReferences
        mediatype = request.accept_mimetypes.best_match(representations, default=None)
        if mediatype in representations:
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp

        return resp
Example #10
0
        def wrapper(*args, **kwargs):
            response, status, h = unpack(f(*args, **kwargs))
            if status == 200 and self.attribute in response:
                instance = i_manager.instances.get(self.resource.region)

                resource_args = self.resource.parsers["get"].parse_args()

                show_bss_stands = 'bss_stands' in resource_args.get('add_poi_infos')
                show_car_park = 'car_park' in resource_args.get('add_poi_infos')

                if show_bss_stands and instance and instance.bss_provider:
                    _handle(
                        response,
                        bss_provider_manager,
                        self.attribute,
                        self.logger,
                        'Error while handling BSS realtime availability',
                    )

                if show_car_park and instance and instance.car_park_provider:
                    _handle(
                        response,
                        car_park_provider_manager,
                        self.attribute,
                        self.logger,
                        'Error while handling car park realtime availability',
                    )

            return response, status, h
Example #11
0
    def dispatch_request(self, *args, **kwargs):

        # Taken from flask
        #noinspection PyUnresolvedReferences
        meth = getattr(self, request.method.lower(), None)
        if meth is None and request.method == 'HEAD':
            meth = getattr(self, 'get', None)
        assert meth is not None, 'Unimplemented method %r' % request.method

        if isinstance(self.method_decorators, Mapping):
            decorators = self.method_decorators.get(request.method.lower(), [])
        else:
            decorators = self.method_decorators

        for decorator in decorators:
            meth = decorator(meth)

        resp = meth(*args, **kwargs)

        if isinstance(resp, ResponseBase):  # There may be a better way to test
            return resp

        representations = self.representations or OrderedDict()

        #noinspection PyUnresolvedReferences
        mediatype = request.accept_mimetypes.best_match(representations,
                                                        default=None)
        if mediatype in representations:
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp

        return resp
Example #12
0
        def wrapper(*args, **kwargs):
            resp = f(*args, **kwargs)

            if isinstance(resp, tuple):
                data, code, headers = unpack(resp)
                return self.field.format(data), code, headers
            return self.field.format(resp)
Example #13
0
 def wrapper(*args, **kwargs):
     resp = f(*args, **kwargs)
     if isinstance(resp, tuple):
         data, code, headers = unpack(resp)
         return marshal(data, self.fields, self.envelope), code, headers
     else:
         return marshal(resp, self.fields, self.envelope)
Example #14
0
 def wrapper(*args, **kwargs):
     resp = f(*args, **kwargs)
     if isinstance(resp, tuple):
         data, code, headers = unpack(resp)
         return self.schema.dump(data, many=self.many).data, code, headers
     else:
         return self.schema.dump(resp, many=self.many).data
Example #15
0
 def wrapper(*args, **kwargs):
     resp = resource(*args, **kwargs)
     if isinstance(resp,
                   ResponseBase):  # There may be a better way to test
         return resp
     data, code, headers = unpack(resp)
     return self.make_response(data, code, headers=headers)
Example #16
0
 def wrapper(*args, **kwargs):
     resp = f(*args, **kwargs)
     if isinstance(resp, tuple):
         data, code, headers = unpack(resp)
         return self.schema.dump(data,
                                 many=self.many).data, code, headers
     else:
         return self.schema.dump(resp, many=self.many).data
Example #17
0
        def inner_wrapper(self, *args, **kwargs):
            resp = fn(self, *args, **kwargs)

            if isinstance(resp, tuple):
                data, code, headers = unpack(resp)
                return schema.dump(data)[0], code, headers
            else:
                return schema.dump(resp)[0]
Example #18
0
        def inner_wrapper(self, *args, **kwargs):
            resp = fn(self, *args, **kwargs)

            if isinstance(resp, tuple):
                data, code, headers = unpack(resp)
                return schema.dump(data)[0], code, headers
            else:
                return schema.dump(resp)[0]
Example #19
0
 def wrapper(*args, **kwargs):
     resp = func(*args, **kwargs)
     if isinstance(resp, tuple):
         query, code, headers = unpack(resp)
         data = self.make_pagination(query)
         return marshal(data, self.fields, self.envelope), code, headers
     else:
         data = self.make_pagination(resp)
         return marshal(data, self.fields, self.envelope)
Example #20
0
        def wrapper(*args, **kwargs):
            objects = f(*args, **kwargs)
            if objects[1] != 200:
                return objects
            if isinstance(objects, tuple):
                data, code, header = unpack(objects)
            else:
                data = objects
            pagination = data.get('pagination', None)
            endpoint = request.endpoint
            kwargs.update(request.args)
            if pagination and endpoint and "region" in kwargs:
                if (
                    "start_page" in pagination
                    and "items_on_page" in pagination
                    and "items_per_page" in pagination
                    and "total_result" in pagination
                ):
                    if "links" not in data:
                        data["links"] = []
                    start_page = int(pagination["start_page"])
                    items_per_page = int(pagination["items_per_page"])
                    items_on_page = int(pagination["items_on_page"])
                    total_result = int(pagination["total_result"])
                    kwargs["_external"] = True

                    if start_page > 0:
                        kwargs["start_page"] = start_page - 1
                        data["links"].append(
                            {"href": url_for(endpoint, **kwargs), "type": "previous", "templated": False}
                        )
                    nb_next_page = items_per_page * start_page
                    nb_next_page += items_on_page
                    if total_result > nb_next_page:
                        kwargs["start_page"] = start_page + 1
                        data["links"].append(
                            {"href": url_for(endpoint, **kwargs), "type": "next", "templated": False}
                        )
                        if items_per_page == 0 or total_result == 0:
                            kwargs["start_page"] = 0
                        else:
                            nb_last_page = total_result - 1
                            nb_last_page = int(nb_last_page / items_per_page)
                            kwargs["start_page"] = nb_last_page
                            data["links"].append(
                                {"href": url_for(endpoint, **kwargs), "type": "last", "templated": False}
                            )

                        del kwargs["start_page"]
                    data["links"].append(
                        {"href": url_for(endpoint, **kwargs), "type": "first", "templated": False}
                    )
            if isinstance(objects, tuple):
                return data, code, header
            else:
                return data
Example #21
0
 def wrapper(*args, **kwargs):
     resp = resource(*args, **kwargs)
     if isinstance(resp, ResponseBase):  # There may be a better way to test
         return resp
     output, code, headers = unpack(resp)
     if isinstance(output, Output):
         data = output.show()
     else:
         data = output
     return self.make_response(data, code, headers=headers)
Example #22
0
		def wrapper(*args, **kwargs):
			resp = f(*args, **kwargs)
			if isinstance(resp, tuple):
				data, code, headers = unpack(resp)
				if data is None:
					return self._get_none(), code, headers

				return marshal(data, self.fields, self.envelope), code, headers
			else:
				if resp is None:
					return self._get_none()

				return marshal(resp, self.fields, self.envelope)
Example #23
0
        def wrapper(*args, **kwargs):
            objects = f(*args, **kwargs)
            if isinstance(objects, tuple):
                data, code, header = unpack(objects)
            else:
                data = objects

            if self.resource.region:
                # Add notes and exceptions
                data.update(self.get_links(data))
            if isinstance(objects, tuple):
                return data, code, header
            else:
                return data
Example #24
0
    def access(self, resource, method, *args, **kwargs):
        if self.channel_manager.node_online() is False:
            return "Ethereum node is not responding", 502
        if self.channel_manager.get_eth_balance() < config.PROXY_BALANCE_LIMIT:
            return "Channel manager ETH balance is below limit", 502
        try:
            data = RequestData(request.headers, request.cookies)
        except ValueError as e:
            return str(e), 409
        accepts_html = (
            'text/html' in request.accept_mimetypes and
            request.accept_mimetypes.best != '*/*'
        )
        headers = {}

        price = resource.price()

        # payment required
        if price > 0:
            paywall, headers = self.paywall_check(price, data)
            if paywall and accepts_html is True:
                reply_data = resource.get_paywall(request.path)
                return self.reply_webui(reply_data, headers)
            elif paywall:
                return make_response('', 402, headers)

        # all ok, return actual content
        resp = method(request.path, *args, **kwargs)

        # merge headers, resource headers take precedence
        headers_lower = {key.lower(): value for key, value in headers.items()}
        lower_to_case = {key.lower(): key for key in headers}

        if isinstance(resp, Response):
            resource_headers = (key for key, value in resp.headers)
        else:
            data, code, resource_headers = unpack(resp)

        for key in resource_headers:
            key_lower = key.lower()
            if key_lower in headers_lower:
                headers.pop(lower_to_case[key_lower])

        if isinstance(resp, Response):
            resp.headers.extend(headers)
            return resp
        else:
            headers.update(resource_headers)
            return make_response(str(data), code, resource_headers)
    def access(self, resource, method, *args, **kwargs):
        if self.channel_manager.node_online() is False:
            return "Ethereum node is not responding", 502
        if self.channel_manager.get_eth_balance() < constants.PROXY_BALANCE_LIMIT:
            return "Channel manager ETH balance is below limit", 502
        try:
            data = RequestData(request.headers, request.cookies)
        except ValueError as e:
            return str(e), 409
        accepts_html = (
            'text/html' in request.accept_mimetypes and
            request.accept_mimetypes.best != '*/*'
        )
        headers = {}

        price = resource.price()

        # payment required
        if price > 0:
            paywall, headers = self.paywall_check(price, data)
            if paywall and accepts_html is True:
                reply_data = resource.get_paywall(request.path)
                return self.reply_webui(reply_data, headers)
            elif paywall:
                return make_response('', 402, headers)

        # all ok, return actual content
        resp = method(request.path, *args, **kwargs)

        # merge headers, resource headers take precedence
        headers_lower = {key.lower(): value for key, value in headers.items()}
        lower_to_case = {key.lower(): key for key in headers}

        if isinstance(resp, Response):
            resource_headers = (key for key, value in resp.headers)
        else:
            data, code, resource_headers = unpack(resp)

        for key in resource_headers:
            key_lower = key.lower()
            if key_lower in headers_lower:
                headers.pop(lower_to_case[key_lower])

        if isinstance(resp, Response):
            resp.headers.extend(headers)
            return resp
        else:
            headers.update(resource_headers)
            return make_response(str(data), code, resource_headers)
Example #26
0
 def wrapper(*args, **kwargs):
     response = f(*args, **kwargs)
     if isinstance(response, tuple):
         data, code, header = unpack(response)
         if code != 200:
             return data, code, header
     else:
         data = response
     if (isinstance(data, dict) or isinstance(data, OrderedDict)) and "links" in data:
         for link in data['links']:
             link['href'] = link['href'].replace("%7B", "{").replace("%7D", "}").replace("%3B", ";")
     if isinstance(response, tuple):
         return data, code, header
     else:
         return data
Example #27
0
        def wrapper(*args, **kwargs):
            resp = f(*args, **kwargs)
            if (self.fields):
                if isinstance(resp, tuple):
                    data, code, headers = unpack(resp)
                    marshal_data = marshal(data, self.fields,
                                           self.envelope), code, headers
                else:
                    marshal_data = marshal(resp, self.fields, self.envelope)
            else:
                marshal_data = resp

            return {
                'success': True,
                'data': marshal_data,
            }
Example #28
0
    def wrapper(*args, **kwargs):
        resp = view(*args, **kwargs)

        if isinstance(resp, current_app.response_class):
            return resp

        endpoint = request.endpoint.partition('.')[-1]
        method = request.method
        if method == 'HEAD':
            method = 'GET'
        try:
            resp_filter = filters[(endpoint, method)]
        except KeyError:
            LOG.error(
                '"(%(endpoint)s, %(method)s)" is not defined in the response '
                'filters.', {
                    "endpoint": endpoint,
                    "method": method
                })
            abort(500)

        headers = None
        status = None
        if isinstance(resp, tuple):
            resp, status, headers = unpack(resp)

        try:
            schemas = resp_filter[status]
        except KeyError:
            LOG.error(
                'The status code %(status)d is not defined in the response '
                'filter "(%(endpoint)s, %(method)s)".', {
                    "status": status,
                    "endpoint": endpoint,
                    "method": method
                })
            abort(500)

        resp, errors = normalize(schemas['schema'], resp)
        if schemas['headers']:
            headers, header_errors = normalize(
                {'properties': schemas['headers']}, headers)
            errors.extend(header_errors)
        if errors:
            abort(500, message='Expectation Failed', errors=errors)

        return resp, status, headers
Example #29
0
    def wrapper(*args, **kwargs):
        resp = view(*args, **kwargs)

        if isinstance(resp, current_app.response_class):
            return resp

        endpoint = request.endpoint.partition(".")[-1]
        method = request.method
        if method == "HEAD":
            method = "GET"
        filter = filters.get((endpoint, method), None)
        if not filter:
            return resp

        headers = None
        status = None
        if isinstance(resp, tuple):
            resp, status, headers = unpack(resp)

        if len(filter) == 1:
            if six.PY3:
                status = list(filter.keys())[0]
            else:
                status = filter.keys()[0]

        schemas = filter.get(status)
        if not schemas:
            # return resp, status, headers
            abort(500, message="`%d` is not a defined status code." % status)

        resp, errors = normalize(schemas["schema"], resp, resolver=resolver)
        if schemas["headers"]:
            headers, header_errors = normalize(
                {"properties": schemas["headers"]}, headers, resolver=resolver)
            errors.extend(header_errors)
        if errors:
            abort(500, message="Expectation Failed", errors=errors)

        return current_app.response_class(
            json.dumps(resp, cls=JSONEncoder) + "\n",
            status=status,
            headers=headers,
            mimetype="application/json",
        )
    def wrapper(*args, **kwargs):
        resp = view(*args, **kwargs)

        if isinstance(resp, current_app.response_class):
            return resp

        endpoint = request.endpoint.partition('.')[-1]
        method = request.method
        if method == 'HEAD':
            method = 'GET'
        filter = filters.get((endpoint, method), None)
        if not filter:
            return resp

        headers = None
        status = None
        if isinstance(resp, tuple):
            resp, status, headers = unpack(resp)

        if len(filter) == 1:
            if six.PY3:
                status = list(filter.keys())[0]
            else:
                status = filter.keys()[0]

        schemas = filter.get(status)
        if not schemas:
            # return resp, status, headers
            abort(500, message='`%d` is not a defined status code.' % status)

        resp, errors = normalize(schemas['schema'], resp, resolver=resolver)
        if schemas['headers']:
            headers, header_errors = normalize(
                {'properties': schemas['headers']}, headers, resolver=resolver)
            errors.extend(header_errors)
        if errors:
            abort(500, message='Expectation Failed', errors=errors)

        return current_app.response_class(
            json.dumps(resp, cls=JSONEncoder) + '\n',
            status=status,
            headers=headers,
            mimetype='application/json'
        )
Example #31
0
    def wrapper(*args, **kwargs):
        resp = view(*args, **kwargs)

        if isinstance(resp, current_app.response_class):
            return resp

        endpoint = request.endpoint.partition('.')[-1]
        method = request.method
        if method == 'HEAD':
            method = 'GET'
        filter = filters.get((endpoint, method), None)
        if not filter:
            return resp

        headers = None
        status = None
        if isinstance(resp, tuple):
            resp, status, headers = unpack(resp)

        if len(filter) == 1:
            if six.PY3:
                status = list(filter.keys())[0]
            else:
                status = filter.keys()[0]

        schemas = filter.get(status)
        if not schemas:
            # return resp, status, headers
            abort(500, message='`%d` is not a defined status code.' % status)

        resp, errors = normalize(schemas['schema'], resp)
        if schemas['headers']:
            headers, header_errors = normalize(
                {'properties': schemas['headers']}, headers)
            errors.extend(header_errors)
        if errors:
            abort(500, message='Expectation Failed', errors=errors)

        return current_app.response_class(json.dumps(resp, cls=JSONEncoder) +
                                          '\n',
                                          status=status,
                                          headers=headers,
                                          mimetype='application/json')
Example #32
0
        def wrapper(*args, **kwargs):
            objects = f(*args, **kwargs)
            if objects[1] != 200:
                return objects
            if isinstance(objects, tuple):
                data, code, header = unpack(objects)
            else:
                data = objects
            self.get_objets(data)
            data = self.prepare_objetcs(objects, True)
            kwargs = self.prepare_kwargs(kwargs, data)

            if 'region' not in kwargs and 'lon' not in kwargs:
                # we don't know how to put links on this object, there is no coverage, we don't add links
                return objects

            uri_id = None
            if "id" in kwargs and "collection" in kwargs and kwargs[
                    "collection"] in data:
                uri_id = kwargs["id"]
            for obj in self.data:
                kwargs["collection"] = resource_type_to_collection.get(
                    obj, obj)
                if kwargs["collection"] in collections_to_resource_type:
                    if not uri_id:
                        kwargs["id"] = "{" + obj + ".id}"

                    endpoint = "v1." + kwargs["collection"] + ".id"
                    collection = kwargs["collection"]
                    to_pass = {
                        k: v
                        for k, v in kwargs.items() if k != "collection"
                    }
                    to_pass["_type"] = obj
                    to_pass["templated"] = True
                    to_pass["rel"] = collection
                    data["links"].append(
                        create_external_link(url=endpoint, **to_pass))
            if isinstance(objects, tuple):
                return data, code, header
            else:
                return data
Example #33
0
    def dispatch_request(self, *args, **kwargs):
        """Overridden to support list and create method names, and improved
        decorator handling for methods
        """
        method = self._get_method_for_request()

        resp = method(*args, **kwargs)
        if isinstance(resp, Response):
            return resp

        representations = self.representations or OrderedDict()
        mediatype = request.accept_mimetypes.best_match(representations,
                                                        default=None)
        if mediatype in representations:
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp

        return resp
Example #34
0
 def wrapper(*args, **kwargs):
     objects = f(*args, **kwargs)
     if objects[1] != 200:
         return objects
     if isinstance(objects, tuple):
         data, code, header = unpack(objects)
     else:
         data = objects
     if isinstance(data, dict) or isinstance(data, OrderedDict):
         data = self.prepare_objetcs(objects, True)
         kwargs = self.prepare_kwargs(kwargs, data)
         kwargs["templated"] = True
         for collection in self.collections:
             kwargs["rel"] = collection
             data["links"].append(
                 create_external_link("v1.{c}.collection".format(c=collection), **kwargs)
             )
     if isinstance(objects, tuple):
         return data, code, header
     else:
         return data
        def wrapper(*args, **kwargs):
            if hasattr(request, '__skip_marshalling'):
                return f(*args, **kwargs)

            fields_to_include = self._get_fields_to_include()
            if self._is_include_parameter_in_request():
                # only pushing "_include" into kwargs when the request
                # contained this parameter, to keep things cleaner (identical
                # behavior for passing "_include" which contains all fields)
                kwargs['_include'] = fields_to_include.keys()

            response = f(*args, **kwargs)

            def wrap_list_items(response):
                wrapped_items = self.wrap_with_response_object(response.items)
                response.items = marshal(wrapped_items, fields_to_include)
                return response

            if isinstance(response, ListResponse):
                return marshal(wrap_list_items(response),
                               ListResponse.resource_fields)
            # SQLAlchemy returns a class that subtypes tuple, but acts
            # differently (it's taken care of in `wrap_with_response_object`)
            if isinstance(response, tuple) and \
                    not isinstance(response, sql_alchemy_collection):
                data, code, headers = unpack(response)
                if isinstance(data, ListResponse):
                    data = wrap_list_items(data)
                    return (marshal(data, ListResponse.resource_fields),
                            code,
                            headers)
                else:
                    data = self.wrap_with_response_object(data)
                    return marshal(data, fields_to_include), code, headers
            else:
                response = self.wrap_with_response_object(response)
                return marshal(response, fields_to_include)
Example #36
0
    def dispatch_request(self, *args, **kwargs):
        # Taken from flask

        meth = getattr(self, request.method.lower(), None)
        if meth is None and request.method == 'HEAD':
            meth = getattr(self, 'get', None)
        assert meth is not None, 'Unimplemented method %r' % request.method

        for decorator in self.method_decorators:
            meth = decorator(meth)

        try:
            increment(total_requests)
        except Exception as exc:
            pass

        # this is where actual method starts

        resp = meth(*args, **kwargs)

        # this is where actual method ends

        if isinstance(resp, ResponseBase):  # There may be a better way to test
            return resp

        representations = self.representations or OrderedDict()

        mediatype = request.accept_mimetypes.best_match(representations,
                                                        default=None)
        if mediatype in representations:
            data, code, headers = unpack(resp)
            resp = representations[mediatype](data, code, headers)
            resp.headers['Content-Type'] = mediatype
            return resp

        return resp
Example #37
0
def test_unpack():
    yield check_unpack, ("hey", 200, {}), unpack("hey")
    yield check_unpack, (("hey",), 200, {}), unpack(("hey",))
    yield check_unpack, ("hey", 201, {}), unpack(("hey", 201))
    yield check_unpack, ("hey", 201, "foo"), unpack(("hey", 201, "foo"))
    yield check_unpack, (["hey", 201], 200, {}), unpack(["hey", 201])
Example #38
0
 def wrapper(*args, **kwargs):
     resp = original_fun(*args, **kwargs)
     if isinstance(resp, Response):  # There may be a better way to test
         return resp
     data, code, headers = unpack(resp)
     return flask_restful.make_response(data, code, headers=headers)
Example #39
0
 def wrapper(*args, **kwargs):
     resp = resource(*args, **kwargs)
     if isinstance(resp, ResponseBase):  # There may be a better way to test
         return resp
     data, code, headers = unpack(resp)
     return self.make_response(data, code, headers=headers)
 def _extend_tuple_response_headers(response, extra_headers):
     data, code, headers = unpack(response)
     headers.update(extra_headers)
     return data, code, headers
Example #41
0
 def wrapper(*args, **kwargs):
     response = f(*args, **kwargs)
     if isinstance(response, tuple):
         data, code, header = unpack(response)
     else:
         data = response
     if 'links' not in data:
         return response
     collection = None
     kwargs["_external"] = True
     templated = True
     for key in data:
         if key == 'disruptions' and collection is not None:
             # disruption is a special case since it can be present in all responses
             continue
         if key in collections_to_resource_type:
             collection = key
         if key in resource_type_to_collection:
             collection = resource_type_to_collection[key]
     if collection is None:
         return response
     kwargs["uri"] = collection + '/'
     if "id" in kwargs:
         kwargs["uri"] += kwargs["id"]
         del kwargs["id"]
         templated = False
     else:
         kwargs["uri"] += '{' + collection + ".id}"
     if (collection in [
             'stop_areas', 'stop_points', 'lines', 'routes', 'addresses'
     ] and "region" in kwargs):
         for api in [
                 'route_schedules', 'stop_schedules', 'arrivals',
                 'departures', "places_nearby"
         ]:
             data['links'].append({
                 "href": url_for("v1." + api, **kwargs),
                 "rel": api,
                 "type": api,
                 "templated": templated
             })
     if collection in ['stop_areas', 'stop_points', 'addresses']:
         data['links'].append({
             "href": url_for("v1.journeys", **kwargs),
             "rel": "journeys",
             "type": "journey",
             "templated": templated,
         })
     # for lines we add the link to the calendars
     if 'region' in kwargs:
         if collection == 'lines':
             data['links'].append({
                 "href":
                 url_for("v1.calendars", **kwargs),
                 "rel":
                 "calendars",
                 "type":
                 "calendar",
                 "templated":
                 templated,
             })
         if collection in ['stop_areas', 'lines', 'networks']:
             data['links'].append({
                 "href":
                 url_for("v1.traffic_reports", **kwargs),
                 "rel":
                 "disruptions",
                 "type":
                 "disruption",
                 "templated":
                 templated,
             })
     if isinstance(response, tuple):
         return data, code, header
     else:
         return data
Example #42
0
def test_unpack():
    yield check_unpack, ("hey", 200, {}), unpack("hey")
    yield check_unpack, (("hey", ), 200, {}), unpack(("hey", ))
    yield check_unpack, ("hey", 201, {}), unpack(("hey", 201))
    yield check_unpack, ("hey", 201, "foo"), unpack(("hey", 201, "foo"))
    yield check_unpack, (["hey", 201], 200, {}), unpack(["hey", 201])
Example #43
0
        def wrapped(self, *args, **kwargs):
            (data, code, headers) = unpack(func(self, *args, **kwargs))
            headers["Deprecation"] = "true"

            return (data, code, headers)