protected override void Parse(OrderConstructParams constructParams)
{
base.Parse(constructParams);
var physicalOrderConstructParams = (PhysicalOrderConstructParams)constructParams;
this.ParsePhysicalSettings(physicalOrderConstructParams.PhysicalSettings);
}
protected override void Parse(OrderConstructParams constructParams)
{
base.Parse(constructParams);
var boOrderConstructParams = (BOOrderConstructParams)constructParams;
_betTypeId = this.CreateReadonlyItem("BOBetTypeID", boOrderConstructParams.BetTypeId);
_frequency = this.CreateReadonlyItem("BOFrequency", boOrderConstructParams.Frequency);
_betOption = this.CreateReadonlyItem("BOBetOption", boOrderConstructParams.BetOption);
_settleTime = this.CreateSoundItem("BOSettleTime", boOrderConstructParams.SettleTime);
_odds = this.CreateReadonlyItem("BOOdds", boOrderConstructParams.Odds);
_paidPledge = this.CreateSoundItem("PaidPledge", boOrderConstructParams.PaidPledge);
_paidPledgeBalance = this.CreateSoundItem("PaidPledgeBalance", boOrderConstructParams.PaidPledgeBalance);
}
private void ParseCommon(OrderConstructParams constructParams, AddDoneOrderCommandBase command)
{
constructParams.Id = Guid.NewGuid();
constructParams.Code = TransactionCodeGenerater.Default.GenerateOrderCode(command.OpenOrder.Owner.Owner.Setting().OrganizationId);
constructParams.Phase = OrderPhase.Placing;
constructParams.IsOpen = false;
constructParams.IsBuy = !command.OpenOrder.IsBuy;
constructParams.SetPrice = command.ClosePrice;
constructParams.OriginalLot = command.OpenOrder.LotBalance;
constructParams.Lot = command.OpenOrder.LotBalance;
constructParams.TradeOption = command.TradeOption;
constructParams.OperationType = Framework.OperationType.AsNewRecord;
}
protected void ValidateForCloseOrder(OrderCommonData orderData, OrderConstructParams constructParams)
{
Logger.InfoFormat("closeOrderId = {0}, totalClosedLot = {1}, lot = {2}", orderData.Id, constructParams.LotBalance, orderData.Lot);
foreach (var eachOrderRelation in orderData.OrderRelations)
{
var closedLot = eachOrderRelation.ClosedLot;
constructParams.LotBalance -= closedLot;
}
if (constructParams.LotBalance != 0)
{
throw new TransactionServerException(TransactionError.InvalidLotBalance, string.Format("closeOrderId = {0}, leftLotBalance = {1}, lot = {2}", orderData.Id, constructParams.LotBalance, orderData.Lot));
}
}
private void ParseCommon(AddAutoCloseOrderCommandBase command)
{
OrderConstructParams constructParams = command.ConstructParams;
constructParams.OperationType = Framework.OperationType.AsNewRecord;
constructParams.Id = Guid.NewGuid();
constructParams.Phase = OrderPhase.Executed;
constructParams.IsOpen = false;
constructParams.IsBuy = !command.OpenOrder.IsBuy;
constructParams.SetPrice = command.ClosePrice;
constructParams.ExecutePrice = command.ClosePrice;
constructParams.Lot = command.OpenOrder.LotBalance;
constructParams.OriginalLot = command.OpenOrder.LotBalance;
constructParams.TradeOption = command.TradeOption;
}
private static Order CreateOrder(Order order, Price price, TradeOption tradeOption)
{
OrderConstructParams orderConstructParams = new OrderConstructParams
{
Id = Guid.NewGuid(),
Phase = OrderPhase.Executed,
IsOpen = false,
IsBuy = !order.IsBuy,
SetPrice = price,
ExecutePrice = price,
Lot = order.LotBalance,
OriginalLot = order.LotBalance,
TradeOption = tradeOption
};
return(OrderFacade.Default.CreateOrder(order.Owner, orderConstructParams));
}
internal Order(Transaction owner, OrderConstructParams constructParams, OrderServiceFactoryBase serviceFactory)
: base(BusinessRecordNames.Order, ATTRIBUTE_ITEMS_CAPACITY)
{
this.ConstructParams = constructParams;
this.ServiceFactory = serviceFactory;
_pairOrderIsHit = false;
this.IsHitReseted = false;
_owner = owner;
_orderSettings = serviceFactory.CreateOrderSettings(this, constructParams);
if (owner != null)
{
owner.AddOrder(this, constructParams.OperationType);
}
_orderRelations = new BusinessRecordDictionary <Guid, OrderRelation>(BusinessRecordCollectionNames.OrderRelations, this, ORDER_RELATION_CAPACITY);
_feeCalculator = new Lazy <OrderFeeCalculatorBase>(() => serviceFactory.CreateOrderFeeCalculator(this, _orderSettings));
_openOrderCalculator = new Lazy <OpenOrderCalculatorBase>(() => serviceFactory.CreateOpenOrderCalculator(this, _orderSettings));
_closeOrderCalculator = new Lazy <CloseOrderCalculator>(() => serviceFactory.CreateCloseOrderCalculator(this, _orderSettings));
_executeService = new Lazy <OrderExecuteServiceBase>(() => serviceFactory.CreateOrderExecuteService(this, _orderSettings));
_precheckServcie = new Lazy <OrderPreCheckServiceBase>(() => serviceFactory.CreatePreCheckService(this));
_valuedPLCalculator = new Lazy <ValuedPLCalculatorBase>(() => serviceFactory.CreateValuedPLCalculator(this));
_currencyId = BusinessItemFactory.Create("CurrencyID", owner.CurrencyId, PermissionFeature.ReadOnly, this);
}
internal abstract OrderSettings CreateOrderSettings(Order order, OrderConstructParams constructParams);
internal override Order CreateOrder(Transaction tran, OrderConstructParams constructParams)
{
return(new Order(tran, constructParams, this));
}
internal override OrderSettings CreateOrderSettings(Order order, OrderConstructParams constructParams)
{
return(new PhysicalOrderSettings((PhysicalOrder)order, (PhysicalOrderConstructParams)constructParams));
}
internal abstract Order CreateOrder(Transaction tran, OrderConstructParams constructParams);
internal override OrderSettings CreateOrderSettings(Agent.Order order, OrderConstructParams constructParams)
{
return(new BOOrderSettings((BinaryOption.Order)order, (BOOrderConstructParams)constructParams));
}
internal override Agent.Order CreateOrder(Transaction tran, OrderConstructParams constructParams)
{
return(new BinaryOption.Order(tran, (BOOrderConstructParams)constructParams, this));
}
internal static void ParseForGeneral(this OrderConstructParams constructParams, IDBRow dataRowOrder, Guid instrumentId, Guid accountId, DateTime?tradeDay)
{
constructParams.Id = (Guid)dataRowOrder["ID"];
if (dataRowOrder["Code"] != DBNull.Value)
{
constructParams.Code = (string)dataRowOrder["Code"];
}
constructParams.BlotterCode = dataRowOrder["BlotterCode"] == DBNull.Value ? null : (string)dataRowOrder["BlotterCode"];
constructParams.Phase = (OrderPhase)(byte)dataRowOrder["Phase"];
constructParams.TradeOption = (TradeOption)(byte)dataRowOrder["TradeOption"];
constructParams.IsOpen = (bool)dataRowOrder["IsOpen"];
constructParams.IsBuy = (bool)dataRowOrder["IsBuy"];
if (dataRowOrder["SetPrice"] != DBNull.Value)
{
constructParams.SetPrice = PriceHelper.CreatePrice((string)dataRowOrder["SetPrice"], instrumentId, tradeDay);
}
if (dataRowOrder["ExecutePrice"] != DBNull.Value)
{
constructParams.ExecutePrice = PriceHelper.CreatePrice((string)dataRowOrder["ExecutePrice"], instrumentId, tradeDay);
}
if (dataRowOrder["SetPriceMaxMovePips"] != DBNull.Value)
{
constructParams.SetPriceMaxMovePips = (int)dataRowOrder["SetPriceMaxMovePips"];
}
if (dataRowOrder["DQMaxMove"] != DBNull.Value)
{
constructParams.DQMaxMove = (int)dataRowOrder["DQMaxMove"];
}
constructParams.Lot = (decimal)dataRowOrder["Lot"];
constructParams.OriginalLot = (decimal)dataRowOrder["OriginalLot"];
constructParams.LotBalance = (decimal)dataRowOrder["LotBalance"];
constructParams.InterestPerLot = dataRowOrder.GetColumn <decimal>("InterestPerLot");
constructParams.StoragePerLot = dataRowOrder.GetColumn <decimal>("StoragePerLot");
constructParams.HitCount = (short)dataRowOrder["HitCount"];
if (dataRowOrder["InterestValueDate"] != DBNull.Value)
{
constructParams.InterestValueDate = (DateTime)dataRowOrder["InterestValueDate"];
}
if (constructParams.HitCount != 0 && dataRowOrder["BestPrice"] != DBNull.Value)
{
constructParams.BestPrice = PriceHelper.CreatePrice((string)dataRowOrder["BestPrice"], instrumentId, tradeDay);
}
if (constructParams.HitCount != 0 && dataRowOrder["BestTime"] != DBNull.Value)
{
constructParams.BestTime = (DateTime)dataRowOrder["BestTime"];
}
if (dataRowOrder["EstimateCloseCommission"] != DBNull.Value)
{
constructParams.EstimateCloseCommission = (decimal)dataRowOrder["EstimateCloseCommission"];
}
if (dataRowOrder["EstimateCloseLevy"] != DBNull.Value)
{
constructParams.EstimateCloseLevy = (decimal)dataRowOrder["EstimateCloseLevy"];
}
}
internal abstract AddOrderCommandBase CreateByGeneral(Transaction tran, OrderConstructParams constructParams);
internal override OrderSettings CreateOrderSettings(Order order, OrderConstructParams constructParams)
{
return(new OrderSettings(order, constructParams));
}
internal override AddOrderCommandBase CreateByGeneral(Transaction tran, OrderConstructParams constructParams)
{
throw new NotImplementedException();
}
public Order CreateOrder(Transaction tran, OrderConstructParams constructParams)
{
return(this.OrderServiceFactoryBase.CreateOrder(tran, constructParams));
}
