openhab-scripting 4.30.3 → 4.32.0

data/lib/openhab/dsl/rules/triggers/channel.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require 'openhab/log/logger'
-require 'openhab/dsl/rules/triggers/trigger'
+require 'openhab/dsl/things'
+require_relative 'trigger'
 
 module OpenHAB
   module DSL
@@ -22,32 +23,59 @@ module OpenHAB
         #   thing(s) to create trigger for if not specified with the channel
         # @param [String, Array<String>] triggered specific triggering condition(s) to match for trigger
         #
-        def channel(*channels, thing: nil, triggered: nil, attach: nil) # rubocop:disable Metrics/AbcSize
-          channels.flatten.product([thing].flatten).each do |(channel, t)|
-            channel = channel.uid if channel.is_a?(org.openhab.core.thing.Channel)
-            t = t.uid if t.is_a?(Thing)
-            channel = [t, channel].compact.join(':')
-            logger.trace("Creating channel trigger for channel(#{channel}), thing(#{t}), trigger(#{triggered})")
+        def channel(*channels, thing: nil, triggered: nil, attach: nil)
+          channel_trigger = Channel.new(rule_triggers: @rule_triggers)
+          Channel.channels(channels: channels, thing: thing).each do |channel|
             [triggered].flatten.each do |trigger|
-              create_channel_trigger(channel, trigger, attach)
+              channel_trigger.trigger(channel: channel, trigger: trigger, attach: attach)
             end
           end
         end
 
-        private
-
-        #
-        # Create a trigger for a channel
         #
-        # @param [String] channel to look for triggers
-        # @param [String] trigger specific channel trigger to match
+        # Creates channel triggers
         #
-        #
-        def create_channel_trigger(channel, trigger, attach)
-          config = { 'channelUID' => channel }
-          config['event'] = trigger.to_s unless trigger.nil?
-          logger.trace("Creating Change Trigger for #{config}")
-          append_trigger(Trigger::CHANNEL_EVENT, config, attach: attach)
+        class Channel < Trigger
+          include OpenHAB::Log
+
+          # @return [String] A channel event trigger
+          CHANNEL_EVENT = 'core.ChannelEventTrigger'
+
+          #
+          # Get an enumerator over the product of the channels and things and map them to a channel id
+          # @param [Object] channels to iterate over
+          # @param [Object] thing to combine with channels and iterate over
+          # @return [Enumerable] enumerable channel ids to trigger on
+          def self.channels(channels:, thing:)
+            logger.state 'Creating Channel/Thing Pairs', channels: channels, thing: thing
+            channels.flatten.product([thing].flatten)
+                    .map { |channel_thing| channel_id(*channel_thing) }
+          end
+
+          #
+          # Get a channel id from a channel and thing
+          # @param [Object] channel part of channel id, get UID if object is a Channel
+          # @param [Object] thing part of channel id, get UID if object is a Thing
+          #
+          def self.channel_id(channel, thing)
+            channel = channel.uid if channel.is_a?(org.openhab.core.thing.Channel)
+            thing = thing.uid if thing.is_a?(Thing)
+            [thing, channel].compact.join(':')
+          end
+
+          #
+          # Create a trigger for a channel
+          #
+          # @param [String] channel to look for triggers
+          # @param [String] trigger specific channel trigger to match
+          #
+          #
+          def trigger(channel:, trigger:, attach:)
+            config = { 'channelUID' => channel }
+            config['event'] = trigger.to_s unless trigger.nil?
+            logger.state 'Creating Channel Trigger', channel: channel, config: config
+            append_trigger(type: CHANNEL_EVENT, config: config, attach: attach)
+          end
         end
       end
     end

data/lib/openhab/dsl/rules/triggers/command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'openhab/log/logger'
+require_relative 'trigger'
 
 module OpenHAB
   module DSL
@@ -22,81 +23,130 @@ module OpenHAB
         #
         #
         def received_command(*items, command: nil, commands: nil, attach: nil)
-          separate_groups(items).map do |item|
-            logger.trace("Creating received command trigger for item(#{item})"\
-                         "command(#{command}) commands(#{commands})")
+          command_trigger = Command.new(rule_triggers: @rule_triggers)
 
