/////////////////////////////////////////////////////////////////
//                                                             //
//                ConnectionProps.cpp                          //
//     implementation of the CConnectionProps class            //
//-------------------------------------------------------------//
//             By Eugene Khodakovsky                           //
//                  June, 2000                                 //
//             Eugene@cpplab.com                               //
//            Last Update: April, 2002                         //
/////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ConnectionProps.h"

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

#define PRESS_MARK_MASK 0x48

LPCTSTR	CConnectionProps::m_szDSNEntry				= "DSN";
LPCTSTR	CConnectionProps::m_szServerNameEntry		= "Server";
LPCTSTR	CConnectionProps::m_szLoginNameEntry		= "UID";
LPCTSTR	CConnectionProps::m_szDatabaseNameEntry		= "Database";
LPCTSTR	CConnectionProps::m_szPasswordEntry			= "PWD";
LPCTSTR	CConnectionProps::m_szTableEntry			= "Table";


static CString GetNextToken(CString& strSrc, const CString strDelim)
{
	CString token;
	int idx = strSrc.FindOneOf(strDelim);
	if(idx != -1)
	{
		token  = strSrc.Left(idx);
		strSrc = strSrc.Right(strSrc.GetLength() - (idx + 1) );
	}
	else
	{
		token = strSrc;
		strSrc.Empty();
	}
	return token;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
IMPLEMENT_SERIAL(CConnectionProps,CObject,0)

CConnectionProps::CConnectionProps(bool bSaveInRegistry):
	m_bSaveInRegistry(bSaveInRegistry)
{
	m_strServerName			= _T("");
	m_strDSN				= _T("");
	m_strDatabaseName		= _T("");
	m_strTableName			= _T("");
	m_strLoginName			= _T("");
	m_strPassword			= _T("");
	m_strIniFileName		= _T("");
}

CConnectionProps::~CConnectionProps()
{
	CloseConnection();
}

const CConnectionProps& CConnectionProps::operator =(const CConnectionProps& right)
{
	Copy(right);
	return *this;
}

void CConnectionProps::Copy(const CConnectionProps& right)
{
	m_strDSN				= (LPCSTR)right.m_strDSN;
	m_strDatabaseName		= (LPCSTR)right.m_strDatabaseName;
	m_strTableName			= (LPCSTR)right.m_strTableName;
	m_strLoginName			= (LPCSTR)right.m_strLoginName;
	m_strPassword			= (LPCSTR)right.m_strPassword;
	m_strServerName			= (LPCSTR)right.m_strServerName;
	m_strIniFileName		= (LPCSTR)right.m_strIniFileName;
}

void CConnectionProps::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		ar	<< StrToFile(m_strDSN);
		ar	<< StrToFile(m_strDatabaseName);
		ar	<< StrToFile(m_strTableName);
		ar	<< StrToFile(m_strLoginName);
		ar	<< StrToFile(m_strPassword);
		ar	<< StrToFile(m_strServerName);
	}
	else
	{
		FileToStr(ar,m_strDSN);
		FileToStr(ar,m_strDatabaseName);
		FileToStr(ar,m_strTableName);
		FileToStr(ar,m_strLoginName);
		FileToStr(ar,m_strPassword);
		FileToStr(ar,m_strServerName);
	}
}

CString CConnectionProps::StrToFile(LPCSTR str, bool bPressMark)
{
	CString token(str);
	if(bPressMark)
	{
		for( int i = 0; i < token.GetLength(); i++)
			token.SetAt(i,token.GetAt(i)^PRESS_MARK_MASK);

	}

	return token;
}

void CConnectionProps::FileToStr(CArchive& ar, CString& str, bool bPressMark)
{
	CString token;
	ar >> token;

	if(bPressMark)
	{
		for( int i = 0; i < token.GetLength(); i++)
			token.SetAt(i,token.GetAt(i)^PRESS_MARK_MASK);

	}
	str = token;
}

void CConnectionProps::SetDSN(LPCSTR dsn)
{
	m_strDSN = dsn;
}
void CConnectionProps::SetUID(LPCSTR uid)
{
	m_strLoginName = uid;
}
void CConnectionProps::SetPassword(LPCSTR pwd)
{
	m_strPassword = pwd;
}


bool CConnectionProps::SaveSettings(LPCTSTR lpszAppSection,LPCTSTR lpszEntry,LPCTSTR lpszValue)
{
	LPCTSTR lpszIniFileName = m_strIniFileName;
	if (m_bSaveInRegistry )
		return AfxGetApp()->WriteProfileString( lpszAppSection,lpszEntry ,lpszValue)== TRUE;
	return 
		::WritePrivateProfileString(lpszAppSection, lpszEntry, 
									lpszValue,lpszIniFileName) == TRUE;
}


