Serializing django-mptt trees in Tastypie

Question

How do I serialize django-mptt trees in Tastypie?

I want to use django-mptt's cache_tree_children(). I've tried applying in different Tastypie hooks, but it throws an error.

Answer 1

Without the cache_tree_children method you could probably have your children serialized by simply hooking up a ToManyField with full=True pointing at the children property:

class MenuResource(ModelResource):

    children = fields.ToManyField('self', 'children', null=True, full=True)
    parent = fields.ToOneField('self', 'parent', null=True)

    class Meta:
        queryset = Menu.objects.all()

To implement the cache_tree_children function you could write your own ToManyField subclass that overrides the standard dehydrate function. Please note, that I only tested this solution very superficially:

def dehydrate(self, bundle):
    if not bundle.obj or not bundle.obj.pk:
    if not self.null:
        raise ApiFieldError("The model '%r' does not have a primary key and can not be used in a ToMany context." % bundle.obj)

        return []

    the_m2ms = None
    previous_obj = bundle.obj
    attr = self.attribute

    if isinstance(self.attribute, basestring):
        attrs = self.attribute.split('__')
        the_m2ms = bundle.obj

        for attr in attrs:
            previous_obj = the_m2ms
            try:
                the_m2ms = getattr(the_m2ms, attr, None)
            except ObjectDoesNotExist:
                the_m2ms = None

            if not the_m2ms:
                break

    elif callable(self.attribute):
        the_m2ms = self.attribute(bundle)

    if not the_m2ms:
        if not self.null:
            raise ApiFieldError("The model '%r' has an empty attribute '%s' and doesn't allow a null value." % (previous_obj, attr))

        return []

    self.m2m_resources = []
    m2m_dehydrated = []

    # There goes your ``cache_tree_children``
    for m2m in cache_tree_children(the_m2ms.all()):
        m2m_resource = self.get_related_resource(m2m)
        m2m_bundle = Bundle(obj=m2m, request=bundle.request)
        self.m2m_resources.append(m2m_resource)
        m2m_dehydrated.append(self.dehydrate_related(m2m_bundle, m2m_resource))

    return m2m_dehydrated

One of the main advantages of this method is that you don't have to care about detail / list view constraints / differences no more. You even can parameterize this aspect of your resource further down until you got some kind of default behavior that fits your needs. Field-based, that is. Which I think is cool.

Answer 2

This is how I solved it:

class MenuResource(ModelResource):
    parent = fields.ForeignKey('self', 'parent', null=True)

    class Meta:
        serializer = PrettyJSONSerializer()
        queryset = Menu.objects.all().select_related('parent')
        include_resource_uri = False
        fields = ['name']

    def get_child_data(self, obj):
        data =  {
            'id': obj.id,
            'name': obj.name,
        }
        if not obj.is_leaf_node():
            data['children'] = [self.get_child_data(child) \
                                for child in obj.get_children()]
        return data

    def get_list(self, request, **kwargs):

        base_bundle = self.build_bundle(request=request)
        objects = self.obj_get_list(bundle=base_bundle, 
                                    **self.remove_api_resource_names(kwargs))
        sorted_objects = self.apply_sorting(objects, options=request.GET)

        paginator = self._meta.paginator_class(
            request.GET, sorted_objects, 
            resource_uri=self.get_resource_uri(), limit=self._meta.limit, 
            max_limit=self._meta.max_limit, 
            collection_name=self._meta.collection_name
        )
        to_be_serialized = paginator.page()

        from mptt.templatetags.mptt_tags import cache_tree_children
        objects = cache_tree_children(objects)

        bundles = []

        for obj in objects:
            data = self.get_child_data(obj)
            bundle = self.build_bundle(data=data, obj=obj, request=request)
            bundles.append(self.full_dehydrate(bundle))

        to_be_serialized[self._meta.collection_name] = bundles
        to_be_serialized = self.alter_list_data_to_serialize(request, 
                                                            to_be_serialized)
        return self.create_response(request, to_be_serialized)

If you're not using pagination you can just take that part out. That's what I did.