-            # Combine command and commands, doing union so only a single nil will be in the combined array.
-            combined_commands = combine_commands(command, commands)
-            create_received_trigger(combined_commands, item, attach)
+          # Combine command and commands, doing union so only a single nil will be in the combined array.
+          combined_commands = Command.combine_commands(command: command, commands: commands)
+
+          Command.flatten_items(items).map do |item|
+            combined_commands.map do |cmd|
+              logger.states 'Creating received command trigger', item: item, command: cmd
+
+              command_trigger.trigger(item: item, command: cmd, attach: attach)
+            end
           end.flatten
         end
 
-        private
-
-        #
-        # Create a received trigger based on item type
         #
-        # @param [Array] commands to create trigger for
-        # @param [Object] item to create trigger for
-        #
-        #
-        def create_received_trigger(commands, item, attach)
-          commands.map do |command|
-            if item.is_a? OpenHAB::DSL::Items::GroupItem::GroupMembers
-              config, trigger = create_group_command_trigger(item)
-            else
-              config, trigger = create_item_command_trigger(item)
+        # Creates command triggers
+        #
+        class Command < Trigger
+          # Combine command and commands into a single array
+          #
+          # @param [Array] command list of commands to trigger on
+          # @param [Array] commands list of commands to trigger on
+          #
+          # @return [Array] Combined flattened and compacted list of commands
+          #
+          def self.combine_commands(command:, commands:)
+            combined_commands = ([command] | [commands]).flatten
+
+            # If either command or commands has a value and one is nil, we need to remove nil from the array.
+            # If it is only now a single nil value, we leave the nil in place, so that we create a trigger
+            # That isn't looking for a specific command.
+            combined_commands = combined_commands.compact unless combined_commands.all?(&:nil?)
+            combined_commands
+          end
+
+          #
+          # Create a received command trigger
+          #
+          # @param [Object] item item to create trigger for
+          # @param [Object] command to check against
+          # @param [Object] attach attachment
+          #
+          # @return [Trigger] OpenHAB triggers
+          #
+          def trigger(item:, command:, attach:)
+            case command
+            when Range then range_trigger(item: item, command: command, attach: attach)
+            when Proc then proc_trigger(item: item, command: command, attach: attach)
+            else command_trigger(item: item, command: command, attach: attach)
             end
+          end
+
+          #
+          # Creates a trigger with a range condition on the 'command' field
+          # @param [Object] item to create changed trigger on
+          # @param [Object] command to restrict trigger to
+          # @param [Object] attach to trigger
+          # @return [Trigger] OpenHAB trigger
+          #
+          def range_trigger(item:, command:, attach:)
+            command_range, * = Conditions::Proc.range_procs(command)
+            proc_trigger(item: item, command: command_range, attach: attach)
+          end
+
+          #
+          # Creates a trigger with a proc condition on the 'command' field
+          # @param [Object] item to create changed trigger on
+          # @param [Object] command to restrict trigger to
+          # @param [Object] attach to trigger
+          # @return [Trigger] OpenHAB trigger
+          #
+          def proc_trigger(item:, command:, attach:)
+            conditions = Conditions::Proc.new(command: command)
+            command_trigger(item: item, command: nil, attach: attach, conditions: conditions)
+          end
+
+          #
+          # Create a received trigger based on item type
+          #
+          # @param [Array] commands to create trigger for
+          # @param [Object] item to create trigger for
+          #
+          #
+          def command_trigger(item:, command:, attach: nil, conditions: nil)
+            type, config = if item.is_a? OpenHAB::DSL::Items::GroupItem::GroupMembers
+                             group(group: item)
+                           else
+                             item(item: item)
+                           end
             config['command'] = command.to_s unless command.nil?
-            append_trigger(trigger, config, attach: attach)
+            append_trigger(type: type, config: config, attach: attach, conditions: conditions)
           end
-        end
 
-        #
-        # Create trigger for item commands
-        #
-        # @param [Item] item to create trigger for
-        #
-        # @return [Array<Hash,Trigger>] first element is hash of trigger config properties
-        #   second element is trigger type
-        #
-        def create_item_command_trigger(item)
-          config = { 'itemName' => item.name }
-          trigger = Trigger::ITEM_COMMAND
-          [config, trigger]
-        end
+          private
 
