def login():
username = request.form['username']
password = request.form['password']
action = request.form['action']
if action == 'Login':
user = check_password(username, password)
if user is not None:
session['session_id'] = user['id']
session['user_id'] = user['id']
session['logged_in'] = True
session['username'] = user['username']
session['is_admin'] = (user.get('group_id') == app.config['ADMIN_GROUP_ID'])
flash('Welcome ' + user['username'], 'flash')
else:
flash('Login failed.', 'error')
elif action =='Register':
username = request.form['username']
password = request.form['password']
check = query_db('SELECT * FROM users WHERE username = ?', [username], one=True)
if check is None:
create_user(username, password)
flash('You successfully registered as ' + username, 'flash')
else:
flash('Your username, ' + username + ', is already taken.', 'error')
return redirect(url_for('home'))
def manage_user():
if request.method == 'POST':
first_name = request.form['signUp_firstName']
last_name = request.form['signUp_lastName'] or None
username = request.form['signUp_username']
password = request.form['signUp_password']
# Validate values
if first_name and username and password:
hashed_password = generate_password_hash(password)
db.create_user(first_name, last_name, username, hashed_password)
return json.dumps({'html':'<span>All fields good !!</span>'})
else:
return json.dumps({'html':'<span>Enter the required fields</span>'})
elif request.method == 'DELETE':
# id = request.form['id']
username = request.form['username']
password = request.form['password']
# Secure enough?
if username and password:
user = db.find_user_by_username(username)
if check_password_hash(user.password, password):
print('Yepp they match')
db.delete_user(username)
return json.dumps({'deleted': 'ok'})
return json.dumps({'error': 'missing user or password'}), 400
def validateLogin(self):
if self.username.get() != '' or self.password.get() != '':
db.create_user(self.username.get(), self.password.get())
self.master
self.f = p2.FrameApp(self)
else:
print('invalid')
def manage_user():
if request.method == 'POST':
first_name = request.form['signUp_firstName']
last_name = request.form['signUp_lastName'] or None
username = request.form['signUp_username']
password = request.form['signUp_password']
# Validate values
if first_name and username and password:
hashed_password = generate_password_hash(password)
db.create_user(first_name, last_name, username, hashed_password)
return json.dumps({'html': '<span>All fields good !!</span>'})
else:
return json.dumps(
{'html': '<span>Enter the required fields</span>'})
elif request.method == 'DELETE':
# id = request.form['id']
username = request.form['username']
password = request.form['password']
# Secure enough?
if username and password:
user = db.find_user_by_username(username)
if check_password_hash(user.password, password):
print('Yepp they match')
db.delete_user(username)
return json.dumps({'deleted': 'ok'})
return json.dumps({'error': 'missing user or password'}), 400
def login():
username = request.form.get('username', '')
password = request.form.get('password', '')
user = db.check_password(username, password)
exists = db.find_user(username)
port = find_open_port()
if port is None:
return abort(503)
if exists and user:
t = binascii.hexlify(os.urandom(16)).decode('ascii')
ws_ports[port] = 1 # placeholder
tokens[t] = port
usernames[t] = username
return jsonify({'token': t})
elif exists:
return abort(403)
elif username and password and meets_requirements(username):
db.create_user(username, password)
t = binascii.hexlify(os.urandom(16)).decode('ascii')
ws_ports[port] = 1 # placeholder
tokens[t] = port
usernames[t] = username
return jsonify({'token': t})
else:
return abort(400)
def login():
if request.method == 'POST':
username = request.form['username']
if not username.isalnum():
return render_template("login.html", data=fetch_user_all())
password = request.form['password']
if not password.isalnum():
return render_template("login.html", data=fetch_user_all())
try:
register = request.form['register']
except:
register = None
if register is not None:
create_user(username, password)
session['User'] = fetch_user_id(username)[0]['Id']
return redirect(url_for('blog'))
else:
for user in fetch_user_all():
if user['UserName'] == username and user[
'Password'] == password:
session['User'] = fetch_user_id(username)[0]['Id']
return redirect(url_for('blog'))
return render_template("login.html", data=fetch_user_all())
def check_users():
"""
Check if accounts exist in stellar and create them if not.
Check if users exist in our system and create them if not.
"""
for user_seed, call_sign in zip(
(TEST_LAUNCHER_SEED, TEST_COURIER_SEED, TEST_RECIPIENT_SEED),
('test_launcher', 'test_courier', 'test_recipient')):
user_keypair = paket_stellar.stellar_base.Keypair.from_seed(user_seed)
user_pubkey = user_keypair.address().decode()
user_seed = user_keypair.seed().decode()
try:
paket_stellar.get_bul_account(user_pubkey)
except paket_stellar.StellarAccountNotExists:
LOGGER.info("creating account %s", user_pubkey)
create_new_account(db.FUNDER_SEED, user_pubkey, XLM_START_BALANCE)
LOGGER.info("adding trust to %s", user_pubkey)
add_trust(user_pubkey, user_seed)
paket_stellar.fund_from_issuer(user_pubkey, BUL_START_BALANCE)
except paket_stellar.TrustError:
LOGGER.info("adding trust to %s", user_pubkey)
add_trust(user_pubkey, user_seed)
paket_stellar.fund_from_issuer(user_pubkey, BUL_START_BALANCE)
try:
db.create_user(user_pubkey, call_sign)
except db.UserAlreadyExists as exc:
LOGGER.info(str(exc))
def register_form():
form = tools.RegisterForm(request.form)
if form.validate():
first_name = form.first_name.data
surname = form.surname.data
email = form.email.data
password = bcrypt_sha256.using(salt=config.salt).hash(
str(form.password.data))
token = tools.token_generator()
try:
db.create_user(first_name, surname, email, password, token,
"photo-opt-in" in request.form)
link = config.url + "/register-confirmation?t=" + token
subject, body = mail_client.create_registration_completion_email(
first_name, surname, link)
email_sent = mail_client.send_email(subject, body, email)
except Exception as e:
flash("User email already registered, sign in?")
return redirect(
url_for('register',
COOKIES_NOTIFICATION=tools.show_cookies_policy(),
LOGGED_IN=tools.is_logged_in()))
flash(
"""We have sent a verification email to you, please confirm so you can access your account"""
)
return render_template(
"register.html",
COOKIES_NOTIFICATION=tools.show_cookies_policy(),
LOGGED_IN=tools.is_logged_in())
def callback():
code = request.args.get('code')
token_endpoint = PROVIDER_CONFIG['token_endpoint']
token_url, headers, body = client.prepare_token_request(
token_endpoint,
authorization_response=request.url,
redirect_url=request.base_url,
code=code,
)
token_response = requests.post(
token_url,
headers=headers,
data=body,
auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
)
client.parse_request_body_response(json.dumps(token_response.json()))
userinfo_endpoint = PROVIDER_CONFIG['userinfo_endpoint']
uri, headers, body = client.add_token(userinfo_endpoint)
userinfo_response = requests.get(uri, headers=headers, data=body)
info = userinfo_response.json()
if info.get("email_verified"):
email = info['email']
picture = info['picture']
name = info['name']
else:
return "User email not available or not verified by Google.", 400
user = User(email, name, picture)
if not db.registered_user(user):
db.create_user(user)
login_user(user)
return redirect(url_for("news"))
def register_user(username, password):
"""helper function to register a user"""
if db.user_exists(username):
return "User already exists", 409
hashed_pass = generate_password_hash(password)
db.create_user(username, hashed_pass)
return "User Created", 200
def register(username, name, password):
usernameFound = db.check_username(username)
if usernameFound == 1:
return ('Username is taken')
else:
passwordHash = generate_password_hash(password)
db.create_user(username, name, passwordHash)
return ('Register was succesful!')
def register():
args = flask.request.args
login = args['login']
passw = args['password']
if db.get_user(login):
return flask.abort(400, 'username_exists')
db.create_user(login, generate_password_hash(passw))
return 'ok'
def internal_test_create_user(self, pubkey, call_sign):
"""Test creating a user."""
self.internal_test_nonexistent(pubkey)
db.create_user(pubkey, call_sign)
user = db.get_user(pubkey=pubkey)
self.assertEqual(user['call_sign'], call_sign)
user = db.get_user(call_sign=call_sign)
self.assertEqual(user['pubkey'], pubkey)
def test_add_score():
session = db.get_session(SESSION)
db.create_user(session, 'kevin')
db.create_user(session, 'kevin', 22)
session = db.get_session()
user = db.exists(session, 'kevin')
assert_equal(22, user.score)
def create_user(self, username, password, verify, go):
print 'USER:'******'Passwords don\'t match. Try again.')
redirect(URL('/first_run'))
db.create_user(username, password)
redirect(URL('/'))
def test_add_score():
session = db.get_session(SESSION)
db.create_user(session, 'kevin')
db.create_user(session, 'kevin', 22)
session = db.get_session()
user = db.exists(session, 'kevin')
assert_equal(22, user.score)
def main(sqlite_path):
if path.exists(db.db_path):
print(db.db_path, 'already exists')
return 1
db.init_db(True)
csv.register_dialect('wormholes',
lineterminator='\n', quoting=csv.QUOTE_MINIMAL, skipinitialspace=True, strict=True)
wormholes = get_wormholes('setup_data/wormholes.csv')
conn = sqlite3.connect(sqlite_path)
conn.row_factory = sqlite3.Row
rows = conn.execute('''
SELECT solarSystemID, solarSystemName, security, regionName, wormholeClassId FROM mapSolarSystems
JOIN mapRegions ON mapRegions.regionID = mapSolarSystems.regionID
JOIN mapLocationWormholeClasses ON mapRegions.regionId = mapLocationWormholeClasses.locationId
''')
for row in rows:
id = int(row['solarSystemID'])
name = row['solarSystemName']
security = row['security']
region = row['regionName']
wormhole = wormholes.get(id)
if wormhole:
assert name == wormhole['name']
whclass = wormhole['class']
effect = wormhole['effect']
static1 = wormhole['static1']
static2 = wormhole['static2']
else:
if security >= 0.45:
whclass = 'highsec'
elif security > 0.0:
whclass = 'lowsec'
else:
whclass = 'nullsec'
effect = static1 = static2 = None
db.SolarSystem(name, id, region, whclass, effect, static1, static2).save()
for wh_type in get_wh_types('setup_data/wh_types.csv'):
"""
id = wh_type['id']
name = wh_type['name']
src = wh_type['src']
dest = wh_type['dest']
lifetime = wh_type['lifetime']
jump_mass = wh_type['jump_mass']
max_mass = wh_type['max_mass']
"""
db.WHType(**wh_type).save()
username = input('username: '******'password: '******'map', b'[]')
return 0
def setUp(self):
db.users_coll.drop();
db.questions_coll.drop()
db.ensure_indexes()
question_mod.init(flush=True)
db.create_user('dan', 'no password')
self.dan_user = user_mod.User.from_username('dan')
def init_test_user():
if db.find_user('*****@*****.**') is None:
password = '******'
pw_hash = bcrypt.generate_password_hash(password).decode('utf-8')
db.create_user(1, pw_hash, 2)
if db.find_user('*****@*****.**') is None:
password = '******'
pw_hash = bcrypt.generate_password_hash(password).decode('utf-8')
db.create_user(7, pw_hash, 3)
def post(self):
with db.conn.cursor() as c:
r = db.query_one(c, 'SELECT admin FROM users WHERE id = ?', self.current_user)
admin = bool(r.admin)
if not admin:
raise tornado.web.HTTPError(403)
username = self.get_argument('username')
password = self.get_argument('password')
if not username or not password:
raise tornado.web.HTTPError(400)
db.create_user(self.get_secure_cookie('username'), username, password)
self.redirect('/account')
def like_ddd(client, message):
global caches
userid = message["from_user"]["id"]
add_message_to_cache(message)
tg_analytic.statistics_chat(message.chat.id, get_title_chat(message))
value_to_send = int(message.text.split(" ")[1])
if message.reply_to_message.from_user.id != message["from_user"][
"id"] and not message["reply_to_message"]["from_user"][
"is_bot"] and value_to_send > 0:
mnemonic = db.get_mnemo(userid)
wallet = Wallet(seed=mnemonic)
balance = db.get_balance(userid)
value_to_send = correct_value_balance(value_to_send, balance)
owner = get_owner_chat(app, message)
to_address = db.create_user(message.reply_to_message.from_user.id)
if value_to_send > 0.01:
if owner != None:
owner_dat = db.create_user(owner.user.id)
# Check if like sending to owner of group or from him
if wallet.address == owner_dat[2] or owner_dat[
2] == to_address[2]:
owner = None
else:
wallet.send(to=owner_dat[2],
value=0.1 * float(value_to_send),
coin="LIKE",
payload='',
include_commission=True)
if owner == None:
transaction = wallet.send(to=to_address[2],
value=float(value_to_send),
coin="LIKE",
payload='',
include_commission=True)
else:
transaction = wallet.send(to=to_address[2],
value=0.9 * float(value_to_send),
coin="LIKE",
payload='',
include_commission=True)
if transaction != None:
# If result success send message to chat
if not 'error' in transaction["result"]:
a = message["reply_to_message"].reply_text(
"Your message was liked by " + get_name(message) +
"'s message! [Spend your coins](https://t.me/MinterLikeBot)",
parse_mode="Markdown",
disable_web_page_preview=True)
tg_analytic.statistics(message.chat.id, "emoji like", True,
value_to_send)
threading.Thread(target=delete_message,
args=(a.chat.id, a.message_id)).start()
def handler(user_id: str) -> Response:
""" Handler of TEAM_06_OPEN_TIME_TRACKING intent,
TEAM_06_OPEN_TIME_TRACKING intent is activated when user says 'zeiterfassung stoppen'
welcomes user
:return: Response
"""
user_info = get_user(user_id)
if user_info:
update_user(user_info)
else:
create_user(user_id)
clockify_api_key = get_clockify_api_key(user_id)
if clockify_api_key is None or clockify_api_key == '':
user_token = get_user_token(user_id)
if user_token is None or user_token == '':
user_token = get_random_string(4)
set_user_token(user_id, user_token)
msg = _('WELCOME_NEW_USER')
response = tell(msg)
response.card = Card(
type_="GENERIC_DEFAULT",
title="Time Tracker: Hinterlege deinen Clockify Account",
text="User Token: {token}".format(token=user_token),
action=get_auth_url(token=user_token),
action_text="Klick hier, um einen Account zu hinterlegen.")
else:
clockify = get_clockify(clockify_api_key)
clockify_id = clockify['user_id']
workspace_id = clockify['active_workspace_id']
time_entries = get_time_entries(clockify_api_key=clockify_api_key,
workspace_id=workspace_id,
user_id=clockify_id)
running_timer = check_running_timer(time_entries)
# Get time tracking status
if running_timer:
msg = _('WELCOME_RETURNING_USER')
msg = msg + " " + _('WELCOME_STOP_SELECTION')
else:
msg = _('WELCOME_SELECTION')
response = ask(msg)
return response
def register():
if request.method == 'GET':
return render_template("register.html")
elif request.method == 'POST':
data = request.json
if check_user_data_collision(data['username'], data['email']):
return jsonify({"status": "Login or email already used"})
else:
create_user(data['username'], data['email'], data['passwd'])
link = 'http://ddesmintyserver.ml:5002/account_confirm?user='******'username'] + '&code=' + \
hash_generate(data['username'] + data['email'])
send_confirm_mail([data['email']], link)
return jsonify({"status": "OK"})
def create_user():
if request.method == "GET":
users_info = db.find_user()
return render_template("login.html", users_info=users_info)
if request.method == "POST":
userid = request.form["userid"]
name = request.form["name"]
password = request.form["password"]
db.create_user(userid, name, password)
return redirect(url_for("add_goal"))
def register():
if request.method == 'POST':
db.create_user({
'first-name': request.form.get('first-name'),
'last-name': request.form.get('last-name'),
'email': request.form.get('email'),
'password': request.form.get('password'),
})
return redirect(url_for('auth.login'))
# else:
# return render_template('auth/register.html')
return render_template('auth/register.html')
def login_step(message, user_data):
if user_exists(user_data.name, user_data.password):
db.create_user(tg_id=user_data.tg_id,
hostname=user_data.hostname,
name=user_data.name,
password=user_data.password)
db.login(message.chat.id)
bot.send_message(message.chat.id,
text='Успешный вход',
reply_markup=keyboards.dashboard())
else:
bot.send_message(message.chat.id,
'Некоректные данные попробуйте снова')
def get(username, session):
""" Return a list of who this person follows"""
text = _fetch(username)
if not text:
return
friends = _get_friends(text)
score = _get_score(text)
user = db.create_user(session, username, score)
for index, friend in enumerate(friends):
friend_record = db.exists(session, friend)
if not friend_record:
friend_record = db.create_user(session, friend)
_queue(friend)
_store(session, user.id, friend_record.id, index + 1)
def get(username, session):
""" Return a list of who this person follows"""
text = _fetch(username)
if not text:
return
friends = _get_friends(text)
score = _get_score(text)
user = db.create_user(session, username, score)
for index, friend in enumerate(friends):
friend_record = db.exists(session, friend)
if not friend_record:
friend_record = db.create_user(session, friend)
_queue(friend)
_store(session, user.id, friend_record.id, index + 1)
def index() -> str:
conn = db.get_connection()
# user: {
# "user_id": "1333463",
# "user_name": "Eric Wu",
# "password": "******"
# }
db.create_user(db.get_connection(), '1333463', 'Eric Wu', 'helloworld01')
user_name = db.select_user_by_user_id(conn, '1333463')
return json.dumps({'a user inserted': user_name })
def signup():
content = json.loads(request.form['PostData'])
email = content['email']
password = content['password']
machine = content['machine']
if check_email(email):
return 'false'
user_dict = {'email': email, 'password': password, 'machine': machine}
try:
create_user(user_dict)
return 'true'
except KeyError:
return 'false'
def signup(error, entries, navigation):
cur = db.conn.cursor()
first_name = entries[0].get()
last_name = entries[1].get()
email = (entries[2].get()).upper()
password = entries[3].get()
confirm_password = entries[4].get()
current_frame = navigation[0]["frame"]
next_frame = navigation[1]["frame"]
window_name = navigation[2]
root = navigation[3]
valid = True
if not first_name.isalpha():
error.configure(text="Invalid first name, must contain letters only!")
valid = False
return
if not last_name.isalpha():
error.configure(text="Invalid last name, must contain letters only!")
valid = False
return
if not validate_email(email):
error.configure(text="Invalid email!")
valid = False
return
if not password_is_valid(password):
error.configure(
text=
"Password must contain upper case letter, lower case letter and a number"
)
valid = False
return
if confirm_password != password:
error.configure(text="Passwords do not match!")
valid = False
return
if valid:
error.configure(text="")
db.create_user(email, md5(password), first_name, last_name)
show_frame(current_frame, next_frame, window_name, root)
def on_login(self):
if self.TEntry2['state'].string == 'readonly':
self.TEntry2['state']='normal'
self.btnLogin.configure(text='''登录''')
config.user = None
return
code = self.TEntry2.get()
if len(code)==0: return
data = web.create_gust(self.TEntry2.get())
if data["code"] == 2000:
ret = gonet.login(self.client, data['data']['Data']['Token'])
db.create_user(data['data']['AccountID'], data['data']['Data']['Token'], code)
self.user = data['data']
self.TEntry2['state'] = 'readonly'
self.btnLogin.configure(text="注销")
def register(username, password, question, answer):
question_id = db.create_question(question, answer)
user_id = db.create_user(username, password.encode('utf-8'), question_id)
if user_id:
return True
else:
return False
def setUp(self):
db.users_coll.drop();
db.questions_coll.drop()
db.ensure_indexes()
db.create_user('dan', 'no password')
self.dan_user = user_mod.User.from_username('dan')
db.create_user('sean', 'i love dan irl')
question_doc = db.insert_question('question #1', 'correct answer', 'wrong1', 'wrong2', 'wrong3')
self.question1 = question_mod.Question.from_doc(question_doc)
self.sean_user = user_mod.User.from_username('sean')
self.sean_user.add_demographic('masculinity', True)
self.sean_user.add_demographic('favorite_food', 'pancakes in a bowl')
self.sean_user.add_demographic('hair color', 'red')
async def login(request):
params = ['identity']
data = with_body(request, params)
if len(data) == len(params):
user = find_identity(data)
if user is not None:
return __create_session(user)
else:
email = '{}@opentact.org'.format(data[0])
avatar = gravatar(email)
new_user = ['Anonymous', '', email, '', avatar, data[0]]
if create_user(new_user):
new_user = user_by_identity(data[0])
if new_user is not None:
return __create_session(new_user)
else:
return response.json(
{'message': 'cannot find user for identity'},
status=500)
else:
return response.json({'message': 'cannot create user'},
status=500)
else:
return response.json({'message': 'missing data'}, status=400)
def create_user():
user_form = AdminUserForm()
if hasattr(current_user, 'role'):
role = current_user.get_role()
else:
role = ""
if user_form.validate_on_submit():
user = db.find_user_by_email(user_form.email.data)
if user is not None:
flash("User {} already exists".format(user_form.email.data),
category='danger')
else:
rowcount = db.create_user(user_form.name.data,
user_form.email.data, user_form.zip.data,
user_form.password.data,
user_form.bio.data,
user_form.rating.data,
user_form.active.data)
if rowcount == 1:
flash("User {} created".format(user_form.name.data),
category='success')
return redirect(url_for('all_users'))
else:
flash("New user not created", category='danger')
return render_template('user-form.html',
form=user_form,
mode='create',
role=role)
async def create_or_fetch_user(user_id, user_name):
logger.info('attempting to fetch user %s ...', user_id)
user = db.get_user_by_id(user_id)
if user is None:
logger.info('user %s does not exist. creating new user ...', user_id)
wallet_command = {'action': 'account_create', 'wallet': wallet}
wallet_output = await communicate_wallet_async(wallet_command)
address = wallet_output['account']
wallet_command = {
'action': 'account_representative_set',
'wallet': wallet,
'account': address,
'representative': settings.representative
}
await communicate_wallet_async(wallet_command)
user = db.create_user(user_id=user_id,
user_name=user_name,
wallet_address=address)
logger.info('user %s created.', user_id)
logger_newuser.info('user_id: %s, user_name: %s, wallet_address: %s',
user_id, user_name, address)
return user
else:
logger.info('user %s fetched.', user_id)
return user
def register():
user_email = request.headers['user_email']
password = request.headers['password']
if (user_email and password):
email_hash = create_user(user_email, password)
# email_hash==101: database error somewhere along the way
# email_hash==False: user already exists
# email_hash==String: user successfully registered and email_hash is returned
if (email_hash != 101):
if (email_hash):
response = make_response()
#response.headers['user_email'] = user_email
response.headers['user_status'] = 'registered'
response.headers['email_hash'] = email_hash
return response
else:
response = make_response()
response.headers['user_status'] = 'already_exists'
return response
else:
response = make_response()
response.headers['user_status'] = 'Try again later'
return response
else: #Redirect to login page if credentials were missing
return redirect('/', 303)
def signup():
form = forms.SignupForm()
if form.validate_on_submit():
user = db.create_user(form.username.data, form.email.data,
generate_password_hash(form.password.data))
session["username"] = user.username
flash("You have signed up sucessfully.")
return redirect(url_for("main"))
return render_template("signup.html", form=form, menu_toggle_signup=True)
def test_duplicate_user(self):
db.create_user("non_unique_name", "password")
try:
db.create_user("non_unique_name", "different password")
self.fail("Expected a duplicate key error")
except pymongo.errors.DuplicateKeyError:
pass
except Exception:
self.fail("Expected a duplicate key error, but got the wrong kind")
db.create_facebook_user("12345")
try:
db.create_facebook_user("12345")
self.fail("Expected a duplicate key error")
except pymongo.errors.DuplicateKeyError:
pass
except Exception:
self.fail("Expected a duplicate key error, but got the wrong kind")
def user():
if request.method=='POST':
action=request.form['action']
if action=='DELETE':
delete_user_form= DeleteUserForm()
if delete_user_form.validate():
username=request.form['username']
if username=='admin' or username=='guest':
flash("admin and guest accounts can't be deleted",'error')
else:
ok=db.delete_user(get_db(),username)
if ok: flash('Deleted %s'%username,'ok')
else: flash('Failed to delete %s'%username,'error')
else:
flash('delete form failed to validate','error')
elif action=='CREATE':
add_user_form = AddUserForm() # create from current form values
if add_user_form.validate():
password=add_user_form.password.data
password_hash=encrypt(password)
ok=db.create_user(get_db(),add_user_form.name.data,add_user_form.email.data,password_hash)
if ok:
flash('New user %s created'%add_user_form.name.data,'ok')
else:
flash('Sorry, could not create user %s'%add_user_form.name.data,'error') # validation OK, but DB failed
else: # posted a invalid form
flash('Please fill in all fields','warning')
elif action=="ADMIN":
admin_form=UserAdminForm()
db.set_user_admin(get_db(),admin_form.username.data,admin_form.admin.data)
# By default reget the page, can't return a new render here as the existing form would pollute the creation values of the new forms
return redirect('/users')
else: # GET
add_user_form = AddUserForm()
userlist=db.get_users(get_db())
# Since get_users doesnt return a list of result, we have to convert the structure in order to insert the delete
# user form into the list
userlist2=[]
for user in userlist:
name=user['name']
isadmin=user['admin']
newrow=list(user)+[DeleteUserForm(username=name),UserAdminForm(username=name,admin=isadmin)]
userlist2.append(newrow)
return render_template('user.html', add_user_form=add_user_form, userlist=userlist2)
def saveData():
myID = request.args.get('id', '')
myFirst = request.args.get('first', '')
myLast = request.args.get('last', '')
myGrade = request.args.get('grade', '')
myRooms = []
for i in range(1,11):
myRooms.append(request.args.get('room' + str(i), ''))
boolean = db.create_user(myID, myFirst, myLast, myGrade, myRooms)
if boolean == 1:
return json.dumps(True)
else:
return json.dumps(False)
def create_user():
username = request.args.get("username", None)
if not username:
return jsonify(ok=False, error="Missing the `username` parameter")
password = request.args.get("password", None)
if not password:
return jsonify(ok=False, error="Missing the `password` parameter")
try:
new_user_oid = db.create_user(username, hash_password(password))
except DuplicateKeyError:
return jsonify(ok=False, error="Username `%s` already exists" % (username,))
return jsonify(ok=True, user_oid=str(new_user_oid))
def signup():
if request.method == 'GET':
return render_template('signup.html')
else:
email = request.form['email']
password = request.form['password']
password2 = request.form['password2']
error = ''
try:
if not email: raise Exception('No email address specified')
if not password: raise Exception('No password specified')
if password != password2: raise Exception('Passwords do not match')
db = database.DataStore()
id =db.create_user({"email":email,"password":password})
session['uid'] = id
return redirect('/')
except Exception,e:
return render_template('signup.html',error=e.message,email=email)
import db
db.users_coll.drop()
db.create_user("dan", "none_yet")
db.create_user("sean", "none_yet")
print "Dan: %s" % (str(db.user_from_username("dan")["_id"]),)
print "Sean: %s" % (str(db.user_from_username("sean")["_id"]),)
def test_count():
session = db.get_session(SESSION)
assert_equal(0, db.get_count(session))
db.create_user(session, 'kevin')
assert_equal(1, db.get_count(session))
def gconnect():
if is_logged_in():
categories = db.get_categories()
categories = [category.name for category in categories]
latest_items = db.get_items()
latest_items = [[item.name, db.get_category_name_by_id(item.category_id)] for item in latest_items] #NOQA
data = {
'categories': categories,
'latest_items': latest_items,
'logged_in': True,
'username': views.login_session['username']
}
return render_template('index.html', data = data)
if request.args.get('state') != views.login_session['state']:
response = make_response(views.json.dumps('Invalid state paremeter'), 401)
response.headers['Content-Type'] = 'application/json'
return response
code = request.data
try:
# Upgrade the authorization code into a credentials object
oauth_flow = views.flow_from_clientsecrets('client_secrets.json', scope='')
oauth_flow.redirect_uri = 'postmessage'
credentials = oauth_flow.step2_exchange(code)
except views.FlowExchangeError:
response = make_response(views.json.dumps('Failed to upgrade the authorization code.'), 401) #NOQA
response.headers['Content-Type'] = 'application/json'
return response
# Check that the access token is valid:
access_token = credentials.access_token
url = ('https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=%s' % access_token) #NOQA
http = httplib2.Http()
result = views.json.loads(http.request(url, 'GET')[1])
# If there was an error in the access token info, abort.
if result.get('error') is not None:
response = make_response(views.json.dumps(result.get('error')), 500)
response.headers['Content-Type'] = 'application/json'
# Verify that the access token is used for the intended user:
gplus_id = credentials.id_token['sub']
if result['user_id'] != gplus_id:
response = make_response("Token's user ID doesn't match given user ID.", 401) #NOQA
response.headers['Content-Type'] = 'application/json'
return response
# Verify that the access token is valid for this app:
if result['issued_to'] != views.CLIENT_ID:
response = make_response(views.json.dumps("Token's client ID does not match app's."), 401) #NOQA
print("Token's client ID does not match app's.")
response.headers['Content-Type'] = 'application/json'
return response
# Check to see if user is already logged in
stored_credentials = views.login_session.get('credentials')
stored_gplus_id = views.login_session.get('gplus_id')
if stored_credentials is not None and gplus_id == stored_gplus_id:
response = make_response(views.json.dumps("Current user is already connected."), 200) #NOQA
response.headers['Content-Type'] = 'application/json'
# Get user info
userinfo_url = 'https://www.googleapis.com/oauth2/v1/userinfo'
params = {'access_token': credentials.access_token, 'alt': 'json'}
answer = requests.get(userinfo_url, params = params)
data = views.json.loads(answer.text)
# Store the access token in the session for later use.
views.login_session['credentials'] = credentials.access_token
views.login_session['gplus_id'] = gplus_id
views.login_session['username'] = data['name']
# Add a new user if this user doesn't already exist
user_id = db.get_user_id_by_name(data['name'])
if not user_id:
user_id = db.create_user(views.login_session)
views.login_session['user_id'] = user_id
return redirect('/')
def test_duplicates():
session = db.get_session(SESSION)
user_id = db.create_user(session, 'kevin')
second_user_id = db.create_user(session, 'kevin')
assert_equal(user_id, second_user_id)
def post(self):
username = self.get_argument("username", "")
password = self.get_argument("password", "")
user_id = db.create_user(username, password)
self.set_current_user(username, user_id)
self.redirect("/")
def save(self):
"""Save the user to the database (or create if it is not present)"""
if self.id:
db.save_user(self.id, self.email, self.password)
else:
self.id = db.create_user(self.email, self.password)
def signup():
create_user(request.form['username'], request.form['password'])
return jsonify(success=True)
