// feeds.cpp : Implementation of CnntpadmApp and DLL registration.

#include "stdafx.h"
#include "nntpcmn.h"
#include "feeds.h"
#include "oleutil.h"

#include "nntptype.h"
#include "nntpapi.h"

#include <lmapibuf.h>

// Must define THIS_FILE_* macros to use NntpCreateException()

#define THIS_FILE_HELP_CONTEXT		0
#define THIS_FILE_PROG_ID			_T("Nntpadm.Feeds.1")
#define THIS_FILE_IID				IID_INntpAdminFeeds

/////////////////////////////////////////////////////////////////////////////
// Defaults:

#define DEFAULT_FEED_ID						0
#define DEFAULT_FEED_SERVER					_T("")
#define DEFAULT_PULL_NEWS_DATE				0
#define DEFAULT_START_TIME					0
#define DEFAULT_FEED_INTERVAL				15
#define DEFAULT_AUTO_CREATE					TRUE
#define DEFAULT_ENABLED						TRUE
#define DEFAULT_MAX_CONNECTIONS_ATTEMPTS	10
#define DEFAULT_SECURITY_TYPE				0
#define DEFAULT_AUTH_TYPE                   AUTH_PROTOCOL_NONE
#define DEFAULT_ACCOUNT_NAME				_T("")
#define DEFAULT_PASSWORD					_T("")
#define DEFAULT_ALLOW_CONTROL_MESSAGES		TRUE
#define DEFAULT_UUCP_NAME                   _T("")
#define DEFAULT_NEWSGROUPS                  _T("\0")
#define DEFAULT_DISTRIBUTION                _T("world\0")

/////////////////////////////////////////////////////////////////////////////
//

//
// Use a macro to define all the default methods
//
DECLARE_METHOD_IMPLEMENTATION_FOR_STANDARD_EXTENSION_INTERFACES(NntpAdminFeeds, CNntpAdminFeeds, IID_INntpAdminFeeds)

STDMETHODIMP CNntpOneWayFeed::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] = 
	{
		&IID_INntpOneWayFeed,
	};

	for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

CNntpOneWayFeed::CNntpOneWayFeed ()
	// CComBSTR's are initialized to NULL by default.
{
//	InitAsyncTrace ( );
}

CNntpOneWayFeed::~CNntpOneWayFeed ()
{
	// All CComBSTR's are freed automatically.
//	TermAsyncTrace ( );
}

STDMETHODIMP CNntpOneWayFeed::get_FeedId ( long * plFeedId )
{
	return StdPropertyGet ( m_feed.m_dwFeedId, plFeedId );
}

STDMETHODIMP CNntpOneWayFeed::get_RemoteServer ( BSTR * pstrRemoteServer )
{
	return StdPropertyGet ( m_feed.m_strRemoteServer, pstrRemoteServer );
}

STDMETHODIMP CNntpOneWayFeed::get_FeedAction ( NNTP_FEED_ACTION * pfeedaction )
{
	return m_feed.get_FeedAction ( pfeedaction );
}

STDMETHODIMP CNntpOneWayFeed::put_FeedAction ( NNTP_FEED_ACTION feedaction )
{
	return m_feed.put_FeedAction ( feedaction );
}

STDMETHODIMP CNntpOneWayFeed::get_UucpName ( BSTR * pstrUucpName )
{
	return StdPropertyGet ( m_feed.m_strUucpName, pstrUucpName );
}

STDMETHODIMP CNntpOneWayFeed::put_UucpName ( BSTR strUucpName )
{
	return StdPropertyPut ( &m_feed.m_strUucpName, strUucpName );
}

STDMETHODIMP CNntpOneWayFeed::get_PullNewsDate ( DATE * pdatePullNews )
{
	return StdPropertyGet ( m_feed.m_datePullNews, pdatePullNews );
}

STDMETHODIMP CNntpOneWayFeed::put_PullNewsDate ( DATE datePullNews )
{
	return StdPropertyPut ( &m_feed.m_datePullNews, datePullNews );
}

