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