public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTFailedParser.Parse: eventType=ATT_FAILED");
ATTFailedEvent_t failedEvent = new ATTFailedEvent_t
{
deviceHistory = ReadDeviceHistory(reader),
callingDevice = ReadCallingDevice(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.failedEvent = failedEvent;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTFailedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTServiceInitiatedParser.Parse: eventType=ATT_SERVICE_INITIATED");
object result;
if (reader.TryReadStruct(typeof(ATTServiceInitiatedEvent_t), out result))
{
logger.Info("ATTServiceInitiatedParser.Parse: successfully read service initiated event!");
ATTServiceInitiatedEvent_t serviceInitiated = (ATTServiceInitiatedEvent_t)result;
logger.Info("ATTServiceInitiatedParser.Parse: serviceInitiated.ucid.value={0}; serviceInitiated.consultMode={1};", serviceInitiated.ucid.value, serviceInitiated.consultMode);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.serviceInitiated = serviceInitiated;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTServiceInitiatedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTOriginatedParser.Parse: eventType=ATT_ORIGINATED");
object result;
if (reader.TryReadStruct(typeof(ATTOriginatedEvent_t), out result))
{
logger.Info("ATTOriginatedParser.Parse: successfully read originated event!");
ATTOriginatedEvent_t originatedEvent = (ATTOriginatedEvent_t)result;
logger.Info("ATTOriginatedParser.Parse: originatedEvent.logicalAgent.device={0}; originatedEvent.userInfo.type={1}; originated.userInfo.length={2}; originatedEvent.userInfo.data={3}; originatedEvent.consultMode={4};", originatedEvent.logicalAgent.device, originatedEvent.userInfo.type, originatedEvent.userInfo.length, originatedEvent.userInfo.data, originatedEvent.consultMode);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.originatedEvent = originatedEvent;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTOriginatedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTSnapshotCallConfParser.Parse: eventType=ATT_SNAPSHOT_CALL_CONF");
ATTSnapshotCallConfEvent_t snapshotCallConf = new ATTSnapshotCallConfEvent_t
{
deviceHistory = ReadDeviceHistory(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.snapshotCallConf = snapshotCallConf;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTSnapshotCallConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTMonitorConfParser.Parse: eventType=ATT_MONITOR_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTMonitorConfEvent_t), out result))
{
logger.Info("ATTMonitorConfParser.Parse: successfully read monitor confirmation event!");
ATTMonitorConfEvent_t monitorStart = (ATTMonitorConfEvent_t)result;
logger.Info("ATTMonitorConfParser.Parse: monitorStart.usedFilter.filter={0}", monitorStart.usedFilter.filter);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.monitorStart = monitorStart;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTMonitorConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTQueryTgConfParser.Parse: eventType=ATT_QUERY_TG_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTQueryTgConfEvent_t), out result))
{
ATTQueryTgConfEvent_t queryTg = (ATTQueryTgConfEvent_t)result;
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.queryTg = queryTg;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTQueryTgConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTChargeAdviceParser.Parse: eventType=ATT_CHARGE_ADVICE");
object result;
if (reader.TryReadStruct(typeof(ATTChargeAdviceEvent_t), out result))
{
ATTChargeAdviceEvent_t chargeAdviceEvent = (ATTChargeAdviceEvent_t)result;
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.chargeAdviceEvent = chargeAdviceEvent;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTChargeAdviceParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTSetAgentStateConfParser.Parse: eventType=ATT_SET_AGENT_STATE_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTSetAgentStateConfEvent_t), out result))
{
logger.Info("ATTSetAgentStateConfParser.Parse: successfully read set agent state confirmation event!");
ATTSetAgentStateConfEvent_t setAgentState = (ATTSetAgentStateConfEvent_t)result;
logger.Info("ATTSetAgentStateConfParser.Parse:setAgentState.isPending={0};", setAgentState.isPending);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.setAgentState = setAgentState;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTSetAgentStateConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTDivertedParser.Parse: eventType=ATT_DIVERTED");
ATTDivertedEvent_t divertedEvent = new ATTDivertedEvent_t {
deviceHistory = ReadDeviceHistory(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.divertedEvent = divertedEvent;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTDivertedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTConnectionClearedParser.Parse: eventType=ATT_CONNECTION_CLEARED");
ATTConnectionClearedEvent_t connectionCleared = new ATTConnectionClearedEvent_t
{
userInfo = ReadUserToUserInfo(reader),
deviceHistory = ReadDeviceHistory(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.connectionCleared = connectionCleared;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTConnectionClearedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTRouteRequestParser.Parse: eventType=ATT_ROUTE_REQUEST");
ATTRouteRequestEvent_t routeRequest = new ATTRouteRequestEvent_t
{
trunkGroup = ReadTrunkGroup(reader),
lookaheadInfo = ReadLookaheadInfo(reader),
userEnteredCode = ReadUserEnteredCode(reader),
userInfo = ReadUserToUserInfo(reader),
ucid = ReadUCID(reader),
callOriginatorInfo = ReadCallOriginatorInfo(reader),
flexibleBilling = ReadFlexibleBilling(reader),
trunkMember = ReadTrunkMember(reader),
deviceHistory = ReadDeviceHistory(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.routeRequest = routeRequest;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTRouteRequestParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTSingleStepConferenceCallConfParser.Parse: eventType=ATT_SINGLE_STEP_CONFERENCE_CALL_CONF");
ATTSingleStepConferenceCallConfEvent_t ssconference = new ATTSingleStepConferenceCallConfEvent_t
{
newCall = ReadNewCall(reader),
connList = ReadConnList(reader),
ucid = ReadUCID(reader)
};
ATTEvent_t attEvent = new ATTEvent_t();
attEvent.u.ssconference = ssconference;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTSingleStepConferenceCallConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTMonitorStopOnCallConfParser.Parse: eventType=ATT_MONITOR_STOP_ON_CALL_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTMonitorStopOnCallConfEvent_t), out result))
{
ATTMonitorStopOnCallConfEvent_t monitorStopOnCall = (ATTMonitorStopOnCallConfEvent_t)result;
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.monitorStopOnCall = monitorStopOnCall;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTMonitorStopOnCallConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTHeldParser.Parse: eventType=ATT_HELD");
object result;
if (reader.TryReadStruct(typeof(ATTHeldEvent_t), out result))
{
logger.Info("ATTHeldParser.Parse: successfully read Held event!");
ATTHeldEvent_t heldEvent = (ATTHeldEvent_t)result;
logger.Info("ATTHeldParser.Parse: heldEvent.consultMode={0}", heldEvent.consultMode);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.heldEvent = heldEvent;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTHeldParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTRouteUsedParser.Parse: eventType=ATT_ROUTE_USED");
object result;
if (reader.TryReadStruct(typeof(ATTRouteUsedEvent_t), out result))
{
ATTRouteUsedEvent_t routeUsed = (ATTRouteUsedEvent_t)result;
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.routeUsed = routeUsed;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTRouteUsedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTConferencedParser.Parse: eventType=ATT_CONFERENCED");
ATTConferencedEvent_t conferencedEvent = new ATTConferencedEvent_t
{
originalCallInfo = ReadOriginalCallInfo(reader),
distributingDevice = ReadDistributingDevice(reader),
ucid = ReadUCID(reader),
trunkList = ReadTrunkList(reader),
deviceHistory = ReadDeviceHistory(reader),
distributingVDN = ReadDistributingVDN(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.conferencedEvent = conferencedEvent;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTConferencedParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTTransferCallConfParser.Parse: eventType=ATT_TRANSFER_CALL_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTTransferCallConfEvent_t), out result))
{
logger.Info("ATTTransferCallConfParser.Parse: successfully read transfer call confirmation event!");
ATTTransferCallConfEvent_t transferCall = (ATTTransferCallConfEvent_t)result;
logger.Info("ATTTransferCallConfParser.Parse: transferCall.ucid.value={0};", transferCall.ucid.value);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.transferCall = transferCall;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTTransferCallConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTMonitorCallConfParser.Parse: eventType=ATT_MONITOR_CALL_CONF");
ATTMonitorCallConfEvent_t monitorCallStart = new ATTMonitorCallConfEvent_t
{
usedFilter = ReadUsedFilter(reader),
snapshotCall = ReadSnapshotCall(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.monitorCallStart = monitorCallStart;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTMonitorCallConfParser.Parse: {0}", err));
}
return(null);
}
protected void Cstaeventreport(CstaEventReport data, ATTEvent_t pd, eventTypeCSTA eventType)
{
switch (pd.eventType)
{
case TypeATTEvent.ATTQueryAgentLoginResp_t_PDU:
var crid = pd.queryAgentLoginResp.privEventCrossRefID;
if (pd.queryAgentLoginResp.list.count != 0)
{
var list =
pd.queryAgentLoginResp.list.list.Take(pd.queryAgentLoginResp.list.count)
.Select(_ => _.device)
.ToList();
ReportArray.AddOrUpdate(crid,
list,
(u, o) =>
{
var l = o as List <string>;
if (l != null)
{
l.AddRange(list);
}
return((object)l);
});
CbTaskForToPartNew.UpdateTimeout(crid);
}
else
{
object obj;
var flag = ReportArray.TryRemove(crid, out obj);
CbTaskForToPartNew.Set(crid, flag ? obj : new List <string>());
}
break;
}
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTLoggedOnParser.Parse: eventType=ATT_LOGGED_ON");
object result;
if (reader.TryReadStruct(typeof(ATTLoggedOnEvent_t), out result))
{
logger.Info("ATTLoggedOnParser.Parse: successfully read LoggedOn event!");
ATTLoggedOnEvent_t loggedOnEvent = (ATTLoggedOnEvent_t)result;
logger.Info("ATTLoggedOnParser.Parse: loggedOnEvent.workMode={0}", loggedOnEvent.workMode);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.loggedOnEvent = loggedOnEvent;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTLoggedOnParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTQueryAcdSplitConfParser.Parse: eventType=ATT_QUERY_ACD_SPLIT_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTQueryAcdSplitConfEvent_t), out result))
{
logger.Info("ATTQueryAcdSplitConfParser.Parse: successfully parsed ATTQueryAcdSplitConfEvent_t!");
ATTQueryAcdSplitConfEvent_t queryAcdSplit = (ATTQueryAcdSplitConfEvent_t)result;
logger.Info("ATTQueryAcdSplitConfParser.Parse: queryAcdSplit.agentsLoggedIn={0};queryAcdSplit.availableAgents={1};queryAcdSplit.callsInQueue={2};", queryAcdSplit.agentsLoggedIn, queryAcdSplit.availableAgents, queryAcdSplit.callsInQueue);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.queryAcdSplit = queryAcdSplit;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTQueryAcdSplitConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
logger.Info("ATTSingleStepTransferCallConfParser.Parse: eventType=ATT_SINGLE_STEP_TRANSFER_CALL_CONF");
object result;
if (reader.TryReadStruct(typeof(ATTSingleStepTransferCallConfEvent_t), out result))
{
ATTSingleStepTransferCallConfEvent_t ssTransferCallConf = (ATTSingleStepTransferCallConfEvent_t)result;
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.ssTransferCallConf = ssTransferCallConf;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTSingleStepTransferCallConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTNetworkReachedParser.Parse: eventType=ATT_NETWORK_REACHED");
ATTNetworkReachedEvent_t networkReachedEvent = new ATTNetworkReachedEvent_t
{
progressLocation = ReadProgressLocation(reader),
progressDescription = ReadProgressDescription(reader),
trunkGroup = ReadTrunkGroup(reader),
trunkMember = ReadTrunkMember(reader),
deviceHistory = ReadDeviceHistory(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.networkReachedEvent = networkReachedEvent;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTNetworkReachedParser.Parse: {0}", err));
}
return(null);
}
internal ATTEvent_t Read()
{
try
{
if (m_PrivateData.length > 0)
{
ATTEventBuf_t attEventBuf = new ATTEventBuf_t();
logger.Info("PrivateDataReader.ReadEvent: privateData.length={0};privateData.vendor={1};privateData.data={2}", m_PrivateData.length, m_PrivateData.vendor, new string(m_PrivateData.data));
logger.Info("PrivateDataReader.ReadEvent: decode the private data buffer...");
int RetCode_t = ATT.Proxy.attPrivateData(ref m_PrivateData, ref attEventBuf);
logger.Info("PrivateDataReader.ReadEvent: ReturnCode={0}", RetCode_t);
if (RetCode_t == CSTA.Constants.ACSPOSITIVE_ACK)
{
logger.Info("PrivateDataReader.ReadEvent: attEventBuf.data.Length={0};attEventBuf.data={1};", attEventBuf.data.Length, Encoding.UTF8.GetString(attEventBuf.data));
if (attEventBuf.data.Length > 0)
{
MemoryStream stream = new MemoryStream(attEventBuf.data);
StructReader reader = new StructReader(stream);
logger.Info("PrivateDataReader.ReadEvent: eventType={0}", attEventBuf.eventType);
if (m_ParserFactory != null)
{
logger.Info("PrivateDataReader.ReadEvent: create event parser...");
IATTEventParser parser = m_ParserFactory.CreateParser(attEventBuf.eventType);
if (parser != null)
{
logger.Info("PrivateDataReader.ReadEvent: parse the private data event...");
ATTEvent_t attEvent = parser.Parse(reader);
logger.Info("PrivateDataReader.ReadEvent: attEvent={0}", attEvent);
return(attEvent);
}
logger.Info("***************************");
logger.Info("* UNKNOWN EVENT TYPE: {0} *", attEventBuf.eventType);
logger.Info("***************************");
}
}
}
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in PrivateDataReader.Read: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTSnapshotDeviceConfParser.Parse: eventType=ATT_SNAPSHOT_DEVICE_CONF");
ATTSnapshotDeviceConfEvent_t snapshotDevice = new ATTSnapshotDeviceConfEvent_t();
logger.Info("ATTSnapshotDeviceConfParser.Parse: read count from stream...");
uint count = reader.ReadUInt32();
logger.Info("ATTSnapshotDeviceConfParser.Parse: count={0}", count);
List <ATTSnapshotDevice_t> snapshotDeviceList = new List <ATTSnapshotDevice_t>();
for (int i = 0; i < count; i++)
{
object result;
logger.Info("ATTSnapshotDeviceConfParser.Parse: read snapshot device from the stream...");
if (reader.TryReadStruct(typeof(ATTSnapshotDevice_t), out result))
{
logger.Info("ATTSnapshotDeviceConfParser.Parse: successfully read snapshot device from the stream!");
ATTSnapshotDevice_t device = (ATTSnapshotDevice_t)result;
logger.Info("ATTSnapshotDeviceConfParser.Parse: index={0};snapshot.pSnapshotDevice.call.callID={1};snapshot.pSnapshotDevice.call.deviceID.device={2}, snapshot.pSnapshotDevice.call.devIDType={3};snapshot.pSnapshotDevice.state={4}", i, device.call.callID, device.call.deviceID.device, device.call.devIDType, device.state);
snapshotDeviceList.Add(device);
}
}
snapshotDevice.count = count;
snapshotDevice.pSnapshotDevice = snapshotDeviceList.ToArray();
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.snapshotDevice = snapshotDevice;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTSnapshotDeviceConfParser.Parse: {0}", err));
}
return(null);
}
protected void Cstaunsolicited(CstaUnsolicitedEvent data, ATTEvent_t pd, eventTypeCSTA eventType)
{
MonitorEventCollection evnt;
if (Monitors.TryGetValue((int)data.monitorCrossRefId, out evnt))
{
if (eventType == eventTypeCSTA.CSTA_DELIVERED)
{
}
evnt.Invoke(data, eventType, pd, data.monitorCrossRefId);
if (eventType == eventTypeCSTA.CSTA_MONITOR_STOP || eventType == eventTypeCSTA.CSTA_MONITOR_ENDED)
{
Monitors.TryRemove((int)data.monitorCrossRefId, out evnt);
evnt.Dispose();
}
}
}
public ATTEvent_t Parse(IStructReader reader)
{
try
{
logger.Info("ATTDeliveredParser.Parse: eventType=ATT_DELIVERED");
ATTDeliveredEvent_t deliveredEvent = new ATTDeliveredEvent_t
{
deliveredType = ReadDeliveredType(reader),
trunkGroup = ReadTrunkGroup(reader),
trunkMember = ReadTrunkMember(reader),
split = ReadSplit(reader),
lookaheadInfo = ReadLookaheadInfo(reader),
userEnteredCode = ReadUserEnteredCode(reader),
userInfo = ReadUserToUserInfo(reader),
reason = ReadReason(reader),
originalCallInfo = ReadOriginalCallInfo(reader),
distributingDevice = ReadDistributingDevice(reader),
ucid = ReadUCID(reader),
callOriginatorInfo = ReadCallOriginatorInfo(reader),
flexibleBilling = ReadFlexibleBilling(reader),
deviceHistory = ReadDeviceHistory(reader),
distributingVDN = ReadDistributingVDN(reader)
};
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.deliveredEvent = deliveredEvent;
return(attEvent);
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTDeliveredParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
object result;
logger.Info("ATTQueryUcidConfParser.Parse: eventType=ATT_QUERY_UCID_CONF");
logger.Info("ATTQueryUcidConfParser.Parse: try to read the ATTQueryUcidConfEvent_t event...");
if (reader.TryReadStruct(typeof(ATTQueryUcidConfEvent_t), out result))
{
logger.Info("ATTQueryUcidConfParser.Parse: successfully read the ATTQueryUcidConfEvent_t event!");
ATTQueryUcidConfEvent_t queryUCID = (ATTQueryUcidConfEvent_t)result;
logger.Info("ATTQueryUcidConfParser.Parse: ucid={0}", queryUCID.ucid.value);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.queryUCID = queryUCID;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTQueryUcidConfParser.Parse: {0}", err));
}
return(null);
}
public ATTEvent_t Parse(IStructReader reader)
{
Logger logger = LogManager.GetLogger("TSAPIClient");
try
{
object result;
logger.Info("ATTCallClearedParser.Parse: eventType=ATT_CALL_CLEARED");
logger.Info("ATTCallClearedParser.Parse: try to read the ATTCallClearedEvent_t event...");
if (reader.TryReadStruct(typeof(ATTCallClearedEvent_t), out result))
{
logger.Info("ATTCallClearedParser.Parse: successfully read the ATTCallClearedEvent_t event!");
ATTCallClearedEvent_t callClearedEvent = (ATTCallClearedEvent_t)result;
logger.Info("ATTCallClearedParser.Parse: reason={0}", callClearedEvent.reason);
ATTEvent_t attEvent = new ATTEvent_t()
{
eventType = (ushort)eventType
};
attEvent.u.callClearedEvent = callClearedEvent;
return(attEvent);
}
}
catch (Exception err)
{
logger.Error(string.Format("Error in ATTCallClearedParser.Parse: {0}", err));
}
return(null);
}
public void Invoke(CstaUnsolicitedEvent data, eventTypeCSTA eventType, ATTEvent_t attData, uint monitorCrossRefId)
{
switch (eventType)
{
case eventTypeCSTA.CSTA_CALL_CLEARED: if (OnCallCleared != null)
{
OnCallCleared(this, new CstaAttEventArgs <CSTACallClearedEvent_t, ATTCallClearedEvent_t>(data.callCleared, attData.callClearedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_CONFERENCED: if (OnConferenced != null)
{
OnConferenced(this, new CstaAttEventArgs <CSTAConferencedEvent_t, ATTConferencedEvent_t>(data.conferenced, attData.conferencedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_CONNECTION_CLEARED: if (OnConnectionCleared != null)
{
OnConnectionCleared(this, new CstaEventArgs <CSTAConnectionClearedEvent_t>(data.connectionCleared), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_DELIVERED: if (OnDelivered != null)
{
OnDelivered(this, new CstaAttEventArgs <CSTADeliveredEvent_t, ATTDeliveredEvent_t>(data.delivered, attData.deliveredEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_DIVERTED: if (OnDiverted != null)
{
OnDiverted(this, new CstaAttEventArgs <CSTADivertedEvent_t, ATTDivertedEvent_t>(data.diverted, attData.divertedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_ESTABLISHED: if (OnEstablished != null)
{
OnEstablished(this, new CstaAttEventArgs <CSTAEstablishedEvent_t, ATTEstablishedEvent_t>(data.established, attData.establishedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_FAILED: if (OnFailed != null)
{
OnFailed(this, new CstaAttEventArgs <CSTAFailedEvent_t, ATTFailedEvent_t>(data.failed, attData.failedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_HELD: if (OnHeld != null)
{
OnHeld(this, new CstaEventArgs <CSTAHeldEvent_t>(data.held), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_NETWORK_REACHED: if (OnNetworkReached != null)
{
OnNetworkReached(this, new CstaAttEventArgs <CSTANetworkReachedEvent_t, ATTNetworkReachedEvent_t>(data.networkReached, attData.networkReachedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_ORIGINATED: if (OnOriginated != null)
{
OnOriginated(this, new CstaAttEventArgs <CSTAOriginatedEvent_t, ATTOriginatedEvent_t>(data.originated, attData.originatedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_QUEUED: if (OnQueued != null)
{
OnQueued(this, new CstaAttEventArgs <CSTAQueuedEvent_t, ATTQueuedEvent_t>(data.queued, attData.queuedEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_RETRIEVED: if (OnRetrieved != null)
{
OnRetrieved(this, new CstaEventArgs <CSTARetrievedEvent_t>(data.retrieved), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_SERVICE_INITIATED: if (OnServiceInitiated != null)
{
OnServiceInitiated(this, new CstaAttEventArgs <CSTAServiceInitiatedEvent_t, ATTServiceInitiatedEvent_t>(data.serviceInitiated, attData.serviceInitiated), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_TRANSFERRED: if (OnTransferred != null)
{
OnTransferred(this, new CstaAttEventArgs <CSTATransferredEvent_t, ATTTransferredEvent_t>(data.transferred, attData.transferredEvent), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_CALL_INFORMATION: if (OnCallInformation != null)
{
OnCallInformation(this, new CstaEventArgs <CSTACallInformationEvent_t>(data.callInformation), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_DO_NOT_DISTURB: if (OnDoNotDisturb != null)
{
OnDoNotDisturb(this, new CstaEventArgs <CSTADoNotDisturbEvent_t>(data.doNotDisturb), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_FORWARDING: if (OnForwarding != null)
{
OnForwarding(this, new CstaEventArgs <CSTAForwardingEvent_t>(data.forwarding), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_MESSAGE_WAITING: if (OnMessageWaiting != null)
{
OnMessageWaiting(this, new CstaEventArgs <CSTAMessageWaitingEvent_t>(data.messageWaiting), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_BACK_IN_SERVICE: if (OnBackInService != null)
{
OnBackInService(this, new CstaEventArgs <CSTABackInServiceEvent_t>(data.backInService), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_OUT_OF_SERVICE: if (OnOutOfService != null)
{
OnOutOfService(this, new CstaEventArgs <CSTAOutOfServiceEvent_t>(data.outOfService), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_PRIVATE_STATUS: if (OnPrivateStatus != null)
{
OnPrivateStatus(this, new CstaEventArgs <CSTAPrivateStatusEvent_t>(data.privateStatus), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_MONITOR_ENDED: MonitorEndedInvoke(data.monitorEnded, monitorCrossRefId); break;
case eventTypeCSTA.CSTA_LOGGED_ON: if (OnPrivateStatus != null)
{
OnLogOn(this, new CstaEventArgs <CSTALoggedOnEvent_t>(data.loggedOn), monitorCrossRefId);
}
break;
case eventTypeCSTA.CSTA_LOGGED_OFF: if (OnPrivateStatus != null)
{
OnLogOff(this, new CstaEventArgs <CSTALoggedOffEvent_t>(data.loggedOff), monitorCrossRefId);
}
break;
}
}
