public async Task <TradingFee> InsertAsync(TradingFee tradingFee)
{
using (var context = _connectionFactory.CreateDataContext())
{
var existedTradingFee = await GetAsync(tradingFee.Id, tradingFee.BrokerId, context);
if (existedTradingFee != null)
{
throw new DuplicatedEntityException(ErrorCode.DuplicateItem, $"TradingFee with id '{tradingFee.Id}' already exists.");
}
existedTradingFee = await GetAsync(tradingFee.BrokerId, tradingFee.AssetPair, context);
if (existedTradingFee != null)
{
throw new DuplicatedEntityException(ErrorCode.DuplicateItem, $"TradingFee with the asset pair '{tradingFee.AssetPair ?? "null"}' already exists.");
}
var data = _mapper.Map <TradingFeeEntity>(tradingFee);
data.Created = DateTime.UtcNow;
data.Modified = data.Created;
context.TradingFees.Add(data);
await context.SaveChangesAsync();
return(_mapper.Map <TradingFee>(data));
}
}
public async Task <TradingFee> UpdateAsync(TradingFee tradingFee)
{
using (var context = _connectionFactory.CreateDataContext())
{
var data = await GetAsync(tradingFee.Id, tradingFee.BrokerId, context);
if (data == null)
{
throw new EntityNotFoundException(ErrorCode.ItemNotFound, $"TradingFee with id '{tradingFee.Id}' does not exist.");
}
// save fields that has not be updated
var assetPair = data.AssetPair;
var levels = data.Levels;
var created = data.Created;
_mapper.Map(tradingFee, data);
// restore fields that has not be updated
data.AssetPair = assetPair;
data.Levels = levels;
data.Created = created;
data.Modified = DateTime.UtcNow;
await context.SaveChangesAsync();
return(_mapper.Map <TradingFee>(data));
}
}
private TradingFee Map(Domain.Entities.TradingFee domain, IReadOnlyList <Domain.Entities.TradingFeeLevel> levels)
{
if (domain == null)
{
return(null);
}
var model = new TradingFee();
model.Id = domain.Id;
model.BrokerId = domain.BrokerId;
model.AssetPair = domain.AssetPair;
model.Asset = domain.Asset;
model.Levels.AddRange(levels.Select(x =>
{
var newLevel = new TradingFeeLevel
{
Id = x.Id,
TradingFeeId = x.TradingFeeId,
Volume = x.Volume.ToString(CultureInfo.InvariantCulture),
MakerFee = x.MakerFee.ToString(CultureInfo.InvariantCulture),
TakerFee = x.TakerFee.ToString(CultureInfo.InvariantCulture),
Created = x.Created.ToTimestamp(),
Modified = x.Modified.ToTimestamp()
};
return(newLevel);
}));
model.Created = Timestamp.FromDateTime(domain.Created);
model.Modified = Timestamp.FromDateTime(domain.Modified);
return(model);
}
public async Task <TradingFee> UpdateAsync(TradingFee tradingFee)
{
var result = await _tradingFeeRepository.UpdateAsync(tradingFee);
_logger.LogInformation("TradingFee has been updated. {@TradingFee}", result);
return(result);
}
public TradingFeeModel(TradingFee tradingFee, IEnumerable <TradingFeeLevel> levels)
{
Id = tradingFee.Id;
BrokerId = tradingFee.BrokerId;
AssetPair = tradingFee.AssetPair;
Asset = tradingFee.Asset;
Levels = levels.Select(x => new TradingFeeLevelModel(x)).ToList();
Created = tradingFee.Created.ToDateTime();
Modified = tradingFee.Modified.ToDateTime();
}
public async Task <TradingFee> GetTradingFee(string instrument, string currency)
{
var responseObj = new TradingFee
{
Success = true
};
try
{
HttpResponseMessage response = await Api.GetTradingFeeRaw(instrument, currency);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var baseResponse = JsonConvert.DeserializeObject <TradingFee>(content);
if (baseResponse != null)
{
responseObj.Success = baseResponse.Success;
responseObj.ErrorCode = baseResponse.ErrorCode;
responseObj.ErrorMessage = baseResponse.ErrorMessage;
responseObj.TradingFeeRate = baseResponse.TradingFeeRate;
responseObj.Volume30Day = baseResponse.Volume30Day;
}
}
else
{
responseObj.Success = false;
responseObj.ErrorCode = 101;
responseObj.ErrorMessage = "Remote api returned invalid status code while retrieving trading fee";
}
}
catch (Exception ex)
{
responseObj.Success = false;
responseObj.ErrorCode = 100;
responseObj.ErrorMessage = ex.ToString();
}
return(responseObj);
}
public async Task <TradingFee> AddAsync(TradingFee tradingFee)
{
//var assets = await _assetsClient.Assets.GetAllByBrokerId(tradingFee.BrokerId);
//if (tradingFee.Asset != null &&
// !assets.Select(x => x.Symbol).Contains(tradingFee.Asset))
//{
// throw new EntityNotFoundException(ErrorCode.ItemNotFound, "Asset does not exist.");
//}
//var assetPairs = await _assetsClient.AssetPairs.GetAllByBrokerId(tradingFee.BrokerId);
//if (tradingFee.AssetPair != null &&
// !assetPairs.Select(x => x.Symbol).Contains(tradingFee.AssetPair))
//{
// throw new EntityNotFoundException(ErrorCode.ItemNotFound, "Asset pair does not exist.");
//}
var result = await _tradingFeeRepository.InsertAsync(tradingFee);
_logger.LogInformation("TradingFee has been added. {@TradingFee}", result);
return(result);
}
