AlertsMgr.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.IO;
using Seci.Definitions;
using System.ComponentModel;
using System.Xml;
using System.Xml.Serialization;

namespace Seci.Managers
{
    public static class AlertsMgr
    {
        private static string PHONE_NUMBERS_FILENAME = "phone_numbers.xml";

        private static Tools.PhoneNumbersList PhoneNumbers = new Tools.PhoneNumbersList();
        private static Tools.AlertsBox Alerts = new Tools.AlertsBox();
        private static BackgroundWorker _sender;

        public static void SetAlerts(Tools.AlertsBox alerts)
        {
            Alerts = alerts;
        }

        public static void SetPhoneNumbers(Tools.PhoneNumbersList numbers)
        {
            PhoneNumbers = numbers;
        }

        public static void CheckBlockInRange(Definitions.BlockInfo block)
        {
            if (Alerts != null && Alerts.BlockLimitsAlerts.ContainsKey(block.BlockName.ToLower()))
            {
                BlockAlert temp = Alerts.BlockLimitsAlerts[block.BlockName.ToLower()];
                double value;

                if (!temp.Enabled) return;

                if (Double.TryParse(block.CurrentValue, out value))
                {
                    if (value <= temp.HighLimit && value >= temp.LowLimit)
                    {
                        //In range
                        if (temp.OutOfRange)
                        {
                            //If it comes back into range then reset the last message time
                            temp.TimeWentOutOfRange = new DateTime();
                        }
                        temp.OutOfRange = false;
                    }
                    else
                    {
                        if (!temp.OutOfRange)
                        {
                            temp.OutOfRange = true;
                            temp.TimeWentOutOfRange = DateTime.Now;
                        }

                        //Out of range
                        TimeSpan diff = DateTime.Now - temp.TimeWentOutOfRange;
                        if (diff > temp.DelayBeforeSms)
                        {
                            //Check a message has not been sent in the last hour
                            if (DateTime.Now - temp.LastMessageSent > new TimeSpan(1, 0, 0))
                            {
                                //Send a message
                                temp.LastMessageSent = DateTime.Now;
                                sendMessage("The " + block.BlockName + " block has gone out of range on " + Seci.Definitions.Status.Instrument.ToUpper());
                            }
                        }
                    }
                }
            }
        }

        public static void CheckInWaiting(Boolean waiting)
        {
            if (Alerts != null && Alerts.WaitingStateAlert != null)
            {
                if (waiting)
                {
                    if (!Alerts.WaitingStateAlert.OutOfRange)
                    {
                        Alerts.WaitingStateAlert.OutOfRange = true;
                        Alerts.WaitingStateAlert.TimeWentOutOfRange = DateTime.Now;
                    }

                    TimeSpan diff = DateTime.Now - Alerts.WaitingStateAlert.TimeWentOutOfRange;
                    if (diff > Alerts.WaitingStateAlert.DelayBeforeSms)
                    {
                        //Check a message has not been sent in the last hour
                        if (DateTime.Now - Alerts.WaitingStateAlert.LastMessageSent > new TimeSpan(1, 0, 0))
                        {
                            //Send a message
                            Alerts.WaitingStateAlert.LastMessageSent = DateTime.Now;

                            sendMessage("The " + Seci.Definitions.Status.Instrument.ToUpper() + " system has been in the WAITING state for longer than the set limit");
                        }
                    }
                }
                else
                {
                    if (Alerts.WaitingStateAlert.OutOfRange)
                    {
                        //If it comes out of waiting then reset the last message time
                        Alerts.WaitingStateAlert.TimeWentOutOfRange = new DateTime();
                    }
                    Alerts.WaitingStateAlert.OutOfRange = false;
                }
            }
        }       

        private static void sendMessage(String message)
        {
            _sender = new BackgroundWorker();
            _sender.DoWork += new DoWorkEventHandler(_sender_DoWork);
            _sender.RunWorkerAsync(message);
        }