STDMETHODIMP CNntpOneWayFeed::get_FeedInterval ( long * plFeedInterval )
{
	return StdPropertyGet ( m_feed.m_dwFeedInterval, plFeedInterval );
}

STDMETHODIMP CNntpOneWayFeed::put_FeedInterval ( long lFeedInterval )
{
	return StdPropertyPut ( &m_feed.m_dwFeedInterval, lFeedInterval );
}

STDMETHODIMP CNntpOneWayFeed::get_AutoCreate ( BOOL * pfAutoCreate )
{
	return StdPropertyGet ( m_feed.m_fCreateAutomatically, pfAutoCreate );
}

STDMETHODIMP CNntpOneWayFeed::put_AutoCreate ( BOOL fAutoCreate )
{
	return StdPropertyPut ( &m_feed.m_fCreateAutomatically, fAutoCreate );
}

STDMETHODIMP CNntpOneWayFeed::get_Enabled ( BOOL * pfEnabled )
{
	return StdPropertyGet ( m_feed.m_fEnabled, pfEnabled );
}

STDMETHODIMP CNntpOneWayFeed::put_Enabled ( BOOL fEnabled )
{
	return StdPropertyPut ( &m_feed.m_fEnabled, fEnabled );
}

STDMETHODIMP CNntpOneWayFeed::get_MaxConnectionAttempts ( long * plMaxConnectionAttempts )
{
	return StdPropertyGet ( m_feed.m_dwMaxConnectionAttempts, plMaxConnectionAttempts );
}

STDMETHODIMP CNntpOneWayFeed::put_MaxConnectionAttempts ( long lMaxConnectionAttempts )
{
	return StdPropertyPut ( &m_feed.m_dwMaxConnectionAttempts, lMaxConnectionAttempts );
}

STDMETHODIMP CNntpOneWayFeed::get_SecurityType ( long * plSecurityType )
{
	return StdPropertyGet ( m_feed.m_dwSecurityType, plSecurityType );
}

STDMETHODIMP CNntpOneWayFeed::put_SecurityType ( long lSecurityType )
{
	return StdPropertyPut ( &m_feed.m_dwSecurityType, lSecurityType );
}

STDMETHODIMP CNntpOneWayFeed::get_AuthenticationType ( long * plAuthenticationType )
{
	return StdPropertyGet ( m_feed.m_dwAuthenticationType, plAuthenticationType );
}

STDMETHODIMP CNntpOneWayFeed::put_AuthenticationType ( long lAuthenticationType )
{
	return StdPropertyPut ( &m_feed.m_dwAuthenticationType, lAuthenticationType );
}

STDMETHODIMP CNntpOneWayFeed::get_AccountName ( BSTR * pstrAccountName )
{
	return StdPropertyGet ( m_feed.m_strAccountName, pstrAccountName );
}

STDMETHODIMP CNntpOneWayFeed::put_AccountName ( BSTR strAccountName )
{
	return StdPropertyPut ( &m_feed.m_strAccountName, strAccountName );
}

STDMETHODIMP CNntpOneWayFeed::get_Password ( BSTR * pstrPassword )
{
	return StdPropertyGet ( m_feed.m_strPassword, pstrPassword );
}

STDMETHODIMP CNntpOneWayFeed::put_Password ( BSTR strPassword )
{
	return StdPropertyPut ( &m_feed.m_strPassword, strPassword );
}

STDMETHODIMP CNntpOneWayFeed::get_AllowControlMessages ( BOOL * pfAllowControlMessages )
{
	return StdPropertyGet ( m_feed.m_fAllowControlMessages, pfAllowControlMessages );
}

STDMETHODIMP CNntpOneWayFeed::put_AllowControlMessages ( BOOL fAllowControlMessages )
{
	return StdPropertyPut ( &m_feed.m_fAllowControlMessages, fAllowControlMessages );
}

STDMETHODIMP CNntpOneWayFeed::get_OutgoingPort ( long * plOutgoingPort )
{
	return StdPropertyGet ( m_feed.m_dwOutgoingPort, plOutgoingPort );
}

