def get_user(self, username: str) -> Optional[User]: try: r = requests.get(url=f'{self.ig_home}{username}', timeout=10) if r.ok: regex = r'(?<="graphql":{"user":).*(?=},"toast_)' regex_res = re.findall(pattern=regex, string=r.text)[0] _user = json.loads(regex_res) user = User( id=_user.get('id'), url=f'{self.ig_home}{username}', bio=_user.get('biography'), username=username, fullname=_user.get('full_name'), followers=_user.get('edge_followed_by', {}).get('count'), followings=_user.get('edge_follow', {}).get('count'), is_business=_user.get('is_business_account'), is_private=_user.get('is_private'), profile_picture_url=_user.get('profile_pic_url_hd')) logger.info( f"Returning the IGParser's result for username {username}") return user except TimeoutError as e: logger.error(f'Cannot parse page for {username}: {type(e)}') raise ApplicationError() except Exception as e: logger.error(f'Cannot parse page for {username}: {type(e)}') raise RegexError()
def login(): # if user is already logged in if current_user.is_authenticated: return redirect(url_for('home')) form = LoginForm() if form.validate_on_submit(): username = request.form['username'] password = request.form['password'] find_user = Database.find_one('users', {'username': username}) # checks if the login is valid if User.login_valid(username, password, bcrypt): log_user = User(find_user['username'], find_user['password'], find_user['profile_image'], find_user['_id']) login_user(log_user, remember=form.remember.data) next_page = request.args.get('next') User.login(username) flash('Login successful', 'success') return redirect(next_page) if next_page else redirect( url_for('home')) # if login was not valid session['email'] should be None else: session['username'] = None flash('Check your credentials.', 'danger') return render_template('login.html', title='Login', form=form)
def test_init_noargs(): from src.models.user import User u = User() assert u.name is None assert u.email is None assert u.password is None assert u.lang is None
def make_row(cls, text_messages_count=0, text_messages_with_obscene_count=0, words_count=0, obscene_words_count=0): stat = UserStat(text_messages_count=text_messages_count, text_messages_with_obscene_count=text_messages_with_obscene_count, words_count=words_count, obscene_words_count=obscene_words_count) cls.user_count += 1 user = User(cls.user_count, cls.user_count, f'user{cls.user_count}', f'user{cls.user_count}') return stat, user
def test_check_lang(): from src.models.user import User u = User() assert u.check("lang", "en") assert u.check("lang", "fr") assert u.check("lang", "") == "Language length must be at least 1" assert u.check("lang", "asdf") == "Language length must be at most 3"
def __init__(self): """ Virtually private constructor. """ if UserHandler.__instance != None: raise Exception("This class is a singleton!") else: UserHandler.__instance = self self.curr_user = User(id=-1, name="???", code="???")
def add(): form = UserForm() if form.validate_on_submit: User(**get_data(form)) flash('User added') return redirect(url_for('user.show_all')) return render_template('/user/add.html', form=form)
def signup(): print("What's your username?") name = input() print("What's is the secret code?") code = input() UserHandler.get_instance().set_global_curr_user(dbo_user.add_user(User(-1, name, code)))
def get(self): if not self.request.get('code'): redirect_url = self.request.get( 'target') or self.request.referer or '/' self.redirect('/authenticate?' + urllib.urlencode({ 'callback': self.request.path, 'handler_data': redirect_url, })) return OAuthBaseHandler.GetTokenFromCode(self) if not self.auth_token: return response = self.GetWcaApi('/api/v0/me') wca_info = json.loads(response)['me'] self.session['wca_account_number'] = wca_info['id'] self.session['login_time'] = ( datetime.datetime.now() - datetime.datetime.utcfromtimestamp(0)).total_seconds() user = User.get_by_id(wca_info['id']) or User(id=wca_info['id']) user.FromDict(json.dumps(wca_info)) user.last_login = datetime.datetime.now() user.put() self.redirect(str(self.handler_data))
def get_user(self, discord_id=None, username=None, discriminator=None, email=None) -> Union[User, bool]: todo_ref = self.db.collection(os.getenv('DISCORD_DB_PATH') + '/users') if discord_id: doc = todo_ref.document(str(discord_id)).get() print(doc.to_dict()) return User(doc.to_dict()['username'], doc.to_dict()['discriminator'], doc.to_dict()['discord_id'], doc.to_dict()['group_name'], doc.to_dict()['email']) if doc.to_dict() else None else: for usr in todo_ref.stream(): if (username is not None and usr.to_dict()['username'] == username) and ( discriminator is not None and discriminator == usr.to_dict()['discriminator']) or usr.to_dict()['email'] == email: return User(usr.to_dict()['username'], usr.to_dict()['discriminator'], usr.to_dict()['discord_id'], usr.to_dict()['group_name'], usr.to_dict()['email']) return None
def test_logout(self): login = '******' password = '******' src.main.db.session.add(User(login, password)) src.main.db.session.commit() json_payload = {"login": login, "password": password} response = self.app.post('/v1/auth/login', data=json.dumps(json_payload), headers={'Content-Type': 'application/json'}) self.assertEquals(response.status_code, 200) token = json.loads(response.get_data())['token'] logout_json_payload = {"token": token} self.app.post('/v1/auth/logout', data=json.dumps(logout_json_payload), headers={'Content-Type': 'application/json'}) response = self.app.get('/v1/client', headers={ 'Content-Type': 'application/json', 'token': token }) self.assertEquals(response.status_code, 403)
def import_users(): global users (row_success, row_error) = (0, 0) ses = db_session() users = read_users(full_user_csv) users = users[:-10] # drop last 10 rows for user in users.values: try: record = User( **{ # "id": user[0], # - nie wstawiam id, bo popsuje auto increment "full_name": user[1], "email": user[2], "hashed_password": user[3], "is_active": user[4], }) ses.add(record) ses.commit() row_success += 1 except: ses.rollback() ses = db_session() row_error += 1 ses.close() print(f"User table results: success: {row_success}, failed: {row_error}")
def facebook_logged_in(facebook_blueprint, token): if not token: flash("Failed to log in.", category="error") return False resp = facebook_blueprint.session.get("/me?fields=id,name,email") if not resp.ok: msg = "Failed to fetch user info." flash(msg, category="error") return False info = resp.json() print(f"Info is {info}") user_id = info["id"] # Find this OAuth token in the database, or create it query = OAuth.query.filter_by( provider=facebook_blueprint.name, provider_user_id=user_id, ) try: oauth = query.one() except NoResultFound: oauth = OAuth( provider=facebook_blueprint.name, provider_user_id=user_id, token=token, ) if oauth.user: login_user(oauth.user) flash("Successfully signed in.") else: # Create a new local user account for this user user = User( fb_username=info["name"], email=info["email"], ) # Associate the new local user account with the OAuth token oauth.user = user # Save and commit our database models db.session.add_all([user, oauth]) db.session.commit() # Log in the new local user account login_user(user) flash("Successfully signed in.") # Disable Flask-Dance's default behavior for saving the OAuth token token_query = Token.query.filter_by(user_id=current_user.id) try: token = token_query.one() except NoResultFound: token = Token(user_id=current_user.id, uuid=str(uuid.uuid4().hex)) db.session.add(token) db.session.commit() print(current_user.id) return redirect("http://localhost:3000/?api_key={}".format(token.uuid))
def seed_db(): for i in range(100): experiences = [] for j in range(randint(0, 3)): start_date = fake.date_between(start_date="-30y", end_date="-10y") end_date = fake.date_between(start_date="-30y", end_date="-10y") experience_summary_sentences = randint(1, 5) experience = Experience( company_name=fake.company(), position_title=fake.job(), start_date=start_date, end_date=end_date, description=fake.paragraph( nb_sentences=experience_summary_sentences, variable_nb_sentences=True, ext_word_list=None, ), ) db.session.add(experience) experiences.append(experience) password = fake.word().encode() user = User( first_name=fake.first_name(), last_name=fake.last_name(), city_state=f"{fake.city()},{fake.state()}", phone_number=fake.phone_number(), email_address=fake.ascii_safe_email(), password=hashpw(password, gensalt()), experiences=list(experiences), ) db.session.add(user) db.session.commit()
def from_dao(obj): return User( name=obj['name'], face_embedding=np.array(obj['face_embedding']), uuid=obj['_id'], phone_number=obj['phone_number'] )
def register(): if request.method == 'POST': data = request.get_json()['input'] username = data['username'] email = data['email'] password_hash = data['password'] mobile = data['mobile'] # address = data['address'] check_mobile = User.query.filter_by(mobile=mobile).first() if check_mobile: return jsonify({'false': 'existed mobile'}) user = User.query.filter_by(email=email).first() if user: print("You've already have account, please sign in") if not user: user = User(email=email, username=username, mobile=mobile) user.set_password(password_hash) db.session.add(user) db.session.commit() new_token = Token(user_id=user.id, uuid=str(uuid.uuid4().hex)) db.session.add(new_token) db.session.commit() print("Registered success!", user.email) return jsonify({ 'email': email, 'username': username, 'mobile': mobile, "token": new_token.uuid }) return jsonify({'false': 'false'})
def get_top(type: str, uid: int) -> Optional[User]: if type not in db: return None if uid not in db[type]: return None replylove__ignore = CONFIG.get('replylove__ignore', []) if uid in replylove__ignore: return None replylove__dragon_lovers = CONFIG.get('replylove__dragon_lovers', []) if uid in replylove__dragon_lovers: return User(0, 0, 'drakon', '🐉') sorted: List[Tuple[int, int]] = sort_dict(db[type][uid]) if len(sorted) == 0: return None replylove__ignore_pairs = CONFIG.get('replylove__ignore_pairs', {}).get(str(chat_id), {}).get(str(uid), []) for result_uid, count in sorted: if count < 5: continue if uid == result_uid: continue if result_uid in replylove__dragon_lovers: continue if result_uid in replylove__ignore: continue if result_uid in replylove__ignore_pairs: continue return User.get(result_uid) return None
def get_top_pair(uid: int) -> Optional[User]: replylove__dragon_lovers = CONFIG.get('replylove__dragon_lovers', []) if uid in replylove__dragon_lovers: return User(0, 0, 'drakon', '🐉') replylove__ignore = CONFIG.get('replylove__ignore', []) replylove__ignore_pairs = CONFIG.get('replylove__ignore_pairs', {}).get(str(chat_id), {}).get(str(uid), []) pairs: List[Tuple[str, int]] = sort_dict(db['pair']) for pair, count in pairs: a_uid, b_uid = [get_int(x) for x in pair.split(',')] strast = None if a_uid is None or b_uid is None: continue if count < 5: continue if uid == a_uid and a_uid == b_uid: continue if any(x in replylove__dragon_lovers for x in (a_uid, b_uid)): continue if any(x in replylove__ignore for x in (uid, a_uid, b_uid)): continue if any(x in replylove__ignore_pairs for x in (a_uid, b_uid)): continue if uid == a_uid: strast = User.get(b_uid) if uid == b_uid: strast = User.get(a_uid) if strast: return strast return None
def save(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] user = User(username, password) user.save() return
def registration(self): """ Возвращает пользователя. Либо в случае неудачи raise RegistraionError """ def get_password(): """ Ввести пароль и подтвердить его. Либо возвращает 1, если не получилось. Либо финальный пароль """ password = raw_input("Пароль: ") repeat_password = raw_input("Повторите пароль: ") if password != repeat_password: print 'Пароли не совпадают' print '1 - Повторить ввод паролей' print 'Любой символ - выход' choice = raw_input("Ваш выбор: ") if choice == '1': get_password() else: return -1 else: return password try: print 'Регистрация' username = raw_input("Имя пользователя: ") password = get_password() if password == -1: raise RegistrationError('Не зарегистрирован') name = raw_input( "Введите имя (не обязательно - нажать Enter): ") or None email = raw_input( "Введите Email (не обязательно - нажать Enter): ") or None if (email is not None) and ("@" not in email or "." not in email): raise ValueError('Некорректный формат Email-а') user = User(username=username, password=password, name=name, email=email) return user except ValueError as err: print 'Ошибка при регистрации:', err.message print '1 - Повторить регистрацию' print 'Любой символ - выйти' choice = raw_input("Выбор: ") if choice == '1': return self.registration() else: raise RegistrationError("Ошибка при регистрации")
def test_should_create_a_user(self): ID = 1 NAME = "John Snow" user = User(ID, NAME) self.assertEqual(user.id, ID) self.assertEqual(user.name, NAME)
def test_calculate_recommended_rewards(self): user = User(id=19, points=600) rewards = RewardsEngine(QueueService(3, 'rewards', 'rewards')) expected_response = {'Weekend Ticket': 2, 'General Ticket': 1} self.assertEqual(rewards.calculate_recommended_rewards(user), expected_response)
def SetUp(self): """ Запускается в начале каждого теста, создает пользователя для тестирования """ self.real_name, self.real_password = '******', 'password1234' self.user = User(self.real_name, self.real_password) print self.user.username
def create_user(name: str, email: str, password: str, **kwargs) -> Optional[User]: existing_user = UserRepository.get_by_email(email) if existing_user: return None new_user = User(name, email, password, **kwargs) return new_user.save()
def test_constructor_returns_instance_with_correct_values(self): user = User(self.user_mock) self.assertEqual(user.first_name, 'Unit Test') self.assertEqual(user.last_name, 'User') self.assertEqual(user.username, 'unittest.user') self.assertEqual(user.password, 'chapisco100!') self.assertEqual(user.access_level, 9) self.assertEqual(user.email, '*****@*****.**')
def add_user_by_picture_name_phone_number(self, img: Image, name, phone_number): face_locs = self.fh.get_face_locations(img) assert len(face_locs) == 1 embedding = self.fh.get_face_encoding_by_location(img, face_locs[0]) user = User(name, embedding, phone_number=phone_number) self.fh.add_face_by_user(user) UserDao(user).save()
def save(self, **kwargs): print(self.validated_data['username']) user = User(username=self.validated_data['username'], password=hashers.SHA1PasswordHasher().encode( self.validated_data['password'], salt='1123'), full_name=self.validated_data['full_name'], code=self.validated_data['code'], role=self.validated_data['role']) user.save()
def test_check_password(): from src.models.user import User u = User() assert u.check("password", "password123") assert u.check("password", "asdf") == "Password length must be at least 6" assert u.check( "password", "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" ) == "Password length must be at most 120"
def save(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] image = request.files['image'].read() user = User(username, password, image) user.save() # return return "Image Uploaded ML Processing"
def post(self): args = register_args.parse_args() hashed_pass = generate_password_hash(args['password']) new_user = User(name=args['name'], password=hashed_pass, role=args['role']) saved = new_user.save() user = updateDocFields(saved) return user, 201