public void RenameCalculation(string oldName,
string newName,
string fundingStreamId,
CalculationNamespace calculationNamespace,
string originalSource,
string expectedSource)
{
Calculation calculation = new Calculation
{
FundingStreamId = fundingStreamId,
Current = new CalculationVersion
{
SourceCode = originalSource,
Namespace = calculationNamespace
}
};
string actualSource = new CalculationCodeReferenceUpdate()
.ReplaceSourceCodeReferences(calculation.Current.SourceCode, oldName, newName, calculation.Namespace);
actualSource
.Should()
.Be(expectedSource);
}
public CalculationBuilder WithCalculationNamespaceType(CalculationNamespace namespaceType)
{
_namespace = namespaceType;
return this;
}
public FundingLineCalculationBuilder WithCalculationNamespaceType(CalculationNamespace namespaceType)
{
_namespace = namespaceType;
return(this);
}
public async Task <CreateCalculationResponse> CreateCalculation(string specificationId,
CalculationCreateModel model,
CalculationNamespace calculationNamespace,
CalculationType calculationType,
Reference author,
string correlationId,
CalculationDataType calculationDataType = CalculationDataType.Decimal,
bool initiateCalcRun = true,
IEnumerable <string> allowedEnumTypeValues = null)
{
Guard.ArgumentNotNull(model, nameof(model));
Guard.ArgumentNotNull(author, nameof(author));
if (string.IsNullOrWhiteSpace(model.Id))
{
model.Id = Guid.NewGuid().ToString();
}
model.SpecificationId = specificationId;
model.CalculationType = calculationType;
ValidationResult validationResult = await _calculationCreateModelValidator.ValidateAsync(model);
if (!validationResult.IsValid)
{
return(new CreateCalculationResponse
{
ValidationResult = validationResult,
ErrorType = CreateCalculationErrorType.InvalidRequest
});
}
Calculation calculation = new Calculation
{
Id = model.Id,
FundingStreamId = model.FundingStreamId,
SpecificationId = model.SpecificationId
};
CalculationVersion calculationVersion = new CalculationVersion
{
CalculationId = calculation.Id,
PublishStatus = PublishStatus.Draft,
Author = author,
Date = DateTimeOffset.Now.ToLocalTime(),
Version = 1,
SourceCode = model.SourceCode,
Description = model.Description,
ValueType = model.ValueType.Value,
CalculationType = calculationType,
WasTemplateCalculation = false,
Namespace = calculationNamespace,
Name = model.Name,
DataType = calculationDataType,
AllowedEnumTypeValues = allowedEnumTypeValues != null ? new List <string>(allowedEnumTypeValues) : Enumerable.Empty <string>()
};
calculation.Current = calculationVersion;
bool?nameValidResult = await _calculationNameInUseCheck.IsCalculationNameInUse(calculation.SpecificationId, calculation.Name, null);
if (nameValidResult == true)
{
string error =
$"Calculation with the same generated source code name already exists in this specification. Calculation Name {calculation.Name} and Specification {calculation.SpecificationId}";
_logger.Error(error);
return(new CreateCalculationResponse
{
ErrorMessage = error,
ErrorType = CreateCalculationErrorType.InvalidRequest
});
}
calculation.Current.SourceCodeName = _typeIdentifierGenerator.GenerateIdentifier(calculation.Name);
HttpStatusCode result = await _calculationRepositoryPolicy.ExecuteAsync(() => _calculationsRepository.CreateDraftCalculation(calculation));
if (result.IsSuccess())
{
await _calculationVersionsRepositoryPolicy.ExecuteAsync(() => _calculationVersionRepository.SaveVersion(calculationVersion));
await UpdateSearch(calculation, model.SpecificationName, model.FundingStreamName);
string cacheKey = $"{CacheKeys.CalculationsMetadataForSpecification}{specificationId}";
await _cachePolicy.ExecuteAsync(() => _cacheProvider.RemoveAsync <List <CalculationMetadata> >(cacheKey));
if (!initiateCalcRun)
{
return(new CreateCalculationResponse
{
Succeeded = true,
Calculation = calculation
});
}
try
{
Job job = await SendInstructAllocationsToJobService(calculation.SpecificationId, author.Id, author.Name, new Trigger
{
EntityId = calculation.Id,
EntityType = nameof(Calculation),
Message = $"Saving calculation: '{calculation.Id}' for specification: '{calculation.SpecificationId}'"
}, correlationId);
if (job != null)
{
_logger.Information($"New job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' created with id: '{job.Id}'");
return(new CreateCalculationResponse
{
Succeeded = true,
Calculation = calculation
});
}
else
{
string errorMessage = $"Failed to create job of type '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' on specification '{calculation.SpecificationId}'";
_logger.Error(errorMessage);
return(new CreateCalculationResponse
{
ErrorType = CreateCalculationErrorType.Exception,
ErrorMessage = errorMessage
});
}
}
catch (Exception ex)
{
return(new CreateCalculationResponse
{
ErrorMessage = ex.Message,
ErrorType = CreateCalculationErrorType.Exception
});
}
}
else
{
string errorMessage = $"There was problem creating a new calculation with name {calculation.Name} in Cosmos Db with status code {(int)result}";
_logger.Error(errorMessage);
return(new CreateCalculationResponse
{
ErrorMessage = errorMessage,
ErrorType = CreateCalculationErrorType.Exception
});
}
}
