netdb.cpp.svn-base

股票软件源码

	}

	markup.ResetPos();
	return TRUE;

/*	OLD VERSION
	SetSize( 0 );
	m_strVersion.Empty();

	MSXML::IXMLDOMNodePtr		pNodeRoot = m_xmlDocument.XMLDoc();

	try
	{
		// extract setting
		MSXML::IXMLDOMNodeListPtr	pNodeList = pNodeRoot->selectNodes( szSettingElement );
		if( NULL != pNodeList )
		{
			for( int i=0; i<pNodeList->length; i++ )
			{
				MSXML::IXMLDOMNodePtr pNode = pNodeList->Getitem(i);
				if( !SetAttribute( pNode ) )
				{
					m_xmlDocument.SetLastErrorMessage( szErrXMLServerSetting );
					return FALSE;
				}
			}
		}

		// extract server
		pNodeList = pNodeRoot->selectNodes( szServerElement );
		if( NULL == pNodeList || 0 == pNodeList->length )
		{
			return TRUE;
		}

		for( int i=0; i<pNodeList->length; i++ )
		{
			MSXML::IXMLDOMNodePtr pNode = pNodeList->Getitem(i);
			CDownloadServer	server;
			if( server.SetAttribute( pNode ) )
				m_aDownloadServers.Add( server );
		}
	}
	catch( _com_error e )
	{
		m_xmlDocument.SetLastErrorMessage( e.ErrorMessage() );
		return FALSE;
	}
	return TRUE;
*/
}

BOOL CServers::GetLastErrorMessage(LPTSTR lpszError, UINT nMaxError)
{
	return m_xmlDocument.GetLastErrorMessage( lpszError, nMaxError );
}

BOOL CServers::SaveToProfile( )
{
	CSPStringArray	astrServers;
	for( int i=0; i<m_aDownloadServers.GetSize(); i++ )
		astrServers.Add( m_aDownloadServers.ElementAt(i).AsString() );
	AfxGetProfile().SetDownloadServers( astrServers );
	AfxGetProfile().StoreProfile();
	AfxGetQSProfile().AddQuoteServers( m_aQuoteServers );
	AfxGetQSProfile().StoreAliases( m_aAliases );
	AfxGetQSProfile().StoreProfile();
	return TRUE;
}

//////////////////////////////////////////////////////////////////////////////////
//	class CNetDatabase

CNetDatabase::CNetDatabase( )
{
}

CNetDatabase::~CNetDatabase( )
{
}

BOOL CNetDatabase::SetServer( LPCTSTR lpszServer, INTERNET_PORT port )
{
	if( !m_httpClient.SetServer( lpszServer, port ) )
	{
		SetLastError( ERR_NETDB_HTTPCLIENT );
		return FALSE;
	}
	return TRUE;
}

BOOL CNetDatabase::SetAccessType( int nAccessType, int nProxyType, LPCTSTR lpszProxyAddress, UINT nProxyPort,
								LPCSTR lpszProxyUser, LPCTSTR lpszProxyPasswd )
{
	if( ! m_httpClient.SetAccessType( nAccessType, nProxyType, lpszProxyAddress, nProxyPort, lpszProxyUser, lpszProxyPasswd ) )
	{
		SetLastError( ERR_NETDB_HTTPCLIENT );
		return FALSE;
	}
	return TRUE;
}

BOOL CNetDatabase::Login( LPCTSTR lpszRegCode, LPCTSTR lpszUserName,
						  LPCTSTR lpszPasswd, LPCTSTR lpszVersion )
{
	if( ! m_httpClient.Login( lpszRegCode, lpszUserName, lpszPasswd, lpszVersion ) )
	{
		SetLastError( ERR_NETDB_HTTPCLIENT );
		return FALSE;
	}
	return TRUE;
}

