public async Task GetReturnData_GivenReturn_QuarterWindowShouldBeRetrieved()
{
var @return = new Return(A.Fake <Organisation>(), A.Fake <Quarter>(), "id", A.Fake <FacilityType>());
A.CallTo(() => returnDataAccess.GetById(A <Guid> ._)).Returns(@return);
var result = await populatedReturn.GetReturnData(A.Dummy <Guid>(), A.Dummy <bool>());
A.CallTo(() => quarterWindowFactory.GetQuarterWindow(@return.Quarter)).MustHaveHappened(Repeated.Exactly.Once);
}
private async Task ActionAndAssertApprovalDate(Action <Guid> assertion, DateTime?approvalDate, DateTime windowStartDate)
{
using (database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var userContext = A.Fake <IUserContext>();
A.CallTo(() => userContext.UserId).Returns(Guid.Parse(database.Model.AspNetUsers.First().Id));
A.CallTo(() => quarterWindowFactory.GetQuarterWindow(A <Quarter> ._))
.Returns(new Domain.DataReturns.QuarterWindow(windowStartDate, windowStartDate.AddDays(1), QuarterType.Q1));
await CreateReturnToCopy(approvalDate);
var message = new CopyReturn(@return.Id);
var authorization = new AuthorizationBuilder().AllowEverything().Build();
handler = new CopyReturnHandler(authorization,
database.WeeeContext,
userContext,
quarterWindowFactory);
var result = await handler.HandleAsync(message);
@return = database.WeeeContext.Returns.AsNoTracking().First(r => r.Id == message.ReturnId);
copiedReturn = database.WeeeContext.Returns.First(r => r.Id == result);
assertion(result);
}
}
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 <Aatf> > FetchAatfByReturnQuarterWindow(Return @return)
{
var quarterWindow = await quarterWindowFactory.GetQuarterWindow(@return.Quarter);
return(await context.Aatfs.Where(a => a.Organisation.Id == @return.Organisation.Id &&
a.FacilityType.Value == @return.FacilityType.Value &&
a.ComplianceYear == @return.Quarter.Year &&
a.ApprovalDate.HasValue &&
a.ApprovalDate.Value < quarterWindow.StartDate.Date).Select(a => a).OrderBy(a => a.Name).ToListAsync());
}
public async Task FetchAatfByReturnQuarterWindow_GivenMatchingParameters_ReturnedListContainsAatf()
{
using (var database = new DatabaseWrapper())
{
var helper = new ModelHelper(database.Model);
var domainHelper = new DomainHelper(database.WeeeContext);
var dataAccess = new FetchAatfDataAccess(database.WeeeContext, quarterWindowFactory);
var genericDataAccess = new GenericDataAccess(database.WeeeContext);
var aatf = await CreateAatf(database, FacilityType.Aatf, DateTime.Now, 2019);
var @return = new Return(aatf.Organisation, new Quarter(2019, QuarterType.Q1), "created", FacilityType.Aatf);
A.CallTo(() => quarterWindowFactory.GetQuarterWindow(@return.Quarter)).Returns(new QuarterWindow(DateTime.Now.AddDays(1), DateTime.Now.AddDays(1), QuarterType.Q1));
await genericDataAccess.AddMany <Aatf>(new List <Aatf>() { aatf });
var aatfList = await dataAccess.FetchAatfByReturnQuarterWindow(@return);
aatfList.Should().Contain(aatf);
}
}
private async Task RemoveAatfsWithInvalidApprovalDate(Return returnCopy)
{
var quarterWindow = await quarterWindowFactory.GetQuarterWindow(returnCopy.Quarter);
var sentOnToRemove = context.WeeeSentOn.Where(Predicate <WeeeSentOn>(quarterWindow, returnCopy))
.Include(w => w.WeeeSentOnAmounts).ToList();
context.WeeeSentOnAmount.RemoveRange(sentOnToRemove.SelectMany(r => r.WeeeSentOnAmounts));
context.WeeeSentOn.RemoveRange(sentOnToRemove);
var reusedToRemove = context.WeeeReused.Where(Predicate <WeeeReused>(quarterWindow, returnCopy))
.Include(w => w.WeeeReusedAmounts)
.Include(w => w.WeeeReusedSites).ToList();
context.WeeeReusedAmount.RemoveRange(reusedToRemove.SelectMany(r => r.WeeeReusedAmounts));
context.WeeeReusedSite.RemoveRange(reusedToRemove.SelectMany(r => r.WeeeReusedSites));
context.WeeeReused.RemoveRange(reusedToRemove);
var receivedToRemove = context.WeeeReceived.Where(Predicate <WeeeReceived>(quarterWindow, returnCopy))
.Include(w => w.WeeeReceivedAmounts).ToList();
context.WeeeReceivedAmount.RemoveRange(receivedToRemove.SelectMany(r => r.WeeeReceivedAmounts));
context.WeeeReceived.RemoveRange(receivedToRemove);
}
public async Task <IEnumerable <ErrorData> > Validate(Quarter quarter)
{
var result = new List <ErrorData>();
var currentDate = SystemTime.Now;
var systemSettings = await systemDataDataAccess.Get();
if (systemSettings.UseFixedCurrentDate)
{
currentDate = systemSettings.FixedCurrentDate;
}
var quarterWindow = await quarterWindowFactory.GetQuarterWindow(quarter);
if (quarterWindow.IsBeforeWindow(currentDate))
{
var errorMessage = string.Format(
"The submission window for {0} {1} has not yet opened. The submission window will open on the {2}, resubmit your return XML file on or after this date.",
quarter.Q, quarter.Year, quarterWindow.StartDate.ToString("dd MMM yyyy"));
result.Add(new ErrorData(errorMessage, ErrorLevel.Error));
return(result);
}
if (quarterWindow.IsAfterWindow(currentDate))
{
var errorMessage = string.Format(
"The window for resubmitting data returns for the {0} compliance period has closed.",
quarter.Year);
result.Add(new ErrorData(errorMessage, ErrorLevel.Error));
return(result);
}
return(result);
}
public CopyReturnHandlerTests()
{
quarterWindowFactory = A.Fake <IQuarterWindowFactory>();
A.CallTo(() => quarterWindowFactory.GetQuarterWindow(A <Quarter> ._)).Returns(new EA.Weee.Domain.DataReturns.QuarterWindow(DateTime.MaxValue, DateTime.MinValue, QuarterType.Q1));
}
