public async Task HandleAsync_GivenOrganisation_ReturnQuarterShouldBeRetrieved(Core.AatfReturn.FacilityType facilityType)
{
var message = new GetReturns(Guid.NewGuid(), facilityType);
var result = await handler.HandleAsync(message);
A.CallTo(() => returnFactory.GetReturnQuarter(message.OrganisationId, message.Facility)).MustHaveHappenedOnceExactly();
}
public async Task HandleAsync_GivenAddReturnRequest_DataAccessSubmitsIsCalled(QuarterType quarterType, FacilityType facility)
{
var request = new AddReturn {
OrganisationId = Guid.NewGuid(), Quarter = quarterType, Year = year, FacilityType = Core.AatfReturn.FacilityType.Aatf
};
var @return = A.Dummy <Return>();
var organisation = new Organisation();
var userId = Guid.NewGuid();
A.CallTo(() => userContext.UserId).Returns(userId);
A.CallTo(() => genericDataAccess.GetById <Organisation>(request.OrganisationId)).Returns(organisation);
A.CallTo(() => returnFactory.GetReturnQuarter(A <Guid> ._, A <FacilityType> ._)).Returns(new Quarter(year, quarterType));
await handler.HandleAsync(request);
A.CallTo(() => returnDataAccess.Submit(A <Return> .That.Matches(c => c.Quarter.Year == request.Year && (int)c.Quarter.Q == (int)quarterType && c.Organisation.Equals(organisation) && c.CreatedById.Equals(userId.ToString())))).MustHaveHappened(Repeated.Exactly.Once);
}
private async Task ValidateReturnMessage(AddReturn message)
{
var existingReturn =
await returnFactoryDataAccess.HasReturnQuarter(message.OrganisationId, message.Year, (QuarterType)message.Quarter, message.FacilityType);
var returnWindow = await returnFactory.GetReturnQuarter(message.OrganisationId, message.FacilityType);
if (existingReturn || returnWindow.Q != message.Quarter || returnWindow.Year != message.Year)
{
throw new InvalidOperationException("Return already exists");
}
}
public AddReturnUploadHandlerTests()
{
var weeeAuthorization = A.Fake <IWeeeAuthorization>();
returnDataAccess = A.Fake <IReturnDataAccess>();
genericDataAccess = A.Fake <IGenericDataAccess>();
userContext = A.Fake <IUserContext>();
returnFactoryDataAccess = A.Fake <IReturnFactoryDataAccess>();
returnFactory = A.Fake <IReturnFactory>();
A.CallTo(() => returnFactoryDataAccess.HasReturnQuarter(A <Guid> ._, A <int> ._, A <EA.Weee.Domain.DataReturns.QuarterType> ._, A <FacilityType> ._)).Returns(false);
A.CallTo(() => returnFactory.GetReturnQuarter(A <Guid> ._, A <FacilityType> ._)).Returns(new Quarter(year, quarter));
handler = new AddReturnHandler(weeeAuthorization, returnDataAccess, genericDataAccess, userContext, returnFactoryDataAccess, returnFactory);
}
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));
}
