public async Task FindClientByIdAsync_WhenClientExistsWithCollections_ExpectClientReturnedCollections()
{
var storeHolder = GetConfigurationDocumentStoreHolder();
var testClient = new Client
{
ClientId = "properties_test_client",
ClientName = "Properties Test Client",
AllowedCorsOrigins = { "https://localhost" },
AllowedGrantTypes = GrantTypes.HybridAndClientCredentials,
AllowedScopes = { "openid", "profile", "api1" },
Claims = { new ClientClaim("test", "value") },
ClientSecrets = { new Secret(CryptographyHelper.CreateHash("secret")) },
IdentityProviderRestrictions = { "AD" },
PostLogoutRedirectUris = { "https://locahost/signout-callback" },
Properties = { { "foo1", "bar1" }, { "foo2", "bar2" }, },
RedirectUris = { "https://locahost/signin" }
};
using (var session = storeHolder.OpenAsyncSession())
{
await session.StoreAsync(testClient.ToEntity());
await session.SaveChangesAsync();
}
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
var store = new ClientStore(storeHolder, FakeLogger <ClientStore> .Create());
var client = await store.FindClientByIdAsync(testClient.ClientId);
client.Should().BeEquivalentTo(testClient);
}
public async Task <IActionResult> Index(ConsentInputModel model)
{
var result = await ProcessConsent(model);
if (result.IsRedirect)
{
if (await ClientStore.IsPkceClientAsync(result.ClientId))
{
// if the client is PKCE then we assume it's native, so this change in how to
// return the response is for better UX for the end user.
return(View("Redirect", new RedirectViewModel {
RedirectUrl = result.RedirectUri
}));
}
return(Redirect(result.RedirectUri));
}
if (result.HasValidationError)
{
ModelState.AddModelError(string.Empty, result.ValidationError);
}
return(result.ShowView ? View("Index", result.ViewModel) : View("Error"));
}
public async Task FindClientByIdAsync_WhenClientExistsWithCollections_ExpectClientReturnedCollections(DbContextOptions <ConfigurationDbContext> options)
{
var testClient = new Client
{
ClientId = "properties_test_client",
ClientName = "Properties Test Client",
AllowedCorsOrigins = { "https://localhost" },
AllowedGrantTypes = GrantTypes.HybridAndClientCredentials,
AllowedScopes = { "openid", "profile", "api1" },
Claims = { new Claim("test", "value") },
ClientSecrets = { new Secret("secret".Sha256()) },
IdentityProviderRestrictions = { "AD" },
PostLogoutRedirectUris = { "https://locahost/signout-callback" },
Properties = { { "foo1", "bar1" }, { "foo2", "bar2" }, },
RedirectUris = { "https://locahost/signin" }
};
using (var context = new ConfigurationDbContext(options, StoreOptions))
{
context.Clients.Add(testClient.ToEntity());
context.SaveChanges();
}
Client client;
using (var context = new ConfigurationDbContext(options, StoreOptions))
{
var store = new ClientStore(context, FakeLogger <ClientStore> .Create());
client = await store.FindClientByIdAsync(testClient.ClientId);
}
client.Should().BeEquivalentTo(testClient);
}
public async Task FindClientByIdAsync_WhenClientExists_ExpectClientReturned()
{
var storeHolder = GetConfigurationDocumentStoreHolder();
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
var testClient = new Client
{
ClientId = "test_client",
ClientName = "Test Client"
};
using (var session = storeHolder.OpenAsyncSession())
{
await session.StoreAsync(testClient.ToEntity());
await session.SaveChangesAsync();
}
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
var store = new ClientStore(storeHolder, FakeLogger <ClientStore> .Create());
var client = await store.FindClientByIdAsync(testClient.ClientId);
client.Should().NotBeNull();
}
public void FindClientByIdAsync_WhenClientExists_ExpectClientRetured(
DbContextOptions <ConfigurationDbContext> options)
{
var testClient = new Client
{
ClientId = "test_client",
ClientName = "Test Client"
};
using (var context =
new ConfigurationDbContext(options, StoreOptions))
{
context.Clients.Add(testClient.ToEntity());
context.SaveChanges();
}
Client client;
using (var context =
new ConfigurationDbContext(options, StoreOptions))
{
var store = new ClientStore(
context,
NullLogger <ClientStore> .Create()
);
client = store.FindClientByIdAsync(testClient.ClientId).Result;
}
Assert.NotNull(client);
}
public async Task Can_call_ClientStore_FindClientByIdAsync()
=> await ExecuteWithStrategyInTransactionAsync(
async context =>
{
context.AddRange(
new Client
{
ClientId = "C1", Description = "D1",
},
new Client
{
ClientId = "C2", Description = "D2",
},
new Client
{
ClientId = "C3", Description = "D3",
});
await context.SaveChangesAsync();
},
async context =>
{
var store = new ClientStore(context, new FakeLogger <ClientStore>());
Assert.Equal("D2", (await store.FindClientByIdAsync("C2")).Description);
}
);
public static List <RefreshTokenHandleRecord> InsertTestData(ClientStore clientStore, ScopeStore scopeStore, TokenHandleStore ths, RefreshTokenStore store, int count = 1)
{
List <RefreshTokenHandleRecord> result = new List <RefreshTokenHandleRecord>();
var insert = TokenHandleStoreTest.InsertTestData(clientStore, scopeStore, ths, count);
var subjectSeed = Guid.NewGuid().ToString();
var clientId = insert[0].Record.ClientId;
foreach (var item in insert)
{
RefreshTokenHandle tokenHandle = new RefreshTokenHandle
{
ClientId = clientId,
AccessToken = item.Record,
CreationTime = DateTimeOffset.UtcNow,
Key = Guid.NewGuid().ToString(),
Expires = DateTimeOffset.UtcNow.AddMinutes(5),
LifeTime = 5,
SubjectId = item.Record.SubjectId,
Version = 1
};
var tokenHandleRecord = new RefreshTokenHandleRecord(tokenHandle);
store.CreateAsync(tokenHandleRecord.Record);
result.Add(tokenHandleRecord);
}
return(result);
}
public async Task FindClientByIdAsync_WhenClientIdReceived_ExpectClientToBeReturned()
{
var store = new ClientStore(StoreOptions, new FakeLogger <ClientStore>());
foreach (var testObject in GetClientTestObjects())
{
await store.StoreAsync(testObject);
}
var client = await store.FindClientByIdAsync("roclient");
Assert.Single(client.Claims);
Assert.Equal("role", client.Claims.ToArray()[0].Type);
Assert.Equal("service", client.Claims.ToArray()[0].Value);
Assert.Equal("https://cors/", client.AllowedCorsOrigins.ToArray()[0]);
Assert.Equal("https://origin/", client.AllowedCorsOrigins.ToArray()[1]);
Assert.Single(client.AllowedGrantTypes);
Assert.Equal("password", client.AllowedGrantTypes.ToArray()[0]);
Assert.Single(client.ClientSecrets);
Assert.Equal("K7gNU3sdo+OL0wNhqoVWhr3g6s1xYv72ol/pe/Unols=", client.ClientSecrets.ToArray()[0].Value);
Assert.Equal("SharedSecret", client.ClientSecrets.ToArray()[0].Type);
Assert.Equal("api1", client.AllowedScopes.ToArray()[0]);
Assert.Equal("api2.read_only", client.AllowedScopes.ToArray()[1]);
Assert.Equal("provider", client.IdentityProviderRestrictions.ToArray()[0]);
Assert.Equal("https://logout/redirect/", client.PostLogoutRedirectUris.ToArray()[0]);
Assert.Equal("https://logout/redirect-failure/", client.PostLogoutRedirectUris.ToArray()[1]);
Assert.Equal("https://redirect/", client.RedirectUris.ToArray()[0]);
}
public async Task FindClientByIdAsync_WhenClientExists_ExpectClientRetured()
{
var repo = g.configurationDb.GetRepository <IdentityServer4.Fsql.Storage.Entities.Client>();
var testClient = new Client
{
ClientId = "test_client",
ClientName = "Test Client"
};
var entity = testClient.ToEntity();
repo.Insert(entity);
repo.SaveMany(entity, "AllowedCorsOrigins");
repo.SaveMany(entity, "AllowedGrantTypes");
repo.SaveMany(entity, "AllowedScopes");
repo.SaveMany(entity, "Claims");
repo.SaveMany(entity, "ClientSecrets");
repo.SaveMany(entity, "IdentityProviderRestrictions");
repo.SaveMany(entity, "PostLogoutRedirectUris");
repo.SaveMany(entity, "Properties");
repo.SaveMany(entity, "RedirectUris");
Client client;
var store = new ClientStore(g.configurationDb, FakeLogger <ClientStore> .Create());
client = await store.FindClientByIdAsync(testClient.ClientId);
client.Should().NotBeNull();
DeleteTestData(entity);
}
private void FrozenInStoreConfirmScan_Load(object sender, EventArgs e)
{
//不做离线，直接从接口取
var listObj = RpcFacade.Call <List <RpcObject> >("/MainSystem/B3Butchery/Rpcs/BaseInfoRpc/SyncFrozenStore");
var list = new List <ClientStore>();
foreach (RpcObject obj in listObj)
{
var store = new ClientStore();
store.ID = obj.Get <long>("ID");
store.Name = obj.Get <string>("Name");
list.Add(store);
}
_storeList = list;
comboBox1.DataSource = _storeList;
comboBox1.DisplayMember = "Name";
comboBox1.ValueMember = "ID";
var productPlanObj = RpcFacade.Call <List <RpcObject> >("/MainSystem/B3Butchery/Rpcs/ProduceOutputRpc/GetProductPlan");
var productPlanList = new List <ClientProductPlan>();
foreach (RpcObject obj in productPlanObj)
{
var productPlan = new ClientProductPlan();
productPlan.ID = obj.Get <long>("ID");
productPlan.PlanNumber = obj.Get <string>("PlanNumber");
productPlanList.Add(productPlan);
}
_productPlanList = productPlanList;
comboBox2.DataSource = _productPlanList;
comboBox2.DisplayMember = "PlanNumber";
comboBox2.ValueMember = "ID";
}
public void Setup()
{
base.Setup();
_clientStore = new ClientStore(StoreSettings.UsingFolder(TargetFolder));
_tokenHandleStore = new TokenHandleStore(StoreSettings.UsingFolder(TargetFolder));
_scopeStore = new ScopeStore(StoreSettings.UsingFolder(TargetFolder));
}
public async Task Should_Retrieve_Client_With_Allowed_Cors_Origins(TestDatabase testDb)
{
var testClient = new Client()
{
ClientId = Guid.NewGuid().ToString(),
ClientName = "Test Client with CORS Origins",
AllowedCorsOrigins =
{
"*.tld1",
"*.tld2",
"*.tld3"
}
};
using (var session = testDb.OpenSession())
{
await session.SaveAsync(testClient.ToEntity());
await session.FlushAsync();
}
Client requestedClient;
var loggerMock = new Mock <ILogger <ClientStore> >();
using (var session = testDb.OpenSession())
{
var store = new ClientStore(session, loggerMock.Object);
requestedClient = await store.FindClientByIdAsync(testClient.ClientId);
}
requestedClient.Should().NotBeNull();
requestedClient.AllowedCorsOrigins.Count.Should().Be(3);
await CleanupTestDataAsync(testDb);
}
public async Task Should_Retrieve_Client_With_Properties(TestDatabase testDb)
{
var testClient = new Client()
{
ClientId = Guid.NewGuid().ToString(),
ClientName = "Test Client with Properties",
Properties =
{
{ "prop1", "val1" },
{ "prop2", "val2" },
{ "prop3", "val3" }
}
};
using (var session = testDb.OpenSession())
{
await session.SaveAsync(testClient.ToEntity());
await session.FlushAsync();
}
Client requestedClient;
var loggerMock = new Mock <ILogger <ClientStore> >();
using (var session = testDb.OpenSession())
{
var store = new ClientStore(session, loggerMock.Object);
requestedClient = await store.FindClientByIdAsync(testClient.ClientId);
}
requestedClient.Should().NotBeNull();
requestedClient.Properties.Count.Should().Be(3);
await CleanupTestDataAsync(testDb);
}
public void FindClientByIdAsync_WhenClientExists_ExpectClientRetured()
{
var testClient = new Client {
Claims = new List <ClientClaim> {
new ClientClaim {
Type = "type", Value = "value"
}
}, ClientName = "re", ClientId = "re", AllowedGrantTypes = new List <ClientGrantType> {
new ClientGrantType {
GrantType = "xxxxx"
}
}
};
using (var session = martenFixture.Store.OpenSession())
{
session.Store(testClient);
session.SaveChanges();
}
using (var session = martenFixture.Store.OpenSession())
{
var _client = new ClientStore(session).FindClientByIdAsync(testClient.ClientId).Result;
Assert.NotNull(_client);
}
}
public async Task FindClientByIdAsync_should_return_client()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
using var s1 = store.OpenAsyncSession();
await s1.StoreAsync(new Entity.Client
{
Id = "test",
AllowedGrantTypes = new List <Entity.ClientGrantType>
{
new Entity.ClientGrantType
{
Id = $"{nameof(Entity.ClientGrantType).ToLowerInvariant()}/test"
}
}
}, $"{nameof(Entity.Client)}/test");
await s1.StoreAsync(new Entity.ClientGrantType
{
Id = "test",
GrantType = "client_credential"
}, $"{nameof(Entity.ClientGrantType).ToLowerInvariant()}/test");
await s1.SaveChangesAsync();
var sut = new ClientStore(new ScopedAsynDocumentcSession(store.OpenAsyncSession()));
var result = await sut.FindClientByIdAsync("test");
Assert.NotNull(result);
Assert.Contains(result.AllowedGrantTypes, g => g == "client_credential");
}
public void FindClientByIdAsync_WhenClientExists_ExpectClientPropertiesRetured(DbContextOptions <ConfigurationDbContext> options)
{
var testClient = new Client
{
ClientId = "properties_test_client",
ClientName = "Properties Test Client",
Properties =
{
{ "foo1", "bar1" },
{ "foo2", "bar2" },
}
};
using (var context = new ConfigurationDbContext(options, StoreOptions))
{
context.Clients.Add(testClient.ToEntity());
context.SaveChanges();
}
Client client;
using (var context = new ConfigurationDbContext(options, StoreOptions))
{
var store = new ClientStore(context, FakeLogger <ClientStore> .Create());
client = store.FindClientByIdAsync(testClient.ClientId).Result;
}
client.Properties.Should().NotBeNull();
client.Properties.Count.Should().Be(2);
client.Properties.ContainsKey("foo1").Should().BeTrue();
client.Properties.ContainsKey("foo2").Should().BeTrue();
client.Properties["foo1"].Should().Be("bar1");
client.Properties["foo2"].Should().Be("bar2");
}
public TcpServerController(TcpListener server, TraceSource trace, ClientStore clientStore, NetworkStreamReader reader, NetworkStreamWriter writer)
{
if (server == null)
{
throw new ArgumentNullException(nameof(server));
}
if (trace == null)
{
throw new ArgumentNullException(nameof(trace));
}
if (clientStore == null)
{
throw new ArgumentNullException(nameof(clientStore));
}
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
_server = server;
_trace = trace;
_clientStore = clientStore;
_reader = reader;
_writer = writer;
}
public async Task Should_Retrieve_Client_If_It_Exists(TestDatabase testDb)
{
var testClient = new Client()
{
ClientId = Guid.NewGuid().ToString(),
ClientName = "Test Client"
};
using (var session = testDb.OpenSession())
{
await session.SaveAsync(testClient.ToEntity());
await session.FlushAsync();
}
Client requestedClient;
var loggerMock = new Mock <ILogger <ClientStore> >();
using (var session = testDb.OpenSession())
{
var store = new ClientStore(session, loggerMock.Object);
requestedClient = await store.FindClientByIdAsync(testClient.ClientId);
}
requestedClient.Should().NotBeNull();
await CleanupTestDataAsync(testDb);
}
public async Task CanLoadClientById()
{
var store = new ClientStore(Session);
var client = await store.FindClientByIdAsync("codeclient");
client.ShouldNotBe(null);
}
public async Task FindClientByIdAsync_WhenClientExists_ExpectClientReturned()
{
using var ravenStore = GetDocumentStore();
await new ClientIndex().ExecuteAsync(ravenStore);
var testClient = new Client
{
ClientId = "test_client",
ClientName = "Test Client"
};
using (var session = ravenStore.OpenSession())
{
session.Store(testClient.ToEntity());
session.SaveChanges();
}
WaitForIndexing(ravenStore);
Client client;
using (var session = ravenStore.OpenAsyncSession())
{
var store = new ClientStore(session, FakeLogger <ClientStore> .Create());
client = await store.FindClientByIdAsync(testClient.ClientId);
}
client.Should().NotBeNull();
}
private static void Seed(IApplicationBuilder app)
{
var options = app.ApplicationServices.GetRequiredService <IOptions <TableStorageConfigurationOptions> >();
// seed API resources
var apiResourceLogger = app.ApplicationServices.GetRequiredService <ILogger <ApiResourceTableStore> >();
var apiResourceStore = new ApiResourceTableStore(options, apiResourceLogger);
foreach (var apiResource in Host.Configuration.Resources.GetApiResources())
{
apiResourceStore.StoreAsync(apiResource).GetAwaiter().GetResult();
}
// seed Identity resources
var identityResourceLogger = app.ApplicationServices.GetRequiredService <ILogger <IdentityResourceTableStore> >();
var identityResourceStore = new IdentityResourceTableStore(options, identityResourceLogger);
foreach (var identityResource in Host.Configuration.Resources.GetIdentityResources())
{
identityResourceStore.StoreAsync(identityResource).GetAwaiter().GetResult();
}
// seed Clients
var clientLogger = app.ApplicationServices.GetRequiredService <ILogger <ClientStore> >();
var clientStore = new ClientStore(options, clientLogger);
foreach (var client in Clients.Get())
{
clientStore.StoreAsync(client).GetAwaiter().GetResult();
}
}
public async Task FindClientByIdAsync_WhenClientDoesNotExist_ExpectNull()
{
var store = new ClientStore(g.configurationDb, FakeLogger <ClientStore> .Create());
var client = await store.FindClientByIdAsync(Guid.NewGuid().ToString());
client.Should().BeNull();
}
private async Task <ConsentViewModel> BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
{
var request = await Interaction.GetAuthorizationContextAsync(returnUrl);
if (request != null)
{
var client = await ClientStore.FindEnabledClientByIdAsync(request.ClientId);
if (client != null)
{
var resources = await ResourceStore.FindEnabledResourcesByScopeAsync(request.ScopesRequested);
if (resources != null && (resources.IdentityResources.Any() || resources.ApiResources.Any()))
{
return(CreateConsentViewModel(model, returnUrl, request, client, resources));
}
else
{
Logger.LogError("No scopes matching: {0}", request.ScopesRequested.Aggregate((x, y) => x + ", " + y));
}
}
else
{
Logger.LogError("Invalid client id: {0}", request.ClientId);
}
}
else
{
Logger.LogError("No consent request matching request: {0}", returnUrl);
}
return(null);
}
public async override Task <IActionResult> OnGetAsync()
{
LoginInput = new LoginInputModel();
var context = await Interaction.GetAuthorizationContextAsync(ReturnUrl);
if (context != null)
{
ShowCancelButton = true;
LoginInput.UserNameOrEmailAddress = context.LoginHint;
//TODO: Reference AspNetCore MultiTenancy module and use options to get the tenant key!
var tenant = context.Parameters[TenantResolverConsts.DefaultTenantKey];
if (!string.IsNullOrEmpty(tenant))
{
CurrentTenant.Change(Guid.Parse(tenant));
Response.Cookies.Append(TenantResolverConsts.DefaultTenantKey, tenant);
}
}
if (context?.IdP != null)
{
LoginInput.UserNameOrEmailAddress = context.LoginHint;
ExternalProviders = new[] { new ExternalProviderModel {
AuthenticationScheme = context.IdP
} };
return(Page());
}
var providers = await GetExternalProviders();
ExternalProviders = providers.ToList();
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
if (context?.Client?.ClientId != null)
{
var client = await ClientStore.FindEnabledClientByIdAsync(context?.Client?.ClientId);
if (client != null)
{
EnableLocalLogin = client.EnableLocalLogin;
if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
{
providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
}
}
}
if (IsExternalLoginOnly)
{
return(await base.OnPostExternalLogin(providers.First().AuthenticationScheme));
}
return(Page());
}
public AdminService(IMongoClient client, IMongoDatabase db, StoreSettings settings)
{
_client = client;
_db = db;
_settings = settings;
_clientSerializer = new ClientSerializer();
_clientStore = new ClientStore(db, settings, _clientSerializer);
_scopeStore = new ScopeStore(db, settings);
}
public HomeController(ClientStore cs, BookCatalog bc, MusicCatalog muc, MovieCatalog moc, MagazineCatalog mac, Search search)
{
_cs = cs;
_bookc = bc;
_moviec = moc;
_musicc = muc;
_magazinec = mac;
_search = search;
}
public IActionResult OnGet(Guid id)
{
Client = ClientStore.GetClientById(id);
if (Client == null)
{
return(RedirectToPage("./Add"));
}
return(Page());
}
public IActionResult OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
ClientStore.AddCliente(Client);
return(RedirectToPage("./Index"));
}
public TransactionServer(Bank bank, Dispatcher dispatcher)
{
_bank = bank;
_bank.Dispatcher = dispatcher;
clients = new ClientStore();
ThreadedReceiver.ServerDataReceived += ThreadedReceiver_ServerDataReceived;
listenerThread = new ThreadedListener(tx);
listenerThread.Run(clients);
}
public async Task FindClientByIdAsync_WhenClientsExistWithManyCollections_ExpectClientReturnedInUnderFiveSeconds()
{
var storeHolder = GetConfigurationDocumentStoreHolder();
var testClient = new Client
{
ClientId = "test_client_with_uris",
ClientName = "Test client with URIs",
AllowedScopes = { "openid", "profile", "api1" },
AllowedGrantTypes = GrantTypes.CodeAndClientCredentials
};
for (int i = 0; i < 50; i++)
{
testClient.RedirectUris.Add($"https://localhost/{i}");
testClient.PostLogoutRedirectUris.Add($"https://localhost/{i}");
testClient.AllowedCorsOrigins.Add($"https://localhost:{i}");
}
using (var session = storeHolder.OpenAsyncSession())
{
await session.StoreAsync(testClient.ToEntity());
for (int i = 0; i < 50; i++)
{
await session.StoreAsync(new Client
{
ClientId = testClient.ClientId + i,
ClientName = testClient.ClientName,
AllowedScopes = testClient.AllowedScopes,
AllowedGrantTypes = testClient.AllowedGrantTypes,
RedirectUris = testClient.RedirectUris,
PostLogoutRedirectUris = testClient.PostLogoutRedirectUris,
AllowedCorsOrigins = testClient.AllowedCorsOrigins,
}.ToEntity());
}
await session.SaveChangesAsync();
}
WaitForIndexing(storeHolder.IntegrationTest_GetDocumentStore());
var store = new ClientStore(storeHolder, FakeLogger <ClientStore> .Create());
const int timeout = 5000;
var task = Task.Run(() => store.FindClientByIdAsync(testClient.ClientId));
if (await Task.WhenAny(task, Task.Delay(timeout)) == task)
{
var client = task.Result;
client.Should().BeEquivalentTo(testClient);
}
else
{
throw new TestTimeoutException(timeout);
}
}
public SetupController(
Contexts.IDS4Context context,
LuigiTrabacchin.IdentityServer4.EntityFramework.Identity.UserManager<Int32> userManager,
ScopeStore<Int32> scopeStore,
ClientStore<Int32> clientStore
)
{
this.Context = context;
this._userManager = userManager;
this._scopeStore = scopeStore;
this._clientStore = clientStore;
}
