public static Position FromHistory(this IPositionHistory positionHistory)
{
return(new Position(
id: positionHistory.Id,
code: positionHistory.Code,
assetPairId: positionHistory.AssetPairId,
volume: positionHistory.Volume,
accountId: positionHistory.AccountId,
tradingConditionId: positionHistory.TradingConditionId,
accountAssetId: positionHistory.AccountAssetId,
expectedOpenPrice: positionHistory.ExpectedOpenPrice,
openMatchingEngineId: positionHistory.OpenMatchingEngineId,
openDate: positionHistory.OpenDate,
openTradeId: positionHistory.OpenTradeId,
openOrderType: positionHistory.OpenOrderType,
openOrderVolume: positionHistory.OpenOrderVolume,
openPrice: positionHistory.OpenPrice,
openFxPrice: positionHistory.OpenFxPrice,
equivalentAsset: positionHistory.EquivalentAsset,
openPriceEquivalent: positionHistory.OpenPriceEquivalent,
relatedOrders: positionHistory.RelatedOrders,
legalEntity: positionHistory.LegalEntity,
openOriginator: positionHistory.OpenOriginator,
externalProviderId: positionHistory.ExternalProviderId,
fxAssetPairId: positionHistory.FxAssetPairId,
fxToAssetPairDirection: positionHistory.FxToAssetPairDirection,
additionalInfo: positionHistory.AdditionalInfo
));
}
private Task CommitExceptionHandler(Exception exception, IPositionHistory positionHistory, IDeal deal)
{
var context = $"Error {exception.Message} \n" +
$"Entity <{nameof(IPositionHistory)}>: \n" +
positionHistory.ToJson() + " \n" +
$"Entity <{nameof(IDeal)}>: \n" +
deal?.ToJson();
return(_log.WriteErrorAsync(nameof(PositionsHistorySqlRepository), nameof(AddAsync), context, exception));
}
public async Task AddAsync(IPositionHistory positionHistory, IDeal deal)
{
var entity =
_convertService.Convert <IPositionHistory, PositionHistoryEntity>(positionHistory,
o => o.ConfigureMap(MemberList.Source));
entity.Timestamp = DateTimeOffset.UtcNow;
await _tableStorage.InsertOrReplaceAsync(entity);
}
public static PositionsHistoryEntity Create(IPositionHistory history)
{
return(new PositionsHistoryEntity
{
DealId = history.DealId,
AccountAssetId = history.AccountAssetId,
AccountId = history.AccountId,
AssetPairId = history.AssetPairId,
CloseComment = history.CloseComment,
CloseCommissionRate = history.CloseCommissionRate,
CloseDate = history.CloseDate,
CloseFxPrice = history.CloseFxPrice,
CloseMatchingEngineId = history.CloseMatchingEngineId,
CloseOriginator = history.CloseOriginator?.ToString(),
ClosePrice = history.ClosePrice,
ClosePriceEquivalent = history.ClosePriceEquivalent,
CloseReason = history.CloseReason.ToString(),
CloseTrades = history.CloseTrades.ToJson(),
FxAssetPairId = history.FxAssetPairId,
FxToAssetPairDirection = history.FxToAssetPairDirection.ToString(),
Code = history.Code,
CommissionLot = history.CommissionLot,
Direction = history.Direction.ToString(),
EquivalentAsset = history.EquivalentAsset,
ExpectedOpenPrice = history.ExpectedOpenPrice,
ExternalProviderId = history.ExternalProviderId,
HistoryType = history.HistoryType.ToString(),
Id = history.Id,
LastModified = history.LastModified,
LegalEntity = history.LegalEntity,
OpenCommissionRate = history.OpenCommissionRate,
OpenDate = history.OpenDate,
OpenFxPrice = history.OpenFxPrice,
OpenMatchingEngineId = history.OpenMatchingEngineId,
OpenOriginator = history.OpenOriginator.ToString(),
OpenPrice = history.OpenPrice,
OpenPriceEquivalent = history.OpenPriceEquivalent,
OpenTradeId = history.OpenTradeId,
OpenOrderType = history.OpenOrderType.ToString(),
OpenOrderVolume = history.OpenOrderVolume,
RelatedOrders = history.RelatedOrders.ToJson(),
StartClosingDate = history.CloseDate,
SwapCommissionRate = history.SwapCommissionRate,
TotalPnL = history.TotalPnL,
ChargedPnl = history.ChargedPnl,
AdditionalInfo = history.AdditionalInfo,
TradingConditionId = history.TradingConditionId,
Volume = history.Volume,
HistoryTimestamp = history.HistoryTimestamp,
ForceOpen = history.ForceOpen,
CorrelationId = history.CorrelationId
});
}
private PositionEventContract Convert(IPositionHistory positionHistory)
{
if (positionHistory == null)
{
return(null);
}
return(new PositionEventContract
{
Id = positionHistory.Id,
Code = positionHistory.Code,
AssetPairId = positionHistory.AssetPairId,
Direction = positionHistory.Direction.ToType <PositionDirectionContract>(),
Volume = positionHistory.Volume,
AccountId = positionHistory.AccountId,
TradingConditionId = positionHistory.TradingConditionId,
AccountAssetId = positionHistory.AccountAssetId,
ExpectedOpenPrice = positionHistory.ExpectedOpenPrice,
OpenMatchingEngineId = positionHistory.OpenMatchingEngineId,
OpenDate = positionHistory.OpenDate,
OpenTradeId = positionHistory.OpenTradeId,
OpenPrice = positionHistory.OpenPrice,
OpenFxPrice = positionHistory.OpenFxPrice,
EquivalentAsset = positionHistory.EquivalentAsset,
OpenPriceEquivalent = positionHistory.OpenPriceEquivalent,
RelatedOrders = positionHistory.RelatedOrders.Select(Convert).ToList(),
LegalEntity = positionHistory.LegalEntity,
OpenOriginator = positionHistory.OpenOriginator.ToType <OriginatorTypeContract>(),
ExternalProviderId = positionHistory.ExternalProviderId,
SwapCommissionRate = positionHistory.SwapCommissionRate,
OpenCommissionRate = positionHistory.OpenCommissionRate,
CloseCommissionRate = positionHistory.CloseCommissionRate,
CommissionLot = positionHistory.CommissionLot,
CloseMatchingEngineId = positionHistory.CloseMatchingEngineId,
ClosePrice = positionHistory.ClosePrice,
CloseFxPrice = positionHistory.CloseFxPrice,
ClosePriceEquivalent = positionHistory.ClosePriceEquivalent,
StartClosingDate = positionHistory.StartClosingDate,
CloseDate = positionHistory.CloseDate,
CloseOriginator = positionHistory.CloseOriginator?.ToType <OriginatorTypeContract>(),
CloseReason = positionHistory.CloseReason.ToType <PositionCloseReasonContract>(),
CloseComment = positionHistory.CloseComment,
CloseTrades = positionHistory.CloseTrades,
LastModified = positionHistory.LastModified,
TotalPnL = positionHistory.TotalPnL,
ChargedPnl = positionHistory.ChargedPnl,
HistoryType = positionHistory.HistoryType.ToType <PositionHistoryTypeContract>(),
DealId = positionHistory.DealId,
Timestamp = positionHistory.HistoryTimestamp,
CorrelationId = positionHistory.CorrelationId
});
}
private async Task DoAdd(SqlConnection conn, SqlTransaction transaction, IPositionHistory positionHistory, IDeal deal)
{
var positionEntity = PositionsHistoryEntity.Create(positionHistory);
await conn.ExecuteAsync($"insert into {TableName} ({GetColumns}) values ({GetFields})",
positionEntity,
transaction);
if (deal != null)
{
var entity = DealEntity.Create(deal);
await conn.ExecuteAsync(
$@"INSERT INTO [dbo].[Deals] ({string.Join(",", DealsSqlRepository.DealInsertColumns)}) VALUES (@{string.Join(",@", DealsSqlRepository.DealInsertColumns)})",
new
{
entity.DealId,
entity.Created,
entity.AccountId,
entity.AssetPairId,
entity.OpenTradeId,
entity.OpenOrderType,
entity.OpenOrderVolume,
entity.OpenOrderExpectedPrice,
entity.CloseTradeId,
entity.CloseOrderType,
entity.CloseOrderVolume,
entity.CloseOrderExpectedPrice,
entity.Direction,
entity.Volume,
entity.Originator,
entity.OpenPrice,
entity.OpenFxPrice,
entity.ClosePrice,
entity.CloseFxPrice,
entity.Fpl,
entity.PnlOfTheLastDay,
entity.AdditionalInfo,
entity.CorrelationId
},
transaction);
await conn.ExecuteAsync("INSERT INTO [dbo].[DealCommissionParams] (DealId) VALUES (@DealId)",
new { deal.DealId },
transaction);
}
}
public async Task AddAsync(IPositionHistory positionHistory, IDeal deal)
{
await TransactionWrapperExtensions.RunInTransactionAsync(
(conn, transaction) => DoAdd(conn, transaction, positionHistory, deal),
_connectionString,
RollbackExceptionHandler,
commitException => CommitExceptionHandler(commitException, positionHistory, deal));
if (deal != null)
{
Task.Run(async() =>
{
using (var conn = new SqlConnection(_connectionString))
{
try
{
await conn.ExecuteAsync("[dbo].[UpdateDealCommissionParamsOnDeal]",
new
{
deal.DealId,
deal.OpenTradeId,
deal.OpenOrderVolume,
deal.CloseTradeId,
deal.CloseOrderVolume,
deal.Volume,
},
commandType: CommandType.StoredProcedure);
}
catch (Exception e)
{
await _log.WriteErrorAsync(nameof(PositionsHistorySqlRepository),
nameof(AddAsync),
$"Failed to calculate commissions for the deal {deal.DealId}, skipping.", e);
}
}
});
}
}
/// <summary>
/// Return true if there was difference, false if items were the same.
/// </summary>
public static bool Merge(this Position position, IPositionHistory positionHistory)
{
return(position.SetIfDiffer(new Dictionary <string, object>
{
{ nameof(Position.Volume), positionHistory.Volume },
{ nameof(Position.RelatedOrders), positionHistory.RelatedOrders },
{ nameof(Position.SwapCommissionRate), positionHistory.SwapCommissionRate },
{ nameof(Position.CloseCommissionRate), positionHistory.CloseCommissionRate },
{ nameof(Position.CommissionLot), positionHistory.CommissionLot },
{ nameof(Position.CloseMatchingEngineId), positionHistory.CloseMatchingEngineId },
{ nameof(Position.ClosePrice), positionHistory.ClosePrice },
{ nameof(Position.CloseFxPrice), positionHistory.CloseFxPrice },
{ nameof(Position.ClosePriceEquivalent), positionHistory.ClosePriceEquivalent },
{ nameof(Position.StartClosingDate), positionHistory.StartClosingDate },
{ nameof(Position.CloseDate), positionHistory.CloseDate },
{ nameof(Position.CloseOriginator), positionHistory.CloseOriginator },
{ nameof(Position.CloseReason), positionHistory.CloseReason },
{ nameof(Position.CloseComment), positionHistory.CloseComment },
{ nameof(Position.CloseTrades), positionHistory.CloseTrades },
{ nameof(Position.LastModified), positionHistory.LastModified },
{ nameof(Position.ChargedPnL), positionHistory.ChargedPnl },
{ nameof(Position.AdditionalInfo), positionHistory.AdditionalInfo },
}));
}
/// <summary>
/// 构造函数，测试
/// </summary>
public GetEmployeeStatistics(IVacation iVacation, IPositionHistory iPositionHistory)
{
_DalVacation = iVacation;
_DalPositionHistory = iPositionHistory;
}
