def get(self, *args):
     logger.debug("!!!START REQUEST!!!")
     """Handler method for OAuth GET requests."""   
     logger.debug("!!!Req URL: %s"%self.request.url)
  
     # user authorization
     
     #TODO: put up a screen explaining what this authorization is for before
     #approving the request_token, and allowing the user to decide if they 
     #want to proceed- now it just approves right away. If the user rejects
     #the approval , redirect to the callback with an error parameter
     
     
     logger.debug("!!!Entering AUTHORIZATION_URL")
     # get the request token
     oauth_server, oauth_request = initialize_server_request(self.request)
     if oauth_server is None:
         return send_oauth_error(oauth.OAuthError('Invalid request parameters.'), self.response)
     else:
         logger.debug("!!!OAuth Params: %s"%oauth_request.parameters)
     try:
         # get the request token
         token = oauth_server.fetch_request_token(oauth_request)
     except oauth.OAuthError, err:
         logger.exception("Failed accessing request token")
         return send_oauth_error(err, self.response)

def callback_view(request, **args):
    d = {}
    if 'error' in args:
        d['error'] = args['error']

    try:
        oauth_token = Token.objects.get(key=args['oauth_token'])
    except AttributeError, e:
        send_oauth_error(e)

 def wrapper(self,*args,**kwargs):
     if is_valid_request(self.request):
         try:
             consumer, token, parameters = validate_token(self.request)               
             if consumer and token:
                 return method(self,*args,**kwargs)
         except oauth.OAuthError, e:
             send_oauth_error(e,self.response)
             return       

 def __call__(self, request, *args, **kwargs):
     if self.is_valid_request(request):
         try:
             consumer, token, parameters = self.validate_token(request)
         except OAuthError, e:
             return send_oauth_error(e)
         
         if self.resource_name and token.resource.name != self.resource_name:
             return send_oauth_error(OAuthError(_('You are not allowed to access this resource.')))
         elif consumer and token:
             return self.view_func(request, *args, **kwargs)

    def __call__(self, request):
        if self.is_valid_request(request):
            try:
                consumer, token, parameters = self.validate_token(request)
            except OAuthError, e:
                return send_oauth_error(e)

            # lou w - changed to check token scope and self scope instead of resource
            if self.scopes and token.scope != self.scopes:
                return send_oauth_error(OAuthError(_('You are not allowed to access this resource.')))
            elif consumer and token:
                return self.view_func(request, *args, **kwargs)

