utilities.cpp

Avaya AES Tsapi接口开发的 CallRouting 代码

#include "stdafx.h"

#include <time.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/timeb.h>
#include <string.h>
#include "utilities.h"
#include "global.h"

void outputACSevent( char *func, CSTAEvent_t *eventBufPtr )
{
	if ( ! DBG1 ) return;

	CString retrievedStr;
	CString *cs = new CString;
	CString *csPtr;
	CString *csEventType = makeACSEventTypeStr( eventBufPtr->eventHeader.eventType );
	switch( eventBufPtr->eventHeader.eventClass )
	{
		case ACSCONFIRMATION:
			(void) (void) retrieveFromHashMap( eventBufPtr->event.acsConfirmation.invokeID, retrievedStr );
			cs->Format( "ACSCONFIRMATION: invokeID=%d %s\n   %s", eventBufPtr->event.acsConfirmation.invokeID, retrievedStr.GetString(), csEventType->GetString() );
			switch( eventBufPtr->eventHeader.eventType )
			{
				case ACS_OPEN_STREAM:
				{
					break;
				}
				case ACS_OPEN_STREAM_CONF:
				{
					*cs += "\n   apiVer=";
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.apiVer;
					*cs += " drvrVer=";
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.drvrVer;
					*cs += " libVer=";
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.libVer;
					*cs += " tsrvVer="; 
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.tsrvVer;
					break;
				}
				case ACS_CLOSE_STREAM:
				{
					break;
				}
				case ACS_CLOSE_STREAM_CONF:
				{
					break;
				}
				case ACS_ABORT_STREAM:
				{
					break;
				}
				case ACS_UNIVERSAL_FAILURE:
				case ACS_UNIVERSAL_FAILURE_CONF:
				{
					*cs += "\n   error=";
					csPtr = makeACSUFStr( eventBufPtr->event.acsConfirmation.u.failureEvent.error );
					*cs += csPtr->GetString();
					delete csPtr;
					break; 
				}
				case ACS_KEY_REQUEST:
				{
					break;
				}
				case ACS_KEY_REPLY:
				{
					break;
				}
				case ACS_NAME_SRV_REQUEST:
				{
					break;
				}
				case ACS_NAME_SRV_REPLY:
				{
					break;
				}
				case ACS_AUTH_REPLY:
				{
					break;
				}
				case ACS_AUTH_REPLY_TWO:
				{
					break;
				}
				default:
				{
					*cs += "\n   Invalid eventType Context";
					break;
				}
			}
			break;
		case ACSUNSOLICITED:
			cs->Format( "ACSUNSOLICITED:\n   %s", csEventType->GetString() );
			switch( eventBufPtr->eventHeader.eventType )
			{
				case ACS_UNIVERSAL_FAILURE:
				case ACS_UNIVERSAL_FAILURE_CONF:
				{
					*cs += "\n   ";
					csPtr = makeACSUFStr( eventBufPtr->event.acsUnsolicited.u.failureEvent.error );
					*cs += csPtr->GetString();
					delete csPtr;
					break; 
				}
				default:
				{
					*cs += "\n   Invalid eventType Context";
				}
			}
			break;
		default:
			csPtr = new CString;
			csPtr->Format( "unknown eventClass=%d:\n   %s", eventBufPtr->eventHeader.eventClass, csEventType->GetString() );
			*cs += csPtr->GetString();
			delete csPtr;
			break;
	}
	DBG1_OUT( func, "%s", cs->GetString() );
	delete cs;
	delete csEventType;
}

