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 static void Initialize(OrderRelation item, DataRow dataRow)
{
item.OrderId1 = (Guid)dataRow["OpenOrderId"];
item.OrderId2 = (Guid)dataRow["CloseOrderId"];
item.Lot = (decimal)dataRow["ClosedLot"];
}
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;
}
