public Task AddAsync(IOrderHistory order)
{
var entity = MarginTradingOrderHistoryEntity.Create(order);
// ReSharper disable once RedundantArgumentDefaultValue
return(_tableStorage.InsertAndGenerateRowKeyAsDateTimeAsync(entity, entity.CloseDate ?? entity.OpenDate ?? entity.CreateDate, RowKeyDateTimeFormat.Iso));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[Inject] IAggregateRepository repository,
[Inject] IOrderHistory orderHistory,
[Inject] ICustomerHistory customerHistory)
{
var dict = req.GetQueryParameterDictionary();
var validator = new PlaceOrderValidator();
var result = await validator.Validate(
GetValueOrDefault("OrderNumber", dict),
GetValueOrDefault("CustomerId", dict),
orderHistory,
customerHistory);
if (!result.HasPassed)
{
return(new BadRequestObjectResult(result.Errors));
}
var order = new Order();
order.Place(validator.CustomerId, validator.OrderNumber);
await repository.Save(order);
return(new OkObjectResult("Thanks for placing an order"));
}
/// <summary>
/// Return true if there was difference, false if items were the same.
/// </summary>
public static bool Merge(this Order order, IOrderHistory orderHistory)
{
return(order.SetIfDiffer(new Dictionary <string, object>
{
{ nameof(Order.Volume), orderHistory.Volume },
{ nameof(Order.Status), orderHistory.Status },
{ nameof(Order.ParentOrderId), orderHistory.ParentOrderId },
{ nameof(Order.ParentPositionId), orderHistory.PositionId },
{ nameof(Order.ExecutionPrice), orderHistory.ExecutionPrice },
{ nameof(Order.FxRate), orderHistory.FxRate },
{ nameof(Order.Validity), orderHistory.ValidityTime },
{ nameof(Order.LastModified), orderHistory.ModifiedTimestamp },
{ nameof(Order.Activated), orderHistory.ActivatedTimestamp },
{ nameof(Order.ExecutionStarted), orderHistory.ExecutionStartedTimestamp },
{ nameof(Order.Executed), orderHistory.ExecutedTimestamp },
{ nameof(Order.Canceled), orderHistory.CanceledTimestamp },
{ nameof(Order.Rejected), orderHistory.Rejected },
{ nameof(Order.EquivalentRate), orderHistory.EquivalentRate },
{ nameof(Order.RejectReason), orderHistory.RejectReason },
{ nameof(Order.RejectReasonText), orderHistory.RejectReasonText },
{ nameof(Order.ExternalOrderId), orderHistory.ExternalOrderId },
{ nameof(Order.ExternalProviderId), orderHistory.ExternalProviderId },
{ nameof(Order.MatchingEngineId), orderHistory.MatchingEngineId },
{ nameof(Order.MatchedOrders), orderHistory.MatchedOrders },
{ nameof(Order.RelatedOrders), orderHistory.RelatedOrderInfos },
{ nameof(Order.AdditionalInfo), orderHistory.AdditionalInfo },
{ nameof(Order.PendingOrderRetriesCount), orderHistory.PendingOrderRetriesCount },
}));
}
public static OrderHistoryContract ToBackendHistoryOpenedContract(this IOrderHistory src)
{
return(new OrderHistoryContract
{
Id = src.Id,
AccountId = src.AccountId,
Instrument = src.Instrument,
AssetAccuracy = src.AssetAccuracy,
Type = src.Type.ToType <OrderDirectionContract>(),
Status = OrderStatusContract.Active,
CloseReason = src.CloseReason.ToType <OrderCloseReasonContract>(),
OpenDate = src.OpenDate,
CloseDate = null,
OpenPrice = src.OpenPrice,
ClosePrice = src.ClosePrice,
Volume = src.Volume,
TakeProfit = src.TakeProfit,
StopLoss = src.StopLoss,
TotalPnl = src.PnL,
Pnl = src.Fpl,
InterestRateSwap = src.InterestRateSwap,
CommissionLot = src.CommissionLot,
OpenCommission = src.OpenCommission,
CloseCommission = src.CloseCommission,
EquivalentAsset = src.EquivalentAsset,
OpenPriceEquivalent = src.OpenPriceEquivalent,
ClosePriceEquivalent = src.ClosePriceEquivalent,
OpenExternalOrderId = src.OpenExternalOrderId,
OpenExternalProviderId = src.OpenExternalProviderId,
CloseExternalOrderId = src.CloseExternalOrderId,
CloseExternalProviderId = src.CloseExternalProviderId,
MatchingEngineMode = src.MatchingEngineMode.ToType <MatchingEngineModeContract>()
});
}
public Task AddAsync(IOrderHistory order, ITrade trade)
{
return(TransactionWrapperExtensions.RunInTransactionAsync(
(conn, transaction) => DoAdd(conn, transaction, order, trade),
_connectionString,
RollbackExceptionHandler,
commitException => CommitExceptionHandler(commitException, order, trade)));
}
public Task AddAsync(IOrderHistory order, ITrade trade)
{
var entity = OrderHistoryEntity.Create(order);
// ReSharper disable once RedundantArgumentDefaultValue
//TODO: use event datetime
return(_tableStorage.InsertAndGenerateRowKeyAsDateTimeAsync(entity,
DateTime.UtcNow, RowKeyDateTimeFormat.Iso));
}
public static MarginTradingOrderRejectedEntity Create(IOrderHistory src)
{
return(new MarginTradingOrderRejectedEntity
{
PartitionKey = GeneratePartitionKey(src.ClientId),
RowKey = GenerateRowKey(src.Id),
Id = src.Id,
ClientId = src.ClientId,
AccountId = src.AccountId,
TradingConditionId = src.TradingConditionId,
AccountAssetId = src.AccountAssetId,
Instrument = src.Instrument,
Type = src.Type.ToString(),
CreateDate = src.CreateDate,
OpenDate = src.OpenDate,
CloseDate = src.CloseDate,
ExpectedOpenPrice = (double?)src.ExpectedOpenPrice,
OpenPrice = (double)src.OpenPrice,
OpenCrossPrice = (double)src.OpenCrossPrice,
ClosePrice = (double)src.ClosePrice,
CloseCrossPrice = (double)src.CloseCrossPrice,
TakeProfit = (double?)src.TakeProfit,
StopLoss = (double?)src.StopLoss,
Fpl = (double)src.Fpl,
PnL = (double)src.PnL,
InterestRateSwap = (double)src.InterestRateSwap,
CommissionLot = (double)src.CommissionLot,
OpenCommission = (double)src.OpenCommission,
CloseCommission = (double)src.CloseCommission,
QuoteRate = (double)src.QuoteRate,
AssetAccuracy = src.AssetAccuracy,
MarginInit = (double)src.MarginInit,
MarginMaintenance = (double)src.MarginMaintenance,
StartClosingDate = src.StartClosingDate,
Status = src.Status.ToString(),
CloseReason = src.CloseReason.ToString(),
FillType = src.FillType.ToString(),
Volume = (double)src.Volume,
MatchedVolume = (double)src.MatchedVolume,
MatchedCloseVolume = (double)src.MatchedCloseVolume,
RejectReason = src.RejectReason.ToString(),
RejectReasonText = src.RejectReasonText,
Orders = src.MatchedOrders.SerializeArrayForTableStorage(),
ClosedOrders = src.MatchedCloseOrders.SerializeArrayForTableStorage(),
SwapCommission = (double)src.SwapCommission,
EquivalentAsset = src.EquivalentAsset,
OpenPriceEquivalent = (double)src.OpenPriceEquivalent,
ClosePriceEquivalent = (double)src.ClosePriceEquivalent,
Comment = src.Comment,
OrderUpdateType = src.OrderUpdateType.ToString(),
OpenExternalOrderId = src.OpenExternalOrderId,
OpenExternalProviderId = src.OpenExternalProviderId,
CloseExternalOrderId = src.CloseExternalOrderId,
CloseExternalProviderId = src.CloseExternalProviderId,
MatchingEngineMode = src.MatchingEngineMode.ToString()
});
}
private Task CommitExceptionHandler(Exception exception, IOrderHistory order, ITrade trade)
{
var context = $"Error {exception.Message} \n" +
$"Entity <{nameof(IOrderHistory)}>: \n" +
order.ToJson() + " \n" +
$"Entity <{nameof(ITrade)}>: \n" +
trade?.ToJson();
return(_log.WriteErrorAsync(nameof(OrdersHistorySqlRepository), nameof(AddAsync), context, exception));
}
public static OrderHistoryEntity Create(IOrderHistory order)
{
return(new OrderHistoryEntity
{
Id = order.Id,
AccountId = order.AccountId,
AssetPairId = order.AssetPairId,
CreatedTimestamp = order.CreatedTimestamp,
Direction = order.Direction.ToString(),
ExecutionPrice = order.ExecutionPrice,
FxRate = order.FxRate,
FxAssetPairId = order.FxAssetPairId,
FxToAssetPairDirection = order.FxToAssetPairDirection.ToString(),
ExpectedOpenPrice = order.ExpectedOpenPrice,
ForceOpen = order.ForceOpen,
ModifiedTimestamp = order.ModifiedTimestamp,
Originator = order.Originator.ToString(),
CancellationOriginator = order.CancellationOriginator?.ToString(),
ParentOrderId = order.ParentOrderId,
PositionId = order.PositionId,
Status = order.Status.ToString(),
FillType = order.FillType.ToString(),
Type = order.Type.ToString(),
ValidityTime = order.ValidityTime,
Volume = order.Volume,
//------
AccountAssetId = order.AccountAssetId,
EquivalentAsset = order.EquivalentAsset,
ActivatedTimestamp = order.ActivatedTimestamp,
CanceledTimestamp = order.CanceledTimestamp,
Code = order.Code,
Comment = order.Comment,
EquivalentRate = order.EquivalentRate,
ExecutedTimestamp = order.ExecutedTimestamp,
ExecutionStartedTimestamp = order.ExecutionStartedTimestamp,
ExternalOrderId = order.ExternalOrderId,
ExternalProviderId = order.ExternalProviderId,
LegalEntity = order.LegalEntity,
MatchingEngineId = order.MatchingEngineId,
Rejected = order.Rejected,
RejectReason = order.RejectReason.ToString(),
RejectReasonText = order.RejectReasonText,
RelatedOrderInfos = order.RelatedOrderInfos.ToJson(),
TradingConditionId = order.TradingConditionId,
MatchedOrders = order.MatchedOrders.ToJson(),
UpdateType = order.UpdateType.ToString(),
AdditionalInfo = order.AdditionalInfo,
CorrelationId = order.CorrelationId,
PendingOrderRetriesCount = order.PendingOrderRetriesCount,
});
}
public static OrderHistory Create(IOrderHistory orderHistory)
{
return(new OrderHistory
{
Id = orderHistory.Id,
AccountId = orderHistory.AccountId,
AssetPairId = orderHistory.AssetPairId,
ParentOrderId = orderHistory.ParentOrderId,
PositionId = orderHistory.PositionId,
Direction = orderHistory.Direction,
Type = orderHistory.Type,
Status = orderHistory.Status,
FillType = orderHistory.FillType,
Originator = orderHistory.Originator,
CancellationOriginator = orderHistory.CancellationOriginator,
Volume = orderHistory.Volume,
ExpectedOpenPrice = orderHistory.ExpectedOpenPrice,
ExecutionPrice = orderHistory.ExecutionPrice,
FxRate = orderHistory.FxRate,
FxAssetPairId = orderHistory.FxAssetPairId,
FxToAssetPairDirection = orderHistory.FxToAssetPairDirection,
ForceOpen = orderHistory.ForceOpen,
ValidityTime = orderHistory.ValidityTime,
CreatedTimestamp = orderHistory.CreatedTimestamp,
ModifiedTimestamp = orderHistory.ModifiedTimestamp,
Code = orderHistory.Code,
ActivatedTimestamp = orderHistory.ActivatedTimestamp,
ExecutionStartedTimestamp = orderHistory.ExecutionStartedTimestamp,
ExecutedTimestamp = orderHistory.ExecutedTimestamp,
CanceledTimestamp = orderHistory.CanceledTimestamp,
Rejected = orderHistory.Rejected,
TradingConditionId = orderHistory.TradingConditionId,
AccountAssetId = orderHistory.AccountAssetId,
EquivalentAsset = orderHistory.EquivalentAsset,
EquivalentRate = orderHistory.EquivalentRate,
RejectReason = orderHistory.RejectReason,
RejectReasonText = orderHistory.RejectReasonText,
Comment = orderHistory.Comment,
ExternalOrderId = orderHistory.ExternalOrderId,
ExternalProviderId = orderHistory.ExternalProviderId,
MatchingEngineId = orderHistory.MatchingEngineId,
LegalEntity = orderHistory.LegalEntity,
MatchedOrders = orderHistory.MatchedOrders,
RelatedOrderInfos = orderHistory.RelatedOrderInfos,
UpdateType = orderHistory.UpdateType,
AdditionalInfo = orderHistory.AdditionalInfo,
CorrelationId = orderHistory.CorrelationId,
PendingOrderRetriesCount = orderHistory.PendingOrderRetriesCount,
});
}
private async Task DoAdd(SqlConnection conn, SqlTransaction transaction, IOrderHistory order, ITrade trade)
{
var orderHistoryEntity = OrderHistoryEntity.Create(order);
await conn.ExecuteAsync(
$"insert into {TableName} ({GetColumns}) values ({GetFields})",
orderHistoryEntity,
transaction);
if (trade != null)
{
var tradeEntity = TradeEntity.Create(trade);
await conn.ExecuteAsync(
$"insert into {TradesSqlRepository.TableName} ({TradesSqlRepository.GetColumns}) values ({TradesSqlRepository.GetFields})",
tradeEntity,
transaction);
}
}
public async Task <ValidationResult> Validate(
string rawOrderNumber,
string rawCustomerId,
IOrderHistory orderHistory,
ICustomerHistory customerHistory)
{
var errors = new List <string>();
this.ValidateArguments(rawOrderNumber, rawCustomerId, errors);
await this.ValidateBusinessRules(orderHistory, customerHistory, errors);
if (errors.Any())
{
return(ValidationResult.Fails(errors));
}
return(ValidationResult.Pass());
}
private async Task ValidateBusinessRules(IOrderHistory orderHistory, ICustomerHistory customerHistory, List <string> errors)
{
if (this.OrderNumber != null)
{
if (await orderHistory.OrderExists(this.OrderNumber))
{
errors.Add($"Order # {this.OrderNumber.Value} already exists");
}
}
if (this.CustomerId != null)
{
if (await customerHistory.HasPlacedRecentOrder(this.CustomerId))
{
errors.Add($"Customer # {this.CustomerId.Value} already has an order in progress");
}
}
}
public async Task AddAsync(IOrderHistory order)
{
using (var conn = new SqlConnection(_settings.Db.ReportsSqlConnString))
{
var query = $"insert into {TableName} " +
@"(Id, Code, ClientId, TradingConditionId, AccountAssetId, Instrument, Type, CreateDate, OpenDate,
CloseDate, ExpectedOpenPrice, OpenPrice, ClosePrice, QuoteRate, Volume, TakeProfit,
StopLoss, CommissionLot, OpenCommission, CloseCommission, SwapCommission, StartClosingDate,
Status, CloseReason, FillType, RejectReason, RejectReasonText, Comment, MatchedVolume,
MatchedCloseVolume, Fpl, PnL, InterestRateSwap, MarginInit, MarginMaintenance,
OrderUpdateType, OpenExternalOrderId, OpenExternalProviderId, CloseExternalOrderId,
CloseExternalProviderId, MatchingEngineMode, LegalEntity)
values
(@Id, @Code, @ClientId, @TradingConditionId, @AccountAssetId, @Instrument, @Type, @CreateDate, @OpenDate,
@CloseDate, @ExpectedOpenPrice, @OpenPrice, @ClosePrice, @QuoteRate, @Volume, @TakeProfit,
@StopLoss, @CommissionLot, @OpenCommission, @CloseCommission, @SwapCommission, @StartClosingDate,
@Status, @CloseReason, @FillType, @RejectReason, @RejectReasonText, @Comment, @MatchedVolume,
@MatchedCloseVolume, @Fpl, @PnL, @InterestRateSwap, @MarginInit, @MarginMaintenance,
@OrderUpdateType, @OpenExternalOrderId, @OpenExternalProviderId, @CloseExternalOrderId,
@CloseExternalProviderId, @MatchingEngineMode, @LegalEntity)";
try
{
var entity = MarginTradingOrderHistoryEntity.Create(order);
await conn.ExecuteAsync(query, entity);
}
catch (Exception ex)
{
var msg = $"Error {ex.Message} \n" +
"Entity <IOrderHistory>: \n" +
order.ToJson();
_log?.WriteWarning("AccountTransactionsReportsSqlRepository", "InsertOrReplaceAsync", msg);
throw new Exception(msg);
}
}
}
public static Order FromHistory(this IOrderHistory orderHistory)
{
return(new Order(
id: orderHistory.Id,
code: orderHistory.Code,
assetPairId: orderHistory.AssetPairId,
volume: orderHistory.Volume,
created: orderHistory.CreatedTimestamp,
lastModified: orderHistory.ModifiedTimestamp,
validity: orderHistory.ValidityTime,
accountId: orderHistory.AccountId,
tradingConditionId: orderHistory.TradingConditionId,
accountAssetId: orderHistory.AccountAssetId,
price: orderHistory.ExpectedOpenPrice,
equivalentAsset: orderHistory.EquivalentAsset,
fillType: orderHistory.FillType,
comment: orderHistory.Comment,
legalEntity: orderHistory.LegalEntity,
forceOpen: orderHistory.ForceOpen,
orderType: orderHistory.Type,
parentOrderId: orderHistory.ParentOrderId,
parentPositionId: orderHistory.PositionId,
originator: orderHistory.Originator,
equivalentRate: orderHistory.EquivalentRate,
fxRate: orderHistory.FxRate,
fxAssetPairId: orderHistory.FxAssetPairId,
fxToAssetPairDirection: orderHistory.FxToAssetPairDirection,
status: orderHistory.Status,
additionalInfo: orderHistory.AdditionalInfo,
correlationId: orderHistory.CorrelationId,
positionsToBeClosed: string.IsNullOrWhiteSpace(orderHistory.PositionId)
? new List <string>()
: new List <string> {
orderHistory.PositionId
},
externalProviderId: orderHistory.ExternalProviderId
));
}
public OrderHistoryController()
{
_orderHistory = new DataLayer.dbOrderHistory();
}
private static OrderInfo Map(IOrderHistory order)
{
var status = order.Status == OrderStatus.Placed ? OrderStatus.Inactive : order.Status;
return(new OrderInfo(order.Id, order.Volume, order.ExpectedOpenPrice, status, order.Type));
}
static OrderHistoryBUS()
{
orderHis = new OrderHistory_Act();
}
public async Task AddAsync(IOrderHistory order)
{
var entity = MarginTradingOrderRejectedEntity.Create(order);
await _tableStorage.InsertOrReplaceAsync(entity);
}
