public async Task <ManagePendingCharges> HandleAsync(Requests.Charges.FetchPendingCharges message)
{
authorization.EnsureCanAccessInternalArea(true);
UKCompetentAuthority authority = await dataAccess.FetchCompetentAuthority(message.Authority);
IReadOnlyList <MemberUpload> memberUploads = await dataAccess.FetchSubmittedNonInvoicedMemberUploadsAsync(authority);
var groups = memberUploads.GroupBy(mu => new { mu.Scheme, mu.ComplianceYear });
List <PendingCharge> pendingCharges = new List <PendingCharge>();
foreach (var group in groups)
{
PendingCharge pendingCharge = new PendingCharge()
{
SchemeName = group.Key.Scheme.SchemeName,
SchemeApprovalNumber = group.Key.Scheme.ApprovalNumber,
ComplianceYear = group.Key.ComplianceYear.Value,
TotalGBP = group.Sum(p => p.TotalCharges),
SubmittedDate = group.FirstOrDefault().SubmittedDate.Value
};
pendingCharges.Add(pendingCharge);
}
var managePendingCharges = new ManagePendingCharges
{
PendingCharges = pendingCharges,
CanUserIssueCharges = authorization.CheckUserInRole(Roles.InternalAdmin)
};
return(managePendingCharges);
}
public async Task <SchemeData> HandleAsync(GetSchemeById request)
{
authorization.EnsureCanAccessInternalArea();
var scheme = await dataAccess.GetSchemeOrDefault(request.SchemeId);
if (scheme == null)
{
string message = string.Format("No scheme was found with id \"{0}\".", request.SchemeId);
throw new ArgumentException(message);
}
var schemeData = mapper.Map <Scheme, SchemeData>(scheme);
var complianceYearsWithSubmittedMemberUploads =
await dataAccess.GetComplianceYearsWithSubmittedMemberUploads(request.SchemeId);
var complianceYearsWithSubmittedDataReturns =
await dataAccess.GetComplianceYearsWithSubmittedDataReturns(request.SchemeId);
var schemeDownloadsByYears = mapper.Map <Core.Scheme.SchemeDataAvailability>(
Domain.Scheme.SchemeDataAvailability.Create(
complianceYearsWithSubmittedMemberUploads,
complianceYearsWithSubmittedDataReturns));
schemeData.SchemeDataAvailability = schemeDownloadsByYears;
schemeData.CanEdit = authorization.CheckUserInRole(Roles.InternalAdmin);
return(schemeData);
}
public async void HandleAsync_GivenAatfId_CanEditContactDetailsSet(bool selectedValue)
{
var aatfContact = A.Fake <AatfContact>();
A.CallTo(() => authorization.CheckUserInRole(A <Roles> ._)).Returns(selectedValue);
A.CallTo(() => dataAccess.GetContact(A <Guid> ._)).Returns(aatfContact);
var result = await handler.HandleAsync(A.Dummy <GetAatfContact>());
result.CanEditContactDetails.Should().Be(selectedValue);
}
public async Task <AatfContactData> HandleAsync(GetAatfContact message)
{
authorization.EnsureCanAccessInternalArea();
var contact = await dataAccess.GetContact(message.AatfId);
var result = mapper.Map(contact);
result.CanEditContactDetails = authorization.CheckUserInRole(Roles.InternalAdmin);
return(result);
}
public async Task <OrganisationData> HandleAsync(OrganisationBySchemeId message)
{
authorization.CheckInternalOrSchemeAccess(message.SchemeId);
var organisation = await organisationDataAccess.GetBySchemeId(message.SchemeId);
var organisationData = mapper.Map <Organisation, OrganisationData>(organisation);
organisationData.CanEditOrganisation = authorization.CheckUserInRole(Roles.InternalAdmin);
return(organisationData);
}
public async Task HandleAsync_GivenReturnAndAuthorisation_CanEditPropertiesShouldBeSet()
{
var aatfData = this.fixture.Create <AatfData>();
var aatf = this.fixture.Create <Aatf>();
var canEdit = this.fixture.Create <bool>();
A.CallTo(() => this.fakeMapper.Map(aatf)).Returns(aatfData);
A.CallTo(() => this.dataAccess.GetAatfById(A.Dummy <Guid>())).Returns(aatf);
A.CallTo(() => authorization.CheckUserInRole(Roles.InternalAdmin)).Returns(canEdit);
var result = await this.handler.HandleAsync(new GetAatfById(A.Dummy <Guid>()));
result.CanEdit.Should().Be(canEdit);
result.Contact.CanEditContactDetails.Should().Be(canEdit);
}
public async Task <OrganisationData> HandleAsync(GetInternalOrganisation query)
{
authorization.EnsureCanAccessInternalArea();
var org = await context.Organisations.SingleOrDefaultAsync(o => o.Id == query.OrganisationId);
if (org == null)
{
throw new ArgumentException($"Could not find an organisation with id {query.OrganisationId}");
}
var organisationData = organisationMap.Map(org);
organisationData.CanEditOrganisation = authorization.CheckUserInRole(Roles.InternalAdmin);
return(organisationData);
}
public async Task <ManageUserData> HandleAsync(GetUserData query)
{
authorization.EnsureCanAccessInternalArea();
var manageUserData = await dataAccess.GetOrganisationUser(query.OrganisationUserId) ??
await dataAccess.GetCompetentAuthorityUser(query.OrganisationUserId);
if (manageUserData != null &&
userContext != null &&
userContext.UserId.ToString() == manageUserData.UserId)
{
manageUserData.CanManageRoleAndStatus = false;
}
manageUserData.CanEditUser = authorization.CheckUserInRole(Roles.InternalAdmin);
return(manageUserData);
}
public async Task <ProducerDetailsScheme> HandleAsync(Requests.Admin.GetProducerDetailsByRegisteredProducerId request)
{
authorization.EnsureCanAccessInternalArea();
RegisteredProducer registeredProducer = await dataAccess.Fetch(request.RegisteredProducerId);
if (registeredProducer == null)
{
string message = string.Format(
"No producer has been registered with the id \"{0}\".",
request.RegisteredProducerId);
throw new Exception(message);
}
bool hasSubmittedEee = false;
IEnumerable <DataReturn> dataReturns = await dataAccess.FetchDataReturns(registeredProducer.Scheme, registeredProducer.ComplianceYear);
foreach (DataReturn dataReturn in dataReturns)
{
if (dataReturn.CurrentVersion != null &&
dataReturn.CurrentVersion.EeeOutputReturnVersion != null)
{
ICollection <EeeOutputAmount> eeeOutputAmounts = dataReturn.CurrentVersion.EeeOutputReturnVersion.EeeOutputAmounts;
if (eeeOutputAmounts.Any(a => a.RegisteredProducer == registeredProducer))
{
hasSubmittedEee = true;
break;
}
}
}
var canRemoveProducer = authorization.CheckUserInRole(Roles.InternalAdmin);
return(new ProducerDetailsScheme
{
SchemeName = registeredProducer.Scheme.SchemeName,
ComplianceYear = registeredProducer.ComplianceYear,
ProducerName = registeredProducer.CurrentSubmission.OrganisationName,
RegistrationNumber = registeredProducer.ProducerRegistrationNumber,
HasSubmittedEEE = hasSubmittedEee,
CanRemoveProducer = canRemoveProducer
});
}
public async Task <AatfData> HandleAsync(GetAatfById message)
{
authorization.EnsureCanAccessInternalArea();
var aatf = await aatfDataAccess.GetAatfById(message.AatfId);
if (aatf == null)
{
throw new ArgumentException($"Could not find an aatf with Id {message.AatfId}");
}
var aatfMapped = mapper.Map(aatf);
var internalAdmin = authorization.CheckUserInRole(Roles.InternalAdmin);
aatfMapped.CanEdit = internalAdmin;
aatfMapped.Contact.CanEditContactDetails = internalAdmin;
return(aatfMapped);
}
public async Task <ProducerDetails> HandleAsync(Requests.Admin.GetProducerDetails request)
{
authorization.EnsureCanAccessInternalArea();
List <ProducerSubmission> producers = await dataAccess.Fetch(request.RegistrationNumber, request.ComplianceYear);
if (producers.Count == 0)
{
string message = string.Format(
"No producer has been registered with the registration number \"{0}\" in the {1} compliance year.",
request.RegistrationNumber, request.ComplianceYear);
throw new ArgumentException(message);
}
ProducerDetails producerDetails = new ProducerDetails();
producerDetails.CanRemoveProducer = authorization.CheckUserInRole(Roles.InternalAdmin);
producerDetails.Schemes = new List <ProducerDetailsScheme>();
var schemeGroups = producers
.GroupBy(p => new { p.MemberUpload.Scheme.Id, p.MemberUpload.Scheme.SchemeName })
.OrderBy(p => p.Key.SchemeName);
foreach (var schemeGroup in schemeGroups)
{
DateTime registrationDate = schemeGroup
.OrderBy(p => p.UpdatedDate)
.First()
.UpdatedDate;
ProducerSubmission latestDetails = schemeGroup
.OrderBy(p => p.UpdatedDate)
.Last();
string companyNumber = null;
if (latestDetails.ProducerBusiness.CompanyDetails != null)
{
companyNumber = latestDetails.ProducerBusiness.CompanyDetails.CompanyNumber;
}
var isAuthorisedRepresentative = "No";
if (latestDetails.AuthorisedRepresentativeId != null &&
latestDetails.AuthorisedRepresentative.OverseasContactId != null &&
latestDetails.AuthorisedRepresentative.OverseasContact != null &&
!string.IsNullOrEmpty(latestDetails.AuthorisedRepresentative.OverseasContact.Email))
{
isAuthorisedRepresentative = "Yes";
}
ProducerContact producerBusinessContact = null;
bool isCompany = false;
if (latestDetails.ProducerBusiness.CompanyDetails != null)
{
producerBusinessContact = latestDetails.ProducerBusiness.CompanyDetails.RegisteredOfficeContact;
isCompany = true;
}
else if (latestDetails.ProducerBusiness.Partnership != null)
{
producerBusinessContact = latestDetails.ProducerBusiness.Partnership.PrincipalPlaceOfBusiness;
}
else
{
throw new MissingFieldException(
string.Format("No producer business details could be found for producer:{0}", latestDetails.Id));
}
ProducerContactDetails producerBusinessContactDetails = new ProducerContactDetails
{
ContactName = producerBusinessContact.ContactName,
Email = producerBusinessContact.Email,
Mobile = producerBusinessContact.Mobile,
Telephone = producerBusinessContact.Telephone,
Address = producerBusinessContact.Address.ToString()
};
ProducerDetailsScheme producerSchemeDetails = new ProducerDetailsScheme()
{
RegisteredProducerId = latestDetails.RegisteredProducer.Id,
SchemeName = schemeGroup.Key.SchemeName,
ProducerName = latestDetails.OrganisationName,
TradingName = latestDetails.TradingName,
RegistrationDate = registrationDate,
CompanyNumber = companyNumber,
ObligationType = (ObligationType)latestDetails.ObligationType,
ChargeBandType = (ChargeBandType)latestDetails.ChargeBandAmount.ChargeBand,
CeasedToExist = latestDetails.CeaseToExist,
IsAuthorisedRepresentative = isAuthorisedRepresentative,
ProducerBusinessContact = producerBusinessContactDetails,
IsCompany = isCompany,
ProducerEeeDetails =
mapper.Map <IEnumerable <ProducerEeeByQuarter>, ProducerEeeDetails>(
(await
dataAccess.EeeOutputBySchemeAndComplianceYear(request.RegistrationNumber, request.ComplianceYear,
schemeGroup.Key.Id)))
};
producerDetails.Schemes.Add(producerSchemeDetails);
}
return(producerDetails);
}
public async Task HandleAsync_ForUnknownBusinessType_ThrowsException()
{
// Arrange
Scheme scheme = new Scheme(A.Dummy <Guid>());
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
A.Dummy <string>(),
A.Dummy <List <MemberUploadError> >(),
A.Dummy <decimal>(),
2017,
scheme,
A.Dummy <string>(),
A.Dummy <string>());
RegisteredProducer registeredProducer = new RegisteredProducer(
"WEE/AA1111AA",
2017,
scheme);
var producer = new ProducerSubmission(
registeredProducer,
memberUpload,
new ProducerBusiness(),
null,
new DateTime(2015, 1, 1),
0,
false,
null,
"Trading Name 1",
EEEPlacedOnMarketBandType.Lessthan5TEEEplacedonmarket,
SellingTechniqueType.Both,
Domain.Obligation.ObligationType.Both,
AnnualTurnOverBandType.Greaterthanonemillionpounds,
new List <BrandName>(),
new List <SICCode>(),
A.Dummy <ChargeBandAmount>(),
0,
A.Dummy <StatusType>());
IGetProducerDetailsDataAccess dataAccess = A.Fake <IGetProducerDetailsDataAccess>();
A.CallTo(() => dataAccess.Fetch(A <string> ._, A <int> ._))
.Returns(new List <ProducerSubmission> {
producer
});
IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();
A.CallTo(() => authorization.CheckUserInRole(Roles.InternalAdmin))
.Returns(false);
IMapper mapper = A.Fake <IMapper>();
GetProducerDetailsHandler handler = new GetProducerDetailsHandler(dataAccess, authorization, mapper);
// Act
Func <Task> action = async() => await handler.HandleAsync(A.Dummy <GetProducerDetails>());
// Assert
await Assert.ThrowsAsync <MissingFieldException>(action);
}
public async Task HandleAsync_ForPartnershipProducer_ReturnsPartnershipContactDetails_AndIsCompanyValueFalse()
{
// Arrange
Scheme scheme = new Scheme(A.Dummy <Guid>());
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
A.Dummy <string>(),
A.Dummy <List <MemberUploadError> >(),
A.Dummy <decimal>(),
2017,
scheme,
A.Dummy <string>(),
A.Dummy <string>());
RegisteredProducer registeredProducer = new RegisteredProducer(
"WEE/AA1111AA",
2017,
scheme);
var producerAddress = new ProducerAddress("PrimaryName", "SecondaryName", "Street", "Town", "Locality", "AdministrativeArea",
new Country(A.Dummy <Guid>(), "TestCountry"), "PostCode");
var producerContact = new ProducerContact(
"Title", "Forename", "Surname", "123456", "1235467", "12345678", "[email protected]", producerAddress);
var producerBusiness = new ProducerBusiness(
partnership: new Partnership("TestPartnership", producerContact, new List <Partner> {
}));
var producer = new ProducerSubmission(
registeredProducer,
memberUpload,
producerBusiness,
null,
new DateTime(2015, 1, 1),
0,
false,
null,
"Trading Name 1",
EEEPlacedOnMarketBandType.Lessthan5TEEEplacedonmarket,
SellingTechniqueType.Both,
Domain.Obligation.ObligationType.Both,
AnnualTurnOverBandType.Greaterthanonemillionpounds,
new List <BrandName>(),
new List <SICCode>(),
A.Dummy <ChargeBandAmount>(),
0,
A.Dummy <StatusType>());
IGetProducerDetailsDataAccess dataAccess = A.Fake <IGetProducerDetailsDataAccess>();
A.CallTo(() => dataAccess.Fetch(A <string> ._, A <int> ._))
.Returns(new List <ProducerSubmission> {
producer
});
IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();
A.CallTo(() => authorization.CheckUserInRole(Roles.InternalAdmin))
.Returns(false);
IMapper mapper = A.Fake <IMapper>();
GetProducerDetailsHandler handler = new GetProducerDetailsHandler(dataAccess, authorization, mapper);
// Act
var result = await handler.HandleAsync(A.Dummy <GetProducerDetails>());
// Assert
Assert.NotNull(result);
Assert.Single(result.Schemes);
ProducerContactDetails businessContact = result.Schemes[0].ProducerBusinessContact;
Assert.Equal("PrimaryName, SecondaryName, Street, Town, Locality, AdministrativeArea, PostCode, TestCountry", businessContact.Address);
Assert.Equal("Title Forename Surname", businessContact.ContactName);
Assert.Equal("123456", businessContact.Telephone);
Assert.Equal("1235467", businessContact.Mobile);
Assert.Equal("[email protected]", businessContact.Email);
Assert.False(result.Schemes[0].IsCompany);
}
public async Task HandleAync_ReturnsFalseForCanRemoveProducer_WhenCurrentUserIsNotInternalAdmin()
{
Scheme scheme = new Scheme(A.Dummy <Guid>());
MemberUpload memberUpload = new MemberUpload(
A.Dummy <Guid>(),
A.Dummy <string>(),
A.Dummy <List <MemberUploadError> >(),
A.Dummy <decimal>(),
2017,
scheme,
A.Dummy <string>(),
A.Dummy <string>());
RegisteredProducer registeredProducer = new RegisteredProducer(
"WEE/AA1111AA",
2017,
scheme);
var producer = new ProducerSubmission(
registeredProducer,
memberUpload,
CreatePartnershipBusiness(),
null,
new DateTime(2015, 1, 1),
0,
false,
null,
"Trading Name 1",
EEEPlacedOnMarketBandType.Lessthan5TEEEplacedonmarket,
SellingTechniqueType.Both,
Domain.Obligation.ObligationType.Both,
AnnualTurnOverBandType.Greaterthanonemillionpounds,
new List <BrandName>(),
new List <SICCode>(),
A.Dummy <ChargeBandAmount>(),
0,
A.Dummy <StatusType>());
IGetProducerDetailsDataAccess dataAccess = A.Fake <IGetProducerDetailsDataAccess>();
A.CallTo(() => dataAccess.Fetch(A <string> ._, A <int> ._))
.Returns(new List <ProducerSubmission> {
producer
});
IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();
A.CallTo(() => authorization.CheckUserInRole(Roles.InternalAdmin))
.Returns(false);
IMapper mapper = A.Fake <IMapper>();
GetProducerDetailsHandler handler = new GetProducerDetailsHandler(dataAccess, authorization, mapper);
var result = await handler.HandleAsync(A.Dummy <GetProducerDetails>());
Assert.False(result.CanRemoveProducer);
A.CallTo(() => authorization.CheckUserInRole(Roles.InternalAdmin))
.MustHaveHappened();
}
public AuthorizationBuilder AllowRole(Roles role)
{
A.CallTo(() => fake.EnsureUserInRole(role)).DoesNothing();
A.CallTo(() => fake.CheckUserInRole(role)).Returns(true);
return(this);
}
