Update so that embedded resources provide self link:

{
    "_links": {
        "self": {
            "href": "http://example.org/api/user?page=3"
        },
     ...
    }
    "_embedded": {
        "users": [
            {
                "_links": {
                    "self": {
                        "href": "http://example.org/api/user/mwop"
                    }
                },
                "id": "mwop",
                "name": "Matthew Weier O'Phinney"
            },
            {
                "_links": {
                    "self": {
                        "href": "http://example.org/api/user/mac_nibblet"
                    }
                },
                "id": "mac_nibblet",
                "name": "Antoine Hedgecock"
            },
           ...
        ]
    }
}

Since all adapters should respond with an empty string in the case of a 204 status code, should this logic should be baked in to the base adapter? If so, how?

To meet my immediate need, I've applied the logic to each adapter.

Thanks!

Some managers (AlchemyManager for instance) return an empty dict on delete(). Along with #60, this change facilitates an empty response when deleting a resource.

Stupid ripozo implementations that automatically generate rest endpoints in a single line. These would most likely have to be framework/database dependent.

Possible combos: flask/sqlalchemy, Django.

As @tomdottom pointed out ripozo was missing the _links attribute in embedded resources. These should also include other relationships within the embedded resource.

This should be optional but default to True. This would be a resource that points to all of the other resources. This is helpful in discovery of what is capable in the api. This should be created on a per dispatcher basis.

for example

class MyResource(ResourceBase):
    resource_name = 'myresource'

    @apimethod(route='/extra')
    def my_method(cls, request):
        return cls()

Would be something like

>>> MyResource.my_method(RequestContainer()).url
'/myresource'

When it should be

>>> MyResource.my_method(RequestContainer()).url
'/myresource/extra'

These are useful if you want to restrict what can be updated, created, and or retrieved as those may be different. For example, passwords on a User object should be able to be set but not retrieved.

For example, on a resource like a user, there can be multiple possible unique identifiers (e.g. id, email, username), that all refer to the same resource. Currently you can inherit, change the _pks, and create a new resource endpoint, but this hides the implementation layer. However, it could be hard to implement since I'm not sure how you would actually go about it.

File "/Users/martin/oss/ripozo/ripozo/viewsets/constructor.py", line 30, in __new__
    mcs._register_class(klass)
  File "/Users/martin/oss/ripozo/ripozo/viewsets/constructor.py", line 55, in _register_class
    method.cls = klass
AttributeError: 'instancemethod' object has no attribute 'cls'

Came from a third level inherited class

from ripozo.utilities import pick_processor
from ripozo.viewsets.restmixins import RetrieveUpdate

class UserResource(RetrieveUpdate):
    _pks = ['username']
    _preprocessors = [picky_processor(login_required, exclude=['login_user']),
                      picky_processor(admin_required, include=['update'])]
    _resource_name = 'user'
    _manager = UserManager

class UserIdResource(UserResource):
    _pks = ['id']
    _resource_name = 'user_id'

This would mean that dispatchers would simply have to construct the Request object and pass it to the apimethods instead of the mess it is now. More or less it would just be an intermediate step.

I'm implementing a RESTful server that reponses in the portuguese language and with the ensure_ascii=True the 'ã' looks like '\u00e3' in the json responses.

Is there any problem what will cause make this change (ensure_ascii=False)? Or is there any way to implement an option to JSONAPIAdapter call json.dumps with the argument ensure_ascii=False?

I think that decode the json to utf8 is not job for the client application.

Maybe can I use the postprocessors in some way?

problem
ripozo will automatically append slash in the end of the URL where append_slash is true or not.

Fix problem
Modify ripozo/utilities:join_url_parts()

if part is  '':
    continue

Currently, the manager interface more or less assumes that it can operate completely independently of the request object and doesn't pass it in. You can see this in code like:

class Create(ResourceBase):
    """
    A base class to extend that allows for
    adding the create ability to your resource.
    """
    __abstract__ = True

    @apimethod(methods=['POST'], no_pks=True)
    @manager_translate(validate=True, fields_attr='create_fields')
    def create(cls, request):
        """
        Creates a new resource using the cls.manager.create
        method.  Returns the resource that was just created
        as an instance of the class that created it.
        :param RequestContainer request: The request in the standardized
            ripozo style.
        :return: An instance of the class
            that was called.
        :rtype: Update
        """
        _logger.debug('Creating a resource using manager %s', cls.manager)
        props = cls.manager.create(request.body_args)
        meta = dict(links=dict(created=props))
        return cls(properties=props, meta=meta, status_code=201)

