public async Task HandleAsync_GivenMessageContainingUpdatedAmounts_AmountsAreUpdatedCorrectly()
{
var updatedValues = new List <ObligatedValue>()
{
new ObligatedValue(Guid.NewGuid(), A.Dummy <int>(), 1, 2),
new ObligatedValue(Guid.NewGuid(), A.Dummy <int>(), 3, 4)
};
var message = new EditObligatedSentOn()
{
CategoryValues = updatedValues
};
var returnAmounts = new List <WeeeSentOnAmount>()
{
new WeeeSentOnAmount(A.Dummy <WeeeSentOn>(), A.Dummy <int>(), A.Dummy <decimal?>(), A.Dummy <decimal?>()),
new WeeeSentOnAmount(A.Dummy <WeeeSentOn>(), A.Dummy <int>(), A.Dummy <decimal?>(), A.Dummy <decimal?>())
};
A.CallTo(() => genericDataAccess.GetById <WeeeSentOnAmount>(updatedValues.ElementAt(0).Id)).Returns(returnAmounts.ElementAt(0));
A.CallTo(() => genericDataAccess.GetById <WeeeSentOnAmount>(updatedValues.ElementAt(1).Id)).Returns(returnAmounts.ElementAt(1));
await handler.HandleAsync(message);
A.CallTo(() => obligatedSentOnDataAccess.UpdateAmounts(returnAmounts.ElementAt(0), 1, 2)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => obligatedSentOnDataAccess.UpdateAmounts(returnAmounts.ElementAt(1), 3, 4)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task HandleAsync_GivenMessageContainingUpdatedAmounts_AmountsAreUpdatedCorrectly()
{
var updatedValues = new List <NonObligatedValue>()
{
new NonObligatedValue(A.Dummy <int>(), 1, false, Guid.NewGuid()),
new NonObligatedValue(A.Dummy <int>(), 2, false, Guid.NewGuid())
};
var message = new EditNonObligated()
{
CategoryValues = updatedValues
};
var returnAmounts = new List <NonObligatedWeee>()
{
new NonObligatedWeee(A.Fake <Return>(), 1, false, 1),
new NonObligatedWeee(A.Fake <Return>(), 2, false, 2)
};
A.CallTo(() => genericDataAccess.GetById <NonObligatedWeee>(updatedValues.ElementAt(0).Id)).Returns(returnAmounts.ElementAt(0));
A.CallTo(() => genericDataAccess.GetById <NonObligatedWeee>(updatedValues.ElementAt(1).Id)).Returns(returnAmounts.ElementAt(1));
await handler.HandleAsync(message);
A.CallTo(() => nonObligatedDataAccess.UpdateAmount(returnAmounts.ElementAt(0), 1)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => nonObligatedDataAccess.UpdateAmount(returnAmounts.ElementAt(1), 2)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task HandleAsync_GivenAddressId_AddressShouldBeRetrieved()
{
var id = Guid.NewGuid();
var result = await handler.HandleAsync(new GetAddress(id, A.Dummy <Guid>()));
A.CallTo(() => dataAccess.GetById <Address>(id)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task HandleAsync_GivenSiteAddressDataInRequest_AddressDataShouldBeOfTypeSiteAddressData()
{
var request = CreateRequest();
var value = A.Fake <AatfAddress>();
var country = new Country(A.Dummy <Guid>(), A.Dummy <string>());
A.CallTo(() => genericDataAccess.GetById <AatfAddress>(request.SiteAddressData.Id)).Returns(value);
A.CallTo(() => organisationDetailsDataAccess.FetchCountryAsync(request.SiteAddressData.CountryId)).Returns(country);
await handler.HandleAsync(request);
A.CallTo(() => offSiteDataAccess.Update(value, A <SiteAddressData> ._, country)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task HandleAsync_GivenGetSentOnAatfSiteRequest_DataAccessIsCalled()
{
var weeeSentOnId = Guid.NewGuid();
var weeeSentOn = new WeeeSentOn();
var weeeSentOnAmount = new List <WeeeSentOnAmount>();
A.CallTo(() => genericDataAccess.GetById <WeeeSentOn>(weeeSentOnId)).Returns(weeeSentOn);
A.CallTo(() => obligatedWeeeDataAccess.FetchObligatedWeeeSentOnForReturn(weeeSentOnId)).Returns(weeeSentOnAmount);
await handler.HandleAsync(new RemoveWeeeSentOn(weeeSentOnId));
A.CallTo(() => genericDataAccess.Remove(weeeSentOn)).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => genericDataAccess.RemoveMany(weeeSentOnAmount)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <Guid> HandleAsync(AddContactPerson message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
var contactPerson = ValueObjectInitializer.CreateContact(message.ContactPerson);
Guid id;
if (message.ContactId.HasValue)
{
var contact = await dataAccess.GetById <Contact>(message.ContactId.Value);
contact.Overwrite(contactPerson);
id = contact.Id;
}
else
{
id = await dataAccess.Add <Contact>(contactPerson);
}
await db.SaveChangesAsync();
return(id);
}
public async Task <CSVFileData> HandleAsync(GetReturnNonObligatedCsv request)
{
var @return = await dataAccess.GetById <Return>(request.ReturnId);
authorization.EnsureOrganisationAccess(@return.Organisation.Id);
var items = await weeContext.StoredProcedures.GetReturnNonObligatedCsvData(@return.Id);
var fileName =
$"{@return.Quarter.Year}_{@return.Quarter.Q}_{@return.Organisation.OrganisationName}_Non-obligated return data_{SystemTime.UtcNow:ddMMyyyy_HHmm}.csv";
var csvWriter = csvWriterFactory.Create <NonObligatedWeeeReceivedCsvData>();
csvWriter.DefineColumn(@"Compliance year", i => i.Year);
csvWriter.DefineColumn(@"Quarter", i => i.Quarter);
csvWriter.DefineColumn(@"Submitted by", i => i.SubmittedBy);
csvWriter.DefineColumn(@"Submitted date (GMT)", i => i.SubmittedDate);
csvWriter.DefineColumn(@"Name of operator", i => i.OrganisationName);
csvWriter.DefineColumn(@"Category", i => i.Category);
csvWriter.DefineColumn(@"Total non-obligated WEEE received (t)", i => i.TotalNonObligatedWeeeReceived);
if (await SelectedDcf(@return.Id))
{
csvWriter.DefineColumn(@"Non-obligated WEEE kept / retained by DCFs (t)", i => i.TotalNonObligatedWeeeReceivedFromDcf);
}
var fileContent = csvWriter.Write(items);
return(new CSVFileData
{
FileContent = fileContent,
FileName = fileName
});
}
public async Task <bool> HandleAsync(RemoveWeeeSentOn message)
{
authorization.EnsureCanAccessExternalArea();
var weeeSentOn = await genericDataAccess.GetById <WeeeSentOn>(message.WeeeSentOnId);
if (weeeSentOn == null)
{
return(false);
}
var weeeSentOnAmount = await obligatedWeeeDataAccess.FetchObligatedWeeeSentOnForReturn(message.WeeeSentOnId);
genericDataAccess.Remove(weeeSentOn.SiteAddress);
genericDataAccess.Remove(weeeSentOn.OperatorAddress);
genericDataAccess.Remove(weeeSentOn);
genericDataAccess.RemoveMany(weeeSentOnAmount);
await context.SaveChangesAsync();
return(true);
}
public async Task <bool> HandleAsync(SubmitReturn message)
{
authorization.EnsureCanAccessExternalArea();
var @return = await genericDataAccess.GetById <Return>(message.ReturnId);
if (@return == null)
{
throw new ArgumentException($"No return was found with id {message.ReturnId}.");
}
if (@return.ReturnStatus == ReturnStatus.Submitted)
{
return(true);
}
authorization.EnsureOrganisationAccess(@return.Organisation.Id);
@return.UpdateSubmitted(userContext.UserId.ToString(), message.NilReturn);
var aatfs = await fetchAatfDataAccess.FetchAatfByReturnQuarterWindow(@return);
var returnAatfs = aatfs.Select(a => new ReturnAatf(a, @return));
await genericDataAccess.AddMany <ReturnAatf>(returnAatfs);
await weeeContext.SaveChangesAsync();
return(true);
}
public async Task HandleAsync_GivenMessageContainingUpdatedAddress_DetailsAreUpdatedCorrectly()
{
var updateRequest = new EditAatfSite()
{
AddressData = new SiteAddressData()
{
Name = "Name",
Address1 = "Address1",
Address2 = "Address2",
TownOrCity = "Town",
CountyOrRegion = "County",
Postcode = "Postcode",
CountryId = Guid.NewGuid(),
Id = Guid.NewGuid()
}
};
var returnAdress = A.Fake <AatfAddress>();
var country = new Country(A.Dummy <Guid>(), A.Dummy <string>());
A.CallTo(() => organisationDetailsDataAccess.FetchCountryAsync(updateRequest.AddressData.CountryId)).Returns(country);
A.CallTo(() => genericDataAccess.GetById <AatfAddress>(updateRequest.AddressData.Id)).Returns(returnAdress);
await handler.HandleAsync(updateRequest);
A.CallTo(() => aatfSiteDataAccess.Update(returnAdress, updateRequest.AddressData, country)).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <bool> HandleAsync(RemoveAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var site = await genericDataAccess.GetById <AatfAddress>(message.SiteId);
var weeeReusedSiteId = (await genericDataAccess.GetSingleByExpression <WeeeReusedSite>(new WeeeReusedByAddressIdSpecification(message.SiteId))).Id;
var weeeReusedSite = await genericDataAccess.GetById <WeeeReusedSite>(weeeReusedSiteId);
genericDataAccess.Remove(weeeReusedSite);
genericDataAccess.Remove(site);
await context.SaveChangesAsync();
return(true);
}
public async Task HandleAsync_GivenGetSentOnAatfSiteRequest_DataAccessIsCalled()
{
var siteAddressId = Guid.NewGuid();
var weeeReusedSiteId = Guid.NewGuid();
var siteAddress = new AatfAddress();
var weeeReusedSite = new WeeeReusedSite();
var weeeReusedSiteReturned = new WeeeReusedSite();
A.CallTo(() => genericDataAccess.GetById <AatfAddress>(siteAddressId)).Returns(siteAddress);
A.CallTo(() => genericDataAccess.GetSingleByExpression <WeeeReusedSite>(A <WeeeReusedByAddressIdSpecification> .That.Matches(w => w.SiteId == siteAddressId))).Returns(weeeReusedSite);
A.CallTo(() => genericDataAccess.GetById <WeeeReusedSite>(weeeReusedSite.Id)).Returns(weeeReusedSiteReturned);
await handler.HandleAsync(new RemoveAatfSite(siteAddressId));
A.CallTo(() => genericDataAccess.Remove(weeeReusedSiteReturned)).MustHaveHappened(Repeated.Exactly.Once)
.Then(A.CallTo(() => genericDataAccess.Remove(siteAddress)).MustHaveHappened(Repeated.Exactly.Once))
.Then(A.CallTo(() => context.SaveChangesAsync()).MustHaveHappened(Repeated.Exactly.Once));
}
public async Task HandleAsync_GivenAddReturnRequest_DataAccessSubmitsIsCalled(QuarterType quarterType, FacilityType facility)
{
var request = new AddReturn {
OrganisationId = Guid.NewGuid(), Quarter = quarterType, Year = year, FacilityType = Core.AatfReturn.FacilityType.Aatf
};
var @return = A.Dummy <Return>();
var organisation = new Organisation();
var userId = Guid.NewGuid();
A.CallTo(() => userContext.UserId).Returns(userId);
A.CallTo(() => genericDataAccess.GetById <Organisation>(request.OrganisationId)).Returns(organisation);
A.CallTo(() => returnFactory.GetReturnQuarter(A <Guid> ._, A <FacilityType> ._)).Returns(new Quarter(year, quarterType));
await handler.HandleAsync(request);
A.CallTo(() => returnDataAccess.Submit(A <Return> .That.Matches(c => c.Quarter.Year == request.Year && (int)c.Quarter.Q == (int)quarterType && c.Organisation.Equals(organisation) && c.CreatedById.Equals(userId.ToString())))).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <Guid> HandleAsync(EditSentOnAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var siteCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.SiteAddressData.CountryId);
var existingSiteAddress = await genericDataAccess.GetById <AatfAddress>(message.SiteAddressData.Id);
var siteAddress = new SiteAddressData()
{
Name = message.SiteAddressData.Name,
Address1 = message.SiteAddressData.Address1,
Address2 = message.SiteAddressData.Address2,
TownOrCity = message.SiteAddressData.TownOrCity,
CountyOrRegion = message.SiteAddressData.CountyOrRegion,
Postcode = message.SiteAddressData.Postcode,
CountryName = message.SiteAddressData.CountryName,
CountryId = message.SiteAddressData.CountryId
};
await offSiteDataAccess.Update(existingSiteAddress, siteAddress, siteCountry);
var operatorCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.OperatorAddressData.CountryId);
var existingOperatorAddress = await genericDataAccess.GetById <AatfAddress>(message.OperatorAddressData.Id);
var operatorAddress = new OperatorAddressData()
{
Name = message.OperatorAddressData.Name,
Address1 = message.OperatorAddressData.Address1,
Address2 = message.OperatorAddressData.Address2,
TownOrCity = message.OperatorAddressData.TownOrCity,
CountyOrRegion = message.OperatorAddressData.CountyOrRegion,
Postcode = message.OperatorAddressData.Postcode,
CountryName = message.OperatorAddressData.CountryName,
CountryId = message.OperatorAddressData.CountryId
};
await offSiteDataAccess.Update(existingOperatorAddress, operatorAddress, operatorCountry);
return(message.WeeeSentOnId);
}
public async Task <bool> HandleAsync(EditAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId);
var value = await genericDataAccess.GetById <AatfAddress>(message.AddressData.Id);
await offSiteDataAccess.Update(value, message.AddressData, country);
return(true);
}
private Guid SetupReturn()
{
var returnId = Guid.NewGuid();
var @return = A.Fake <Return>();
var organisation = Organisation.CreatePartnership("Name");
A.CallTo(() => @return.Quarter).Returns(new Quarter(2019, QuarterType.Q1));
A.CallTo(() => @return.Id).Returns(returnId);
A.CallTo(() => @return.Organisation).Returns(organisation);
A.CallTo(() => dataAccess.GetById <Return>(returnId)).Returns(@return);
return(returnId);
}
public async Task HandleAsync_GivenMessageContainingUpdatedAddress_MapperIsCalled()
{
var data = CreateAatfData(out var competentAuthority);
var updateRequest = fixture.Build <EditAatfDetails>().With(e => e.Data, data).Create();
var siteAddress = A.Fake <AatfAddress>();
A.CallTo(() => addressMapper.Map(data.SiteAddress)).Returns(siteAddress);
var aatf = A.Fake <Aatf>();
A.CallTo(() => genericDataAccess.GetById <Aatf>(updateRequest.Data.Id)).Returns(aatf);
var result = await handler.HandleAsync(updateRequest);
Assert.True(result);
A.CallTo(() => addressMapper.Map(data.SiteAddress)).MustHaveHappenedOnceExactly();
}
public async Task <AddressData> HandleAsync(GetAddress message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
var address = await dataAccess.GetById <Address>(message.AddressId);
if (address == null)
{
throw new ArgumentException($"Could not find an address with Id {message.AddressId}");
}
return(mapper.Map(address));
}
public async Task <bool> HandleAsync(EditNonObligated message)
{
authorization.EnsureCanAccessExternalArea();
foreach (var nonObligatedValue in message.CategoryValues)
{
var value = await genericDataAccess.GetById <NonObligatedWeee>(nonObligatedValue.Id);
await dataAccess.UpdateAmount(value, nonObligatedValue.Tonnage);
}
return(true);
}
public async Task <ContactData> HandleAsync(GetContact message)
{
authorization.EnsureOrganisationAccess(message.OrganisationId);
var contact = await dataAccess.GetById <Contact>(message.ContactId);
if (contact == null)
{
throw new ArgumentException($"Could not find a contact with Id {message.ContactId}");
}
return(mapper.Map(contact));
}
public async Task <bool> HandleAsync(EditObligatedReceived message)
{
authorization.EnsureCanAccessExternalArea();
foreach (var obligatedValue in message.CategoryValues)
{
var value = await genericDataAccess.GetById <WeeeReceivedAmount>(obligatedValue.Id);
await obligatedReceivedDataAccess.UpdateAmounts(value, obligatedValue.HouseholdTonnage, obligatedValue.NonHouseholdTonnage);
}
return(true);
}
public async Task <bool> HandleAsync(AddAatf message)
{
authorization.EnsureCanAccessInternalArea();
authorization.EnsureUserInRole(Roles.InternalAdmin);
var siteAddress = addressMapper.Map(message.Aatf.SiteAddress);
var organisation = await dataAccess.GetById <Organisation>(message.OrganisationId);
var competentAuthority = await commonDataAccess.FetchCompetentAuthority(message.Aatf.CompetentAuthority.Abbreviation);
var contact = contactMapper.Map(message.AatfContact);
LocalArea localArea = null;
PanArea panArea = null;
if (message.Aatf.LocalAreaData != null)
{
localArea = await commonDataAccess.FetchLookup <LocalArea>(message.Aatf.LocalAreaData.Id);
}
if (message.Aatf.PanAreaData != null)
{
panArea = await commonDataAccess.FetchLookup <PanArea>(message.Aatf.PanAreaData.Id);
}
var aatf = new Domain.AatfReturn.Aatf(
message.Aatf.Name,
competentAuthority,
message.Aatf.ApprovalNumber,
Enumeration.FromValue <Domain.AatfReturn.AatfStatus>(message.Aatf.AatfStatus.Value),
organisation,
siteAddress,
Enumeration.FromValue <Domain.AatfReturn.AatfSize>(message.Aatf.Size.Value),
message.Aatf.ApprovalDate.GetValueOrDefault(),
contact,
message.Aatf.FacilityType.ToDomainEnumeration <Domain.AatfReturn.FacilityType>(),
message.Aatf.ComplianceYear,
localArea,
panArea, message.AatfId);
await dataAccess.Add <Domain.AatfReturn.Aatf>(aatf);
return(true);
}
public async Task <bool> HandleAsync(AddObligatedSentOn message)
{
authorization.EnsureCanAccessExternalArea();
var weeeSent = await genericDataAccess.GetById <WeeeSentOn>(message.WeeeSentOnId);
var aatfWeeeSentOnAmount = new List <WeeeSentOnAmount>();
foreach (var categoryValue in message.CategoryValues)
{
aatfWeeeSentOnAmount.Add(new WeeeSentOnAmount(weeeSent, categoryValue.CategoryId, categoryValue.HouseholdTonnage, categoryValue.NonHouseholdTonnage));
}
await obligatedSentOnDataAccess.Submit(aatfWeeeSentOnAmount);
return(true);
}
public async Task HandleAsync_NoOrganisationAccess_ThrowsSecurityException()
{
var authorization = new AuthorizationBuilder().DenyOrganisationAccess().Build();
A.CallTo(() => genericDataAccess.GetById <Return>(A <Guid> ._)).Returns(A.Fake <Return>());
handler = new SubmitReturnHandler(authorization,
userContext,
genericDataAccess,
weeeContext,
fetchAatfDataAccess);
Func <Task> action = async() => await handler.HandleAsync(A.Dummy <SubmitReturn>());
await action.Should().ThrowAsync <SecurityException>();
}
public async Task <Guid> HandleAsync(AddReturn message)
{
authorization.EnsureCanAccessExternalArea();
authorization.EnsureOrganisationAccess(message.OrganisationId);
await ValidateReturnMessage(message);
var quarter = new Quarter(message.Year, (QuarterType)message.Quarter);
var aatfOrganisation = await genericDataAccess.GetById <Organisation>(message.OrganisationId);
var type = Enumeration.FromValue <EA.Weee.Domain.AatfReturn.FacilityType>((int)message.FacilityType);
var aatfReturn = new Return(aatfOrganisation, quarter, userContext.UserId.ToString(), type);
await returnDataAccess.Submit(aatfReturn);
return(aatfReturn.Id);
}
public async Task <Guid> HandleAsync(EditSentOnAatfSiteWithOperator message)
{
authorization.EnsureCanAccessExternalArea();
var sentOn = await genericDataAccess.GetById <WeeeSentOn>((Guid)message.WeeeSentOnId);
Country operatorCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.OperatorAddressData.CountryId);
var operatorAddress = new AatfAddress(
message.OperatorAddressData.Name,
message.OperatorAddressData.Address1,
message.OperatorAddressData.Address2,
message.OperatorAddressData.TownOrCity,
message.OperatorAddressData.CountyOrRegion,
message.OperatorAddressData.Postcode,
operatorCountry);
await sentOnDataAccess.UpdateWithOperatorAddress(sentOn, operatorAddress);
return(sentOn.Id);
}
public async Task HandleAsync_GivenEditSentOnAatfSiteWithOperatorRequest_DataAccessIsCalled()
{
var request = new EditSentOnAatfSiteWithOperator()
{
WeeeSentOnId = Guid.NewGuid(),
OperatorAddressData = new OperatorAddressData()
{
Name = "OpName",
Address1 = "Address1",
Address2 = "Address2",
TownOrCity = "Town",
CountyOrRegion = "County",
Postcode = "GU22 7UY",
CountryId = Guid.NewGuid()
}
};
var weeeSentOn = new WeeeSentOn();
var country = new Country(A.Dummy <Guid>(), A.Dummy <string>());
A.CallTo(() => genericDataAccess.GetById <WeeeSentOn>((Guid)request.WeeeSentOnId)).Returns(weeeSentOn);
A.CallTo(() => orgDataAccess.FetchCountryAsync(request.OperatorAddressData.CountryId)).Returns(country);
var operatorAddress = new AatfAddress(
request.OperatorAddressData.Name,
request.OperatorAddressData.Address1,
request.OperatorAddressData.Address2,
request.OperatorAddressData.TownOrCity,
request.OperatorAddressData.CountyOrRegion,
request.OperatorAddressData.Postcode,
country);
await handler.HandleAsync(request);
A.CallTo(() => sentOnDataAccess.UpdateWithOperatorAddress(weeeSentOn, operatorAddress)).WhenArgumentsMatch(p => p.Get <AatfAddress>("request").Address1 == operatorAddress.Address1);
}
public async Task <Guid> HandleAsync(AddSentOnAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var siteCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.SiteAddressData.CountryId);
var operatorCountry = await organisationDetailsDataAccess.FetchCountryAsync(message.OperatorAddressData.CountryId);
var @return = await returnDataAccess.GetById(message.ReturnId);
var aatf = await genericDataAccess.GetById <Aatf>(message.AatfId);
var siteAddress = new AatfAddress(
message.SiteAddressData.Name,
message.SiteAddressData.Address1,
message.SiteAddressData.Address2,
message.SiteAddressData.TownOrCity,
message.SiteAddressData.CountyOrRegion,
message.SiteAddressData.Postcode,
siteCountry);
var operatorAddress = new AatfAddress(
message.OperatorAddressData.Name,
message.OperatorAddressData.Address1,
message.OperatorAddressData.Address2,
message.OperatorAddressData.TownOrCity,
message.OperatorAddressData.CountyOrRegion,
message.OperatorAddressData.Postcode,
operatorCountry);
var weeeSentOn = new WeeeSentOn(operatorAddress, siteAddress, aatf, @return);
await sentOnDataAccess.Submit(weeeSentOn);
return(weeeSentOn.Id);
}
public async Task <bool> HandleAsync(EditAatfDetails message)
{
authorization.EnsureCanAccessInternalArea();
authorization.EnsureUserInRole(Roles.InternalAdmin);
using (var transaction = context.BeginTransaction())
{
try
{
var updatedAddress = addressMapper.Map(message.Data.SiteAddress);
var existingAatf = await genericDataAccess.GetById <Aatf>(message.Data.Id);
var competentAuthority = await commonDataAccess.FetchCompetentAuthority(message.Data.CompetentAuthority.Abbreviation);
LocalArea localArea = null;
PanArea panArea = null;
if (message.Data.LocalAreaDataId.HasValue)
{
localArea = await commonDataAccess.FetchLookup <LocalArea>(message.Data.LocalAreaDataId.Value);
}
if (message.Data.PanAreaDataId.HasValue)
{
panArea = await commonDataAccess.FetchLookup <PanArea>(message.Data.PanAreaDataId.Value);
}
var updatedAatf = new Aatf(
message.Data.Name,
competentAuthority,
message.Data.ApprovalNumber,
Enumeration.FromValue <Domain.AatfReturn.AatfStatus>(message.Data.AatfStatusValue),
existingAatf.Organisation,
updatedAddress,
Enumeration.FromValue <Domain.AatfReturn.AatfSize>(message.Data.AatfSizeValue),
message.Data.ApprovalDate.GetValueOrDefault(),
existingAatf.Contact,
existingAatf.FacilityType,
existingAatf.ComplianceYear,
localArea,
panArea);
var existingAddress = await genericDataAccess.GetById <AatfAddress>(existingAatf.SiteAddress.Id);
var country = await organisationDetailsDataAccess.FetchCountryAsync(message.Data.SiteAddress.CountryId);
await aatfDataAccess.UpdateAddress(existingAddress, updatedAddress, country);
if (message.Data.ApprovalDate.HasValue && existingAatf.ApprovalDate.HasValue)
{
var flags = await getAatfApprovalDateChangeStatus.Validate(existingAatf, message.Data.ApprovalDate.Value);
if (flags.HasFlag(CanApprovalDateBeChangedFlags.DateChanged))
{
var existingQuarter = await quarterWindowFactory.GetAnnualQuarterForDate(existingAatf.ApprovalDate.Value);
var newQuarter = await quarterWindowFactory.GetAnnualQuarterForDate(message.Data.ApprovalDate.Value);
var range = Enumerable.Range((int)existingQuarter, (int)newQuarter - 1);
await aatfDataAccess.RemoveAatfData(existingAatf, range);
}
}
await aatfDataAccess.UpdateDetails(existingAatf, updatedAatf);
context.Commit(transaction);
}
catch (Exception ex)
{
transaction.Rollback();
if (ex.InnerException != null)
{
throw ex.InnerException;
}
}
finally
{
context.Dispose(transaction);
}
}
return(true);
}