def callback_view(request, **args):
    d = {}
    if "error" in args:
        d["error"] = args["error"]

    try:
        oauth_token = Token.objects.get(key=args["oauth_token"])
    except AttributeError as e:
        send_oauth_error("https" if request.is_secure() else "http", get_current_site(request).domain, e)
    except Token.DoesNotExist as e:
        send_oauth_error("https" if request.is_secure() else "http", get_current_site(request).domain, e)
    d["verifier"] = oauth_token.verifier
    return render(request, "oauth_verifier_pin.html", d)

        def wrapped_view(request, *args, **kwargs):
            oauth_request = get_oauth_request(request)
            if oauth_request is None:
                return INVALID_PARAMS_RESPONSE

            try:
                consumer = store.get_consumer(request, oauth_request, oauth_request['oauth_consumer_key'])
            except InvalidConsumerError:
                return INVALID_CONSUMER_RESPONSE

            try:
                token = store.get_access_token(request, oauth_request, consumer, oauth_request.get_parameter('oauth_token'))
            except InvalidTokenError:
                return send_oauth_error(oauth.Error(_('Invalid access token: %s') % oauth_request.get_parameter('oauth_token')))

            if not verify_oauth_request(request, oauth_request, consumer, token):
                return COULD_NOT_VERIFY_OAUTH_REQUEST_RESPONSE

            if self.scope_name and (not token.scope
                                    or token.scope.name != self.scope_name):
                return INVALID_SCOPE_RESPONSE

            if token.user:
                request.user = token.user
            return view_func(request, *args, **kwargs)

        def wrapped_view(request, *args, **kwargs):
            oauth_request = get_oauth_request(request)
            scheme = 'https' if request.is_secure() else 'http'
            domain = get_current_site(request).domain
            if oauth_request is None:
                return invalid_params_response(scheme, domain)

            try:
                consumer = store.get_consumer(
                    request, oauth_request, oauth_request['oauth_consumer_key'])
            except InvalidConsumerError:
                return INVALID_CONSUMER_RESPONSE

            try:
                token = store.get_access_token(
                    request, oauth_request, consumer, oauth_request.get_parameter('oauth_token'))
            except InvalidTokenError:
                return send_oauth_error('https' if request.is_secure() else 'http',
                    get_current_site(request).domain,
                    oauth.Error(_('Invalid access token: %s') % oauth_request.get_parameter('oauth_token')))

            if not verify_oauth_request(request, oauth_request, consumer, token):
                return could_not_verify_oauth_request_response(scheme, domain)

            if self.scope_name and (not token.scope or
                                    token.scope.name != self.scope_name):
                return invalid_scope_response(scheme, domain)

            if token.user:
                request.user = token.user
            return view_func(request, *args, **kwargs)

 def __call__(self, request, *args, **kwargs):
     if self.is_valid_request(request):
         oauth_request = get_oauth_request(request)
         consumer = store.get_consumer(request, oauth_request, 
                         oauth_request.get_parameter('oauth_consumer_key'))
         try:
             token = store.get_access_token(request, oauth_request, 
                             consumer, oauth_request.get_parameter('oauth_token'))
         except InvalidTokenError:
             return send_oauth_error(Error(_('Invalid access token: %s') % oauth_request.get_parameter('oauth_token')))
         try:
             parameters = self.validate_token(request, consumer, token)
         except Error, e:
             return send_oauth_error(e)
         
         if self.resource_name and token.resource.name != self.resource_name:
             return send_oauth_error(Error(_('You are not allowed to access this resource.')))
         elif consumer and token:
             return self.view_func(request, *args, **kwargs)

    def handle_request(self, request):
        # pdb.set_trace()
        if self.is_valid_request(request):
            try:
                consumer, token, parameters = self.validate_token(request)
            except OAuthError, e:
                return send_oauth_error(e)

            if consumer and token:
                request["user"] = token.user

 def __call__(self, request, *args, **kwargs):
     if self.is_valid_request(request):
         oauth_request = get_oauth_request(request)
         consumer = store.get_consumer(request, oauth_request, 
                         oauth_request.get_parameter('oauth_consumer_key'))
         consumer.key = str(consumer.key)
         consumer.secret = str(consumer.secret)
         try:
             token = store.get_access_token(request, oauth_request, 
                             consumer, oauth_request.get_parameter('oauth_token'))
             token.key = str(token.key)
             token.secret = str(token.secret)
         except InvalidTokenError:
             return send_oauth_error(Error(_('Invalid access token: %s') % oauth_request.get_parameter('oauth_token')))
         try:
             parameters = self.validate_token(request, consumer, token)
         except Error, e:
             return send_oauth_error(e)
         
         if consumer and token:
             request.user = token.user
             return self.view_func(request, *args, **kwargs)

def user_authorization(request):
    """
    The Consumer cannot use the Request Token until it has been authorized by 
    the User.
    """
    oauth_server, oauth_request = initialize_server_request(request)
    if oauth_request is None:
        return INVALID_PARAMS_RESPONSE
    try:
        # get the request token
        token = oauth_server.fetch_request_token(oauth_request)
    except OAuthError, err:
        return send_oauth_error(err)