This forces managers that need to access something off of the request (such as, the database transaction associated with this current request) to use something like thread local storage to smuggle the currently active transaction into the manager. Global state and indirect passing is a bit of an anti pattern and I generally prefer to pass things like that explicitly into the methods.

The resources themselves generally support this just fine since each of those methods accepts a request object, but the same isn't the true for managers (and by extension, any of the code that calls a manager, like the CRUD mixins).

If instead a function was called with the request object to get these, that would make it possible to do this cleanly. For example:

class ResourceBase:

    @classmethod
    def get_manager(cls, request):
        return self.manager

class Create(ResourceBase):

    __abstract__ = True

    @apimethod(methods=['POST'], no_pks=True)
    @manager_translate(validate=True, fields_attr='create_fields')
    def create(cls, request):
        """
        Creates a new resource using the cls.manager.create
        method.  Returns the resource that was just created
        as an instance of the class that created it.
        :param RequestContainer request: The request in the standardized
            ripozo style.
        :return: An instance of the class
            that was called.
        :rtype: Update
        """
        _logger.debug('Creating a resource using manager %s', cls.manager)
        props = cls.get_manager(request).create(request.body_args)
        meta = dict(links=dict(created=props))
        return cls(properties=props, meta=meta, status_code=201)

This would mean that by default, folks who assigned their manager to Resource.manager will have everything still work, but folks like me who want to have explicit request bound sessions can then do something like:

from ripozo_sqlalchemy import AlchemyManager, SessionHandler


class PersonManager(AlchemyManager):
    model = Person
    fields = ('id', 'first_name', 'last_name')


class RequestBoundManager:
    @classmethod
    def get_manager(cls, request):
        return PersonManager(SessionHandler(request.db)

And then things should just work, without needing to use thread locals to smuggle that information in.

When I do the following query (count is not necessary to reproduce):

GET /courses/?day=5&count=1

Actual result:

{
    "_embedded": {},
    "_links": {
        "courses": [
            {
                "href": "/courses/276"
            }
        ],
        "next": {
            "href": "/courses?page=2&count=1"      <----HERE
        },
        "self": {
            "href": "http://127.0.0.1:5000/courses?day=5"
        }
    },
    "count": [
        "1"
    ],
    "day": 5
}

Expected result:

{
    "_embedded": {},
    "_links": {
        "courses": [
            {
                "href": "/courses/276"
            }
        ],
        "next": {
            "href": "/courses?day=5&page=2&count=1"      <----HERE
        },
        "self": {
            "href": "http://127.0.0.1:5000/courses?day=5"
        }
    },
    "count": [
        "1"
    ],
    "day": 5
}

I try to create an API which inherited from ResourceBase, The problem is i can't set every record as jsonApi, I expected,

{
  "data": [
    {
      "type": "trademarks",
      "id": "1",
      "attributes": {
        "expediente": "1717801",
        "fecha_de_presentacion": "01/02/2016 12:00:00 AM",
        "figura_juridica": "REGISTRO DE MARCA",
        "logotipo": null,
        "signo": "IGUY",
        "tipo": "NOMINATIVA",
        "titular": "SAMSONITE IP HOLDINGS S.\u00c0.R.L."
      }
    },
    .
    . rest of the data
    .
    ]
}

Got

{
    "data": {
        "attributes": {
            "trademarks": [
                {
                    "fecha_de_presentacion": "01/02/2016 12:00:00 AM",
                    "figura_juridica": "REGISTRO DE MARCA",
                    "id": 1,
                    "signo": "IGUY",
                    "logotipo": null,
                    "tipo": "NOMINATIVA",
                    "titular": "SAMSONITE IP HOLDINGS S.À.R.L.",
                    "expediente": "1717801"
                },
    .
    . rest of the data
    .
    ]
}

# python implementation using ripozo
class Trademarks(restmixins.ResourceBase):
    """
    Trademarks Class provide a resource for search Using a TSVector
    to create a search box
    """
    @apimethod(methods=['GET'])
    def search_trademark(cls, request):
        print(request.query_args)
        props = {'pks': ('id',)}
        if 'search' in request.query_args:
            search = request.query_args.pop('search')[0]
            result = TrademarkMarcanet.query.search(search).all()
        else:
            result = TrademarkMarcanet.query.all()
        response = [r.serialize() for r in result]
        props.update(dict(trademarks=make_json_safe(response)))
        return cls(properties=props, status_code=200)

exists another way to do this task using ripozo api?