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, 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, 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/')
