public OrderLimit PlaceOrderLimit(Symbol symbol, OrderSide side, decimal quantity, decimal price,
Action <OrderBase> orderStatusHandler = null, Action <OrderBase, ErrorCodes> errorHandler = null)
{
OrderLimit order = new OrderLimit(side, quantity, price, symbol, this);
return(_sender.PlaceOrderLimit(order, orderStatusHandler, errorHandler));
}
public void Lower_limit_by_actual_sum()
{
var supplier = TestSupplier.CreateNaked(session);
var price = supplier.Prices[0];
supplier.CreateSampleCore(session);
price.Costs[0].PriceItem.PriceDate = DateTime.Now.AddDays(-10);
session.Save(supplier);
supplier.Maintain(session);
var address = session.Load <Address>(user.AvaliableAddresses[0].Id);
var limit = new OrderLimit(session.Load <Supplier>(supplier.Id), 1000)
{
Today = 500
};
address.OrderLimits.Add(limit);
var settings = session.Load <ClientSettings>(user.Client.Id);
settings.AllowDelayOfPayment = true;
var offer = price.Core[0];
var clientOrder = ToClientOrder(offer);
clientOrder.Orders[0].Items[0].ResultCost = 150;
session.Flush();
PostOrder(clientOrder);
session.Refresh(limit);
Assert.AreEqual(900, limit.Value);
Assert.AreEqual(500, limit.Today);
}
internal OrderLimit PlaceOrderLimit(OrderLimit order, Action <OrderBase> orderStatusHandler = null, Action <OrderBase, ErrorCodes> errorHandler = null)
{
if (!_connection.IsControlConnected())
{
return(null);
}
order.OrderStatusChanged += orderStatusHandler;
order.ErrorEvent += errorHandler;
_ordersLock.EnterWriteLock();
try
{ _orders.Add(order.ClientId, order); }
finally
{ _ordersLock.ExitWriteLock(); }
bool result = _connection.PlaceOrder(order);
if (!result)
{
_ordersLock.EnterWriteLock();
try
{
order.Dispose();
_orders.Remove(order.ClientId);
}
finally
{ _ordersLock.ExitWriteLock(); }
order = null;
}
return(order);
}
public PendingLimitLog(RequestLog request, OrderLimit limit, Tuple <decimal, decimal> values)
{
Request = request;
Limit = limit;
Value = values.Item1;
ToDay = values.Item2;
}
public LeverageData(Message message)
{
if (message.KontentCase != Message.KontentOneofCase.LeverageMsg)
{
throw new ArgumentException($"Error: Message containis KontentCase {message.KontentCase} " +
$" instead of LeverageMsg.");
}
Symbol symbol = SymbolsContainer.GetSymbol(message.MarketId);
LeverageMessage leverageMessage = message.LeverageMsg;
DWConverter.FromProtoDecimal(leverageMessage.AccumQuantity);
BuyOrderMargin = DWConverter.FromProtoDecimal(leverageMessage.BuyOrderMargin);
BuyOrderQuantity = DWConverter.FromProtoDecimal(leverageMessage.BuyOrderQuantity);
LastTradePrice = DWConverter.FromProtoDecimal(leverageMessage.LastTradePrice);
LastTradeQuantity = DWConverter.FromProtoDecimal(leverageMessage.LastTradeQuantity);
LastTradeTimestamp = DWConverter.FromLongDateTime(leverageMessage.LastTradeTimestamp);
Leverage = leverageMessage.Leverage;
OrderMargin = DWConverter.FromProtoDecimal(leverageMessage.OrderMargin);
Orders = new List <OrderBase>();
foreach (OrderMessage orderMessage in leverageMessage.Orders)
{
OrderBase order = new OrderLimit(orderMessage, symbol);
Orders.Add(order);
}
Pnl = DWConverter.FromProtoDecimal(leverageMessage.Pnl);
PositionBankruptcyVolume = DWConverter.FromProtoDecimal(leverageMessage.PositionBankruptcyVolume);
PositionContracts = DWConverter.FromProtoDecimal(leverageMessage.PositionContracts);
PositionLiquidationVolume = DWConverter.FromProtoDecimal(leverageMessage.PositionLiquidationVolume);
PositionMargin = DWConverter.FromProtoDecimal(leverageMessage.PositionMargin);
PositionType = leverageMessage.PositionType;
PositionVolume = DWConverter.FromProtoDecimal(leverageMessage.PositionVolume);
SellOrderMargin = DWConverter.FromProtoDecimal(leverageMessage.SellOrderMargin);
SellOrderQuantity = DWConverter.FromProtoDecimal(leverageMessage.SellOrderQuantity);
TraderBalance = DWConverter.FromProtoDecimal(leverageMessage.TraderBalance);
Trades = new List <Trade>();
foreach (TradeMessage tradeMessage in leverageMessage.Trades)
{
Trade trade = new Trade(tradeMessage, symbol);
Trades.Add(trade);
}
Upnl = DWConverter.FromProtoDecimal(leverageMessage.Upnl);
}
public static void SetLimit(ISession session)
{
Console.Write("Поставщик:");
var supplierId = Convert.ToUInt32(Console.ReadLine());
Console.Write("Лимит:");
var value = Convert.ToDecimal(Console.ReadLine());
var user = ServerFixture.User(session);
var address = session.Load <Common.Models.Address>(user.AvaliableAddresses[0].Id);
var limit = address.OrderLimits.FirstOrDefault(l => l.Supplier.Id == supplierId);
if (limit == null)
{
limit = new OrderLimit(session.Load <Common.Models.Supplier>(supplierId), value);
address.OrderLimits.Add(limit);
}
limit.Value = value;
session.Save(address);
}
private void MakeOrder(OrderType orderType, OrderAction orderAction)
{
Contract contract = new Contract();
IBApi.Order order = new IBApi.Order();
switch (orderType)
{
case OrderType.MTL:
// AUC
contract.Symbol = "IBKR";
contract.SecType = "STK";
contract.Currency = "USD";
contract.Exchange = "SMART";
OrderAuction orderAuction = new OrderAuction();
orderAuction.Action = orderAction;
orderAuction.LimitPrice = 10;
orderAuction.Quantity = 1;
order = orderAuction.GetOrder;
break;
case OrderType.MKT:
contract.Symbol = "IBKR";
contract.SecType = "STK";
contract.Currency = "USD";
contract.Exchange = "SMART";
OrderMarket orderMarket = new OrderMarket();
orderMarket.Action = orderAction;
orderMarket.Quantity = 1;
orderMarket.TimeInForce = OrderTimeInForce.GTC;
order = orderMarket.GetOrder;
break;
case OrderType.LMT:
contract.Symbol = "IBKR";
contract.SecType = "STK";
contract.Currency = "USD";
contract.Exchange = "SMART";
OrderLimit orderLimit = new OrderLimit();
orderLimit.Action = orderAction;
orderLimit.LimitPrice = 10;
orderLimit.Quantity = 1;
orderLimit.TimeInForce = OrderTimeInForce.GTC;
order = orderLimit.GetOrder;
break;
}
manager.SubmitOrder(contract, order);
}
/// <summary>
/// Call for starting parsing by the contained rules, using provided crude information html content string.
/// </summary>
public PageParseResult Parse(string relativeUri = null)
{
if (fastWeb == null)
{
fastWeb = new FastWeb2(Domain);
}
var rawHtml = fastWeb.Get(relativeUri);
//PreprocessPlan
string processedHtml = PagePreprocess == null ? rawHtml : rawHtml.Mold(PagePreprocess);
//interpret as document node
HtmlDocument document = new HtmlDocument();
document.LoadHtml(processedHtml);
HtmlNode entireDocumentNode = document.DocumentNode;
var pageParseResult = new PageParseResult
{
Title = Title.ExtractSingle(node: entireDocumentNode)
};
if (Subtitle != null)
{
pageParseResult.Title += " " + Subtitle.ExtractSingleFromNode(node: entireDocumentNode);
}
if (Thumbnail != null)
{
pageParseResult.ThumbPath = Thumbnail.ExtractSingleFromNode(node: entireDocumentNode);
}
//Parsing Actual Options
if (DefaultOptionMode != DefaultOptionMode.Single)
{
try
{
bool isRegex = OptionsList.SelectMethod == SelectMethod.Regex;
IEnumerable <object> crudeOptions;
if (isRegex)
{
crudeOptions = OptionsList.ExtractList(entireDocumentNode.InnerHtml);
}
else
{
crudeOptions = OptionsList.ExtractList(entireDocumentNode);
}
foreach (var entry in crudeOptions)
{
var optionParseResult = isRegex ? ActualOption.Parse(entry as string) : ActualOption.Parse(entry as HtmlNode);
if (optionParseResult.Price.Amount == 0 && PriceMode != PriceMode.Add)
{
continue;
}
pageParseResult.OptionParseResults.Add(optionParseResult);
}
}
catch (NullReferenceException nrex) when(DefaultOptionMode == DefaultOptionMode.Alongside || DefaultOptionMode == DefaultOptionMode.Alternative)
{
//swallow when actual options absence allowed
Logger.Log(nrex.Message + " @ PageParsing of " + relativeUri);
}
}
//Default Option Logic
if (DefaultOptionMode != DefaultOptionMode.Ignore)
{
if (DefaultOptionMode == DefaultOptionMode.Single)
{
Logger.Log(Domain + " has 1 option per page setup. Add all options separately.");
}
OptionParseResult defaultOption;
try
{
defaultOption = DefaultOption.Parse(entireDocumentNode);
defaultOption.PropertyA = defaultOption.Code = DefaultOptionMode.ToString();
}
catch (NullReferenceException nrex)
{
Logger.Log(nrex.Message + " @ PageParsing of " + relativeUri);
throw;
}
//Prices correction according to Price Mode Setting
if (PriceMode == PriceMode.Add)
{
foreach (OptionParseResult optParseRes in pageParseResult.OptionParseResults)
{
optParseRes.Price.Amount += defaultOption.Price.Amount;
}
}
//Adding default option to the options list, if necessary
if (DefaultOptionMode == DefaultOptionMode.Alongside ||
DefaultOptionMode == DefaultOptionMode.Single ||
(DefaultOptionMode == DefaultOptionMode.Alternative && pageParseResult.OptionParseResults.Count == 0))
{
pageParseResult.OptionParseResults.Add(defaultOption);
}
}
//Prices correction according to the Main Currency & Shop Ordering Rules
foreach (OptionParseResult optParseRes in pageParseResult.OptionParseResults)
{
optParseRes.Price = optParseRes.Price.AsMainCurrency();
var value = optParseRes.Price.Amount;
value /= 1 + OrderDeduction;
if (OrderExtra != null && OrderLimit != null && OrderLimit.AsMainCurrency().Amount > 0)
{
decimal limitValue = OrderLimit.AsMainCurrency().Amount;
decimal orderExtraValue = OrderExtra.AsMainCurrency().Amount;
decimal piecesPerOrder = limitValue / value;
decimal extraPerPiece = orderExtraValue / piecesPerOrder;
value += extraPerPiece;
}
optParseRes.Price.Amount = value;
}
return(pageParseResult);
}
