openhab-scripting 4.30.3 → 4.30.4

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,90 @@ 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|
+            logger.states 'Creating received command trigger', item: item, command: command, commands: commands,
+                                                               combined_commands: combined_commands
+
+            command_trigger.trigger(item: item, commands: combined_commands, attach: attach)
           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 trigger based on item type
+          #
+          # @param [Array] commands to create trigger for
+          # @param [Object] item to create trigger for
+          #
+          #
+          def trigger(item:, commands:, attach:)
+            commands.map do |command|
+              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(type: type, config: config, attach: attach)
             end
-            config['command'] = command.to_s unless command.nil?
-            append_trigger(trigger, config, attach: attach)
           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
+          # @return [String] A group command trigger for items in the group
+          GROUP_COMMAND = 'core.GroupCommandTrigger'
 
-          # 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
+          #
+          # 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/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

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'java'
+require_relative 'cron'
+
+module OpenHAB
+  module DSL
+    module Rules
+      #
+      # Cron type rules
+      #
+      module Triggers
+        #
+        # Cron trigger handler that provides trigger ID
+        #
+        module CronHandler
+          include OpenHAB::Log
+
+          #
+          # Creates trigger types and trigger type factories for OpenHAB
+          #
+          def self.add_script_cron_handler
+            java_import org.openhab.core.automation.type.TriggerType
+            OpenHAB::Core.automation_manager.add_trigger_handler(
+              OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID,
+              OpenHAB::DSL::Rules::Triggers::CronHandler::CronTriggerHandlerFactory.new
+            )
+
+            OpenHAB::Core.automation_manager.add_trigger_type(cron_trigger_type)
+            OpenHAB::Log.logger(self).trace('Added script cron trigger handler')
+          end
+
+          #
+          # Creates trigger types and trigger type factories for OpenHAB
+          #
+          private_class_method def self.cron_trigger_type
+            TriggerType.new(
+              OpenHAB::DSL::Rules::Triggers::Cron::CRON_TRIGGER_MODULE_ID,
+              nil,
+              'A specific instant occurs',
+              'Triggers when the specified instant occurs',
+              nil,
+              org.openhab.core.automation.Visibility::VISIBLE,
+              nil
+            )
+          end
+
+          # Cron Trigger Handler that provides trigger IDs
+          # Unfortunatly because the CronTriggerHandler in OpenHAB core is marked internal
+          # the entire thing must be recreated here
+          class CronTriggerHandler < org.openhab.core.automation.handler.BaseTriggerModuleHandler
+            include OpenHAB::Log
+            include org.openhab.core.scheduler.SchedulerRunnable
+            include org.openhab.core.automation.handler.TimeBasedTriggerHandler
+
+            # Provides access to protected fields
+            field_accessor :callback
+
+            # Creates a new CronTriggerHandler
+            # @param [Trigger] OpenHAB trigger associated with handler
+            #
+            def initialize(trigger)
+              @trigger = trigger
+              @scheduler = OpenHAB::Core::OSGI.service('org.openhab.core.scheduler.CronScheduler')
+              @expression = trigger.configuration.get('cronExpression')
+              super(trigger)
+            end
+
+            #
+            # Set the callback to execute when cron trigger fires
+            # @param [Object] callback to run
+            #
+            def setCallback(callback) # rubocop:disable Naming/MethodName
+              synchronized do
+                super(callback)
+                @scheduler.schedule(self, @expression)
+                logger.trace("Scheduled cron job '#{@expression}' for trigger '#{@trigger.id}'.")
+              end
+            end
+
+            #
+            # Get the temporal adjuster
+            # @return [CronAdjuster]
+            #
+            def getTemporalAdjuster # rubocop:disable Naming/MethodName
+              org.openhab.core.scheduler.CronAdjuster.new(expression)
+            end
+
+            #
+            # Execute the callback
+            #
+            def run
+              callback&.triggered(@trigger, { 'module' => @trigger.id })
+            end
+
+            #
+            # Displose of the handler
+            # cancel the cron scheduled task
+            #
+            def dispose
+              synchronized do
+                super
+                return unless @schedule
+
+                @schedule&.cancel(true)
+              end
+              logger.trace("cancelled job for trigger '#{@trigger.id}'.")
+            end
+          end
+
+          # Implements the ScriptedTriggerHandlerFactory interface to create a new Cron Trigger Handler
+          class CronTriggerHandlerFactory
+            include org.openhab.core.automation.module.script.rulesupport.shared.factories.ScriptedTriggerHandlerFactory
+
+            # Invoked by the OpenHAB core to get a trigger handler for the supllied trigger
+            # @param [Trigger] OpenHAB trigger
+            #
+            # @return [WatchTriggerHandler] trigger handler for supplied trigger
+            def get(trigger)
+              CronTriggerHandler.new(trigger)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Add the cron handler to OpenHAB
+OpenHAB::DSL::Rules::Triggers::CronHandler.add_script_cron_handler

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'openhab/log/logger'
+require_relative 'trigger'
 
 module OpenHAB
   module DSL
@@ -21,7 +22,7 @@ module OpenHAB
         #
         def trigger(type, attach: nil, **configuration)
           logger.trace("Creating a generic trigger for type(#{type}) with configuration(#{configuration})")
-          append_trigger(type, configuration, attach: attach)
+          Trigger.new(rule_triggers: @rule_triggers).append_trigger(type: type, config: configuration, attach: attach)
         end
       end
     end