listexportdlg.cpp.svn-base

股票软件源码

// ListExportDlg.cpp : implementation file
//

#include "stdafx.h"

#include "ListExportDlg.h"
#include <io.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// class CExportDB

CExportDB::CExportDB( )
{
	m_pTableDef		=	NULL;
	m_pRecord		=	NULL;
}

CExportDB::~CExportDB( )
{
	CloseAllDB( );
}

CString CExportDB::ESCString( CString &string )
{
	CString	strResult;
	for( int i=0; i<string.GetLength(); i++ )
	{
		char ch = string.GetAt(i);
		if( ch == '\\' || ch == '\'' )
			strResult	+=	"\\";
		strResult	+=	ch;
	}
	return strResult;
}

CString CExportDB::ESCCSVString( CString &string )
{
	CString	strResult;
	for( int i=0; i<string.GetLength(); i++ )
	{
		char ch = string.GetAt(i);
		if( ch == '\\' || ch == '\'' || ch == ',' )
			strResult	+=	"\\";
		strResult	+=	ch;
	}
	return strResult;
}

BOOL CExportDB::ExecuteODBCFile( CString strODBCDest )
{
	if( -1 != strODBCDest.Find( "DSN=Excel" )
		|| -1 != strODBCDest.Find( "DSN=MS Access Database" ) )
	{
		int nIndex	=	strODBCDest.Find( "DBQ=" );
		if( -1 != nIndex )
		{
			CString	strDBQ	=	strODBCDest.Mid( nIndex+4 );
			nIndex	=	strDBQ.Find( ";" );
			if( -1 != nIndex )
				strDBQ	=	strDBQ.Left( nIndex );
			ShellExecute( NULL, "open", strDBQ, NULL, NULL, SW_SHOW );
			return TRUE;
		}
	}
	else
	{
		int nIndex	=	strODBCDest.Find( "DefaultDir=" );
		if( -1 != nIndex )
		{
			CString	strDefaultDir	=	strODBCDest.Mid( nIndex + 11 );
			nIndex	=	strDefaultDir.Find( ";" );
			if( -1 != nIndex )
				strDefaultDir	=	strDefaultDir.Left( nIndex );
			ShellExecute( NULL, "open", strDefaultDir, NULL, NULL, SW_SHOW );
			return TRUE;
		}
	}
	return FALSE;
}

BOOL CExportDB::SetTableColumn( CStringArray & astrColumnName, CUIntArray & anWidth )
{
	ASSERT( astrColumnName.GetSize() == anWidth.GetSize() );
	if( astrColumnName.GetSize() != anWidth.GetSize() )
		return FALSE;

	m_astrColumnName.Copy( astrColumnName );
	m_anColumnWidth.Copy( anWidth );
	ASSERT( m_astrColumnName.GetSize() > 0 );
	return m_astrColumnName.GetSize() > 0;
}

BOOL CExportDB::OpenTxtDB( LPCTSTR lpszTxtDest, BOOL bTxtPath )
{
	if( NULL == lpszTxtDest || strlen(lpszTxtDest) <= 0 )
	{
		ASSERT( FALSE );
		return FALSE;
	}
	if( bTxtPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( lpszTxtDest ) )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	CloseTxtDB( );
	m_strTxtDest	=	lpszTxtDest;
	m_bTxtPath		=	bTxtPath;
	return TRUE;
}

