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