// AdoManager.cpp : implementation file
// This class can be used to access database.
// Write by shao
// Date: 2000/8/15

#include "stdafx.h"
#include "AdoManager.h"

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

/////////////////////////////////////////////////////////////////////////////
//global function and variant
void dump_com_error(_com_error &e)
{
	
//	_tprintf(_T("Oops - hit an error!\n"));
	TRACE(_T("\a\tCode = %08lx\n"), e.Error());
	TRACE(_T("\a\tCode meaning = %s\n"), e.ErrorMessage());
	_bstr_t bstrSource(e.Source());
	_bstr_t bstrDescription(e.Description());
	TRACE(_T("\a\tSource = %s\n"), (LPCTSTR) bstrSource);
	TRACE(_T("\a\tDescription = %s\n"), (LPCTSTR) bstrDescription);
	TRACE("\a\t%s\n",(LPCTSTR) bstrDescription);
//	AfxMessageBox((LPCTSTR) bstrDescription,MB_ICONERROR);

	char szError[512];
	memset(szError,0,sizeof(szError));
/*	sprintf(szError,"\a\tCode = %08lx\n",e.Error());
	PrintInfo(szError,PRINT_FAILED);

	sprintf(szError,"\a\tCode = %08lx\n",e.Error());
	PrintInfo(szError,PRINT_FAILED);
	sprintf(szError,"\a\tCode meaning = %s\n", e.ErrorMessage());
	PrintInfo(szError,PRINT_FAILED);

	_bstr_t bstrSource(e.Source());
	_bstr_t bstrDescription(e.Description());
*///	sprintf(szError,"\a\tSource = %s\n", (LPCTSTR) bstrSource);
//	PrintInfo(szError,PRINT_FAILED);
	sprintf(szError,"\a\t數據庫錯誤：Description = %s\n", (LPCTSTR) bstrDescription);
//	PrintInfo(szError,PRINT_FAILED);
//	sprintf(szError,"\a\t%s\n",(LPCTSTR) bstrDescription);

//	PrintInfo(szError,PRINT_FAILED);
}

// Need two distinct "empty" VARIANTs for Command::Execute
static VARIANT* pvtEmpty = static_cast<VARIANT*> (&vtMissing);
static _variant_t vtMissing2(DISP_E_PARAMNOTFOUND, VT_ERROR);
static VARIANT* pvtEmpty2 = static_cast<VARIANT*> (&vtMissing2);

/////////////////////////////////////////////////////////////////////////////
//CRecordSet
CRecordSet::CRecordSet(_ConnectionPtr gconnection,char *SqlStr)
{
	m_pRecordSet=NULL;
	Open(gconnection,SqlStr);
}

CRecordSet::~CRecordSet()
{
	Close();
}
UINT CRecordSet::GetCount()
{
	long l=m_pRecordSet->GetRecordCount();
//	return m_pRecordSet->GetRecordCount();
	return l;

}


