def promote_user(self, from_jid, nick):
ji_ref = api.actor_lookup_im(api.ROOT, from_jid.base())
if jid_ref:
# TODO(tyler): Should we tell the user who they are?
raise exception.ValidationError(
"You already have an account and are signed in.")
if not NICK_RE.match(nick):
raise exception.ValidationError(
"Invalid screen name, can only use letters or numbers, 3 to 16 "
"characters")
# Create the user. (user_create will check to see if the account has
# already been created.)
password = util.generate_uuid()[:8]
# TODO(termie): Must have a first/last name. :(
actor = api.user_create(api.ROOT,
nick=nick,
password=password,
given_name=nick,
family_name=nick)
# link this im account to the user's account (equivalent of SIGN IN)
self.sign_in(from_jid, nick, password)
# Inform the user of their new password
welcome = '\n'.join([
HELP_WELCOME_NICK % nick, HELP_PASSWORD % password, HELP_POST,
HELP_CHANNEL_POST, HELP_COMMENT, HELP_FOLLOW, HELP_STOP, HELP_MORE,
HELP_FOOTER
])
self.send_message([from_jid], welcome)
def promote_user(self, from_jid, nick):
ji_ref = api.actor_lookup_im(api.ROOT, from_jid.base())
if jid_ref:
# TODO(tyler): Should we tell the user who they are?
raise exception.ValidationError(
"You already have an account and are signed in.")
if not NICK_RE.match(nick):
raise exception.ValidationError(
"Invalid screen name, can only use letters or numbers, 3 to 16 "
"characters")
# Create the user. (user_create will check to see if the account has
# already been created.)
password = util.generate_uuid()[:8]
# TODO(termie): Must have a first/last name. :(
actor = api.user_create(api.ROOT, nick=nick, password=password,
given_name=nick, family_name=nick)
# link this im account to the user's account (equivalent of SIGN IN)
self.sign_in(from_jid, nick, password)
# Inform the user of their new password
welcome = '\n'.join([HELP_WELCOME_NICK % nick,
HELP_PASSWORD % password,
HELP_POST,
HELP_CHANNEL_POST,
HELP_COMMENT,
HELP_FOLLOW,
HELP_STOP,
HELP_MORE,
HELP_FOOTER])
self.send_message([from_jid], welcome)
def generate_user_auth_token(nick,
password,
timeout=(14 * 24 * 60 * 60)):
""" Generates a user authentication token and stores it in the
database for later retrieval.
Why store tokens in the database? Because GAE flushes memcache quite
aggressively and this was causing users to be logged out much more
frequently than was acceptable.
"""
# Clear cache of expired tokens
purge_expired_user_auth_token_keys()
token = util.hash_generic(util.generate_uuid())
key = generate_user_auth_token_key(nick, token)
# Set an expiration date to enable us to purge old, inactive
# sessions from the database. Cookie expiration dates are what
# actually govern how long sessions last.
expire_date = (api.utcnow() +
datetime.timedelta(seconds=timeout))
session = Session(key_name=key,
session_data=db.Blob(password.encode("utf-8")),
expire_date=expire_date)
session.put()
return token
def save(self, commit=True):
self.cleaned_data["username"] = self.cleaned_data["username"].lower()
user = super(RegisterForm, self).save(commit=False)
user.code = util.generate_uuid()
user.set_password(self.cleaned_data["password1"])
if commit:
user.save()
return user
def __init__(self, *args, **kw):
if not 'uuid' in kw or not kw['uuid']:
kw['uuid'] = util.generate_uuid()
if not 'key_name' in kw and 'key' not in kw:
kw['key_name'] = self.key_from(**kw)
super(BaseModel, self).__init__(*args, **kw)
self.app_label = self.applabel()
def login_login(request):
redirect_to = request.REQUEST.get('redirect_to', '/')
redirect_to = clean.redirect_to(redirect_to)
if request.POST:
try:
login = request.POST.get('log', None)
password = request.POST.get('pwd', None)
rememberme = request.POST.get('rememberme', None)
# TODO validate
current_user = user.lookup_user_by_login(login, password)
if current_user:
if redirect_to == '/':
redirect_to = current_user.url('/overview')
# Attempt to do some cleanup on the user if necessary
api.user_cleanup(api.ROOT, current_user.nick)
# if we aren't hosted or aren't ssl just set the cookie and go home
if (not settings.HOSTED_DOMAIN_ENABLED
or not settings.SSL_LOGIN_ENABLED):
response = http.HttpResponseRedirect(redirect_to)
response = user.set_user_cookie(response, current_user,
rememberme)
return response
# otherwise, we're going to have to redirect to set the cookie on
# the proper domain
sso_token = util.generate_uuid()
cache.set('sso/%s' % sso_token,
(current_user.nick, rememberme),
timeout=10)
sso_url = 'http://%s/login/noreally' % (settings.DOMAIN)
sso_url = util.qsa(sso_url, {
'redirect_to': redirect_to,
'sso_token': sso_token
})
return http.HttpResponseRedirect(sso_url)
else:
raise exception.ValidationError("Invalid username or password")
except:
exception.handle_exception(request)
if request.user:
if redirect_to == '/':
redirect_to = request.user.url('/overview')
return http.HttpResponseRedirect(redirect_to)
c = template.RequestContext(request, locals())
t = loader.get_template('login/templates/login.html')
return http.HttpResponse(t.render(c))
def create_blob(cls, name='', content=None, content_type=None, user=None):
params = {
'name':name,
'slug':unicode(slugify(name)),
'uuid':util.generate_uuid(),
'user':user.username,
'content':content,
'content_type': content_type,
#'privacy': user.privacy
}
blob_ref = cls(**params)
blob_ref.put()
return blob_ref
def login_login(request):
redirect_to = request.REQUEST.get('redirect_to', '/')
redirect_to = clean.redirect_to(redirect_to)
if request.POST:
try:
login = request.POST.get('log', None)
password = request.POST.get('pwd', None)
rememberme = request.POST.get('rememberme', None)
# TODO validate
current_user = user.lookup_user_by_login(login, password)
if current_user:
if redirect_to == '/':
redirect_to = current_user.url('/overview')
# Attempt to do some cleanup on the user if necessary
api.user_cleanup(api.ROOT, current_user.nick)
# if we aren't hosted or aren't ssl just set the cookie and go home
if (not settings.HOSTED_DOMAIN_ENABLED
or not settings.SSL_LOGIN_ENABLED):
response = http.HttpResponseRedirect(redirect_to)
response = user.set_user_cookie(response, current_user, rememberme)
return response
# otherwise, we're going to have to redirect to set the cookie on
# the proper domain
sso_token = util.generate_uuid()
cache.set('sso/%s' % sso_token, (current_user.nick, rememberme), timeout=10)
sso_url = 'http://%s/login/noreally' % (settings.DOMAIN)
sso_url = util.qsa(
sso_url, {'redirect_to': redirect_to, 'sso_token': sso_token})
return http.HttpResponseRedirect(sso_url)
else:
raise exception.ValidationError("Invalid username or password")
except:
exception.handle_exception(request)
view =user.get_user_from_cookie_or_legacy_auth(request)
area="login"
if view:
if redirect_to == '/':
redirect_to = request.user.url('/overview')
return http.HttpResponseRedirect(redirect_to)
c = template.RequestContext(request, locals())
t = loader.get_template('login/templates/login.html')
return http.HttpResponse(t.render(c))
def save(self):
super(InstallForm, self).save()
params = {"username":self.cleaned_data["username"].lower(),
"first_name":self.cleaned_data["first_name"],
"last_name":self.cleaned_data["last_name"],
"email":self.cleaned_data["email"],
"active":True,
"superuser":True,
"roles":['authenticated', 'administrator']}
user = User(**params)
user.code = util.generate_uuid()
user.set_password(self.cleaned_data["password1"])
user.save()
ConfigData.set_configdata('ADMIN_USERNAME', user.username)
return user
class CleanImageTest(CleanTest):
good_data = [
'%s/bg_%s.jpg' % ('*****@*****.**', '012340'),
'%s/bg_%s.jpg' % ('*****@*****.**', '0123af'),
# How about a deterministic test:
'%s/bg_%s.jpg' % ('*****@*****.**', util.generate_uuid()),
None
]
bad_data = [
'%s/bg_%s.jpg' % ('popu@[email protected]', '012340'),
'%s/bg_%s.jpg' % ('*****@*****.**', '0123afx'),
]
normalize_data = [(x, x) for x in good_data]
cleaner = staticmethod(clean.bg_image)
def create_thumbails(cls, name, content, content_type, username='******', sizes={}):
_name = _name = util.generate_uuid()[:6] + name
blob_ref = cls.create_blob(_name, content, content_type, username)
thumbails = {}
for size, dimensions in sizes.iteritems():
image = images.Image(blob_ref.content)
original_width, original_height = float(image.width), float(image.height)
width, height = dimensions
f_width, f_height = float(width), float(height)
if original_width > original_height:
right_x = (f_width * original_height)/(f_height * original_width)
bottom_y = 1.0
if right_x > 1.0:
bottom_y = 1.0 / right_x
right_x = 1.0
else:
right_x = 1.0
bottom_y = (f_height * original_width)/(f_width * original_height)
if bottom_y > 1.0:
right_x = 1.0 / bottom_y
bottom_y = 1.0
image.crop(0.0, 0.0, right_x, bottom_y)
image.resize(width, height)
img_content = image.execute_transforms(images.JPEG)
thumbail_name = "thumbail_%s_%s" % (blob_ref.name, size)
cls.create_blob(name=thumbail_name,
content=img_content,
content_type=content_type,
username=username)
thumbails[size] = reverse('blob_serve', args=[thumbail_name])
return thumbails
def save(self):
if self.instance is None:
params = {'uuid':util.generate_uuid()}
self.cleaned_data.update(params)
return super(BaseForm, self).save()
def generate_user_auth_token(nick, password, timeout=(14 * 24 * 60 * 60)):
token = util.hash_generic(util.generate_uuid())
cache.set("user_auth_token/%s/%s" % (nick, token), password, timeout)
return token
def create_blob_from_file(cls, file, user, **kwargs):
_name = util.generate_uuid()[:6] + kwargs.pop('filename', file.name)
return cls.create_blob(name=_name,
content=file.read(),
content_type=file.content_type,
user=user)
def save(self): self.user.set_password(self.cleaned_data["password1"]) self.user.code = util.generate_uuid() self.user.put()
def send_instructions(self): self.user.code = util.generate_uuid() self.user.put() mail_password_instructions(self.user, self.user.code)
def generate_user_auth_token(nick, password, timeout=(14 * 24 * 60 * 60)):
token = util.hash_generic(util.generate_uuid())
cache.set("user_auth_token/%s/%s" % (nick, token), password, timeout)
return token
def save(self):
logging.info("***** Form save")
self.user.set_password(self.cleaned_data["password1"])
self.user.code = util.generate_uuid()
logging.info(" * code: %s" % self.user.code)
self.user.put()
