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

    def get(self, request, format=None):
        api = OrderedDict((
            ('version', reverse('stackdio:version',
                                request=request,
                                format=format)),
            ('users', reverse('api:users:user-list',
                              request=request,
                              format=format)),
            ('groups', reverse('api:users:group-list',
                               request=request,
                               format=format)),
            ('current_user', reverse('api:users:currentuser-detail',
                                     request=request,
                                     format=format)),
            ('cloud', reverse('api:cloud:root',
                              request=request,
                              format=format)),
            ('blueprints', reverse('api:blueprints:blueprint-list',
                                   request=request,
                                   format=format)),
            ('formulas', reverse('api:formulas:formula-list',
                                 request=request,
                                 format=format)),
            ('stacks', reverse('api:stacks:stack-list',
                               request=request,
                               format=format)),
            ('volumes', reverse('api:volumes:volume-list',
                                request=request,
                                format=format)),
            ('search', reverse('api:search:search',
                               request=request,
                               format=format)),
        ))

        return Response(api)

    def retrieve(self, request, project, jm, pk=None):
        """
        GET method implementation for detail view

        Return a single job with log_references and
        artifact names and links to the artifact blobs.
        """
        obj = jm.get_job(pk)
        if obj:
            job = obj[0]
            job["resource_uri"] = reverse("jobs-detail",
                kwargs={"project": jm.project, "pk": job["id"]})
            job["logs"] = jm.get_log_references(pk)

            # make artifact ids into uris
            artifact_refs = jm.get_job_artifact_references(pk)
            job["artifacts"] = []
            for art in artifact_refs:
                ref = reverse("artifact-detail",
                              kwargs={"project": jm.project, "pk": art["id"]})
                art["resource_uri"] = ref
                job["artifacts"].append(art)

            option_collections = jm.refdata_model.get_all_option_collections()
            job["platform_opt"] = option_collections[job["option_collection_hash"]]['opt']

            return Response(job)
        else:
            return Response("No job with id: {0}".format(pk), 404)

    def fetch_scheduled_on(self, act):
        scheduled_on = {}
        scheduled_activities = EighthScheduledActivity.objects.filter(activity=act).select_related("block")

        # user = self.context.get("user", self.context["request"].user)
        # favorited_activities = set(user.favorited_activity_set
        #                               .values_list("id", flat=True))
        # available_restricted_acts = EighthActivity.restricted_activities_available_to_user(user)

        for scheduled_activity in scheduled_activities:
            scheduled_on[scheduled_activity.block.id] = {
                "id": scheduled_activity.block.id,
                "date": scheduled_activity.block.date,
                "block_letter": scheduled_activity.block.block_letter,
                "url": reverse("api_eighth_block_detail",
                               args=[scheduled_activity.block.id],
                               request=self.context["request"]),
                "roster": {
                    "id": scheduled_activity.id,
                    "url": reverse("api_eighth_scheduled_activity_signup_list",
                                   args=[scheduled_activity.id],
                                   request=self.context["request"]),
                }
            }
        return scheduled_on

 def get(self, request, format=None):
     root_url = reverse('api-root', request=request, format=format)
     token_url = reverse('api-token-auth', request=request, format=format)
     links = [
         '<%s>; rel="%s"' % (root_url, 'api-root'),
         '<%s>; rel="%s"' % (token_url, 'api-get-auth-token'),
     ]
     if not request.user.is_anonymous():
         list_name = '{basename}-list'
         detail_name = '{basename}-detail'
         for prefix, viewset, basename in self.router.registry:
             singleton_pk = getattr(viewset, 'singleton_pk', False)
             if singleton_pk:
                 url_name = detail_name.format(basename=basename)
                 kwargs = { 'pk': singleton_pk(viewset(), request) }
             else:
                 url_name = list_name.format(basename=basename)
                 kwargs = {}
             url = reverse(url_name, request=request, format=format, kwargs=kwargs)
             links.append('<%s>; rel="%s"' % (url, url_name))
         # Add user link
         url_name = detail_name.format(basename='user')
         kwargs = { 'pk': request.user.pk }
         url = reverse(url_name, request=request, format=format, kwargs=kwargs)
         links.append('<%s>; rel="%s"' % (url, url_name))
     headers = { 'Link': ', '.join(links) }
     body = {
         name.lower(): getattr(settings, name, None) for name in self.names
     }
     return Response(body, headers=headers)

def api_root(request, format=None):
    """
    Welcome to the XBee Wi-Fi Cloud Kit API Explorer
    ------------------------------------------------

    From here, you can browse and interact with API resources right in your
    browser, using the same calls made by the frontend. Unauthenticated users
    will have limited visibility into the system, users can log in via the
    login API or via the link in the header.

    From the API root, you will find links for the following resources:

    * `login/logout` - Used for establishing session based authentication
    * `user` - View the user resource associated with your account
    * `devices` - Explore device information for status, data, and
                        configuration
    * `dashboards` - Explore the dashboard resource rendered by the frontend

    """
    return Response({
        'login': reverse('api_login', request=request, format=format),
        'logout': reverse('api_logout', request=request, format=format),
        'user': reverse('deviceclouduser-list',
                        request=request, format=format),
        'dashboards': reverse('dashboard-list', request=request,
                              format=format),
        'devices': reverse('devices-list', request=request, format=format),
    })