public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTACallInformationParser.Parse: eventType=CSTA_CALL_INFORMATION"); logger.Info("CSTACallInformationParser.Parse: try to read the CSTACallInformationEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTACallInformationEvent_t), out result)) { logger.Info("CSTACallInformationParser.Parse: successfully read the CSTACallInformationEvent_t unsolicited event!"); CSTACallInformationEvent_t callInformation = (CSTACallInformationEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { callInformation = callInformation } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTACallInformationParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTABackInServiceParser.Parse: eventType=CSTA_BACK_IN_SERVICE"); logger.Info("CSTABackInServiceParser.Parse: try to read the CSTABackInServiceEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTABackInServiceEvent_t), out result)) { logger.Info("CSTABackInServiceParser.Parse: successfully read the CSTABackInServiceEvent_t unsolicited event!"); CSTABackInServiceEvent_t backInService = (CSTABackInServiceEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { backInService = backInService } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTABackInServiceParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTANetworkReachedParser.Parse: eventType=CSTA_NETWORK_REACHED"); logger.Info("CSTANetworkReachedParser.Parse: try to read the CSTANetworkReachedEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTANetworkReachedEvent_t), out result)) { logger.Info("CSTANetworkReachedParser.Parse: successfully read the CSTANetworkReachedEvent_t unsolicited event!"); CSTANetworkReachedEvent_t networkReached = (CSTANetworkReachedEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { networkReached = networkReached } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTANetworkReachedParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTAEstablishedParser.Parse: eventType=CSTA_ESTABLISHED"); logger.Info("CSTAEstablishedParser.Parse: try to read the CSTAEstablishedEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTAEstablishedEvent_t), out result)) { logger.Info("CSTAEstablishedParser.Parse: successfully read the CSTAEstablishedEvent_t unsolicited event!"); CSTAEstablishedEvent_t established = (CSTAEstablishedEvent_t)result; logger.Info("CSTAEstablishedParser.Parse: answeringDevice=" + established.answeringDevice.deviceID.device + ";callingDevice=" + established.callingDevice.deviceID.device + ";calledDevice=" + established.calledDevice.deviceID.device + ";"); CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { established = established } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTAEstablishedParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { try { logger.Info("CSTAConferencedParser.Parse: eventType=CSTA_CONFERENCED"); CSTAConferencedEvent_t conferenced = new CSTAConferencedEvent_t { primaryOldCall = ReadPrimaryOldCall(reader), secondaryOldCall = ReadSecondaryOldCall(reader), confController = ReadConfController(reader), addedParty = ReadAddedParty(reader), conferenceConnections = ReadConferenceConnections(reader), localConnectionInfo = ReadLocalConnectionInfo(reader), cause = ReadCause(reader) }; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { conferenced = conferenced } }; return(cstaUnsolicited); } catch (Exception err) { logger.Error(string.Concat("Error in CSTAConferencedParser.Parse: ", err.ToString())); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTAMessageWaitingParser.Parse: eventType=CSTA_MESSAGE_WAITING"); logger.Info("CSTAMessageWaitingParser.Parse: try to read the CSTAMessageWaitingEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTAMessageWaitingEvent_t), out result)) { logger.Info("CSTAMessageWaitingParser.Parse: successfully read the CSTAMessageWaitingEvent_t unsolicited event!"); CSTAMessageWaitingEvent_t messageWaiting = (CSTAMessageWaitingEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { messageWaiting = messageWaiting } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTAMessageWaitingParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTAConnectionClearedParser.Parse: eventType=CSTA_CONNECTION_CLEARED"); logger.Info("CSTAConnectionClearedParser.Parse: try to read the CSTAConnectionClearedEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTAConnectionClearedEvent_t), out result)) { logger.Info("CSTAConnectionClearedParser.Parse: successfully read the CSTAConnectionClearedEvent_t unsolicited event!"); CSTAConnectionClearedEvent_t connectionCleared = (CSTAConnectionClearedEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent(); cstaUnsolicited.u.connectionCleared = connectionCleared; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTAConnectionClearedParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTAPrivateStatusParser.Parse: eventType=CSTA_PRIVATE_STATUS"); logger.Info("CSTAPrivateStatusParser.Parse: try to read the CSTAPrivateStatusEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTAPrivateStatusEvent_t), out result)) { logger.Info("CSTAPrivateStatusParser.Parse: successfully read the CSTAPrivateStatusEvent_t unsolicited event!"); CSTAPrivateStatusEvent_t privateStatus = (CSTAPrivateStatusEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { privateStatus = privateStatus } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTAPrivateStatusParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTADeliveredParser.Parse: eventType=CSTA_DELIVERED"); logger.Info("CSTADeliveredParser.Parse: try to read the CSTADeliveredEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTADeliveredEvent_t), out result)) { logger.Info("CSTADeliveredParser.Parse: successfully read the CSTADeliveredEvent_t unsolicited event!"); CSTADeliveredEvent_t delivered = (CSTADeliveredEvent_t)result; logger.Info("CSTADeliveredParser.Parse: connection.callID={0};connection.deviceID.device={1};connection.devIDType={2};alertingDevice.deviceID.device={3};alertingDevice.deviceIDStatus={4};alertingDevice.deviceIDType={5};callingDevice.deviceID.device={6};callingDevice.deviceIDStatus={7};callingDevice.deviceIDType={8};calledDevice.deviceID.device={9};calledDevice.deviceIDStatus={10};calledDevice.deviceIDType={11};cause={12}", delivered.connection.callID, delivered.connection.deviceID.device, delivered.connection.devIDType, delivered.alertingDevice.deviceID.device, delivered.alertingDevice.deviceIDStatus, delivered.alertingDevice.deviceIDType, delivered.callingDevice.deviceID.device, delivered.callingDevice.deviceIDStatus, delivered.callingDevice.deviceIDType, delivered.calledDevice.deviceID.device, delivered.calledDevice.deviceIDStatus, delivered.calledDevice.deviceIDType, delivered.cause); CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { delivered = delivered } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTADeliveredParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { try { logger.Info("CSTATransferredParser.Parse: eventType=CSTA_TRANSFERRED"); CSTATransferredEvent_t transferred = new CSTATransferredEvent_t { primaryOldCall = ReadPrimaryOldCall(reader), secondaryOldCall = ReadSecondaryOldCall(reader), transferringDevice = ReadTransferringDevice(reader), transferredDevice = ReadTransferredDevice(reader), transferredConnections = ReadTransferredConnections(reader), localConnectionInfo = ReadLocalConnectionInfo(reader), cause = ReadCause(reader) }; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { transferred = transferred } }; return(cstaUnsolicited); } catch (Exception err) { logger.Error(string.Concat("Error in CSTATransferredParser.Parse: ", err.ToString())); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTADoNotDisturbParser.Parse: eventType=CSTA_DO_NOT_DISTURB"); logger.Info("CSTADoNotDisturbParser.Parse: try to read the CSTADoNotDisturbEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTADoNotDisturbEvent_t), out result)) { logger.Info("CSTADoNotDisturbParser.Parse: successfully read the CSTADoNotDisturbEvent_t unsolicited event!"); CSTADoNotDisturbEvent_t doNotDisturb = (CSTADoNotDisturbEvent_t)result; CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { doNotDisturb = doNotDisturb } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTADoNotDisturbParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTAQueuedParser.Parse: eventType=CSTA_QUEUED"); logger.Info("CSTAQueuedParser.Parse: try to read the CSTAQueuedEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTAQueuedEvent_t), out result)) { logger.Info("CSTAQueuedParser.Parse: successfully read the CSTAQueuedEvent_t unsolicited event!"); CSTAQueuedEvent_t queued = (CSTAQueuedEvent_t)result; StringBuilder bldr = new StringBuilder(); bldr.Append("CSTAQueuedParser.Parse: "); bldr.AppendFormat("queuedConnection.callID={0};", queued.queuedConnection.callID); bldr.AppendFormat("queuedConnection.deviceID={0};", queued.queuedConnection.deviceID.device); bldr.AppendFormat("queuedConnection.devIDType={0};", queued.queuedConnection.devIDType); bldr.AppendFormat("queue.deviceID={0};", queued.queue.deviceID.device); bldr.AppendFormat("queue.deviceIDType={0};", queued.queue.deviceIDType); bldr.AppendFormat("queue.deviceIDStatus={0};", queued.queue.deviceIDStatus); bldr.AppendFormat("callingDevice.deviceID={0};", queued.callingDevice.deviceID.device); bldr.AppendFormat("callingDevice.deviceIDType={0};", queued.callingDevice.deviceIDType); bldr.AppendFormat("callingDevice.deviceIDStatus={0};", queued.callingDevice.deviceIDStatus); bldr.AppendFormat("calledDevice.deviceID={0};", queued.calledDevice.deviceID.device); bldr.AppendFormat("calledDevice.deviceIDType={0};", queued.calledDevice.deviceIDType); bldr.AppendFormat("calledDevice.deviceIDStatus={0};", queued.calledDevice.deviceIDStatus); bldr.AppendFormat("lastRedirectionDevice.deviceID={0};", queued.lastRedirectionDevice.deviceID.device); bldr.AppendFormat("lastRedirectionDevice.deviceIDType={0};", queued.lastRedirectionDevice.deviceIDType); bldr.AppendFormat("lastRedirectionDevice.deviceIDStatus={0};", queued.lastRedirectionDevice.deviceIDStatus); bldr.AppendFormat("numberQueued={0};", queued.numberQueued); bldr.AppendFormat("localConnectionInfo={0};", queued.localConnectionInfo); bldr.AppendFormat("cause={0};", queued.cause); logger.Info(bldr.ToString()); CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { queued = queued } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTAQueuedParser.Parse: {0}", err)); } return(null); }
public CSTAUnsolicitedEvent Parse(IStructReader reader) { Logger logger = LogManager.GetLogger("TSAPIClient"); try { object result; logger.Info("CSTACallClearedParser.Parse: eventType=CSTA_CALL_CLEARED"); logger.Info("CSTACallClearedParser.Parse: try to read the CSTACallClearedEvent_t unsolicited event..."); if (reader.TryReadStruct(typeof(CSTACallClearedEvent_t), out result)) { logger.Info("CSTACallClearedParser.Parse: successfully read the CSTACallClearedEvent_t unsolicited event!"); CSTACallClearedEvent_t callCleared = (CSTACallClearedEvent_t)result; StringBuilder bldr = new StringBuilder(); bldr.Append("CSTACallClearedParser.Parse: "); bldr.AppendFormat("clearedCall.callID={0};", callCleared.clearedCall.callID); bldr.AppendFormat("clearedCall.deviceID={0};", callCleared.clearedCall.deviceID.device); bldr.AppendFormat("clearedCall.devIDType={0};", callCleared.clearedCall.devIDType); bldr.AppendFormat("localConnectionInfo={0};", callCleared.localConnectionInfo); bldr.AppendFormat("cause={0};", callCleared.cause); logger.Info(bldr.ToString()); CSTAUnsolicitedEvent cstaUnsolicited = new CSTAUnsolicitedEvent { u = { callCleared = callCleared } }; return(cstaUnsolicited); } } catch (Exception err) { logger.Error(string.Format("Error in CSTACallClearedParser.Parse: {0}", err)); } return(null); }
internal CSTAEvent_t Read() { try { logger.Info("EventReader.Read: read event header..."); object result; if (m_FrameReader.TryReadStruct(typeof(ACSEventHeader_t), out result)) { ACSEventHeader_t eventHeader = (ACSEventHeader_t)result; logger.Info("EventReader.Read: acsHandle={0};eventClass={1};eventType={2};", eventHeader.acsHandle, eventHeader.eventClass, eventHeader.eventType); switch (eventHeader.eventClass) { case Constants.CSTACONFIRMATION: #region CSTACONFIRMATION int invokeID = m_FrameReader.ReadInt32(); logger.Info("EventReader.Read.CSTACONFIRMATION: invokeID={0};", invokeID); logger.Info("EventReader.Read.CSTACONFIRMATION: Getting CSTAConfParser from parserFactory..."); ICSTAConfirmationParser cstaConfParser = m_CSTAConfParserFactory.CreateParser(eventHeader.eventType); if (cstaConfParser != null) { CSTAConfirmationEvent cstaConfirmation = cstaConfParser.Parse(m_FrameReader); cstaConfirmation.invokeID = invokeID; CSTAEvent_t cstaEvent = new CSTAEvent_t() { eventHeader = eventHeader, Event = { cstaConfirmation = cstaConfirmation } }; return(cstaEvent); } logger.Info("EventReader.Read.CSTACONFIRMATION: ICSTAConfParserFactory failed to return parser!!"); #endregion CSTACONFIRMATION break; case Constants.CSTAUNSOLICITED: #region CSTAUNSOLICITED int xref = m_FrameReader.ReadInt32(); logger.Info("EventReader.Read.CSTAUNSOLICITED: xref={0};", xref); logger.Info("EventReader.Read.CSTAUNSOLICITED: Getting CSTAUnsolicitedParser from parserFactory..."); ICSTAUnsolicitedParser cstaUnsolicitedParser = m_CSTAUnsolicitedParserFactory.CreateParser(eventHeader.eventType); if (cstaUnsolicitedParser != null) { CSTAUnsolicitedEvent cstaUnsolicited = cstaUnsolicitedParser.Parse(m_FrameReader); cstaUnsolicited.monitorCrossRefId = xref; CSTAEvent_t cstaEvent = new CSTAEvent_t() { eventHeader = eventHeader, Event = { cstaUnsolicited = cstaUnsolicited } }; return(cstaEvent); } logger.Info("EventReader.Read.CSTAUNSOLICITED: ICSTAUnsolicitedParserFactory failed to return parser!!"); #endregion CSTAUNSOLICITED break; case Constants.ACSCONFIRMATION: #region ACSCONFIRMATION invokeID = m_FrameReader.ReadInt32(); logger.Info("EventReader.Read.ACSCONFIRMATION: invokeID={0};", invokeID); logger.Info("EventReader.Read.ACSCONFIRMATION: Getting ACSConfirmationParser from parserFactory..."); IACSConfirmationParser acsConfParser = m_ACSConfParserFactory.CreateParser(eventHeader.eventType); if (acsConfParser != null) { ACSConfirmationEvent acsConfirmation = acsConfParser.Parse(m_FrameReader); acsConfirmation.invokeID = invokeID; CSTAEvent_t cstaEvent = new CSTAEvent_t() { eventHeader = eventHeader, Event = { acsConfirmation = acsConfirmation } }; return(cstaEvent); } logger.Info("EventReader.Read.ACSCONFIRMATION: IACSConfirmationParserFactory failed to return parser!!"); #endregion ACSCONFIRMATION break; case Constants.ACSUNSOLICITED: #region ACSUNSOLICITED logger.Info("ACSUNSOLICITED :: Getting ACSUnsolicitedParser from parserFactory..."); IACSUnsolicitedParser acsUnsolicitedParser = m_ACSUnsolicitedParserFactory.CreateParser(eventHeader.eventType); if (acsUnsolicitedParser != null) { ACSUnsolicitedEvent acsUnsolicited = acsUnsolicitedParser.Parse(m_FrameReader); CSTAEvent_t cstaEvent = new CSTAEvent_t() { eventHeader = eventHeader, Event = { acsUnsolicited = acsUnsolicited } }; return(cstaEvent); } logger.Info("ACSUNSOLICITED :: IACSUnsolicitedParserFactory failed to return parser!!"); #endregion ACSUNSOLICITED break; } } } catch (Exception err) { logger.Error(string.Format("Error in EventReader.ReadEvent: {0}", err)); } return(null); }