def __init__(self, email='', password='', name=''):
UserMixin.__init__(self)
self.email = email
self.name = name
self.password = password
self.valid = False
self.id = '' # Extra id field for Flask-login requirement
def login():
if request.method == 'POST':
user = request.form.to_dict()
#incomplete data
#incomplete data
errors = {}
user['username'] = user['username'].strip().lower()
if len(user['username']) == 0:
errors['username'] = '******'t be blank'
if len(user['password']) == 0:
errors['password'] = '******'
user_found = db.users.find_one({
'username': user['username'],
'password': user['password']
})
#username or password incorrect
if not user_found:
errors['not_valid'] = 'username or password is not valid'
return render_template('login.html', user=user, errors=errors)
user = UserMixin()
user.username = user_found['username']
user.id = user_found['_id'].__str__()
login_user(user)
g.user = user
return redirect(request.args.get("next") or url_for("index"))
return render_template('login.html', user={'username': '', 'password': ''})
def __init__(self, password=None, **kwargs):
Principal.__init__(self)
UserMixin.__init__(self)
db.Model.__init__(self, **kwargs)
if self.can_login and password is not None:
self.set_password(password)
def login():
if current_user.is_authenticated:
return redirect('/')
try:
if request.method == 'POST':
email = request.form['email']
password = request.form['password']
if not (email and password):
error="Empty field detected"
return render_template('login.html',error=error)
cursor=g.conn.execute("SELECT password FROM Users WHERE email='%s'"%email)
real=''
for result in cursor:
real=result['password']
cursor.close()
if real==password:
cur_user = UserMixin()
cur_user.id=email
login_user(cur_user)
print("login successfully")
#_next=request.args.get('next')
#print(_next)
#if not next_is_valid(_next):
# return abort(400)
return redirect('/')
else:
error="Email and password don't match"
return render_template('login.html',error=error)
else:
return render_template('login.html')
except:
return redirect('/login')
def user_loader(login):
db_manager = DbManager.Manager()
if db_manager.get_user(login) is None:
return
user = UserMixin()
user.id = login
return user
def __init__(self, password=None, **kwargs):
Principal.__init__(self)
UserMixin.__init__(self)
db.Model.__init__(self, **kwargs)
if self.can_login and password is not None:
self.set_password(password)
def login():
if request.method == 'POST':
user = request.form.to_dict()
#incomplete data
#incomplete data
errors = {}
user['username'] = user['username'].strip().lower()
if len(user['username']) == 0:
errors['username'] = '******'t be blank'
if len(user['password']) == 0:
errors['password'] = '******'
user_found = db.users.find_one({'username':user['username'], 'password':user['password']})
#username or password incorrect
if not user_found:
errors['not_valid'] = 'username or password is not valid'
return render_template('login.html', user = user, errors = errors)
user = UserMixin()
user.username = user_found['username']
user.id = user_found['_id'].__str__()
login_user(user)
g.user = user
return redirect(request.args.get("next") or url_for("index"))
return render_template('login.html', user= {'username':'', 'password':''})
def register():
if request.method == 'POST':
new_user = request.form.to_dict()
#incomplete data
errors = {}
new_user['username'] = new_user['username'].strip().lower()
if len(new_user['username']) == 0:
errors['username'] = '******'t be blank'
if len(new_user['password']) == 0:
errors['password'] = '******'
#user already registered
if db.users.find_one({'username':new_user['username']}):
errors['username'] = '******' % new_user['username']
if len(errors) > 0:
return render_template('register.html', new_user=new_user, errors=errors)
db.users.save(new_user)
user = UserMixin()
user.username = new_user['username']
user.id = new_user['_id'].__str__()
login_user(user)
return redirect(request.args.get("next") or url_for("index"))
elif request.method == 'GET':
return render_template('register.html', new_user= {'username':'', 'password':'', 'email':''})
def create_root(config):
from flask_login import UserMixin
import pickle
root_user = UserMixin()
root_user.id = 1
with open(config['ROOT_FILE'], 'wb') as f:
pickle.dump(root_user, f)
def login():
if request.method == "GET":
next_ = '/' if ("next" not in request.args) else request.args.get("next")
params = {
'formAction': url_for("login_api.login"),
'next': next_
}
return render_template("login.html", **params) # unpack the params dictionary, using its values as named parameters
elif request.method == "POST":
data = request.form
password = str(data["password"])
username = str(data["username"])
next_ = str(data["next"])
# find the hashed password associated with the given username
passwordHash = database.getPasswordHash(username)
# error if there is no such username, or the password is incorrect
if passwordHash == -1 or not util.checkHash(passwordHash, password):
flash("Invalid username or password", "error")
return redirect(url_for(".login"))
userId = database.getUserByName(username)['id']
user = UserMixin()
user.id = userId
login_user(user)
flash("Log in successful", "success")
# don't render a template directly off of a POST request; redirect to a GET request, avoiding problems if the user manually reloads the page
return redirect(next_)
def connexion():
if request.method == 'GET':
if current_user.is_anonymous:
return render_template("connexion.html")
else:
return redirect(url_for('main'))
elif request.method == 'POST':
email = request.form['email']
password = request.form['password']
results = c.execute(
"SELECT prenom, password FROM utilisateur WHERE email=?",
(email, )).fetchone()
if results:
passwordEnBase = results[1]
if sha256_crypt.verify(password, passwordEnBase):
user = UserMixin()
user.id = email
user.prenom = results[0]
login_user(user)
return redirect(url_for('main'))
else:
flash(
"Votre email et/ou votre mot de passe est incorrect. Veuillez les saisir à nouveau ",
"danger")
return render_template("connexion.html")
else:
flash(
"Votre email et/ou votre mot de passe est incorrect. Veuillez les saisir à nouveau ",
"danger")
return render_template("connexion.html")
def merge_added_problems(user: UserMixin, new_added_problems: list,
new_structure: list) -> list:
"""Прибавление новых заданий"""
added_problems = loads(user.added_problems)
# считаем количество новых заданий по каждой теме
new_counts = jmp.search('[*].topic.count', new_added_problems)
# если новые задания появились перестраиваем старое дерево разности
if any(new_counts):
# вытягиваем списки новых проблем
new_problems = jmp.search('[*].problems', new_added_problems)
for count, problems, topic in zip(new_counts, new_problems,
added_problems):
# прибавляем (а НЕ переписываем!) количества заданий и сами задания
topic['topic']['count'] += count
topic['problems'] += problems
kwargs = dict(indent=2, ensure_ascii=False)
user.added_problems = dumps(added_problems, **kwargs)
user.problems = dumps(new_structure, **kwargs)
return added_problems
def load_user(userid):
#get the user 3
user_found = db.users.find_one({'_id': ObjectId(userid)})
user = UserMixin()
user.username = user_found['username']
user.id = user_found['_id'].__str__()
g.user = user
return user
def load_user(userid):
#get the user 3
user_found = db.users.find_one({'_id': ObjectId(userid)})
user = UserMixin()
user.username = user_found['username']
user.id = user_found['_id'].__str__()
g.user = user
return user
def __init__(self, name, email, password, location, department):
"""Initialize a User model"""
UserMixin.__init__(self)
self.name = name
self.email = email
self.password = generate_password_hash(password)
self.location = location
self.department = department
self.is_admin = False
def __init__(self, name, email, password, location, department):
"""Initialize a User model"""
UserMixin.__init__(self)
self.name = name
self.email = email
self.password = generate_password_hash(password)
self.location = location
self.department = department
self.is_admin = False
def load_user(user_id):
userDansLaBase = c.execute("SELECT email, prenom, pro FROM utilisateur WHERE email=?", (user_id,)).fetchone()
if userDansLaBase is None:
return None
user = UserMixin()
user.id = user_id
user.prenom = userDansLaBase[1]
user.pro = userDansLaBase[2]
return user
def __init__(self, dic=None):
UserMixin.__init__(self)
self.curr_order = {}
if dic is not None:
self.chef_id = dic['chef_id']
self.chef_service_year = dic['chef_service_year']
self.chef_name = dic['chef_name']
self.chef_rank = dic['chef_rank']
self.hall_id = dic['hall_id']
def __init__(self, dic=None):
UserMixin.__init__(self)
self.curr_order = {}
if dic is not None:
self.user_id = dic['user_id']
self.user_name = dic['user_name']
self.user_gender = dic['user_gender']
self.user_sid = dic['user_sid']
self.user_phone = dic['user_phone']
self.user_type = dic['user_type']
def __init__(self, db_user):
"""Crée l’objet à partir de la base de donnée
:db_user: Objet User de la base de donnée
"""
UserMixin.__init__(self)
self._db_user = db_user
self.id = db_user.id
def user_loader(user_id): # user_id為表單資料的['user_id']
# user_loader是特殊method，雖然接受的是UserMixin() 但會自動取出其中的.id屬性
print("檢查登入狀態")
user = UserMixin()
user.id = user_id # 產生新的UserMixin()預設是沒有.id這個東西，但在自身的method中卻需要用到, 要補給他才會在current_user.id有紀錄
# user.is_anonymous 匿名用戶為T 登入用戶為 F
# user.is_active 帳號啟用 且 登入成功
# user.get_id() == user.id
# .is_authenticated是個T/F 這個是辨認有無登入的關鍵 為T時才可以使用@login_required method
return user
def __init__(self, **kwargs):
# A bit of duplication here keeps the kwargs being
# set but encrypts the password.
for k, v in kwargs.items():
if k != 'password':
setattr(self, k, v)
else:
self.set_password(v)
OurMixin.__init__(self)
UserMixin.__init__(self)
def load_user(user_id):
with db_connection.cursor() as cursor:
cursor.execute('SELECT username FROM "user" WHERE username=%s', (user_id,))
entry = cursor.fetchone()
if not entry:
return None
user = User()
user.id = entry[0]
return user
def __init__(self, dic=None):
UserMixin.__init__(self)
self.get_order = []
if dic is not None:
# print("111111111111111111111111111111")
self.delivery_id= dic['delivery_id']
self.delivery_name= dic['delivery_name']
self.delivery_path = dic['delivery_path']
self.delivery_service_year= dic['delivery_year']
self.delivery_phone = dic['delivery_phone']
self.delivery_rank = dic['delivery_rank']
def login():
error = None
user = UserMixin()
user.id = "admin"
#User[user] = 1
if request.method == 'POST':
if request.form['username'] != 'admin' or request.form['password'] != '123':
error = 'Invalid Credentials. Please try again.'
else:
#session['username'] = request.form['username']
#session.add(user)
login_user(user)
return redirect(url_for('home_page'))
return render_template('login.html', error=error)
def login():
if request.method == 'GET':
logged_in = 'true' if current_user.get_id(
) == ADMIN_USERNAME else 'false'
return render_template('login.html', logged_in=logged_in)
if request.form['username'] == ADMIN_USERNAME and request.form[
'password'] == ADMIN_PASSWORD:
user = UserMixin()
user.id = request.form['username']
login_user(user)
print(f'Logged in as {user.id}')
return redirect('/browse.html')
return render_template('login.html')
def verify():
print('try login')
user_id = request.form['user_id'] # Flask.request
if ((user_id in usersinfo['user_id'])
and (request.form['password']
== users[usersinfo['user_id'].index(user_id)][1])):
# 如果帳密符合資料庫內容 就產生一個UserMixin()紀錄Session 存取id
user = UserMixin()
user.id = user_id
# 會將Session送到@login_manager.user_loader 將其激活
login_user(user) #需要@login_manager.user_loader來接收資料
print('驗證成功')
return redirect(url_for('success')) # 這裡的from_start是指method名稱
else:
return redirect(url_for('fail'))
def validate(self):
"""Validate form contents."""
print("errors are\n{}".format(self.errors))
if not Form.validate(self):
print("validation failed")
return False
# In this trivial app, a login is valid if
# 1) the username and password fields are not empty, and
# 2), the password is the username backwards.
if self.username.data == self.password.data[::-1]:
self.user = UserMixin()
self.user.id = self.username.data
users[self.user.id] = self.user
print("we are good")
# The `remember` flag means our app will remember
# users even if they close their browser. It uses
# cookies to accomplish this.
login_user(self.user, remember=True)
print("current_user: {}".format(current_user.get_id()))
return True
print("invalid password")
# See this link for why the following pattern is necessary:
# https://stackoverflow.com/questions/22889295/flask-self-errors-append-attributeerror-tuple-object-has-no-attribute-ap#comment74244200_22889381
errorlist = list(self.username.errors) # issue
errorlist.append('Invalid password')
self.username.errors = errorlist
flash('invalid passwird')
print(self.username.errors)
return False
def signup():
if flask.request.method == 'GET':
if flask_login.current_user.is_authenticated:
return flask.redirect(f'/users/{flask_login.current_user.id}')
return flask.render_template('signup.html')
else:
error_flag, bday, bmonth, byear, email, first_name, last_name, password, re_password, username = \
validate_form_data()
if error_flag:
return flask.redirect(flask.request.referrer)
with db_connection:
with db_connection.cursor() as cursor:
cursor.execute('SELECT username FROM "user" WHERE username=%s', (username,))
if cursor.fetchone():
flask.flash('Username already in use')
return flask.redirect(flask.request.referrer)
if password != re_password:
flask.flash('Passwords don\'t match')
return flask.redirect(flask.request.referrer)
password_hash = hashlib.sha256(password.encode()).hexdigest()
birth_date = datetime.date(int(byear), int(bmonth), int(bday))
# If this fails, it's a programming error and should be detected, the user will get an internal
# server error
cursor.execute('INSERT INTO'
' "user" ('
' username, '
' password_hash, '
' first_name, '
' last_name, '
' email, '
' birth_date)'
'VALUES(%s, %s, %s, %s, %s, %s)',
(username, password_hash, first_name, last_name, email, birth_date))
user = User()
user.id = username
flask_login.login_user(user)
return flask.redirect(f'/users/{username}')
def save_session(self, user: UserMixin, key: str):
""" Register new user session at session repository.
Args:
user (UserMixin) : User session instance to be registered.
key (str): Key used to identify the new user session.
"""
self.users[key] = user
self.users_id_dict[user.id] = self.users[user.username()]
def login_view():
users = {'testteam': '123321a', 'dev': 'dev2016', 'admin': 'admin.com'}
for k, v in request.args.iteritems():
print(k, v)
result = None
form = LoginForm()
if form.validate_on_submit():
if form.user.data in users and form.password.data == users.get(form.user.data):
user = UserMixin()
user.id = form.user.data
login_user(user=user, remember=True)
flash(u"登录成功.")
return redirect(request.args.get("next") or "/")
else:
result = u'登录失败，账号不存在或者密码错误'
return render_template('home/login.html', form=form, result=result)
def load_user(request) -> typing.Optional[UserMixin]:
"""
Verify that the 'Authorization' header equals our secret key.
Returns an empty `UserMixin` on success.
Docs: https://flask-login.readthedocs.io/en/latest/#installation
Example: http://gouthamanbalaraman.com/blog/minimal-flask-login-example.html
"""
token = str(request.headers.get('Authorization'))
secret = str(current_app.config['SECRET_KEY'])
return UserMixin() if token == secret else None
def login():
if request.method == 'GET':
return render_template('login.html')
else:
email = request.form.get('email')
password = request.form.get('password')
print(email, password)
SQL = """
SELECT password
FROM `movie.users`
WHERE email='%s'
""" % (email)
try:
df = pandas_gbq.read_gbq(SQL)
print('success')
print(df)
if len(df) > 0:
if df.iloc[0].password == password:
#print('iam here')
cur_user = UserMixin()
cur_user.id = email
login_user(cur_user)
session['user_email'] = email
SQL = """
SELECT uid
FROM `movie.users`
WHERE email='%s'
""" % (email)
df = pandas_gbq.read_gbq(SQL)
session['user_id'] = int(df.iloc[0].uid)
session.permenant = True
return redirect(url_for('index'))
else:
error = 'email or password is wrong, try again'
return render_template('login.html', error=error)
else:
error = 'user does not exist'
return render_template('login.html', error=error)
except:
error = 'something wrong try again'
return render_template('login.html', error=error)
def __str__(self):
msg = UserMixin.__str__(self)
return "{} (id: {}, name: {}, backend: {}, admin: {}, moderator: {}, authenticated: {}, active: {})".format(
msg,
self.get_id(),
self.name,
self.backend,
self.is_admin,
self.is_moderator,
self.is_authenticated,
self.is_active,
)
def __str__(self):
msg = UserMixin.__str__(self)
return '{} (id: {}, name: {}, backend: {}, admin: {}, moderator: {}, authenticated: {}, active: {})'.format(
msg,
self.get_id(),
self.name,
self.backend,
self.is_admin,
self.is_moderator,
self.is_authenticated,
self.is_active
)
def register():
if request.method == 'POST':
new_user = request.form.to_dict()
#incomplete data
errors = {}
new_user['username'] = new_user['username'].strip().lower()
if len(new_user['username']) == 0:
errors['username'] = '******'t be blank'
if len(new_user['password']) == 0:
errors['password'] = '******'
#user already registered
if db.users.find_one({'username': new_user['username']}):
errors[
'username'] = '******' % new_user[
'username']
if len(errors) > 0:
return render_template('register.html',
new_user=new_user,
errors=errors)
db.users.save(new_user)
user = UserMixin()
user.username = new_user['username']
user.id = new_user['_id'].__str__()
login_user(user)
return redirect(request.args.get("next") or url_for("index"))
elif request.method == 'GET':
return render_template('register.html',
new_user={
'username': '',
'password': '',
'email': ''
})
def get_user(user_id=None, username=None):
global _users_data
if not _users_data:
_users_data = {}
with open(os.path.join(const.DATA_DIR, "users.csv")) as f:
user_dict = util.csv_to_array_of_dicts(f)
for user in user_dict:
new_user = UserMixin()
new_user.id = user["id"]
new_user.username = user["name"]
new_user.password = user["password"]
_users_data[new_user.get_id()] = new_user
if user_id is None:
for user in _users_data.values():
if user.username == username:
return user
if user_id in _users_data:
return _users_data[user_id]
else:
return False
def load_user(user_id):
users = {'testteam': '123321a', 'dev': 'dev2016', 'admin': 'admin.com'}
if user_id in users:
user = UserMixin()
user.id = user_id
return user
def init(self, *args, **kwargs):
UserMixin.__init__(self, *args, **kwargs)
self.data = None
def get_user(user_id): user = UserMixin() user.id = user_id user.is_authenticated = lambda: user.id in app.config['ALLOWED_USERS'] return user