BOOL CNetDatabase::Logout( )
{
	if( ! m_httpClient.Logout( ) )
	{
		SetLastError( ERR_NETDB_HTTPCLIENT );
		return FALSE;
	}
	return TRUE;
}

BOOL CNetDatabase::GetLastErrorMessage(LPTSTR lpszError, UINT nMaxError )
{
	switch( GetLastError() )
	{
	case ERR_NETDB_HTTPCLIENT:
		return m_httpClient.GetLastErrorMessage( lpszError, nMaxError );
	case ERR_NETDB_PACKAGES:
		return m_packages.GetLastErrorMessage( lpszError, nMaxError );
	case ERR_NETDB_SERVERS:
		return m_servers.GetLastErrorMessage( lpszError, nMaxError );
	case ERR_NETDB_ZIPDLL:
		strncpy( lpszError, szErrZipDll, nMaxError );
		return strlen(lpszError)>0;
	case ERR_NETDB_ZIP:
		strncpy( lpszError, szErrZip, nMaxError );
		return strlen(lpszError)>0;
	default:
		return CStDatabase::GetLastErrorMessage( lpszError, nMaxError );
	}
}

CString CNetDatabase::GetProgressMessage(UINT nProgressCode)
{
	CString	string;
	switch( nProgressCode )
	{
	case PROG_HTTPCONNECTTING:	string	=	szProgHttpConnectting;	break;
	case PROG_REQUESTSENT:		string	=	szProgRequestSent;	break;
	case PROG_REDIRECTING:		string	=	szProgRedirecting;	break;
	case PROG_TRANSFERRING:		string	=	szProgTransferring;	break;
	case PROG_INSTALLPACKAGE:	string	=	szProgInstallPackage;	break;
	case PROG_EXTRACTZIPFILES:	string	=	szProgExtractZipFiles;	break;
	case PROG_ERRORPAC:			string	=	szProgErrorPac;	break;
	default:;
	}
	return string;
}

BOOL CNetDatabase::NetloadPackageInfo( PROGRESS_CALLBACK fnCallback, void *cookie )
{
	CString	strPackageInfo;
	if( !m_httpClient.LoadPackageInfo( strPackageInfo, fnCallback, cookie ) )
	{
		SetLastError( ERR_NETDB_HTTPCLIENT );
		return FALSE;
	}

	if( ! m_packages.SetRawXMLDocument( strPackageInfo ) )
	{
		SetLastError( ERR_NETDB_PACKAGES );
		return FALSE;
	}

	AfxGetProfile().SetNetInfo( m_packages.m_strInfo, m_packages.m_strInfourl );
	AfxGetProfile().SetLatestver( m_packages.m_strLatestver );

	return TRUE;
}

BOOL CNetDatabase::NetloadServerInfo( PROGRESS_CALLBACK fnCallback, void *cookie )
{
	CString	strServerInfo;
	if( !m_httpClient.LoadServerInfo( strServerInfo, fnCallback, cookie ) )
	{
		SetLastError( ERR_NETDB_HTTPCLIENT );
		return FALSE;
	}

	if( ! m_servers.SetRawXMLDocument( strServerInfo ) )
	{
		SetLastError( ERR_NETDB_SERVERS );
		return FALSE;
	}

	return TRUE;
}

int CNetDatabase::NetloadCodetbl( PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;
	
	CSPTime	tmFrom(NULL);
	CSPTime	tmTo	=	CSPTime::GetCurrentTime();
	return NetloadPackage( CPackage::packageCode, tmFrom, tmTo, fnCallback, cookie );
}


int CNetDatabase::NetloadDayKLine( LPCTSTR lpszStockCode, CSPTime *ptmFrom, CSPTime *ptmTo,
								   PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;
	
	CSPTime	tmFrom(NULL), tmTo(NULL);
	if( NULL != ptmFrom )
		tmFrom	=	*ptmFrom;

	if( NULL != ptmTo )
		tmTo	=	*ptmTo;
	else
		GetLatestTimeNet( tmTo, CPackage::packageDay );

	return NetloadPackage( CPackage::packageDay, tmFrom, tmTo, fnCallback, cookie );
}

