public async Task <Result <TickFormulaErrorCodes> > AddAsync(ITickFormula model, string username,
string correlationId)
{
SetDefaultLadderAndTicksIfNeeded(model);
var validationResult = ValidateLaddersAndTicks(model);
if (validationResult.IsFailed)
{
return(validationResult);
}
var addResult = await _tickFormulaRepository.AddAsync(model);
if (addResult.IsFailed)
{
return(addResult);
}
await _auditService.TryAudit(correlationId, username, model.Id, AuditDataType.TickFormula,
model.ToJson());
await _entityChangedSender.SendEntityCreatedEvent <ITickFormula, TickFormulaContract, TickFormulaChangedEvent>(
model, username, correlationId);
return(new Result <TickFormulaErrorCodes>());
}
public async Task <Result <ProductsErrorCodes> > InsertAsync(Product product, string username,
string correlationId)
{
var validationResult =
await _addOrUpdateValidationAndEnrichment.ValidateAllAsync(product, username, correlationId);
if (validationResult.IsFailed)
{
return(validationResult.ToResultWithoutValue());
}
product = validationResult.Value;
var result = await _repository.InsertAsync(product);
if (result.IsSuccess)
{
await _auditService.TryAudit(correlationId, username, product.ProductId, AuditDataType.Product,
product.ToJson());
await _entityChangedSender.SendEntityCreatedEvent <Product, ProductContract, ProductChangedEvent>(
product,
username, correlationId);
}
return(result);
}
public async Task InsertAsync(AssetTypeWithTemplate model, string username, string correlationId)
{
var brokerSettingsResponse = await _brokerSettingsApi.GetByIdAsync(_brokerId);
if (brokerSettingsResponse.ErrorCode == BrokerSettingsErrorCodesContract.BrokerSettingsDoNotExist)
{
throw new BrokerSettingsDoNotExistException();
}
await ValidateUnderlyingCategory(model.UnderlyingCategoryId);
var regulationId = brokerSettingsResponse.BrokerSettings.RegulationId;
await ValidateRegulatoryType(model.RegulatoryTypeId, regulationId);
List <ClientProfileSettings> clientProfileSettings;
//duplicate settings if we use template
if (!string.IsNullOrEmpty(model.AssetTypeTemplateId))
{
var regulatoryProfileTemplateExists =
await _assetTypesRepository.ExistsAsync(model.AssetTypeTemplateId);
if (!regulatoryProfileTemplateExists)
{
throw new AssetTypeDoesNotExistException();
}
clientProfileSettings = await
_clientProfileSettingsRepository.GetAllAsync(null, model.AssetTypeTemplateId);
foreach (var clientProfileSetting in clientProfileSettings)
{
clientProfileSetting.AssetTypeId = model.Id;
var regulatorySettings = await _regulatorySettingsApi.GetRegulatorySettingsByIdsAsync(
clientProfileSetting.RegulatoryProfileId, model.RegulatoryTypeId);
ValidateRegulatoryConstraint(regulatorySettings, clientProfileSetting);
}
}
else
{
clientProfileSettings = new List <ClientProfileSettings>();
var allRegulatorySettings =
await _regulatorySettingsApi.GetRegulatorySettingsByRegulationAsync(regulationId);
var clientProfiles = await _clientProfilesRepository.GetAllAsync();
foreach (var clientProfile in clientProfiles)
{
var regulatorySettings = allRegulatorySettings.RegulatorySettings.Single(x =>
x.TypeId == model.RegulatoryTypeId && x.ProfileId == clientProfile.RegulatoryProfileId);
clientProfileSettings.Add(new ClientProfileSettings
{
AssetTypeId = model.Id,
ClientProfileId = clientProfile.Id,
Margin = regulatorySettings.MarginMinPercent,
IsAvailable = regulatorySettings.IsAvailable,
});
}
}
await _assetTypesRepository.InsertAsync(model, clientProfileSettings);
await _auditService.TryAudit(correlationId, username, model.Id, AuditDataType.AssetType,
model.ToJson());
await _entityChangedSender.SendEntityCreatedEvent <AssetType, AssetTypeContract, AssetTypeChangedEvent>(model,
username, correlationId);
foreach (var profileSettings in clientProfileSettings)
{
await _entityChangedSender
.SendEntityCreatedEvent <ClientProfileSettings, ClientProfileSettingsContract,
ClientProfileSettingsChangedEvent>(profileSettings, username, correlationId);
}
}