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]