public async Task TestNoContactInformationCanBeFoundShouldReturnErrorCode() { var contactRepositoryMock = new Mock <IContactRepository>(); contactRepositoryMock.Setup(c => c.LoadContactInformationByAddressAsync(It.IsAny <Address>())) .Throws(new MessengerException(ResponseCode.NoContactInformationPresent)); var messenger = new InMemoryMessenger(); var respository = new InMemoryContactRepository(); var interactor = new AddContactInteractor(contactRepositoryMock.Object, messenger); var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW"); var request = new AddContactRequest { ContactAddress = contactAddress, RequestAddress = new Address(Seed.Random().Value), ImagePath = "kjasdjkahsda89dafhfafa", Name = "Chiota User", PublicKeyAddress = new Address(Seed.Random().Value), UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey }; var response = await interactor.ExecuteAsync(request); Assert.AreEqual(ResponseCode.NoContactInformationPresent, response.Code); }
public async Task TestGivenContactIsStoredInGivenRepository() { var respository = new InMemoryContactRepository(); var interactor = new AddContactInteractor(respository, new InMemoryMessenger()); var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW"); var publicKeyAddress = Seed.Random().Value; var request = new AddContactRequest { ContactAddress = contactAddress, RequestAddress = new Address(Seed.Random().Value), ImagePath = "kjasdjkahsda89dafhfafa", Name = "Chiota User", PublicKeyAddress = new Address(publicKeyAddress), UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey }; await interactor.ExecuteAsync(request); Assert.AreEqual(1, respository.PersistedContacts.Count); var contact = respository.PersistedContacts[0]; Assert.AreEqual(publicKeyAddress, contact.PublicKeyAddress); Assert.IsFalse(contact.Rejected); Assert.IsNotNull(contact.ChatAddress); }
public void Index_Get_RetriveAllContactFromReporsitry() { //Arrange Contact contact1 = new Repositiry.Contact { Id = 100, Name = "adjen" }; Contact contact2 = new Repositiry.Contact { Id = 200, Name = "sagepay" }; InMemoryContactRepository repository = new InMemoryContactRepository(); repository.CreateNewContact(contact1); repository.CreateNewContact(contact2); HomeController controller = GetHomeController(repository); // Act var result = controller.Index() as ViewResult; var model = (IEnumerable <Contact>)result.ViewData.Model; CollectionAssert.Contains(model.ToList(), contact1); CollectionAssert.Contains(model.ToList(), contact2); }
public async Task TestContactsAreCachedAndOnTangleShouldExcludeRejectedContactsAndSetCache() { var pubKeyAddress = Seed.Random().Value; var contactRequestAddress = new Address(Seed.Random().Value); var rejectedContactAddress = Seed.Random().Value; var storedContactAddress = Seed.Random().Value; var keyPair = InMemoryContactRepository.NtruKeyPair; var contactRepository = new InMemoryContactRepository(); await contactRepository.AddContactAsync(storedContactAddress, true, pubKeyAddress); await contactRepository.AddContactAsync(rejectedContactAddress, false, pubKeyAddress); var rejectedContactBundle = CreateBundle( contactRequestAddress, ContactExchange.Create( new Contact { ChatAddress = rejectedContactAddress, PublicKeyAddress = rejectedContactAddress, Rejected = true }, keyPair.PublicKey, keyPair.PublicKey).Payload); var approvedContactBundle = CreateBundle( contactRequestAddress, ContactExchange.Create( new Contact { ChatAddress = storedContactAddress, PublicKeyAddress = storedContactAddress }, keyPair.PublicKey, keyPair.PublicKey).Payload); var requestBundle = CreateBundle( contactRequestAddress, ContactExchange.Create( new Contact { ChatAddress = storedContactAddress, PublicKeyAddress = storedContactAddress, Request = true, Name = "Requester" }, keyPair.PublicKey, keyPair.PublicKey).Payload); var messenger = new InMemoryMessenger(); messenger.SentMessages.Add(new Message(rejectedContactBundle.Transactions.Aggregate(new TryteString(), (current, transaction) => current.Concat(transaction.Fragment)), contactRequestAddress)); messenger.SentMessages.Add(new Message(approvedContactBundle.Transactions.Aggregate(new TryteString(), (current, transaction) => current.Concat(transaction.Fragment)), contactRequestAddress)); messenger.SentMessages.Add(new Message(requestBundle.Transactions.Aggregate(new TryteString(), (current, transaction) => current.Concat(transaction.Fragment)), contactRequestAddress)); var interactor = new GetContactsInteractor(contactRepository, messenger, NtruEncryption.Key); var response = await interactor.ExecuteAsync( new GetContactsRequest { PublicKeyAddress = new Address(pubKeyAddress), RequestAddress = contactRequestAddress, KeyPair = keyPair }); Assert.AreEqual(ResponseCode.Success, response.Code); Assert.AreEqual(1, response.ApprovedContacts.Count); Assert.AreEqual(1, response.PendingContactRequests.Count); }
public static void BuildApp(this IApplicationBuilder app) { app.UseRouter(r => { var contactRepo = new InMemoryContactRepository(); r.MapGet("contacts", async(request, response, routeData) => { var contacts = await contactRepo.GetAll(); await response.WriteJson(contacts); }); r.MapGet("contacts/{id:int}", async(request, response, routeData) => { var contact = await contactRepo.Get(Convert.ToInt32(routeData.Values["id"])); if (contact == null) { response.StatusCode = 404; return; } await response.WriteJson(contact); }); r.MapPost("contacts", async(request, response, routeData) => { var newContact = await request.HttpContext.ReadFromJson <Contact>(); if (newContact == null) { return; } await contactRepo.Add(newContact); response.StatusCode = 201; await response.WriteJson(newContact); }); r.MapPut("contacts/{id:int}", async(request, response, routeData) => { var updatedContact = await request.HttpContext.ReadFromJson <Contact>(); if (updatedContact == null) { return; } updatedContact.ContactId = Convert.ToInt32(routeData.Values["id"]); await contactRepo.Update(updatedContact); response.StatusCode = 204; }); r.MapDelete("contacts/{id:int}", async(request, response, routeData) => { await contactRepo.Delete(Convert.ToInt32(routeData.Values["id"])); response.StatusCode = 204; }); }); }
public async Task TestContactsAreCachedAndOnTangleShouldExcludeRejectedContactsAndSetCache() { var pubKeyAddress = Seed.Random().Value; var contactRequestAddress = new Address(Seed.Random().Value); var rejectedContactAddress = Seed.Random().Value; var storedContactAddress = Seed.Random().Value; var contactRepository = new InMemoryContactRepository(); await contactRepository.AddContactAsync(storedContactAddress, true, pubKeyAddress); await contactRepository.AddContactAsync(rejectedContactAddress, false, pubKeyAddress); var approvedContactMessage = TryteString.FromUtf8String(JsonConvert.SerializeObject(new Contact { ChatAddress = storedContactAddress })); var rejectedContactBundle = CreateBundle( contactRequestAddress, TryteString.FromUtf8String(JsonConvert.SerializeObject(new Contact { ChatAddress = rejectedContactAddress, Rejected = true }))); var approvedContactBundle = CreateBundle(contactRequestAddress, approvedContactMessage); var iotaRepository = new InMemoryIotaRepository(); iotaRepository.SentBundles.Add(rejectedContactBundle); iotaRepository.SentBundles.Add(approvedContactBundle); iotaRepository.SentBundles.Add( CreateBundle( contactRequestAddress, TryteString.FromUtf8String(JsonConvert.SerializeObject(new Contact { ChatAddress = storedContactAddress, Request = true })))); var transactionCache = new InMemoryTransactionCache(); var cacheItem = new TransactionCacheItem { Address = contactRequestAddress, TransactionHash = approvedContactBundle.Transactions[0].Hash, TransactionTrytes = approvedContactMessage }; transactionCache.Items.Add(cacheItem); var interactor = new GetContactsInteractor(contactRepository, transactionCache, iotaRepository); var response = await interactor.ExecuteAsync( new GetContactsRequest { PublicKeyAddress = new Address(pubKeyAddress), ContactRequestAddress = contactRequestAddress }); Assert.AreEqual(1, response.ApprovedContacts.Count); Assert.AreEqual(1, response.PendingContactRequests.Count); Assert.AreEqual(3, transactionCache.Items.Count); }
public void Test_To_Create_Post_Contact_Repository() { InMemoryContactRepository contactrepository = new InMemoryContactRepository(); ContactController contactcontroller = GetContactController(contactrepository); tbl_contact contact = GetContactID(); contactcontroller.Create(contact); IEnumerable <tbl_contact> contactList = contactrepository.GetAllContact(); //Assert.IsTrue(contactList.Contains(contact)); }
public void Create_Post_PutsValidContactIntoRepository() { var repository = new InMemoryContactRepository(); var controller = GetHomeController(repository); var contact = GetContact(Guid.NewGuid(), "", ""); controller.Create(contact); IEnumerable <Contact> contacts = repository.GetAllContacts(); Assert.IsTrue(contacts.Contains(contact)); }
public void Create_Post_PutsValidContactIntoRepository() { // Arrange InMemoryContactRepository repository = new InMemoryContactRepository(); HomeController controller = GetHomeController(repository); Contact contact = GetContactID_1(); // Act controller.Create(contact); // Assert IEnumerable <Contact> contacts = repository.GetAllContacts(); Assert.IsTrue(contacts.Contains(contact)); }
public void Test_To_Get_All_Contact_From_Repository() { // Arrange tbl_contact contact1 = GetContactName(1, "John", "Doe", "*****@*****.**", "987654321", true); tbl_contact contact2 = GetContactName(2, "John1", "Doe1", "*****@*****.**", "987654312", true); InMemoryContactRepository inMemoryContactRepository = new InMemoryContactRepository(); inMemoryContactRepository.InsertContact(contact1); inMemoryContactRepository.InsertContact(contact2); var controller = GetContactController(inMemoryContactRepository); var result = controller.Index(); var datamodel = (List <tbl_contact>)result.ViewData.Model; CollectionAssert.Contains(datamodel.ToArray(), contact1); CollectionAssert.Contains(datamodel.ToArray(), contact2); }
public async Task TestDeclinedContactGetsAddedToRepository() { var contactRepository = new InMemoryContactRepository(); var interactor = new DeclineContactInteractor(contactRepository); var response = await interactor.ExecuteAsync( new DeclineContactRequest { ContactChatAddress = new Address(Hash.Empty.Value), UserPublicKeyAddress = new Address(Hash.Empty.Value) }); Assert.AreEqual(ResponseCode.Success, response.Code); Assert.AreEqual(Hash.Empty.Value, contactRepository.PersistedContacts[0].ChatAddress); Assert.AreEqual(Hash.Empty.Value, contactRepository.PersistedContacts[0].PublicKeyAddress); Assert.IsTrue(contactRepository.PersistedContacts[0].Rejected); }
public void Index_Get_RetrievesAllContactsFromRepository() { Contact contact1 = GetContact(Guid.NewGuid(), "Orlando", "Gee"); Contact contact2 = GetContact(Guid.NewGuid(), "Keith", "Harris"); InMemoryContactRepository repository = new InMemoryContactRepository(); repository.Add(contact1); repository.Add(contact2); var controller = GetHomeController(repository); var result = controller.Index(); var view = (ViewResult)result; var model = (IEnumerable <Contact>)view.ViewData.Model; CollectionAssert.Contains(model.ToList(), contact1); CollectionAssert.Contains(model.ToList(), contact2); }
public async Task TestContactsAreContainedCachedAndApproved() { var pubKeyAddress = Seed.Random().Value; var contactRequestAddress = new Address(Seed.Random().Value); var storedContactAddress = Seed.Random().Value; var keyPair = InMemoryContactRepository.NtruKeyPair; var contactRepository = new InMemoryContactRepository(); var transactionCache = new MemoryTransactionCache(); var bundle = CreateBundle( contactRequestAddress, ContactExchange.Create(new Contact { ChatAddress = storedContactAddress, Rejected = true }, keyPair.PublicKey, keyPair.PublicKey).Payload); bundle.Transactions.ForEach(async t => await transactionCache.SaveTransactionAsync(new TransactionCacheItem { Address = contactRequestAddress, TransactionHash = t.Hash, TransactionTrytes = t.ToTrytes() })); await contactRepository.AddContactAsync(storedContactAddress, true, pubKeyAddress); var iotaRepositoryMock = new Mock <IIotaRepository>(); iotaRepositoryMock.Setup(i => i.FindTransactionsByAddressesAsync(It.IsAny <List <Address> >())).ReturnsAsync( new TransactionHashList { Hashes = new List <Hash>(bundle.Transactions.Select(t => t.Hash)) }); iotaRepositoryMock.Setup(i => i.GetTrytesAsync(It.IsAny <List <Hash> >())).ReturnsAsync(new List <TransactionTrytes>()); var interactor = new GetContactsInteractor(contactRepository, new TangleMessenger(iotaRepositoryMock.Object, transactionCache), NtruEncryption.Key); var response = await interactor.ExecuteAsync( new GetContactsRequest { PublicKeyAddress = new Address(pubKeyAddress), RequestAddress = contactRequestAddress, KeyPair = keyPair }); Assert.AreEqual(1, response.ApprovedContacts.Count); }
public async Task TestUnkownExceptionIsThrownShouldReturnErrorCode() { var messenger = new ExceptionMessenger(new Exception("Hi")); var respository = new InMemoryContactRepository(); var interactor = new AddContactInteractor(respository, messenger); var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW"); var request = new AddContactRequest { ContactAddress = contactAddress, RequestAddress = new Address(Seed.Random().Value), ImageHash = "kjasdjkahsda89dafhfafa", Name = "Chiota User", PublicKeyAddress = new Address(Seed.Random().Value) }; var response = await interactor.ExecuteAsync(request); Assert.AreEqual(ResponseCode.UnkownException, response.Code); }
public void Create_Post_ReturnsViewIfRepositoryThrowsException() { InMemoryContactRepository repository = new InMemoryContactRepository(); Exception ex = new Exception(); repository.ExceptionToThrow = ex; HomeController controller = GetHomeController(repository); Contact model = GetContact(Guid.NewGuid(), "", ""); var result = controller.Create(model); var view = (ViewResult)result; Assert.AreEqual("Create", view.ViewName); ModelState modelState = view.ViewData.ModelState[""]; Assert.IsNotNull(modelState); Assert.IsTrue(modelState.Errors.Any()); Assert.AreEqual(ex, modelState.Errors[0].Exception); }
public async Task TestContactsAreContainedCachedAndApproved() { var pubKeyAddress = Seed.Random().Value; var contactRequestAddress = new Address(Seed.Random().Value); var storedContactAddress = Seed.Random().Value; var contactRepository = new InMemoryContactRepository(); var transactionCache = new InMemoryTransactionCache(); var cacheItem = new TransactionCacheItem { Address = contactRequestAddress, TransactionHash = new Hash(Seed.Random().Value), TransactionTrytes = TryteString.FromUtf8String( JsonConvert.SerializeObject( new Contact { ChatAddress = storedContactAddress })) }; await transactionCache.SaveTransactionAsync(cacheItem); await contactRepository.AddContactAsync(storedContactAddress, true, pubKeyAddress); var iotaRepositoryMock = new Mock <IIotaRepository>(); iotaRepositoryMock.Setup(i => i.FindTransactionsByAddressesAsync(It.IsAny <List <Address> >())).ReturnsAsync( new TransactionHashList { Hashes = new List <Hash> { cacheItem.TransactionHash } }); var interactor = new GetContactsInteractor(contactRepository, transactionCache, iotaRepositoryMock.Object); var response = await interactor.ExecuteAsync( new GetContactsRequest { PublicKeyAddress = new Address(pubKeyAddress), ContactRequestAddress = contactRequestAddress }); Assert.AreEqual(1, response.ApprovedContacts.Count); }
public async Task TestChatPasKeyIsSentViaMessenger() { var messenger = new InMemoryMessenger(); var respository = new InMemoryContactRepository(); var interactor = new AddContactInteractor(respository, messenger); var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW"); var request = new AddContactRequest { ContactAddress = contactAddress, RequestAddress = new Address(Seed.Random().Value), ImageHash = "kjasdjkahsda89dafhfafa", Name = "Chiota User", PublicKeyAddress = new Address(Seed.Random().Value) }; var response = await interactor.ExecuteAsync(request); Assert.AreEqual(2, messenger.SentMessages.Count); Assert.AreEqual(ResponseCode.Success, response.Code); }
public void Index_Get_RetrievesAllContactsFromRepository() { // Arrange Contact contact1 = GetContactNamed(1, "Orlando", "Gee"); Contact contact2 = GetContactNamed(2, "Keith", "Harris"); InMemoryContactRepository repository = new InMemoryContactRepository(); repository.Add(contact1); repository.Add(contact2); var controller = GetHomeController(repository); // Act var result = controller.Index(); // Assert var model = (IEnumerable <Contact>)result.ViewData.Model; CollectionAssert.Contains(model.ToList(), contact1); CollectionAssert.Contains(model.ToList(), contact1); }
public void Create_Post_ReturnsViewIfRepositoryThrowsException() { // Arrange InMemoryContactRepository repository = new InMemoryContactRepository(); Exception exception = new Exception(); repository.ExceptionToThrow = exception; HomeController controller = GetHomeController(repository); Contact model = GetContactID_1(); // Act var result = (ViewResult)controller.Create(model); // Assert Assert.AreEqual("Create", result.ViewName); ModelState modelState = result.ViewData.ModelState[""]; Assert.IsNotNull(modelState); Assert.IsTrue(modelState.Errors.Any()); Assert.AreEqual(exception, modelState.Errors[0].Exception); }
public async Task TestMessengerCannotSendMessageShouldReturnErrorCodeAndNotWriteToContactRepository() { var messenger = new ExceptionMessenger(); var respository = new InMemoryContactRepository(); var interactor = new AddContactInteractor(respository, messenger); var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW"); var request = new AddContactRequest { ContactAddress = contactAddress, RequestAddress = new Address(Seed.Random().Value), ImagePath = "kjasdjkahsda89dafhfafa", Name = "Chiota User", PublicKeyAddress = new Address(Seed.Random().Value), UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey }; var response = await interactor.ExecuteAsync(request); Assert.AreEqual(ResponseCode.MessengerException, response.Code); Assert.AreEqual(0, respository.PersistedContacts.Count); }
public async Task TestMessengerGetsCalledWithAddContactRequestAndContactJsonPayload() { var messenger = new InMemoryMessenger(); var respository = new InMemoryContactRepository(); var interactor = new AddContactInteractor(respository, messenger); var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW"); var requestAddress = Seed.Random().Value; var publicKeyAddress = Seed.Random().Value; var request = new AddContactRequest { ContactAddress = contactAddress, RequestAddress = new Address(requestAddress), ImagePath = "kjasdjkahsda89dafhfafa", Name = "Chiota User", PublicKeyAddress = new Address(publicKeyAddress), UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey }; await interactor.ExecuteAsync(request); Assert.AreEqual(2, messenger.SentMessages.Count); var sentMessage = messenger.SentMessages[0]; Assert.AreEqual(contactAddress.Value, sentMessage.Receiver.Value); var decryptedPayload = NtruEncryption.Key.Decrypt(InMemoryContactRepository.NtruKeyPair, sentMessage.Payload.ToBytes()); var sentPayload = JsonConvert.DeserializeObject <Contact>(Encoding.UTF8.GetString(decryptedPayload)); Assert.AreEqual("kjasdjkahsda89dafhfafa", sentPayload.ImagePath); Assert.AreEqual("Chiota User", sentPayload.Name); Assert.AreEqual(publicKeyAddress, sentPayload.PublicKeyAddress); Assert.AreEqual(requestAddress, sentPayload.ContactAddress); Assert.IsTrue(InputValidator.IsAddress(sentPayload.ChatAddress)); Assert.IsTrue(InputValidator.IsAddress(sentPayload.ChatKeyAddress)); Assert.IsTrue(sentPayload.Request); Assert.IsFalse(sentPayload.Rejected); }
public static void Main(string[] args) => new WebHostBuilder() .UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .ConfigureAppConfiguration((hostingContext, config) => { config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true).AddEnvironmentVariables(); }) .ConfigureLogging((hostingContext, l) => { l.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); l.AddConsole(); }) .UseIISIntegration() .ConfigureServices(s => { // set up embedded identity server s.AddIdentityServer(). AddTestClients(). AddTestResources(). AddDeveloperSigningCredential(); s.AddRouting() .AddAuthorization(options => { // set up authorization policy for the API options.AddPolicy("API", policy => { policy.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme); policy.RequireAuthenticatedUser().RequireClaim("scope", "read"); }); }) .AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme) .AddIdentityServerAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme, o => { o.Authority = "http://localhost:5000/openid"; o.RequireHttpsMetadata = false; }); }) .Configure(app => { app.Map("/openid", id => { // use embedded identity server to issue tokens id.UseIdentityServer(); }) .UseAuthentication() // consume the JWT tokens in the API .Use(async(c, next) => // authorize the whole API against the API policy { var allowed = await c.RequestServices.GetRequiredService <IAuthorizationService>().AuthorizeAsync(c.User, null, "API"); if (allowed.Succeeded) { await next(); } else { c.Response.StatusCode = 401; } }) .UseRouter(r => // define all API endpoints { var contactRepo = new InMemoryContactRepository(); r.MapGet("contacts", async(request, response, routeData) => { var contacts = await contactRepo.GetAll(); response.WriteJson(contacts); }); r.MapGet("contacts/{id:int}", async(request, response, routeData) => { var contact = await contactRepo.Get(Convert.ToInt32(routeData.Values["id"])); if (contact == null) { response.StatusCode = 404; return; } response.WriteJson(contact); }); }); }) .Build().Run();
public static async Task Main(string[] args) => await WebHost.CreateDefaultBuilder(args) .ConfigureServices(s => { // set up embedded identity server s.AddIdentityServer(). AddTestClients(). AddTestResources(). AddDeveloperSigningCredential(); s.AddRouting() .AddAuthorization(options => { // set up authorization policy for the API options.AddPolicy("API", policy => { policy.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme); policy.RequireAuthenticatedUser().RequireClaim("scope", "read"); }); }) .AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme) .AddIdentityServerAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme, o => { o.Authority = "https://localhost:5001/identity"; }); }) .Configure(app => { app.Map("/identity", id => { // use embedded identity server to issue tokens id.UseIdentityServer(); }) .UseAuthentication() // consume the JWT tokens in the API .Use(async(c, next) => // authorize the whole API against the API policy { var allowed = await c.RequestServices.GetRequiredService <IAuthorizationService>().AuthorizeAsync(c.User, null, "API"); if (allowed.Succeeded) { await next(); } else { c.Response.StatusCode = 401; } }) .UseRouter(r => // define all API endpoints { var contactRepo = new InMemoryContactRepository(); r.MapGet("contacts", async(request, response, routeData) => { var contacts = await contactRepo.GetAll(); response.WriteJson(contacts); }); r.MapGet("contacts/{id:int}", async(request, response, routeData) => { var contact = await contactRepo.Get(Convert.ToInt32(routeData.Values["id"])); if (contact == null) { response.StatusCode = 404; return; } response.WriteJson(contact); }); r.MapPost("contacts", async(request, response, routeData) => { var newContact = request.HttpContext.ReadFromJson <Contact>(); if (newContact == null) { return; } await contactRepo.Add(newContact); response.StatusCode = 201; response.WriteJson(newContact); }); r.MapPut("contacts/{id:int}", async(request, response, routeData) => { var updatedContact = request.HttpContext.ReadFromJson <Contact>(); if (updatedContact == null) { return; } updatedContact.ContactId = Convert.ToInt32(routeData.Values["id"]); await contactRepo.Update(updatedContact); response.StatusCode = 204; }); r.MapDelete("contacts/{id:int}", async(request, response, routeData) => { await contactRepo.Delete(Convert.ToInt32(routeData.Values["id"])); response.StatusCode = 204; }); }); }) .Build().RunAsync();
public static async Task Main(string[] args) => await WebHost.CreateDefaultBuilder(args) .ConfigureServices(s => { s.AddEmbeddedIdentityServer(); s.AddRouting(); }) .Configure(app => { app.Map("/identity", id => { // use embedded identity server to issue tokens id.UseIdentityServer(); }) .UseAuthentication() // consume the JWT tokens in the API .Use(async(c, next) => // authorize the whole API against the API policy { var allowed = await c.RequestServices.GetRequiredService <IAuthorizationService>().AuthorizeAsync(c.User, "API"); if (!allowed.Succeeded) { c.Response.StatusCode = 401; return; } await next(); }) .UseRouter(r => // define all API endpoints { var contactRepo = new InMemoryContactRepository(); r.MapGet("contacts", async(request, response, routeData) => { var contacts = await contactRepo.GetAll(); response.WriteJson(contacts); }); r.MapGet("contacts/{id:int}", async(request, response, routeData) => { var contact = await contactRepo.Get(Convert.ToInt32(routeData.Values["id"])); if (contact == null) { response.StatusCode = 404; return; } response.WriteJson(contact); }); r.MapPost("contacts", async(request, response, routeData) => { var newContact = request.HttpContext.ReadFromJson <Contact>(); if (newContact == null) { return; } await contactRepo.Add(newContact); response.StatusCode = 201; response.WriteJson(newContact); }); r.MapPut("contacts/{id:int}", async(request, response, routeData) => { var updatedContact = request.HttpContext.ReadFromJson <Contact>(); if (updatedContact == null) { return; } updatedContact.ContactId = Convert.ToInt32(routeData.Values["id"]); await contactRepo.Update(updatedContact); response.StatusCode = 204; }); r.MapDelete("contacts/{id:int}", async(request, response, routeData) => { await contactRepo.Delete(Convert.ToInt32(routeData.Values["id"])); response.StatusCode = 204; }); }); }) .Build().RunAsync();
public static void Main(string[] args) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddEnvironmentVariables().Build(); var host = new WebHostBuilder() .UseKestrel() .UseConfiguration(config) .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .ConfigureLogging(l => l.AddConsole(config.GetSection("Logging"))) .ConfigureServices(s => { // set up embedded identity server s.AddIdentityServer(). AddTestClients(). AddTestResources(). AddTemporarySigningCredential(); s.AddRouting(); // set up authorization policy for the API s.AddAuthorization(options => { options.AddPolicy("API", policy => { policy.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme); policy.RequireAuthenticatedUser().RequireClaim("scope", "read"); }); }); }) .Configure(app => { // use embedded identity server to issue tokens app.UseIdentityServer(); // consume the JWT tokens in the API app.UseIdentityServerAuthentication(new IdentityServerAuthenticationOptions { Authority = "http://localhost:34917", RequireHttpsMetadata = false, }); // authorize the whole API against the API policy app.Use(async(c, next) => { var authz = c.RequestServices.GetRequiredService <IAuthorizationService>(); var allowed = await authz.AuthorizeAsync(c.User, null, "API"); if (allowed) { await next(); } else { c.Response.StatusCode = 401; } }); // define all API endpoints app.UseRouter(r => { var contactRepo = new InMemoryContactRepository(); r.MapGet("contacts", async(request, response, routeData) => { var contacts = await contactRepo.GetAll(); await response.WriteJson(contacts); }); r.MapGet("contacts/{id:int}", async(request, response, routeData) => { var contact = await contactRepo.Get(Convert.ToInt32(routeData.Values["id"])); if (contact == null) { response.StatusCode = 404; return; } await response.WriteJson(contact); }); }); }) .Build(); host.Run(); }