Python reverse.reverse函数代码示例

def browse_view(request, format=None):
    return Response({
        'manuscripts': reverse('manuscript-list', request=request, format=format),
        'chants': reverse('chant-list', request=request, format=format),
        'folios': reverse('folio-list', request=request, format=format),
        'concordances': reverse('concordance-list', request=request, format=format)
    })

 def get_links(self, obj):
     request = self.context['request']
     username = obj.get_username()
     return {
         'self': reverse('user_detail', kwargs={User.USERNAME_FIELD: username}, request=request),
         'task': '{}?assigned={}'.format(reverse('task-list', request=request), username)
     }

 def _add_to_basket(self, product_id, quantity=1):
     url = reverse('api-basket-add-product')
     data = {
         "url": reverse('product-detail', args=[product_id]),
         "quantity": quantity
     }
     return self.client.post(url, data)

    def test_setting_reviews_to_order_by_level_works(self):
        self.client.force_login(self.user)

        level_4_review = create_review(create_vocab("level4"), self.user)
        level_4_review.vocabulary.readings.create(level=4, character="level4", kana="level4")

        level_5_review = create_review(create_vocab("level5"), self.user)
        level_5_review.vocabulary.readings.create(level=5, character="level5", kana="level5")

        level_3_review = create_review(create_vocab("level3"), self.user)
        level_3_review.vocabulary.readings.create(level=3, character="level3", kana="level3")

        response = self.client.get(reverse("api:review-current"))
        reviews = response.data["results"]
        actual_review_order = [review["vocabulary"]["readings"][0]["level"] for review in reviews]

        assert len(reviews) == 4
        assert [3, 4, 5, 5] != actual_review_order

        self.user.profile.order_reviews_by_level = True
        self.user.profile.save()

        response = self.client.get(reverse("api:review-current"))
        reviews = response.data["results"]
        actual_review_order = [review["vocabulary"]["readings"][0]["level"] for review in reviews]

        assert len(reviews) == 4
        assert [3, 4, 5, 5] == actual_review_order

 def test_change_vendor_photo(self):
     # create dummy image and upload image      
     imgfile = StringIO.StringIO('GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
     imgfile.name = 'test_img_file.gif'
     data = {'image': imgfile} 
     url = reverse('vendor-photo-add')       
     photo_response = self.client.post(url, data, format='multipart')
     self.assertEqual(photo_response.status_code, status.HTTP_201_CREATED)
     self.assertEqual(photo_response.data['id'], 1)    
     
     # add image to product
     url =  reverse('vendor')
     data = {'id': 2, 'photo': photo_response.data['id']}
     response = self.client.patch(url, data)
     self.assertEqual(response.status_code, status.HTTP_200_OK)  
     print "updated vendor: ", response.content
     self.assertEqual(response.data['photo']['id'], 1)
     
     # upload new image 
     new_imgfile = StringIO.StringIO('GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
     new_imgfile.name = 'new_img_file.gif'
     data = {'image': new_imgfile} 
     url = reverse('vendor-photo-add')       
     new_photo_response = self.client.post(url, data, format='multipart')
     self.assertEqual(new_photo_response.status_code, status.HTTP_201_CREATED)
     self.assertEqual(new_photo_response.data['id'], 2)  
     
     # change image of the product
     url =  reverse('vendor')
     data = {'id': 2, 'photo': new_photo_response.data['id']}
     response = self.client.patch(url, data)
     self.assertEqual(response.status_code, status.HTTP_200_OK)  
     print "updated vendor: ", response.content
     self.assertEqual(response.data['photo']['id'], 2)   

def reverses(request, format=None):
    return {
        'events':       reverse('recommender-events', request=request, format=format),
        'recommender':  reverse('recommender-recommender', request=request, format=format),
        'items':        reverse('recommender-items', request=request, format=format),
        'redirect':     reverse('recommender-redirect', request=request, format=format),
    }

 def get(self, request, *args, **kwargs):
     response = Response(
         {"snippets": reverse("snippet-list", request=request),
          "tags": reverse("tag-list", request=request),
          "people": reverse("person-list", request=request)}
     )
     return response

 def to_representation(self, course_overview):
     course_id = unicode(course_overview.id)
     request = self.context.get("request")
     return {
         # identifiers
         "id": course_id,
         "name": course_overview.display_name,
         "number": course_overview.display_number_with_default,
         "org": course_overview.display_org_with_default,
         # dates
         "start": course_overview.start,
         "start_display": course_overview.start_display,
         "start_type": course_overview.start_type,
         "end": course_overview.end,
         # notification info
         "subscription_id": course_overview.clean_id(padding_char="_"),
         # access info
         "courseware_access": has_access(request.user, "load_mobile", course_overview).to_json(),
         # various URLs
         # course_image is sent in both new and old formats
         # (within media to be compatible with the new Course API)
         "media": {"course_image": {"uri": course_overview.course_image_url, "name": "Course Image"}},
         "course_image": course_overview.course_image_url,
         "course_about": reverse("about_course", kwargs={"course_id": course_id}, request=request),
         "course_updates": reverse("course-updates-list", kwargs={"course_id": course_id}, request=request),
         "course_handouts": reverse("course-handouts-list", kwargs={"course_id": course_id}, request=request),
         "discussion_url": reverse("discussion_course", kwargs={"course_id": course_id}, request=request)
         if course_overview.is_discussion_tab_enabled()
         else None,
         "video_outline": reverse("video-summary-list", kwargs={"course_id": course_id}, request=request),
     }

    def to_native(self, obj):
        view_name = self.view_name
        request = self.context.get('request', None)
        format = self.format or self.context.get('format', None)
        pk = getattr(obj, 'pk', None)
        if pk is None:
            return
        kwargs = {self.pk_url_kwarg: pk}
        try:
            return reverse(view_name, kwargs=kwargs, request=request, format=format)
        except:
            pass

        slug = getattr(obj, self.slug_field, None)

        if not slug:
            raise ValidationError('Could not resolve URL for field using view name "%s"' % view_name)

        kwargs = {self.slug_url_kwarg: slug}
        try:
            return reverse(self.view_name, kwargs=kwargs, request=request, format=format)
        except:
            pass

        kwargs = {self.pk_url_kwarg: obj.pk, self.slug_url_kwarg: slug}
        try:
            return reverse(self.view_name, kwargs=kwargs, request=request, format=format)
        except:
            pass

        raise ValidationError('Could not resolve URL for field using view name "%s"' % view_name)

    def field_to_native(self, obj, field_name):
        request = self.context.get('request', None)
        format = self.format or self.context.get('format', None)
        view_namespace = self.view_namespace if self.view_namespace is not None else self.parent.opts.view_namespace
        view_name = self.view_name or self.parent.opts.view_name
        if view_namespace:
            view_name = "%(namespace)s:%(view)s" % {
                'view':view_name,
                'namespace':view_namespace
            }
        kwargs = {self.pk_url_kwarg: obj.pk}
        try:
            return reverse(view_name, kwargs=kwargs, request=request, format=format)
        except:
            pass

        slug = getattr(obj, self.slug_field, None)

        if not slug:
            raise ValidationError('Could not resolve URL for field using view name "%s"' % view_name)

        kwargs = {self.slug_url_kwarg: slug}
        try:
            return reverse(view_name, kwargs=kwargs, request=request, format=format)
        except:
            pass

        kwargs = {self.pk_url_kwarg: obj.pk, self.slug_url_kwarg: slug}
        try:
            return reverse(view_name, kwargs=kwargs, request=request, format=format)
        except:
            pass

        raise ValidationError('Could not resolve URL for field using view name "%s"', view_name)

def Root(request):
    return Response({
        'test': reverse('blog_api:test', request=request),
        'categories': reverse('blog_api:category-list', request=request),
        'articles': reverse('blog_api:article-list', request=request),
        'popular-articles': reverse('blog_api:popular-article-list', request=request),
    })

    def get(self, request, format=None):
        return Response({
            'export-badges': reverse('api:export-badges', request=request,
                                     format=format),
            'export-instructors': reverse('api:export-instructors',
                                          request=request, format=format),
            'export-members': reverse('api:export-members', request=request,
                                      format=format),
            'events-published': reverse('api:events-published',
                                        request=request, format=format),
            'user-todos': reverse('api:user-todos',
                                  request=request, format=format),
            'reports-list': reverse('api:reports-list',
                                    request=request, format=format),

            # "new" API list-type endpoints below
            'airport-list': reverse('api:airport-list', request=request,
                                    format=format),
            'person-list': reverse('api:person-list', request=request,
                                   format=format),
            'event-list': reverse('api:event-list', request=request,
                                  format=format),
            'host-list': reverse('api:host-list', request=request,
                                 format=format),
        })

 def get(self, request, format=None):
     ret = {}
     for key, url_name in api_root_dict.items():
         ret[key] = reverse.reverse(url_name, request=request, format=format)
     for api_view_key in api_view_urls.keys():
         ret[api_view_key] = reverse.reverse(api_view_urls[api_view_key].name, request=request, format=format)
     return response.Response(ret)

def photos_upload_request(request, format=None):
    """
    Use the GET parameter `num_photos` to specify how many photos you would
    like to upload
    """
    num_photos = int(request.GET.get('num_photos', 1))

    response_data = []
    for i in xrange(num_photos):
        pending_photo = Photo.objects.upload_request(author=request.user)

        if settings.USING_LOCAL_PHOTOS:
            upload_url = reverse('photo-upload', [pending_photo.photo_id], request=request)
            fullres_upload_url = reverse('photo-upload', [pending_photo.photo_id], request=request)
        else:
            upload_url = settings.PHOTO_UPLOAD_SERVER_URL + '/photos/upload/' + pending_photo.photo_id + '/'
            fullres_upload_url = settings.PHOTO_UPLOAD_SERVER_URL + '/photos/upload/' + pending_photo.photo_id + '/original/'

        response_data.append({
            'photo_id': pending_photo.photo_id,
            'upload_url': upload_url,
            'fullres_upload_url': fullres_upload_url
            })

    return Response(response_data)

    def to_representation(self, course_overview):
        course_id = unicode(course_overview.id)
        request = self.context.get('request')
        return {
            # identifiers
            'id': course_id,
            'name': course_overview.display_name,
            'number': course_overview.display_number_with_default,
            'org': course_overview.display_org_with_default,

            # dates
            'start': course_overview.start,
            'start_display': course_overview.start_display,
            'start_type': course_overview.start_type,
            'end': course_overview.end,

            # notification info
            'subscription_id': course_overview.clean_id(padding_char='_'),

            # access info
            'courseware_access': has_access(
                request.user,
                'load_mobile',
                course_overview
            ).to_json(),

            # various URLs
            # course_image is sent in both new and old formats
            # (within media to be compatible with the new Course API)
            'media': {
                'course_image': {
                    'uri': course_overview.course_image_url,
                    'name': 'Course Image',
                }
            },
            'course_image': course_overview.course_image_url,
            'course_about': get_link_for_about_page(course_overview),
            'course_sharing_utm_parameters': get_encoded_course_sharing_utm_params(),
            'course_updates': reverse(
                'course-updates-list',
                kwargs={'course_id': course_id},
                request=request,
            ),
            'course_handouts': reverse(
                'course-handouts-list',
                kwargs={'course_id': course_id},
                request=request,
            ),
            'discussion_url': reverse(
                'discussion_course',
                kwargs={'course_id': course_id},
                request=request,
            ) if course_overview.is_discussion_tab_enabled() else None,

            'video_outline': reverse(
                'video-summary-list',
                kwargs={'course_id': course_id},
                request=request,
            ),
        }