protected override void OnPendingOrderCreated(PendingOrder newPendingOrder)
{
if (newPendingOrder.TradeType == TradeType.Sell)
ordemv = newPendingOrder;
else
ordemc = newPendingOrder;
}
/// <summary>
/// Change parameters for pending order
/// </summary>
/// <param name="ord"></param>
/// <returns></returns>
protected RequestStatus ModifyPendingOrder(PendingOrder ord)
{
return(robotContext.SendEditPendingRequest(protectedContext.MakeProtectedContext(), ord));
}
/// <summary>
/// Вызывается на торговых событиях установка снятие ордера, изменение параметров, срабатывание ордера
/// </summary>
/// <param name="order"></param>
public virtual void OnTradeEvent(PendingOrder order)
{
TerminalLog.Instance.SaveRobotLog(string.Format("робот {0}: срабатывание отложенного ордера {1}, {2}, статус {3}, side = {4}",
TypeName, order.ID, order.Symbol, order.Status, order.Side));
}
public static bool CreateStopOrder(this IStrategyBase Strategy, StringBuilder sb, TradeType?direction,
double price, long size, double?sl, double?tp, string comment, out PendingOrder po)
{
TradeResult result = Strategy.Robot.PlaceStopOrder(direction.Value, Strategy.Symbol,
size, price, Strategy.GetLabel(), sl, tp, null, comment);
if (result.IsSuccessful)
{
po = result.PendingOrder;
sb.AppendLine("Created Stop: {0} {1} {2} {3}", direction.Value, Strategy.Symbol.Code, size, price);
}
else
{
po = null;
sb.AppendLine("Stop Limit order failed {0}", result.Error);
}
return(result.IsSuccessful);
}
/// <summary>
/// Moneymanagement adjustments
/// </summary>
/// <param name="order"></param>
public override void MoneyManagement(PendingOrder order)
{
}
/// <summary> /// Get commission and fees /// </summary> /// <param name="order"></param> /// <returns></returns> public decimal GetCommissionAndFees(PendingOrder order) => 0m;
private string _getPendingOrderString(PendingOrder o, string action)
{
return _getPositionString(action, o.SymbolCode, o.Label, o.Volume, o.TradeType.ToString());
}
/// <summary>
/// send order that is compatible with OrderDelegate events
/// </summary>
/// <param name="o"></param>
public void SendOrder(PendingOrder o)
{
SendOrderStatus(o);
}
internal void Reset()
{
RobotPosition = null;
RobotPendingOrder = null;
Status = TradeStatus.Inactive;
}
/// <summary>
/// Process submit order
/// </summary>
/// <param name="ticket"></param>
protected virtual OrderTicketResponse SubmitOrder(SubmitOrderTicket ticket)
{
//Get order from factory
PendingOrder pendingorder = OrderFactory.CreateOrder(ticket);
OrderImpl order = pendingorder.Order as OrderImpl;
//Round off order quantity for correct amounts
RoundLotSize(order);
//try and get the order from the order tracker
if (!OrderTracker.TryAddOrder(pendingorder))
{
_log.Error($"Unable to add new order, order with id {pendingorder.OrderId} was already submitted");
return(OrderTicketResponse.Error(pendingorder.OrderId, OrderTicketResponseErrorCode.OrderAlreadyExists, $"Current order with id {pendingorder.OrderId} was already submitted"));
}
if (!OrderTracker.TryGetOrder(pendingorder.OrderId, out pendingorder))
{
_log.Error($"Unable to retrieve newly added order, order with id {pendingorder.OrderId} was cannot be processed properly");
return(OrderTicketResponse.Error(pendingorder.OrderId, OrderTicketResponseErrorCode.UnableToFindOrder, $"Current order with id {pendingorder.OrderId} cannot be found"));
}
//Round of prices
RoundOrderPrices(order);
//Set our new order
pendingorder.UpdateOrder(order);
//Check for correct size
if (order.Quantity == 0)
{
order.State = OrderState.Invalid;
var ticketresponse = OrderTicketResponse.Error(order.InternalId, OrderTicketResponseErrorCode.OrderQuantityZero);
Portfolio.Log(LogLevel.Error, ticketresponse.ErrorMessage);
return(ticketresponse);
}
//Check if we have enough capital for an order
bool sufficientcapital = GetSufficientCapitalForOrder(pendingorder);
if (!sufficientcapital)
{
//Not enough capital to execute this order
order.State = OrderState.Invalid;
var response = OrderTicketResponse.Error(order.InternalId,
OrderTicketResponseErrorCode.InsufficientBuyingPower, $"Cannot execute order with id {order.InternalId}, insufficient funds to execute order.");
Portfolio.Log(LogLevel.Error, response.ErrorMessage);
HandleOrderTicketEvent(OrderTicketEvent.Error(order.InternalId, $"Insufficent capital to execute order"));
return(response);
}
//Check if broker accepts order at this moment
try
{
if (!Portfolio.BrokerModel.CanSubmitOrder(order, out var message))
{
//Broker model did not accept this order
order.State = OrderState.Invalid;
var response = OrderTicketResponse.Error(order.InternalId,
OrderTicketResponseErrorCode.BrokerageModelRefusedToSubmitOrder, $"Order with id {order.InternalId}: {message}");
Portfolio.Log(LogLevel.Error, "");
HandleOrderTicketEvent(OrderTicketEvent.Error(order.InternalId, $"Broker model of type {Portfolio.BrokerModel.BrokerType} declared order cannot be submitted, message: {message}"));
return(response);
}
}
catch (Exception exc)
{
_log.Error(exc, $"Could not run CanSubmitOrder on order with id {order.InternalId}, please check the implemented logic");
order.State = OrderState.Invalid;
return(OrderTicketResponse.Error(pendingorder.OrderId, OrderTicketResponseErrorCode.ProcessingError, $"Current order with id {pendingorder.OrderId} cannot be processed due to error"));
}
//Try to execute this order to the broker connection attached
bool ordersuccess = false;
try
{
ordersuccess = BrokerConnection.SubmitOrder(pendingorder);
}
catch (Exception exc)
{
_log.Error(exc);
}
//Check if placing the order was a success
if (!ordersuccess)
{
order.State = OrderState.Invalid;
var submitmessage = "BrokerConnection failed to place order";
var response = OrderTicketResponse.Error(order.InternalId,
OrderTicketResponseErrorCode.BrokerageFailedToSubmitOrder, submitmessage);
Portfolio.Log(LogLevel.Error, submitmessage);
HandleOrderTicketEvent(OrderTicketEvent.Error(order.InternalId, submitmessage));
return(response);
}
order.State = OrderState.Submitted;
return(OrderTicketResponse.Processed(order.InternalId));
}
public void CheckPendingOrder(PendingOrder order, Dictionary <string, QuoteData> curPrices)
{
// проверка на зафлаживание
if (pendingFloodTimes.ContainsKey(order.ID))
{
var time = pendingFloodTimes[order.ID];
if (DateTime.Now < time)
{
return;
}
pendingFloodTimes.Remove(order.ID);
}
// отменить устаревший ордер)
if (order.TimeTo.HasValue)
{
if (DateTime.Now > order.TimeTo)
{
//var pairCancel = curPrices.ContainsKey(order.Symbol) ? curPrices[order.Symbol] : null;
//var priceCancel = pairCancel == null ? 0 : order.Side > 0 ? pairCancel.Bid : pairCancel.Ask;
proxyTrade.SendDeletePendingOrderRequest(ProtectedOperationContext.MakeServerSideContext(),
order, PendingOrderStatus.Отменен, null, "Экспирация");
return;
}
}
// получить текущую котировку
if (!curPrices.ContainsKey(order.Symbol))
{
if ((DateTime.Now - timeStarted).TotalMilliseconds > MinMillsToReportError)
{
floodSafeLogger.LogMessageFormatCheckFlood(LogEntryType.Debug, MsgNoQuoteMagic, 5 * 60 * 1000,
"CheckOrder: нет котировки по {0} для отлож. ордера #{1}",
order.Symbol, order.ID);
}
return;
}
var pricePair = curPrices[order.Symbol];
var price = order.Side > 0 ? pricePair.ask : pricePair.bid;
// проверить нахождение в рамках цены и времени
if (order.TimeFrom.HasValue)
{
if (DateTime.Now < order.TimeFrom)
{
return;
}
}
// цена...
var orderFires = false;
if (order.Side > 0 && ((PendingOrderPriceSide)order.PriceSide) == PendingOrderPriceSide.Limit)
{
if (price <= order.PriceFrom && (order.PriceTo == null ? true : price >= order.PriceTo))
{
orderFires = true;
}
}
else
if (order.Side < 0 && ((PendingOrderPriceSide)order.PriceSide) == PendingOrderPriceSide.Limit)
{
if (price >= order.PriceFrom && (order.PriceTo == null ? true : price <= order.PriceTo))
{
orderFires = true;
}
}
else
if (order.Side > 0 && ((PendingOrderPriceSide)order.PriceSide) == PendingOrderPriceSide.Stop)
{
if (price >= order.PriceFrom && (order.PriceTo == null ? true : price <= order.PriceTo))
{
orderFires = true;
}
}
else
{
if (price <= order.PriceFrom && (order.PriceTo == null ? true : price >= order.PriceTo))
{
orderFires = true;
}
}
if (!orderFires)
{
return;
}
Logger.InfoFormat("Активация отлож. ордера #{0} ({1} {2} at {3}), цена {4}",
order.ID, (DealType)order.Side, order.PriceSide,
order.PriceFrom.ToStringUniformPriceFormat(true),
price.ToStringUniformPriceFormat(true));
// активировать ордер
var orderMarket = new MarketOrder
{
AccountID = order.AccountID,
Magic = order.Magic,
Symbol = order.Symbol,
Volume = order.Volume,
Side = order.Side,
StopLoss = order.StopLoss,
TakeProfit = order.TakeProfit,
Comment = string.Format("по ордеру #{0}", order.ID)
};
var reqStatus = proxyTrade.SendNewOrderRequest(
ProtectedOperationContext.MakeServerSideContext(),
RequestUniqueId.Next(),
orderMarket,
OrderType.Market,
0, 0); // проскальзывание
if (reqStatus == RequestStatus.OK)
{
// удалить парный ордер
if (order.PairOCO.HasValue && order.PairOCO > 0)
{
List <PendingOrder> orders;
try
{
proxyAccount.GetPendingOrders(order.AccountID, out orders);
var orderPair = orders == null ? null : orders.FirstOrDefault(o => o.ID == order.PairOCO.Value);
if (orderPair != null)
{
proxyTrade.SendDeletePendingOrderRequest(ProtectedOperationContext.MakeServerSideContext(),
orderPair, PendingOrderStatus.Отменен, null, "OCO");
}
}
catch (Exception ex)
{
Logger.ErrorFormat("Ошибка удаления парного ордера {0} для ордера {1}: {2}",
order.PairOCO, order, ex);
}
}
// удалить ордер
proxyTrade.SendDeletePendingOrderRequest(ProtectedOperationContext.MakeServerSideContext(),
order, PendingOrderStatus.Исполнен, null, "Активирован");
}
else
{
Logger.ErrorFormat("Ошибка активации отлож. ордера #{0}: {1}", order.ID, reqStatus);
// удалить ордер
proxyTrade.SendDeletePendingOrderRequest(ProtectedOperationContext.MakeServerSideContext(),
order, PendingOrderStatus.Отменен, null, "Отменен");
// зафлаживание
var nextTime = DateTime.Now.AddMilliseconds(PendingFloodTimeoutMils);
if (pendingFloodTimes.ContainsKey(order.ID))
{
pendingFloodTimes[order.ID] = nextTime;
}
else
{
pendingFloodTimes.Add(order.ID, nextTime);
}
}
}
private void MakePending(int side)
{
var priceVal = tbPrice.Text.Replace(",", ".").ToFloatUniformSafe();
if (!priceVal.HasValue)
{
MessageBox.Show(Localizer.GetString("MessagePriceNotProvided"));
tbPrice.Focus();
return;
}
var price = priceVal.Value;
if (price <= 0)
{
MessageBox.Show(Localizer.GetString("MessagePriceMustBePositive"));
tbPrice.Text = "";
tbPrice.Focus();
return;
}
if (lastQuote == null)
{
MessageBox.Show(Localizer.GetString("MessageNoQuote"));
return;
}
// создать новый отложенный ордер
var volm = cbVolume.Text.Replace(" ", "").ToInt();
var orderType = PendingOrderType.Limit;
if ((side == 1 && lastQuote.ask < price) || (side == -1 && lastQuote.bid > price))
{
orderType = PendingOrderType.Stop;
}
var orderOCO = (PendingOrder)cbOrderOCO.SelectedItem;
var orderOCOId = orderOCO == null ? (int?)null : orderOCO.ID;
float?[] trailingLevels;
float?[] trailTargets;
GetTrailingLevels(side, out trailingLevels, out trailTargets);
var order = new PendingOrder
{
AccountID = AccountStatus.Instance.accountID,
Symbol = Ticker,
Magic = tbMagic.Text.ToIntSafe(),
Volume = volm,
Side = side,
PriceSide = orderType,
PriceFrom = price,
PriceTo = tbPriceTo.Text.Replace(",", ".").ToFloatUniformSafe(),
TimeFrom = cbStartFrom.Checked ? dpTimeFrom.Value : (DateTime?)null,
TimeTo = cbEndTime.Checked ? dpTimeTo.Value : (DateTime?)null,
StopLoss = tbSL.Text.Replace(",", ".").ToFloatUniformSafe(),
TakeProfit = tbTP.Text.Replace(",", ".").ToFloatUniformSafe(),
PairOCO = orderOCOId > 0 ? orderOCO.ID : (int?)null,
Comment = tbComment.Text,
ExpertComment = tbExpertComment.Text,
// трейлинг
TrailLevel1 = trailingLevels[0],
TrailLevel2 = trailingLevels[1],
TrailLevel3 = trailingLevels[2],
TrailLevel4 = trailingLevels[3],
TrailTarget1 = trailTargets[0],
TrailTarget2 = trailTargets[1],
TrailTarget3 = trailTargets[2],
TrailTarget4 = trailTargets[3],
};
MainForm.Instance.SendNewPendingOrderRequestSafe(RequestUniqueId.Next(), order);
}
public override RequestStatus SendEditPendingRequest(ProtectedOperationContext secCtx, PendingOrder ord)
{
foreach (var order in orders.Where(order => order.ID == ord.ID && AccountInfo.ID == order.AccountID))
{
order.Magic = ord.Magic;
order.PriceFrom = ord.PriceFrom;
order.PriceTo = ord.PriceTo;
order.TimeFrom = ord.TimeFrom;
order.TimeTo = ord.TimeTo;
order.Comment = ord.Comment;
order.ExpertComment = ord.ExpertComment;
order.StopLoss = ord.StopLoss;
order.TakeProfit = ord.TakeProfit;
order.Volume = ord.Volume;
order.PriceSide = ord.PriceSide;
order.Side = ord.Side;
order.Symbol = ord.Symbol;
return(RequestStatus.OK);
}
return(RequestStatus.NotFound);
}
public override RequestStatus SendDeletePendingOrderRequest(ProtectedOperationContext ctx, PendingOrder order,
PendingOrderStatus status, int?positionId, string closeReason)
{
order.Status = status;
order.CloseReason = closeReason;
ordHistory.Add(order);
orders.Remove(order);
return(RequestStatus.OK);
}
public override RequestStatus SendNewPendingOrderRequest(
ProtectedOperationContext ctx, int requestUniqueId, PendingOrder order)
{
orders.Add(order);
return(RequestStatus.OK);
}
private void LoadPendingOrderData()
{
RequestStatus status;
List <PendingOrder> actualPos;
try
{
status = TradeSharpAccount.Instance.proxy.GetPendingOrders(AccountStatus.Instance.accountID, out actualPos);
}
catch (Exception ex)
{
Logger.Error("OrderDlg::GetPendingOrders proxy error", ex);
return;
}
if (status != RequestStatus.OK)
{
return;
}
var pos = actualPos.FirstOrDefault(p => p.ID == orderId);
if (pos == null)
{
Logger.ErrorFormat("OrderDlg::GetPendingOrders - not found ({0})", orderId);
return;
}
pendingOrder = pos;
Ticker = pos.Symbol;
orderSide = pos.Side;
cbVolume.Text = pos.Volume.ToStringUniformMoneyFormat();
tbSL.Text = pos.StopLoss.ToStringUniformPriceFormat("", true);
tbTP.Text = pos.TakeProfit.ToStringUniformPriceFormat("", true);
tbComment.Text = pos.Comment;
tbExpertComment.Text = pos.ExpertComment;
Text = string.Format("Отл. ордер №{0} {1} {2} price={3}",
pos.ID, pos.Side > 0 ? "BUY" : "SELL", pos.Symbol, pos.PriceFrom);
cbCurx.SelectedIndex = cbCurx.Items.IndexOf(pos.Symbol);
tbMagic.Text = pos.Magic.HasValue ? pos.Magic.Value.ToString() : "";
tbPrice.Text = pos.PriceFrom.ToStringUniformPriceFormat(true);
// трейлинг
LoadTrailingLevels(pos.trailingLevels, pos.trailingTargets);
// доп параметры
if (pos.TimeFrom.HasValue)
{
cbStartFrom.Checked = true;
dpTimeFrom.Value = pos.TimeFrom.Value;
}
else
{
cbStartFrom.Checked = false;
}
if (pos.TimeTo.HasValue)
{
cbEndTime.Checked = true;
dpTimeTo.Value = pos.TimeTo.Value;
}
else
{
cbEndTime.Checked = false;
}
if (pos.PriceTo.HasValue)
{
cbPriceTo.Checked = true;
tbPriceTo.Text = pos.PriceTo.Value.ToStringUniformPriceFormat(true);
}
// стоп-лимит
var orderCaption = string.Format("{0} {1}",
pos.Side > 0 ? "BUY" : "SELL",
pos.PriceSide == PendingOrderType.Stop ? "STOP" : "LIMIT");
// кнопки
var inactBtn = pos.Side > 0 ? btnSellMarket : btnBuyMarket;
btnBuyMarket.Enabled = false;
btnSellMarket.Enabled = false;
inactBtn.Enabled = true;
if (pos.Side > 0)
{
btnBuyMarket.buttonCaption = orderCaption;
}
else
{
btnSellMarket.buttonCaption = orderCaption;
}
inactBtn.textLeftColor = SystemColors.InactiveCaptionText;
inactBtn.textRightColor = SystemColors.InactiveCaptionText;
inactBtn.captionColor = SystemColors.ControlText;
inactBtn.buttonCaption = "Отменить";
}
/// <summary>
/// Submit an order that is going through the regular template cycle of orders
/// </summary>
/// <param name="pendingorder"></param>
/// <param name="state"></param>
/// <returns></returns>
protected bool ProcessOrder(PendingOrder pendingorder, AgentState state)
{
//Track Orders
PendingOrder entryOrder = pendingorder;
PendingOrder rmOrder = null;
//Check if we are allowed to trade
var types = Templates.Select(x => x.GetType());
RiskManagementTemplate rm = (RiskManagementTemplate)Templates.FirstOrDefault(x => x.GetType().BaseType == typeof(RiskManagementTemplate));
if (rm != null &&
!rm.IsTradingAllowed() &&
(state != AgentState.EntryLong || state != AgentState.EntryShort))
{
return(false);
}
//Check risk management
if (InvokeRm.Count > 0)
{
//Check all Risk Management template logics
Exec.InvokeAll(InvokeRm, pendingorder, state);
//On Order Event
if (InvokeRm[0].Result != null)
{
rmOrder = InvokeRm[0].Result;
RiskManagement(rmOrder);
}
}
//Submit our new stop order
if (rmOrder != null && rmOrder.Order.IsValid)
{
SubmitOrder(rmOrder);
}
else if (rmOrder != null && !rmOrder.Order.IsValid)
{
_logger.Warn("RM: INVALID ORDER {0} - {1}", rmOrder.OrderStatus, rmOrder.Order.Security.Name);
}
//Check money management
if (InvokeMm.Count > 0)
{
Exec.InvokeAll(InvokeMm, pendingorder, state);
MoneyManagement(pendingorder);
}
//Submit our new entry order
if (entryOrder.Order.IsValid)
{
SubmitOrder(entryOrder);
}
else
{
_logger.Warn("MM: INVALID ORDER {0} - {1}", entryOrder.OrderStatus, entryOrder.Order.Security.Name);
}
return(true);
}
internal void WhenOrderFilled(Position robotPosition)
{
RobotPosition = robotPosition;
RobotPendingOrder = null;
Status = TradeStatus.Active;
}
public StatusType SubmitOrder(PendingOrder pendingorder)
{
return(Agent.SubmitOrder(pendingorder));
}
/// <summary> /// Returns the applied commissions and fees for processing this pending order /// </summary> /// <param name="pendingorder"></param> /// <returns></returns> public decimal GetCommissionAndFees(PendingOrder pendingorder) => pendingorder.Value * 0.0025m;
public void QueueOrder(PendingOrder order)
{
_pendingOrders.Add(order);
_queuedOrders.Add(order);
}
/// <summary>
/// Вызывается на торговых событиях установка снятие ордера, изменение параметров, срабатывание ордера
/// </summary>
/// <param name="order"></param>
public override void OnTradeEvent(PendingOrder order)
{
}
public void AddOrder(PendingOrder order)
{
var queue = GetRuleBasedQueue(order.OrderRuleType);
queue.Add(order);
}
/// <summary>
/// Fill order, if possible
/// </summary>
/// <param name="broker">Associated broker model</param>
/// <param name="datapoint">Currently received data point</param>
/// <param name="pendingorder">Pending order to check for filling</param>
/// <param name="highliquidfill">If true, size of ticks are not taken in to account</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public override Fill FillOrder(BrokerModel broker, DataPoint datapoint, PendingOrder pendingorder, bool highliquidfill)
{
throw new NotImplementedException();
}
/// <summary>
/// Riskmanagement adjustments
/// </summary>
/// <param name="order"></param>
public override void RiskManagement(PendingOrder order)
{
}
public static OrderImpactResponse GetMarketOrderImpact(PendingOrder curPendingOrder)
{
return(GetMarketOrderImpact(curPendingOrder.AccountNumber, curPendingOrder.Quote.symbolId, curPendingOrder.IsBuyOrder, curPendingOrder.Quantity));
}
public static bool PlaceOrder(this IStrategyBase Strategy, StringBuilder sb, TradeType?direction,
double price, double?tp, double?sl, long size, string comment, out PendingOrder po)
{
double marketPrice = Strategy.Symbol.Bid;
if (price > marketPrice && direction == TradeType.Sell)
{
return(CreateLimitOrder(Strategy, sb, direction, price, size, sl, tp, comment, out po));
}
else if (price > marketPrice && direction == TradeType.Buy)
{
return(CreateStopOrder(Strategy, sb, direction, price, size, sl, tp, comment, out po));
}
else if (price < marketPrice && direction == TradeType.Sell)
{
return(CreateStopOrder(Strategy, sb, direction, price, size, sl, tp, comment, out po));
}
else if (price < marketPrice && direction == TradeType.Buy)
{
return(CreateLimitOrder(Strategy, sb, direction, price, size, sl, tp, comment, out po));
}
po = null;
return(false);
}
public static bool CreateMarketOrder(PendingOrder curPendingOrder)
{
return(CreateMarketOrder(curPendingOrder.AccountNumber, curPendingOrder.Quote.symbol, curPendingOrder.Quote.symbolId, curPendingOrder.IsBuyOrder, curPendingOrder.Quantity));
}
/// <summary>
/// Delete pending order request
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
protected RequestStatus DeletePendingOrder(PendingOrder order)
{
return(robotContext.SendDeletePendingOrderRequest(protectedContext.MakeProtectedContext(), order,
PendingOrderStatus.Отменен, null, "Отменен роботом"));
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
try
{
if (this.itemView.DataSource != null)
{
this.itemView.DataSource = null;
}
else
{
this.itemView.Rows.Clear();
}
if (this.dataGridPO.DataSource != null)
{
this.dataGridPO.DataSource = null;
}
else
{
this.dataGridPO.Rows.Clear();
}
if (this.dataGridO.DataSource != null)
{
this.dataGridO.DataSource = null;
}
else
{
this.dataGridO.Rows.Clear();
}
if (this.cart.DataSource != null)
{
this.cart.DataSource = null;
}
else
{
this.cart.Rows.Clear();
}
error = "";
orders = new List <Item>();
tempItems = new List <Item>();
TotalNewOrder = 0;
newTotal.Text = TotalNewOrder.ToString();
Items = new List <Item>();
string line;
using (System.IO.StreamReader reader = new System.IO.StreamReader(@"Items.csv"))
{
reader.ReadLine();
while ((line = reader.ReadLine()) != null)
{
string[] part = line.Split(',');
int ID = int.Parse(part[0]);
string Title = part[1];
string Origin = part[2];
double Quantity = double.Parse(part[3]);
double Price = System.Math.Round(double.Parse(part[4]), 2);
double SellingPrice = System.Math.Round(double.Parse(part[5]), 2);
string Status = part[6];
DateTime Date = DateTime.Parse(part[7]);
string Details = part[8];
Item temp = new Item(ID, Title, Origin, Quantity, Price, SellingPrice, Status, Date, Details);
Items.Add(temp);
}
AddItems(Items);
}
OrdersPending = new List <PendingOrder>();
using (StreamReader reader = new StreamReader(@"PendingOrders.csv"))
{
reader.ReadLine();
while ((line = reader.ReadLine()) != null)
{
string[] part = line.Split(',');
int ID = int.Parse(part[0]);
DateTime Date = DateTime.Parse(part[1]);
string Title = part[2];
string Address = part[3];
string ItemID = part[4];
string Quantity = part[5];
double Payment = double.Parse(part[6]);
string Status = part[7];
string Details = part[8];
PendingOrder temp = new PendingOrder(ID, Date, Title, Address, ItemID, Quantity, Payment, Status, Details);
OrdersPending.Add(temp);
}
AddPendingOrders(OrdersPending);
}
Orders = new List <Order>();
double total = 0;
using (StreamReader reader = new StreamReader(@"Orders.csv"))
{
reader.ReadLine();
while ((line = reader.ReadLine()) != null)
{
string[] part = line.Split(',');
int ID = int.Parse(part[0]);
DateTime Date = DateTime.Parse(part[1]);
string ItemID = part[2];
string Quantity = part[3];
double Payment = double.Parse(part[4]);
total += Payment;
string Details = part[5];
Order temp = new Order(ID, Date, ItemID, Quantity, Payment, Details);
Orders.Add(temp);
}
AddOrders(Orders);
totalReceivedPayment.Text = total.ToString();
}
}
catch (Exception exc)
{
error = exc.Message;
errorMessage.Text += "Failed to load data. Fatal error. " + error;
errorMessage.Visible = true;
tabControl.Visible = false;
}
}
protected override void OnPendingOrderCreated(PendingOrder newOrder)
{
if (newOrder.TradeType == TradeType.Buy)
_buyOrder = newOrder;
else
_sellOrder = newOrder;
}
/// <summary>
/// Begin order for new certificate for one or more domains, fetching the required challenges
/// to complete
/// </summary>
/// <param name="log"> </param>
/// <param name="config"> </param>
/// <param name="orderUri"> Uri of existing order to resume </param>
/// <returns> </returns>
public async Task <PendingOrder> BeginCertificateOrder(ILog log, CertRequestConfig config, string orderUri = null)
{
if (DateTime.Now.Subtract(_lastInitDateTime).TotalMinutes > 30)
{
// our acme context nonce may have expired (which returns "JWS has an invalid
// anti-replay nonce") so start a new one
await InitProvider(null);
}
var pendingOrder = new PendingOrder {
IsPendingAuthorizations = true
};
// prepare a list of all pending authorization we need to complete, or those we have
// already satisfied
var authzList = new List <PendingAuthorization>();
//if no alternative domain specified, use the primary domain as the subject
var domainOrders = new List <string>();
// order all of the distinct domains in the config (primary + SAN).
domainOrders.Add(_idnMapping.GetAscii(config.PrimaryDomain));
if (config.SubjectAlternativeNames != null)
{
foreach (var s in config.SubjectAlternativeNames)
{
if (!domainOrders.Contains(s))
{
domainOrders.Add(_idnMapping.GetAscii(s));
}
}
}
try
{
IOrderContext order = null;
int remainingAttempts = 3;
bool orderCreated = false;
try
{
while (!orderCreated && remainingAttempts > 0)
{
try
{
remainingAttempts--;
log.Error($"BeginCertificateOrder: creating/retrieving order. Retries remaining:{remainingAttempts} ");
if (orderUri != null)
{
order = _acme.Order(new Uri(orderUri));
}
else
{
order = await _acme.NewOrder(domainOrders);
}
if (order != null)
{
orderCreated = true;
}
}
catch (Exception exp)
{
remainingAttempts--;
log.Error($"BeginCertificateOrder: error creating order. Retries remaining:{remainingAttempts} {exp.ToString()} ");
if (remainingAttempts == 0)
{
// all attempts to create order failed
throw;
}
else
{
await Task.Delay(1000);
}
}
}
}
catch (NullReferenceException exp)
{
var msg = $"Failed to begin certificate order (account problem or API is not currently available): {exp}";
log.Error(msg);
pendingOrder.Authorizations =
new List <PendingAuthorization> {
new PendingAuthorization
{
AuthorizationError = msg,
IsFailure = true
}
};
return(pendingOrder);
}
if (order == null)
{
throw new Exception("Failed to begin certificate order.");
}
orderUri = order.Location.ToString();
pendingOrder.OrderUri = orderUri;
log.Information($"Created ACME Order: {orderUri}");
// track order in memory, keyed on order Uri
if (_currentOrders.Keys.Contains(orderUri))
{
_currentOrders.Remove(orderUri);
}
_currentOrders.Add(orderUri, order);
// handle order status 'Ready' if all authorizations are already valid
var orderDetails = await order.Resource();
if (orderDetails.Status == OrderStatus.Ready)
{
pendingOrder.IsPendingAuthorizations = false;
}
// get all required pending (or already valid) authorizations for this order
log.Information($"Fetching Authorizations.");
var orderAuthorizations = await order.Authorizations();
// get the challenges for each authorization
foreach (IAuthorizationContext authz in orderAuthorizations)
{
log.Debug($"Fetching Authz Challenges.");
var allChallenges = await authz.Challenges();
var res = await authz.Resource();
string authzDomain = res.Identifier.Value;
if (res.Wildcard == true)
{
authzDomain = "*." + authzDomain;
}
var challenges = new List <AuthorizationChallengeItem>();
// add http challenge (if any)
var httpChallenge = await authz.Http();
if (httpChallenge != null)
{
var httpChallengeStatus = await httpChallenge.Resource();
log.Information($"Got http-01 challenge {httpChallengeStatus.Url}");
if (httpChallengeStatus.Status == ChallengeStatus.Invalid)
{
log.Error($"HTTP challenge has an invalid status");
}
challenges.Add(new AuthorizationChallengeItem
{
ChallengeType = SupportedChallengeTypes.CHALLENGE_TYPE_HTTP,
Key = httpChallenge.Token,
Value = httpChallenge.KeyAuthz,
ChallengeData = httpChallenge,
ResourceUri = $"http://{authzDomain.Replace("*.", "")}/.well-known/acme-challenge/{httpChallenge.Token}",
ResourcePath = $".well-known\\acme-challenge\\{httpChallenge.Token}",
IsValidated = (httpChallengeStatus.Status == ChallengeStatus.Valid)
});
}
// add dns challenge (if any)
var dnsChallenge = await authz.Dns();
if (dnsChallenge != null)
{
var dnsChallengeStatus = await dnsChallenge.Resource();
log.Information($"Got dns-01 challenge {dnsChallengeStatus.Url}");
if (dnsChallengeStatus.Status == ChallengeStatus.Invalid)
{
log.Error($"DNS challenge has an invalid status");
}
var dnsValue = _acme.AccountKey.DnsTxt(dnsChallenge.Token); //ComputeDnsValue(dnsChallenge, _acme.AccountKey);
var dnsKey = $"_acme-challenge.{authzDomain}".Replace("*.", "");
challenges.Add(new AuthorizationChallengeItem
{
ChallengeType = SupportedChallengeTypes.CHALLENGE_TYPE_DNS,
Key = dnsKey,
Value = dnsValue,
ChallengeData = dnsChallenge,
IsValidated = (dnsChallengeStatus.Status == ChallengeStatus.Valid)
});
}
// report back on the challenges we now may need to attempt
authzList.Add(
new PendingAuthorization
{
Challenges = challenges,
Identifier = new IdentifierItem
{
Dns = authzDomain,
IsAuthorizationPending = !challenges.Any(c => c.IsValidated) //auth is pending if we have no challenges already validated
},
AuthorizationContext = authz,
IsValidated = challenges.Any(c => c.IsValidated),
OrderUri = orderUri
});
}
pendingOrder.Authorizations = authzList;
return(pendingOrder);
}
catch (AcmeRequestException exp)
{
// failed to register one or more domain identifier with LE (invalid, rate limit or
// CAA fail?)
var msg = $"Failed to begin certificate order: {exp.Error?.Detail}";
log.Error(msg);
pendingOrder.Authorizations =
new List <PendingAuthorization> {
new PendingAuthorization
{
AuthorizationError = msg,
IsFailure = true
}
};
return(pendingOrder);
}
}
private void SimBroker_GotFill(Trade t, PendingOrder o)
{
fillcount++;
}
protected override void OnPendingOrderCreated(PendingOrder newOrder)
{
}