bool CConnectionProps::SaveSettings(LPCTSTR lpszAppSection)
{
	bool bok = true;

	if ( !SaveSettings( lpszAppSection,m_szDSNEntry ,m_strDSN))
		bok = false;
	if ( !SaveSettings( lpszAppSection,m_szDatabaseNameEntry ,m_strDatabaseName))
		bok = false;
	if ( !SaveSettings( lpszAppSection,m_szTableEntry ,m_strTableName))
		bok = false;
	if ( !SaveSettings( lpszAppSection,m_szLoginNameEntry ,m_strLoginName))
		bok = false;
	if ( !SaveSettings( lpszAppSection,m_szPasswordEntry ,m_strPassword))
		bok = false;
	if ( !SaveSettings( lpszAppSection,m_szServerNameEntry ,m_strServerName))
		bok = false;

	return bok;
}

CString CConnectionProps::LoadSettings(LPCTSTR lpszAppSection,LPCTSTR lpszEntry)
{ 
	LPCTSTR lpszIniFileName = m_strIniFileName;
	if (m_bSaveInRegistry)
		return  AfxGetApp()->GetProfileString( lpszAppSection,lpszEntry );

	LPCSTR	lpszDefault = &afxChNil;    // don't pass in NULL
	char szT[4096];
	DWORD dw = ::GetPrivateProfileString(lpszAppSection, lpszEntry,
			lpszDefault, szT, sizeof(szT),lpszIniFileName);
	ASSERT(dw < 4095);
	return szT;
}

bool CConnectionProps::LoadSettings(LPCTSTR lpszAppSection)
{
	bool bok = true;
	CString value;

	if(m_strLoginName.IsEmpty())
	{
		value = LoadSettings( lpszAppSection,m_szLoginNameEntry );
		if(value.IsEmpty())
			bok = false;
		m_strLoginName = value; 
	}

	if(m_strPassword.IsEmpty())
	{
		value = LoadSettings( lpszAppSection,m_szPasswordEntry );
		m_strPassword = value; 
	}

	// The variables can be set up from comand line
	if(m_strDSN.IsEmpty())
	{
		value = LoadSettings(lpszAppSection, m_szDSNEntry );
		if(value.IsEmpty())
			bok = false;

		m_strDSN = value; 
	}


	if(m_strDatabaseName.IsEmpty())
	{
		value = LoadSettings( lpszAppSection,m_szDatabaseNameEntry );
		m_strDatabaseName = value; 
	}

	if(m_strTableName.IsEmpty())
	{
		value = LoadSettings( lpszAppSection,m_szTableEntry );
		if(value.IsEmpty())
			bok = false;
		m_strTableName = value; 
	}

	if(m_strServerName.IsEmpty())
	{
		value = LoadSettings( lpszAppSection,m_szServerNameEntry );
		if(value.IsEmpty())
			bok = false;
		m_strServerName = value; 
	}

	return bok;
}

#ifdef ODBDC_SUPPORT

bool CConnectionProps::Connect(CDatabase& database, bool bShowDialog)
{
	CWaitCursor cursor;

	if(m_strDSN.IsEmpty())
	{

		ShowError("Empty ODBC Source");
		return false;
	}
	if(m_strLoginName.IsEmpty())
	{

		ShowError("Empty Login Name");
		return false;
	}

	CString ConnectString = 
	"DSN="			+ m_strDSN			+ ";";

	if(!m_strDatabaseName.IsEmpty())
	{
		ConnectString += 
		"DATABASE="		+ m_strDatabaseName + ";";
	}
	
	ConnectString += 
	"UID="			+ m_strLoginName	+ ";"	+
	"PWD="			+ m_strPassword		+ ";"
	;

	try
	{

		DWORD dwOptions = CDatabase::useCursorLib;
		if(!bShowDialog)
			dwOptions |= CDatabase::noOdbcDialog;
		if(database.IsOpen())
			database.Close();
		if(!database.OpenEx(ConnectString,dwOptions))
		{
			return false;
		}
	}
	catch( CDBException* pExc)
	{

		pExc->ReportError();
		pExc->Delete();
		return false;

	}

	return true;
}

bool CConnectionProps::ReadProps(CDatabase& database)
{
	return ReadProps(database.GetConnect());
}

