cstatst2.cpp

csta协议的开发

// cstatst.cpp : Defines the class behaviors for the application.
//

#include "stdafx.h"
#include "cstatst32.h"
#include "dialog.h"
#include "mdump.h"
#include "viola.h"
#include "GenerateToneDlg.h"
#include "CancelToneDlg.h"
#include "StartDataCollDlg.h"
#include "StopDataCollDlg.h"
//#include "DataCollectedDlg.h"

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

extern char * recPrivateData; /*YB 131102*/

////////  CSTA Computing function services  ////////

/*void CMainWind::CSTARouteRegisterReq() {
  CRouteRegister dlg;
  
  if (dlg.DoModal() == IDOK) {
    DeviceID_t deviceID1 = "35500";
    DeviceID_t deviceID2 = "35511";

    //strcpy (deviceID, dlg.m_sRoutingDevice);
    m_nRetCode = cstaRouteRegisterReq (m_acsHandle,
                    0,
                    &deviceID1,
                    pPrivateData);      
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaRouteRegisterReq", m_nRetCode);
      return;
    }
    m_nRetCode = cstaRouteRegisterReq (m_acsHandle,
                    0,
                    &deviceID2,
                    pPrivateData);      
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaRouteRegisterReq", m_nRetCode);
      return;
    }
    CString eventString;
    
    DisplayEventTitle ("CSTA REQUEST Route Register Request:");
	eventString += "          Route Register Req:";
    eventString += dlg.m_sRoutingDevice;
    DisplayString (eventString);
  }
}
*/
void CMainWind::CSTARouteRegisterReq() {
  CRouteRegister dlg;
  
  if (dlg.DoModal() == IDOK) {
    DeviceID_t deviceID;

    strcpy (deviceID, dlg.m_sRoutingDevice);
/*YB 221102+*/    
	char privData[SIZE_OF_ALCATEL_PRIVATE_DATA];
	memset (privData,0,SIZE_OF_ALCATEL_PRIVATE_DATA);
	
	CstaCommonArguments_t *cstaCommonArgumentsPt = (CstaCommonArguments_t*) ((PrivateData_t FAR*)privData)->data;
	
	cstaCommonArgumentsPt->privateData.numberOfPrivateData =1;
	cstaCommonArgumentsPt->privateData.AlcCstaPrivPtOffsetArray[0]=0;
	CstaServiceOption_t my_cstaServiceOption = 0;
	if(dlg.m_bBackUp)
		my_cstaServiceOption |= SO_BACKUP_ROUTING;
	
	AlcatelCstaPrivObject_t *alcatelCstaPrivObjectPt = (AlcatelCstaPrivObject_t*)((char*) cstaCommonArgumentsPt->privateData.privateHeap);
	alcatelCstaPrivObjectPt->objectId = cstaServiceOption_Id;
	alcatelCstaPrivObjectPt->u.cstaServiceOption = my_cstaServiceOption;
	CopyPrivateData(1,cstaCommonArgumentsPt, privData);
/*YB 221102-*/    

    m_nRetCode = cstaRouteRegisterReq (m_acsHandle,
                    0,
                    &deviceID,
                    (PrivateData_t*)privData);/*YB 221102*/
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaRouteRegisterReq", m_nRetCode);
      return;
    }
    CString eventString;
    
    DisplayEventTitle ("CSTA REQUEST Route Register Request:");
	eventString += "          Route Register Req:";
    eventString += dlg.m_sRoutingDevice;
    DisplayString (eventString);
  }
} 
void CMainWind::CstaRouteRegisterReqConfEvent() { 
  CString eventString;                                                       
  char str[15];
 
  eventString = "CSTA CONFIRM Route Register Req - Route Register Req ID: ";
  sprintf(str, "%ld", m_cstaEvent.event.cstaConfirmation.u.routeRegister.registerReqID);
  eventString += str;
  DisplayTheEvent(eventString);
}

