windows-server-2003/net/tapi/skywalker/tapi3/agentsess.cpp

/*++

Copyright (c) 1997  Microsoft Corporation

Module Name:

    agentsess.cpp

Abstract:

    Implementation of the Agent Session object for TAPI 3.0.
    CAgentSession class
    CAgentSessionEvent class

Author:

    noela - 11/04/97

Notes:

    optional-notes

Revision History:

--*/



#include "stdafx.h"
#include "lmcons.h"

DWORD MapAgentSessionStateFrom3to2(AGENT_SESSION_STATE tapi3State);
HRESULT MapAgentSessionStateFrom2to3(DWORD tapi2State, AGENT_SESSION_STATE  *tapi3State);





/////////////////////////////////////////////////////////////////////////////
// CAgentSession

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Method    : Initialize
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::Initialize(
        HAGENTSESSION       hAgentSession, 
        ITAgent           * pAgent, 
        ITACDGroup        * pGroup, 
        ITAddress         * pAddress,
        CAgentHandler     * pHandler,
        AddressLineStruct * pAddressLine
        )
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "Initialize - enter, sessionhandle :%d", hAgentSession ));

    m_SessionState                  = ASST_NOT_READY;

    m_hAgentSession                 = hAgentSession;
    m_pAgent                        = pAgent;
    m_pGroup                        = pGroup;
    m_pReceiveCallsOnThisAddress    = pAddress;
    pAddress->AddRef();
    m_pHandler                      = pHandler;
    m_pAddressLine                  = pAddressLine;
  
    m_bRequiresUpdating             = TRUE;

    // Now add to AgentHandler hash table 
    m_pHandler->AddAgentSessionToHash(m_hAgentSession, this);

    
    // UpdateInfo();

    // Fire an event here
    CAgentSessionEvent::FireEvent(this, ASE_NOT_READY);


    LOG((TL_TRACE, hr, "Initialize - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Method    : FinalRelease
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CAgentSession::FinalRelease()
{
    LOG((TL_TRACE, "FinalRelease session %d", m_hAgentSession ));

    // Now Remove to AgentHandler hash table 
    //m_pHandler->RemoveAgentSessionFromHash(m_hAgentSession);

    // And then close our line
    CAddress *pAddress = (CAddress*)m_pReceiveCallsOnThisAddress;
    pAddress->MaybeCloseALine (&m_pAddressLine);
    pAddress->Release();

}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Method    : UpdateInfo
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::UpdateInfo()
{
    HRESULT                     hr2,hr = S_OK;
    LINEAGENTSESSIONINFO        AgentSessionInfo;


    LOG((TL_TRACE, "UpdateInfo - enter" ));
 
    AgentSessionInfo.dwTotalSize = sizeof(LINEAGENTSESSIONINFO);
    AgentSessionInfo.dwNeededSize = sizeof(LINEAGENTSESSIONINFO);
    AgentSessionInfo.dwUsedSize = sizeof(LINEAGENTSESSIONINFO);

    
    // **************************************************
    // Get Agent Info from Proxy
    hr = lineGetAgentSessionInfo(
                        m_pAddressLine->t3Line.hLine,
                        m_hAgentSession, 
                        &AgentSessionInfo);

    if( SUCCEEDED(hr) )
    {
        // wait for async reply
        hr = WaitForReply( hr );
        if ( SUCCEEDED(hr) )
        {
            Lock();
    
            if( FAILED( MapAgentSessionStateFrom2to3(AgentSessionInfo.dwAgentSessionState, &m_SessionState) ) )
            {    
                LOG((TL_ERROR, "UpdateInfo - AgentSessionState is invalid %d - setting to ASST_NOT_READY",AgentSessionInfo.dwAgentSessionState));
            }    

            if( FAILED( MapAgentSessionStateFrom2to3(AgentSessionInfo.dwNextAgentSessionState, &m_NextSessionState) ) )
            {    
                LOG((TL_ERROR, "UpdateInfo - NextAgentSessionState is invalid %d - setting to ASST_NOT_READY",AgentSessionInfo.dwAgentSessionState));
            }    
                                    
            m_dwSessionStartTime     = AgentSessionInfo.dateSessionStartTime;     
            m_dwSessionDuration      = AgentSessionInfo.dwSessionDuration;        
            m_dwNumberOfCalls        = AgentSessionInfo.dwNumberOfCalls;          
            m_dwTotalTalkTime        = AgentSessionInfo.dwTotalTalkTime;          
            m_dwAverageTalkTime      = AgentSessionInfo.dwAverageTalkTime;        
            m_dwTotalCallTime        = AgentSessionInfo.dwTotalCallTime;          
            m_dwAverageCallTime      = AgentSessionInfo.dwAverageCallTime;        
            m_dwTotalWrapUpTime      = AgentSessionInfo.dwTotalWrapUpTime;        
            m_dwAverageWrapUpTime    = AgentSessionInfo.dwAverageWrapUpTime;      
            m_dwACDCallRate          = AgentSessionInfo.cyACDCallRate;            
            m_dwLongestTimeToAnswer  = AgentSessionInfo.dwLongestTimeToAnswer;    
            m_dwAverageTimeToAnswer  = AgentSessionInfo.dwAverageTimeToAnswer;    

            m_bRequiresUpdating      = FALSE;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "UpdateInfo - call to lineGetAgentSessionInfo failed async" ));
        }
    }
    else
    {
        LOG((TL_ERROR, "UpdateInfo - call to lineGetAgentSessionInfo failed" ));
    }



    LOG((TL_TRACE, hr, "UpdateInfo - exit" ));
    return hr;
}





