public async void HandleAsync_WithValidOrganisationId_SetsStatusToComplete()
{
Guid organisationId = Guid.NewGuid();
Organisation organisation = A.Dummy <Organisation>();
A.CallTo(() => dataAccess.FetchOrganisationAsync(organisationId))
.Returns(organisation);
CompleteOrganisationAdminHandler handler = new CompleteOrganisationAdminHandler(authorization, this.dataAccess);
CompleteOrganisationAdmin request = new CompleteOrganisationAdmin()
{
OrganisationId = organisationId
};
var result = await handler.HandleAsync(request);
// Assert
A.CallTo(() => dataAccess.FetchOrganisationAsync(organisationId))
.MustHaveHappened(Repeated.Exactly.Once);
Assert.Equal(OrganisationStatus.Complete, organisation.OrganisationStatus);
A.CallTo(() => dataAccess.SaveAsync())
.MustHaveHappened(Repeated.Exactly.Once);
Assert.Equal(result, true);
}
public async Task HandleAsync_EverythingCorrectButWithNewOrganisation_CreateSchemeCallsSaveAndReturnsSuccess_CompleteOrgCalled()
{
Organisation organisation = A.Fake <Organisation>();
organisation.OrganisationStatus = Domain.Organisation.OrganisationStatus.Incomplete;
// Act
CreateScheme request = new CreateScheme(
organisation.Id,
"New scheme name",
"WEE/AB8888CD/SCH",
"WEE7453956",
ObligationType.B2B,
new Guid("559B69CE-865C-465F-89ED-D6A58AA8B0B9"),
SchemeStatus.Approved);
A.CallTo(() => organisationDataAccess.FetchOrganisationAsync(organisation.Id)).Returns(organisation);
CreateOrUpdateSchemeInformationResult result = await handler.HandleAsync(request);
A.CallTo(() => dataAccess.SaveAsync()).MustHaveHappened();
A.CallTo(() => organisationDataAccess.SaveAsync()).MustHaveHappened();
Assert.NotNull(result);
Assert.Equal(CreateOrUpdateSchemeInformationResult.ResultType.Success, result.Result);
}
public async Task <bool> HandleAsync(CompleteOrganisationAdmin message)
{
authorization.EnsureCanAccessInternalArea();
authorization.EnsureUserInRole(Roles.InternalAdmin);
Organisation organisation = await dataAccess.FetchOrganisationAsync(message.OrganisationId);
organisation.OrganisationStatus = OrganisationStatus.Complete;
await dataAccess.SaveAsync();
return(true);
}
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 <CreateOrUpdateSchemeInformationResult> HandleAsync(CreateScheme message)
{
authorization.EnsureCanAccessInternalArea();
Scheme scheme = new Scheme(message.OrganisationId);
this.dataAccess.AddScheme(scheme);
/*
* Check the uniqueness of the approval number if the value is being changed.
*/
if (await dataAccess.CheckSchemeApprovalNumberInUseAsync(message.ApprovalNumber))
{
return(new CreateOrUpdateSchemeInformationResult()
{
Result = CreateOrUpdateSchemeInformationResult.ResultType.ApprovalNumberUniquenessFailure
});
}
UKCompetentAuthority environmentAgency = await dataAccess.FetchEnvironmentAgencyAsync();
if (environmentAgency.Id == message.CompetentAuthorityId)
{
// The 1B1S customer reference is mandatory for schemes in the Environmetn Agency.
if (string.IsNullOrEmpty(message.IbisCustomerReference))
{
return(new CreateOrUpdateSchemeInformationResult()
{
Result = CreateOrUpdateSchemeInformationResult.ResultType.IbisCustomerReferenceMandatoryForEAFailure,
});
}
else
{
/*
* The 1B1S customer refernece must be unique across schemes within the Environment Agency.
*
* Try and find another non-rejected scheme for the Environment Agency with the same
* 1B1S customer reference. In production, this should at most only ever return one result.
*
* As the check for uniqueness has not always existed, it is possible that other
* environments may contain multiple schemes with the same 1B1S customer reference
* so we are using FirstOrDefault rather than SingleOrDefault.
*/
List <Scheme> nonRejectedEnvironmentAgencySchemes = await dataAccess.FetchNonRejectedEnvironmentAgencySchemesAsync();
Scheme otherScheme = nonRejectedEnvironmentAgencySchemes
.Where(s => s.Id != scheme.Id)
.Where(s => s.IbisCustomerReference == message.IbisCustomerReference)
.FirstOrDefault();
if (otherScheme != null)
{
return(new CreateOrUpdateSchemeInformationResult()
{
Result = CreateOrUpdateSchemeInformationResult.ResultType.IbisCustomerReferenceUniquenessFailure,
IbisCustomerReferenceUniquenessFailure = new CreateOrUpdateSchemeInformationResult.IbisCustomerReferenceUniquenessFailureInfo()
{
IbisCustomerReference = message.IbisCustomerReference,
OtherSchemeApprovalNumber = otherScheme.ApprovalNumber,
OtherSchemeName = otherScheme.SchemeName
}
});
}
}
}
Domain.Obligation.ObligationType obligationType = ValueObjectInitializer.GetObligationType(message.ObligationType);
scheme.UpdateScheme(
message.SchemeName,
message.ApprovalNumber,
message.IbisCustomerReference,
obligationType,
message.CompetentAuthorityId);
SchemeStatus status = message.Status.ToDomainEnumeration <SchemeStatus>();
scheme.SetStatus(status);
await dataAccess.SaveAsync();
Organisation org = await organisationDataAccess.FetchOrganisationAsync(message.OrganisationId);
if (org.OrganisationStatus == OrganisationStatus.Incomplete)
{
org.CompleteRegistration();
await organisationDataAccess.SaveAsync();
}
return(new CreateOrUpdateSchemeInformationResult()
{
Result = CreateOrUpdateSchemeInformationResult.ResultType.Success
});
}