STDMETHODIMP CNntpOneWayFeed::put_OutgoingPort ( long lOutgoingPort )
{
	return StdPropertyPut ( &m_feed.m_dwOutgoingPort, lOutgoingPort );
}

STDMETHODIMP CNntpOneWayFeed::get_Newsgroups ( SAFEARRAY ** ppsastrNewsgroups )
{
	return StdPropertyGet ( &m_feed.m_mszNewsgroups, ppsastrNewsgroups );
}

STDMETHODIMP CNntpOneWayFeed::put_Newsgroups ( SAFEARRAY * psastrNewsgroups )
{
	return StdPropertyPut ( &m_feed.m_mszNewsgroups, psastrNewsgroups );
}

STDMETHODIMP CNntpOneWayFeed::get_NewsgroupsVariant ( SAFEARRAY ** ppsavarNewsgroups )
{
	HRESULT			hr;
	SAFEARRAY *		psastrNewsgroups	= NULL;

	hr = get_Newsgroups ( &psastrNewsgroups );
	if ( FAILED(hr) ) {
		goto Exit;
	}

	hr = StringArrayToVariantArray ( psastrNewsgroups, ppsavarNewsgroups );

Exit:
	if ( psastrNewsgroups ) {
		SafeArrayDestroy ( psastrNewsgroups );
	}

	return hr;
}

STDMETHODIMP CNntpOneWayFeed::put_NewsgroupsVariant ( SAFEARRAY * psavarNewsgroups )
{
	HRESULT			hr;
	SAFEARRAY *		psastrNewsgroups	= NULL;

	hr = VariantArrayToStringArray ( psavarNewsgroups, &psastrNewsgroups );
	if ( FAILED(hr) ) {
		goto Exit;
	}

	hr = put_Newsgroups ( psastrNewsgroups );

Exit:
	if ( psastrNewsgroups ) {
		SafeArrayDestroy ( psastrNewsgroups );
	}

	return hr;
}

STDMETHODIMP CNntpOneWayFeed::get_Distributions ( SAFEARRAY ** ppsastrDistributions )
{
	return StdPropertyGet ( &m_feed.m_mszDistributions, ppsastrDistributions );
}

STDMETHODIMP CNntpOneWayFeed::put_Distributions ( SAFEARRAY * psastrDistributions )
{
	return StdPropertyPut ( &m_feed.m_mszDistributions, psastrDistributions );
}

STDMETHODIMP CNntpOneWayFeed::get_TempDirectory ( BSTR * pstrTempDirectory )
{
	return StdPropertyGet ( m_feed.m_strTempDirectory, pstrTempDirectory );
}

STDMETHODIMP CNntpOneWayFeed::put_TempDirectory ( BSTR strTempDirectory )
{
	return StdPropertyPut ( &m_feed.m_strTempDirectory, strTempDirectory );
}

STDMETHODIMP CNntpOneWayFeed::Default	( )
{
	TraceFunctEnter ( "CNntpOneWayFeed::Default" );

	SYSTEMTIME	st;
	DATE		dateToday;

	GetSystemTime ( &st );
	SystemTimeToVariantTime ( &st, &dateToday );

	m_feed.m_dwFeedId				= DEFAULT_FEED_ID;
	m_feed.m_strRemoteServer		= DEFAULT_FEED_SERVER;
	m_feed.m_dwFeedInterval			= DEFAULT_FEED_INTERVAL;
	m_feed.m_fCreateAutomatically	= DEFAULT_AUTO_CREATE;
	m_feed.m_fEnabled				= DEFAULT_ENABLED;
	m_feed.m_dwMaxConnectionAttempts	= DEFAULT_MAX_CONNECTIONS_ATTEMPTS;
	m_feed.m_dwSecurityType			= DEFAULT_SECURITY_TYPE;
    m_feed.m_dwAuthenticationType   = DEFAULT_AUTH_TYPE;
	m_feed.m_strAccountName			= DEFAULT_ACCOUNT_NAME;
	m_feed.m_strPassword			= DEFAULT_PASSWORD;
	m_feed.m_fAllowControlMessages	= DEFAULT_ALLOW_CONTROL_MESSAGES;
    m_feed.m_strUucpName         	= DEFAULT_UUCP_NAME;
    m_feed.m_dwOutgoingPort			= 119;

    m_feed.m_mszNewsgroups           = DEFAULT_NEWSGROUPS;
    m_feed.m_mszDistributions        = DEFAULT_DISTRIBUTION;

	m_feed.m_datePullNews			= dateToday;

	if ( !m_feed.CheckValid() ) {
		TraceFunctLeave ();
		return E_OUTOFMEMORY;
	}
	
	TraceFunctLeave ();
	return NOERROR;
}