-        #
-        # Create trigger for group items
-        #
-        # @param [Group] group to create trigger for
-        #
-        # @return [Array<Hash,Trigger>] first element is hash of trigger config properties
-        #   second element is trigger type
-        #
-        def create_group_command_trigger(group)
-          config = { 'groupName' => group.group.name }
-          trigger = Trigger::GROUP_COMMAND
-          [config, trigger]
-        end
+          # @return [String] item command trigger
+          ITEM_COMMAND = 'core.ItemCommandTrigger'
 
-        #
-        # Combine command and commands into a single array
-        #
-        # @param [Array] command list of commands to trigger on
-        # @param [Array] commands list of commands to trigger on
-        #
-        # @return [Array] Combined flattened and compacted list of commands
-        #
-        def combine_commands(command, commands)
-          combined_commands = ([command] | [commands]).flatten
-
-          # If either command or commands has a value and one is nil, we need to remove nil from the array.
-          # If it is only now a single nil value, we leave the nil in place, so that we create a trigger
-          # That isn't looking for a specific command.
-          combined_commands = combined_commands.compact unless combined_commands.all?(&:nil?)
-          combined_commands
+          # @return [String] A group command trigger for items in the group
+          GROUP_COMMAND = 'core.GroupCommandTrigger'
+
+          #
+          # Create trigger for item commands
+          #
+          # @param [Item] item to create trigger for
+          #
+          # @return [Array<Hash,Trigger>] first element is hash of trigger config properties
+          #   second element is trigger type
+          #
+          def item(item:)
+            [ITEM_COMMAND, { 'itemName' => item.name }]
+          end
+
+          #
+          # Create trigger for group items
+          #
+          # @param [Group] group to create trigger for
+          #
+          # @return [Array<Hash,Trigger>] first element is hash of trigger config properties
+          #   second element is trigger type
+          #
+          def group(group:)
+            [GROUP_COMMAND, { 'groupName' => group.group.name }]
+          end
         end
       end
     end

data/lib/openhab/dsl/rules/triggers/conditions/proc.rb

@@ -38,9 +38,9 @@ module OpenHAB
             #
             def self.range_proc(range)
               logger.trace("Creating range proc for #{range}")
-              lambda do |state|
-                logger.trace("Range proc checking if #{state} is in  #{range}")
-                range.include? state
+              lambda do |val|
+                logger.trace("Range proc checking if #{val} is in #{range}")
+                range.cover? val
               end
             end
 
@@ -77,9 +77,10 @@ module OpenHAB
             # @param [Proc] from Proc to check against from value
             # @param [Proc] to Proc to check against to value
             #
-            def initialize(from: nil, to: nil)
+            def initialize(from: nil, to: nil, command: nil)
               @from = from
               @to = to
+              @command = command
             end
 
             #
@@ -88,7 +89,18 @@ module OpenHAB
             #
             def process(mod:, inputs:) # rubocop:disable Lint/UnusedMethodArgument - mod is unused here but required
               logger.trace("Checking #{inputs} against condition trigger #{self}")
-              yield if check_from(inputs: inputs) && check_to(inputs: inputs)
+              yield if check_procs(inputs: inputs)
+            end
+
+            #
+            # Check if command condition match the proc
+            # @param [Hash] inputs from trigger must be supplied if state is not supplied
+            # @return [true/false] depending on if from is set and matches supplied conditions
+            #
+            def check_command(inputs: nil)
+              command = input_state(inputs, 'command')
+              logger.trace "Checking command(#{@command}) against command(#{command})"
+              check_proc(proc: @command, value: command)
             end
 
             #
@@ -100,7 +112,7 @@ module OpenHAB
             def check_from(inputs: nil, state: nil)
               state ||= input_state(inputs, 'oldState')
               logger.trace "Checking from(#{@from}) against state(#{state})"
-              check_proc(proc: @from, state: state)
+              check_proc(proc: @from, value: state)
             end
 
             #
