private async Task <Build> CheckDatasetValidAggregations(PreviewRequest previewRequest)
{
Build build = null;
IEnumerable <string> aggregateParameters = SourceCodeHelpers.GetDatasetAggregateFunctionParameters(previewRequest.SourceCode);
if (aggregateParameters.IsNullOrEmpty())
{
return(build);
}
string cacheKey = $"{CacheKeys.DatasetRelationshipFieldsForSpecification}{previewRequest.SpecificationId}";
IEnumerable <DatasetSchemaRelationshipModel> datasetSchemaRelationshipModels = Enumerable.Empty <DatasetSchemaRelationshipModel>();
datasetSchemaRelationshipModels = await _cacheProvider.GetAsync <List <DatasetSchemaRelationshipModel> >(cacheKey);
if (datasetSchemaRelationshipModels.IsNullOrEmpty())
{
ApiResponse <IEnumerable <Common.ApiClient.DataSets.Models.DatasetSchemaRelationshipModel> > datasetsApiClientResponse = await _datasetsApiClientPolicy.ExecuteAsync(() => _datasetsApiClient.GetDatasetSchemaRelationshipModelsForSpecificationId(previewRequest.SpecificationId));
if (!datasetsApiClientResponse.StatusCode.IsSuccess())
{
string message = $"No dataset schema relationship found for specificationId '{previewRequest.SpecificationId}'.";
_logger.Error(message);
throw new RetriableException(message);
}
if (datasetsApiClientResponse.Content != null)
{
datasetSchemaRelationshipModels = _mapper.Map <IEnumerable <DatasetSchemaRelationshipModel> >(datasetsApiClientResponse.Content);
}
await _cacheProvider.SetAsync <List <DatasetSchemaRelationshipModel> >(cacheKey, datasetSchemaRelationshipModels.ToList());
}
HashSet <string> compilerErrors = new HashSet <string>();
IEnumerable <string> datasetAggregationFields = datasetSchemaRelationshipModels?.SelectMany(m => m.Fields?.Where(f => f.IsAggregable).Select(f => f.FullyQualifiedSourceName));
foreach (string aggregateParameter in aggregateParameters)
{
if (datasetAggregationFields.IsNullOrEmpty() || !datasetAggregationFields.Any(m => string.Equals(m.Trim(), aggregateParameter.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
compilerErrors.Add($"{aggregateParameter} is not an aggregable field");
}
}
if (compilerErrors.Any())
{
build = new Build
{
CompilerMessages = compilerErrors.Select(m => new CompilerMessage {
Message = m, Severity = Severity.Error
}).ToList()
};
}
return(build);
}
public void GetDatasetAggregateFunctionParameters_GivenSourceHasZeroDatasetParameters_ReturnsEmptyList()
{
//Arrange
string sourceCode = "Return Sum(Calc1)";
//Act
IEnumerable <string> aggregateParameters = SourceCodeHelpers.GetDatasetAggregateFunctionParameters(sourceCode);
//Assert
aggregateParameters
.Should()
.BeEmpty();
}
private async Task <Build> CheckDatasetValidAggregations(PreviewRequest previewRequest)
{
Build build = null;
IEnumerable <string> aggregateParameters = SourceCodeHelpers.GetDatasetAggregateFunctionParameters(previewRequest.SourceCode);
if (aggregateParameters.IsNullOrEmpty())
{
return(build);
}
string cacheKey = $"{CacheKeys.DatasetRelationshipFieldsForSpecification}{previewRequest.SpecificationId}";
IEnumerable <DatasetSchemaRelationshipModel> datasetSchemaRelationshipModels = Enumerable.Empty <DatasetSchemaRelationshipModel>();
datasetSchemaRelationshipModels = await _cacheProvider.GetAsync <List <DatasetSchemaRelationshipModel> >(cacheKey);
if (datasetSchemaRelationshipModels.IsNullOrEmpty())
{
datasetSchemaRelationshipModels = await _datasetRepository.GetDatasetSchemaRelationshipModelsForSpecificationId(previewRequest.SpecificationId);
await _cacheProvider.SetAsync <List <DatasetSchemaRelationshipModel> >(cacheKey, datasetSchemaRelationshipModels.ToList());
}
HashSet <string> compilerErrors = new HashSet <string>();
IEnumerable <string> datasetAggregationFields = datasetSchemaRelationshipModels?.SelectMany(m => m.Fields?.Where(f => f.IsAggregable).Select(f => f.FullyQualifiedSourceName));
foreach (string aggregateParameter in aggregateParameters)
{
if (datasetAggregationFields.IsNullOrEmpty() || !datasetAggregationFields.Any(m => string.Equals(m.Trim(), aggregateParameter.Trim(), StringComparison.CurrentCultureIgnoreCase)))
{
compilerErrors.Add($"{aggregateParameter} is not an aggregable field");
}
}
if (compilerErrors.Any())
{
build = new Build
{
CompilerMessages = compilerErrors.Select(m => new CompilerMessage {
Message = m, Severity = Severity.Error
}).ToList()
};
}
return(build);
}
public void GetDatasetAggregateFunctionParameters_GivenSourceHasOneDatasetParameter_ReturnsOneParameter()
{
//Arrange
string sourceCode = "Return Sum(Datasets.Testing1) + Sum(Calc1)";
//Act
IEnumerable <string> aggregateParameters = SourceCodeHelpers.GetDatasetAggregateFunctionParameters(sourceCode);
//Assert
aggregateParameters
.Count()
.Should()
.Be(1);
aggregateParameters
.First()
.Should()
.Be("Datasets.Testing1");
}
public void GetDatasetAggregateFunctionParameters_GivenSourceHasTwoDatasetParameters_ReturnsTwoParameters()
{
//Arrange
string sourceCode = "Return Sum(Datasets.Testing1) + Sum(Datasets.Testing2) + Sum(Calc1)";
//Act
IEnumerable <string> aggregateParameters = SourceCodeHelpers.GetDatasetAggregateFunctionParameters(sourceCode);
//Assert
aggregateParameters
.Count()
.Should()
.Be(2);
aggregateParameters
.ElementAt(0)
.Should()
.Be("Datasets.Testing1");
aggregateParameters
.ElementAt(1)
.Should()
.Be("Datasets.Testing2");
}
private async Task ProcessFieldChanges(string datasetDefinitionId, IEnumerable <FieldDefinitionChanges> fieldChanges, IEnumerable <string> relationshipSpecificationIds)
{
Guard.IsNullOrWhiteSpace(datasetDefinitionId, nameof(datasetDefinitionId));
Guard.ArgumentNotNull(fieldChanges, nameof(fieldChanges));
Guard.ArgumentNotNull(relationshipSpecificationIds, nameof(relationshipSpecificationIds));
IEnumerable <IGrouping <string, FieldDefinitionChanges> > groupedFieldChanges = fieldChanges.GroupBy(f => f.FieldDefinition.Id);
IList <FieldDefinitionChanges> fieldDefinitionChanges = new List <FieldDefinitionChanges>();
bool shouldResetCalculation = false;
foreach (IGrouping <string, FieldDefinitionChanges> grouping in groupedFieldChanges)
{
FieldDefinitionChanges fieldDefinitionChange = grouping.FirstOrDefault(m => m.ChangeTypes.Any(
c => c == FieldDefinitionChangeType.FieldName) || m.RequiresRemap);
if (fieldDefinitionChange != null)
{
fieldDefinitionChanges.Add(fieldDefinitionChange);
}
shouldResetCalculation = true;
}
if (!shouldResetCalculation)
{
return;
}
foreach (string specificationId in relationshipSpecificationIds)
{
IEnumerable <DatasetSpecificationRelationshipViewModel> relationships = await _datasetRepositoryPolicy.ExecuteAsync(() => _datasetRepository.GetCurrentRelationshipsBySpecificationIdAndDatasetDefinitionId(specificationId, datasetDefinitionId));
if (relationships.IsNullOrEmpty())
{
throw new RetriableException($"No relationships found for specificationId '{specificationId}' and dataset definition id '{datasetDefinitionId}'");
}
IEnumerable <Calculation> calculations = (await _calculationsRepositoryPolicy.ExecuteAsync(() => _calculationsRepository.GetCalculationsBySpecificationId(specificationId))).ToList();
IEnumerable <string> aggregateParameters = calculations.SelectMany(m => SourceCodeHelpers.GetDatasetAggregateFunctionParameters(m.Current.SourceCode));
HashSet <string> fieldNames = new HashSet <string>();
foreach (FieldDefinitionChanges changes in fieldDefinitionChanges)
{
//Check if only aggregable changes
if (!changes.ChangeTypes.Contains(FieldDefinitionChangeType.FieldType) && !changes.ChangeTypes.Contains(FieldDefinitionChangeType.FieldName))
{
foreach (DatasetSpecificationRelationshipViewModel datasetSpecificationRelationshipViewModel in relationships)
{
if (aggregateParameters.Contains($"Datasets.{VisualBasicTypeGenerator.GenerateIdentifier(datasetSpecificationRelationshipViewModel.Name)}.{VisualBasicTypeGenerator.GenerateIdentifier(changes.ExistingFieldDefinition.Name)}"))
{
fieldNames.Add(changes.ExistingFieldDefinition.Name);
}
}
}
else
{
fieldNames.Add(changes.ExistingFieldDefinition.Name);
}
}
if (fieldNames.Any())
{
await _calculationService.ResetCalculationForFieldDefinitionChanges(relationships, specificationId, fieldNames);
}
}
}