private static async Task SuperOrderAsync(KrakenClient cli, OrderKind kind, string pair, decimal amount)
{
OrderBook orderBook = await cli.GetOrderBookAsync(pair);
var(price, volumeAbove) = GetBestCurrentPrice(orderBook, kind, -1, amount);
string txid = await LimitOrderAsync(cli, kind, pair, amount, price);
Console.WriteLine("Opened initial order to {0} {1} {2} @ {3} ({4} volume above)",
kind == OrderKind.Buy ? "buy" : "sell", amount, pair, price, volumeAbove);
while (true)
{
Task <Dictionary <string, OrderInfo> > orderReq = cli.QueryOrdersAsync(new[] { txid });
Task <OrderBook> orderBookReq = cli.GetOrderBookAsync(pair);
OrderInfo order = (await orderReq).Values.Single();
orderBook = await orderBookReq;
if (order.Status == OrderStatus.Closed)
{
break;
}
decimal amountLeft = order.Volume - order.VolumeExecuted;
var(newPrice, newVolumeAbove) = GetBestCurrentPrice(orderBook, kind, price, amountLeft);
if (newPrice == price)
{
Console.WriteLine("Positioned correctly. Current volume: {0}, {1} above", amountLeft, newVolumeAbove);
await Task.Delay(2000);
continue;
}
try
{
await cli.CancelOrderAsync(txid);
}
catch (KrakenException)
{
await Task.Delay(2000);
continue;
}
order = (await cli.QueryOrdersAsync(new[] { txid })).Values.Single();
amountLeft = order.Volume - order.VolumeExecuted;
if (order.Status == OrderStatus.Closed || amountLeft <= 0)
{
break;
}
txid = await LimitOrderAsync(cli, kind, pair, amountLeft, newPrice);
Console.WriteLine("Moved order from {0} to {1} ({2} above)", price, newPrice, newVolumeAbove);
price = newPrice;
await Task.Delay(4000);
}
}
internal OrderByClauseItem(
Node orderExpr,
OrderKind orderKind,
Identifier optCollationIdentifier)
{
this._orderExpr = orderExpr;
this._orderKind = orderKind;
this._optCollationIdentifier = optCollationIdentifier;
}
/// <summary>
/// Сохраняет в базе модель создания элемента.
/// </summary>
/// <param name="token">Токен безопасности.</param>
/// <param name="model">Модель создания сущности для сохранения.</param>
/// <param name="result">Результат с ошибками.</param>
public override void SaveCreateModel(SecurityToken token, OrderKindCreateModel model, GridSaveModelResult result)
{
var entity = new OrderKind
{
Title = model.Title,
OrderKindID = model.OrderKindID
};
RemontinkaServer.Instance.EntitiesFacade.SaveOrderKind(token, entity);
RemontinkaServer.Instance.GetService <IWebSiteSettingsService>().CleanOrderKinds(token);
}
public static string ToApiString(this OrderKind kind)
{
switch (kind)
{
case OrderKind.Buy: return("buy");
case OrderKind.Sell: return("sell");
default: throw new ArgumentOutOfRangeException(nameof(kind));
}
}
public RepairOrder CreateTestRepairOrder()
{
var store = CreateStore();
var orderStatus = new OrderStatus();
orderStatus.Title = "Title";
orderStatus.StatusKindID = StatusKindSet.Completed.StatusKindID;
store.SaveOrderStatus(orderStatus);
var item = new OrderKind();
item.Title = "Title";
store.SaveOrderKind(item);
var branch = CreateTestBranch();
var user = CreateTestUser();
var order = new RepairOrder();
order.BranchID = branch.BranchID;
order.CallEventDateDateTime = new DateTime(2015, 06, 01);
order.ClientAddress = "ClientAddress33323";
order.ClientEmail = "ClientEmail";
order.ClientFullName = "ClientFullName";
order.ClientPhone = "ClientPhone";
order.DateOfBeReadyDateTime = new DateTime(2015, 07, 07);
order.Defect = "Defect";
order.DeviceAppearance = "DeviceAppearance";
order.DeviceModel = "DeviceModel";
order.DeviceSN = "DeviceSN";
order.DeviceTitle = "DeviceTitle";
order.DeviceTrademark = "DeviceTrademark";
order.EngineerID = user.UserID;
order.EventDateDateTime = new DateTime(2014, 02, 05);
order.GuidePrice = 44;
order.IsUrgentBoolean = true;
order.IssueDateDateTime = new DateTime(2013, 05, 04);
order.IssuerID = user.UserID;
order.ManagerID = user.UserID;
order.Notes = "Notes";
order.Number = "Number" + Guid.NewGuid();
order.Options = "Options";
order.OrderKindID = item.OrderKindID;
order.OrderStatusID = orderStatus.OrderStatusID;
order.PrePayment = 55;
order.Recommendation = "Recommendation";
order.WarrantyToDateTime = new DateTime(2017, 01, 2);
order.RepairOrderIDGuid = _repairOrderId;
store.SaveRepairOrder(order);
return(order);
}
private static async Task <string> LimitOrderAsync(
KrakenClient cli, OrderKind kind, string pair, decimal amount, decimal price)
{
var result = await cli.AddOrderAsync(new OrderRequest
{
Kind = kind,
Pair = pair,
Type = OrderType.Limit,
Price = price,
Volume = amount,
});
string txid = result.TransactionIds.Single();
return(txid);
}
public async Task <Order> CreateOrderAsync(string marketId, OrderType type, OrderKind kind, decimal amount, decimal?price = null)
{
if (type == OrderType.LIMIT && !(price >= 0))
{
throw new InvalidOperationException("Limit orders must have price specified");
}
var submission = new OrderSubmission
{
side = kind == OrderKind.Bid ? "buy" : "sell",
volume = amount,
market = marketId,
price = type == OrderType.MARKET ? null : price,
ord_type = type.ToString().ToLower()
};
return(await ExecuteRequestWithRetry <Order>(Method.POST, Urls.OrderSubmit, null, submission));
}
public void OrderCancel(UpbitAPI _U, string _coinCode, OrderKind _orderKind = OrderKind.BuyCancel)
{
//특정코인만 주문취소하기...
//string coinCode = "KRW-TT";
//string orderkind = "bid";//bid : 매수, ask : 매도
var orders = MessagePackSerializer.Typeless.Deserialize(MessagePackSerializer.FromJson(_U.GetAllOrder()));
switch (_orderKind)
{
case OrderKind.BuyCancel:
foreach (var o in orders as object[])
{
Dictionary <object, object> d = o as Dictionary <object, object>;
if ((string)d["market"] == _coinCode && (string)d["side"] == "bid")
{
Console.WriteLine(_U.CancelOrder((string)d["uuid"]));
}
}
break;
case OrderKind.SellCancel:
foreach (var o in orders as object[])
{
Dictionary <object, object> d = o as Dictionary <object, object>;
if ((string)d["market"] == _coinCode && (string)d["side"] == "ask")
{
Console.WriteLine(_U.CancelOrder((string)d["uuid"]));
}
}
break;
case OrderKind.AllCancel:
foreach (var o in orders as object[])
{
Dictionary <object, object> d = o as Dictionary <object, object>;
if ((string)d["market"] == _coinCode)
{
Console.WriteLine(_U.CancelOrder((string)d["uuid"]));
}
}
break;
}
}
public void OrderKindTest()
{
var store = CreateStore();
var item = new OrderKind();
item.Title = "Title";
store.SaveOrderKind(item);
var savedItem = store.GetOrderKind(item.OrderKindIDGuid);
Assert.IsNotNull(savedItem);
Assert.AreEqual(item.Title, savedItem.Title);
store.DeleteOrderKind(savedItem.OrderKindIDGuid);
savedItem = store.GetOrderKind(item.OrderKindIDGuid);
Assert.IsNull(savedItem);
}
/// <summary>
/// Initializes collated order by clause item.
/// </summary>
/// <param name="optCollationIdentifier">optional Collation identifier</param>
internal OrderByClauseItem(Node orderExpr, OrderKind orderKind, Identifier optCollationIdentifier)
{
_orderExpr = orderExpr;
_orderKind = orderKind;
_optCollationIdentifier = optCollationIdentifier;
}
/// <summary>
/// Initializes non-collated order by clause item.
/// </summary>
internal OrderByClauseItem(Node orderExpr, OrderKind orderKind)
: this(orderExpr, orderKind, null)
{
}
/// <summary>
/// Initializes non-collated order by clause item.
/// </summary>
internal OrderByClauseItem(Node orderExpr, OrderKind orderKind)
: this(orderExpr, orderKind, null)
{
}
private static (decimal price, decimal above) GetBestCurrentPrice(OrderBook orderBook, OrderKind kind, decimal myCurPrice, decimal myVolume)
{
// Allowed cumulative volume percentage above our order
const decimal allowAbove = 0.15m;
decimal volumeAllowedAbove = myVolume * allowAbove;
IReadOnlyList <OrderBookEntry> entries = kind == OrderKind.Buy ? orderBook.Bids : orderBook.Asks;
int placeAbove = 0;
while (true)
{
OrderBookEntry entry = entries[placeAbove];
decimal volume = entry.Volume - (entry.Price == myCurPrice ? myVolume : 0);
if (volume > volumeAllowedAbove)
{
break;
}
placeAbove++;
volumeAllowedAbove -= volume;
}
decimal price = entries[placeAbove].Price;
if (kind == OrderKind.Buy)
{
price += 0.00001m;
}
else
{
price -= 0.00001m;
}
return(price, myVolume *allowAbove - volumeAllowedAbove);
}
public OrderInfo(
string transactionId,
string referralId,
int?userReferenceId,
OrderStatus status,
DateTimeOffset openTime,
DateTimeOffset?startTime,
DateTimeOffset?expireTime,
string pair,
OrderKind kind,
OrderType type,
OrderPrice?price,
OrderPrice?price2,
string leverage,
string description,
string closeDescription,
decimal volume,
decimal volumeExecuted,
decimal cost,
decimal fee,
decimal averagePrice,
decimal stopPrice,
decimal limitPrice,
bool stopped,
bool touched,
bool liquidated,
bool partial,
bool volumeInQuoteCurrency,
bool preferFeeInBaseCurrency,
bool preferFeeInQuoteCurrency,
bool noMarketPriceProtection,
IReadOnlyList <string> tradeIds,
DateTimeOffset?closeTime,
string closeReason)
{
TransactionId = transactionId;
ReferralId = referralId;
UserReferenceId = userReferenceId;
Status = status;
OpenTime = openTime;
StartTime = startTime;
ExpireTime = expireTime;
Pair = pair;
Kind = kind;
Type = type;
Price = price;
Price2 = price2;
Leverage = leverage;
Description = description;
CloseDescription = closeDescription;
Volume = volume;
VolumeExecuted = volumeExecuted;
Cost = cost;
Fee = fee;
AveragePrice = averagePrice;
StopPrice = stopPrice;
LimitPrice = limitPrice;
Stopped = stopped;
Touched = touched;
Liquidated = liquidated;
Partial = partial;
VolumeInQuoteCurrency = volumeInQuoteCurrency;
PreferFeeInBaseCurrency = preferFeeInBaseCurrency;
PreferFeeInQuoteCurrency = preferFeeInQuoteCurrency;
NoMarketPriceProtection = noMarketPriceProtection;
TradeIds = tradeIds;
CloseTime = closeTime;
CloseReason = closeReason;
}
internal OrderByClauseItem(Node orderExpr, OrderKind orderKind)
: this(orderExpr, orderKind, (Identifier)null)
{
}
public void RepairOrderTest()
{
var store = CreateStore();
var orderStatus = new OrderStatus();
orderStatus.Title = "Title";
orderStatus.StatusKindID = StatusKindSet.Completed.StatusKindID;
store.SaveOrderStatus(orderStatus);
var item = new OrderKind();
item.Title = "Title";
store.SaveOrderKind(item);
var branch = CreateTestBranch();
var user = CreateTestUser();
try
{
var order = new RepairOrder();
order.BranchID = branch.BranchID;
order.CallEventDateDateTime = new DateTime(2015, 06, 01);
order.ClientAddress = "ClientAddress";
order.ClientEmail = "ClientEmail";
order.ClientFullName = "ClientFullName";
order.ClientPhone = "ClientPhone";
order.DateOfBeReadyDateTime = new DateTime(2015, 07, 07);
order.Defect = "Defect";
order.DeviceAppearance = "DeviceAppearance";
order.DeviceModel = "DeviceModel";
order.DeviceSN = "DeviceSN";
order.DeviceTitle = "DeviceTitle";
order.DeviceTrademark = "DeviceTrademark";
order.EngineerID = user.UserID;
order.EventDateDateTime = new DateTime(2014, 02, 05);
order.GuidePrice = 44;
order.IsUrgentBoolean = true;
order.IssueDateDateTime = new DateTime(2013, 05, 04);
order.IssuerID = user.UserID;
order.ManagerID = user.UserID;
order.Notes = "Notes";
order.Number = "Number" + Guid.NewGuid();
order.Options = "Options";
order.OrderKindID = item.OrderKindID;
order.OrderStatusID = orderStatus.OrderStatusID;
order.PrePayment = 55;
order.Recommendation = "Recommendation";
order.WarrantyToDateTime = new DateTime(2017, 01, 2);
store.SaveRepairOrder(order);
var savedItem = store.GetRepairOrder(order.RepairOrderIDGuid);
Assert.IsNotNull(savedItem);
Assert.AreEqual(order.BranchID, savedItem.BranchID);
Assert.AreEqual(order.CallEventDate, savedItem.CallEventDate);
Assert.AreEqual(order.ClientAddress, savedItem.ClientAddress);
Assert.AreEqual(order.ClientEmail, savedItem.ClientEmail);
Assert.AreEqual(order.ClientFullName, savedItem.ClientFullName);
Assert.AreEqual(order.ClientPhone, savedItem.ClientPhone);
Assert.AreEqual(order.DateOfBeReady, savedItem.DateOfBeReady);
Assert.AreEqual(order.Defect, savedItem.Defect);
Assert.AreEqual(order.DeviceAppearance, savedItem.DeviceAppearance);
Assert.AreEqual(order.DeviceModel, savedItem.DeviceModel);
Assert.AreEqual(order.DeviceSN, savedItem.DeviceSN);
Assert.AreEqual(order.DeviceTitle, savedItem.DeviceTitle);
Assert.AreEqual(order.DeviceTrademark, savedItem.DeviceTrademark);
Assert.AreEqual(order.EngineerID, savedItem.EngineerID);
Assert.AreEqual(order.EventDate, savedItem.EventDate);
Assert.AreEqual(order.GuidePrice, savedItem.GuidePrice);
Assert.AreEqual(order.IsUrgent, savedItem.IsUrgent);
Assert.AreEqual(order.IssueDate, savedItem.IssueDate);
Assert.AreEqual(order.IssuerID, savedItem.IssuerID);
Assert.AreEqual(order.ManagerID, savedItem.ManagerID);
Assert.AreEqual(order.Notes, savedItem.Notes);
Assert.AreEqual(order.Number, savedItem.Number);
Assert.AreEqual(order.Options, savedItem.Options);
Assert.AreEqual(order.OrderKindID, savedItem.OrderKindID);
Assert.AreEqual(order.OrderStatusID, savedItem.OrderStatusID);
Assert.AreEqual(order.PrePayment, savedItem.PrePayment);
Assert.AreEqual(order.Recommendation, savedItem.Recommendation);
Assert.AreEqual(order.WarrantyTo, savedItem.WarrantyTo);
store.DeleteRepairOrder(order.RepairOrderIDGuid);
savedItem = store.GetRepairOrder(order.RepairOrderIDGuid);
Assert.IsNull(savedItem);
}
finally
{
store.DeleteOrderStatus(orderStatus.OrderStatusIDGuid);
store.DeleteOrderKind(item.OrderKindIDGuid);
DeleteTestBranch();
DeleteTestUser();
}
}