/////////////////////////////////////////////////////////////////////////////
//

STDMETHODIMP CNntpFeed::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] = 
	{
		&IID_INntpFeed,
	};

	for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

CNntpFeed::CNntpFeed () :
	m_type ( NNTP_FEED_TYPE_PEER )
	// CComBSTR's are initialized to NULL by default.
{
//	InitAsyncTrace ( );
}

CNntpFeed::~CNntpFeed ()
{
	// All CComBSTR's are freed automatically.
//	TermAsyncTrace ( );
}

STDMETHODIMP CNntpFeed::get_RemoteServer ( BSTR * pstrRemoteServer )
{
	return StdPropertyGet ( m_strRemoteServer, pstrRemoteServer );
}

STDMETHODIMP CNntpFeed::put_RemoteServer ( BSTR strRemoteServer )
{
	return StdPropertyPut ( &m_strRemoteServer, strRemoteServer );
}

STDMETHODIMP CNntpFeed::get_FeedType ( NNTP_FEED_SERVER_TYPE * pfeedtype )
{
	*pfeedtype = m_type;
	return NOERROR;
}

STDMETHODIMP CNntpFeed::put_FeedType ( NNTP_FEED_SERVER_TYPE feedtype )
{
	switch ( feedtype ) {
	case NNTP_FEED_TYPE_PEER:
	case NNTP_FEED_TYPE_MASTER:
	case NNTP_FEED_TYPE_SLAVE:
		m_type = feedtype;
		return NOERROR;
		break;

	default:
		return RETURNCODETOHRESULT ( ERROR_INVALID_PARAMETER );
		break;
	}
}

STDMETHODIMP CNntpFeed::get_HasInbound ( BOOL * pfHasInbound )
{
    *pfHasInbound = m_pInbound != NULL;
    return NOERROR;
}

STDMETHODIMP CNntpFeed::get_HasOutbound ( BOOL * pfHasOutbound )
{
    *pfHasOutbound = m_pOutbound != NULL;
    return NOERROR;
}

STDMETHODIMP CNntpFeed::get_InboundFeed ( INntpOneWayFeed ** ppFeed )
{
    HRESULT     hr  = NOERROR;

    *ppFeed = NULL;
    if ( m_pInbound ) {
        hr = m_pInbound->QueryInterface ( IID_INntpOneWayFeed, (void **) ppFeed );
        return hr;
    }
    return E_FAIL;
}

STDMETHODIMP CNntpFeed::get_OutboundFeed ( INntpOneWayFeed ** ppFeed )
{
    HRESULT     hr  = NOERROR;

    *ppFeed = NULL;
    if ( m_pOutbound ) {
        hr = m_pOutbound->QueryInterface ( IID_INntpOneWayFeed, (void **) ppFeed );
    	return hr;
    }
    return E_FAIL;
}

STDMETHODIMP CNntpFeed::put_InboundFeed ( INntpOneWayFeed * pFeed )
{
    HRESULT     hr  = NOERROR;

    // !!!magnush - Do some feed type checking here.

    m_pInbound.Release ();
    m_pInbound = pFeed;

    return NOERROR;
}

