private bool ProcessSellLimit(PhysicalOrder order, Tick tick)
{
long orderPrice = order.Price.ToLong();
long price = tick.IsQuote ? tick.lBid : tick.lPrice;
bool isFilled = false;
if (price >= orderPrice)
{
isFilled = true;
}
else if (tick.IsTrade && tick.lPrice > orderPrice)
{
price = orderPrice;
isFilled = true;
}
if (isFilled)
{
CreatePhysicalFillHelper(-order.Size, price.ToDouble(), tick.Time, tick.UtcTime, order);
}
return(isFilled);
}
private void UpdateInstalments(PhysicalOrder order)
{
decimal instalmentAmount = order.PhysicalOriginValueBalance - Math.Abs(order.PaidPledgeBalance);
if (instalmentAmount > 0m)
{
order.DeleteAllInstalmentDetail();
order.GenerateInstalmentDetails(DateTime.Now.Date);
}
else
{
foreach (var eachInstalment in order.Instalment.InstalmentDetails)
{
if (eachInstalment.IsDeleted)
{
continue;
}
eachInstalment.Update(0, 0, 0, DateTime.Now, DateTime.Now, order.LotBalance);
}
}
}
public void OnCancelBrokerOrder(PhysicalOrder physicalOrder)
{
if (trace)
{
log.Trace("OnCancelBrokerOrder " + physicalOrder);
}
Order order = physicalOrder.BrokerOrder as Order;
if (order != null)
{
client.CancelOrder(order.OrderId);
if (debug)
{
log.Debug("Cancel Order: " + physicalOrder.Symbol.Symbol + " " + OrderToString(order));
}
}
else
{
throw new ApplicationException("BrokerOrder property want's an Order object.");
}
}
private InstalmentConstructParams CreateInstalmentConstructParams(PhysicalOrder order)
{
if (order.Instalment == null)
{
return(null);
}
InstalmentConstructParams result = new InstalmentConstructParams
{
InstalmentPolicyId = order.Instalment.InstalmentPolicyId,
DownPayment = order.Instalment.DownPayment,
DownPaymentBasis = order.Instalment.DownPaymentBasis,
InstalmentOverdueDay = order.Instalment.InstalmentOverdueDay,
Period = order.Period,
Frequence = order.Frequence,
InstalmentType = order.Instalment.InstalmentType,
IsInstalmentOverdue = order.Instalment.IsInstalmentOverdue,
RecalculateRateType = order.Instalment.RecalculateRateType
};
return(result);
}
private void ProcessMatchPhysicalExit(LogicalOrder logical, PhysicalOrder physical)
{
var strategyPosition = logical.StrategyPosition;
if (strategyPosition == 0)
{
TryCancelBrokerOrder(physical);
}
else if (Math.Abs(strategyPosition) != physical.Size || logical.Price.ToLong() != physical.Price.ToLong())
{
var origBrokerOrder = physical.BrokerOrder;
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, Math.Abs(strategyPosition));
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
VerifySide(logical, physical);
}
}
private void ProcessMatch(LogicalOrder logical, PhysicalOrder physical)
{
if (trace)
{
log.Trace("Process Match()");
}
if (physical.OrderState == OrderState.Suspended)
{
if (debug)
{
log.Trace("Cannot change a suspended order: " + physical);
}
return;
}
switch (logical.TradeDirection)
{
case TradeDirection.Entry:
ProcessMatchPhysicalEntry(logical, physical);
break;
case TradeDirection.Exit:
ProcessMatchPhysicalExit(logical, physical);
break;
case TradeDirection.ExitStrategy:
ProcessMatchPhysicalExitStrategy(logical, physical);
break;
case TradeDirection.Reverse:
ProcessMatchPhysicalReverse(logical, physical);
break;
case TradeDirection.Change:
ProcessMatchPhysicalChange(logical, physical);
break;
default:
throw new ApplicationException("Unknown TradeDirection: " + logical.TradeDirection);
}
}
internal static decimal CalculateMarketValue(PhysicalOrder order, Price price, DateTime?tradeDay, out decimal valueAsMargin)
{
valueAsMargin = 0;
decimal result = 0m;
if (!order.IsPhysical)
{
return(result);
}
var physicalOpenOrder = order as PhysicalOrder;
if ((physicalOpenOrder.PhysicalTradeSide == PhysicalTradeSide.Buy && physicalOpenOrder.IsPayoff) || physicalOpenOrder.PhysicalTradeSide == PhysicalTradeSide.Deposit)
{
TradePLFormula tradePLFormula = order.Owner.SettingInstrument(tradeDay).TradePLFormula;
decimal lot = order.LotBalance, contractSize = order.Owner.ContractSize(tradeDay);
decimal discountOfOdd = order.Owner.TradePolicyDetail(tradeDay).DiscountOfOdd;
decimal marketValue = CalculateValue(tradePLFormula, lot, price, discountOfOdd, contractSize);
valueAsMargin = order.Owner.CurrencyRate(tradeDay).Exchange(marketValue * order.Owner.TradePolicyDetail(tradeDay).ValueDiscountAsMargin);
return(order.Owner.CurrencyRate(tradeDay).Exchange(marketValue));
}
return(result);
}
public void OnChangeBrokerOrder(PhysicalOrder physicalOrder)
{
if (trace)
{
log.Trace("OnChangeBrokerOrder " + physicalOrder);
}
Order order = physicalOrder.BrokerOrder as Order;
if (order != null)
{
if (debug)
{
log.Debug("Change Order (Cancel/Replace): " + physicalOrder.Symbol.Symbol + " " + OrderToString(order));
}
OnCancelBrokerOrder(physicalOrder);
OnCreateBrokerOrder(physicalOrder);
}
else
{
throw new ApplicationException("BrokerOrder property want's an Order object.");
}
}
private bool ProcessBuyLimitQuoteThrough(PhysicalOrder order, Tick tick)
{
long orderPrice = order.Price.ToLong();
long price = tick.IsQuote ? tick.lBid : tick.lPrice;
bool isFilled = false;
if (price <= orderPrice)
{
isFilled = true;
price = Math.Min(orderPrice, tick.lBid - minimumTick * 4);
}
else if (tick.IsTrade && tick.lPrice < orderPrice)
{
price = orderPrice;
isFilled = true;
}
if (isFilled)
{
CreatePhysicalFillHelper(order.Size, price.ToDouble(), tick.Time, tick.UtcTime, order);
}
return(isFilled);
}
private void OrderSideWrongReject(PhysicalOrder order)
{
var message = "Sorry, improper setting of a " + order.Side + " order when position is " + actualPosition;
lock ( orderMapLocker) {
orderMap.Remove((string)order.BrokerOrder);
}
var node = (LinkedListNode <PhysicalOrder>)order.Reference;
if (node.List != null)
{
node.List.Remove(node);
}
if (onRejectOrder != null)
{
onRejectOrder(order, message);
}
else
{
throw new ApplicationException(message + " while handling order: " + order);
}
}
private void SortAdjust(ActiveList <PhysicalOrder> list, PhysicalOrder order, Func <PhysicalOrder, PhysicalOrder, double> compare)
{
AssureNode(order);
var orderNode = (LinkedListNode <PhysicalOrder>)order.Reference;
if (orderNode.List == null || !orderNode.List.Equals(list))
{
if (orderNode.List != null)
{
orderNode.List.Remove(orderNode);
}
bool found = false;
var next = list.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
var other = node.Value;
if (object.ReferenceEquals(order, other))
{
found = true;
break;
}
else
{
var result = compare(order, other);
if (result < 0)
{
list.AddBefore(node, orderNode);
found = true;
break;
}
}
}
if (!found)
{
list.AddLast(orderNode);
}
}
}
private static void CalculateNotValuedOrderRelationPL(TradeDayInfo tradeDayInfo, Exchanger exchanger, Dictionary <Guid, OrderResetResult> resetOrderDict, List <Guid> affectedOrders)
{
foreach (var eachOrderRelation in tradeDayInfo.OrderRelations)
{
Order closeOrder = eachOrderRelation.CloseOrder;
if (!closeOrder.ShouldCalculate(affectedOrders))
{
continue;
}
PhysicalOrder physicalCloseOrder = closeOrder as PhysicalOrder;
PhysicalOrderRelation physicalOrderRelation = eachOrderRelation as PhysicalOrderRelation;
if (closeOrder.Phase == OrderPhase.Executed && !closeOrder.IsOpen && closeOrder.ExecuteTime <= tradeDayInfo.Settings.ResetTime && eachOrderRelation.ValueTime == null)
{
OrderResetResult resetResult = CreateOrderResetResult(closeOrder, tradeDayInfo, resetOrderDict);
resetResult.NotValuedPL += new InterestStorage(exchanger.ExchangeByCommonDecimals(eachOrderRelation.InterestPL), exchanger.ExchangeByCommonDecimals(eachOrderRelation.StoragePL));
resetResult.TradePLNotValued += exchanger.ExchangeByCommonDecimals(eachOrderRelation.TradePL);
if (physicalOrderRelation != null)
{
resetResult.PhysicalTradePLNotValued += CalculatePhysicalTradePL(physicalOrderRelation, exchanger);
}
}
}
}
private static bool ExistNotMaturePhysicalValueForCloseOrder(this Order order, IEnumerable <OrderRelation> orderRelations)
{
PhysicalOrder physicalOrder = order as PhysicalOrder;
if (physicalOrder == null)
{
return(false);
}
foreach (var eachOrderRelation in orderRelations)
{
if (eachOrderRelation.CloseOrder.Id != order.Id)
{
continue;
}
PhysicalOrderRelation physicalOrderRelation = (PhysicalOrderRelation)eachOrderRelation;
if (eachOrderRelation.ValueTime == null ||
(physicalOrderRelation != null && physicalOrderRelation.PhysicalValueMatureDay != null && physicalOrderRelation.RealPhysicalValueMatureDate == null))
{
return(true);
}
}
return(false);
}
private void SortAdjust(PhysicalOrder order)
{
switch (order.Type)
{
case OrderType.BuyLimit:
case OrderType.SellStop:
SortAdjust(decreaseOrders, order, (x, y) => y.Price - x.Price);
break;
case OrderType.SellLimit:
case OrderType.BuyStop:
SortAdjust(increaseOrders, order, (x, y) => x.Price - y.Price);
break;
case OrderType.BuyMarket:
case OrderType.SellMarket:
Adjust(marketOrders, order);
break;
default:
throw new ApplicationException("Unexpected order type: " + order.Type);
}
}
public void OnCreateBrokerOrder(PhysicalOrder physicalOrder)
{
if (trace)
{
log.Trace("OnCreateBrokerOrder " + physicalOrder);
}
SymbolInfo symbol = physicalOrder.Symbol;
Contract contract = SymbolToContract(symbol);
// Contract contract = new Contract(symbol.Symbol,"SMART",SecurityType.Stock,"USD");
// Contract contract = new Contract(symbol.Symbol,"GLOBEX",SecurityType.Future,"USD","201006");
Order brokerOrder = ToBrokerOrder(physicalOrder);
while (nextValidId == 0)
{
Thread.Sleep(10);
}
nextValidId++;
client.PlaceOrder(nextValidId, contract, brokerOrder);
physicalToLogicalOrderMap.Add(nextValidId, physicalOrder.LogicalOrderId);
if (debug)
{
log.Debug("Place Order: " + contract.Symbol + " " + OrderToString(brokerOrder));
}
}
internal InstalmentDetail(PhysicalOrder owner, OrderInstalmentData data)
: base("InstalmentDetail", 10)
{
this.CreateBusinessItems(owner.Id, data.Sequence, data.Principal, data.Interest, data.DebitInterest, data.PaymentDateTimeOnPlan, data.InterestRate, data.PaidDateTime, data.UpdateTime, data.LotBalance, data.UpdatePersonId);
this.Initialize(owner.AccountId, owner.Instrument().Id);
}
internal InstalmentDetail(PhysicalOrder owner, int period, decimal principal, decimal interest, decimal debitInterest, DateTime?paymentDateTimeOnPlan, DateTime?paidDateTime)
: base("InstalmentDetail", 10)
{
this.CreateBusinessItems(owner.Id, period, principal, interest, debitInterest, paymentDateTimeOnPlan, owner.Instalment.InstalmentPolicyDetail(null).InterestRate, paidDateTime, null, owner.LotBalance, null);
this.Initialize(owner.AccountId, owner.Instrument().Id);
}
private static List <Physical.InstalmentBusiness.InstalmentDetail> GetNotPayoffInstalmentDetails(PhysicalOrder order, DateTime closeTime)
{
var result = new List <Physical.InstalmentBusiness.InstalmentDetail>();
foreach (var eachInstalmentDetail in order.Instalment.InstalmentDetails)
{
if (eachInstalmentDetail.PaidDateTime == null || eachInstalmentDetail.PaidDateTime >= closeTime)
{
result.Add(eachInstalmentDetail);
}
}
return(result);
}
private static void RecovePaidPledgeBalanceAndOriginValueBalance(PhysicalOrder order, decimal paybackPledge, decimal closedPhysicalValue)
{
order.PaidPledgeBalance += paybackPledge;
order.PhysicalOriginValueBalance += closedPhysicalValue;
}
internal PhysicalCloseOrderFeeCalculator(PhysicalOrder order, OrderSettings settings)
: base(order, settings)
{
}
internal PhysicalCloseOrderFeeBookCalculator(PhysicalOrder order, Physical.OrderBusiness.PhysicalOrderSettings settings)
: base(order, settings)
{
}
private bool ShouldFrozen(PhysicalOrder openOrder)
{
return(_physicalOrder.PhysicalTradeSide != PhysicalTradeSide.Delivery && openOrder.PhysicalTradeSide == PhysicalTradeSide.Deposit && openOrder.PhysicalValueMatureDay > 0);
}
private void UpdateForOpenOrder(PhysicalOrderRelation orderRelation, PhysicalOrder openOrder)
{
openOrder.PhysicalOriginValueBalance += -orderRelation.ClosedPhysicalValue;
openOrder.PaidPledgeBalance += orderRelation.PayBackPledgeOfOpenOrder;
openOrder.UpdateLotBalance(orderRelation.ClosedLot, _physicalOrder.PhysicalTradeSide == PhysicalTradeSide.Delivery);
}
internal PhysicalCloseOrderCalculator(PhysicalOrder order, PhysicalOrderSettings physicalSettings)
: base(order, physicalSettings)
{
_physicalSettings = physicalSettings;
_physicalOrder = order;
}
internal PhysicalValuedPLCalculator(PhysicalOrder order)
: base(order)
{
}
internal PhysicalOpenOrderCalculator(PhysicalOrder order, PhysicalOrderSettings physicalSettings, OpenOrderServiceFactoryBase openOrderServiceFactory)
: base(order, physicalSettings, openOrderServiceFactory)
{
_physicalOrder = order;
_physicalSettings = physicalSettings;
}
private int FindPendingAdjustments()
{
var positionDelta = desiredPosition - actualPosition;
var pendingAdjustments = 0;
var next = originalPhysicals.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
PhysicalOrder order = node.Value;
if (order.Type != OrderType.BuyMarket &&
order.Type != OrderType.SellMarket)
{
continue;
}
if (order.LogicalOrderId == 0)
{
if (order.Type == OrderType.BuyMarket)
{
pendingAdjustments += order.Size;
}
if (order.Type == OrderType.SellMarket)
{
pendingAdjustments -= order.Size;
}
if (positionDelta > 0)
{
if (pendingAdjustments > positionDelta)
{
TryCancelBrokerOrder(order);
pendingAdjustments -= order.Size;
}
else if (pendingAdjustments < 0)
{
TryCancelBrokerOrder(order);
pendingAdjustments += order.Size;
}
}
if (positionDelta < 0)
{
if (pendingAdjustments < positionDelta)
{
TryCancelBrokerOrder(order);
pendingAdjustments += order.Size;
}
else if (pendingAdjustments > 0)
{
TryCancelBrokerOrder(order);
pendingAdjustments -= order.Size;
}
}
if (positionDelta == 0)
{
TryCancelBrokerOrder(order);
pendingAdjustments += order.Type == OrderType.SellMarket ? order.Size : -order.Size;
}
physicalOrders.Remove(order);
}
}
return(pendingAdjustments);
}
private bool ProcessExtraPhysical(PhysicalOrder physical)
{
return(TryCancelBrokerOrder(physical));
}
private void ProcessMatchPhysicalEntry(LogicalOrder logical, PhysicalOrder physical)
{
log.Trace("ProcessMatchPhysicalEntry()");
var strategyPosition = logical.StrategyPosition;
var difference = logical.Position - Math.Abs(strategyPosition);
log.Trace("position difference = " + difference);
if (difference == 0)
{
TryCancelBrokerOrder(physical);
}
else if (difference != physical.Size)
{
var origBrokerOrder = physical.BrokerOrder;
if (strategyPosition == 0)
{
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
if (strategyPosition > 0)
{
if (logical.Type == OrderType.BuyStop || logical.Type == OrderType.BuyLimit)
{
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
TryCancelBrokerOrder(physical);
}
}
if (strategyPosition < 0)
{
if (logical.Type == OrderType.SellStop || logical.Type == OrderType.SellLimit)
{
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
TryCancelBrokerOrder(physical);
}
}
}
}
else if (logical.Price.ToLong() != physical.Price.ToLong())
{
var origBrokerOrder = physical.BrokerOrder;
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
VerifySide(logical, physical);
}
}
private void ProcessMatchPhysicalChange(LogicalOrder logical, PhysicalOrder physical)
{
var strategyPosition = logical.StrategyPosition;
var logicalPosition =
logical.Type == OrderType.BuyLimit ||
logical.Type == OrderType.BuyMarket ||
logical.Type == OrderType.BuyStop ?
logical.Position : -logical.Position;
logicalPosition += strategyPosition;
var physicalPosition =
physical.Side == OrderSide.Buy ?
physical.Size : -physical.Size;
var delta = logicalPosition - strategyPosition;
var difference = delta - physicalPosition;
if (debug)
{
log.Debug("PhysicalChange(" + logical.SerialNumber + ") delta=" + delta + ", strategyPosition=" + strategyPosition + ", difference=" + difference);
}
if (delta == 0 || strategyPosition == 0)
{
if (debug)
{
log.Debug("(Flat) Canceling: " + physical);
}
TryCancelBrokerOrder(physical);
}
else if (difference != 0)
{
var origBrokerOrder = physical.BrokerOrder;
if (delta > 0)
{
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, OrderSide.Buy, Math.Abs(delta));
if (debug)
{
log.Debug("(Delta) Changing " + origBrokerOrder + " to " + physical);
}
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
OrderSide side;
if (strategyPosition > 0 && logicalPosition < 0)
{
side = OrderSide.Sell;
delta = strategyPosition;
if (delta == physical.Size)
{
if (debug)
{
log.Debug("Delta same as size: Check Price and Side.");
}
ProcessMatchPhysicalChangePriceAndSide(logical, physical, delta);
return;
}
}
else
{
side = OrderSide.SellShort;
}
side = (long)strategyPosition >= (long)Math.Abs(delta) ? OrderSide.Sell : OrderSide.SellShort;
if (side == physical.Side)
{
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, Math.Abs(delta));
if (debug)
{
log.Debug("(Size) Changing " + origBrokerOrder + " to " + physical);
}
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
if (debug)
{
log.Debug("(Side) Canceling " + physical);
}
TryCancelBrokerOrder(physical);
}
}
}
else
{
ProcessMatchPhysicalChangePriceAndSide(logical, physical, delta);
}
}
