def register(self): if app_globals.sandbox_mode: default_roles = ["user", "admin"] else: default_roles = ["user"] errors, values = {}, None if request.method == 'POST': try: schema = Register() values = request.params account = schema.deserialize(values) exists = model.Account.find_one({"name": account['name']}) if exists: raise colander.Invalid( Register.name, _("Login name already exists, please choose a " "different one")) if not account['password1'] == account['password2']: raise colander.Invalid(Register.password1, _("Passwords \ don't match!")) password = account['password1'] account['password_hash'] = \ generate_password_hash(password) del account['password1'] del account['password2'] account['_roles'] = default_roles model.Account.c.insert(account) who_api = get_api(request.environ) authenticated, headers = who_api.login( {"login": account['name'], "password": password}) response.headers.extend(headers) return redirect("/") except colander.Invalid, i: errors = i.asdict()
def register(self): require.account.create() errors, values = {}, None if request.method == 'POST': try: schema = AccountRegister() values = request.params data = schema.deserialize(values) if Account.by_name(data['name']): raise colander.Invalid( AccountRegister.name, _("Login name already exists, please choose a " "different one")) if not data['password1'] == data['password2']: raise colander.Invalid(AccountRegister.password1, _("Passwords \ don't match!")) account = Account() account.name = data['name'] account.fullname = data['fullname'] account.email = data['email'] account.password = generate_password_hash(data['password1']) db.session.add(account) db.session.commit() who_api = get_api(request.environ) authenticated, headers = who_api.login({ "login": account.name, "password": data['password1'] }) response.headers.extend(headers) return redirect("/") except colander.Invalid, i: errors = i.asdict()
def register(self): require.account.create() self._disable_cache() errors, values = {}, None if request.method == 'POST': try: schema = AccountRegister() values = request.params data = schema.deserialize(values) if Account.by_name(data['name']): raise colander.Invalid( AccountRegister.name, _("Login name already exists, please choose a " "different one")) if not data['password1'] == data['password2']: raise colander.Invalid(AccountRegister.password1, _("Passwords don't match!")) account = Account() account.name = data['name'] account.fullname = data['fullname'] account.email = data['email'] account.password = generate_password_hash(data['password1']) db.session.add(account) db.session.commit() who_api = get_api(request.environ) authenticated, headers = who_api.login({ "login": account.name, "password": data['password1'] }) response.headers.extend(headers) return redirect("/") except colander.Invalid, i: errors = i.asdict()
def register(self): require.account.create() c.config = config self._disable_cache() errors, values = {}, None if request.method == 'POST': try: schema = AccountRegister() values = request.params data = schema.deserialize(values) if Account.by_name(data['name']): raise colander.Invalid( AccountRegister.name, _("Login name already exists, please choose a " "different one")) if not data['password1'] == data['password2']: raise colander.Invalid(AccountRegister.password1, _("Passwords don't match!")) account = Account() account.name = data['name'] account.fullname = data['fullname'] account.email = data['email'] account.password = generate_password_hash(data['password1']) db.session.add(account) db.session.commit() who_api = get_api(request.environ) authenticated, headers = who_api.login({ "login": account.name, "password": data['password1'] }) errors = subscribe_lists(('community', 'developer'), data) if errors: h.flash_notice( _("Subscription to the following mailing " + "lists probably failed: %s.") % ', '.join(errors)) response.headers.extend(headers) return redirect("/") except colander.Invalid, i: errors = i.asdict()
def settings(self): errors, values = {}, c.account if request.method == 'POST': try: schema = Settings() values = request.params data = schema.deserialize(values) if not data['password1'] == data['password2']: raise colander.Invalid(Register.password1, _("Passwords don't match!")) if len(data['password1']): password = data['password1'] data['password_hash'] = generate_password_hash(password) del data['password1'] del data['password2'] account.update(c.account, {"$set": data}) h.flash_success(_("Your settings have been updated.")) except colander.Invalid, i: errors = i.asdict()
def settings(self): require.account.update(c.account) errors, values = {}, c.account if request.method == 'POST': try: schema = AccountSettings() values = request.params data = schema.deserialize(values) if not data['password1'] == data['password2']: raise colander.Invalid(AccountSettings.password1, _("Passwords don't match!")) c.account.fullname = data['fullname'] c.account.email = data['email'] if data['password1'] is not None and len(data['password1']): c.account.password = generate_password_hash(data['password1']) db.session.add(c.account) db.session.commit() h.flash_success(_("Your settings have been updated.")) except colander.Invalid, i: errors = i.asdict()
def register(self): require.account.create() c.config = config self._disable_cache() errors, values = {}, None if request.method == 'POST': try: schema = AccountRegister() values = request.params data = schema.deserialize(values) if Account.by_name(data['name']): raise colander.Invalid( AccountRegister.name, _("Login name already exists, please choose a " "different one")) if not data['password1'] == data['password2']: raise colander.Invalid(AccountRegister.password1, _("Passwords don't match!")) account = Account() account.name = data['name'] account.fullname = data['fullname'] account.email = data['email'] account.password = generate_password_hash(data['password1']) db.session.add(account) db.session.commit() who_api = get_api(request.environ) authenticated, headers = who_api.login({ "login": account.name, "password": data['password1'] }) errors = subscribe_lists(('community', 'developer'), data) if errors: h.flash_notice(_("Subscription to the following mailing " + "lists probably failed: %s.") % ', '.join(errors)) response.headers.extend(headers) return redirect("/") except colander.Invalid, i: errors = i.asdict()
def settings(self): require.account.update(c.account) errors, values = {}, c.account if request.method == 'POST': try: schema = AccountSettings() values = request.params data = schema.deserialize(values) if not data['password1'] == data['password2']: raise colander.Invalid(AccountSettings.password1, _("Passwords don't match!")) c.account.fullname = data['fullname'] c.account.email = data['email'] if data['password1'] is not None and len(data['password1']): c.account.password = generate_password_hash( data['password1']) db.session.add(c.account) db.session.commit() h.flash_success(_("Your settings have been updated.")) except colander.Invalid, i: errors = i.asdict()
def register(self): """ Perform registration of a new user """ # We must allow account creation require.account.create() # We add the config as a context variable in case anything happens # (like with login we need this to allow subscriptions to mailing lists) c.config = config # Disable the cache (don't want anything getting in the way) self._disable_cache() # Initial values and errors errors, values = {}, None # If this is a POST operation somebody is trying to register if request.method == 'POST': try: # Get the account register schema (for validation) schema = AccountRegister() # Set values from the request parameters # (for validation and so we can autofill forms) values = request.params # Grab the actual data and validate it data = schema.deserialize(values) # Check if the username already exists, return an error if so if Account.by_name(data['name']): raise colander.Invalid( AccountRegister.name, _("Login name already exists, please choose a " "different one")) # Check if passwords match, return error if not if not data['password1'] == data['password2']: raise colander.Invalid(AccountRegister.password1, _("Passwords don't match!")) # Create the account account = Account() # Set username and full name account.name = data['name'] account.fullname = data['fullname'] # Set email and if email address should be public account.email = data['email'] account.public_email = data['public_email'] # Hash the password and store the hash account.password = generate_password_hash(data['password1']) # Commit the new user account to the database db.session.add(account) db.session.commit() # Perform a login for the user who_api = get_api(request.environ) authenticated, headers = who_api.login({ "login": account.name, "password": data['password1'] }) # Add the login headers response.headers.extend(headers) # Subscribe the user to the mailing lists errors = subscribe_lists(('community', 'developer'), data) # Notify if the mailing list subscriptions failed if errors: h.flash_notice(_("Subscription to the following mailing " + "lists probably failed: %s.") % ', '.join(errors)) # Registration successful - Redirect to the front page return redirect("/") except colander.Invalid, i: # Mark colander errors errors = i.asdict()
def settings(self): """ Change settings for the logged in user """ # The logged in user must be able to update the account require.account.update(c.account) # Disable the cache self._disable_cache() # Initial values and errors errors, values = {}, c.account # If POST the user is trying to update the settings if request.method == 'POST': try: # Get the account settings schema (for validation) schema = AccountSettings() # Set values from the request parameters # (for validation and so we can autofill forms) values = request.params # Grab the actual data and validate it data = schema.deserialize(values) # If the passwords don't match we notify the user if not data['password1'] == data['password2']: raise colander.Invalid(AccountSettings.password1, _("Passwords don't match!")) # Update full name c.account.fullname = data['fullname'] # Update the script root c.account.script_root = data['script_root'] # Update email and whether email should be public c.account.email = data['email'] c.account.public_email = data['public_email'] # If twitter handle is provided we update it # (and if it should be public) if data['twitter'] is not None: c.account.twitter_handle = data['twitter'].lstrip('@') c.account.public_twitter = data['public_twitter'] # If a new password was provided we update it as well if data['password1'] is not None and len(data['password1']): c.account.password = generate_password_hash(data['password1']) # Do the actual update in the database db.session.add(c.account) db.session.commit() # Let the user know we've updated successfully h.flash_success(_("Your settings have been updated.")) except colander.Invalid, i: # Load errors if we get here errors = i.asdict()
def register(self): """ Perform registration of a new user """ # We must allow account creation require.account.create() # We add the config as a context variable in case anything happens # (like with login we need this for subscriptions to mailing lists) c.config = config # Disable the cache (don't want anything getting in the way) self._disable_cache() # Initial values and errors errors, values = {}, None # If this is a POST operation somebody is trying to register if request.method == 'POST': try: # Get the account register schema (for validation) schema = AccountRegister() # Set values from the request parameters # (for validation and so we can autofill forms) values = request.params # Grab the actual data and validate it data = schema.deserialize(values) # Check if the username already exists, return an error if so if Account.by_name(data['name']): raise colander.Invalid( AccountRegister.name, _("Login name already exists, please choose a " "different one")) # Check if passwords match, return error if not if not data['password1'] == data['password2']: raise colander.Invalid(AccountRegister.password1, _("Passwords don't match!")) # Create the account account = Account() # Set username and full name account.name = data['name'] account.fullname = data['fullname'] # Set email and if email address should be public account.email = data['email'] account.public_email = data['public_email'] # Hash the password and store the hash account.password = generate_password_hash(data['password1']) # Commit the new user account to the database db.session.add(account) db.session.commit() # Perform a login for the user who_api = get_api(request.environ) authenticated, headers = who_api.login({ "login": account.name, "password": data['password1'] }) # Add the login headers response.headers.extend(headers) # Subscribe the user to the mailing lists errors = subscribe_lists(('community', 'developer'), data) # Notify if the mailing list subscriptions failed if errors: h.flash_notice( _("Subscription to the following mailing " + "lists probably failed: %s.") % ', '.join(errors)) # Registration successful - Redirect to the front page return redirect("/") except colander.Invalid as i: # Mark colander errors errors = i.asdict() # Show the templates (with possible errors and form values) return templating.render('account/login.html', form_fill=values, form_errors=errors)
def settings(self): """ Change settings for the logged in user """ # The logged in user must be able to update the account require.account.update(c.account) # Disable the cache self._disable_cache() # Initial values and errors errors, values = {}, c.account # If POST the user is trying to update the settings if request.method == 'POST': try: # Get the account settings schema (for validation) schema = AccountSettings() # Set values from the request parameters # (for validation and so we can autofill forms) values = request.params # Grab the actual data and validate it data = schema.deserialize(values) # If the passwords don't match we notify the user if not data['password1'] == data['password2']: raise colander.Invalid(AccountSettings.password1, _("Passwords don't match!")) # Update full name c.account.fullname = data['fullname'] # Update the script root c.account.script_root = data['script_root'] # Update email and whether email should be public c.account.email = data['email'] c.account.public_email = data['public_email'] # If twitter handle is provided we update it # (and if it should be public) if data['twitter'] is not None: c.account.twitter_handle = data['twitter'].lstrip('@') c.account.public_twitter = data['public_twitter'] # If a new password was provided we update it as well if data['password1'] is not None and len(data['password1']): c.account.password = generate_password_hash( data['password1']) # Do the actual update in the database db.session.add(c.account) db.session.commit() # Let the user know we've updated successfully h.flash_success(_("Your settings have been updated.")) except colander.Invalid as i: # Load errors if we get here errors = i.asdict() else: # Get the account values to autofill the form values = c.account.as_dict() # We need to put public checks separately because they're not # a part of the dictionary representation of the account if c.account.public_email: values['public_email'] = c.account.public_email if c.account.public_twitter: values['public_twitter'] = c.account.public_twitter # Return the rendered template return templating.render('account/settings.html', form_fill=values, form_errors=errors)