Source code of Windows XP (NT5)
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.
 
 
 
 
 
 

1579 lines
39 KiB

/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
agent.cpp
Abstract:
Implementation of the Agent object for TAPI 3.0.
CAgent class
CAgentEvent class
Author:
noela - 11/04/97
Notes:
optional-notes
Revision History:
--*/
#include "stdafx.h"
DWORD MapAgentStateFrom3to2(AGENT_STATE tapi3State);
HRESULT MapAgentStateFrom2to3(DWORD tapi2State, AGENT_STATE *tapi3State);
/////////////////////////////////////////////////////////////////////////////
// CAgent
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Method : Initialize
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::Initialize(
HAGENT hAgent,
PWSTR pszUserName,
PWSTR pszID,
PWSTR pszPIN,
CAgentHandler * pHandler
)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "Initialize - enter" ));
m_bRegisteredForAgentEvents = FALSE;
m_bRegisteredForAgentSessionEvents = FALSE;
m_bRequiresUpdating = TRUE;
m_pHandler = pHandler;
m_hAgent = hAgent;
m_AgentState = AS_UNKNOWN;
m_szAgentUserName = NULL;
m_szAgentID = NULL;
m_szPIN = NULL;
if (pszUserName != NULL)
{
m_szAgentUserName = (PWSTR) ClientAlloc((lstrlenW(pszUserName) + 1) * sizeof (WCHAR));
if (m_szAgentUserName != NULL)
{
// Copy the name string
lstrcpyW(m_szAgentUserName,pszUserName);
}
else
{
LOG((TL_ERROR, "Initialize - Alloc m_szAgentUserName failed" ));
hr = E_OUTOFMEMORY;
}
}
else // Agent Name is aNULL string
{
LOG((TL_ERROR, "Initialize - Agent Name is NULL" ));
}
// Now do the Agent ID
if (pszID != NULL)
{
m_szAgentID = (PWSTR) ClientAlloc((lstrlenW(pszID) + 1) * sizeof (WCHAR));
if (m_szAgentID != NULL)
{
lstrcpyW(m_szAgentID,pszID);
}
else
{
LOG((TL_ERROR, "Initialize - Alloc m_szAgentID failed" ));
hr = E_OUTOFMEMORY;
}
}
else // ID is a NULL string
{
LOG((TL_INFO, "Initialize - Agent ID is NULL" ));
}
// Now do the Agent PIN
if (pszPIN != NULL)
{
m_szPIN = (PWSTR) ClientAlloc((lstrlenW(pszPIN) + 1) * sizeof (WCHAR));
if (m_szPIN != NULL)
{
lstrcpyW(m_szPIN,pszPIN);
}
else
{
LOG((TL_ERROR, "Initialize - Alloc m_szPIN failed" ));
hr = E_OUTOFMEMORY;
}
}
else // PIN is a NULL string
{
LOG((TL_INFO, "Initialize - Agent PIN is NULL" ));
}
// Get Agent Info from Proxy
// UpdateInfo();
if ( SUCCEEDED(hr) )
{
// Fire an event here
CAgentEvent::FireEvent(this, AE_UNKNOWN);
}
LOG((TL_TRACE, "Initialize Agent - %S, %S", m_szAgentUserName, m_szAgentID ));
LOG((TL_TRACE, hr, "Initialize - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Method : FinalRelease
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CAgent::FinalRelease()
{
LOG((TL_TRACE, "FinalRelease Agent - %S", m_szAgentUserName ));
if ( m_szAgentUserName != NULL )
{
ClientFree(m_szAgentUserName);
}
if ( m_szAgentID != NULL )
{
ClientFree(m_szAgentID);
}
if (m_szPIN != NULL)
{
ClientFree(m_szPIN);
}
m_AgentSessionArray.Shutdown();
LOG((TL_TRACE, "FinalRelease Agent - exit"));
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Method : UpdateInfo
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::UpdateInfo()
{
HRESULT hr = S_OK;
LINEAGENTINFO AgentInfo;
LOG((TL_TRACE, "UpdateInfo - enter" ));
AgentInfo.dwTotalSize = sizeof(LINEAGENTINFO);
AgentInfo.dwNeededSize = sizeof(LINEAGENTINFO);
AgentInfo.dwUsedSize = sizeof(LINEAGENTINFO);
// **************************************************
// Get Agent Info from Proxy
hr = lineGetAgentInfo(
m_pHandler->getHLine(),
m_hAgent,
&AgentInfo);
if( SUCCEEDED(hr) )
{
// wait for async reply
hr = WaitForReply( hr );
if ( SUCCEEDED(hr) )
{
Lock();
if( FAILED( MapAgentStateFrom2to3(AgentInfo.dwAgentState, &m_AgentState) ) )
{
LOG((TL_ERROR, "UpdateInfo - AgentState is invalid %d - setting to AS_UNKNOWN", AgentInfo.dwAgentState));
}
if( FAILED( MapAgentStateFrom2to3(AgentInfo.dwNextAgentState, &m_NextAgentState) ) )
{
LOG((TL_ERROR, "UpdateInfo - NextAgentState is invalid %d - setting to AS_UNKNOWN",AgentInfo.dwNextAgentState));
}
m_dwMeasurementPeriod = AgentInfo.dwMeasurementPeriod;
m_cyOverallCallRate = AgentInfo.cyOverallCallRate;
m_dwNumberOfACDCalls = AgentInfo.dwNumberOfACDCalls;
m_dwNumberOfIncomingCalls = AgentInfo.dwNumberOfIncomingCalls;
m_dwNumberOfOutgoingCalls = AgentInfo.dwNumberOfOutgoingCalls;
m_dwTotalACDTalkTime = AgentInfo.dwTotalACDTalkTime;
m_dwTotalACDCallTime = AgentInfo.dwTotalACDCallTime;
m_dwTotalACDWrapUpTime = AgentInfo.dwTotalACDWrapUpTime;
m_bRequiresUpdating = FALSE;
Unlock();
}
else
{
LOG((TL_ERROR, "UpdateInfo - call to lineGetAgentInfo failed async" ));
}
}
else
{
LOG((TL_ERROR, "UpdateInfo - call to lineGetAgentInfo failed" ));
}
LOG((TL_TRACE, hr, "UpdateInfo - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Method : CheckIfUpToDate
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::CheckIfUpToDate()
{
HRESULT hr = S_OK;
if (m_bRequiresUpdating)
{
hr = UpdateInfo();
}
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : EnumerateAgentSessions
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::EnumerateAgentSessions(IEnumAgentSession ** ppEnumAgentSession)
{
ITAgent* pITAgent;
CAgent * pAgent;
HRESULT hr = S_OK;
LOG((TL_TRACE, "EnumerateAgentSessions - enter" ));
LOG((TL_TRACE, "EnumerateAgentSessions - ppEnumAgentSessions %p", ppEnumAgentSession ));
if(!TAPIIsBadWritePtr( ppEnumAgentSession, sizeof(IEnumAgentSession *) ) )
{
Lock();
//
// create the enumerator
//
CComObject< CTapiEnum<IEnumAgentSession, ITAgentSession, &IID_IEnumAgentSession> > * pEnum;
hr = CComObject< CTapiEnum<IEnumAgentSession, ITAgentSession, &IID_IEnumAgentSession> > ::CreateInstance( &pEnum );
if ( SUCCEEDED (hr) )
{
//
// initialize it with our Session list
//
pEnum->Initialize(m_AgentSessionArray);
//
// return it
*ppEnumAgentSession = pEnum;
}
else
{
LOG((TL_TRACE, "EnumerateAgentSessions - could not create enum" ));
}
Unlock();
}
else
{
LOG((TL_ERROR, "EnumerateAgentSessions - bad ppEnumAgentSession pointer" ));
hr = E_POINTER;
}
LOG((TL_ERROR, hr, "EnumerateAgentSessions - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : get_AgentSessions
//
// Return a collection of agent sessions
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_AgentSessions(VARIANT * pVariant)
{
HRESULT hr = S_OK;
IDispatch * pDisp = NULL;
LOG((TL_TRACE, "get_AgentSessions - enter"));
if (!TAPIIsBadWritePtr( pVariant, sizeof(VARIANT) ) )
{
//
// create the collection
//
CComObject< CTapiCollection< ITAgentSession > > * p;
hr = CComObject< CTapiCollection< ITAgentSession > >::CreateInstance( &p );
if (SUCCEEDED(hr) )
{
// initialize it with our address list
Lock();
hr = p->Initialize( m_AgentSessionArray );
Unlock();
if ( SUCCEEDED(hr) )
{
// get the IDispatch interface
hr = p->_InternalQueryInterface( IID_IDispatch, (void **) &pDisp );
if ( SUCCEEDED(hr) )
{
// put it in the variant
VariantInit(pVariant);
pVariant->vt = VT_DISPATCH;
pVariant->pdispVal = pDisp;
}
else
{
LOG((TL_ERROR, "get_AgentSessions - could not get IDispatch interface" ));
delete p;
}
}
else
{
LOG((TL_ERROR, "get_AgentSessions - could not initialize collection" ));
delete p;
}
}
else
{
LOG((TL_ERROR, "get_AgentSessions - could not create collection" ));
}
}
else
{
LOG((TL_ERROR, "get_AgentSessions - bad pVariant pointer" ));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "get_AgentSessions - exit"));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : RegisterAgentEvents
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::RegisterAgentEvents(VARIANT_BOOL bNotify)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "RegisterAgentEvents - enter" ));
m_bRegisteredForAgentEvents = bNotify;
LOG((TL_TRACE, "RegisterAgentEvents - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : RegisterAgentSessionEvents
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::RegisterAgentSessionEvents(VARIANT_BOOL bNotify)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "RegisterAgentSessionEvents - enter" ));
m_bRegisteredForAgentSessionEvents = bNotify;
LOG((TL_TRACE, hr, "RegisterAgentSessionEvents - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : CreateSessionWithPIN
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::CreateSessionWithPIN(ITACDGroup * pACDGroup,
ITAddress * pAddress,
BSTR pPIN,
ITAgentSession ** ppAgentSession
)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "CreateSessionWithPIN - enter" ));
if ( agentHasID() )
{
if(!TAPIIsBadWritePtr( ppAgentSession, sizeof(ITAgentSession *) ) )
{
if (!IsBadStringPtrW( pPIN, -1 ))
{
// Pointer OK, is it empty ?
if( pPIN != NULL)
{
hr = InternalCreateSession(pACDGroup, pAddress, pPIN, ppAgentSession);
}
else // PIN is NULL
{
LOG((TL_ERROR, "CreateSessionWithPIN - failed, PIN is NULL"));
hr = E_INVALIDARG;
}
}
else // bad BSTR pointer
{
LOG((TL_ERROR, "CreateSessionWithPIN - invalid pPIN pointer" ));
hr = E_POINTER;
}
}
else
{
LOG((TL_ERROR, "CreateSessionWithPIN - invalid ppAgentSession pointer" ));
hr = E_POINTER;
}
}
else // no ID
{
LOG((TL_ERROR, "CreateSessionWithPIN - Agent not created by CreateAgentWithID()" ));
hr = TAPI_E_CALLCENTER_NO_AGENT_ID;
}
LOG((TL_TRACE, hr, "CreateSessionWithPIN - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : CreateSession
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::CreateSession(ITACDGroup * pACDGroup,
ITAddress * pAddress,
ITAgentSession ** ppAgentSession
)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "CreateSession - enter" ));
if(!TAPIIsBadWritePtr( ppAgentSession, sizeof(ITAgentSession *) ) )
{
hr = InternalCreateSession(pACDGroup, pAddress, m_szPIN, ppAgentSession);
}
else
{
LOG((TL_ERROR, "CreateSession - invalid ppAgentSession pointer" ));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "CreateSession - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : CreateSession
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::InternalCreateSession(ITACDGroup * pACDGroup,
ITAddress * pAddress,
PWSTR pszPIN,
ITAgentSession ** ppAgentSession)
{
HAGENTSESSION hAgentSession;
LINEAGENTENTRY Agent;
DWORD dwAddressID;
GUID GroupID;
CACDGroup * pGroup = NULL;
CAddress * pCAddress = NULL;
CComObject<CAgentSession> * pAgentSession;
AddressLineStruct * pAddressLine;
HRESULT hr = S_OK;
LOG((TL_TRACE, "InternalCreateSession - enter" ));
// check for a valid ACD group & get its address ID
pGroup = dynamic_cast<CComObject<CACDGroup>*>(pACDGroup);
if (pGroup != NULL)
{
GroupID = pGroup->getID();
// check for a valid address & get its address ID
pCAddress = dynamic_cast<CComObject<CAddress>*>(pAddress);
if (pCAddress != NULL)
{
dwAddressID = pCAddress->GetAddressID();
hr = pCAddress->FindOrOpenALine (LINEMEDIAMODE_INTERACTIVEVOICE, &pAddressLine);
if(SUCCEEDED(hr) )
{
// All OK so far, try to create session (sends request to proxy)
hr = LineCreateAgentSession(
pAddressLine->t3Line.hLine,
m_hAgent,
pszPIN,
dwAddressID,
&GroupID,
&hAgentSession
);
if ( SUCCEEDED(hr) )
{
hr = WaitForReply( hr );
if ( SUCCEEDED(hr) )
{
LOG((TL_INFO, "InternalCreateSession - create new session" ));
hr = CComObject<CAgentSession>::CreateInstance( &pAgentSession );
if ( SUCCEEDED(hr) )
{
ITAgentSession * pITAgentSession;
hr = pAgentSession->QueryInterface(IID_ITAgentSession, (void **)&pITAgentSession);
if ( SUCCEEDED(hr) )
{
// initialize the Agent
hr = pAgentSession->Initialize(
hAgentSession,
this,
pACDGroup,
pAddress,
m_pHandler,
pAddressLine
);
if ( SUCCEEDED(hr) )
{
// add to list
Lock();
m_AgentSessionArray.Add( pITAgentSession );
Unlock();
pITAgentSession->Release();
// This is the clients reference
pAgentSession->AddRef();
try
{
// set return value
*ppAgentSession = pAgentSession;
}
catch(...)
{
hr = E_POINTER;
}
}
else //(FAILED (hr) ) pAgentSession->Initialize
{
LOG((TL_ERROR, "InternalCreateSession - failed to initialize new object" ));
delete pAgentSession;
}
}
else //(FAILED (hr) ) pAgentSession->QueryInterface
{
LOG((TL_ERROR, "InternalCreateSession - failed to query interface" ));
delete pAgentSession;
}
}
else //(FAILED (hr) ) CreateInstance
{
LOG((TL_ERROR, "InternalCreateSession - createInstance failed for COM object" ));
}
}
else // LineCreateAgentSession failed async
{
LOG((TL_ERROR, "InternalCreateSession - LineCreateAgentSession failed async" ));
}
}
else //(FAILED (hr) ) LineCreateAgentSession
{
LOG((TL_ERROR, "InternalCreateSession - LineCreateAgentSession failed" ));
}
}
else
{
LOG((TL_ERROR, "InternalCreateSession - Failed to open a line for the target Address" ));
hr = E_UNEXPECTED;
}
}
else //(pCAddress == NULL)
{
LOG((TL_ERROR, "InternalCreateSession - invalid Destination Address" ));
hr = E_INVALIDARG;
}
}
else //(pGroup == NULL)
{
LOG((TL_ERROR, "InternalCreateSession - invalid ACDGroup" ));
hr = E_INVALIDARG;
}
LOG((TL_TRACE, hr, "InternalCreateSession - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : ID
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_ID(BSTR * pID)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "ID - enter" ));
Lock();
if ( !agentHasID() )
{
LOG((TL_ERROR, "ID - Agent not created by CreateAgentWithID()" ));
hr = TAPI_E_CALLCENTER_NO_AGENT_ID;
}
if(!TAPIIsBadWritePtr( pID, sizeof(BSTR) ) )
{
if (m_szAgentID == NULL)
{
*pID = NULL;
}
else
{
*pID = SysAllocString(m_szAgentID);
if (*pID == NULL)
{
hr = E_OUTOFMEMORY;
}
}
}
else
{
LOG((TL_ERROR, "ID - bad pID pointer" ));
hr = E_POINTER;
}
Unlock();
LOG((TL_TRACE, hr, "ID - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : User
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_User(BSTR * ppUser)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "User - enter" ));
Lock();
if(!TAPIIsBadWritePtr( ppUser, sizeof(BSTR) ) )
{
*ppUser = SysAllocString(m_szAgentUserName);
if (*ppUser == NULL)
{
hr = E_OUTOFMEMORY;
}
}
else
{
LOG((TL_ERROR, "User - bad ppUser pointer" ));
hr = E_POINTER;
}
Unlock();
LOG((TL_TRACE, hr, "User - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : put_State
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::put_State(AGENT_STATE AgentState)
{
HRESULT hr = S_OK;
HLINE hLine;
DWORD dwState = 0;
LOG((TL_TRACE, "put_State - enter" ));
Lock();
hLine = (GetAgentHandler() )->getHLine();
Unlock();
dwState = MapAgentStateFrom3to2(AgentState);
hr = lineSetAgentStateEx
(hLine,
m_hAgent,
dwState,
0 //MapAgentStateFrom3to2(m_NextAgentState)
);
if( SUCCEEDED(hr) )
{
// wait for async reply
hr = WaitForReply( hr );
if ( SUCCEEDED(hr) )
{
Lock();
m_AgentState = AgentState;
Unlock();
switch(AgentState) {
case AS_NOT_READY:
CAgentEvent::FireEvent(this, AE_NOT_READY);
break;
case AS_READY:
CAgentEvent::FireEvent(this, AE_READY);
break;
case AS_BUSY_ACD:
CAgentEvent::FireEvent(this, AE_BUSY_ACD);
break;
case AS_BUSY_INCOMING:
CAgentEvent::FireEvent(this, AE_BUSY_INCOMING);
break;
case AS_BUSY_OUTGOING:
CAgentEvent::FireEvent(this, AE_BUSY_OUTGOING);
case AS_UNKNOWN:
CAgentEvent::FireEvent(this, AE_UNKNOWN);
break;
}
}
else
{
LOG((TL_ERROR, "put_State - lineSetAgentStateEx failed async" ));
}
}
else
{
LOG((TL_ERROR, "put_State - lineSetAgentStateEx failed" ));
}
LOG((TL_TRACE, hr, "put_State - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : get_State
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_State(AGENT_STATE * pAgentState)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "get_State - enter" ));
if(!TAPIIsBadWritePtr( pAgentState, sizeof(AGENT_STATE) ) )
{
Lock();
*pAgentState = m_AgentState;
Unlock();
}
else
{
LOG((TL_ERROR, "get_State - bad pAgentState pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "get_State - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : put_MeasurementPeriod
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::put_MeasurementPeriod(long ulPeriod)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "put_MeasurementPeriod - enter" ));
// Tell Proxy
hr = lineSetAgentMeasurementPeriod(
m_pHandler->getHLine(),
m_hAgent,
ulPeriod);
if( SUCCEEDED(hr) )
{
// wait for async reply
hr = WaitForReply( hr );
if ( SUCCEEDED(hr) )
{
Lock();
m_dwMeasurementPeriod = ulPeriod;
Unlock();
}
else
{
LOG((TL_ERROR, "put_MeasurementPeriod - call to LineSetAgentMeasurementPeriod failed async" ));
}
}
else
{
LOG((TL_ERROR, "put_MeasurementPeriod - call to LineSetAgentMeasurementPeriod failed" ));
}
LOG((TL_TRACE, hr, "put_MeasurementPeriod - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : get_MeasurementPeriod
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_MeasurementPeriod(long * pulPeriod)
{
HRESULT hr = S_OK;
DWORD period;
LOG((TL_TRACE, "get_MeasurementPeriod - enter" ));
if(!TAPIIsBadWritePtr( pulPeriod, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulPeriod = m_dwMeasurementPeriod;
Unlock();
}
else
{
LOG((TL_ERROR, "get_MeasurementPeriod - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_MeasurementPeriod -bad pulPeriod pointer" ));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "get_MeasurementPeriod - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : OverallCallrate
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_OverallCallRate(CURRENCY * pcyCallrate)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "OverallCallrate - enter" ));
if (!TAPIIsBadWritePtr( pcyCallrate, sizeof(CURRENCY) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pcyCallrate = m_cyOverallCallRate;
Unlock();
}
else
{
LOG((TL_ERROR, "get_OverallCallRate - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_OverallCallRate - bad pcyCallrate pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "OverallCallrate - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : NumberOfACDCalls
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_NumberOfACDCalls(long * pulCalls)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "NumberOfACDCalls - enter" ));
if (!TAPIIsBadWritePtr( pulCalls, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulCalls = m_dwNumberOfACDCalls;
Unlock();
}
else
{
LOG((TL_ERROR, "get_NumberOfACDCalls - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_NumberOfACDCalls - bad pulCalls pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "NumberOfACDCalls - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : NumberOfIncomingCalls
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_NumberOfIncomingCalls(long * pulCalls)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "NumberOfIncomingCalls - enter" ));
if (!TAPIIsBadWritePtr( pulCalls, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulCalls = m_dwNumberOfIncomingCalls;
Unlock();
}
else
{
LOG((TL_ERROR, "get_NumberOfIncomingCalls - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_NumberOfIncomingCalls - bad pulCalls pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "NumberOfIncomingCalls - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : NumberOfOutgoingCalls
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_NumberOfOutgoingCalls(long * pulCalls)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "NumberOfOutgoingCalls - enter" ));
if (!TAPIIsBadWritePtr( pulCalls, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulCalls = m_dwNumberOfOutgoingCalls;
Unlock();
}
else
{
LOG((TL_ERROR, "get_NumberOfOutgoingCalls - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_NumberOfOutgoingCalls - bad pulCalls pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "NumberOfOutgoingCalls - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : TotalACDTalkTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_TotalACDTalkTime(long * pulTalkTime)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "TotalACDTalkTime - enter" ));
if (!TAPIIsBadWritePtr( pulTalkTime, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulTalkTime = m_dwTotalACDTalkTime;
Unlock();
}
else
{
LOG((TL_ERROR, "get_TotalACDTalkTime - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_TotalACDTalkTime - bad pulTalkTime pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "TotalACDTalkTime - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : TotalACDCallTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_TotalACDCallTime(long * pulCallTime)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "TotalACDCallTime - enter" ));
if (!TAPIIsBadWritePtr( pulCallTime, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulCallTime = m_dwTotalACDCallTime;
Unlock();
}
else
{
LOG((TL_ERROR, "get_TotalACDCallTime - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_TotalACDCallTime - bad pulCallTime pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "TotalACDCallTime - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : TotalWrapUpTime
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::get_TotalWrapUpTime(long * pulWrapUpTime)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "TotalWrapUpTime - enter" ));
if (!TAPIIsBadWritePtr( pulWrapUpTime, sizeof(long) ) )
{
hr = CheckIfUpToDate();
if ( SUCCEEDED(hr) )
{
Lock();
*pulWrapUpTime = m_dwTotalACDWrapUpTime;
Unlock();
}
else
{
LOG((TL_ERROR, "get_TotalWrapUpTime - Object update failed"));
}
}
else
{
LOG((TL_ERROR, "get_TotalWrapUpTime - bad pulWrapUpTime pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "TotalWrapUpTime - exit" ));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgent
// Interface : ITAgent
// Method : put_PIN
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgent::put_PIN(BSTR pPIN)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "put_PIN - enter" ));
if (!IsBadStringPtrW( pPIN, -1 ))
{
// Pointer OK, is it empty ?
if( pPIN != NULL)
{
// do we have an existng PIN ?
if (m_szPIN != NULL)
{
LOG((TL_INFO, "put_PIN - Overwrite exising PIN"));
ClientFree(m_szPIN);
}
// Alloc space for new PIN
m_szPIN = (PWSTR) ClientAlloc((lstrlenW(pPIN) + 1) * sizeof (WCHAR));
if (m_szPIN != NULL)
{
lstrcpyW(m_szPIN, pPIN);
}
else
{
LOG((TL_ERROR, "put_PIN - ClientAlloc m_szPIN failed" ));
hr = E_OUTOFMEMORY;
}
}
else // PIN is NULL
{
LOG((TL_ERROR, "put_PIN - failed, PIN is NULL"));
hr = E_INVALIDARG;
}
}
else // bad BSTR pointer
{
LOG((TL_ERROR, "put_PIN - invalid pointer" ));
return E_POINTER;
}
LOG((TL_TRACE, hr, "put_PIN - exit" ));
return hr;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CAgentEvent
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgentEvent
// Method : FireEvent
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
HRESULT CAgentEvent::FireEvent(CAgent* pAgent, AGENT_EVENT Event)
{
HRESULT hr = S_OK;
CComObject<CAgentEvent> * pEvent;
IDispatch * pIDispatch;
//
// create event
//
hr = CComObject<CAgentEvent>::CreateInstance( &pEvent );
if ( SUCCEEDED(hr) )
{
//
// initialize
//
pEvent->m_AgentEvent = Event;
pEvent->m_pAgent= dynamic_cast<ITAgent *>(pAgent);
pEvent->m_pAgent->AddRef();
//
// get idisp interface
//
hr = pEvent->QueryInterface( IID_IDispatch, (void **)&pIDispatch );
if ( SUCCEEDED(hr) )
{
//
// get callback & fire event
//
CTAPI *pTapi = (pAgent->GetAgentHandler() )->GetTapi();
pTapi->Event( TE_AGENT, pIDispatch );
// release stuff
//
pIDispatch->Release();
}
else
{
STATICLOG((TL_ERROR, "(Event)FireEvent - Could not get disp interface of AgentEvent object"));
delete pEvent;
}
}
else
{
STATICLOG((TL_ERROR, "(Event)FireEvent - Could not create AgentEvent object"));
}
STATICLOG((TL_TRACE, hr, "(Event)FireEvent - exit"));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgentEvent
// Method : FinalRelease
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CAgentEvent::FinalRelease()
{
m_pAgent->Release();
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgentEvent
// Interface : ITAgentEvent
// Method : Agent
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentEvent::get_Agent(ITAgent ** ppAgent)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "(Event)Agent - enter" ));
if(!TAPIIsBadWritePtr( ppAgent, sizeof(ITAgent *) ) )
{
*ppAgent = m_pAgent;
m_pAgent->AddRef();
}
else
{
LOG((TL_ERROR, "(Event)Agent - bad ppAgent pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "(Event)Agent - exit"));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Class : CAgentEvent
// Interface : ITAgentEvent
// Method : Event
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
STDMETHODIMP CAgentEvent::get_Event(AGENT_EVENT * pEvent)
{
HRESULT hr = S_OK;
LOG((TL_TRACE, "Event - enter" ));
if(!TAPIIsBadWritePtr( pEvent, sizeof(AGENT_EVENT) ) )
{
*pEvent = m_AgentEvent;
}
else
{
LOG((TL_ERROR, "Event - bad pEvent pointer"));
hr = E_POINTER;
}
LOG((TL_TRACE, hr, "Event - exit"));
return hr;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Function : MapAgentStateFrom3to2
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
DWORD MapAgentStateFrom3to2(AGENT_STATE tapi3State)
{
DWORD tapi2State = 0;
switch(tapi3State)
{
case AS_NOT_READY:
tapi2State = LINEAGENTSTATEEX_NOTREADY;
break;
case AS_READY:
tapi2State = LINEAGENTSTATEEX_READY;
break;
case AS_BUSY_ACD:
tapi2State = LINEAGENTSTATEEX_BUSYACD;
break;
case AS_BUSY_INCOMING:
tapi2State = LINEAGENTSTATEEX_BUSYINCOMING;
break;
case AS_BUSY_OUTGOING:
tapi2State = LINEAGENTSTATEEX_BUSYOUTGOING;
break;
case AS_UNKNOWN:
tapi2State = LINEAGENTSTATEEX_UNKNOWN;
break;
default:
break;
}
return tapi2State;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Function : MapAgentStateFrom2to3
//
//
//
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
HRESULT MapAgentStateFrom2to3(DWORD tapi2State, AGENT_STATE *tapi3State)
{
HRESULT hr = S_OK;
if (tapi2State & LINEAGENTSTATEEX_NOTREADY)
{
*tapi3State = AS_NOT_READY;
}
else if (tapi2State & LINEAGENTSTATEEX_READY)
{
*tapi3State = AS_READY;
}
else if (tapi2State & LINEAGENTSTATEEX_BUSYACD)
{
*tapi3State = AS_BUSY_ACD;
}
else if (tapi2State & LINEAGENTSTATEEX_BUSYINCOMING)
{
*tapi3State = AS_BUSY_INCOMING;
}
else if (tapi2State & LINEAGENTSTATEEX_BUSYOUTGOING)
{
*tapi3State = AS_BUSY_OUTGOING;
}
else if (tapi2State & LINEAGENTSTATEEX_UNKNOWN)
{
*tapi3State = AS_UNKNOWN;
}
else
{
*tapi3State = AS_UNKNOWN; // default
hr = E_INVALIDARG;
}
return hr;
}