//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Method    : CheckIfUpToDate
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::CheckIfUpToDate()
{
    HRESULT     hr = S_OK;

    if (m_bRequiresUpdating)
    {
        hr = UpdateInfo();
    }
    return hr;
}





//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession 
// Interface : ITAgentSession
// Method    : AverageTimeToAnswer
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_AverageTimeToAnswer(long * pulAnswerTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "AverageTimeToAnswer - enter" ));
    if (!TAPIIsBadWritePtr( pulAnswerTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulAnswerTime = m_dwAverageTimeToAnswer;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_AverageTimeToAnswer - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_AverageTimeToAnswer - bad pulAnswerTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "AverageTimeToAnswer - exit" ));
    return hr;

}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : LongestTimeToAnswer
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_LongestTimeToAnswer(long * pulAnswerTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "LongestTimeToAnswer - enter" ));
    if (!TAPIIsBadWritePtr( pulAnswerTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulAnswerTime = m_dwLongestTimeToAnswer;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_LongestTimeToAnswer - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_LongestTimeToAnswer - bad pulAnswerTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "LongestTimeToAnswer - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : ACDCallRate
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_ACDCallRate(CURRENCY * pcyCallrate)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "ACDCallRate - enter" ));
    if (!TAPIIsBadWritePtr( pcyCallrate, sizeof(CURRENCY) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pcyCallrate = m_dwACDCallRate;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_ACDCallRate - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_ACDCallRate - bad pcyCallrate pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "ACDCallRate - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : AverageWrapUpTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_AverageWrapUpTime(long * pulAverageWrapUpTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "AverageWrapUpTime - enter" ));
    if (!TAPIIsBadWritePtr( pulAverageWrapUpTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulAverageWrapUpTime = m_dwAverageWrapUpTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_AverageWrapUpTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_AverageWrapUpTime - bad pulAverageWrapUpTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "AverageWrapUpTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : TotalWrapUpTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_TotalWrapUpTime(long * pulTotalWrapUpTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "TotalWrapUpTime - enter" ));
    if (!TAPIIsBadWritePtr( pulTotalWrapUpTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulTotalWrapUpTime = m_dwTotalWrapUpTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_TotalWrapUpTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_TotalWrapUpTime - bad pulTotalWrapUpTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "TotalWrapUpTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : AverageCallTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_AverageCallTime(long * pulAverageCallTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "AverageCallTime - enter" ));
    if (!TAPIIsBadWritePtr( pulAverageCallTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulAverageCallTime = m_dwTotalCallTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_AverageCallTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_AverageCallTime - bad pulAverageCallTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "AverageCallTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : TotalCallTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_TotalCallTime(long * pulTotalCallTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "TotalCallTime - enter" ));
    if (!TAPIIsBadWritePtr( pulTotalCallTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulTotalCallTime = m_dwTotalCallTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_TotalCallTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_TotalCallTime - bad pulTotalCallTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "TotalCallTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : AverageTalkTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_AverageTalkTime(long * pulAverageTalkTime)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "AverageTalkTime - enter" ));
    if (!TAPIIsBadWritePtr( pulAverageTalkTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulAverageTalkTime = m_dwAverageTalkTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_AverageTalkTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_AverageTalkTime - bad pulAverageTalkTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "AverageTalkTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : TotalTalkTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_TotalTalkTime(long * pulTotalTalkTime)
{
    HRESULT  hr = S_OK;
 
	LOG((TL_TRACE, "TotalTalkTime - enter" ));
    if (!TAPIIsBadWritePtr( pulTotalTalkTime, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulTotalTalkTime = m_dwTotalTalkTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_TotalTalkTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_TotalTalkTime - bad pulTotalTalkTime pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "TotalTalkTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : NumberOfCalls
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_NumberOfCalls(long * pulNumberOfCalls)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "NumberOfCalls - enter" ));
    if (!TAPIIsBadWritePtr( pulNumberOfCalls, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulNumberOfCalls = m_dwNumberOfCalls;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_NumberOfCalls - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_NumberOfCalls - bad pulNumberOfCalls pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "NumberOfCalls - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : SessionDuration
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_SessionDuration(long * pulSessionDuration)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "SessionDuration - enter" ));
    if (!TAPIIsBadWritePtr( pulSessionDuration, sizeof(long) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *pulSessionDuration = m_dwSessionDuration;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_SessionDuration - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_SessionDuration - bad pulSessionDuration pointer"));
        hr = E_POINTER;                                          
    }

    LOG((TL_TRACE, hr, "SessionDuration - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : SessionStartTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_SessionStartTime(DATE * dateSessionStart)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "SessionStartTime - enter" ));
    if (!TAPIIsBadWritePtr( dateSessionStart, sizeof(DATE) ) )
    {
        hr = CheckIfUpToDate();
        if ( SUCCEEDED(hr) )
        {
            Lock();
            *dateSessionStart = m_dwSessionStartTime;
            Unlock();
        }
        else
        {
            LOG((TL_ERROR, "get_SessionStartTime - Object update failed"));
        }
    }
    else
    {
        LOG((TL_ERROR, "get_SessionStartTime - bad dateSessionStart pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "SessionStartTime - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : get_State
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_State(AGENT_SESSION_STATE * pSessionState)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "get_State - enter" ));
    if (!TAPIIsBadWritePtr( pSessionState, sizeof(AGENT_SESSION_STATE) ) )
    {
        Lock();
        *pSessionState = m_SessionState;
        Unlock();    
    }
    else
    {
        LOG((TL_ERROR, "get_State - bad pSessionState pointer"));
        hr = E_POINTER;
    }

    LOG((TL_TRACE, hr, "get_State - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : put_State
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::put_State(AGENT_SESSION_STATE sessionState)
{
    HRESULT hr = S_OK;
    HLINE   hLine;    
    DWORD   dwSessionState = 0;

    LOG((TL_TRACE, "put_State - enter" ));

    Lock();
    hLine = m_pAddressLine->t3Line.hLine;
    Unlock();

    dwSessionState = MapAgentSessionStateFrom3to2(sessionState);
    
    if( 0 == dwSessionState )
    {
        hr = E_INVALIDARG;        
    }
    else
    {
        hr = lineSetAgentSessionState
                (hLine, 
                 m_hAgentSession, 
                 dwSessionState,
                 0          // MapAgentSessionStateFrom3to2(m_NextSessionState)
                 );
    
        if( SUCCEEDED(hr) )
        {
            // wait for async reply
            hr = WaitForReply( hr );
            if ( SUCCEEDED(hr) )
            {
                Lock();
                m_SessionState =  sessionState;
                Unlock();
                switch( sessionState )
                {
                    case ASST_NOT_READY:
                    CAgentSessionEvent::FireEvent(this, ASE_NOT_READY);
                    break;
                    case ASST_READY:
                    CAgentSessionEvent::FireEvent(this, ASE_READY);
                    break;
                    case ASST_BUSY_ON_CALL:
                    CAgentSessionEvent::FireEvent(this, ASE_BUSY);
                    break;
                    case ASST_BUSY_WRAPUP:
                    CAgentSessionEvent::FireEvent(this, ASE_WRAPUP);
                    break;
                    case ASST_SESSION_ENDED:
                    CAgentSessionEvent::FireEvent(this, ASE_END);
                    break;
                }
            }
            else
            {
                LOG((TL_ERROR, "put_State - lineSetAgentSessionState failed async" ));
            }
        }
        else
        {
            LOG((TL_ERROR, "put_State - lineSetAgentSessionState failed" ));
        }
    }

    LOG((TL_TRACE, hr, "put_State - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : ACDGroup
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_ACDGroup(ITACDGroup **ppACDGroup)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "ACDGroup - enter" ));
    if (!TAPIIsBadWritePtr( ppACDGroup, sizeof(ITACDGroup *) ) )
        {
        Lock();
        *ppACDGroup = m_pGroup;
        Unlock();    
        }
    else
        {
        LOG((TL_ERROR, "get_ACDGroup - bad ppACDGroup pointer"));
        hr = E_POINTER;
        }

    LOG((TL_TRACE, hr, "ACDGroup - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : Address
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_Address(ITAddress **ppAddress)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "Address - enter" ));
    if (!TAPIIsBadWritePtr( ppAddress, sizeof(ITAddress *) ) )
        {
        Lock();
        *ppAddress = m_pReceiveCallsOnThisAddress;
        Unlock();
        }
    else
        {
        LOG((TL_ERROR, "get_Address - bad ppAddress pointer"));
        hr = E_POINTER;
        }
    
    LOG((TL_TRACE, hr, "Address - exit" ));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSession
// Interface : ITAgentSession
// Method    : Agent
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSession::get_Agent(ITAgent **ppAgent)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "Agent - enter" ));
    if (!TAPIIsBadWritePtr( ppAgent, sizeof(ITAgent *) ) )
        {
        Lock();
        *ppAgent = m_pAgent;
        Unlock();
        }
    else
        {
        LOG((TL_ERROR, "get_Agent - bad ppAgent pointer"));
        hr = E_POINTER;
        }
    
    LOG((TL_TRACE, hr, "Agent - exit" ));
    return hr;
}


                            

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





/////////////////////////////////////////////////////////////////////////////
// CAgentSessionEvent


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSessionEvent
// Method    : FireEvent
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
HRESULT CAgentSessionEvent::FireEvent(CAgentSession * pAgentSession, AGENT_SESSION_EVENT event)
{
    HRESULT                           hr = S_OK;
    CComObject<CAgentSessionEvent>  * pEvent;
    IDispatch                       * pIDispatch;
    CAgentHandler                   * pAgentHandler = NULL;


    //
    // create event
    //
    hr = CComObject<CAgentSessionEvent>::CreateInstance( &pEvent );

    if ( SUCCEEDED(hr) )
    {
        //
        // initialize
        //
        pEvent->m_SessionEvent = event;
        pEvent->m_pSession= dynamic_cast<ITAgentSession *>(pAgentSession);
        pEvent->m_pSession->AddRef();
    
        //
        // get idisp interface
        //
        hr = pEvent->QueryInterface( IID_IDispatch, (void **)&pIDispatch );

        if ( SUCCEEDED(hr) )
        {
            //
            // get callback & fire event

            //
            pAgentHandler = pAgentSession->GetAgentHandler();
            if( pAgentHandler != NULL)
            {
                CTAPI *pTapi = pAgentHandler->GetTapi();
                pTapi->Event( TE_AGENTSESSION, pIDispatch );
            }
            // release stuff
            //
            pIDispatch->Release();
            
        }
        else
        {
            STATICLOG((TL_ERROR, "(Event)FireEvent - Could not get disp interface of AgentSessionEvent object"));
            delete pEvent;
        }
    }
    else
    {
        STATICLOG((TL_ERROR, "(Event)FireEvent - Could not create AgentSessionEvent object"));
    }

   
    STATICLOG((TL_TRACE, hr, "(Event)FireEvent - exit"));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSessionEvent
// Method    : FinalRelease
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CAgentSessionEvent::FinalRelease()
{
    m_pSession->Release();

}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSessionEvent 
// Interface : ITAgentSessionEvent
// Method    : Session
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSessionEvent::get_Session(ITAgentSession * * ppSession)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "(Event)Session - enter" ));

    if (!TAPIIsBadWritePtr( ppSession, sizeof(ITAgentSession *) ) )
        {
        *ppSession = m_pSession;
        m_pSession->AddRef();
        }
    else
        {
        LOG((TL_ERROR, "(Event)Session - bad ppSession pointer"));
        hr = E_POINTER;
        }
    
    LOG((TL_TRACE, hr, "(Event)Session - exit"));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class     : CAgentSessionEvent              .
// Interface : ITAgentSessionEvent
// Method    : Event
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentSessionEvent::get_Event(AGENT_SESSION_EVENT * pEvent)
{
    HRESULT  hr = S_OK;


    LOG((TL_TRACE, "Event - enter" ));

    if (!TAPIIsBadWritePtr( pEvent, sizeof(AGENT_SESSION_EVENT) ) )
        {
        *pEvent = m_SessionEvent;
        }
    else
        {
        LOG((TL_ERROR, "Event - bad pEvent pointer"));
        hr = E_POINTER;
        }

    LOG((TL_TRACE, hr, "Event - exit"));
    return hr;
}



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Function  : MapAgentSessionStateFrom3to2
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
DWORD MapAgentSessionStateFrom3to2(AGENT_SESSION_STATE tapi3State)
{
    DWORD tapi2State = 0;

    switch(tapi3State)
    {
        case  ASST_NOT_READY:
            tapi2State = LINEAGENTSESSIONSTATE_NOTREADY;
            break;
        case  ASST_READY:
            tapi2State = LINEAGENTSESSIONSTATE_READY;
            break;
        case  ASST_BUSY_ON_CALL:
            tapi2State = LINEAGENTSESSIONSTATE_BUSYONCALL;
            break;
        case  ASST_BUSY_WRAPUP:
            tapi2State = LINEAGENTSESSIONSTATE_BUSYWRAPUP;
            break;
        case  ASST_SESSION_ENDED:
            tapi2State = LINEAGENTSESSIONSTATE_ENDED;
            break;
        default:
            break;
    }
    
    /*Nikhilb:Assuming that 0 is not a valid state. So if this function 
      returns 0 then it is assumed that it was passed an invalid state*/
    return tapi2State;
}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Function  : MapAgentSessionStateFrom2to3
//
// 
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
HRESULT MapAgentSessionStateFrom2to3(DWORD tapi2State, AGENT_SESSION_STATE  *tapi3State)
{
    HRESULT hr = S_OK;


    if (tapi2State & LINEAGENTSESSIONSTATE_NOTREADY)
    {
        *tapi3State = ASST_NOT_READY;
    }
    else if (tapi2State & LINEAGENTSESSIONSTATE_READY)
    {
        *tapi3State = ASST_READY;
    }
    else if (tapi2State & LINEAGENTSESSIONSTATE_BUSYONCALL)
    {
        *tapi3State = ASST_BUSY_ON_CALL;
    }
    else if (tapi2State & LINEAGENTSESSIONSTATE_BUSYWRAPUP)
    {
        *tapi3State = ASST_BUSY_WRAPUP;
    }
    else if (tapi2State & LINEAGENTSESSIONSTATE_ENDED)
    {
        *tapi3State = ASST_SESSION_ENDED;
    }
    else
    {
        *tapi3State = ASST_NOT_READY;   // default
        hr = E_INVALIDARG;
    }

    return hr;
}