private void AssertPolicyCreationRequestsAreEqual(PolicyCreationRequest expected, PolicyCreationRequest actual)
{
if (expected.Actions != null && actual.Actions != null)
{
expected.Actions.Sort();
actual.Actions.Sort();
}
CollectionAssert.AreEqual(expected.Actions, actual.Actions);
if (expected.Subjects != null && actual.Subjects != null)
{
expected.Subjects.Sort();
actual.Subjects.Sort();
}
CollectionAssert.AreEqual(expected.Subjects, actual.Subjects);
if (expected.Resources != null && actual.Resources != null)
{
expected.Resources.Sort();
actual.Resources.Sort();
}
CollectionAssert.AreEqual(expected.Resources, actual.Resources);
if (expected.Conditions != null && actual.Conditions != null)
{
expected.Conditions.Sort();
actual.Conditions.Sort();
}
CollectionAssert.AreEqual(expected.Conditions, actual.Conditions);
Assert.AreEqual(expected.Effect, actual.Effect);
Assert.AreEqual(expected.Description, actual.Description);
}
public async Task <IActionResult> CreatePolicy([FromBody] PolicyCreationRequest request)
{
if (string.IsNullOrEmpty(request.Name) ||
string.IsNullOrEmpty(request.Description) ||
string.IsNullOrEmpty(request.CoverageStartDate) ||
request.CoverageLength <= 0 ||
request.PremiumPrice <= 0 ||
!Enum.IsDefined(typeof(RiskLevel), request.RiskLevelId))
{
return(BadRequest());
}
var coverages = new Dictionary <InsuranceCoverage, float>();
if (request.EarthquakeCoverage > 0)
{
coverages.Add(InsuranceCoverage.Earthquake, request.EarthquakeCoverage);
}
if (request.FireCoverage > 0)
{
coverages.Add(InsuranceCoverage.Fire, request.FireCoverage);
}
if (request.TheftCoverage > 0)
{
coverages.Add(InsuranceCoverage.Theft, request.TheftCoverage);
}
if (request.LossCoverage > 0)
{
coverages.Add(InsuranceCoverage.Loss, request.LossCoverage);
}
if (!coverages.Any())
{
return(BadRequest());
}
DateTime coverageStartDate;
try {
coverageStartDate = DateTime.Parse(request.CoverageStartDate);
} catch (FormatException) {
return(BadRequest());
}
var riskLevel = (RiskLevel)request.RiskLevelId;
var policy = await insuranceService.CreatePolicyAsync(
request.Name, request.Description, coverages, coverageStartDate,
request.CoverageLength, request.PremiumPrice, riskLevel);
var response = new PolicyResponse(policy);
return(Ok(response));
}
/// <summary>
/// Adds a policy asynchronously with the information provided as a <see cref="PolicyCreationRequest"/>.
/// </summary>
/// <param name="policyCreationRequest">Information to create the new <see cref="Policy"/> with</param>
/// <returns>The newly created <see cref="Policy"/></returns>
public async Task <Policy> AddPolicyAsync(PolicyCreationRequest policyCreationRequest)
{
await _semaphore.WaitAsync();
try
{
var newPolicy = new Policy(policyCreationRequest)
{
Id = Guid.NewGuid().ToString()
};
_activePolicies.Add(newPolicy.Id, newPolicy);
return(await Task.FromResult(newPolicy));
}
finally
{
_semaphore.Release();
}
}
/// <summary>
/// Adds a policy asynchronously with the information provided as a <see cref="Zuehlke.Hades.PolicyCreationRequest"/>.
/// </summary>
/// <param name="policyCreationRequest">Information to create the new <see cref="Zuehlke.Hades.Policy"/> with</param>
/// <returns>The newly created <see cref="Zuehlke.Hades.Policy"/></returns>
public async Task <Policy> AddPolicyAsync(PolicyCreationRequest policyCreationRequest)
{
using (var con = new SqlConnection(_connectionString))
{
await con.OpenAsync();
using (var transaction = con.BeginTransaction())
{
var guid = Guid.NewGuid().ToString();
var policy = new Policy(policyCreationRequest)
{
Id = guid
};
await AddPolicyAsync(policy, con, transaction);
transaction.Commit();
return(policy);
}
}
}
public async Task <IActionResult> UpdatePolicy([FromRoute] string policyIdString, [FromBody] PolicyCreationRequest request)
{
if (string.IsNullOrEmpty(policyIdString) ||
string.IsNullOrEmpty(request.Name) ||
string.IsNullOrEmpty(request.Description) ||
string.IsNullOrEmpty(request.CoverageStartDate) ||
request.CoverageLength <= 0 ||
request.PremiumPrice <= 0 ||
!Enum.IsDefined(typeof(RiskLevel), request.RiskLevelId))
{
return(BadRequest());
}
Guid policyId;
try {
policyId = Guid.Parse(policyIdString);
} catch (FormatException) {
return(BadRequest());
}
var coverages = new Dictionary <InsuranceCoverage, float>();
if (request.EarthquakeCoverage > 0)
{
coverages.Add(InsuranceCoverage.Earthquake, request.EarthquakeCoverage);
}
if (request.FireCoverage > 0)
{
coverages.Add(InsuranceCoverage.Fire, request.FireCoverage);
}
if (request.TheftCoverage > 0)
{
coverages.Add(InsuranceCoverage.Theft, request.TheftCoverage);
}
if (request.LossCoverage > 0)
{
coverages.Add(InsuranceCoverage.Loss, request.LossCoverage);
}
if (!coverages.Any())
{
return(BadRequest());
}
DateTime coverageStartDate;
try {
coverageStartDate = DateTime.Parse(request.CoverageStartDate);
} catch (FormatException) {
return(BadRequest());
}
var riskLevel = (RiskLevel)request.RiskLevelId;
InsurancePolicy policy;
try {
policy = await insuranceService.GetPolicyAsync(policyId);
} catch (ResourceNotFoundException) {
return(NotFound());
}
var updatedPolicy = await insuranceService.UpdatePolicyAsync(policyId, request.Name, request.Description, request.PremiumPrice);
var response = new PolicyResponse(updatedPolicy);
return(Ok(response));
}
