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_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(AddAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId);
var address = new AatfAddress(
message.AddressData.Name,
message.AddressData.Address1,
message.AddressData.Address2,
message.AddressData.TownOrCity,
message.AddressData.CountyOrRegion,
message.AddressData.Postcode,
country);
var weeeReused = await genericDataAccess.GetManyByExpression <WeeeReused>(new WeeeReusedByAatfIdAndReturnIdSpecification(message.AatfId, message.ReturnId));
var weeeReusedSite = new WeeeReusedSite(
weeeReused.Last(),
address);
await offSiteDataAccess.Submit(weeeReusedSite);
return(true);
}
public async Task HandleAsync_WithValidInput_SubmitIsCalledCorrectly()
{
var siteRequest = AddAatfSiteRequest();
var weeReused = new WeeeReused(siteRequest.AatfId, siteRequest.ReturnId);
var country = new Country(A.Dummy <Guid>(), A.Dummy <string>());
A.CallTo(() => organisationDetailsDataAccess.FetchCountryAsync(siteRequest.AddressData.CountryId)).Returns(country);
A.CallTo(() => genericDataAccess.GetManyByExpression(
A <WeeeReusedByAatfIdAndReturnIdSpecification> .That.Matches(w =>
w.AatfId == siteRequest.AatfId && w.ReturnId == siteRequest.ReturnId))).Returns(new List <WeeeReused>()
{
weeReused
});
await handler.HandleAsync(siteRequest);
A.CallTo(() => addAatfSiteDataAccess.Submit(A <WeeeReusedSite> .That.Matches(w =>
w.Address.Address1.Equals(siteRequest.AddressData.Address1) &&
w.Address.Address2.Equals(siteRequest.AddressData.Address2) &&
w.Address.CountyOrRegion.Equals(siteRequest.AddressData.CountyOrRegion) &&
w.Address.TownOrCity.Equals(siteRequest.AddressData.TownOrCity) &&
w.Address.Postcode.Equals(siteRequest.AddressData.Postcode) &&
w.Address.Country.Equals(country) &&
w.WeeeReused.Equals(weeReused)))).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);
}
public async Task <bool> HandleAsync(UpdateSchemeContactDetails message)
{
authorization.EnsureInternalOrOrganisationAccess(message.SchemeData.OrganisationId);
if (authorization.CheckCanAccessInternalArea())
{
authorization.EnsureUserInRole(Roles.InternalAdmin);
}
var scheme = await dataAccess.FetchSchemeAsync(message.SchemeData.OrganisationId);
if (scheme == null)
{
var errorMessage = $"A scheme with organisation id \"{message.SchemeData.OrganisationId}\" could not be found.";
throw new ArgumentException(errorMessage);
}
var contact = new Contact(
message.SchemeData.Contact.FirstName,
message.SchemeData.Contact.LastName,
message.SchemeData.Contact.Position);
var contactChanged = !contact.Equals(scheme.Contact);
scheme.AddOrUpdateMainContactPerson(contact);
var country = await dataAccess.FetchCountryAsync(message.SchemeData.Address.CountryId);
var address = new Address(
message.SchemeData.Address.Address1,
message.SchemeData.Address.Address2,
message.SchemeData.Address.TownOrCity,
message.SchemeData.Address.CountyOrRegion,
message.SchemeData.Address.Postcode,
country,
message.SchemeData.Address.Telephone,
message.SchemeData.Address.Email);
var schemeAddressChanged = !address.Equals(scheme.Address);
scheme.AddOrUpdateAddress(address);
await dataAccess.SaveAsync();
if (message.SendNotificationOnChange &&
(contactChanged || schemeAddressChanged) && scheme.CompetentAuthority != null)
{
await weeeEmailService.SendOrganisationContactDetailsChanged(scheme.CompetentAuthority.Email, scheme.SchemeName, EntityType.Pcs);
}
return(true);
}
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 HandleAsync_WithValidInput_SubmitIsCalledCorrectly()
{
var siteRequest = AddSentOnAatfSiteRequest();
var country = new Country(A.Dummy <Guid>(), A.Dummy <string>());
var countryOP = new Country(A.Dummy <Guid>(), A.Dummy <string>());
A.CallTo(() => organisationDetailsDataAccess.FetchCountryAsync(siteRequest.SiteAddressData.CountryId)).Returns(country);
A.CallTo(() => organisationDetailsDataAccess.FetchCountryAsync(siteRequest.OperatorAddressData.CountryId)).Returns(countryOP);
await handler.HandleAsync(siteRequest);
A.CallTo(() => sentOnDataAccess.Submit(A <WeeeSentOn> .That.Matches(w => w.SiteAddress.Address1.Equals(siteRequest.SiteAddressData.Address1) &&
w.SiteAddress.Address2.Equals(siteRequest.SiteAddressData.Address2) &&
w.SiteAddress.CountyOrRegion.Equals(siteRequest.SiteAddressData.CountyOrRegion) &&
w.SiteAddress.Postcode.Equals(siteRequest.SiteAddressData.Postcode) &&
w.SiteAddress.TownOrCity.Equals(siteRequest.SiteAddressData.TownOrCity) &&
w.SiteAddress.Country.Equals(country) &&
w.OperatorAddress.Name.Equals(siteRequest.OperatorAddressData.Name) &&
w.OperatorAddress.Address2.Equals(siteRequest.OperatorAddressData.Address2) &&
w.OperatorAddress.CountyOrRegion.Equals(siteRequest.OperatorAddressData.CountyOrRegion) &&
w.OperatorAddress.Postcode.Equals(siteRequest.OperatorAddressData.Postcode) &&
w.OperatorAddress.TownOrCity.Equals(siteRequest.OperatorAddressData.TownOrCity) &&
w.OperatorAddress.Country.Equals(countryOP)))).MustHaveHappened(Repeated.Exactly.Once);
}
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 <bool> HandleAsync(UpdateOrganisationDetails message)
{
authorization.EnsureCanAccessInternalArea();
authorization.EnsureUserInRole(Roles.InternalAdmin);
Organisation organisation = await dataAccess.FetchOrganisationAsync(message.OrganisationData.Id);
switch (message.OrganisationData.OrganisationType)
{
case Core.Organisations.OrganisationType.RegisteredCompany:
organisation.UpdateRegisteredCompanyDetails(message.OrganisationData.Name, message.OrganisationData.CompanyRegistrationNumber, message.OrganisationData.TradingName);
break;
case Core.Organisations.OrganisationType.Partnership:
organisation.UpdatePartnershipDetails(message.OrganisationData.TradingName);
break;
case Core.Organisations.OrganisationType.SoleTraderOrIndividual:
organisation.UpdateSoleTraderDetails(message.OrganisationData.Name, message.OrganisationData.TradingName);
break;
}
Country country = await dataAccess.FetchCountryAsync(message.OrganisationData.BusinessAddress.CountryId);
Address address = new Address(
message.OrganisationData.BusinessAddress.Address1,
message.OrganisationData.BusinessAddress.Address2,
message.OrganisationData.BusinessAddress.TownOrCity,
message.OrganisationData.BusinessAddress.CountyOrRegion,
message.OrganisationData.BusinessAddress.Postcode,
country,
message.OrganisationData.BusinessAddress.Telephone,
message.OrganisationData.BusinessAddress.Email);
organisation.AddOrUpdateAddress(AddressType.RegisteredOrPPBAddress, address);
await dataAccess.SaveAsync();
return(true);
}
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 <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);
}