/// <summary>
        /// Shows the messages.
        /// </summary>
        public void RefreshView()
        {
            OutgoingMessage selectedMsg = lvwMessages.SelectedObject as OutgoingMessage;

            lvwMessages.BeginUpdate();
            lvwMessages.ClearObjects();
            IOrderedQueryable <OutgoingMessage> results = OutgoingMessage.All().Where(msg => msg.Status == StringEnum.GetStringValue(MessageStatus.Archived)).OrderByDescending(msg => msg.LastUpdate);
            List <OutgoingMessage> messages             = new List <OutgoingMessage>(results.AsEnumerable());

            lvwMessages.SetObjects(messages);


            if (messages.Count() == 0)
            {
                lvwMessages.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
            }
            else
            {
                lvwMessages.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
            }

            lvwMessages.AutoResizeColumn(3, ColumnHeaderAutoResizeStyle.HeaderSize);


            if (selectedMsg != null)
            {
                lvwMessages.SelectObject(selectedMsg);
            }

            lvwMessages.EndUpdate();
            lvwMessages.Refresh();
        }
        /// <summary>
        /// Polls the message.
        /// </summary>
        /// <param name="obj">The object</param>
        private void PollMessages(object obj)
        {
            // Check by last updated timestamp
            IOrderedQueryable <OutgoingMessage> results = OutgoingMessage.All().Where
                                                              (msg => msg.Status == StringEnum.GetStringValue(MessageStatus.Failed) && msg.LastUpdate > this.lastUpdateTimestamp).OrderByDescending(msg => msg.LastUpdate);

            if (results.Count() > 0 && !this.Enabled)
            {
                RefreshView();
            }
        }
        /// <summary>
        /// Shows the messages.
        /// </summary>
        public void RefreshView()
        {
            if (this.lvwMessages.InvokeRequired)
            {
                SetListCallback callback = new SetListCallback(RefreshView);
                this.Invoke(callback);
            }
            else
            {
                OutgoingMessage selectedMsg = lvwMessages.SelectedObject as OutgoingMessage;

                lvwMessages.BeginUpdate();
                lvwMessages.ClearObjects();
                IOrderedQueryable <OutgoingMessage> results = OutgoingMessage.All().Where(msg => msg.Status != StringEnum.GetStringValue(MessageStatus.Archived) &&
                                                                                          msg.Status != StringEnum.GetStringValue(MessageStatus.Failed)).OrderByDescending(msg => msg.LastUpdate);
                List <OutgoingMessage> messages = new List <OutgoingMessage>(results.AsEnumerable());
                lvwMessages.SetObjects(messages);

                if (messages.Count() == 0)
                {
                    lvwMessages.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                }
                else
                {
                    lvwMessages.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
                }

                lvwMessages.AutoResizeColumn(3, ColumnHeaderAutoResizeStyle.HeaderSize);


                if (selectedMsg != null)
                {
                    lvwMessages.SelectObject(selectedMsg);
                }

                lvwMessages.EndUpdate();
                lvwMessages.Refresh();


                if (messages.Count() > 0)
                {
                    this.lastUpdateTimestamp = messages.OrderByDescending(m => m.LastUpdate).ElementAt(0).LastUpdate;
                }
            }
        }
        /// <summary>
        /// Does the work.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public override void DoWork(object sender, ElapsedEventArgs e)
        {
            if (messageGatewayService.Gateways.Count() == 0)
            {
                return;
            }

            if (log.IsDebugEnabled)
            {
                log.Debug("Checking outgoing message");
            }

            IOrderedQueryable <OutgoingMessage> messages = OutgoingMessage.All().Where(msg => msg.Status != StringEnum.GetStringValue(MessageStatus.Archived) &&
                                                                                       msg.Status != StringEnum.GetStringValue(MessageStatus.Failed) &&
                                                                                       msg.Status != StringEnum.GetStringValue(MessageStatus.Sending) &&
                                                                                       msg.Status != StringEnum.GetStringValue(MessageStatus.Sent) &&
                                                                                       (
                                                                                           msg.ScheduledDate == null ||
                                                                                           msg.ScheduledDate <= DateTime.Now
                                                                                       )).OrderBy(msg => msg.LastUpdate);


            // Send out messages
            foreach (OutgoingMessage message in messages)
            {
                List <IMessage>     outgoingMessages = new List <IMessage>(messages.Count());
                OutgoingMessageType messageType      = (OutgoingMessageType)StringEnum.Parse(typeof(OutgoingMessageType), message.MessageType);
                if (messageType == OutgoingMessageType.SMS)
                {
                    // Get the target routed gateway
                    Sms sms = Sms.NewInstance();
                    sms.Identifier         = message.Id;
                    sms.DestinationAddress = message.Recipient;
                    sms.Content            = message.Message;
                    MessageFormat format = (MessageFormat)StringEnum.Parse(typeof(MessageFormat), message.MessageFormat);
                    sms.DataCodingScheme = EnumMatcher.MessageCoding[format];
                    sms.ValidityPeriod   = MessageValidPeriod.OneDay;

                    MessageStatusReport statusReport = (MessageStatusReport)StringEnum.Parse(typeof(MessageStatusReport), message.StatusReport);
                    if (statusReport == MessageStatusReport.StatusReport)
                    {
                        sms.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
                    }
                    else if (statusReport == MessageStatusReport.NoStatusReport)
                    {
                        sms.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
                    }

                    sms.DcsMessageClass = EnumMatcher.MessageClass[message.MessageClass];
                    sms.QueuePriority   = EnumMatcher.MessagePriority[message.Priority];

                    IGateway      gateway       = messageGatewayService.Router.GetRoute(sms);
                    GatewayConfig gatewayConfig = GatewayConfig.SingleOrDefault(g => g.Id == gateway.Id);
                    if (gatewayConfig != null)
                    {
                        // Message validity period
                        if (!string.IsNullOrEmpty(gatewayConfig.MessageValidity))
                        {
                            sms.ValidityPeriod = EnumMatcher.ValidityPeriod[gatewayConfig.MessageValidity];
                        }

                        // Status report
                        if (statusReport == MessageStatusReport.FollowChannel)
                        {
                            if (gatewayConfig.RequestStatusReport.Value)
                            {
                                sms.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
                            }
                            else
                            {
                                sms.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
                            }
                        }

                        if (gatewayConfig.UseSimSmsc.HasValue && !gatewayConfig.UseSimSmsc.Value && !string.IsNullOrEmpty(gatewayConfig.Smsc))
                        {
                            sms.ServiceCenterNumber = gatewayConfig.Smsc;
                        }
                    }
                    outgoingMessages.Add(sms);

                    // Update status to "Sending"
                    message.Status     = StringEnum.GetStringValue(MessageStatus.Sending);
                    message.LastUpdate = DateTime.Now;
                    message.Update();
                }
                else if (messageType == OutgoingMessageType.WAPPush)
                {
                    Wappush wappush = Wappush.NewInstance(message.Recipient, message.WapUrl, message.Message);

                    ServiceIndicationAction signal;
                    if (EnumMatcher.ServiceIndication.TryGetValue(message.WapSignal, out signal))
                    {
                        wappush.Signal = signal;
                    }
                    wappush.CreateDate = message.WapCreateDate.Value;
                    wappush.ExpireDate = message.WapExpiryDate.Value;

                    MessageStatusReport statusReport = (MessageStatusReport)StringEnum.Parse(typeof(MessageStatusReport), message.StatusReport);
                    if (statusReport == MessageStatusReport.StatusReport)
                    {
                        wappush.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
                    }
                    else if (statusReport == MessageStatusReport.NoStatusReport)
                    {
                        wappush.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
                    }

                    wappush.DcsMessageClass = EnumMatcher.MessageClass[message.MessageClass];
                    wappush.QueuePriority   = EnumMatcher.MessagePriority[message.Priority];

                    IGateway      gateway       = messageGatewayService.Router.GetRoute(wappush);
                    GatewayConfig gatewayConfig = GatewayConfig.SingleOrDefault(g => g.Id == gateway.Id);
                    if (gatewayConfig != null)
                    {
                        // Message validity period
                        if (!string.IsNullOrEmpty(gatewayConfig.MessageValidity))
                        {
                            wappush.ValidityPeriod = EnumMatcher.ValidityPeriod[gatewayConfig.MessageValidity];
                        }

                        // Status report
                        if (statusReport == MessageStatusReport.FollowChannel)
                        {
                            if (gatewayConfig.RequestStatusReport.Value)
                            {
                                wappush.StatusReportRequest = MessageStatusReportRequest.SmsReportRequest;
                            }
                            else
                            {
                                wappush.StatusReportRequest = MessageStatusReportRequest.NoSmsReportRequest;
                            }
                        }
                    }

                    outgoingMessages.Add(wappush);

                    // Update status to "Sending"
                    message.Status     = StringEnum.GetStringValue(MessageStatus.Sending);
                    message.LastUpdate = DateTime.Now;
                    message.Update();
                }

                int count = messageGatewayService.SendMessages(outgoingMessages);
                log.Debug(string.Format("Messages are queued for sending. Count of number of messages is [{0}]", count));
            }
        }