internal static HistoryEntity Map(BaseHistoryRecord entity)
{
if (entity == null)
{
return(null);
}
switch (entity)
{
case Cashin cashin:
return(Mapper.Map <HistoryEntity>(cashin));
case Cashout cashout:
return(Mapper.Map <HistoryEntity>(cashout));
case Trade trade:
return(Mapper.Map <HistoryEntity>(trade));
case OrderEvent orderEvent:
return(Mapper.Map <HistoryEntity>(orderEvent));
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task <bool> TryInsertAsync(BaseHistoryRecord entity)
{
using (var connection = await _connectionFactory.CreateNpgsqlConnection())
{
var result = await connection.ExecuteAsync(_insertQuery, HistoryTypeMapper.Map(entity));
return(result > 0);
}
}
public async Task <bool> TryInsertAsync(BaseHistoryRecord entity)
{
if (await GetAsync(entity.Id, entity.WalletId) == null)
{
_data.Add(entity);
return(true);
}
return(false);
}
private async Task ProcessMessageAsync(CashTransferEvent message)
{
var fees = message.CashTransfer.Fees;
var fee = fees?.FirstOrDefault()?.Transfer;
var operationId = Guid.Parse(message.Header.RequestId);
var fromWallet = Guid.Parse(message.CashTransfer.FromWalletId);
var toWallet = Guid.Parse(message.CashTransfer.ToWalletId);
var volume = decimal.Parse(message.CashTransfer.Volume);
var timestamp = message.Header.Timestamp;
var assetId = message.CashTransfer.AssetId;
var feeSourceWalletId = fee != null?Guid.Parse(fee.SourceWalletId) : (Guid?)null;
var feeSize = ParseNullabe(fee?.Volume);
var cashInOuts = new BaseHistoryRecord[] {
new Cashout()
{
Id = operationId,
WalletId = fromWallet,
Volume = -Math.Abs(volume),
Timestamp = timestamp,
AssetId = assetId,
FeeSize = fromWallet == feeSourceWalletId ? feeSize : null,
State = Antares.Service.History.Core.Domain.Enums.HistoryState.Finished
},
new Cashin()
{
Id = operationId,
WalletId = toWallet,
Volume = Math.Abs(volume),
Timestamp = timestamp,
AssetId = assetId,
FeeSize = toWallet == feeSourceWalletId ? feeSize : null,
State = Antares.Service.History.Core.Domain.Enums.HistoryState.Finished
}
};
foreach (var cashInOut in cashInOuts)
{
if (!await _historyRecordsRepository.TryInsertAsync(cashInOut))
{
_log.Warning($"Skipped duplicated transfer record", context: new
{
id = operationId
});
}
}
}
public static HistoryResponseItem Map(BaseHistoryRecord baseHistoryRecord)
{
var item = new HistoryResponseItem()
{
Id = baseHistoryRecord.Id.ToString(),
Timestamp = baseHistoryRecord.Timestamp.ToUniversalTime().ToTimestamp(),
WalletId = baseHistoryRecord.WalletId.ToString(),
};
switch (baseHistoryRecord.Type)
{
case HistoryType.CashIn:
{
var cashinModel = (Antares.Service.History.Core.Domain.History.Cashin)baseHistoryRecord;
item.Type = GrpcContract.Common.HistoryType.CashIn;
item.CashIn = new CashInModel()
{
AssetId = cashinModel.AssetId,
BlockchainHash = cashinModel.BlockchainHash,
FeeSize = cashinModel.FeeSize,
Volume = cashinModel.Volume
};
break;
}
case HistoryType.CashOut:
{
var cashout = (Antares.Service.History.Core.Domain.History.Cashout)baseHistoryRecord;
item.Type = GrpcContract.Common.HistoryType.CashOut;
item.CashOut = new CashOutModel()
{
AssetId = cashout.AssetId,
BlockchainHash = cashout.BlockchainHash,
FeeSize = cashout.FeeSize,
Volume = cashout.Volume
};
break;
}
case HistoryType.Trade:
{
var trade = (Antares.Service.History.Core.Domain.History.Trade)baseHistoryRecord;
item.Type = GrpcContract.Common.HistoryType.Trade;
item.Trade = new TradeModel()
{
FeeSize = trade.FeeSize,
AssetPairId = trade.AssetPairId,
OrderId = trade.OrderId.ToString(),
BaseAssetId = trade.BaseAssetId,
BaseVolume = trade.BaseVolume,
FeeAssetId = trade.FeeAssetId,
Index = trade.Index,
Price = trade.Price,
QuotingAssetId = trade.QuotingAssetId,
QuotingVolume = trade.QuotingVolume,
Role = trade.Role switch
{
TradeRole.Unknown => GrpcContract.Common.TradeRole.Unknown,
TradeRole.Maker => GrpcContract.Common.TradeRole.Maker,
TradeRole.Taker => GrpcContract.Common.TradeRole.Taker,
_ => throw new ArgumentOutOfRangeException(nameof(trade.Role), trade.Role, null)
}
};
break;
}
case HistoryType.OrderEvent:
{
var orderEvent = (Antares.Service.History.Core.Domain.History.OrderEvent)baseHistoryRecord;
item.Type = GrpcContract.Common.HistoryType.OrderEvent;
item.OrderEvent = new OrderEventModel()
{
AssetPairId = orderEvent.AssetPairId,
OrderId = orderEvent.OrderId.ToString(),
Price = orderEvent.Price,
Status = orderEvent.Status switch
{
OrderStatus.Unknown => GrpcContract.Common.OrderStatus.UnknownOrder,
OrderStatus.Placed => GrpcContract.Common.OrderStatus.Placed,
OrderStatus.PartiallyMatched => GrpcContract.Common.OrderStatus.PartiallyMatched,
OrderStatus.Matched => GrpcContract.Common.OrderStatus.Matched,
OrderStatus.Pending => GrpcContract.Common.OrderStatus.Pending,
OrderStatus.Cancelled => GrpcContract.Common.OrderStatus.Cancelled,
OrderStatus.Replaced => GrpcContract.Common.OrderStatus.Replaced,
OrderStatus.Rejected => GrpcContract.Common.OrderStatus.Rejected,
_ => throw new ArgumentOutOfRangeException(nameof(orderEvent.Status), orderEvent.Status, null)
},
Volume = orderEvent.Volume
};
break;
}
