嗨，我的Django oscar项目实现了Django oscar。我能够实现我的自定义API，我用它来查看类别并显示它们。现在API的问题是类别的子类别在我的API视图中显示为类别，我希望它们在一个数组中，表明它们是子类别。我的类别代码如下
customapi序列化程序类
class CategorySerializer(serializers.ModelSerializer):
class Meta:
model = Category
fields = ('id', 'numchild', 'name', 'description', 'image', 'slug')
视图
class CategoryList(generics.ListAPIView):
queryset = Category.objects.all()
serializer_class = CategorySerializer
class CategoryDetail(generics.RetrieveAPIView):
queryset = Category.objects.all()
serializer_class = CategorySerializer
customapi / urls.py
url(r'^caty/$', CategoryList.as_view(), name='category-list'),
url(r'^caty/(?P<category_slug>[\w-]+(/[\w-]+)*)_(?P<pk>\d+)/$',
CategoryDetail.as_view(), name='category'),
的Json
[
{
"id": 2,
"path": "0001",
"depth": 1,
"numchild": 4,
"name": "Clothes",
"description": "<p>Beautiful Clothes</p>",
"image": null,
"slug": "clothes"
},
{
"id": 8,
"path": "00010001",
"depth": 2,
"numchild": 0,
"name": "c",
"description": "",
"image": null,
"slug": "c"
},
{
"id": 7,
"path": "00010002",
"depth": 2,
"numchild": 0,
"name": "b",
"description": "",
"image": null,
"slug": "b"
},
{
"id": 6,
"path": "00010003",
"depth": 2,
"numchild": 0,
"name": "a",
"description": "",
"image": null,
"slug": "a"
},
{
"id": 5,
"path": "00010004",
"depth": 2,
"numchild": 0,
"name": "MsWears",
"description": "",
"image": null,
"slug": "mswears"
},]
注意第一个的numchild是4，表示它是父类别，其余是子类别。
子类别从Django-oscar模型中呈现如下
class AbstractCategory(MP_Node):
"""
A product category. Merely used for navigational purposes; has no effects on business logic.
Uses Django-treebeard.
"""
name = models.CharField(_('Name'), max_length=255, db_index=True)
description = models.TextField(_('Description'), blank=True)
image = models.ImageField(_('Image'), upload_to='categories', blank=True,
null=True, max_length=255)
slug = SlugField(_('Slug'), max_length=255, db_index=True)
_slug_separator = '/'
_full_name_separator = ' > '
def __str__(self):
return self.full_name
@property
def full_name(self):
"""
Returns a string representation of the category and it's ancestors,
e.g. 'Books > Non-fiction > Essential programming'.
It's rarely used in Oscar's codebase, but used to be stored as a
CharField and is hence kept for backward compatibility. It's also sufficiently useful to keep around.
"""
names = [category.name for category in self.get_ancestors_and_self()]
return self._full_name_separator.join(names)
@property
def full_slug(self):
"""
Returns a string of this category's slug concatenated with the slugs
of it's ancestors, e.g. 'books/non-fiction/essential-programming'.
Oscar used to store this as in the 'slug' model field, but this field
has been re-purposed to only store this category's slug and to not
include it's ancestors' slugs.
"""
slugs = [category.slug for category in self.get_ancestors_and_self()]
return self._slug_separator.join(slugs)
def generate_slug(self):
"""
Generates a slug for a category. This makes no attempt at generating a unique slug.
"""
return slugify(self.name)
def ensure_slug_uniqueness(self):
"""
Ensures that the category's slug is unique amongst its siblings.
This is inefficient and probably not thread-safe.
"""
unique_slug = self.slug
siblings = self.get_siblings().exclude(pk=self.pk)
next_num = 2
while siblings.filter(slug=unique_slug).exists():
unique_slug = '{slug}_{end}'.format(slug=self.slug, end=next_num)
next_num += 1
if unique_slug != self.slug:
self.slug = unique_slug
self.save()
def save(self, *args, **kwargs):
"""
Oscar traditionally auto-generated slugs from names. As that is often convenient, we still do so if a slug is not supplied through other means. If you want to control slug creation, just create instances with a slug already set, or expose a field on the appropriate forms.
"""
if self.slug:
# Slug was supplied. Hands off!
super(AbstractCategory, self).save(*args, **kwargs)
else:
self.slug = self.generate_slug()
super(AbstractCategory, self).save(*args, **kwargs)
# We auto-generated a slug, so we need to make sure that it's
# unique. As we need to be able to inspect the category's siblings
# for that, we need to wait until the instance is saved. We
# update the slug and save again if necessary.
self.ensure_slug_uniqueness()
def get_ancestors_and_self(self):
"""
Gets ancestors and includes itself. Use treebeard's get_ancestors
if you don't want to include the category itself. It's a separate function as it's commonly used in templates.
"""
return list(self.get_ancestors()) + [self]
def get_descendants_and_self(self):
"""
Gets descendants and includes itself. Use treebeard's get_descendants
if you don't want to include the category itself. It's a separate function as it's commonly used in templates.
"""
return list(self.get_descendants()) + [self]
def get_absolute_url(self):
"""
Our URL scheme means we have to look up the category's ancestors. As that is a bit more expensive, we cache the generated URL. That is
safe even for a stale cache, as the default implementation of
ProductCategoryView does the lookup via primary key anyway. But if you change that logic, you'll have to reconsider the caching approach.
"""
current_locale = get_language()
cache_key = 'CATEGORY_URL_%s_%s' % (current_locale, self.pk)
url = cache.get(cache_key)
if not url:
url = reverse(
'catalogue:category',
kwargs={'category_slug': self.full_slug, 'pk': self.pk})
cache.set(cache_key, url)
return url
class Meta:
abstract = True
app_label = 'catalogue'
ordering = ['path']
verbose_name = _('Category')
verbose_name_plural = _('Categories')
def has_children(self):
return self.get_num_children() > 0
def get_num_children(self):
return self.get_children().count()
当选择一个类别时，相应的JSON看起来像这样
{
"url": "http://127.0.0.1:8000/nativapi/products/16/",
"id": 16,
"title": "Deall",
"images": [],
"price": {
"currency": "NGN",
"excl_tax": "1000.00",
"incl_tax": "1000.00",
"tax": "0.00"
},
"availability": "http://127.0.0.1:8000/nativapi/products/16/availability/"
},
{
"url": "http://127.0.0.1:8000/nativapi/products/13/",
"id": 13,
"title": "ada",
"images": [
{
"id": 8,
"original": "http://127.0.0.1:8000/media/images/products/2018/05/f3.jpg",
"caption": "",
"display_order": 0,
"date_created": "2018-05-26T17:24:34.762848Z",
"product": 13
},]
这意味着只返回该类别下的产品。如果一个类别如果是子类，则该子类的编号应作为对象数组返回。
答案 0 :(得分：2)
我建议将类别特定数据分开（详细信息页面）并仅保留产品API。
要获得特定类别的产品，您可以执行类似的操作 -
<强> views.py
from django.shortcuts import get_object_or_404
from oscar.core.loading import get_model
from rest_framework import generics
from oscarapi.serializers import ProductsSerializer
Category = get_model('catalogue', 'Category')
Product = get_model('catalogue', 'Product')
class CategoryProductsView(generics.ListAPIView):
serializer_class = ProductsSerializer
def get_queryset(self):
cat_id = self.kwargs.get('pk', None)
if cat_id is not None:
category = get_object_or_404(Category, id=cat_id)
return Product.objects.filter(
categories__path__startswith=category.path).all()
else:
return Product.objects.none()
<强> urls.py
from views import CategoryProductsView
urlpatterns = [
...
url(r'^caty/(?P<pk>[0-9]+)/products/$', CategoryProducts.as_view(), name='category-products'),
...
]
由于我们使用categories__path__startswith，我们会获得该类别下的所有产品，包括给定类别的子类别下的产品，等等。
<强>更新
对于您想要列出的子类别，您只需添加SerializerMethodField()即可。我建议为子类别获取一个id列表，以便根据它的id（从现有类别列表中简单查找）进一步获取该子类别的详细信息
<强> serializers.py
from oscarapi.utils import OscarModelSerializer
from rest_framework import serializers
class CategorySerializer(OscarModelSerializer):
subcategories = serializers.SerializerMethodField()
class Meta:
model = Category
fields = ('id', 'numchild', 'name', 'description', 'image', 'slug',
'path', 'depth', 'subcategories')
def get_subcategories(self, obj):
return Category.objects.filter(path__startswith=obj.path,
depth=obj.depth+1
).values_list('id', flat=True)
示例输出
"results": [
{
"id": 1,
"numchild": 1,
"name": "Cat1",
"description": "",
"image": "http://localhost:8001/media/categories/images/categories/cat1.jpg",
"slug": "cat1",
"path": "0001",
"depth": 1,
"subcategories": [
2
]
},
{
"id": 2,
"numchild": 0,
"name": "SubCat1",
"description": "",
"image": null,
"slug": "subcat1",
"path": "00010001",
"depth": 2,
"subcategories": [
]
},
]
答案 1 :(得分：1)
django-oscar使用django-treebeard进行materialized path实施，几乎与您要检索的嵌套层次结构相反。
我没有使用treebeard编写序列化程序的经验，但我很确定你需要将序列化程序重写为
# Get all categories from /caty
class CategorySerializer(serializers.ModelSerializer):
children = serializers.SerializerMethodField('get_children')
def get_children(self, obj):
if obj.numchild == 0:
return None
# Use treebeards built-in tree generation
[CategorySerializer(child) for child in Category.get_tree(obj)]
class Meta:
model = Category
请注意，我没有对此进行过任何测试，我只是想指出一个可能让您更接近解决方案的方向。