private void GetOrder(int order_key)
{
ExecuteFaultHandledOperation(() =>
{
IOrderService order_service = service_factory.CreateClient <IOrderService>();
using (order_service)
{
Order = new OrderWrapper(order_service.GetOrder(order_key));
AccountContacts = new ObservableCollection <AccountPerson>(Order.Account.Model.Employees.Where(item =>
item.CompanyRoleType == QIQOPersonType.AccountContact).ToList());
Order.PropertyChanged += Context_PropertyChanged;
Order.AcceptChanges();
_currentAccount = Order.Account.Model;
}
DefaultBillingAddress = Order.OrderItems[0].OrderItemBillToAddress;
DefaultShippingAddress = Order.OrderItems[0].OrderItemShipToAddress;
ViewTitle = Order.OrderNumber;
GridIsEnabled = Order.OrderStatus != QIQOOrderStatus.Complete ? true : false;
//AccountContacts = new ObservableCollection<AccountPerson>(Order.Account.Model.Employees.Where(item =>
// item.CompanyRoleType == QIQOPersonType.AccountContact).ToList());
event_aggregator.GetEvent <GeneralMessageEvent>().Publish($"Order {Order.OrderNumber} loaded successfully");
event_aggregator.GetEvent <OrderLoadedEvent>().Publish(Order.OrderNumber);
});
}
public InterpreterTests()
{
var container = new UnityContainer();
//container.RegisterType<IExpression<string, object>, IndexExpression>();
_contextMock = new Mock <IContext>();
_contextMock.Setup(o => o.Input).Returns("[%o_number%] [%c_firstName%] [%c_lastName%]");
var context = new Context("[%o_number%] [%c_firstName%] [%c_lastName%] [%h_SerialNumber%]");
var contextInput = "Numer zlecenia [%numer%], Data: [%data%] ";
_context2 = new Context(contextInput);
var orderModel = new CustomerWrapper(new Customer()
{
Id = Guid.NewGuid(), FirstName = "Jan", LastName = "Nowak"
});
var customerModel = new OrderWrapper(new Order()
{
Id = Guid.NewGuid(), Number = "01/092019"
});
var hardwareModel = new HardwareWrapper(new Hardware()
{
Id = Guid.NewGuid(), SerialNumber = "12332151HD"
});
//_interpreter = new Interpreter(context, Expression.IndexExpression, orderModel, customerModel, hardwareModel);
}
private void SendNewOrderRequest(Orders order)
{
var orderWrapper = new OrderWrapper();
orderWrapper.Order = new Order();
orderWrapper.Order.OrderId = order.Id;
orderWrapper.Order.IsBuy = order.Side;
orderWrapper.Order.Price = order.Rate;
orderWrapper.Order.OpenQuantity = order.QuantityRemaining;
orderWrapper.Order.IsStop = order.StopRate != 0;
orderWrapper.OrderCondition = (OrderCondition)((byte)order.OrderCondition);
orderWrapper.StopPrice = order.StopRate;
orderWrapper.TipQuantity = order.IcebergQuantity > 0 ? order.Quantity : 0;
orderWrapper.TotalQuantity = order.IcebergQuantity ?? 0;
if (order.CancelOn.HasValue)
{
DateTime Jan1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
orderWrapper.Order.CancelOn = (int)order.CancelOn.Value.Subtract(Jan1970).TotalSeconds;
}
var bytes = OrderSerializer.Serialize(orderWrapper);
_queueProducer.Produce(bytes);
}
private OrderlineUniter UniteOrderlines(List <OrderLine> unSortedOrderlines)
{
OrderlineUniter uniter = new OrderlineUniter();
foreach (OrderLine orderLine in unSortedOrderlines)
{
OrderWrapper key = uniter.QuantityPerProduct.FirstOrDefault(x => x.ProdV.Id == orderLine.ProductVersion.Id);
if (key != null && key.OrderedUnit == orderLine.Unit)
{
//The orderline already exists in the list, so we simply add the quantity of the current orderline.
key.Quantity += orderLine.Quantity;
}
else
{
//The orderlines does not exsist, so we add a new one to the list.
uniter.QuantityPerProduct.Add(new OrderWrapper(orderLine.Quantity, orderLine.Unit, orderLine.ProductVersion));
}
}
//Sorts the orderlines by name. Orderlines with the same name but different units will be two different entries, but grouped together.
uniter.Sort();
return(uniter);
}
public void Deserialize_Doesnotthrowexception()
{
var order1 = new Order {
CancelOn = 12345678, IsBuy = true, OrderId = 56789, Price = 404, FeeId = 69
};
var orderWrapper = new OrderWrapper()
{
StopPrice = 9534, TotalQuantity = 7878234, TipQuantity = 2356, OrderCondition = OrderCondition.ImmediateOrCancel, OrderAmount = 12345.6789m, Order = order1
};
var bytes = OrderSerializer.Serialize(orderWrapper);
var messageLength = BitConverter.ToInt32(bytes, 0);
Assert.Equal(99, messageLength);
var order = OrderSerializer.Deserialize(bytes);
Assert.Equal(12345678, order.Order.CancelOn);
Assert.True(order.Order.IsBuy);
Assert.Equal(OrderCondition.ImmediateOrCancel, order.OrderCondition);
Assert.Equal((OrderId)56789, order.Order.OrderId);
Assert.Equal(404, order.Order.Price);
Assert.Equal(2356, order.TipQuantity);
Assert.True(order.Order.IsStop);
Assert.Equal(9534, order.StopPrice);
Assert.Equal(7878234, order.TotalQuantity);
Assert.Equal((Quantity)12345.6789m, order.OrderAmount);
Assert.Equal(69, order.Order.FeeId);
}
public async Task <OpenOrderResult> PlaceOpeningOrder(TradeDetail trade, IEnumerable <TradeDetail> relatedTrades)
{
var market = trade.Match.BetfairData.Markets.Single(x => x.MarketName == trade.MarketName);
var runnerId = market.Runners.Single(x => x.Name == trade.RunnerName).Id;
var latestRunnerBook = await _runnerService.GetRunnerDetails(market.MarketId, runnerId);
var orderTick = _orderPriceFinder.GetPrice(trade.Side, latestRunnerBook.ExchangePrices);
var openingOrderWrapper = new OrderWrapper(market.MarketId, runnerId, trade.Side, orderTick, PersistenceType.LAPSE);
var policy = Policy.Handle <MarketSuspendedException>().Or <OrderActionErrorException>().Or <OrderNotPlaceableException>().WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt * 4)));
var betReport = await policy.Execute(() => _orderPlacer.PlaceOrder(openingOrderWrapper));
var betId = betReport.InstructionReports.Single().BetId;
openingOrderWrapper.AddBetId(betId);
_sleepService.Sleep(5000);
var matchReport = await _runnerService.GetRunnerDetails(market.MarketId, runnerId);
var orderReport = matchReport.Orders.Where(x => x.BetId == betId).Sum(x => x.SizeRemaining);
if (orderReport != 0)
{
var cancelReport = await _orderPlacer.CancelOrder(betId, market.MarketId);
if (cancelReport.Status == ExecutionReportStatus.SUCCESS)
{
throw new OrderCancelledException(betId);
}
}
return(new OpenOrderResult(trade, openingOrderWrapper));
}
public IActionResult AddOrder(OrderWrapper fromForm)
{
if (ModelState.IsValid)
{
Product Product = dbContext.Products
.FirstOrDefault(p => p.ProductId == fromForm.Order.ProductId);
Product.QuantityInStore = (Product.QuantityInStore - fromForm.Order.OrderQuantity);
dbContext.Update(Product);
dbContext.Entry(Product).Property("CreatedAt").IsModified = false;
dbContext.SaveChanges();
dbContext.Add(fromForm.Order);
dbContext.SaveChanges();
return(RedirectToAction("Orders"));
}
else
{
OrderWrapper OrderWrapper = new OrderWrapper();
OrderWrapper.AllCustomers = dbContext.Customers.ToList();
OrderWrapper.AllProducts = dbContext.Products.ToList();
OrderWrapper.AllOrders = dbContext.Orders
.Include(o => o.Product)
.Include(o => o.Customer)
.ToList();
return(View("Orders", OrderWrapper));
}
}
private OrderList SeparateOrders(OrderBase[] orders)
{
var result = new OrderList(_assetPairsCachedReader);
foreach (var orderBase in orders)
{
var marketOrder = orderBase as MarketOrder;
if (marketOrder != null)
{
result.MarketOrders.Add(marketOrder);
}
var limitOrder = orderBase as LimitOrder;
if (limitOrder != null)
{
if (limitOrder.Action == OrderAction.Buy)
{
result.LimitOrdersBuy.Add(OrderWrapper.Create(limitOrder));
}
if (limitOrder.Action == OrderAction.Sell)
{
result.LimitOrdersSell.Add(OrderWrapper.Create(limitOrder));
}
}
}
result.MarketOrders = result.MarketOrders.OrderBy(itm => itm.Id).ToList();
result.LimitOrdersBuy = result.LimitOrdersBuy.OrderByDescending(itm => itm.Order.Price).ToList();
result.LimitOrdersSell = result.LimitOrdersSell.OrderBy(itm => itm.Order.Price).ToList();
return(result);
}
public OrderNotification(OrderWrapper<Notification> notificationInfo)
{
Id = notificationInfo.Order.Id;
Status = notificationInfo.Order.Status;
Description = notificationInfo.Order.Description;
Warnings = notificationInfo.Warnings;
}
public void Deserialize_Doesnotthrowexception_Min()
{
var order1 = new Order {
CancelOn = int.MinValue, IsBuy = false, OrderId = OrderId.MinValue, Price = int.MinValue, FeeId = short.MinValue
};
var orderWrapper = new OrderWrapper()
{
StopPrice = int.MinValue, TotalQuantity = int.MinValue, TipQuantity = int.MinValue, OrderCondition = OrderCondition.None, OrderAmount = Quantity.MinValue, Order = order1
};
var bytes = OrderSerializer.Serialize(orderWrapper);
var messageLength = BitConverter.ToInt32(bytes, 0);
Assert.Equal(99, messageLength);
var order = OrderSerializer.Deserialize(bytes);
Assert.Equal(int.MinValue, order.Order.CancelOn);
Assert.False(order.Order.IsBuy);
Assert.Equal(OrderCondition.None, order.OrderCondition);
Assert.Equal(OrderId.MinValue, order.Order.OrderId);
Assert.Equal(int.MinValue, order.Order.Price);
Assert.Equal(0, order.TipQuantity);
Assert.False(order.Order.IsStop);
Assert.Equal(int.MinValue, order.StopPrice);
Assert.Equal(int.MinValue, order.TotalQuantity);
Assert.Equal(Quantity.MinValue, order.OrderAmount);
Assert.Equal(short.MinValue, order.Order.FeeId);
}
public void Deserialize_Doesnotthrowexception_Max()
{
var order1 = new Order {
CancelOn = int.MaxValue, IsBuy = true, OrderId = OrderId.MaxValue, Price = int.MaxValue, OrderAmount = decimal.MaxValue
};
var orderWrapper = new OrderWrapper()
{
StopPrice = int.MaxValue, TotalQuantity = int.MaxValue, TipQuantity = int.MaxValue, OrderCondition = OrderCondition.FillOrKill, Order = order1
};
var bytes = OrderSerializer.Serialize(orderWrapper);
var messageLength = BitConverter.ToInt32(bytes, 0);
Assert.Equal(97, messageLength);
var order = OrderSerializer.Deserialize(bytes);
Assert.Equal(int.MaxValue, order.Order.CancelOn);
Assert.True(order.Order.IsBuy);
Assert.Equal(OrderCondition.FillOrKill, order.OrderCondition);
Assert.Equal(OrderId.MaxValue, order.Order.OrderId);
Assert.Equal((Price)int.MaxValue, order.Order.Price);
Assert.Equal((Quantity)int.MaxValue, order.TipQuantity);
Assert.True(order.Order.IsStop);
Assert.Equal((Price)int.MaxValue, order.StopPrice);
Assert.Equal((Quantity)int.MaxValue, order.TotalQuantity);
Assert.Equal((Quantity)decimal.MaxValue, order.Order.OrderAmount);
}
public async void PostTitleOrderAsync_Processing_Timeout()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = Options.Create(new LtsaOptions());
var service = helper.Create <LtsaService>(options, user);
var token = new TokenModel()
{
AccessToken = "test"
};
var response = new OrderWrapper <OrderParent <Title> >(new TitleOrder()
{
Status = OrderParent <Title> .StatusEnum.Processing, OrderId = "1"
});
var client = helper.GetService <Mock <IHttpRequestClient> >();
client.Setup(m => m.PostJsonAsync(It.IsAny <string>(), It.IsAny <IntegratorCredentials>())).ReturnsAsync <IHttpRequestClient, HttpResponseMessage>(new HttpResponseMessage()
{
Content = new StringContent(accessTokenResponse)
});
client.Setup(m => m.SendJsonAsync <OrderWrapper <OrderParent <Title> >, OrderWrapper <TitleOrder> >(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <OrderWrapper <TitleOrder> >(), It.IsAny <Func <HttpResponseMessage, bool> >())).ReturnsAsync(response);
client.Setup(m => m.SendAsync <OrderWrapper <OrderParent <Title> > >(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <HttpContent>(), It.IsAny <Func <HttpResponseMessage, bool> >())).ReturnsAsync(response);
// Act
await Assert.ThrowsAsync <LtsaException>(async() => await service.PostTitleOrder("titleNumber", "VA"));
// Assert
client.Verify(m => m.SendJsonAsync <OrderWrapper <OrderParent <Title> >, OrderWrapper <TitleOrder> >(options.Value.HostUri.AppendToURL(options.Value.OrdersEndpoint), HttpMethod.Post,
It.IsAny <OrderWrapper <TitleOrder> >(), null), Times.Once());
client.Verify(m => m.SendAsync <OrderWrapper <OrderParent <Title> > >(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <HttpContent>(), It.IsAny <Func <HttpResponseMessage, bool> >()), Times.AtLeastOnce());
}
public async void PostSpcpOrderAsync_Valid()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = Options.Create(new LtsaOptions());
var service = helper.Create <LtsaService>(options, user);
var token = new TokenModel()
{
AccessToken = "test"
};
var response = new OrderWrapper <OrderParent <StrataPlanCommonProperty> >(new SpcpOrder());
var client = helper.GetService <Mock <IHttpRequestClient> >();
client.Setup(m => m.PostJsonAsync(It.IsAny <string>(), It.IsAny <IntegratorCredentials>())).ReturnsAsync <IHttpRequestClient, HttpResponseMessage>(new HttpResponseMessage()
{
Content = new StringContent(accessTokenResponse)
});
client.Setup(m => m.SendJsonAsync <OrderWrapper <OrderParent <StrataPlanCommonProperty> >, OrderWrapper <SpcpOrder> >(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <OrderWrapper <SpcpOrder> >(), It.IsAny <Func <HttpResponseMessage, bool> >())).ReturnsAsync(response);
// Act
var result = await service.PostSpcpOrder("123-456-789");
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <OrderWrapper <OrderParent <StrataPlanCommonProperty> > >(result);
client.Verify(m => m.SendJsonAsync <OrderWrapper <OrderParent <StrataPlanCommonProperty> >, OrderWrapper <SpcpOrder> >(options.Value.HostUri.AppendToURL(options.Value.OrdersEndpoint), HttpMethod.Post,
It.IsAny <OrderWrapper <SpcpOrder> >(), null), Times.Once());
result.Order.Should().Be(response.Order);
}
private void InitializeOrder(Order order)
{
Order = new OrderWrapper(order);
Order.PropertyChanged += (s, e) =>
{
if (!HasChanges)
{
HasChanges = _orderRepository.HasChanges();
}
if (e.PropertyName == nameof(Order.HasErrors))
{
((DelegateCommand)SaveCommand).RaiseCanExecuteChanged();
}
if (e.PropertyName == nameof(Order.OrderNumber) ||
e.PropertyName == nameof(Order.OrderDate))
{
SetTitle();
}
};
((DelegateCommand)SaveCommand).RaiseCanExecuteChanged();
if (Order.Id == 0)
{
// little trick to trigger the validation
Order.OrderDate = DateTime.Now.Date;
}
SetTitle();
}
public override async void OnNavigatedTo(NavigationContext navigationContext)
{
base.OnNavigatedTo(navigationContext);
if (navigationContext.Parameters.ContainsKey("CustomerId"))
{
//Order is a new order
SetBusy("OrderLoad", true);
var customerId = navigationContext.Parameters.GetValue <Guid>("CustomerId");
await DispatcherHelper.ExecuteOnUIThreadAsync(
async() =>
{
var customer = await _contosoRepository.Customers.GetAsync(customerId);
Order = new OrderWrapper(_contosoRepository, new Order(customer));
});
SetBusy("OrderLoad", false);
}
if (navigationContext.Parameters.ContainsKey("OrderId"))
{
//Order is an existing order
SetBusy("OrderLoad", true);
var orderId = navigationContext.Parameters.GetValue <Guid>("OrderId");
await DispatcherHelper.ExecuteOnUIThreadAsync(
async() =>
{
var order = await _contosoRepository.Orders.GetAsync(orderId);
Order = new OrderWrapper(_contosoRepository, order);
});
SetBusy("OrderLoad", false);
}
}
internal OrderNotification(OrderWrapper <Notification> notificationInfo)
{
Id = notificationInfo.Order.Id;
Status = notificationInfo.Order.Status;
Description = notificationInfo.Order.Description;
Custom = notificationInfo.Order.Custom;
Warnings = notificationInfo.Warnings;
}
static void Main(string[] args)
{
try
{
do
{
Console.WriteLine("Type \"INITIALIZE\" (in caps) to initialize process.");
} while (Console.ReadLine() != "INITIALIZE");
int marketId;
do
{
Console.Write("Enter Market Id > ");
} while (!int.TryParse(Console.ReadLine(), out marketId));
Console.WriteLine(marketId);
do
{
Console.Write("Re-Enter Market Id > ");
} while (!int.TryParse(Console.ReadLine(), out var f) || f != marketId);
Console.WriteLine(marketId);
QueueProducer queueProducer = new QueueProducer("engine-in", "fanout", "engine-reader", "#", "localhost", "/", "guest", "guest");
var dbContext = new ExchangeContext(new GlobalQueryFilterRegisterer(), "Host=localhost;Database=Exchange;Username=postgres;Password=root");
var orders = dbContext.Orders.Where(x => x.IsDeleted == false && x.MarketId == marketId && (x.OrderStatus == Entity.Partials.OrderStatus.Accepted || x.OrderStatus == Entity.Partials.OrderStatus.Received)).OrderBy(x => x.CreatedOn).ToList();
foreach (var order in orders)
{
var orderWrapper = new OrderWrapper();
orderWrapper.Order = new Order();
orderWrapper.Order.OrderId = order.Id;
orderWrapper.Order.IsBuy = order.Side;
orderWrapper.Order.Price = order.Rate;
orderWrapper.Order.OpenQuantity = order.QuantityRemaining;
orderWrapper.Order.IsStop = order.StopRate != 0;
orderWrapper.OrderCondition = (OrderCondition)((byte)order.OrderCondition);
orderWrapper.StopPrice = order.StopRate;
orderWrapper.TipQuantity = order.IcebergQuantity > 0 ? order.Quantity : 0;
orderWrapper.TotalQuantity = order.IcebergQuantity ?? 0;
if (order.CancelOn.HasValue)
{
DateTime Jan1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
orderWrapper.Order.CancelOn = (int)order.CancelOn.Value.Subtract(Jan1970).TotalSeconds;
}
var bytes = OrderSerializer.Serialize(orderWrapper);
queueProducer.Produce(bytes);
}
queueProducer.Flush();
queueProducer.Close();
Console.WriteLine("Finished..");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.ReadLine();
}
public async Task <PlaceExecutionReport> PlaceOrder(OrderWrapper orderWrapper)
{
var method = "SportsAPING/v1.0/placeOrders";
var args = new Dictionary <string, object>
{
["marketId"] = orderWrapper.MarketId
};
var limitOrder = new LimitOrder
{
PersistenceType = orderWrapper.Persistencetype,
Price = orderWrapper.OrderTick.Price,
Size = orderWrapper.OrderTick.Stake
};
var placeInstructions = new List <PlaceInstruction>()
{
new PlaceInstruction
{
Handicap = 0,
Side = orderWrapper.Side,
OrderType = OrderType.LIMIT,
LimitOrder = limitOrder,
SelectionId = orderWrapper.SelectionId,
}
};
args["instructions"] = placeInstructions;
var apiClient = await _apiClientFactory.GetApiClient();
var placeOrderReport = apiClient.GetData <JsonResponse <PlaceExecutionReport> >(method, args);
if (placeOrderReport.Result.Status == ExecutionReportStatus.SUCCESS)
{
return(placeOrderReport.Result);
}
if (placeOrderReport.Result.ErrorCode == ExecutionReportErrorCode.MARKET_SUSPENDED)
{
throw new MarketSuspendedException();
}
if (placeOrderReport.Result.ErrorCode == ExecutionReportErrorCode.BET_ACTION_ERROR)
{
throw new OrderActionErrorException();
}
if (placeOrderReport.Result.ErrorCode == ExecutionReportErrorCode.INSUFFICIENT_FUNDS)
{
throw new InsufficientFundsException();
}
throw new OrderNotPlaceableException();
}
public void orderJsonSerialize()
{
var order = new Order {
IsBuy = true, IsTip = false, OpenQuantity = 100, OrderId = 1001, Price = 400, Sequnce = 0
};
var orderWrapper = new OrderWrapper()
{
TotalQuantity = 100, OrderCondition = OrderCondition.None, StopPrice = 0
};
var orderJsonString = JsonConvert.SerializeObject(orderWrapper);
}
public void orderBinarySerialize()
{
var order = new Order {
IsBuy = true, IsTip = false, OpenQuantity = 100, OrderId = 1001, Price = 400, Sequnce = 0
};
var orderWrapper = new OrderWrapper()
{
TotalQuantity = 100, OrderCondition = OrderCondition.None, StopPrice = 0
};
var bytes = OrderSerializer.Serialize(orderWrapper);
}
public void Serialize_Doesnotthrowexception_Max()
{
var order1 = new Order {
CancelOn = int.MaxValue, IsBuy = true, OrderId = OrderId.MaxValue, Price = int.MaxValue, OrderAmount = decimal.MaxValue
};
var orderWrapper = new OrderWrapper()
{
StopPrice = int.MaxValue, TotalQuantity = int.MaxValue, TipQuantity = int.MaxValue, OrderCondition = OrderCondition.FillOrKill, Order = order1
};
var bytes = OrderSerializer.Serialize(orderWrapper);
}
internal OrderNotification(OrderWrapper <Notification> notificationInfo)
{
Id = notificationInfo.Order.Id;
Status = notificationInfo.Order.Status;
OldStatus = notificationInfo.Order.OldStatus;
Description = notificationInfo.Order.Description;
Custom = notificationInfo.Order.Custom;
Category = notificationInfo.Order.Category;
DecisionCode = notificationInfo.Order.DecisionCode;
Warnings = notificationInfo.Warnings;
}
public bool CloseOrder(OrderWrapper order)
{
if (open_orders.ContainsValue(order))
{
var key = open_orders.FirstOrDefault(x => x.Value == order).Key;
open_orders.Remove(key);
event_aggregator.GetEvent <OpenOrderServiceEvent>().Publish(open_orders.Count);
return(true);
}
return(false);
}
public void Serialize_Doesnotthrowexception_Min()
{
var order1 = new Order {
CancelOn = int.MinValue, IsBuy = false, OrderId = OrderId.MinValue, Price = int.MinValue, FeeId = short.MinValue
};
var orderWrapper = new OrderWrapper()
{
StopPrice = int.MinValue, TotalQuantity = int.MinValue, TipQuantity = int.MinValue, OrderCondition = OrderCondition.None, OrderAmount = Quantity.MinValue, Order = order1
};
var bytes = OrderSerializer.Serialize(orderWrapper);
}
/// <summary>
/// Validates the Order object fields
/// Sends the order to riskified server endpoint as configured in the ctor
/// </summary>
/// <param name="order">The order object to send</param>
/// <param name="riskifiedEndpointUrl">the endpoint to which the order should be sent</param>
/// <returns>The order tranaction result containing status and order id in riskified servers (for followup only - not used latter) in case of successful transfer</returns>
/// <exception cref="OrderFieldBadFormatException">On bad format of the order (missing fields data or invalid data)</exception>
/// <exception cref="RiskifiedTransactionException">On errors with the transaction itself (network errors, bad response data)</exception>
private OrderNotification SendOrder(AbstractOrder order, Uri riskifiedEndpointUrl)
{
if (_validationMode != Validations.Skip)
{
order.Validate(_validationMode);
}
var wrappedOrder = new OrderWrapper <AbstractOrder>(order);
var transactionResult = HttpUtils.JsonPostAndParseResponseToObject <OrderWrapper <Notification>, OrderWrapper <AbstractOrder> >(riskifiedEndpointUrl, wrappedOrder, _authToken, _shopDomain);
return(new OrderNotification(transactionResult));
}
public bool OpenOrder(OrderWrapper order)
{
if (!open_orders.ContainsValue(order))
{
string new_key = GenOrderKey();
order.OrderNumber = new_key;
open_orders.Add(new_key, order);
event_aggregator.GetEvent <OpenOrderServiceEvent>().Publish(open_orders.Count);
return(true);
}
return(false);
}
public async void PostLtsaFieldsAsync_Valid()
{
// Arrange
var helper = new TestHelper();
var user = PrincipalHelper.CreateForPermission();
var options = Options.Create(new LtsaOptions());
var service = helper.Create <LtsaService>(options, user);
var token = new TokenModel()
{
AccessToken = "test"
};
var titleResponse = new OrderWrapper <OrderParent <Title> >(new TitleOrder());
var parcelInfoResponse = new OrderWrapper <OrderParent <ParcelInfo> >(new ParcelInfoOrder());
var titleSummariesResponse = new TitleSummariesResponse()
{
TitleSummaries = new List <TitleSummary>()
{
new TitleSummary()
{
TitleNumber = "titleNumber",
LandTitleDistrictCode = LandTitleDistrictCode.VA,
}
}
};
var client = helper.GetService <Mock <IHttpRequestClient> >();
client.Setup(m => m.PostJsonAsync(It.IsAny <string>(), It.IsAny <IntegratorCredentials>())).ReturnsAsync <IHttpRequestClient, HttpResponseMessage>(new HttpResponseMessage()
{
Content = new StringContent(accessTokenResponse)
});
client.Setup(m => m.SendJsonAsync <OrderWrapper <OrderParent <Title> >, OrderWrapper <TitleOrder> >(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <OrderWrapper <TitleOrder> >(), It.IsAny <Func <HttpResponseMessage, bool> >())).ReturnsAsync(titleResponse);
client.Setup(m => m.SendJsonAsync <OrderWrapper <OrderParent <ParcelInfo> >, OrderWrapper <ParcelInfoOrder> >(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <OrderWrapper <ParcelInfoOrder> >(), It.IsAny <Func <HttpResponseMessage, bool> >())).ReturnsAsync(parcelInfoResponse);
client.Setup(m => m.SendAsync <TitleSummariesResponse>(It.IsAny <string>(), It.IsAny <HttpMethod>(), It.IsAny <HttpContent>(), It.IsAny <Func <HttpResponseMessage, bool> >())).ReturnsAsync(titleSummariesResponse);
// Act
var result = await service.PostLtsaFields("123-456-789");
// Assert
Assert.NotNull(result);
Assert.IsAssignableFrom <LtsaOrders>(result);
client.Verify(m => m.SendJsonAsync <OrderWrapper <OrderParent <Title> >, OrderWrapper <TitleOrder> >(options.Value.HostUri.AppendToURL(options.Value.OrdersEndpoint), HttpMethod.Post,
It.IsAny <OrderWrapper <TitleOrder> >(), null), Times.Once());
client.Verify(m => m.SendJsonAsync <OrderWrapper <OrderParent <ParcelInfo> >, OrderWrapper <ParcelInfoOrder> >(options.Value.HostUri.AppendToURL(options.Value.OrdersEndpoint), HttpMethod.Post,
It.IsAny <OrderWrapper <ParcelInfoOrder> >(), null), Times.Once());
result.ParcelInfo.Should().Be(parcelInfoResponse.Order);
result.TitleOrders.Should().BeEquivalentTo(new List <OrderParent <Title> >()
{
titleResponse.Order
});
}
private bool VerifyDetails(Dictionary <string, object> y, OrderWrapper orderWrapper)
{
var success = false;
var instruction = y["instructions"] as List <PlaceInstruction>;
success = 1 == instruction.Count;
success = instruction.Single().Handicap == 0;
success = instruction.Single().Side == orderWrapper.Side;
success = instruction.Single().OrderType == OrderType.LIMIT;
success = instruction.Single().LimitOrder.PersistenceType == orderWrapper.Persistencetype;
success = instruction.Single().LimitOrder.Price == orderWrapper.OrderTick.Price;
success = instruction.Single().LimitOrder.Size == orderWrapper.OrderTick.Stake;
success = instruction.Single().SelectionId == orderWrapper.SelectionId;
return(success);
}
private async Task CloseoutBet(OpenOrderResult openingOrderSummary)
{
var marketId = openingOrderSummary.OpenOrderResponse.MarketId;
var runnerId = openingOrderSummary.OpenOrderResponse.SelectionId;
var betId = openingOrderSummary.OpenOrderResponse.BetId;
var latestRunnerBook = await _runnerService.GetRunnerDetails(marketId, runnerId);
var openingOrders = latestRunnerBook.Orders.Where(x => x.BetId == betId).ToList();
double closingPrice = 0;
if (openingOrderSummary.OpenOrderRequest.TrackingTradeOffset.HasValue)
{
closingPrice = PriceLadderUtility.GetWinningPriceTarget(Side.BACK, openingOrderSummary.OpenOrderResponse.OrderTick.Price, openingOrderSummary.OpenOrderRequest.TrackingTradeOffset.Value);
}
else if (openingOrderSummary.OpenOrderResponse.Side == Side.BACK)
{
closingPrice = latestRunnerBook.ExchangePrices.AvailableToLay.Min(x => x.Price);
}
else if (openingOrderSummary.OpenOrderResponse.Side == Side.LAY)
{
closingPrice = latestRunnerBook.ExchangePrices.AvailableToBack.Max(x => x.Price);
}
else
{
throw new System.Exception("No closing side specified");
}
var closeoutStake = _closingStakeCalculator.GetFullHedgeStake(openingOrders, closingPrice);
var orderWrapper = new OrderWrapper(marketId, runnerId, closeoutStake.Key, new OrderTick(closingPrice, closeoutStake.Value), PersistenceType.LAPSE);
var closeoutOrderReport = await _orderPlacer.PlaceOrder(orderWrapper);
if (closeoutOrderReport.Status != ExecutionReportStatus.SUCCESS)
{
throw new System.Exception("Closeout bet not placed!");
}
var closeoutBetId = closeoutOrderReport.InstructionReports.Single().BetId;
_sleepService.Sleep(10000);
await ManageCloseoutOrderMatching(marketId, runnerId, closeoutBetId);
}
public IActionResult Orders()
{
RegisterUser fromLogin = HttpContext.Session.GetObjectFromJson <RegisterUser>("LoggedInUser");
if (fromLogin == null)
{
return(RedirectToAction("Index"));
}
OrderWrapper OrderWrapper = new OrderWrapper();
OrderWrapper.AllCustomers = dbContext.Customers.ToList();
OrderWrapper.AllProducts = dbContext.Products.ToList();
OrderWrapper.AllOrders = dbContext.Orders
.Include(o => o.Product)
.Include(o => o.Customer)
.ToList();
return(View("Orders", OrderWrapper));
}
private void InitNewOrder()
{
Order new_order = new Order() //*** GET this initializatoin stuff into the objects themselves!! (complete)
{
OrderEntryDate = DateTime.Now,
OrderStatusDate = DateTime.Now,
DeliverByDate = DateTime.Now.AddDays(7), // think about a defaul lead time for each account
SalesRep = SalesRepList[0],
AccountRep = AccountRepList[0]
};
new_order.OrderItems.Add(InitNewOrderItem(1));
SelectedOrderItemIndex = 0;
Order = new OrderWrapper(new_order);
DefaultBillingAddress = new AddressWrapper(new Address());
DefaultShippingAddress = new AddressWrapper(new Address());
Order.PropertyChanged += Context_PropertyChanged;
Order.AcceptChanges();
GridIsEnabled = false;
}
private void OnChangeSelectedCustomer(CustomerWrapper selectedCustomer)
{
selectedCustomer.Orders =
new ObservableCollection<OrderWrapper>(
_ordersRepository.GetAllOrders().Where(o => o.CustomerId == SelectedCustomer.Id).Select(
x => new OrderWrapper(x)));
var order = new Order
{
CustomerId = selectedCustomer.Id,
ItemsTotal = 1,
OrderDate = DateTime.Now,
StoreId = selectedCustomer.StoreId,
Phone = SelectedCustomer.Phone,
DeliveryCity = SelectedCustomer.City,
DeliveryState = selectedCustomer.State,
DeliveryStreet = selectedCustomer.Street,
DeliveryZip = selectedCustomer.Zip,
DeliveryDate = DateTime.Now.AddDays(2)
};
NewOrder = new OrderWrapper(order);
}
private void OnCancel(object obj)
{
if(NewOrder.IsChanged)
{
var result = _messageDialogService.ShowYesNoDialog("Cancel", "Do you want to cancel");
if(result == MessageDialogResult.Yes)
{
NewOrder = new OrderWrapper(new Order());
}
}
}
/// <summary>
/// Validates the Order object fields
/// Sends the order to riskified server endpoint as configured in the ctor
/// </summary>
/// <param name="order">The order object to send</param>
/// <param name="riskifiedEndpointUrl">the endpoint to which the order should be sent</param>
/// <returns>The order tranaction result containing status and order id in riskified servers (for followup only - not used latter) in case of successful transfer</returns>
/// <exception cref="OrderFieldBadFormatException">On bad format of the order (missing fields data or invalid data)</exception>
/// <exception cref="RiskifiedTransactionException">On errors with the transaction itself (network errors, bad response data)</exception>
private OrderNotification SendOrder(AbstractOrder order, Uri riskifiedEndpointUrl)
{
if(_validationMode != Validations.Skip)
{
order.Validate(_validationMode);
}
var wrappedOrder = new OrderWrapper<AbstractOrder>(order);
var transactionResult = HttpUtils.JsonPostAndParseResponseToObject<OrderWrapper<Notification>, OrderWrapper<AbstractOrder>>(riskifiedEndpointUrl, wrappedOrder, _authToken, _shopDomain);
return new OrderNotification(transactionResult);
}