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 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 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)