#742 Adding EssentialsRoomCombiner device (in progress)

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

@@ -288,6 +288,7 @@
     <Compile Include="Remotes\CrestronRemotePropertiesConfig.cs" />
     <Compile Include="Remotes\Hrxx0WirelessRemoteController.cs" />
     <Compile Include="Room\Behaviours\RoomOnToDefaultSourceWhenOccupied.cs" />
+    <Compile Include="Room\Combining\EssentialsRoomCombiner.cs" />
     <Compile Include="Room\Combining\EssentialsRoomCombinerPropertiesConfig.cs" />
     <Compile Include="Room\Combining\IEssentialsRoomCombiner.cs" />
     <Compile Include="Room\Combining\RoomCombinationScenario.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/EssentialsRoomCombiner.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+namespace PepperDash.Essentials.Core
+{
+    public class EssentialsRoomCombiner : EssentialsDevice, IEssentialsRoomCombiner
+    {
+        private EssentialsRoomCombinerPropertiesConfig _propertiesConfig;
+
+        private IRoomCombinationScenario _currentScenario;
+
+        private List<IEssentialsRoom> _rooms;
+
+        private bool isInAutoMode;
+
+        public EssentialsRoomCombiner(string key, EssentialsRoomCombinerPropertiesConfig props)
+            : base(key)
+        {
+            _propertiesConfig = props;
+
+            IsInAutoModeFeedback = new BoolFeedback(() => isInAutoMode);
+
+            // default to auto mode
+            isInAutoMode = true;
+
+            if (_propertiesConfig.defaultToManualMode)
+            {
+                isInAutoMode = false;
+            }
+
+            IsInAutoModeFeedback.FireUpdate();
+
+            CreateScenarios();
+
+            SetupPartitionStateProviders();
+
+            SetRooms();
+        }
+
+        void CreateScenarios()
+        {
+            foreach (var scenarioConfig in _propertiesConfig.Scenarios)
+            {
+                var scenario = new RoomCombinationScenario(scenarioConfig);
+            }
+        }
+
+        void SetRooms()
+        {
+            foreach (var roomKey in _propertiesConfig.RoomKeys)
+            {
+                var room = DeviceManager.GetDeviceForKey(roomKey) as IEssentialsRoom;
+                if (room != null)
+                {
+                    _rooms.Add(room);
+                }
+            }
+        }
+
+        void SetupPartitionStateProviders()
+        {
+
+        }
+
+        #region IEssentialsRoomCombiner Members
+
+        public event EventHandler<EventArgs> RoomCombinationScenarioChanged;
+
+        public IRoomCombinationScenario CurrentScenario
+        {
+            get
+            {
+                return _currentScenario;
+            }
+            set
+            {
+                if (value != _currentScenario)
+                {
+                    _currentScenario = value;
+                    var handler = RoomCombinationScenarioChanged;
+                    if (handler != null)
+                    {
+                        handler(this, new EventArgs());
+                    }
+                }
+            }
+        }
+
+        public BoolFeedback IsInAutoModeFeedback { get; private set; }
+
+        public void SetAutoMode()
+        {
+            isInAutoMode = true;
+            IsInAutoModeFeedback.FireUpdate();
+        }
+
+        public void SetManualMode()
+        {
+            isInAutoMode = false;
+            IsInAutoModeFeedback.FireUpdate();
+        }
+
+        public void ToggleMode()
+        {
+            isInAutoMode = !isInAutoMode;
+            IsInAutoModeFeedback.FireUpdate();
+        }
+
+        public List<IRoomCombinationScenario> RoomCombinationScenarios { get; private set; }
+
+        public List<IPartitionStateProvider> PartitionStateProviders { get; private set; }
+
+        public void TogglePartitionState(string partitionKey)
+        {
+            var partition = PartitionStateProviders.FirstOrDefault((p) => p.Key.Equals(partitionKey)) as IManualPartitionSensor;
+
+            if (partition != null)
+            {
+                partition.ToggglePartitionState();
+            }
+        }
+
+        public void SetRoomCombinationScenario(string scenarioKey)
+        {
+
+        }
+
+        #endregion
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/EssentialsRoomCombinerPropertiesConfig.cs

@@ -28,10 +28,22 @@ namespace PepperDash.Essentials.Core
         public List<RoomCombinationScenarioConfig> Scenarios { get; set; }
 
         /// <summary>
-        /// The list of rooms that can be combined
+        /// The list of rooms keys that can be combined
         /// </summary>
         [JsonProperty("roomMap")]
-        public Dictionary<string, string> RoomMap {get; set;}
+        public List<string> RoomKeys {get; set;}
+
+        /// <summary>
+        /// Set to true to default to manual mode
+        /// </summary>
+        [JsonProperty("defaultToManualMode")]
+        public bool defaultToManualMode { get; set; }
+
+        /// <summary>
+        /// The key of the scenario to default to at system startup if in manual mode
+        /// </summary>
+        [JsonProperty("defaultScenarioKey")]
+        public string defaultScenarioKey { get; set; }
     }
 
     /// <summary>
@@ -54,8 +66,8 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Keys of the rooms that this partion would be located between
         /// </summary>
-        [JsonProperty("roomKeys")]
+        [JsonProperty("adjacentRoomKeys")]
-        public List<string> RoomKeys { get; set; }
+        public List<string> AdjacentRoomKeys { get; set; }
     }
 
     /// <summary>
