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