//---------------------------------------------------------------------------
//  Copyright (c) Jim Wright, 2002
//
//  MCDB.cpp
//  Description: COM interface class to the Music Control Database
//
//  $Workfile::                $
//  $Author::                  $
//  $Revision::                $
//  $Date::                    $
//  $NoKeywords: $
//  Change History
//   ----------------------
//   03/26/02   by Jim Wright       Initial Code
//---------------------------------------------------------------------------

#include "StdAfx.h"
#include "\JimsCode\CPP\MusicControler\StdAfx.h"
#include "\JimsCode\CPP\MusicControler\MusicContGlobal.h"
#include "\JimsCode\CPP\MCDB\mcdb.h"

//---------------------------------------------------------------------------
//
//  Private Method for setting the COM error fields
//
//---------------------------------------------------------------------------

void CMCDB::SetComError(_com_error &e)
{
	bstr_t bstrDescription(e.Description());

	m_lngLastErrorNumber = e.Error();
}

void CMCDB::SetError(long error)
{
	m_lngLastErrorNumber = error;
}

CMCDB::CMCDB(void)
{
	HRESULT		hr = S_OK;

	hr = m_adoConnection.CreateInstance(__uuidof(ADODB::Connection));
	hr = m_adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	_bstr_t bsDSN = _T("DSN=MusicController;Provider=MSDASQL;User=;Password=;");
	hr = m_adoConnection->Open (bsDSN, (LPCTSTR) NULL, (LPCTSTR) NULL, NULL);

	m_lngLastErrorNumber = 0;
}

CMCDB::~CMCDB(void)
{
}

//---------------------------------------------------------------------------
//
//  Delete All Discs
//
//---------------------------------------------------------------------------

long	CMCDB::DeleteAllDiscs(		void)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("delete from Discs ");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Delete All the rows in the Need to Check Table
//
//---------------------------------------------------------------------------
long	CMCDB::DeleteAllNeedToCheck(
								void)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("delete from NeedToCheck ");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Delete Disc Location
//
//---------------------------------------------------------------------------

long	CMCDB::DeleteDiscLocation(	
							CString strDeviceID,
							CString strDiscID)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("delete from Locations ");
	strSQL  +=	_T("where DeviceID='");
	strSQL +=   strDeviceID;
	strSQL +=	_T("' and DiscID='");
	strSQL +=   strDiscID;
	strSQL +=	_T("'");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Delete Location
//
//---------------------------------------------------------------------------

long	CMCDB::DeleteLocation(	CString		strDeviceID,
								long		lngItem)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString strNumber;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("delete from Locations ");
	strSQL  +=	_T("where DeviceID='");
	strSQL +=   strDeviceID;
	strSQL +=	_T("' and ItemNumber=");
	strNumber.Format(_T("%d"),lngItem);
	strSQL +=	strNumber;

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Delete Need to Check Row
//
//---------------------------------------------------------------------------

long	CMCDB::DeleteNeedToCheck(	CString		strDeviceID,
								long		lngItem)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString strNumber;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("delete from NeedToCheck ");
	strSQL  +=	_T("where DeviceID='");
	strSQL +=   strDeviceID;
	strSQL +=	_T("' and ItemNumber=");
	strNumber.Format(_T("%d"),lngItem);
	strSQL +=	strNumber;

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Returns a RecordSet with the Whole Devices
//
//---------------------------------------------------------------------------