STDMETHODIMP CNntpFeed::put_OutboundFeed ( INntpOneWayFeed * pFeed )
{
    HRESULT     hr  = NOERROR;

    // !!!magnush - Do some feed type checking here.

    m_pOutbound.Release ();
    m_pOutbound = pFeed;

    return hr;
}

STDMETHODIMP CNntpFeed::get_InboundFeedDispatch ( IDispatch ** ppDispatch )
{
	HRESULT						hr;
	CComPtr<INntpOneWayFeed>	pInbound;

	hr = get_InboundFeed ( &pInbound );
	BAIL_ON_FAILURE(hr);

	hr = pInbound->QueryInterface ( IID_IDispatch, (void **) ppDispatch );
	BAIL_ON_FAILURE(hr);

Exit:
	return hr;
}

STDMETHODIMP CNntpFeed::put_InboundFeedDispatch ( IDispatch * pDispatch )
{
	HRESULT						hr;
	CComPtr<INntpOneWayFeed>	pInbound;

	hr = pDispatch->QueryInterface ( IID_INntpOneWayFeed, (void **) &pInbound );
	BAIL_ON_FAILURE(hr);

	hr = put_InboundFeed ( pInbound );
	BAIL_ON_FAILURE(hr);

Exit:
	return hr;
}

STDMETHODIMP CNntpFeed::get_OutboundFeedDispatch ( IDispatch ** ppDispatch )
{
	HRESULT						hr;
	CComPtr<INntpOneWayFeed>	pOutbound;

	hr = get_OutboundFeed ( &pOutbound );
	BAIL_ON_FAILURE(hr);

	hr = pOutbound->QueryInterface ( IID_IDispatch, (void **) ppDispatch );
	BAIL_ON_FAILURE(hr);

Exit:
	return hr;
}

STDMETHODIMP CNntpFeed::put_OutboundFeedDispatch ( IDispatch * pDispatch )
{
	HRESULT						hr;
	CComPtr<INntpOneWayFeed>	pOutbound;

	hr = pDispatch->QueryInterface ( IID_INntpOneWayFeed, (void **) &pOutbound );
	BAIL_ON_FAILURE(hr);

	hr = put_OutboundFeed ( pOutbound );
	BAIL_ON_FAILURE(hr);

Exit:
	return hr;
}

HRESULT	CNntpFeed::FromFeedPair ( CFeedPair * pFeedPair )
{
	HRESULT		hr	= NOERROR;

	m_pInbound.Release ();
	m_pOutbound.Release ();

	m_strRemoteServer	= pFeedPair->m_strRemoteServer;
	m_type				= pFeedPair->m_type;
	if ( pFeedPair->m_pInbound ) {
		hr = pFeedPair->m_pInbound->ToINntpOneWayFeed ( &m_pInbound );
		BAIL_ON_FAILURE(hr);
	}
	if ( pFeedPair->m_pOutbound ) {
		hr = pFeedPair->m_pOutbound->ToINntpOneWayFeed ( &m_pOutbound );
		BAIL_ON_FAILURE(hr);
	}

Exit:
	return hr;
}

/////////////////////////////////////////////////////////////////////////////
//

STDMETHODIMP CNntpAdminFeeds::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] = 
	{
		&IID_INntpAdminFeeds,
	};

	for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

CNntpAdminFeeds::CNntpAdminFeeds () :
	m_fEnumerated				( FALSE )
	// CComBSTR's are initialized to NULL by default.
{

	InitAsyncTrace ( );

    m_iadsImpl.SetService ( MD_SERVICE_NAME );
    m_iadsImpl.SetName ( _T("Feeds") );
    m_iadsImpl.SetClass ( _T("IIsNntpFeeds") );

    OleInitialize( NULL );
}

CNntpAdminFeeds::~CNntpAdminFeeds ()
{
	// All CComBSTR's are freed automatically.
	TermAsyncTrace ( );
    OleUninitialize();
}

//
//  IADs methods:
//

DECLARE_SIMPLE_IADS_IMPLEMENTATION(CNntpAdminFeeds,m_iadsImpl)

//////////////////////////////////////////////////////////////////////
// Properties:
//////////////////////////////////////////////////////////////////////

