public async Task JoinOrganisationHandler_UserDoesNotExist_ShouldVerifyAuthorization_AndThrowArgumentException()
{
A.CallTo(() => userContext.UserId)
.Returns(Guid.NewGuid());
A.CallTo(() => dataAccess.DoesUserExist(A <Guid> ._))
.Returns(false);
await Assert.ThrowsAnyAsync <ArgumentException>(
() => JoinOrganisationHandler().HandleAsync(new JoinOrganisation(Guid.NewGuid())));
A.CallTo(() => weeeAuthorization.EnsureCanAccessExternalArea())
.MustHaveHappened();
}
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 <List <decimal?> > HandleAsync(Request message)
{
authorization.EnsureCanAccessExternalArea();
authorization.EnsureOrganisationAccess(message.OrganisationsId);
return(await dataAccess.FetchNonObligatedWeeeForReturn(message.ReturnId, message.Dcf));
}
public async Task <Guid> HandleAsync(JoinOrganisation message)
{
authorization.EnsureCanAccessExternalArea();
var userId = userContext.UserId;
if (!await dataAccess.DoesUserExist(userId))
{
throw new ArgumentException(string.Format("Could not find a user with id {0}", userId));
}
if (!await dataAccess.DoesOrganisationExist(message.OrganisationId))
{
throw new ArgumentException(string.Format("Could not find an organisation with id {0}",
message.OrganisationId));
}
var organisationUser = new OrganisationUser(userId, message.OrganisationId,
Domain.User.UserStatus.Pending);
var result = await dataAccess.JoinOrganisation(organisationUser);
if (!result.Successful)
{
throw new InvalidOperationException(result.ErrorMessage);
}
return(message.OrganisationId);
}
public async Task <bool> HandleAsync(RemoveWeeeSentOn message)
{
authorization.EnsureCanAccessExternalArea();
var weeeSentOn = await genericDataAccess.GetById <WeeeSentOn>(message.WeeeSentOnId);
if (weeeSentOn == null)
{
return(false);
}
var weeeSentOnAmount = await obligatedWeeeDataAccess.FetchObligatedWeeeSentOnForReturn(message.WeeeSentOnId);
genericDataAccess.Remove(weeeSentOn.SiteAddress);
genericDataAccess.Remove(weeeSentOn.OperatorAddress);
genericDataAccess.Remove(weeeSentOn);
genericDataAccess.RemoveMany(weeeSentOnAmount);
await context.SaveChangesAsync();
return(true);
}
public async Task <bool> HandleAsync(AddAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId);
var address = new AatfAddress(
message.AddressData.Name,
message.AddressData.Address1,
message.AddressData.Address2,
message.AddressData.TownOrCity,
message.AddressData.CountyOrRegion,
message.AddressData.Postcode,
country);
var weeeReused = await genericDataAccess.GetManyByExpression <WeeeReused>(new WeeeReusedByAatfIdAndReturnIdSpecification(message.AatfId, message.ReturnId));
var weeeReusedSite = new WeeeReusedSite(
weeeReused.Last(),
address);
await offSiteDataAccess.Submit(weeeReusedSite);
return(true);
}
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 <WeeeSentOnData> HandleAsync(GetWeeeSentOnById message)
{
authorization.EnsureCanAccessExternalArea();
var weeeSentOnList = new List <WeeeSentOnData>();
var weeeSentOn = await getSentOnAatfSiteDataAccess.GetWeeeSentOnById(message.WeeeSentOnId);
if (weeeSentOn == null)
{
return(null);
}
var amount = await fetchWeeeSentOnAmountDataAccess.FetchObligatedWeeeSentOnForReturn(weeeSentOn.Id);
var weeeSentOnObligatedData = amount.Select(n => new WeeeObligatedData(n.Id, new AatfData(n.WeeeSentOn.Aatf.Id, n.WeeeSentOn.Aatf.Name, n.WeeeSentOn.Aatf.ApprovalNumber, n.WeeeSentOn.Aatf.ComplianceYear), n.CategoryId, n.NonHouseholdTonnage, n.HouseholdTonnage)).ToList();
var weeeSentOnData = new WeeeSentOnData()
{
SiteAddress = addressMapper.Map(weeeSentOn.SiteAddress),
Tonnages = weeeSentOnObligatedData,
WeeeSentOnId = weeeSentOn.Id,
SiteAddressId = weeeSentOn.SiteAddress.Id
};
if (weeeSentOn.OperatorAddress != null)
{
weeeSentOnData.OperatorAddress = addressMapper.Map(weeeSentOn.OperatorAddress);
weeeSentOnData.OperatorAddressId = weeeSentOn.OperatorAddress.Id;
}
return(weeeSentOnData);
}
public async Task <ReturnData> HandleAsync(GetReturn message)
{
authorization.EnsureCanAccessExternalArea();
var returnData = await getPopulatedReturn.GetReturnData(message.ReturnId, message.ForSummary);
return(returnData);
}
public async Task <bool> HandleAsync(RemoveReturnScheme message)
{
authorization.EnsureCanAccessExternalArea();
await returnSchemeDataAccess.RemoveReturnScheme(message.SchemeIds, message.ReturnId);
return(true);
}
public async Task <List <ReportOnQuestion> > HandleAsync(GetReportOnQuestion message)
{
authorization.EnsureCanAccessExternalArea();
var questions = await dataAccess.GetAll <Domain.AatfReturn.ReportOnQuestion>();
return(questions.Select(s => new ReportOnQuestion(s.Id, s.Question, s.Description, s.ParentId ?? default(int), s.AlternativeDescription, s.Title)).ToList());
}
public async Task <AatfAddressData> HandleAsync(GetSentOnAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var aatfAddress = await getSentOnAatfSiteDataAccess.GetWeeeSentOnSiteAddress(message.WeeeSentOnId);
var addressData = mapper.Map(aatfAddress);
return(addressData);
}
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 <List <SchemeData> > HandleAsync(GetSchemesExternal message)
{
authorization.EnsureCanAccessExternalArea();
var schemes = await dataAccess.GetCompleteSchemes();
return(schemes.Where(s => (s.SchemeStatus == SchemeStatus.Approved) || (s.SchemeStatus == SchemeStatus.Withdrawn))
.Select(s => schemeMap.Map(s))
.OrderBy(sd => sd.SchemeName)
.ToList());
}
public async Task <bool> HandleAsync(AddNonObligated message)
{
authorization.EnsureCanAccessExternalArea();
var aatfReturn = await returnDataAccess.GetById(message.ReturnId);
var nonObligatedWeees = mapper.Map(message, aatfReturn);
await nonObligatedDataAccess.InsertNonObligatedWeee(message.ReturnId, nonObligatedWeees);
return(true);
}
public async Task <bool> HandleAsync(EditNonObligated message)
{
authorization.EnsureCanAccessExternalArea();
var aatfReturn = await returnDataAccess.GetById(message.ReturnId);
var idsToAmounts = mapper.Map(message, aatfReturn);
await nonObligatedDataAccess.UpdateNonObligatedWeeeAmounts(message.ReturnId, idsToAmounts);
return(true);
}
public async Task <bool> HandleAsync(EditAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
Country country = await organisationDetailsDataAccess.FetchCountryAsync(message.AddressData.CountryId);
var value = await genericDataAccess.GetById <AatfAddress>(message.AddressData.Id);
await offSiteDataAccess.Update(value, message.AddressData, country);
return(true);
}
public async Task <bool> HandleAsync(EditNonObligated message)
{
authorization.EnsureCanAccessExternalArea();
foreach (var nonObligatedValue in message.CategoryValues)
{
var value = await genericDataAccess.GetById <NonObligatedWeee>(nonObligatedValue.Id);
await dataAccess.UpdateAmount(value, nonObligatedValue.Tonnage);
}
return(true);
}
public async Task <bool> HandleAsync(EditObligatedReceived message)
{
authorization.EnsureCanAccessExternalArea();
foreach (var obligatedValue in message.CategoryValues)
{
var value = await genericDataAccess.GetById <WeeeReceivedAmount>(obligatedValue.Id);
await obligatedReceivedDataAccess.UpdateAmounts(value, obligatedValue.HouseholdTonnage, obligatedValue.NonHouseholdTonnage);
}
return(true);
}
public async Task <SchemeDataList> HandleAsync(GetReturnScheme message)
{
authorization.EnsureCanAccessExternalArea();
var schemeListData = new List <SchemeData>();
var returnSchemeList = await returnSchemeDataAccess.GetSelectedSchemesByReturnId(message.ReturnId);
var schemeDataList = returnSchemeList.Select(s => mapper.Map <Scheme, SchemeData>(s.Scheme)).OrderBy(sd => sd.SchemeName).ToList();
var organisation = await returnSchemeDataAccess.GetOrganisationByReturnId(message.ReturnId);
return(new SchemeDataList(schemeDataList, mapper.Map <Organisation, OrganisationData>(organisation)));
}
public async Task <AddressTonnageSummary> HandleAsync(GetAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var addressData = await getAatfSiteDataAccess.GetAddresses(message.AatfId, message.ReturnId);
var returnObligatedReusedValues = await getAatfSiteDataAccess.GetObligatedWeeeForReturnAndAatf(message.AatfId, message.ReturnId);
var aatfAddressObligatedAmount = new AatfAddressObligatedAmount(addressData, returnObligatedReusedValues);
var result = mapper.Map(aatfAddressObligatedAmount);
return(result);
}
public async Task <bool> HandleAsync(AddNonObligated message)
{
authorization.EnsureCanAccessExternalArea();
var aatfReturn = await returnDataAccess.GetById(message.ReturnId);
var nonObligatedWee = new List <NonObligatedWeee>();
foreach (var categoryValue in message.CategoryValues)
{
nonObligatedWee.Add(new NonObligatedWeee(aatfReturn, categoryValue.CategoryId, message.Dcf, categoryValue.Tonnage));
}
await nonObligatedDataAccess.Submit(nonObligatedWee);
return(true);
}
public async Task <bool> HandleAsync(RemoveAatfSite message)
{
authorization.EnsureCanAccessExternalArea();
var site = await genericDataAccess.GetById <AatfAddress>(message.SiteId);
var weeeReusedSiteId = (await genericDataAccess.GetSingleByExpression <WeeeReusedSite>(new WeeeReusedByAddressIdSpecification(message.SiteId))).Id;
var weeeReusedSite = await genericDataAccess.GetById <WeeeReusedSite>(weeeReusedSiteId);
genericDataAccess.Remove(weeeReusedSite);
genericDataAccess.Remove(site);
await context.SaveChangesAsync();
return(true);
}
public async Task <List <Guid> > HandleAsync(AddReturnScheme message)
{
authorization.EnsureCanAccessExternalArea();
var @return = await returnDataAccess.GetById(message.ReturnId);
var returnSchemes = new List <ReturnScheme>();
foreach (var schemeId in message.SchemeIds)
{
var scheme = await schemeDataAccess.GetSchemeOrDefault(schemeId);
returnSchemes.Add(new ReturnScheme(scheme, @return));
}
return(await returnSchemeDataAccess.Submit(returnSchemes));
}
public async Task <bool> HandleAsync(AddObligatedSentOn message)
{
authorization.EnsureCanAccessExternalArea();
var weeeSent = await genericDataAccess.GetById <WeeeSentOn>(message.WeeeSentOnId);
var aatfWeeeSentOnAmount = new List <WeeeSentOnAmount>();
foreach (var categoryValue in message.CategoryValues)
{
aatfWeeeSentOnAmount.Add(new WeeeSentOnAmount(weeeSent, categoryValue.CategoryId, categoryValue.HouseholdTonnage, categoryValue.NonHouseholdTonnage));
}
await obligatedSentOnDataAccess.Submit(aatfWeeeSentOnAmount);
return(true);
}
public async Task <ReturnsData> HandleAsync(GetReturns message)
{
authorization.EnsureCanAccessExternalArea();
var currentDate = SystemTime.UtcNow;
var systemSettings = await systemDataDataAccess.Get();
if (systemSettings.UseFixedCurrentDate)
{
currentDate = systemSettings.FixedCurrentDate;
}
var @returns = await returnDataAccess.GetByOrganisationId(message.OrganisationId);
var quarter = await returnFactory.GetReturnQuarter(message.OrganisationId, message.Facility);
var openQuarters = await quarterWindowFactory.GetQuarterWindowsForDate(currentDate);
var returnsData = new List <ReturnData>();
foreach (var @return in @returns.Where(p => p.FacilityType.Value == (int)message.Facility))
{
returnsData.Add(await getPopulatedReturn.GetReturnData(@return.Id, false));
}
var returnOpenQuarters = new List <Core.DataReturns.Quarter>();
foreach (var q in openQuarters)
{
returnOpenQuarters.Add(new Core.DataReturns.Quarter(q.StartDate.Year, (Core.DataReturns.QuarterType)q.QuarterType));
}
Core.AatfReturn.QuarterWindow nextQuarter = null;
if (openQuarters.Count > 0)
{
var latestOpenQuarter = openQuarters.OrderByDescending(p => p.QuarterType).FirstOrDefault();
var nextWindow = await quarterWindowFactory.GetNextQuarterWindow(latestOpenQuarter.QuarterType, latestOpenQuarter.StartDate.Year);
nextQuarter = new Core.AatfReturn.QuarterWindow(nextWindow.StartDate, nextWindow.EndDate, (QuarterType)nextWindow.QuarterType);
}
return(new ReturnsData(returnsData, quarter, returnOpenQuarters, nextQuarter, currentDate));
}
public async Task <Guid> HandleAsync(CreatePartnershipRequest message)
{
authorization.EnsureCanAccessExternalArea();
var organisation = Organisation.CreatePartnership(message.TradingName);
db.Organisations.Add(organisation);
await db.SaveChangesAsync();
var organisationUser = new OrganisationUser(userContext.UserId, organisation.Id, UserStatus.Active);
db.OrganisationUsers.Add(organisationUser);
await db.SaveChangesAsync();
return(organisation.Id);
}
public async Task <Guid> HandleAsync(CreateRegisteredCompanyRequest message)
{
authorization.EnsureCanAccessExternalArea();
var organisation = Organisation.CreateRegisteredCompany(message.BusinessName,
message.CompanyRegistrationNumber, message.TradingName);
db.Organisations.Add(organisation);
await db.SaveChangesAsync();
var organisationUser = new OrganisationUser(userContext.UserId, organisation.Id, UserStatus.Active);
db.OrganisationUsers.Add(organisationUser);
await db.SaveChangesAsync();
return(organisation.Id);
}
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);
}