@@ -112,27 +124,34 @@ module OpenHAB
             def check_to(inputs: nil, state: nil)
               state ||= input_state(inputs, 'newState', 'state')
               logger.trace "Checking to(#{@to}) against state(#{state})"
-              check_proc(proc: @to, state: state)
+              check_proc(proc: @to, value: state)
             end
 
             # Describe the Proc Condition as a string
             # @return [String] string representation of proc condition
             #
             def to_s
-              "From:(#{@from}) To:(#{@to})"
+              "From:(#{@from}) To:(#{@to}) Command:(#{@command})"
             end
 
             private
 
+            #
+            # Check all procs
+            # @param [Hash] inputs from event
+            # @return [true/false] true if all procs return true, false otherwise
+            def check_procs(inputs:)
+              check_from(inputs: inputs) && check_to(inputs: inputs) && check_command(inputs: inputs)
+            end
+
             # Check if a field matches the proc condition
             # @param [Proc] proc to call
-            # @param [Hash] inputs containing fields
-            # @param [Array] fields array of fields to extract from inputs, first one found is passed to proc
+            # @param [Hash] value to check
             # @return [true,false] true if proc is nil or proc.call returns true, false otherwise
-            def check_proc(proc:, state:)
-              return true if proc.nil? || proc.call(state)
+            def check_proc(proc:, value:)
+              return true if proc.nil? || proc.call(value)
 
-              logger.trace("Skipped execution of rule because state #{state} evalulated false for (#{proc})")
+              logger.trace("Skipped execution of rule because value #{value} evaluated false for (#{proc})")
               false
             end
 

