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 HandleAsync_GivenRequest_DataAccessShouldBeCalled()
{
await handler.HandleAsync(new GetReportOnQuestion());
A.CallTo(() => dataAccess.GetAll <ReportOnQuestion>()).MustHaveHappened(Repeated.Exactly.Once);
}
public async Task <PreviousQuarterReturnResult> HandleAsync(GetPreviousQuarterSchemes message)
{
authorization.EnsureCanAccessExternalArea();
IEnumerable <Return> allReturns = await dataAccess.GetAll <Return>();
var currentReturn = allReturns.First(r => r.Id == message.ReturnId);
if (allReturns.Any(r => r.Quarter == currentReturn.Quarter &&
r.Id != currentReturn.Id &&
r.Organisation.Id == currentReturn.Organisation.Id &&
r.FacilityType.Value == currentReturn.FacilityType.Value))
{
return(new PreviousQuarterReturnResult());
}
// Filter the returns by the organisationId. Also ignore the return we are creating. Finally make sure they are submitted.
// Then order them by the Quarter descending so that we can get the latest returns
allReturns = allReturns.Where(p => p.Organisation.Id == message.OrganisationId &&
p.Id != message.ReturnId &&
p.ReturnStatus == Domain.AatfReturn.ReturnStatus.Submitted &&
p.FacilityType.Value == currentReturn.FacilityType.Value &&
p.Quarter.Year <= currentReturn.Quarter.Year)
.OrderByDescending(p => p.Quarter.Year)
.ThenByDescending(p => (int)p.Quarter.Q)
.ThenByDescending(p => p.SubmittedDate).ToList();
// This is their first return
if (!allReturns.Any())
{
return(new PreviousQuarterReturnResult());
}
// Find the last quarter submitted
Quarter lastQ = allReturns.FirstOrDefault().Quarter;
// Grab the last submitted return
Return lastReturn = allReturns.FirstOrDefault(p => p.Quarter == lastQ);
if (lastReturn == null)
{
return(new PreviousQuarterReturnResult());
}
IEnumerable <ReturnScheme> returnSchemes = await dataAccess.GetAll <ReturnScheme>();
if (returnSchemes == null)
{
return(new PreviousQuarterReturnResult());
}
List <ReturnScheme> lastSchemes = new List <ReturnScheme>();
lastSchemes.AddRange(returnSchemes.Where(p => p.ReturnId == lastReturn.Id));
PreviousQuarterReturnResult result = new PreviousQuarterReturnResult()
{
PreviousQuarter = new Core.DataReturns.Quarter(lastQ.Year, (Core.DataReturns.QuarterType)lastQ.Q),
PreviousSchemes = lastSchemes.Select(p => p.SchemeId).ToList()
};
return(result);
}
public async Task HandleAsync_ProvideOrganisationIdWithPreviousReturns_ReturnsPreviousSchemesForThatOrganisation()
{
Organisation requestedOrganisation = fixture.Build <Organisation>().With(o => o.OrganisationStatus, OrganisationStatus.Complete).Create();
Organisation otherOrganisation = fixture.Build <Organisation>().With(o => o.OrganisationStatus, OrganisationStatus.Complete).Create();
Quarter q1 = new Quarter(2019, QuarterType.Q1);
Quarter q2 = new Quarter(2019, QuarterType.Q2);
Quarter q3 = new Quarter(2019, QuarterType.Q3);
Quarter q4 = new Quarter(2019, QuarterType.Q4);
Return previousReturn = A.Fake <Return>();
A.CallTo(() => previousReturn.Id).Returns(Guid.NewGuid());
A.CallTo(() => previousReturn.Quarter).Returns(q3);
A.CallTo(() => previousReturn.Organisation).Returns(requestedOrganisation);
A.CallTo(() => previousReturn.ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Submitted);
Return currentReturn = A.Fake <Return>();
A.CallTo(() => currentReturn.Id).Returns(Guid.NewGuid());
A.CallTo(() => currentReturn.Quarter).Returns(q4);
A.CallTo(() => currentReturn.Organisation).Returns(requestedOrganisation);
A.CallTo(() => currentReturn.ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Submitted);
List <Return> returns = new List <Return>()
{
A.Fake <Return>(),
A.Fake <Return>(),
A.Fake <Return>(),
A.Fake <Return>()
};
A.CallTo(() => returns.ElementAt(0).Id).Returns(Guid.NewGuid());
A.CallTo(() => returns.ElementAt(0).Quarter).Returns(q2);
A.CallTo(() => returns.ElementAt(0).Organisation).Returns(requestedOrganisation);
A.CallTo(() => returns.ElementAt(0).ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Submitted);
A.CallTo(() => returns.ElementAt(1).Id).Returns(Guid.NewGuid());
A.CallTo(() => returns.ElementAt(1).Quarter).Returns(q1);
A.CallTo(() => returns.ElementAt(1).Organisation).Returns(requestedOrganisation);
A.CallTo(() => returns.ElementAt(1).ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Submitted);
A.CallTo(() => returns.ElementAt(2).Id).Returns(Guid.NewGuid());
A.CallTo(() => returns.ElementAt(2).Quarter).Returns(q1);
A.CallTo(() => returns.ElementAt(2).Organisation).Returns(otherOrganisation);
A.CallTo(() => returns.ElementAt(2).ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Submitted);
A.CallTo(() => returns.ElementAt(3).Id).Returns(Guid.NewGuid());
A.CallTo(() => returns.ElementAt(3).Quarter).Returns(q2);
A.CallTo(() => returns.ElementAt(3).Organisation).Returns(otherOrganisation);
A.CallTo(() => returns.ElementAt(3).ReturnStatus).Returns(Domain.AatfReturn.ReturnStatus.Submitted);
returns.Add(previousReturn);
returns.Add(currentReturn);
A.CallTo(() => dataAccess.GetAll <Return>()).Returns(returns);
List <ReturnScheme> returnSchemes = new List <ReturnScheme>()
{
A.Fake <ReturnScheme>(),
A.Fake <ReturnScheme>(),
A.Fake <ReturnScheme>()
};
A.CallTo(() => returnSchemes.ElementAt(0).SchemeId).Returns(Guid.NewGuid());
A.CallTo(() => returnSchemes.ElementAt(0).Id).Returns(Guid.NewGuid());
A.CallTo(() => returnSchemes.ElementAt(0).ReturnId).Returns(previousReturn.Id);
A.CallTo(() => returnSchemes.ElementAt(1).SchemeId).Returns(Guid.NewGuid());
A.CallTo(() => returnSchemes.ElementAt(1).Id).Returns(Guid.NewGuid());
A.CallTo(() => returnSchemes.ElementAt(1).ReturnId).Returns(previousReturn.Id);
A.CallTo(() => returnSchemes.ElementAt(2).SchemeId).Returns(Guid.NewGuid());
A.CallTo(() => returnSchemes.ElementAt(2).Id).Returns(Guid.NewGuid());
A.CallTo(() => returnSchemes.ElementAt(2).ReturnId).Returns(returns.FirstOrDefault(p => p.Organisation.Id == otherOrganisation.Id).Id);
A.CallTo(() => dataAccess.GetAll <ReturnScheme>()).Returns(returnSchemes);
GetPreviousQuarterSchemes request = new GetPreviousQuarterSchemes(requestedOrganisation.Id, currentReturn.Id);
PreviousQuarterReturnResult result = await handler.HandleAsync(request);
Assert.Equal(2, result.PreviousSchemes.Count);
result.PreviousQuarter.Should().Be(new Core.DataReturns.Quarter(q3.Year, (Core.DataReturns.QuarterType)q3.Q));
result.PreviousSchemes.Should().Contain(returnSchemes.Where(p => p.ReturnId == previousReturn.Id).Select(p => p.SchemeId));
A.CallTo(() => dataAccess.GetAll <Return>()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => dataAccess.GetAll <ReturnScheme>()).MustHaveHappened(Repeated.Exactly.Once);
}
