why not support post request about drf-flex-fields HOT 12 CLOSED

import logging
from rest_framework import (
    generics,
    response,
    status,
    mixins,
    viewsets,
)

logger = logging.getLogger(__name__)


class FlexFieldsMixin:
    """
    This View is used with drf-flex-fields package.
    Automatically select fields for select_related
    for queryset from currently used serializer
    and all serializers in expandable_fields dict.
    Developer must define fields to prefetch by himself in `get_queryset` method.
    """
    def get_expanded_related_fields(self):
        root_serializer = self.get_serializer_class()
        select_related_fields = set()

        for root_field in self.request.query_params.get('expand', '').split(','):
            if not root_field:
                continue
            serializer = root_serializer
            fields_to_select = []
            for field in root_field.split('.'):
                if not hasattr(serializer, 'expandable_fields'):
                    continue
                try:
                    many = serializer.expandable_fields[field][1].get('many')
                except (KeyError, IndexError) as e:
                    logger.warning(e)
                    # Request contains wrong expand key that is not present in expandable_fields
                    continue
                if many:
                    continue
                expandable_serializer = serializer.expandable_fields[field][0]
                if type(expandable_serializer) == str:
                    expandable_serializer = serializer._import_serializer_class(expandable_serializer)
                serializer = expandable_serializer
                fields_to_select.append(field)
                field = '__'.join(fields_to_select)
                select_related_fields.add(field)
        return list(select_related_fields)

    def get_queryset(self):
        queryset = super().get_queryset()
        expanded_fields = self.get_expanded_related_fields()
        if expanded_fields:
            queryset.select_related(*expanded_fields)
        return queryset

    @staticmethod
    def is_field_expanded(request, key):
        """
        Examines request object to return boolean of whether
        passed field is expanded.

        Adds all fields that are included in nested argument
        i.e. `?expand=organizer.user.avatar` means that
        organiser, organizer.user and organizer.user.avatar are expanded

        """
        expanded_fields = set()
        for field in request.query_params.get('expand', '').split(','):
            parts = field.split('.')
            for i in range(1, len(parts) + 1):
                expanded_fields.add('.'.join(parts[:i]))

        return '~all' in expanded_fields or key in expanded_fields


class FlexCreateModelMixin(FlexFieldsMixin, mixins.CreateModelMixin):
    def get_object_flex(self, data):
        """
        Just like default get_object but without url lookup
        Additional db request is needed in order to select related objects
        that were requested by `expand` GET parameter.
        """
        lookup_field = self.lookup_field
        if lookup_field == 'pk':
            lookup_field = 'id'

        queryset = self.filter_queryset(self.get_queryset())
        filter_kwargs = {lookup_field: data[lookup_field]}
        obj = generics.get_object_or_404(queryset, **filter_kwargs)
        self.check_object_permissions(self.request, obj)
        return obj

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        if request.query_params.get('expand'):
            serializer = self.get_serializer_class()(
                instance=self.get_object_flex(
                    serializer.data
                ),
                context={
                    'request': request,
                },
                expand=request.query_params['expand'].split(','),
            )

        return response.Response(
            serializer.data,
            status=status.HTTP_201_CREATED,
            headers=headers,
        )


class FlexUpdateModelMixin(FlexFieldsMixin, mixins.UpdateModelMixin):
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()

        context = {}
        expand = request.query_params.get('expand', '').split(',')
        if expand:
            context['request'] = request

        serializer = self.get_serializer(
            instance,
            data=request.data,
            partial=partial,
            context=context,
        )
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)

        if getattr(instance, '_prefetched_objects_cache', None):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        serializer = self.get_serializer(
            instance,
            context=context,
            expand=expand,
        )
        return response.Response(serializer.data)


class FlexModelViewSet(FlexCreateModelMixin,
                       mixins.RetrieveModelMixin,
                       FlexUpdateModelMixin,
                       mixins.DestroyModelMixin,
                       mixins.ListModelMixin,
                       viewsets.GenericViewSet):
    """
    A viewset that provides default `create()`, `retrieve()`, `update()`,
    `partial_update()`, `destroy()` and `list()` actions.
    """
    pass