//------------------------------------------------------------------------------------------------------------------------//
void CMarketDataProvider::SubscribeRisksSingle(const CTicker& ticker)
{
IRisksProviderPtr spProvider = GetRisksProvider();
try
{
if (static_cast<bool>(spProvider))
{
ITicker request;
ticker.CopyTo(request);
_com_util::CheckError(spProvider->raw_SubscribeRisks(&request));
SysFreeString(request.Symbol);
SysFreeString(request.Exchange);
m_bInRequestMode = true;
}
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
}
return;
}
//------------------------------------------------------------------------------------------------------------------------//
void CMarketDataProvider::UnSubscribeQuote()
{
try
{
IPriceProviderPtr spPriceProvider = GetPriceProvider();
if (static_cast<bool>(spPriceProvider))
{
if (m_bInSubscribeMode)
{
spPriceProvider->raw_UnSubscribeQuote();
m_bInSubscribeMode = false;
}
}
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
};
return;
}
//------------------------------------------------------------------------------------------------------------------------//
void CMarketDataProvider::SubscribeQuotesSingle(const CTicker& ticker)
{
IPriceProviderPtr spPriceProvider = GetPriceProvider();
try
{
if (static_cast<bool>(spPriceProvider))
{
QuoteUpdateParams request;
ticker.CopyTo(request);
_com_util::CheckError(spPriceProvider->raw_SubscribeQuote(&request));
SysFreeString(request.Symbol);
SysFreeString(request.Exchange);
m_bInRequestMode = true;
}
}
catch (_com_error& err)
{
if (static_cast<bool>(spPriceProvider))
spPriceProvider->raw_CancelLastQuote();
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
};
return;
}
//-----------------------------------------------------------------------------------------------------//
void CMarketDataProvider::Disconnect()
{
try
{
IPriceProviderPtr spPriceProvider = GetPriceProvider();
if(static_cast<bool>(spPriceProvider))
{
DispQuotes::DispEventUnadvise(spPriceProvider);
DispRisks::DispEventUnadvise(spPriceProvider);
Sleep(1000L);
CancelLastQuote();
m_bInSubscribeMode = false;
m_bInRequestMode = false;
spPriceProvider->Disconnect();
SetPriceProvider(NULL);
}
}
catch(_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch(...)
{
TRACE_UNKNOWN_ERROR();
};
}
BOOL Sp::Open(LPCTSTR lpcszConn,int nTimeout,BOOL bAsync)
{
try
{
m_conn.CreateInstance("ADODB.Connection");
if (nTimeout > 0)
m_conn->ConnectionTimeout = nTimeout;
HRESULT hr = m_conn->Open(lpcszConn,L"",L"",bAsync ? adAsyncConnect : adConnectUnspecified);
if (SUCCEEDED(hr))
{
return TRUE;
}
else
{
TRACE(_T("Sp::Open exception Hr:0x%X\n"),hr);
m_conn = NULL;
return FALSE;
}
}
catch (_com_error &ex)
{
m_conn = NULL;
TRACE_COM_ERROR(ex);
return FALSE;
}
}
//----------------------------------------------------------------------------------//
void CTradesCache::LoadTrades()
{
try
{
if (static_cast<bool>(m_spTradeChannel))
{
BSTR bstrConnectionString;
if (GetSettingsImpl().get() == NULL)
utils::ThrowErrorNoSetErrorInfo(E_POINTER, L"Failed to GetSettings.");
GetSettingsImpl()->GetDBConnection(&bstrConnectionString);
SetConnectionString(bstrConnectionString);
HRESULT hr = m_spTradeChannel->put_DatabaseString(bstrConnectionString);
hr = m_spTradeChannel->LoadTrades(0, GetMain(), VARIANT_FALSE);
if(FAILED(hr))
utils::ThrowErrorNoSetErrorInfo(hr, L"Failed to LoadTrades.");
}
}
catch (_com_error& err){
std::ostringstream out_stream;
out_stream << "Exception occured while loading trades.";
TRACE_COM_ERROR(LOG4CPLUS_ERROR, VS::Log, err, std::string(out_stream.str()));
}
catch (...){
std::ostringstream out_stream;
out_stream<<"Unknown C++ exception occured while loading trades.";
TRACE_UNKNOWN_ERROR(LOG4CPLUS_ERROR, VS::Log, std::string(out_stream.str()));
ATLASSERT(FALSE);
}
};
//--------------------------------------------------------------------------------//
void CSyntheticEquity::AddComponent(IBasketAssetComponentPtr spComponent)
{
try
{
if (static_cast<bool>(spComponent) && static_cast<bool>(m_spComponents))
{
IAssetPtr spAsset = NULL;
//_CHK(spComponent->get_Asset(&spAsset), _T("Fail to get Asset."));
if (static_cast<bool>(spAsset))
{
LONG lID = 0;
BSTR bsSymbol = NULL;
IBasketAssetComponentPtr spAdded = NULL;
spAsset->get_ID(&lID);
spAsset->get_Symbol(&bsSymbol);
_CHK(m_spComponents->Add(lID, bsSymbol, spComponent.GetInterfacePtr(), &spAdded),
_T("Fail to add synthetic component."));
}
}
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
};
};
BOOL Sp::IsConnected(void)
{
try
{
return (m_conn->State == adStateOpen);
}
catch (_com_error &ex)
{
TRACE_COM_ERROR(ex);
return FALSE;
}
}
void Sp::Close(BOOL bCancel)
{
try
{
if (bCancel)
m_conn->Cancel();
m_conn = NULL;
}
catch (_com_error &ex)
{
TRACE_COM_ERROR(ex);
}
}
//--------------------------------------------------------------------------------//
STDMETHODIMP
CCalculationSettingsAtom::put_CurveInterpolationType(LONG newVal){
try {
CCalculationSettingsSingleton::Instance()->set_interpolation_type(newVal);
}
catch (_com_error& err){
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...){
TRACE_UNKNOWN_ERROR();
return E_FAIL;
};
return S_OK;
};
//--------------------------------------------------------------------------------------//
void CMarketDataProvider::Subscribe(RequestVector& request)
{
HRESULT hr = S_OK;
try
{
IBatchPriceProviderPtr spBatchPriceProvider = GetBatchPriceProvider();
if (static_cast<bool>(spBatchPriceProvider))
{
CComRecPtr<QuoteUpdateParams, &LIBID_PRICEPROVIDERSLib> RequestInfo;
RequestInfo.Init();
long outSize = static_cast<long>(request.size());
SAFEARRAYBOUND sab = { outSize, 0 };
LPSAFEARRAY psa = ::SafeArrayCreateEx( VT_RECORD, 1, &sab, (PVOID) RequestInfo.GetRecordInfo() );
if(psa)
{
QuoteUpdateParams* pvOutData = NULL;
if(SUCCEEDED(hr = ::SafeArrayAccessData(psa, (void**)&pvOutData)))
{
memset(pvOutData, 0, outSize * sizeof(QuoteUpdateParams));
int j = 0;
for (RequestVector::iterator it = request.begin(); it != request.end(); ++it)
{
(*it).CopyTo(pvOutData[j]);
j++;
}
::SafeArrayUnaccessData(psa);
}
}
_com_util::CheckError(spBatchPriceProvider->raw_SubscribeMultipleQuotes(&psa));
::SafeArrayDestroy(psa);
m_bInSubscribeMode = true;
}
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
};
return;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP
CCalculationSettingsAtom::put_Normal(DOUBLE Value){
try{
CCalculationSettingsSingleton::Instance()->setNormal(double(Value));
}
catch (_com_error& err){
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...){
TRACE_UNKNOWN_ERROR();
return E_FAIL;
};
return S_OK;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP CCalculationSettingsAtom::put_GreeksCalculationMode(LONG newVal)
{
try
{
CCalculationSettingsSingleton::Instance()->SetGreeksCalculationMode(static_cast<IvRmCore::GreeksCalculationModeEnum>(newVal));
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
};
return S_OK;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP CCalculationSettingsAtom::put_PriceRoundingRule(LONG newVal)
{
try
{
CCalculationSettingsSingleton::Instance()->SetPriceRoundingRule(newVal);
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
return E_FAIL;
}
return S_OK;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP CCalculationSettingsAtom::put_UseTheoVolaIfBadMarketVola(LONG newVal)
{
try
{
CCalculationSettingsSingleton::Instance()->SetUseTheoVolaIfBadMarketVola(newVal > 0 ? true : false);
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
return E_FAIL;
}
return S_OK;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP
CCalculationSettingsAtom::get_CurveInterpolationType(LONG* pRetVal){
if (pRetVal == NULL)
return E_POINTER;
try{
*pRetVal = CCalculationSettingsSingleton::Instance()->interpolation_type();
}
catch (_com_error& err){
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...){
TRACE_UNKNOWN_ERROR();
return E_FAIL;
};
return S_OK;
};
//------------------------------------------------------------------------------------------------------
STDMETHODIMP CEtsDivColl::Reload(void)
{
try
{
CDBConnection dbConnection;
if(!dbConnection.IsOpened())
dbConnection.Open(CGenegalSettings::GetDBConnectionString(), 10, 120, 300, 300);
if (dbConnection.IsOpened())
{
Clear();
CStoredProc<> db(dbConnection, L"usp_Dividends_Get");
//push parameters
db << m_nAssetID;
CClientRecordset rs;
rs.Open(db);
DATE dtDividendDate;
DOUBLE dDividendAmmount;
for(rs.MoveFirst(); !rs.IsEOF(); ++rs)
{
dtDividendDate = (vt_date)rs[L"DivYtes"];
dDividendAmmount = rs[L"DivAmnt"];
_CHK(AddNonUnique(dtDividendDate, dDividendAmmount), _T("Fail to Add Dividend payment date."));
};
dbConnection.Close();
};
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
}
return S_OK;
}
//-----------------------------------------------------------------------------------------------------//
void CMarketDataProvider::Connect()
{
try
{
if(GetPriceProvider()) Disconnect();
IPriceProviderPtr spPriceProvider;
_com_util::CheckError(spPriceProvider.CreateInstance(__uuidof(DataFeedBatchPriceInfo)));
IProviderPtr spProvider = spPriceProvider;
//spProvider->Type = 10;
spPriceProvider->Connect();
IProvidersPtr spProvidersInfo;
_com_util::CheckError(spProvidersInfo.CreateInstance(CLSID_Providers));
_com_util::CheckError(spProvidersInfo->Initialize());
IProviderDataPtr spProviderInfo;
//_com_util::CheckError(spProvidersInfo->GetProvider(spProvider->Type,&spProviderInfo));
_com_util::CheckError(DispQuotes::DispEventAdvise(spPriceProvider/*, &IID_IBatchPriceProvider*/)); // can't connect error occure
_com_util::CheckError(DispRisks::DispEventAdvise(spPriceProvider/*, &IID_IRisksProvider*/)); // can't connect error occure
SetPriceProvider(spPriceProvider);
m_dwCooke = NULL;
CComGITPtr<IPriceProvider> ptrProviderGIT(m_spPriceProvider.GetInterfacePtr());
m_dwCooke = ptrProviderGIT.Detach();
}
catch(_com_error& err)
{
Disconnect();
TRACE_COM_ERROR(err);
}
catch(...)
{
TRACE_UNKNOWN_ERROR();
}
};
//--------------------------------------------------------------------------------//
STDMETHODIMP CCalculationSettingsAtom::get_GreeksCalculationMode(LONG* pRetVal)
{
if (pRetVal == NULL)
return E_POINTER;
try
{
*pRetVal = static_cast<LONG>(CCalculationSettingsSingleton::Instance()->GetGreeksCalculationMode());
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
};
return S_OK;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP
CCalculationSettingsAtom::get_Normal(DOUBLE* RetVal){
if (RetVal == NULL)
return E_POINTER;
try{
*RetVal = CCalculationSettingsSingleton::Instance()->getNormal();
}
catch (_com_error& err){
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...){
TRACE_UNKNOWN_ERROR();
return E_FAIL;
};
return S_OK;
};
//-----------------------------------------------------------------------------------------------------//
void CMarketDataProvider::GetRisksUpdate()
{
HRESULT hr = S_OK;
try
{
IRisksProviderPtr spProvider = GetRisksProvider();
if (static_cast<bool>(spProvider))
{
SAFEARRAY* pSafeArray = spProvider->GetRisksUpdates();
if(pSafeArray)
{
IRisksFullInfo* pvData = NULL;
if( SUCCEEDED( hr = ::SafeArrayAccessData( pSafeArray, (void**)&pvData) ) )
{
long lLBound = 0;
long lUBound = 0;
HRESULT hRes = SafeArrayGetLBound(pSafeArray, 1L, &lLBound);
hRes = SafeArrayGetUBound(pSafeArray, 1L, &lUBound);
long lArraySize = lUBound - lLBound ;
for(int i = 0; i<= lArraySize; ++i)
_AcceptRisks(pvData[i].Ticker, pvData[i].Risks);
::SafeArrayUnaccessData(pSafeArray);
}
::SafeArrayDestroy(pSafeArray);
}
}
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
}
return;
};
//--------------------------------------------------------------------------------//
STDMETHODIMP CCalculationSettingsAtom::get_PriceTolerance(DOUBLE* pRetVal)
{
if (pRetVal == NULL)
return E_POINTER;
try
{
*pRetVal = static_cast<DOUBLE>(CCalculationSettingsSingleton::Instance()->GetPriceTolerance());
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
return E_FAIL;
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
return E_FAIL;
};
return S_OK;
};
//-----------------------------------------------------------------------------------------------------//
STDMETHODIMP CMarketDataProvider::_AcceptQuote(const QuoteUpdateParams& Params, QuoteUpdateInfo& Info)
{
HRESULT __Result = E_FAIL;
try
{
CTicker ticker(Params);
CQuote quote(Info);
AcceptQuote(ticker, quote);
__Result = S_OK;
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
}
return __Result;
};
//---------------------------------------------------------------------------------------------//
STDMETHODIMP CMmTradeChannel::GetData(IEtsFilterData* ipFilter, IMmTradeInfoColl** ipResult)
{
try
{
__CHECK_POINTER(ipFilter);
IEtsFilterDataPtr spFilter = NULL;
spFilter.Attach(ipFilter, true);
if (!ipResult)
return E_POINTER;
if(*ipResult){
(*ipResult)->Release();
*ipResult = NULL;
};
IMmTradeInfoCollPtr spResult = IMmTradeInfoCollPtr(__uuidof(MmTradeInfoColl));
*ipResult = (IMmTradeInfoColl*)spResult;
if (*ipResult)
(*ipResult)->AddRef();
if (*ipResult){
CTradeInfoViewData filteredTrades;
FilterData(spFilter, filteredTrades);
if (filteredTrades.size() > 0){
CTradeInfoViewData::iterator it = filteredTrades.begin();
CTradeInfoViewData::iterator itEnd = filteredTrades.end();
for (; it != itEnd; it++)
{
long lTradeID = 0L;
_CHK((*it)->get_TradeID(&lTradeID), _T("Fail to get trade id."));
DATE dtTradeDate = 0.;
_CHK((*it)->get_TradeDate(&dtTradeDate), _T("Fail to get TradeDate."));
IMmTradeInfoAtomPtr spReturnPtr = NULL;
IMmTradeInfoAtomPtr spTrade = (*it);
spResult->Add(lTradeID, dtTradeDate, spTrade, &spReturnPtr);
/*_CHK((*ipResult)->Add(lTradeID, dtTradeDate, spTrade, &spReturnPtr),
_T("Fail to Add trade to collection."));*/
}
}
};
}
catch (_com_error& err)
{
TRACE_COM_ERROR(err);
ATLASSERT(FALSE);
throw;
}
catch (...)
{
TRACE_UNKNOWN_ERROR();
ATLASSERT(FALSE);
throw;
};
return S_OK;
};
//----------------------------------------------------------------------------------//
bool CTradesCache::ProcessTradeForAnalytics(CTradePtr spTrade){
if (spTrade.get()){
long lStep = 0;
IRisks retRisks;
try{
retRisks = spTrade->m_spContract->Calculate(NULL, NULL);
}
catch (_com_error& err){
std::ostringstream out_stream;
out_stream << "Analytical data for trade [";
out_stream << spTrade->m_nTradeID;
out_stream<< "] has not been ready at this moment. It will be respocessed one more time by queue.";
TRACE_COM_ERROR(LOG4CPLUS_WARN,
VS::Log,
err,
std::string(out_stream.str()));
return false;
}
try{
//format xml to pass to DB
lStep = 1;
_bstr_t bstrXML;
bstrXML.Attach(GetXMLString(&retRisks, spTrade));
lStep = 2;
//save to DB
InitializeDB();
CStoredProc<CClientRecordset> rs(GetDBConnection(), L"usp_ContractAnalytics_Save");
rs << bstrXML;
lStep = 3;
rs.Open();
lStep = 4;
rs.Close();
return true;
}
catch (_com_error& err){
std::ostringstream out_stream;
out_stream<<"Exception occured while ProcessTradeForAnalytics().\n\tStep = " << lStep;
out_stream<<"\n\tTradeID = " << spTrade->m_nTradeID;
TRACE_COM_ERROR(LOG4CPLUS_ERROR, VS::Log, err, std::string(out_stream.str()));
return false;
}
catch (...){
std::ostringstream out_stream;
out_stream<<"Unknown C++ exception occured while ProcessTradeForAnalytics().\n\tStep = " << lStep;
out_stream<<"\n\tTradeID = " << spTrade->m_nTradeID;
TRACE_UNKNOWN_ERROR(LOG4CPLUS_ERROR, VS::Log, std::string(out_stream.str()));
return false;
}
}
return false;
};
