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);
}
