def update(self, request, pantry_id, food_id):
        # Retrieve data parameters...
        amount = float(request.data.get('amount'))
        unit_of_measure_id = int(request.data.get('unit_of_measure'))
        unit_of_measure = get_object_or_404(UnitOfMeasure, pk=unit_of_measure_id)

        # Retrieve pantry...
        get_user_pantry_or_404(request.user, pantry_id=pantry_id)

        # Retrieve food...
        get_object_or_404(Food, pk=food_id)

        # Find pantry food...
        try:
            pantry_food = PantryFood.objects.select_related('pantry', 'food').get(
                pantry__pk=pantry_id, food__pk=food_id
            )

        except PantryFood.DoesNotExist:
            return Response(status=status.HTTP_400_BAD_REQUEST, data={
                'message': 'The specified food is not in your pantry.'
            })

        else:
            pantry_food.amount = amount
            pantry_food.unit_of_measure = unit_of_measure
            pantry_food.save()

        return Response(status=status.HTTP_200_OK)

    def post(self, request, provider_id):
        """ POST handler. """
        provider = generics.get_object_or_404(CreditProvider, provider_id=provider_id)
        data = request.data

        # Ensure the input data is valid
        serializer = CreditProviderCallbackSerializer(data=data, provider=provider)
        serializer.is_valid(raise_exception=True)

        # Update the credit request status
        request_uuid = data["request_uuid"]
        new_status = data["status"]
        credit_request = generics.get_object_or_404(CreditRequest, uuid=request_uuid, provider=provider)
        old_status = credit_request.status
        credit_request.status = new_status
        credit_request.save()

        log.info(
            "Updated [%s] CreditRequest [%s] from status [%s] to [%s].",
            provider_id,
            request_uuid,
            old_status,
            new_status,
        )

        return Response()

 def post(self, request, *args, **kwargs):
     print "Updating"
     self.folder = get_object_or_404(self.get_queryset(), pk=self.kwargs["pk"])
     self.ctype = get_object_or_404(ContentType, model=self.kwargs["model"], app_label=self.kwargs["app"])
     self.object = get_object_or_404(self.ctype.model_class(), pk=self.kwargs["pki"])
     FolderContent.objects.create(folder=self.folder, content_object=self.object)
     return Response({"ok": 1}, status=status.HTTP_201_CREATED)

    def social_routes(self, request, *args, **kwargs):
        '''
            return a list of [
                {profile_id: ''}
            ]
        '''
        target_user_id = request.query_params.get('target_user')
        
        dest_profile = get_object_or_404(Profile, user_id=target_user_id)
        src_profile = get_object_or_404(Profile, user=request.user)
        routes = calculate_topN_social_routes(src_profile, dest_profile, 10)
        profile_id_set = set()
    
        for route in routes:
            profile_id_set.update(route['profile_ids'])

        p_qs = Profile.objects.filter(id__in=profile_id_set).values('id', 
                                        'user__nickname', 'user__username', 'phone_num')
        id_profile_dict = {}
        for p in p_qs:
            nickname = p.pop('user__nickname')
            username = p.pop('user__username')
            p.update({
                'display_name': nickname or username, 
            })
            # if display_name is '' then from user's own mobile
            if p['display_name']:
                p.pop('phone_num')
            id_profile_dict[ p['id'] ] = p
        result = []
        for route in routes:
            result.append( self._prepare_route_result(route, id_profile_dict) )

        return Response(result)

    def reduce_score(self, request, *args, **kwargs):

        student_id = kwargs.get('student_id')
        problem_id = kwargs.get('problem_id')

        student = get_object_or_404(User.objects.all(), member_id=student_id)
        problem = get_object_or_404(Problem.objects.all(), id=problem_id)
        assignment = problem.assignment_id
        try:
            instance = PlagiarismRequest.objects.get(assignment=assignment)
            if not instance.status:
                return Response({'status': 'failure', 'message': 'Plagiarism Check not done'},
                                status=status.HTTP_400_BAD_REQUEST)
            points = self.request.data.get('points', None)
            print "points", points
            if points is None or not (0 <= points <= problem.points):
                return Response({'status': 'failure', 'message': 'Invalid point allocation'},
                                status=status.HTTP_400_BAD_REQUEST)
            problem_score = get_object_or_404(ProblemScore, student=student, problem=problem)
            problem_score.score = points
            problem_score.save()
            return Response({'status': 'success', 'message': 'Points Updated'},
                            status=status.HTTP_200_OK)
        except PlagiarismRequest.DoesNotExist:
            return Response({'status': 'failure', 'message': 'Plagiarism Check not done'},
                            status=status.HTTP_400_BAD_REQUEST)

    def create(self, request, pantry_id, food_id):
        # Retrieve data parameters...
        amount = float(request.data.get('amount'))
        unit_of_measure_id = int(request.data.get('unit_of_measure'))
        unit_of_measure = get_object_or_404(UnitOfMeasure, pk=unit_of_measure_id)

        # Retrieve pantry...
        user_pantry = get_user_pantry_or_404(request.user, pantry_id=pantry_id)

        # Retrieve food...
        food = get_object_or_404(Food, pk=food_id)

        # Find pantry food...
        try:
            PantryFood.objects.select_related('pantry', 'food').get(pantry__pk=pantry_id, food__pk=food_id)

            return Response(status=status.HTTP_400_BAD_REQUEST, data={
                'message': 'The specified food is already in your pantry.'
            })

        except PantryFood.DoesNotExist:
            PantryFood.objects.create(
                pantry=user_pantry.pantry,
                food=food,
                amount=amount,
                unit_of_measure=unit_of_measure
            )

        return Response(status=status.HTTP_201_CREATED)

 def retrieve(self, request, pk=None):
     if is_integer(pk):
         queryset = get_object_or_404(Project, pk=pk)
     else:
         queryset = get_object_or_404(Project, linkname=pk)
     serializer = ProjectSerializer(queryset)
     return Response(serializer.data)

    def get(self, request, *args, **kwargs):
        account_slug = kwargs['account_slug']
        board_slug = kwargs['board_slug']

        account_collaborator = get_object_or_404(
            AccountCollaborator.objects.select_related('account', 'user'),
            account__slug=account_slug,
            is_owner=True)

        if account_collaborator.account.type == Account.PERSONAL_ACCOUNT:
            boards = account_collaborator.user.boards

        board = get_object_or_404(boards, slug=board_slug)

        collaborator_users = []

        if board.is_shared:
            collaborator_users = BoardCollaborator.objects.filter(
                board_id=board.id, user__isnull=False
            ).values_list('user', flat=True)

        data = {
            'board': board,
            'collaborator_users': collaborator_users
        }

        return Response(data, template_name='index.html')

    def get_object(self, queryset=None):
        obj = super(DataViewSet, self).get_object()
        pk_lookup, dataid_lookup = self.lookup_fields
        pk = self.kwargs.get(pk_lookup)
        dataid = self.kwargs.get(dataid_lookup)

        if pk is not None and dataid is not None:
            try:
                int(dataid)
            except ValueError:
                raise ParseError(_(u"Invalid dataid %(dataid)s"
                                   % {'dataid': dataid}))

            if not obj.is_merged_dataset:
                obj = get_object_or_404(Instance, pk=dataid, xform__pk=pk,
                                        deleted_at__isnull=True)
            else:
                xforms = obj.mergedxform.xforms.filter(deleted_at__isnull=True)
                pks = [xform_id
                       for xform_id in xforms.values_list('pk', flat=True)]

                obj = get_object_or_404(Instance, pk=dataid, xform_id__in=pks,
                                        deleted_at__isnull=True)

        return obj

 def create(self, request, **kwargs):
     app = get_object_or_404(self.model, id=kwargs['id'])
     if request.user != app.owner and not request.user.is_superuser:
         return Response(status=status.HTTP_403_FORBIDDEN)
     user = get_object_or_404(User, username=request.DATA['username'])
     assign_perm(self.perm, user, app)
     models.log_event(app, "User {} was granted access to {}".format(user, app))
     return Response(status=status.HTTP_201_CREATED)

 def destroy(self, request, pk=None, parent_lookup_organization=None):
     '''Remove a user from an organization.'''
     user = get_object_or_404(User, pk=pk)
     org = get_object_or_404(
         SeedOrganization, pk=parent_lookup_organization)
     self.check_object_permissions(request, org)
     org.users.remove(user)
     return Response(status=status.HTTP_204_NO_CONTENT)

 def update(self, request, pk=None, parent_lookup_organization=None):
     '''Add a user to an organization.'''
     user = get_object_or_404(User, pk=pk)
     org = get_object_or_404(
         SeedOrganization, pk=parent_lookup_organization)
     self.check_object_permissions(request, org)
     org.users.add(user)
     return Response(status=status.HTTP_204_NO_CONTENT)

 def create(self, request, *args, **kwargs):
     request._data = request.DATA.copy()
     app = request.DATA["app"] = get_object_or_404(models.App, id=self.kwargs["id"])
     # check the user is authorized for this app
     user = request.DATA["owner"] = get_object_or_404(User, username=self.request.DATA["receive_user"])
     if user == app.owner or user in get_users_with_perms(app):
         return super(AppPushViewSet, self).create(request, *args, **kwargs)
     raise PermissionDenied()

 def create(self, request, *args, **kwargs):
     app = get_object_or_404(models.App, id=request.DATA["receive_repo"])
     user = get_object_or_404(User, username=request.DATA["receive_user"])
     # check the user is authorized for this app
     if user == app.owner or user in get_users_with_perms(app):
         config = app.release_set.latest().config
         serializer = self.get_serializer(config)
         return Response(serializer.data, status=status.HTTP_200_OK)
     raise PermissionDenied()

 def create(self, request, **kwargs):
     app = get_object_or_404(self.model, id=kwargs['id'])
     if request.user != app.owner:
         return Response(status=status.HTTP_403_FORBIDDEN)
     user = get_object_or_404(User, username=request.DATA['username'])
     assign_perm(self.perm, user, app)
     app.publish()
     tasks.converge_controller.apply_async().wait()
     return Response(status=status.HTTP_201_CREATED)

 def destroy(self, request, **kwargs):
     app = get_object_or_404(self.model, id=kwargs['id'])
     if request.user != app.owner and not request.user.is_superuser:
         return Response(status=status.HTTP_403_FORBIDDEN)
     user = get_object_or_404(User, username=kwargs['username'])
     if user.has_perm(self.perm, app):
         remove_perm(self.perm, user, app)
         models.log_event(app, "User {} was revoked access to {}".format(user, app))
         return Response(status=status.HTTP_204_NO_CONTENT)
     else:
         return Response(status=status.HTTP_404_NOT_FOUND)

 def update(self, request, pk):
     product = get_object_or_404(Product, pk=pk)
     self.check_object_permissions(request, product)  # compruebo si el usuario autenticado puede hacer PUT en este product
     serializer = ProductUpdateSerializer(instance=product, data=request.data)
     if serializer.is_valid():
         category = get_object_or_404(Category, index=request.data.get('category', dict()).get('index'))
         seller = get_object_or_404(Profile, user=request.user)
         product = serializer.save(seller=seller, category=category)
         response_serializer = ProductSerializer(product)
         return Response(response_serializer.data, status=status.HTTP_200_OK)
     else:
         return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

 def destroy(self, request, **kwargs):
     app = get_object_or_404(self.model, id=kwargs['id'])
     if request.user != app.owner:
         return Response(status=status.HTTP_403_FORBIDDEN)
     user = get_object_or_404(User, username=kwargs['username'])
     if user.has_perm(self.perm, app):
         remove_perm(self.perm, user, app)
         app.publish()
         tasks.converge_controller.apply_async().wait()
         return Response(status=status.HTTP_204_NO_CONTENT)
     else:
         return Response(status=status.HTTP_404_NOT_FOUND)

    def delete(self, request, *args, **kwargs):
        try:
            uuid = request.data['uuid']
        except KeyError:
            raise Http404

        filter_params = {
            'uuid': uuid,
            'user': request.user
        }

        get_object_or_404(self.model, **filter_params).delete()
        return Response(status=204)

 def destroy(self, request, **kwargs):
     app = get_object_or_404(self.model, id=kwargs["id"])
     if request.user != app.owner:
         return Response(status=status.HTTP_403_FORBIDDEN)
     user = get_object_or_404(User, username=kwargs["username"])
     if user.has_perm(self.perm, app):
         remove_perm(self.perm, user, app)
         app.publish()
         tasks.converge_controller.apply_async().wait()
         models.log_event(app, "User {} was revoked access to {}".format(user, app))
         return Response(status=status.HTTP_204_NO_CONTENT)
     else:
         return Response(status=status.HTTP_404_NOT_FOUND)