def put():
args = put_parser.parse_args()
session = db_session.create_session()
user = current_user_from_db(session)
if error := set_avatar_to_user(user, args.avatar):
return error
def get():
args = list_get_parser.parse_args()
session = db_session.create_session()
cur_user = current_user_from_db(session)
type_ = args.type
query = session.query(Users)
if type_ == 'incoming':
friend_dicts = []
for request in cur_user.incoming_friend_requests:
request: UsersFriends
if request.is_accepted is not True:
user = query.filter(Users.id == request.inviter_id).first()
friend_dict = user.to_dict(only=USERS_PUBLIC_ONLY)
friend_dict['is_accepted'] = request.is_accepted
friend_dicts += [friend_dict]
return jsonify({'friends': friend_dicts})
elif type_ == 'outgoing':
friends = []
for request in cur_user.outgoing_friend_requests:
request: UsersFriends
if not request.is_accepted:
user = query.filter(Users.id == request.invitee_id).first()
friends += [user]
return jsonify({
'friends':
[user.to_dict(only=USERS_PUBLIC_ONLY) for user in friends]
})
else:
return jsonify({
'friends': [
user.to_dict(only=USERS_PUBLIC_ONLY)
for user in cur_user.friends
]
})
def sign_up(email, username, password, photo=None):
with create_session() as session:
if session.query(User).filter(User.email == email).first() is not None:
raise EmailAlreadyExists(email)
if session.query(User).filter(
User.username == username).first() is not None:
raise UsernameAlreadyExists(username)
if not is_password_secure(password):
raise InsecurePassword
if not check_username(username):
raise InvalidUsername
user = User(email=email, username=username)
user.set_password(password)
confirmation_code = random.randint(100000, 999999)
user.confirmation_code = confirmation_code
send_email(
"Подтверждение учетной записи Stream Support",
sender=os.environ.get("MAIL_USERNAME"),
recipients=[email],
text_body=render_template("email/confirmation.txt",
confirmation_code=confirmation_code),
html_body=render_template("email/confirmation.html",
confirmation_code=confirmation_code))
session.add(user)
session.commit()
if photo:
photo_filename = f"{generate_photo_filename(user.id)}.{photo.filename.split('.')[-1]}"
photo.save(f"app/static/img/profile-photos/{photo_filename}")
user.photo = photo_filename
flask_login.login_user(user)
def post():
"""Возвращает ключ доступа и ключ обновления к API в формате
{access_token: "ключ", refresh_token: "ключ"}.
Параметры запроса:
email: адрес электронной почти пользователя, для которого нужно
получить API ключ;
password: пароль этого пользователя.
Если такого email нет, возвращается ошибка 404. Если пароль неверный -
ошибка 401.
Если все данные верны, возвращается JWT токен, содержащий alternative_id
пользователя.
"""
args = login_post_parser.parse_args()
email = args.email
session = db_session.create_session()
user: Users = session.query(Users).filter(Users.email == email).first()
if not user or not user.check_password(args.password):
abort(404, message='Bad email or password')
return
user_id = user.alternative_id
try:
if expires_in := args.get('expires_in'):
expires_in = datetime.timedelta(seconds=expires_in)
except OverflowError:
return jsonify({'error': 'expires_in value too big'})
access_token = create_access_token(identity=user_id,
expires_delta=expires_in)
refresh_token = create_refresh_token(identity=user_id)
return jsonify(access_token=access_token, refresh_token=refresh_token)
def confirm_email(code):
with create_session() as session:
user = session.query(User).get(current_user.id)
if user.confirmation_code != code:
raise InvalidConfirmationCode
user.confirmed = True
user.confirmation_code = None
def post(self):
# метод post с помощью ChatParticipants
# args = post_parser.parse_args()
# chat_participants = args['chat_participants']
# chat = Chats(
# title=args.get('title')
# )
# session = db_session.create_session()
# session.add(chat)
# for user in chat_participants:
# chat_participants_obj = ChatParticipants(
# user_id=user.id,
# chat_id=chat.id
# )
# session.add(chat_participants_obj)
# session.commit()
# return jsonify({'success': 'OK'})
args = post_parser.parse_args()
session = db_session.create_session()
users = []
for alt_id in [args.first_author_id, args.second_author_id]:
abort_if_user_not_found(alt_id)
users += [user_by_alt_id(session, alt_id)]
# chat = Chats(
# # title=args.get('title'),
# first_author_id=args['first_author_id'],
# second_author_id=args['second_author_id']
# )
create_chat(session, *users)
return jsonify({'success': 'OK'})
def post():
args = post_parser.parse_args()
session = db_session.create_session()
if session.query(Users).filter(Users.email == args['email']).first():
return jsonify({'error': 'This user already exists'})
user = Users()
if error := set_avatar_to_user(user, args.avatar):
return error
def create_alternative_id():
"""Создаёт уникальный альтернативный id для пользователя."""
session = db_session.create_session()
alt_id = generate_alternative_id()
query = session.query(Users).exists().where(Users.alternative_id == alt_id)
while session.query(query).scalar():
alt_id = generate_alternative_id()
return alt_id
def log_in(login, password, remember_me=False):
with create_session() as session:
user = session.query(User).filter((User.email == login)
| (User.username == login)).first()
if user is None or not user.check_password(password):
raise InvalidLoginOrPassword
flask_login.login_user(user, remember=remember_me)
return True
def set_active_server(server_id):
with create_session() as session:
user = session.query(User).get(current_user.id)
server = session.query(MCServer).get(server_id)
if user is None or server is None:
raise ResourceNotFound
if server not in user.mc_servers:
raise ResourceNotFound
user.active_mc_server = server_id
def set_types_table():
"""Заполняет таблицу AdditivesTypes значениями."""
session = db_session.create_session()
# Очистим таблицу и заполним её заново
session.query(additives_types.AdditivesTypes).delete()
for title in ADDITIVE_TYPES_TITLES:
ad_type = additives_types.AdditivesTypes()
ad_type.title = title
session.add(ad_type)
session.commit()
def get_user_json(username):
with create_session() as session:
user = session.query(User).filter(User.username == username).first()
if user is None:
raise ResourceNotFound
if current_user.is_authenticated and user == current_user and current_user.confirmed:
return user.to_dict(additional=[
"email", "active_mc_server", "mc_servers", "confirmed", "money"
])
return user.to_dict()
def delete_server(server_id):
with create_session() as session:
server = session.query(MCServer).get(server_id)
if server is None:
raise ResourceNotFound
if current_user != server.owner:
raise ResourceNotFound
if server.owner.active_mc_server == server.id:
server.owner.active_mc_server = None
server.owner.mc_servers.remove(server)
session.delete(server)
def edit(twitch, youtube, photo):
with create_session() as session:
user = session.query(User).get(current_user.id)
user.twitch = twitch
user.youtube = youtube
if photo:
if user.photo:
os.remove(f"app/static/img/profile-photos/{user.photo}")
photo_filename = f"{generate_photo_filename(user.id)}.{photo.filename.split('.')[-1]}"
photo.save(f"app/static/img/profile-photos/{photo_filename}")
user.photo = photo_filename
def get(user_id=None):
identity = get_jwt_identity()
user_id = user_id or identity
if not user_id:
abort(400, message='User not specified')
abort_if_user_not_found(user_id)
session = db_session.create_session()
user = user_by_alt_id(session, user_id)
if current_user and user_id == current_user.user_id:
return jsonify({'user': user.to_dict(only=USERS_PRIVATE_ONLY)})
elif identity and user in current_user_from_db(session).friends:
return jsonify({'user': user.to_dict(only=USERS_PRIVATE_ONLY)})
return jsonify({'user': user.to_dict(only=USERS_PUBLIC_ONLY)})
def get():
args = get_parser.parse_args()
chat_id = args.chat_id
chat_with = args.chat_with
if not (chat_id or chat_with) or (chat_id and chat_with):
return jsonify(
{'error': 'You must specify chat_id OR chat_with param'})
session = db_session.create_session()
cur_user = current_user_from_db(session)
if chat_id:
chat = session.query(Chats).filter(Chats.id == chat_id).first()
chat: Chats
if error := error_if_user_not_chat_member(cur_user, chat):
return error
if not chat:
abort(404, message=f'Chat {chat_id} not found')
return
def delete():
args = delete_parser.parse_args()
alt_id = args.friend_id
abort_if_user_not_found(alt_id)
session = db_session.create_session()
user = user_by_alt_id(session, alt_id)
cur_user = current_user_from_db(session)
request = session.query(UsersFriends).filter(
(UsersFriends.inviter_id == cur_user.id)
& (UsersFriends.invitee_id == user.id)).first()
if request:
session.delete(request)
session.commit()
return jsonify({'success': 'OK'})
else:
return jsonify(
{'error': f'You didn\'t send friend request to user {alt_id}'})
def post():
args = tokens_args.post_parser.parse_args()
session = db_session.create_session()
token = session.query(Tokens).filter(
Tokens.token == args.token).first()
if token:
user: Users = session.query(Users).filter(
Users.email == token.email).first()
if user:
user.is_confirmed = True
session.commit()
return jsonify({'success': 'OK'})
else:
abort(404, message=f'No user with token {args.token}')
return
else:
abort(404, message=f'Token {args.token} not found')
def get():
args = list_get_parser.parse_args()
receiver_id = args.receiver_id
chat_id = args.chat_id
session = db_session.create_session()
cur_user = current_user_from_db(session)
if receiver_id or chat_id:
if receiver_id:
receiver = user_by_alt_id(session, receiver_id)
chat = get_chat(session, cur_user, receiver)
else:
chat = session.query(Chats).filter(Chats.id == chat_id).first()
if not chat:
return jsonify({'messages': []})
query = session.query(Messages)
date = datetime.datetime.fromtimestamp(args.date)
messages = query.filter((Messages.sending_date > date)
& (Messages.chat_id == chat.id)).order_by(
Messages.sending_date).all()
messages_serialized = [msg.to_dict() for msg in messages]
return jsonify({'messages': messages_serialized})
else:
chats_ids = list(
map(
itemgetter(0),
session.query(ChatParticipants.chat_id).filter(
ChatParticipants.user_id == cur_user.id).all()))
chats_query = session.query(Chats)
msg_query = session.query(Messages).order_by(
Messages.sending_date.desc())
messages = []
users_query = session.query(Users)
for chat_id in chats_ids:
chat: Chats = chats_query.get(chat_id)
if chat.first_author_id == cur_user.id:
chat_with = users_query.get(
chat.second_author_id).alternative_id
else:
chat_with = users_query.get(
chat.first_author_id).alternative_id
if last_msg := msg_query.filter(
Messages.chat_id == chat_id).first():
last_message_dict = last_msg.to_dict()
last_message_dict['chat_with'] = chat_with
messages += [last_message_dict]
return jsonify({'messages': messages})
def delete(self):
args = delete_parser.parse_args()
alt_id = args.get('user_id')
chat_id = args.get('id')
session = db_session.create_session()
cur_user = current_user_from_db(session)
if chat_id:
abort_if_chat_not_found(chat_id)
chat = session.query(Chats).get(chat_id)
if error := error_if_user_not_chat_member(cur_user, chat):
return error
messages = session.query(Messages).filter(
Messages.chat_id == chat_id)
for message in messages:
session.delete(message)
session.delete(chat)
session.commit()
return jsonify({'success': 'OK'})
def get():
args = tokens_args.get_parser.parse_args()
session = db_session.create_session()
token = session.query(Tokens).filter(
Tokens.email == args.email).first()
if token:
password = args.password
user: Users = session.query(Users).filter(
Users.email == token.email).first()
if user:
if user.check_password(password):
return jsonify({'token': token.token})
else:
return abort(401, message='Bad password')
else:
return abort(404, message=f'No user with email {args.email}')
else:
return abort(404,
message=f'Token for email {args.email} not found')
def friends(self):
"""Свойство возвращает всех друзей пользователя в виде FriendsList
(друзья - пользователи, заявки в друзья которых принял текущий
пользователь, либо пользователи, которые приняли заявку в друзья от
текущего)"""
session = db_session.create_session()
friends_list = FriendsList()
users_query = session.query(Users)
for friend in self.incoming_friend_requests:
if friend.is_accepted:
user = users_query.filter(
Users.id == friend.inviter_id).first()
friends_list.append(user)
for friend in self.outgoing_friend_requests:
if friend.is_accepted:
user = users_query.filter(
Users.id == friend.invitee_id).first()
friends_list.append(user)
return friends_list
def create_server(name,
host,
rcon_port,
rcon_password,
nickname,
make_active=True):
with create_session() as session:
user = session.query(User).get(current_user.id)
for server in user.mc_servers:
if server.host == host and server.rcon_port == rcon_port:
raise ServerAlreadyAdded
if not check_connection(host, rcon_port, rcon_password):
raise ServerConnectionError
server = MCServer(name=name,
host=host,
rcon_port=rcon_port,
rcon_password=rcon_password,
nickname=nickname)
user.mc_servers.append(server)
session.commit()
if make_active:
user.active_mc_server = server.id
def act_sand_handler(username):
PRICE = 30
with create_session() as session:
user = session.query(User).get(current_user.id)
streamer = session.query(User).filter(
User.username == username).first()
if streamer is None:
raise ResourceNotFound
if streamer.active_mc_server is None:
raise ResourceNotFound
if user.money < PRICE:
raise NotEnoughMoney
server = session.query(MCServer).get(streamer.active_mc_server)
res = sand_lock(server.nickname, server.host, server.rcon_port,
server.rcon_password)
if res:
user.money -= PRICE
else:
raise RconCommandError
def give_item_handler(username, item_id):
with create_session() as session:
user = session.query(User).get(current_user.id)
streamer = session.query(User).filter(
User.username == username).first()
item = session.query(Item).get(item_id)
if streamer is None or item is None:
raise ResourceNotFound
if streamer.active_mc_server is None:
raise ResourceNotFound
if user.money < item.price:
raise NotEnoughMoney
server = session.query(MCServer).get(streamer.active_mc_server)
item_name = get_minecraft_item_name(item.name)
res = give_item(server.nickname, item_name, 1, server.host,
server.rcon_port, server.rcon_password)
if res:
user.money -= item.price
else:
raise RconCommandError
def post():
args = post_parser.parse_args()
session = db_session.create_session()
cur_user = current_user_from_db(session)
receiver_id = args.receiver_id
chat_id = args.chat_id
if not (chat_id or receiver_id) or (chat_id and receiver_id):
return jsonify(
{'error': 'You must specify chat_id OR receiver_id'})
query = session.query(Chats)
if receiver_id:
receiver = user_by_alt_id(session, receiver_id)
chat = get_chat(session, cur_user, receiver)
if not chat:
if cur_user not in receiver.friends:
return jsonify({
'error':
'User {0} isn\' your friend'.format(
cur_user.alternative_id)
})
create_chat(session, cur_user, receiver)
else:
chat = query.filter(Chats.id == chat_id).first()
if not chat:
return jsonify(
{'error': 'Chat with id {0} not found'.format(chat_id)})
message = Messages(sender_id=cur_user.id,
chat_id=chat.id,
text=args.text)
session.add(message)
session.commit()
emit('new_message',
message.to_dict(),
room=f'chat_{chat.id}',
namespace='/')
return jsonify({'success': 'OK'})
def create_token(user, session=None):
session = session or db_session.create_session()
token = Tokens(token=create_email_token(user.email), email=user.email)
session.add(token)
session.commit()
def get_all_users():
with create_session() as session:
return [
item.to_dict() for item in session.query(User).filter(
User.active_mc_server.isnot(None)).all()
]
def to_dict(self, *args, **kwargs):
session = create_session()
msg_dict = super().to_dict(*args, **kwargs)
if sender_id := msg_dict.get('sender_id'):
user: Users = session.query(Users).get(sender_id)
msg_dict['sender_id'] = user.alternative_id
class UsersListResource(Resource):
@staticmethod
def get():
args = list_get_parser.parse_args()
if limit := args.get('limit'):
if limit > constants.USERS_LIST_RESOURCE_GET_COUNT:
return jsonify({
'error':
'Maximum limit is {0}'.format(
constants.USERS_LIST_RESOURCE_GET_COUNT)
})
else:
limit = constants.USERS_LIST_RESOURCE_GET_COUNT
fields = ['first_name', 'second_name', 'alternative_id']
session = db_session.create_session()
query = session.query(Users)
if search_request := args.search_request:
for word in search_request.split(' '):
req = users_like(fields[0], word)
for i in range(0, len(fields) - 1):
req = req | users_like(fields[i + 1], word)
query = query.filter(req)
else:
field_names = {'user_id': 'alternative_id'}
for key in ['first_name', 'second_name', 'user_id']:
if val := args.get(key):
field = field_names.get(key, key)
query = query.filter(users_like(field, val))
start = args.start
users = query.all()[start:start + limit]