def user_authorization(request, form_class=AuthorizeRequestTokenForm):
    if 'oauth_token' not in request.REQUEST:
        return HttpResponseBadRequest('No request token specified.')

    oauth_request = get_oauth_request(request)

    try:
        request_token = store.get_request_token(request, oauth_request, request.REQUEST['oauth_token'])
    except InvalidTokenError:
        return HttpResponseBadRequest('Invalid request token.')

    consumer = store.get_consumer_for_request_token(request, oauth_request, request_token)

    if request.method == 'POST':
        form = form_class(request.POST)
        if request.session.get('oauth', '') == request_token.key and form.is_valid():
            request.session['oauth'] = ''
            if form.cleaned_data['authorize_access']:
                request_token = store.authorize_request_token(request, oauth_request, request_token)
                args = { 'oauth_token': request_token }
            else:
                args = { 'error': _('Access not granted by user.') }
            
            if request_token.callback is not None and request_token.callback != OUT_OF_BAND:
                response = HttpResponseRedirect(request_token.get_callback_url(args))
            else:
                # try to get custom callback view
                callback_view_str = getattr(settings, OAUTH_CALLBACK_VIEW, 
                                    'oauth_provider.views.fake_callback_view')
                try:
                    callback_view = get_callable(callback_view_str)
                except AttributeError:
                    raise Exception, "%s view doesn't exist." % callback_view_str
                response = callback_view(request, **args)
        else:
            response = send_oauth_error(oauth.Error(_('Action not allowed.')))
    else:
        # try to get custom authorize view
        authorize_view_str = getattr(settings, OAUTH_AUTHORIZE_VIEW, 
                                    'oauth_provider.views.fake_authorize_view')
        try:
            authorize_view = get_callable(authorize_view_str)
        except AttributeError:
            raise Exception, "%s view doesn't exist." % authorize_view_str
        params = oauth_request.get_normalized_parameters()
        # set the oauth flag
        request.session['oauth'] = request_token.key
        response = authorize_view(request, request_token, request_token.get_callback_url(), params)
        
    return response

def access_token(request):    
    """
    The Consumer exchanges the Request Token for an Access Token capable of 
    accessing the Protected Resources.
    """
    oauth_server, oauth_request = initialize_server_request(request)
    if oauth_request is None:
        return INVALID_PARAMS_RESPONSE
    try:
        # get the request token
        token = oauth_server.fetch_access_token(oauth_request)
        # return the token
        response = HttpResponse(token.to_string(), mimetype="text/plain")
    except OAuthError, err:
        response = send_oauth_error(err)

    def __call__(self, request):
        pdb.set_trace()
        if self.is_valid_request(request):
            try:
                consumer, token, parameters = self.validate_token(request)
            except OAuthError, e:
                return send_oauth_error(e)

            # Not sure how self.resource_name was being passed...the model class should handle this later
            # if self.resource_name and token.resource.name != self.resource_name:
            #     return send_oauth_error(OAuthError(_('You are not allowed to access this resource.')))
            # elif consumer and token:
            #     return self.view_func(request, *args, **kwargs)
            if consumer and token:
                request["user"] = token.user

def request_token(request):
    """
    The Consumer obtains an unauthorized Request Token by asking the Service 
    Provider to issue a Token. The Request Token's sole purpose is to receive 
    User approval and can only be used to obtain an Access Token.
    """
    oauth_server, oauth_request = initialize_server_request(request)
    if oauth_server is None:
        return INVALID_PARAMS_RESPONSE
    try:
        # create a request token
        token = oauth_server.fetch_request_token(oauth_request)
        # return the token
        response = HttpResponse(token.to_string(), mimetype="text/plain")
    except OAuthError, err:
        response = send_oauth_error(err)

