You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3497 lines
108 KiB
C++

// XTPCalendarDatabaseDataProvider.cpp: implementation of the CXTPCalendarDatabaseDataProvider class.
//
// This file is a part of the XTREME CALENDAR MFC class library.
// (c)1998-2012 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Common/XTPPropExchange.h"
#include "Common/XTPSmartPtrInternalT.h"
#include "Common/XTPResourceManager.h"
#include "Common/XTPColorManager.h"
#include "Common/XTPNotifyConnection.h"
#include "Common/XTPVC80Helpers.h"
#include "XTPCalendarUtils.h"
#include "XTPCalendarDefines.h"
#include "XTPCalendarNotifications.h"
#include "XTPCalendarPtrCollectionT.h"
#include "XTPCalendarOptions.h"
#include "XTPCalendarEvent.h"
#include "XTPCalendarEvents.h"
#include "XTPCalendarRecurrencePattern.h"
#include "XTPCalendarCustomProperties.h"
#include "XTPCalendarResource.h"
#include "XTPCalendarEventLabel.h"
#include "XTPCalendarADO.h"
#include "XTPCalendarData.h"
#include "XTPCalendarDatabaseDataProvider.h"
#pragma warning(disable: 4571) // warning C4571: catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
AFX_INLINE CString MakeSQLDateTime(DATE t)
{
COleDateTime ct(t);
return ct.Format(_T("#%Y-%m-%d %H:%M:%S#"));
}
AFX_INLINE const _variant_t DATE2VAR(DATE dt)
{
return _variant_t(dt, VT_DATE);
}
AFX_INLINE const _variant_t STRING2VAR(const CString& str)
{
VARIANT vtStr;
vtStr.vt = VT_BSTR;
vtStr.bstrVal = str.AllocSysString();
return _variant_t(vtStr, false); // Will deallocate in destructor
}
template<class _TData>
_TData _GetField(XTPADODB::_Recordset* pRS, LPCWSTR pcszFName, _TData defVal)
{
_TData dataValue;
try
{
XTPADODB::FieldPtr ptrField = pRS->Fields->GetItem(pcszFName);
if (ptrField)
{
_variant_t vtValue = ptrField->Value;
if (vtValue.vt == VT_NULL || vtValue.vt == VT_EMPTY ||
vtValue.vt == VT_ERROR)
{
return defVal;
}
dataValue = (_TData)vtValue;
return dataValue;
}
}
catch (_com_error &e)
{
e;
#ifdef _DEBUG
if (pRS->GetActiveConnection().vt == VT_DISPATCH &&
pRS->GetActiveConnection().pdispVal)
{
XTPADODB::_Connection* pConnDB = NULL;
HRESULT hr = pRS->GetActiveConnection().pdispVal->QueryInterface(__uuidof(XTPADODB::_Connection), (void**)&pConnDB);
if (SUCCEEDED(hr))
{
CXTPCalendarDatabaseDataProvider::TRACE_ProviderError(pConnDB);
}
}
CXTPCalendarDatabaseDataProvider::TRACE_ComError(e);
#endif
}
catch(...)
{}
TRACE(_T("ERROR: CalendarDB provider: Cannot Get field '%s' \n"), pcszFName);
return defVal;
}
inline CString VariantToString(VARIANT vtValue, LPCTSTR lpszDefault)
{
if (vtValue.vt != VT_BSTR)
{
if (FAILED(::VariantChangeType(&vtValue, &vtValue, 0, VT_BSTR)))
{
return lpszDefault;
}
}
return CString(V_BSTR(&vtValue));
}
CString _GetFieldString(XTPADODB::_Recordset* pRS, LPCWSTR pcszFName, LPCTSTR defVal = NULL)
{
try
{
XTPADODB::FieldPtr ptrField = pRS->Fields->GetItem(pcszFName);
if (ptrField)
{
_variant_t vtValue = ptrField->Value;
if (vtValue.vt == VT_NULL || vtValue.vt == VT_EMPTY ||
vtValue.vt == VT_ERROR)
{
return defVal;
}
return VariantToString(vtValue, defVal);
}
}
catch (_com_error &e)
{
e;
#ifdef _DEBUG
if (pRS->GetActiveConnection().vt == VT_DISPATCH &&
pRS->GetActiveConnection().pdispVal)
{
XTPADODB::_Connection* pConnDB = NULL;
HRESULT hr = pRS->GetActiveConnection().pdispVal->QueryInterface(__uuidof(XTPADODB::_Connection), (void**)&pConnDB);
if (SUCCEEDED(hr))
{
CXTPCalendarDatabaseDataProvider::TRACE_ProviderError(pConnDB);
}
}
CXTPCalendarDatabaseDataProvider::TRACE_ComError(e);
#endif
}
catch(...)
{}
TRACE(_T("ERROR: CalendarDB provider: Cannot Get field '%s' \n"), pcszFName);
return defVal;
}
class CXTPCalendarDatabaseDataProvider::CADOCommand : public CCmdTarget
{
public:
CADOCommand(XTPADODB::_ConnectionPtr pConnection, LPCWSTR pcszSQLText);
~CADOCommand();
void CreateParameter(LPCWSTR pcszParamName, XTPADODB::DataTypeEnum adDataType,
XTPADODB::ParameterDirectionEnum adDirection, long nSize,
const _variant_t& vtValue);
void SetParameter(XTPADODB::DataTypeEnum adDataType, long nSize,
const _variant_t& vtValue);
void SetSQLString(LPCWSTR pcszSQLText);
void SetParameterValue(LPCWSTR pcszParamName, const _variant_t& vtValue);
XTPADODB::_RecordsetPtr Execute();
void ClearParams();
void TraceComError(_com_error &e);
private:
XTPADODB::_CommandPtr m_pcmdSQL;
XTPADODB::_ConnectionPtr m_pconnDb;
};
//===========================================================================
// Summary:
// Define Empty DB string.
//===========================================================================
#define EMPTY_DB_STR L"abcdefghabcdefghabcdefghabcdefghabcde"
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CXTPCalendarDatabaseDataProvider, CXTPCalendarData)
//////////////////////////////////////////////////////////////////////
void AFX_CDECL CXTPCalendarDatabaseDataProvider::TRACE_ComError(_com_error &e)
{
LPCWSTR bstrSource(e.Source());
// Print COM errors.
TRACE(_T("COM_ERROR: HRESULT = %08lx, Code meaning = %s, Source = %ls\n"),
e.Error(), (LPCTSTR)e.ErrorMessage(), (LPCWSTR)bstrSource);
}
//===========================================================================
void AFX_CDECL CXTPCalendarDatabaseDataProvider::TRACE_ProviderError(XTPADODB::_Connection* pConnDB)
{
// Print Provider Errors from Connection object.
ASSERT(pConnDB);
if (!pConnDB)
return;
if (pConnDB->Errors->Count > 0)
{
long nCount = pConnDB->Errors->Count;
TRACE(_T("DB ERROR(s): "));
for (long i = 0; i < nCount; i++)
{
XTPADODB::ErrorPtr ptrErr = pConnDB->Errors->GetItem(i);
TRACE(_T(" (Error- %x, '%ls'); "), ptrErr->Number, (LPCWSTR)ptrErr->Description);
}
TRACE(_T(" \n"));
}
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CXTPCalendarDatabaseDataProvider::CXTPCalendarDatabaseDataProvider()
{
m_pconnDb = NULL;
m_bCloseDbConnection = TRUE;
m_bTraceOptions = FALSE;
m_typeProvider = xtpCalendarDataProviderDatabase;
SetCacheMode(xtpCalendarDPCacheModeOnRepeat);
m_pcmdAddEvent = NULL;
m_pcmdDelEvent = NULL;
m_pcmdUpdEvent = NULL;
m_pcmdUpdEventPatternID = NULL;
m_pcmdGetDayEvents = NULL;
m_pcmdGetRExceptions = NULL;
m_pcmdGetLastID = NULL;
m_pcmdGetEvent = NULL;
m_pcmdAddRPattern = NULL;
m_pcmdDelRPattern = NULL;
m_pcmdUpdRPattern = NULL;
m_pcmdGetRPattern = NULL;
m_pcmdRemoveAllEvents = NULL;
m_pcmdRemoveAllRPatterns = NULL;
m_pcmdRemoveAllOptions = NULL;
m_pcmdGetOptions = NULL;
m_pcmdAddOptions = NULL;
m_pcmdAddSchedule = NULL;
m_pcmdUpdSchedule = NULL;
try
{
HRESULT hr = m_pconnDb.CreateInstance(__uuidof(XTPADODB::Connection));
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
{
TRACE(_T("ERROR: Cannot create XTPADODB::Connection. (HRESULT = %08lx) \n"), hr);
}
}
catch(...)
{
ASSERT(FALSE);
TRACE(_T("ERROR: Cannot create XTPADODB::Connection. Exception was happend. \n"));
}
}
CXTPCalendarDatabaseDataProvider::~CXTPCalendarDatabaseDataProvider()
{
try
{
DeleteAllDBCommands();
Close();
return;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
ASSERT(FALSE);
}
catch (...)
{
ASSERT(FALSE);
}
TRACE(_T("ERROR: Exception in ~CXTPCalendarDatabaseDataProvider()"));
}
void CXTPCalendarDatabaseDataProvider::DeleteAllDBCommands()
{
CMDTARGET_RELEASE(m_pcmdAddEvent);
CMDTARGET_RELEASE(m_pcmdDelEvent);
CMDTARGET_RELEASE(m_pcmdUpdEvent);
CMDTARGET_RELEASE(m_pcmdGetDayEvents);
CMDTARGET_RELEASE(m_pcmdGetLastID);
CMDTARGET_RELEASE(m_pcmdAddRPattern);
CMDTARGET_RELEASE(m_pcmdDelRPattern);
CMDTARGET_RELEASE(m_pcmdUpdRPattern);
CMDTARGET_RELEASE(m_pcmdGetRPattern);
CMDTARGET_RELEASE(m_pcmdGetRExceptions);
CMDTARGET_RELEASE(m_pcmdGetEvent);
CMDTARGET_RELEASE(m_pcmdUpdEventPatternID);
CMDTARGET_RELEASE(m_pcmdRemoveAllEvents);
CMDTARGET_RELEASE(m_pcmdRemoveAllRPatterns);
CMDTARGET_RELEASE(m_pcmdRemoveAllOptions);
CMDTARGET_RELEASE(m_pcmdGetOptions);
CMDTARGET_RELEASE(m_pcmdAddOptions);
CMDTARGET_RELEASE(m_pcmdAddSchedule);
CMDTARGET_RELEASE(m_pcmdUpdSchedule);
}
BOOL CXTPCalendarDatabaseDataProvider::Open()
{
if (m_strConnectionString.IsEmpty())
return FALSE;
if (IsOpen())
{
TRACE(_T("Provider is alredy opened. CXTPCalendarDatabaseDataProvider::Open(ConnectionString='%s') \n"), (LPCTSTR)m_strConnectionString);
return TRUE;
}
if (m_pconnDb == NULL)
{
return FALSE;
}
// Check is the special mode to use OpenEx later.
CString strConn = m_strConnectionString;
strConn.MakeLower();
if (strConn.Find(_T("provider=access;")) >= 0 || strConn == _T("provider=access") ||
strConn.Find(_T("provider=ado;")) >= 0 || strConn == _T("provider=ado"))
{
return TRUE;
}
//-----------------------------------------------------------
try
{
m_bCloseDbConnection = TRUE;
HRESULT hr = m_pconnDb->Open(_bstr_t(XTP_CT2CW(m_strConnectionString)), L"", L"", -1);
ASSERT(SUCCEEDED(hr));
if (SUCCEEDED(hr) && _Open())
{
return TRUE;
}
TRACE(_T("ERROR: Cannot open DB Connection. (HRESULT = %08lx, ConnectionString='%s') \n"), hr, (LPCTSTR)m_strConnectionString);
return FALSE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch (...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::Open(ConnectionString='%s') \n"), (LPCTSTR)m_strConnectionString);
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::OpenEx(LPDISPATCH pdispADOConnection)
{
if (IsOpen())
{
TRACE(_T("Provider is alredy opened. CXTPCalendarDatabaseDataProvider::OpenEx() \n"));
return TRUE;
}
if (m_pconnDb == NULL) // Object was not created on constructor. ADO is not installed ???
{
return FALSE;
}
try
{
_variant_t vtADOConn(pdispADOConnection);
m_pconnDb = vtADOConn;
m_bCloseDbConnection = FALSE;
if (_Open())
{
return TRUE;
}
TRACE(_T("ERROR: Cannot open using External ADO Connection. \n") );
return FALSE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch (...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::OpenEx() \n"), (LPCTSTR)m_strConnectionString);
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::_Open()
{
if (m_pconnDb == NULL)
{
ASSERT(FALSE);
return FALSE;
}
VERIFY(UpdateDBStructure(m_pconnDb));
CreateGetLastIDCommand();
CreateAddEventCommand();
CreateDelEventCommand();
CreateUpdEventCommand();
CreateGetDayEventCommand();
CreateAddRPatternCommand();
CreateDelRPatternCommand();
CreateUpdRPatternCommand();
CreateGetRPatternCommand();
CreateGetRExceptionsCommand();
CreateGetEventCommand();
CreateUpdEventPatternIDCommand();
CreateRemoveAllCommands();
CreateGetOptionsCommand();
CreateAddOptionsCommand();
CreateAddScheduleCommand();
CreateUpdScheduleCommand();
CXTPCalendarData::Open();
LoadOptions();
CXTPCalendarSchedulesPtr ptrSchedules = LoadSchedules();
if (ptrSchedules)
{
CMDTARGET_RELEASE(m_pSchedules);
m_pSchedules = ptrSchedules;
CMDTARGET_ADDREF(m_pSchedules);
}
else if (m_pSchedules)
{
m_pSchedules->RemoveAll();
}
return IsOpen();
}
BOOL CXTPCalendarDatabaseDataProvider::IsTableExist(XTPADOX::_CatalogPtr ptrCatalog, LPCWSTR pwszTableName)
{
try
{
XTPADOX::_TablePtr ptrTable = ptrCatalog->Tables->GetItem(pwszTableName);
return ptrTable != NULL;
}
catch (...)
{}
return FALSE;
}
void CXTPCalendarDatabaseDataProvider::CreateSchedulesTable(XTPADOX::_CatalogPtr ptrCatalog)
{
XTPADOX::_TablePtr ptrTable;
// Event table
ptrTable.CreateInstance(__uuidof (XTPADOX::Table));
ptrTable->Name = L"Schedules";
// ------ Columns -------
// ScheduleID
XTPADOX::_ColumnPtr ptrID(__uuidof(XTPADOX::Column));
ptrID->Name = L"ScheduleID";
ptrID->Type = XTPADOX::adInteger;
ptrID->ParentCatalog = ptrCatalog;
ptrID->Properties->GetItem(L"AutoIncrement")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*) ptrID, true), XTPADOX::adInteger, 0);
#ifdef _BUSINESS_MODEL_
// ScheduleSecurity
XTPADOX::_ColumnPtr ptrSec(__uuidof(XTPADOX::Column));
ptrSec->Name = L"ScheduleSecurity";
ptrSec->Type = XTPADOX::adInteger;
ptrSec->ParentCatalog = ptrCatalog;
ptrSec->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*) ptrSec, true), XTPADOX::adInteger, 0);
#endif
// Name
XTPADOX::_ColumnPtr ptrName(__uuidof(XTPADOX::Column));
ptrName->Name = L"Name";
ptrName->Type = XTPADOX::adWChar;
ptrName->ParentCatalog = ptrCatalog;
ptrName->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*) ptrName, true), XTPADOX::adWChar, 255);
// XMLData
XTPADOX::_ColumnPtr ptrXMLData(__uuidof(XTPADOX::Column));
ptrXMLData->Name = L"CustomPropertiesXMLData";
ptrXMLData->Type = XTPADOX::adLongVarWChar;
ptrXMLData->ParentCatalog = ptrCatalog;
ptrXMLData->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*) ptrXMLData, true), XTPADOX::adLongVarWChar, 0);
// SaveDateTime
XTPADOX::_ColumnPtr ptrSaveDateTime(__uuidof(XTPADOX::Column));
ptrSaveDateTime->Name = L"Modified";
ptrSaveDateTime->Type = XTPADOX::adDate;
ptrSaveDateTime->ParentCatalog = ptrCatalog;
ptrSaveDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*) ptrSaveDateTime, true), XTPADOX::adDate, 0);
// --------- Keys ---------
// Table key
ptrTable->Keys->Append(L"PK", XTPADOX::adKeyPrimary, L"ScheduleID", L"", L"");
ptrCatalog->Tables->Append(_variant_t((IDispatch *) ptrTable));
ptrTable = NULL;
}
void CXTPCalendarDatabaseDataProvider::CreateOptionsTable(XTPADOX::_CatalogPtr ptrCatalog)
{
XTPADOX::_TablePtr ptrTable;
// Event table
ptrTable.CreateInstance(__uuidof (XTPADOX::Table));
ptrTable->Name = L"Options";
// ------ Columns -------
// EventID
XTPADOX::_ColumnPtr ptrOID(__uuidof(XTPADOX::Column));
ptrOID->Name = L"OptionsID";
ptrOID->Type = XTPADOX::adInteger;
ptrOID->ParentCatalog = ptrCatalog;
ptrOID->Properties->GetItem(L"AutoIncrement")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrOID, true), XTPADOX::adInteger, 0);
// SaveDateTime
XTPADOX::_ColumnPtr ptrSaveDateTime(__uuidof(XTPADOX::Column));
ptrSaveDateTime->Name = L"SaveDateTime";
ptrSaveDateTime->Type = XTPADOX::adDate;
ptrSaveDateTime->ParentCatalog = ptrCatalog;
ptrSaveDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrSaveDateTime, true), XTPADOX::adDate, 0);
// XMLData
XTPADOX::_ColumnPtr ptrXMLData(__uuidof(XTPADOX::Column));
ptrXMLData->Name = L"XMLData";
ptrXMLData->Type = XTPADOX::adLongVarWChar;
ptrXMLData->ParentCatalog = ptrCatalog;
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrXMLData, true), XTPADOX::adLongVarWChar, 0);
// --------- Keys ---------
// Table key
ptrTable->Keys->Append(L"PK", XTPADOX::adKeyPrimary, L"OptionsID", L"", L"");
ptrCatalog->Tables->Append(_variant_t((IDispatch *)ptrTable));
ptrTable = NULL;
}
void CXTPCalendarDatabaseDataProvider::CreateEventTable(XTPADOX::_CatalogPtr ptrCatalog)
{
XTPADOX::_TablePtr ptrTable;
// Event table
ptrTable.CreateInstance(__uuidof (XTPADOX::Table));
ptrTable->Name = L"Event";
// ------ Columns -------
// EventID
XTPADOX::_ColumnPtr ptrEID(__uuidof(XTPADOX::Column));
ptrEID->Name = L"EventID";
ptrEID->Type = XTPADOX::adInteger;
ptrEID->ParentCatalog = ptrCatalog;
ptrEID->Properties->GetItem(L"AutoIncrement")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrEID, true), XTPADOX::adInteger, 0);
// StartDateTime
XTPADOX::_ColumnPtr ptrStartDateTime(__uuidof(XTPADOX::Column));
ptrStartDateTime->Name = L"StartDateTime";
ptrStartDateTime->Type = XTPADOX::adDate;
ptrStartDateTime->ParentCatalog = ptrCatalog;
ptrStartDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrStartDateTime, true), XTPADOX::adDate, 0);
// EndDateTime
XTPADOX::_ColumnPtr ptrEndDateTime(__uuidof(XTPADOX::Column));
ptrEndDateTime->Name = L"EndDateTime";
ptrEndDateTime->Type = XTPADOX::adDate;
ptrEndDateTime->ParentCatalog = ptrCatalog;
ptrEndDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrEndDateTime, true), XTPADOX::adDate, 0);
// RecurrenceState
XTPADOX::_ColumnPtr ptrRS(__uuidof(XTPADOX::Column));
ptrRS->Name = L"RecurrenceState";
ptrRS->Type = XTPADOX::adInteger;
ptrRS->ParentCatalog = ptrCatalog;
ptrRS->Properties->GetItem(L"Nullable")->PutValue(_variant_t(false));
ptrRS->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrRS->Properties->GetItem(L"Description")->PutValue(_variant_t(L"normal - 0, master 1, exception 3"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrRS, true), XTPADOX::adInteger, 0);
// IsAllDayEvent
XTPADOX::_ColumnPtr ptrIsADE(__uuidof(XTPADOX::Column));
ptrIsADE->Name = L"IsAllDayEvent";
ptrIsADE->Type = XTPADOX::adInteger;
ptrIsADE->ParentCatalog = ptrCatalog;
ptrIsADE->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrIsADE->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrIsADE->Properties->GetItem(L"Description")->PutValue(_variant_t(L"all day event 1, 0 - otherwise"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrIsADE, true), XTPADOX::adInteger, 0);
// Subject
XTPADOX::_ColumnPtr ptrSubject(__uuidof(XTPADOX::Column));
ptrSubject->Name = L"Subject";
ptrSubject->Type = XTPADOX::adLongVarWChar;
ptrSubject->ParentCatalog = ptrCatalog;
ptrSubject->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrSubject, true), XTPADOX::adLongVarWChar, 0);
// Location
XTPADOX::_ColumnPtr ptrLocation(__uuidof(XTPADOX::Column));
ptrLocation->Name = L"Location";
ptrLocation->Type = XTPADOX::adLongVarWChar;
ptrLocation->ParentCatalog = ptrCatalog;
ptrLocation->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrLocation, true), XTPADOX::adLongVarWChar, 0);
// RemainderSoundFile
XTPADOX::_ColumnPtr ptrRSF(__uuidof(XTPADOX::Column));
ptrRSF->Name = L"RemainderSoundFile";
ptrRSF->Type = XTPADOX::adWChar;
ptrRSF->ParentCatalog = ptrCatalog;
ptrRSF->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrRSF, true), XTPADOX::adWChar, 255);
// Body
XTPADOX::_ColumnPtr ptrBody(__uuidof(XTPADOX::Column));
ptrBody->Name = L"Body";
ptrBody->Type = XTPADOX::adLongVarWChar;
ptrBody->ParentCatalog = ptrCatalog;
ptrBody->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrBody, true), XTPADOX::adLongVarWChar, 0);
// Created
XTPADOX::_ColumnPtr ptrCreated(__uuidof(XTPADOX::Column));
ptrCreated->Name = L"Created";
ptrCreated->Type = XTPADOX::adDate;
ptrCreated->ParentCatalog = ptrCatalog;
ptrCreated->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrCreated, true), XTPADOX::adDate, 0);
// Modified
XTPADOX::_ColumnPtr ptrModified(__uuidof(XTPADOX::Column));
ptrModified->Name = L"Modified";
ptrModified->Type = XTPADOX::adDate;
ptrModified->ParentCatalog = ptrCatalog;
ptrModified->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrModified, true), XTPADOX::adDate, 0);
// BusyStatus
XTPADOX::_ColumnPtr ptrBusyStatus(__uuidof(XTPADOX::Column));
ptrBusyStatus->Name = L"BusyStatus";
ptrBusyStatus->Type = XTPADOX::adInteger;
ptrBusyStatus->ParentCatalog = ptrCatalog;
ptrBusyStatus->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrBusyStatus->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrBusyStatus, true), XTPADOX::adInteger, 0);
// ImportanceLevel
XTPADOX::_ColumnPtr ptrImportanceLevel(__uuidof(XTPADOX::Column));
ptrImportanceLevel->Name = L"ImportanceLevel";
ptrImportanceLevel->Type = XTPADOX::adInteger;
ptrImportanceLevel->ParentCatalog = ptrCatalog;
ptrImportanceLevel->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrImportanceLevel->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrImportanceLevel, true), XTPADOX::adInteger, 0);
// LabelID
XTPADOX::_ColumnPtr ptrLabelID(__uuidof(XTPADOX::Column));
ptrLabelID->Name = L"LabelID";
ptrLabelID->Type = XTPADOX::adInteger;
ptrLabelID->ParentCatalog = ptrCatalog;
ptrLabelID->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrLabelID->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrLabelID, true), XTPADOX::adInteger, 0);
// RecurrencePatternID
XTPADOX::_ColumnPtr ptrRecurrencePatternID(__uuidof(XTPADOX::Column));
ptrRecurrencePatternID->Name = L"RecurrencePatternID";
ptrRecurrencePatternID->Type = XTPADOX::adInteger;
ptrRecurrencePatternID->ParentCatalog = ptrCatalog;
ptrRecurrencePatternID->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrRecurrencePatternID->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrRecurrencePatternID, true), XTPADOX::adInteger, 0);
// ScheduleID
XTPADOX::_ColumnPtr ptrScheduleID(__uuidof(XTPADOX::Column));
ptrScheduleID->Name = L"ScheduleID";
ptrScheduleID->Type = XTPADOX::adInteger;
ptrScheduleID->ParentCatalog = ptrCatalog;
ptrScheduleID->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrScheduleID->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrScheduleID, true), XTPADOX::adInteger, 0);
// ISRecurrenceExceptionDeleted
XTPADOX::_ColumnPtr ptrIsRED(__uuidof(XTPADOX::Column));
ptrIsRED->Name = L"ISRecurrenceExceptionDeleted";
ptrIsRED->Type = XTPADOX::adInteger;
ptrIsRED->ParentCatalog = ptrCatalog;
ptrIsRED->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrIsRED->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrIsRED, true), XTPADOX::adInteger, 0);
// RExceptionStartTimeOrig
XTPADOX::_ColumnPtr ptrREStart(__uuidof(XTPADOX::Column));
ptrREStart->Name = L"RExceptionStartTimeOrig";
ptrREStart->Type = XTPADOX::adDate;
ptrREStart->ParentCatalog = ptrCatalog;
ptrREStart->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrREStart, true), XTPADOX::adDate, 0);
// RExceptionEndTimeOrig
XTPADOX::_ColumnPtr ptrREEnd(__uuidof(XTPADOX::Column));
ptrREEnd->Name = L"RExceptionEndTimeOrig";
ptrREEnd->Type = XTPADOX::adDate;
ptrREEnd->ParentCatalog = ptrCatalog;
ptrREEnd->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrREEnd, true), XTPADOX::adDate, 0);
// IsMeeting
XTPADOX::_ColumnPtr ptrIsMeeting(__uuidof(XTPADOX::Column));
ptrIsMeeting->Name = L"IsMeeting";
ptrIsMeeting->Type = XTPADOX::adInteger;
ptrIsMeeting->ParentCatalog = ptrCatalog;
ptrIsMeeting->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrIsMeeting->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrIsMeeting, true), XTPADOX::adInteger, 0);
// IsPrivate
XTPADOX::_ColumnPtr ptrIsPrivate(__uuidof(XTPADOX::Column));
ptrIsPrivate->Name = L"IsPrivate";
ptrIsPrivate->Type = XTPADOX::adInteger;
ptrIsPrivate->ParentCatalog = ptrCatalog;
ptrIsPrivate->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrIsPrivate->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrIsPrivate, true), XTPADOX::adInteger, 0);
// IsReminder
XTPADOX::_ColumnPtr ptrIsReminder(__uuidof(XTPADOX::Column));
ptrIsReminder->Name = L"IsReminder";
ptrIsReminder->Type = XTPADOX::adInteger;
ptrIsReminder->ParentCatalog = ptrCatalog;
ptrIsReminder->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrIsReminder->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrIsReminder, true), XTPADOX::adInteger, 0);
// ReminderMinutesBeforeStart
XTPADOX::_ColumnPtr ptrReminderMin(__uuidof(XTPADOX::Column));
ptrReminderMin->Name = L"ReminderMinutesBeforeStart";
ptrReminderMin->Type = XTPADOX::adInteger;
ptrReminderMin->ParentCatalog = ptrCatalog;
ptrReminderMin->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrReminderMin->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrReminderMin, true), XTPADOX::adInteger, 0);
// CustomProperties
XTPADOX::_ColumnPtr ptrXMLData(__uuidof(XTPADOX::Column));
ptrXMLData->Name = L"CustomPropertiesXMLData";
ptrXMLData->Type = XTPADOX::adLongVarWChar;
ptrXMLData->ParentCatalog = ptrCatalog;
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrXMLData, true), XTPADOX::adLongVarWChar, 0);
// --------- Keys ---------
// Table key
ptrTable->Keys->Append(L"PK", XTPADOX::adKeyPrimary, L"EventID", L"", L"");
ptrCatalog->Tables->Append(_variant_t((IDispatch *)ptrTable));
ptrTable = NULL;
}
void CXTPCalendarDatabaseDataProvider::CreateRPatternTable(XTPADOX::_CatalogPtr ptrCatalog)
{
XTPADOX::_TablePtr ptrTable;
// Event table
ptrTable.CreateInstance(__uuidof (XTPADOX::Table));
ptrTable->Name = L"RecurrencePattern";
// -------- Columns -------
// RecurrencePatternID
XTPADOX::_ColumnPtr ptrRPID(__uuidof(XTPADOX::Column));
ptrRPID->Name = L"RecurrencePatternID";
ptrRPID->Type = XTPADOX::adInteger;
ptrRPID->ParentCatalog = ptrCatalog;
ptrRPID->Properties->GetItem(L"AutoIncrement")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrRPID, true), XTPADOX::adInteger, 0);
// PatternStartDateTime
XTPADOX::_ColumnPtr ptrPatternStartDateTime(__uuidof(XTPADOX::Column));
ptrPatternStartDateTime->Name = L"PatternStartDateTime";
ptrPatternStartDateTime->Type = XTPADOX::adDate;
ptrPatternStartDateTime->ParentCatalog = ptrCatalog;
ptrPatternStartDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrPatternStartDateTime, true), XTPADOX::adDate, 0);
// PatternEndDateTime
XTPADOX::_ColumnPtr ptrEndDateTime(__uuidof(XTPADOX::Column));
ptrEndDateTime->Name = L"PatternEndDateTime";
ptrEndDateTime->Type = XTPADOX::adDate;
ptrEndDateTime->ParentCatalog = ptrCatalog;
ptrEndDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrEndDateTime, true), XTPADOX::adDate, 0);
// StartDateTime
XTPADOX::_ColumnPtr ptrStartDateTime(__uuidof(XTPADOX::Column));
ptrStartDateTime->Name = L"StartDateTime";
ptrStartDateTime->Type = XTPADOX::adDate;
ptrStartDateTime->ParentCatalog = ptrCatalog;
ptrStartDateTime->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrStartDateTime, true), XTPADOX::adDate, 0);
// Duration
XTPADOX::_ColumnPtr ptrDuration(__uuidof(XTPADOX::Column));
ptrDuration->Name = L"Duration";
ptrDuration->Type = XTPADOX::adInteger;
ptrDuration->ParentCatalog = ptrCatalog;
ptrDuration->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrDuration->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrDuration, true), XTPADOX::adInteger, 0);
// EndAfterOccurrence
XTPADOX::_ColumnPtr ptrEndAfterOccurrence(__uuidof(XTPADOX::Column));
ptrEndAfterOccurrence->Name = L"EndAfterOccurrence";
ptrEndAfterOccurrence->Type = XTPADOX::adInteger;
ptrEndAfterOccurrence->ParentCatalog = ptrCatalog;
ptrEndAfterOccurrence->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrEndAfterOccurrence->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrEndAfterOccurrence, true), XTPADOX::adInteger, 0);
// UseEnd
XTPADOX::_ColumnPtr ptrUseEnd(__uuidof(XTPADOX::Column));
ptrUseEnd->Name = L"UseEnd";
ptrUseEnd->Type = XTPADOX::adInteger;
ptrUseEnd->ParentCatalog = ptrCatalog;
ptrUseEnd->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrUseEnd->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrUseEnd, true), XTPADOX::adInteger, 0);
// RecurrenceTypeID
XTPADOX::_ColumnPtr ptrRecurrenceTypeID(__uuidof(XTPADOX::Column));
ptrRecurrenceTypeID->Name = L"RecurrenceTypeID";
ptrRecurrenceTypeID->Type = XTPADOX::adInteger;
ptrRecurrenceTypeID->ParentCatalog = ptrCatalog;
ptrRecurrenceTypeID->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrRecurrenceTypeID->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrRecurrenceTypeID->Properties->GetItem(L"Description")->PutValue(_variant_t(L"XTPCalendarEventRecurrenceType"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrRecurrenceTypeID, true), XTPADOX::adInteger, 0);
// OccurrenceInterval
XTPADOX::_ColumnPtr ptrOccurrenceInterval(__uuidof(XTPADOX::Column));
ptrOccurrenceInterval->Name = L"OccurrenceInterval";
ptrOccurrenceInterval->Type = XTPADOX::adInteger;
ptrOccurrenceInterval->ParentCatalog = ptrCatalog;
ptrOccurrenceInterval->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrOccurrenceInterval->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrOccurrenceInterval->Properties->GetItem(L"Description")->PutValue(_variant_t(L"occurs evere Nth (day, week, month)"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrOccurrenceInterval, true), XTPADOX::adInteger, 0);
// DayOfWeekMask
XTPADOX::_ColumnPtr ptrDayOfWeekMask(__uuidof(XTPADOX::Column));
ptrDayOfWeekMask->Name = L"DayOfWeekMask";
ptrDayOfWeekMask->Type = XTPADOX::adInteger;
ptrDayOfWeekMask->ParentCatalog = ptrCatalog;
ptrDayOfWeekMask->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrDayOfWeekMask->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrDayOfWeekMask->Properties->GetItem(L"Description")->PutValue(_variant_t(L"stores weeks day (for weeks, month) in packed form"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrDayOfWeekMask, true), XTPADOX::adInteger, 0);
// DayOfMonth
XTPADOX::_ColumnPtr ptrDayOfMonth(__uuidof(XTPADOX::Column));
ptrDayOfMonth->Name = L"DayOfMonth";
ptrDayOfMonth->Type = XTPADOX::adInteger;
ptrDayOfMonth->ParentCatalog = ptrCatalog;
ptrDayOfMonth->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrDayOfMonth->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrDayOfMonth->Properties->GetItem(L"Description")->PutValue(_variant_t(L"day of month number (for monthly, yearly)"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrDayOfMonth, true), XTPADOX::adInteger, 0);
// MonthOfYear
XTPADOX::_ColumnPtr ptrMonthOfYear(__uuidof(XTPADOX::Column));
ptrMonthOfYear->Name = L"MonthOfYear";
ptrMonthOfYear->Type = XTPADOX::adInteger;
ptrMonthOfYear->ParentCatalog = ptrCatalog;
ptrMonthOfYear->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrMonthOfYear->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrMonthOfYear->Properties->GetItem(L"Description")->PutValue(_variant_t(L"for yearly: (month number mapped to month name)"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrMonthOfYear, true), XTPADOX::adInteger, 0);
// IsEveryWeekDay
XTPADOX::_ColumnPtr ptrIsEveryWeekDay(__uuidof(XTPADOX::Column));
ptrIsEveryWeekDay->Name = L"IsEveryWeekDay";
ptrIsEveryWeekDay->Type = XTPADOX::adInteger;
ptrIsEveryWeekDay->ParentCatalog = ptrCatalog;
ptrIsEveryWeekDay->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrIsEveryWeekDay->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrIsEveryWeekDay->Properties->GetItem(L"Description")->PutValue(_variant_t(L"For daily: is occurred each weekday"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrIsEveryWeekDay, true), XTPADOX::adInteger, 0);
// DayOccurrenceTypeID
XTPADOX::_ColumnPtr ptrDayOccurrenceTypeID(__uuidof(XTPADOX::Column));
ptrDayOccurrenceTypeID->Name = L"DayOccurrenceTypeID";
ptrDayOccurrenceTypeID->Type = XTPADOX::adInteger;
ptrDayOccurrenceTypeID->ParentCatalog = ptrCatalog;
ptrDayOccurrenceTypeID->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrDayOccurrenceTypeID->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrDayOccurrenceTypeID->Properties->GetItem(L"Description")->PutValue(_variant_t(L"Day occurrence: first, second, third, fourth or last occurrence of day ( WhichDay)"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrDayOccurrenceTypeID, true), XTPADOX::adInteger, 0);
// DayMask
XTPADOX::_ColumnPtr ptrDayMask(__uuidof(XTPADOX::Column));
ptrDayMask->Name = L"DayMask";
ptrDayMask->Type = XTPADOX::adInteger;
ptrDayMask->ParentCatalog = ptrCatalog;
ptrDayMask->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrDayMask->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrDayMask, true), XTPADOX::adInteger, 0);
// MasterEventID
XTPADOX::_ColumnPtr ptrMasterEventID(__uuidof(XTPADOX::Column));
ptrMasterEventID->Name = L"MasterEventID";
ptrMasterEventID->Type = XTPADOX::adInteger;
ptrMasterEventID->ParentCatalog = ptrCatalog;
ptrMasterEventID->Properties->GetItem(L"Nullable")->PutValue(_variant_t(true));
ptrMasterEventID->Properties->GetItem(L"Default")->PutValue(_variant_t((long)0, VT_I4));
ptrMasterEventID->Properties->GetItem(L"Description")->PutValue(_variant_t(L"EventID of master event"));
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrMasterEventID, true), XTPADOX::adInteger, 0);
// CustomProperties
XTPADOX::_ColumnPtr ptrXMLData(__uuidof(XTPADOX::Column));
ptrXMLData->Name = L"CustomPropertiesXMLData";
ptrXMLData->Type = XTPADOX::adLongVarWChar;
ptrXMLData->ParentCatalog = ptrCatalog;
ptrTable->Columns->Append(_variant_t((IDispatch*)ptrXMLData, true), XTPADOX::adLongVarWChar, 0);
// --------- Keys ---------
// Table primary key
ptrTable->Keys->Append(L"PK", XTPADOX::adKeyPrimary, L"RecurrencePatternID", L"", L"");
ptrCatalog->Tables->Append(_variant_t((IDispatch *)ptrTable));
ptrTable = NULL;
}
BOOL CXTPCalendarDatabaseDataProvider::Create()
{
try
{
XTPADOX::_CatalogPtr ptrCatalog;
// Create database file
if (FAILED(ptrCatalog.CreateInstance(__uuidof(XTPADOX::Catalog))))
return FALSE;
ptrCatalog->Create(_bstr_t(XTP_CT2CW(m_strConnectionString)));
// Create main tables
CreateEventTable(ptrCatalog);
CreateRPatternTable(ptrCatalog);
// Create Schedules table
CreateSchedulesTable(ptrCatalog);
// Create options table
CreateOptionsTable(ptrCatalog);
ptrCatalog = NULL;
}
catch (_com_error &e)
{
e;
#ifdef _DEBUG
TRACE(_T("ERROR: CXTPCalendarDatabaseDataProvider::Create: "));
LPCWSTR err(e.Description());
if (err) TRACE(_T("%ls"), err);
#endif
return FALSE;
}
return Open();
}
BOOL CXTPCalendarDatabaseDataProvider::UpdateDBStructure(XTPADODB::_Connection* pconnDb)
{
try
{
XTPADOX::_CatalogPtr ptrCatalog;
if (FAILED(ptrCatalog.CreateInstance(__uuidof(XTPADOX::Catalog))))
return FALSE;
ptrCatalog->PutRefActiveConnection((IDispatch*)pconnDb);
if (!IsTableExist(ptrCatalog, L"Event"))
CreateEventTable(ptrCatalog);
if (!IsTableExist(ptrCatalog, L"RecurrencePattern"))
CreateRPatternTable(ptrCatalog);
if (!IsTableExist(ptrCatalog, L"Options"))
CreateOptionsTable(ptrCatalog);
if (!IsTableExist(ptrCatalog, L"Schedules"))
CreateSchedulesTable(ptrCatalog);
return TRUE;
}
catch (_com_error &e)
{
e;
#ifdef _DEBUG
TRACE(_T("ERROR: CXTPCalendarDatabaseDataProvider::UpdateDB: "));
LPCWSTR err(e.Description());
if (err) TRACE(_T("%ls"), err);
#endif
}
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::Save()
{
VERIFY( CXTPCalendarData::Save() );
UpdateSchedules();
// Save calendar's options
#ifndef _XTP_EXCLUDE_XML
CXTPPropExchangeXMLNode px(FALSE, 0, _T("Calendar"));
px.ExchangeLocale();
CXTPPropExchangeSection secOptions(px.GetSection(_T("Options")));
secOptions->EmptySection();
// TODO:
if (m_pCalendarOptions)
{
m_pCalendarOptions->DoPropExchange(&secOptions);
}
CString strXML(px.GetXML());
return SaveOptions(strXML);
#else
return TRUE;
#endif
}
BOOL CXTPCalendarDatabaseDataProvider::LoadOptions()
{
// Load calendar's options
if (!m_pCalendarOptions)
{
return FALSE;
}
#ifndef _XTP_EXCLUDE_XML
// Load data from the database
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetOptions->Execute();
if (ptrDataRS == NULL || ptrDataRS->bEOF)
return FALSE;
CString strXMLData = _GetFieldString(ptrDataRS, L"XMLData");
ptrDataRS->Close();
// Populate XML node with data
CXTPPropExchangeXMLNode px(TRUE, 0, _T("Calendar"));
if (!px.LoadFromString(strXMLData))
return FALSE;
// Apply data to the calendar
px.ExchangeLocale();
CXTPPropExchangeSection secOptions(px.GetSection(_T("Options")));
m_pCalendarOptions->DoPropExchange(&secOptions);
return TRUE;
#else
return FALSE;
#endif
}
CXTPCalendarSchedulesPtr CXTPCalendarDatabaseDataProvider::LoadSchedules()
{
if (!IsOpen())
{
return NULL;
}
CXTPCalendarSchedulesPtr ptrSchedules = new CXTPCalendarSchedules();
if (!ptrSchedules)
return NULL;
CADOCommand cmdGetSchedules(m_pconnDb.GetInterfacePtr(),
L"SELECT * FROM Schedules");
try
{
XTPADODB::_RecordsetPtr ptrDataRS = cmdGetSchedules.Execute();
if (ptrDataRS == NULL)
{
ASSERT(FALSE);
return NULL;
}
// process recordset
while (!ptrDataRS->bEOF)
{
CXTPCalendarSchedule* pNewSch = _ReadSchedule(ptrDataRS);
if (pNewSch)
ptrSchedules->Add(pNewSch, FALSE);
// next record
ptrDataRS->MoveNext();
}
ptrDataRS->Close();
return ptrSchedules;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::LoadSchedules() \n"));
return NULL;
}
CXTPCalendarSchedule* CXTPCalendarDatabaseDataProvider::_ReadSchedule(XTPADODB::_Recordset* pRS)
{
ASSERT(pRS);
if (!pRS)
return NULL;
try
{
ULONG ulID = (ULONG)(long)pRS->Fields->GetItem(L"ScheduleID")->Value;
#ifdef _BUSINESS_MODEL_
ULONG ulSec = (ULONG)(long)pRS->Fields->GetItem(L"ScheduleSecurity")->Value;
#endif
CString strName = _GetFieldString(pRS, L"Name");
CString strPropsXMLData = _GetFieldString(pRS, L"CustomPropertiesXMLData");
CXTPCalendarSchedule* pNewSch = new CXTPCalendarSchedule(ulID, strName);
if (pNewSch && pNewSch->GetCustomProperties())
pNewSch->GetCustomProperties()->LoadFromXML(strPropsXMLData);
#ifdef _BUSINESS_MODEL_
if (pNewSch)
pNewSch->SetSecType(ulSec);
#endif
return pNewSch;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
ASSERT(FALSE);
}
return NULL;
}
void CXTPCalendarDatabaseDataProvider::UpdateSchedules()
{
if (!m_pSchedules)
return;
CXTPCalendarSchedulesPtr ptrSchedulesOrig = LoadSchedules();
if (!ptrSchedulesOrig || ptrSchedulesOrig->GetCount() == 0)
{
_AddSchedules(m_pSchedules);
return;
}
CXTPCalendarSchedules arAdd;
CXTPCalendarSchedules arUpdate;
CUIntArray arDelete;
int i;
int nCount = m_pSchedules->GetCount();
for (i = 0; i < nCount; i++)
{
CXTPCalendarSchedule* pSch = m_pSchedules->GetAt(i, FALSE);
int nIdx = ptrSchedulesOrig->FindIndex(pSch->GetID());
if (nIdx >= 0)
arUpdate.Add(pSch, TRUE);
else
arAdd.Add(pSch, TRUE);
}
int nCount_orig = ptrSchedulesOrig->GetCount();
for (i = 0; i < nCount_orig; i++)
{
CXTPCalendarSchedule* pSch = ptrSchedulesOrig->GetAt(i, FALSE);
int nIdx = m_pSchedules->FindIndex(pSch->GetID());
if (nIdx < 0)
arDelete.Add(pSch->GetID());
}
_AddSchedules(&arAdd);
_UpdateSchedules(&arUpdate, ptrSchedulesOrig);
_DeleteSchedules(&arDelete);
}
void CXTPCalendarDatabaseDataProvider::_AddSchedules(CXTPCalendarSchedules* pAddSet)
{
if (!IsOpen())
{
return;
}
if (!pAddSet || !m_pcmdAddSchedule)
{
return;
}
_variant_t vtdtNow = DATE2VAR(COleDateTime::GetCurrentTime());
int nCount = pAddSet->GetCount();
for (int i = 0; i < nCount; i++)
{
CXTPCalendarSchedule* pSch = pAddSet->GetAt(i, FALSE);
ASSERT(pSch);
if (!pSch)
continue;
try
{
CString strName = pSch->GetName();
CString strData;
if (pSch->GetCustomProperties())
pSch->GetCustomProperties()->SaveToXML(strData);
m_pcmdAddSchedule->SetParameterValue(L"prm_Name", STRING2VAR(strName));
m_pcmdAddSchedule->SetParameterValue(L"prm_Modified", vtdtNow);
m_pcmdAddSchedule->SetParameterValue(L"prm_CustomPropertiesXMLData", STRING2VAR(strData));
m_pcmdAddSchedule->Execute();
// get ID
CADOCommand cmdGetLastID(m_pconnDb.GetInterfacePtr(), L"SELECT MAX(ScheduleID) AS NewScheduleID FROM Schedules");
XTPADODB::_RecordsetPtr ptrRS_NewID = cmdGetLastID.Execute();
ASSERT(ptrRS_NewID != NULL);
if (ptrRS_NewID)
{
ASSERT(!ptrRS_NewID->bEOF);
if (!ptrRS_NewID->bEOF)
{
UINT uNewSchID = (DWORD)(long)ptrRS_NewID->Fields->GetItem(L"NewScheduleID")->Value;
pSch->SetID(uNewSchID);
#ifdef _BUSINESS_MODEL_
UINT uNewSchSec = (DWORD)(long)ptrRS_NewID->Fields->GetItem(L"NewScheduleSecurity")->Value;
pSch->SetSecType(uNewSchSec);
#endif
}
ptrRS_NewID->Close();
}
}
catch (_com_error &e)
{
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::_AddSchedules()"));
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::_AddSchedules()"));
}
}
}
void CXTPCalendarDatabaseDataProvider::_UpdateSchedules(CXTPCalendarSchedules* pUpdateSet, CXTPCalendarSchedules* pOrigSet)
{
if (!IsOpen())
{
return;
}
if (!pUpdateSet || !m_pcmdUpdSchedule)
{
return;
}
_variant_t vtdtNow = DATE2VAR(COleDateTime::GetCurrentTime());
int nCount = pUpdateSet->GetCount();
for (int i = 0; i < nCount; i++)
{
CXTPCalendarSchedule* pSch = pUpdateSet->GetAt(i, FALSE);
ASSERT(pSch);
if (!pSch)
continue;
long nID = pSch->GetID();
#ifdef _BUSINESS_MODEL_
long nSecType = pSch->GetSecType();
#endif
CString strName = pSch->GetName();
CString strData;
XTP_SAFE_CALL2(pSch, GetCustomProperties(), SaveToXML(strData));
// check is changed
if (pOrigSet)
{
int nIdx = pOrigSet->FindIndex(nID);
ASSERT(nIdx >= 0);
CXTPCalendarSchedule* pSch_orig = pOrigSet->GetAt(nIdx, FALSE);
ASSERT(pSch_orig);
if (pSch_orig)
{
CString strData_orig;
XTP_SAFE_CALL2(pSch_orig, GetCustomProperties(), SaveToXML(strData_orig));
if (strName == pSch_orig->GetName() &&
strData_orig == strData)
{
continue; // skip update if no changes
}
}
}
try
{
m_pcmdUpdSchedule->SetParameterValue(L"prm_ScheduleID", nID);
#ifdef _BUSINESS_MODEL_
m_pcmdUpdSchedule->SetParameterValue(L"prm_ScheduleSecurity", nSecType);
#endif
m_pcmdUpdSchedule->SetParameterValue(L"prm_Name", STRING2VAR(strName));
m_pcmdUpdSchedule->SetParameterValue(L"prm_Modified", vtdtNow);
m_pcmdUpdSchedule->SetParameterValue(L"prm_CustomPropertiesXMLData", STRING2VAR(strData));
m_pcmdUpdSchedule->Execute();
}
catch (_com_error &e)
{
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::_UpdateSchedules()"));
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::_UpdateSchedules()"));
}
}
}
void CXTPCalendarDatabaseDataProvider::_DeleteSchedules(CUIntArray* pDeleteIDs)
{
if (!IsOpen() || !pDeleteIDs || pDeleteIDs->GetSize() == 0)
{
return;
}
TCHAR szBuff[64];
CString strIDs;
int nCount = (int)pDeleteIDs->GetSize();
for (int i = 0; i < nCount; i++)
{
int nID = (int)pDeleteIDs->GetAt(i);
if (i)
strIDs += _T(",");
ITOT_S(nID, szBuff, 64, 10);
strIDs += szBuff;
}
CString strSqlText = _T("DELETE FROM Schedules WHERE ScheduleID IN ( ");
strSqlText += strIDs;
strSqlText += _T(" )");
try
{
CADOCommand cmdDeleteSchedules(m_pconnDb.GetInterfacePtr(), XTP_CT2CW(strSqlText));
cmdDeleteSchedules.Execute();
return;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::_DeleteSchedules()"));
}
void CXTPCalendarDatabaseDataProvider::Close()
{
if (!IsOpen())
return;
CXTPCalendarData::Close();
try
{
DeleteAllDBCommands();
if (m_bCloseDbConnection)
{
HRESULT hr = m_pconnDb->Close();
ASSERT(SUCCEEDED(hr));
if (FAILED(hr))
{
TRACE(_T("ERROR: Cannot close XTPADODB::Connection. (HRESULT = %08lx). CXTPCalendarDatabaseDataProvider::Close() \n"), hr);
}
}
return;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::Close"));
}
CXTPCalendarEventPtr CXTPCalendarDatabaseDataProvider::_ReadEvent_common(XTPADODB::_Recordset* pRS, BOOL bEcxception)
{
if (!IsOpen())
{
return NULL;
}
try
{
DWORD dwEventID = (DWORD)(long)pRS->Fields->GetItem(L"EventID")->Value;
CXTPCalendarEventPtr ptrEvent = CreateNewEvent(dwEventID);
ptrEvent->SetEndTime((DATE)pRS->Fields->GetItem(L"EndDateTime")->Value);
ptrEvent->SetStartTime((DATE)pRS->Fields->GetItem(L"StartDateTime")->Value);
ptrEvent->SetAllDayEvent(_GetField<long>(pRS, L"IsAllDayEvent", 0) != 0);
ptrEvent->SetSubject(_GetFieldString(pRS, L"Subject"));
ptrEvent->SetLocation(_GetFieldString(pRS, L"Location"));
ptrEvent->SetBody(_GetFieldString(pRS, L"Body"));
ptrEvent->SetReminderSoundFile(_GetFieldString(pRS, L"RemainderSoundFile"));
ptrEvent->SetBusyStatus(_GetField<long>(pRS, L"BusyStatus", 0));
ptrEvent->SetImportance(_GetField<long>(pRS, L"ImportanceLevel", 0));
ptrEvent->SetLabelID(_GetField<long>(pRS, L"LabelID", 0));
ptrEvent->SetScheduleID(_GetField<long>(pRS, L"ScheduleID", 0));
ptrEvent->SetCreationTime(_GetField<DATE>(pRS, L"Created", 0));
ptrEvent->SetLastModificationTime(_GetField<DATE>(pRS, L"Modified", 0));
ptrEvent->SetMeeting(_GetField<long>(pRS, L"IsMeeting", 0) != 0);
ptrEvent->SetPrivate(_GetField<long>(pRS, L"IsPrivate", 0) != 0);
ptrEvent->SetReminder(_GetField<long>(pRS, L"IsReminder", 0) != 0);
ptrEvent->SetReminderMinutesBeforeStart(_GetField<long>(pRS, L"ReminderMinutesBeforeStart", 0));
if (ptrEvent->GetCustomProperties())
{
CString bstrPropsXMLData = _GetFieldString(pRS, L"CustomPropertiesXMLData");
ptrEvent->GetCustomProperties()->LoadFromXML(bstrPropsXMLData);
COleVariant ovarIDs;
// update CustomIcons
if (ptrEvent->GetCustomProperties()->GetProperty(cszEventCustProp_IconsIDs, ovarIDs))
{
VERIFY(ptrEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_IconsIDs));
CString strArray = VariantToString(ovarIDs, NULL);
ptrEvent->GetCustomIcons()->LoadFromString(strArray);
}
// update Categories
if (ptrEvent->GetCustomProperties()->GetProperty(cszEventCustProp_CategoryIDs, ovarIDs))
{
VERIFY(ptrEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_CategoryIDs));
CString strArray = VariantToString(ovarIDs, NULL);
ptrEvent->GetCategories()->LoadFromString(strArray);
}
}
if (!bEcxception)
{
long nRState = _GetField<long>(pRS, L"RecurrenceState", xtpCalendarRecurrenceNotRecurring);
long nPatternID = _GetField<long>(pRS, L"RecurrencePatternID", XTP_CALENDAR_UNKNOWN_RECURRENCE_PATTERN_ID);
ptrEvent->GetCustomProperties()->SetProperty(cszProcess_RecurrenceState, COleVariant((long)nRState));
ptrEvent->GetCustomProperties()->SetProperty(cszProcess_RecurrencePatternID, COleVariant((long)nPatternID));
}
return ptrEvent;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::ReadEvent()"));
return NULL;
}
CXTPCalendarEventsPtr CXTPCalendarDatabaseDataProvider::DoRetrieveDayEvents(COleDateTime dtDay)
{
if (!IsOpen())
{
return NULL;
}
dtDay = CXTPCalendarUtils::ResetTime(dtDay);
CXTPCalendarEventsPtr ptrEvents = new CXTPCalendarEvents();
if (!ptrEvents)
{
return NULL;
}
CXTPCalendarEventPtr ptrEvent;
if (!m_pcmdGetDayEvents)
{
ASSERT(FALSE);
return NULL;
}
m_pcmdGetDayEvents->SetParameterValue(L"prm_DayDate", DATE2VAR(dtDay));
try
{
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetDayEvents->Execute();
if (ptrDataRS == NULL)
{
ASSERT(FALSE);
return NULL;
}
// process recordset
while (!ptrDataRS->bEOF) //
{
ptrEvent = _ReadEvent_common(ptrDataRS, FALSE);
if (!ptrEvent)
{
ASSERT(FALSE);
ptrDataRS->MoveNext();
continue;
}
ptrEvents->Add(ptrEvent);
// next record
ptrDataRS->MoveNext();
}
ptrDataRS->Close();
return ptrEvents;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::RetrieveDayEvents(%s) \n"), (LPCTSTR)dtDay.Format());
return NULL;
}
CXTPCalendarEventsPtr CXTPCalendarDatabaseDataProvider::DoGetAllEvents_raw()
{
if (!IsOpen())
{
return NULL;
}
CXTPCalendarEventsPtr ptrEvents = new CXTPCalendarEvents();
if (!ptrEvents)
{
return NULL;
}
CString strSqlText;
strSqlText.Format(_T("SELECT * FROM Event WHERE RecurrenceState = %d OR RecurrenceState = %d"),
xtpCalendarRecurrenceNotRecurring, xtpCalendarRecurrenceMaster);
CADOCommand cmdGetAllEvents_raw(m_pconnDb.GetInterfacePtr(), XTP_CT2CW(strSqlText));
CXTPCalendarEventPtr ptrEvent;
try
{
XTPADODB::_RecordsetPtr ptrDataRS = cmdGetAllEvents_raw.Execute();
if (ptrDataRS == NULL)
{
ASSERT(FALSE);
return NULL;
}
// process recordset
while (!ptrDataRS->bEOF) //
{
ptrEvent = _ReadEvent_common(ptrDataRS, FALSE);
if (!ptrEvent)
{
ASSERT(FALSE);
ptrDataRS->MoveNext();
continue;
}
ptrEvents->Add(ptrEvent);
// next record
ptrDataRS->MoveNext();
}
ptrDataRS->Close();
return ptrEvents;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::DoGetAllEvents_raw() \n"));
return NULL;
}
CXTPCalendarEventsPtr CXTPCalendarDatabaseDataProvider::DoGetUpcomingEvents(
COleDateTime dtFrom, COleDateTimeSpan spPeriod)
{
if (!IsOpen())
{
return NULL;
}
//-----------------------------------------------------------------------
if ((double)spPeriod == 0)
{
return DoGetAllEvents_raw();
}
//-----------------------------------------------------------------------
CXTPCalendarEventsPtr ptrEvents = new CXTPCalendarEvents();
if (!ptrEvents)
{
return NULL;
}
COleDateTime dtTo = dtFrom + spPeriod;
CString strDateTo = MakeSQLDateTime(dtTo);
CString strSqlText;
strSqlText.Format(_T("SELECT * FROM Event \
WHERE \
(RecurrenceState = $normal$ OR RecurrenceState = $master$ ) AND \
( IsReminder <> 0 OR \
( RecurrenceState = $master$ AND \
RecurrencePatternID IN \
( SELECT RecurrencePatternID FROM Event \
WHERE \
RecurrenceState = $exception$ And \
IsReminder <> 0 AND \
DATEADD(\"n\", -1 * ReminderMinutesBeforeStart, StartDateTime) <= %s \
) \
) \
) AND \
DATEADD(\"n\", -1 * ReminderMinutesBeforeStart, StartDateTime) <= %s \
"),
(LPCTSTR)strDateTo, (LPCTSTR)strDateTo);
TCHAR szBuff[64];
strSqlText.Replace(_T("$normal$"), ITOT_S((int)xtpCalendarRecurrenceNotRecurring, szBuff, 64, 10));
strSqlText.Replace(_T("$master$"), ITOT_S((int)xtpCalendarRecurrenceMaster, szBuff, 64, 10));
strSqlText.Replace(_T("$exception$"), ITOT_S((int)xtpCalendarRecurrenceException, szBuff, 64, 10));
CADOCommand cmdGetUpcomingEvents(m_pconnDb.GetInterfacePtr(), XTP_CT2CW(strSqlText));
CXTPCalendarEventPtr ptrEvent;
try
{
XTPADODB::_RecordsetPtr ptrDataRS = cmdGetUpcomingEvents.Execute();
if (ptrDataRS == NULL)
{
ASSERT(FALSE);
return NULL;
}
// process recordset
while (!ptrDataRS->bEOF) //
{
ptrEvent = _ReadEvent_common(ptrDataRS, FALSE);
if (!ptrEvent)
{
ASSERT(FALSE);
ptrDataRS->MoveNext();
continue;
}
ptrEvents->Add(ptrEvent);
// next record
ptrDataRS->MoveNext();
}
ptrDataRS->Close();
return ptrEvents;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::DoGetAllEvents_raw() \n"));
return NULL;
}
BOOL CXTPCalendarDatabaseDataProvider::DoCreate_Event(CXTPCalendarEvent* pEvent, DWORD& rdwNewEventID)
{
if (!IsOpen())
{
return FALSE;
}
if (!pEvent || !m_pcmdAddEvent || !m_pcmdUpdEventPatternID)
{
ASSERT(FALSE);
return FALSE;
}
try
{
COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
pEvent->SetLastModificationTime(dtNow);
int nRState = (long)pEvent->GetRecurrenceState();
ASSERT(nRState == xtpCalendarRecurrenceMaster || nRState == xtpCalendarRecurrenceNotRecurring ||
nRState == xtpCalendarRecurrenceException);
m_pcmdAddEvent->SetParameterValue(L"prm_StartDateTime", DATE2VAR(pEvent->GetStartTime()));
m_pcmdAddEvent->SetParameterValue(L"prm_EndDateTime", DATE2VAR(pEvent->GetEndTime()));
m_pcmdAddEvent->SetParameterValue(L"prm_RecurrenceState", _variant_t((long)nRState));
_variant_t vtIsAllDayEvent = (long)(pEvent->IsAllDayEvent() ? 1 : 0);
m_pcmdAddEvent->SetParameterValue(L"prm_IsAllDayEvent", vtIsAllDayEvent);
CString strData = pEvent->GetSubject();
m_pcmdAddEvent->SetParameterValue(L"prm_Subject", STRING2VAR(strData));
strData = pEvent->GetLocation();
m_pcmdAddEvent->SetParameterValue(L"prm_Location", STRING2VAR(strData));
strData = pEvent->GetReminderSoundFile();
m_pcmdAddEvent->SetParameterValue(L"prm_RemainderSoundFile", STRING2VAR(strData));
strData = pEvent->GetBody();
m_pcmdAddEvent->SetParameterValue(L"prm_Body", STRING2VAR(strData));
m_pcmdAddEvent->SetParameterValue(L"prm_Created", DATE2VAR(pEvent->GetCreationTime()));
m_pcmdAddEvent->SetParameterValue(L"prm_Modified", DATE2VAR(pEvent->GetLastModificationTime()));
m_pcmdAddEvent->SetParameterValue(L"prm_BusyStatus", _variant_t((long)pEvent->GetBusyStatus()));
m_pcmdAddEvent->SetParameterValue(L"prm_ImportanceLevel", _variant_t((long)pEvent->GetImportance()));
m_pcmdAddEvent->SetParameterValue(L"prm_LabelID", _variant_t((long)pEvent->GetLabelID()));
m_pcmdAddEvent->SetParameterValue(L"prm_RecurrencePatternID", _variant_t((long)pEvent->GetRecurrencePatternID()));
m_pcmdAddEvent->SetParameterValue(L"prm_ScheduleID", _variant_t((long)pEvent->GetScheduleID()));
_variant_t vtIsRecurrenceExceptionDeleted = (long)(pEvent->IsRExceptionDeleted() ? 1 : 0);
m_pcmdAddEvent->SetParameterValue(L"prm_IsRecurrenceExceptionDeleted", vtIsRecurrenceExceptionDeleted);
m_pcmdAddEvent->SetParameterValue(L"prm_RExceptionStartTimeOrig", DATE2VAR(pEvent->GetRException_StartTimeOrig()) );
m_pcmdAddEvent->SetParameterValue(L"prm_RExceptionEndTimeOrig", DATE2VAR(pEvent->GetRException_EndTimeOrig()) );
_variant_t vtIsMeeting = (long)(pEvent->IsMeeting() ? 1 : 0);
m_pcmdAddEvent->SetParameterValue(L"prm_IsMeeting", vtIsMeeting);
_variant_t vtIsPrivate = (long)(pEvent->IsPrivate() ? 1 : 0);
m_pcmdAddEvent->SetParameterValue(L"prm_IsPrivate", vtIsPrivate);
_variant_t vtIsReminder = (long)(pEvent->IsReminder() ? 1 : 0);
m_pcmdAddEvent->SetParameterValue(L"prm_IsReminder", vtIsReminder);
m_pcmdAddEvent->SetParameterValue(L"prm_ReminderMinutesBeforeStart", _variant_t((long)pEvent->GetReminderMinutesBeforeStart()));
if (pEvent->GetCustomProperties())
{
// update CustomIcons
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_IconsIDs);
if (pEvent->GetCustomIcons() && pEvent->GetCustomIcons()->GetSize())
{
CString strArray = pEvent->GetCustomIcons()->SaveToString();
VERIFY(pEvent->GetCustomProperties()->SetProperty(cszEventCustProp_IconsIDs, STRING2VAR(strArray)));
}
// update Categories
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_CategoryIDs);
if (pEvent->GetCategories() && pEvent->GetCategories()->GetSize())
{
CString strArray = pEvent->GetCategories()->SaveToString();
VERIFY(pEvent->GetCustomProperties()->SetProperty(cszEventCustProp_CategoryIDs, STRING2VAR(strArray)));
}
// Save CustomProperties
pEvent->GetCustomProperties()->SaveToXML(strData);
// remove temporary data
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_IconsIDs);
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_CategoryIDs);
}
m_pcmdAddEvent->SetParameterValue(L"prm_CustomPropertiesXMLData", STRING2VAR(strData));
m_pcmdAddEvent->Execute();
// get event ID
m_pcmdGetLastID->SetSQLString(L"SELECT MAX(EventID) AS NewEventID FROM Event");
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetLastID->Execute();
ASSERT(ptrDataRS != NULL);
if (ptrDataRS)
{
ASSERT(!ptrDataRS->bEOF);
if (!ptrDataRS->bEOF)
{
rdwNewEventID = (DWORD)(long)ptrDataRS->Fields->GetItem(L"NewEventID")->Value;
}
}
ptrDataRS->Close();
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::_AddEvent()"));
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::DoDelete_Event(CXTPCalendarEvent* pEvent)
{
if (!IsOpen())
{
return FALSE;
}
if (!m_pcmdDelEvent || !pEvent)
{
ASSERT(FALSE);
return FALSE;
}
DWORD dwEventID = pEvent->GetEventID();
ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
m_pcmdDelEvent->SetParameterValue(L"EventID", _variant_t((long)dwEventID));
m_pcmdDelEvent->Execute();
return TRUE;
}
BOOL CXTPCalendarDatabaseDataProvider::DoUpdate_Event(CXTPCalendarEvent* pEvent)
{
if (!IsOpen())
{
return FALSE;
}
if (!pEvent || !m_pcmdUpdEvent)
{
ASSERT(FALSE);
return FALSE;
}
COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
pEvent->SetLastModificationTime(dtNow);
DWORD dwEventID = pEvent->GetEventID();
ASSERT(dwEventID != XTP_CALENDAR_UNKNOWN_EVENT_ID);
//===========================================================================
try
{
// Update Event properties
m_pcmdUpdEvent->SetParameterValue(L"prm_StartDateTime", DATE2VAR(pEvent->GetStartTime()));
m_pcmdUpdEvent->SetParameterValue(L"prm_EndDateTime", DATE2VAR(pEvent->GetEndTime()));
m_pcmdUpdEvent->SetParameterValue(L"prm_RecurrenceState", _variant_t((long)pEvent->GetRecurrenceState()));
_variant_t vtIsAllDayEvent((long)0);
if (pEvent->IsAllDayEvent())
vtIsAllDayEvent = _variant_t((long)1);
m_pcmdUpdEvent->SetParameterValue(L"prm_IsAllDayEvent", vtIsAllDayEvent);
CString strData = pEvent->GetSubject();
m_pcmdUpdEvent->SetParameterValue(L"prm_Subject", STRING2VAR(strData));
strData = pEvent->GetLocation();
m_pcmdUpdEvent->SetParameterValue(L"prm_Location", STRING2VAR(strData));
strData = pEvent->GetReminderSoundFile();
m_pcmdUpdEvent->SetParameterValue(L"prm_RemainderSoundFile", STRING2VAR(strData));
strData = pEvent->GetBody();
m_pcmdUpdEvent->SetParameterValue(L"prm_Body", STRING2VAR(strData));
m_pcmdUpdEvent->SetParameterValue(L"prm_Created", DATE2VAR(pEvent->GetCreationTime()));
m_pcmdUpdEvent->SetParameterValue(L"prm_Modified", DATE2VAR(pEvent->GetLastModificationTime()));
m_pcmdUpdEvent->SetParameterValue(L"prm_BusyStatus", _variant_t((long)pEvent->GetBusyStatus()));
m_pcmdUpdEvent->SetParameterValue(L"prm_ImportanceLevel", _variant_t((long)pEvent->GetImportance()));
m_pcmdUpdEvent->SetParameterValue(L"prm_LabelID", _variant_t((long)pEvent->GetLabelID()));
m_pcmdUpdEvent->SetParameterValue(L"prm_RecurrencePatternID", _variant_t((long)pEvent->GetRecurrencePatternID()));
m_pcmdUpdEvent->SetParameterValue(L"prm_ScheduleID", _variant_t((long)pEvent->GetScheduleID()));
_variant_t vtIsRecurrenceExceptionDeleted = (long)(pEvent->IsRExceptionDeleted() ? 1 : 0);
m_pcmdUpdEvent->SetParameterValue(L"prm_IsRecurrenceExceptionDeleted", vtIsRecurrenceExceptionDeleted);
m_pcmdUpdEvent->SetParameterValue(L"prm_RExceptionStartTimeOrig", DATE2VAR(pEvent->GetRException_StartTimeOrig()) );
m_pcmdUpdEvent->SetParameterValue(L"prm_RExceptionEndTimeOrig", DATE2VAR(pEvent->GetRException_EndTimeOrig()) );
_variant_t vtIsMeeting = (long)(pEvent->IsMeeting() ? 1 : 0);
m_pcmdUpdEvent->SetParameterValue(L"prm_IsMeeting", vtIsMeeting);
_variant_t vtIsPrivate = (long)(pEvent->IsPrivate() ? 1 : 0);
m_pcmdUpdEvent->SetParameterValue(L"prm_IsPrivate", vtIsPrivate);
_variant_t vtIsReminder = (long)(pEvent->IsReminder() ? 1 : 0);
m_pcmdUpdEvent->SetParameterValue(L"prm_IsReminder", vtIsReminder);
m_pcmdUpdEvent->SetParameterValue(L"prm_ReminderMinutesBeforeStart", _variant_t((long)pEvent->GetReminderMinutesBeforeStart()));
if (pEvent->GetCustomProperties())
{
// update CustomIcons
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_IconsIDs);
if (pEvent->GetCustomIcons() && pEvent->GetCustomIcons()->GetSize())
{
CString strArray = pEvent->GetCustomIcons()->SaveToString();
VERIFY(pEvent->GetCustomProperties()->SetProperty(cszEventCustProp_IconsIDs, STRING2VAR(strArray)));
}
// update Categories
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_CategoryIDs);
if (pEvent->GetCategories() && pEvent->GetCategories()->GetSize())
{
CString strArray = pEvent->GetCategories()->SaveToString();
VERIFY(pEvent->GetCustomProperties()->SetProperty(cszEventCustProp_CategoryIDs, STRING2VAR(strArray)));
}
// Save CustomProperties
pEvent->GetCustomProperties()->SaveToXML(strData);
// remove temporary data
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_IconsIDs);
pEvent->GetCustomProperties()->RemoveProperty(cszEventCustProp_CategoryIDs);
}
m_pcmdUpdEvent->SetParameterValue(L"prm_CustomPropertiesXMLData", STRING2VAR(strData));
//"EventID"
m_pcmdUpdEvent->SetParameterValue(L"prm_EventID", _variant_t((long)dwEventID));
m_pcmdUpdEvent->Execute();
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::UpdateEvent(ID = %d)"), dwEventID);
return FALSE;
}
// ------------------- RecurrencePattern processing -----------------------------
CXTPCalendarRecurrencePatternPtr CXTPCalendarDatabaseDataProvider::DoRead_RPattern(DWORD dwPatternID)
{
if (!IsOpen())
{
return NULL;
}
if (!m_pcmdGetRPattern)
{
ASSERT(FALSE);
return NULL;
}
try
{
m_pcmdGetRPattern->SetParameterValue(L"RecurrencePatternID", _variant_t((long)dwPatternID));
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetRPattern->Execute();
// process recordset
if (ptrDataRS == NULL || ptrDataRS->bEOF)
{
return NULL;
}
//ChangePatternID(pPattern, dwPatternID);
CXTPCalendarRecurrencePatternPtr ptrPattern = CreateNewRecurrencePattern(dwPatternID);
ptrPattern->SetMasterEventID((DWORD)(long)ptrDataRS->Fields->GetItem(L"MasterEventID")->Value);
ptrPattern->SetStartTime((DATE)ptrDataRS->Fields->GetItem(L"StartDateTime")->Value);
ptrPattern->SetDurationMinutes((long)ptrDataRS->Fields->GetItem(L"Duration")->Value);
ptrPattern->SetPatternStartDate((DATE)ptrDataRS->Fields->GetItem(L"PatternStartDateTime")->Value);
int nUseEnd = _GetField<long>(ptrDataRS, L"UseEnd", xtpCalendarPatternEndNoDate);
if (nUseEnd == xtpCalendarPatternEndDate)
{
ptrPattern->SetPatternEndDate(_GetField<DATE>(ptrDataRS, L"PatternEndDateTime", 0));
}
else if (nUseEnd == xtpCalendarPatternEndAfterOccurrences)
{
ptrPattern->SetEndAfterOccurrences(_GetField<long>(ptrDataRS, L"EndAfterOccurrence", 1));
}
else if (nUseEnd == xtpCalendarPatternEndNoDate)
{
ptrPattern->SetNoEndDate();
}
XTP_CALENDAR_RECURRENCE_OPTIONS tmp_options;
if (!_GetRPatternOptions(ptrDataRS, &tmp_options))
{
ASSERT(FALSE);
ptrDataRS->Close();
return NULL;
}
ptrPattern->SetRecurrenceOptions(tmp_options);
if (ptrPattern->GetCustomProperties())
{
CString bstrPropsXMLData = _GetFieldString(ptrDataRS, L"CustomPropertiesXMLData");
ptrPattern->GetCustomProperties()->LoadFromXML(bstrPropsXMLData);
}
ptrDataRS->Close();
if (!_ReadRExceptions(ptrPattern))
{
ASSERT(FALSE);
return NULL;
}
return ptrPattern;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::ReadRPattern(ID = %d)"), dwPatternID);
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::_ReadRExceptions(CXTPCalendarRecurrencePattern* pPattern)
{
if (!IsOpen())
{
return FALSE;
}
if (!pPattern || !m_pcmdGetRExceptions)
{
ASSERT(FALSE);
return FALSE;
}
DWORD dwPatternID = pPattern->GetPatternID();
try
{
m_pcmdGetRExceptions->SetParameterValue(L"PatternID", (long)dwPatternID);
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetRExceptions->Execute();
if (ptrDataRS == NULL)
{
ASSERT(FALSE);
return FALSE;
}
// process recordset
while (!ptrDataRS->bEOF) //
{
CXTPCalendarEventPtr ptrEvent = _ReadEvent_common(ptrDataRS, TRUE);
if (!ptrEvent)
{
#ifdef _DEBUG
long nID = _GetField<long>(ptrDataRS, L"EventID", 0);
TRACE(_T("! Cannot Read Exception event. ID = %d"), nID);
#endif
ptrDataRS->MoveNext();
continue;
}
int nRState = _GetField<long>(ptrDataRS, L"RecurrenceState", xtpCalendarRecurrenceUnknown);
ASSERT(nRState == xtpCalendarRecurrenceException);
if (nRState == xtpCalendarRecurrenceException)
{
if (!ptrEvent->MakeAsRException(dwPatternID))
{
ASSERT(FALSE);
ptrDataRS->MoveNext();
continue;
}
ptrEvent->SetRExceptionDeleted(0 != _GetField<long>(ptrDataRS, L"IsRecurrenceExceptionDeleted", 1));
DATE dtStartOrig = _GetField<DATE>(ptrDataRS, L"RExceptionStartTimeOrig", INT_MAX);
DATE dtEndOrig = _GetField<DATE>(ptrDataRS, L"RExceptionEndTimeOrig", INT_MAX);
if (dtStartOrig != INT_MAX && dtEndOrig != INT_MAX)
{
ptrEvent->SetRException_StartTimeOrig(dtStartOrig);
ptrEvent->SetRException_EndTimeOrig(dtEndOrig);
VERIFY(pPattern->SetException(ptrEvent));
}
else
{
ASSERT(FALSE);
}
}
// next record
ptrDataRS->MoveNext();
}
ptrDataRS->Close();
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::ReadRExceptions(PatternID = %d)"), dwPatternID);
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::DoCreate_RPattern(CXTPCalendarRecurrencePattern* pPattern, DWORD& rdwNewPatternID)
{
if (!IsOpen())
{
return FALSE;
}
if (!pPattern || !m_pcmdAddRPattern)
{
return FALSE;
}
try
{
m_pcmdAddRPattern->SetParameterValue(L"prm_MasterEventID", _variant_t((long)pPattern->GetMasterEventID()));
m_pcmdAddRPattern->SetParameterValue(L"prm_PatternStartDateTime", DATE2VAR(pPattern->GetPatternStartDate()));
m_pcmdAddRPattern->SetParameterValue(L"prm_StartDateTime", DATE2VAR(pPattern->GetStartTime()));
m_pcmdAddRPattern->SetParameterValue(L"prm_Duration", _variant_t((long)pPattern->GetDurationMinutes()));
int nUseEnd = pPattern->GetUseEndMethod();
m_pcmdAddRPattern->SetParameterValue(L"prm_UseEnd", _variant_t((long)nUseEnd));
m_pcmdAddRPattern->SetParameterValue(L"prm_PatternEndDateTime", DATE2VAR((nUseEnd == xtpCalendarPatternEndDate) ? (DATE)pPattern->GetPatternEndDate() : (DATE)0));
m_pcmdAddRPattern->SetParameterValue(L"prm_EndAfterOccurrences", (long)pPattern->GetEndAfterOccurrences());
_SetRPatternOptions(m_pcmdAddRPattern, pPattern);
CString strData;
if (pPattern->GetCustomProperties())
pPattern->GetCustomProperties()->SaveToXML(strData);
m_pcmdAddRPattern->SetParameterValue(L"prm_CustomPropertiesXMLData", STRING2VAR(strData));
m_pcmdAddRPattern->Execute();
// get event ID
m_pcmdGetLastID->SetSQLString(L"SELECT MAX(RecurrencePatternID) AS NewRecurrencePatternID FROM RecurrencePattern");
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetLastID->Execute();
ASSERT(ptrDataRS != NULL);
if (ptrDataRS)
{
ASSERT(!ptrDataRS->bEOF);
if (!ptrDataRS->bEOF)
{
rdwNewPatternID = (DWORD)(long)ptrDataRS->Fields->GetItem(L"NewRecurrencePatternID")->Value;
}
ptrDataRS->Close();
}
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::AddRPattern()"));
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::DoDelete_RPattern(CXTPCalendarRecurrencePattern* pPattern)
{
if (!IsOpen())
{
return FALSE;
}
if (!m_pcmdDelRPattern || !pPattern)
{
ASSERT(FALSE);
return FALSE;
}
DWORD dwPatternID = pPattern->GetPatternID();
m_pcmdDelRPattern->SetParameterValue(L"RecurrencePatternID", _variant_t((long)dwPatternID));
m_pcmdDelRPattern->Execute();
//-------------------------------------------
m_pConnection->SendEvent(XTP_NC_CALENDARPATTERNWASDELETED, dwPatternID, 0);
return TRUE;
}
BOOL CXTPCalendarDatabaseDataProvider::DoUpdate_RPattern(CXTPCalendarRecurrencePattern* pPattern)
{
if (!IsOpen())
{
return FALSE;
}
if (!pPattern || !m_pcmdUpdRPattern)
{
ASSERT(FALSE);
return FALSE;
}
DWORD dwPatternID = pPattern->GetPatternID();
//-------------------------------------
m_pcmdUpdRPattern->SetParameterValue(L"prm_MasterEventID", _variant_t((long)pPattern->GetMasterEventID()));
m_pcmdUpdRPattern->SetParameterValue(L"prm_StartDateTime", DATE2VAR(pPattern->GetStartTime()));
m_pcmdUpdRPattern->SetParameterValue(L"prm_Duration", DATE2VAR(pPattern->GetDurationMinutes()));
m_pcmdUpdRPattern->SetParameterValue(L"prm_PatternStartDateTime", DATE2VAR(pPattern->GetPatternStartDate()));
int nUseEnd = pPattern->GetUseEndMethod();
m_pcmdUpdRPattern->SetParameterValue(L"prm_UseEnd", _variant_t((long)nUseEnd));
m_pcmdUpdRPattern->SetParameterValue(L"prm_PatternEndDateTime", DATE2VAR((nUseEnd == xtpCalendarPatternEndDate) ? (DATE)pPattern->GetPatternEndDate() : (DATE)0));
m_pcmdUpdRPattern->SetParameterValue(L"prm_EndAfterOccurrences", (long)pPattern->GetEndAfterOccurrences());
if (!_SetRPatternOptions(m_pcmdUpdRPattern, pPattern))
{
ASSERT(FALSE);
return FALSE;
}
CString strData;
if (pPattern->GetCustomProperties())
pPattern->GetCustomProperties()->SaveToXML(strData);
m_pcmdUpdRPattern->SetParameterValue(L"prm_CustomPropertiesXMLData", STRING2VAR(strData));
m_pcmdUpdRPattern->SetParameterValue(L"prm_RecurrencePatternID", _variant_t((long)dwPatternID)); //
m_pcmdUpdRPattern->Execute();
//-------------------------------------
return TRUE;
}
BOOL CXTPCalendarDatabaseDataProvider::_GetRPatternOptions(XTPADODB::_Recordset* pRS, XTP_CALENDAR_RECURRENCE_OPTIONS* rROptions)
{
try
{
rROptions->m_nRecurrenceType = (XTPCalendarEventRecurrenceType)(long)pRS->Fields->GetItem(L"RecurrenceTypeID")->Value;
switch (rROptions->m_nRecurrenceType)
{
case xtpCalendarRecurrenceDaily : // = 1
rROptions->m_Daily.bEveryWeekDayOnly = (long)pRS->Fields->GetItem(L"IsEveryWeekDay")->Value > 0;
if (rROptions->m_Daily.bEveryWeekDayOnly)
{
rROptions->m_Daily.nIntervalDays = 1;
}
else
{
rROptions->m_Daily.nIntervalDays = (long)pRS->Fields->GetItem(L"OccurrenceInterval")->Value;
}
break;
case xtpCalendarRecurrenceWeekly : // = 2,
rROptions->m_Weekly.nIntervalWeeks = (long)pRS->Fields->GetItem(L"OccurrenceInterval")->Value;
rROptions->m_Weekly.nDayOfWeekMask = (long)pRS->Fields->GetItem(L"DayOfWeekMask")->Value;
break;
case xtpCalendarRecurrenceMonthly : // = 3,
rROptions->m_Monthly.nIntervalMonths = (long)pRS->Fields->GetItem(L"OccurrenceInterval")->Value;
rROptions->m_Monthly.nDayOfMonth = (long)pRS->Fields->GetItem(L"DayOfMonth")->Value;
break;
case xtpCalendarRecurrenceMonthNth : // = 4,
rROptions->m_MonthNth.nIntervalMonths = (long)pRS->Fields->GetItem(L"OccurrenceInterval")->Value;
rROptions->m_MonthNth.nWhichDay = (long)pRS->Fields->GetItem(L"DayOccurrenceTypeID")->Value;
rROptions->m_MonthNth.nWhichDayMask = (long)pRS->Fields->GetItem(L"DayMask")->Value;
break;
case xtpCalendarRecurrenceYearly : // = 5,
rROptions->m_Yearly.nMonthOfYear = (long)pRS->Fields->GetItem(L"MonthOfYear")->Value;
rROptions->m_Yearly.nDayOfMonth = (long)pRS->Fields->GetItem(L"DayOfMonth")->Value;
break;
case xtpCalendarRecurrenceYearNth : // = 6,
rROptions->m_YearNth.nWhichDay = (long)pRS->Fields->GetItem(L"DayOccurrenceTypeID")->Value;
rROptions->m_YearNth.nWhichDayMask = (long)pRS->Fields->GetItem(L"DayMask")->Value;
rROptions->m_YearNth.nMonthOfYear = (long)pRS->Fields->GetItem(L"MonthOfYear")->Value;
break;
default:
ASSERT(FALSE);
return FALSE;
}
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::GetRPatternOptions()"));
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::_SetRPatternOptions(CXTPCalendarDatabaseDataProvider::CADOCommand* pCmd, CXTPCalendarRecurrencePattern* pPattern)
{
try
{
int nRecurrenceTypeID = pPattern->GetRecurrenceType();
pCmd->SetParameterValue(L"prm_RecurrenceTypeID", _variant_t((long)nRecurrenceTypeID));
XTP_CALENDAR_RECURRENCE_OPTIONS pROptions = pPattern->GetRecurrenceOptions();
switch (nRecurrenceTypeID)
{
case xtpCalendarRecurrenceDaily : // = 1
if (pROptions.m_Daily.bEveryWeekDayOnly)
{
pCmd->SetParameterValue(L"prm_IsEveryWeekDay", _variant_t((long)1));
pCmd->SetParameterValue(L"prm_OccurrenceInterval", _variant_t((long)0));
}
else
{
pCmd->SetParameterValue(L"prm_IsEveryWeekDay", _variant_t((long)0));
pCmd->SetParameterValue(L"prm_OccurrenceInterval", _variant_t((long)pROptions.m_Daily.nIntervalDays));
}
break;
case xtpCalendarRecurrenceWeekly : // = 2,
pCmd->SetParameterValue(L"prm_OccurrenceInterval", _variant_t((long)pROptions.m_Weekly.nIntervalWeeks));
pCmd->SetParameterValue(L"prm_DayOfWeekMask", _variant_t((long)pROptions.m_Weekly.nDayOfWeekMask));
break;
case xtpCalendarRecurrenceMonthly : // = 3,
pCmd->SetParameterValue(L"prm_OccurrenceInterval", _variant_t((long)pROptions.m_Monthly.nIntervalMonths));
pCmd->SetParameterValue(L"prm_DayOfMonth", _variant_t((long)pROptions.m_Monthly.nDayOfMonth));
break;
case xtpCalendarRecurrenceMonthNth : // = 4,
pCmd->SetParameterValue(L"prm_OccurrenceInterval", _variant_t((long)pROptions.m_MonthNth.nIntervalMonths));
pCmd->SetParameterValue(L"prm_DayOccurrenceType", _variant_t((long)pROptions.m_MonthNth.nWhichDay));
pCmd->SetParameterValue(L"prm_DayMask", _variant_t((long)pROptions.m_MonthNth.nWhichDayMask));
break;
case xtpCalendarRecurrenceYearly : // = 5,
pCmd->SetParameterValue(L"prm_MonthOfYear", _variant_t((long)pROptions.m_Yearly.nMonthOfYear));
pCmd->SetParameterValue(L"prm_DayOfMonth", _variant_t((long)pROptions.m_Yearly.nDayOfMonth));
break;
case xtpCalendarRecurrenceYearNth : // = 6,
pCmd->SetParameterValue(L"prm_DayOccurrenceType", _variant_t((long)pROptions.m_YearNth.nWhichDay));
pCmd->SetParameterValue(L"prm_DayMask", _variant_t((long)pROptions.m_YearNth.nWhichDayMask));
pCmd->SetParameterValue(L"prm_MonthOfYear", _variant_t((long)pROptions.m_YearNth.nMonthOfYear));
break;
default:
ASSERT(FALSE);
return FALSE;
}
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::SetRPatternOptions()"));
return FALSE;
}
BOOL CXTPCalendarDatabaseDataProvider::SaveOptions(const CString& strOptionsData)
{
if (!IsOpen())
return FALSE;
if (!m_pcmdAddOptions || !m_pcmdRemoveAllOptions)
{
ASSERT(FALSE);
return FALSE;
}
try
{
// Remove old options records if necessary
if (!m_bTraceOptions)
{
m_pcmdRemoveAllOptions->Execute();
}
// Add new options record
COleDateTime dtNow = CXTPCalendarUtils::GetCurrentTime();
m_pcmdAddOptions->SetParameterValue(L"prm_SaveDateTime", DATE2VAR(dtNow));
m_pcmdAddOptions->SetParameterValue(L"prm_XMLData", STRING2VAR(strOptionsData));
m_pcmdAddOptions->Execute();
return TRUE;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{}
TRACE(_T("ERROR: Exception in CXTPCalendarDatabaseDataProvider::SaveOptions()"));
return FALSE;
}
CXTPCalendarEventPtr CXTPCalendarDatabaseDataProvider::DoRead_Event(DWORD dwEventID)
{
if (!IsOpen())
{
return NULL;
}
if (!m_pcmdGetEvent)
{
ASSERT(FALSE);
return NULL;
}
m_pcmdGetEvent->SetParameterValue(L"EventID", (long)dwEventID);
XTPADODB::_RecordsetPtr ptrDataRS = m_pcmdGetEvent->Execute();
if (ptrDataRS == NULL || ptrDataRS->bEOF)
{
return NULL;
}
CXTPCalendarEventPtr ptrEvent = _ReadEvent_common(ptrDataRS, FALSE);
if (!ptrEvent)
{
ptrDataRS->Close();
return NULL;
}
ptrDataRS->Close();
return ptrEvent;
}
void CXTPCalendarDatabaseDataProvider::DoRemoveAllEvents()
{
if (!IsOpen())
{
return;
}
if (!m_pcmdRemoveAllEvents || !m_pcmdRemoveAllRPatterns)
{
ASSERT(FALSE);
return;
}
m_pcmdRemoveAllEvents->Execute();
m_pcmdRemoveAllRPatterns->Execute();
}
void CXTPCalendarDatabaseDataProvider::CreateGetLastIDCommand()
{
m_pcmdGetLastID = new CADOCommand(m_pconnDb.GetInterfacePtr(), L"");
}
void CXTPCalendarDatabaseDataProvider::CreateAddEventCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"PARAMETERS \
prm_StartDateTime DateTime, \
prm_EndDateTime DateTime, \
prm_RecurrenceState Integer, \
prm_IsAllDayEvent Integer, \
prm_Subject TEXT, \
prm_Location TEXT, \
prm_RemainderSoundFile CHARACTER,\
prm_Body TEXT, \
prm_Created DateTime, \
prm_Modified DateTime, \
prm_BusyStatus Integer, \
prm_ImportanceLevel Integer, \
prm_LabelID Integer, \
prm_RecurrencePatternID Integer, \
prm_ScheduleID Integer, \
prm_IsRecurrenceExceptionDeleted Integer, \
prm_RExceptionStartTimeOrig DateTime, \
prm_RExceptionEndTimeOrig DateTime, \
prm_IsMeeting Integer, \
prm_IsPrivate Integer, \
prm_IsReminder Integer, \
prm_ReminderMinutesBeforeStart Integer, \
prm_CustomPropertiesXMLData TEXT; "
L" \
\
INSERT INTO Event ( \
\
StartDateTime, \
EndDateTime, \
RecurrenceState, \
IsAllDayEvent, \
Subject, \
Location, \
RemainderSoundFile,\
Body, \
Created, \
Modified, \
BusyStatus, \
ImportanceLevel, \
LabelID, \
RecurrencePatternID, \
ScheduleID, \
IsRecurrenceExceptionDeleted, \
RExceptionStartTimeOrig, \
RExceptionEndTimeOrig, \
IsMeeting, \
IsPrivate, \
IsReminder, \
ReminderMinutesBeforeStart, \
CustomPropertiesXMLData\
) \
VALUES ( \
prm_StartDateTime, \
prm_EndDateTime, \
prm_RecurrenceState, \
prm_IsAllDayEvent, \
prm_Subject, \
prm_Location, \
prm_RemainderSoundFile,\
prm_Body, \
prm_Created, \
prm_Modified, \
prm_BusyStatus, \
prm_ImportanceLevel, \
prm_LabelID, \
prm_RecurrencePatternID, \
prm_ScheduleID, \
prm_IsRecurrenceExceptionDeleted, \
prm_RExceptionStartTimeOrig, \
prm_RExceptionEndTimeOrig, \
prm_IsMeeting, \
prm_IsPrivate, \
prm_IsReminder, \
prm_ReminderMinutesBeforeStart, \
prm_CustomPropertiesXMLData\
) \
";
//---------------- sql statement body -------------------------
m_pcmdAddEvent = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
//m_pcmdAddEvent->CreateParameter(L"StartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
//m_pcmdAddEvent->CreateParameter(L"EndDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_StartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_EndDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_RecurrenceState", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_IsAllDayEvent", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_Subject", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdAddEvent->CreateParameter(L"prm_Location", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdAddEvent->CreateParameter(L"prm_RemainderSoundFile", XTPADODB::adBSTR, XTPADODB::adParamInput, 255, vtEmptyStr);
m_pcmdAddEvent->CreateParameter(L"prm_Body", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdAddEvent->CreateParameter(L"prm_Created", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_Modified", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_BusyStatus", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_ImportanceLevel", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_LabelID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_RecurrencePatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_ScheduleID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_IsRecurrenceExceptionDeleted", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_RExceptionStartTimeOrig", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_RExceptionEndTimeOrig", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_IsMeeting", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_IsPrivate", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_IsReminder", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_ReminderMinutesBeforeStart", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddEvent->CreateParameter(L"prm_CustomPropertiesXMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
}
void CXTPCalendarDatabaseDataProvider::CreateDelEventCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"DELETE FROM Event WHERE EventID = ?";
//---------------- sql statement body -------------------------
_variant_t vtEmpty((long)0);
m_pcmdDelEvent = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
m_pcmdDelEvent->CreateParameter(L"EventID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateUpdEventCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"PARAMETERS \
prm_StartDateTime DateTime, \
prm_EndDateTime DateTime, \
prm_RecurrenceState Integer, \
prm_IsAllDayEvent Integer, \
prm_Subject TEXT, \
prm_Location TEXT, \
prm_RemainderSoundFile CHARACTER,\
prm_Body TEXT, \
prm_Created DateTime, \
prm_Modified DateTime, \
prm_BusyStatus Integer, \
prm_ImportanceLevel Integer, \
prm_LabelID Integer, \
prm_RecurrencePatternID Integer, \
prm_ScheduleID Integer, \
prm_IsRecurrenceExceptionDeleted Integer, \
prm_RExceptionStartTimeOrig DateTime, \
prm_RExceptionEndTimeOrig DateTime, \
prm_IsMeeting Integer, \
prm_IsPrivate Integer, \
prm_IsReminder Integer, \
prm_ReminderMinutesBeforeStart Integer, \
prm_CustomPropertiesXMLData TEXT,\
prm_EventID Integer; "
L" \
UPDATE Event SET \
StartDateTime = prm_StartDateTime, \
EndDateTime = prm_EndDateTime, \
RecurrenceState = prm_RecurrenceState, \
IsAllDayEvent = prm_IsAllDayEvent, \
Subject = prm_Subject, \
Location = prm_Location, \
RemainderSoundFile = prm_RemainderSoundFile, \
Body = prm_Body, \
Created = prm_Created, \
Modified = prm_Modified, \
BusyStatus = prm_BusyStatus, \
ImportanceLevel = prm_ImportanceLevel, \
LabelID = prm_LabelID, \
RecurrencePatternID = prm_RecurrencePatternID, \
ScheduleID = prm_ScheduleID, \
"
L" \
IsRecurrenceExceptionDeleted = prm_IsRecurrenceExceptionDeleted, \
RExceptionStartTimeOrig = prm_RExceptionStartTimeOrig, \
RExceptionEndTimeOrig = prm_RExceptionEndTimeOrig, \
IsMeeting = prm_IsMeeting, \
IsPrivate = prm_IsPrivate, \
IsReminder = prm_IsReminder, \
ReminderMinutesBeforeStart = prm_ReminderMinutesBeforeStart, \
CustomPropertiesXMLData = prm_CustomPropertiesXMLData \
\
WHERE EventID = prm_EventID \
";
//---------------- sql statement body -------------------------
m_pcmdUpdEvent = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
m_pcmdUpdEvent->CreateParameter(L"prm_StartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_EndDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_RecurrenceState", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_IsAllDayEvent", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_Subject", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdEvent->CreateParameter(L"prm_Location", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdEvent->CreateParameter(L"prm_RemainderSoundFile", XTPADODB::adBSTR, XTPADODB::adParamInput, 255, vtEmptyStr);
m_pcmdUpdEvent->CreateParameter(L"prm_Body", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdEvent->CreateParameter(L"prm_Created", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_Modified", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_BusyStatus", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_ImportanceLevel", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_LabelID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_RecurrencePatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_ScheduleID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_IsRecurrenceExceptionDeleted", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_RExceptionStartTimeOrig", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_RExceptionEndTimeOrig", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_IsMeeting", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_IsPrivate", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_IsReminder", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_ReminderMinutesBeforeStart", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEvent->CreateParameter(L"prm_CustomPropertiesXMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdEvent->CreateParameter(L"prm_EventID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateUpdEventPatternIDCommand()
{
LPCWSTR strSqlText;
strSqlText =
//---------------- sql statement body -------------------------
L"UPDATE Event \
SET RecurrencePatternID = ? \
WHERE EventID = ? \
";
//---------------- sql statement body -------------------------
m_pcmdUpdEventPatternID = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
m_pcmdUpdEventPatternID->CreateParameter(L"RecurrencePatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdEventPatternID->CreateParameter(L"EventID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateGetDayEventCommand()
{
CString strSqlText;
strSqlText.Format(
//---------------- sql statement body -------------------------
_T("PARAMETERS prm_DayDate DateTime; \
SELECT EventID, \
StartDateTime, \
EndDateTime, \
RecurrenceState, \
IsAllDayEvent, \
Subject, \
Location, \
RemainderSoundFile,\
Body, \
Created, \
Modified, \
BusyStatus, \
ImportanceLevel, \
LabelID, \
RecurrencePatternID, \
ScheduleID, \
IsRecurrenceExceptionDeleted, \
IsMeeting, \
IsPrivate, \
IsReminder, \
ReminderMinutesBeforeStart, \
CustomPropertiesXMLData \
FROM Event \
WHERE DateValue(StartDateTime) <= DateValue(prm_DayDate) \
AND DateValue(prm_DayDate) <= DateValue(EndDateTime) \
AND (RecurrenceState = %d OR RecurrenceState = %d) \
"),
xtpCalendarRecurrenceNotRecurring, xtpCalendarRecurrenceMaster);
//---------------- sql statement body -------------------------
m_pcmdGetDayEvents = new CADOCommand(m_pconnDb.GetInterfacePtr(), XTP_CT2CW(strSqlText));
_variant_t vtEmpty((long)0);
m_pcmdGetDayEvents->CreateParameter(L"prm_DayDate", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateGetEventCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"SELECT EventID, \
StartDateTime, \
EndDateTime, \
RecurrenceState, \
IsAllDayEvent, \
Subject, \
Location, \
RemainderSoundFile,\
Body, \
Created, \
Modified, \
BusyStatus, \
ImportanceLevel, \
LabelID, \
RecurrencePatternID, \
ScheduleID, \
IsRecurrenceExceptionDeleted, \
IsMeeting, \
IsPrivate, \
IsReminder, \
ReminderMinutesBeforeStart, \
CustomPropertiesXMLData \
FROM Event \
WHERE EventID = ? \
";
//---------------- sql statement body -------------------------
_variant_t vtEmpty((long)0);
m_pcmdGetEvent = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
m_pcmdGetEvent->CreateParameter(L"EventID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateGetRExceptionsCommand()
{
CString strSqlText;
strSqlText.Format(
//---------------- sql statement body -------------------------
_T("SELECT EventID, \
StartDateTime, \
EndDateTime, \
RecurrenceState, \
IsAllDayEvent, \
Subject, \
Location, \
RemainderSoundFile,\
Body, \
Created, \
Modified, \
BusyStatus, \
ImportanceLevel, \
LabelID, \
RecurrencePatternID, \
ScheduleID, \
IsRecurrenceExceptionDeleted, \
RExceptionStartTimeOrig, \
RExceptionEndTimeOrig, \
IsMeeting, \
IsPrivate, \
IsReminder, \
ReminderMinutesBeforeStart, \
CustomPropertiesXMLData \
FROM Event \
WHERE RecurrencePatternID = ? \
AND RecurrenceState = %d \
"),
xtpCalendarRecurrenceException);
//---------------- sql statement body -------------------------
_variant_t vtEmpty((long)0);
m_pcmdGetRExceptions = new CADOCommand(m_pconnDb.GetInterfacePtr(), XTP_CT2CW(strSqlText));
m_pcmdGetRExceptions->CreateParameter(L"PatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateAddRPatternCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"PARAMETERS \
prm_PatternStartDateTime DateTime, \
prm_PatternEndDateTime DateTime, \
prm_StartDateTime DateTime, \
prm_Duration Integer, \
prm_EndAfterOccurrence Integer, \
prm_UseEnd Integer, \
prm_RecurrenceTypeID Integer, \
prm_OccurrenceInterval Integer, \
prm_DayOfWeekMask Integer, \
prm_DayOfMonth Integer, \
prm_MonthOfYear Integer, \
prm_IsEveryWeekDay Integer, \
prm_DayOccurrenceTypeID Integer, \
prm_DayMask Integer, \
prm_MasterEventID Integer, \
prm_CustomPropertiesXMLData TEXT; "
L" \
\
INSERT INTO RecurrencePattern( \
PatternStartDateTime, \
PatternEndDateTime, \
StartDateTime, \
Duration, \
EndAfterOccurrence, \
UseEnd, \
RecurrenceTypeID, \
OccurrenceInterval, \
DayOfWeekMask, \
DayOfMonth, \
MonthOfYear, \
IsEveryWeekDay, \
DayOccurrenceTypeID, \
DayMask, \
MasterEventID, \
CustomPropertiesXMLData\
) \
VALUES( \
prm_PatternStartDateTime, \
prm_PatternEndDateTime, \
prm_StartDateTime, \
prm_Duration, \
prm_EndAfterOccurrence, \
prm_UseEnd, \
prm_RecurrenceTypeID, \
prm_OccurrenceInterval, \
prm_DayOfWeekMask, \
prm_DayOfMonth, \
prm_MonthOfYear, \
prm_IsEveryWeekDay, \
prm_DayOccurrenceTypeID, \
prm_DayMask, \
prm_MasterEventID, \
prm_CustomPropertiesXMLData \
) \
";
//---------------- sql statement body -------------------------
m_pcmdAddRPattern = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
m_pcmdAddRPattern->CreateParameter(L"prm_PatternStartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_PatternEndDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_StartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_Duration", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_EndAfterOccurrences", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_UseEnd", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_RecurrenceTypeID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_OccurrenceInterval", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_DayOfWeekMask", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_DayOfMonth", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_MonthOfYear", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_IsEveryWeekDay", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_DayOccurrenceType", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_DayMask", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_MasterEventID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddRPattern->CreateParameter(L"prm_CustomPropertiesXMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
}
void CXTPCalendarDatabaseDataProvider::CreateDelRPatternCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"DELETE FROM RecurrencePattern WHERE RecurrencePatternID = ?";
//---------------- sql statement body -------------------------
_variant_t vtEmpty((long)0);
m_pcmdDelRPattern = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
m_pcmdDelRPattern->CreateParameter(L"RecurrencePatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateRemoveAllCommands()
{
LPCWSTR strSqlText;
strSqlText = L"DELETE FROM Event";
m_pcmdRemoveAllEvents = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
strSqlText = L"DELETE FROM RecurrencePattern";
m_pcmdRemoveAllRPatterns = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
strSqlText = L"DELETE FROM Options";
m_pcmdRemoveAllOptions = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
}
void CXTPCalendarDatabaseDataProvider::CreateUpdRPatternCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"PARAMETERS \
prm_PatternStartDateTime DateTime, \
prm_PatternEndDateTime DateTime, \
prm_StartDateTime DateTime, \
prm_Duration Integer, \
prm_EndAfterOccurrence Integer, \
prm_UseEnd Integer, \
prm_RecurrenceTypeID Integer, \
prm_OccurrenceInterval Integer, \
prm_DayOfWeekMask Integer, \
prm_DayOfMonth Integer, \
prm_MonthOfYear Integer, \
prm_IsEveryWeekDay Integer, \
prm_DayOccurrenceTypeID Integer, \
prm_DayMask Integer, \
prm_MasterEventID Integer, \
prm_CustomPropertiesXMLData TEXT, \
\
prm_RecurrencePatternID Integer; "
L" \
\
UPDATE RecurrencePattern SET \
PatternStartDateTime = prm_PatternStartDateTime, \
PatternEndDateTime = prm_PatternEndDateTime, \
StartDateTime = prm_StartDateTime, \
Duration = prm_Duration, \
EndAfterOccurrence = prm_EndAfterOccurrence, \
UseEnd = prm_UseEnd, \
RecurrenceTypeID = prm_RecurrenceTypeID, \
OccurrenceInterval = prm_OccurrenceInterval, \
DayOfWeekMask = prm_DayOfWeekMask, \
DayOfMonth = prm_DayOfMonth, \
MonthOfYear = prm_MonthOfYear, \
IsEveryWeekDay = prm_IsEveryWeekDay, \
DayOccurrenceTypeID = prm_DayOccurrenceTypeID, \
DayMask = prm_DayMask, \
MasterEventID = prm_MasterEventID, \
CustomPropertiesXMLData = prm_CustomPropertiesXMLData \
\
WHERE RecurrencePatternID = prm_RecurrencePatternID \
";
//---------------- sql statement body -------------------------
m_pcmdUpdRPattern = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
m_pcmdUpdRPattern->CreateParameter(L"prm_PatternStartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_PatternEndDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_StartDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_Duration", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_EndAfterOccurrences", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_UseEnd", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_RecurrenceTypeID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_OccurrenceInterval", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_DayOfWeekMask", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_DayOfMonth", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_MonthOfYear", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_IsEveryWeekDay", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_DayOccurrenceType", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_DayMask", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_MasterEventID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdUpdRPattern->CreateParameter(L"prm_CustomPropertiesXMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdRPattern->CreateParameter(L"prm_RecurrencePatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateGetRPatternCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"SELECT RecurrencePatternID, \
PatternStartDateTime, \
PatternEndDateTime, \
StartDateTime, \
Duration, \
EndAfterOccurrence, \
UseEnd, \
RecurrenceTypeID, \
OccurrenceInterval, \
DayOfWeekMask, \
DayOfMonth, \
MonthOfYear, \
IsEveryWeekDay, \
DayOccurrenceTypeID, \
DayMask, \
MasterEventID, \
CustomPropertiesXMLData \
\
FROM RecurrencePattern \
WHERE RecurrencePatternID = ? \
";
//---------------- sql statement body -------------------------
m_pcmdGetRPattern = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
m_pcmdGetRPattern->CreateParameter(L"RecurrencePatternID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateGetOptionsCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"SELECT TOP 1 OptionsID, SaveDateTime, XMLData \
FROM Options \
ORDER BY OptionsID DESC;";
//---------------- sql statement body -------------------------
m_pcmdGetOptions = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
}
void CXTPCalendarDatabaseDataProvider::CreateAddOptionsCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"PARAMETERS prm_SaveDateTime DateTime, prm_XMLData TEXT; \
INSERT INTO Options (SaveDateTime, XMLData) \
VALUES (prm_SaveDateTime, prm_XMLData) ";
//---------------- sql statement body -------------------------
m_pcmdAddOptions = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
m_pcmdAddOptions->CreateParameter(L"prm_SaveDateTime", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
m_pcmdAddOptions->CreateParameter(L"prm_XMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
}
void CXTPCalendarDatabaseDataProvider::CreateAddScheduleCommand()
{
LPCWSTR strSqlText =
//---------------- sql statement body -------------------------
L"PARAMETERS \
prm_Name CHARACTER, \
prm_CustomPropertiesXMLData TEXT, \
prm_Modified DateTime; \
\
INSERT INTO Schedules ( \
Name, \
CustomPropertiesXMLData, \
Modified) \
VALUES ( \
prm_Name, \
prm_CustomPropertiesXMLData, \
prm_Modified) ";
//---------------- sql statement body -------------------------
m_pcmdAddSchedule = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
m_pcmdAddSchedule->CreateParameter(L"prm_Name", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdAddSchedule->CreateParameter(L"prm_CustomPropertiesXMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdAddSchedule->CreateParameter(L"prm_Modified", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
}
void CXTPCalendarDatabaseDataProvider::CreateUpdScheduleCommand()
{
//---------------- sql statement body -------------------------
#ifdef _BUSINESS_MODEL_
LPCWSTR strSqlText =
L"PARAMETERS \
prm_ScheduleID Integer, \
prm_ScheduleSecurity Integer, \
prm_Name CHARACTER, \
prm_CustomPropertiesXMLData TEXT, \
prm_Modified DateTime;"
#else
LPCWSTR strSqlText =
L"PARAMETERS \
prm_ScheduleID Integer, \
prm_Name CHARACTER, \
prm_CustomPropertiesXMLData TEXT, \
prm_Modified DateTime;"
#endif
L" \
UPDATE Schedules SET \
Name = prm_Name, \
CustomPropertiesXMLData = prm_CustomPropertiesXMLData, \
Modified = prm_Modified \
\
WHERE ScheduleID = prm_ScheduleID \
";
//---------------- sql statement body -------------------------
m_pcmdUpdSchedule = new CADOCommand(m_pconnDb.GetInterfacePtr(), strSqlText);
_variant_t vtEmpty((long)0);
_variant_t vtEmptyStr(EMPTY_DB_STR);
m_pcmdUpdSchedule->CreateParameter(L"prm_ScheduleID", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
#ifdef _BUSINESS_MODEL_
m_pcmdUpdSchedule->CreateParameter(L"prm_ScheduleSecurity", XTPADODB::adInteger, XTPADODB::adParamInput, -1, vtEmpty);
#endif
m_pcmdUpdSchedule->CreateParameter(L"prm_Name", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdSchedule->CreateParameter(L"prm_CustomPropertiesXMLData", XTPADODB::adBSTR, XTPADODB::adParamInput, 0, vtEmptyStr);
m_pcmdUpdSchedule->CreateParameter(L"prm_Modified", XTPADODB::adDate, XTPADODB::adParamInput, -1, vtEmpty);
}
/////////////////////////////////////////////////////////////////////////////
// CADOCommand
CXTPCalendarDatabaseDataProvider::CADOCommand::CADOCommand(XTPADODB::_ConnectionPtr pConnection, LPCWSTR pcszSQLText)
{
m_pconnDb = NULL;
try
{
m_pcmdSQL.CreateInstance(__uuidof(XTPADODB::Command));
m_pcmdSQL->ActiveConnection = pConnection.GetInterfacePtr();
m_pcmdSQL->CommandText = pcszSQLText;
m_pconnDb = pConnection.GetInterfacePtr();
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
TRACE(_T("Unknown error in CADOCommand() \n"));
}
}
CXTPCalendarDatabaseDataProvider::CADOCommand::~CADOCommand()
{
m_pconnDb = NULL;
}
void CXTPCalendarDatabaseDataProvider::CADOCommand::SetSQLString(LPCWSTR pcszSQLText)
{
try
{
m_pcmdSQL->CommandText = pcszSQLText;
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
TRACE(_T("Unknown error in CADOCommand::SetSQLString() \n"));
}
}
void CXTPCalendarDatabaseDataProvider::CADOCommand::SetParameter(
XTPADODB::DataTypeEnum adDataType,
long nSize,
const _variant_t& vtValue)
{
CreateParameter(L"",
adDataType,
XTPADODB::adParamInput,
nSize,
vtValue);
}
void CXTPCalendarDatabaseDataProvider::CADOCommand::CreateParameter(
LPCWSTR pcszParamName,
XTPADODB::DataTypeEnum adDataType,
XTPADODB::ParameterDirectionEnum adDirection,
long nSize,
const _variant_t& vtValue)
{
XTPADODB::_ParameterPtr pParam = NULL;
try
{
pParam = m_pcmdSQL->CreateParameter(pcszParamName, adDataType, adDirection, nSize, vtValue);
m_pcmdSQL->Parameters->Append(pParam);
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch (...)
{
TRACE(_T("Unknown error in CreateParameter() \n"));
}
}
void CXTPCalendarDatabaseDataProvider::CADOCommand::SetParameterValue(LPCWSTR pcszParamName, const _variant_t& vtValue)
{
try
{
m_pcmdSQL->GetParameters()->GetItem(pcszParamName)->PutValue(vtValue);
}
catch (_com_error &e)
{
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
TRACE(_T("Unknown error in CADOCommand() \n"));
}
}
XTPADODB::_RecordsetPtr CXTPCalendarDatabaseDataProvider::CADOCommand::Execute()
{
XTPADODB::_RecordsetPtr pRecordSet = NULL;
try
{
pRecordSet = m_pcmdSQL->Execute(NULL, NULL, XTPADODB::adCmdText);
return pRecordSet;
}
catch (_com_error &e)
{
//ClearParams();
TRACE_ProviderError(m_pconnDb);
TRACE_ComError(e);
}
catch(...)
{
TRACE(_T("Unknown error in Execute() \n"));
}
ASSERT(FALSE);
return NULL;
}
void CXTPCalendarDatabaseDataProvider::CADOCommand::ClearParams()
{
long nParamCount = m_pcmdSQL->Parameters->Count;
for (long nParamCounter = 0; nParamCount > nParamCounter; nParamCounter++)
{
try
{
m_pcmdSQL->Parameters->Delete(_variant_t((long)nParamCounter));
}
catch(...)
{
TRACE(_T("Unknown error in ClearParams() \n"));
}
}
}