public async Task <DataReturnSubmissionsHistoryResult> HandleAsync(GetDataReturnSubmissionsHistoryResults request)
{
authorization.EnsureInternalOrOrganisationAccess(request.OrganisationId);
var historyResult = await historyResultsDataAccess.GetDataReturnSubmissionsHistory(request.SchemeId, request.ComplianceYear,
request.Ordering, request.IncludeSummaryData);
var historyData = historyResult.Select(x =>
new
{
Result = x,
HistoryData =
new DataReturnSubmissionsHistoryData
{
SchemeId = x.SchemeId,
OrganisationId = x.OrganisationId,
DataReturnUploadId = x.DataReturnUploadId,
SubmittedBy = x.SubmittedBy,
ComplianceYear = x.ComplianceYear,
SubmissionDateTime = x.SubmissionDateTime,
FileName = x.FileName,
Quarter = x.Quarter,
EeeOutputB2b = x.EeeOutputB2b,
EeeOutputB2c = x.EeeOutputB2c,
WeeeCollectedB2b = x.WeeeCollectedB2b,
WeeeCollectedB2c = x.WeeeCollectedB2c,
WeeeDeliveredB2b = x.WeeeDeliveredB2b,
WeeeDeliveredB2c = x.WeeeDeliveredB2c,
DataReturnVersionId = x.DataReturnVersion.Id
}
})
.ToList();
if (request.CompareEeeOutputData)
{
foreach (var item in historyData)
{
var currentDataVersion = item.Result.DataReturnVersion;
var previousSubmission = await submissionsDataAccess.GetPreviousSubmission(currentDataVersion);
var eeeDataChanged = dataReturnVersionComparer.EeeDataChanged(currentDataVersion, previousSubmission);
item.HistoryData.EeeDataChanged = eeeDataChanged;
if (eeeDataChanged)
{
item.HistoryData.PreviousSubmissionDataReturnVersionId = previousSubmission.Id;
}
}
}
var historyDataList = historyData
.Select(x => x.HistoryData)
.ToList();
return(new DataReturnSubmissionsHistoryResult()
{
Data = historyDataList,
ResultCount = historyDataList.Count
});
}
public async Task <OrganisationData> HandleAsync(GetOrganisationInfo query)
{
authorization.EnsureInternalOrOrganisationAccess(query.OrganisationId);
// Need to materialize EF request before mapping (because mapping parses enums)
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);
var schemes = await context.Schemes.SingleOrDefaultAsync(o => o.OrganisationId == query.OrganisationId);
if (schemes != null)
{
organisationData.SchemeId = schemes.Id;
}
organisationData.HasAatfs = await context.Aatfs.AnyAsync(o => o.Organisation.Id == query.OrganisationId && o.FacilityType.Value == (int)FacilityType.Aatf.Value);
organisationData.HasAes = await context.Aatfs.AnyAsync(o => o.Organisation.Id == query.OrganisationId && o.FacilityType.Value == (int)FacilityType.Ae.Value);
return(organisationData);
}
public Task <bool> HandleAsync(VerifyOrganisationExists message)
{
authorization.EnsureInternalOrOrganisationAccess(message.OrganisationId);
var organisationExists = context.Organisations.FirstOrDefault(o => o.Id == message.OrganisationId) != null;
return(Task.FromResult(organisationExists));
}
public async Task <List <AatfData> > HandleAsync(GetAatfByOrganisation message)
{
authorization.EnsureInternalOrOrganisationAccess(message.OrganisationId);
var aatfs = await genericDataAccess.GetManyByExpression(new AatfsByOrganisationSpecification(message.OrganisationId));
return(aatfs.Select(a => mapper.Map(a)).ToList());
}
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 <SchemeData> HandleAsync(GetSchemeByOrganisationId request)
{
authorization.EnsureInternalOrOrganisationAccess(request.OrganisationId);
var scheme = await dataAccess.GetSchemeOrDefaultByOrganisationId(request.OrganisationId);
if (scheme == null)
{
return(null);
}
var schemeData = mapper.Map <Scheme, SchemeData>(scheme);
return(schemeData);
}
public async Task <int> HandleAsync(UpdateOrganisationUserStatus query)
{
var organisationUser = await dataAccess.GetOrganisationUser(query.OrganisationUserId);
if (organisationUser == null)
{
throw new Exception(string.Format("No organisation user was found with ID \"{0}\".", query.OrganisationUserId));
}
authorization.EnsureInternalOrOrganisationAccess(organisationUser.OrganisationId);
if (userContext != null && userContext.UserId.ToString() == organisationUser.UserId)
{
throw new InvalidOperationException(string.Format("Error for user with Id '{0}': Users cannot change their own status", userContext.UserId));
}
return(await dataAccess.ChangeOrganisationUserStatus(organisationUser, query.UserStatus));
}
public async Task <List <ErrorData> > HandleAsync(GetMemberUploadData message)
{
authorization.EnsureInternalOrOrganisationAccess(message.PcsId);
var memberUpload = await context.MemberUploads.FirstOrDefaultAsync(m => m.Id == message.MemberUploadId);
if (memberUpload == null)
{
throw new ArgumentNullException(string.Format("Could not find a MemberUpload with id {0}", message.MemberUploadId));
}
if (memberUpload.OrganisationId != message.PcsId)
{
throw new ArgumentException(string.Format("Member upload {0} is not owned by PCS {1}", message.MemberUploadId, message.PcsId));
}
return(memberUpload.Errors.OrderBy(e => e.LineNumber).Select(e => memberUploadErrorMap.Map(e)).ToList());
}
public async Task GetSubmissionHistoryResultHandler_RequestByExternalUser_ReturnSubmissionHistoryData()
{
// Arrange
IGetSubmissionsHistoryResultsDataAccess dataAccess = CreateFakeDataAccess();
IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();
GetSubmissionsHistoryResultsHandler handler = new GetSubmissionsHistoryResultsHandler(authorization, dataAccess);
GetSubmissionsHistoryResults request = new GetSubmissionsHistoryResults(A.Dummy <Guid>(), A.Dummy <Guid>(), A.Dummy <int>());
request.Ordering = SubmissionsHistoryOrderBy.ComplianceYearAscending;
// Act
SubmissionsHistorySearchResult results = await handler.HandleAsync(request);
// Assert
A.CallTo(() => authorization.EnsureInternalOrOrganisationAccess(A <Guid> ._)).MustHaveHappened();
Assert.Equal(2, results.Data.Count);
Assert.Equal(2, results.ResultCount);
}
public async Task <ProducerCSVFileData> HandleAsync(GetProducerCSV request)
{
authorization.EnsureInternalOrOrganisationAccess(request.OrganisationId);
var organisation = await context.Organisations.FindAsync(request.OrganisationId);
var scheme = await context.Schemes.SingleAsync(s => s.OrganisationId == request.OrganisationId);
if (organisation == null)
{
string message = string.Format("An organisation could not be found with ID \"{0}\".", request.OrganisationId);
throw new ArgumentException(message);
}
var items = await context.StoredProcedures.SpgCSVDataByOrganisationIdAndComplianceYear(
request.OrganisationId,
request.ComplianceYear);
CsvWriter <ProducerCsvData> csvWriter = csvWriterFactory.Create <ProducerCsvData>();
csvWriter.DefineColumn("Producer name", i => i.OrganisationName);
csvWriter.DefineColumn("Trading name", i => i.TradingName);
csvWriter.DefineColumn("Producer registration number", i => i.RegistrationNumber);
csvWriter.DefineColumn("Company registration number", i => i.CompanyNumber);
csvWriter.DefineColumn("Charge band", i => i.ChargeBand);
csvWriter.DefineColumn("Obligation Type", i => i.ObligationType);
csvWriter.DefineColumn("Date & time (GMT) registered", i => i.DateRegistered.ToString("dd/MM/yyyy HH:mm:ss"));
csvWriter.DefineColumn("Date & time (GMT) last updated", i => (i.DateRegistered.ToString("dd/MM/yyyy HH:mm:ss").Equals(i.DateAmended.ToString("dd/MM/yyyy HH:mm:ss")) ? string.Empty : i.DateAmended.ToString("dd/MM/yyyy HH:mm:ss")));
csvWriter.DefineColumn("Authorised representative", i => i.AuthorisedRepresentative);
csvWriter.DefineColumn("Overseas producer", i => i.OverseasProducer);
string fileContent = csvWriter.Write(items);
var fileName = string.Format("{0}_fullmemberlist_{1}_{2}.csv", scheme.ApprovalNumber, request.ComplianceYear, DateTime.Now.ToString("ddMMyyyy_HHmm"));
return(new ProducerCSVFileData
{
FileContent = fileContent,
FileName = fileName
});
}
public async Task <List <int> > HandleAsync(GetComplianceYears request)
{
authorization.EnsureInternalOrOrganisationAccess(request.PcsId);
var organisation = await context.Organisations.FindAsync(request.PcsId);
if (organisation == null)
{
string message = string.Format("An organisation could not be found with ID \"{0}\".", request.PcsId);
throw new ArgumentException(message);
}
return(await context.MemberUploads
.Where(mu => mu.OrganisationId == request.PcsId)
.Where(mu => mu.IsSubmitted)
.Where(mu => mu.ComplianceYear.HasValue)
.GroupBy(mu => (int)mu.ComplianceYear)
.Select(group => group.Key)
.OrderByDescending(year => year)
.ToListAsync());
}
public async Task GetDataReturnSubmissionsHistoryResultHandler_RequestByExternalUser_ReturnDataReturnSubmissionsHistoryData()
{
// Arrange
IGetDataReturnSubmissionsHistoryResultsDataAccess resultsDataAccess = CreateFakeResultsDataAccess();
var submissionsDataAccess = A.Fake <IDataReturnSubmissionsDataAccess>();
var dataReturnVersionComparer = A.Fake <IDataReturnVersionComparer>();
IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();
GetDataReturnSubmissionsHistoryResultsHandler handler =
new GetDataReturnSubmissionsHistoryResultsHandler(authorization, resultsDataAccess,
submissionsDataAccess, dataReturnVersionComparer);
GetDataReturnSubmissionsHistoryResults request = new GetDataReturnSubmissionsHistoryResults(A.Dummy <Guid>(), A.Dummy <Guid>(), A.Dummy <int>());
request.Ordering = DataReturnSubmissionsHistoryOrderBy.SubmissionDateAscending;
// Act
DataReturnSubmissionsHistoryResult results = await handler.HandleAsync(request);
// Assert
A.CallTo(() => authorization.EnsureInternalOrOrganisationAccess(A <Guid> ._)).MustHaveHappened();
Assert.Equal(2, results.Data.Count);
}
public async Task OrganisationUserExists_AndIsNotCurrentUser_ShouldVerifyAuthorization_BeforeChangingOrgansiationUserStatus(UserStatus userStatus)
{
var userId = Guid.NewGuid();
var organisationId = Guid.NewGuid();
var organisationUserId = Guid.NewGuid();
var organisationUser = OrganisationUser(userStatus, organisationId, Guid.NewGuid());
A.CallTo(() => userContext.UserId)
.Returns(userId);
A.CallTo(() => dataAccess.GetOrganisationUser(organisationUserId))
.Returns(organisationUser);
await
UpdateOrganisationUserStatusHandler()
.HandleAsync(new UpdateOrganisationUserStatus(organisationUserId, userStatus));
A.CallTo(() => weeeAuthorization.EnsureInternalOrOrganisationAccess(A <Guid> ._))
.MustHaveHappened(Repeated.Exactly.Once)
.Then(
A.CallTo(() => dataAccess.ChangeOrganisationUserStatus(organisationUser, userStatus))
.MustHaveHappened(Repeated.Exactly.Once));
}
public async Task <FileInfo> HandleAsync(Requests.DataReturns.FetchSummaryCsv message)
{
authorization.EnsureInternalOrOrganisationAccess(message.OrganisationId);
Domain.Scheme.Scheme scheme = await dataAccess.FetchSchemeAsync(message.OrganisationId);
List <DataReturnSummaryCsvData> results = await dataAccess.FetchResultsAsync(
scheme.Id,
message.ComplianceYear);
CsvWriter <DataReturnSummaryCsvData> csvWriter = CreateWriter();
string content = csvWriter.Write(results);
byte[] data = Encoding.UTF8.GetBytes(content);
string fileName = string.Format("{0}_EEE_WEEE_data_{1}_{2:ddMMyyyy_HHmm}.csv",
scheme.ApprovalNumber,
message.ComplianceYear,
SystemTime.Now);
return(new FileInfo(fileName, data));
}
public async Task <SubmissionsHistorySearchResult> HandleAsync(GetSubmissionsHistoryResults request)
{
authorization.EnsureInternalOrOrganisationAccess(request.OrganisationId);
return(await dataAccess.GetSubmissionsHistory(request.SchemeId, request.ComplianceYear, request.Ordering, request.IncludeSummaryData));
}
public AuthorizationBuilder AllowInternalOrOrganisationAccess()
{
A.CallTo(() => fake.EnsureInternalOrOrganisationAccess(A.Dummy <Guid>())).WithAnyArguments().DoesNothing();
A.CallTo(() => fake.CheckInternalOrOrganisationAccess(A.Dummy <Guid>())).WithAnyArguments().Returns(true);
return(this);
}
