Wagtail API嵌套关系处理：关联案例字段扩展需求

Alright, let's tackle this! You've got a Wagtail StreamField (related_cases) where each related_case_block stores a reference to another Case Page—right now your API returns just the case ID, but you want to replace that with a nested object containing specific fields like id, title, and more. Here are two straightforward approaches to make this happen:

Approach 1: Customize the Block's API Representation #

The cleanest way is to add a get_api_representation method directly to your RelatedCaseBlock definition. This lets you control exactly how the block's data is formatted when sent to the API.

First, here's what your block might look like (adjust the page type to match your actual Case Page model):

from wagtail.core import blocks
from wagtail.core.models import Page

class RelatedCaseBlock(blocks.StructBlock):
    case = blocks.PageChooserBlock(page_type="myapp.CasePage")
    short_text = blocks.CharBlock()

    class Meta:
        template = "blocks/related_case_block.html"

    # Add this method to customize API output
    def get_api_representation(self, value, context=None):
        # Start with the default block representation (includes short_text)
        representation = super().get_api_representation(value, context=context)
        
        # If a case is linked, replace the ID with a nested object of desired fields
        if case_page := value.get("case"):
            representation["case"] = {
                "id": case_page.id,
                "title": case_page.title,
                "url": case_page.url,
                # Add any other custom fields from your CasePage here, e.g.:
                # "published_date": case_page.published_date.isoformat()
            }
        
        return representation

With this change, your API response will automatically include the nested case object instead of just the ID for each block in related_cases.

Approach 2: Override the Page API Serializer #

If you need more control at the page level (or if you're using a custom API serializer), you can use a SerializerMethodField to manually process the related_cases field.

First, define a custom serializer for your page model:

from wagtail.api.v2.serializers import PageSerializer
from rest_framework import serializers
from .models import YourParentPageModel  # Replace with your actual page model

class CustomParentPageSerializer(PageSerializer):
    # Use SerializerMethodField to handle related_cases
    related_cases = serializers.SerializerMethodField()

    def get_related_cases(self, obj):
        processed_blocks = []
        for block in obj.related_cases:
            # Get the default block data
            block_data = block.get_api_representation(context=self.context)
            
            # If it's a related_case_block, enhance the case field
            if block.block_type == "related_case_block":
                if case_page := block.value.get("case"):
                    # Reuse Wagtail's PageSerializer for consistent formatting (optional)
                    case_serializer = PageSerializer(case_page, context=self.context)
                    block_data["case"] = case_serializer.data
                    # Or manually define fields like in Approach 1 if you don't need all PageSerializer fields
            
            processed_blocks.append(block_data)
        return processed_blocks

Then, update your API viewset to use this serializer:

from wagtail.api.v2.views import PagesAPIViewSet
from .models import YourParentPageModel
from .serializers import CustomParentPageSerializer

class CustomParentPageAPIViewSet(PagesAPIViewSet):
    serializer_class = CustomParentPageSerializer
    model = YourParentPageModel

Key Notes #

• Make sure the user accessing the API has permission to view the linked Case Pages—Wagtail will respect page permissions when accessing case_page attributes.
• If you want to match Wagtail's default Page API response format exactly, using PageSerializer (as shown in Approach 2) is a great way to stay consistent.

内容的提问来源于stack exchange，提问作者boydbueno