directorynumber.cpp

利用AVAYA AES的TASPI开发的一套软电话系统,仅供参考,ACTIVEX形式的.

STDMETHODIMP CDirectoryNumber::get_AgentState(AGENTSTATES *pVal)
{
	// TODO: Add your implementation code here
	WriteLog("Agent get status service.");
	if (strlen((char*)&m_agentId)>0)
	{// There's a agent has logged in
		BOOL bSave=m_bIsCmdMsg;
		m_bIsCmdMsg=TRUE;
		RetCode_t ret=-1;

		ATTPrivateData_t privateData={0};
		ret=attQueryAgentState(&privateData,(DeviceID_t*)m_agentGroup);

		if (ret==ACSPOSITIVE_ACK)
			ret=cstaQueryAgentState(m_serverHandle,m_invokeId,
									(DeviceID_t*)&m_agentId,
									(PrivateData_t*)&privateData);
		if (ret==ACSPOSITIVE_ACK)
		{
			MSG msg;
			while (GetMessage(&msg,NULL,0,0))
			{
				if (msg.message ==UM_CMDMSG)
				{
					if (msg.wParam ==UM_APIFAILED)
					{
						break;
					}else if (msg.wParam ==CSTA_QUERY_AGENT_STATE_CONF)
					{
						break;
					}else if (msg.wParam ==CSTA_CONNECTION_CLEARED)
					{
						break;
					}
				}
			}
		}
		m_bIsCmdMsg=bSave;
	}
	*pVal=m_agentStat;
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_ErrCode(long *pVal)
{
	// TODO: Add your implementation code here
	*pVal=m_lErrCode;
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_ErrMsg(BSTR *pVal)
{
	// TODO: Add your implementation code here
	*pVal=C2B(m_ErrMsg.c_str());
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_HoldID(long *pVal)
{
	// TODO: Add your implementation code here
	*pVal=m_holdConnId.callID;
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_Logged(BOOL *pVal)
{
	// TODO: Add your implementation code here
	*pVal=m_bLogged;
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_Registered(BOOL *pVal)
{
	// TODO: Add your implementation code here
	*pVal=m_monitorId!=0;
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_ActiveID(long *pVal)
{
	// TODO: Add your implementation code here
	*pVal=m_activeConnId.callID;
	return S_OK;
}



STDMETHODIMP CDirectoryNumber::get_AgentID(BSTR *pVal)
{
	// TODO: Add your implementation code here
	*pVal=C2B((char*)&m_agentId);
	return S_OK;
}


BOOL CDirectoryNumber::GetCallInfo(CSTAHeldEvent_t* pHeldEvent)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pHeldEvent->holdingDevice,sizeof(SubjectDeviceID_t));
	return TRUE;
};

BOOL CDirectoryNumber::GetCallInfo(CSTARetrievedEvent_t* pRetrieveEvent)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pRetrieveEvent->retrievingDevice,sizeof(SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTAConferencedEvent_t* pConfer)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pConfer->confController,sizeof(SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTALoggedOffEvent_t* pLogoff)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pLogoff->agentDevice,sizeof(SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTATransferredEvent_t* pTransfer)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pTransfer->transferringDevice,sizeof(SubjectDeviceID_t));
	memcpy(&m_otherDevice,&pTransfer->transferredDevice,sizeof(SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTADeliveredEvent_t* pDeliverEvent)
{
	BOOL bIsMyAlart=FALSE;
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	if (strcmp((char*)&m_deviceId,(char*)&pDeliverEvent->alertingDevice.deviceID)!=0)
		bIsMyAlart=FALSE;
	else bIsMyAlart=TRUE;

	if (bIsMyAlart)
	{
		memcpy(&m_otherDevice,&pDeliverEvent->callingDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_thisDevice,&pDeliverEvent->alertingDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_ani,&pDeliverEvent->calledDevice.deviceID,sizeof(DeviceID_t));
		memcpy(&m_dnis,&m_deviceId,sizeof(DeviceID_t));
	}else
	{
		memcpy(&m_otherDevice,&pDeliverEvent->calledDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_thisDevice,&pDeliverEvent->callingDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_dnis,&pDeliverEvent->alertingDevice.deviceID,sizeof(DeviceID_t));
		memcpy(&m_ani,&m_deviceId,sizeof(DeviceID_t));
	}

	switch (m_otherDevice.deviceIDType)
	{
	case IMPLICIT_PRIVATE :
	case EXPLICIT_PRIVATE_UNKNOWN :
    case EXPLICIT_PRIVATE_LEVEL3_REGIONAL_NUMBER :
    case EXPLICIT_PRIVATE_LEVEL2_REGIONAL_NUMBER :
    case EXPLICIT_PRIVATE_LEVEL1_REGIONAL_NUMBER :
    case EXPLICIT_PRIVATE_PTN_SPECIFIC_NUMBER :
    case EXPLICIT_PRIVATE_LOCAL_NUMBER :
    case EXPLICIT_PRIVATE_ABBREVIATED :
		m_callType=CT_Internal;
		break;
	default:
		if (bIsMyAlart)
			m_callType=CT_Inbound;
		else 
			m_callType=CT_Outbound;
		break;
	}
	{
		char temp[300]={0};
		wsprintf((char*)&temp,"Ringing: calledDevice %s, callingdevice %s, alertingDevice %s",pDeliverEvent->calledDevice.deviceID ,pDeliverEvent->callingDevice.deviceID ,pDeliverEvent->alertingDevice.deviceID  );
		WriteLog((char*)&temp);
	}
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTALoggedOnEvent_t* pLogon)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pLogon->agentDevice,sizeof (SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber:: GetCallInfo(CSTAOriginatedEvent_t* pOriginated)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pOriginated->callingDevice,sizeof (SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTAFailedEvent_t* pFailed)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pFailed->failingDevice,sizeof (SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTAConnectionClearedEvent_t* pConnclearEvnet)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	memcpy(&m_thisDevice,&pConnclearEvnet->releasingDevice,sizeof (SubjectDeviceID_t));
	return TRUE;
}

BOOL CDirectoryNumber::GetCallInfo(CSTAEstablishedEvent_t* pEstablishEvent)
{
	memset(&m_otherDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_thisDevice,0,sizeof(ExtendedDeviceID_t));
	memset(&m_ani,0,sizeof(DeviceID_t));
	memset(&m_dnis,0,sizeof(DeviceID_t));
	m_callType=CT_Unknown;

	BOOL bIsMyAnswer=FALSE;
	if (strcmp((char*)&m_deviceId,(char*)&pEstablishEvent->answeringDevice.deviceID)!=0)
		bIsMyAnswer=FALSE;
	else bIsMyAnswer=TRUE;

	if (bIsMyAnswer)
	{
		memcpy(&m_otherDevice,&pEstablishEvent->callingDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_thisDevice,&pEstablishEvent->answeringDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_ani,&pEstablishEvent->calledDevice.deviceID,sizeof(DeviceID_t));
		memcpy(&m_dnis,&m_deviceId,sizeof(DeviceID_t));
	}else
	{
		memcpy(&m_otherDevice,&pEstablishEvent->calledDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_thisDevice,&pEstablishEvent->callingDevice,sizeof(CalledDeviceID_t));
		memcpy(&m_dnis,&pEstablishEvent->answeringDevice.deviceID,sizeof(DeviceID_t));
		memcpy(&m_ani,&m_deviceId,sizeof(DeviceID_t));
	}

	switch (m_otherDevice.deviceIDType)
	{
	case IMPLICIT_PRIVATE :
	case EXPLICIT_PRIVATE_UNKNOWN :
    case EXPLICIT_PRIVATE_LEVEL3_REGIONAL_NUMBER :
    case EXPLICIT_PRIVATE_LEVEL2_REGIONAL_NUMBER :
    case EXPLICIT_PRIVATE_LEVEL1_REGIONAL_NUMBER :
    case EXPLICIT_PRIVATE_PTN_SPECIFIC_NUMBER :
    case EXPLICIT_PRIVATE_LOCAL_NUMBER :
    case EXPLICIT_PRIVATE_ABBREVIATED :
		m_callType=CT_Internal;
		break;
	default:
		if (bIsMyAnswer)
			m_callType=CT_Inbound;
		else 
			m_callType=CT_Outbound;
		break;
	}
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::MuteTransfer(BSTR dn, LPKVLIST data)
{
	// TODO: Add your implementation code here
	ATLASSERT(FALSE);
	return TRUE;
}

//monitor the agent split
BOOL CDirectoryNumber::MonitorSplit(AgentGroup_t* agentSplit)
{
	BOOL bRet=FALSE;
	WriteLog("Monitor split service.");
	if (m_splitMonitorId==0)
	{
		//  placed on the monitor in the monitor confirmation event.
		CSTAMonitorFilter_t noFilter;
		noFilter.call = 0;
		noFilter.feature = 0;
		noFilter.agent = 0;
		noFilter.maintenance = 0;
		noFilter.privateFilter = 0;
		BOOL bSave=m_bIsCmdMsg;
		m_bIsCmdMsg=TRUE;
		RetCode_t retCode=cstaMonitorDevice(m_serverHandle,m_invokeId,agentSplit,&noFilter,NULL);
		if (retCode>=0)
		{
			MSG msg;
			BOOL bQuit=FALSE;
			while (GetMessage(&msg,NULL,0,0))
			{
				if (msg.message==UM_CMDMSG)
				{
					switch (msg.wParam)
					{
					case CSTA_MONITOR_CONF:
						bQuit=TRUE;
						bRet=TRUE;
						break;
					case UM_APIFAILED:
						bQuit=TRUE;
						break;
					}
				}
				if (bQuit)
					break;
			}
		}else
		{
			m_lErrCode=retCode;
			m_ErrMsg="cstaMonitorDevice return an error.";
		}
		m_bIsCmdMsg=bSave;
	}else
	{
		bRet=TRUE;
	}
	if (!bRet)
	{
		char tep[300];
		wsprintf((char*)&tep,"error:%s,code:%d.",m_ErrMsg.c_str(),m_lErrCode);
		WriteLog((char*)&tep);
	}
	return bRet;
}

void CDirectoryNumber::StopMonitor(CSTAMonitorCrossRefID_t monitorId)
{
	WriteLog("Stop monitor service.");
	if (monitorId!=0)
	{
		BOOL bSave=m_bIsCmdMsg;
		m_bIsCmdMsg=TRUE;
		RetCode_t retCode=cstaMonitorStop(m_serverHandle,m_invokeId,monitorId,NULL);
		if (retCode==ACSPOSITIVE_ACK)
		{
			MSG msg;
			while (GetMessage(&msg,NULL,0,0))
			{
				if (msg.message==UM_CMDMSG)
				{
					if (msg.wParam==UM_APIFAILED)
						break;
					else if (msg.wParam ==CSTA_MONITOR_STOP_CONF)
						break;
				}
			}
		}
	}
	return ;
}

STDMETHODIMP CDirectoryNumber::get_HoldConnID(BSTR *pVal)
{
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_ActiveConnID(BSTR *pVal)
{
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::ID2ConnID(long id, BSTR *connid)
{
	return S_OK;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::UpdateData(BSTR connid, LPKVLIST data)
{
	return TRUE;
}


STDMETHODIMP_(BOOL) CDirectoryNumber::DeleteData(BSTR connid, BSTR key)
{
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::DeleteAllData(BSTR connid)
{
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::AttachData(BSTR connid, LPKVLIST data)
{
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::CancelForward(FORWARDMODES mode)
{
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::Forward(BSTR dn, FORWARDMODES mode)
{
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::AlternateCall()
{
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::RedirectCall(BSTR dn, BSTR connid)
{
	return TRUE;
}
STDMETHODIMP_(BOOL) CDirectoryNumber::MergeCalls(MERGETYPES type)
{
	return TRUE;
}
STDMETHODIMP_(BOOL) CDirectoryNumber::DeleteFromConference(BSTR dn)
{
	return TRUE;
}
STDMETHODIMP CDirectoryNumber::get_ErrReport(BOOL *pVal)
{
	// TODO: Add your implementation code here
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_DND(BOOL *pVal)
{
	// TODO: Add your implementation code here
	return S_OK;
}

STDMETHODIMP CDirectoryNumber::get_OnHook(BOOL *pVal)
{
	// TODO: Add your implementation code here
	return S_OK;
}
STDMETHODIMP CDirectoryNumber::get_ACDQ(BSTR *pVal)
{
	// TODO: Add your implementation code here
	return S_OK;
}
STDMETHODIMP CDirectoryNumber::get_Type(ADDRTYPES *pVal)
{
	// TODO: Add your implementation code here
	return S_OK;
}
STDMETHODIMP CDirectoryNumber::get_Number(BSTR *pVal)
{
	// TODO: Add your implementation code here
	return S_OK;
}

BOOL CDirectoryNumber::ValidateString(char* pStr,UINT bufLen)
{
	char* pTemp=new char[2*bufLen];
	memset(pTemp,0,2*bufLen*sizeof(char));
	if (pTemp)
	{
		int nTempPos=0;
		for (int nPos=0;pStr[nPos];nPos++)
		{
			if (strlen(pTemp)>=bufLen)
				break;
			if (pStr[nPos]!='/')
			{
				pTemp[nTempPos]=pStr[nPos];
				nTempPos++;
			}else
			{
				pTemp[nTempPos]='/';
				pTemp[nTempPos+1]='/';
				nTempPos+=2;
			}
		}
		strcpy(pStr,pTemp);
		delete pTemp;
	}
	return TRUE;
}

STDMETHODIMP_(BOOL) CDirectoryNumber::SendDTMF(BSTR tone)
{
	// TODO: Add your implementation code here
	BOOL ret=FALSE;
	char pTone[40]={0};
	if (B2C(tone,pTone,sizeof(pTone))&&m_activeConnId.callID!=0)
	{
		ATTPrivateData_t privateData={0};
		if (strlen(pTone)>0)
		{
			RetCode_t retCode=attSendDTMFToneExt(
								&privateData,
								&m_activeConnId,
								NULL,// The reciver, ignored
								(char*)&pTone,//
								0,// tone duration, ignored
								0);//pause duration, ignored
			if (retCode==ACSPOSITIVE_ACK)
			{
				retCode=cstaEscapeService(m_serverHandle,m_invokeId,
									(PrivateData_t *)&privateData);
				if (retCode==ACSPOSITIVE_ACK)
				{
					MSG msg;
					while (GetMessage(&msg,NULL,0,0))
					{
						if (msg.message==UM_CMDMSG)
						{
							if (msg.wParam==CSTA_ESCAPE_SVC_CONF)
							{
								ret=TRUE;
								break;
							}else if (msg.wParam==UM_APIFAILED)
							{
								break;
							}
						}
					}
				}else
				{
					m_lErrCode=retCode;
					m_ErrMsg="cstaEscapeService failed.";
				}
			}else
			{
				m_lErrCode=retCode;
				m_ErrMsg="attSendDTMFToneExt failed.";
			}
		}else
			ret=TRUE;
	}else
	{
		m_lErrCode=LUCENT_INVALID_PARAM;
		m_ErrMsg="Invalid parameter.";
	}
	if (!ret)
	{
		char tep[300];
		wsprintf((char*)&tep,"error:%s,code:%d.",m_ErrMsg.c_str(),m_lErrCode);
		WriteLog((char*)&tep);
	}
	return ret;
}