Commits

Alexis Metaireau  committed f4fdfd7

Add a way to configure tokens and server in the model. Create management command too

  • Participants
  • Parent commits 0814401

Comments (0)

Files changed (6)

File oauthclient/management/__init__.py

+from django.db.models import get_models, signals
+from oauthclient import models as oauthclient_app
+from django.core.management import call_command
+
+def create_oauth_token(app, created_models, verbosity, **kwargs):
+    from oauthclient.models import Token
+    if Token in created_models and kwargs.get('interactive', True):
+        msg = "\nYou just installed oauthclient app, wich means you" \
+                "don't have any token defined yet.\n Would you like to define " \
+                "them now ? (yes/no): "
+        confirm = raw_input(msg)
+        while 1:
+            if confirm not in ('yes', 'no'):
+                confirm = raw_input('Please enter either "yes" or "no": ')
+                continue
+            if confirm == 'yes':
+                call_command("oauthcreatetoken", interactive=True)
+            break
+
+signals.post_syncdb.connect(create_oauth_token, sender=oauthclient_app,
+    dispatch_uid="oauthclient.management.create_oauth_token")

File oauthclient/management/commands/__init__.py

Empty file added.

File oauthclient/management/commands/oauthcreatetoken.py

+"""
+Management utility to create OAuth tokens
+
+"""
+from optparse import make_option
+from django.core.management.base import BaseCommand, CommandError
+from django.utils.translation import ugettext as _
+
+from oauthclient.models import OAuthServer, Token
+
+class Command(BaseCommand):
+    option_list = BaseCommand.option_list + (
+        make_option('--identifier', dest='identifier', default=None, 
+            help='Specify an identifier to identify the token later. A good' \
+                'idea is to enter the name of the service, or the OAuth' \
+                'server.'),
+        make_option('--key', dest='key', default=None, 
+            help='Specify the OAuth token key to use'),
+        make_option('--secret', dest='secret', default=None,
+            help='Specify the OAuth token secret to user'), 
+        make_option('--serverurl', dest='serverurl', default=None, 
+            help='Specify the OAuth server root url to use'),
+        make_option('--request-token-url', dest='request_token_url',
+            default='/oauth/request_token/', 
+            help='Specify the request token url'),
+        make_option('--access_token_url', dest = 'access_token_url',
+            default='/oauth/access_token/',
+            help='Specify the access token url'),
+        make_option('--authorize-url', dest = 'authorize_url', 
+            default='/oauth/authorize/', 
+            help='Specify the authorize url'),
+        make_option('--noinput', action='store_false', dest='interactive', default=True,
+            help='Tells Django to NOT prompt the user for input of any kind. '    \
+                 'You must use --server-url, --key and --secret with --noinput.')
+    )
+
+    help = 'Used to specify OAuth access urls and token (key & secret).'
+
+    def handle(self, *args, **options):
+        identifier = options.get('identifier', None)
+        key = options.get('key', None)
+        secret = options.get('secret', None)
+        server_url = options.get('serverurl', None)
+        request_token_url = options.get('request_token_url')
+        access_token_url = options.get('access_token_url')
+        authorize_url = options.get('authorize_url')
+        interactive = options.get('interactive')
+
+        if not interactive:
+            if not key or not secret or not server_url:
+                raise CommandError("You must use --server-url, --key and" \
+                    "--secret with --noinput")
+
+        if interactive:
+            if not identifier:
+                identifier = raw_input('Token identifier: ')
+            if not key:
+                key = raw_input('Token key: ')
+            if not secret:
+                secret = raw_input('Token secret: ')
+            if not server_url:
+                server_url = raw_input('Server URL: ')
+            if not request_token_url:
+                request_token_url = raw_input('Request token URL (without server '\
+                    'URL prefix): ')
+            if not access_token_url:
+                access_token_url = raw_input('Access token URL (without server '\
+                    'URL prefix): ')
+            if not authorize_url:
+                authorize_url = raw_input('Authorize URL (without server '\
+                    'URL prefix): ')
+
+        server = OAuthServer(server_url=server_url, 
+            request_token_url=request_token_url,
+            access_token_url=access_token_url,
+            authorize_url=authorize_url)
+        server.save()
+
+        token = Token(identifier=identifier, key=key, secret=secret, server=server)
+        token.save()
+        print "Token and Server successfully configured"

File oauthclient/models.py