bool CConnectionProps::ReadProps(const CString strConnectionString)
{
	CString strConnection = strConnectionString;

	CString strToken;
	while( !(strToken = GetNextToken(strConnection,";")).IsEmpty())
	{
		CString strTok	 = GetNextToken(strToken,"=");
		strTok.TrimLeft(); strTok.TrimRight();
		CString strValue = GetNextToken(strToken,"");
		strValue.TrimLeft(); strValue.TrimRight();

		if(strTok.CompareNoCase(m_szDSNEntry) == 0)
			m_strDSN = strValue;
		else
		if(strTok.CompareNoCase(m_szServerNameEntry) == 0)
			m_strServerName = strValue;
		else
		if(strTok.CompareNoCase(m_szLoginNameEntry) == 0)
			m_strLoginName = strValue;
		else
		if(strTok.CompareNoCase(m_szDatabaseNameEntry) == 0)
			m_strDatabaseName = strValue;
		else
		if(strTok.CompareNoCase(m_szPasswordEntry) == 0)
			m_strPassword = strValue;
		else
		if(strTok.CompareNoCase(m_szTableEntry) == 0)
			m_strTableName = strValue;
	}

	return true;
}

#else

bool CConnectionProps::Connect(ATL::CDataSource* pDataSource,CSession* pSession)
{
	ASSERT(pDataSource);

	CComBSTR bstrServer(m_strServerName);
	CComBSTR bstrUser(m_strLoginName);
	CComBSTR bstrPassword(m_strPassword);
	CComBSTR bstrDatabase(m_strDatabaseName);


	if (pSession && pSession->m_spOpenRowset != NULL)
		pSession->m_spOpenRowset.Release();

	CDBPropSet	dbinit(DBPROPSET_DBINIT);

	dbinit.AddProperty(DBPROP_AUTH_PASSWORD, bstrPassword);
	dbinit.AddProperty(DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO, false);
	dbinit.AddProperty(DBPROP_AUTH_USERID, bstrUser);
	dbinit.AddProperty(DBPROP_INIT_CATALOG, bstrDatabase);
	dbinit.AddProperty(DBPROP_INIT_DATASOURCE, bstrServer);
	dbinit.AddProperty(DBPROP_INIT_LCID, (long)1049);
	dbinit.AddProperty(DBPROP_INIT_PROMPT, (short)4);

	if(FAILED(pDataSource->Open(_T("SQLOLEDB.1"), &dbinit)))
	{
		CString strMsg = "Cannot connect to data source";
		strMsg += "\nServer\t= "	+ m_strServerName;
		strMsg += "\nDatabase\t= "	+ m_strDatabaseName;
		strMsg += "\nLogin\t= "		+ m_strLoginName;

		AfxMessageBox(strMsg);
		if(pDataSource)
		{
			pDataSource->Close();
		}
		goto ErrorExit;
	}
	else
	{
		if (pSession && pSession->Open(*pDataSource) != S_OK)
		{
			AfxMessageBox(_T("Couldn't create session on data source"));
			goto ErrorExit;
		}
	}
	return true;

ErrorExit:
	CloseConnection();
	return false;
}

#endif

void CConnectionProps::CloseConnection()
{
#ifdef ODBDC_SUPPORT
#else
	if(m_Session.m_spOpenRowset)
		m_Session.Close();

	if(m_DataSource.m_spInit)
		m_DataSource.Close();
#endif
}

void CConnectionProps::ShowError(LPCSTR error)
{
	MessageBox(NULL,error,"Error",MB_ICONERROR | MB_OK);
}

bool CConnectionProps::LoadFromFile(LPCSTR FileName)
{
	LPCSTR iniFileName = FileName;
	try
	{
		CFile file(iniFileName,CFile::modeRead);
		CArchive ar(&file,CArchive::load);
		Serialize(ar);
	}
	catch(CFileException *ex)
	{
		ex->Delete();
		return false;

	}
	catch(CArchiveException *exAr)
	{
		exAr->Delete();
		return false;

	}

	return true;
}

void CConnectionProps::SaveToFile(LPCSTR FileName)
{
	LPCSTR iniFileName = FileName;
	try
	{
		CFile file(iniFileName,CFile::modeWrite | CFile::modeCreate);
		CArchive ar(&file,CArchive::store);
		Serialize(ar);
	}
	catch(CFileException *ex)
	{
		ex->Delete();
		return ;

	}
	catch(CArchiveException *exAr)
	{
		exAr->Delete();
		return ;

	}
}