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();
}
