public async System.Threading.Tasks.Task GetProjectedVacanciesTestAsync(Scenario scenario, int expectedNumberDisplayed)
{
var fakeIAVService = A.Fake <IAVService>();
var getVacanciesDetailsFunction = new GetVacanciesDetailsFunction(fakeIAVService);
var dummyProjectedVacancySummary = new ProjectedVacancySummary
{
SocCode = "SOC123",
AccessToken = "Access123",
SocMappingId = Guid.NewGuid(),
Vacancies = GetDummyVacanciesSummary()
};
A.CallTo(() => fakeIAVService.GetApprenticeshipVacancyDetailsAsync(A <string> ._)).Returns(GetDummyVacanciesDetails(A <string> ._));
//Check for calling GetOutput before Execute
Action test = () => { getVacanciesDetailsFunction.GetOutput(); };
test.Should().Throw <InvalidOperationException>();
await getVacanciesDetailsFunction.ExecuteAsync(dummyProjectedVacancySummary);
var projectedVacancyDetails = getVacanciesDetailsFunction.GetOutput();
projectedVacancyDetails.SocCode.Should().Be(dummyProjectedVacancySummary.SocCode);
projectedVacancyDetails.SocMappingId.Should().Be(dummyProjectedVacancySummary.SocMappingId);
projectedVacancyDetails.AccessToken.Should().Be(dummyProjectedVacancySummary.AccessToken);
projectedVacancyDetails.Vacancies.Count().Should().Be(2);
}
/// <summary>
/// Runs the specified my queue item.
/// </summary>
/// <param name="myQueueItem">My queue item.</param>
/// <param name="mode">The mode.</param>
public static async Task <ProjectedVacancyDetails> RunAsync(ProjectedVacancySummary myQueueItem, RunMode mode, IAsyncCollector <AuditRecord <object, object> > asyncCollector, AuditRecord <object, object> masterRecord)
{
var container = ConfigureContainer(mode, asyncCollector, masterRecord);
var getDetailsFunc = container.Resolve <IGetAvDetailsByIdsFunc>();
await getDetailsFunc.ExecuteAsync(myQueueItem);
return(getDetailsFunc.GetOutput());
}
private static void CheckResultIsAsExpected(string SocCode, ProjectedVacancySummary projectedVacancies, int expectedCount)
{
projectedVacancies.SocCode.Should().Be(SocCode);
var numberOfProjectedVacanices = 0;
if (expectedCount > 0)
{
foreach (ApprenticeshipVacancySummary v in projectedVacancies.Vacancies)
{
numberOfProjectedVacanices++;
v.Title.Should().Be("Displayed");
}
}
numberOfProjectedVacanices.Should().Be(expectedCount);
}
public static async Task Run(
[QueueTrigger("projectedavfeedforsocmapping")]
ProjectedVacancySummary myQueueItem,
TraceWriter log,
[Queue("projectedavdetails")]
IAsyncCollector <ProjectedVacancyDetails> projectedVacancyDetails,
[DocumentDB("AVFeedAudit", "AuditRecords", ConnectionStringSetting = "AVAuditCosmosDB")]
IAsyncCollector <AuditRecord <object, object> > auditRecord)
{
try
{
await GetDetailsForProjectedAvFunc(myQueueItem, projectedVacancyDetails, auditRecord);
}
finally
{
log.Info($"C# Queue trigger function processed: {myQueueItem} CorrelationId = {myQueueItem.CorrelationId} SOC = {myQueueItem.SocCode}");
}
}
public async Task ExecuteAsync(ProjectedVacancySummary projectedVacancySummary)
{
if (projectedVacancySummary == null)
{
throw new ApplicationException(nameof(projectedVacancySummary));
}
projectedVacancyDetails = new ProjectedVacancyDetails()
{
SocCode = projectedVacancySummary.SocCode, AccessToken = projectedVacancySummary.AccessToken, SocMappingId = projectedVacancySummary.SocMappingId
};
var vacancyDetailsList = new List <ApprenticeshipVacancyDetails>();
foreach (var v in projectedVacancySummary.Vacancies)
{
vacancyDetailsList.Add(await avService.GetApprenticeshipVacancyDetailsAsync(v.VacancyReference.ToString()));
}
projectedVacancyDetails.Vacancies = vacancyDetailsList;
}
private static async Task AuditMapping(ProjectedVacancySummary myQueueItem, IAsyncCollector <AuditRecord <object, object> > auditRecord, DateTime startTime, ProjectedVacancyDetails getDetailsResult)
{
myQueueItem.AccessToken = null;
await auditRecord.AddAsync(new AuditRecord <object, object>
{
CorrelationId = myQueueItem.CorrelationId,
StartedAt = startTime,
EndedAt = DateTime.Now,
Function = nameof(GetAVDetailsForProjectedAVFunction),
Input = myQueueItem,
Output = new
{
CorrelationId = myQueueItem.CorrelationId,
SocCode = getDetailsResult.SocCode,
SocMappingId = getDetailsResult.SocMappingId,
VacanciesCount = getDetailsResult.Vacancies.Count()
},
});
int index = 1;
foreach (var item in getDetailsResult.Vacancies)
{
await auditRecord.AddAsync(new AuditRecord <object, object>
{
CorrelationId = myQueueItem.CorrelationId,
StartedAt = startTime,
EndedAt = DateTime.Now,
Function = nameof(GetAVDetailsForProjectedAVFunction),
Input = myQueueItem,
Output = new
{
CorrelationId = myQueueItem.CorrelationId,
SocCode = getDetailsResult.SocCode,
SocMappingId = getDetailsResult.SocMappingId,
Vacancy = item,
Index = index++
},
});
}
}
private static async Task GetDetailsForProjectedAvFunc(ProjectedVacancySummary myQueueItem, IAsyncCollector <ProjectedVacancyDetails> projectedVacancyDetails, IAsyncCollector <AuditRecord <object, object> > auditRecord, int attempt = 1)
{
try
{
var startTime = DateTime.UtcNow;
ConfigureLog.ConfigureNLogWithAppInsightsTarget();
var getDetailsResult = await Startup.RunAsync(myQueueItem, RunMode.Azure, auditRecord, new AuditRecord <object, object>
{
CorrelationId = myQueueItem.CorrelationId,
StartedAt = startTime,
EndedAt = DateTime.Now,
Function = nameof(GetAVDetailsForProjectedAVFunction),
Input = "",
Output = ""
}).ConfigureAwait(false);
getDetailsResult.CorrelationId = myQueueItem.CorrelationId;
await AuditMapping(myQueueItem, auditRecord, startTime, getDetailsResult);
await projectedVacancyDetails.AddAsync(getDetailsResult).ConfigureAwait(false);
}
catch (AvApiResponseException responseException)
{
if (responseException.StatusCode == ((HttpStatusCode)429) && attempt < 3)
{
var retryInSeconds = 60;
int.TryParse(Regex.Match(responseException.Message, "\\d+")?.Value, out retryInSeconds);
await Task.Delay(retryInSeconds * 1000);
await GetDetailsForProjectedAvFunc(myQueueItem, projectedVacancyDetails, auditRecord, attempt ++);
}
else
{
throw;
}
}
}
public void Execute(MappedVacancySummary mappedVacancySummary)
{
if (mappedVacancySummary != null)
{
projectedVacanciesForSOC = new ProjectedVacancySummary
{
SocCode = mappedVacancySummary.SocCode,
SocMappingId = mappedVacancySummary.SocMappingId,
AccessToken = mappedVacancySummary.AccessToken,
};
//if none were found for SOC
if (mappedVacancySummary.Vacancies == null)
{
return;
}
var numberProvoidersFound = mappedVacancySummary.Vacancies.Select(v => v.TrainingProviderName).Distinct().Count();
var projection = Enumerable.Empty <ApprenticeshipVacancySummary>();
if (numberProvoidersFound > 1)
{
//have multipe providers
projection = mappedVacancySummary.Vacancies
.GroupBy(v => v.TrainingProviderName)
.Select(g => g.First())
.Take(2);
}
else
{
//just have a single or no provider
projection = mappedVacancySummary.Vacancies.Take(2);
}
projectedVacanciesForSOC.Vacancies = projection;
}
}
private static async Task AuditProjections(SocMapping myQueueItem, IAsyncCollector <AuditRecord <object, object> > auditRecord, DateTime startTime, MappedVacancySummary mappedResult, ProjectedVacancySummary projectedResult)
{
myQueueItem.AccessToken = null;
await auditRecord.AddAsync(new AuditRecord <object, object>
{
CorrelationId = myQueueItem.CorrelationId,
StartedAt = startTime,
EndedAt = DateTime.Now,
Function = "ProjectVacanciesAzFunction",
Input = new
{
CorrelationId = myQueueItem.CorrelationId,
SocCode = mappedResult.SocCode,
SocMappingId = mappedResult.SocMappingId,
VacanciesCount = mappedResult.Vacancies.Count()
},
Output = projectedResult,
});
}
public static async Task <ProjectedVacancyDetails> RunAsync(ProjectedVacancySummary myQueueItem, RunMode mode)
{
return(await RunAsync(myQueueItem, mode, null, null));
}
