public virtual async Task IsLinkedAsync()
    {
        var john = await UserRepository.GetAsync(TestData.UserJohnId);

        var david = await UserRepository.GetAsync(TestData.UserDavidId);

        var neo = await UserRepository.GetAsync(TestData.UserNeoId);

        (await IdentityLinkUserManager.IsLinkedAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
                                                     new IdentityLinkUserInfo(david.Id, david.TenantId))).ShouldBeTrue();

        (await IdentityLinkUserManager.IsLinkedAsync(new IdentityLinkUserInfo(john.Id, john.TenantId),
                                                     new IdentityLinkUserInfo(neo.Id, neo.TenantId))).ShouldBeFalse();
    }
        public virtual async Task ValidateAsync(ExtensionGrantValidationContext context)
        {
            var accessToken = context.Request.Raw["access_token"];

            if (accessToken.IsNullOrWhiteSpace())
            {
                context.Result = new GrantValidationResult
                {
                    IsError = true,
                    Error   = "invalid_access_token"
                };
                return;
            }

            var result = await TokenValidator.ValidateAccessTokenAsync(accessToken);

            if (result.IsError)
            {
                context.Result = new GrantValidationResult
                {
                    IsError          = true,
                    Error            = result.Error,
                    ErrorDescription = result.ErrorDescription
                };
                return;
            }

            using (CurrentPrincipalAccessor.Change(result.Claims))
            {
                if (!Guid.TryParse(context.Request.Raw["LinkUserId"], out var linkUserId))
                {
                    context.Result = new GrantValidationResult
                    {
                        IsError = true,
                        Error   = "invalid_link_user_id"
                    };
                    return;
                }

                Guid?linkTenantId = null;
                if (!context.Request.Raw["LinkTenantId"].IsNullOrWhiteSpace())
                {
                    if (!Guid.TryParse(context.Request.Raw["LinkTenantId"], out var parsedGuid))
                    {
                        context.Result = new GrantValidationResult
                        {
                            IsError = true,
                            Error   = "invalid_link_tenant_id"
                        };
                        return;
                    }

                    linkTenantId = parsedGuid;
                }

                var isLinked = await IdentityLinkUserManager.IsLinkedAsync(
                    new IdentityLinkUserInfo(CurrentUser.GetId(), CurrentTenant.Id),
                    new IdentityLinkUserInfo(linkUserId, linkTenantId),
                    true);

                if (isLinked)
                {
                    using (CurrentTenant.Change(linkTenantId))
                    {
                        var user = await UserManager.GetByIdAsync(linkUserId);

                        var sub = await UserManager.GetUserIdAsync(user);

                        var additionalClaims = new List <Claim>();
                        await AddCustomClaimsAsync(additionalClaims, user, context);

                        context.Result = new GrantValidationResult(
                            sub,
                            GrantType,
                            additionalClaims.ToArray()
                            );
                    }
                }
                else
                {
                    context.Result = new GrantValidationResult
                    {
                        IsError = true,
                        Error   = Localizer["TheTargetUserIsNotLinkedToYou"]
                    };
                }
            }
        }