void outputCSTAevent( char *func, CSTAEvent_t *eventBufPtr, ATTEvent_t *attEvent )
{
	if ( ! DBG1 ) return;

	CString retrievedStr;
	CString *cs = new CString;
	CString *csPtr;
	CString *csEventType = makeCSTAEventTypeStr( eventBufPtr->eventHeader.eventType );
	switch( eventBufPtr->eventHeader.eventClass )
	{
		case CSTACONFIRMATION:
			(void) (void) retrieveFromHashMap( eventBufPtr->event.cstaConfirmation.invokeID, retrievedStr );
			cs->Format( "CSTACONFIRMATION: invokeID=%d %s\n   %s", eventBufPtr->event.cstaConfirmation.invokeID, retrievedStr.GetString(), csEventType->GetString() );
			switch( eventBufPtr->eventHeader.eventType )
			{
				case CSTA_ALTERNATE_CALL_CONF:
				{
					break;
				}
				case CSTA_ANSWER_CALL_CONF:
				{
					break;
				}
				case CSTA_CALL_COMPLETION_CONF:
				{
					break;
				}
				case CSTA_CLEAR_CALL_CONF:
				{
					break;
				}
				case CSTA_CLEAR_CONNECTION_CONF:
				{
					break;
				}
				case CSTA_CONFERENCE_CALL_CONF:
				{
					*cs += "\n   newCall=";
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaConfirmation.u.conferenceCall.newCall );
					*cs += csPtr->GetString();
					delete csPtr;
					*cs += "\n   connList=";
					csPtr = makeConnectionListStr( &eventBufPtr->event.cstaConfirmation.u.conferenceCall.connList );
					*cs += csPtr->GetString();
					delete csPtr;
					break;
				}
				case CSTA_CONSULTATION_CALL_CONF:
				{
					*cs += "\n   newCall=";
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaConfirmation.u.consultationCall.newCall );
					*cs += csPtr->GetString();
					delete csPtr;
					break;
				}
				case CSTA_DEFLECT_CALL_CONF:
				{
					break;
				}
				case CSTA_PICKUP_CALL_CONF:
				{
					break;
				}
				case CSTA_GROUP_PICKUP_CALL_CONF:
				{
					break;
				}
				case CSTA_HOLD_CALL_CONF:
				{
					break;
				}
				case CSTA_MAKE_CALL_CONF:
				{
					break;
				}
				case CSTA_MAKE_PREDICTIVE_CALL_CONF:
				{
					break;
				}
				case CSTA_QUERY_MWI_CONF:
				{
					break;
				}
				case CSTA_QUERY_DND_CONF:
				{
					break;
				}
				case CSTA_QUERY_FWD_CONF:
				{
					break;
				}
				case CSTA_QUERY_AGENT_STATE_CONF:
				{
					break;
				}
				case CSTA_QUERY_LAST_NUMBER_CONF:
				{
					break;
				}
				case CSTA_QUERY_DEVICE_INFO_CONF:
				{
					break;
				}
				case CSTA_RECONNECT_CALL_CONF:
				{
					break;
				}
				case CSTA_RETRIEVE_CALL_CONF:
				{
					break;
				}
				case CSTA_SET_MWI_CONF:
				{
					break;
				}
				case CSTA_SET_DND_CONF:
				{
					break;
				}
				case CSTA_SET_FWD_CONF:
				{
					break;
				}
				case CSTA_SET_AGENT_STATE_CONF:
				{
					break;
				}
				case CSTA_TRANSFER_CALL_CONF:
				{
					break;
				}
				case CSTA_UNIVERSAL_FAILURE_CONF:
				{
					*cs += "\n   ";
					csPtr = makeCSTAUFStr( eventBufPtr->event.cstaConfirmation.u.universalFailure.error );
					*cs += csPtr->GetString();
					delete csPtr;
					break; 
				}
				case CSTA_QUEUED:
				{
					break;
				}
				case CSTA_CALL_INFORMATION:
				{
					break;
				}
				case CSTA_DO_NOT_DISTURB:
				{
					break;
				}
				case CSTA_FORWARDING:
				{
					break;
				}
				case CSTA_MESSAGE_WAITING:
				{
					break;
				}
				case CSTA_LOGGED_ON:
				{
					break;
				}
				case CSTA_LOGGED_OFF:
				{
					break;
				}
				case CSTA_NOT_READY:
				{
					break;
				}
				case CSTA_READY:
				{
					break;
				}
				case CSTA_WORK_NOT_READY:
				{
					break;
				}
				case CSTA_WORK_READY:
				{
					break;
				}
				case CSTA_ROUTE_REGISTER_REQ_CONF:
				{
					csPtr = new CString;
					csPtr->Format( "\n   registerReqID=%ld", eventBufPtr->event.cstaConfirmation.u.routeRegister.registerReqID );
					*cs += csPtr->GetString();
					delete csPtr;
					break;
				}
				case CSTA_ROUTE_REGISTER_CANCEL_CONF:
				{
					break;
				}
				case CSTA_ROUTE_REGISTER_ABORT:
				{
					break;
				}
				case CSTA_ROUTE_REQUEST:
				{
					break;
				}
				case CSTA_ROUTE_SELECT_REQUEST:
				{
					break;
				}
				case CSTA_RE_ROUTE_REQUEST:
				{
					break;
				}
				case CSTA_ROUTE_USED:
				{
					break;
				}
				case CSTA_ROUTE_END:
				{
					break;
				}
				case CSTA_ROUTE_END_REQUEST:
				{
					break;
				}
				case CSTA_ESCAPE_SVC_CONF:
				{
					break;
				}
				case CSTA_ESCAPE_SVC_REQ_CONF:
				{
					break;
				}
				case CSTA_PRIVATE:
				{
					break;
				}
				case CSTA_PRIVATE_STATUS:
				{
					break;
				}
				case CSTA_SEND_PRIVATE:
				{
					break;
				}
				case CSTA_BACK_IN_SERVICE:
				{
					break;
				}
				case CSTA_OUT_OF_SERVICE:
				{
					break;
				}
				case CSTA_REQ_SYS_STAT_CONF:
				{
					break;
				}
				case CSTA_SYS_STAT_START_CONF:
				{
					break;
				}
				case CSTA_SYS_STAT_STOP_CONF:
				{
					break;
				}
				case CSTA_CHANGE_SYS_STAT_FILTER_CONF:
				{
					break;
				}
				case CSTA_SYS_STAT:
				{
					break;
				}
				case CSTA_SYS_STAT_ENDED:
				{
					break;
				}
				case CSTA_SYS_STAT_REQ_CONF:
				{
					break;
				}
				case CSTA_SYS_STAT_EVENT_SEND:
				{
					break;
				}
				case CSTA_MONITOR_DEVICE:
				{
					break;
				}
				case CSTA_MONITOR_CALL:
				{
					break;
				}
				case CSTA_MONITOR_CALLS_VIA_DEVICE:
				{
					break;
				}
				case CSTA_MONITOR_CONF:
				{
					csPtr = new CString;
					csPtr->Format( "\n   monitorCrossRefID=%d", eventBufPtr->event.cstaConfirmation.u.monitorStart.monitorCrossRefID );
					*cs += csPtr->GetString();
					delete csPtr;
					*cs += "\n   monitorFilter=";
					csPtr = makeCSTAMonitorFilterStr( &eventBufPtr->event.cstaConfirmation.u.monitorStart.monitorFilter );
					*cs += csPtr->GetString();
					delete csPtr;
					break;
				}
				case CSTA_CHANGE_MONITOR_FILTER_CONF:
				{
					break;
				}
				case CSTA_MONITOR_STOP_CONF:
				{
					break;
				}
				case CSTA_SNAPSHOT_CALL_CONF:
				{
					*cs += "\n   snapshotData=";
					csPtr = makeCSTASnapshotCallDataStr( &eventBufPtr->event.cstaConfirmation.u.snapshotCall.snapshotData );
					*cs += csPtr->GetString();
					delete csPtr;
					break;
				}
				case CSTA_SNAPSHOT_DEVICE:
				{
					break;
				}
				case CSTA_SNAPSHOT_DEVICE_CONF:
				{
					*cs += "\n   snapshotData=";
					csPtr = makeCSTASnapshotDeviceDataStr( &eventBufPtr->event.cstaConfirmation.u.snapshotDevice.snapshotData );
					*cs += csPtr->GetString();
					delete csPtr;
					break;
				}
				case CSTA_GETAPI_CAPS_CONF:
				{
					break;
				}
				case CSTA_GET_DEVICE_LIST_CONF:
				{
					break;
				}
				case CSTA_QUERY_CALL_MONITOR_CONF:
				{
					break;
				}
				case CSTA_ROUTE_REQUEST_EXT:
				{
					break;
				}
				case CSTA_ROUTE_USED_EXT:
				{
					break;
				}
				case CSTA_ROUTE_SELECT_INV_REQUEST:
				{
					break;
				}
				case CSTA_ROUTE_END_INV_REQUEST:
				{
					break;
				}
				default:
				{
					*cs += "\n   Invalid eventType Context";
					break;
				}
			}
			break;
		case CSTAUNSOLICITED:
			cs->Format( "CSTAUNSOLICITED: monitorCrossRefId=%d\n   %s", eventBufPtr->event.cstaUnsolicited.monitorCrossRefId, csEventType->GetString() );
			switch( eventBufPtr->eventHeader.eventType )
			{
				case CSTA_CONFERENCE_CALL:
				{
					break;
				}