long CMCDB::GetAllDevices(		ADODB::_Recordset** pipRecordset)
{
	HRESULT hr;
	CString strSQL;

	strSQL  = _T("select DeviceID, Name, Type, Maker, Port ");
	strSQL += _T(" from Devices");

	try
	{
		if (ADODB::adStateClosed != m_adoRecordSet->GetState())
		{
			m_adoRecordSet->Close();
		}
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = m_adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
												ADODB::adLockOptimistic, 
												ADODB::adCmdText);
		CHECKHR(hr);
		CHECKHR(m_adoRecordSet->QueryInterface(	__uuidof(ADODB::_Recordset), 
												(void**)pipRecordset));
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Returns a RecordSet the table of Contents
//
//---------------------------------------------------------------------------

long	CMCDB::GetAllDiscs(		ADODB::_Recordset** pipRecordset)
{
	HRESULT hr;
	CString strSQL;

	strSQL  = _T("select Title,");
	strSQL += _T(" Artist,");
	strSQL += _T(" DeviceID,");
	strSQL += _T(" Discs.DiscID,");
	strSQL += _T(" ItemNumber");
	strSQL += _T(" from Discs,");
	strSQL += _T(" Locations");
	strSQL += _T(" where Discs.DiscID = Locations.DiscID");
	strSQL += _T(" Order by DeviceID, ItemNumber");

	try
	{
		if (ADODB::adStateClosed != m_adoRecordSet->GetState())
		{
			m_adoRecordSet->Close();
		}
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = m_adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
												ADODB::adLockOptimistic, 
												ADODB::adCmdText);
		CHECKHR(hr);
		CHECKHR(m_adoRecordSet->QueryInterface(	__uuidof(ADODB::_Recordset), 
												(void**)pipRecordset));
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Returns a RecordSet the table of Contents
//
//---------------------------------------------------------------------------

long	CMCDB::GetAllDiscsPlus(		ADODB::_Recordset** pipRecordset)
{
	HRESULT hr;
	CString strSQL;

	strSQL  = _T("select ItemName \"Title\",");
	strSQL += _T(" '' \"Artist\",");
	strSQL += _T(" DeviceID \"DeviceID\",");
	strSQL += _T(" '' \"DiscID\",");
	strSQL += _T(" ItemNumber \"ItemNumber\"");
	strSQL += _T(" from NeedToCheck");
	strSQL += _T(" union");
	strSQL += _T(" select Title,");
	strSQL += _T(" Artist,");
	strSQL += _T(" DeviceID,");
	strSQL += _T(" CAST(Discs.DiscID as varchar(60)),");
	strSQL += _T(" ItemNumber");
	strSQL += _T(" from Discs, Locations");
	strSQL += _T(" where Discs.DiscID = Locations.DiscID");
	strSQL += _T(" order by 3,5");

	try
	{
		if (ADODB::adStateClosed != m_adoRecordSet->GetState())
		{
			m_adoRecordSet->Close();
		}
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = m_adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
												ADODB::adLockOptimistic, 
												ADODB::adCmdText);
		CHECKHR(hr);
		CHECKHR(m_adoRecordSet->QueryInterface(	__uuidof(ADODB::_Recordset), 
												(void**)pipRecordset));
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Returns a RecordSet the table of Contents of the Need To Check
//
//---------------------------------------------------------------------------

long	CMCDB::GetAllNeedToCheck(		ADODB::_Recordset** pipRecordset)
{
	HRESULT hr;
	CString strSQL;

	strSQL  = _T("select DeviceID,");
	strSQL += _T(" ItemNumber");
	strSQL += _T(" from NeedToCheck");

	try
	{
		if (ADODB::adStateClosed != m_adoRecordSet->GetState())
		{
			m_adoRecordSet->Close();
		}
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = m_adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
												ADODB::adLockOptimistic, 
												ADODB::adCmdText);
		CHECKHR(hr);
		CHECKHR(m_adoRecordSet->QueryInterface(	__uuidof(ADODB::_Recordset), 
												(void**)pipRecordset));
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Returns a RecordSet the table of Contents
//
//---------------------------------------------------------------------------

long	CMCDB::GetAllTracks(
							ADODB::_Recordset** pipRecordset,
							CString strDiscID)
{
	HRESULT hr;
	CString strSQL;

	strSQL  = _T("select Title,");
	strSQL += _T(" TrackNumber");
	strSQL += _T(" from Tracks");
	strSQL += _T(" where DiscID = '");
	strSQL += strDiscID;
	strSQL += _T("' Order by TrackNumber");

	try
	{
		if (ADODB::adStateClosed != m_adoRecordSet->GetState())
		{
			m_adoRecordSet->Close();
		}
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = m_adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
												ADODB::adLockOptimistic, 
												ADODB::adCmdText);
		CHECKHR(hr);
		CHECKHR(m_adoRecordSet->QueryInterface(	__uuidof(ADODB::_Recordset), 
												(void**)pipRecordset));
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}


//---------------------------------------------------------------------------
//
//  Get Disc From TOC
//
//---------------------------------------------------------------------------

long	CMCDB::GetDiscFromTOC(		
							CString strTOC,
							unsigned char** pstrDiscID,
							unsigned char** pstrMediaID,
							unsigned char** pstrMuiID,
							unsigned char** pstrTitle,
							unsigned char** pstrArtist,
							long* plngYear,
							long* plngGenre,
							long* plngLanguage,
							unsigned char** pstrLabel)
{
	ADORecordsetPtr adoRecordSet;
	CString strSQL;

	HRESULT hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));
	CHECKHR(hr);

	bstr_t  bsMessageText;

	strSQL  =	_T("select DiscID, MediaID, MuiID, Title, Artist, Year, Genra, Language, Label");
	strSQL +=	_T(" From Discs");
	strSQL +=	_T(" Where TOC = '");
	strSQL +=   strTOC;
	strSQL +=	_T("'");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
		CHECKHR(hr);
		
		if(adoRecordSet->GetRecordCount() > 0)
		{

			/////////////////////////////
			// DiscID
			/////////////////////////////
			bsMessageText = adoRecordSet->Fields->Item["DiscID"]->Value;
			*pstrDiscID = 
					(unsigned char*)CoTaskMemAlloc(
					strlen((char*)bsMessageText)+STRINGPAD);

			if(NULL == *pstrDiscID)
			{
				SetError(-200);
				return(MC_ERROR);
			}
			
			strcpy((char*)*pstrDiscID,(char*)bsMessageText);

			/////////////////////////////
			// MediaID
			/////////////////////////////
			bsMessageText = adoRecordSet->Fields->Item["MediaID"]->Value;
			*pstrMediaID = 
					(unsigned char*)CoTaskMemAlloc(
					strlen((char*)bsMessageText)+STRINGPAD);

			if(NULL == *pstrMediaID)
			{
				SetError(-200);
				return(MC_ERROR);
			}
			
			strcpy((char*)*pstrMediaID,(char*)bsMessageText);

			/////////////////////////////
			// MuiID
			/////////////////////////////
			bsMessageText = adoRecordSet->Fields->Item["MuiID"]->Value;
			*pstrMuiID = 
					(unsigned char*)CoTaskMemAlloc(
					strlen((char*)bsMessageText)+STRINGPAD);

			if(NULL == *pstrMuiID)
			{
				SetError(-200);
				return(MC_ERROR);
			}
			
			strcpy((char*)*pstrMuiID,(char*)bsMessageText);

			/////////////////////////////
			// Title
			/////////////////////////////
			bsMessageText = adoRecordSet->Fields->Item["Title"]->Value;
			*pstrTitle = 
					(unsigned char*)CoTaskMemAlloc(
					strlen((char*)bsMessageText)+STRINGPAD);

			if(NULL == *pstrTitle)
			{
				SetError(-200);
				return(MC_ERROR);
			}
			
			strcpy((char*)*pstrTitle,(char*)bsMessageText);

			/////////////////////////////
			// Artist
			/////////////////////////////
			bsMessageText = adoRecordSet->Fields->Item["Artist"]->Value;
			*pstrArtist = 
					(unsigned char*)CoTaskMemAlloc(
					strlen((char*)bsMessageText)+STRINGPAD);

			if(NULL == *pstrArtist)
			{
				SetError(-200);
				return(MC_ERROR);
			}
			
			strcpy((char*)*pstrArtist,(char*)bsMessageText);

			/////////////////////////////
			// Year
			/////////////////////////////
			*plngYear = adoRecordSet->Fields->Item["Year"]->Value;

			/////////////////////////////
			// Genre
			/////////////////////////////
			*plngGenre = adoRecordSet->Fields->Item["Genre"]->Value;

			/////////////////////////////
			// Language
			/////////////////////////////
			*plngLanguage = adoRecordSet->Fields->Item["Language"]->Value;

			/////////////////////////////
			// Label
			/////////////////////////////
			bsMessageText = adoRecordSet->Fields->Item["Label"]->Value;
			*pstrLabel = 
					(unsigned char*)CoTaskMemAlloc(
					strlen((char*)bsMessageText)+STRINGPAD);

			if(NULL == *pstrLabel)
			{
				SetError(-200);
				return(MC_ERROR);
			}
			
			strcpy((char*)*pstrLabel,(char*)bsMessageText);

		}
		else
		{
			SetError(-100);
			return(MC_NODATA);
		}
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	if (ADODB::adStateClosed != adoRecordSet->GetState())
	{
		adoRecordSet->Close();
	}
	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Get DiscID From TOC
//
//---------------------------------------------------------------------------

long	CMCDB::GetDiscIDFromTOC(		
							CString strTOC,
							CString* pstrDiscID)
{
	ADORecordsetPtr adoRecordSet;
	CString strSQL;

	HRESULT hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));
	CHECKHR(hr);

	bstr_t  bsMessageText;

	strSQL  =	_T("select DiscID");
	strSQL +=	_T(" From Discs");
	strSQL +=	_T(" Where TOC = '");
	strSQL +=   strTOC;
	strSQL +=	_T("'");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
		CHECKHR(hr);
		
		if(adoRecordSet->GetRecordCount() > 0)
		{
			/////////////////////////////
			// DiscID
			/////////////////////////////
			*pstrDiscID = adoRecordSet->Fields->Item["DiscID"]->Value;
		}
		else
		{
			SetError(-100);
			return(MC_NODATA);
		}
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	if (ADODB::adStateClosed != adoRecordSet->GetState())
	{
		adoRecordSet->Close();
	}
	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Public Method to get the name of the disc
//
//---------------------------------------------------------------------------
long    CMCDB::GetDiscTitle(	CString strDiscID,
								CString* pstrTitle)
{
	ADORecordsetPtr adoRecordSet;
	CString strSQL;

	HRESULT hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));
	CHECKHR(hr);

	bstr_t  bsMessageText;

	strSQL  =	_T("select Title");
	strSQL +=	_T(" From Discs");
	strSQL +=	_T(" Where DiscID = '");
	strSQL +=   strDiscID;
	strSQL +=	_T("'");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
		CHECKHR(hr);
		
		if(adoRecordSet->GetRecordCount() > 0)
		{
			/////////////////////////////
			// DiscID
			/////////////////////////////
			*pstrTitle = adoRecordSet->Fields->Item["Title"]->Value;
		}
		else
		{
			SetError(-100);
			return(MC_NODATA);
		}
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	if (ADODB::adStateClosed != adoRecordSet->GetState())
	{
		adoRecordSet->Close();
	}
	return(MC_OK);
}


