Merge branch 'development' into feature/GenericHttpClientOptions

Feature: Add constructor to set client options

feature: Add overloaded methods to set Request Types for Client Requests

essentials-framework/Essentials Core/PepperDashEssentialsBase/Comm and IR/GenericHttpClient.cs

@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
+using System.ComponentModel;
 using Crestron.SimplSharp.Net.Http;
+using Crestron.SimplSharp.Ssh;
+using Crestron.SimplSharpPro.EthernetCommunication;
 using PepperDash.Core;
-using PepperDash.Core.DebugThings;
 
 namespace PepperDash.Essentials.Core
 {
@@ -17,52 +16,130 @@ namespace PepperDash.Essentials.Core
 		public GenericHttpClient(string key, string name, string hostname)
 			: base(key, name)
 		{
-			Client = new HttpClient();
-			Client.HostName = hostname;
-			
-			
+			Client = new HttpClient {HostName = hostname};
 		}
 
-		/// <summary>
-		/// 
+	    public GenericHttpClient(string key, string name, string hostname, GenericHttpClientConnectionOptions options)
+	        : base(key, name)
+	    {
+	        Client = new HttpClient
+	        {
+	            HostName = hostname,
+	            Accept = options.Accept,
+	            KeepAlive = options.KeepAlive,
+	            Password = options.Password,
+	            Timeout = options.Timeout,
+	            TimeoutEnabled = options.TimeoutEnabled,
+	            UserAgent = options.UserAgent,
+	            UserName = options.UserName,
+	            Version = options.Version
+	        };
+	        if (options.Port > 0) Client.Port = options.Port;
+	    }
+
+	    /// <summary>
+		/// Send a HTTP Get Request to a client
 		/// </summary>
-		/// <param name="path"></param>
-		public void SendText(string path)
-		{
-			HttpClientRequest request = new HttpClientRequest();
-			string url = string.Format("http://{0}/{1}", Client.HostName, path);
-			request.Url = new UrlParser(url);
-			HttpClient.DISPATCHASYNC_ERROR error = Client.DispatchAsyncEx(request, Response, request); 
-		}
-		public void SendText(string format, params object[] items)
-		{
-			HttpClientRequest request = new HttpClientRequest();
-			string url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
-			request.Url = new UrlParser(url);
-			HttpClient.DISPATCHASYNC_ERROR error = Client.DispatchAsyncEx(request, Response, request);
-		}
+		/// <param name="path">Path to request node</param>
+        public void SendText(string path)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, path);
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
 
-		public void SendTextNoResponse(string format, params object[] items)
-		{
-			HttpClientRequest request = new HttpClientRequest();
-			string url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
-			request.Url = new UrlParser(url);
-			Client.Dispatch(request);
-		}
+        /// <summary>
+        /// Send a HTTP Get Request to a client using a formatted string
+        /// </summary>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendText(string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send a unidirectional HTTP Get Request to a client using a formatted string
+        /// </summary>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendTextNoResponse(string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            Client.Dispatch(request);
+        }
+
+        /// <summary>
+        /// Send an HTTP Request of a specific request type
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="path">Path to request node</param>
+        public void SendText(RequestType requestType, string path)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, path);
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url),
+                RequestType = requestType
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send an HTTP Request of a specific request type using a formatted string
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendText(RequestType requestType, string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url),
+                RequestType = requestType
+            };
+            var error = Client.DispatchAsyncEx(request, Response, request);
+        }
+
+        /// <summary>
+        /// Send a unidirectional HTTP Request of a specific request type using a formatted string
+        /// </summary>
+        /// <param name="requestType">HTTP Request Type</param>
+        /// <param name="format">Path</param>
+        /// <param name="items">Parameters for Path String Formatting</param>
+        public void SendTextNoResponse(RequestType requestType, string format, params object[] items)
+        {
+            var url = string.Format("http://{0}/{1}", Client.HostName, string.Format(format, items));
+            var request = new HttpClientRequest()
+            {
+                Url = new UrlParser(url)
+            };
+            Client.Dispatch(request);
+        }
 
 		private void Response(HttpClientResponse response, HTTP_CALLBACK_ERROR error, object request)
 		{
-			if (error == HTTP_CALLBACK_ERROR.COMPLETED)
-			{
-				var responseReceived = response;
-
-				if (responseReceived.ContentString.Length > 0)
-				{
-					if (ResponseRecived != null)
-						ResponseRecived(this, new GenericHttpClientEventArgs(responseReceived.ContentString, (request as HttpClientRequest).Url.ToString(), error));
-				}
-			}
+		    if (error != HTTP_CALLBACK_ERROR.COMPLETED) return;
+		    var responseReceived = response;
 
+		    if (responseReceived.ContentString.Length <= 0) return;
+		    if (ResponseRecived == null) return;
+		    var httpClientRequest = request as HttpClientRequest;
+		    if (httpClientRequest != null)
+		        ResponseRecived(this, new GenericHttpClientEventArgs(responseReceived.ContentString, httpClientRequest.Url.ToString(), error));
 		}
 
 
