public async Task TestMainOccupancyReportGeneration(string ilrFilename, string validLearnRefNumbersFilename, string albFilename, string fm25Filename, string fm35Filename)
{
string csv = string.Empty;
DateTime dateTime = DateTime.UtcNow;
string filename = $"10033670_1_Main Occupancy Report {dateTime:yyyyMMdd-HHmmss}";
Mock <IReportServiceContext> reportServiceContextMock = new Mock <IReportServiceContext>();
reportServiceContextMock.SetupGet(x => x.JobId).Returns(1);
reportServiceContextMock.SetupGet(x => x.SubmissionDateTimeUtc).Returns(DateTime.UtcNow);
reportServiceContextMock.SetupGet(x => x.Ukprn).Returns(10033670);
reportServiceContextMock.SetupGet(x => x.Filename).Returns(ilrFilename);
reportServiceContextMock.SetupGet(x => x.FundingFM25OutputKey).Returns("FundingFm25Output");
reportServiceContextMock.SetupGet(x => x.FundingFM35OutputKey).Returns("FundingFm35Output");
reportServiceContextMock.SetupGet(x => x.ValidLearnRefNumbersKey).Returns("ValidLearnRefNumbers");
reportServiceContextMock.SetupGet(x => x.CollectionName).Returns("ILR1819");
DataStoreConfiguration dataStoreConfiguration = new DataStoreConfiguration()
{
ILRDataStoreConnectionString = new TestConfigurationHelper().GetSectionValues <DataStoreConfiguration>("DataStoreSection").ILRDataStoreConnectionString,
ILRDataStoreValidConnectionString = new TestConfigurationHelper().GetSectionValues <DataStoreConfiguration>("DataStoreSection").ILRDataStoreValidConnectionString
};
IIlr1819ValidContext IlrValidContextFactory()
{
var options = new DbContextOptionsBuilder <ILR1819_DataStoreEntitiesValid>().UseSqlServer(dataStoreConfiguration.ILRDataStoreValidConnectionString).Options;
return(new ILR1819_DataStoreEntitiesValid(options));
}
IIlr1819RulebaseContext IlrRulebaseContextFactory()
{
var options = new DbContextOptionsBuilder <ILR1819_DataStoreEntities>().UseSqlServer(dataStoreConfiguration.ILRDataStoreConnectionString).Options;
return(new ILR1819_DataStoreEntities(options));
}
Mock <ILogger> logger = new Mock <ILogger>();
Mock <IDateTimeProvider> dateTimeProviderMock = new Mock <IDateTimeProvider>();
Mock <IStreamableKeyValuePersistenceService> storage = new Mock <IStreamableKeyValuePersistenceService>();
Mock <IStreamableKeyValuePersistenceService> redis = new Mock <IStreamableKeyValuePersistenceService>();
IIntUtilitiesService intUtilitiesService = new IntUtilitiesService();
IJsonSerializationService jsonSerializationService = new JsonSerializationService();
IXmlSerializationService xmlSerializationService = new XmlSerializationService();
IFM35ProviderService fm35ProviderService = new FM35ProviderService(logger.Object, redis.Object, jsonSerializationService, intUtilitiesService, IlrValidContextFactory, IlrRulebaseContextFactory);
IFM25ProviderService fm25ProviderService = new FM25ProviderService(logger.Object, storage.Object, jsonSerializationService, intUtilitiesService, IlrRulebaseContextFactory);
IIlrProviderService ilrProviderService = new IlrProviderService(logger.Object, storage.Object, xmlSerializationService, dateTimeProviderMock.Object, intUtilitiesService, IlrValidContextFactory, IlrRulebaseContextFactory);
IValidLearnersService validLearnersService = new ValidLearnersService(logger.Object, redis.Object, jsonSerializationService, dataStoreConfiguration);
Mock <ILarsProviderService> larsProviderService = new Mock <ILarsProviderService>();
IStringUtilitiesService stringUtilitiesService = new StringUtilitiesService();
ITopicAndTaskSectionOptions topicsAndTasks = TestConfigurationHelper.GetTopicsAndTasks();
IMainOccupancyReportModelBuilder reportModelBuilder = new MainOccupancyReportModelBuilder();
IValueProvider valueProvider = new ValueProvider();
var validLearnersStr = File.ReadAllText(validLearnRefNumbersFilename);
storage.Setup(x => x.GetAsync(It.IsAny <string>(), It.IsAny <Stream>(), It.IsAny <CancellationToken>()))
.Callback <string, Stream, CancellationToken>((st, sr, ct) => File.OpenRead(ilrFilename).CopyTo(sr))
.Returns(Task.CompletedTask);
storage.Setup(x => x.SaveAsync($"{filename}.csv", It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Callback <string, string, CancellationToken>((key, value, ct) => csv = value)
.Returns(Task.CompletedTask);
storage.Setup(x => x.ContainsAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
redis.Setup(x => x.ContainsAsync("FundingFm35Output", It.IsAny <CancellationToken>())).ReturnsAsync(true);
redis.Setup(x => x.GetAsync("FundingFm35Output", It.IsAny <Stream>(), It.IsAny <CancellationToken>())).Callback <string, Stream, CancellationToken>((st, sr, ct) => File.OpenRead(fm35Filename).CopyTo(sr)).Returns(Task.CompletedTask);
storage.Setup(x => x.ContainsAsync("FundingFm25Output", It.IsAny <CancellationToken>())).ReturnsAsync(true);
redis.Setup(x => x.GetAsync("FundingFm25Output", It.IsAny <CancellationToken>()))
.ReturnsAsync(File.ReadAllText(fm25Filename));
storage.Setup(x => x.ContainsAsync("ValidLearnRefNumbers", It.IsAny <CancellationToken>())).ReturnsAsync(true);
redis.Setup(x => x.ContainsAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
redis.Setup(x => x.GetAsync("ValidLearnRefNumbers", It.IsAny <CancellationToken>())).ReturnsAsync(validLearnersStr);
IMessage message = await ilrProviderService.GetIlrFile(reportServiceContextMock.Object, CancellationToken.None);
List <string> validLearners = jsonSerializationService.Deserialize <List <string> >(validLearnersStr);
Dictionary <string, LarsLearningDelivery> learningDeliveriesDict =
new Dictionary <string, LarsLearningDelivery>();
List <LearnerAndDeliveries> learnerAndDeliveries = new List <LearnerAndDeliveries>();
foreach (ILearner messageLearner in message.Learners)
{
if (validLearners.Contains(messageLearner.LearnRefNumber))
{
List <LearningDelivery> learningDeliveries = new List <LearningDelivery>();
foreach (ILearningDelivery learningDelivery in messageLearner.LearningDeliveries)
{
var learningDeliveryRes = new LearningDelivery(
learningDelivery.LearnAimRef,
learningDelivery.AimSeqNumber,
learningDelivery.FworkCodeNullable,
learningDelivery.ProgTypeNullable,
learningDelivery.PwayCodeNullable,
learningDelivery.LearnStartDate);
learningDeliveryRes.FrameworkComponentType = 1;
learningDeliveries.Add(learningDeliveryRes);
learningDeliveriesDict[learningDelivery.LearnAimRef] = new LarsLearningDelivery()
{
LearningAimTitle = "A",
NotionalNvqLevel = "B",
Tier2SectorSubjectArea = 3
};
}
learnerAndDeliveries.Add(
new LearnerAndDeliveries(messageLearner.LearnRefNumber, learningDeliveries));
}
}
larsProviderService
.Setup(x => x.GetLearningDeliveriesAsync(It.IsAny <string[]>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(learningDeliveriesDict);
larsProviderService
.Setup(x => x.GetFrameworkAimsAsync(It.IsAny <string[]>(), It.IsAny <List <ILearner> >(), It.IsAny <CancellationToken>())).ReturnsAsync(learnerAndDeliveries);
dateTimeProviderMock.Setup(x => x.GetNowUtc()).Returns(dateTime);
dateTimeProviderMock.Setup(x => x.ConvertUtcToUk(It.IsAny <DateTime>())).Returns(dateTime);
var mainOccupancyReport = new MainOccupancyReport(
logger.Object,
storage.Object,
ilrProviderService,
stringUtilitiesService,
validLearnersService,
fm25ProviderService,
fm35ProviderService,
larsProviderService.Object,
dateTimeProviderMock.Object,
valueProvider,
topicsAndTasks,
reportModelBuilder);
await mainOccupancyReport.GenerateReport(reportServiceContextMock.Object, null, false, CancellationToken.None);
csv.Should().NotBeNullOrEmpty();
#if DEBUG
File.WriteAllText($"{filename}.csv", csv);
#endif
TestCsvHelper.CheckCsv(csv, new CsvEntry(new MainOccupancyMapper(), 1));
}
public async Task GenerateReport(IReportServiceContext reportServiceContext, ZipArchive archive, bool isFis, CancellationToken cancellationToken)
{
Task <IMessage> ilrFileTask = _ilrProviderService.GetIlrFile(reportServiceContext, cancellationToken);
Task <FM25Global> fm25Task = _fm25ProviderService.GetFM25Data(reportServiceContext, cancellationToken);
Task <FM35Global> fm35Task = _fm35ProviderService.GetFM35Data(reportServiceContext, cancellationToken);
Task <List <string> > validLearnersTask = _validLearnersService.GetLearnersAsync(reportServiceContext, cancellationToken);
await Task.WhenAll(ilrFileTask, fm25Task, fm35Task, validLearnersTask);
if (cancellationToken.IsCancellationRequested)
{
return;
}
List <ILearner> learners =
ilrFileTask.Result?.Learners?.Where(x => validLearnersTask.Result.Contains(x.LearnRefNumber)).ToList();
if (learners == null)
{
_logger.LogWarning("Failed to get learners for Main Occupancy Report");
return;
}
string[] learnAimRefs = learners.SelectMany(x => x.LearningDeliveries).Select(x => x.LearnAimRef).Distinct().ToArray();
Task <Dictionary <string, LarsLearningDelivery> > larsLearningDeliveriesTask = _larsProviderService.GetLearningDeliveriesAsync(learnAimRefs, cancellationToken);
Task <List <LearnerAndDeliveries> > larsFrameworkAimsTask = _larsProviderService.GetFrameworkAimsAsync(learnAimRefs, learners, cancellationToken);
await Task.WhenAll(larsLearningDeliveriesTask, larsFrameworkAimsTask);
if (larsLearningDeliveriesTask.Result == null || larsFrameworkAimsTask.Result == null)
{
_logger.LogWarning("Failed to get LARS data for Main Occupancy Report");
return;
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
List <string> larsErrors = new List <string>();
List <MainOccupancyModel> mainOccupancyModels = new List <MainOccupancyModel>();
foreach (var learner in learners)
{
if (learner.LearningDeliveries == null)
{
continue;
}
FM25Global fm25Data = fm25Task.Result;
FM35Global fm35Data = fm35Task.Result;
foreach (ILearningDelivery learningDelivery in learner.LearningDeliveries)
{
if (!CheckIsApplicableLearner(learningDelivery))
{
continue;
}
if (!larsLearningDeliveriesTask.Result.TryGetValue(learningDelivery.LearnAimRef, out LarsLearningDelivery larsModel))
{
larsErrors.Add(learningDelivery.LearnAimRef);
continue;
}
LearningDelivery frameworkAim = larsFrameworkAimsTask.Result?.SingleOrDefault(x => string.Equals(x.LearnerLearnRefNumber, learner.LearnRefNumber, StringComparison.OrdinalIgnoreCase))
?.LearningDeliveries?.SingleOrDefault(x => string.Equals(x.LearningDeliveryLearnAimRef, learningDelivery.LearnAimRef, StringComparison.OrdinalIgnoreCase) &&
x.LearningDeliveryAimSeqNumber == learningDelivery.AimSeqNumber);
if (frameworkAim == null)
{
larsErrors.Add(learningDelivery.LearnAimRef);
continue;
}
if (learningDelivery.FundModel == 35)
{
ILR.FundingService.FM35.FundingOutput.Model.Output.LearningDelivery learnerFm35Data = fm35Data
?.Learners?.SingleOrDefault(l => string.Equals(l.LearnRefNumber, learner.LearnRefNumber, StringComparison.OrdinalIgnoreCase))
?.LearningDeliveries?.SingleOrDefault(l => l.AimSeqNumber == learningDelivery.AimSeqNumber);
if (learnerFm35Data != null)
{
mainOccupancyModels.Add(_mainOccupancyReportModelBuilder.BuildFm35Model(
learner,
learningDelivery,
larsModel,
frameworkAim,
learnerFm35Data,
_stringUtilitiesService));
}
}
if (learningDelivery.FundModel != 25)
{
continue;
}
FM25Learner learnerFm25Data =
fm25Data?.Learners?.SingleOrDefault(l => string.Equals(l.LearnRefNumber, learner.LearnRefNumber, StringComparison.OrdinalIgnoreCase));
mainOccupancyModels.Add(_mainOccupancyReportModelBuilder.BuildFm25Model(
learner,
learningDelivery,
learnerFm25Data));
}
}
LogWarnings(larsErrors);
mainOccupancyModels.Sort(MainOccupancyModelComparer);
string csv = GetReportCsv(mainOccupancyModels);
var jobId = reportServiceContext.JobId;
var ukPrn = reportServiceContext.Ukprn.ToString();
var externalFileName = GetExternalFilename(ukPrn, jobId, reportServiceContext.SubmissionDateTimeUtc);
var fileName = GetFilename(ukPrn, jobId, reportServiceContext.SubmissionDateTimeUtc);
await _streamableKeyValuePersistenceService.SaveAsync($"{externalFileName}.csv", csv, cancellationToken);
await WriteZipEntry(archive, $"{fileName}.csv", csv);
}
