def add_some_user():
user1 = User(username="******", email="*****@*****.**",
password="******")
user2 = User(username="******", email="*****@*****.**",
password="******")
user3 = User(username="******", email="*****@*****.**",
password="******")
return [user1, user2, user3]
def register_user(ch, **kwargs):
payload = json.loads(kwargs.get('body'))
repository: UserRepository = current_app.injector.get(UserRepository)
repository.save(
User(id=payload['id'],
name=payload['name'],
last_name=payload['last_name']))
def registration():
body = request.get_json()
user = User(**body)
user.hash_password()
user.save()
id = user.id
return {'id': str(id)}, 200
def test_update_by_regular_user(db_session: Session):
example_user = User(
email='*****@*****.**',
username='******',
hashed_password='******',
is_admin=False
)
db_session.add(example_user)
db_session.commit()
user_dict = {
'username': '******',
'is_admin': True
}
db_user = db_session.query(User).first()
updated_user = update(db_session, db_user=db_user, user_to_update=user_dict, updated_by_admin=False)
db_user: User = db_session.query(User).first()
assert db_user.email == example_user.email == updated_user.email
assert db_user.hashed_password == example_user.hashed_password == updated_user.hashed_password
assert db_user.is_admin == example_user.is_admin == updated_user.is_admin
assert db_user.username == user_dict['username'] == updated_user.username
def complete_alt_login(update, context):
session = Session()
role = context.user_data.get('role', '-')
name = context.user_data.get('name', '-')
patronymic = context.user_data.get('patronymic', '-')
surname = context.user_data.get('surname', '-')
group = '-'
post = '-'
directions = '-'
if role == 'student':
group = context.user_data.get('group', '-')
elif role == 'mentor':
post = context.user_data.get('post', '-')
directions = context.user_data.get('directions', '-')
user = User(tg_chat_id=update.message.chat_id,
role=role,
name=name,
surname=surname,
patronymic=patronymic,
group=group,
post=post,
directions=directions)
try:
schedule_notifications_job(context, user)
context.job_queue.run_daily(schedule_notifications_job,
time=datetime.time(
hour=1,
minute=0,
tzinfo=pytz.timezone('Etc/GMT-3')),
days=(0, 1, 2, 3, 4, 5),
context=user,
name='Обновить расписание')
user.is_notified = True
except (NoEntriesException, WentWrongException, ChoicesException):
context.bot.send_message(chat_id=user.tg_chat_id,
text=alt_login_replicas['notification_error'])
session.add(user)
context.bot.send_message(
chat_id=update.message.chat_id,
text=f"Здравствуйте, {user.name} {user.patronymic}. Вы авторизованы.")
context.user_data.pop('role', None)
context.user_data.pop('name', None)
context.user_data.pop('patronymic', None)
context.user_data.pop('surname', None)
context.user_data.pop('group', None)
context.user_data.pop('post', None)
context.user_data.pop('directions', None)
session.commit()
session.close()
return user
def test_post_login_should_return_302(app, client):
with app.app_context():
user = User(username='******', password='******')
db.session.add(user)
db.session.commit()
rv = client.post('/login', data={'username': '******', 'password': '******'})
assert rv.status_code == 302
assert rv.headers['Location'] == 'http://localhost/'
def create_user(username: str, password: str):
new_user = User(username, password)
Session.add(new_user)
try:
Session.commit()
except Exception as e:
logger.error(f'Can not write new user to DB: {e}')
raise InternalServerError('Can not create user')
def _create_user_from_data(data: dict) -> User:
"""Создание модели пользователя из данных."""
user = User(
email=data["email"],
username=data["username"],
)
user.set_password(data["password"])
user.set_role(data["role"])
return user
def register(service: RegistrationService):
form = RegistrationForm(data=request.get_json())
if not form.validate():
return {'success': False, 'errors': form.errors}
user = User()
form.populate_obj(user)
success, errors = service.register(user)
if errors:
form.email.errors.append(errors)
return {'success': success, 'errors': form.errors}
def create(self, db: Session, *, obj_in: UserCreate) -> User:
obj_in_data = jsonable_encoder(obj_in)
hashed_password = get_password_hash(obj_in_data["password"])
del obj_in_data["password"]
obj_in_data["hashed_password"] = hashed_password
db_obj = User(**obj_in_data)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def create(db: Session, obj_input: UserCreate):
db_obj = User(
oid=obj_input.oid,
nickname=obj_input.nickname,
is_active=obj_input.is_active,
is_superuser=obj_input.is_superuser
)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def create(db_session: Session, new_user: UserCreate) -> User:
user = User(
username=new_user.username or new_user.email.split('@')[0],
email=new_user.email,
hashed_password=get_password_hash(new_user.password),
is_admin=new_user.is_admin
)
db_session.add(user)
db_session.commit()
return user
def test_get_all(db_session: Session):
example_users = [
User(
email='*****@*****.**',
username='******',
hashed_password='******',
is_admin=False
),
User(
email='*****@*****.**',
username='******',
hashed_password='******',
is_admin=False
)
]
db_session.add_all(example_users)
db_session.commit()
users = get_all(db_session)
assert len(users) == 2
async def name(message: types.Message):
uid = message.from_user.id
with session_scope() as session:
user = User(uid=uid,
username=message.from_user.username,
full_name=message.text) \
.insert_me(session)
logging.info(f'user created: {user}')
await message.reply(MESSAGES['pleased_to_meet_you'],
parse_mode=ParseMode.MARKDOWN,
reply=False)
await show_event_list_task(uid)
def generate(count: int):
service = current_app.injector.get(RegistrationService)
with click.progressbar(range(int(count))) as bar:
for _ in bar:
fake = Faker()
user = User()
user.name = fake.first_name()
user.last_name = fake.last_name()
user.email = fake.email()
user.birth_date = fake.date_time().date().__str__()
user.password = fake.password()
user.city = fake.city()
service.register(user)
def create(self, db: Session, *, obj_in: UserCreate) -> User:
db_obj = User(email=obj_in.email,
password_hash=get_password_hash(obj_in.email +
obj_in.password),
name=obj_in.name,
login=obj_in.login,
avatar_url=obj_in.avatar_url,
is_active=obj_in.is_active,
is_superuser=obj_in.is_superuser)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def register():
form = RegisterForm()
if form.validate_on_submit():
try:
user = User(
username=form.username.data,
password=form.password.data
)
db.session.add(user)
db.session.commit()
return redirect(url_for('auth.login'))
except IntegrityError:
form.username.errors.append('Username already taken.')
return render_template('auth/register.html', form=form)
def create_user(db: Session, user: schemas.UserCreate):
hashed_password = get_password_hash(user.password)
db_user = User(
first_name=user.first_name,
last_name=user.last_name,
email=user.email,
is_active=user.is_active,
is_superuser=user.is_superuser,
hashed_password=hashed_password,
)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def init(db_session: Session) -> None:
user = db_session.query(User).filter(
User.username == settings.FIRST_ADMIN).first()
if not user:
logger.info('Initializing database')
user = User(email='*****@*****.**',
username=settings.FIRST_ADMIN,
hashed_password=get_password_hash(
settings.FIRST_ADMIN_PASSWORD),
is_admin=True)
db_session.add(user)
db_session.commit()
logger.info('Database initialized')
def users():
return [
User(
username="******",
email="*****@*****.**",
hashed_password=get_password_hash("secret_1"),
is_active=True,
is_superuser=True,
),
User(
username="******",
email="*****@*****.**",
hashed_password=get_password_hash("secret_2"),
is_active=True,
is_superuser=False,
),
User(
username="******",
email="*****@*****.**",
hashed_password=get_password_hash("secret_3"),
is_active=False,
is_superuser=False,
),
]
def create_user(db: Session, user_data: UserCreate) -> User:
user = User(
username=user_data.username,
email=user_data.email,
hashed_password=get_password_hash(user_data.password),
is_active=user_data.is_active,
is_superuser=user_data.is_superuser,
)
db.add(user)
db.commit()
db.refresh(user)
return user
def create(db_session: Session,
*,
username: str,
email: str,
password: str,
is_superuser: bool = False,
is_active: bool = False):
user = User(username=username,
email=email,
password=password,
is_superuser=is_superuser,
is_active=is_active)
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return user
def test_remove(db_session):
example_user = User(
email='*****@*****.**',
username='******',
hashed_password='******',
is_admin=False
)
db_session.add(example_user)
db_session.commit()
users = db_session.query(User).all()
assert len(users) == 1
remove(db_session, example_user)
users = db_session.query(User).all()
assert len(users) == 0
def post_users():
user_id = get_jwt_identity()
if user_id == "admin":
file = request.files['file']
file.save('import.json')
with open("import.json", "r") as read_file:
file = json.load(read_file)
if file:
data = file
for order in data["orders"]:
id = order["_id"]["$oid"]
order.pop("_id", None)
orders = Order(**order, id=id)
orders.save()
for user in data["users"]:
id = user["_id"]["$oid"]
user.pop("_id", None)
users = User(**user, id=id)
users.save()
return '', 200
return {"msg": "log in as admin"}, 401
def register():
"""
Register form function.
"""
reg_form = RegisterForm()
if reg_form.validate_on_submit():
t_username = reg_form.username.data
t_password = reg_form.password.data
t_email = reg_form.email.data
user = User.query.filter_by(user_name=t_username.lower()).first()
if user:
flash('This Username already exist... Try other!')
return redirect(url_for('register'))
new_user = User(username=t_username,
email=t_email,
password=t_password)
try:
db.session.add(new_user)
db.session.commit()
flash('Success ! Try Login...')
return redirect(url_for('login'))
except Exception as err:
db.session.rollback()
return '<h3>Some error...</h3>{0}'\
.format(err)
return render_template('register.html', form=reg_form)
def create(username, password, bio=None, photo=None):
user = User(username=username, password=password, bio=bio, photo=photo)
db.session.add(user)
db.session.commit()
return user
def do_login_auth(update, context):
login_data = {
'email': context.user_data['email'],
'password': context.user_data['password']
}
login_result = requests.post(url=LOGIN_URL, data=login_data).json()
if login_result['auth']:
session = Session()
user_info = login_result['user']
if user_info['role'] == 'student':
user = User(tg_chat_id=update.message.chat_id,
role=user_info['role'],
surname=user_info['surname'],
name=user_info['name'],
patronymic=user_info['patronymic'],
group=user_info['group'],
email=user_info['email'],
phone=user_info['phone'],
post='',
directions='',
is_notified=True,
is_admin=False)
elif user_info['role'] == 'mentor':
user = User(tg_chat_id=update.message.chat_id,
role=user_info['role'],
surname=user_info['surname'],
name=user_info['name'],
patronymic=user_info['patronymic'],
group='',
email=user_info['email'],
phone=user_info['phone'],
post=user_info['post'],
directions=user_info['directions'])
else:
context.bot.send_message(
chat_id=update.message.chat_id,
text=auth_replicas['something_gone_wrong'])
return ConversationHandler.END
try:
schedule_notifications_job(context, user)
context.job_queue.run_daily(schedule_notifications_job,
time=datetime.time(
hour=1,
minute=0,
tzinfo=pytz.timezone('Etc/GMT-3')),
days=(0, 1, 2, 3, 4, 5),
context=user,
name='Обновить расписание')
user.is_notified = True
except (NoEntriesException, WentWrongException, ChoicesException):
context.bot.send_message(chat_id=user.tg_chat_id,
text=auth_replicas['notification_error'])
session.add(user)
session.commit()
context.bot.send_message(
chat_id=update.message.chat_id,
text=
f"Здравствуйте, { user.name } { user.patronymic }. Вы авторизованы."
)
session.close()
else:
if 'message' in context.user_data.keys():
if 'message' == "User didn't activated account.":
context.bot.sendMessage(
chat_id=update.message.chat_id,
text=auth_replicas['not_activated_account'])
else:
context.bot.sendMessage(chat_id=update.message.chat_id,
text=auth_replicas['something_gone_wrong'])
del context.user_data['email']
del context.user_data['password']
return ConversationHandler.END
def create_user(username, password):
user = User(username=username, password=password)
db.session.add(user)
db.session.commit()
click.echo('Created user {}'.format(username))
def example_user():
return User(email='*****@*****.**',
username='******',
hashed_password=pwd_context.hash('passwd'))
def example_user():
return User(id=1,
email='*****@*****.**',
username='******',
is_admin=False)