void CMainWind::CSTARouteRegisterCancel() {
  CRouteRegisterCancelDlg dlg;
  char strCrossRefID [15];
  
  if (dlg.DoModal () == IDOK) {
    m_nRetCode = cstaRouteRegisterCancel (m_acsHandle,
                    0,
                    dlg.m_nRouteRegID,
                    pPrivateData);
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaRouteRegisterCancel", m_nRetCode);
      return;
    }
    CString eventString;
  
    DisplayEventTitle("CSTA REQUEST Route Register Cancel - Route Register ID: ");
    sprintf (strCrossRefID, "%ld", dlg.m_nRouteRegID);
    eventString += strCrossRefID; 
    DisplayTheEvent (eventString);
  }
}

void CMainWind::CstaRouteRegisterCancelConfEvent() {
  CString eventString;                                                       
  char str[15];
  
  eventString = "CSTA CONFIRM Route Cancel Req - Route Register Req ID: ";
  sprintf(str, "%ld", m_cstaEvent.event.cstaConfirmation.u.routeCancel.routeRegisterReqID);
  eventString += str;
  DisplayTheEvent(eventString);
}

void CMainWind::CstaRouteRegisterAbortEvent() {
  CString eventString;                                                       
  char str[15];
  
  eventString = "CSTA EVENT REPORT Route Register Abort - Route Register Req ID: ";
  sprintf(str, "%ld", m_cstaEvent.event.cstaEventReport.u.registerAbort.routeRegisterReqID);
  eventString += str;
  DisplayTheEvent(eventString);
}

void CMainWind::CstaRouteRequestEvent() { 
  CString eventString;
  char str[100];
  CSTARouteRequestExtEvent_t* pEvt;
  pEvt = &m_cstaEvent.event.cstaRequest.u.routeRequestExt; 
  DisplayEventTitle("CSTA REQUEST Route Request Event:");
  eventString += "          Route Register Req ID:";
  sprintf(str, "%ld", pEvt->routeRegisterReqID);
  eventString += str;
  eventString += "   Routing Cross Ref ID: ";
  sprintf(str, "%ld", pEvt->routingCrossRefID);
  eventString += str;                      
  DisplayString(eventString);
  eventString = "          Current Route: ";
  eventString += AddExtendedDeviceID (pEvt->currentRoute);
  eventString += "    Calling Device: ";
  eventString += AddExtendedDeviceID (pEvt->callingDevice);
  DisplayString(eventString);  
  eventString = "          Routed Call : ";
  eventString += AddConnectionID(pEvt->routedCall);
  DisplayString(eventString);
  eventString = "          Routed Sel Algorithm: ";
  switch (pEvt->routedSelAlgorithm) {
    case SV_NORMAL :
      eventString += "SV_NORMAL";
      break;
    case SV_LEAST_COST :
      eventString += "SV_LEAST_COST";
      break;
    case SV_EMERGENCY :
      eventString += "SV_EMERGENCY";
      break;
    case SV_ACD :
      eventString += "SV_ACD";
      break;
    case SV_USER_DEFINED :
      eventString += "SV_USER_DEFINED";
      break;
    default :
      eventString += "UNKNOWN";
      break;
  }                          
  eventString += "     Priority: ";
  if (pEvt->priority)
    eventString += "TRUE";
  else
    eventString += "FALSE";
	DisplayString(eventString);

	// Process the ISDN class
    eventString = "          Setup Info: ";
	DisplayString(eventString);
	DeviceProfile_t2	*deviceProfilePt = (DeviceProfile_t2*) (  (char *) &(m_cstaEvent.event.cstaRequest.u.routeRequestExt)
							+ (sizeof (CSTARouteRequestExtEvent_t)));


	eventString.Format ("               ISDN class: ");
 	switch (deviceProfilePt->deviceClass){
	case DC_VOICE:
		eventString += "DC_VOICE";
	break;
	case DC_DATA:
		eventString += "DC_DATA";
	break;
	case DC_IMAGE:
		eventString += "DC_IMAGE";
	break;
	case DC_OTHER:
		eventString += "DC_OTHER";
	break;
	case DC_AUDIO:
		eventString += "DC_AUDIO";
	break;
	}
	DisplayString(eventString);

	// process the ISDN setup
	char buffer [258];
	memset (buffer,0,258);
	int i;
	setupValue_t2 my_setUpValue;
	memset(my_setUpValue,0,129);
	memcpy(my_setUpValue,deviceProfilePt->ISDNSetup,pEvt->setupInformation.length);
	//Csta_Buffer	*my_Csta_Buffer;
	//my_Csta_Buffer =  (Csta_Buffer*) my_setUpValue;
		for (i=0 ; i < pEvt->setupInformation.length; i++){
			sprintf (&buffer[2 * i], "% 02x",( unsigned char ) my_setUpValue[i]);
	}
	eventString = "               Set Up Value: ";

	eventString += buffer;
	DisplayString (eventString);
/*YB 131102+*/
	if (((PrivateData_t*)&recPrivateData)->length != 0){
		DisplayPrivateData((PrivateData_t*)&recPrivateData);
	}
/*YB 131102-*/

}