BOOL CRecordSet::Open(_ConnectionPtr gconnection,char *filterstr)
{
	HRESULT hr;
	try
	{
		hr = m_pRecordSet.CreateInstance(__uuidof(Recordset));
		if (FAILED(hr)) return hr;
		VARIANT v;
		V_VT(&v) = VT_DISPATCH;
		V_DISPATCH(&v) = (IDispatch*) gconnection;

		// Need the AddRef() as VariantClear() calls Release(), unless fAddRef
		// false indicates we're taking ownership
		//
		V_DISPATCH(&v)->AddRef();

		hr = m_pRecordSet->Open(filterstr, v,adOpenDynamic, adLockOptimistic, 8);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

BOOL CRecordSet::Close()
{
	if(m_pRecordSet==NULL) return FALSE;
	HRESULT hr;
	try
	{
		hr = m_pRecordSet->Close();
//		Release();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;	
}
long CRecordSet::GetCol()
{
	long col=0;
	Fields* pFields;
	try{
		m_pRecordSet->get_Fields(&pFields);
		pFields->get_Count(&col);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		pFields->Release();
		return -1;
	}
	pFields->Release();
	return col;

}

BOOL CRecordSet::MoveFirst()
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->MoveFirst();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;

}

BOOL CRecordSet::MoveLast()
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->MoveLast();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;

}

BOOL CRecordSet::MoveNext()
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->MoveNext();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}
BOOL CRecordSet::Move(long nNumber)
{
	HRESULT hr;
	try
	{
		hr=m_pRecordSet->Move(nNumber);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

BOOL CRecordSet::IsEOF()
{
	HRESULT hr;
	try
	{
		hr = m_pRecordSet->EndOfFile;
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}

//從一行記錄中取前FIELDNUM個值放到V[]數組中

BOOL CRecordSet::GetFields(VARIANT v[], int fieldnum)
{
		HRESULT hr=0;
/*	if(m_pRecordSet==NULL) return FALSE;
	Fields* pFields;
	HRESULT hr=m_pRecordSet->get_Fields(&pFields);
	if(FAILED(hr)) return hr;
	Field* pField;
	
	VARIANT vitem;
	vitem.vt = VT_I1;
	for(int i=0;i<fieldnum;i++)
	{
		vitem.bVal = i;
		try{
			hr=pFields->get_Item(vitem,&pField);
			if(SUCCEEDED(hr))
				hr=pField->get_Value(&v[i]);
			if(FAILED(hr)) return hr;
		}catch (_com_error& e) 
		{
			dump_com_error(e);
			return -1;
		}
	}
*/	return hr;
}

BOOL CRecordSet::GetColValue(VARIANT *pv, int id)
{
	Fields* pFields;
	Field* pField;
	
	VARIANT vitem;
	vitem.vt = VT_I1;
	vitem.bVal = id;
	HRESULT hr;
	try{
		hr=m_pRecordSet->get_Fields(&pFields);
		hr=pFields->get_Item(vitem,&pField);
		hr=pField->get_Value(pv);
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		pField->Release();
		pFields->Release();
		return -1;
	}

	pField->Release();
	pFields->Release();
	return hr;
}
BOOL CRecordSet::GetColValue(VARIANT *pv, char* ColName)
{
	Fields* pFields;
	Field* pField;

	VARIANT vitem;
	vitem.vt   = VT_I1;
	vitem.bVal = 0;

	HRESULT hr;
	try{
		hr=m_pRecordSet->get_Fields(&pFields);
		while(!(hr=pFields->get_Item(vitem,&pField)))
		{
			_bstr_t bstr,tmpbstr;
			tmpbstr=ColName;
			bstr=pField->GetName();
			if(bstr==tmpbstr)
			{
				hr=pField->get_Value(pv);
				pField->Release();
				pFields->Release();
				return hr;
			}
			vitem.bVal ++ ;
			pField->Release();
		}
	}catch (_com_error& e) 
	{
		dump_com_error(e);
		pField->Release();
		pFields->Release();
		return -1;
	}

	pFields->Release();
	return -1;
}
/////////////////////////////////////////////////////////////////////////////
//CAdoManager
CAdoManager::CAdoManager()
{
	gconnection=NULL;
}

CAdoManager::~CAdoManager()
{
	CloseDb();
	if(gconnection)
		gconnection.Release();
}

//////////////////////////////////////////////////////////////////
/*****************************************************************
*	NAME	:	InitConnection
*	Function:	Initialize database connection
*	Return	:	If connection is successful return 0 else not 0
*****************************************************************/

BOOL CAdoManager::OpenDb(char* ConnectionString)
{
	HRESULT hr = gconnection.CreateInstance(__uuidof(Connection));
	try{
		if (SUCCEEDED(hr))
			hr = gconnection->Open(_bstr_t(ConnectionString), L"", L"",-1);
		if (SUCCEEDED(hr))
			hr = gcommand.CreateInstance(__uuidof(Command));
		if (SUCCEEDED(hr))
			hr = gcommand->putref_ActiveConnection(gconnection);
	}catch(_com_error& e) 
	{
		dump_com_error(e);
		return -1;
	}
	return hr;
}
void CAdoManager::CloseDb()
{
   if(gconnection==NULL || !IsOpen()) return;

	try{
		gconnection->Close();
	}catch (_com_error& e) 
	{
		dump_com_error(e);
	}
}

BOOL CAdoManager::IsOpen()
{
	if((gconnection!=NULL))
	{
		return gconnection->State == 1;
	}
	else
		return 0;
}

BOOL CAdoManager::Execute(char* query)
{
	HRESULT hr;
	try
	{
		hr = gconnection->Execute(_bstr_t(query), pvtEmpty, adCmdText);
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}

int CAdoManager::Exec(LPCTSTR lpszSql)
{

	long lCount=gcommand->Parameters->GetCount();
	for(short i=lCount-1; i>=0; i--)
	{
		gcommand->Parameters->Delete(i);
	}

	gcommand->CommandText = lpszSql;
	gcommand->CommandType = adCmdUnknown;
	gcommand->Execute(NULL,NULL,adCmdUnknown);

	return 1;
}


BOOL CAdoManager::BeginTrans()
{
	HRESULT hr;
	try
	{
		hr = gconnection->BeginTrans() ;
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}

BOOL CAdoManager::CommitTrans()
{
	HRESULT hr;
	try
	{
		hr = gconnection->CommitTrans() ;
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}


BOOL CAdoManager::RollBackTrans()
{
	HRESULT hr;
	try
	{
		hr = gconnection->RollbackTrans() ;
	}catch (_com_error& e) 
	{
		
		dump_com_error(e);
		return -1;
	}
	if(SUCCEEDED(hr))
	    return 0;
	else
		return -1;
}

CRecordSet* CAdoManager::CreateRecordSet(char* query)
{
	CRecordSet* pRecordSet = new CRecordSet;
	if(!pRecordSet->Open(gconnection,query))
		return pRecordSet;
	else
	{
		delete pRecordSet;
		return NULL;
	}
}
//
void CAdoManager::DestroyRecordSet(CRecordSet* pRecordSet)
{
	delete pRecordSet;
	pRecordSet=NULL;
}


BOOL CRecordSet::GetColVar(DWORD *pvalue, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	*pvalue=(DWORD)v.ulVal;
	return rec;
}

BOOL CRecordSet::GetColVar(int *pvalue, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	*pvalue=(int)v.dblVal;
	return rec;
}
BOOL CRecordSet::GetColVar(CString *pStr, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	*pStr=v.bstrVal;
	::VariantClear(&v);
	return rec;
}
BOOL CRecordSet::GetColVar(char *pStr, char *colName)
{
//	VARIANT v;
	CString str;
	BOOL rec=GetColVar(&str,colName);
	sprintf(pStr,"%s",str.GetBuffer(0));
	return rec;
}

BOOL CRecordSet::GetColVar(DATE *pdata, char *colName)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,colName);
	*pdata=v.date;
	return rec;
}

void CRecordSet::Delete(enum AffectEnum AffectRecords)
{
	m_pRecordSet->Delete(AffectRecords);
}
BOOL CRecordSet::GetColVar(DATE *pDate, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	*pDate=v.date;
	return rec;

}
BOOL CRecordSet::GetColVar(CString *pStr, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	*pStr=v.bstrVal;
	::VariantClear(&v);
	return rec;

}
BOOL CRecordSet::GetColVar(char *pStr, int index)
{
//	VARIANT v;
	CString str;
	BOOL rec=GetColVar(&str, index);
	sprintf(pStr,"%s",str.GetBuffer(0));
	return rec;

}

BOOL CRecordSet::GetColVar(DWORD *pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	*pvalue=(DWORD)v.ulVal;
	return rec;
}
BOOL CRecordSet::GetColVar(int *pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	*pvalue=(int)v.dblVal;
//	*pvalue=v.iVal;
	return rec;
}

void CRecordSet::Release()
{
	m_pRecordSet->Release();
}
BOOL CRecordSet::GetColVar(float &pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pvalue=v.dblVal;
	return rec;
}

BOOL CRecordSet::GetColVar(double &pvalue, int index)
{
	VARIANT v;
	BOOL rec=GetColValue(&v,index);
	pvalue=v.dblVal;
	return rec;
}