public Game()
{
this.Board = new Board(this);
this.Sides = new Side[] { new Side(this), new Side(this) };
this.Sides[0].sideType = SideType.Bottom;
this.Sides[1].sideType = SideType.Top;
this.InitPieces();
this.InitBoard();
this.WhosTurn = this.WhosFirst;
}
public LevelBlockRequirements(SideType sideType)
{
LeftSideType = sideType;
RightSideType = sideType;
TopSideType = sideType;
BottomSideType = sideType;
Group = "";
Theme = "";
}
public LevelBlockRequirements()
{
LeftSideType = SideType.Any;
RightSideType = SideType.Any;
TopSideType = SideType.Any;
BottomSideType = SideType.Any;
Group = "";
Theme = "";
}
public static SideType OppositeSide(SideType side)
{
if (side == SideType.TopSide)
{
return SideType.BottomSide;
}
if (side == SideType.BottomSide)
{
return SideType.TopSide;
}
if (side == SideType.LeftSide)
{
return SideType.RightSide;
}
return SideType.LeftSide;
}
private static void GetIntersectionPoint(Vector2 center, Vector2 originDirection, IEnumerable<KeyValuePair<SideType,MathLine>> sides, MathLine inputLine, out SideType intersectionSide, out Vector2 intersectionPoint)
{
intersectionSide = SideType.None;
intersectionPoint = new Vector2(Mathf.Infinity, Mathf.Infinity);
float sqrDistance = Mathf.Infinity;
foreach (var side in sides)
{
SideType sideType = side.Key;
MathLine line = side.Value;
Vector2 point = line.GetIntersectionPoint(inputLine.Coefficients);
Vector2 direction = point - center;
float distance = Vector2.SqrMagnitude(direction);
if (distance <= sqrDistance && Vector2.Dot(direction, originDirection) > 0)
{
sqrDistance = distance;
intersectionSide = sideType;
intersectionPoint = point;
}
}
}
public static bool IsMax(SideType side)
{
return side == SideType.RightSide || side == SideType.BottomSide;
}
/// <summary>
/// Create a new market order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "Buy" : "Sell";
var _params = tradeClient.MergeParamsAndArgs(
new Dictionary <string, object>
{
{ "symbol", _market.result.symbol },
{ "side", _buy_sell },
{ "ordType", "Market" },
{ "orderQty", quantity }
},
args
);
var _json_value = await tradeClient.CallApiPost1Async("/api/v1/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <BPlaceOrderItem>(_json_value.Content);
{
_order.orderType = OrderType.Market;
//_order.amount = (_order.quantity * _order.price).Normalize();
//_order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancel an order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(
new Dictionary <string, object>
{
{ "orderID", order_id }
},
args
);
var _json_value = await tradeClient.CallApiDelete1Async("/api/v1/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <List <BPlaceOrderItem> >(_json_value.Content);
var _order = _json_data.FirstOrDefault();
if (_order != null)
{
_result.result = _order;
}
else
{
_json_result.SetFailure();
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public async Task SlotImport(string line, IFormFile file)
{
try
{
List <string> noPns = new List <string>();
var filename = ContentDispositionHeaderValue
.Parse(file.ContentDisposition)
.FileName
.Trim('"');
filename = _hostingEnv.WebRootPath + $@"\{ filename }";
System.IO.File.Delete(filename);
using (FileStream fs = System.IO.File.Create(filename))
{
file.CopyTo(fs);
fs.Flush();
}
var lines = System.IO.File.ReadLines(filename).ToArray();
string machine = null, product = null, table = null, machineType = null, version = null, slotName = null;
SideType boardSide = SideType.T;
SideType side = SideType.L;
List <Slot> listSlot = new List <Slot>();
if (lines[0].TrimStart().StartsWith("Machine")) // NXT 料站表
{
machineType = "NXT";
foreach (var l in lines)
{
var strs = l.Split("\t", StringSplitOptions.RemoveEmptyEntries);
if (strs.Length == 2 && strs[0] == "Machine") // 获取机器名
{
machine = strs[1];
}
if (strs.Length == 2 && strs[0].StartsWith("Recipe")) // 获取机种
{
var ps = strs[1].Split("_", StringSplitOptions.RemoveEmptyEntries);
product = ps[0].Substring(0, ps[0].Length - 1);
if (ps[0].Substring(ps[0].Length - 1) == "S")
{
boardSide = SideType.B;
}
else
{
boardSide = SideType.T;
}
}
if (strs.Length == 2 && strs[0] == "Revision") // 获取版本
{
version = strs[1];
}
if (strs.Length == 7 && strs[0].Contains("- "))
{
var partNoId = strs[1].Trim();
if (partNoId != null && _repositoryMPN.FirstOrDefault(partNoId) != null)
{
if (int.Parse(strs[5]) == 0)
{
continue;
}
table = strs[0].Trim().Split(" ", StringSplitOptions.RemoveEmptyEntries)[0].Replace("-", "");
var slot = _repositorySlot.FirstOrDefault(s => s.BoardSide == boardSide && s.Machine == machine && s.ProductId == product && s.LineId == line && s.Table == table && s.PartNoId == partNoId && s.SlotName == strs[0]);
if (slot == null)
{
listSlot.Add(new Slot()
{
BoardSide = boardSide,
Feeder = strs[4],
IsActive = true,
LineId = line,
Machine = machine,
PartNoId = partNoId,
Version = version,
Table = table,
SlotName = strs[0],
Side = SideType.L,
Qty = int.Parse(strs[5]),
ProductId = product,
MachineType = machineType,
Location = string.Join(",", strs[6].Trim().Replace("\"", "").Replace("-", "").Split(' ', StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries).Length > 1 ?
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[1] :
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[0]).Distinct().OrderBy(s => s)),
LineSide = SideType.L,
});
}
else
{
slot.BoardSide = boardSide;
slot.Feeder = strs[4];
slot.IsActive = true;
slot.LineId = line;
slot.Machine = machine;
slot.PartNoId = partNoId;
slot.Version = version;
slot.Table = table;
slot.SlotName = strs[0];
slot.Side = SideType.L;
slot.Qty = int.Parse(strs[5]);
slot.ProductId = product;
slot.MachineType = machineType;
slot.Location = string.Join(",", strs[6].Trim().Replace("\"", "").Replace("-", "").Split(' ', StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries).Length > 1 ?
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[1] :
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[0]).OrderBy(s => s));
slot.LineSide = SideType.L;
listSlot.Add(slot);
}
}
}
if (strs.Length == 6 && strs[0].Contains("- "))
{
var partNoId = strs[1].Trim();
if (int.Parse(strs[4]) == 0)
{
continue;
}
if (partNoId != null && _repositoryMPN.FirstOrDefault(partNoId) != null)
{
table = strs[0].Split(" ", StringSplitOptions.RemoveEmptyEntries)[0].Replace("-", "");
var slot = _repositorySlot.FirstOrDefault(s => s.BoardSide == boardSide && s.Machine == machine && s.ProductId == product && s.LineId == line && s.Table == table && s.PartNoId == partNoId && s.SlotName == strs[0]);
if (slot == null)
{
listSlot.Add(new Slot()
{
BoardSide = boardSide,
IsActive = true,
LineId = line,
Machine = machine,
PartNoId = partNoId,
Version = version,
Table = table,
SlotName = strs[0],
Side = SideType.L,
Qty = int.Parse(strs[4]),
ProductId = product,
MachineType = machineType,
Location = string.Join(",", strs[5].Trim().Replace("\"", "").Replace("-", "").Split(' ', StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries).Length > 1 ?
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[1] :
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[0]).OrderBy(s => s)),
LineSide = SideType.L,
});
}
else
{
slot.BoardSide = boardSide;
slot.IsActive = true;
slot.LineId = line;
slot.Machine = machine;
slot.PartNoId = partNoId;
slot.Version = version;
slot.Table = table;
slot.SlotName = strs[0];
slot.Side = SideType.L;
slot.Qty = int.Parse(strs[4]);
slot.ProductId = product;
slot.MachineType = machineType;
slot.Location = string.Join(",", strs[5].Trim().Replace("\"", "").Replace("-", "").Split(' ', StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries).Length > 1 ?
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[1] :
s.Trim().Split(':', StringSplitOptions.RemoveEmptyEntries)[0]).OrderBy(s => s));
slot.LineSide = SideType.L;
listSlot.Add(slot);
}
}
}
}
}
if (lines[0].TrimStart().Contains("Lot")) // CM 料站表
{
machineType = "CM";
DataTable dataTable = _fileHelperService.OpenCSV(filename);
foreach (DataRow item in dataTable.Rows)
{
if (item[0].ToString().Contains("Lot")) //
{
var strs = item[0].ToString().Split(":");
var ps = strs[1].Split(new char[] { '-', '_' }, StringSplitOptions.RemoveEmptyEntries);
product = ps[0].Substring(0, ps[0].Length - 1).Trim();
version = ps[1].Trim();
if (ps[0].Substring(ps[0].Length - 1).Trim() == "S")
{
boardSide = SideType.B;
}
else
{
boardSide = SideType.T;
}
}
if (item[0].ToString().Contains("MC") && !item[0].ToString().Contains("File"))
{
machine = item[0].ToString().Split(":", StringSplitOptions.RemoveEmptyEntries)[1];
}
var partNoId = item[2].ToString().Trim();
// 查询料号是否维护
if (partNoId != null && _repositoryMPN.FirstOrDefault(partNoId) != null)
{
if (int.Parse(item[7].ToString().Trim()) == 0)
{
continue;
}
// 变更站位
if (item[1].ToString().Trim().Length > 0)
{
slotName = item[1].ToString().Trim();
}
table = item[0].ToString().Trim();
if (item[4].ToString().Trim() == "R")
{
side = SideType.R;
}
else
{
side = SideType.L;
}
var slot = _repositorySlot.FirstOrDefault(s => s.BoardSide == boardSide && s.Machine == machine && s.ProductId == product && s.LineId == line && s.Table == table && s.PartNoId == partNoId && s.SlotName == slotName && s.Side == side);
if (slot == null)
{
listSlot.Add(new Slot()
{
BoardSide = boardSide,
Feeder = item[5].ToString().Trim(),
IsActive = true,
LineId = line,
Machine = machine,
PartNoId = partNoId,
Version = version,
Table = table,
SlotName = slotName,
Side = side,
Qty = int.Parse(item[7].ToString().Trim()),
ProductId = product,
MachineType = machineType,
Location = string.Join(",", item[8].ToString().Trim().Replace("\"", "").Replace("-", "").Split(',', StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).OrderBy(s => s)),
LineSide = SideType.L,
});
}
else
{
slot.BoardSide = boardSide;
slot.Feeder = item[5].ToString().Trim();
slot.IsActive = true;
slot.LineId = line;
slot.Machine = machine;
slot.PartNoId = partNoId;
slot.Version = version;
slot.Table = table;
slot.SlotName = slotName;
slot.Side = side;
slot.Qty = int.Parse(item[7].ToString().Trim());
slot.ProductId = product;
slot.MachineType = machineType;
slot.Location = string.Join(",", item[8].ToString().Trim().Replace("\"", "").Replace("-", "").Split(',', StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).OrderBy(s => s));
slot.LineSide = SideType.L;
listSlot.Add(slot);
}
}
}
}
if (lines[0].TrimStart().StartsWith("Recipe")) // NPM 料站表
{
machineType = "NPM";
DataTable dataTable = _fileHelperService.OpenCSV(filename);
foreach (DataRow item in dataTable.Rows)
{
if (item[0].ToString().Contains("Recipe")) //
{
var strs = item[0].ToString().Split(":");
var ps = strs[1].Split("_", StringSplitOptions.RemoveEmptyEntries);
product = ps[0].Substring(0, ps[0].Length - 1).Trim();
version = ps[1].Trim();
if (ps[0].Substring(ps[0].Length - 1).Trim() == "S")
{
boardSide = SideType.B;
}
else
{
boardSide = SideType.T;
}
}
var partNoId = item[5].ToString().Trim();
// 查询料号是否维护
if (partNoId != null && _repositoryMPN.FirstOrDefault(partNoId) != null)
{
if (int.Parse(item[7].ToString().Trim()) == 0)
{
continue;
}
// 变更站位
if (item[3].ToString().Trim().Length > 0)
{
slotName = item[3].ToString().Trim();
}
table = item[2].ToString().Trim();
if (item[4].ToString().Trim() == "R")
{
side = SideType.R;
}
else
{
side = SideType.L;
}
machine = item[1].ToString().Trim();
var slot = _repositorySlot.FirstOrDefault(s => s.BoardSide == boardSide && s.Machine == machine && s.ProductId == product && s.LineId == line && s.Table == table && s.PartNoId == partNoId && s.SlotName == slotName && s.Side == side);
if (slot == null)
{
listSlot.Add(new Slot()
{
BoardSide = boardSide,
Feeder = item[6].ToString().Trim(),
IsActive = true,
LineId = line,
Machine = machine,
PartNoId = partNoId,
Version = version,
Table = table,
SlotName = slotName,
Side = side,
Qty = int.Parse(item[7].ToString().Trim()),
ProductId = product,
MachineType = machineType,
Location = string.Join(",", item[8].ToString().Trim().Replace("\"", "").Replace("-", "").Split(',', StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).OrderBy(s => s)),
LineSide = SideType.L,
});
}
else
{
slot.BoardSide = boardSide;
slot.Feeder = item[6].ToString().Trim();
slot.IsActive = true;
slot.LineId = line;
slot.Machine = machine;
slot.PartNoId = partNoId;
slot.Version = version;
slot.Table = table;
slot.SlotName = slotName;
slot.Side = side;
slot.Qty = int.Parse(item[7].ToString().Trim());
slot.ProductId = product;
slot.MachineType = machineType;
slot.Location = string.Join(",", item[8].ToString().Trim().Replace("\"", "").Replace("-", "").Split(',', StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).OrderBy(s => s));
slot.LineSide = SideType.L;
listSlot.Add(slot);
}
}
else
{
if (item[5].ToString().Trim().Length > 0)
{
noPns.Add(item[5].ToString().Trim());
}
}
}
}
int slotIndex = 1;
foreach (var item in listSlot)
{
item.Index = slotIndex;
slotIndex++;
await _repositorySlot.InsertOrUpdateAsync(item);
}
CurrentUnitOfWork.SaveChanges();
// 将不在本次料表中的站位更新为无效
// 查询该机种该线别该版本
var NoActives = _repositorySlot.GetAll().Where(r => r.BoardSide == listSlot.FirstOrDefault().BoardSide&& r.ProductId == listSlot.FirstOrDefault().ProductId&& r.LineId == listSlot.FirstOrDefault().LineId&& !listSlot.Select(s => s.Id).Contains(r.Id)).ToArray();
foreach (var item in NoActives)
{
item.IsActive = false;
await _repositorySlot.UpdateAsync(item);
}
System.IO.File.Delete(filename);
}
catch (Exception ex)
{
throw new LYException(ex.Message);
}
}
/// <summary>
/// Generate a random radio call sign. Optionally specify a side of the Mississippi River to limit stations to that side.
/// </summary>
/// <param name="sideType"></param>
/// <returns></returns>
public string Radio(SideType? sideType = null)
{
// Initial Letter (Typically Designated by SideType of Mississippi River)
string fl;
switch (sideType)
{
case SideType.East:
fl = "W";
break;
case SideType.West:
fl = "K";
break;
default:
fl = Character(pool: "KW").ToString(CultureInfo.InvariantCulture);
break;
}
return string.Format("{0}{1}{2}{3}", fl, Character(alpha: true, casing: CasingType.Upper), Character(alpha: true, casing: CasingType.Upper), Character(alpha: true, casing: CasingType.Upper));
}
internal OrderSample(SecDBFileReader file, OrderSample ps, DateTime ts, Stream stream)
: base(ts)
{
var flags = SecDBPrimitives.ReadByte(stream);
InternalOrder = (flags & (1)) !=0;
CancelAll = (flags >> 1) !=0;
if (!CancelAll)
{
IsActive = (flags >> 2) !=0;
IsReplacement = (flags >> 3) !=0;
Side = (SideType)((flags >> 4)&0x1);
IsTakeProfit = (flags >> 5) !=0;
IsStopLoss = (flags >> 6) !=0;
OrderID = SecDBPrimitives.ReadSLEB128(stream);
if (IsActive)
{
var price = SecDBPrimitives.ReadSLEB128(stream);
if (ps!=null)
PriceStep = price;
else
PriceStep = ps.PriceStep + price;
Price = PriceStep * file.SystemHeader.PriceStep;
Qty = SecDBPrimitives.ReadSLEB128(stream);
}
if (IsReplacement)
OldOrderID = SecDBPrimitives.ReadSLEB128(stream);
}
}
/// <summary>
/// Used to place a limit order in a specific market.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("method", "order");
_params.Add("currency", _market.result.symbol);
_params.Add("price", price);
_params.Add("amount", quantity);
_params.Add("tradeType", sideType == SideType.Bid ? 1 : 0);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async($"/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <ZPlaceOrder>(_json_value.Content);
{
var _orderItem = _order.result;
{
_orderItem.symbol = _market.result.symbol;
_orderItem.orderType = OrderType.Limit;
_orderItem.orderStatus = OrderStatus.Open;
_orderItem.sideType = sideType;
_orderItem.quantity = quantity;
_orderItem.price = price;
_orderItem.amount = quantity * price;
//_orderItem.fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker;
_orderItem.timestamp = CUnixTime.NowMilli;
};
_result.result = _orderItem;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Place an order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("side", _buy_sell); // order side
_params.Add("instrument", _market.result.symbol); // currency pair of market
_params.Add("type", "limit"); // order type
_params.Add("currency", _market.result.baseId); // order currency
_params.Add("amount", quantity.Normalize(4).ToString()); // order amount; maximum of 4 decimal places of precision
_params.Add("display", quantity.ToString()); // display amount for iceberg orders
_params.Add("price", price.Normalize(2).ToString()); // order price; maximum of 2 decimal places of precision
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/v1/wallets/{__wallet_id}/orders", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <TPlaceOrderItem>(_json_value.Content);
{
_order.amount = quantity * price;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Used to place a limit order in a specific market.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateLimitOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("pair", _market.result.symbol);
_params.Add("order_type", _buy_sell);
_params.Add("rate", price);
_params.Add("amount", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/api/exchange/orders", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <CPlaceOrderItem>(_json_value.Content);
{
_order.orderType = OrderType.Limit;
_order.orderStatus = OrderStatus.Open;
_order.amount = (_order.quantity * _order.price).Normalize();
//_order.fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
internal TradeSample(SecDBFileReader file, TradeSample ps, DateTime ts, Stream stream)
: base(ts)
{
var flags = SecDBPrimitives.ReadByte(stream);
InternalTrade = (flags & (1)) !=0;
Aggressor = (AggressorType)((flags >> 1)&0x3);
Side = (SideType)((flags >> 3)&0x1);
IsQty = (flags & (1 << 4)) !=0;
IsTradeID = (flags & (1 << 5)) !=0;
IsOrderID = (flags & (1 << 6)) !=0;
var price = SecDBPrimitives.ReadSLEB128(stream);
if (ps==null)
PriceStep = price;
else
PriceStep = ps.PriceStep + price;
Price = PriceStep * file.SystemHeader.PriceStep;
if (IsQty) Qty = SecDBPrimitives.ReadSLEB128(stream);
if (IsTradeID) TradeID = SecDBPrimitives.ReadULEB128(stream);
if (IsOrderID) OrderID = SecDBPrimitives.ReadULEB128(stream);
}
private Vector2I CreateSide(Vector2I location, Direction direction, SideType sideType)
{
var target = GetTargetLocation(location, direction);
if (direction.Equals(Direction.North))
{
this[location].NorthSide = sideType;
this[target].SouthSide = sideType;
}
else if (direction.Equals(Direction.South))
{
this[location].SouthSide = sideType;
this[target].NorthSide = sideType;
}
else if (direction.Equals(Direction.West))
{
this[location].WestSide = sideType;
this[target].EastSide = sideType;
}
else if (direction.Equals(Direction.East))
{
this[location].EastSide = sideType;
this[target].WestSide = sideType;
}
return target;
}
public static TileFlag SlopeFlagFromSide(SideType side)
{
if (side == SideType.LeftSide)
{
return TileFlag.LeftSlope;
}
if (side == SideType.RightSide)
{
return TileFlag.RightSlope;
}
if (side == SideType.TopSide)
{
return TileFlag.TopSlope;
}
return TileFlag.BottomSlope;
}
public static bool Vertical(SideType side)
{
return side == SideType.TopSide || side == SideType.BottomSide;
}
public static bool IsMin(SideType side)
{
return !IsMax(side);
}
/// <summary>
/// Cancel Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("order_id", Convert.ToInt64(order_id));
tradeClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexClient.CheckFuturesUrl(_market.result, "/cancel_order.do", "/future_cancel.do", _params);
var _json_value = await okexClient.CallApiPost1Async(_end_point.endPoint, _end_point.args);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = okexClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = okexClient.DeserializeObject <OCancelOrderItem>(_json_value.Content);
{
var _order_id = "";
var _order_status = OrderStatus.Unknown;
{
if (String.IsNullOrEmpty(_json_data.success) == false)
{
_order_id = _json_data.success;
_order_status = OrderStatus.Canceled;
}
else if (String.IsNullOrEmpty(_json_data.failure) == false)
{
_order_id = _json_data.failure;
_order_status = OrderStatus.Unknown;
}
}
if (String.IsNullOrEmpty(_order_id) == false)
{
var _order = new OMyOrderItem
{
symbol = _market.result.symbol,
orderId = _order_id,
orderType = OrderType.Limit,
orderStatus = _order_status,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli
};
_result.result = _order;
}
else
{
_json_result.SetFailure();
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Used to cancel a buy or sell order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiDelete1Async($"/api/exchange/orders/{order_id}", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <CCancelOrderItem>(_json_value.Content);
{
_order.symbol = _market.result.symbol;
_order.orderType = OrderType.Limit;
_order.orderStatus = OrderStatus.Canceled;
_order.sideType = sideType;
_order.quantity = quantity;
_order.price = price;
_order.amount = (_order.quantity * _order.price).Normalize();
//_order.fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker;
_order.timestamp = CUnixTime.NowMilli;
}
_result.result = _order;
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancel an order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/orders/{order_id}/submitcancel", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <HPlaceOrder>(_json_value.Content);
{
var _order = new HPlaceOrderItem
{
symbol = _market.result.symbol,
orderId = _json_data.result.orderId,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Canceled,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli
};
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public static void GetInternalIntersectionPoint(this Cell cell, MathLine inputLine, Vector2 center, Vector2 direction, float offset, out SideType intersectionSide, out Vector2 intersectionPoint)
{
// Exclude Left side from calculations
var sides = cell.GetCellSides(offset).Where(i => i.Key != SideType.Left);
// Get best intersection data
GetIntersectionPoint(center, direction, sides, inputLine, out intersectionSide, out intersectionPoint);
}
// The API doesn't directly support market orders because they provide you with no price protection.
// Instead, use the “immediate-or-cancel” order execution option,
// coupled with an aggressive limit price(i.e.very high for a buy order or very low for a sell order), to achieve the same result.
/// <summary>
/// New Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("side", _buy_sell);
_params.Add("type", "exchange market");
_params.Add("amount", quantity);
_params.Add("price", price);
_params.Add("options", "immediate-or-cancel");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/new", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <GPlaceOrderItem>(_json_value.Content);
{
_order.amount = (_order.quantity * _order.price).Normalize();
_order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_order.orderStatus = _order.is_live == true && _order.quantity == _order.remaining ? OrderStatus.Open
: _order.is_live == true && _order.quantity != _order.remaining ? OrderStatus.Partially
: _order.is_cancelled == true ? OrderStatus.Canceled
: _order.remaining == 0 ? OrderStatus.Closed
: OrderStatus.Unknown;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
private Vector2 GetStumpVector(SideType side)
{
switch (side)
{
case SideType.Top: return new Vector2(0f, -1f);
case SideType.Bottom: return new Vector2(0f, 1f);
case SideType.Left: return new Vector2(1f, 0f);
case SideType.Right: return new Vector2(-1f, 0f);
default:
throw new System.NotImplementedException();
}
}
/// <summary>
/// Used to cancel a buy or sell order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("method", "cancelOrder");
_params.Add("currency", _market.result.symbol);
_params.Add("id", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiGet1Async($"/cancelOrder", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <ZPlaceOrder>(_json_value.Content);
if (_json_data.success == true)
{
var _order = new ZPlaceOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Canceled,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
timestamp = CUnixTime.NowMilli
};
_result.result = _order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
// Initialize a side with given type
public Side(SideType side)
{
m_side = side;
}
/// <summary>
/// Cancel Open Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency_pair", _market.result.symbol);
_params.Add("id", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/user/orders/cancel", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <List <KCancelOrderItem> >(_json_value.Content);
{
var _cancel_order = _json_data.FirstOrDefault();
if (_cancel_order != null)
{
var _order = new KMyOrderItem
{
orderId = _cancel_order.orderId,
symbol = _market.result.symbol,
timestamp = CUnixTime.NowMilli,
orderStatus = OrderStatus.Canceled,
orderType = OrderType.Limit,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _order;
var _success = _cancel_order.status == "success";
if (_success == false)
{
_json_result.SetFailure(_cancel_order.status, ErrorCode.OrderNotFound);
}
}
else
{
_json_result.SetFailure();
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.baseId);
_params.Add("units", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/trade/market_{_buy_sell}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BPlaceOrders>(_json_value.Content);
if (_json_data.success == true)
{
var _market_order = new BPlaceOrderItem
{
orderId = _json_data.orderId,
sideType = sideType,
orderType = OrderType.Market,
orderStatus = OrderStatus.Open,
timestamp = Convert.ToInt64(_json_data.orderId),
price = price,
quantity = quantity,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
filled = 0m,
cost = 0m
};
foreach (var _trade in _json_data.data)
{
_market_order.filled += _trade.quantity;
_market_order.cost += _trade.amount + _trade.fee;
}
_result.result = _market_order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Generate a TV station call sign. This is an alias for radio() since they both follow the same rules. Optionally specify a side of the Mississippi River to limit stations to that side.
/// </summary>
/// <param name="sideType"></param>
/// <returns></returns>
public string Tv(SideType? sideType = null)
{
return Radio(sideType);
}
public async Task <FtxResult <TriggerOrder> > PlaceTakeProfitOrderAsync(string instrument, SideType side, decimal triggerPrice, decimal amount, bool reduceOnly = false)
{
var path = $"api/conditional_orders";
var body =
$"{{\"market\": \"{instrument}\"," +
$"\"side\": \"{side}\"," +
$"\"triggerPrice\": {triggerPrice}," +
$"\"type\": \"takeProfit\"," +
$"\"size\": {amount}," +
$"\"reduceOnly\": {reduceOnly.ToString().ToLower()}}}";
var sign = GenerateSignature(HttpMethod.Post, "/api/conditional_orders", body);
var result = await CallAsyncSign(HttpMethod.Post, path, sign, body);
return(JsonSerializer.Deserialize <FtxResult <TriggerOrder> >(result));
}
/// <summary>
/// Update an order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public async Task <MyOrder> UpdateOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(
new Dictionary <string, object>
{
{ "orderID", order_id },
{ "orderQty", quantity },
{ "price", price }
},
args
);
var _json_value = await tradeClient.CallApiPut1Async("/api/v1/order", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BPlaceOrderItem>(_json_value.Content);
_result.result = _json_data;
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Order_V2 - Limit Buy/Sell
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("price", price);
_params.Add("qty", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/v2/order/limit_{_buy_sell}", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <CPlaceOrder>(_json_value.Content);
if (_json_data.success == true)
{
var _order = new CPlaceOrderItem
{
orderId = _json_data.orderId.ToUpper(),
timestamp = CUnixTime.NowMilli,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Open,
sideType = sideType,
price = price,
quantity = quantity,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker,
filled = 0m,
cost = 0m
};
_result.result = _order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancel an Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = tradeClient.MergeParamsAndArgs(args);
var _json_value = await tradeClient.CallApiPut1Async($"/orders/{order_id}/cancel", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <QPlaceOrderItem>(_json_value.Content);
{
_order.amount = (_order.quantity * _order.price).Normalize();
_order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order;
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public static bool Horizontal(SideType side)
{
return !Vertical(side);
}
/// <summary>
/// DeSerialize the Side object from XML String
/// </summary>
/// <returns>XML containing the Side object state XML</returns>
public void XmlDeserialize(XmlNode xmlSide)
{
// Serialize and append to the side object
m_side = (SideType)XMLHelper.XmlDeserialize(typeof(SideType), xmlSide.InnerXml);
}
/// <summary>
/// create new market order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("pair", _market.result.symbol);
_params.Add("type", _buy_sell);
_params.Add("ordertype", "market");
//_params.Add("price", price); // (optional. dependent upon ordertype)
//_params.Add("price2", "?"); // secondary price (optional. dependent upon ordertype)
_params.Add("volume", quantity); // order volume in lots
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/0/private/AddOrder", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <KResponse <KMyPlaceOrder> >(_json_value.Content);
{
foreach (var _p in _json_data.result.transactionIds)
{
var _order = new KMyPlaceOrderItem
{
orderId = _p,
symbol = _market.result.symbol,
timestamp = CUnixTime.NowMilli,
orderType = OrderType.Market,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _order;
break;
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// bithumb 회원 판/구매 거래 취소
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "bid" : "ask";
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("order_id", order_id);
_params.Add("type", _buy_sell);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/trade/cancel", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <BPlaceOrder>(_json_value.Content);
if (_json_data.success == true)
{
var _cancel_order = new BPlaceOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
orderStatus = OrderStatus.Canceled,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _cancel_order;
}
else
{
_json_result.SetResult(_json_data);
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Cancel open order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrderAsync(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("txid", order_id);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/0/private/CancelOrder", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <KResponse <KMyCancelOrder> >(_json_value.Content);
if (_json_data.result.count > 0)
{
var _order = new KMyPlaceOrderItem
{
orderId = order_id,
symbol = _market.result.symbol,
orderType = OrderType.Unknown,
sideType = sideType,
timestamp = CUnixTime.NowMilli,
quantity = quantity,
price = price,
amount = quantity * price,
count = _json_data.result.count,
pending = _json_data.result.pending
};
_result.result = _order;
}
else
{
_json_result.SetFailure();
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Submit a new Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("side", _buy_sell);
_params.Add("amount", quantity.ToString());
_params.Add("price", price.ToString());
_params.Add("type", "exchange market");
_params.Add("ocoorder", false);
_params.Add("buy_price_oco", 0);
_params.Add("sell_price_oco", 0);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/new", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <BPlaceOrderItem>(_json_value.Content);
{
_order.orderType = OrderType.Market;
_order.amount = (_order.quantity * _order.price).Normalize();
_order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// 지정가 주문
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateLimitOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("currencyPair", _market.result.symbol);
_params.Add("rate", price);
_params.Add("amount ", quantity);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/1/private/{_buy_sell}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <GPlaceOrderItem>(_json_value.Content);
{
_json_data.amount = _json_data.quantity * _json_data.price;
_json_data.orderType = OrderType.Limit;
_json_data.orderStatus = _json_data.remaining_volume == 0.0m ? OrderStatus.Closed
: _json_data.filled == 0.0m ? OrderStatus.Open
: OrderStatus.Partially;
_json_data.quantity = _json_data.remaining_volume + _json_data.filled;
_json_data.sideType = SideTypeConverter.FromString(_buy_sell);
_json_data.symbol = _market.result.symbol;
_json_data.timestamp = CUnixTime.NowMilli;
_result.result = _json_data;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Order_V2 - Cancel Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("currency", _market.result.symbol);
_params.Add("order_id", order_id);
_params.Add("price", price);
_params.Add("qty", quantity);
_params.Add("is_ask", sideType == SideType.Ask ? 1 : 0);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async("/v2/order/cancel", _params);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
//var _json_data = tradeClient.DeserializeObject<JToken>(_json_value.Content);
{
var _order = new MyOrderItem
{
orderId = order_id.ToUpper(),
symbol = _market.result.symbol,
sideType = sideType,
quantity = quantity,
price = price,
amount = quantity * price
};
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// 주문 취소
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="order_id">Order number registered for sale or purchase</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CancelOrder(string base_name, string quote_name, string order_id, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _params = new Dictionary <string, object>();
{
_params.Add("orderNumber", order_id);
_params.Add("currencyPair", _market.result.symbol);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/1/private/cancelOrder", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = tradeClient.DeserializeObject <GCancelOrder>(_json_value.Content);
{
if (_json_data.success == true)
{
_json_data.price = price;
_json_data.quantity = quantity;
_json_data.amount = _json_data.quantity * _json_data.price;
_json_data.orderId = order_id;
_json_data.orderStatus = OrderStatus.Canceled;
_json_data.orderType = OrderType.Limit;
_json_data.symbol = _market.result.symbol;
_json_data.timestamp = CUnixTime.NowMilli;
_result.result = _json_data;
}
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Submit a new Order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
if (args.ContainsKey("account-id") && args["account-id"].ToString() != "")
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("account-id", args["account-id"].ToString());
_params.Add("amount", quantity.ToString());
//_params.Add("source", ); // 'api' for spot trade and 'margin-api' for margin trade
_params.Add("symbol", _market.result.symbol);
_params.Add("type", _buy_sell + "-market");
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/v1/order/orders/place", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <HPlaceOrder>(_json_value.Content);
{
_order.result.orderType = OrderType.Market;
//_order.result.price = price;
_order.result.quantity = quantity;
_order.result.sideType = sideType;
_order.result.symbol = _market.result.symbol;
_order.result.timestamp = CUnixTime.NowMilli;
//_order.result.amount = (_order.result.quantity * _order.result.price).Normalize();
_order.result.fee = _order.result.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order.result;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetFailure("required args[account-id]");
}
}
else
{
_result.SetResult(_market);
}
return(_result);
}
public Die(SideType side)
{
this.TopSide = side;
}
/// <summary>
/// Place Limit Order.
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async ValueTask <MyOrder> CreateLimitOrderAsync(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarketAsync(_result.marketId);
if (_market.success == true)
{
okexClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "buy" : "sell";
var _params = new Dictionary <string, object>();
{
_params.Add("symbol", _market.result.symbol);
_params.Add("type", _buy_sell);
_params.Add("amount", quantity);
_params.Add("price", price);
tradeClient.MergeParamsAndArgs(_params, args);
}
var _end_point = okexClient.CheckFuturesUrl(_market.result, "/trade.do", "/future_trade.do", _params);
var _json_value = await okexClient.CallApiPost1Async(_end_point.endPoint, _end_point.args);
#if RAWJSON
_result.rawJson = _json_value.Content;
#endif
var _json_result = okexClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _json_data = okexClient.DeserializeObject <OPlaceOrderItem>(_json_value.Content);
if (_json_data.result == true)
{
var _order = new OPlaceOrderItem
{
orderId = _json_data.orderId.ToUpper(),
timestamp = CUnixTime.NowMilli,
orderType = OrderType.Limit,
orderStatus = OrderStatus.Open,
sideType = sideType,
price = price,
quantity = quantity,
amount = quantity * price,
//fee = quantity * price * publicApi.ExchangeInfo.Fees.trading.maker
};
_result.result = _order;
}
else
{
_result.SetFailure();
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
/// <summary>
/// Place market order
/// </summary>
/// <param name="base_name">The type of trading base-currency of which information you want to query for.</param>
/// <param name="quote_name">The type of trading quote-currency of which information you want to query for.</param>
/// <param name="quantity">amount of coin</param>
/// <param name="price">price of coin</param>
/// <param name="sideType">type of buy(bid) or sell(ask)</param>
/// <param name="args">Add additional attributes for each exchange</param>
/// <returns></returns>
public override async Task <MyOrder> CreateMarketOrder(string base_name, string quote_name, decimal quantity, decimal price, SideType sideType, Dictionary <string, object> args = null)
{
var _result = new MyOrder(base_name, quote_name);
var _market = await publicApi.LoadMarket(_result.marketId);
if (_market.success == true)
{
tradeClient.ExchangeInfo.ApiCallWait(TradeType.Trade);
var _buy_sell = sideType == SideType.Bid ? "BUY" : "SELL";
var _params = new Dictionary <string, object>();
{
_params.Add("type", _buy_sell);
_params.Add("amount", quantity);
_params.Add("price", price);
// limit, market별 request param 설명이 없음, response 다름(https://cex.io/rest-api) -> Place order
tradeClient.MergeParamsAndArgs(_params, args);
}
var _json_value = await tradeClient.CallApiPost1Async($"/place_order/{_market.result.symbol}", _params);
#if DEBUG
_result.rawJson = _json_value.Content;
#endif
var _json_result = tradeClient.GetResponseMessage(_json_value.Response);
if (_json_result.success == true)
{
var _order = tradeClient.DeserializeObject <CPlaceOrderItem>(_json_value.Content); // limit order랑 넘어오는 데이터가 다름
{
_order.orderType = OrderType.Market;
_order.amount = (_order.quantity * _order.price).Normalize();
_order.fee = _order.amount * tradeClient.ExchangeInfo.Fees.trading.maker;
_result.result = _order;
}
}
_result.SetResult(_json_result);
}
else
{
_result.SetResult(_market);
}
return(_result);
}