def user_authorization(request, form_class=AuthorizeRequestTokenForm):
    if "oauth_token" not in request.REQUEST:
        return HttpResponseBadRequest("No request token specified.")

    oauth_request = get_oauth_request(request)

    try:
        request_token = store.get_request_token(request, oauth_request, request.REQUEST["oauth_token"])
    except InvalidTokenError:
        return HttpResponseBadRequest("Invalid request token.")

    consumer = store.get_consumer_for_request_token(request, oauth_request, request_token)

    if request.method == "POST":
        form = form_class(request.POST)
        if request.session.get("oauth", "") == request_token.key and form.is_valid():
            request.session["oauth"] = ""
            if form.cleaned_data["authorize_access"]:
                request_token = store.authorize_request_token(request, oauth_request, request_token)
                args = {"oauth_token": request_token.key}
            else:
                args = {"error": _("Access not granted by user.")}
            if request_token.callback is not None and request_token.callback != OUT_OF_BAND:
                response = HttpResponseRedirect("%s&%s" % (request_token.get_callback_url(), urlencode(args)))
            else:
                # try to get custom callback view
                callback_view_str = getattr(settings, OAUTH_CALLBACK_VIEW, "oauth_provider.views.fake_callback_view")
                try:
                    callback_view = get_callable(callback_view_str)
                except AttributeError:
                    raise Exception, "%s view doesn't exist." % callback_view_str
                response = callback_view(request, **args)
        else:
            response = send_oauth_error(oauth.Error(_("Action not allowed.")))
    else:
        # try to get custom authorize view
        authorize_view_str = getattr(settings, OAUTH_AUTHORIZE_VIEW, "oauth_provider.views.fake_authorize_view")
        try:
            authorize_view = get_callable(authorize_view_str)
        except AttributeError:
            raise Exception, "%s view doesn't exist." % authorize_view_str
        params = oauth_request.get_normalized_parameters()
        # set the oauth flag
        request.session["oauth"] = request_token.key
        response = authorize_view(request, request_token, request_token.get_callback_url(), params)

    return response

def request_token(request):
    oauth_request = get_oauth_request(request)
    if oauth_request is None:
        return INVALID_PARAMS_RESPONSE

    missing_params = require_params(oauth_request, ("oauth_callback",))
    if missing_params is not None:
        return missing_params

    try:
        consumer = store.get_consumer(request, oauth_request, oauth_request["oauth_consumer_key"])
    except InvalidConsumerError:
        return HttpResponseBadRequest("Invalid Consumer.")

    if not verify_oauth_request(request, oauth_request, consumer):
        return HttpResponseBadRequest("Could not verify OAuth request.")

    try:
        request_token = store.create_request_token(request, oauth_request, consumer, oauth_request["oauth_callback"])
    except oauth.Error, err:
        return send_oauth_error(err)

def request_token(request):
    oauth_request = get_oauth_request(request)
    if oauth_request is None:
        return INVALID_PARAMS_RESPONSE

    missing_params = require_params(oauth_request, ('oauth_callback',))
    if missing_params is not None:
        return missing_params

    try:
        consumer = store.get_consumer(request, oauth_request, oauth_request['oauth_consumer_key'])
    except InvalidConsumerError:
        logging.info('Oauth error: invalid consumer: %d' % oauth_request['oauth_consumer_key'])
        return HttpResponseBadRequest('Invalid Consumer.')

    if not verify_oauth_request(request, oauth_request, consumer):
        logging.info('Oauth error: could not verify request')
        return HttpResponseBadRequest('Could not verify OAuth request.')

    try:
        request_token = store.create_request_token(request, oauth_request, consumer, oauth_request['oauth_callback'])
    except oauth.Error, err:
        return send_oauth_error(err)

def request_token(request):
    oauth_request = get_oauth_request(request)
    if oauth_request is None:
        return INVALID_PARAMS_RESPONSE

    missing_params = require_params(oauth_request, ('oauth_callback',))
    if missing_params is not None:
        return missing_params

    if is_xauth_request(oauth_request):
        return HttpResponseBadRequest('xAuth not allowed for this method.')

    try:
        consumer = store.get_consumer(request, oauth_request, oauth_request['oauth_consumer_key'])
    except InvalidConsumerError:
        return HttpResponseBadRequest('Invalid Consumer.')

    if not verify_oauth_request(request, oauth_request, consumer):
        return HttpResponseBadRequest('Could not verify OAuth request.')

    try:
        request_token = store.create_request_token(request, oauth_request, consumer, oauth_request['oauth_callback'])
    except oauth.Error, err:
        return send_oauth_error(err)