public async void ShouldCheckUserIsAbleToAccessOrganisation() { var organisationId = Guid.NewGuid(); await GetManageableOrganisationUsersHandler().HandleAsync(new GetManageableOrganisationUsers(organisationId)); A.CallTo(() => weeeAuthorization.EnsureOrganisationAccess(organisationId)) .MustHaveHappened(Repeated.Exactly.Once); }
public async Task <bool> HandleAsync(SubmitReturn message) { authorization.EnsureCanAccessExternalArea(); var @return = await genericDataAccess.GetById <Return>(message.ReturnId); if (@return == null) { throw new ArgumentException($"No return was found with id {message.ReturnId}."); } if (@return.ReturnStatus == ReturnStatus.Submitted) { return(true); } authorization.EnsureOrganisationAccess(@return.Organisation.Id); @return.UpdateSubmitted(userContext.UserId.ToString(), message.NilReturn); var aatfs = await fetchAatfDataAccess.FetchAatfByReturnQuarterWindow(@return); var returnAatfs = aatfs.Select(a => new ReturnAatf(a, @return)); await genericDataAccess.AddMany <ReturnAatf>(returnAatfs); await weeeContext.SaveChangesAsync(); return(true); }
public async Task <Guid> HandleAsync(AddContactPerson message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var contactPerson = ValueObjectInitializer.CreateContact(message.ContactPerson); Guid id; if (message.ContactId.HasValue) { var contact = await dataAccess.GetById <Contact>(message.ContactId.Value); contact.Overwrite(contactPerson); id = contact.Id; } else { id = await dataAccess.Add <Contact>(contactPerson); } await db.SaveChangesAsync(); return(id); }
public async Task <List <decimal?> > HandleAsync(Request message) { authorization.EnsureCanAccessExternalArea(); authorization.EnsureOrganisationAccess(message.OrganisationsId); return(await dataAccess.FetchNonObligatedWeeeForReturn(message.ReturnId, message.Dcf)); }
public async Task <Guid> HandleAsync(MemberUploadSubmission message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var memberUpload = await context.MemberUploads.SingleOrDefaultAsync(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.OrganisationId) { throw new ArgumentException(string.Format("Member upload {0} is not owned by PCS {1}", message.MemberUploadId, message.OrganisationId)); } if (!memberUpload.IsSubmitted) { User submittingUser = await domainUserContext.GetCurrentUserAsync(); memberUpload.Submit(submittingUser); await context.SaveChangesAsync(); } return(memberUpload.Id); }
public async Task <ReturnData> GetReturnData(Guid returnId, bool forSummary) { authorization.EnsureCanAccessExternalArea(); var @return = await returnDataAccess.GetById(returnId); if (@return == null) { throw new ArgumentException($"No return found for return id {returnId}"); } authorization.EnsureOrganisationAccess(@return.Organisation.Id); var annualQuarterWindow = await quarterWindowFactory.GetQuarterWindow(@return.Quarter); var returnNonObligatedValues = await nonObligatedDataAccess.FetchNonObligatedWeeeForReturn(returnId); var returnObligatedReceivedValues = await obligatedDataAccess.FetchObligatedWeeeReceivedForReturn(returnId); var returnObligatedReusedValues = await obligatedDataAccess.FetchObligatedWeeeReusedForReturn(returnId); List <Aatf> aatfs; if (forSummary && @return.ReturnStatus.Equals(EA.Weee.Domain.AatfReturn.ReturnStatus.Submitted)) { aatfs = await aatfDataAccess.FetchAatfByReturnId(@return.Id); } else { aatfs = await aatfDataAccess.FetchAatfByReturnQuarterWindow(@return); } var sentOn = await obligatedDataAccess.FetchObligatedWeeeSentOnForReturnByReturn(returnId); var returnSchemeList = await returnSchemeDataAccess.GetSelectedSchemesByReturnId(returnId); var returnReportsOn = await genericDataAccess.GetManyByExpression(new ReturnReportOnByReturnIdSpecification(returnId)); var currentDate = SystemTime.Now; var systemSettings = await systemDataDataAccess.Get(); if (systemSettings.UseFixedCurrentDate) { currentDate = systemSettings.FixedCurrentDate; } var returnQuarterWindow = new ReturnQuarterWindow(@return, annualQuarterWindow, aatfs, returnNonObligatedValues, returnObligatedReceivedValues, returnObligatedReusedValues, @return.Organisation, sentOn, returnSchemeList, returnReportsOn, currentDate); return(mapper.Map(returnQuarterWindow)); }
public async Task <CSVFileData> HandleAsync(GetReturnNonObligatedCsv request) { var @return = await dataAccess.GetById <Return>(request.ReturnId); authorization.EnsureOrganisationAccess(@return.Organisation.Id); var items = await weeContext.StoredProcedures.GetReturnNonObligatedCsvData(@return.Id); var fileName = $"{@return.Quarter.Year}_{@return.Quarter.Q}_{@return.Organisation.OrganisationName}_Non-obligated return data_{SystemTime.UtcNow:ddMMyyyy_HHmm}.csv"; var csvWriter = csvWriterFactory.Create <NonObligatedWeeeReceivedCsvData>(); csvWriter.DefineColumn(@"Compliance year", i => i.Year); csvWriter.DefineColumn(@"Quarter", i => i.Quarter); csvWriter.DefineColumn(@"Submitted by", i => i.SubmittedBy); csvWriter.DefineColumn(@"Submitted date (GMT)", i => i.SubmittedDate); csvWriter.DefineColumn(@"Name of operator", i => i.OrganisationName); csvWriter.DefineColumn(@"Category", i => i.Category); csvWriter.DefineColumn(@"Total non-obligated WEEE received (t)", i => i.TotalNonObligatedWeeeReceived); if (await SelectedDcf(@return.Id)) { csvWriter.DefineColumn(@"Non-obligated WEEE kept / retained by DCFs (t)", i => i.TotalNonObligatedWeeeReceivedFromDcf); } var fileContent = csvWriter.Write(items); return(new CSVFileData { FileContent = fileContent, FileName = fileName }); }
public Task <bool> HandleAsync(VerifyOrganisationExistsAndIncomplete message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var organisationExistsAndIncomplete = context.Organisations.FirstOrDefault(o => o.Id == message.OrganisationId && o.OrganisationStatus.Value == OrganisationStatus.Incomplete.Value) != null; return(Task.FromResult(organisationExistsAndIncomplete)); }
public async Task <List <OrganisationUserData> > HandleAsync(GetManageableOrganisationUsers query) { authorization.EnsureOrganisationAccess(query.OrganisationId); var organisationUsers = await dataAccess.GetManageableUsers(query.OrganisationId); return(organisationUsers.Select(item => organisationUserMap.Map(item)).ToList()); }
public async Task <AatfData> HandleAsync(GetAatfByIdExternal message) { authorization.EnsureCanAccessExternalArea(); var aatf = await fetchDataAccess.FetchById(message.AatfId); authorization.EnsureOrganisationAccess(aatf.Organisation.Id); return(mapper.Map(aatf)); }
public async Task <Guid> HandleAsync(CopyReturn message) { authorization.EnsureCanAccessExternalArea(); var returnCopy = await context.Returns.Include(r => r.Organisation).FirstOrDefaultAsync(r => r.Id == message.ReturnId); if (returnCopy == null) { throw new ArgumentException($"No return was found with id {message.ReturnId}."); } authorization.EnsureOrganisationAccess(returnCopy.Organisation.Id); using (var transaction = context.Database.BeginTransaction()) { try { await CopyReturnReportsOn(message, returnCopy); await CopyReturnSchemes(message, returnCopy); await CopyReturnNonObligated(message, returnCopy); CopyReturnReceived(message, returnCopy); CopyReturnSentOn(message, returnCopy); CopyReturnReused(message, returnCopy); CopyReturn(message, returnCopy); await context.SaveChangesAsync(); await RemoveAatfsWithInvalidApprovalDate(returnCopy); await context.SaveChangesAsync(); await RemoveAnyDuplicateNonObligatedAndSave(returnCopy); transaction.Commit(); return(@returnCopy.Id); } catch { transaction.Rollback(); throw; } finally { transaction.Dispose(); } } }
public async Task <ContactData> HandleAsync(GetContact message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var contact = await dataAccess.GetById <Contact>(message.ContactId); if (contact == null) { throw new ArgumentException($"Could not find a contact with Id {message.ContactId}"); } return(mapper.Map(contact)); }
public async Task <AddressData> HandleAsync(GetAddress message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var address = await dataAccess.GetById <Address>(message.AddressId); if (address == null) { throw new ArgumentException($"Could not find an address with Id {message.AddressId}"); } return(mapper.Map(address)); }
public async Task <SchemeStatus> HandleAsync(GetSchemeStatus message) { authorization.EnsureOrganisationAccess(message.PcsId); var scheme = await context.Schemes .SingleOrDefaultAsync(s => s.OrganisationId == message.PcsId); if (scheme != null) { return(mapper.Map(scheme.SchemeStatus)); } throw new InvalidOperationException(string.Format("Scheme with Id '{0}' does not exist", message.PcsId)); }
public async Task <OrganisationOverview> HandleAsync(GetOrganisationOverview message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var organisationOverview = new OrganisationOverview(); organisationOverview.HasMemberSubmissions = await dataAccess.HasMemberSubmissions(message.OrganisationId); organisationOverview.HasMultipleOrganisationUsers = await dataAccess.HasMultipleManageableOrganisationUsers(message.OrganisationId); organisationOverview.HasDataReturnSubmissions = await dataAccess.HasDataReturnSubmissions(message.OrganisationId); return(organisationOverview); }
public async Task <Guid> HandleAsync(AddAddressToOrganisation message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var addresstype = ValueObjectInitializer.GetAddressType(message.TypeOfAddress); if (await db.Organisations.FirstOrDefaultAsync(o => o.Id == message.OrganisationId) == null) { throw new ArgumentException(string.Format("Could not find an organisation with id {0}", message.OrganisationId)); } var organisation = await db.Organisations.SingleAsync(o => o.Id == message.OrganisationId); if (await db.Countries.FirstOrDefaultAsync(c => c.Id == message.Address.CountryId) == null) { throw new ArgumentException(string.Format("Could not find country with id {0}", message.Address.CountryId)); } var country = await db.Countries.SingleAsync(c => c.Id == message.Address.CountryId); message.Address.CountryName = country.Name; var address = ValueObjectInitializer.CreateAddress(message.Address, country); if (addresstype.Equals(AddressType.SchemeAddress)) { if (message.AddressId.HasValue) { var findAddress = await db.Addresses.SingleAsync(a => a.Id == message.AddressId.Value); findAddress.Overwrite(address); address = findAddress; } else { db.Addresses.Add(address); } } else { organisation.AddOrUpdateAddress(addresstype, address); } await db.SaveChangesAsync(); return(GetAddressId(addresstype, organisation, address)); }
public async Task <OrganisationUserData> HandleAsync(GetManageableOrganisationUser query) { OrganisationUser organisationUser = await context.OrganisationUsers.FindAsync(query.OrganisationUserId); if (organisationUser == null) { string message = string.Format( "No organisation user was found with ID \"{0}\".", query.OrganisationUserId); throw new Exception(message); } authorization.EnsureOrganisationAccess(organisationUser.OrganisationId); return(organisationUserMap.Map(organisationUser)); }
public async Task <MemberUploadData> HandleAsync(GetMemberUploadById message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var memberUpload = await context.MemberUploads.SingleOrDefaultAsync(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.OrganisationId) { throw new ArgumentException(string.Format("Member upload {0} is not owned by PCS {1}", message.MemberUploadId, message.OrganisationId)); } return(memberUploadMap.Map(memberUpload)); }
public async Task <Guid> HandleAsync(AddReturn message) { authorization.EnsureCanAccessExternalArea(); authorization.EnsureOrganisationAccess(message.OrganisationId); await ValidateReturnMessage(message); var quarter = new Quarter(message.Year, (QuarterType)message.Quarter); var aatfOrganisation = await genericDataAccess.GetById <Organisation>(message.OrganisationId); var type = Enumeration.FromValue <EA.Weee.Domain.AatfReturn.FacilityType>((int)message.FacilityType); var aatfReturn = new Return(aatfOrganisation, quarter, userContext.UserId.ToString(), type); await returnDataAccess.Submit(aatfReturn); return(aatfReturn.Id); }
public async Task <CSVFileData> HandleAsync(GetReturnObligatedCsv request) { var @return = await returnDataAccess.GetById(request.ReturnId); authorization.EnsureOrganisationAccess(@return.Organisation.Id); var obligatedData = await weeContext.StoredProcedures.GetReturnObligatedCsvData(@return.Id); var fileName = $"{@return.Quarter.Year}_{@return.Quarter.Q}_{@return.Organisation.OrganisationName}_Obligated return data_{SystemTime.UtcNow:ddMMyyyy_HHmm}.csv"; var fileContent = obligatedData.DataTableToCsv(new List <string>(new string[] { "ReturnId", "AatfKey", "ObligationType", "CategoryId", "AatfId" })); obligatedData.Dispose(); return(new CSVFileData { FileContent = fileContent, FileName = fileName }); }
public async Task <Guid> HandleAsync(CompleteRegistration message) { authorization.EnsureOrganisationAccess(message.OrganisationId); if (await context.Organisations.FirstOrDefaultAsync(o => o.Id == message.OrganisationId) == null) { throw new ArgumentException(string.Format("Could not find an organisation with id {0}", message.OrganisationId)); } var organisation = await context.Organisations.SingleAsync(o => o.Id == message.OrganisationId); organisation.CompleteRegistration(); var scheme = new Scheme(message.OrganisationId, message.AddressId, message.ContactId); context.Schemes.Add(scheme); await context.SaveChangesAsync(); return(organisation.Id); }
public async Task <Guid> HandleAsync(CopyOrganisationAddressIntoRegisteredOffice message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var organisation = await context.Organisations.FirstOrDefaultAsync(o => o.Id == message.OrganisationId); var address = await context.Addresses.FirstOrDefaultAsync(s => s.Id == message.AddressId); if (address == null) { throw new ArgumentException($"Could not find an address with Id {message.AddressId}"); } if (organisation == null) { throw new ArgumentException($"Could not find an organisation with Id {message.OrganisationId}"); } // we're explicitly making a copy here rather than pointing at the same address row // this is only assumed to be the preferred option var businessAddress = new Address( address.Address1, address.Address2, address.TownOrCity, address.CountyOrRegion, address.Postcode, address.Country, address.Telephone, address.Email); organisation.AddOrUpdateAddress(AddressType.RegisteredOrPPBAddress, businessAddress); await context.SaveChangesAsync(); return(organisation.Id); }
public async Task <ReturnStatusData> HandleAsync(GetReturnStatus message) { authorization.EnsureCanAccessExternalArea(); var @return = await returnDataAccess.GetById(message.ReturnId); if (@return == null) { throw new ArgumentException($"No return was found with id {message.ReturnId}."); } authorization.EnsureOrganisationAccess(@return.Organisation.Id); var returnsInYear = await returnDataAccess.GetByComplianceYearAndQuarter(@return); var returnData = new ReturnStatusData { ReturnStatus = mapper.Map <ReturnStatus>(@return.ReturnStatus), OrganisationId = @return.Organisation.Id, OtherInProgressReturn = returnsInYear.Any(r => r.ReturnStatus == EA.Weee.Domain.AatfReturn.ReturnStatus.Created) }; return(returnData); }
public async Task <Guid> HandleAsync(UpdateOrganisationTypeDetails message) { authorization.EnsureOrganisationAccess(message.OrganisationId); var organisation = await db.Organisations.SingleOrDefaultAsync(o => o.Id == message.OrganisationId); if (organisation == null) { throw new ArgumentException(string.Format("Could not find an organisation with id {0}", message.OrganisationId)); } organisation.UpdateOrganisationTypeDetails(message.Name, message.CompaniesRegistrationNumber, message.TradingName, GetOrganisationType(message.OrganisationType)); try { await db.SaveChangesAsync(); } catch (Exception ex) { throw new InvalidOperationException(ex.Message); } return(organisation.Id); }
public async Task <Guid> HandleAsync(ProcessXmlFile message) { authorization.EnsureOrganisationAccess(message.OrganisationId); // record XML processing start time Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); var errors = await xmlValidator.Validate(message); List <MemberUploadError> memberUploadErrors = errors as List <MemberUploadError> ?? errors.ToList(); bool containsSchemaErrors = memberUploadErrors.Any(e => e.ErrorType == UploadErrorType.Schema); bool containsErrorOrFatal = memberUploadErrors.Any(e => (e.ErrorLevel == ErrorLevel.Error || e.ErrorLevel == ErrorLevel.Fatal)); Dictionary <string, ProducerCharge> producerCharges = null; int deserializedcomplianceYear = 0; decimal?totalChargesCalculated = 0; var scheme = await context.Schemes.SingleAsync(c => c.OrganisationId == message.OrganisationId); var annualChargeToBeAdded = false; if (!containsSchemaErrors || !containsErrorOrFatal) { var deserializedXml = xmlConverter.Deserialize <schemeType>(xmlConverter.Convert(message.Data)); deserializedcomplianceYear = int.Parse(deserializedXml.complianceYear); var hasAnnualCharge = totalChargeCalculatorDataAccess.CheckSchemeHasAnnualCharge(scheme, deserializedcomplianceYear); if (!hasAnnualCharge) { var annualcharge = scheme.CompetentAuthority.AnnualChargeAmount ?? 0; if (annualcharge > 0 || scheme.CompetentAuthority.Abbreviation == UKCompetentAuthorityAbbreviationType.EA) { annualChargeToBeAdded = true; } } producerCharges = totalChargeCalculator.TotalCalculatedCharges(message, scheme, deserializedcomplianceYear, annualChargeToBeAdded, ref totalChargesCalculated); if (xmlChargeBandCalculator.ErrorsAndWarnings.Any(e => e.ErrorLevel == ErrorLevel.Error) && memberUploadErrors.All(e => e.ErrorLevel != ErrorLevel.Error)) { throw new ApplicationException(String.Format( "Upload for Organisation '{0}' has no validation errors, but does have producer charge calculation errors which are not currently being enforced", message.OrganisationId)); } } var totalCharges = totalChargesCalculated ?? 0; var upload = generateFromXml.GenerateMemberUpload(message, memberUploadErrors, totalCharges, scheme, annualChargeToBeAdded); IEnumerable <ProducerSubmission> producers = Enumerable.Empty <ProducerSubmission>(); //Build producers domain object if there are no errors (schema or business) during validation of xml file. if (!containsErrorOrFatal) { producers = await generateFromXml.GenerateProducers(message, upload, producerCharges); } // record XML processing end time stopwatch.Stop(); upload.SetProcessTime(stopwatch.Elapsed); context.MemberUploads.Add(upload); producerSubmissionDataAccess.AddRange(producers); await context.SaveChangesAsync(); return(upload.Id); }
public AuthorizationBuilder AllowOrganisationAccess() { A.CallTo(() => fake.EnsureOrganisationAccess(A.Dummy <Guid>())).WithAnyArguments().DoesNothing(); A.CallTo(() => fake.CheckOrganisationAccess(A.Dummy <Guid>())).WithAnyArguments().Returns(true); return(this); }