public override async Task <SendFriendRequestResponse> SendFriendRequest(SendFriendRequestRequest request, ServerCallContext context)
        {
            RedisUserModel user = context.UserState["user"] as RedisUserModel;

            if (user == null)
            {
                return new SendFriendRequestResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
                       }
            }
            ;

            RedisUserModel friend = await RedisUserModel.GetUserFromGuid(request.FriendId);

            if (friend == null)
            {
                return new SendFriendRequestResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST)
                       }
            }
            ;

            if (await friend.HasFriendRequestFrom(user))
            {
                return new SendFriendRequestResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.DUPLICATE)
                       }
            }
            ;

            if (await friend.IsBlocked(user) || await user.IsBlocked(friend))
            {
                return new SendFriendRequestResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.PLAYER_IS_BLOCKED)
                       }
            }
            ;

            // Add request to the other player.
            await friend.AddFriendRequestFrom(user);

            return(new SendFriendRequestResponse()
            {
                Status = ResponseFactory.createResponse(ResponseType.SUCCESS)
            });
        }
        public override async Task <UnblockPlayerResponse> UnblockPlayer(UnblockPlayerRequest request, ServerCallContext context)
        {
            RedisUserModel user = context.UserState["user"] as RedisUserModel;

            if (user == null)
            {
                return new UnblockPlayerResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
                       }
            }
            ;

            // Check if player is valid.
            RedisUserModel friend = await RedisUserModel.GetUserFromGuid(request.UserIdToBlock);

            if (friend == null)
            {
                return new UnblockPlayerResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST)
                       }
            }
            ;

            // Check if player is blocked.
            if (!await user.IsBlocked(friend))
            {
                return new UnblockPlayerResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.INVALID_REQUEST)
                       }
            }
            ;

            await user.UnblockUser(friend);

            return(new UnblockPlayerResponse()
            {
                Status = ResponseFactory.createResponse(ResponseType.SUCCESS)
            });
        }
        public override async Task <BlockPlayerResponse> BlockPlayer(BlockPlayerRequest request, ServerCallContext context)
        {
            RedisUserModel user = context.UserState["user"] as RedisUserModel;

            if (user == null)
            {
                return new BlockPlayerResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
                       }
            }
            ;

            RedisUserModel friend = await RedisUserModel.GetUserFromGuid(request.UserIdToBlock);

            if (friend == null)
            {
                return new BlockPlayerResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.PLAYER_DOES_NOT_EXIST)
                       }
            }
            ;

            if (await user.IsBlocked(friend))
            {
                return new BlockPlayerResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.DUPLICATE)
                       }
            }
            ;

            await user.BlockUser(friend);

            return(new BlockPlayerResponse()
            {
                Status = ResponseFactory.createResponse(ResponseType.SUCCESS)
            });
        }