//---------------------------------------------------------------------------
//
//  Public Method for alowing a user to get the error message that last occured
//
//---------------------------------------------------------------------------

long CMCDB::GetLastError(		long *plngMessageID)
{
	*plngMessageID = m_lngLastErrorNumber;

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Get the Disc ID for a Device and Item
//
//---------------------------------------------------------------------------

long	CMCDB::GetLocation(CString strDeviceID,
							long	lngItem,
							CString* pstrDiscID)
{
	ADORecordsetPtr adoRecordSet;
	CString strSQL;
	CString strNumber;

	HRESULT hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));
	CHECKHR(hr);

//	bstr_t  bsMessageText;

	strSQL  =	_T("select DiscID");
	strSQL +=	_T(" From Locations");
	strSQL +=	_T(" Where DeviceID = '");
	strSQL +=   strDeviceID;
	strSQL +=	_T("' and ItemNumber =");
	strNumber.Format(_T("%d"),lngItem);
	strSQL +=	strNumber;
 
	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
		CHECKHR(hr);
		
		if(adoRecordSet->GetRecordCount() > 0)
		{
			/////////////////////////////
			// DiscID
			/////////////////////////////
			*pstrDiscID = adoRecordSet->Fields->Item["DiscID"]->Value;
		}
		else
		{
			SetError(-100);
			return(MC_NODATA);
		}
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	if (ADODB::adStateClosed != adoRecordSet->GetState())
	{
		adoRecordSet->Close();
	}
	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Get TOC for Disc