BOOL CExportDB::OpenTxtTable( LPCTSTR lpszTableName, BOOL bOverwrite )
{
	if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	if( m_strTxtDest.GetLength() == 0		/* Txt DB Not Open */
		|| m_astrColumnName.GetSize() == 0	/* Not Set Table Column */ )
	{
		ASSERT( FALSE );
		return FALSE;
	}
	
	// Path Txt DB
	if( m_bTxtPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( m_strTxtDest ) )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	CloseTxtTable( );

	// Path Txt DB
	CString	strTxtFile	=	m_strTxtDest;
	if( m_bTxtPath )
		strTxtFile	=	m_strTxtDest + lpszTableName + ".txt";

	UINT nOpenFlags = CFile::modeCreate | CFile::modeWrite;
	if( !bOverwrite )
		nOpenFlags	|=	CFile::modeNoTruncate;
	if( !m_fileTxt.Open( strTxtFile, nOpenFlags ) )
		return FALSE;

	m_fileTxt.SeekToEnd();

	if( bOverwrite )
	{
		m_fileTxt.WriteString( CString(lpszTableName) + "\n"/*STRING_CRLF*/ );

		int	nStrLenTotal = 0, cxTotal = 0;
		for( int nCol=0; nCol < m_astrColumnName.GetSize(); nCol ++ )
		{
			int	nColWidth	=	m_anColumnWidth[nCol];
			CString	strText	=	m_astrColumnName.ElementAt(nCol);
			strText	+=	" ";
			while( ( (nStrLenTotal+strText.GetLength()) * 6 ) < cxTotal+nColWidth )
				strText	=	" " + strText;

			m_fileTxt.WriteString( strText );
			nStrLenTotal	+=	strText.GetLength();
			cxTotal			+=	nColWidth;
		}
		m_fileTxt.WriteString( "\n"/*STRING_CRLF*/ );
	}
	return TRUE;
}

BOOL CExportDB::OpenMdbDB( LPCTSTR lpszMdbDest )
{
	if( NULL == lpszMdbDest || strlen(lpszMdbDest) <= 0 )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	TRY
	{
		CloseMdbDB( );

		if( 0 == access( lpszMdbDest, 0 ) )
			m_mdb.Open( lpszMdbDest );
		else
			m_mdb.Create( lpszMdbDest );
	}
	CATCH( CDaoException, e )
	{
		CloseMdbDB();
		e->ReportError( );
		return FALSE;
	}
	END_CATCH

	return m_mdb.IsOpen();
}

BOOL CExportDB::OpenMdbTable( LPCTSTR lpszTableName, BOOL bOverwrite )
{
	if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
	{
		ASSERT( FALSE );
		return FALSE;
	}
	TRY
	{
		if( !m_mdb.IsOpen() || m_astrColumnName.GetSize() <= 0 )
		{
			ASSERT( FALSE );
			return FALSE;
		}
		CloseMdbTable();

		CString	strTableName	=	lpszTableName;

		BOOL	bCreateNew	=	bOverwrite;
		if( !bOverwrite )
		{
			try {
				CDaoTableDefInfo	tabledefinfo;
				m_mdb.GetTableDefInfo( strTableName, tabledefinfo );

				CDaoTableDef	tabledef( &m_mdb );
				tabledef.Open( strTableName );
				if( !tabledef.IsOpen() )
					bCreateNew	=	TRUE;
				else
				{
					if( m_astrColumnName.GetSize() != tabledef.GetFieldCount() )
						bCreateNew	=	TRUE;
					CDaoFieldInfo	fieldinfo;
					for( int i=0; i<tabledef.GetFieldCount(); i++ )
					{
						tabledef.GetFieldInfo( i, fieldinfo, AFX_DAO_ALL_INFO );
						bCreateNew	|=	( 0 != fieldinfo.m_strName.Compare(m_astrColumnName[i]) );
						bCreateNew	|=	( dbText != fieldinfo.m_nType );
						bCreateNew	|=	( 255 != fieldinfo.m_lSize );
						bCreateNew	|=	(! ( (dbVariableField | dbUpdatableField) & fieldinfo.m_lAttributes) );
					}
					tabledef.Close();
				}
			}catch( CDaoException * e ) {
				e->Delete();
				bCreateNew	=	TRUE;
			}
		}

		if( bCreateNew )
		{
			// Create New Table
			int	nCount	=	1;
			while( TRUE )
			{
				try {
					if( 1 != nCount )
						strTableName.Format( "%s%d", lpszTableName, nCount );
					CDaoTableDefInfo	tabledefinfo;
					m_mdb.GetTableDefInfo( strTableName, tabledefinfo );
				}catch ( CDaoException * e){
					e->Delete();
					break;
				}
				nCount	++;
			}

			//	create strTableName.
			CDaoTableDef	tabledef( &m_mdb );
			tabledef.Create( strTableName );

			//	def strTableName's field.
			CDaoFieldInfo	fieldinfo;

			fieldinfo.m_bRequired	=	false;
			fieldinfo.m_lCollatingOrder	=	dbSortGeneral;
			fieldinfo.m_strSourceTable	=	strTableName;
			for( int i=0; i<m_astrColumnName.GetSize(); i++ )
			{
				fieldinfo.m_bAllowZeroLength	=	true;
				fieldinfo.m_nOrdinalPosition	=	i+1;
				fieldinfo.m_strName	=	ESCString(m_astrColumnName[i]);
				fieldinfo.m_lSize	=	255;
				fieldinfo.m_nType		=	dbText;
				fieldinfo.m_lAttributes	=	dbVariableField | dbUpdatableField;
				fieldinfo.m_strSourceField	=	ESCString(m_astrColumnName[i]);
				tabledef.CreateField( fieldinfo );
			}
			tabledef.Append( );
			tabledef.Close( );
			// CreateNew End
		}

		//	Open Table
		if( !m_mdb.IsOpen( ) )
			return FALSE;
		m_pTableDef	=	new	CDaoTableDef( &m_mdb );
		m_pTableDef->Open( strTableName );
		m_pRecord	=	new	CDaoRecordset( &m_mdb );
		m_pRecord->Open( m_pTableDef, dbOpenDynaset );
		if( !m_pRecord->IsOpen() || !m_pTableDef->IsOpen() )
		{
			CloseMdbTable();
			return FALSE;
		}
	}
	CATCH( CDaoException, e )
	{
		CloseMdbTable();
		e->ReportError( );
		return FALSE;
	}
	END_CATCH

	return TRUE;
}

