Merge branch 'development' into hotfix/vtc-room-activation-deactivation-changes

Update Crestron DBS & PD Core DEV

PepperDashEssentials/ControlSystem.cs

@@ -401,21 +401,20 @@ namespace PepperDash.Essentials
                         }
                         else if (this.ControllerPrompt.IndexOf("mpc3", StringComparison.OrdinalIgnoreCase) > -1)
                         {
-							Debug.Console(2, "MPC3 processor type detected.  Adding Mpc3TouchpanelController.");
+                            Debug.Console(2, "MPC3 processor type detected.  Adding Mpc3TouchpanelController.");
 
-							var butToken = devConf.Properties["buttons"];
-							if (butToken == null)
-							{
-								Debug.Console(0, Debug.ErrorLogLevel.Error,
-									"Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
-								continue;
-							}
-
-							var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
-							var tpController = new Core.Touchpanels.Mpc3TouchpanelController(
-									string.Format("{0}-keypadButtons", devConf.Key), devConf.Name, Global.ControlSystem, buttons);
-
-							DeviceManager.AddDevice(tpController);	
+                            var butToken = devConf.Properties["buttons"];
+                            if (butToken != null)
+                            {
+                                var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
+                                var tpController = new Essentials.Core.Touchpanels.Mpc3TouchpanelController(devConf.Key, devConf.Name, Global.ControlSystem, buttons);
+                                DeviceManager.AddDevice(tpController);
+                            }
+                            else
+                            {
+                                Debug.Console(0, Debug.ErrorLogLevel.Error, "Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
+                            }
+                            
                         }
                         else
                         {

essentials-framework/Essentials Core/PepperDashEssentialsBase/Bridges/JoinMaps/PduJoinMapBase.cs

@@ -10,7 +10,7 @@ namespace PepperDash.Essentials.Core.Bridges
 
         [JoinName("Online")]
         public JoinDataComplete Online = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },
-            new JoinMetadata { Description = "Online", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
+            new JoinMetadata { Description = "PDU Name", JoinCapabilities = eJoinCapabilities.ToSIMPL, JoinType = eJoinType.Digital });
 
         [JoinName("OutletCount")]
         public JoinDataComplete OutletCount = new JoinDataComplete(new JoinData { JoinNumber = 1, JoinSpan = 1 },

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

@@ -0,0 +1,218 @@
+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,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -8,17 +9,70 @@ 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/JoinMaps/JoinMapBase.cs

@@ -356,18 +356,16 @@ namespace PepperDash.Essentials.Core
         {
             foreach (var customJoinData in joinData)
             {
-                JoinDataComplete join;
-
-                if (!Joins.TryGetValue(customJoinData.Key, out join))
-                {
-                    Debug.Console(2, "No matching key found in join map for: '{0}'", customJoinData.Key);
-                    continue;
-                }
+                var join = Joins[customJoinData.Key];
 
                 if (join != null)
                 {
                     join.SetCustomJoinData(customJoinData.Value);
                 }
+                else
+                {
+                    Debug.Console(2, "No matching key found in join map for: '{0}'", customJoinData.Key);
+                }
             }
 
             PrintJoinMapInfo();

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

@@ -200,6 +200,7 @@
     <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
+		Composite, Component, DmCat, DmMmFiber, DmSmFiber, Speaker, Streaming, UsbC, HdBaseT
 	}
 
 	/// <summary>

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

@@ -199,5 +199,45 @@ 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";
+    }
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/Mpc3Touchpanel.cs

@@ -1,295 +1,144 @@
-using System.Collections.Generic;
-using System.Globalization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
 using Crestron.SimplSharpPro;
-using Newtonsoft.Json;
+
 using PepperDash.Core;
+using PepperDash.Essentials.Core;
 
 namespace PepperDash.Essentials.Core.Touchpanels
 {
-	/// <summary>
-	/// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
-	/// behavior of the keybad buttons
-	/// </summary>
-	public class Mpc3TouchpanelController : Device
-	{
-		readonly MPC3Basic _touchpanel;
+    /// <summary>
+    /// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
+    /// behavior of the keybad buttons
+    /// </summary>
+    public class Mpc3TouchpanelController : Device
+    {
+        MPC3Basic _Touchpanel;
 
-		readonly Dictionary<string, KeypadButton> _buttons;
+        Dictionary<string, KeypadButton> _Buttons;
 
-		public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
-			: base(key, name)
-		{
-			_touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
-			if (_touchpanel == null)
-			{
-				Debug.Console(1, this, "Failed to construct MPC3 Touchpanel Controller with key {0}, check configuration", key);
-				return;
-			}
+        public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
+            : base(key, name)
+        {
+            _Touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
+            _Buttons = buttons;
 
-			_touchpanel.ButtonStateChange += _touchpanel_ButtonStateChange;
-			_buttons = buttons;
-			if (_buttons == null)
-			{
-				Debug.Console(1, this,
-					"Button properties are null, failed to setup MPC3 Touch Controller, check configuration");
-				return;
-			}
+            _Touchpanel.ButtonStateChange += new Crestron.SimplSharpPro.DeviceSupport.ButtonEventHandler(_Touchpanel_ButtonStateChange);
 
-			AddPostActivationAction(() =>
-			{
-				foreach (var button in _buttons)
-				{
-					var buttonKey = button.Key.ToLower();
-					var buttonConfig = button.Value;
+            AddPostActivationAction(() =>
+                {
+                    // Link up the button feedbacks to the specified BoolFeedbacks
+                    foreach (var button in _Buttons)
+                    {
+                        var feedbackConfig = button.Value.Feedback;
+                        var device = DeviceManager.GetDeviceForKey(feedbackConfig.DeviceKey) as Device;
+                        if (device != null)
+                        {
+                            var bKey = button.Key.ToLower();
 
-					InitializeButton(buttonKey, buttonConfig);
-					InitializeButtonFeedback(buttonKey, buttonConfig);
-				}
-			});
-		}
+                            var feedback = device.GetFeedbackProperty(feedbackConfig.FeedbackName);
 
-		/// <summary>
-		/// Enables/disables buttons based on event type configuration 
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="config"></param>
-		public void InitializeButton(string key, KeypadButton config)
-		{
-			if (config == null)
-			{
-				Debug.Console(1, this, "Button '{0}' config is null, unable to initialize", key);
-				return;
-			}
+                            var bFeedback = feedback as BoolFeedback;
+                            var iFeedback = feedback as IntFeedback;
+                            if (bFeedback != null)
+                            {
 
-			int buttonNumber;
-			TryParseInt(key, out buttonNumber);
+                                if (bKey == "power")
+                                {
+                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackPower);
+                                    continue;
+                                }
+                                else if (bKey == "mute")
+                                {
+                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackMute);
+                                    continue;
+                                }
 
-			var buttonEventTypes = config.EventTypes;
+                                // Link to the Crestron Feedback corresponding to the button number
+                                bFeedback.LinkCrestronFeedback(_Touchpanel.Feedbacks[UInt16.Parse(button.Key)]);
+                            }
+                            else if (iFeedback != null)
+                            {
+                                if (bKey == "volumefeedback")
+                                {
+                                    var volFeedback = feedback as IntFeedback;
+                                    // TODO: Figure out how to subsribe to a volume IntFeedback and link it to the voluem
+                                    volFeedback.LinkInputSig(_Touchpanel.VolumeBargraph);
+                                }
+                            }
+                            else
+                            {
+                                Debug.Console(1, this, "Unable to get BoolFeedback with name: {0} from device: {1}", feedbackConfig.FeedbackName, device.Key);
+                            }
+                        }
+                        else
+                        {
+                            Debug.Console(1, this, "Unable to get device with key: {0}", feedbackConfig.DeviceKey);
+                        }
+                    }
+                });
+        }
 
-			switch (key)
-			{
-				case ("power"):
-					{
-						if (buttonEventTypes == null)
-							_touchpanel.DisablePowerButton();
-						else
-							_touchpanel.EnablePowerButton();
+        void _Touchpanel_ButtonStateChange(GenericBase device, Crestron.SimplSharpPro.DeviceSupport.ButtonEventArgs args)
+        {
+            Debug.Console(1, this, "Button {0} ({1}), {2}", args.Button.Number, args.Button.Name, args.NewButtonState);
+            var type = args.NewButtonState.ToString();
 
-						break;
-					}
-				case ("volumeup"):
-					{
-						if (buttonEventTypes == null)
-							_touchpanel.DisableVolumeUpButton();
+            if (_Buttons.ContainsKey(args.Button.Number.ToString()))
+            {
+                Press(args.Button.Number.ToString(), type);
+            }
+            else if(_Buttons.ContainsKey(args.Button.Name.ToString()))
+            {
+                Press(args.Button.Name.ToString(), type);
+            }
+        }
 
-						break;
-					}
-				case ("volumedown"):
-					{
-						if (buttonEventTypes == null)
-							_touchpanel.DisableVolumeDownButton();
+        /// <summary>
+        /// Runs the function associated with this button/type. One of the following strings:
+        /// Pressed, Released, Tapped, DoubleTapped, Held, HeldReleased    
+        /// </summary>
+        /// <param name="number"></param>
+        /// <param name="type"></param>
+        public void Press(string number, string type)
+        {
+            // TODO: In future, consider modifying this to generate actions at device activation time
+            //       to prevent the need to dynamically call the method via reflection on each button press
+            if (!_Buttons.ContainsKey(number)) { return; }
+            var but = _Buttons[number];
+            if (but.EventTypes.ContainsKey(type))
+            {
+                foreach (var a in but.EventTypes[type]) { DeviceJsonApi.DoDeviceAction(a); }
+            }
+        }
 
-						break;
-					}
-				case ("volumefeedback"):
-					{
 
-						break;
-					}
-				case ("mute"):
-					{
-						if (buttonEventTypes == null)
-							_touchpanel.DisableMuteButton();
-						else
-							_touchpanel.EnableMuteButton();
+    }
 
-						break;
-					}
-				default:
-					{
-						if (buttonNumber == 0)
-							break;
+    /// <summary>
+    /// Represents the configuration of a keybad buggon
+    /// </summary>
+    public class KeypadButton
+    {
+        public Dictionary<string, DeviceActionWrapper[]> EventTypes { get; set; }
+        public KeypadButtonFeedback Feedback { get; set; }
 
-						if (buttonEventTypes == null)
-							_touchpanel.DisableNumericalButton((uint)buttonNumber);
-						else
-							_touchpanel.EnableNumericalButton((uint)buttonNumber);
+        public KeypadButton()
+        {
+            EventTypes = new Dictionary<string, DeviceActionWrapper[]>();
+            Feedback = new KeypadButtonFeedback();
+        }
+    }
 
-						break;
-					}
-			}
-
-			Debug.Console(1, this, "Button '{0}' {1}", key, buttonEventTypes == null
-				? "is disabled, verify eventTypes are configured."
-				: "is enabled");
-		}
-
-		/// <summary>
-		/// Links button feedback if configured
-		/// </summary>
-		/// <param name="key"></param>
-		/// <param name="config"></param>
-		public void InitializeButtonFeedback(string key, KeypadButton config)
-		{
-			if (config == null)
-			{
-				Debug.Console(1, this, "Button '{0}' config is null, unable to initialize feedback", key);
-				return;
-			}
-
-			int buttonNumber;
-			TryParseInt(key, out buttonNumber);
-
-			// Link up the button feedbacks to the specified device feedback
-			var buttonFeedback = config.Feedback;
-			if (buttonFeedback == null)
-			{
-				Debug.Console(1, this, "Button '{0}' feedback not configured and will not be implemented. Verify feedback is configured if required.", key);
-				return;
-			}
-
-			var device = DeviceManager.GetDeviceForKey(buttonFeedback.DeviceKey) as Device;
-			if (device == null)
-			{
-				Debug.Console(1, this, "Button '{0}' feedback device with key '{0}' not found, feedback will not be implemented.  Verify feedback deviceKey is properly configured.",
-					buttonFeedback.DeviceKey);
-				return;
-			}
-
-			// TODO [ ] verify if this can replace the current method
-			var deviceFeedback = device.GetFeedbackProperty(buttonFeedback.FeedbackName);
-			Debug.Console(0, this, "deviceFeedback.GetType().Name: '{0}'", deviceFeedback.GetType().Name);
-			//switch (feedback.GetType().Name.ToLower())
-			//{
-			//    case("boolfeedback"):
-			//    {
-			//        break;
-			//    }
-			//    case("intfeedback"):
-			//    {
-			//        break;
-			//    }
-			//    case("stringfeedback"):
-			//    {
-			//        break;
-			//    }
-			//}
-
-			var boolFeedback = deviceFeedback as BoolFeedback;
-			var intFeedback = deviceFeedback as IntFeedback;
-
-			switch (key)
-			{
-				case ("power"):
-					{
-						if (boolFeedback != null) boolFeedback.LinkCrestronFeedback(_touchpanel.FeedbackPower);
-						break;
-					}
-				case ("volumeup"):
-				case ("volumedown"):
-				case ("volumefeedback"):
-					{
-						if (intFeedback != null)
-						{
-							var volumeFeedback = intFeedback;
-							volumeFeedback.LinkInputSig(_touchpanel.VolumeBargraph);
-						}
-						break;
-					}
-				case ("mute"):
-					{
-						if (boolFeedback != null) boolFeedback.LinkCrestronFeedback(_touchpanel.FeedbackMute);
-						break;
-					}
-				default:
-					{
-						if (boolFeedback != null) boolFeedback.LinkCrestronFeedback(_touchpanel.Feedbacks[(uint)buttonNumber]);
-						break;
-					}
-			}
-		}
-
-		/// <summary>
-		/// Try parse int helper method
-		/// </summary>
-		/// <param name="str"></param>
-		/// <param name="result"></param>
-		/// <returns></returns>
-		public bool TryParseInt(string str, out int result)
-		{
-			try
-			{
-				result = int.Parse(str);
-				return true;
-			}
-			catch
-			{
-				result = 0;
-				return false;
-			}
-		}
-
-		private void _touchpanel_ButtonStateChange(GenericBase device, Crestron.SimplSharpPro.DeviceSupport.ButtonEventArgs args)
-		{
-			Debug.Console(1, this, "Button {0} ({1}), {2}", args.Button.Number, args.Button.Name, args.NewButtonState);
-			var type = args.NewButtonState.ToString();
-
-			if (_buttons.ContainsKey(args.Button.Number.ToString(CultureInfo.InvariantCulture)))
-			{
-				Press(args.Button.Number.ToString(CultureInfo.InvariantCulture), type);
-			}
-			else if (_buttons.ContainsKey(args.Button.Name.ToString()))
-			{
-				Press(args.Button.Name.ToString(), type);
-			}
-		}
-
-		/// <summary>
-		/// Runs the function associated with this button/type. One of the following strings:
-		/// Pressed, Released, Tapped, DoubleTapped, Held, HeldReleased    
-		/// </summary>
-		/// <param name="buttonKey"></param>
-		/// <param name="type"></param>
-		public void Press(string buttonKey, string type)
-		{
-			// TODO: In future, consider modifying this to generate actions at device activation time
-			//       to prevent the need to dynamically call the method via reflection on each button press
-			if (!_buttons.ContainsKey(buttonKey)) return;
-
-			var button = _buttons[buttonKey];
-			if (!button.EventTypes.ContainsKey(type)) return;
-
-			foreach (var eventType in button.EventTypes[type]) DeviceJsonApi.DoDeviceAction(eventType);
-		}
-	}
-
-	/// <summary>
-	/// Represents the configuration of a keypad button
-	/// </summary>
-	public class KeypadButton
-	{
-		[JsonProperty("eventTypes")]
-		public Dictionary<string, DeviceActionWrapper[]> EventTypes { get; set; }
-
-		[JsonProperty("feedback")]
-		public KeypadButtonFeedback Feedback { get; set; }
-
-		public KeypadButton()
-		{
-			EventTypes = new Dictionary<string, DeviceActionWrapper[]>();
-			Feedback = new KeypadButtonFeedback();
-		}
-	}
-
-	/// <summary>
-	/// Represents the configuration of a keypad button feedback
-	/// </summary>
-	public class KeypadButtonFeedback
-	{
-		[JsonProperty("deviceKey")]
-		public string DeviceKey { get; set; }
-
-		[JsonProperty("feedbackName")]
-		public string FeedbackName { get; set; }
-	}
+    /// <summary>
+    /// 
+    /// </summary>
+    public class KeypadButtonFeedback
+    {
+        public string DeviceKey { get; set; }
+        public string FeedbackName { get; set; }
+    }
 }

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmpsRoutingController.cs

