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 login(cls, username, pw):
"""
Returns a user instance if user and password match
"""
u = cls.by_name(username)
if u and utils.valid_pw(username, pw, u.pw_hash):
return u
def login(cls, username, password):
"""
Returns a user instance if user and password match
"""
user = cls.by_name(username)
if user and utils.valid_pw(username, password, user.password):
return user
def post(self):
user_uname = self.request.get('username')
user_psswrd = self.request.get('password')
valid_pwd = False
valid_user = False
#Get user and check password.
q = mydb.single_user_by_name(user_uname)
if not (q is None):
valid_user = True
valid_pwd = utils.valid_pw(user_uname, user_psswrd,
q.password_hash)
if valid_pwd and valid_user:
# Set cookie and redirect.
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(q.key.id())), str(redir)))
self.redirect(str(redir))
else:
self.render_login(uname=cgi.escape(user_uname),
login_err="Invalid username or password")
def post(self):
username = self.request.get('username')
password = self.request.get('password')
userError = ''
passwordError = ''
invalidError = ''
user_id = ''
if not username:
userError = USERNAME_ER
if not password:
passwordError = PASSWORD_ER
if not(userError or passwordError):
u = User.by_name(username)
if not (u and utils.valid_pw(username, password, u.password)):
invalidError = INVALID_ER
else:
user_id = str(u.key().id())
if(userError or passwordError or invalidError):
self.render('login.html', username=username,
usernameError=userError,
passwordError=passwordError,
invalidError=invalidError)
else:
id_string = user_id
cookieHsh = utils.make_secure_val(id_string)
self.response.headers.add_header('Set-Cookie', 'user_id=%s; Path=/' %
cookieHsh)
self.redirect('/')
def login(cls, username, pw):
"""
Returns a user instance if user and password match
"""
u = cls.by_name(username)
if u and utils.valid_pw(username, pw, u.pw_hash):
return u
def run(connection, privmsg):
# Split up the text from privmsg.post_command_text into a list so that it can be addressed one word at a time.
# However, if there is no chan argument, raise ValueError exception to be handled in privmsg.
msg = privmsg.post_command_text.split()
try:
input_chan = msg[0]
except IndexError:
raise ValueError
if utils.valid_chan(connection, privmsg, input_chan):
pass
else:
return
# Now to grab the password... potentially. Basically the same shit as with grabbing the chan earlier.
try:
pw = msg[1]
except IndexError:
pw = ""
# Prep password for insertion into the SQL database. If it's blank (no password) convert to NULL string for SQL.
if pw == "":
pw = "NULL"
# Parse for invalid chars. If False is returned (invalid)
else:
if utils.valid_pw(connection, privmsg, pw):
pass
else:
return
# With that out of the way, now that we have both chan and the password, let's connect to the database.
con = lite.connect(os.path.join(connection.homedir, "inumuta.db"))
with con:
cur = con.cursor()
# First we have to check to see whether or not the channel already exists in the database. If it doesn't already
# exist in the db (returns None), we can continue on.
cur.execute("SELECT Name FROM Chans WHERE Name=:ChanName", {"ChanName": input_chan})
con.commit()
# Get the contents of the search. Assuming there's not a horrifying error, there should only be
# only one entry of a chan.
row = cur.fetchone()
if row == None:
cur.execute("INSERT INTO Chans VALUES(:ChanName,:Password)", {"ChanName": input_chan, "Password": pw})
# Convert back to non-SQL none-value
if pw == "NULL":
pw = ""
else:
pass
# Call joinChan() function to actually send the join command to the channel.
connection.join_channel(input_chan, pw)
# If it's already there, send message back to original channel (message loc 2) that is already on ajoin.
else:
connection.send_msg(privmsg.chan, "Channel already added to auto-join list.")
return
def login(cls, username, password):
"""
Returns a user instance if user and password match
"""
user = cls.by_name(username)
if user and utils.valid_pw(username, password, user.password):
return user
def post(self):
username = self.request.get('username')
password = self.request.get('password')
userError = ''
passwordError = ''
invalidError = ''
user_id = ''
if not username:
userError = USERNAME_ER
if not password:
passwordError = PASSWORD_ER
if not (userError or passwordError):
u = User.by_name(username)
if not (u and utils.valid_pw(username, password, u.password)):
invalidError = INVALID_ER
else:
user_id = str(u.key().id())
if (userError or passwordError or invalidError):
self.render('login.html',
username=username,
usernameError=userError,
passwordError=passwordError,
invalidError=invalidError)
else:
id_string = user_id
cookieHsh = utils.make_secure_val(id_string)
self.response.headers.add_header('Set-Cookie',
'user_id=%s; Path=/' % cookieHsh)
self.redirect('/')
def post(self):
username = self.request.get('username')
password = self.request.get('password')
logging.info("User: %s", username)
user = model.User.by_name(username)
if user and utils.valid_pw(username, password, user.password_hash):
logging.info("User Valid %s", user.name)
self.set_secure_cookie('user_id',str(user.key().id()))
self.redirect("/")
else:
self.render('login.html',username = username,error = 'Invalid login')
def post(self):
username = self.request.get('username')
password = self.request.get('password')
logging.info("User: %s", username)
user = model.User.by_name(username)
if user and utils.valid_pw(username, password, user.password_hash):
logging.info("User Valid %s", user.name)
self.set_secure_cookie('user_id', str(user.key().id()))
self.redirect("/")
else:
self.render('login.html', username=username, error='Invalid login')
def login(cls, username, password):
'''
check that data provided for logging in is correct
and return user if exists
'''
if username is None or password is None:
return None
user = cls.get_by_username(username)
if user and valid_pw(username, password, user.pw_hash):
return user
return None
def post(self):
username = self.request.get('username')
password = self.request.get('password')
u = User.query(User.username == username).get()
if u and utils.valid_pw(username, password, u.pw_hash):
user_id = u.key.id()
self.set_secure_cookie('user_id', str(user_id))
self.redirect('/user/%s' % username)
else:
error = "Invalid login."
self.template('login.html', username=username, other_error=error)
def post(self):
user_name = self.request.get('username')
user_password = self.request.get('password')
# Look up user
u = models.get_user_by_name(user_name)
if not u or not utils.valid_pw(user_name, user_password, u.password):
error = "Invalid login"
self.render_login(user_name, error)
else:
user_id = u.key().id()
uid_cookie = str(self.put_user_id_cookie(user_id, u.password))
self.response.headers.add_header("Set-Cookie", "user_id=%s; Path=/"%uid_cookie)
self.redirect("/")
def post(self):
username = self.request.get('username')
password = self.request.get('password')
#next_url = str(self.request.get('next_url'))
#if not next_url or next_url.startswith('/login'):
#next_url = '/blog'
user = db.GqlQuery("SELECT * FROM User WHERE name = :1", username).get()
if user and utils.valid_pw(username, password, user.password):
self.login(user)
self.redirect('/wiki')
else:
self.render("login.html", error=True)
def POST(self):
data_in = web.input()
user = Users.userByName(data_in.username)
if user:
result = utils.valid_pw(data_in.username, data_in.password, user.pw)
if result:
self.login(user)
self.user = user
raise web.seeother('/')
else:
return views.render.base(views.Users.login(),user=self.user)
else:
return views.render.base(views.Users.login(),user=self.user)
return views.render.base(views.Users.login(),user=self.user)
def post(self):
user_name = self.request.get('username')
user_password = self.request.get('password')
# Look up user
u = models.get_user_by_name(user_name)
if not u or not utils.valid_pw(user_name, user_password, u.password):
error = "Invalid login"
self.render_login(user_name, error)
else:
user_id = u.key().id()
uid_cookie = str(self.put_user_id_cookie(user_id, u.password))
self.response.headers.add_header("Set-Cookie",
"user_id=%s; Path=/" % uid_cookie)
self.redirect("/showqu")
def post(self):
username = self.request.get("username")
password = self.request.get("password")
if not username or not password or hasSpace(username) or hasSpace(password):
self.render("login.html", username=username, password=password, loginError="Invalid login 1.")
else:
user = User.by_name(username)
if not user: # user doesn't exist
self.render("login.html", username=username, password=password, loginError="Invalid login 2. (User doesn't exist)")
elif not valid_pw(username, password, user.salt, user.password_hash):
self.render("login.html", username=username, password=password, loginError="Invalid login 3. (Invalid password)")
else:
# Login successful
self.set_cookie("user_id", user.key().id())
self.redirect("/")
def post(self):
username = self.request.get('username')
password = self.request.get('password')
q = User.all()
q.filter("username ="******"login.html", invalid_login="******")
return
user = q.get()
if not utils.valid_pw(username, password, user.password_hash):
self.render("login.html", invalid_login="******")
return
else:
self.response.headers.add_header('Set-Cookie', 'uname=%s;Path=/' % str(username))
self.redirect("/")
def post(self):
login_input_username = self.request.get("username")
login_input_pw = self.request.get("password")
u = User.all().filter('username =', login_input_username).get()
if u:
hashed_pw = u.hashed_pw
if u4.valid_pw(login_input_username, login_input_pw, hashed_pw):
self.login(username=str(login_input_username), secret=secret)
self.redirect("/welcome")
else:
loginerror = "Invalid username and password combination."
self.write_form(loginerror=loginerror, username=login_input_username)
else:
loginerror = "Username does not exist in database."
self.write_form(loginerror=loginerror)
def post(self):
login_input_username = self.request.get("username")
login_input_pw = self.request.get("password")
u = User.all().filter('username =', login_input_username).get()
if u:
hashed_pw = u.hashed_pw
if u4.valid_pw(login_input_username, login_input_pw, hashed_pw):
self.login(username=str(login_input_username), secret=secret)
self.redirect("/welcome")
else:
loginerror = "Invalid username and password combination."
self.write_form(loginerror=loginerror,
username=login_input_username)
else:
loginerror = "Username does not exist in database."
self.write_form(loginerror=loginerror)
def post(self):
# Get user input
username = self.request.get('username')
password = self.request.get('password')
# Check if user is in database
u = User.by_name(username)
if u and utils.valid_pw(username, password, u.hashed_pw):
# Process a valid input
# 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:
# error
error_msg = "Invalid username or password"
self.render('login.html', error_msg=error_msg)
def post(self, redirect_url="/"):
user_username = self.request.get("username")
user_password = self.request.get("password")
res = db.Query(User).filter("username ="******"Invalid Login"
self.render_login(error=err)
else:
password = res.password
salt = res.salt
verify = password +"|"+salt
if utils.valid_pw(user_username, user_password, verify):
setUser = "******" + user_username+"; Path=/"
self.response.headers.add_header('Set-Cookie', setUser.encode())
self.redirect(redirect_url)
else:
err="Invalid Login"
self.render_login(error=err)
def post(self):
username = self.request.get("username")
password = self.request.get("password")
error = False
if not utils.valid_username(username):
error = True
else:
user_data = db.GqlQuery("SELECT * FROM User WHERE username = '******'" %
username).get()
if not user_data:
error = True
elif not utils.valid_pw(username, password, user_data.hashed_pw):
error = True
if (error):
self.render("Week4/login.html", username=username, error="Invalid login")
else:
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):
user_uname = self.request.get('username')
user_psswrd = self.request.get('password')
print user_uname
valid_pwd = False
valid_user = False
q = mydb.single_user_by_name(user_uname)
print q
if not(q is None):
valid_user = True
valid_pwd = utils.valid_pw(user_uname, user_psswrd, q.password_hash)
if valid_pwd and valid_user:
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(q.key().id())), str(redir)))
self.redirect(str(redir))
else:
self.render_login(uname=cgi.escape(user_uname), login_err="Invalid username or password")
def run(connection, privmsg):
# Set the channame to the first word after the command string.
msg = privmsg.post_command_text.split()
try:
input_chan = msg[0]
except IndexError:
raise ValueError
# Now we make sure there aren't any invalid characters in our chan var :3
if not utils.valid_chan(connection, privmsg, input_chan):
return
# Now to grab the password! It'll be in position 1 if there is one.
try:
pw = msg[1]
except IndexError:
pw = ""
if not utils.valid_pw(connection, privmsg, pw):
return
# Call joinChan() function to actually send the join command to the channel.
connection.join_channel(input_chan, pw)
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 login(cls, name, pw):
u = cls.by_name(name)
if u and valid_pw(name, pw, u.code) and u.valid == "True":
return u
def login(cls, name, pw): user = cls.by_name(name) if user and utils.valid_pw(name, pw, user.password): return user
def login(cls, name, pw):
u = cls.by_name(name)
if u and valid_pw(name, pw, u.code) and u.valid == "True":
return u
def login(cls, username, pw):
u = cls.by_name(username)
if u and valid_pw(username, pw, u.password):
return u
def login(cls, name, pw):
user = cls.userByName(name)
if user and utils.valid_pw(name, pw, user.password):
return user
else:
return None
def login(cls, username, password):
u = cls.by_name(username)
if u and utils.valid_pw(username, password, u.pw_hash):
return u
def login(cls,name,pw):
u = cls.by_name(name)
if u and utils.valid_pw(name,pw,u.pw_hash):
return u
def login(cls, email, pw):
u = cls.by_email(email)
if u:
name = u.name
if u and utils.valid_pw(name, pw, u.pw_hash):
return u
def login(cls, email, pw):
u = cls.by_email(email)
if u:
email = u.email
if u and utils.valid_pw(email, pw, u.pw_hash):
return u
def login(cls, name, password):
user = cls.by_name(name)
if user and valid_pw(name, password, user.password_hash):
return user
def login(cls, name, pw):
user = cls.by_name(name)
if user and valid_pw(name, pw, user.pw_hash):
return user
def login(cls, name, pw):
u = cls.by_name(name)
if u and utils.valid_pw(name, pw, u.pw_hash):
return u
