logo标签列表

在Json Child中显示Django子类别、每个类别的产品。

djangodjango-rest-frameworkdjango-oscar
15

你好，在我的Django oscar项目中，我实现了使用Django oscar查看类别并显示它们的自定义API。现在API的问题是类别的子类别在我的API视图中显示为类别，而我希望它们以数组形式出现，表示它们是子类别。我的类别代码如下：

自定义API序列化类

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
            },]

这意味着只返回该类别下的产品。如果一个类别有一个或多个子级，则应将子级数量作为对象数组返回。
你能给出一个期望的分类 API 输出示例吗？因为这取决于所要求的内容，这是一个非常动态的问题，解决方案将根据需求的级别而有所不同。 - shad0w_wa1k3r
嗨，我已经更新了问题，以显示在选择类别超链接时所需的输出。 - King
您（更新后）期望的输出是一个产品JSON，而不是嵌套的类别（这是最初的要求）。请明确您想要的内容。 - shad0w_wa1k3r
我在我的更新中作为一个声明做了那个。我添加的产品模型是返回产品。 - King
2个回答
6
我建议将类别特定的数据（在详细页面中）与仅有产品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": [
        ]
    },
]
这个代码运行良好，可以返回每个类别和子类别下的产品，但是当单击一个类别链接时如何显示它的子类别呢？我希望能够显示其下的子类别。例如 Nike，Adidas，Puma 是鞋子的子类别。如果我点击url "availability": "http://127.0.0.1:8000/api/caty/1/"，我应该能够看到相应的子类别。 - King
@King 我已更新答案，以显示相应的子类别。 - shad0w_wa1k3r
1

django-oscar使用django-treebeard实现了materialized path，这与您想检索的嵌套层次结构完全相反。

我没有在treebeard中编写序列化器的经验，但我非常确定您需要将Serializer重写为类似以下内容：

# 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

请注意，我没有测试过这些内容，我只是试图指出一条可能让您更接近解决方案的方向。
1
啊，我忘记了get_tree返回从父对象开始的整个嵌套列表 - 你可能会使用.depth等等，但我刚刚看到shad0w_wa1k3r已经更新了他的答案，从第一眼看来，我会说那就是你需要的。 - wiesion
1
我也考虑过使用内置功能，但不幸的是，您仍然需要根据要求进行调整，并且将树形结果进行JSON序列化将是另一个障碍。 - shad0w_wa1k3r
1
我明白了，我知道这可能会有一些问题，我只是想给一个大致的提示去哪里... 我也考虑过对 Category 模型进行更改，使其能够拥有一个父级，在模型的更新/保存中设置它，并仅在序列化器中使用该递归，而不在其他逻辑中使用，但这是一个相当庞大的任务，并且在更新依赖项时容易出错。 - wiesion
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接