コード例 #1
0
    def answer_lobby_invite(self, request):
        if not isinstance(request, AnswerLobbyInviteRequest):
            return RpcError(message="Wrong message type, expecting AnswerLobbyInviteRequest", error_code=1)
            
        with db(session):
            query_type = Lobby.query.filter(Lobby.lobby_id==request.lobbyId).first()
            if not query_type:
                return RpcError(message="Lobby does not exists", error_code=2)
            accepted_count = LobbyMembership.query.filter(LobbyMembership.lobby_id==request.lobbyId).filter(LobbyMembership.status=="member").count()

            user_lobby = LobbyMembership.query.filter(LobbyMembership.lobby_id==request.lobbyId).filter(LobbyMembership.user_id==request.userId).first()
            if not user_lobby:
                return RpcError(message="Not permitted to the lobby", error_code=30)

            if(request.answer == "accept"):
                if(query_type.game_type >= accepted_count + 1):
                    session.delete(user_lobby)
                    session.add(LobbyMembership(lobby_id=user_lobby.lobby_id, status="member", user_id=user_lobby.user_id))
                    session.commit()
                    return AnswerLobbyInviteResponse(answer=True)
                else:
                    session.delete(user_lobby)
                    session.commit()
                    return RpcError(message="Lobby is full", error_code=31)
                    
            elif(request.answer == "deny"):
                try:
                    session.delete(user_lobby)
                    session.commit()
                    return AnswerLobbyInviteResponse(answer=True)
            
                except Exception as e:
                    return AnswerLobbyInviteResponse(answer=False)
            
            return RpcError(message="Unknown answer should be accept or deny", error_code=3)
コード例 #2
0
 def add_friend(self, request):
     print "in add_Friend"
     with db(session):
         try:
             friend = User.query.filter(User.email == request.friend_email).first()
             friendship = Friendship(user_id=request.userId, friend_id=friend.id)
             session.add(friendship)
             session.commit()
             return AddFriendResponse(friend_added=True)
         except Exception as e:
             session.rollback()
             return AddFriendResponse(friend_added=False)
コード例 #3
0
    def create_lobby(self, request):
        if not isinstance(request, CreateLobbyRequest):
            return RpcError(message="Wrong message type, expecting CreateLobbyRequest", error_code=1)
            
        lobby = Lobby(game_type = request.gameType, owner_id = request.userId)
        member = LobbyMembership(
            status="member",
            user_id=request.userId
        )
        lobby.lobbymemberships.append(member)

        session.add(lobby)
        session.commit()
        return CreateLobbyResponse(lobbyId=lobby.lobby_id)
コード例 #4
0
    def invite_to_lobby(self, request):
        if not isinstance(request, InviteLobbyRequest):
            return RpcError(message="Wrong message type, expecting InviteLobbyRequest", error_code=1)
            
        if not request.invites:
            return InviteLobbyResponse(friends_invited=False)

        with db(session):
            lobby = Lobby.query.filter(Lobby.lobby_id==request.lobbyId).filter(Lobby.owner_id==request.userId).first()
            if(lobby==None):
                return RpcError(message="No permission to manage the lobby", error_code=35)
                
            # Clearing out duplicates from invited list
            users = User.query.filter(User.id.in_(request.invites)).all()
            users = set(users)
            uids = map(lambda u:u.id, users)
            
            # Check to make sure the lobby owner does not get invited
            for user in users:
                if(user.id == request.userId):
                    users.remove(user)
                    break
            
            # Check and remove invited users who has previously been invited
            already_invited = LobbyMembership.query.filter(LobbyMembership.user_id.in_(uids)).filter(LobbyMembership.lobby_id==request.lobbyId).all()
            for invited in already_invited:
                for person in users:
                    if(invited.user_id==person.id):
                        users.remove(person)
                        break
                    
                    
            print users
            if(users == set([])):
                return InviteLobbyResponse(friends_invited=False)
            
            else:
                for invited in users:
                    lobby_membership = LobbyMembership(lobby_id = request.lobbyId, status = "invited" , user_id = invited.id)
                    session.add(lobby_membership)
                
                session.commit()               
                return InviteLobbyResponse(friends_invited=True)   
コード例 #5
0
    def create_user(self, request):
        if not isinstance(request, RegistrationRequest):
            return RpcError(message = "Wrong message type, expecting RegistrationRequest", error_code=1)
        # TODO: add more logic before insert the user to db
        if None in (request.email, request.password):
            return RpcError(message="Both email and password requires to be set", error_code=10)
        try:
            user = User(
                email = request.email,
                password = request.password
            )
            session.add(user)
            session.commit()

            return RegistrationResponse(userId=user.id)
        except IntegrityError as e:
            session.rollback()
            return RpcError(message="E-mail already used", error_code=11)
        except Exception as e:
            session.rollback()
            return RpcError(message=e.message) # TODO: improve this