@@ -100,6 +177,8 @@ namespace PepperDash.Essentials.Core
 
 		#endregion
 	}
+
+
 	public class GenericHttpClientEventArgs : EventArgs
 	{
 		public string ResponseText { get; private set; }
@@ -112,4 +191,84 @@ namespace PepperDash.Essentials.Core
 			Error = error;
 		}
 	}
+
+    /// <summary>
+    /// Objedct to set parameters for HTTP Requests
+    /// </summary>
+    public class GenericHttpClientConnectionOptions
+    {
+        /// <summary>
+        ///     Gets or sets content types that are acceptable for the response. The default
+        ///     value is "text/html, image/gif, image/jpeg, image/png, */*".
+        /// </summary>
+        [DefaultValue("text/html, image/gif, image/jpeg, image/png")]
+        public string Accept { get; set; }
+
+        /// <summary>
+        ///     Controls whether to use HTTP Keep-Alive to keep the connection alive between
+        ///     requests. If enabled (true) , once a request is made and a connection is
+        ///     established, this connection is kept open and used for future requests. If
+        ///     disabled, the connection is closed, and a new connection is created for future
+        ///     requests.
+        /// </summary>
+        [DefaultValue(true)]
+        public bool KeepAlive { get; set; }
+
+        /// <summary>
+        ///     This property controls whether the request operation will do an automatic
+        ///     timeout checking. If timeout handling is turned on (i.e. this property is
+        ///     set to true) and a request takes longer than Timeout, it will be terminated.
+        /// </summary>
+        [DefaultValue(true)]
+        public bool TimeoutEnabled { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the maximum amount of time (in seconds) that a client will wait
+        ///     for a server response within a single request. The default value is 60 seconds
+        ///     (1 minute).  The timeout handling can be activated via the TimeoutEnabled
+        ///     property.
+        /// </summary>
+        [DefaultValue(60)]
+        public int Timeout { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the version identifier of the UserAgent. Can be used to mimic
+        ///     particular browsers like Internet Explorer 6.0
+        /// </summary>
+        [DefaultValue("1.1")]
+        public string Version { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the identifier of the software being used to retrieve data via
+        ///     the URL. Some custom HTTP servers check this HTTP header to provide content
+        ///     optimized for particular HTTP browsers.
+        /// </summary>
+        [DefaultValue("Crestron SimplSharp HTTP Client")]
+        public string UserAgent { get; set; }
+
+        /// <summary>
+        ///    Name that will be inserted into the Authorization HTTP header in the request
+        ///    to the server.
+        /// </summary>
+        public string UserName { get; set; }
+
+        /// <summary>
+        ///     Password that will be inserted into the Authorization HTTP header in the
+        ///     request to the server.
+        /// </summary>
+        public string Password { get; set; }
+
+        /// <summary>
+        ///     The server Port that you intend the client to connect to.  If you do not
+        ///     assign a port number on this property, the port number in the parsed URL
+        ///     will be used. If a port number is assigned in the parsed URL, it will take
+        ///     precedence over this property.
+        /// </summary>
+        /// <remarks>
+        ///     If you do not assign a port number on this property, the port number in the
+        ///     parsed URL will be used.
+        /// </remarks>
+        /// 
+        public int Port { get; set; }
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Device Info/NetworkDeviceHelpers.cs

@@ -1,218 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using PepperDash.Core;
-using Crestron.SimplSharp;
-using PepperDash.Essentials.Core;
-
-namespace PepperDash.Essentials.Core.DeviceInfo
-{
-    public static class NetworkDeviceHelpers
-    {
-        /// <summary>
-        /// Event raised when ArpTable changes
-        /// </summary>
-        public static event ArpTableEventHandler ArpTableUpdated;
-
-        /// <summary>
-        /// Delegate called by ArpTableUpdated
-        /// </summary>
-        /// <param name="args">contains the entire ARP table and a bool to note if there was an error in retrieving the data</param>
-        public delegate void ArpTableEventHandler(ArpTableEventArgs args);
-
-        private static readonly char NewLineSplitter = CrestronEnvironment.NewLine.ToCharArray().First();
-        private static readonly string NewLine = CrestronEnvironment.NewLine;
-
-        private static readonly CCriticalSection Lock = new CCriticalSection();
-
-        /// <summary>
-        /// Last resolved ARP table - it is recommended to refresh the arp before using this.
-        /// </summary>
-        public static List<ArpEntry> ArpTable { get; private set; }
-
-        /// <summary>
-        /// Force recheck of ARP table
-        /// </summary>
-        public static void RefreshArp()
-        {
-            var error = false;
-            try
-            {
-                Lock.Enter();
-                var consoleResponse = string.Empty;
-                if (!CrestronConsole.SendControlSystemCommand("showarptable", ref consoleResponse)) return;
-                if (string.IsNullOrEmpty(consoleResponse))
-                {
-                    error = true;
-                    return;
-                }
-                ArpTable.Clear();
-
-                Debug.Console(2, "ConsoleResponse of 'showarptable' : {0}{1}", NewLine, consoleResponse);
-
-                var myLines =
-                    consoleResponse.Split(NewLineSplitter)
-                        .ToList()
-                        .Where(o => (o.Contains(':') && !o.Contains("Type", StringComparison.OrdinalIgnoreCase)))
-                        .ToList();
-                foreach (var line in myLines)
-                {
-                    var item = line;
-                    var seperator = item.Contains('\t') ? '\t' : ' ';
-                    var dataPoints = item.Split(seperator);
-                    if (dataPoints == null || dataPoints.Length < 2) continue;
-                    var ipAddress = SanitizeIpAddress(dataPoints.First().TrimAll());
-                    var macAddress = dataPoints.Last();
-                    ArpTable.Add(new ArpEntry(ipAddress, macAddress));
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.Console(0, "Exception in \"RefreshArp\" : {0}", ex.Message);
-                error = true;
-            }
-            finally
-            {
-                Lock.Leave();
-                OnArpTableUpdated(new ArpTableEventArgs(ArpTable, error));
-            }
-        }
-
-
-        private static void OnArpTableUpdated(ArpTableEventArgs args)
-        {
-            if (args == null) return;
-            var handler = ArpTableUpdated;
-            if (handler == null) return;
-            handler.Invoke(args);
-        }
-
-        static NetworkDeviceHelpers()
-        {
-            ArpTable = new List<ArpEntry>();
-        }
-
-        /// <summary>
-        /// Removes leading zeros, leading whitespace, and trailing whitespace from an IPAddress string
-        /// </summary>
-        /// <param name="ipAddressIn">Ip Address to Santitize</param>
-        /// <returns>Sanitized Ip Address</returns>
-        public static string SanitizeIpAddress(string ipAddressIn)
-        {
-            try
-            {
-                var ipAddress = IPAddress.Parse(ipAddressIn.TrimStart('0'));
-                return ipAddress.ToString();
-            }
-            catch (Exception ex)
-            {
-                Debug.Console(0, "Unable to Santize Ip : {0}", ex.Message);
-                return ipAddressIn;
-            }
-        }
-
-        /// <summary>
-        /// Resolves a hostname by IP Address using DNS
-        /// </summary>
-        /// <param name="ipAddress">IP Address to resolve from</param>
-        /// <returns>Resolved Hostname - on failure to determine hostname, will return IP Address</returns>
-        public static string ResolveHostnameFromIp(string ipAddress)
-        {
-            try
-            {
-                var santitizedIp = SanitizeIpAddress(ipAddress);
-                var hostEntry = Dns.GetHostEntry(santitizedIp);
-                return hostEntry == null ? ipAddress : hostEntry.HostName;
-            }
-            catch (Exception ex)
-            {
-                Debug.Console(0, "Exception Resolving Hostname from IP Address : {0}", ex.Message);
-                return ipAddress;
-            }
-        }
-
-        /// <summary>
-        /// Resolves an IP Address by hostname using DNS
-        /// </summary>
-        /// <param name="hostName">Hostname to resolve from</param>
-        /// <returns>Resolved IP Address - on a failure to determine IP Address, will return hostname</returns>
-        public static string ResolveIpFromHostname(string hostName)
-        {
-            try
-            {
-                var hostEntry = Dns.GetHostEntry(hostName);
-                return hostEntry == null ? hostName : hostEntry.AddressList.First().ToString();
-            }
-            catch (Exception ex)
-            {
-                Debug.Console(0, "Exception Resolving IP Address from Hostname : {0}", ex.Message);
-                return hostName;
-            }
-        }
-
-    }
-
-    /// <summary>
-    /// Object to hold data about an arp entry
-    /// </summary>
-    public class ArpEntry
-    {
-        public readonly IPAddress IpAddress;
-        public readonly string MacAddress;
-
-        /// <summary>
-        /// Constructs new ArpEntry object
-        /// </summary>
-        /// <param name="ipAddress">string formatted as ipv4 address</param>
-        /// <param name="macAddress">mac address string - format is unimportant</param>
-        public ArpEntry(string ipAddress, string macAddress)
-        {
-            if (string.IsNullOrEmpty(ipAddress))
-            {
-                throw new ArgumentException("\"ipAddress\" cannot be null or empty");
-            }
-            if (string.IsNullOrEmpty(macAddress))
-            {
-                throw new ArgumentException("\"macAddress\" cannot be null or empty");
-            }
-            IpAddress = IPAddress.Parse(ipAddress.TrimStart().TrimStart('0').TrimEnd());
-            MacAddress = macAddress;
-        }
-    }
-
-    /// <summary>
-    /// Arguments passed by the ArpTableUpdated event
-    /// </summary>
-    public class ArpTableEventArgs : EventArgs
-    {
-        /// <summary>
-        /// The retrieved ARP Table
-        /// </summary>
-        public readonly List<ArpEntry> ArpTable;
-        /// <summary>
-        /// True if there was a problem retrieving the ARP Table
-        /// </summary>
-        public readonly bool Error;
-
-        /// <summary>
-        /// Constructor for ArpTableEventArgs
-        /// </summary>
-        /// <param name="arpTable">The entirety of the retrieved ARP table</param>
-        /// <param name="error">True of an error was encountered updating the ARP table</param>
-        public ArpTableEventArgs(List<ArpEntry> arpTable, bool error)
-        {
-            ArpTable = arpTable;
-            Error = error;
-        }
-
-        /// <summary>
-        /// Constructor for ArpTableEventArgs - assumes no error encountered in retrieving ARP Table
-        /// </summary>
-        /// <param name="arpTable">The entirety of the retrieved ARP table</param>
-        public ArpTableEventArgs(List<ArpEntry> arpTable)
-        {
-            ArpTable = arpTable;
-            Error = false;
-        }
-    }
-}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Extensions/StringExtensions.cs

@@ -1,5 +1,4 @@
 using System;
-using System.ComponentModel;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -9,70 +8,17 @@ namespace PepperDash.Essentials.Core
 {
     public static class StringExtensions
     {
-        /// <summary>
-        /// Returns null if a string is empty, otherwise returns the string
-        /// </summary>
-        /// <param name="s">string input</param>
-        /// <returns>null if the string is emtpy, otherwise returns the string</returns>
         public static string NullIfEmpty(this string s)
         {
             return string.IsNullOrEmpty(s) ? null : s;
         }
-
-        /// <summary>
-        /// Returns null if a string is empty or made of only whitespace characters, otherwise returns the string
-        /// </summary>
-        /// <param name="s">string input</param>
-        /// <returns>null if the string is wempty or made of only whitespace characters, otherwise returns the string</returns>
         public static string NullIfWhiteSpace(this string s)
         {
             return string.IsNullOrEmpty(s.Trim()) ? null : s;
         }
-
-        /// <summary>
-        /// Returns a replacement string if the input string is empty or made of only whitespace characters, otherwise returns the input string
-        /// </summary>
-        /// <param name="s">input string</param>
-        /// <param name="newString">string to replace with if input string is empty or whitespace</param>
-        /// <returns>returns newString if s is null, emtpy, or made of whitespace characters, otherwise returns s</returns>
         public static string ReplaceIfNullOrEmpty(this string s, string newString)
         {
             return string.IsNullOrEmpty(s) ? newString : s;
         }
-
-        /// <summary>
-        /// Overload for Contains that allows setting an explicit String Comparison
-        /// </summary>
-        /// <param name="source">Source String</param>
-        /// <param name="toCheck">String to check in Source String</param>
-        /// <param name="comp">Comparison parameters</param>
-        /// <returns>true of string contains "toCheck"</returns>
-        public static bool Contains(this string source, string toCheck, StringComparison comp)
-        {
-            if (string.IsNullOrEmpty(source)) return false;
-            return source.IndexOf(toCheck, comp) >= 0;
-        }
-
-        /// <summary>
-        /// Performs TrimStart() and TrimEnd() on source string
-        /// </summary>
-        /// <param name="source">String to Trim</param>
-        /// <returns>Trimmed String</returns>
-        public static string TrimAll(this string source)
-        {
-            return string.IsNullOrEmpty(source) ? string.Empty : source.TrimStart().TrimEnd();
-        }
-
-        /// <summary>
-        /// Performs TrimStart(chars char[]) and TrimEnd(chars char[]) on source string.
-        /// </summary>
-        /// <param name="source">String to Trim</param>
-        /// <param name="chars">Char Array to trim from string</param>
-        /// <returns>Trimmed String</returns>
-        public static string TrimAll(this string source, char[] chars)
-        {
-            return string.IsNullOrEmpty(source) ? string.Empty : source.TrimStart(chars).TrimEnd(chars);
-        }
-
     }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -200,7 +200,6 @@
     <Compile Include="Crestron IO\Relay\GenericRelayDevice.cs" />
     <Compile Include="Crestron IO\Relay\ISwitchedOutput.cs" />
     <Compile Include="Crestron IO\StatusSign\StatusSignController.cs" />
-    <Compile Include="Device Info\NetworkDeviceHelpers.cs" />
     <Compile Include="Devices\PowerInterfaces.cs" />
     <Compile Include="Web\RequestHandlers\AppDebugRequestHandler.cs" />
     <Compile Include="Web\RequestHandlers\GetFeedbacksForDeviceRequestHandler.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Routing/RoutingPort.cs

@@ -42,7 +42,7 @@ namespace PepperDash.Essentials.Core
 	public enum eRoutingPortConnectionType
 	{
 		None, BackplaneOnly, DisplayPort, Dvi, Hdmi, Rgb, Vga, LineAudio, DigitalAudio, Sdi, 
-		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming, UsbC, HdBaseT
+		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming
 	}
 
 	/// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Routing/RoutingPortNames.cs

@@ -199,45 +199,5 @@ namespace PepperDash.Essentials.Core.Routing
         /// MediaPlayer
         /// </summary>
         public const string MediaPlayer = "mediaPlayer";
-        /// <summary>
-        /// UsbCIn
-        /// </summary>
-        public const string UsbCIn = "usbCIn";
-        /// <summary>
-        /// UsbCIn1
-        /// </summary>
-        public const string UsbCIn1 = "usbCIn1";
-        /// <summary>
-        /// UsbCIn2
-        /// </summary>
-        public const string UsbCIn2 = "usbCIn2";
-        /// <summary>
-        /// UsbCIn3
-        /// </summary>
-        public const string UsbCIn3 = "usbCIn3";
-        /// <summary>
-        /// UsbCOut
-        /// </summary>
-        public const string UsbCOut = "usbCOut";
-        /// <summary>
-        /// UsbCOut1
-        /// </summary>
-        public const string UsbCOut1 = "usbCOut1";
-        /// <summary>
-        /// UsbCOut2
-        /// </summary>
-        public const string UsbCOut2 = "usbCOut2";
-        /// <summary>
-        /// UsbCOut3
-        /// </summary>
-        public const string UsbCOut3 = "usbCOut3";
-        /// <summary>
-        /// HdBaseTIn
-        /// </summary>
-        public const string HdBaseTIn = "hdBaseTIn";
-        /// <summary>
-        /// HdBaseTOut
-        /// </summary>
-        public const string HdBaseTOut = "hdBaseTOut";
-    }
+	}
 }