BOOL CExportDB::OpenCsvDB( LPCTSTR lpszCsvDest, BOOL bCsvPath )
{
	if( NULL == lpszCsvDest || strlen(lpszCsvDest) <= 0 )
	{
		ASSERT( FALSE );
		return FALSE;
	}
	if( bCsvPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( lpszCsvDest ) )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	CloseCsvDB( );
	m_strCsvDest	=	lpszCsvDest;
	m_bCsvPath		=	bCsvPath;
	return TRUE;
}

BOOL CExportDB::OpenCsvTable( LPCTSTR lpszTableName, BOOL bOverwrite )
{
	if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	if( m_strCsvDest.GetLength() == 0		/* Csv DB Not Open */
		|| m_astrColumnName.GetSize() == 0	/* Not Set Table Column */ )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	// Path Csv DB
	if( m_bCsvPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( m_strCsvDest ) )
	{
		ASSERT( FALSE );
		return FALSE;
	}

	CloseCsvTable( );

	CString	strCsvFile	=	m_strCsvDest;
	if( m_bCsvPath )
		strCsvFile	=	m_strCsvDest + lpszTableName + ".csv";

	UINT nOpenFlags = CFile::modeCreate | CFile::modeWrite;
	if( !bOverwrite )
		nOpenFlags	|=	CFile::modeNoTruncate;
	if( !m_fileCsv.Open( strCsvFile, nOpenFlags ) )
	{
		return FALSE;
	}

	m_fileCsv.SeekToEnd();

	if( bOverwrite )
	{
		m_fileCsv.WriteString( CString(lpszTableName) + "\n" );
		
		CString	strText;
		for( int nCol=0; nCol < m_astrColumnName.GetSize(); nCol ++ )
		{
			int	nColWidth	=	m_anColumnWidth[nCol];
			if( strText.GetLength() > 0 )
				strText	+=	",";
			strText	+=	m_astrColumnName.ElementAt(nCol);
		}
		m_fileCsv.WriteString( strText );
		m_fileCsv.WriteString( "\n" );
	}
	return TRUE;
}

BOOL CExportDB::OpenODBCDB( LPCTSTR lpszDSN )
{
	TRY
	{
		CloseODBCDB( );

		if( !m_dbODBC.Open(lpszDSN, FALSE, FALSE, _T("ODBC;"), FALSE) )
			return FALSE;

		return TRUE;
	}
	CATCH(CException, e)
	{
		CloseODBCDB( );
		if(e)	e->ReportError( );
		return FALSE;
	}
	END_CATCH
}

BOOL CExportDB::OpenODBCTable( LPCTSTR lpszTableName, BOOL bOverwrite )
{
	if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
	{