private void pnl_search_QueryClick(object sender, EventArgs e) { var strWhere = pnl_search.QueryString; strWhere += string.Format(" and enable_flag='" + Convert.ToInt32(DataSources.EnumEnableFlag.USING)) + "' and (info_status='" + Convert.ToInt32(DataSources.EnumAuditStatus.Balance) + "' or info_status='" + +Convert.ToInt32(DataSources.EnumAuditStatus.AUDIT) + "')"; dgv_primary.DataSource = OrderRelation.GetIsUsePreOrder("tb_maintain_info", "maintain_id", "tb_maintain_three_guaranty", strWhere); }
internal static Tuple <decimal, decimal> CalculateEstimateFee(this Order order, ExecuteContext context) { if (!order.IsOpen || order.Owner.OrderType == OrderType.BinaryOption) { return(Tuple.Create(0m, 0m)); } decimal estimateCommission = 0, estimateLevy = 0, estimateOtherFee = 0; var tran = order.Owner; var feeParameter = FeeParameter.CreateByOpenOrder(context, order); OrderRelation.CalculateFee(feeParameter, out estimateCommission, out estimateLevy, out estimateOtherFee); var instrument = tran.SettingInstrument(context.TradeDay); //don't support fees denpends on PL, just set the value to ZERO now if (instrument.CommissionFormula.IsDependOnPL()) { estimateCommission = 0; } if (instrument.LevyFormula.IsDependOnPL()) { estimateLevy = 0; } return(Tuple.Create(estimateCommission, estimateLevy)); }
internal static void Parse(string exchangeCode,XmlNode transactionNode, List<Transaction> transactions, List<Order> orders, List<OrderRelation> orderRelations) { Transaction transaction = new Transaction(); transaction.Initialize(transactionNode); transactions.Add(transaction); foreach (XmlNode orderNode in transactionNode.ChildNodes) { Order order = new Order(); CommandConvertor.Parse(orderNode,transaction,out order); orders.Add(order); foreach (XmlNode orderRelationNode in orderNode.ChildNodes) { string openOrderPrice = string.Empty; string openOrderID = orderRelationNode.Attributes["OpenOrderID"].Value; Guid openOrderId = new Guid(openOrderID); decimal closeLot = decimal.Parse(orderRelationNode.Attributes["ClosedLot"].Value); if (_OrderRelationOpenPrics.ContainsKey(openOrderID)) { openOrderPrice = _OrderRelationOpenPrics[openOrderID]; } else { openOrderPrice = ExchangeData.GetOrderRelationOpenPrice(exchangeCode, openOrderID); _OrderRelationOpenPrics.Add(openOrderID, openOrderPrice); } OrderRelation relation = new OrderRelation(order.Id, openOrderId, closeLot, openOrderPrice); orderRelations.Add(relation); } } }
private PLValue GetValuedPL(OrderRelation orderRelation) { if (!orderRelation.IsValued) { return(PLValue.Empty); } return(orderRelation.CalculateValuedPL()); }
protected override void UpdateOpenOrder(OrderRelation orderRelation, bool isLast, ExecuteContext context) { var boOrderRelation = (BOOrderRelation)orderRelation; base.UpdateOpenOrder(orderRelation, isLast, context); boOrderRelation.UpdateOpenOrderPledge(); boOrderRelation.CalculatePayBackPledge(); _boOrder.PayBackPledge += boOrderRelation.PayBackPledge; }
protected virtual void UpdateOpenOrder(OrderRelation orderRelation, bool isLast, ExecuteContext context) { var openOrder = orderRelation.OpenOrder; orderRelation.OpenOrder.UpdateLotBalance(orderRelation.ClosedLot, false); openOrder.RecalculateEstimateFee(context); orderRelation.EstimateCloseCommissionOfOpenOrder = openOrder.EstimateCloseCommission; orderRelation.EstimateCloseLevyOfOpenOrder = openOrder.EstimateCloseLevy; }
protected override void UpdateOpenOrder(OrderRelation orderRelation, bool isLast, ExecuteContext context) { var physicalOrderRelation = orderRelation as PhysicalOrderRelation; var openOrder = orderRelation.OpenOrder as PhysicalOrder; physicalOrderRelation.IsFullPayment = openOrder.IsPayoff; this.CalculateOrderRelaiton(physicalOrderRelation, isLast, context); this.UpdateForOpenOrder(physicalOrderRelation, openOrder); this.UpdateCloseOrder(physicalOrderRelation, context); }
internal static void Parse(string exchangeCode,XmlNode transactionNode, out Transaction[] transactions,out Order[] orders, out OrderRelation[] orderRelations) { List<Transaction> transactionList = new List<Transaction>(); List<Order> orderList = new List<Order>(); List<OrderRelation> orderRelationList = new List<OrderRelation>(); CommandConvertor.Parse(exchangeCode,transactionNode, transactionList, orderList, orderRelationList); transactions = transactionList.ToArray(); orders = orderList.ToArray(); orderRelations = orderRelationList.ToArray(); }
private decimal CalculateClosedLot(Order placingOrder, List <KeyValuePair <Guid, decimal> > remainCloseLotPerOpenOrderList) { decimal closedLot = 0m; if (remainCloseLotPerOpenOrderList != null && remainCloseLotPerOpenOrderList.Count > 0) { decimal canBeClosedLot = 0; foreach (var eachPair in remainCloseLotPerOpenOrderList) { OrderRelation relation = placingOrder.GetOrderRelation(eachPair.Key); canBeClosedLot += Math.Min(eachPair.Value, relation.ClosedLot); } closedLot = Math.Min(placingOrder.Lot, canBeClosedLot); } return(closedLot); }
private void CollectLotFromOrderRelation(OrderRelation orderRelation, Order closeOrder, Dictionary <Order, List <decimal> > closeLotsPerOpenOrderDict, ref List <string> ocoCloseTrans) { if (closeOrder.Owner.Type == TransactionType.OneCancelOther) { if (ocoCloseTrans == null) { ocoCloseTrans = new List <string>(); } string ocoKey; if (this.IsOCOOrderCollected(closeOrder, orderRelation.OpenOrder, ocoCloseTrans, out ocoKey)) { return; } else { ocoCloseTrans.Add(ocoKey); } } List <decimal> closeLotList = this.GetOrCreateCloseLotList(orderRelation.OpenOrder, closeLotsPerOpenOrderDict); closeLotList.Add(orderRelation.ClosedLot); }
protected override bool ShouldDoValue(OrderRelation orderRelation, ExecuteContext context) { return(base.ShouldDoValue(orderRelation, context) && this.IsInValueDate(context)); }
protected virtual bool ShouldDoValue(OrderRelation orderRelation, ExecuteContext context) { return(!orderRelation.IsValued); }
private decimal CalculateValuedPL(decimal value, OrderRelation orderRelation, Exchanger exchanger) { return(exchanger.Exchange(value, orderRelation.RateIn, orderRelation.RateOut, orderRelation.Decimals)); }
private decimal GetClosedLot(OrderRelation orderRelation, Order originCloseOrder) { return(this.ShouldCalculateClosedLot(orderRelation, originCloseOrder) ? orderRelation.ClosedLot : 0m); }
public OrderRelationXmlService(OrderRelation owner) { _owner = owner; }
private static void Initialize(OrderRelation item, DataRow dataRow) { item.OrderId1 = (Guid)dataRow["OpenOrderId"]; item.OrderId2 = (Guid)dataRow["CloseOrderId"]; item.Lot = (decimal)dataRow["ClosedLot"]; }
private bool ShouldCalculateClosedLot(OrderRelation orderRelation, Order originCloseOrder) { var closeOrder = orderRelation.CloseOrder; return(this.IsOrderPhaseIsOk(closeOrder, originCloseOrder) && this.IsTheSameTradeOption(closeOrder, originCloseOrder)); }
private decimal CaculateFeeForCutting(decimal closedLot, Price cutPrice, ICollection <CuttingItem> cuttingItems) { if ((decimal)cutPrice == 0) { return(0m); } decimal commission = 0m, levy = 0m, otherFee = 0m; Settings.Instrument instrument = _owner.Setting; Settings.Account account = _owner.Owner.Setting(); TradePolicyDetail tradePolicyDetail = _owner.TradePolicyDetail(); SpecialTradePolicyDetail specialTradePolicyDetail = _owner.SpecialTradePolicyDetail(null); decimal contractSize = tradePolicyDetail.ContractSize; CurrencyRate currencyRate = _owner.CurrencyRate(null); if (instrument.ExchangeSystem == ExchangeSystem.Local && (account.RiskLevelAction == RiskLevelAction.CloseNetPosition || account.RiskLevelAction == RiskLevelAction.CloseAll)) { if (!instrument.CommissionFormula.TakeFeeAsCost() || !instrument.LevyFormula.TakeFeeAsCost() || !instrument.OtherFeeFormula.TakeFeeAsCost()) { foreach (CuttingItem eachCuttingItem in cuttingItems) { Price buyPrice, sellPrice, closePrice; if (eachCuttingItem.IsBuy) { buyPrice = cutPrice; sellPrice = eachCuttingItem.ExecutePrice; } else { sellPrice = cutPrice; buyPrice = eachCuttingItem.ExecutePrice; } closePrice = cutPrice; decimal subCommission = 0m, subLevy = 0m, subOtherFee = 0m; decimal tradePL = TradePLCalculator.Calculate(instrument.TradePLFormula, eachCuttingItem.CuttingLot, eachCuttingItem.ContractSize, (decimal)buyPrice, (decimal)sellPrice, (decimal)closePrice, _owner.Currency(null).Decimals); var feeParameter = new FeeParameter() { Account = account, TradePolicyDetail = tradePolicyDetail, SpecialTradePolicyDetail = specialTradePolicyDetail, Instrument = instrument, CurrencyRate = currencyRate, ContractSize = contractSize, OpenOrderExecuteTime = eachCuttingItem.ExecuteTime, ClosedLot = eachCuttingItem.CuttingLot, ExecutePrice = cutPrice, TradePL = tradePL }; OrderRelation.CalculateFee(feeParameter, out subCommission, out subLevy, out subOtherFee); commission += subCommission; levy += subLevy; otherFee += subOtherFee; } } if (instrument.LevyFormula.TakeFeeAsCost()) { levy = this.CalculateFeeCommon(account.RateLevy, tradePolicyDetail.LevyClose, closedLot, contractSize); } if (instrument.OtherFeeFormula.TakeFeeAsCost()) { otherFee = this.CalculateFeeCommon(account.RateOtherFee, tradePolicyDetail.OtherFeeClose, closedLot, contractSize); } if (instrument.CommissionFormula.TakeFeeAsCost()) { commission = this.CalculateFeeCommon(account.RateCommission, tradePolicyDetail.CommissionCloseD, closedLot, contractSize); } else { if (commission >= 0) { commission = Math.Max(commission, tradePolicyDetail.MinCommissionClose); } } } else { if (instrument.CommissionFormula.TakeFeeAsCost()) //Adjust PricePips { commission = this.CalculateFeeCommon(account.RateCommission, tradePolicyDetail.CommissionOpen, closedLot, contractSize); } else { if (!instrument.CommissionFormula.IsDependOnPL() && specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionCommissionOn) { commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * tradePolicyDetail.CommissionOpen, (int)closedLot, contractSize, cutPrice, currencyRate) + FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * tradePolicyDetail.CommissionOpen, closedLot - (int)closedLot, contractSize, cutPrice, currencyRate); } else { commission = FeeCalculator.CalculateCommission(instrument.CommissionFormula, instrument.TradePLFormula, account.RateCommission * tradePolicyDetail.CommissionOpen, closedLot, contractSize, cutPrice, currencyRate); } if (commission >= 0) { commission = Math.Max(commission, tradePolicyDetail.MinCommissionOpen); } } if (instrument.LevyFormula.TakeFeeAsCost()) //Adjust PricePips { levy = this.CalculateFeeCommon(account.RateLevy, tradePolicyDetail.LevyOpen, closedLot, contractSize); } else { if (!instrument.LevyFormula.IsDependOnPL() && specialTradePolicyDetail != null && specialTradePolicyDetail.IsFractionCommissionOn) { levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * tradePolicyDetail.LevyOpen, (int)closedLot , contractSize, cutPrice, currencyRate) + FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * tradePolicyDetail.LevyOpen, closedLot - (int)closedLot , contractSize, cutPrice, currencyRate); } else { levy = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateLevy * tradePolicyDetail.LevyOpen, closedLot, contractSize, cutPrice, currencyRate); } if (!instrument.LevyFormula.IsDependOnPL() && specialTradePolicyDetail != null) { CurrencyRate cgseLevyCurrencyRate = FeeCalculator.GetCGSELevyCurrencyRate(account, instrument, specialTradePolicyDetail, currencyRate, null); levy += FeeCalculator.CalculateCGSELevy(closedLot, true, specialTradePolicyDetail, cgseLevyCurrencyRate); } } if (instrument.OtherFeeFormula.TakeFeeAsCost()) { otherFee = this.CalculateFeeCommon(account.RateOtherFee, tradePolicyDetail.OtherFeeOpen, closedLot, contractSize); } else { otherFee = FeeCalculator.CalculateLevy(instrument.LevyFormula, instrument.TradePLFormula, account.RateOtherFee * tradePolicyDetail.OtherFeeOpen, closedLot, contractSize, cutPrice, currencyRate); } } return(commission + levy + otherFee);; }
private bool ShouldUpdateOrderRelationValueDate(OrderRelation orderRelation, DateTime resetTime) { Order closeOrder = orderRelation.CloseOrder; return(closeOrder.Phase == OrderPhase.Executed && !closeOrder.IsOpen && closeOrder.ExecuteTime <= resetTime && orderRelation.ValueTime == null); }
internal OrderRelationSettings(OrderRelation owner, Order closeOrder, OrderRelationConstructParams constructParams) : base(owner) { _closeOrder = closeOrder; this.Parse(constructParams); }
internal OrderRelationExecuteService(OrderRelation owner, OrderRelationSettings settings) { _owner = owner; _settings = settings; }