int CNetDatabase::Netload5MinKLine( LPCTSTR lpszStockCode, CSPTime *ptmFrom, CSPTime *ptmTo,
									PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;

	CSPTime	tmFrom(NULL), tmTo(NULL);
	if( NULL != ptmFrom )
		tmFrom	=	*ptmFrom;

	if( NULL != ptmTo )
		tmTo	=	*ptmTo;
	else
		GetLatestTimeNet( tmTo, CPackage::packageMin5 );

	return NetloadPackage( CPackage::packageMin5, tmFrom, tmTo, fnCallback, cookie );
}

int CNetDatabase::NetloadDRData( LPCTSTR lpszStockCode, CSPTime *ptmFrom, CSPTime *ptmTo,
								 PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;

	CSPTime	tmFrom(NULL), tmTo(NULL);
	if( NULL != ptmFrom )
		tmFrom	=	*ptmFrom;
	
	if( NULL != ptmTo )
		tmTo	=	*ptmTo;
	else
		GetLatestTimeNet( tmTo, CPackage::packageDR );

	return NetloadPackage( CPackage::packageDR, tmFrom, tmTo, fnCallback, cookie );
}

int CNetDatabase::NetloadBasetext( LPCTSTR lpszStockCode, CSPTime *ptmFrom, CSPTime *ptmTo,
								   PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;

	CSPTime	tmFrom(NULL), tmTo(NULL);
	if( NULL != ptmFrom )
		tmFrom	=	*ptmFrom;
	else
		tmFrom	=	CSPTime(NULL);
	if( NULL != ptmTo )
		tmTo	=	*ptmTo;
	else
		GetLatestTimeNet( tmTo, CPackage::packageBasetext );

	return NetloadPackage( CPackage::packageBasetext, tmFrom, tmTo, fnCallback, cookie );
}

int CNetDatabase::NetloadBasetable( LPCTSTR lpszStockCode, CSPTime *ptmFrom, CSPTime *ptmTo,
								   PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;

	CSPTime	tmFrom(NULL), tmTo(NULL);
	if( NULL != ptmFrom )
		tmFrom	=	*ptmFrom;
	else
		tmFrom	=	CSPTime(NULL);
	if( NULL != ptmTo )
		tmTo	=	*ptmTo;
	else
		GetLatestTimeNet( tmTo, CPackage::packageBasetable );

	return NetloadPackage( CPackage::packageBasetable, tmFrom, tmTo, fnCallback, cookie );
}

struct progress_cookie_t {
	DWORD nLenFinished;
	DWORD nLenCur;
	DWORD	nLenTotal;
	PROGRESS_CALLBACK	fnCallbackSuper;
	void	* cookieSuper;
};

BOOL CALLBACK LocalProgressCallback(DWORD dwCode, DWORD dwProgress,
							LPCTSTR lpszMsg, void *cookie)
{
	struct progress_cookie_t *p = (struct progress_cookie_t *)cookie;

	if( PROG_PROGRESS == dwCode )
	{
		DWORD dwLenCurFinished = DWORD( (double(dwProgress))*p->nLenCur / STKLIB_MAXF_PROGRESS );
		if( dwLenCurFinished > p->nLenCur )
			dwLenCurFinished	=	p->nLenCur;
		DWORD dwTotalProgress = dwProgress;
		if( p->nLenTotal > 0 )
			dwTotalProgress	= DWORD( STKLIB_MAXF_PROGRESS*(p->nLenFinished+dwLenCurFinished)/(p->nLenTotal) );
		if( p->fnCallbackSuper )
			return p->fnCallbackSuper( dwCode, dwTotalProgress, lpszMsg, p->cookieSuper );
		return TRUE;
	}
	else
	{
		if( p->fnCallbackSuper )
			return p->fnCallbackSuper( dwCode, dwProgress, lpszMsg, p->cookieSuper );
		return TRUE;
	}
}

