drf-routers 0.2

drf-routers
=====================

此包的源代码基于：https://github.com/alanjds/drf-nested-routers

此包提供路由器和字段，用于在[Django Rest Framework](http://django-rest-framework.org/)中创建分组/嵌套资源

嵌套资源对于完整的REST URL结构是必要的，如果一个资源位于另一个资源内部。
分组资源允许您将多个资源分组，以便在单个根API视图中显示。

以下示例是关于域和DNS名称服务器。
有许多域，每个域有许多名称服务器。如果没有域名，"nameserver"资源就不存在，因此您需要将其“嵌套”在域名中。
安装

您可以使用pip安装此库
------------

```pip install drf-routers```

快速入门

所需的URL签名如下
----------

\domain\ <- 域列表
```
\domain\{pk}\ <- 一个域，从{pk}
\domain\{domain_pk}\nameservers\ <- 来自{domain_pk}的域名名称服务器
\domain\{domain_pk}\nameservers\{pk} <- 来自{domain_pk}的特定名称服务器，从{pk}
如何实现（示例）
```

```python
# urls.py
from drf_routers import routers
from views import DomainViewSet, NameserverViewSet
router = routers.SimpleRouter()
(...)

router.register(r'domains', DomainViewSet)
domains_router = routers.NestedRouter(router, r'domains', lookup='domain')

```
domains_router.register(r'nameservers', NameserverViewSet, base_name='domain-nameservers')
‘base_name’是可选的。只有在同一个视图集被多次注册时才需要
关于此选项的官方DRF文档：https://django-rest-framework.django.ac.cn/api-guide/routers/

urlpatterns = patterns('',
url(r'^', include(router.urls)),
url(r'^', include(domains_router.urls)),
)
```
# urls.py
views.py
class NameserverViewSet(viewsets.ViewSet)
def list(self, request, domain_pk=None)
nameservers = self.queryset.filter(domain=domain_pk)
(...)
return Response([...])

def retrieve(self, request, pk=None, domain_pk=None)
nameservers = self.queryset.get(pk=pk, domain=domain_pk)
(...)
return Response(serializer.data)
```

（可选）如果您需要嵌套关系的超链接，您需要一个自定义序列化器。
# urls.py
serializers.py
（仅在您想在API上为嵌套关系添加超链接时需要）
from drf_routers.relations import NestedHyperlinkedRelatedField

class DomainSerializer(HyperlinkedModelSerializer)
class Meta
model = Domain

nameservers = HyperlinkedIdentityField(
view_name='domain-nameservers-list',
lookup_url_kwarg='domain_pk'
)

## OR ##

nameservers = NestedHyperlinkedRelatedField(
many=True,
read_only=True, # 或添加一个查询集
view_name='domain-nameservers-detail'
parent_lookup_url_kwarg='domain_pk'
)
```


嵌套路由器的示例，深度为3级。您可以使用相同的逻辑嵌套路由器，深度满足您的需求。此示例实现了以下URL模式。
```
/clients/
/clients/{pk}/
/clients/{client_pk}/maildrops/
/clients/{client_pk}/maildrops/{maildrop_pk}/
/clients/{client_pk}/maildrops/{maildrop_pk}/recipients/
/clients/{client_pk}/maildrops/{maildrop_pk}/recipients/{pk}/
```

# urls.py
from drf_routers import routers
router = DefaultRouter()
router.register(r'clients', ClientViewSet, base_name='clients')

client_router = routers.NestedRouter(router, r'clients', lookup='client')
client_router.register(r'maildrops', MailDropViewSet, base_name='maildrops')

maildrops_router = routers.NestedRouter(client_router, r'maildrops', lookup='maildrop')
maildrops_router.register(r'recipients', MailRecipientViewSet, base_name='recipients')

urlpatterns = patterns (
'',
url(r'^', include(router.urls)),
url(r'^', include(client_router.urls)),
url(r'^', include(maildrops_router.urls)),
)
```

# urls.py
views.py
class ClientViewSet(viewsets.ViewSet)
serializer_class = ClientSerializer

def list(self, request,)
queryset = Client.objects.filter()
serializer = ClientSerializer(queryset, many=True)
return Response(serializer.data)

def retrieve(self, request, pk=None)
queryset = Client.objects.filter()
client = get_object_or_404(queryset, pk=pk)
serializer = ClientSerializer(client)
return Response(serializer.data)

class MailDropViewSet(viewsets.ViewSet)
serializer_class = MailDropSerializer

def list(self, request, client_pk=None)
queryset = MailDrop.objects.filter(client=client_pk)
serializer = MailDropSerializer(queryset, many=True)
return Response(serializer.data)

def retrieve(self, request, pk=None, client_pk=None)
queryset = MailDrop.objects.filter(pk=pk, client=client_pk)
maildrop = get_object_or_404(queryset, pk=pk)
serializer = MailDropSerializer(maildrop)
return Response(serializer.data)

class MailRecipientViewSet(viewsets.ViewSet)
serializer_class = MailRecipientSerializer

def list(self, request, client_pk=None, maildrop_pk=None)
queryset = MailRecipient.objects.filter(mail_drop__client=client_pk, mail_drop=maildrop_pk)
serializer = MailRecipientSerializer(queryset, many=True)
return Response(serializer.data)

def retrieve(self, request, pk=None, client_pk=None, maildrop_pk=None)
queryset = MailRecipient.objects.filter(pk=pk, mail_drop=maildrop_pk, mail_drop__client=client_pk)
maildrop = get_object_or_404(queryset, pk=pk)
serializer = MailRecipientSerializer(maildrop)
return Response(serializer.data)
```