protected virtual Task <T> GetModelAsync()
{
return(AdminStore.GetAsync(Id, new GetRequest
{
Expand = Expand
}));
}
private async Task GetEntityList(PageRequest pageRequest)
{
var page = await AdminStore.GetAsync(pageRequest)
.ConfigureAwait(false);
EntityList = page.Items;
}
protected Task OnFilterChanged(string filter)
{
_cancellationTokenSource?.Cancel();
_cancellationTokenSource?.Dispose();
_cancellationTokenSource = new CancellationTokenSource();
var token = _cancellationTokenSource.Token;
return(Task.Delay(500, token)
.ContinueWith(async task =>
{
if (task.IsCanceled)
{
return;
}
var propertyArray = SelectProperties.Split(',');
var expressionArray = new string[propertyArray.Length];
for (int i = 0; i < propertyArray.Length; i++)
{
expressionArray[i] = $"contains({propertyArray[i]},'{filter.Replace("'", "''")}')";
}
_pageRequest.Filter = string.Join(" or ", expressionArray);
var page = await AdminStore.GetAsync(_pageRequest, token)
.ConfigureAwait(false);
EntityList = page.Items;
await InvokeAsync(() => StateHasChanged())
.ConfigureAwait(false);
}, TaskScheduler.Default));
}
protected Task OnFilterChanged(string filter)
{
_cancellationTokenSource?.Cancel();
_cancellationTokenSource?.Dispose();
_cancellationTokenSource = new CancellationTokenSource();
var token = _cancellationTokenSource.Token;
return(Task.Delay(500, token)
.ContinueWith(async task =>
{
_pageRequest.Filter = CreateRequestFilter(filter);
var page = await AdminStore.GetAsync(_pageRequest, token)
.ConfigureAwait(false);
if (task.IsCanceled)
{
return;
}
EntityList = page.Items;
await InvokeAsync(() => StateHasChanged())
.ConfigureAwait(false);
}, TaskScheduler.Default));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
AdminStore adminStore = await db.AdminStores.FindAsync(id);
db.AdminStores.Remove(adminStore);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task GetAsync_by_odata_requqest_should_expand_properties()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ProtectResource> > >();
var id = "test";
var resourceId = Guid.NewGuid().ToString();
using (var s1 = store.OpenAsyncSession())
{
await s1.StoreAsync(new ProtectResource
{
Id = id,
Description = "test",
DisplayName = "test",
Enabled = true,
Resources = new List <ApiLocalizedResource>
{
new ApiLocalizedResource
{
Id = $"{nameof(ApiLocalizedResource).ToLowerInvariant()}/{resourceId}"
}
}
}, $"{nameof(ProtectResource).ToLowerInvariant()}/{id}");
await s1.StoreAsync(new ApiLocalizedResource
{
Id = resourceId,
ApiId = $"{nameof(ApiLocalizedResource).ToLowerInvariant()}/{id}",
CultureId = "fr",
ResourceKind = EntityResourceKind.DisplayName,
Value = "test"
}, $"{nameof(ApiLocalizedResource).ToLowerInvariant()}/{resourceId}");
await s1.SaveChangesAsync();
}
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ProtectResource>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var page = await sut.GetAsync(new PageRequest
{
Expand = "Resources"
});
Assert.Single(page.Items);
Assert.NotNull(page.Items.First().Resources);
Assert.Single(page.Items.First().Resources);
Assert.Equal(resourceId, page.Items.First().Resources.First().Id);
Assert.Equal(id, page.Items.First().Resources.First().ApiId);
Assert.Equal("fr", page.Items.First().Resources.First().CultureId);
Assert.Equal("test", page.Items.First().Resources.First().Value);
}
public async Task <ActionResult> Edit(AdminStore adminStore)
{
if (ModelState.IsValid)
{
db.Entry(adminStore).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(adminStore));
}
public async Task GetAsync_should_filter_by_odata_request()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ProtectResource> > >();
var id = "test";
using (var s1 = store.OpenAsyncSession())
{
await s1.StoreAsync(new ProtectResource
{
Id = id,
Description = "test",
DisplayName = "test",
Enabled = true
}, $"{nameof(ProtectResource).ToLowerInvariant()}/{id}");
await s1.SaveChangesAsync();
}
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ProtectResource>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var page = await sut.GetAsync(new PageRequest
{
Filter = $"{nameof(ProtectResource.Id)} eq 'test'",
Skip = 0,
Take = 10
});
Assert.Single(page.Items);
page = await sut.GetAsync(new PageRequest
{
Filter = $"{nameof(ProtectResource.DisplayName)} eq 'no-test'",
Skip = 0,
Take = 10
});
Assert.Empty(page.Items);
page = await sut.GetAsync(new PageRequest
{
Filter = $"{nameof(ProtectResource.CreatedAt)} eq {DateTime.UtcNow.ToString("o")}",
Skip = 0,
Take = 10
});
Assert.Empty(page.Items);
}
public async Task DeleteAsync_should_delete_cascade()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ProtectResource> > >();
var id = "test";
var claimId = Guid.NewGuid().ToString();
using (var s1 = store.OpenAsyncSession())
{
await s1.StoreAsync(new ProtectResource
{
Id = id,
Description = "test",
DisplayName = "test",
Enabled = true,
ApiClaims = new List <ApiClaim>
{
new ApiClaim
{
Id = $"{nameof(ApiClaim).ToLowerInvariant()}/{claimId}"
}
}
}, $"{nameof(ProtectResource).ToLowerInvariant()}/{id}");
await s1.StoreAsync(new ApiClaim
{
Id = claimId,
ApiId = $"{nameof(ProtectResource).ToLowerInvariant()}/{id}",
Type = "test"
}, $"{nameof(ApiClaim).ToLowerInvariant()}/{claimId}");
await s1.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession())
{
var sut = new AdminStore <ProtectResource>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
await sut.DeleteAsync(id);
}
using var s2 = store.OpenAsyncSession();
var claimStore = new AdminStore <ApiClaim>(new ScopedAsynDocumentcSession(s2), new Mock <ILogger <AdminStore <ApiClaim> > >().Object);
var claim = await claimStore.GetAsync(claimId, null);
Assert.Null(claim);
}
public async Task DeleteAsync_should_throw_on_entity_not_found()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ProtectResource> > >();
var id = "test";
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ProtectResource>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.DeleteAsync(id));
}
public async Task <ActionResult> Create(AdminStore adminStore)
{
if (ModelState.IsValid)
{
adminStore.CreatedOn = DateTime.Now;
db.AdminStores.Add(adminStore);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(adminStore));
}
public async Task CreateAsync_should_populate_auditable_properties_when_auditable()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <TestEntity> > >();
using var session = store.OpenAsyncSession();
var sut = new AdminStore <TestEntity>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var result = await sut.CreateAsync(new TestEntity() as object) as TestEntity;
Assert.NotNull(result.Id);
}
public async Task GetAsync_by_id_should_expand_properties()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ApiClaim> > >();
var id = "test";
var claimId = Guid.NewGuid().ToString();
using (var s1 = store.OpenAsyncSession())
{
await s1.StoreAsync(new ProtectResource
{
Id = id,
Description = "test",
DisplayName = "test",
Enabled = true,
ApiClaims = new List <ApiClaim>
{
new ApiClaim
{
Id = $"{nameof(ApiClaim).ToLowerInvariant()}/{claimId}"
}
}
}, $"{nameof(ProtectResource).ToLowerInvariant()}/{id}");
await s1.StoreAsync(new ApiClaim
{
Id = claimId,
ApiId = $"{nameof(ProtectResource).ToLowerInvariant()}/{id}",
Type = "test"
}, $"{nameof(ApiClaim).ToLowerInvariant()}/{claimId}");
await s1.SaveChangesAsync();
}
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ApiClaim>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
var claim = await sut.GetAsync(claimId, new GetRequest
{
Expand = "Api"
});
Assert.NotNull(claim);
Assert.NotNull(claim.Api);
Assert.Equal(id, claim.Api.Id);
Assert.Equal(id, claim.ApiId);
}
// GET: AdminStores/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AdminStore adminStore = await db.AdminStores.FindAsync(id);
if (adminStore == null)
{
return(HttpNotFound());
}
return(View(adminStore));
}
public async Task <IActionResult> Addmember(AdminStore adminStore)
{
if (ModelState.IsValid)
{
_mahjongDBContext.AdminStore.Add(adminStore);
await _mahjongDBContext.SaveChangesAsync();
ModelState.Clear();
ViewBag.JavaScriptFunction = true;
ViewBag.RasId = new SelectList(_mahjongDBContext.RightAdminStore, "RasId", "RasDetail");
ViewBag.SId = HttpContext.Session.GetString("Store_sid");
}
return(View());
}
public void ConfigureServices(IServiceCollection services)
{
services.AddDataProtection()
.PersistKeysToFileSystem(keyRing);
services.AddMvc();
var appSettings = Configuration.GetSection("App").Get <AppSettings>();
var cipherService = new CipherService(DataProtectionProvider.Create(keyRing));
var adminStore = new AdminStore(appSettings, cipherService);
var accountStore = new AccountStore(appSettings, adminStore);
services.AddSingleton <ICipherService>(cipherService);
services.AddSingleton <IAdminStore>(adminStore);
services.AddSingleton <IAccountStore>(accountStore);
}
protected virtual async Task DeleteEntity()
{
try
{
await AdminStore.DeleteAsync(GetModelId(Model))
.ConfigureAwait(false);
await Notifier.NotifyAsync(new Models.Notification
{
Header = GetModelId(Model),
Message = "Deleted"
}).ConfigureAwait(false);
NavigationManager.NavigateTo(BackUrl);
}
catch (Exception e)
{
await HandleModificationErrorAsync(e).ConfigureAwait(false);
}
}
public async Task GetAsync_by_id_should_throw_on_expand_wrong_property()
{
using var store = new RavenDbTestDriverWrapper().GetDocumentStore();
var loggerMock = new Mock <ILogger <AdminStore <ApiClaim> > >();
using var session = store.OpenAsyncSession();
var sut = new AdminStore <ApiClaim>(new ScopedAsynDocumentcSession(session), loggerMock.Object);
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.GetAsync("test", new GetRequest
{
Expand = "Type"
}));
await Assert.ThrowsAsync <InvalidOperationException>(() => sut.GetAsync("test", new GetRequest
{
Expand = "Test"
}));
}
protected async Task DeleteEntity()
{
try
{
await AdminStore.DeleteAsync(GetModelId(Model))
.ConfigureAwait(false);
}
catch (ProblemException pe)
{
Notifier.Notify(new Models.Notification
{
Header = "Error",
IsError = true,
Message = pe.Details.Detail
});
throw;
}
#pragma warning disable CA1031 // Do not catch general exception types. We want to notify all error
catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types
{
Notifier.Notify(new Models.Notification
{
Header = "Error",
IsError = true,
Message = e.Message
});
throw;
}
NavigationManager.NavigateTo(BackUrl);
Notifier.Notify(new Models.Notification
{
Header = GetModelId(Model),
Message = "Deleted"
});
}
