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); }