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 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 = 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 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 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 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 get():
session = db_session.create_session()
cur_user = current_user_from_db(session)
return jsonify({'chats': [chat.to_dict() for chat in cur_user.chats]})
def post():
args = post_parser.parse_args()
abort_if_user_not_found(args.friend_id)
session = db_session.create_session()
cur_user = current_user_from_db(session)
friend = user_by_alt_id(session, args.friend_id)
action = args.action
if action in ('accept', 'deny'):
request_from_friend = session.query(UsersFriends).filter(
(UsersFriends.inviter_id == friend.id)
& (UsersFriends.invitee_id == cur_user.id)).first()
request_from_cur_user = session.query(UsersFriends).filter(
(UsersFriends.inviter_id == cur_user.id)
& (UsersFriends.invitee_id == friend.id)).first()
if request_from_friend:
if action == 'accept':
if request_from_friend.is_accepted is True:
return jsonify({
'error':
f'Friend request from '
f'{friend.alternative_id} already accepted'
})
request_from_friend.is_accepted = True
# Создаём чат между пользователями сразу, т.к. иначе на
# главной странице пользователь не будет добавлен в
# комнату SocketIO с чатом между этими пользователями, и
# соответственно не будет получать сообщения от этого
# пользователя
create_chat(session, cur_user, friend)
else:
if request_from_friend.is_accepted is False:
return jsonify({
'error':
f'Friend request from {friend.id} already '
f'denied'
})
request_from_friend.is_accepted = False
elif request_from_cur_user:
if action == 'deny':
request = UsersFriends()
request.inviter_id = friend.id
request.invitee_id = cur_user.id
request.is_accepted = False
session.add(request)
session.delete(request_from_cur_user)
else:
return jsonify(
{'error': 'Only invitee can accept friend request'})
else:
if not (request_from_friend or request_from_cur_user):
return jsonify({
'error':
'{0} didn\'t send friend request to {1}'.format(
friend.alternative_id, cur_user.alternative_id)
})
elif action == 'add':
request = session.query(UsersFriends).filter(
(UsersFriends.inviter_id == cur_user.id)
& (UsersFriends.invitee_id == friend.id)).first()
if request:
return jsonify({
'error':
'Friend request to {0} already sent'.format(
friend.alternative_id)
})
users_friends_obj = UsersFriends(inviter_id=cur_user.id,
invitee_id=friend.id)
session.add(users_friends_obj)
session.commit()
return jsonify({'success': 'OK'})