//
//---------------------------------------------------------------------------

long	CMCDB::GetTOCForDisc(		
							CString strDeviceID,
							long            lngItem,
							CString* pstrTOC)
{
	ADORecordsetPtr adoRecordSet;
	CString	strSQL;
	CString	strNumber;

	HRESULT hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));
	CHECKHR(hr);

	bstr_t  bsMessageText;

	strSQL  =	_T("select TOC");
	strSQL +=	_T(" From Discs,");
	strSQL +=	_T(" Locations");
	strSQL +=	_T(" Where Locations.DeviceID = '");
	strSQL +=   strDeviceID;
	strSQL +=	_T("' and Locations.Item = ");
	strNumber.Format(_T("%d"),lngItem);
	strSQL +=	strNumber;
	strSQL +=	_T(" and Locations.DiscID = Discs.DiscID");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
		CHECKHR(hr);
		
		if(adoRecordSet->GetRecordCount() > 0)
		{
			/////////////////////////////
			// TOC
			/////////////////////////////
			*pstrTOC = adoRecordSet->Fields->Item["TOC"]->Value;
		}
		else
		{
			SetError(-100);
			return(MC_NODATA);
		}
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	if (ADODB::adStateClosed != adoRecordSet->GetState())
	{
		adoRecordSet->Close();
	}
	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Insert Device