@@ -72,11 +84,14 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("partitionStates")]
         public List<PartitionState> PartitionStates { get; set; }
 
-        [JsonProperty("enabledRoomKeys")]
+        [JsonProperty("roomMap")]
-        public List<string> EnabledRoomKeys { get; set; }
+        public Dictionary<string, string> RoomMap { get; set; }
 
-        [JsonProperty("actions")]
+        [JsonProperty("activationActions")]
-        public List<DeviceActionWrapper> Actions { get; set; }    
+        public List<DeviceActionWrapper> ActivationActions { get; set; }
+
+        [JsonProperty("deactivationActions")]
+        public List<DeviceActionWrapper> DeactivationActions { get; set; }    
     }
 
     /// <summary>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/IEssentialsRoomCombiner.cs

@@ -13,28 +13,69 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public interface IEssentialsRoomCombiner
     {
-        // TODO: Update the EventArgs class as needed to specify scenario change
+        /// <summary>
+        /// Indicates that the room combination scenario has changed
+        /// </summary>
         event EventHandler<EventArgs> RoomCombinationScenarioChanged;
 
+        /// <summary>
+        /// The current room combination scenario
+        /// </summary>
+        IRoomCombinationScenario CurrentScenario { get; }
+
+        /// <summary>
+        /// When true, indicates the current mode is auto mode
+        /// </summary>
         BoolFeedback IsInAutoModeFeedback {get;}
 
+        /// <summary>
+        /// Sets auto mode
+        /// </summary>
         void SetAutoMode();
 
+        /// <summary>
+        /// Sets manual mode
+        /// </summary>
         void SetManualMode();
 
+        /// <summary>
+        /// Toggles the current mode between auto and manual
+        /// </summary>
         void ToggleMode();
 
-        List<IRoomCombinationScenario> Scenarios { get; }
+        /// <summary>
+        /// The available room combinatino scenarios
+        /// </summary>
+        List<IRoomCombinationScenario> RoomCombinationScenarios { get; }
 
-        List<IPartitionStateProvider> Partitions { get; }
+        /// <summary>
+        /// The partition
+        /// </summary>
+        List<IPartitionStateProvider> PartitionStateProviders { get; }
 
+        /// <summary>
+        /// Toggles the state of a manual partition sensor
+        /// </summary>
+        /// <param name="partitionKey"></param>
         void TogglePartitionState(string partitionKey);
+
+        /// <summary>
+        /// Sets the room combination scenario (if in manual mode)
+        /// </summary>
+        /// <param name="scenarioKey"></param>
+        void SetRoomCombinationScenario(string scenarioKey);
     }
 
     public interface IRoomCombinationScenario : IKeyName
     {
-        BoolFeedback IsActive { get; }
+        /// <summary>
+        /// When true, indicates that this room combination scenario is active
+        /// </summary>
+        BoolFeedback IsActiveFeedback { get; }
 
+        /// <summary>
+        /// Activates this room combination scenario
+        /// </summary>
         void Activate();
     }
 

essentials-framework/Essentials Core/PepperDashEssentialsBase/Room/Combining/RoomCombinationScenario.cs

@@ -13,17 +13,69 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class RoomCombinationScenario: IRoomCombinationScenario
     {
-        [JsonProperty("key")]
+        private RoomCombinationScenarioConfig _config;
+
         public string Key { get; set; }
 
-        [JsonProperty("name")]
         public string Name { get; set; }
 
-        public BoolFeedback IsActive { get; private set; }
+        public List<PartitionState> PartitionStates { get; private set; }
+
+        public Dictionary<string, string> EnabledRoomMap { get; set; }
+
+        private bool _isActive;
+
+        public BoolFeedback IsActiveFeedback { get; private set; }
+
+        List<DeviceActionWrapper> activationActions;
+
+        List<DeviceActionWrapper> deactivationActions;
+
+        public RoomCombinationScenario(RoomCombinationScenarioConfig config)
+        {
+            Key = config.Key;
+
+            Name = config.Name;
+
+            PartitionStates = config.PartitionStates;
+
+            EnabledRoomMap = config.RoomMap;
+
+            activationActions = config.ActivationActions;
+
+            deactivationActions = config.DeactivationActions;
+
+            _config = config;
+
+            IsActiveFeedback = new BoolFeedback(() => _isActive);
+        }
 
         public void Activate()
         {
+            if (activationActions != null)
+            {
+                foreach (var action in activationActions)
+                {
+                    DeviceJsonApi.DoDeviceAction(action);
+                }
+            }
 
+            _isActive = true;
+            IsActiveFeedback.FireUpdate();
+        }
+
+        public void Deactivate()
+        {
+            if (deactivationActions != null)
+            {
+                foreach (var action in deactivationActions)
+                {
+                    DeviceJsonApi.DoDeviceAction(action);
+                }
+            }
+
+            _isActive = false;
+            IsActiveFeedback.FireUpdate();
         }
 
     }