@@ -991,41 +991,28 @@ namespace PepperDash.Essentials.DM
                     case (DMInputEventIds.OnlineFeedbackEventId):
                         {
                             Debug.Console(2, this, "DM Input OnlineFeedbackEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
-
-							if(!InputEndpointOnlineFeedbacks.ContainsKey(args.Number)){
-								break;
-							}
-							InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
+                            InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                     case (DMInputEventIds.EndpointOnlineEventId):
                         {
                             Debug.Console(2, this, "DM Input EndpointOnlineEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
-
-							if(!InputEndpointOnlineFeedbacks.ContainsKey(args.Number)){
-								break;
-							}
                             InputEndpointOnlineFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                     case (DMInputEventIds.VideoDetectedEventId):
                         {
                             Debug.Console(2, this, "DM Input {0} VideoDetectedEventId", args.Number);
-
-							if(!VideoInputSyncFeedbacks.ContainsKey(args.Number)){
-								break;
-							}
                             VideoInputSyncFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                     case (DMInputEventIds.InputNameEventId):
                         {
                             Debug.Console(2, this, "DM Input {0} NameFeedbackEventId", args.Number);
-                            if(!InputNameFeedbacks.ContainsKey(args.Number))
+                            if(InputNameFeedbacks.ContainsKey(args.Number))
                             {
-								break;
+                                InputNameFeedbacks[args.Number].FireUpdate();
                             }
-							InputNameFeedbacks[args.Number].FireUpdate();
                             break;
                         }
                 }

essentials-framework/Essentials Devices Common/Essentials Devices Common/Codec/iHasScheduleAwareness.cs

@@ -216,10 +216,6 @@ namespace PepperDash.Essentials.Devices.Common.Codec
                 return joinable;
             }
         }
-
-		[JsonProperty("dialable")]
-		public bool Dialable { get; set; }
-
         //public string ConferenceNumberToDial { get; set; }
         [JsonProperty("conferencePassword")]
         public string ConferencePassword { get; set; }

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/CiscoCodec/BookingsDataClasses.cs

@@ -348,8 +348,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
                     if (b.DialInfo.ConnectMode.Value.ToLower() == "obtp" || b.DialInfo.ConnectMode.Value.ToLower() == "manual")
                         meeting.IsOneButtonToPushMeeting = true;
 
-				meeting.Dialable = b.DialInfo.Calls.Call.Count > 0;
-
                 if (b.DialInfo.Calls.Call != null)
                 {
                     foreach (Call c in b.DialInfo.Calls.Call)

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/VideoCodecBase.cs

@@ -940,7 +940,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec
 
 		        //digitals
 		        tokenArray[digitalIndex] = new XSigDigitalToken(digitalIndex + 1, meeting.Joinable);
-		        tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, meeting.Dialable);
+		        tokenArray[digitalIndex + 1] = new XSigDigitalToken(digitalIndex + 2, meeting.Id != "0");
 
 		        //serials
 		        tokenArray[stringIndex] = new XSigSerialToken(stringIndex + 1, meeting.Organizer);

essentials-framework/Essentials Devices Common/Essentials Devices Common/VideoCodec/ZoomRoom/ResponseObjects.cs

@@ -1510,8 +1510,6 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.ZoomRoom
 
 				meeting.Privacy = b.IsPrivate ? eMeetingPrivacy.Private : eMeetingPrivacy.Public;
 
-				meeting.Dialable = meeting.Id != "0";
-
 				// No meeting.Calls data exists for Zoom Rooms.  Leaving out for now.
 				var now = DateTime.Now;
 				if (meeting.StartTime < now && meeting.EndTime < now)

packages.config

@@ -1,3 +1,3 @@
 <packages>
-	<package id="PepperDashCore" version="1.3.1" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
+	<package id="PepperDashCore" version="1.3.0" targetFramework="net35" allowedVersions="[1.0,2.0)"/>
 </packages>