public async Task <TradingConditionContract> Insert([FromBody] TradingConditionContract tradingCondition)
{
await ValidateTradingCondition(tradingCondition);
var defaultTradingCondition =
(await _tradingConditionsRepository.GetDefaultAsync()).FirstOrDefault();
if (tradingCondition.IsDefault &&
defaultTradingCondition != null && defaultTradingCondition.Id != tradingCondition.Id)
{
await SetDefault(defaultTradingCondition, false);
}
if (defaultTradingCondition == null)
{
tradingCondition.IsDefault = true;
}
_defaultLegalEntitySettings.Set(tradingCondition);
if (!await _tradingConditionsRepository.TryInsertAsync(
_convertService.Convert <TradingConditionContract, TradingCondition>(tradingCondition)))
{
throw new ArgumentException($"Trading condition with id {tradingCondition.Id} already exists",
nameof(tradingCondition.Id));
}
await _eventSender.SendSettingsChangedEvent($"{Request.Path}",
SettingsChangedSourceType.TradingCondition, tradingCondition.Id);
return(tradingCondition);
}
public async Task <AssetPairContract> Insert([FromBody] AssetPairContract assetPair)
{
await ValidatePairInsert(assetPair);
_defaultLegalEntitySettings.Set(assetPair);
var inserted = await _assetPairsRepository.InsertAsync(
_convertService.Convert <AssetPairContract, AssetPair>(assetPair));
if (inserted == null)
{
throw new ArgumentException($"Asset pair with id {assetPair.Id} already exists", nameof(assetPair.Id));
}
var insertedContract = _convertService.Convert <IAssetPair, AssetPairContract>(inserted);
await _eventSender.SendSettingsChangedEvent($"{Request.Path}", SettingsChangedSourceType.AssetPair,
inserted.Id);
await _cqrsMessageSender.SendAssetPairChangedEvent(new AssetPairChangedEvent
{
OperationId = Guid.NewGuid().ToString("N"),
AssetPair = insertedContract,
});
return(insertedContract);
}
public async Task <AssetContract> Insert([FromBody] AssetContract asset)
{
Validate(asset);
if (!await _assetsRepository.TryInsertAsync(_convertService.Convert <AssetContract, Asset>(asset)))
{
throw new ArgumentException($"Asset with id {asset.Id} already exists", nameof(asset.Id));
}
await _eventSender.SendSettingsChangedEvent($"{Request.Path}", SettingsChangedSourceType.Asset,
asset.Id);
return(asset);
}
public async Task <MarketContract> Insert([FromBody] MarketContract market)
{
Validate(market);
if (!await _marketRepository.TryInsertAsync(_convertService.Convert <MarketContract, Market>(market)))
{
throw new ArgumentException($"Market with id {market.Id} already exists", nameof(market.Id));
}
await _eventSender.SendSettingsChangedEvent($"{Request.Path}", SettingsChangedSourceType.Market,
market.Id);
return(market);
}
public async Task <MatchingEngineRouteContract> Insert([FromBody] MatchingEngineRouteContract route)
{
await ValidateRoute(route);
if (!await _tradingRoutesRepository.TryInsertAsync(
_convertService.Convert <MatchingEngineRouteContract, TradingRoute>(route)))
{
throw new ArgumentException($"Trading route with id {route.Id} already exists", nameof(route.Id));
}
await _eventSender.SendSettingsChangedEvent($"{Request.Path}",
SettingsChangedSourceType.TradingRoute, route.Id);
return(route);
}
public async Task <TradingInstrumentContract> Insert([FromBody] TradingInstrumentContract instrument)
{
await ValidateTradingInstrument(instrument);
if (!await _tradingInstrumentsRepository.TryInsertAsync(
_convertService.Convert <TradingInstrumentContract, TradingInstrument>(instrument)))
{
throw new ArgumentException($"Trading instrument with tradingConditionId {instrument.TradingConditionId}" +
$"and assetPairId {instrument.Instrument} already exists");
}
await _eventSender.SendSettingsChangedEvent($"{Request.Path}",
SettingsChangedSourceType.TradingInstrument, GetIdContractSerialized(instrument));
return(instrument);
}
public async Task <ScheduleSettingsContract> Insert([FromBody] ScheduleSettingsContract scheduleSetting)
{
await ValidateScheduleSettings(scheduleSetting);
if (!await _scheduleSettingsRepository.TryInsertAsync(
_convertService.Convert <ScheduleSettingsContract, ScheduleSettings>(scheduleSetting)))
{
throw new ArgumentException($"Schedule setting with id {scheduleSetting.Id} already exists",
nameof(scheduleSetting.Id));
}
await _eventSender.SendSettingsChangedEvent($"{Request.Path}",
SettingsChangedSourceType.ScheduleSettings, scheduleSetting.Id);
return(scheduleSetting);
}
public Task <bool> Post([FromBody] bool enabled)
{
_maintenanceModeService.SetMode(enabled);
_eventSender.SendSettingsChangedEvent($"{Request.Path}", SettingsChangedSourceType.ServiceMaintenance);
return(Task.FromResult(true));
}
