#include "stdafx.h"
#include "SqlLibHandler.h"

CSqlLibHandler::CSqlLibHandler()
{
}

CSqlLibHandler::~CSqlLibHandler()
{
	Disconnect();
}

void CSqlLibHandler::Disconnect()
{
	if(m_sqlconn.isConnected()) 
	{
		m_sqlconn.Disconnect();
	}
}

void CSqlLibHandler::SetConnectInfo(char* strCon, char* szID, char* szPwd, SAClient_t clienttype)
{
	strncpy(m_szConnect, strCon, 128);
	strncpy(m_szId, szID, 64);
	strncpy(m_szPwd, szPwd, 64);
	m_clienttype = clienttype;
}

bool CSqlLibHandler::isResultSet()
{
	return m_sqlcmd.isResultSet();
}

long CSqlLibHandler::RowsAffected()
{
	return m_sqlcmd.RowsAffected();
}

bool CSqlLibHandler::ConnectDBMS()
{	
	try
	{	if(m_sqlconn.isConnected()) m_sqlconn.Disconnect();
		
		m_sqlconn.Connect(m_szConnect, m_szId, m_szPwd, m_clienttype);
		m_sqlcmd.setConnection(&m_sqlconn);
	}
	catch(SAException &e)
	{		
		SetError("DB Connect fail", m_szConnect, __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}

	return true;
}

void CSqlLibHandler::SetError(const char* szError, const char* szParamter, int nLineNum, const char* szFileName, const char* szDescription, int nErrorCode)
{
	char szSrcInfo[MAX_PATH];
	StringCchPrintf(szSrcInfo, MAX_PATH, " (FileName: %s, FileLineNum: %d)", szFileName, nLineNum);
	
	m_strLastError = "ERROR:";
	m_strLastError += szError;
	m_strLastError += ", PARAMETER:";
	m_strLastError += szParamter;	
	m_strLastError += ", DESCRIPTOIN:";
	m_strLastError += szDescription;
	m_strLastError += szSrcInfo;

	m_nErrorCode = nErrorCode;

	BILLING_LOG(WZPUBLIC::LEVEL_ERROR, "DataBase fail [%s] [%d]", GetLastErrorStr(), GetLastErrorCode());	
}

int CSqlLibHandler::GetLastErrorCode()
{
	return m_nErrorCode;
}

const char* CSqlLibHandler::GetLastErrorStr()
{
	return m_strLastError.c_str();
}

bool CSqlLibHandler::SetQureyText(const char* szSQL)
{
	try
	{		
		m_sqlcmd.setCommandText(szSQL);		
		//m_sqlcmd.setOption("DBPROP_COMMONDTIMEOUT") = "500";
	}
	catch(SAException &e)
	{		
		SetError("SetQureyText fail", szSQL , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::Exec()
{
	try
	{
		//DWORD aa = GetTickCount();
		m_sqlcmd.Execute();
		//DWORD bb = GetTickCount();
		//DWORD cc = bb - aa;
		//int a = 0;
	}
	catch(SAException &e)
	{			
		SetError("Exec fail", "" , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::FetchNext()
{	
	try
	{		
		return m_sqlcmd.FetchNext();
	}
	catch(SAException &e)
	{			
		SetError("FetchNext fail", "" , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}


bool CSqlLibHandler::IsConnected()
{	
	return m_sqlconn.isConnected();
}

int CSqlLibHandler::GetCountFiled()
{	
	return m_sqlcmd.FieldCount();
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, tm& _time)
{
	try
	{			
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsDateTime() = _time; break;
		case FIELD_OUTPUT:
			_time = m_sqlcmd.Field(szCol).asDateTime(); break;
		case PARAM_OUTPUT:
			_time = m_sqlcmd.Param(szCol).asDateTime(); break;
		case FIELD_INPUT:
		default:
			return false;
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			break;
		}
	}
	catch(SAException &e)
	{	
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, long& nValue)
{
	try
	{		
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsLong() = nValue; break;
		case FIELD_OUTPUT:			 
			m_sqlcmd.Field(szCol).isNull() ?
				nValue = -1 : nValue = m_sqlcmd.Field(szCol).asLong(); break;
		case PARAM_OUTPUT:
			nValue = m_sqlcmd.Param(szCol).asLong(); break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{		
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, short& nValue)
{
	try
	{
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsShort() = nValue; break;
		case FIELD_OUTPUT:
			nValue = m_sqlcmd.Field(szCol).asShort(); break;
		case PARAM_OUTPUT:
			nValue = m_sqlcmd.Param(szCol).asShort(); break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, double& nValue)
{
	try
	{
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsDouble() = nValue; break;
		case FIELD_OUTPUT:
			nValue = m_sqlcmd.Field(szCol).asDouble(); break;
		case PARAM_OUTPUT:
			nValue = m_sqlcmd.Param(szCol).asDouble(); break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, char& nValue)
{
	try
	{		
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsString() = nValue; break;
		case FIELD_OUTPUT:
			nValue = m_sqlcmd.Field(szCol).asString()[0]; break;
		case PARAM_OUTPUT:
			nValue = m_sqlcmd.Param(szCol).asString()[0]; break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, BYTE& nValue)
{
	try
	{			
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsBytes() = nValue; break;
		case FIELD_OUTPUT:			 
			nValue = m_sqlcmd.Field(szCol).asBytes()[0]; break;
		case PARAM_OUTPUT:
			nValue = m_sqlcmd.Param(szCol).asBytes()[0]; break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, bool& nValue)
{
	try
	{		
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsBool() = nValue; break;
		case FIELD_OUTPUT:			 
			nValue = m_sqlcmd.Field(szCol).asBool(); break;
		case PARAM_OUTPUT:
			nValue = m_sqlcmd.Param(szCol).asBool(); break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, char* nValue, int Size)
{
	try
	{		
		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsString() = nValue; break;
		case FIELD_OUTPUT:			
			strncpy(nValue , m_sqlcmd.Field(szCol).asString(), 
				m_sqlcmd.Field(szCol).asString().GetLength() > Size ? Size : m_sqlcmd.Field(szCol).asString().GetLength()); break;
		case PARAM_OUTPUT:
			strncpy(nValue , m_sqlcmd.Param(szCol).asString(), 
				m_sqlcmd.Field(szCol).asString().GetLength() > Size ? Size : m_sqlcmd.Field(szCol).asString().GetLength()); break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}
	return true;	
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, WCHAR* nValue, int Size)
{
	try
	{	
		USES_CONVERSION;		

		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsString() = W2A(nValue); break;			
		case FIELD_OUTPUT:
			{
			int Len = wcslen(A2W(m_sqlcmd.Field(szCol).asString()));
			wcsncpy(nValue , A2W(m_sqlcmd.Field(szCol).asString()), Len > Size ? Size : Len); break;
			}
		case PARAM_OUTPUT:
			{
			int Len = wcslen(A2W(m_sqlcmd.Field(szCol).asString()));
			wcsncpy(nValue , A2W(m_sqlcmd.Param(szCol).asString()), Len > Size ? Size : Len); break;
			}
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}

	return true;
}

bool CSqlLibHandler::ModifyValue(VALUE_TYPE vt, const char* szCol, WCHAR& nValue)
{
	try
	{	
		USES_CONVERSION;		

		switch(vt)
		{
		case PARAM_INPUT: 
			m_sqlcmd.Param(szCol).setAsString() = nValue; break;			
		case FIELD_OUTPUT:
			nValue = A2W(m_sqlcmd.Field(szCol).asString())[0]; break;
		case PARAM_OUTPUT:
			nValue = A2W(m_sqlcmd.Param(szCol).asString())[0]; break;
		case FIELD_INPUT:
		default:
			SetError("GetField fail", szCol , __LINE__, __FILE__, "Not Define VALUE_TYPE", 0);
			return false;
		}
	}
	catch(SAException &e)
	{
		SetError("GetField fail", szCol , __LINE__, __FILE__, (const char*)e.ErrText(), e.ErrNativeCode());
		return false;
	}

	return true;
}