-"""Needed to be considered as a django app."""
+from django.db import models
+
+KEY_SIZE = SECRET_SIZE = 16
+
+class OAuthServer(models.Model):
+    """Defines the urls to use for the oauth authentication.
+
+    """
+    server_url = models.URLField(verify_exists = False)
+    request_token_url = models.CharField(max_length=300)
+    access_token_url = models.CharField(max_length=300)
+    authorize_url = models.CharField(max_length=300) 
+
+class Token(models.Model):
+    """Define a couple key-secret provided by the oauth server for this
+    application.
+
+    """
+    identifier = models.CharField(max_length=200, unique=True)
+    key = models.CharField(max_length=KEY_SIZE, null=True, blank=True)
+    secret = models.CharField(max_length=SECRET_SIZE, null=True, blank=True)
+    server = models.ForeignKey(OAuthServer)
+    last_modification = models.DateField(auto_now=True)
+    
+    class Meta:
+        get_latest_by = 'last_modification'

File oauthclient/oauth2.py.old

-"""
-The MIT License
-
-Copyright (c) 2007 Leah Culver, Joe Stump, Mark Paschal, Vic Fryzel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-"""
-
-import urllib
-import time
-import random
-import urlparse
-import hmac
-import binascii
-import httplib2
-from types import ListType
-
-try:
-    from urlparse import parse_qs, parse_qsl
-except ImportError:
-    from cgi import parse_qs, parse_qsl
-
-
-VERSION = '1.0' # Hi Blaine!
-HTTP_METHOD = 'GET'
-SIGNATURE_METHOD = 'PLAINTEXT'
-
-
-class Error(RuntimeError):
-    """Generic exception class."""
-
-    def __init__(self, message='OAuth error occured.'):
-        self._message = message
-
-    @property
-    def message(self):
-        """A hack to get around the deprecation errors in 2.6."""
-        return self._message
-
-    def __str__(self):
-        return self._message
-
-class MissingSignature(Error):
-    pass
-
-def build_authenticate_header(realm=''):
-    """Optional WWW-Authenticate header (401 error)"""
-    return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
-
-
-def escape(s):
-    """Escape a URL including any /."""
-    return urllib.quote(s, safe='~')
-
-
-def generate_timestamp():
-    """Get seconds since epoch (UTC)."""
-    return int(time.time())
-
-
-def generate_nonce(length=8):
-    """Generate pseudorandom number."""
-    return ''.join([str(random.randint(0, 9)) for i in range(length)])
-
-
-def generate_verifier(length=8):
-    """Generate pseudorandom number."""
-    return ''.join([str(random.randint(0, 9)) for i in range(length)])
-
-
-class Consumer(object):
-    """A consumer of OAuth-protected services.
- 
-    The OAuth consumer is a "third-party" service that wants to access
-    protected resources from an OAuth service provider on behalf of an end
-    user. It's kind of the OAuth client.
- 
-    Usually a consumer must be registered with the service provider by the
-    developer of the consumer software. As part of that process, the service
-    provider gives the consumer a *key* and a *secret* with which the consumer
-    software can identify itself to the service. The consumer will include its
-    key in each request to identify itself, but will use its secret only when
-    signing requests, to prove that the request is from that particular
-    registered consumer.
- 
-    Once registered, the consumer can then use its consumer credentials to ask
-    the service provider for a request token, kicking off the OAuth
-    authorization process.
-    """
-
-    key = None
-    secret = None
-
-    def __init__(self, key, secret):
-        self.key = key
-        self.secret = secret
-
-        if self.key is None or self.secret is None:
-            raise ValueError("Key and secret must be set.")
-
-    def __str__(self):
-        data = {
-            'oauth_consumer_key': self.key,
-            'oauth_consumer_secret': self.secret
-        }
-
-        return urllib.urlencode(data)
-
-
-class Token(object):
-    """An OAuth credential used to request authorization or a protected
-    resource.
- 
-    Tokens in OAuth comprise a *key* and a *secret*. The key is included in
-    requests to identify the token being used, but the secret is used only in
-    the signature, to prove that the requester is who the server gave the
-    token to.
- 
-    When first negotiating the authorization, the consumer asks for a *request
-    token* that the live user authorizes with the service provider. The
-    consumer then exchanges the request token for an *access token* that can
-    be used to access protected resources.
-    """
-
-    key = None
-    secret = None
-    callback = None
-    callback_confirmed = None
-    verifier = None
-
-    def __init__(self, key, secret):
-        self.key = key
-        self.secret = secret
-
-        if self.key is None or self.secret is None:
-            raise ValueError("Key and secret must be set.")
-
-    def set_callback(self, callback):
-        self.callback = callback
-        self.callback_confirmed = 'true'
-
-    def set_verifier(self, verifier=None):
-        if verifier is not None:
-            self.verifier = verifier
-        else:
-            self.verifier = generate_verifier()
-
-    def get_callback_url(self):
-        if self.callback and self.verifier:
-            # Append the oauth_verifier.
-            parts = urlparse.urlparse(self.callback)
-            scheme, netloc, path, params, query, fragment = parts[:6]
-            if query:
-                query = '%s&oauth_verifier=%s' % (query, self.verifier)
-            else:
-                query = 'oauth_verifier=%s' % self.verifier
-            return urlparse.urlunparse((scheme, netloc, path, params,
-                query, fragment))
-        return self.callback
-
-    def to_string(self):
-        """Returns this token as a plain string, suitable for storage.
- 
-        The resulting string includes the token's secret, so you should never
-        send or store this string where a third party can read it.
-        """
-
-        data = {
-            'oauth_token': self.key,
-            'oauth_token_secret': self.secret,
-        }
-
-        if self.callback_confirmed is not None:
-            data['oauth_callback_confirmed'] = self.callback_confirmed
-        return urllib.urlencode(data)
- 
-    @staticmethod
-    def from_string(s):
-        """Deserializes a token from a string like one returned by
-        `to_string()`."""
-
-        if not len(s):
-            raise ValueError("Invalid parameter string.")
-
-        params = parse_qs(s, keep_blank_values=False)
-        if not len(params):
-            raise ValueError("Invalid parameter string.")
-
-        try:
-            key = params['oauth_token'][0]
-        except Exception:
-            raise ValueError("'oauth_token' not found in OAuth request.")
-
-        try:
-            secret = params['oauth_token_secret'][0]
-        except Exception:
-            raise ValueError("'oauth_token_secret' not found in " 
-                "OAuth request.")
-
-        token = Token(key, secret)
-        try:
-            token.callback_confirmed = params['oauth_callback_confirmed'][0]
-        except KeyError:
-            pass # 1.0, no callback confirmed.
-        return token
-
-    def __str__(self):
-        return self.to_string()
-
-
-def setter(attr):
-    name = attr.__name__
- 
-    def getter(self):
-        try:
-            return self.__dict__[name]
-        except KeyError:
-            raise AttributeError(name)
- 
-    def deleter(self):
-        del self.__dict__[name]
- 
-    return property(getter, attr, deleter)
-
-
-class Request(dict):
- 
-    """The parameters and information for an HTTP request, suitable for
-    authorizing with OAuth credentials.
- 
-    When a consumer wants to access a service's protected resources, it does
-    so using a signed HTTP request identifying itself (the consumer) with its
-    key, and providing an access token authorized by the end user to access
-    those resources.
- 
-    """
- 
-    http_method = HTTP_METHOD
-    http_url = None
-    version = VERSION
- 
-    def __init__(self, method=HTTP_METHOD, url=None, parameters=None):
-        if method is not None:
-            self.method = method
- 
-        if url is not None:
-            self.url = url
- 
-        if parameters is not None:
-            self.update(parameters)
- 
-    @setter
-    def url(self, value):
-        parts = urlparse.urlparse(value)
-        scheme, netloc, path = parts[:3]
-
-        # Exclude default port numbers.
-        if scheme == 'http' and netloc[-3:] == ':80':
-            netloc = netloc[:-3]
-        elif scheme == 'https' and netloc[-4:] == ':443':
-            netloc = netloc[:-4]
-
-        if scheme != 'http' and scheme != 'https':
-            raise ValueError("Unsupported URL %s (%s)." % (value, scheme))
-
-        value = '%s://%s%s' % (scheme, netloc, path)
-        self.__dict__['url'] = value
- 
-    @setter
-    def method(self, value):
-        self.__dict__['method'] = value.upper()
- 
-    def _get_timestamp_nonce(self):
-        return self['oauth_timestamp'], self['oauth_nonce']
- 
-    def get_nonoauth_parameters(self):
-        """Get any non-OAuth parameters."""
-        return dict([(k, v) for k, v in self.iteritems() 
-                    if not k.startswith('oauth_')])
- 
-    def to_header(self, realm=''):
-        """Serialize as a header for an HTTPAuth request."""
-        oauth_params = ((k, v) for k, v in self.items() 
-                            if k.startswith('oauth_'))
-        stringy_params = ((k, escape(str(v))) for k, v in oauth_params)
-        header_params = ('%s="%s"' % (k, v) for k, v in stringy_params)
-        params_header = ', '.join(header_params)
- 
-        auth_header = 'OAuth realm="%s"' % realm
-        if params_header:
-            auth_header = "%s, %s" % (auth_header, params_header)
- 
-        return {'Authorization': auth_header}
- 
-    def to_postdata(self):
-        """Serialize as post data for a POST request."""
-        # tell urlencode to deal with sequence values and map them correctly
-        # to resulting querystring. for example self["k"] = ["v1", "v2"] will
-        # result in 'k=v1&k=v2' and not k=%5B%27v1%27%2C+%27v2%27%5D
-        return urllib.urlencode(self, True)
- 
-    def to_url(self):
-        """Serialize as a URL for a GET request."""
-        return '%s?%s' % (self.url, self.to_postdata())
-
-    def get_parameter(self, parameter):
-        ret = self.get(parameter)
-        if ret is None:
-            raise Error('Parameter not found: %s' % parameter)
-
-        return ret
- 
-    def get_normalized_parameters(self):
-        """Return a string that contains the parameters that must be signed."""
-        # 1.0a/9.1.1 states that kvp must be sorted by key, then by value
-        items = [(k, v if type(v) != ListType else sorted(v)) for k,v in sorted(self.items()) if k != 'oauth_signature']
-        encoded_str = urllib.urlencode(items, True)
-        # Encode signature parameters per Oauth Core 1.0 protocol
-        # spec draft 7, section 3.6
-        # (http://tools.ietf.org/html/draft-hammer-oauth-07#section-3.6)
-        # Spaces must be encoded with "%20" instead of "+"
-        return encoded_str.replace('+', '%20')
- 
-    def sign_request(self, signature_method, consumer, token):
-        """Set the signature parameter to the result of sign."""
-
-        if 'oauth_consumer_key' not in self:
-            self['oauth_consumer_key'] = consumer.key
-
-        if token and 'oauth_token' not in self:
-            self['oauth_token'] = token.key
-
-        self['oauth_signature_method'] = signature_method.name
-        self['oauth_signature'] = signature_method.sign(self, consumer, token)
- 
-    @classmethod
-    def make_timestamp(cls):
-        """Get seconds since epoch (UTC)."""
-        return str(int(time.time()))
- 
-    @classmethod
-    def make_nonce(cls):
-        """Generate pseudorandom number."""
-        return str(random.randint(0, 100000000))
- 
-    @classmethod
-    def from_request(cls, http_method, http_url, headers=None, parameters=None,
-            query_string=None):
-        """Combines multiple parameter sources."""
-        if parameters is None:
-            parameters = {}
- 
-        # Headers
-        if headers and 'Authorization' in headers:
-            auth_header = headers['Authorization']
-            # Check that the authorization header is OAuth.
-            if auth_header[:6] == 'OAuth ':
-                auth_header = auth_header[6:]
-                try:
-                    # Get the parameters from the header.
-                    header_params = cls._split_header(auth_header)
-                    parameters.update(header_params)
-                except:
-                    raise Error('Unable to parse OAuth parameters from '
-                        'Authorization header.')
- 
-        # GET or POST query string.
-        if query_string:
-            query_params = cls._split_url_string(query_string)
-            parameters.update(query_params)
- 
-        # URL parameters.
-        param_str = urlparse.urlparse(http_url)[4] # query
-        url_params = cls._split_url_string(param_str)
-        parameters.update(url_params)
- 
-        if parameters:
-            return cls(http_method, http_url, parameters)
- 
-        return None
- 
-    @classmethod
-    def from_consumer_and_token(cls, consumer, token=None,
-            http_method=HTTP_METHOD, http_url=None, parameters=None):
-        if not parameters:
-            parameters = {}
- 
-        defaults = {
-            'oauth_consumer_key': consumer.key,
-            'oauth_timestamp': cls.make_timestamp(),
-            'oauth_nonce': cls.make_nonce(),
-            'oauth_version': cls.version,
-        }
- 
-        defaults.update(parameters)
-        parameters = defaults
- 
-        if token:
-            parameters['oauth_token'] = token.key
-            if token.verifier:
-                parameters['oauth_verifier'] = token.verifier
- 
-        return Request(http_method, http_url, parameters)
- 
-    @classmethod
-    def from_token_and_callback(cls, token, callback=None, 
-        http_method=HTTP_METHOD, http_url=None, parameters=None):
-
-        if not parameters:
-            parameters = {}
- 
-        parameters['oauth_token'] = token.key
- 
-        if callback:
-            parameters['oauth_callback'] = callback
- 
-        return cls(http_method, http_url, parameters)
- 
-    @staticmethod
-    def _split_header(header):
-        """Turn Authorization: header into parameters."""
-        params = {}
-        parts = header.split(',')
-        for param in parts:
-            # Ignore realm parameter.
-            if param.find('realm') > -1:
-                continue
-            # Remove whitespace.
-            param = param.strip()
-            # Split key-value.
-            param_parts = param.split('=', 1)
-            # Remove quotes and unescape the value.
-            params[param_parts[0]] = urllib.unquote(param_parts[1].strip('\"'))
-        return params
- 
-    @staticmethod
-    def _split_url_string(param_str):
-        """Turn URL string into parameters."""
-        parameters = parse_qs(param_str, keep_blank_values=False)
-        for k, v in parameters.iteritems():
-            parameters[k] = urllib.unquote(v[0])
-        return parameters
-
-
-class Server(object):
-    """A skeletal implementation of a service provider, providing protected
-    resources to requests from authorized consumers.
- 
-    This class implements the logic to check requests for authorization. You
-    can use it with your web server or web framework to protect certain
-    resources with OAuth.
-    """
-
-    timestamp_threshold = 300 # In seconds, five minutes.
-    version = VERSION
-    signature_methods = None
-
-    def __init__(self, signature_methods=None):
-        self.signature_methods = signature_methods or {}
-
-    def add_signature_method(self, signature_method):
-        self.signature_methods[signature_method.name] = signature_method
-        return self.signature_methods
-
-    def verify_request(self, request, consumer, token):
-        """Verifies an api call and checks all the parameters."""
-
-        version = self._get_version(request)
-        self._check_signature(request, consumer, token)
-        parameters = request.get_nonoauth_parameters()
-        return parameters
-
-    def build_authenticate_header(self, realm=''):
-        """Optional support for the authenticate header."""
-        return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
-
-    def _get_version(self, request):
-        """Verify the correct version request for this server."""
-        try:
-            version = request.get_parameter('oauth_version')
-        except:
-            version = VERSION
-
-        if version and version != self.version:
-            raise Error('OAuth version %s not supported.' % str(version))
-
-        return version
-
-    def _get_signature_method(self, request):
-        """Figure out the signature with some defaults."""
-        try:
-            signature_method = request.get_parameter('oauth_signature_method')
-        except:
-            signature_method = SIGNATURE_METHOD
-
-        try:
-            # Get the signature method object.
-            signature_method = self.signature_methods[signature_method]
-        except:
-            signature_method_names = ', '.join(self.signature_methods.keys())
-            raise Error('Signature method %s not supported try one of the following: %s' % (signature_method, signature_method_names))
-
-        return signature_method
-
-    def _get_verifier(self, request):
-        return request.get_parameter('oauth_verifier')
-
-    def _check_signature(self, request, consumer, token):
-        timestamp, nonce = request._get_timestamp_nonce()
-        self._check_timestamp(timestamp)
-        signature_method = self._get_signature_method(request)
-
-        try:
-            signature = request.get_parameter('oauth_signature')
-        except:
-            raise MissingSignature('Missing oauth_signature.')
-
-        # Validate the signature.
-        valid = signature_method.check(request, consumer, token, signature)
-
-        if not valid:
-            key, base = signature_method.signing_base(request, consumer, token)
-
-            raise Error('Invalid signature. Expected signature base ' 
-                'string: %s' % base)
-
-        built = signature_method.sign(request, consumer, token)
-
-    def _check_timestamp(self, timestamp):
-        """Verify that timestamp is recentish."""
-        timestamp = int(timestamp)
-        now = int(time.time())
-        lapsed = now - timestamp
-        if lapsed > self.timestamp_threshold:
-            raise Error('Expired timestamp: given %d and now %s has a '
-                'greater difference than threshold %d' % (timestamp, now, self.timestamp_threshold))
-
-
-class Client(httplib2.Http):
-    """OAuthClient is a worker to attempt to execute a request."""
-
-    def __init__(self, consumer, token=None, cache=None, timeout=None,
-        proxy_info=None):
-
-        if consumer is not None and not isinstance(consumer, Consumer):
-            raise ValueError("Invalid consumer.")
-
-        if token is not None and not isinstance(token, Token):
-            raise ValueError("Invalid token.")
-
-        self.consumer = consumer
-        self.token = token
-        self.method = SignatureMethod_HMAC_SHA1()
-
-        httplib2.Http.__init__(self, cache=cache, timeout=timeout, 
-            proxy_info=proxy_info)
-
-    def set_signature_method(self, method):
-        if not isinstance(method, SignatureMethod):
-            raise ValueError("Invalid signature method.")
-
-        self.method = method
-
-    def request(self, uri, method="GET", body=None, headers=None, 
-        redirections=httplib2.DEFAULT_MAX_REDIRECTS, connection_type=None):
-        
-        if not isinstance(headers, dict):
-            headers = {}
-
-        if body and method == "POST":
-            parameters = dict(parse_qsl(body))
-        elif method == "GET":
-            parsed = urlparse.urlparse(uri)
-            parameters = parse_qsl(parsed.query)
-        else:
-            parameters = None
-
-        req = Request.from_consumer_and_token(self.consumer, token=self.token,
-            http_method=method, http_url=uri, parameters=parameters)
-
-        req.sign_request(self.method, self.consumer, self.token)
-
-        if method == "POST":
-            body = req.to_postdata() 
-            headers['Content-Type'] = 'application/x-www-form-urlencoded'
-        elif method == "GET":
-            uri = req.to_url()
-        else:
-            headers.update(req.to_header())
-
-        return httplib2.Http.request(self, uri, method=method, body=body, 
-            headers=headers, redirections=redirections, 
-            connection_type=connection_type)
-
-
-class SignatureMethod(object):
-    """A way of signing requests.
- 
-    The OAuth protocol lets consumers and service providers pick a way to sign
-    requests. This interface shows the methods expected by the other `oauth`
-    modules for signing requests. Subclass it and implement its methods to
-    provide a new way to sign requests.
-    """
-
-    def signing_base(self, request, consumer, token):
-        """Calculates the string that needs to be signed.
-
-        This method returns a 2-tuple containing the starting key for the
-        signing and the message to be signed. The latter may be used in error
-        messages to help clients debug their software.
-
-        """
-        raise NotImplementedError
-
-    def sign(self, request, consumer, token):
-        """Returns the signature for the given request, based on the consumer
-        and token also provided.
-
-        You should use your implementation of `signing_base()` to build the
-        message to sign. Otherwise it may be less useful for debugging.
-
-        """
-        raise NotImplementedError
-
-    def check(self, request, consumer, token, signature):
-        """Returns whether the given signature is the correct signature for
-        the given consumer and token signing the given request."""
-        built = self.sign(request, consumer, token)
-        return built == signature
-
-
-class SignatureMethod_HMAC_SHA1(SignatureMethod):
-    name = 'HMAC-SHA1'
-        
-    def signing_base(self, request, consumer, token):
-        sig = (
-            escape(request.method),
-            escape(request.url),
-            escape(request.get_normalized_parameters()),
-        )
-
-        key = '%s&' % escape(consumer.secret)
-        if token:
-            key += escape(token.secret)
-        raw = '&'.join(sig)
-        return key, raw
-
-    def sign(self, request, consumer, token):
-        """Builds the base signature string."""
-        key, raw = self.signing_base(request, consumer, token)
-
-        # HMAC object.
-        try:
-            import hashlib # 2.5
-            hashed = hmac.new(key, raw, hashlib.sha1)
-        except ImportError:
-            import sha # Deprecated
-            hashed = hmac.new(key, raw, sha)
-
-        # Calculate the digest base 64.
-        return binascii.b2a_base64(hashed.digest())[:-1]
-
-class SignatureMethod_PLAINTEXT(SignatureMethod):
-
-    name = 'PLAINTEXT'
-
-    def signing_base(self, request, consumer, token):
-        """Concatenates the consumer key and secret with the token's
-        secret."""
-        sig = '%s&' % escape(consumer.secret)
-        if token:
-            sig = sig + escape(token.secret)
-        return sig, sig
-
-    def sign(self, request, consumer, token):
-        key, raw = self.signing_base(request, consumer, token)
-        return raw
-

File oauthclient/utils.py

 from django.shortcuts import redirect
 from django.core.urlresolvers import reverse
 
+from models import Token, OAuthServer
+
+def get_token_field(identifier, field):
+    return getattr(Token.objects.get(identifier=identifier), field)
+
+def get_server_field(identifier, field):
+    return getattr(Token.objects.get(identifier=identifier).server, field) 
+
 def oauth_need_authentication(request, force=False):
     """Authenticate user using oauth flow, if the an authentication does not
     already exists.