protected void UpdateMarketDataVM(MarketDataVM mktVM, PBMarketData md)
{
//var contractInfo = ClientDbContext.FindContract(md.Contract);
mktVM.LastPrice = md.MatchPrice;
mktVM.BidPrice = md.BidPrice[0];
mktVM.AskPrice = md.AskPrice[0];
mktVM.BidSize = md.BidVolume[0];
mktVM.AskSize = md.AskVolume[0];
mktVM.Volume = md.Volume;
mktVM.OpenValue = md.OpenValue;
mktVM.PreCloseValue = md.PreCloseValue;
mktVM.HighValue = md.HighValue;
mktVM.LowValue = md.LowValue;
mktVM.UpperLimitPrice = md.HighLimit;
mktVM.LowerLimitPrice = md.LowLimit;
mktVM.SettlePrice = md.SettlePrice;
mktVM.PreSettlePrice = md.PreSettlePrice;
mktVM.AveragePrice = md.AveragePrice;
mktVM.HighLimint = md.HighLimit;
mktVM.LowLimint = md.LowLimit;
mktVM.OpenInterest = md.OpenInterest;
mktVM.OpenValue = md.OpenValue;
mktVM.PreOpenInterest = md.PreOpenInterest;
mktVM.PriceChange = md.PriceChange;
mktVM.CloseValue = md.CloseValue;
mktVM.Turnover = md.Turnover;
mktVM.MidPrice = (mktVM.BidPrice + mktVM.AskPrice) / 2;
mktVM.AveragePriceMultiplier = mktVM.AveragePrice / mktVM.Multiple;
mktVM.UpdateTime = string.Format("{0:D2}:{1:D2}:{2:D2}", md.UpdateTime / 3600, (md.UpdateTime / 60) % 60, md.UpdateTime % 60);
}
protected virtual IList <MarketDataVM> AddToMarketDataMap(IEnumerable <ContractKeyVM> subList)
{
var ret = new List <MarketDataVM>();
foreach (var md in subList)
{
MarketDataVM mktVM = FindMarketData(md.Contract);
if (mktVM == null)
{
var contractInfo = ClientDbContext.FindContract(md.Contract);
mktVM = new MarketDataVM
{
Exchange = md.Exchange,
Contract = md.Contract,
Multiple = contractInfo != null ? contractInfo.VolumeMultiple : 1
};
MarketDataMap[md.Contract] = new WeakReference <MarketDataVM>(mktVM);
}
ret.Add(mktVM);
}
return(ret);
}
protected virtual IList <MarketDataVM> SubMDSuccessAction(PBMarketDataList marketList)
{
var ret = new List <MarketDataVM>();
foreach (var md in marketList.MarketData)
{
MarketDataVM mktVM = FindMarketData(md.Contract);
if (mktVM != null)
{
if (mktVM.OpenValue == 0)
{
UpdateMarketDataVM(mktVM, md);
}
if (string.IsNullOrEmpty(mktVM.Exchange))
{
mktVM.Exchange = md.Exchange;
}
ret.Add(mktVM);
}
}
return(ret);
}
public void FilterByContract(string contract)
{
if (quoteListView == null)
{
return;
}
ICollectionView view = CollectionViewSource.GetDefaultView(quoteListView.ItemsSource);
view.Filter = delegate(object o)
{
if (contract == null)
{
return(true);
}
MarketDataVM qvm = o as MarketDataVM;
if (qvm.Contract.Contains(contract))
{
return(true);
}
return(false);
};
}
private void quoteListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (OnQuoteSelected != null)
{
MarketDataVM quoteVM = quoteListView.SelectedItem as MarketDataVM;
OnQuoteSelected(quoteVM);
}
}
public void OnQuoteSelected(MarketDataVM quoteVM)
{
if (quoteVM != null)
{
_currentContract = quoteVM.Contract;
stackPanelPrices.DataContext = quoteVM;
OrderVM.Contract = quoteVM.Contract;
}
}
public MarketDataVM FindMarketData(string contract)
{
WeakReference <MarketDataVM> mktVMRef;
MarketDataVM mktVM = null;
if (MarketDataMap.TryGetValue(contract, out mktVMRef))
{
mktVMRef.TryGetTarget(out mktVM);
}
return(mktVM);
}
private async void PnLIndex(string portfolio)
{
var positions = _tradeExHandler.PositionVMCollection.Where(p => p.Portfolio == portfolio);
foreach (var vm in positions)
{
var contractinfo = ClientDbContext.FindContract(vm.Contract);
string basecontract = null;
if (contractinfo != null)
{
if (!string.IsNullOrEmpty(contractinfo.UnderlyingContract))
{
basecontract = contractinfo.UnderlyingContract;
}
else
{
basecontract = contractinfo.Contract;
}
MarketDataVM = await _marketDataHandler.SubMarketDataAsync(basecontract);
}
if (_riskSet.Contains(basecontract))
{
if ((callCheckBox.IsChecked.Value && contractinfo.ContractType == (int)ContractType.CONTRACTTYPE_CALL_OPTION) ||
(putCheckBox.IsChecked.Value && contractinfo.ContractType == (int)ContractType.CONTRACTTYPE_PUT_OPTION) ||
(futureCheckBox.IsChecked.Value && contractinfo.ContractType == (int)ContractType.CONTRACTTYPE_FUTURE))
{
int index;
var basecontractPosition = positions.Where(p => p.Contract == basecontract).FirstOrDefault();
if (basecontractPosition != null)
{
if (basecontractPosition.Direction == PositionDirectionType.PD_LONG)
{
basecontractPosition.Profit = (MarketDataVM.LastPrice - basecontractPosition.MeanCost) * basecontractPosition.Position * basecontractPosition.Multiplier;
}
else if (basecontractPosition.Direction == PositionDirectionType.PD_SHORT)
{
basecontractPosition.Profit = (basecontractPosition.MeanCost - MarketDataVM.LastPrice) * basecontractPosition.Position * basecontractPosition.Multiplier;
}
if (_riskDict.TryGetValue(basecontract, out index))
{
var barItem = BarItemCollection[index];
barItem.Value += basecontractPosition.Profit;
}
}
}
}
}
plotModel.InvalidatePlot(true);
}
public void SetBindingData(MarketDataVM vmQuoteViewModel,
PositionViewModel longPosition,
PositionViewModel shortPosition,
FundViewModel vmFundViewModel)
{
mQuoteViewModel = vmQuoteViewModel;
mLPositionViewModel = longPosition;
mSPositionViewModel = shortPosition;
mFundViewModel = vmFundViewModel;
FundGrid.DataContext = mFundViewModel;
/// TBD
///
//for example by Lucas
QuoteGrid.DataContext = mQuoteViewModel;
}
protected virtual IList <MarketDataVM> SubMDSuccessAction(PBPricingDataList marketList)
{
var ret = new List <MarketDataVM>();
foreach (var md in marketList.PricingData)
{
MarketDataVM mktVM = FindMarketData(md.Contract);
if (mktVM == null)
{
mktVM = new MarketDataVM
{
Exchange = md.Exchange,
Contract = md.Contract
};
MarketDataMap[md.Contract] = new WeakReference <MarketDataVM>(mktVM);
}
ret.Add(mktVM);
}
return(ret);
}
//DataType is for window style, tabIndex is for
public void Filter(string tabTitle, string exchange, string underlying, string contract)
{
if (quoteListView == null)
{
return;
}
FilterSettingsWin.FilterTabTitle = tabTitle;
FilterSettingsWin.FilterExchange = exchange;
FilterSettingsWin.FilterUnderlying = underlying;
FilterSettingsWin.FilterContract = contract;
ICollectionView view = _viewSource.View;
view.Filter = delegate(object o)
{
if (contract == null)
{
return(true);
}
MarketDataVM qvm = o as MarketDataVM;
if (qvm == null)
{
return(true);
}
if (qvm.Exchange.ContainsAny(exchange) &&
qvm.Contract.ContainsAny(contract) &&
qvm.Contract.ContainsAny(underlying))
{
return(true);
}
return(false);
};
}
public void OnQuoteSelected(MarketDataVM quoteVM)
{
if (quoteVM != null)
{
checkBox.IsEnabled = true;
radioButtonBuy.IsChecked = true;
//radioButtonSell.IsChecked = false;
RadioA.IsChecked = true;
//RadioB.IsChecked = false;
//RadioC.IsChecked = false;
_currentContract = quoteVM.Contract;
OrderVM.Contract = quoteVM.Contract;
FastOrderContract.SelectedItem = OrderVM.Contract;
stackPanelPrices.DataContext = quoteVM;
OrderVM.LimitPrice = quoteVM.LastPrice;
var contractInfo = ClientDbContext.FindContract(OrderVM.Contract);
LimitTxt.Increment = contractInfo == null ? 1 : contractInfo.PriceTick;
if (radioButtonBuy.IsChecked.Value)
{
if (LabelAskPrice.Content != null)
{
LimitTxt.Value = double.Parse(LabelAskPrice.Content.ToString());
}
}
else if (radioButtonSell.IsChecked.Value)
{
if (LabelBidPrice.Content != null)
{
LimitTxt.Value = double.Parse(LabelBidPrice.Content.ToString());
}
}
if (checkBox.IsChecked.Value)
{
LimitTxt.Increment = null;
}
}
}
public void OnNewMarketData(MarketDataVM mktDataVM)
{
if (TradeHandler.PositionContractSet.Contains(mktDataVM.Contract))
{
Task.Run(() =>
{
lock (TradeHandler.PositionVMCollection)
{
var positions = TradeHandler.PositionVMCollection.FindByContract(mktDataVM.Contract);
foreach (var positionVM in positions)
{
if (positionVM.Direction == PositionDirectionType.PD_LONG)
{
positionVM.Profit = (mktDataVM.LastPrice - positionVM.MeanCost) * positionVM.Position * positionVM.Multiplier;
}
else if (positionVM.Direction == PositionDirectionType.PD_SHORT)
{
positionVM.Profit = (positionVM.MeanCost - mktDataVM.LastPrice) * positionVM.Position * positionVM.Multiplier;
}
}
}
});
}
}
protected void RaiseNewMD(MarketDataVM md)
{
OnNewMarketData?.Invoke(md);
}
