private async Task SaveVersion(TestScenario testScenario, string gherkin)
{
TestScenarioVersion testScenarioVersion = testScenario.Current.Clone() as TestScenarioVersion;
testScenarioVersion.Gherkin = gherkin;
testScenarioVersion = await _versionRepository.CreateVersion(testScenarioVersion, testScenario.Current);
testScenario.Current = testScenarioVersion;
await _scenariosRepositoryPolicy.ExecuteAsync(() => _scenariosRepository.SaveTestScenario(testScenario));
await _versionRepository.SaveVersion(testScenarioVersion);
await _cacheProvider.RemoveAsync <GherkinParseResult>($"{CacheKeys.GherkinParseResult}{testScenario.Id}");
}
public async Task UpdateScenarioForSpecification(Message message)
{
SpecificationVersionComparisonModel specificationVersionComparison = message.GetPayloadAsInstanceOf <SpecificationVersionComparisonModel>();
if (specificationVersionComparison == null || specificationVersionComparison.Current == null)
{
_logger.Error("A null specificationVersionComparison was provided to UpdateScenarioForSpecification");
throw new InvalidModelException(nameof(Models.Specs.SpecificationVersionComparisonModel), new[] { "Null or invalid model provided" });
}
if (specificationVersionComparison.HasNoChanges && !specificationVersionComparison.HasNameChange)
{
_logger.Information("No changes detected");
return;
}
string specificationId = specificationVersionComparison.Id;
IEnumerable <TestScenario> scenarios = await _scenariosRepository.GetTestScenariosBySpecificationId(specificationId);
if (scenarios.IsNullOrEmpty())
{
_logger.Information($"No scenarios found for specification id: {specificationId}");
return;
}
IEnumerable <string> fundingStreamIds = specificationVersionComparison.Current.FundingStreams?.Select(m => m.Id);
IList <ScenarioIndex> scenarioIndexes = new List <ScenarioIndex>();
IList <TestScenarioVersion> scenarioVersions = new List <TestScenarioVersion>();
foreach (TestScenario scenario in scenarios)
{
TestScenarioVersion newVersion = new TestScenarioVersion
{
FundingPeriodId = specificationVersionComparison.Current.FundingPeriod.Id,
FundingStreamIds = specificationVersionComparison.Current.FundingStreams.Select(m => m.Id),
Author = scenario.Current.Author,
Gherkin = scenario.Current.Gherkin,
Description = scenario.Current.Description,
PublishStatus = scenario.Current.PublishStatus
};
newVersion = await _versionRepository.CreateVersion(newVersion, scenario.Current);
scenario.Current = newVersion;
scenarioVersions.Add(newVersion);
ScenarioIndex scenarioIndex = CreateScenarioIndexFromScenario(scenario, new SpecificationSummary
{
Id = specificationVersionComparison.Id,
Name = specificationVersionComparison.Current.Name,
FundingPeriod = specificationVersionComparison.Current.FundingPeriod,
FundingStreams = specificationVersionComparison.Current.FundingStreams
});
scenarioIndexes.Add(scenarioIndex);
}
await TaskHelper.WhenAllAndThrow(
_scenariosRepository.SaveTestScenarios(scenarios),
_versionRepository.SaveVersions(scenarioVersions),
_searchRepository.Index(scenarioIndexes)
);
}
public async Task <IActionResult> SaveVersion(HttpRequest request)
{
string json = await request.GetRawBodyStringAsync();
CreateNewTestScenarioVersion scenarioVersion = JsonConvert.DeserializeObject <CreateNewTestScenarioVersion>(json);
if (scenarioVersion == null)
{
_logger.Error("A null scenario version was provided");
return(new BadRequestObjectResult("Null or empty calculation Id provided"));
}
BadRequestObjectResult validationResult = (await _createNewTestScenarioVersionValidator.ValidateAsync(scenarioVersion)).PopulateModelState();
if (validationResult != null)
{
return(validationResult);
}
TestScenario testScenario = null;
if (!string.IsNullOrEmpty(scenarioVersion.Id))
{
testScenario = await _scenariosRepository.GetTestScenarioById(scenarioVersion.Id);
}
bool saveAsVersion = true;
SpecificationSummary specification = await _specificationsRepository.GetSpecificationSummaryById(scenarioVersion.SpecificationId);
if (specification == null)
{
_logger.Error($"Unable to find a specification for specification id : {scenarioVersion.SpecificationId}");
return(new StatusCodeResult(412));
}
Reference user = request.GetUserOrDefault();
if (testScenario == null)
{
string Id = Guid.NewGuid().ToString();
testScenario = new TestScenario
{
Id = Id,
SpecificationId = specification.Id,
Name = scenarioVersion.Name,
Current = new TestScenarioVersion
{
Date = DateTimeOffset.Now.ToLocalTime(),
TestScenarioId = Id,
PublishStatus = PublishStatus.Draft,
Version = 1,
Author = user,
Gherkin = scenarioVersion.Scenario,
Description = scenarioVersion.Description,
FundingPeriodId = specification.FundingPeriod.Id,
FundingStreamIds = specification.FundingStreams.Select(s => s.Id).ToArraySafe(),
}
};
}
else
{
testScenario.Name = scenarioVersion.Name;
saveAsVersion = !string.Equals(scenarioVersion.Scenario, testScenario.Current.Gherkin) ||
scenarioVersion.Description != testScenario.Current.Description;
TestScenarioVersion newVersion = testScenario.Current.Clone() as TestScenarioVersion;
if (saveAsVersion == true)
{
newVersion.Author = user;
newVersion.Gherkin = scenarioVersion.Scenario;
newVersion.Description = scenarioVersion.Description;
newVersion.FundingStreamIds = specification.FundingStreams.Select(s => s.Id).ToArraySafe();
newVersion.FundingPeriodId = specification.FundingPeriod.Id;
newVersion = await _versionRepository.CreateVersion(newVersion, testScenario.Current);
testScenario.Current = newVersion;
}
}
HttpStatusCode statusCode = await _scenariosRepository.SaveTestScenario(testScenario);
if (!statusCode.IsSuccess())
{
_logger.Error($"Failed to save test scenario with status code: {statusCode.ToString()}");
return(new StatusCodeResult((int)statusCode));
}
await _versionRepository.SaveVersion(testScenario.Current);
ScenarioIndex scenarioIndex = CreateScenarioIndexFromScenario(testScenario, specification);
await _searchRepository.Index(new List <ScenarioIndex> {
scenarioIndex
});
await _cacheProvider.RemoveAsync <List <TestScenario> >($"{CacheKeys.TestScenarios}{testScenario.SpecificationId}");
await _cacheProvider.RemoveAsync <GherkinParseResult>($"{CacheKeys.GherkinParseResult}{testScenario.Id}");
IEnumerable <Models.Calcs.CalculationCurrentVersion> calculations = await _calcsRepositoryPolicy.ExecuteAsync(() => _calcsRepository.GetCurrentCalculationsBySpecificationId(specification.Id));
if (calculations.IsNullOrEmpty())
{
_logger.Information($"No calculations found to test for specification id: '{specification.Id}'");
}
else
{
string correlationId = request.GetCorrelationId();
try
{
Trigger trigger = new Trigger
{
EntityId = testScenario.Id,
EntityType = nameof(TestScenario),
Message = $"Saving test scenario: '{testScenario.Id}'"
};
bool generateCalculationAggregations = SourceCodeHelpers.HasCalculationAggregateFunctionParameters(calculations.Select(m => m.SourceCode));
Job job = await SendInstructAllocationsToJobService(specification.Id, user, trigger, correlationId, generateCalculationAggregations);
_logger.Information($"New job of type '{job.JobDefinitionId}' created with id: '{job.Id}'");
}
catch (Exception ex)
{
_logger.Error(ex, $"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{specification.Id}'");
return(new InternalServerErrorResult($"An error occurred attempting to execute calculations prior to running tests on specification '{specification.Id}'"));
}
}
CurrentTestScenario testScenarioResult = await _scenariosRepository.GetCurrentTestScenarioById(testScenario.Id);
return(new OkObjectResult(testScenarioResult));
}