//
//---------------------------------------------------------------------------

long CMCDB::InsertDevice(		CString strName,
								CString strType,
								CString strMaker,
								CString strPort)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("insert into Devices ");
	strSQL  +=	_T("(Name, Type, Maker, Port)");
	strSQL  +=	_T(" values('");
	strSQL +=   strName;
	strSQL +=	_T("','");
	strSQL +=   strType;
	strSQL +=	_T("','");
	strSQL +=   strMaker;
	strSQL +=	_T("','");
	strSQL +=   strPort;
	strSQL +=	_T("')");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Insert Disc
//
//---------------------------------------------------------------------------

long CMCDB::InsertDisc(			CString strTOC,
								CString strMediaID,
								CString strMuiID,
								CString strTitle,
								CString strArtist,
								long lngYear,
								long lngGenre,
								long lngLanguage,
								CString strLabel)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString	strNumber;
	CString lstrArtist = strArtist;
	CString lstrLabel  = strLabel;
	CString lstrTitle  = strTitle;
	
	lstrArtist.Replace(_T("'"),_T("''"));
	lstrLabel.Replace(_T("'"),_T("''"));
	lstrTitle.Replace(_T("'"),_T("''"));

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("insert into Discs ");
	strSQL  +=	_T("(TOC, MediaID, MuiID, Title, Artist, Year, Genre, Language, Label)");
	strSQL  +=	_T("values('");
	strSQL +=   strTOC;
	strSQL +=	_T("','");
	strSQL +=   strMediaID;
	strSQL +=	_T("','");
	strSQL +=   strMuiID;
	strSQL +=	_T("','");
	strSQL +=   lstrTitle;
	strSQL +=	_T("','");
	strSQL +=   lstrArtist;
	strSQL +=	_T("',");
	strNumber.Format(_T("%d"),lngYear);
	strSQL +=	strNumber;
	strSQL +=	_T(",");
	strNumber.Format(_T("%d"),lngGenre);
	strSQL +=	strNumber;
	strSQL +=	_T(",");
	strNumber.Format(_T("%d"),lngLanguage);
	strSQL +=	strNumber;
	strSQL +=	_T(",'");
	strSQL +=   lstrLabel;
	strSQL +=	_T("')");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Insert Location
