public static CallUserEvent GetInstance()
 {
     if (_userEventObject == null)
     {
         _userEventObject = new CallUserEvent();
     }
     return(_userEventObject);
 }
        public void ReceiveCalls(IMessage events)
        {
            try
            {
                if (Settings.SFDCOptions.SFDCPopupPages != null)
                {
                    if (events != null)
                    {
                        logger.Info("ReceiveCalls : Agent Voice Event " + events.ToString());
                        switch (events.Id)
                        {
                            #region EventRinging
                        case EventRinging.MessageId:
                            eventRinging = (EventRinging)events;

                            if (eventRinging.CallType == CallType.Inbound)
                            {
                                IsConsultCallReceived = false;
                                CallRinging.GetInstance().PopupRecords(eventRinging, SFDCCallType.Inbound);
                                if (!Settings.UserEventData.ContainsKey(eventRinging.ConnID.ToString()))
                                {
                                    Settings.UserEventData.Add(eventRinging.ConnID.ToString(), SFDCCallType.Inbound);
                                }
                            }
                            else if (eventRinging.CallType == CallType.Consult)
                            {
                                IsConsultCallReceived = true;
                                CallRinging.GetInstance().PopupRecords(eventRinging, SFDCCallType.ConsultReceived);
                                if (!Settings.UserEventData.ContainsKey(eventRinging.ConnID.ToString()))
                                {
                                    Settings.UserEventData.Add(eventRinging.ConnID.ToString(), SFDCCallType.ConsultReceived);
                                }
                            }
                            break;
                            #endregion

                            #region EventPartyChanged
                        case EventPartyChanged.MessageId:
                            EventPartyChanged partyChanged = (EventPartyChanged)events;
                            IsConsultCallReceived = true;
                            if (CallDurationData.ContainsKey(partyChanged.PreviousConnID.ToString()) && !CallDurationData.ContainsKey(partyChanged.ConnID.ToString()))
                            {
                                CallDurationData.Add(partyChanged.ConnID.ToString(), CallDurationData[partyChanged.PreviousConnID.ToString()]);
                            }
                            if (Settings.UpdateSFDCLog.ContainsKey(partyChanged.PreviousConnID.ToString()))
                            {
                                Settings.UpdateSFDCLog.Add(partyChanged.ConnID.ToString(), Settings.UpdateSFDCLog[partyChanged.PreviousConnID.ToString()]);
                            }
                            this.consultConnId = partyChanged.PreviousConnID.ToString();
                            break;
                            #endregion

                            #region EventDialing
                        case EventDialing.MessageId:
                            eventDialing = (EventDialing)events;

                            if (eventDialing.Reasons != null && eventDialing.Reasons.ContainsKey("ClickToDial"))
                            {
                                Settings.ClickToDialData.Add(eventDialing.ConnID.ToString(), eventDialing.Reasons.GetAsString("ClickToDial"));
                            }
                            if (eventDialing.CallType == CallType.Unknown || eventDialing.CallType == CallType.Outbound)
                            {
                                CallDialing.GetInstance().PopupRecords(eventDialing, SFDCCallType.OutboundSuccess);

                                if (!Settings.UserEventData.ContainsKey(eventDialing.ConnID.ToString()))
                                {
                                    Settings.UserEventData.Add(eventDialing.ConnID.ToString(), SFDCCallType.OutboundSuccess);
                                }
                            }
                            else if (eventDialing.CallType == CallType.Consult)
                            {
                                CallDialing.GetInstance().PopupRecords(eventDialing, SFDCCallType.ConsultSuccess);

                                if (!Settings.UserEventData.ContainsKey(eventDialing.ConnID.ToString()))
                                {
                                    Settings.UserEventData.Add(eventDialing.ConnID.ToString(), SFDCCallType.ConsultSuccess);
                                }
                            }
                            break;
                            #endregion

                            #region EventEstablished
                        case EventEstablished.MessageId:

                            eventEstablished = (EventEstablished)events;

                            if (!CallDurationData.ContainsKey(eventEstablished.ConnID.ToString()))
                            {
                                CallDurationData.Add(eventEstablished.ConnID.ToString(), System.DateTime.Now);
                            }
                            if (eventEstablished.CallType == CallType.Inbound)
                            {
                                if (IsConsultCallReceived)
                                {
                                    CallConnected.GetInstance().PopupRecords(eventEstablished, SFDCCallType.ConsultReceived);
                                }
                                else
                                {
                                    CallConnected.GetInstance().PopupRecords(eventEstablished, SFDCCallType.Inbound);
                                }
                            }
                            else if (eventEstablished.CallType == CallType.Unknown || eventEstablished.CallType == CallType.Outbound)
                            {
                                if (IsConsultCallReceived)
                                {
                                    CallConnected.GetInstance().PopupRecords(eventEstablished, SFDCCallType.ConsultReceived);
                                }
                                else
                                {
                                    CallConnected.GetInstance().PopupRecords(eventEstablished, SFDCCallType.OutboundSuccess);
                                }
                            }
                            else if (eventEstablished.CallType == CallType.Consult)
                            {
                                if (IsConsultCallReceived)
                                {
                                    CallConnected.GetInstance().PopupRecords(eventEstablished, SFDCCallType.ConsultReceived);
                                }
                                else
                                {
                                    CallConnected.GetInstance().PopupRecords(eventEstablished, SFDCCallType.ConsultSuccess);
                                }
                            }


                            break;
                            #endregion

                            #region EventReleased
                        case EventReleased.MessageId:

                            eventReleased = (EventReleased)events;

                            if (eventReleased.CallState != 22)
                            {
                                string callDuration = string.Empty;
                                if (CallDurationData.ContainsKey(eventReleased.ConnID.ToString()))
                                {
                                    TimeSpan ts = System.DateTime.Now.Subtract(CallDurationData[eventReleased.ConnID.ToString()]);
                                    callDuration = ts.Hours + "Hr " + ts.Minutes + " mins " + ts.Seconds + "secs";
                                    if (!FinishedCallDuration.ContainsKey(eventReleased.ConnID.ToString()))
                                    {
                                        FinishedCallDuration.Add(eventReleased.ConnID.ToString(), callDuration);
                                    }
                                    else
                                    {
                                        FinishedCallDuration[eventReleased.ConnID.ToString()] = callDuration;
                                    }
                                }
                                if (eventReleased.CallType == CallType.Inbound)
                                {
                                    if (!IsConsultCallReceived)
                                    {
                                        CallReleased.GetInstance().PopupRecords(eventReleased, SFDCCallType.Inbound, callDuration);
                                    }
                                    else
                                    {
                                        IsConsultCallReceived = false;
                                        CallReleased.GetInstance().PopupRecords(eventReleased, SFDCCallType.ConsultReceived, callDuration);
                                    }
                                }
                                else if (eventReleased.CallType == CallType.Unknown || eventReleased.CallType == CallType.Outbound)
                                {
                                    if (IsConsultCallReceived)
                                    {
                                        CallReleased.GetInstance().PopupRecords(eventReleased, SFDCCallType.ConsultReceived, callDuration);
                                        IsConsultCallReceived = false;
                                    }
                                    else
                                    {
                                        CallReleased.GetInstance().PopupRecords(eventReleased, SFDCCallType.OutboundSuccess, callDuration);
                                    }
                                }
                                else if (eventReleased.CallType == CallType.Consult)
                                {
                                    if (IsConsultCallReceived)
                                    {
                                        CallReleased.GetInstance().PopupRecords(eventReleased, SFDCCallType.ConsultReceived, callDuration);
                                        IsConsultCallReceived = false;
                                    }
                                    else
                                    {
                                        CallReleased.GetInstance().PopupRecords(eventReleased, SFDCCallType.ConsultSuccess, callDuration);
                                    }
                                }
                            }

                            break;
                            #endregion

                            #region EventUserEvent
                        case EventUserEvent.MessageId:
                            EventUserEvent userEvent = (EventUserEvent)events;

                            if (userEvent.ConnID != null)
                            {
                                if (Settings.UserEventData.ContainsKey(userEvent.ConnID.ToString()))
                                {
                                    if (FinishedCallDuration.ContainsKey(userEvent.ConnID.ToString()))
                                    {
                                        CallUserEvent.GetInstance().UpdateRecords(userEvent, Settings.UserEventData[userEvent.ConnID.ToString()], FinishedCallDuration[userEvent.ConnID.ToString()]);
                                    }
                                    else
                                    {
                                        CallUserEvent.GetInstance().UpdateRecords(userEvent, Settings.UserEventData[userEvent.ConnID.ToString()], "");
                                    }
                                }
                            }

                            break;
                            #endregion

                            #region EventError
                        case EventError.MessageId:
                            EventError eventError = (EventError)events;
                            if (eventError.CallType == CallType.Outbound)
                            {
                                CallEventError.GetInstance().PopupRecords(eventError, SFDCCallType.OutboundFailure);
                            }
                            else if (eventError.CallType == CallType.Consult)
                            {
                                CallEventError.GetInstance().PopupRecords(eventError, SFDCCallType.ConsultFailure);
                            }
                            break;
                            #endregion

                            #region EventAbandoned
                        case EventAbandoned.MessageId:
                            EventAbandoned eventAbandoned = (EventAbandoned)events;
                            if (eventAbandoned.CallType == CallType.Outbound)
                            {
                                CallEventAbandoned.GetInstance().PopupRecords(eventAbandoned, SFDCCallType.OutboundFailure);
                            }
                            else if (eventAbandoned.CallType == CallType.Consult)
                            {
                                CallEventAbandoned.GetInstance().PopupRecords(eventAbandoned, SFDCCallType.ConsultFailure);
                            }
                            break;
                            #endregion

                            #region EventDestinationBusy
                        case EventDestinationBusy.MessageId:

                            EventDestinationBusy destinationBusyEvent = (EventDestinationBusy)events;
                            if (destinationBusyEvent.CallType == CallType.Outbound)
                            {
                                CallEventDestinationBusy.GetInstance().PopupRecords(destinationBusyEvent, SFDCCallType.OutboundFailure);
                            }
                            else if (destinationBusyEvent.CallType == CallType.Consult)
                            {
                                CallEventDestinationBusy.GetInstance().PopupRecords(destinationBusyEvent, SFDCCallType.ConsultFailure);
                            }
                            break;
                            #endregion

                        default:
                            logger.Info("ReceiveCalls : Unhandled Event " + events.Name);
                            break;
                        }
                    }
                }
            }
            catch (Exception generalException)
            {
                logger.Error("ReceiveCalls : Error occured while receiving voice events " + generalException.ToString());
            }
        }