You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1216 lines
29 KiB
1216 lines
29 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
faxarchiveinner.h
|
|
|
|
Abstract:
|
|
|
|
Declaration and Implementation of Fax Archive Inner Template Class.
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG) May, 2000
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#ifndef __FAXARCHIVEINNER_H_
|
|
#define __FAXARCHIVEINNER_H_
|
|
|
|
#include "resource.h" // main symbols
|
|
#include "FaxCommon.h"
|
|
|
|
|
|
//
|
|
//================ FAX ARCHIVE INNER =========================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
class CFaxArchiveInner :
|
|
public IDispatchImpl<T, piid, &LIBID_FAXCOMEXLib>,
|
|
public CFaxInitInner
|
|
{
|
|
public:
|
|
CFaxArchiveInner() : CFaxInitInner(_T("FAX ARCHIVE INNER"))
|
|
{
|
|
m_bInitialized = FALSE;
|
|
}
|
|
|
|
virtual ~CFaxArchiveInner()
|
|
{};
|
|
|
|
STDMETHOD(get_SizeLow)(/*[out, retval]*/ long *plSizeLow);
|
|
STDMETHOD(get_SizeHigh)(/*[out, retval]*/ long *plSizeHigh);
|
|
STDMETHOD(get_UseArchive)(/*[out, retval]*/ VARIANT_BOOL *pbUseArchive);
|
|
STDMETHOD(put_UseArchive)(/*[in]*/ VARIANT_BOOL bUseArchive);
|
|
STDMETHOD(get_ArchiveFolder)(BSTR *pbstrArchiveFolder);
|
|
STDMETHOD(put_ArchiveFolder)(BSTR bstrArchiveFolder);
|
|
STDMETHOD(get_SizeQuotaWarning)(VARIANT_BOOL *pbSizeQuotaWarning);
|
|
STDMETHOD(put_SizeQuotaWarning)(VARIANT_BOOL bSizeQuotaWarning);
|
|
STDMETHOD(get_HighQuotaWaterMark)(long *plHighQuotaWaterMark);
|
|
STDMETHOD(put_HighQuotaWaterMark)(long lHighQuotaWaterMark);
|
|
STDMETHOD(get_LowQuotaWaterMark)(long *plLowQuotaWaterMark);
|
|
STDMETHOD(put_LowQuotaWaterMark)(long lLowQuotaWaterMark);
|
|
STDMETHOD(get_AgeLimit)(long *plAgeLimit);
|
|
STDMETHOD(put_AgeLimit)(long lAgeLimit);
|
|
STDMETHOD(Refresh)();
|
|
STDMETHOD(Save)();
|
|
STDMETHOD(GetMessage)(BSTR bstrMessageId, MsgIfc **ppFaxMessage);
|
|
STDMETHOD(GetMessages)(long lPrefetchSize, IteratorIfc **ppFaxMessageIterator);
|
|
|
|
private:
|
|
bool m_bInitialized;
|
|
|
|
VARIANT_BOOL m_bUseArchive;
|
|
CComBSTR m_bstrArchiveFolder;
|
|
VARIANT_BOOL m_bSizeQuotaWarning;
|
|
long m_lHighQuotaWaterMark;
|
|
long m_lLowQuotaWaterMark;
|
|
long m_lAgeLimit;
|
|
ULARGE_INTEGER m_uliSize;
|
|
};
|
|
|
|
//
|
|
//========================= REFRESH ====================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::Refresh(
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::Refresh
|
|
|
|
Routine description:
|
|
|
|
Retrieve Current Configuration of the Incoming / Outgoing Archive on Fax Server
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_ENTER (_T("CFaxArchiveInner::Refresh"), hr);
|
|
|
|
//
|
|
// Get Fax Server Handle
|
|
//
|
|
HANDLE hFaxHandle = NULL;
|
|
hr = GetFaxHandle(&hFaxHandle);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
|
|
CFaxPtr<FAX_ARCHIVE_CONFIG> pFaxArchiveConfig;
|
|
if ( 0 == ::FaxGetArchiveConfiguration(hFaxHandle, ArchiveType, &pFaxArchiveConfig))
|
|
{
|
|
//
|
|
// Failed to Get Archive Configuration
|
|
//
|
|
hr = Fax_HRESULT_FROM_WIN32(GetLastError());
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("::FaxGetArchiveConfiguration()"), hr);
|
|
return hr;
|
|
}
|
|
|
|
if (!pFaxArchiveConfig || pFaxArchiveConfig->dwSizeOfStruct != sizeof(FAX_ARCHIVE_CONFIG))
|
|
{
|
|
//
|
|
// Failed to Get Archive Configuration
|
|
//
|
|
hr = E_FAIL;
|
|
AtlReportError(*pcid, IDS_ERROR_OPERATION_FAILED, *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("Invalid pFaxArchiveConfig"), hr);
|
|
return hr;
|
|
}
|
|
|
|
m_bUseArchive = bool2VARIANT_BOOL(pFaxArchiveConfig->bUseArchive);
|
|
m_bSizeQuotaWarning = bool2VARIANT_BOOL(pFaxArchiveConfig->bSizeQuotaWarning);
|
|
m_lHighQuotaWaterMark = pFaxArchiveConfig->dwSizeQuotaHighWatermark;
|
|
m_lLowQuotaWaterMark = pFaxArchiveConfig->dwSizeQuotaLowWatermark;
|
|
m_lAgeLimit = pFaxArchiveConfig->dwAgeLimit;
|
|
m_uliSize.QuadPart = pFaxArchiveConfig->dwlArchiveSize;
|
|
|
|
m_bstrArchiveFolder = pFaxArchiveConfig->lpcstrFolder;
|
|
if (!m_bstrArchiveFolder && pFaxArchiveConfig->lpcstrFolder)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
AtlReportError(*pcid, IDS_ERROR_OUTOFMEMORY, *piid, hr);
|
|
CALL_FAIL(MEM_ERR, _T("CComBSTR& operator=()"), hr);
|
|
return hr;
|
|
}
|
|
|
|
m_bInitialized = TRUE;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//==================== USE ARCHIVE ====================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_UseArchive(
|
|
VARIANT_BOOL *pbUseArchive
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_UseArchive
|
|
|
|
Routine description:
|
|
|
|
Return Flag indicating whether or not to Archive the Fax Messages
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
pbUseArchive [out] - Ptr to the Place to put Current value of the Flag
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_UseArchive"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetVariantBool(pbUseArchive, m_bUseArchive);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>::
|
|
put_UseArchive(
|
|
VARIANT_BOOL bUseArchive
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::put_UseArchive
|
|
|
|
Routine description:
|
|
|
|
Set new Use Archive Flag
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
bUseArchive [in] - the new Value for the Use Archive Flag
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_ENTER (_T("CFaxArchiveInner::put_UseArchive"), hr, _T("%ld"), bUseArchive);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_bUseArchive = bUseArchive;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//==================== ARCHIVE FOLDER ====================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_ArchiveFolder(
|
|
BSTR *pbstrArchiveFolder
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_ArchiveFolder
|
|
|
|
Routine description:
|
|
|
|
return Archive Folder on Server
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
pbstrArchiveFolder [out] - the Archive Folder
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_ArchiveFolder"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetBstr(pbstrArchiveFolder, m_bstrArchiveFolder);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::put_ArchiveFolder (
|
|
BSTR bstrArchiveFolder
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::put_ArchiveFolder
|
|
|
|
Routine description:
|
|
|
|
Set Archive Folder
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
bstrArchiveFolder [in] - new Archive Folder on Server
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_ENTER (_T("CFaxArchiveInner::put_ArchiveFolder"), hr, _T("%s"), bstrArchiveFolder);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_bstrArchiveFolder = bstrArchiveFolder;
|
|
if (bstrArchiveFolder && !m_bstrArchiveFolder)
|
|
{
|
|
//
|
|
// Not enough memory
|
|
//
|
|
hr = E_OUTOFMEMORY;
|
|
AtlReportError(*pcid,
|
|
IDS_ERROR_OUTOFMEMORY,
|
|
*piid,
|
|
hr);
|
|
CALL_FAIL(MEM_ERR, _T("CComBSTR::operator="), hr);
|
|
return hr;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//==================== SIZE QUOTA WARNING ================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_SizeQuotaWarning(
|
|
VARIANT_BOOL *pbSizeQuotaWarning
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_SizeQuotaWarning
|
|
|
|
Routine description:
|
|
|
|
Return Flag indicating whether or not to issue event log warning when
|
|
watermarks are crossed
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
pbSizeQuotaWarning [out] - ptr to place where to put the Current value of the Flag
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_SizeQuotaWarning"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetVariantBool(pbSizeQuotaWarning, m_bSizeQuotaWarning);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::put_SizeQuotaWarning(
|
|
VARIANT_BOOL bSizeQuotaWarning
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::put_SizeQuotaWarning
|
|
|
|
Routine description:
|
|
|
|
Set new SizeQuotaWarning Flag
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
bSizeQuotaWarning [in] - the new Value for the SizeQuotaWarning Flag
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (_T("CFaxArchiveInner::put_SizeQuotaWarning"), hr, _T("%ld"), bSizeQuotaWarning);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_bSizeQuotaWarning = bSizeQuotaWarning;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//================= QUOTA WATER MARKS ===============================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_HighQuotaWaterMark(
|
|
long *plHighQuotaWaterMark
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_HighQuotaWaterMark
|
|
|
|
Routine description:
|
|
|
|
Return HighQuotaWaterMark
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
plHighQuotaWaterMark [out] - HighQuotaWaterMark
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_HighQuotaWaterMark"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetLong(plHighQuotaWaterMark , m_lHighQuotaWaterMark);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::put_HighQuotaWaterMark(
|
|
long lHighQuotaWaterMark
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::put_HighQuotaWaterMark
|
|
|
|
Routine description:
|
|
|
|
Set HighQuotaWaterMark
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
lHighQuotaWaterMark [in] - HighQuotaWaterMark to Set
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (_T("CFaxArchiveInner::put_HighQuotaWaterMark"), hr, _T("%ld"), lHighQuotaWaterMark);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_lHighQuotaWaterMark = lHighQuotaWaterMark;
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_LowQuotaWaterMark(
|
|
long *plLowQuotaWaterMark
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_LowQuotaWaterMark
|
|
|
|
Routine description:
|
|
|
|
Return LowQuotaWaterMark
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
plLowQuotaWaterMark [out] - LowQuotaWaterMark
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_LowQuotaWaterMark"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetLong(plLowQuotaWaterMark , m_lLowQuotaWaterMark);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::put_LowQuotaWaterMark(
|
|
long lLowQuotaWaterMark
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::put_LowQuotaWaterMark
|
|
|
|
Routine description:
|
|
|
|
Set LowQuotaWaterMark
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
lLowQuotaWaterMark [in] - LowQuotaWaterMark to Set
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (_T("CFaxArchiveInner::put_LowQuotaWaterMark"), hr, _T("%ld"), lLowQuotaWaterMark);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_lLowQuotaWaterMark = lLowQuotaWaterMark;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//================= AGE LIMIT ===============================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_AgeLimit(
|
|
long *plAgeLimit
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_AgeLimit
|
|
|
|
Routine description:
|
|
|
|
Return how long in days Fax Message is stored at Fax Server
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
plAgeLimit [out] - AgeLimit
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_AgeLimit"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetLong(plAgeLimit, m_lAgeLimit);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::put_AgeLimit(
|
|
long lAgeLimit
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::put_AgeLimit
|
|
|
|
Routine description:
|
|
|
|
Set AgeLimit
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
lAgeLimit [in] - AgeLimit to Set
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (_T("CFaxArchiveInner::put_AgeLimit"), hr, _T("%ld"), lAgeLimit);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
m_lAgeLimit = lAgeLimit;
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//================= SIZE ==============================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_SizeLow(
|
|
long *plSizeLow
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_SizeLow
|
|
|
|
Routine description:
|
|
|
|
Return Size in Bytes of the Archive
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), May, 2000
|
|
|
|
Arguments:
|
|
|
|
plSizeLow [out] - Ptr to the place to put the Size in
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_SizeLow"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetLong(plSizeLow, long(m_uliSize.LowPart));
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::get_SizeHigh(
|
|
long *plSizeHigh
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::get_SizeHigh
|
|
|
|
Routine description:
|
|
|
|
Return Size in Bytes of the Archive
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), May, 2000
|
|
|
|
Arguments:
|
|
|
|
plSizeHigh [out] - Ptr to the place to put the Size in
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::get_SizeHigh"), hr);
|
|
|
|
//
|
|
// Initialize before first use
|
|
//
|
|
if (!m_bInitialized)
|
|
{
|
|
hr = Refresh();
|
|
if (FAILED(hr))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
hr = GetLong(plSizeHigh, long(m_uliSize.HighPart));
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//========================= SAVE ====================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::Save(
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::Save
|
|
|
|
Routine description:
|
|
|
|
Save the Archive's Configuration
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), Apr, 2000
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
HANDLE hFaxHandle = NULL;
|
|
FAX_ARCHIVE_CONFIG FaxArchiveConfig;
|
|
|
|
DBG_ENTER (_T("CFaxArchiveInner::Save"), hr);
|
|
|
|
//
|
|
// Get Fax Server Handle
|
|
//
|
|
hr = GetFaxHandle(&hFaxHandle);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
|
|
if (hFaxHandle == NULL)
|
|
{
|
|
//
|
|
// Fax Server Is Not Connected
|
|
//
|
|
hr = E_HANDLE;
|
|
AtlReportError(*pcid,
|
|
IDS_ERROR_SERVER_NOT_CONNECTED,
|
|
*piid,
|
|
hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("hFaxHandle == NULL"), hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// FaxArchiveConfig.dwlArchiveSize is ignored for SetConfiguration()
|
|
//
|
|
FaxArchiveConfig.dwSizeOfStruct = sizeof(FAX_ARCHIVE_CONFIG);
|
|
|
|
FaxArchiveConfig.bUseArchive = VARIANT_BOOL2bool(m_bUseArchive);
|
|
FaxArchiveConfig.bSizeQuotaWarning = VARIANT_BOOL2bool(m_bSizeQuotaWarning);
|
|
FaxArchiveConfig.dwSizeQuotaHighWatermark = m_lHighQuotaWaterMark;
|
|
FaxArchiveConfig.dwSizeQuotaLowWatermark = m_lLowQuotaWaterMark;
|
|
FaxArchiveConfig.dwAgeLimit = m_lAgeLimit;
|
|
FaxArchiveConfig.lpcstrFolder = m_bstrArchiveFolder;
|
|
|
|
if ( 0 == ::FaxSetArchiveConfiguration(hFaxHandle, ArchiveType, &FaxArchiveConfig))
|
|
{
|
|
//
|
|
// Failed to Set Archive Configuration
|
|
//
|
|
hr = Fax_HRESULT_FROM_WIN32(GetLastError());
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("::FaxSetArchiveConfiguration()"), hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//=============== GET MESSAGE ========================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::GetMessage(
|
|
BSTR bstrMessageId,
|
|
MsgIfc **ppFaxMessage
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::GetMessage
|
|
|
|
Routine description:
|
|
|
|
Return Message by given Id
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), May, 2000
|
|
|
|
Arguments:
|
|
|
|
bstrMessageId [in] - Id of the Message to return
|
|
ppFaxMessage [out] - Ptr to the place to put the Message
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::GetMessage"), hr, _T("%s"), bstrMessageId);
|
|
|
|
//
|
|
// Check that we can write to the given pointer
|
|
//
|
|
if (::IsBadWritePtr(ppFaxMessage, sizeof(MsgIfc *)))
|
|
{
|
|
//
|
|
// Got Bad Return Pointer
|
|
//
|
|
hr = E_POINTER;
|
|
AtlReportError(*pcid, IDS_ERROR_INVALID_ARGUMENT, *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("::IsBadWritePtr"), hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Get Fax Server Handle
|
|
//
|
|
HANDLE hFaxHandle = NULL;
|
|
hr = GetFaxHandle(&hFaxHandle);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// convert Message Id that we've got to hexadecimal DWORDLONG
|
|
//
|
|
DWORDLONG dwlMsgId;
|
|
int iParsed = _stscanf (bstrMessageId, _T("%I64x"), &dwlMsgId);
|
|
if ( iParsed != 1)
|
|
{
|
|
//
|
|
// Failed to conver the number
|
|
//
|
|
hr = E_INVALIDARG;
|
|
CALL_FAIL(GENERAL_ERR, _T("_stscanf()"), hr);
|
|
AtlReportError(*pcid, IDS_ERROR_INVALIDMSGID, *piid, hr);
|
|
return hr;
|
|
}
|
|
|
|
CFaxPtr<FAX_MESSAGE> pFaxPtrMessage;
|
|
if (!FaxGetMessage(hFaxHandle, dwlMsgId, ArchiveType, &pFaxPtrMessage))
|
|
{
|
|
//
|
|
// Failed to retrieve the Message
|
|
//
|
|
hr = Fax_HRESULT_FROM_WIN32(GetLastError());
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("FaxGetMessage()"), hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Check that pFaxPtrMessage is valid
|
|
//
|
|
if (!pFaxPtrMessage || pFaxPtrMessage->dwSizeOfStruct != sizeof(FAX_MESSAGE))
|
|
{
|
|
//
|
|
// Failed to Get Message
|
|
//
|
|
hr = E_FAIL;
|
|
AtlReportError(*pcid, IDS_ERROR_OPERATION_FAILED, *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("Invalid pFaxMessage"), hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Create Message Object
|
|
//
|
|
CComPtr<MsgIfc> pTmpMessage;
|
|
hr = MsgType::Create(&pTmpMessage);
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// Failed to create the Message object
|
|
//
|
|
AtlReportError(*pcid, IDS_ERROR_OPERATION_FAILED, *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("MsgType::Create()"), hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Initialize the Message Object
|
|
//
|
|
hr = ((MsgType *)((MsgIfc *)pTmpMessage))->Init(pFaxPtrMessage, m_pIFaxServerInner);
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// Failed to Init the Message Object
|
|
//
|
|
AtlReportError(*pcid, IDS_ERROR_OPERATION_FAILED, *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("<casted>pTmpMessage->Init(pFaxMessage, m_pIFaxServerInner)"), hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Return Message Object to the Caller
|
|
//
|
|
hr = pTmpMessage.CopyTo(ppFaxMessage);
|
|
if (FAILED(hr))
|
|
{
|
|
//
|
|
// Failed to Copy Interface
|
|
//
|
|
AtlReportError(*pcid, IDS_ERROR_OPERATION_FAILED, *piid, hr);
|
|
CALL_FAIL(GENERAL_ERR, _T("CComPtr::CopyTo"), hr);
|
|
return hr;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
//========================= GET MESSAGES ==============================================
|
|
//
|
|
template <class T, const IID* piid, const CLSID* pcid, FAX_ENUM_MESSAGE_FOLDER ArchiveType,
|
|
class MsgIfc, class MsgType, class IteratorIfc, class IteratorType>
|
|
STDMETHODIMP
|
|
CFaxArchiveInner<T, piid, pcid, ArchiveType, MsgIfc, MsgType, IteratorIfc, IteratorType>
|
|
::GetMessages(
|
|
long lPrefetchSize,
|
|
IteratorIfc **ppFaxMessageIterator
|
|
)
|
|
/*++
|
|
|
|
Routine name : CFaxArchiveInner::GetMessages
|
|
|
|
Routine description:
|
|
|
|
Return Iterator on Archive's Messages.
|
|
|
|
Author:
|
|
|
|
Iv Garber (IvG), May, 2000
|
|
|
|
Arguments:
|
|
|
|
lPrefetchSize [in] - Size of Prefetch Buffer for Messages.
|
|
ppFaxMessageIterator [out] - Ptr to place to put Iterator Object
|
|
|
|
Return Value:
|
|
|
|
Standard HRESULT code
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBG_ENTER (TEXT("CFaxArchiveInner::GetMessages"), hr);
|
|
|
|
CObjectHandler<IteratorType, IteratorIfc> objectCreator;
|
|
CComPtr<IteratorIfc> pObjectTmp;
|
|
hr = objectCreator.GetObject(&pObjectTmp, m_pIFaxServerInner);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
//
|
|
// Set object prefetch size to default value
|
|
//
|
|
hr = pObjectTmp->put_PrefetchSize(lPrefetchSize);
|
|
if (FAILED(hr))
|
|
{
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
//
|
|
// Object is successfully created and set - copy it back to caller
|
|
//
|
|
hr = pObjectTmp.CopyTo(ppFaxMessageIterator);
|
|
if (FAILED(hr))
|
|
{
|
|
CALL_FAIL(GENERAL_ERR, _T("CComPtr::CopyTo"), hr);
|
|
AtlReportError(*pcid, GetErrorMsgId(hr), *piid, hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
} // CFaxArchiveInner::GetMessages
|
|
|
|
#endif //__FAXARCHIVEINNER_H_
|