Ejemplo n.º 1
0
 def Ping(self, request, context):
     with session_scope(self._Session) as session:
         # auth ought to make sure the user exists
         user = session.query(User).filter(User.id == context.user_id).one()
         return api_pb2.PingRes(user_id=user.id,
                                username=user.username,
                                name=user.name,
                                color=user.color)
Ejemplo n.º 2
0
    def Ping(self, request, context):
        with session_scope() as session:
            # auth ought to make sure the user exists
            user = session.query(User).filter(User.id == context.user_id).one()

            # gets only the max message by self-joining messages which have a greater id
            # if it doesn't have a greater id, it's the biggest
            message_2 = aliased(Message)
            unseen_sent_host_request_count = (
                session.query(Message.id)
                .join(HostRequest, Message.conversation_id == HostRequest.conversation_id)
                .outerjoin(
                    message_2, and_(Message.conversation_id == message_2.conversation_id, Message.id < message_2.id)
                )
                .filter(HostRequest.from_user_id == context.user_id)
                .filter(message_2.id == None)
                .filter(HostRequest.from_last_seen_message_id < Message.id)
                .count()
            )

            unseen_received_host_request_count = (
                session.query(Message.id)
                .join(HostRequest, Message.conversation_id == HostRequest.conversation_id)
                .outerjoin(
                    message_2, and_(Message.conversation_id == message_2.conversation_id, Message.id < message_2.id)
                )
                .filter(HostRequest.to_user_id == context.user_id)
                .filter(message_2.id == None)
                .filter(HostRequest.to_last_seen_message_id < Message.id)
                .count()
            )

            unseen_message_count = (
                session.query(Message.id)
                .outerjoin(GroupChatSubscription, GroupChatSubscription.group_chat_id == Message.conversation_id)
                .filter(GroupChatSubscription.user_id == context.user_id)
                .filter(Message.time >= GroupChatSubscription.joined)
                .filter(or_(Message.time <= GroupChatSubscription.left, GroupChatSubscription.left == None))
                .filter(Message.id > GroupChatSubscription.last_seen_message_id)
                .count()
            )

            pending_friend_request_count = (
                session.query(FriendRelationship)
                .filter(FriendRelationship.to_user_id == context.user_id)
                .filter(FriendRelationship.status == FriendStatus.pending)
                .count()
            )

            return api_pb2.PingRes(
                user=user_model_to_pb(user, session, context),
                unseen_message_count=unseen_message_count,
                unseen_sent_host_request_count=unseen_sent_host_request_count,
                unseen_received_host_request_count=unseen_received_host_request_count,
                pending_friend_request_count=pending_friend_request_count,
            )