STDMETHODIMP InterfaceFetchAccounts::Add(IInterfaceFetchAccount **pVal)
{
try
{
if (!fetch_accounts_)
return GetAccessDenied();
if (!fetch_accounts_)
return authentication_->GetAccessDenied();
CComObject<InterfaceFetchAccount>* pIntFA = new CComObject<InterfaceFetchAccount>();
pIntFA->SetAuthentication(authentication_);
shared_ptr<HM::FetchAccount> pFA = shared_ptr<HM::FetchAccount>(new HM::FetchAccount);
pFA->SetAccountID(fetch_accounts_->GetAccountID());
pIntFA->AttachItem(pFA);
pIntFA->AttachParent(fetch_accounts_, false);
pIntFA->AddRef();
*pVal = pIntFA;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceSSLCertificates::get_Item(long Index, IInterfaceSSLCertificate **pVal)
{
try
{
if (!m_pSSLCertificates)
return GetAccessDenied();
CComObject<InterfaceSSLCertificate>* pInterfaceSSLCertificate = new CComObject<InterfaceSSLCertificate>();
pInterfaceSSLCertificate->SetAuthentication(m_pAuthentication);
shared_ptr<HM::SSLCertificate> pBA = m_pSSLCertificates->GetItem(Index);
if (!pBA)
return DISP_E_BADINDEX;
pInterfaceSSLCertificate->AttachItem(pBA);
pInterfaceSSLCertificate->AttachParent(m_pSSLCertificates, true);
pInterfaceSSLCertificate->AddRef();
*pVal = pInterfaceSSLCertificate;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceBlockedAttachments::get_ItemByDBID(long lDBID, IInterfaceBlockedAttachment **pVal)
{
try
{
if (!m_pBlockedAttachments)
return GetAccessDenied();
CComObject<InterfaceBlockedAttachment>* pInterfaceBlockedAttachment = new CComObject<InterfaceBlockedAttachment>();
pInterfaceBlockedAttachment->SetAuthentication(m_pAuthentication);
shared_ptr<HM::BlockedAttachment> pBA = m_pBlockedAttachments->GetItemByDBID(lDBID);
if (!pBA)
return DISP_E_BADINDEX;
pInterfaceBlockedAttachment->AttachItem(pBA);
pInterfaceBlockedAttachment->AttachParent(m_pBlockedAttachments, true);
pInterfaceBlockedAttachment->AddRef();
*pVal = pInterfaceBlockedAttachment;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceIMAPFolders::get_ItemByDBID(long DBID, IInterfaceIMAPFolder **pVal)
{
try
{
if (!m_pObject)
return GetAccessDenied();
CComObject<InterfaceIMAPFolder>* pIMAPFolderInt = new CComObject<InterfaceIMAPFolder>();
pIMAPFolderInt->SetAuthentication(m_pAuthentication);
shared_ptr<HM::IMAPFolder> pIMAPFolder = m_pObject->GetItemByDBID(DBID);
if (!pIMAPFolder)
return DISP_E_BADINDEX;
pIMAPFolderInt->Attach(pIMAPFolder);
pIMAPFolderInt->AttachParent(m_pObject, true);
pIMAPFolderInt->AddRef();
*pVal = pIMAPFolderInt;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceGreyListingWhiteAddresses::get_Item(long Index, IInterfaceGreyListingWhiteAddress **pVal)
{
try
{
if (!gl_white_addresses_)
return GetAccessDenied();
CComObject<InterfaceGreyListingWhiteAddress>* pInterfaceGreyListingWhiteAddress = new CComObject<InterfaceGreyListingWhiteAddress>();
pInterfaceGreyListingWhiteAddress->SetAuthentication(authentication_);
shared_ptr<HM::GreyListingWhiteAddress> pBA = gl_white_addresses_->GetItem(Index);
if (!pBA)
return DISP_E_BADINDEX;
pInterfaceGreyListingWhiteAddress->AttachItem(pBA);
pInterfaceGreyListingWhiteAddress->AttachParent(gl_white_addresses_, true);
pInterfaceGreyListingWhiteAddress->AddRef();
*pVal = pInterfaceGreyListingWhiteAddress;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceDistributionLists::Add(IInterfaceDistributionList **pVal)
{
try
{
if (!m_pDistributionLists)
return GetAccessDenied();
if (!m_pDistributionLists)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceDistributionList>* pList = new CComObject<InterfaceDistributionList>();
pList->SetAuthentication(m_pAuthentication);
shared_ptr<HM::DistributionList> pPersList = shared_ptr<HM::DistributionList>(new HM::DistributionList);
pPersList->SetDomainID(m_iDomainID);
pList->AttachItem(pPersList);
pList->AttachParent(m_pDistributionLists, false);
pList->AddRef();
*pVal = pList;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceFetchAccounts::get_Item(long lIndex, IInterfaceFetchAccount** pVal)
{
try
{
if (!m_pFetchAccounts)
return GetAccessDenied();
CComObject<InterfaceFetchAccount>* pInterfaceAccount = new CComObject<InterfaceFetchAccount>();
pInterfaceAccount->SetAuthentication(m_pAuthentication);
boost::shared_ptr<HM::FetchAccount> pFetchAccount = m_pFetchAccounts->GetItem(lIndex);
if (!pFetchAccount)
return DISP_E_BADINDEX;
pInterfaceAccount->AttachItem(pFetchAccount);
pInterfaceAccount->AttachParent(m_pFetchAccounts, true);
pInterfaceAccount->AddRef();
*pVal = pInterfaceAccount;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceAccounts::get_ItemByAddress(BSTR Address, IInterfaceAccount **pVal)
{
try
{
if (!m_pAccounts)
return GetAccessDenied();
CComObject<InterfaceAccount>* pAccountInt = new CComObject<InterfaceAccount>();
pAccountInt->SetAuthentication(m_pAuthentication);
shared_ptr<HM::Account> pAccount = m_pAccounts->GetItemByName(Address);
if (!pAccount)
return DISP_E_BADINDEX;
pAccountInt->AttachItem(pAccount);
pAccountInt->SetAuthentication(m_pAuthentication);
pAccountInt->AttachParent(m_pAccounts, true);
pAccountInt->AddRef();
*pVal = pAccountInt;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceAccounts::Add(IInterfaceAccount **pVal)
{
try
{
if (!m_pAccounts)
return GetAccessDenied();
if (!m_pAuthentication->GetIsDomainAdmin())
return m_pAuthentication->GetAccessDenied();
if (!m_pAccounts)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceAccount>* pAccountInterface = new CComObject<InterfaceAccount>();
pAccountInterface->SetAuthentication(m_pAuthentication);
shared_ptr<HM::Account> pAccount = shared_ptr<HM::Account>(new HM::Account);
pAccount->SetDomainID(m_iDomainID);
pAccountInterface->AttachItem(pAccount);
pAccountInterface->AttachParent(m_pAccounts, false);
pAccountInterface->SetAuthentication(m_pAuthentication);
pAccountInterface->AddRef();
*pVal = pAccountInterface;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceIMAPFolderPermissions::get_Item(long Index, IInterfaceIMAPFolderPermission **pVal)
{
try
{
if (!m_pACLPermissions)
return GetAccessDenied();
CComObject<InterfaceIMAPFolderPermission>* pACLPermission = new CComObject<InterfaceIMAPFolderPermission>();
pACLPermission->SetAuthentication(m_pAuthentication);
shared_ptr<HM::ACLPermission> pPersACLPermission = m_pACLPermissions->GetItem(Index);
if (!pPersACLPermission)
return DISP_E_BADINDEX;
pACLPermission->AttachItem(pPersACLPermission);
pACLPermission->AttachParent(m_pACLPermissions, true);
pACLPermission->AddRef();
*pVal = pACLPermission;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceIMAPFolderPermissions::Add(IInterfaceIMAPFolderPermission **pVal)
{
try
{
if (!m_pACLPermissions)
return GetAccessDenied();
if (!m_pAuthentication->GetIsDomainAdmin())
return m_pAuthentication->GetAccessDenied();
if (!m_pACLPermissions)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceIMAPFolderPermission>* pIntACLPermission = new CComObject<InterfaceIMAPFolderPermission>();
pIntACLPermission->SetAuthentication(m_pAuthentication);
shared_ptr<HM::ACLPermission> pACLPermission = shared_ptr<HM::ACLPermission>(new HM::ACLPermission);
pACLPermission->SetShareFolderID(m_pFolder->GetID());
pIntACLPermission->AttachItem(pACLPermission);
pIntACLPermission->AttachParent(m_pACLPermissions, false);
pIntACLPermission->AddRef();
*pVal = pIntACLPermission;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceRules::Add(IInterfaceRule** pVal)
{
try
{
if (!rules_)
return GetAccessDenied();
if (!rules_)
return authentication_->GetAccessDenied();
CComObject<InterfaceRule>* pIntDA = new CComObject<InterfaceRule>();
pIntDA->SetAuthentication(authentication_);
shared_ptr<HM::Rule> pDA = shared_ptr<HM::Rule>(new HM::Rule);
// Make sure that the new rule is
// added to the right account.
pDA->SetAccountID(rules_->GetAccountID());
pIntDA->AttachItem(pDA);
pIntDA->AttachParent(rules_, false);
pIntDA->AddRef();
*pVal = pIntDA;
return S_OK;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceRules::get_Item(long lIndex, IInterfaceRule** pVal)
{
try
{
if (!rules_)
return GetAccessDenied();
CComObject<InterfaceRule>* pInterfaceRule = new CComObject<InterfaceRule>();
pInterfaceRule->SetAuthentication(authentication_);
shared_ptr<HM::Rule> pRule = rules_->GetItem(lIndex);
if (!pRule)
return DISP_E_BADINDEX;
pInterfaceRule->AttachParent(rules_, true);
pInterfaceRule->AttachItem(pRule);
pInterfaceRule->AddRef();
*pVal = pInterfaceRule;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceFetchAccounts::get_ItemByDBID(long lDBID, IInterfaceFetchAccount** pVal)
{
try
{
if (!fetch_accounts_)
return GetAccessDenied();
CComObject<InterfaceFetchAccount>* pInterfaceAccount = new CComObject<InterfaceFetchAccount>();
pInterfaceAccount->SetAuthentication(authentication_);
shared_ptr<HM::FetchAccount> pFetchAccount = fetch_accounts_->GetItemByDBID(lDBID);
if (!pFetchAccount)
return DISP_E_BADINDEX;
pInterfaceAccount->AttachItem(pFetchAccount);
pInterfaceAccount->AttachParent(fetch_accounts_, true);
pInterfaceAccount->AddRef();
*pVal = pInterfaceAccount;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceSURBLServers::get_Item(long Index, IInterfaceSURBLServer **pVal)
{
try
{
if (!m_pSURBLServers)
return GetAccessDenied();
CComObject<InterfaceSURBLServer>* pInterfaceSURBLServer = new CComObject<InterfaceSURBLServer>();
pInterfaceSURBLServer->SetAuthentication(m_pAuthentication);
shared_ptr<HM::SURBLServer> pDNSBlackList = m_pSURBLServers->GetItem(Index);
if (!pDNSBlackList)
return DISP_E_BADINDEX;
pInterfaceSURBLServer->AttachItem(pDNSBlackList);
pInterfaceSURBLServer->AttachParent(m_pSURBLServers, true);
pInterfaceSURBLServer->AddRef();
*pVal = pInterfaceSURBLServer;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceSURBLServers::get_ItemByDBID(long lDBID, IInterfaceSURBLServer **pVal)
{
try
{
if (!surbl_servers_)
return GetAccessDenied();
CComObject<InterfaceSURBLServer>* pInterfaceSURBLServer = new CComObject<InterfaceSURBLServer>();
pInterfaceSURBLServer->SetAuthentication(authentication_);
std::shared_ptr<HM::SURBLServer> pDNSBlackList = surbl_servers_->GetItemByDBID(lDBID);
if (!pDNSBlackList)
return DISP_E_BADINDEX;
pInterfaceSURBLServer->AttachItem(pDNSBlackList);
pInterfaceSURBLServer->AttachParent(surbl_servers_, true);
pInterfaceSURBLServer->AddRef();
*pVal = pInterfaceSURBLServer;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceDistributionLists::get_ItemByAddress(BSTR sAddress, IInterfaceDistributionList **pVal)
{
try
{
if (!m_pDistributionLists)
return GetAccessDenied();
CComObject<InterfaceDistributionList>* pList = new CComObject<InterfaceDistributionList>();
pList->SetAuthentication(m_pAuthentication);
shared_ptr<HM::DistributionList> pPersList = m_pDistributionLists->GetItemByAddress(sAddress);
if (!pPersList)
return DISP_E_BADINDEX;
pList->AttachItem(pPersList);
pList->AttachParent(m_pDistributionLists, true);
pList->AddRef();
*pVal = pList;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceIncomingRelays::Add(IInterfaceIncomingRelay **pVal)
{
try
{
if (!m_pIncomingRelays)
return GetAccessDenied();
if (!m_pIncomingRelays)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceIncomingRelay>* pInterfaceRange = new CComObject<InterfaceIncomingRelay>();
pInterfaceRange->SetAuthentication(m_pAuthentication);
shared_ptr<HM::IncomingRelay> pRange = shared_ptr<HM::IncomingRelay>(new HM::IncomingRelay);
pInterfaceRange->AttachItem(pRange);
pInterfaceRange->AttachParent(m_pIncomingRelays, false);
pInterfaceRange->AddRef();
*pVal = pInterfaceRange;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceFetchAccounts::Add(IInterfaceFetchAccount **pVal)
{
try
{
if (!m_pFetchAccounts)
return GetAccessDenied();
if (!m_pFetchAccounts)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceFetchAccount>* pIntFA = new CComObject<InterfaceFetchAccount>();
pIntFA->SetAuthentication(m_pAuthentication);
boost::shared_ptr<HM::FetchAccount> pFA = boost::shared_ptr<HM::FetchAccount>(new HM::FetchAccount);
pFA->SetAccountID(m_pFetchAccounts->GetAccountID());
pIntFA->AttachItem(pFA);
pIntFA->AttachParent(m_pFetchAccounts, false);
pIntFA->AddRef();
*pVal = pIntFA;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceIncomingRelays::get_Item(long Index, IInterfaceIncomingRelay **pVal)
{
try
{
if (!m_pIncomingRelays)
return GetAccessDenied();
CComObject<InterfaceIncomingRelay>* pRangeInt = new CComObject<InterfaceIncomingRelay>();
pRangeInt->SetAuthentication(m_pAuthentication);
shared_ptr<HM::IncomingRelay> pRange = m_pIncomingRelays->GetItem(Index);
if (pRange)
{
pRangeInt->AttachItem(pRange);
pRangeInt->AttachParent(m_pIncomingRelays, true);
pRangeInt->AddRef();
*pVal = pRangeInt;
}
else
{
return DISP_E_BADINDEX;
}
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceIMAPFolders::get_ItemByName(BSTR sName, IInterfaceIMAPFolder **pVal)
{
try
{
if (!m_pObject)
return GetAccessDenied();
CComObject<InterfaceIMAPFolder>* pIMAPFolderInt = new CComObject<InterfaceIMAPFolder>();
pIMAPFolderInt->SetAuthentication(m_pAuthentication);
HM::String sUnicode (sName);
HM::AnsiString sFolderName = HM::ModifiedUTF7::Encode(sUnicode);
shared_ptr<HM::IMAPFolder> pIMAPFolder = m_pObject->GetFolderByName(sFolderName);
if (!pIMAPFolder)
return DISP_E_BADINDEX;
pIMAPFolderInt->Attach(pIMAPFolder);
pIMAPFolderInt->AttachParent(m_pObject, true);
pIMAPFolderInt->AddRef();
*pVal = pIMAPFolderInt;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceGroups::Add(IInterfaceGroup **pVal)
{
try
{
if (!m_pGroups)
return GetAccessDenied();
if (!m_pGroups)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceGroup>* pInterfaceGroup = new CComObject<InterfaceGroup>();
pInterfaceGroup->SetAuthentication(m_pAuthentication);
boost::shared_ptr<HM::Group> pBA = boost::shared_ptr<HM::Group>(new HM::Group);
pInterfaceGroup->AttachItem(pBA);
pInterfaceGroup->AttachParent(m_pGroups, false);
pInterfaceGroup->AddRef();
*pVal = pInterfaceGroup;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceGreyListingWhiteAddresses::Add(IInterfaceGreyListingWhiteAddress **pVal)
{
try
{
if (!gl_white_addresses_)
return GetAccessDenied();
if (!gl_white_addresses_)
return authentication_->GetAccessDenied();
CComObject<InterfaceGreyListingWhiteAddress>* pInterfaceGreyListingWhiteAddress = new CComObject<InterfaceGreyListingWhiteAddress>();
pInterfaceGreyListingWhiteAddress->SetAuthentication(authentication_);
shared_ptr<HM::GreyListingWhiteAddress> pBA = shared_ptr<HM::GreyListingWhiteAddress>(new HM::GreyListingWhiteAddress);
pInterfaceGreyListingWhiteAddress->AttachItem(pBA);
pInterfaceGreyListingWhiteAddress->AttachParent(gl_white_addresses_, false);
pInterfaceGreyListingWhiteAddress->AddRef();
*pVal = pInterfaceGreyListingWhiteAddress;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceGroups::get_Item(long Index, IInterfaceGroup **pVal)
{
try
{
if (!m_pGroups)
return GetAccessDenied();
CComObject<InterfaceGroup>* pInterfaceGroup = new CComObject<InterfaceGroup>();
pInterfaceGroup->SetAuthentication(m_pAuthentication);
boost::shared_ptr<HM::Group> pBA = m_pGroups->GetItem(Index);
if (!pBA)
return DISP_E_BADINDEX;
pInterfaceGroup->AttachItem(pBA);
pInterfaceGroup->AttachParent(m_pGroups, true);
pInterfaceGroup->AddRef();
*pVal = pInterfaceGroup;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceSSLCertificates::Add(IInterfaceSSLCertificate **pVal)
{
try
{
if (!m_pSSLCertificates)
return GetAccessDenied();
if (!m_pSSLCertificates)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceSSLCertificate>* pInterfaceSSLCertificate = new CComObject<InterfaceSSLCertificate>();
pInterfaceSSLCertificate->SetAuthentication(m_pAuthentication);
shared_ptr<HM::SSLCertificate> pBA = shared_ptr<HM::SSLCertificate>(new HM::SSLCertificate);
pInterfaceSSLCertificate->AttachItem(pBA);
pInterfaceSSLCertificate->AttachParent(m_pSSLCertificates, false);
pInterfaceSSLCertificate->AddRef();
*pVal = pInterfaceSSLCertificate;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceSURBLServers::Add(IInterfaceSURBLServer **pVal)
{
try
{
if (!m_pSURBLServers)
return GetAccessDenied();
if (!m_pSURBLServers)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceSURBLServer>* pInterfaceSURBLServer = new CComObject<InterfaceSURBLServer>();
pInterfaceSURBLServer->SetAuthentication(m_pAuthentication);
shared_ptr<HM::SURBLServer> pDNSBL = shared_ptr<HM::SURBLServer>(new HM::SURBLServer);
pInterfaceSURBLServer->AttachItem(pDNSBL);
pInterfaceSURBLServer->AttachParent(m_pSURBLServers, false);
pInterfaceSURBLServer->AddRef();
*pVal = pInterfaceSURBLServer;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceBlockedAttachments::Add(IInterfaceBlockedAttachment **pVal)
{
try
{
if (!m_pBlockedAttachments)
return GetAccessDenied();
if (!m_pBlockedAttachments)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceBlockedAttachment>* pInterfaceBlockedAttachment = new CComObject<InterfaceBlockedAttachment>();
pInterfaceBlockedAttachment->SetAuthentication(m_pAuthentication);
shared_ptr<HM::BlockedAttachment> pBA = shared_ptr<HM::BlockedAttachment>(new HM::BlockedAttachment);
pInterfaceBlockedAttachment->AttachItem(pBA);
pInterfaceBlockedAttachment->AttachParent(m_pBlockedAttachments, false);
pInterfaceBlockedAttachment->AddRef();
*pVal = pInterfaceBlockedAttachment;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP
InterfaceSURBLServers::get_ItemByDNSHost(BSTR ItemName, IInterfaceSURBLServer **pVal)
{
try
{
if (!m_pSURBLServers)
return GetAccessDenied();
CComObject<InterfaceSURBLServer>* pInterfaceSURBLServer = new CComObject<InterfaceSURBLServer>();
pInterfaceSURBLServer->SetAuthentication(m_pAuthentication);
shared_ptr<HM::SURBLServer> pDNSBL = m_pSURBLServers->GetItemByName(ItemName);
if (!pDNSBL)
return S_FALSE;
pInterfaceSURBLServer->AttachItem(pDNSBL);
pInterfaceSURBLServer->AttachParent(m_pSURBLServers, true);
pInterfaceSURBLServer->AddRef();
*pVal = pInterfaceSURBLServer;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceAliases::Add(IInterfaceAlias **pVal)
{
try
{
if (!m_pAliases)
return GetAccessDenied();
if (!m_pAuthentication->GetIsDomainAdmin())
return m_pAuthentication->GetAccessDenied();
if (!m_pAliases)
return m_pAuthentication->GetAccessDenied();
CComObject<InterfaceAlias>* pIntAlias = new CComObject<InterfaceAlias>();
pIntAlias->SetAuthentication(m_pAuthentication);
shared_ptr<HM::Alias> pAliasADO = shared_ptr<HM::Alias>(new HM::Alias);
pIntAlias->AttachItem(pAliasADO);
pIntAlias->AttachParent(m_pAliases, false);
pAliasADO->SetDomainID(m_iDomainID);
pIntAlias->AddRef();
*pVal = pIntAlias;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}
STDMETHODIMP InterfaceRules::get_ItemByDBID(long lDBID, IInterfaceRule** pVal)
{
try
{
if (!m_pRules)
return GetAccessDenied();
CComObject<InterfaceRule>* pInterfaceRule = new CComObject<InterfaceRule>();
pInterfaceRule->SetAuthentication(m_pAuthentication);
shared_ptr<HM::Rule> pRule = m_pRules->GetItemByDBID(lDBID);
if (!pRule)
return DISP_E_BADINDEX;
pInterfaceRule->AttachParent(m_pRules, true);
pInterfaceRule->AttachItem(pRule);
pInterfaceRule->AddRef();
*pVal = pInterfaceRule;
return S_OK;
}
catch (...)
{
return COMError::GenerateGenericMessage();
}
}