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
