// XTPCalendarMAPIDataProvider.h: interface for the CXTPCalendarData 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
//
/////////////////////////////////////////////////////////////////////////////
//{{AFX_CODEJOCK_PRIVATE
#if !defined(_XTPCalendarMAPIDataProvider_H__)
#define _XTPCalendarMAPIDataProvider_H__
//}}AFX_CODEJOCK_PRIVATE
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CXTPCalendarRecurrencePattern;
class CXTPCalendarEventLabels;
class CXTPNotifyConnection;
//{{AFX_CODEJOCK_PRIVATE
// Common customizable properties
// DP props collection
static const LPCTSTR cszMAPIpropName_AppointmentMessageClass = _T("AppointmentMessageClass");
static const LPCTSTR cszMAPIpropVal_AppointmentMessageClass = _T("IPM.Appointment");
static const LPCTSTR cszMAPIpropName_OutlookInternalVersion = _T("OutlookInternalVersion");
static const int cnMAPIpropVal_OutlookInternalVersionDef = 115608;
static const LPCTSTR cszMAPIpropName_OutlookVersion = _T("OutlookVersion");
static const LPCTSTR cszMAPIpropVal_OutlookVersionDef = _T("11");
// event runtime custom properties
static const LPCTSTR cszMAPIpropVal_EntryID = _T("MAPIEntryID");
static const LPCTSTR cszMAPIpropVal_SearchKey = _T("MAPISearchKey");
// event customizable properties
// Event props collection
//static const LPCTSTR cszMAPIpropName_AppointmentIconIndex = _T("AppointmentIconIndex");
static const int cnMAPIpropVal_AppointmentIcon = 1024;
static const int cnMAPIpropVal_AppointmentIconRecurr = 1025;
// Connection string MAPI parameter names
static const LPCTSTR cszMAPIProfileName = _T("mapiProfileName");
static const LPCTSTR cszMAPIPassword = _T("mapiPassword");
static const LPCTSTR cszMAPIFlags = _T("mapiFlags");
//-------------------------------------------------------------------------
// Summary: Structure describes MAPI property ID, type, and guid.
//-------------------------------------------------------------------------
struct XTP_MAPI_PROP_NAME
{
ULONG m_ulID; // ID
ULONG m_ulType; // Type
GUID m_GuidPS; // Guid
//-------------------------------------------------------------------------
// Summary: Default constructor
//-------------------------------------------------------------------------
XTP_MAPI_PROP_NAME(ULONG ulID, ULONG ulType, const GUID& guidPS)
{
m_ulID = ulID;
m_ulType = ulType;
m_GuidPS = guidPS;
}
};
//===========================================================================
// Summary:
// Undocumented MAPI
// See also:
// http://support.microsoft.com/?kbid=171670
// http://www.cdolive.com/cdo10.htm
//===========================================================================
#define XTP_TAG_ID_MAPI_CALENDAR_FOLDER 0x36D00102 // Used to query for the EntryID of the calendar folder off of the root folder
//#define XTP_PS_MAPI_EVENT Guid( "0x0220060000000000C000000000000046") //CdoPropSetID1
//#define XTP_PS_MAPI_EVENT_GUID "{00062002-0000-0000-C000-000000000046}" // The GUID of the class of appointment item extended properties
//#define XTP_PS_MAPI_COMMON Guid( "0x0820060000000000C000000000000046") //CdoPropSetID4
//#define XTP_PS_MAPI_COMMON_GUID "{00062008-0000-0000-C000-000000000046}" // The GUID of the class of common Outlook extended properties
//#define XTP_PS_MAPI_AGGREGATE_GUID "{00020329-0000-0000-C000-000000000046}" // First introduced to support 'keywords' on calendar items
// The GUID of the class of appointment item extended properties
static const GUID xtpGUID_PS_MAPI_Event = {0x00062002,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
// The GUID of the class of common Outlook extended properties
static const GUID xtpGUID_PS_MAPI_Common = {0x00062008,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
//===========================================================================
#define XTP_PR_MAPI_EVENT_ICON_INDEX PROP_TAG(PT_LONG, 0x1080) // Event icon index
// PT_LONG - Busy status. See also XTPCalendarEventBusyStatus - note that enum values are the same as Outlook values
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_BusyStatus(0x8205, PT_LONG, xtpGUID_PS_MAPI_Event);
// PT_STRING - Event location string
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_Location(0x8208, PT_STRING8, xtpGUID_PS_MAPI_Event);
// PT_SYSTIME - Event start-time
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_StartTime(0x820D, PT_SYSTIME, xtpGUID_PS_MAPI_Event);
// PT_SYSTIME - Event end-time
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_EndTime(0x820E, PT_SYSTIME, xtpGUID_PS_MAPI_Event);
// PT_LONG - Event duration
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_Duration(0x8213, PT_LONG, xtpGUID_PS_MAPI_Event);
// PT_LONG - Event color
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_Color(0x8214, PT_LONG, xtpGUID_PS_MAPI_Event);
// PT_BOOLEAN - Is all day
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_AllDay(0x8215, PT_BOOLEAN, xtpGUID_PS_MAPI_Event);
// PT_LONG - Meeting status enumeration
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_MeetingStatus(0x8217, PT_LONG, xtpGUID_PS_MAPI_Event);
// PT_BINARY - Recurrence binary data
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_RecurrenceState(0x8216, PT_BINARY, xtpGUID_PS_MAPI_Event);
// PT_BOOLEAN - Whether event is recurring
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_IsRecuring(0x8223, PT_BOOLEAN, xtpGUID_PS_MAPI_Event);
// PT_SYSTIME - Recurrence base time
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_RecurrenceBase(0x8228, PT_SYSTIME, xtpGUID_PS_MAPI_Event);
// PT_LONG - Recurrence type. See also XTPCalendarEventRecurrenceType - note that enum values are the same as Outlook values
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_RecurrenceType(0x8231, PT_LONG, xtpGUID_PS_MAPI_Event);
// PT_TSTRING
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_RecurrencePattern(0x8232, PT_STRING8, xtpGUID_PS_MAPI_Event);
// PT_BINARY Event time zone binaries -- for recurrence events only
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_TimeZone(0x8233, PT_BINARY, xtpGUID_PS_MAPI_Event);
//#define XTP_PRID_MAPI_EVENT_TIMEZONE_DESCRIPTION 0x8234 // PT_TSTRING
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_TimeZoneDescription(0x8234, PT_STRING8, xtpGUID_PS_MAPI_Event);
//#define XTP_PRID_MAPI_EVENT_RECURRENCE_START 0x8235 // PT_SYSTIME
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_RecurrenceStart(0x8235, PT_SYSTIME, xtpGUID_PS_MAPI_Event);
//#define XTP_PRID_MAPI_EVENT_RECURRENCE_END 0x8236 // PT_SYSTIME
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_RecurrenceEnd(0x8236, PT_SYSTIME, xtpGUID_PS_MAPI_Event);
//#define XTP_PRID_MAPI_EVENT_RESPONSE_STATUS 0x8218 // PT_TSTRING
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_(0x8218, PT_STRING8, xtpGUID_PS_MAPI_Event);
//#define XTP_PRID_MAPI_EVENT_REPLY_TIME 0x8222 // PT_TSTRING
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_(, , xtpGUID_PS_MAPI_Event);
//#define XTP_PRID_MAPI_EVENT_ORGANIZER 0x822E // PT_TSTRING
//static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_(, , xtpGUID_PS_MAPI_Event);
// PT_LONG - Outlook Internal Version
static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_OutlookInternalVersion(0x8552, PT_LONG, xtpGUID_PS_MAPI_Common);
// PT_STRING - Outlook Version
static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_OutlookVersion(0x8554, PT_STRING8, xtpGUID_PS_MAPI_Common);
// PT_LONG - Reminder Minutes Before
static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_ReminderMinutesBefore(0x8501, PT_LONG, xtpGUID_PS_MAPI_Common);
// PT_SYSTIME - Reminder Date
static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_ReminderDate(0x8502, PT_SYSTIME, xtpGUID_PS_MAPI_Common);
// PT_BOOLEAN - Is reminder set
static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_ReminderSet(0x8503, PT_BOOLEAN, xtpGUID_PS_MAPI_Common);
// PT_BOOLEAN - Event private flag
static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_IsPrivate(0x8506, PT_BOOLEAN, xtpGUID_PS_MAPI_Common);
//#define XTP_PRID_MAPI_COMMON_CONTEXT_MENU_FLAGS 0x8510 // PT_LONG
//static const XTP_MAPI_PROP_NAME xtpMAPIpropCommon_(0x8510, PT_LONG, xtpGUID_PS_MAPI_Common);
// PT_STRING - Event custom properties XML string
static const XTP_MAPI_PROP_NAME xtpMAPIpropEvent_CustomProperties(0x8581, PT_STRING8, xtpGUID_PS_MAPI_Event);
/////////////////////////////////////////////////////////////////////////////
//===========================================================================
// Summary: MAPI recurrence type undocumented enum.
//===========================================================================
enum XTPCalendarMAPIRcType
{
xtpMAPIRcType_Unknown = 0, // Recurrence Type unknown.
xtpMAPIRcType_Daily = 0x200A, // Daily Recurrence
xtpMAPIRcType_Weekly = 0x200B, // Weekly Recurrence
xtpMAPIRcType_Monthly = 0x200C, // Monthly Recurrence
xtpMAPIRcType_Yearly = 0x200D, // Yearly Recurrence
};
//===========================================================================
// Summary: MAPI recurrence type undocumented enum - second version.
//===========================================================================
enum XTPCalendarMAPIRcType2
{
// xtpMAPIRcType_Unknown = -1,
xtpMAPIRcType2_First = 0, // First enum value
xtpMAPIRcType2_Daily = 0, // Daily Recurrence
xtpMAPIRcType2_Weekly = 1, // Weekly Recurrence
xtpMAPIRcType2_MonYearly = 2, // Monthly/Yearly Recurrence
xtpMAPIRcType2_MonYearly_Nth = 3, // Monthly/Yearly every Nth item
xtpMAPIRcType2_Last = 3, // Last enum value
};
//===========================================================================
// Summary: Describes recurrence end type
//===========================================================================
enum XTPCalendarMAPIRcEnd
{
xtpMAPIRcEnd_Date = 0x2021, // End by date
xtpMAPIRcEnd_Number = 0x2022, // End after a number of occurrences
xtpMAPIRcEnd_Never = 0x2023 // Never end
};
//===========================================================================
// Summary: Constants for parsing of changes of the
// single occurrence in recurrence data.
// Comment is the size of extra data
//===========================================================================
enum XTPCalendarMAPIRcExceptionData
{
xtpMAPIRcED_Subject = 0x001, // [w:buf-size][w:str-len][ascii-char: count=len]
xtpMAPIRcED_IsMeeting = 0x002, // [dw] - bool(0|1)
xtpMAPIRcED_ReminderTime = 0x004, // [dw] minutes before start
xtpMAPIRcED_IsReminder = 0x008, // [dw] - bool(0|1)
xtpMAPIRcED_Location = 0x010, // [w:buf-size][w:str-len][ascii-char: count=len]
xtpMAPIRcED_BusyStatus = 0x020, // [dw] - busy status [0..3] = (free, busy, tent, oof)
xtpMAPIRcED_Reserved = 0x040, // unknown flag from MAPI
xtpMAPIRcED_IsAllDay = 0x080, // [dw] - bool(0|1)
xtpMAPIRcED_Label = 0x100, // [dw] - label ID
};
//===========================================================================
// Summary: This structure is used by CDO/MAPI to store timezone information
// See also: TIME_ZONE_INFORMATION overview in platform SDK.
//===========================================================================
struct XTP_MAPI_TIME_ZONE_INFORMATION
{
LONG Bias; // Current bias for local time translation on this computer, in minutes.
LONG StandardBias; // Bias value to be used during local time translations that occur during standard time.
LONG DaylightBias; // Bias value to be used during local time translations that occur during daylight saving time.
WORD Reserved1; // Not used
SYSTEMTIME StandardDate; // A SYSTEMTIME structure that contains a date and local time when the transition from daylight saving time to standard time occurs on this operating system.
WORD Reserved2; // Not used
SYSTEMTIME DaylightDate; // A SYSTEMTIME structure that contains a date and local time when the transition from standard time to daylight saving time occurs on this operating system.
};
//===========================================================================
// Summary:
// This is an internal class which represents MAPI Binary data structure
// and implements main operations under it.
//===========================================================================
class CXTPMAPIBinary
{
public:
// Default constructor.
CXTPMAPIBinary();
// Construct an object from MAPI pointers.
CXTPMAPIBinary(ULONG cbEntryID, LPENTRYID lpEntryID);
// Copy constructor.
CXTPMAPIBinary(const CXTPMAPIBinary& eid);
// Destructor
virtual ~CXTPMAPIBinary();
// The operator= method sets this CXTPMAPIBinary object equal to the
// specified CXTPMAPIBinary object.
CXTPMAPIBinary& operator=(const CXTPMAPIBinary& eid);
// Returns a size of MAPI entry structure,
ULONG GetBinarySize() const;
// Returns a pointer to the MAPI EntryID binary data.
LPBYTE GetBinaryData() const;
// Initializes an object from MAPI pointers.
void Set(ULONG cbSize, LPBYTE lpData);
// Initializes an object from MAPI PropValue structure.
void Set(LPSPropValue pPropEntryID);
// Binary comparison of those objects.
static BOOL IsBinaryEqual(const CXTPMAPIBinary& eid1, const CXTPMAPIBinary& eid2);
#ifdef _DEBUG
void DebugPrint();
#endif
//private:
ULONG m_cb; // Bytes count in the MAPI structure.
CByteArray m_arBytes; // Binary storage for Entry ID data.
private:
friend class CXTPCalendarMAPIDataProvider;
friend class CXTP_ID_Collection;
};
// Define EventID to EntryID map association.
typedef CMap<DWORD, DWORD, CXTPMAPIBinary, CXTPMAPIBinary&> CMap_EventID_EntryIDIndex;
// Define EntryID to EventID map association.
typedef CMap<CXTPMAPIBinary, CXTPMAPIBinary&, DWORD, DWORD> CMap_EntryIDIndex_EventID;
// Define EventID's collection with fast search.
typedef CMap<DWORD, DWORD, BOOL, BOOL> CMap_EventIDs;
// Implements Hash method for MAPI Entry ID items.
template<> AFX_INLINE
UINT AFXAPI HashKey(CXTPMAPIBinary& key)
{
UINT nRes = 0;
for (UINT i = 0; (i < 4) && (key.m_cb > i); i++)
{
nRes *= 256;
nRes += key.m_arBytes.GetAt(i);
}
return nRes;
}
// Compare method helper for MAPI entry ID items
template<> AFX_INLINE BOOL AFXAPI CompareElements(
const CXTPMAPIBinary* lpt1, const CXTPMAPIBinary* lpt2)
{
return CXTPMAPIBinary::IsBinaryEqual(*lpt1, *lpt2);
}
//===========================================================================
// Summary:
// This internal class implements a collection of events' MAPI Entry ID's
// and events' XTP Event ID's with the possibility to quickly search for
// each other.
//===========================================================================
class CXTP_ID_Collection
{
public:
// Default constructor.
CXTP_ID_Collection();
// Lookup for Entry ID by corresponding EventID.
BOOL Lookup(const DWORD dwEventID, CXTPMAPIBinary& obEntryID);
// Lookup for EventID by corresponding EntryID.
BOOL Lookup(CXTPMAPIBinary& obEntryID, DWORD& dwEventID);
// Adds a pair EventID/EntryID into the collection.
BOOL Add(const DWORD dwEventID, CXTPMAPIBinary& obEntryID);
// Iterate all internal EventID's and look for them in the mapEntries
void FindMissing(CMap_EventIDs& mapExisting, CMap_EventIDs& mapMissed);
protected:
CMap_EventID_EntryIDIndex m_mapEventID; // index from EventID to EntryID
CMap_EntryIDIndex_EventID m_mapEntryID; // index from EntryID to EventID
};
//}}AFX_CODEJOCK_PRIVATE
//===========================================================================
// Summary:
// This class is the implementation of the XTPCalendarData abstract
// class which represents the data portion of the Calendar control.
// Remarks:
// This implementation uses Extended MAPI as the data source.
// The Data source stores all Events data and provides a way to retrieve
// and save CXTPCalendarEvent objects.
//
// To use CXTPCalendarMAPIDataProvider first construct an instance
// of CXTPCalendarMAPIDataProvider object then use Open() member function
// to establish connection to the data source and initialize the object.
// Class provides a number of functions to manipulate events and events
// related data. After finished working with the data source must call
// the Close() member function to close the connection and to de-initialize
// the object and free any unused resources.
//
// MAPI data provider automatically opens default message store and default
// user's calendar folder and reads all appointments there. MAPI data provider
// uses Memory Data Provider internally as a private cache.
// Also it uses a MAPI notifications mechanism in order to have MAPI
// appointments always updated. When event is updated in MAPI storage,
// it will be automatically reloaded in the data provider and updated on
// the screen. It also works in the same way reverse: when an event is
// updated in the Calendar control, it will be automatically updated in
// the MAPI storage.
//
// See Also: CXTPCalendarData, CXTPCalendarMemoryDataProvider
//===========================================================================
class _XTP_EXT_CLASS CXTPCalendarMAPIDataProvider : public CXTPCalendarData, public CXTPCalendarMAPIWrapper
{
//{{AFX_CODEJOCK_PRIVATE
DECLARE_DYNAMIC(CXTPCalendarMAPIDataProvider)
//}}AFX_CODEJOCK_PRIVATE
public:
//-----------------------------------------------------------------------
// Summary:
// Default constructor.
// Remarks:
// Constructs a CXTPCalendarMAPIDataProvider object. To establish a
// connection to a specified data source and initialize the object the
// Open() member function must be called immediately after construction.
// See Also: Open()
//-----------------------------------------------------------------------
CXTPCalendarMAPIDataProvider();
//-----------------------------------------------------------------------
// Summary:
// Default Destructor.
// Remarks:
// Handles all deallocation.
//-----------------------------------------------------------------------
virtual ~CXTPCalendarMAPIDataProvider();
//-----------------------------------------------------------------------
// Summary:
// Open user's message store, default calendar folder and reads all
// events there.
// Remarks:
// Call this member function to initialize a newly constructed
// CXTPCalendarMAPIDataProvider object.
// Data object must be created before you call Open.
// This method firstly initializes MAPI, login with specified user's
// credentials and then reads all appointments.
// Returns:
// TRUE is successful. FALSE otherwise.
//-----------------------------------------------------------------------
virtual BOOL Open();
//-----------------------------------------------------------------------
// Summary:
// For MAPI Data Provider this methods does the same sequence of
// actions as Open method.
// Returns:
// TRUE is successful. FALSE otherwise.
// See also:
// Open
//-----------------------------------------------------------------------
virtual BOOL Create();
//-----------------------------------------------------------------------
// Summary:
// For MAPI Data Provider this methods does nothing.
// Returns:
// TRUE if the operation is successful, FALSE else.
//-----------------------------------------------------------------------
virtual BOOL Save();
//-----------------------------------------------------------------------
// Summary:
// Call this member function to close the connection to a data source.
// Remarks:
// This method closes the connection to the MAPI data source and
// uninitializes MAPI libraries.
//-----------------------------------------------------------------------
virtual void Close();
//-----------------------------------------------------------------------
// Summary:
// Checks whether a connection to the MAPI data source is already opened.
// Returns:
// TRUE is connection is opened. FALSE otherwise.
// See also:
// Open
//-----------------------------------------------------------------------
virtual BOOL IsOpen() const;
protected:
//-----------------------------------------------------------------------
// Summary:
// Retrieve day events from memory cache.
// Parameters:
// dtDay - A specified day.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method works from memory cache.
// Returns:
// A collection of events for a specified day.
//-----------------------------------------------------------------------
virtual CXTPCalendarEventsPtr DoRetrieveDayEvents(COleDateTime dtDay);
//-----------------------------------------------------------------------
// Summary:
// Remove all events from the MAPI storage.
// Remarks:
// This method works with memory cache only and removes all data there.
//-----------------------------------------------------------------------
virtual void DoRemoveAllEvents();
//-----------------------------------------------------------------------
// Summary:
// Read event from the MAPI storage
// Parameters:
// dwEventID - Event ID of the read target.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method reads an event from the memory cache.
// Returns:
// A pointer to the created CXTPCalendarEvent object.
//-----------------------------------------------------------------------
virtual CXTPCalendarEventPtr DoRead_Event(DWORD dwEventID);
//-----------------------------------------------------------------------
// Summary:
// Read recurrence pattern from the MAPI storage
// Parameters:
// dwPatternID - Pattern ID of the read target.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method reads a recurrence pattern from the memory cache.
// Returns:
// A pointer to the created CXTPCalendarRecurrencePattern object.
//-----------------------------------------------------------------------
virtual CXTPCalendarRecurrencePatternPtr DoRead_RPattern(DWORD dwPatternID);
//-----------------------------------------------------------------------
// Summary:
// Creates a new appointment in the MAPI storage.
// Parameters:
// pEvent - Pointer to the CXTPCalendarEvent object which describes
// all data fields of a newly created appointment.
// rdwNewEventID - [out] EventID of a newly created record.
// Remarks:
// This method creates a new message of the appointment type in the
// MAPI data storage and saves all event properties there.
// Returns:
// TRUE if an appointment created successfully,
// FALSE in case of any errors during the process.
//-----------------------------------------------------------------------
virtual BOOL DoCreate_Event(CXTPCalendarEvent* pEvent, DWORD& rdwNewEventID);
//-----------------------------------------------------------------------
// Summary:
// Updates appointment properties in the MAPI storage.
// Parameters:
// pEvent - Pointer to the CXTPCalendarEvent object which describes
// all data fields of an appointment.
// Remarks:
// This method updates a corresponding MAPI appointment with
// properties from the specified event.
// Returns:
// TRUE if an appointment updated successfully,
// FALSE in case of any errors during the process.
//-----------------------------------------------------------------------
virtual BOOL DoUpdate_Event(CXTPCalendarEvent* pEvent);
//-----------------------------------------------------------------------
// Summary:
// Deletes an appointment from the MAPI storage.
// Parameters:
// pEvent - Pointer to the CXTPCalendarEvent object which describes
// all data fields of an appointment.
// Remarks:
// This method deletes a corresponding MAPI appointment from the
// MAPI storage.
// Returns:
// TRUE if an appointment deleted successfully,
// FALSE in case of any errors during the process.
//-----------------------------------------------------------------------
virtual BOOL DoDelete_Event(CXTPCalendarEvent* pEvent);
//-----------------------------------------------------------------------
// Summary:
// Creates a new recurrence pattern
// Parameters:
// pPattern - [in] Pointer to the CXTPCalendarRecurrencePattern
// object.
// rdwNewPatternID - [out] Pattern ID.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method just assigns rdwNewPatternID to the provided pattern ID..
// Returns:
// Always returns TRUE.
//-----------------------------------------------------------------------
virtual BOOL DoCreate_RPattern(CXTPCalendarRecurrencePattern* pPattern, DWORD& rdwNewPatternID);
//-----------------------------------------------------------------------
// Summary:
// Updates a recurrence pattern
// Parameters:
// pPattern - Pointer to the CXTPCalendarRecurrencePattern object.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method actually does nothing..
// Returns:
// Always returns TRUE.
//-----------------------------------------------------------------------
virtual BOOL DoUpdate_RPattern(CXTPCalendarRecurrencePattern* pPattern);
//-----------------------------------------------------------------------
// Summary:
// Deletes a recurrence pattern
// Parameters:
// pPattern - Pointer to the CXTPCalendarRecurrencePattern object.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method actually does nothing..
// Returns:
// Always returns TRUE.
//-----------------------------------------------------------------------
virtual BOOL DoDelete_RPattern(CXTPCalendarRecurrencePattern* pPattern);
//-----------------------------------------------------------------------
// Summary:
// Retrieves a collection of events expiring in the period from
// dtFrom during next spPeriod.
// Parameters:
// dtFrom - Start date and time of a specified period.
// spPeriod - A duration of a specified period.
// Remarks:
// As far as we are getting cache synchronized with the MAPI storage,
// this method actually works from memory cache.
// It is used by a reminders manager.
// Returns:
// A CXTPCalendarEvents pointer containing a collection of
// upcoming events.
// See Also:
// CXTPCalendarRemindersManager overview
//-----------------------------------------------------------------------
virtual CXTPCalendarEventsPtr DoGetUpcomingEvents(COleDateTime dtFrom, COleDateTimeSpan spPeriod);
//-----------------------------------------------------------------------
// Summary:
// This method implements Getting all events from the MAPI storage
// without generating recurrence occurrences.
// Remarks:
// Simple events are included as is.
// For the recurrence events only master events are included,
// recurrence occurrences are not generated.
// As far as we are getting cache synchronized with the MAPI storage,
// this method actually works from memory cache.
// Returns:
// A CXTPCalendarEvents pointer containing a collection of
// all events.
// See Also: GetAllEvents_raw()
//-----------------------------------------------------------------------
virtual CXTPCalendarEventsPtr DoGetAllEvents_raw();
protected:
//-----------------------------------------------------------------------
// Summary:
// This member function is used to retrieve parameters for MAPI session
// login. Default implementation try to read them from the connection
// string or return values for loging with default credentials.
// Parameters:
// rpszProfile - A reference to LPTSTR pointer to receive pointer
// with profile name string (or NULL).
// rpszPassword - A reference to LPTSTR pointer to receive pointer
// with password string (or NULL).
// ruFlags - A reference to FLAGS variable to receive loging
// flags.
//-----------------------------------------------------------------------
virtual void GetMAPILogonParams(LPTSTR& rpszProfile, LPTSTR& rpszPassword,
FLAGS& ruFlags);
//-----------------------------------------------------------------------
// Summary:
// This member function is used to retrieve parameters from the
// connection string.
// Parameters:
// lpszConnectionString - A pointer to the connection string.
// pcszParameterName - A pointer to the parameter name string.
// rstrValue - A reference to CString variable to receive
// parameter value.
// Returns:
// TRUE if parameter with specified name find, FALSe otherwise.
//-----------------------------------------------------------------------
static BOOL AFX_CDECL GetParameterValueFromConStr(LPCTSTR lpszConnectionString,
LPCTSTR pcszParameterName, CString& rstrValue);
//-----------------------------------------------------------------------
// Summary:
// This method is called by the calendar control framework when Time Zone is Changed.
// Remarks:
// The data provider implementation may use this method to adjust its data for
// a new timezone.
// Returns:
// TRUE if internal data changed and calendar must be re-populated, FALSE if this
// event is ignored (no data changed).
// Base implementation do nothing and returns FALSE.
// See Also:
// CXTPTopLevelWndMsgNotifier, XTP_WM_TIME_ZONE_CHANGED
//-----------------------------------------------------------------------
virtual BOOL OnTimeZoneChanged();
protected:
// Connection string items (for the next version)
//CString m_strProfileName; // Name of the MAPI profile
//CString m_strUsername; // Login name to this profile
//CString m_strPassword; // User's password for login to the profile.
//CString m_strMsgStoreGuid;// Message store
//CString m_strFolderGUID; // Folder with appointment items
//BOOL m_bShowFolderChooser;// Whether to choose a folder using a buit-in dialog.
//{{AFX_CODEJOCK_PRIVATE
//private:
CXTP_ID_Collection m_mapID; // A map object with ID's referencing each other...
// Compares eid1 and eid2.
// Returns TRUE if IDs are equal and FALSE otherwise.
BOOL Equal(const CXTPMAPIBinary& eid1, const CXTPMAPIBinary& eid2);
//private:
// Finds event SearchKey its MAPI EntryID.
CXTPMAPIBinary GetSearchKey(ULONG cbEntryID, LPENTRYID lpEntryID);
// Finds Calendar event ID by its MAPI SearchKey.
// Adds new event ID / SearchKey pair if not exists.
DWORD GetEventID(ULONG cbSearchKey, LPENTRYID lpSearchKey, BOOL bAddNew = FALSE);
// Finds MAPI EntryID of the event by its MAPI Search Key
CXTPMAPIBinary GetEntryID(CXTPMAPIBinary& eSearchKey);
// Calculates next unique EventID, which does not exists in ID's collection.
DWORD GetNextUniqueEventID(DWORD dwEventID = XTP_CALENDAR_UNKNOWN_EVENT_ID);
//private:
// Opens default MAPI Message Store.
static STDMETHODIMP OpenDefaultMessageStore(LPMAPISESSION lpMAPISession, LPMDB * lpMDB, CXTPCalendarMAPIDataProvider* pProvider);
// Opens default MAPI Inbox folder.
static STDMETHODIMP OpenInbox(LPMDB lpMDB, LPMAPIFOLDER *lpInboxFolder, LPMAPIFOLDER *lpCalendarFolder, CXTPCalendarMAPIDataProvider* pProvider);
//static LPSRestriction BuildDayRestriction(const COleDateTime dtDay);
static LPSRestriction BuildBinaryRestriction(ULONG cbSize, LPBYTE lpData, ULONG ulPropTag);
// Imports all events (by a restriction) to the events collection and returns it.
CXTPCalendarEventsPtr ImportAllEvents(LPSRestriction lpRestriction = NULL);
// Scans events table (by a restriction),
// adds new events into the specified collection,
// and deletes removed events from this collection.
// Returns: TRUE if ptrEvents collection was changed during the processing,
// FALSE if ptrEvents wasn't changed, what means that collections are equal.
//BOOL ImportNewEvents(CXTPCalendarEventsPtr ptrEvents, LPSRestriction lpRestriction = NULL);
BOOL ImportNewEvents();
// Creates and returns an Event object, imports all its known fields from lpRow.
CXTPCalendarEventPtr ImportEvent(LPSRow lpRow);
// Creates and returns an Event object, imports all its known fields by EntryID.
CXTPCalendarEventPtr ImportEvent(ULONG cbEntryID, LPENTRYID lpEntryID);
// Creates and returns an Event object, imports all its known fields from pMessage.
CXTPCalendarEventPtr ImportEvent(LPMESSAGE pMessage);
CXTPCalendarEventPtr ImportEvent_FromCalendarFolderOnly(ULONG cbEntryID, LPENTRYID lpEntryID);
// Import Recurrence structure from the binary arRCData into the associated
// recurrence pattern for pMasterEvent.
void ImportRecurrence(CXTPCalendarEvent* pMasterEvent, const CByteArray& arRCData);
// Updates MAPI event data from source Calendar Event structure.
BOOL UpdateMAPIEvent(LPMESSAGE pMessage, CXTPCalendarEvent* pEvent);
// Set Event global MAPI properties if those are not already exist.
void _SetMAPIEventGlobalPropsIfNeed(LPMESSAGE pMessage, CXTPCalendarEvent* pEvent);
void _SetEventRuntimeProps(CXTPCalendarCustomProperties* pEventProps, LPMESSAGE pMessage);
void _MoveMAPIEventRuntimeProps(CXTPCalendarCustomProperties* pDest, CXTPCalendarCustomProperties* pSrc);
HRESULT _getPropVal(LPMESSAGE pMessage, ULONG ulPropTag, CByteArray& rData);
CString _getPropVal_str(LPMESSAGE pMessage, ULONG ulPropTag);
int _getPropVal_int(LPMESSAGE pMessage, ULONG ulPropTag);
SYSTEMTIME _getPropVal_UtcTime(LPMESSAGE pMessage, ULONG ulPropTag);
CString _getPropVal_str(LPMESSAGE pMessage, const XTP_MAPI_PROP_NAME& propNameEx);
int _getPropVal_int(LPMESSAGE pMessage, const XTP_MAPI_PROP_NAME& propNameEx);
SYSTEMTIME _getPropVal_UtcTime(LPMESSAGE pMessage, const XTP_MAPI_PROP_NAME& propNameEx);
BOOL _setPropTagVal_int(LPMESSAGE pMessage, ULONG ulPropTag, int nValue);
BOOL _setPropTagVal_str(LPMESSAGE pMessage, ULONG ulPropTag, LPCTSTR pcszValue);
BOOL _setPropTagVal_UtcTime(LPMESSAGE pMessage, ULONG ulPropTag, const SYSTEMTIME& stTime);
BOOL _setPropTagVal_bin(LPMESSAGE pMessage, ULONG ulPropTag, const CByteArray& arData);
HRESULT _deletePropTag(LPMESSAGE pMessage, ULONG ulPropTag);
HRESULT _deletePropsTags(LPMESSAGE pMessage, CUIntArray& arPropsTags);
int GetEventGlobalPropVal_int(LPCTSTR pcszPropName, int nDefault);
CString GetEventGlobalPropVal_str(LPCTSTR pcszPropName, LPCTSTR pcszDefault);
static int _getSimpleMAPITypeSize(int nType);
static UINT _getStreamSize(IStream* pStream);
static LONG STDAPICALLTYPE MAPICallBack_OnNotify(LPVOID lpvContext,
ULONG cNotif,
LPNOTIFICATION lpNotif);
// This class implements a collection of property tags and their IDs
// with the possibility to quickly find each corresponding other.
class CMAPIPropIDMap
{
public:
CMAPIPropIDMap();
ULONG GetPropTagByID(LPMESSAGE pMessage, const XTP_MAPI_PROP_NAME& propNameEx);
ULONG GetPropIDByTag(LPMESSAGE pMessage, ULONG ulPropTag);
protected:
typedef CMap<ULONG, ULONG, ULONG, ULONG> CMapULONG;
// Read all properties existing in the pMessage
void _UpdateMaps(LPMESSAGE pMessage);
// Try Read requested property tag from the pMessage
ULONG _GetPropTagFromID_ex(LPMESSAGE pMessage, const XTP_MAPI_PROP_NAME& propNameEx);
CMapULONG m_mapPropID2Tag; // Map Property ID to Property Tag
CMapULONG m_mapPropTag2ID; // Map Property Tag to Property ID
//private:
CXTPCalendarMAPIDataProvider* m_pProvider; // MAPI Wrapper
friend class CXTPCalendarMAPIDataProvider;
};
CMAPIPropIDMap m_MapiHelper; // MAPI Properties ID/Tag helper
//private:
BOOL m_bMAPIInitialized; // MAPI library is initialized or not.
LPMAPISESSION m_lpMAPISession; // MAPI Session
LPMDB m_lpMDB; // MAPI message store
LPMAPIFOLDER m_lpCalendarFolder; // Calendar folder handler
CXTPMAPIBinary m_eidCalendarFolder; // Calendar folder Entry ID
ULONG m_ulMAPIConID0;
ULONG m_ulMAPIConID1;
LPMAPIADVISESINK m_lpAdviseSink;
LPMAPIADVISESINK m_lpAdviseSink_ThrSafe;
CXTPCalendarData* m_pMemDP;
private:
CString m_strProfile_tmp;
CString m_strPassword_tmp;
//}}AFX_CODEJOCK_PRIVATE
protected:
friend class CXTPCalendarMemDPInternal;
friend class CMAPIPropIDMap;
using CXTPCalendarData::SendNotification;
//=======================================================================
// Summary: Internal extension of the CXTPCalendarMemoryDataProvider
// used for handling all notifications.
//=======================================================================
class CXTPCalendarMemDPInternal : public CXTPCalendarMemoryDataProvider
{
CXTPCalendarData* m_pDPExternal; // External data provider.
public:
//-------------------------------------------------------------------
// Summary: Default constructor.
// Parameters:
// pDPExternal - Pointer to the external data provider to be
// initialized with.
//-------------------------------------------------------------------
CXTPCalendarMemDPInternal(CXTPCalendarData* pDPExternal);
//-------------------------------------------------------------------
// Summary:
// This member function sends a notification to all subscribers.
// Parameters:
// EventCode - A specific code identifying the event.
// wParam - First custom parameter. Depends on the event type.
// See specific event description for details.
// lParam - Second custom parameter. Depends on the event type.
// See specific event description for details.
//-------------------------------------------------------------------
virtual void SendNotification(XTP_NOTIFY_CODE EventCode, WPARAM wParam , LPARAM lParam);
};
};
/////////////////////////////////////////////////////////////////////////////
#endif // !defined(_XTPCalendarMAPIDataProvider_H__)