// Enumeration Properties:

STDMETHODIMP CNntpAdminFeeds::get_Count ( long * plCount )
{
	return StdPropertyGet ( m_listFeeds.GetCount(), plCount );
}

//////////////////////////////////////////////////////////////////////
// Methods:
//////////////////////////////////////////////////////////////////////

STDMETHODIMP CNntpAdminFeeds::Enumerate	( )
{
	TraceFunctEnter ( "CNntpAdminFeeds::Enumerate" );

	HRESULT				hr			= NOERROR;
	DWORD				dwError		= NOERROR;
	DWORD				cFeeds		= 0;
	LPNNTP_FEED_INFO	pFeedInfo	= NULL;
	DWORD				i;

	dwError = NntpEnumerateFeeds (
        m_iadsImpl.QueryComputer(),
        m_iadsImpl.QueryInstance(),
        &cFeeds,
        &pFeedInfo
        );
	if ( dwError != 0 ) {
		ErrorTrace ( (LPARAM) this, "Error enumerating feeds: %x", dwError );
		hr = RETURNCODETOHRESULT ( dwError );
		goto Exit;
	}

	// Empty the old feed list:
	m_fEnumerated = FALSE;
    m_listFeeds.Empty ();

    // Add each feed to our list:
    for ( i = 0; i < cFeeds; i++ ) {
        DWORD           dwPairID;
        CFeedPair *     pFeedPair;
        CFeed *         pFeed;

        // Create a new Feed object:
        hr = CFeed::CreateFeedFromFeedInfo ( &pFeedInfo[i], &pFeed );
        if ( FAILED(hr) ) {
            goto Exit;
        }

        // Find the pair that matches Feed[i]:
        dwPairID = pFeed->m_dwPairFeedId;
        pFeedPair = m_listFeeds.Find ( dwPairID );

        if ( pFeedPair ) {
            // We found a matching pair, so add it:
            hr = pFeedPair->AddFeed ( pFeed );
            if ( hr == E_FAIL ) {
                // Something went wrong - Try to add the feed by itself.
                pFeedPair = NULL;
                hr = NOERROR;
            }
            if ( FAILED(hr) ) {
                goto Exit;
            }
        }

        if ( pFeedPair == NULL ) {
            // We need to create a new feed pair:
            hr = CFeedPair::CreateFeedPair ( 
            	&pFeedPair, 
            	pFeedInfo[i].ServerName,
            	FeedTypeToEnum ( pFeedInfo[i].FeedType )
            	);
            if ( FAILED(hr) ) {
                goto Exit;
            }

            // Add the current feed to the new pair:
            hr = pFeedPair->AddFeed ( pFeed );
            if ( FAILED(hr) ) {
                goto Exit;
            }

            // Add the new pair to the pair list:
            m_listFeeds.Add ( pFeedPair );
        }
    }

    // !!!magnush - Stop memory leaks here.

	m_fEnumerated 	= TRUE;

Exit:
	if ( FAILED(hr) ) {
        m_listFeeds.Empty();
	}

	if ( pFeedInfo ) {
		::NetApiBufferFree ( pFeedInfo );
	}

	TRACE_HRESULT(hr);
	TraceFunctLeave ();
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::Item ( long lIndex, INntpFeed ** ppFeed )
{
	TraceFunctEnter ( "CNntpAdminFeeds::Item" );

	HRESULT		        hr	= NOERROR;
    CFeedPair *         pFeedPair;

	// Did we enumerate first?
	if ( !m_fEnumerated ) {
		hr = NntpCreateException ( IDS_NNTPEXCEPTION_DIDNT_ENUMERATE );
		TraceFunctLeave ();
        return hr;
	}
	
    pFeedPair = m_listFeeds.Item ( lIndex );
    if ( !pFeedPair ) {
        hr = NntpCreateException ( IDS_NNTPEXCEPTION_INVALID_INDEX );
        goto Exit;
    }

    hr = pFeedPair->ToINntpFeed ( ppFeed );
    if ( FAILED(hr) ) {
        goto Exit;
    }

Exit:
	TRACE_HRESULT(hr);
	TraceFunctLeave ();
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::FindID ( long lID, long * plIndex )
{
	TraceFunctEnter ( "CNntpAdminFeeds::FindID" );

	HRESULT		hr	= NOERROR;
    CFeedPair * pFeedPair;

    *plIndex = -1;

    pFeedPair   = m_listFeeds.Find ( (DWORD) lID );

    if ( pFeedPair ) {
        *plIndex = (long) m_listFeeds.GetPairIndex ( pFeedPair );
    }

	TraceFunctLeave ();
	return hr;
}

HRESULT CNntpAdminFeeds::ReturnFeedPair ( CFeedPair * pFeedPair, INntpFeed * pFeed )
{
	HRESULT						hr;
    CComPtr<INntpOneWayFeed>    pInbound;
    CComPtr<INntpOneWayFeed>    pOutbound;
    CComPtr<INntpFeed>          pNewFeedPair;

    hr = pFeedPair->ToINntpFeed ( &pNewFeedPair );
	BAIL_ON_FAILURE(hr);

    pNewFeedPair->get_InboundFeed ( &pInbound );
    pNewFeedPair->get_OutboundFeed ( &pOutbound );

    pFeed->put_InboundFeed ( pInbound );
    pFeed->put_OutboundFeed ( pOutbound );

Exit:
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::Add ( INntpFeed * pFeed )
{
	TraceFunctEnter ( "CNntpAdminFeeds::Add" );

	HRESULT		hr 				= NOERROR;
    CFeedPair * pFeedPair       = NULL;
    CComBSTR	strRemoteServer;
    CComBSTR	strServer;
    NNTP_FEED_SERVER_TYPE	    type;
    CMetabaseKey *pMK = NULL;
    IMSAdminBase *pMeta = NULL;

	hr = pFeed->get_RemoteServer ( &strRemoteServer );
	BAIL_ON_FAILURE(hr);

	hr = get_Server(&strServer);
	BAIL_ON_FAILURE(hr);

    hr = CreateMetabaseObject( strServer, &pMeta ); 
    _ASSERT( SUCCEEDED( hr ) );
    BAIL_ON_FAILURE(hr);

	pMK = new CMetabaseKey(pMeta);
	if (!pMK)
		BAIL_WITH_FAILURE(hr, E_OUTOFMEMORY);

	hr = pFeed->get_FeedType ( &type );
	BAIL_ON_FAILURE(hr);

    hr = CFeedPair::CreateFeedPair ( &pFeedPair, strRemoteServer, type );
	BAIL_ON_FAILURE(hr);

    hr = pFeedPair->FromINntpFeed ( pFeed );
	BAIL_ON_FAILURE(hr);

    hr = pFeedPair->AddToServer (
        m_iadsImpl.QueryComputer(),
        m_iadsImpl.QueryInstance(),
        pMK
        );
	BAIL_ON_FAILURE(hr);

    m_listFeeds.Add ( pFeedPair );

    //  Return the new feeds (and their IDs) to the caller:
	hr = ReturnFeedPair ( pFeedPair, pFeed );
	BAIL_ON_FAILURE(hr);

Exit:
    if ( FAILED(hr) ) {
        delete pFeedPair;
    }

    if (pMK)
    	delete pMK;

    if (pMeta)
    	pMeta->Release();

	TRACE_HRESULT(hr);
	TraceFunctLeave ();
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::Set ( long lIndex, INntpFeed * pFeed )
{
	TraceFunctEnter ( "CNntpAdminFeeds::Set" );

	HRESULT		hr = NOERROR;
    CFeedPair * pFeedPair;
    CComPtr<INntpFeed>          pNewFeedPair;
    CComPtr<INntpOneWayFeed>    pInbound;
    CComPtr<INntpOneWayFeed>    pOutbound;
    CComBSTR	strServer;
    CMetabaseKey *pMK = NULL;
    IMSAdminBase *pMeta = NULL;

	hr = get_Server ( &strServer );
	BAIL_ON_FAILURE(hr);

    hr = CreateMetabaseObject( strServer, &pMeta ); 
    _ASSERT( SUCCEEDED( hr ) );
    BAIL_ON_FAILURE(hr);

	pMK = new CMetabaseKey(pMeta);
	if (!pMK)
		BAIL_WITH_FAILURE(hr, E_OUTOFMEMORY);

    pFeedPair = m_listFeeds.Item ( lIndex );
    if ( !pFeedPair ) {
        hr = NntpCreateException ( IDS_NNTPEXCEPTION_INVALID_INDEX );
        goto Exit;
    }

    hr = pFeedPair->SetToServer (
        m_iadsImpl.QueryComputer(),
        m_iadsImpl.QueryInstance(),
        pFeed,
        pMK
        );
	BAIL_ON_FAILURE(hr);

    //  Return the new feeds (and their IDs) to the caller:
	hr = ReturnFeedPair ( pFeedPair, pFeed );
	BAIL_ON_FAILURE(hr);

Exit:
    if (pMK)
    	delete pMK;

    if (pMeta)
    	pMeta->Release();

	TRACE_HRESULT(hr);
	TraceFunctLeave ();
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::Remove ( long lIndex )
{
	TraceFunctEnter ( "CNntpAdminFeeds::Remove" );

	HRESULT		hr = NOERROR;
	CFeedPair *	pFeedPair;
    CComBSTR	strServer;
    CMetabaseKey *pMK = NULL;
    IMSAdminBase *pMeta = NULL;

    pFeedPair   = m_listFeeds.Item ( lIndex );
    if ( !pFeedPair ) {
        hr = NntpCreateException ( IDS_NNTPEXCEPTION_INVALID_INDEX );
        goto Exit;
    }

	hr = get_Server ( &strServer );
	BAIL_ON_FAILURE(hr);

    hr = CreateMetabaseObject( strServer, &pMeta ); 
    _ASSERT( SUCCEEDED( hr ) );
    BAIL_ON_FAILURE(hr);

	pMK = new CMetabaseKey(pMeta);
	if (!pMK)
		BAIL_WITH_FAILURE(hr, E_OUTOFMEMORY);

    hr = pFeedPair->RemoveFromServer (
        m_iadsImpl.QueryComputer(),
        m_iadsImpl.QueryInstance(),
        pMK
        );
    if ( FAILED(hr) ) {
        goto Exit;
    }

    m_listFeeds.Remove ( pFeedPair );

Exit:
    if (pMK)
    	delete pMK;

    if (pMeta)
    	pMeta->Release();

	TRACE_HRESULT(hr);
	TraceFunctLeave ();
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::ItemDispatch ( long index, IDispatch ** ppDispatch )
{
	HRESULT				hr;
	CComPtr<INntpFeed>	pFeed;

	hr = Item ( index, &pFeed );
	BAIL_ON_FAILURE ( hr );

	hr = pFeed->QueryInterface ( IID_IDispatch, (void **) ppDispatch );
	BAIL_ON_FAILURE ( hr );

Exit:
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::AddDispatch ( IDispatch * pFeed )
{
	HRESULT				hr;
	CComPtr<INntpFeed>	pINntpFeed;

	hr = pFeed->QueryInterface ( IID_INntpFeed, (void **) &pINntpFeed );
	BAIL_ON_FAILURE(hr);

	hr = Add ( pINntpFeed );
	BAIL_ON_FAILURE(hr);

Exit:
	return hr;
}

STDMETHODIMP CNntpAdminFeeds::SetDispatch ( long lIndex, IDispatch * pFeed )
{
	HRESULT				hr;
	CComPtr<INntpFeed>	pINntpFeed;

	hr = pFeed->QueryInterface ( IID_INntpFeed, (void **) &pINntpFeed );
	BAIL_ON_FAILURE(hr);

	hr = Set ( lIndex, pINntpFeed );
	BAIL_ON_FAILURE(hr);

Exit:
	return hr;
}