iSpyApplication.Controls.VolumeLevel.ProcessAlertEvent C# (CSharp) Method

ProcessAlertEvent() private method

private ProcessAlertEvent ( string mode, string pluginmessage, string type, string param1, string param2, string param3, string param4 ) : void
mode string
pluginmessage string
type string
param1 string
param2 string
param3 string
param4 string
return void
        private void ProcessAlertEvent(string mode, string pluginmessage, string type, string param1, string param2, string param3, string param4)
        {
            string id = Micobject.id.ToString(CultureInfo.InvariantCulture);

            param1 = param1.Replace("{ID}", id).Replace("{NAME}", Micobject.name).Replace("{MSG}", pluginmessage);
            param2 = param2.Replace("{ID}", id).Replace("{NAME}", Micobject.name).Replace("{MSG}", pluginmessage);
            param3 = param3.Replace("{ID}", id).Replace("{NAME}", Micobject.name).Replace("{MSG}", pluginmessage);
            param4 = param4.Replace("{ID}", id).Replace("{NAME}", Micobject.name).Replace("{MSG}", pluginmessage);

            try
            {
                switch (type)
                {
                    case "Exe":
                        {
                            if (param1.ToLower() == "ispy.exe" || param1.ToLower() == "ispy")
                            {
                                MainForm.InstanceReference.ProcessCommandString(param2);
                            }
                            else
                            {
                                try
                                {

                                    var startInfo = new ProcessStartInfo
                                    {
                                        UseShellExecute = true,
                                        FileName = param1,
                                        Arguments = param2
                                    };
                                    try
                                    {
                                        var fi = new FileInfo(param1);
                                        if (fi.DirectoryName != null)
                                            startInfo.WorkingDirectory = fi.DirectoryName;
                                    }
                                    catch(Exception ex)
                                    {
                                        ErrorHandler?.Invoke(ex.Message);
                                    }
                                    if (!MainForm.Conf.CreateAlertWindows)
                                    {
                                        startInfo.CreateNoWindow = true;
                                        startInfo.WindowStyle = ProcessWindowStyle.Hidden;
                                    }

                                    Process.Start(startInfo);
                                }
                                catch (Exception e)
                                {
                                    ErrorHandler?.Invoke(e.Message);
                                }
                            }
                        }
                        break;
                    case "URL":
                        {
                            var request = (HttpWebRequest)WebRequest.Create(param1);
                            request.Credentials = CredentialCache.DefaultCredentials;
                            var response = (HttpWebResponse)request.GetResponse();

                            // Get the stream associated with the response.
                            Stream receiveStream = response.GetResponseStream();

                            // Pipes the stream to a higher level stream reader with the required encoding format.
                            if (receiveStream != null)
                            {
                                var readStream = new StreamReader(receiveStream, Encoding.UTF8);
                                readStream.ReadToEnd();
                                response.Close();
                                readStream.Close();
                                receiveStream.Close();
                            }
                            response.Close();
                        }
                        break;
                    case "NM": //network message
                        switch (param1)
                        {
                            case "TCP":
                                {
                                    IPAddress ip;
                                    if (IPAddress.TryParse(param2, out ip))
                                    {
                                        int port;
                                        if (int.TryParse(param3, out port))
                                        {
                                            using (var tcpClient = new TcpClient())
                                            {
                                                try
                                                {
                                                    tcpClient.Connect(ip, port);
                                                    using (var networkStream = tcpClient.GetStream())
                                                    {
                                                        using (var clientStreamWriter = new StreamWriter(networkStream))
                                                        {
                                                            clientStreamWriter.Write(param4);
                                                            clientStreamWriter.Flush();
                                                            clientStreamWriter.Close();
                                                        }
                                                        networkStream.Close();
                                                    }
                                                }
                                                catch (Exception ex)
                                                {
                                                    ErrorHandler?.Invoke(ex.Message);
                                                }
                                                tcpClient.Close();
                                            }

                                        }
                                    }
                                }

                                break;
                            case "UDP":
                                {
                                    IPAddress ip;
                                    if (IPAddress.TryParse(param2, out ip))
                                    {
                                        int port;
                                        if (int.TryParse(param3, out port))
                                        {
                                            using (var udpClient = new UdpClient())
                                            {
                                                try
                                                {

                                                    udpClient.Connect(ip, port);
                                                    var cmd = Encoding.ASCII.GetBytes(param4);
                                                    udpClient.Send(cmd, cmd.Length);

                                                }
                                                catch (Exception ex)
                                                {
                                                    ErrorHandler?.Invoke(ex.Message);
                                                }
                                                finally
                                                {
                                                    udpClient.Close();
                                                }
                                            }

                                        }
                                    }
                                }
                                break;
                        }
                        break;
                    case "S":
                        try
                        {
                            using (var sp = new SoundPlayer(param1))
                            {
                                sp.Play();
                            }
                        }
                        catch (Exception ex)
                        {
                            ErrorHandler?.Invoke(ex.Message);
                        }
                        break;
                    case "ATC":
                        if (CameraControl!=null)
                            AudioSynth.Play(param1, CameraControl);
                        break;
                    case "SW":
                        RemoteCommand?.Invoke(this, new ThreadSafeCommand("show"));
                        break;
                    case "B":
                        Console.Beep();
                        break;
                    case "M":
                        MainForm.InstanceReference._pnlCameras.Maximise(this, false);

                        break;
                    case "TA":
                        {

                            string[] tid = param1.Split(',');
                            switch (tid[0])
                            {
                                case "1":
                                    VolumeLevel vl = MainForm.InstanceReference.GetVolumeLevel(Convert.ToInt32(tid[1]));
                                    if (vl != null && vl != this) //prevent recursion
                                        vl.Alarm(this, EventArgs.Empty);
                                    break;
                                case "2":
                                    CameraWindow cw = MainForm.InstanceReference.GetCameraWindow(Convert.ToInt32(tid[1]));
                                    cw?.Alarm(this, EventArgs.Empty);
                                    break;
                            }

                        }
                        break;
                    case "SOO":
                        {

                            string[] tid = param1.Split(',');
                            switch (tid[0])
                            {
                                case "1":
                                    VolumeLevel vl =
                                        MainForm.InstanceReference.GetVolumeLevel(Convert.ToInt32(tid[1]));
                                    vl?.Enable();
                                    break;
                                case "2":
                                    CameraWindow cw =
                                        MainForm.InstanceReference.GetCameraWindow(Convert.ToInt32(tid[1]));
                                    cw?.Enable();
                                    break;
                            }

                        }
                        break;
                    case "SOF":
                        {

                                string[] tid = param1.Split(',');
                                switch (tid[0])
                                {
                                    case "1":
                                        VolumeLevel vl =
                                            MainForm.InstanceReference.GetVolumeLevel(Convert.ToInt32(tid[1]));
                                        vl?.Disable();
                                        break;
                                    case "2":
                                        CameraWindow cw =
                                            MainForm.InstanceReference.GetCameraWindow(Convert.ToInt32(tid[1]));
                                        cw?.Disable();
                                        break;
                                }

                        }
                        break;
                    case "E":
                        {
                            if (Micobject.settings.messaging)
                            {
                                string subject = MailMerge(MainForm.Conf.MailAlertSubject, mode, Recording, pluginmessage);
                                string message = MailMerge(MainForm.Conf.MailAlertBody, mode, Recording, pluginmessage);

                                message += MainForm.Conf.AppendLinkText;

                                WsWrapper.SendAlert(param1, subject, message);
                            }
                        }
                        break;
                    case "SMS":
                        {
                            if (Micobject.settings.messaging)
                            {
                                string message = MailMerge(MainForm.Conf.SMSAlert, mode, Recording, pluginmessage);
                                if (message.Length > 160)
                                    message = message.Substring(0, 159);

                                WsWrapper.SendSms(param1, message);
                            }
                        }
                        break;
                    case "TM":
                        {
                            if (Micobject.settings.messaging)
                            {
                                string message = MailMerge(MainForm.Conf.SMSAlert, mode, Recording, pluginmessage);
                                if (message.Length > 160)
                                    message = message.Substring(0, 159);

                                WsWrapper.SendTweet(message + " " + MainForm.Webserver + "/mobile/");
                            }
                        }
                        break;
                    case "MO":
                        {
                            NativeCalls.WakeScreen();
                        }
                        break;

                }
            }
            catch (Exception ex)
            {
                ErrorHandler?.Invoke(ex.Message);
            }
        }