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