def post(self): input_username = self.request.get("username") input_password = self.request.get("password") input_verify = self.request.get("verify") input_email = self.request.get("email") valid_username = u4.valid_username(input_username) valid_password = u4.valid_password(input_password) valid_verify = u4.valid_verify(input_password, input_verify) valid_email = u4.valid_email(input_email) errors = ["", "", "", ""] if not valid_username: errors[0] = "That's not a valid username." if not valid_password: errors[1] = "That wasn't a valid password." if not valid_verify: errors[2] = "Your passwords didn't match." if not valid_email and input_email != "": errors[3] = "That's not a valid email." if errors != ["", "", "", ""]: self.write_form(errors, input_username, "", "", input_email) else: user_existence = User.all().filter('username =', input_username).get() if user_existence: errors[0] = "That user already exists." self.write_form(errors, input_username, "", "", input_email) else: hashed_pw = u4.make_pw_hash(str(input_username), str(input_password)) u= User(username=str(input_username), hashed_pw=hashed_pw, email=str(input_email)) u.put() self.login(username=str(input_username), secret=secret) self.redirect("/welcome")
def post(self): globals.init() username = self.request.get('username') pw = self.request.get('password') error = '' data = db.GqlQuery("select * from Users order by user_name") for entry in data: user_name = entry.user_name user_pass = entry.user_pass if user_name == username: check = utils.valid_pw(username,pw,user_pass) if check: user_id = str(entry.key().id()) user_pass_string = str(utils.make_pw_hash(username,pw)) self.response.headers.add_header('Set-Cookie', 'user_id=%s|%s;Path=/' % (user_id,user_pass_string)) current_url = self.request.url.split('/')[-1] if current_url == 'login': self.redirect('/wiki/') else: self.redirect('/homework') else: error = 'Sorry Invalid Login, Please try again.' else: error = "Username not found." self.render('login.html', error = error, username = username)
def post(self): #next_url = str(self.request.get('next_url')) #if not next_url or next_url.startswith('/login'): #next_url = '/' username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') valid_user = utils.valid_username(username) valid_pass = utils.valid_password(password) passwords_match = utils.verify_password(password, verify) email_valid = utils.valid_email(email) params = dict(valid_user = valid_user, valid_pass = valid_pass, passwords_match = passwords_match, email_valid = email_valid) errors = set_errors(params) if not errors: user_exists = db.GqlQuery("SELECT * FROM User WHERE name = :1", username).get() if not user_exists: new_user = User(name = username, password = utils.make_pw_hash(username, password), email = email) new_user.put() self.login(new_user) self.redirect('/wiki') # CHANGE THIS!!! else: error_user = "******" self.render("signup.html", error_user = error_user) else: self.render("signup.html", username=username, email=email, **errors)
def register(cls, username, password, email, public): pw_hash = utils.make_pw_hash(username, password) user = User(username = username, pw_hash = pw_hash, email = email, public = public) return user
def post(self): username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') uname_error, pwd_error, pwd_error_match, email_error, uname_exists = '', '', '', '', '' user_re = re.compile(r"^[a-zA-Z0-9_-]{3,20}$") pwd_re = re.compile(r"^.{3,20}$") email_re = re.compile(r"^[\S]+@[\S]+\.[\S]+$") if not user_re.match(username): uname_error = "That's not a valid username." if not pwd_re.match(password): pwd_error = "That wasn't a valid password." elif password != verify: pwd_error_match = "Your passwords didn't match." if email and not email_re.match(email): # email optional email_error = "That's not a valid email." user = User(username=username, password_hash=utils.make_pw_hash(username, password)) q = User.all() q.filter("username ="******"Username exists" if uname_error or pwd_error or pwd_error_match or email_error or uname_exists: self.render("signup.html", username_error=uname_error, password_error=pwd_error, verify_error=pwd_error_match, email_error=email_error, usernam=username, email=email, username_exists=uname_exists) else: user.put() self.response.headers.add_header('Set-Cookie', 'uname=%s;Path=/' % str(username)) self.redirect("/")
def register(cls, name, pw, email, user_ip, valid="True"): code = make_pw_hash(name, pw) return User(parent=users_key(), name=name, code=code, email=email, user_ip=user_ip, valid=valid)
def register(cls, name, pw): pw_hash = utils.make_pw_hash(name,pw) user = Users() user.name = name user.pw = pw_hash user.put() return user
def register(cls, username, password, email = None): ''' make password hash, create instance of class with given parameters ''' pw_hash = make_pw_hash(username, password) return cls(username = username, pw_hash = pw_hash, email = email)
def register(cls, username, password, email=None): """ Registers a user by creating a new user in the Db. Stores the username, password hash and email-id. """ pw_hash = make_pw_hash(password) return cls(username=username, pw_hash=pw_hash, email=email)
def register(cls, name, pw, email = None): """ returns a new user """ pw_hash = utils.make_pw_hash(name, pw) return User(parent = users_key(), username = name, password_hash = pw_hash, email = email)
def post(self): """ POST method for the /signup action. Validates the inputs and redirects the user to the welcome page if validations are ok. If not, render the signup page, keeping the username and email values, and show error messages. """ input_username = self.request.get("username") input_password = self.request.get("password") input_verify = self.request.get("verify") input_email = self.request.get("email") params = dict(username=input_username, email=input_email) valid_username = verify_username(input_username) valid_password = verify_password(input_password) valid_email = verify_email(input_email) match = verify_match(input_password, input_verify) error = False if not valid_username: params["invalid_username"] = "******" error = True else: if User.by_name(input_username): params["invalid_username"] = "******" error = True if not valid_password: params["invalid_password"] = "******" error = True if not match: params["not_match"] = "Your password didn't match." error = True if not valid_email: params["invalid_email"] = "That's not a valid email." error = True if error: self.render("signup.html", **params) else: encrypted_password = utils.make_pw_hash(input_username, input_password) user = User(username=input_username, pw_hash=encrypted_password, email=input_email) user.put() self.set_secure_cookie("user_id", str(user.key().id())) self.redirect("/welcome")
def post(self): user_uname = self.request.get('username') user_psswrd = self.request.get('password') user_ver = self.request.get('verify') user_email = self.request.get('email') uname = utils.valid_uname(user_uname) uname_ex = utils.user_exists(user_uname) psswrd = utils.valid_psswrd(user_psswrd) verified = utils.verify_psswrd(user_psswrd, user_ver) email = utils.valid_email(user_email) #Create error messages if not uname: uname_err = "That's not a valid username!" if uname_ex: uname_err = "This username already exists!" if not psswrd: psswrd_err = "That wasn't a valid password" if not verified: verify_err = "Passwords did not match" if not email: email_err = "That's not a valid email!" if not (uname and not uname_ex and psswrd and verified and (email or user_email == "")): #There was an error in one of the fields. self.render_signup(uname=cgi.escape(user_uname), uname_err=uname_err, psswrd_err=psswrd_err, verify_err=verify_err, email=cgi.escape(user_email), email_err=email_err) else: #Create a new user. password_hash = utils.make_pw_hash(user_uname, user_psswrd) user = mydb.User(username=user_uname, password_hash=password_hash, salt=password_hash.split('|')[1], email=user_email) user.put() mydb.allusers(update=True, newuser=user) print "added new user %s" % user.username #Redirect the user back to entry where they came from. redir = self.request.cookies.get('Location') if not redir: redir = '/' self.response.headers.add_header( 'Set-Cookie', "user_id=%s;Location=%s;Path=/" % (utils.make_secure_val(str(user.key.id())), str(redir))) self.redirect(str(redir))
def post(self): username = self.request.get('username') password = self.request.get('password') firstname = self.request.get('firstname') lastname = self.request.get('lastname') verify = self.request.get('verify') email = self.request.get('email') userError = '' passwordError = '' verifyError = '' emailError = '' if not (username and valid_username(username)): userError = USERNAME_ER if not (password and valid_password(password)): passwordError = PASSWORD_ER if not (verify and (verify == password)): verifyError = VERIFY_ER if not (valid_email(email)): emailError = EMAIL_ER if (userError or passwordError or verifyError or emailError): self.render('user-signup.html', username=username, firstname=firstname, lastname=lastname, email=email, usernameError=userError, passwordError=passwordError, verifyError=verifyError, emailError=emailError) else: pw_hash = utils.make_pw_hash(username, password) if pw_hash: u = User(username=username, password=pw_hash, firstname=firstname, lastname=lastname, email=email) u.put() id_string = str(u.key().id()) cookieHsh = utils.make_secure_val(id_string) self.response.headers.add_header( 'Set-Cookie', 'user_id=%s; Path=/' % cookieHsh) self.redirect('/') else: self.render('user-signup.html', username=username, email=email, usernameError=userError, passwordError=passwordError, verifyError=verifyError, emailError=emailError)
def post(self): name = self.request.get('name') email = self.request.get('email') password = self.request.get('password') verify_password = self.request.get('verify_password') key = self.request.get('key') error = False error_name = "" error_password = "" error_email = "" error_verify = "" if not utils.valid_username(name): error_name="Your username needs to be between 3 and 20 characters long and only contain numbers and letters" error = True if not utils.valid_password(password): error_password="******" error = True if not utils.valid_email(email): error_email="Please type in a valid email address" error = True if password != verify_password: error_verify="Please ensure your passwords match" error = True if key != "Nicholas001": error_key="Please provide the correct key" error = True if not error: pw_hash = utils.make_pw_hash(name, password) user = model.User(parent=model.users_key(), name=name, email=email, pw_hash=pw_hash) user.put() self.login(user) self.redirect('/fileupload') else: js_code = "$('#register').modal('show');" data = { 'error_name':error_name, 'error_password':error_password, 'error_email':error_email, 'error_verify':error_verify, 'error_key':error_key, 'js_code':js_code } self.render('register.html', data=data) """
def post(self): # Get user input username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') # Process results input_error = False user_error = "" passwd_error = "" verify_error = "" email_error = "" if not utils.valid_username(username): user_error = "That's not a valid username" input_error = True if not utils.valid_password(password): passwd_error = "That wasn't a valid password" input_error = True elif password != verify: verify_error = "Your passwords didn't match" input_error = True if not utils.valid_email(email): email_error = "That's not a valid email" input_error = True # Check if this user is already in our registry if not input_error and User.by_name(username): user_error = "The user already exists" input_error = True if not input_error: # Create user entry in database hashed_pw = utils.make_pw_hash(username, password) u = User(name=username, hashed_pw=hashed_pw, email=email) u.put() # Set cookie to user_id uid = u.key().id() user_id = utils.make_secure_cookie(str(uid)) self.response.headers.add_header('Set-Cookie', 'user_id=%s; Path=/' % user_id) # Redirect to welcome page self.redirect('/blog/welcome') else: self.render('signup.html', username=username, email=email, user_error=user_error, passwd_error=passwd_error, verify_error=verify_error, email_error=email_error)
def post(self): username = self.request.get('username') password = self.request.get('password') firstname = self.request.get('firstname') lastname = self.request.get('lastname') verify = self.request.get('verify') email = self.request.get('email') userError = '' passwordError = '' verifyError = '' emailError = '' if not(username and valid_username(username)): userError = USERNAME_ER if not (password and valid_password(password)): passwordError = PASSWORD_ER if not (verify and (verify == password)): verifyError = VERIFY_ER if not (valid_email(email)): emailError = EMAIL_ER if(userError or passwordError or verifyError or emailError): self.render('user-signup.html', username=username, firstname=firstname, lastname=lastname, email=email, usernameError=userError, passwordError=passwordError, verifyError=verifyError, emailError=emailError) else: pw_hash = utils.make_pw_hash(username, password) if pw_hash: u = User(username=username, password=pw_hash, firstname=firstname, lastname=lastname, email=email) u.put() id_string = str(u.key().id()) cookieHsh = utils.make_secure_val(id_string) self.response.headers.add_header('Set-Cookie', 'user_id=%s; Path=/' % cookieHsh) self.redirect('/') else: self.render('user-signup.html', username=username, email=email, usernameError=userError, passwordError=passwordError, verifyError=verifyError, emailError=emailError)
def post(self): user_name = self.request.get('username') user_password = self.request.get('password') user_verify = self.request.get('verify') user_email = self.request.get('email') name = utils.valid_username(user_name) password = utils.valid_password(user_password) verify = utils.valid_verify(user_verify, user_password) email = utils.valid_email(user_email) nameerror = passworderror = verifyerror = emailerror = "" if not name: nameerror = "That's not a valid username" if not password: passworderror = "That's not a valid password" if password and not verify: verifyerror = "Your passwords didn't match" if user_email and not email: emailerror = "That's not a valid email" if (not (name and password and verify)) or (user_email and not email): self.render_signup(user_name, nameerror, passworderror, verifyerror, user_email, emailerror) else: # lookup user u = User.gql("WHERE username = '******'" % user_name).get() # If user already exists if u: nameerror = "That user already exists" self.render_signup(user_name, nameerror, passworderror, verifyerror, user_email, emailerror) else: # make salted password hash h = utils.make_pw_hash(user_name, user_password) u = User(username=user_name, password=h) u.put() user_id = u.key().id() uid_cookie = str(self.put_user_id_cookie(user_id, h)) self.response.headers.add_header( "Set-Cookie", "user_id=%s; Path=/" % uid_cookie) self.redirect("/")
def post(self): user_username = self.request.get("username") user_password = self.request.get("password") user_verify = self.request.get("verify") user_email = self.request.get("email") uname = user_username email = user_email uname_err = utils.check_username(user_username) pw_err="" vpw_err="" email_err="" Success= True if uname_err != "": Success= False if utils.check_password(user_password)==False: pw_err="That's not a valid password." Success= False if utils.verify_password(user_password, user_verify)==False: vpw_err="Your passwords didn't match." Success= False if len(email) != 0: if utils.check_email(user_email)==False: email_err="That's not a valid email." Success= False if Success: x = utils.make_pw_hash(uname, user_password) saltedPass = x.split("|")[0] salt = x.split("|")[1] if len(email) != 0: newUser = User(key_name = uname, username = uname, email=email, password = saltedPass, salt = salt) else: newUser = User(key_name = uname, username = uname, password = saltedPass, salt = salt) newUser.put() setUser = "******" + uname self.response.headers.add_header('Set-Cookie', setUser.encode()) self.redirect("/") else: self.render_signup(uname, email,uname_err, pw_err, vpw_err,email_err)
def post(self): user_name = self.request.get('username') user_password = self.request.get('password') user_verify = self.request.get('verify') user_email = self.request.get('email') name = utils.valid_username(user_name) password = utils.valid_password(user_password) verify = utils.valid_verify(user_verify, user_password) email = utils.valid_email(user_email) nameerror = passworderror = verifyerror = emailerror = "" if not name: nameerror = "That's not a valid username" if not password: passworderror = "That's not a valid password" if password and not verify: verifyerror = "Your passwords didn't match" if user_email and not email: emailerror = "That's not a valid email" if (not (name and password and verify)) or (user_email and not email): self.render_signup(user_name, nameerror, passworderror, verifyerror, user_email, emailerror) else: # lookup user u = User.gql("WHERE username = '******'"%user_name).get() # If user already exists if u: nameerror = "That user already exists" self.render_signup(user_name, nameerror, passworderror, verifyerror, user_email, emailerror) else: # make salted password hash h = utils.make_pw_hash(user_name, user_password) u = User(username=user_name, password=h) u.put() user_id = u.key().id() uid_cookie = str(self.put_user_id_cookie(user_id, h)) self.response.headers.add_header("Set-Cookie", "user_id=%s; Path=/"%uid_cookie) self.redirect("/")
def post(self): oldPassword = self.request.get('oldPassword') newPassword = self.request.get('newPassword') verifyPassword = self.request.get('verifyPassword') u = self.user if User.login(self.user.name, oldPassword): if newPassword == verifyPassword: u.pw_hash = utils.make_pw_hash(self.user.name, newPassword) u.put() self.redirect('/vitejte') else: self.response.headers['Content-Type'] = 'text/plain' self.response.write('Hesla se neshodují.') else: self.response.headers['Content-Type'] = 'text/plain' self.response.write('Not logged')
def POST(self,uid): if self.user: ins = web.input() errors = {} if utils.validate_pw(ins.pw, ins.confirmpw): errors['nomatch'] u = models.Users.userById(uid) if errors == {} and u: u.pw = utils.make_pw_hash(u.username, ins.pw) u.put() cache.set('Users',u.id, u.dump()) raise web.seeother('/admin/users/_edit/%s'%uid) else: raise web.seeother('/') raise web.seeother('/admin/users')
def post(self): username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') error = utils.validation(username, password, verify, email) if error: self.template('signup.html', other_error=error, username=username, email=email) else: if User.query(User.username==username).get(): error = "Sorry, this username already exists" self.template('signup.html', other_error=error, username=username, email=email) else: h = utils.make_pw_hash(username, password) u = User(parent=user_key(), username=username, pw_hash=h, email=email) new_user_id = u.put().id() # put() returns the models Key, put().id() returns the entities id self.set_secure_cookie('user_id', str(new_user_id)) logging.error("NEW USER WITH ID " + str(new_user_id) + " CREATED") self.redirect('/user/%s' % username)
def post(self): user_uname = self.request.get('username') user_psswrd = self.request.get('password') user_ver = self.request.get('verify') user_email = self.request.get('email') uname = utils.valid_uname(user_uname) uname_ex = utils.user_exists(user_uname) psswrd = utils.valid_psswrd(user_psswrd) verified = utils.verify_psswrd(user_psswrd, user_ver) email = utils.valid_email(user_email) # this will store the values to be returned ret = {"uname":cgi.escape(user_uname), "uname_err":"", "psswrd_err":"", "verify_err":"", "email":cgi.escape(user_email), "email_err":""} if not uname: ret["uname_err"] = "That's not a valid username!" if uname_ex: ret["uname_err"] = "This username already exists!" if not psswrd: ret["psswrd_err"] = "That wasn't a valid password" if not verified: ret["verify_err"] = "Passwords did not match" if not email: ret["email_err"] = "That's not a valid email!" if not(uname and not uname_ex and psswrd and verified and (email or user_email == "")): self.render_signup(uname=ret["uname"], uname_err=ret["uname_err"], psswrd_err=ret["psswrd_err"], verify_err=ret["verify_err"], email=ret["email"], email_err=ret["email_err"]) else: password_hash = utils.make_pw_hash(user_uname, user_psswrd) user = mydb.User(username=user_uname, password_hash=password_hash, salt=password_hash.split('|')[1], email=user_email) user.put() print "added new user %s" % user.username mydb.allusers(True, user) redir = self.request.cookies.get('Location') #time.sleep(1) if not redir: redir = '/' self.response.headers.add_header('Set-Cookie', "user_id=%s;Location=%s;Path=/" % (utils.make_secure_val(str(user.key().id())), str(redir))) print redir self.redirect(str(redir))
def post(self): input_username = self.request.get("username") input_password = self.request.get("password") input_verify = self.request.get("verify") input_email = self.request.get("email") valid_username = u4.valid_username(input_username) valid_password = u4.valid_password(input_password) valid_verify = u4.valid_verify(input_password, input_verify) valid_email = u4.valid_email(input_email) errors = ["", "", "", ""] if not valid_username: errors[0] = "That's not a valid username." if not valid_password: errors[1] = "That wasn't a valid password." if not valid_verify: errors[2] = "Your passwords didn't match." if not valid_email and input_email != "": errors[3] = "That's not a valid email." if errors != ["", "", "", ""]: self.write_form(errors, input_username, "", "", input_email) else: user_existence = User.all().filter('username =', input_username).get() if user_existence: errors[0] = "That user already exists." self.write_form(errors, input_username, "", "", input_email) else: hashed_pw = u4.make_pw_hash(str(input_username), str(input_password)) u = User(username=str(input_username), hashed_pw=hashed_pw, email=str(input_email)) u.put() self.login(username=str(input_username), secret=secret) self.redirect("/welcome")
def post(self): username = self.request.get("username") password = self.request.get("password") verifyPassword = self.request.get("verifyPassword") email = self.request.get("email") errors = {} errorKeys = ["uError", "pError", "pvError", "eError"] for errorKey in errorKeys: errors[errorKey] = "" success = True if not username or hasSpace(username): errors["uError"] = "Enter a valid username." success = False if not password or hasSpace(password): errors["pError"] = "Enter a valid password." success = False if not verifyPassword or password != verifyPassword: errors["pvError"] = "Passwords must match." success = False if email and not validEmail(email): errors["eError"] = "Invalid email." success = False if User.user_already_exists(username): errors["uError"] = "User already exists." success = False if success: salt = make_salt() password_hash = make_pw_hash(username, password, salt) user = User(username=username, password_hash=password_hash, salt=salt, email=email) user.put() self.set_cookie("user_id", user.key().id()) self.redirect("/") else: self.render("signup.html", username=username, password=password, verifyPassword=verifyPassword, email=email, **errors)
def post(self): username = self.request.get("username") password = self.request.get("password") verify = self.request.get("verify") email = self.request.get("email") username_error = "" password_error = "" verify_error = "" email_error = "" if not utils.valid_username(username): username_error = "That's not a valid username." elif db.GqlQuery("SELECT * FROM User WHERE username = '******'" % username).count() != 0: username_error = "Username already exists." if utils.valid_password(password): if not password == verify: verify_error = "Your passwords didn't match." else: password_error = "That wasn't a valid password." if not utils.valid_email(email): email_error = "That's not a valid email." if (username_error != "" or password_error != "" or verify_error != "" or email_error != ""): self.write_form([username, username_error], password_error, verify_error, [email, email_error]) else: user = models.User(username=username, hashed_pw=utils.make_pw_hash(username, password), email=email) user.put() self.response.headers.add_header('Set-Cookie', str('user-id=%s; Path=/' % utils.make_secure_val(utils.SECRET, username))) self.redirect("/blog/welcome")
def post(self): error_username = '' error_password = '' error_verify = '' error_email='' username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') if (valid_user(username) and valid_password(password) and valid_verify(verify,password)) and ((valid_email(email) or email=='')): user1 = db.GqlQuery('SELECT * FROM User WHERE username = :1', username)# see if username already exists user2 = db.GqlQuery('SELECT * FROM User WHERE email = :1', email)# see if email already exists if not (user1.get() and user2.get()): new_user = User(username = username, password = make_pw_hash(username, password), email = email) new_user.put() user_id = new_user.key().id() self.response.headers.add_header('Set-Cookie', 'user_id = %s' %user_id)#set cookie self.redirect('/welcome') else: if user1.get(): error_username = '******' if user2.get(): error_email = 'Email already exists!' self.render('signup.html',username=username, password=password, verify=verify, email=email, error_username=error_username, error_password=error_password, error_verify=error_verify, error_email=error_email) else: if not valid_user(username): error_username = "******" if not valid_password(password): error_password = "******" if not valid_verify(verify,password) or not(password and verify): error_verify = "Your passwords didn't match " if not (valid_email(email) or email == ''): error_email = "That's not a valid email!" self.render('signup.html', username=username, password=password, verify=verify, email=email, error_username=error_username, error_password=error_password, error_verify=error_verify, error_email=error_email)
def post(self): if self.request.get('login_email') and self.request.get('login_password'): user_email = self.request.get('login_email') user_psswrd = self.request.get('login_password') print user_email valid_pwd = False valid_email = False q = mydb.User.get_by_email(user_email) if not(q is None): valid_email = True valid_pwd = utils.valid_pw(user_email, user_psswrd, q.password_hash) if valid_pwd and valid_email: self.response.headers.add_header('Set-Cookie', "user_id=%s;Path=/" % utils.make_secure_val(str(q.key().id()))) self.redirect('/hello') else: self.render_signup(email=cgi.escape(user_email), login_err="Invalid username or password. Please sign up or try again.") else: user_email = self.request.get('email') user_psswrd = self.request.get('password') user_first_name = self.request.get('first_name') user_last_name = self.request.get('last_name') user_dob = self.request.get('dob') user_gender = self.request.get('gender') user_occupation = self.request.get('occupation') user_confirmation = self.request.get('confirmation') print user_email print user_psswrd print user_first_name print user_last_name print utils.convert_dob(user_dob) print user_gender print user_occupation print user_confirmation name = utils.valid_name(user_first_name) and utils.valid_name(user_last_name) user_ex = utils.user_exists(user_email) psswrd = utils.valid_psswrd(user_psswrd) email = utils.valid_email(user_email) # this will store the values to be returned #ret = {"uname":cgi.escape(user_uname), "uname_err":"", "psswrd_err":"", "verify_err":"", "email":cgi.escape(user_email), "email_err":""} if not name or user_ex or not psswrd or not email: input_err = "Some input was incorrect. Further details to come soon." if not(name and not user_ex and psswrd and email): self.render_signup(first_name=first_name, login_err=login_err, input_err=input_err, email=email, last_name=last_name, gender=gender, occupation=occupation) else: password_hash = utils.make_pw_hash(user_email, user_psswrd) user = mydb.User(first_name=user_first_name, last_name=user_last_name, dob=utils.convert_dob(user_dob), gender=user_gender, occupation=user_occupation, password_hash=password_hash, salt=password_hash.split('|')[1], email=user_email) user.put() print "added new user %s" % user.email #mydb.allusers(True, user) time.sleep(0.2) self.response.headers.add_header('Set-Cookie', "user_id=%s;Path=/" % utils.make_secure_val(str(user.key().id()))) self.redirect('/hello')
def register(cls, username, password, email=None): password_hash = make_pw_hash(password) return cls(username = username, password_hash = password_hash, email = email)
def signup(cls, username, password, email = None): password_hash = utils.make_pw_hash(username, password) return User(parent = get_users_key(), username = username, password_hash = password_hash, email = email)
def register(cls, username, password, email=None): """ Converts password to hashed password and initiates an instance """ pw_hash = utils.make_pw_hash(username, password) return User(username=username, password=pw_hash, email=email)
def register(cls, username, pw, email=None): pw_hash = make_pw_hash(username, pw) if email: return User(username=username, password=pw_hash, email=email) else: return User(username=username, password=pw_hash)
def save_user(cls, username, password): user = User(name = username,password_hash = utils.make_pw_hash(username,password)) user.put() return user
def register(cls, username, password, email=None): pw_hash = utils.make_pw_hash(username, password) return User(parent=users_key(), username=username, pw_hash=pw_hash, email=email)
def create_new_userdata(new_user): u_user,u_pass,u_verify,u_email = new_user parent_key = ndb.Key('user_parent','parent') user = Users(user_id=u_user,id=u_user,parent=parent_key,password=utils.make_pw_hash(str(u_pass)),email=u_email) user.put() user_cache(update=True)
def register(cls, name, pw, email = None): pw_hash = make_pw_hash(name, pw) return User(parent = users_key(), name = name, pw_hash = pw_hash, email = email)
def save_user(cls, username, password): user = User(name=username, password_hash=utils.make_pw_hash(username, password)) user.put() return user
def register(cls, username, password, email = None): password = make_pw_hash(username, password) return cls(parent = users_key(), username = username, password = password, email = email)
def register(cls, name, pw, email=None): pw_hash = utils.make_pw_hash(name, pw) return User(name=name, pw_hash=pw_hash, email=email)
def register(cls,name,pw,email=None): pw_hash = utils.make_pw_hash(name,pw) return User(name=name,pw_hash=pw_hash,email=email)
def register(cls, name, password, email=None): pw_hash = make_pw_hash(name, password) return User(name = name, password_hash = pw_hash, email = email)
def register(cls, name, pw, email=None): pw_hash = make_pw_hash(name, pw) return cls(parent=users_key(), name=name, pw_hash=pw_hash, email=email)
def post(self): globals.init() current_url = self.request.url.split('/')[-1] if current_url == 'main': globals.main_page = True has_error = False user_input = self.request.get('username') password_input = self.request.get('password') verify_input = self.request.get('verify') email_input = self.request.get('email') valid_u = utils.valid_username(user_input) valid_p = utils.valid_password(password_input) valid_e = utils.valid_email(email_input) user_error = '' pass_error = '' email_error = '' verify_error = '' if not valid_u: user_error = 'Invalid username, please try again.' has_error = True if not valid_p: pass_error = 'Invalid password, please try again.' has_error = True if password_input != verify_input: verify_error = 'Passwords do not match, try again.' has_error = True if not valid_e and email_input != '': email_error = 'Invalid email, please try again.' has_error = True if has_error != False: if not globals.main_page: self.render("register.html",error_user = user_error ,error_pass = pass_error,error_verify = verify_error,error_email = email_error,username = user_input,email = email_input) else: self.render("register_main.html",error_user = user_error ,error_pass = pass_error,error_verify = verify_error,error_email = email_error,username = user_input,email = email_input) else: hash_pass = utils.make_pw_hash(user_input,password_input) user_input = str(user_input) user_taken = False email_taken = False data = db.GqlQuery("select * from Users order by user_name") for entry in data: user = entry.user_name email= entry.user_email if user == user_input: user_taken = True if email == email_input and email != '': email_taken = True if user_taken or email_taken: user_error = 'Sorry, the username you selected is already taken' email_error= 'Sorry, this email is already registered' if user_taken and email_taken: if not globals.main_page: self.render('register.html', error_user = user_error, error_email = email_error) else: self.render('register_main.html', error_user = user_error, error_email = email_error) if user_taken: if not globals.main_page: self.render('register.html', error_user = user_error, email = email_input) else: self.render('register_main.html', error_user = user_error, email = email_input) else: if not globals.main_page: self.render('register.html', error_email = email_error, username = user_input) else: self.render('register_main.html', error_email = email_error, username = user_input) else: new = Users(user_name = user_input, user_pass = hash_pass, user_email = email_input) new.put() self.response.headers.add_header('Set-Cookie', 'user_id=%s|%s; Path=/' % (new.key().id(),hash_pass)) if globals.main_page: self.redirect('/homework') else: self.redirect('/wiki/')