//
//---------------------------------------------------------------------------

long CMCDB::InsertLocation(		CString strDeviceID,
								CString strDiscID,
								long		   lngItem)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString	strNumber;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("insert into Locations ");
	strSQL  +=	_T("(DeviceID, DiscID, ItemNumber)");
	strSQL  +=	_T("values('");
	strSQL +=   strDeviceID;
	strSQL +=	_T("','");
	strSQL +=   strDiscID;
	strSQL +=	_T("',");
	strNumber.Format(_T("%d"),lngItem);
	strSQL +=	strNumber;
	strSQL +=	_T(")");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Insert A row into the Need To Check
//
//---------------------------------------------------------------------------

long	CMCDB::InsertNeedToCheck(	CString strDeviceID,
							long	lngItem,
							CString strItemName)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString	strNumber;
	CString lstrItemName = strItemName;

	lstrItemName.Replace(_T("'"),_T("''"));

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("insert into NeedToCheck ");
	strSQL  +=	_T("(DeviceID, ItemNumber, ItemName)");
	strSQL  +=	_T("values('");
	strSQL +=   strDeviceID;
	strSQL +=	_T("',");
	strNumber.Format(_T("%d"),lngItem);
	strSQL +=	strNumber;
	strSQL +=	_T(",'");
	strSQL +=   lstrItemName;
	strSQL +=	_T("')");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Insert Track
//
//---------------------------------------------------------------------------

long	CMCDB::InsertTrack(		CString strDiscID,
								long	lngTrackID,
								CString strTitle)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString	strNumber;
	CString lstrTitle = strTitle;

	lstrTitle.Replace(_T("'"),_T("''"));

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("insert into Tracks ");
	strSQL  +=	_T("(DiscID, Title, TrackNumber)");
	strSQL  +=	_T("values('");
	strSQL +=   strDiscID;
	strSQL +=	_T("','");
	strSQL +=   lstrTitle;
	strSQL +=	_T("',");
	strNumber.Format(_T("%d"),lngTrackID);
	strSQL +=	strNumber;
	strSQL +=	_T(")");

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}

//---------------------------------------------------------------------------
//
//  Insert Track
//
//---------------------------------------------------------------------------

long	CMCDB::UpdateTrackLength(
								CString strDiscID,
								long	lngTrackID,
								long	lngTrackLength)
{
	ADORecordsetPtr adoRecordSet;
	HRESULT hr;
	CString strSQL;
	CString strNumber;

	hr = adoRecordSet.CreateInstance(__uuidof(ADODB::Recordset));

	strSQL  =	_T("Update Tracks ");
	strSQL  +=	_T(" Set Length = ");
	strNumber.Format(_T("%d"),lngTrackLength);
	strSQL +=	strNumber;
	strSQL  +=	_T(" where DiscID='");
	strSQL +=   strDiscID;
	strSQL +=	_T("' and TrackNumber=");
	strNumber.Format(_T("%d"),lngTrackID);
	strSQL +=	strNumber;

	try
	{
		_variant_t vConn = static_cast<IDispatch*>(m_adoConnection);
		hr = adoRecordSet->Open(strSQL.GetBuffer(), vConn,	ADODB::adOpenKeyset, 
										ADODB::adLockOptimistic, 
										ADODB::adCmdText);
	}
	catch(_com_error &e)
	{
		SetComError(e);
		return(MC_ERROR);
	}

	return(MC_OK);
}