void CMainWind::CstaReRouteEvent() {
  CString eventString;                                                       
  char str[15];
  
  DisplayEventTitle("CSTA REQUEST Re Route:");
  eventString += "      Route Register Req ID:";
  sprintf(str, "%ld", m_cstaEvent.event.cstaRequest.u.reRouteRequest.routeRegisterReqID);
  eventString += str;
  eventString += "     Routing Cross Ref ID: ";
  sprintf(str, "%ld", m_cstaEvent.event.cstaRequest.u.reRouteRequest.routingCrossRefID);
  eventString += str;
  DisplayString(eventString);
  /*YB 131102+*/
	if (((PrivateData_t*)&recPrivateData)->length != 0){
		DisplayPrivateData((PrivateData_t*)&recPrivateData);
	}
/*YB 131102-*/

}
/*
void CMainWind::CSTARouteSelect() {
  CRouteSelectDlg dlg;
  char str[15];
  
  if (dlg.DoModal() == IDOK) {
    DeviceID_t deviceID;
    SetUpValues_t setupInfo;
    char info[100];
	int i = 1;
    
	for ( i ; i < 100; i++)
	{
    //strcpy(deviceID, dlg.m_sRouteSelected);
    strcpy(deviceID, "31001");
    strcpy(info, dlg.m_sSetupInfo);
    setupInfo.length = 0;
    setupInfo.value = NULL;
	Sleep (800);
    m_nRetCode = cstaRouteSelectInv(m_acsHandle,
									0,
                                 1,
                                 1,
                                 &deviceID,
                                 dlg.m_nRemainRetry,
                                 &setupInfo,
                                 dlg.m_bRouteUsed,
                                 pPrivateData);
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaRouteSelect", m_nRetCode);
      return;
    }
    CString eventString;
  
    DisplayEventTitle("CSTA REQUEST Route Select:");
	eventString += "     Route Register ID:";
    sprintf (str, "%ld", dlg.m_nRouteRegID);
    eventString += str;           
    eventString += "   Routing Cross Ref ID: ";
    sprintf(str, "%ld", dlg.m_nRoutingCRID);
    eventString += str;
    DisplayString (eventString);
    eventString = "                 Route Selected: ";
    eventString += dlg.m_sRouteSelected;
    eventString += "   Remain retry: ";
    sprintf(str, "%d", dlg.m_nRemainRetry);
    eventString += str;
    eventString += "   Setup Info: ";
    eventString += dlg.m_sSetupInfo;
    eventString += "   Route Used: ";
    if (dlg.m_bRouteUsed)
      eventString += "TRUE";
    else
      eventString += "FALSE";
    DisplayString (eventString);

	}// for

  }
}

*/  
void CMainWind::CSTARouteSelect() {
  CRouteSelectDlg dlg;
  char str[15];
  
  if (dlg.DoModal() == IDOK) {
    DeviceID_t deviceID;
    SetUpValues_t setupInfo;
    char info[100];
/*YB 221102+*/    
	char privData[SIZE_OF_ALCATEL_PRIVATE_DATA];
	memset (privData,0,SIZE_OF_ALCATEL_PRIVATE_DATA);
	
	CstaCommonArguments_t *cstaCommonArgumentsPt = (CstaCommonArguments_t*) ((PrivateData_t FAR*)privData)->data;
	
	cstaCommonArgumentsPt->privateData.numberOfPrivateData =1;
	cstaCommonArgumentsPt->privateData.AlcCstaPrivPtOffsetArray[0]=0;
	
	
	AlcatelCstaPrivObject_t *alcatelCstaPrivObjectPt = (AlcatelCstaPrivObject_t*)((char*) cstaCommonArgumentsPt->privateData.privateHeap);
	alcatelCstaPrivObjectPt->objectId = rerouteAuthorisation_Id;
	alcatelCstaPrivObjectPt->u.rerouteAuthorisation = 0x3F;
	CopyPrivateData(1,cstaCommonArgumentsPt, privData);

	CorrelatorData_t my_correlatorData;
	my_correlatorData.length = 0;
	my_correlatorData.correlatorData [0] = '\0';

/*YB 221102-*/    	
	strcpy(deviceID, dlg.m_sRouteSelected);
	strcpy(info, dlg.m_sSetupInfo);
	setupInfo.length = strlen(info);
	setupInfo.value = (unsigned char*)&info[0];
    m_nRetCode = cstaRouteSelectInv(m_acsHandle,
									0,
                                 dlg.m_nRouteRegID,
                                 dlg.m_nRoutingCRID,
                                 &deviceID,
                                 dlg.m_nRemainRetry,
                                 &setupInfo,
                                 dlg.m_bRouteUsed,
								 &my_correlatorData,/*YB 221102*/
                                 (PrivateData_t*)privData);/*YB 221102*/
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaRouteSelect", m_nRetCode);
      return;
    }
    CString eventString;
  
    DisplayEventTitle("CSTA REQUEST Route Select:");
	eventString += "     Route Register ID:";
    sprintf (str, "%ld", dlg.m_nRouteRegID);
    eventString += str;           
    eventString += "   Routing Cross Ref ID: ";
    sprintf(str, "%ld", dlg.m_nRoutingCRID);
    eventString += str;
    DisplayString (eventString);
    eventString = "                 Route Selected: ";
    eventString += dlg.m_sRouteSelected;
    eventString += "   Remain retry: ";
    sprintf(str, "%d", dlg.m_nRemainRetry);
    eventString += str;
    eventString += "   Setup Info: ";
    eventString += dlg.m_sSetupInfo;
    eventString += "   Route Used: ";
    if (dlg.m_bRouteUsed)
      eventString += "TRUE";
    else
      eventString += "FALSE";
    DisplayString (eventString);
  }
}

void CMainWind::CstaRouteUsedEvent() {
  CString eventString;
  char str[100];
  CSTARouteUsedEvent_t* pEvt;
  pEvt = &m_cstaEvent.event.cstaEventReport.u.routeUsed; 
  DisplayEventTitle ( "CSTA EVENT REPORT Route Used Event:");
  eventString += "          Route Register Req ID:";
  sprintf(str, "%ld", pEvt->routeRegisterReqID);
  eventString += str;
  eventString += "   Routing Cross Ref ID: ";
  sprintf(str, "%ld", pEvt->routingCrossRefID);
  eventString += str;                      
  DisplayString(eventString);
  eventString = "          Route Used: ";
  eventString += pEvt->routeUsed;
  eventString += "    Calling Device: ";
  eventString += pEvt->callingDevice;
  eventString += "    Domain: ";
  if (pEvt->domain)
    eventString += "TRUE";
  else
    eventString += "FALSE";
  DisplayString(eventString);
}