public static void QueueAllButOpenOrders(OpenOrder ord)
{
//Queues all but certain open orders
DexConnection dex = null;
lock (DexConnectionList)
{
for (int i = 0; i < DexConnectionList.Count; i++)
{
if (DexConnectionList[i].contype == 3 && DexConnectionList[i].outgoing == true && DexConnectionList[i].open == true)
{
dex = DexConnectionList[i]; break; //Found our connection
}
}
}
//Queue all the open orders not already queued that don't match our open order
lock (MyOpenOrderList)
{
for (int i = MyOpenOrderList.Count - 1; i >= 0; i--)
{
if (MyOpenOrderList[i].queued_order == false && MyOpenOrderList[i].order_nonce.Equals(ord.order_nonce) == false)
{
QueueMyOrderNoLock(MyOpenOrderList[i], dex);
}
}
}
}
public async Task DoP2POffer(string toUserId = null)
{
string p2POffer = JwtProviderBuilder.P2P
.AddOffer("p2p-" + toUserId, "1")
.AddSender(UserId, "p2p", "to myself")
.AddRecipient(toUserId ?? UserId, "p2p", "to him?")
.Jwt;
OpenOrder createExternalP2POffer =
await _marketPlaceClient.CreateExternalOffer(p2POffer).ConfigureAwait(false);
Order submitP2POffer =
await _marketPlaceClient.SubmitOrder(createExternalP2POffer.Id).ConfigureAwait(false);
SubmitTransactionResponse submitTransactionResponse = await _blockChainHandler.SendPayment(_keyPair,
submitP2POffer.BlockChainData.RecipientAddress,
submitP2POffer.Amount, submitP2POffer.Id).ConfigureAwait(false);
Order finishedOrder = await WaitForOrderCompletion(UserId, submitP2POffer.Id).ConfigureAwait(false);
if (!string.IsNullOrEmpty(finishedOrder?.Result?.Jwt))
{
SecurityToken token = _marketPlaceJwtProvider.ValidateJwtToken(finishedOrder?.Result?.Jwt);
}
}
public static List <OpenOrder> BittrexToOpenOrders(BittrexOrder[] bittrexOrders)
{
var list = new List <OpenOrder>();
foreach (var openOrder in bittrexOrders)
{
var pair = openOrder.Exchange.Split("-");
var order = new OpenOrder
{
Base = pair[0],
Terms = pair[1],
Exchange = Constants.Bittrex,
CommissionPaid = openOrder.CommissionPaid,
OrderUuid = openOrder.OrderUuid.ToString(),
Condition = openOrder.Condition,
ConditionTarget = openOrder.ConditionTarget,
CancelInitiated = openOrder.CancelInitiated,
ImmediateOrCancel = openOrder.ImmediateOrCancel,
IsConditional = openOrder.IsConditional,
Limit = openOrder.Limit,
Opened = openOrder.Opened,
Price = openOrder.Price,
Quantity = openOrder.Quantity,
QuantityRemaining = openOrder.QuantityRemaining,
Side = openOrder.OrderType == OrderTypeExtended.LimitBuy ? TradeSide.Buy : TradeSide.Sell
};
list.Add(order);
}
return(list);
}
private void remakeOrder(OpenOrder order, bool fOnlyRecreate = false)
{
if (!fOnlyRecreate)
{
Status.setStatusByOrder(order.OrderUuid, "Cancelling...");
if (!Bridge.cancelOrder(order.OrderUuid).Result)
{
Status.setStatusByOrder(order.OrderUuid, "Failed to Cancel");
return;
}
ToBackup.Push(order);
Status.setStatusByOrder(order.OrderUuid, "Canceled");
}
System.Threading.Thread.Sleep(1000);
Status.setStatusByOrder(order.OrderUuid, "Recreating...");
if (!Bridge.createOrder(order, cancelAwait).Result)
{
Status.setStatusByOrder(order.OrderUuid, "Unknown order");
return;
}
ToErase.Add(order.OrderUuid);
Status.removeStatusByOrder(order.OrderUuid);
return;
}
public OpenOrder Get()
{
OpenOrder auxOrder = new OpenOrder
{
CancelInitiated = this.CancelInitiated,
Closed = this.Closed,
CommissionPaid = this.CommissionPaid,
Condition = this.Condition,
ConditionTarget = this.Exchange,
Exchange = this.Exchange,
Limit = this.Limit,
Opened = this.Opened,
OrderType = this.OrderType,
OrderUuid = this.OrderUuid,
Price = this.Price,
QuantityRemaining = this.QuantityRemaining,
Uuid = this.Uuid,
Quantity = this.Quantity,
PricePerUnit = this.PricePerUnit,
IsConditional = this.IsConditional,
ImmediateOrCancel = this.ImmediateOrCancel
};
return(auxOrder);
}
private async Task DoExternalSpendOffer()
{
string externalSpendOffer = JwtProviderBuilder.Spend
.AddOffer("spendit", "111")
.AddSender(UserId, "speeend it", "block chain sutff isn't coded yet lawl, i'm neva goonna spend")
.Jwt;
OpenOrder createExternalSpendOffer =
await _marketPlaceClient.CreateExternalOffer(externalSpendOffer).ConfigureAwait(false);
Order submitSpendOffer =
await _marketPlaceClient.SubmitOrder(createExternalSpendOffer.Id).ConfigureAwait(false);
SubmitTransactionResponse submitTransactionResponse = await _blockChainHandler.SendPayment(_keyPair,
submitSpendOffer.BlockChainData.RecipientAddress,
submitSpendOffer.Amount, submitSpendOffer.Id).ConfigureAwait(false);
Order finishedOrder = await WaitForOrderCompletion(UserId, submitSpendOffer.Id).ConfigureAwait(false);
if (!string.IsNullOrEmpty(finishedOrder?.Result?.Jwt))
{
SecurityToken token = _marketPlaceJwtProvider.ValidateJwtToken(finishedOrder?.Result?.Jwt);
}
}
public static List <OpenOrder> PoloniexToOpenOrders(Dictionary <string, List <Order> > orders)
{
var list = new List <OpenOrder>();
foreach (var openOrderPair in orders)
{
foreach (var openOrder in openOrderPair.Value)
{
var ccy = openOrderPair.Key.Split('_');
var order = new OpenOrder
{
Exchange = Constants.Poloniex,
Side = openOrder.Type == Jojatekok.PoloniexAPI.OrderType.Buy ? TradeSide.Buy : TradeSide.Sell,
Base = ccy[0],
Terms = ccy[1],
Opened = DateTime.Now,
Quantity = Convert.ToDecimal(openOrder.AmountQuote),
Price = Convert.ToDecimal(openOrder.PricePerCoin),
OrderUuid = openOrder.IdOrder.ToString()
};
list.Add(order);
}
}
return(list);
}
private async Task <Order> DoFirstOffer()
{
OfferList offers = await _marketPlaceClient.GetOffers().ConfigureAwait(false);
//lets do the tutorial!
Offer offer = offers.Offers.SingleOrDefault(o => o.ContentType.Equals("tutorial"));
//This won't go through because the Kin asset isn't trusted yet
if (offer != null)
{
OpenOrder orderResponse = await _marketPlaceClient.CreateOrderForOffer(offer.Id).ConfigureAwait(false);
Order submitOrder = await _marketPlaceClient.SubmitOrder(orderResponse.Id).ConfigureAwait(false);
Order finishedOrder = await WaitForOrderCompletion(UserId, submitOrder.Id).ConfigureAwait(false);
if (!string.IsNullOrEmpty(finishedOrder?.OrderResult?.Jwt))
{
SecurityToken token = _marketPlaceJwtProvider.ValidateJwtToken(finishedOrder?.OrderResult?.Jwt);
}
return(finishedOrder);
}
throw new Exception("no offers dawg");
}
protected void OrderList_ItemCommand(object sender, ListViewCommandEventArgs e)
{
MessageUserControl.TryRun(() =>
{
// Note: POID is imbedded on each list row (with the CommandArgument parameter)
int poID = int.Parse(e.CommandArgument.ToString());
PurchaseOrderController sysmgr = new PurchaseOrderController();
OpenOrder openOrder = sysmgr.OpenOrder_FindByID(poID);
PurchaseOrderID.Text = openOrder.POID.ToString();
Number.Text = openOrder.PONumber.ToString();
Vendor.Text = openOrder.VendorName;
Phone.Text = openOrder.VendorPhone;
// Need to rebind data source before visibility enabled
ReturnList.DataBind();
// Load/Reload page content
ReloadPageContent(poID);
// Ensure insert template gets purchase order ID
HiddenField insertPOID = ReturnList.InsertItem.FindControl("PurchaseOrderIDField") as HiddenField;
insertPOID.Value = poID.ToString();
// Highlight selected row
OrderList.SelectedIndex = e.Item.DisplayIndex;
},
"Order Found",
"Order details successfully retrieved");
}
static bool IsValidStopLimitOrder(OpenOrder o)
{
return
(o.OrderType == OpenOrderType.Limit_Sell &&
o.Condition == "LESS_THAN" &&
!string.IsNullOrEmpty(o.ConditionTarget));
//&& o.Price < currentPrice // need current price!
}
public void OpenOrder_constructor_test()
{
Order order = new Order(1, BrokerDateTime.Make(DateTime.Now), "BP12345-RF-01", "RTS-9.13_FT", TradeAction.Buy, OrderType.Market, 10, 0, 0);
OpenOrder oo = new OpenOrder(order);
Assert.AreEqual(order, oo.Order);
Assert.AreEqual(order.Id, oo.OrderId);
Assert.AreEqual(order.Id, oo.Id);
}
public void writeOrder(OpenOrder order)
{
filestream.Position = filestream.Length;
norder.Assign(apiKeyStore, order);
formatter.Serialize(filestream, norder);
return;
}
/// <summary>
/// Get all orders that you currently have opened. A specific market can be requested
/// </summary>
/// <param name="market">requires a string literal for the market (ex: BTC-LTC)</param>
/// <returns>A list of open orders<returns>
public static List <OpenOrder> GetOpenOrders(string market)
{
string url = Constants.baseUrl + "market/getopenorders?apikey=" + Constants.ApiKey + "&market=" + market + "&nonce=" + nonce;
dynamic response = JsonConvert.DeserializeObject(HTTPMethods.HttpSignAndGet(url));
if (response.success == false)
{
if (response.success == "false")
{
throw new Exception("Unable to get data from API: " + response.message.ToString());
}
}
if (response.message == "INVALID_MARKET")
{
throw new ArgumentException("This is not a valid market. Use GetMarkets() to get a list of valid markets.");
}
List <OpenOrder> openOrdersList = new List <OpenOrder>();
if (response.result == null)
{
throw new NoOpenOrdersException();
}
else
{
foreach (var item in response.result)
{
string uuid = item.Uuid.ToString();
string orderUuid = item.OrderUuid.ToString();
string exchange = item.Exchange.ToString();
string orderType = item.OrderType.ToString();
double quantity = Convert.ToDouble(item.Quantity);
double quantityRemaining = Convert.ToDouble(item.QuantityRemaining);
double limit = Convert.ToDouble(item.Limit);
double commissionPaid = Convert.ToDouble(item.CommissionPaid);
double price = Convert.ToDouble(item.Price);
string pricePerUnit = item.PricePerUnit.ToString();
DateTime opened = Convert.ToDateTime(item.Opened);
string closed = item.Closed.ToString();
bool cancelInitiated = Convert.ToBoolean(item.CancelInitiated);
bool immediateOrCancel = Convert.ToBoolean(item.ImmediateOrCancel);
bool isConditional = Convert.ToBoolean(item.IsConditional);
string condition = item.Condition.ToString();
string conditionTarget = item.ConditionTarget.ToString();
OpenOrder openOrder = new OpenOrder(uuid, orderUuid, exchange, orderType, quantity, quantityRemaining, limit, commissionPaid, price, pricePerUnit, opened, closed,
cancelInitiated, immediateOrCancel, isConditional, condition, conditionTarget);
openOrdersList.Add(openOrder);
}
}
return(openOrdersList);
}
private void LoadOpenOrders()
{
var dt = new DataTable();
using (var sqlAdapter = new SQLiteDataAdapter("SELECT * from OpenOrders", conn))
sqlAdapter.Fill(dt);
foreach (DataRow row in Holdings.Tables["OpenOrders"].Rows)
{
//ADD OpenOrder obj TO OpenOrders ConcDICT in TradeControl
var openOrd = new OpenOrder((string)row["OrderUuid"], (string)row["Exchange"], (string)row["Type"], Convert.ToDecimal(row["TotalQuantity"]), Convert.ToDecimal(row["TotalReserved"]), Convert.ToDecimal(row["Quantity"]), Convert.ToDecimal(row["QuantityRemaining"]), Convert.ToDecimal(row["Limit"]), Convert.ToDecimal(row["Reserved"]), Convert.ToDecimal(row["CommissionReserved"]), Convert.ToDecimal(row["CommissionReservedRemaining"]), Convert.ToDecimal(row["CommissionPaid"]), Convert.ToDecimal(row["Price"]), Convert.ToDecimal(row["PricePerUnit"]), Convert.ToDateTime(row["Opened"]), (a) => OrderDataCallback(a), (a) => OrderExecutedCallback(a), (string)row["CandlePeriod"]);
BtrexREST.TradeController.RegisterOpenOrder(openOrd, (string)row["UniqueID"]);
}
}
public override async Task <ResponseWrapper <AcceptedOrder> > SellLimit(string marketName, decimal quantity, decimal rate)
{
var currentRate = (await GetTicker(marketName)).Result.Last;
var acceptedOrderId = Guid.NewGuid().ToString();
if (currentRate >= rate)
{
var order = new Order
{
Closed = DateTime.Now,
Exchange = marketName,
IsOpen = false,
Limit = rate,
Opened = DateTime.Now,
OrderUuid = acceptedOrderId,
Price = -quantity * rate,
PricePerUnit = rate,
Quantity = -quantity
};
simulatedFinishedOrders.Add(order);
var currency = Helper.GetTargetCurrencyFromMarketName(marketName);
removeBalance(currency, quantity);
}
else
{
var order = new OpenOrder
{
Closed = DateTime.Now,
Exchange = marketName,
Limit = rate,
Opened = DateTime.Now,
OrderUuid = acceptedOrderId,
Price = -quantity * rate,
PricePerUnit = rate,
Quantity = -quantity
};
simulatedOpenOrders.Add(order);
}
return(new ResponseWrapper <AcceptedOrder>
{
Success = true,
Result = new AcceptedOrder
{
Uuid = acceptedOrderId
}
});
}
private async Task RunExample()
{
// Using the ApiCredentials Class
// Client = new Api(new ApiCredentials(CexUsername, CexApiKey, CexApiSecret));
// Or not
// CexClient = new CexApi(CexUsername, CexApiKey, CexApiSecret);
// ApiCredentials/(Username, ApiKey, ApiSecret) not needed for public functions
CexClient = new CexApi();
// Get Ticker Data
Ticker tickerData = await CexClient.Ticker(SymbolPair.BTC_USD);
// Get Order Book
OrderBook orderBook = await CexClient.OrderBook(SymbolPair.BTC_USD);
// Get Trade history
IEnumerable <Trade> tradeHistory = await CexClient.TradeHistory(SymbolPair.BTC_USD);
// ApiCredentials required for user specific calls or "Private Functions"
CexClient = new CexApi(CexUsername, CexApiKey, CexApiSecret);
// Get Account Balance
Balance accountBalance = await CexClient.AccountBalance();
// Get Open Orders
IEnumerable <OpenOrder> openOrders = await CexClient.OpenOrders(SymbolPair.LTC_BTC);
// Place an order
OpenOrder openOrder = await CexClient.PlaceOrder(
SymbolPair.BTC_USD,
new Order
{
Amount = 1.00m,
Price = 0.04644000m,
Type = OrderType.Buy
});
// Cancel an order
bool didSucceed = await CexClient.CancelOrder(openOrder.Id);
// GHash.IO Example
GhashClient = new GhashApi(new ApiCredentials(CexUsername, CexApiKey, CexApiSecret));
// Get Hash Rate
Hashrate hashrate = await GhashClient.Hashrate();
// Get Workers Hash Rate
IEnumerable <KeyValuePair <string, WorkerHashrate> > workerHashRate = await GhashClient.WorkersHashRate();
}
public override async Task <AcceptedOrder> BuyLimit(string ccy1, string ccy2, decimal quantity, decimal rate)
{
string marketName = $"{ccy1}-{ccy2}";
var currentRate = (await GetTicker(ccy1, ccy2)).Last;
var acceptedOrderId = Guid.NewGuid().ToString();
if (currentRate <= rate)
{
var order = new Order
{
Closed = DateTime.Now,
Exchange = marketName,
IsOpen = false,
Limit = rate,
Opened = DateTime.Now,
OrderUuid = acceptedOrderId,
Price = quantity * rate,
PricePerUnit = rate,
Quantity = quantity
};
simulatedFinishedOrders.Add(order);
var currency = Helper.GetTargetCurrencyFromMarketName(marketName);
addBalance(currency, quantity);
}
else
{
var order = new OpenOrder
{
Closed = DateTime.Now,
Exchange = marketName,
Limit = rate,
Opened = DateTime.Now,
OrderUuid = acceptedOrderId,
Price = quantity * rate,
PricePerUnit = rate,
Quantity = quantity
};
simulatedOpenOrders.Add(order);
}
return(new AcceptedOrder
{
Uuid = acceptedOrderId
});
}
public void Handle(OpenOrder command)
{
//No Invariants ..Imagine verifying the customer can open orders or whatever...
var order = NewOrder(command.OrderId);
Apply(new Effect
{
Event = new OrderOpened
{
OrderId = command.OrderId, CustomerId = command.CustomerId
},
Entity = order
});
SaveChanges();
//All "Handle" methods could be wrapped in a
//(save changes / retry n-times on revision conflict)
}
public async Task <bool> createOrder(OpenOrder orderData, System.Threading.CancellationTokenSource cancelOrderAwait)
{
ResponseWrapper <AcceptedOrder> response;
do
{
switch (orderData.OrderType)
{
case "LIMIT_BUY":
response = await account.BuyLimit(orderData.Exchange, orderData.QuantityRemaining, orderData.Limit);
break;
case "LIMIT_SELL":
response = await account.SellLimit(orderData.Exchange, orderData.QuantityRemaining, orderData.Limit);
break;
default:
return(false);
}
await Task.Delay(Constants.second);
}while (!response.Success);
if (cancelOrderAwait != null)
{
cancelOrderAwait.Cancel();
}
while (!ActiveOrders.Exists(x => x.OrderUuid == response.Result.Uuid))
{
await Task.Delay(5 *Constants.second);
if (cancelOrderAwait != null)
{
cancelOrderAwait.Cancel();
}
}
OnHoldOrders.Remove(orderData);
return(true);
}
private async Task DoExternalEarnOffer()
{
string externalEarnOffer = JwtProviderBuilder.Earn
.AddOffer("earrrnit", "111")
.AddRecipient(UserId, "earrrnit it", "block chain sutff isn't coded yet lawl, i'm neva goonna earn")
.Jwt;
OpenOrder createExternalEarnOffer =
await _marketPlaceClient.CreateExternalOffer(externalEarnOffer).ConfigureAwait(false);
Order submitEarnOffer =
await _marketPlaceClient.SubmitOrder(createExternalEarnOffer.Id).ConfigureAwait(false);
Order finishedOrder = await WaitForOrderCompletion(UserId, submitEarnOffer.Id).ConfigureAwait(false);
if (!string.IsNullOrEmpty(finishedOrder?.Result?.Jwt))
{
SecurityToken token = _marketPlaceJwtProvider.ValidateJwtToken(finishedOrder?.Result?.Jwt);
}
}
public void Assign(string api, OpenOrder order)
{
this.ApiKey = api;
this.CancelInitiated = order.CancelInitiated;
this.Closed = order.Closed;
this.CommissionPaid = order.CommissionPaid;
this.Condition = order.Condition;
this.ConditionTarget = order.Exchange;
this.Exchange = order.Exchange;
this.Limit = order.Limit;
this.Opened = order.Opened;
this.OrderType = order.OrderType;
this.OrderUuid = order.OrderUuid;
this.Price = order.Price;
this.QuantityRemaining = order.QuantityRemaining;
this.Uuid = order.Uuid;
this.Quantity = order.Quantity;
this.PricePerUnit = order.PricePerUnit;
this.IsConditional = order.IsConditional;
this.ImmediateOrCancel = order.ImmediateOrCancel;
}
public void AddNewOpenOrderMessage(OpenOrder openOrder)
{
using (var dbContext = new MyDBContext())
{
openOrder.UpdateTime = DateTime.Now;
if (openOrder.Status == "Cancelled" || openOrder.Status == "Filled")
{
var openorder =
dbContext.OpenOrder.Where(x => x.PermanentId == openOrder.PermanentId).ToList();
if (openorder.Count > 0)
{
DeleteAndSaveOpenOrder(openorder, dbContext);
}
}
else
{
openOrdersDictionary.TryGetValue(openOrder.OrderId, out string status);
if (string.IsNullOrWhiteSpace(status))
{
openOrdersDictionary.Add(openOrder.OrderId, openOrder.Status);
Add(openOrder, dbContext);
SaveChanges(dbContext);
}
else
{
if (status == openOrder.Status)
{
return;
}
else if (status != openOrder.Status)
{
openOrdersDictionary[openOrder.OrderId] = openOrder.Status;
//not important to update database on this instance
}
}
}
}
}
public void OrderDataCallback(OpenOrder OrderData)
{
//CREATE/UPDATE DATA ENTRIES IN OpenOrders AND ENQUEUE SQL SAVE-ORDER-UPDATE
var UniqueID = string.Format("UniqueID = '{0}_{1}'", OrderData.CandlePeriod, OrderData.Exchange);
var rows = Holdings.Tables["OpenOrders"].Select(string.Format("UniqueID = '{0}'", UniqueID));
DataRow row;
if (rows.Count() == 0)
{
row = Holdings.Tables["OpenOrders"].NewRow();
Holdings.Tables["OpenOrders"].Rows.Add(row);
}
else
{
row = rows.First();
}
row["UniqueID"] = UniqueID;
row["OrderUuid"] = OrderData.OrderUuid;
row["Exchange"] = OrderData.Exchange;
row["Type"] = OrderData.Type;
row["TotalQuantity"] = OrderData.TotalQuantity;
row["TotalReserved"] = OrderData.TotalReserved;
row["Quantity"] = OrderData.Quantity;
row["QuantityRemaining"] = OrderData.QuantityRemaining;
row["Limit"] = OrderData.Limit;
row["Reserved"] = OrderData.Reserved;
row["CommissionReserved"] = OrderData.CommissionReserved;
row["CommissionReserveRemaining"] = OrderData.CommissionReserveRemaining;
row["CommissionPaid"] = OrderData.CommissionPaid;
row["Price"] = OrderData.Price;
row["PricePerUnit"] = OrderData.PricePerUnit;
row["Opened"] = OrderData.Opened;
row["CandlePeriod"] = OrderData.CandlePeriod;
SQLOrderUpdateWrites.Enqueue(OrderData);
}
void EWrapper.openOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
OpenOrder?.Invoke(orderId, contract, order, orderState);
}
public void OrderExecutedCallback(OpenOrder OrderData)
{
//Find + REMOVE FROM OpenOrders TABLE,
var OpenOrderRows = Holdings.Tables["OpenOrders"].Select(string.Format("UniqueID = '{0}_{1}'", OrderData.CandlePeriod, OrderData.Exchange));
foreach (var row in OpenOrderRows)
{
Holdings.Tables["OpenOrders"].Rows.Remove(row);
}
OrderData.PricePerUnit = Math.Round((OrderData.TotalReserved / OrderData.TotalQuantity), 8);
if (OrderData.Type == "LIMIT_BUY")
{
//Calculate stoploss, within acceptable range per PeriodLength:
decimal stoplossRate = OrderData.PricePerUnit - (CalcStoplossMargin(OrderData.Exchange, OrderData.CandlePeriod) * OPTIONS.ATRmultipleT1);
switch (OrderData.CandlePeriod)
{
case "period5m":
if (stoplossRate / OrderData.PricePerUnit < 0.98M)
{
stoplossRate = OrderData.PricePerUnit * 0.98M;
}
break;
case "period20m":
if (stoplossRate / OrderData.PricePerUnit < 0.95M)
{
stoplossRate = OrderData.PricePerUnit * 0.95M;
}
break;
case "period1h":
if (stoplossRate / OrderData.PricePerUnit < 0.93M)
{
stoplossRate = OrderData.PricePerUnit * 0.93M;
}
break;
case "period4h":
if (stoplossRate / OrderData.PricePerUnit < 0.90M)
{
stoplossRate = OrderData.PricePerUnit * 0.90M;
}
break;
case "period12h":
if (stoplossRate / OrderData.PricePerUnit < 0.88M)
{
stoplossRate = OrderData.PricePerUnit * 0.88M;
}
break;
}
//If 'SAFEMMODE' then Stoploss will be set to sell at minimum satoshis until profitable:
if (OPTIONS.SAFE_MODE)
{
stoplossRate = 0.00105M / OrderData.TotalQuantity;
}
//Register new StopLoss in controller:
StopLossController.RegisterStoploss(new StopLoss(OrderData.Exchange, stoplossRate, OrderData.TotalQuantity, (a, b, c) => ReCalcStoploss(a, b, c), (a, b) => StopLossExecutedCallback(a, b), OrderData.CandlePeriod, OPTIONS.VITRUAL_MODE), string.Format("{0}_{1}", OrderData.CandlePeriod, OrderData.Exchange));
//Enter into Holdings Table:
var newHoldingsRow = Holdings.Tables[OrderData.CandlePeriod].NewRow();
newHoldingsRow["MarketDelta"] = OrderData.Exchange;
newHoldingsRow["DateTimeBUY"] = OrderData.Closed;
newHoldingsRow["Qty"] = OrderData.TotalQuantity;
newHoldingsRow["BoughtRate"] = OrderData.PricePerUnit;
newHoldingsRow["DateTimeSELL"] = "OWNED";
newHoldingsRow["SoldRate"] = "OWNED";
newHoldingsRow["StopLossRate"] = stoplossRate;
newHoldingsRow["SL_Executed"] = 0;
Holdings.Tables[OrderData.CandlePeriod].Rows.Add(newHoldingsRow);
//Create + Enqueue SaveDataUpdate + OrderUpdate
var update = new SaveDataUpdate(OrderData.CandlePeriod, OrderData.Exchange, "BUY", (DateTime)OrderData.Closed, OrderData.TotalQuantity, OrderData.PricePerUnit, stoplossRate);
SQLDataUpdateWrites.Enqueue(update);
SQLOrderUpdateWrites.Enqueue(OrderData);
//OUTPUT BUY
Trace.WriteLine(string.Format("{0}{1} Bought {2} at {3:0.00000000}, SL_Rate: {4:0.00000000}",
OPTIONS.VITRUAL_MODE ? "[VIRTUAL|" + OrderData.Closed + "] ::: " : "[" + OrderData.Closed + "] ::: ",
OrderData.CandlePeriod.Remove(0, 6),
OrderData.Exchange.Split('-')[1],
OrderData.PricePerUnit,
stoplossRate));
}
else if (OrderData.Type == "LIMIT_SELL")
{
StopLossController.CancelStoploss(string.Format("{0}_{1}", OrderData.CandlePeriod, OrderData.Exchange));
//Find row in Holdings:
var holdingRows = Holdings.Tables[OrderData.CandlePeriod].Select(string.Format("MarketDelta = '{0}'", OrderData.Exchange));
//Calc profit with BoughtRate and include fees:
var profit = ((OrderData.PricePerUnit / Convert.ToDecimal(holdingRows[0]["BoughtRate"])) - 1M);
//Calc compound multiple
var compoundMultiple = ((Convert.ToDecimal(holdingRows[0]["BoughtRate"]) * Convert.ToDecimal(holdingRows[0]["Qty"])) / OPTIONS.BTCwagerAmt);
//Calc TradingTotal and NetWorth
TradingTotal += (profit * compoundMultiple);
var netWorth = GetNetPercentage();
var timeHeld = OrderData.Closed - Convert.ToDateTime(holdingRows[0]["DateTimeBUY"]);
//Remove from Holdings:
foreach (var row in holdingRows)
{
Holdings.Tables[OrderData.CandlePeriod].Rows.Remove(row);
}
//Create and add the SQL SaveDataUpdate + OrderUpdate
var update = new SaveDataUpdate(OrderData.CandlePeriod, OrderData.Exchange, "SELL", (DateTime)OrderData.Closed, OrderData.TotalQuantity, OrderData.PricePerUnit, null, false, TradingTotal);
SQLDataUpdateWrites.Enqueue(update);
SQLOrderUpdateWrites.Enqueue(OrderData);
//OUTPUT SELL-ON-SIGNAL
Trace.Write(string.Format("{0}{1} Sold {2} at {3}\r\n =TradeProfit: ",
OPTIONS.VITRUAL_MODE ? "[VIRTUAL|" + OrderData.Closed + "] ::: " : "[" + OrderData.Closed + "] ::: ",
OrderData.CandlePeriod.Remove(0, 6),
OrderData.Exchange.Split('-')[1],
OrderData.PricePerUnit));
//OUTPUT PROFIT ON TRADE:
if (profit < 0)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (profit > 0)
{
Console.ForegroundColor = ConsoleColor.Green;
}
Trace.Write(string.Format("{0:+0.###%;-0.###%;0}", profit));
//OUTPUT TIME HELD
Console.ForegroundColor = ConsoleColor.DarkCyan;
Trace.Write(string.Format(".....=Time-Held: {0:hh\\:mm\\:ss}.....", timeHeld));
//OUTPUT GROSS TOTAL PROFIT PERCENTAGE:
if (TradingTotal < 0)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else if (TradingTotal > 0)
{
Console.ForegroundColor = ConsoleColor.Green;
}
else
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
}
Trace.Write(string.Format("=GrossProfit: {0:+0.###%;-0.###%;0}", TradingTotal / OPTIONS.MAXTOTALENTRANCES));
Console.ForegroundColor = ConsoleColor.DarkCyan;
Trace.Write(".....");
//OUTPUT CURRENT NET WORTH PERCENTAGE INCLUDING HOLDINGS:
if (netWorth > 0)
{
Console.ForegroundColor = ConsoleColor.DarkGreen;
}
else if (netWorth < 0)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
}
else
{
Console.ForegroundColor = ConsoleColor.DarkCyan;
}
Trace.WriteLine(string.Format("=CurrentNetWorth: {0:+0.###%;-0.###%;0}", netWorth));
Console.ForegroundColor = ConsoleColor.DarkCyan;
}
}
public Dictionary <string, object> Post(BookingDetail objbookingDetail)
{
Dictionary <string, object> OrderDetails = new Dictionary <string, object>();
List <OpenOrder> objListOpenOrder = new List <OpenOrder>();
List <ReceiptOrder> objListReceiptOrder = new List <ReceiptOrder>();
List <ROFilesOrder> objListROFilesOrder = new List <ROFilesOrder>();
OpenOrder objOpenOder;
try
{
HomeDAL objHomeDAL = new HomeDAL();
string strXml = string.Empty;
strXml += "<ebooking><actionname>openbookingid</actionname><bookingid>" + objbookingDetail.BookingID + "</bookingid>"
+ "<loguserid>" + objbookingDetail.UserId + "</loguserid>"
+ "<logcentreid>" + objbookingDetail.RevenueCentreID + "</logcentreid>"
+ "<isclassified>" + objbookingDetail.IsClassified + "</isclassified></ebooking>";
DataSet objds = objHomeDAL.eBookingActions(strXml);
if (objds.Tables.Count == 1)
{
objOpenOder = new OpenOrder();
objOpenOder.IsValid = Convert.ToInt16(objds.Tables[0].Rows[0]["ErrorFlag"]);
if (objOpenOder.IsValid == 1)
{
objOpenOder.ErrorMessage = Convert.ToString(objds.Tables[0].Rows[0]["ErrorMessage"]);
objOpenOder.IsValid = Convert.ToInt16(objds.Tables[0].Rows[0]["ErrorFlag"]);
objListOpenOrder.Add(objOpenOder);
OrderDetails.Add("OpenOrder", objListOpenOrder);
}
}
else
{
DataTable objdt = objds.Tables[0];
DataTable objdt1 = objds.Tables[1];
DataTable objdt2 = objds.Tables[2];
if (objdt.Rows.Count > 0)
{
foreach (DataRow dr in objdt.Rows)
{
objOpenOder = new OpenOrder();
objOpenOder.StartCol = Convert.ToString(dr["StartCol"]);
objOpenOder.Yposition = Convert.ToString(dr["Yposition"]);
objOpenOder.BoxNumber = Convert.ToString(dr["BoxNumber"]);
objOpenOder.RevenueCentreID = Convert.ToInt16(dr["RevenueCentreID"]);
objOpenOder.BookingCentreID = Convert.ToInt16(dr["BookingCentreID"]);
objOpenOder.IsClassified = Convert.ToInt16(dr["IsClassified"]);
objOpenOder.RODate = Convert.ToString(dr["RODate"]);
objOpenOder.BookingDate = Convert.ToDateTime(dr["BookingDate"]).ToString("dd/MM/yyyy HH:mm:ss.fff");
objOpenOder.BookingExecID = Convert.ToInt16(dr["BookingExecID"]);
objOpenOder.BookingNumber = Convert.ToString(dr["BookingNumber"]);
objOpenOder.RONumber = Convert.ToString(dr["RONumber"]);
objOpenOder.AgencyID = Convert.ToInt16(dr["AgencyID"]);
objOpenOder.ClientID = Convert.ToInt16(dr["ClientID"]);
objOpenOder.AgentID = Convert.ToInt16(dr["AgentID"]);
objOpenOder.CanvassorID = Convert.ToInt16(dr["CanvassorID"]);
objOpenOder.ROType = Convert.ToInt16(dr["ROType"]);
objOpenOder.BillingCycle = Convert.ToInt16(dr["BillingCycle"]);
objOpenOder.BillTo = Convert.ToInt16(dr["BillTo"]);
objOpenOder.BillType = Convert.ToInt16(dr["BillType"]);
objOpenOder.PaymentModeID = Convert.ToInt16(dr["PaymentMode"]);
objOpenOder.IsManualBilling = Convert.ToInt16(dr["IsManualBilling"]);
objOpenOder.SourceOrder = Convert.ToInt16(dr["SourceOrder"]);
objOpenOder.ROStatus = Convert.ToInt16(dr["ROStatus"]);
objOpenOder.RateFieldChanged = Convert.ToInt16(dr["RateFieldChanged"]);
objOpenOder.ProductID = Convert.ToInt16(dr["ProductID"]);
objOpenOder.BrandID = Convert.ToInt16(dr["BrandID"]);
objOpenOder.SMEID = Convert.ToInt16(dr["SMEID"]);
objOpenOder.BoxTypeID = Convert.ToInt16(dr["BoxTypeID"]);
objOpenOder.ROID = Convert.ToInt64(dr["ROID"]);
objOpenOder.BookingID = Convert.ToInt64(dr["BookingID"]);
objOpenOder.InsNum = Convert.ToInt16(dr["InsNum"]);
objOpenOder.PEID = Convert.ToInt16(dr["PEID"]);
objOpenOder.ReleaseID = Convert.ToInt16(dr["ReleaseID"]);
objOpenOder.ProdPEID = Convert.ToInt16(dr["ProdPEID"]);
objOpenOder.ProdReleaseID = Convert.ToInt16(dr["ProdReleaseID"]);
objOpenOder.ScheduledDate = Convert.ToDateTime(dr["ScheduledDate"]).ToString("dd/MM/yyyy");
objOpenOder.PackageID = Convert.ToInt16(dr["PackageID"]);
objOpenOder.AdTypeID = Convert.ToInt16(dr["AdTypeID"]);
objOpenOder.PremiaID = Convert.ToInt16(dr["PremiaID"]);
objOpenOder.ColorID = Convert.ToInt16(dr["Color"]);
objOpenOder.Status = Convert.ToInt16(dr["Status"]);
objOpenOder.AuditStatus = Convert.ToInt16(dr["AuditStatus"]);
objOpenOder.Free_or_Paid = Convert.ToInt16(dr["Free_or_Paid"]);
objOpenOder.FreeAds = Convert.ToInt16(dr["FreeAds"]);
objOpenOder.PaidAds = Convert.ToInt16(dr["PaidAds"]);
objOpenOder.ItemRateFieldChanged = Convert.ToInt16(dr["ItemRateFieldChanged"]);
objOpenOder.RateCardID = Convert.ToInt16(dr["RateCardID"]);
objOpenOder.AdRateID = Convert.ToInt16(dr["AdRateID"]);
objOpenOder.CardRate = Convert.ToDouble(dr["CardRate"]);
objOpenOder.CardAmount = Convert.ToDouble(dr["CardAmount"]);
objOpenOder.AgreedRate = Convert.ToDouble(dr["AgreedRate"]);
objOpenOder.AgreedAmount = Convert.ToDouble(dr["AgreedAmount"]);
objOpenOder.PECardBaseRate = Convert.ToDouble(dr["PECardBaseRate"]);
objOpenOder.ColorRate = Convert.ToDouble(dr["PECardCOlourRate"]);
objOpenOder.PremiaRate = Convert.ToDouble(dr["PECardPremiaRate"]);
objOpenOder.AgreedDiscPer = Convert.ToDecimal(dr["AgreedDiscPer"]);
objOpenOder.AgreedDiscAmount = Convert.ToDouble(dr["AgreedDiscAmount"]);
objOpenOder.CommissionPer = Convert.ToDouble(dr["CommissionPer"]);
objOpenOder.CommissionAmount = Convert.ToDouble(dr["CommissionAmount"]);
objOpenOder.DisCountColorPer = Convert.ToDouble(dr["DisCountColorPer"]);
objOpenOder.DisCountPremiaPer = Convert.ToDouble(dr["DisCountPremiaPer"]);
// objOpenOder.ExtraDiscountforPE = Convert.ToDouble(dr["ExtraDiscountforPE"]);
objOpenOder.ExtraChargesForPE = Convert.ToDouble(dr["ExtraChargesForPE"]);
objOpenOder.ExtraChargesPer = Convert.ToDouble(dr["ExtraChargesPer"]);
objOpenOder.ExtraDiscPer = Convert.ToDouble(dr["ExtraDiscPer"]);
objOpenOder.ExtraDiscAmount = Convert.ToDouble(dr["ExtraDiscAmount"]);
objOpenOder.ExtraBoxChargesPer = Convert.ToDouble(dr["BoxChargesPer"]);
objOpenOder.ExtraBoxChargesAmount = Convert.ToDouble(dr["BoxChargesAmount"]);
objOpenOder.PreVATAmountforPE = Convert.ToDouble(dr["PreVATAmountforPE"]);
objOpenOder.NetAmountforPE = Convert.ToDouble(dr["NetAmountforPE"]);
objOpenOder.Net = Convert.ToDouble(dr["Net"]);
objOpenOder.Receivable = Convert.ToDouble(dr["Receivable"]);
objOpenOder.VatPer = Convert.ToDouble(dr["VatPer"]);
objOpenOder.VatAmount = Convert.ToDouble(dr["VatAmount"]);
objOpenOder.WTPer = Convert.ToDouble(dr["WTPer"]);
objOpenOder.WTAmount = Convert.ToDouble(dr["WTAmount"]);
objOpenOder.MaterialID = Convert.ToString(dr["MaterialID"]);
objOpenOder.AdsizeID = Convert.ToInt16(dr["AdsizeID"]);
objOpenOder.Adsize = Convert.ToString(dr["AdSize"]);
objOpenOder.AdSizeHeight = Convert.ToDouble(dr["AdHeight"]);
objOpenOder.AdSizeWidth = Convert.ToDouble(dr["AdColsize"]);
objOpenOder.BillableSize = Convert.ToString(dr["BillableSize"]);
objOpenOder.BillableColSize = Convert.ToDouble(dr["BillableColSize"]);
objOpenOder.BillableHeight = Convert.ToDouble(dr["BillableHeight"]);
objOpenOder.BillableArea = Convert.ToDouble(dr["BillableArea"]);
objOpenOder.UOM = Convert.ToInt16(dr["UOM"]);
objOpenOder.SchemeID = Convert.ToInt16(dr["SchemeID"]);
objOpenOder.SchemeDetailID = Convert.ToInt16(dr["SchemedetailID"]);
objOpenOder.MaterialSource = Convert.ToInt16(dr["MaterialSource"]);
objOpenOder.MaterialType = Convert.ToInt16(dr["MaterialType"]);
objOpenOder.MaterialStatus = Convert.ToInt16(dr["MaterialStatus"]);
objOpenOder.AgencyName = Convert.ToString(dr["AgencyName"]);
objOpenOder.ClientName = Convert.ToString(dr["ClientName"]);
objOpenOder.CasualClientName = Convert.ToString(dr["CasualClientName"]);
objOpenOder.CanvassorName = Convert.ToString(dr["CanvassorName"]);
objOpenOder.UserName = Convert.ToString(dr["UserName"]);
objOpenOder.CentreName = Convert.ToString(dr["CentreName"]);
objOpenOder.MaterialPath = Convert.ToString(dr["MaterialPath"]);
objOpenOder.JobPath = Convert.ToString(dr["JobPath"]);
objOpenOder.ROFilePath = Convert.ToString(dr["ROFilePath"]);
objOpenOder.PkgIDs = Convert.ToString(dr["PkgIDs"]);
objOpenOder.PremiaName = Convert.ToString(dr["PremiaName"]);
objOpenOder.SizeName = Convert.ToString(dr["SizeName"]);
objOpenOder.ColorName = Convert.ToString(dr["ColorName"]);
objOpenOder.CustomerTypeID = Convert.ToInt16(dr["CasualRegularFlag"]);
objOpenOder.SchedulingInstructions = Convert.ToString(dr["SchedulingInstructions"]);
objOpenOder.BillingInstruction = Convert.ToString(dr["BillingInstruction"]);
objOpenOder.ProdInstructions = Convert.ToString(dr["ProdInstructions"]);
objOpenOder.Caption = Convert.ToString(dr["Caption"]);
objOpenOder.CasualAddress = Convert.ToString(dr["CasualAddress"]);
objOpenOder.CityID = Convert.ToInt32(dr["CityID"]);
objOpenOder.Zip = Convert.ToString(dr["Zip"]);
objOpenOder.Phone = Convert.ToString(dr["Phone"]);
objOpenOder.NicNumber = Convert.ToString(dr["NICNumber"]);
objOpenOder.VatNumber = Convert.ToString(dr["VATNumber"]);
objOpenOder.MBodyCount = Convert.ToString(dr["MBodyCount"]);
objOpenOder.AdClassification = Convert.ToString(dr["AdClassification"]);
objOpenOder.AdtypeID1 = Convert.ToInt32(dr["Adtype1"]);
objOpenOder.AdtypeID2 = Convert.ToInt32(dr["Adtype2"]);
objOpenOder.AdtypeID3 = Convert.ToInt32(dr["Adtype3"]);
objOpenOder.AdtypeID4 = Convert.ToInt32(dr["Adtype4"]);
objOpenOder.AllowCasualClient = Convert.ToInt32(dr["AllowCasualClient"]);
objOpenOder.BoxAddress = Convert.ToString(dr["BoxAddress"]);
objOpenOder.IsCD = Convert.ToInt32(dr["IsCD"]);
objOpenOder.StyleSheetID = Convert.ToInt32(dr["StyleSheetID"]);
objOpenOder.IsLogo = Convert.ToInt32(dr["IsLogo"]);
objOpenOder.U_BodyText = Convert.ToString(dr["U_BodyText"]);
objOpenOder.PECode = Convert.ToString(dr["PECode"]);
objOpenOder.AdStatus = Convert.ToString(dr["AdStatus"]);
objOpenOder.FileNames = Convert.ToString(dr["FileNames"]);
objOpenOder.ReasonForUnconfirmationID = Convert.ToString(dr["ReasonForUnconfirmationID"]);
objOpenOder.FileHeight = Convert.ToString(dr["FileHeight"]);
objOpenOder.ReadOnlyFlag = Convert.ToString(dr["ReadOnlyFlag"]);
objOpenOder.BlockB4ScheduledDate = Convert.ToDateTime(dr["BlockB4ScheduledDate"]).ToString("dd/MM/yyyy");
objOpenOder.AdColumns = Convert.ToString(dr["CDADColumns"]);
objOpenOder.MaterialTypeDescription = Convert.ToString(dr["MaterialTypeDescription"]);
objOpenOder.DeferredPayment = Convert.ToInt16(dr["DeferredPayment"]);
objOpenOder.AgencyPaymentMode = Convert.ToInt16(dr["AgencyPaymentMode"]);
objOpenOder.CompositeReceiptID = Convert.ToString(dr["CompositeReceiptID"]);
objListOpenOrder.Add(objOpenOder);
}
}
ROFilesOrder objROFilesOrder;
if (objdt1.Rows.Count > 0)
{
foreach (DataRow dr in objdt1.Rows)
{
objROFilesOrder = new ROFilesOrder();
objROFilesOrder.ROID = Convert.ToInt64(dr["ROID"]);
objROFilesOrder.ROFileName = Convert.ToString(dr["ROFileName"]);
objROFilesOrder.ROFileType = Convert.ToString(dr["ROFileType"]);
objROFilesOrder.ROFileTitle = Convert.ToString(dr["ROFileTitle"]);
objListROFilesOrder.Add(objROFilesOrder);
}
}
ReceiptOrder objReceiptOder;
if (objdt2.Rows.Count > 0)
{
foreach (DataRow dr in objdt2.Rows)
{
objReceiptOder = new ReceiptOrder();
objReceiptOder.ReceiptID = Convert.ToInt64(dr["ReceiptID"]);
objReceiptOder.ReceiptNumber = Convert.ToInt64(dr["ReceiptNumber"]);
objReceiptOder.ReceiptPaymentMode = Convert.ToInt16(dr["PaymentMode"]);
objReceiptOder.BankID = Convert.ToInt16(dr["BankID"]);
objReceiptOder.BranchID = Convert.ToInt16(dr["BranchID"]);
objReceiptOder.CheckNumber = Convert.ToString(dr["Number"]);
objReceiptOder.Amount = Convert.ToDouble(dr["Amount"]);
objReceiptOder.TotalAmountPaid = Convert.ToDouble(dr["TotalAmountPaid"]);
objReceiptOder.WriteOffAmount = Convert.ToDouble(dr["WriteOffAmount"]);
objReceiptOder.CashRefund = Convert.ToDouble(dr["CashRefund"]);
objReceiptOder.CashReceived = Convert.ToDouble(dr["CashReceived"]);
objListReceiptOrder.Add(objReceiptOder);
}
}
OrderDetails.Add("OpenOrder", objListOpenOrder);
OrderDetails.Add("ROFilesOrder", objListROFilesOrder);
OrderDetails.Add("ReceiptOrder", objListReceiptOrder);
}
}
catch (Exception ex)
{
Utility.ReportError("DisplayOpenOrderController::Post:", ex);
}
return(OrderDetails);
}
public virtual void openOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
OpenOrder?.Invoke(this, new OpenOrderArgs(orderId, contract, order, orderState));
}
/// <summary>
/// OpenOrder event invocator
/// </summary>
protected virtual void OnOpenOrder(OpenOrderEventArgs e)
{
OpenOrder?.Invoke(this, e);
}
void IEWrapper.OpenOrder(int orderId, Contract contract, Order order, OrderState orderState)
{
OpenOrder?.Invoke(new OpenOrderMessage(orderId, contract, order, orderState));
}
public void Open()
{
OpenOrder?.Invoke(this, EventArgs.Empty);
}
