Python request.clone_request函数代码示例

    def get_schema(self, request=None):
        if request is None:
            endpoints = self.endpoints
        else:
            # Filter the list of endpoints to only include those that
            # the user has permission on.
            endpoints = []
            for key, link, callback in self.endpoints:
                method = link.action.upper()
                view = callback.cls()
                view.request = clone_request(request, method)
                view.format_kwarg = None
                try:
                    view.check_permissions(view.request)
                except exceptions.APIException:
                    pass
                else:
                    endpoints.append((key, link, callback))

        if not endpoints:
            return None

        # Generate the schema content structure, from the endpoints.
        # ('users', 'list'), Link -> {'users': {'list': Link()}}
        content = {}
        for key, link, callback in endpoints:
            insert_into(content, key, link)

        # Return the schema document.
        return coreapi.Document(title=self.title, content=content, url=self.url)

    def get_form(self, view, method, request):
        """
        Get a form, possibly bound to either the input or output data.
        In the absence on of the Resource having an associated form then
        provide a form that can be used to submit arbitrary content.
        """
        obj = getattr(view, 'object', None)
        cloned_request = clone_request(request, method)

        if not self.show_form_for_method(view, method, cloned_request, obj):
            return

        if method in ('DELETE', 'OPTIONS'):
            return True  # Don't actually need to return a form

        if not getattr(view, 'get_serializer', None) or not parsers.FormParser in view.parser_classes:
            return

        serializer = view.get_serializer(instance=obj, request=cloned_request)
        fields = self.serializer_to_form_fields(serializer)

        # Creating an on the fly form see:
        # http://stackoverflow.com/questions/3915024/dynamically-creating-classes-python
        OnTheFlyForm = type(str("OnTheFlyForm"), (forms.Form,), fields)
        data = (obj is not None) and serializer.data or None
        form_instance = OnTheFlyForm(data)
        return form_instance

    def metadata(self, request):
        """
        Return a dictionary of metadata about the view.
        Used to return responses for OPTIONS requests.

        We override the default behavior, and add some extra information
        about the required request body for POST and PUT operations.
        """
        ret = super(GenericAPIView, self).metadata(request)

        actions = {}
        for method in ('PUT', 'POST'):
            if method not in self.allowed_methods:
                continue

            cloned_request = clone_request(request, method)
            try:
                # Test global permissions
                self.check_permissions(cloned_request)
                # Test object permissions
                if method == 'PUT':
                    self.get_object()
            except (exceptions.APIException, PermissionDenied, Http404):
                pass
            else:
                # If user has appropriate permissions for the view, include
                # appropriate metadata about the fields that should be supplied.
                serializer = self.get_serializer()
                actions[method] = serializer.metadata()

        if actions:
            ret['actions'] = actions

        return ret

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        self.object = None
        try:
            self.object = self.get_object()
        except Http404:
            # If this is a PUT-as-create operation, we need to ensure that
            # we have relevant permissions, as if this was a POST request.
            if not self.has_permission(clone_request(request, 'POST')):
                self.permission_denied(self.request)
            created = True
            success_status_code = status.HTTP_201_CREATED
        else:
            created = False
            success_status_code = status.HTTP_200_OK

        serializer = self.get_serializer(self.object, data=request.DATA,
                                         files=request.FILES, partial=partial)

        if serializer.is_valid():
            self.pre_save(serializer.object)
            self.object = serializer.save()
            self.post_save(self.object, created=created)
            return Response(serializer.data, status=success_status_code)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        self.object = None
        try:
            self.object = self.get_object()
        except Http404:
            # If this is a PUT-as-create operation, we need to ensure that
            # we have relevant permissions, as if this was a POST request.
            self.check_permissions(clone_request(request, 'POST'))
            created = True
            save_kwargs = {'force_insert': True}
            success_status_code = status.HTTP_201_CREATED
        else:
            created = False
            save_kwargs = {'force_update': True}
            success_status_code = status.HTTP_200_OK

        serializer = self.get_serializer(self.object, data=request.DATA,
                                         files=request.FILES, partial=partial)

        if serializer.is_valid():
            self.pre_save(serializer.object)
            self.object = serializer.save(**save_kwargs)
            self.post_save(self.object, created=created)
            return Response({
                    'success': True,
                    'data': serializer.data,
                    'message': "",
                }, status=success_status_code)

        return Response({
                'success': False,
                'data': {},
                'message': repr(serializer.errors),
            }, status=status.HTTP_400_BAD_REQUEST)

    def get_actions(self, request, view):
        """
        For generic class based views we return information about
        the fields that are accepted for 'PUT' and 'POST' methods.
        """
        actions = {}
        print
        for method in {'PUT', 'POST'} & set(view.allowed_methods):
            view.request = clone_request(request, method)
            try:
                # Test global permissions
                if hasattr(view, 'check_permissions'):
                    view.check_permissions(view.request)
                # Test object permissions
                if method == 'PUT' and hasattr(view, 'get_object'):
                    view.get_object()
            except (exceptions.APIException, PermissionDenied, Http404):
                pass
            else:
                # If user has appropriate permissions for the view, include
                # appropriate metadata about the fields that should be supplied.
                serializer = view.get_serializer()
                actions[method] = self.get_serializer_info2(serializer)
            finally:
                view.request = request

        return actions

 def create(self, request, *args, **kwargs):
     project = get_object_or_404(Project, id=self.kwargs.get('project_id', None))
     if hasattr(project, 'view_invite'):
         #when view invite already exists then return the existing view invite:
         return self.retrieve(clone_request(request, 'GET'), *args, **kwargs)
     self.check_object_permissions(self.request, project)
     return super(ViewInviteDetail, self).create(request, *args, **kwargs)

    def update(self, request, *args, **kwargs):
        partial = kwargs.pop("partial", False)
        extra_kwargs = {}
        try:
            instance = self.get_object()
        except Http404:
            # this is derived from https://gist.github.com/tomchristie/a2ace4577eff2c603b1b
            # and supports PUT as create.
            if self.request.method == "PUT":
                # For PUT-as-create operation, we need to ensure that we have
                # relevant permissions, as if this was a POST request.  This
                # will either raise a PermissionDenied exception, or simply
                # return None.
                self.check_permissions(clone_request(self.request, "POST"))
                instance = None
                extra_kwargs.update({"id": kwargs["user_id"], "external_id": kwargs["user_id"]})
            else:
                # PATCH requests where the object does not exist should still
                # return a 404 response.
                raise

        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        serializer.is_valid(raise_exception=True)
        serializer.save(**extra_kwargs)
        return Response(serializer.data)

    def _get_actions(self, request, view):
        """Return a JSON Schema for GET, PATCH, PUT, and POST methods."""
        if not hasattr(view, 'get_serializer'):
            return None

        actions = OrderedDict()
        for method in ('GET', 'POST', 'PUT', 'PATCH'):
            if method in view.allowed_methods:
                view.request = clone_request(request, method)
                try:
                    # Test global permissions
                    if hasattr(view, 'check_permissions'):
                        view.check_permissions(view.request)
                    # Test object permissions
                    if method == 'PATCH' and hasattr(view, 'get_object'):
                        view.get_object()
                    if method == 'PUT' and hasattr(view, 'get_object'):
                        view.get_object()
                except (exceptions.APIException, PermissionDenied, Http404):
                    pass
                else:
                    # If user has appropriate permissions for the view, include
                    # appropriate metadata about the fields that should be
                    # supplied.
                    serializer = view.get_serializer()
                    actions[method] = self._get_serializer_fields(serializer)
                finally:
                    view.request = request

        return actions

 def get_object_or_none(self):
     try:
         return self.get_object()
     except Http404:
         # If this is a PUT-as-create operation, we need to ensure that
         # we have relevant permissions, as if this was a POST request.
         # This will either raise a PermissionDenied exception,
         # or simply return None
         self.check_permissions(clone_request(self.request, "POST"))

    def metadata(self, request):
        """
        Return a dictionary of metadata about the view.
        Used to return responses for OPTIONS requests.

        We override the default behavior, and add some extra information
        about the required request body for POST and PUT operations.
        """
        ret = super(GenericAPIView, self).metadata(request)

        actions = {}
        for method in ('PUT', 'POST'):
            if method not in self.allowed_methods:
                continue

            original_request = clone_request(request, request.method)
            self.request = clone_request(request, method)
            try:
                # Test global permissions
                self.check_permissions(self.request)
                # Test object permissions
                if method == 'PUT':
                    try:
                        self.get_object()
                    except Http404:
                        # Http404 should be acceptable and the serializer
                        # metadata should be populated. Except this so the
                        # outer "else" clause of the try-except-else block
                        # will be executed.
                        pass
            except (exceptions.APIException, PermissionDenied):
                pass
            else:
                # If user has appropriate permissions for the view, include
                # appropriate metadata about the fields that should be supplied.
                serializer = self.get_serializer()
                actions[method] = serializer.metadata()
                self.request = original_request

        if actions:
            ret['actions'] = actions

        return ret

    def get_context(self, request):
        request = clone_request(request, request.method)

        if "current_page" in request.GET:
            # Runs through regex in order to clean up potential double quoted strings.
            request.path = request.path_info = re.sub(r'^"|"$', '', request.GET["current_page"])

        self.process_request(request)
        self.context["request"] = request
        return self.context

 def _get_view_queryset(self, view_class, user_field_qs, with_embed_list=None):
     #get the queryset from the view:
     view_instance = view_class(lookup_url_kwarg='user_pk')
     view_instance.args = self.args
     view_instance.kwargs = self.kwargs
     view_instance.request = clone_request(self.request, self.request.method)
     view_instance.queryset = user_field_qs
     view_instance.initial(view_instance.request, self.args, self.kwargs)
     if with_embed_list:
         view_instance.embed_list += with_embed_list
     return view_instance.filter_queryset(view_instance.get_queryset())

 def _get_raw_data_form(self, view, method, request, media_types):
     # We need to impersonate a request with the correct method,
     # so that eg. any dynamic get_serializer_class methods return the
     # correct form for each method.
     restore = view.request
     request = clone_request(request, method)
     view.request = request
     try:
         return self.get_raw_data_form(view, method, request, media_types)
     finally:
         view.request = restore

    def create(self, request, *args, **kwargs):
        bulk = isinstance(request.data, list)

        #if not bulk, use regular create:
        if not bulk:
            return super(BulkUpdateWithCreateMixin, self).create(request, *args, **kwargs)

        #if bulk, use bulk create as bulk update:
        else:
            self.request = clone_request(request, 'PUT')
            return self.bulk_update(self.request, *args, **kwargs)