int CNetDatabase::NetloadPackage( int nPackageType, CSPTime &tmFrom, CSPTime &tmTo,
								  PROGRESS_CALLBACK fnCallback, void *cookie )
{
	if( ! m_packages.IsOK() )
		return FALSE;

	m_packages.Sort( );
	
	int nTotalLen = 0;
	for( int i=0; i<m_packages.GetSize(); i++ )
	{
		CPackage	& pac = m_packages.ElementAt(i);
		if( pac.m_nType != nPackageType
			|| pac.m_tmTo < tmFrom
			|| pac.m_tmFrom > tmTo )
			continue;

		nTotalLen	+=	pac.m_nLength;
	}

	struct	progress_cookie_t	cookieLocal;
	cookieLocal.fnCallbackSuper	=	fnCallback;
	cookieLocal.cookieSuper		=	cookie;
	cookieLocal.nLenTotal		=	nTotalLen<<1;
	cookieLocal.nLenFinished	=	0;

	int i;
	for( i=0; i<m_packages.GetSize(); i++ )
	{
		CPackage	pac = m_packages.ElementAt(i);
		if( pac.m_nType != nPackageType
			|| pac.m_tmTo < tmFrom
			|| pac.m_tmFrom > tmTo )
			continue;

		cookieLocal.nLenCur	=	pac.m_nLength;

		CFile	file;
		BOOL	bOK		=	FALSE;
		BOOL	bExpand	=	FALSE;
		CString	sFileName;
		if( GetTempFile( sFileName ) 
			&& file.Open( sFileName, CFile::modeCreate | CFile::modeReadWrite ) )
		{
			bOK	=	m_httpClient.LoadPackage( pac.GetURL( m_packages.m_strBasePath ), &file, LocalProgressCallback, &cookieLocal );
			if( !bOK && pac.HasAlternateURL() )
			{
				file.Close();
				if( file.Open( sFileName, CFile::modeCreate | CFile::modeReadWrite ) )
					bOK	=	m_httpClient.LoadPackage( pac.GetAlternateURL(m_packages.m_strBasePath), &file, LocalProgressCallback, &cookieLocal );
			}

			if( !bOK && pac.HasExpandPackage( ) )
			{
				m_packages.AppendPackages( pac.GetExpandPackages() );
				m_packages.ElementAt(i).DeleteExpandPackages();
				bExpand	=	TRUE;
			}

			if( CFile::hFileNull != file.m_hFile )
				file.Close();

			m_packages.ElementAt(i).m_bDownloadOK =	bOK;
			m_packages.ElementAt(i).m_strLocalFilename =	sFileName;
		}
		
		if( !bExpand )
			cookieLocal.nLenFinished	+=	pac.m_nLength;
	}

	int	nCount	=	0;
	for( i=0; i<m_packages.GetSize(); i++ )
	{
		CPackage	& pac = m_packages.ElementAt(i);

		BOOL	bOK	=	pac.m_bDownloadOK;
		pac.m_bDownloadOK	=	FALSE;
		if( bOK )
		{
			cookieLocal.nLenCur	=	pac.m_nLength;
			bOK	=	InstallPackageEx( pac, pac.m_strLocalFilename, LocalProgressCallback, &cookieLocal );
			if( !bOK && fnCallback )
			{
				CString	str	=	pac.m_strDescript;
				fnCallback( PROG_ERRORPAC, 0, str.GetBuffer(str.GetLength()+1), cookie );
				str.ReleaseBuffer();
			}
			
			RemoveTempFile( pac.m_strLocalFilename );
			LocalProgressCallback( PROG_PROGRESS, STKLIB_MAX_PROGRESS, NULL, &cookieLocal );
			cookieLocal.nLenFinished	+=	pac.m_nLength;