public RawOrder Make(Order order)
{
RawOrder smartComOrder = new RawOrder();
smartComOrder.Portfolio = order.Portfolio;
smartComOrder.Symbol = order.Symbol;
smartComOrder.Action = Make(order.TradeAction);
smartComOrder.Amount = order.Amount;
smartComOrder.Type = GetStOrderType(order.OrderType);
smartComOrder.Validity = MakeValidity(order.ExpirationDate);
smartComOrder.Cookie = order.Id;
smartComOrder.Id = smartComOrder.Cookie;
smartComOrder.ExpirationDate = DateTime.Now.AddSeconds(60);
if (smartComOrder.Type == StOrder_Type.StOrder_Type_Stop)
{
smartComOrder.Stop = order.Stop;
}
else if (smartComOrder.Type == StOrder_Type.StOrder_Type_Limit)
{
smartComOrder.Price = order.Price;
}
else
{
smartComOrder.Price = 0;
}
return(smartComOrder);
}
/// <summary>
/// <see cref="GetOrderBook(string, int)"/>
/// </summary>
public async Task <IList <RawOrder> > GetOrderBookAsync(string symbol, int depth = 20)
{
var param = new Dictionary <string, object>();
param["size"] = depth.ToString();
string apiUrl = "/instruments/" + symbol + "/book";
string response = await request.Query("GET", apiUrl, param, true).ConfigureAwait(false);
if (string.IsNullOrEmpty(response))
{
throw new OkexNoResponse(string.Format("Request to {0} returned empty", apiUrl));
}
JToken jsonResponse = JsonConvert.DeserializeObject <JToken>(response);
ValidateResponse(apiUrl, jsonResponse);
IList <RawOrder> orderBook = new List <RawOrder>();
JArray asks = jsonResponse["asks"] as JArray;
JArray bids = jsonResponse["bids"] as JArray;
try
{
for (int i = asks.Count - 1; i >= 0; i--)
{
var rawOrder = new RawOrder();
JArray raw = asks[i] as JArray;
rawOrder.Price = raw[0].Value <double>();
rawOrder.Size = raw[1].Value <double>();
rawOrder.Side = OrderSide.Sell;
orderBook.Add(rawOrder);
}
for (int i = 0; i <= bids.Count - 1; i++)
{
var rawOrder = new RawOrder();
JArray raw = bids[i] as JArray;
rawOrder.Price = raw[0].Value <double>();
rawOrder.Size = raw[1].Value <double>();
rawOrder.Side = OrderSide.Buy;
orderBook.Add(rawOrder);
}
}
catch
{
throw new OkexResponseParseError(string.Format("Response of {0} couldn't be parsed as expected", apiUrl));
}
return(orderBook);
}
public void RawOrderFactory_validity_day_for_order_with_expiration_date_before_SessionEnd()
{
Order order = new Order(1, BrokerDateTime.Make(DateTime.Now), "PRTFL", "SMBL", TradeAction.Sell, OrderType.Market, 1, 0, 0);
Assert.AreEqual(new FortsTradingSchedule().SessionEnd, order.ExpirationDate);
RawOrder rawOrder = factory.Make(order);
Assert.AreEqual(StOrder_Validity.StOrder_Validity_Day, rawOrder.Validity);
}
/// <summary>
/// Map from RawOrder to Order(javascript -> database)
/// </summary>
/// <param name="obj">RawOrder</param>
/// <returns></returns>
public Order RawToBaseOrderMapper(RawOrder obj)
{
Order newOrder = new Order();
newOrder.Cust = obj.CustomerID;
newOrder.Store = obj.StoreID;
newOrder.CurTotal = obj.Total;
newOrder.JSONPizzaOrder = JsonSerializer.Serialize <List <RawPizza> >(obj.PizzaList);
return(newOrder);
}
public Order(RawOrder _order)
{
// Id = _order.id; // これはただのインデックスで意味ないので消す
OrderId = _order.child_order_acceptance_id; // 注文受付ID
ChildOrderId = _order.child_order_id; // 約定ID
Date = DateTime.Parse(_order.child_order_date + "+00:00"); // 注文日時
Side = (OrderSide)Enum.Parse(typeof(OrderSide), _order.side, true);
Price = (int)_order.price;
Size = _order.size;
ExecutedSize = _order.executed_size;
OutstandingSize = _order.outstanding_size;
}
public void RawOrderFactory_validity_gtc_for_order_with_expiration_date_greater_than_SessionEnd()
{
Order order = new Order(1, BrokerDateTime.Make(DateTime.Now), "PRTFL", "SMBL", TradeAction.Sell, OrderType.Market, 1, 0, 0);
order.ExpirationDate = new FortsTradingSchedule().SessionEnd.AddMilliseconds(1);
Assert.IsTrue(new FortsTradingSchedule().SessionEnd < order.ExpirationDate);
RawOrder rawOrder = factory.Make(order);
Assert.AreEqual(StOrder_Validity.StOrder_Validity_Gtc, rawOrder.Validity);
}
public Order CreateOrder(RawOrder obj)
{
Order newOrder = mapper.RawToBaseOrderMapper(obj);
List <Crust> storeCrust = storeRepo.GetCrusts(obj.StoreID);
List <Size> storeSize = storeRepo.GetSizes(obj.StoreID);
List <Topping> storeToppings = storeRepo.GetToppings(obj.StoreID);
//mapper.PizzaMapper(newOrder, obj, storeCrust, storeSize, storeToppings);
storeRepo.UpdateInventory(obj.StoreID, obj.PizzaList);
custRepo.UpdateLastStore(obj);
orderRepo.AddOrder(newOrder);
return(newOrder);
}
/// <summary>
/// <see cref="GetOrderBook(string, int)"/>
/// </summary>
public async Task <IList <RawOrder> > GetOrderBookAsync(string symbol, int depth = 20)
{
var param = new Dictionary <string, object>();
param["symbol"] = symbol;
param["depth"] = depth.ToString();
string apiUrl = "/orderBook/L2";
string response = await request.Query("GET", apiUrl, param, true).ConfigureAwait(false);
if (string.IsNullOrEmpty(response))
{
throw new BitmexNoResponse(string.Format("Request to {0} returned empty", apiUrl));
}
JToken jsonResponse = JsonConvert.DeserializeObject <JToken>(response);
ValidateResponse(apiUrl, jsonResponse);
IList <RawOrder> orderBook = new List <RawOrder>();
JArray jArray = jsonResponse as JArray;
if (jArray.Count == 0)
{
return(orderBook);
}
try
{
foreach (var jToken in jArray)
{
var rawOrder = new RawOrder();
string side = jToken["side"].Value <string>();
rawOrder.Price = jToken["price"].Value <double>();
rawOrder.Size = jToken["size"].Value <double>();
rawOrder.Side = side.Equals("Buy") ? OrderSide.Buy
: side.Equals("Sell") ? OrderSide.Sell
: throw new Exception();
orderBook.Add(rawOrder);
}
}
catch
{
throw new BitmexResponseParseError(string.Format("Response of {0} couldn't be parsed as expected", apiUrl));
}
return(orderBook);
}
public void RawOrderFactory_Make_BuyAtMarket_Order()
{
Order order = new Order(1, BrokerDateTime.Make(DateTime.Now), "PRTFL", "SMBL", TradeAction.Buy, OrderType.Market, 1, 0, 0);
RawOrder rawOrder = factory.Make(order);
Assert.AreEqual(order.Id, rawOrder.Cookie);
Assert.AreEqual(order.Amount, rawOrder.Amount);
Assert.AreEqual(StOrder_Action.StOrder_Action_Buy, rawOrder.Action);
Assert.AreEqual(StOrder_Type.StOrder_Type_Market, rawOrder.Type);
Assert.AreEqual(StOrder_Validity.StOrder_Validity_Day, rawOrder.Validity);
Assert.AreEqual("SMBL", rawOrder.Symbol);
Assert.AreEqual("PRTFL", rawOrder.Portfolio);
Assert.AreEqual(0, rawOrder.Price);
}
public void RawOrderFactory_make_limit_order_to_sell()
{
Order order = new Order(1, BrokerDateTime.Make(DateTime.Now), "Portfolio", "Symbol", TradeAction.Sell, OrderType.Limit, 1, 125000, 0);
RawOrder rawOrder = factory.Make(order);
Assert.AreEqual(order.Id, rawOrder.Cookie);
Assert.AreEqual(order.Amount, rawOrder.Amount);
Assert.AreEqual(StOrder_Action.StOrder_Action_Sell, rawOrder.Action);
Assert.AreEqual(StOrder_Type.StOrder_Type_Limit, rawOrder.Type);
Assert.AreEqual(StOrder_Validity.StOrder_Validity_Day, rawOrder.Validity);
Assert.AreEqual("Symbol", rawOrder.Symbol);
Assert.AreEqual("Portfolio", rawOrder.Portfolio);
Assert.AreEqual(125000, rawOrder.Price);
}
public ActionResult <Order> SubmitOrder([FromBody] RawOrder obj)
{
Order newOrder;
if (!ModelState.IsValid)
{
return(StatusCode(400, "Failed to create models"));
}
else
{
newOrder = orderLogic.CreateOrder(obj);
}
return(newOrder);
}
/// <summary>
/// Update the last store the user purchased from
/// </summary>
/// <param name="obj">RawOrder obj</param>
/// <returns></returns>
public Customer UpdateLastStore(RawOrder obj)
{
var customerInfo = context.Customers.SingleOrDefault(n => Guid.Equals(n.CustomerID, obj.CustomerID));
if (customerInfo is null)
{
return(null);
}
else
{
customerInfo.LastStore = obj.StoreID;
context.SaveChanges();
return(customerInfo);
}
}
public void RawOrderFactory_make_stop_order_to_buy()
{
Order order = new Order(1, BrokerDateTime.Make(DateTime.Now), "Portfolio", "Symbol", TradeAction.Buy, OrderType.Stop, 1, 0, 130000);
RawOrder rawOrder = factory.Make(order);
Assert.AreEqual(order.Id, rawOrder.Cookie);
Assert.AreEqual(order.Amount, rawOrder.Amount);
Assert.AreEqual(StOrder_Action.StOrder_Action_Buy, rawOrder.Action);
Assert.AreEqual(StOrder_Type.StOrder_Type_Stop, rawOrder.Type);
Assert.AreEqual(StOrder_Validity.StOrder_Validity_Day, rawOrder.Validity);
Assert.AreEqual("Symbol", rawOrder.Symbol);
Assert.AreEqual("Portfolio", rawOrder.Portfolio);
Assert.AreEqual(0, rawOrder.Price);
Assert.AreEqual(130000, rawOrder.Stop);
}
public void Order_IsClosePosition()
{
RawOrder order = new RawOrder
{
Portfolio = "PRTF",
Symbol = "SBER",
Action = SmartCOM3Lib.StOrder_Action.StOrder_Action_Sell,
Type = SmartCOM3Lib.StOrder_Type.StOrder_Type_Market,
Validity = SmartCOM3Lib.StOrder_Validity.StOrder_Validity_Day,
Price = 0,
Amount = 1,
Stop = 0,
Cookie = SerialIntegerFactory.Make()
};
Assert.IsFalse(order.RequestsOpenPosition());
Assert.IsTrue(order.RequestsClosePosition());
}
public void PlaceOrder(Order order)
{
RawOrderFactory factory = new RawOrderFactory(new FortsTradingSchedule());
RawOrder rawOrder = factory.Make(order);
this.singleton.Instance.PlaceOrder(rawOrder.Portfolio, rawOrder.Symbol, rawOrder.Action, rawOrder.Type, rawOrder.Validity, rawOrder.Price, rawOrder.Amount, rawOrder.Stop, rawOrder.Cookie);
this.logger.Log(String.Format("{0:dd/MM/yyyy H:mm:ss.fff}, {1}, отправлена заявка {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}",
BrokerDateTime.Make(DateTime.Now),
this.GetType().Name,
rawOrder.Cookie,
rawOrder.Portfolio,
rawOrder.Symbol,
rawOrder.Action,
rawOrder.Type,
rawOrder.Validity,
rawOrder.Price,
rawOrder.Amount,
rawOrder.Stop));
}
public IReadOnlyCollection <UpdateInstruction> Process(RawOrder rawOrder)
{
// Build list of executors for this processor
var executors = new OrderProcessingDelegate[]
{
SomeValidator.BindContact,
SomeValidator.BindSecurity,
SomeValidator.ValidateOrder,
SomeBinder.EvaluateCommission,
SomeBinder.DoSomeJobWithArgument("Order")
};
// Firstly prepare order
var processingOrder = new Order(rawOrder);
// Start do single responsibility work
foreach (var exec in executors)
{
processingOrder = exec(processingOrder);
}
// Return useful instructions
return(processingOrder.Instructions);
}
/// <summary>
/// CURRENTLY NOT USED
/// Maps all the RawPizzas from RawOrder to BasicPizzas in Order
/// Goes through all size/crust/toppings and creates an appropriate basic pizza
/// </summary>
/// <param name="newOrder">Order containing List of BasicPizzas</param>
/// <param name="obj">Order containing List of RawPizzas</param>
/// <param name="storeCrust">List of store's crusts</param>
/// <param name="storeSize">List of store's sizes</param>
/// <param name="storeToppings">List of store's toppings</param>
public void PizzaMapper(Order newOrder, RawOrder obj, List <Crust> storeCrust, List <Size> storeSize, List <Topping> storeToppings)
{
foreach (RawPizza rp in obj.PizzaList)
{
BasicPizza bp = new BasicPizza();
bp.Type = rp.Name;
bp.PizzaPrice = rp.Price;
foreach (Crust c in storeCrust)
{
if (c.PizzaType.Name == rp.Crust)
{
bp.Crust = c;
break;
}
}
foreach (Size s in storeSize)
{
if (s.PizzaType.Name == rp.Size)
{
bp.Size = s;
break;
}
}
foreach (string rpt in rp.Toppings)
{
foreach (Topping t in storeToppings)
{
if (t.PizzaType.Name == rpt)
{
bp.Toppings.Add(t);
break;
}
}
}
newOrder.Pizzas.Add(bp);
}
}
public Order(RawOrder rawOrder)
{
this.rawOrder = rawOrder;
}
public void Test_CreateOrder()
{
var options = new DbContextOptionsBuilder <OrderContext>()
.UseInMemoryDatabase(databaseName: "TestDb21")
.Options;
var options1 = new DbContextOptionsBuilder <StoreContext>()
.UseInMemoryDatabase(databaseName: "TestDb21")
.Options;
var options2 = new DbContextOptionsBuilder <CustomerContext>()
.UseInMemoryDatabase(databaseName: "TestDb21")
.Options;
using (var context = new OrderContext(options))
{
using (var context1 = new StoreContext(options1))
{
using (var context2 = new CustomerContext(options2))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
context1.Database.EnsureDeleted();
context1.Database.EnsureCreated();
context2.Database.EnsureDeleted();
context2.Database.EnsureCreated();
OrderRepository orderRepo = new OrderRepository(context);
StoreRepository storeRepo = new StoreRepository(context1);
CustomerRepository custRepo = new CustomerRepository(context2);
OrderLogic ol = new OrderLogic(orderRepo, storeRepo, custRepo);
AStore store = new AStore();
Customer newCust = new Customer();
ItemType item = new ItemType("toppings");
APizzaComponent testCrust = new APizzaComponent("testcrust", item);
APizzaComponent testTopping = new APizzaComponent("testtopping", item);
APizzaComponent testSize = new APizzaComponent("testsize", item);
Crust tempCrust = new Crust(store, 0, 1, testCrust);
Topping tempTopping = new Topping(store, 0, 1, testTopping);
Size tempSize = new Size(store, 0, 1, testSize);
context1.Add <AStore>(store);
context2.Add <Customer>(newCust);
context1.Add <ItemType>(item);
context1.Add <APizzaComponent>(testCrust);
context1.Add <APizzaComponent>(testTopping);
context1.Add <APizzaComponent>(testSize);
context1.Add <Crust>(tempCrust);
context1.Add <Topping>(tempTopping);
context1.Add <Size>(tempSize);
context.SaveChanges();
context1.SaveChanges();
context2.SaveChanges();
RawPizza rawTest = new RawPizza();
rawTest.Name = "Test Pizza";
rawTest.Price = 0;
rawTest.Crust = "testcrust";
rawTest.Size = "testsize";
rawTest.Toppings = new List <string>();
rawTest.Toppings.Add("testtopping");
RawOrder newOrder = new RawOrder();
newOrder.PizzaList = new List <RawPizza>();
newOrder.StoreID = store.StoreID;
newOrder.CustomerID = newCust.CustomerID;
newOrder.Total = 0;
newOrder.PizzaList.Add(rawTest);
Order createOrder = ol.CreateOrder(newOrder);
Assert.NotNull(createOrder);
}
}
}
}