        static void _sender_DoWork(object sender, DoWorkEventArgs e)
        {
            String message = e.Argument.ToString();

            if (!String.IsNullOrEmpty(message) && PhoneNumbers.Numbers.Count > 0)
            {
                foreach (Tools.PhoneNumber pn in PhoneNumbers.Numbers)
                {
                    try
                    {
                        // Create a request using a URL that can receive a post. 
                        WebRequest request = WebRequest.Create("http://www.kapow.co.uk/scripts/sendsms.php");
                        // Set the Method property of the request to POST.
                        request.Method = "POST";
                        // Create POST data and convert it to a byte array.
                        string postData = "username=isissms&password=camacdead&mobile=" + pn.Number + "&sms=" + message;
                        byte[] byteArray = Encoding.UTF8.GetBytes(postData);
                        // Set the ContentType property of the WebRequest.
                        request.ContentType = "application/x-www-form-urlencoded";
                        // Set the ContentLength property of the WebRequest.
                        request.ContentLength = byteArray.Length;
                        // Get the request stream.
                        Stream dataStream = request.GetRequestStream();
                        // Write the data to the request stream.
                        dataStream.Write(byteArray, 0, byteArray.Length);
                        // Close the Stream object.
                        dataStream.Close();
                        // Get the response.
                        WebResponse response = request.GetResponse();
                    }
                    catch(Exception err)
                    {
                        Seci.Helpers.ErrorLogger.SeciError("Alerts Manager", err);
                    }
                }
            }
        }

        public static Tools.PhoneNumbersList GetPhoneNumbersCopy()
        {
            Tools.PhoneNumbersList copy = PhoneNumbers.Clone() as Tools.PhoneNumbersList;
            return copy;
        }

        public static Tools.AlertsBox GetAlertsCopy()
        {
            Tools.AlertsBox copy = Alerts.Clone() as Tools.AlertsBox;
            return copy;
        }

        public static Tools.AlertsBox GetAlertsCopyForSaving()
        {
            Tools.AlertsBox copy = Alerts.Clone() as Tools.AlertsBox;
            Tools.AlertsBox newcopy = new Tools.AlertsBox();

            newcopy.WaitingStateAlert = copy.WaitingStateAlert;
            //newcopy.PhoneNumbers = copy.PhoneNumbers;

            foreach (String key in copy.BlockLimitsAlerts.Keys)
            {
                //Don't add the alert if the block does not exist any more and if it belongs to a subconfiguration
                if (BlockMgr.Blocks.Contains(key) && String.IsNullOrEmpty(Alerts.BlockLimitsAlerts[key].OwningConfiguration))
                {
                    newcopy.AddBlockAlert(copy.BlockLimitsAlerts[key].Blockname, copy.BlockLimitsAlerts[key].BlockType, copy.BlockLimitsAlerts[key].LowLimit, copy.BlockLimitsAlerts[key].HighLimit, copy.BlockLimitsAlerts[key].Enabled);
                }
            }

            return newcopy;
        }

        public static void AddComponentBox(Tools.AlertsBox master, Tools.AlertsBox toAdd, String compName)
        {
            if (master == null)
            {
                master = Alerts;
            }

            //Only use the sub-config's waiting alert if the main config does not have one
            if (toAdd.WaitingStateAlert != null && master.WaitingStateAlert == null)
            {
                master.WaitingStateAlert = toAdd.WaitingStateAlert;
                master.WaitingStateAlert.OwningConfiguration = compName;
            }

            //Add the alerts
            foreach (String key in toAdd.BlockLimitsAlerts.Keys)
            {
                //Don't overwrite any set in the main configuration
                if (!master.BlockLimitsAlerts.ContainsKey(key))
                {
                    master.BlockLimitsAlerts.Add(key, toAdd.BlockLimitsAlerts[key]);
                    master.BlockLimitsAlerts[key].OwningConfiguration = compName;
                }
            }
        }

        public static void ClearAlerts()
        {
            Alerts = new Tools.AlertsBox();
        }

        public static void SavePhoneNumbers()
        {
            FileStream stream = new FileStream(Seci.Definitions.Status.ConfigDir + "\\" + PHONE_NUMBERS_FILENAME, FileMode.Create);

            try
            {
                //Serialise the config
                XmlSerializer serialize = new XmlSerializer(typeof(Tools.PhoneNumbersList));
                serialize.Serialize(stream, PhoneNumbers);

            }
            catch (Exception e)
            {
                //throw error up to next level
                //throw new ArgumentException(e.Message);
            }
            finally
            {
                stream.Close();
            }
        }

        public static void LoadPhoneNumbers()
        {
            FileInfo fi = new FileInfo(Seci.Definitions.Status.ConfigDir + "\\" + PHONE_NUMBERS_FILENAME);

            if (!fi.Exists)
            {
                return;
            }

            FileStream stream = new FileStream(fi.FullName, FileMode.Open, FileAccess.Read);

            try
            {
                XmlSerializer deserialize = new XmlSerializer(typeof(Tools.PhoneNumbersList));
                PhoneNumbers = (Tools.PhoneNumbersList)deserialize.Deserialize(stream);
            }
            catch (Exception e)
            {
                //throw error up to next level
                //throw new ArgumentException(e.Message);
            }
            finally
            {
                stream.Close();
            }
        }
    }
}