class Token(models.Model):
REQUEST = 1
ACCESS = 2
TOKEN_TYPES = ((REQUEST, u'Request'), (ACCESS, u'Access'))
key = models.CharField(max_length=KEY_SIZE)
secret = models.CharField(max_length=SECRET_SIZE)
token_type = models.IntegerField(choices=TOKEN_TYPES)
timestamp = models.IntegerField()
is_approved = models.BooleanField(default=False)
user = models.ForeignKey(settings.AUTH_USER_MODEL,
null=True,
blank=True,
related_name='tokens')
consumer = models.ForeignKey(Consumer)
objects = TokenManager()
def __unicode__(self):
return u"%s Token %s for %s" % (self.get_token_type_display(),
self.key, self.consumer)
def to_string(self, only_key=False):
token_dict = {
'oauth_token': self.key,
'oauth_token_secret': self.secret
}
if only_key:
del token_dict['oauth_token_secret']
return urllib.urlencode(token_dict)
def generate_random_codes(self):
key = settings.AUTH_USER_MODEL.objects.make_random_password(
length=KEY_SIZE)
secret = settings.AUTH_USER_MODEL.objects.make_random_password(
length=SECRET_SIZE)
while Token.objects.filter(key__exact=key,
secret__exact=secret).count():
secret = settings.AUTH_USER_MODEL.objects.make_random_password(
length=SECRET_SIZE)
self.key = key
self.secret = secret
self.save()
class Token(models.Model):
REQUEST = 1
ACCESS = 2
TOKEN_TYPES = ((REQUEST, u'Request'), (ACCESS, u'Access'))
key = models.CharField(max_length=KEY_SIZE)
secret = models.CharField(max_length=SECRET_SIZE)
verifier = models.CharField(max_length=VERIFIER_SIZE)
token_type = models.IntegerField(choices=TOKEN_TYPES)
timestamp = models.IntegerField(default=timestamp_default)
is_approved = models.BooleanField(default=False)
user = models.ForeignKey(User, null=True, blank=True, related_name='tokens')
consumer = models.ForeignKey(Consumer)
callback = models.CharField(max_length=255, null=True, blank=True)
callback_confirmed = models.BooleanField(default=False)
objects = TokenManager()
def __unicode__(self):
return u"%s Token %s for %s" % (self.get_token_type_display(), self.key, self.consumer)
def to_string(self, only_key=False):
token_dict = {
'oauth_token': self.key,
'oauth_token_secret': self.secret,
'oauth_callback_confirmed': 'true',
}
if self.verifier:
token_dict.update({ 'oauth_verifier': self.verifier })
if only_key:
del token_dict['oauth_token_secret']
return urllib.urlencode(token_dict)
def generate_random_codes(self):
key = User.objects.make_random_password(length=KEY_SIZE)
secret = generate_random(SECRET_SIZE)
while Token.objects.filter(key__exact=key, secret__exact=secret).count():
secret = generate_random(SECRET_SIZE)
self.key = key
self.secret = secret
self.save()
# -- OAuth 1.0a stuff
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 set_callback(self, callback):
if callback != "oob": # out of band, says "we can't do this!"
self.callback = callback
self.callback_confirmed = True
self.save()
class Token(models.Model):
REQUEST = 1
ACCESS = 2
TOKEN_TYPES = ((REQUEST, u'Request'), (ACCESS, u'Access'))
key = models.CharField(max_length=KEY_SIZE, null=True, blank=True)
secret = models.CharField(max_length=SECRET_SIZE, null=True, blank=True)
token_type = models.SmallIntegerField(choices=TOKEN_TYPES)
timestamp = models.IntegerField(default=long(time()))
is_approved = models.BooleanField(default=False)
user = models.ForeignKey(User,
null=True,
blank=True,
related_name='tokens')
consumer = models.ForeignKey(Consumer)
resource = models.ForeignKey(Resource)
## OAuth 1.0a stuff
verifier = models.CharField(max_length=VERIFIER_SIZE)
callback = models.CharField(max_length=MAX_URL_LENGTH,
null=True,
blank=True)
callback_confirmed = models.BooleanField(default=False)
objects = TokenManager()
def __unicode__(self):
return u"%s Token %s for %s" % (self.get_token_type_display(),
self.key, self.consumer)
def to_string(self, only_key=False):
token_dict = {
'oauth_token':
self.key,
'oauth_token_secret':
self.secret,
'oauth_callback_confirmed':
self.callback_confirmed and 'true' or 'error'
}
if self.verifier:
token_dict['oauth_verifier'] = self.verifier
if only_key:
del token_dict['oauth_token_secret']
del token_dict['oauth_callback_confirmed']
return urllib.urlencode(token_dict)
def generate_random_codes(self):
"""
Used to generate random key/secret pairings.
Use this after you've added the other data in place of save().
"""
self.key = uuid.uuid4().hex
self.secret = generate_random(length=SECRET_SIZE)
self.save()
def get_callback_url(self, args=None):
"""
OAuth 1.0a, append the oauth_verifier.
"""
if self.callback and self.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
if args is not None:
query += "&%s" % urllib.urlencode(args)
return urlparse.urlunparse(
(scheme, netloc, path, params, query, fragment))
args = args is not None and "?%s" % urllib.urlencode(args) or ""
return self.callback + args
def set_callback(self, callback):
if callback != OUT_OF_BAND: # out of band, says "we can't do this!"
if check_valid_callback(callback):
self.callback = callback
self.callback_confirmed = True
self.save()
else:
raise oauth.Error('Invalid callback URL.')
class Token(models.Model):
REQUEST = 1
ACCESS = 2
TOKEN_TYPES = ((REQUEST, u'Request'), (ACCESS, u'Access'))
key = models.CharField(max_length=KEY_SIZE, null=True, blank=True)
secret = models.CharField(max_length=SECRET_SIZE, null=True, blank=True)
token_type = models.SmallIntegerField(choices=TOKEN_TYPES)
timestamp = models.IntegerField(default=long(time()))
is_approved = models.BooleanField(default=False)
user = models.ForeignKey(User, null=True, blank=True, related_name='tokens')
consumer = models.ForeignKey(Consumer)
resource = models.ForeignKey(Resource)
## OAuth 1.0a stuff
verifier = models.CharField(max_length=VERIFIER_SIZE)
callback = models.CharField(max_length=MAX_URL_LENGTH, null=True, blank=True)
callback_confirmed = models.BooleanField(default=False)
objects = TokenManager()
def __unicode__(self):
return u"%s Token %s for %s" % (self.get_token_type_display(), self.key, self.consumer)
def to_string(self, only_key=False):
token_dict = {
'oauth_token': self.key,
'oauth_token_secret': self.secret,
'oauth_callback_confirmed': 'true',
}
if self.verifier:
token_dict.update({ 'oauth_verifier': self.verifier })
if only_key:
del token_dict['oauth_token_secret']
del token_dict['oauth_callback_confirmed']
return urllib.urlencode(token_dict)
def generate_random_codes(self):
"""
Used to generate random key/secret pairings.
Use this after you've added the other data in place of save().
"""
key = generate_random(length=KEY_SIZE)
secret = generate_random(length=SECRET_SIZE)
while Token.objects.filter(models.Q(key__exact=key) | models.Q(secret__exact=secret)).count():
key = generate_random(length=KEY_SIZE)
secret = generate_random(length=SECRET_SIZE)
self.key = key
self.secret = secret
self.save()
def get_callback_url(self):
"""
OAuth 1.0a, append the oauth_verifier.
"""
if self.callback and self.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