def request_login():
if request.form['password'] == get_login_pass_hash():
if request.form['remember'] == "true":
login_user(User(1), remember=True)
else:
login_user(User(1))
return 'ok'
else:
return 'no'
def accept(self):
self.user = User(self.ui.login.text(),
self.ui.password.text())
if not self.parent().db.is_user_exists(self.user.login, self.user.password):
self.setWindowTitle('Ошибка авторизации')
else:
QDialog.accept(self)
def __init__(self, url, user=None):
"""Open a new session to URL with the specified USER.
USER must be an object that implements the
'csvn.auth.User' interface."""
if user is None:
user = User()
self.pool = Pool()
self.iterpool = Pool()
self.url = RepositoryURI(url)
self.user = user
self.client = POINTER(svn_client_ctx_t)()
svn_client_create_context(byref(self.client), self.pool)
self.user.setup_auth_baton(pointer(self.client.contents.auth_baton))
self._as_parameter_ = POINTER(svn_ra_session_t)()
svn_client_open_ra_session(byref(self._as_parameter_), url,
self.client, self.pool)
self.client[0].log_msg_func2 = \
svn_client_get_commit_log2_t(self._log_func_wrapper)
self.client[0].log_msg_baton2 = c_void_p()
self._log_func = None
def registrate():
form = RegForm()
if request.method == 'GET':
return render_template("registrate.html", myForm=form)
else:
if not form.validate():
return render_template("registrate.html", myForm=form)
user = User()
user.__enter__()
status = user.sign_up( request.form['username'],
request.form['email'])
if status == '200 OK':
session['email'] = request.form["email"]
response = make_response("logged in")
expires = datetime.now()
expires += timedelta(minutes=5)
response.set_cookie('emailCookie', session['email'], expires=expires)
return redirect('/index')
elif status == '500 already existed':
return redirect('/registrate')
else:
return redirect('/registrate')
def login():
if request.method == "GET":
if current_user.is_authenticated:
return redirect(url_for('index'))
return render_template('web/login.html')
else:
if current_user.is_authenticated:
return redirect(url_for('index'))
username = request.form['username']
pw = request.form['password']
user = appDB.users.find_one({'_id': username})
if user:
myuser = User.query_user(user['_id'])
if check_password(myuser.pw_hash, pw):
login_user(myuser)
return redirect(url_for('index'))
else:
flash("Incorrect username/password, please try again")
return render_template('web/login.html')
else:
pw_hash = generate_password_hash(pw)
myuser = User(username, pw_hash, [])
appDB.users.insert_one({"_id": myuser.id, \
"password": myuser.pw_hash, \
"history": []})
login_user(myuser)
return redirect(url_for('index'))
def _validate_and_log_user(form):
if form.validate_on_submit():
mongo_user = mongo.db.users.find_one({'email': form.email.data})
if mongo_user and bcrypt.check_password_hash(mongo_user['password'], form.password.data):
login_user(User(mongo_user), remember=form.remember_me.data)
else:
flash('Utilisateur ou mot de passe non valide.')
def load_user(id):
res = db.get_db().query("select * from users where id='" + str(id) + "'")
if len(res) == 1:
user = User(res[0][0], res[0][1])
user.is_authenticated = True
return user
else:
return None
def request_loader(request):
username = request.form.get('username')
res = db.get_db().query("select * from users where username='******'")
if len(res) == 1:
user = User(res[0][0], res[0][1])
return user
else:
return None
def addusers():
authusers = [{"id": 1, "username": '******', "password": ''}]
users = []
for user in authusers:
users.append(User(user["id"], user["username"], user["password"]))
for user in users:
print(user)
save_to(user, db)
def accept(self):
user = User(self.ui.login.text(), self.ui.password.text())
if len(
reader.select_from_where(
'*', 'Пользователи', '''логин = '{}'
and пароль = '{}' '''.format(
user.login, user.password))) != 1:
self.setWindowTitle('Ошибка авторизации')
else:
QDialog.accept(self)
def login():
form = LoginForm()
if form.validate_on_submit():
user = User()
form.populate_obj(user)
login_user(user)
flash('Logged in successfully.')
return redirect(url_for('homepage'))
return render_template('login.html', form=form)
def login_handler():
if request.method == 'POST':
if validate_user(request.form['username'], request.form['password']):
login_user(User(request.form['username'], True))
return redirect(url_for('quiz_page'))
else:
return render_template(
'quiz-login.html',
message="Incorrect User/Password combination")
return render_template('quiz-login.html', message=None)
def main():
global app
specfile = "./apis/api.yaml"
specurl = "file://" + abspath(specfile)
specdict = read_yaml_file(specfile)
openapi_spec = create_spec(specdict, spec_url=specurl)
openapi_middleware = FalconOpenAPIMiddleware.from_spec(openapi_spec)
app = API(middleware=[openapi_middleware])
auth_server = Auth()
user_server = User()
app.add_route('/user', user_server)
app.add_route('/token', auth_server)
def loadUser(self, username, password):
from auth import User
try:
api = WaApiClient(self.getSetting('Client ID'),
self.getSetting('Client secret'))
api.authenticate_with_contact_credentials(username, password)
contact = api.execute_request('Contacts/me')
id = contact['Id']
user = User(username)
user.id = id
user.groups = []
user.firstName = contact['FirstName']
user.lastName = contact['LastName']
contact = api.execute_request('Contacts/' + str(id))
fieldValues = contact['FieldValues']
approved = False
groupList = []
for fieldValueItem in fieldValues:
if fieldValueItem['FieldName'] == 'Group participation':
groupList = fieldValueItem['Value']
break
for group in groupList:
user.groups.append(group['Label'])
logger.debug(f"Authenticating {username}")
logger.debug(user.groups)
return user
except HTTPError as err:
logger.debug("HTTPError Validating User: "******"Unhandled Error Validating User:", exc_info=True)
raise
return None
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm(db)
if form.validate_on_submit():
user = User(form.username.data)
user.set_password(form.password.data)
user.store(db)
flash("Accont creation successful."
"Welcome to our happy lil' community!")
return redirect(url_for('login'))
return render_template('register.html', form=form)
def login():
if request.method == 'GET':
return '''
<form action='login' method='POST'>
<input type='text' name='email' id='email' placeholder='email'></input>
<input type='password' name='pw' id='pw' placeholder='password'></input>
<input type='submit' name='submit'></input>
</form>
'''
email = request.form['email']
if request.form['pw'] == users[email]['pw']:
user = User()
user.id = email
flask_login.login_user(user)
return redirect(url_for('protected'))
return 'Bad login'
def __init__(self, path, create=False, user=None):
"""Open the repository at PATH. If create is True,
create a new repository.
If specified, user must be a csvn.auth.User instance.
"""
if user is None:
user = User()
self.pool = Pool()
self.iterpool = Pool()
self._as_parameter_ = POINTER(svn_repos_t)()
self.user = user
if create:
svn_repos_create(byref(self._as_parameter_), path,
None, None, None, None, self.pool)
else:
svn_repos_open(byref(self._as_parameter_), path, self.pool)
self.fs = _fs(self)
def signin():
form = LoginForm()
err = None
if request.method == 'GET':
user_email = session.get('email') or request.cookies.get('emailCookie')
if user_email:
return redirect('/index')
return render_template('login.html', myForm=form)
if form.validate_on_submit():
user = User()
user.__enter__()
res = user.sign_in(request.form['email'])
print(res)
if int(res):
session['email'] = request.form["email"]
response = make_response(redirect('/index'))
expires = datetime.now() + timedelta(minutes=15)
response.set_cookie('emailCookie', session['email'], expires=expires)
return response
err = 'Not correct email'
return render_template('login.html', myForm=form, err=err)
def hash_pw(password):
return User().hash_password(password)
def get_password(username):
user = User().get_user(username)
user['username'] = username
g.user = user.copy()
g.user['password'] = ''
return user.get('password')
def user_loader(email):
user = User()
return user
def accept(self):
user = User(self.ui.login.text(), self.ui.password.text())
QDialog.accept(self)
from auth import User
if __name__ == '__main__':
u = input("输入用户名:").strip()
p = input('输入用户密码:').strip()
user = User(u, p, auto_code=True)
app.config["SECRET_KEY"] = "Highly secret key"
admins = {"admin": "password"}
auth = False
questions = Questions()
surveys = Surveys()
reader = CSVReader()
writer = CSVWriter()
sview = SurveyView()
smodel = SurveyModel()
scntrl = SurveyController(smodel, sview)
author = Authenticator(User('', 'invalid'))
def check_auth():
global auth
return auth
def check_password(user_name, password):
global auth
global admins
if user_name in admins:
if password == admins[user_name]:
auth = True
return auth
import sqlite3
import traceback
from flask import Flask, g, render_template, request, Response
from auth import User, handle_login, handle_logout, login_required
def default_config():
return dict(SECRET_KEY=os.urandom(128), DEBUG=True)
app = Flask(__name__)
app.config.update(default_config())
app.config.from_pyfile('config.py')
app.config['USERS'] = {x[0]: User(*x) for x in app.config['USERS']}
def connect_db():
db = sqlite3.connect(app.config['DB_PATH'])
# db = sqlite3.connect(
# 'file:/%s?mode=ro'.format(app.config['DB_PATH']), uri=True
# )
db.row_factory = sqlite3.Row
db.cursor().execute('PRAGMA foreign_keys=ON')
return db
def get_db():
db = getattr(g, '_database', None)
if db is None:
def load_user(user_id):
return User(user_id)
def test_check_pwd(self):
pwd = 'usrpwd'
user = User('user', pwd)
result = user.check_password(pwd)
self.assertEqual(result, True)
app.register_blueprint(auth.bp)
import books
app.register_blueprint(books.bp)
app.add_url_rule('/', endpoint='books.index')
from navbar import nav
nav.init_app(app)
db.create_all()
from auth import Role
# Create '*****@*****.**' user with no roles
if not User.query.filter(User.username == 'user').first():
user = User(
username='******',
password=user_manager.hash_password('Password1'),
)
db.session.add(user)
db.session.commit()
# Create '*****@*****.**' user with 'Admin' and 'Agent' roles
if not User.query.filter(User.username == 'admin').first():
user = User(
username='******',
password=user_manager.hash_password('Password1'),
)
user.roles.append(Role(name='Admin'))
user.roles.append(Role(name='Agent'))
db.session.add(user)
db.session.commit()
#!/usr/local/bin/python
from flask import Flask, session, redirect, request, url_for, render_template
from auth import User
app = Flask(__name__)
app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
user_table = User('login.dat')
@app.route('/')
def home():
if 'username' in session:
return render_template('home.html')
return redirect(url_for('login'))
@app.route('/something')
def something():
if 'username' in session:
return render_template('something.html')
return redirect(url_for('login'))
@app.route('/login', methods=['GET', 'POST'])
def login():
if 'username' in session:
return redirect(url_for('home'))
elif request.method == 'GET':
return render_template('login.html')
username = request.form['username'].lower()
password = request.form['password'].lower()