data/lib/openhab/dsl/rules/triggers/cron/cron.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'java'
+require 'openhab/dsl/rules/triggers/trigger'
+
+module OpenHAB
+  module DSL
+    module Rules
+      #
+      # Cron type rules
+      #
+      module Triggers
+        #
+        # Create a rule that executes at the specified interval
+        #
+        # @param [Object] value Symbol or Duration to execute this rule
+        # @param [Object] at TimeOfDay or String representing TimeOfDay in which to execute rule
+        #
+        #
+        def every(value, at: nil, attach: nil)
+          cron_expression = case value
+                            when Symbol then Cron.from_symbol(value, at)
+                            when Java::JavaTime::Duration then Cron.from_duration(value, at)
+                            else raise ArgumentExpression, 'Unknown interval'
+                            end
+          cron(cron_expression, attach: attach)
+        end
+
+        #
+        # Create a OpenHAB Cron trigger
+        #
+        # @param [String] expression OpenHAB style cron expression
+        #
+        def cron(expression, attach: nil)
+          cron = Cron.new(rule_triggers: @rule_triggers)
+          cron.trigger(config: { 'cronExpression' => expression }, attach: attach)
+        end
+
+        #
+        # Creates cron triggers
+        #
+        class Cron < Trigger
+          # Trigger ID for Watch Triggers
+          CRON_TRIGGER_MODULE_ID = 'jsr223.jruby.CronTrigger'
+
+          #
+          # Returns a default map for cron expressions that fires every second
+          # This map is usually updated via merge by other methods to refine cron type triggers.
+          #
+          # @return [Hash] Map with symbols for :seconds, :minute, :hour, :dom, :month, :dow
+          #   configured to fire every second
+          #
+          CRON_EXPRESSION_MAP =
+            {
+              second: '*',
+              minute: '*',
+              hour: '*',
+              dom: '?',
+              month: '*',
+              dow: '?'
+            }.freeze
+          private_constant :CRON_EXPRESSION_MAP
+
+          # @return [Hash] Map of days of the week from symbols to to OpenHAB cron strings
+          DAY_OF_WEEK_MAP = {
+            monday: 'MON',
+            tuesday: 'TUE',
+            wednesday: 'WED',
+            thursday: 'THU',
+            friday: 'FRI',
+            saturday: 'SAT',
+            sunday: 'SUN'
+          }.freeze
+          private_constant :DAY_OF_WEEK_MAP
+
+          # @return [Hash] Converts the DAY_OF_WEEK_MAP to map used by Cron Expression
+          DAY_OF_WEEK_EXPRESSION_MAP = DAY_OF_WEEK_MAP.transform_values { |v| CRON_EXPRESSION_MAP.merge(dow: v) }
+
+          private_constant :DAY_OF_WEEK_EXPRESSION_MAP
+
+          # @return [Hash] Create a set of cron expressions based on different time intervals
+          EXPRESSION_MAP = {
+            second: CRON_EXPRESSION_MAP,
+            minute: CRON_EXPRESSION_MAP.merge(second: '0'),
+            hour: CRON_EXPRESSION_MAP.merge(second: '0', minute: '0'),
+            day: CRON_EXPRESSION_MAP.merge(second: '0', minute: '0', hour: '0'),
+            week: CRON_EXPRESSION_MAP.merge(second: '0', minute: '0', hour: '0', dow: 'MON'),
+            month: CRON_EXPRESSION_MAP.merge(second: '0', minute: '0', hour: '0', dom: '1'),
+            year: CRON_EXPRESSION_MAP.merge(second: '0', minute: '0', hour: '0', dom: '1', month: '1')
+          }.merge(DAY_OF_WEEK_EXPRESSION_MAP).freeze
+
+          private_constant :EXPRESSION_MAP
+
+          #
+          # Create a cron map from a duration
+          #
+          # @param [java::time::Duration] duration
+          # @param [Object] at TimeOfDay or String representing time of day
+          #
+          # @return [Hash] map describing cron expression
+          #
+          def self.from_duration(duration, at)
+            raise ArgumentError, '"at" cannot be used with duration' if at
+
+            map_to_cron(duration_to_map(duration))
+          end
+
+          #
+          # Create a cron map from a symbol
+          #
+          # @param [Symbol] symbol
+          # @param [Object] at TimeOfDay or String representing time of day
+          #
+          # @return [Hash] map describing cron expression created from symbol
+          #
+          def self.from_symbol(symbol, at)
+            expression_map = EXPRESSION_MAP[symbol]
+            expression_map = at_condition(expression_map, at) if at
+            map_to_cron(expression_map)
+          end
+
+          #
+          # Map cron expression to to cron string
+          #
+          # @param [Map] map of cron expression
+          #
+          # @return [String] OpenHAB cron string
+          #
+          def self.map_to_cron(map)
+            %i[second minute hour dom month dow].map { |field| map.fetch(field) }.join(' ')
+          end
+
+          #
+          # Convert a Java Duration to a map for the map_to_cron method
+          #
+          # @param duration [Java::JavaTime::Duration] The duration object
+          #
+          # @return [Hash] a map suitable for map_to_cron
+          #
+          def self.duration_to_map(duration)
+            if duration.to_millis_part.zero? && duration.to_nanos_part.zero? && duration.to_days.zero?
+              %i[second minute hour].each do |unit|
+                to_unit_part = duration.public_send("to_#{unit}s_part")
+                next unless to_unit_part.positive?
+
+                to_unit = duration.public_send("to_#{unit}s")
+                break unless to_unit_part == to_unit
+
+                return EXPRESSION_MAP[unit].merge(unit => "*/#{to_unit}")
+              end
+            end
+            raise ArgumentError, "Cron Expression not supported for duration: #{duration}"
+          end
+
+          #
+          # If an at time is provided, parse that and merge the new fields into the expression.
+          #
+          # @param [<Type>] expression_map <description>
+          # @param [<Type>] at_time <description>
+          #
+          # @return [<Type>] <description>
+          #
+          def self.at_condition(expression_map, at_time)
+            if at_time
+              tod = at_time.is_a?(TimeOfDay::TimeOfDay) ? at_time : TimeOfDay::TimeOfDay.parse(at_time)
+              expression_map = expression_map.merge(hour: tod.hour, minute: tod.minute, second: tod.second)
+            end
+            expression_map
+          end
+
+          #
+          # Create a cron trigger based on item type
+          #
+          # @param [Array] commands to create trigger for
+          # @param [Object] item to create trigger for
+          #
+          #
+          def trigger(config:, attach:)
+            append_trigger(type: CRON_TRIGGER_MODULE_ID, config: config, attach: attach)
+          end
+        end
+      end
+    end
+  end
+end