openhab-scripting 2.16.2 → 2.19.0

data/lib/openhab/core/dsl/rule/triggers/command.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/log'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Module holds rule triggers
-        #
-        module Triggers
-          include Logging
-
-          #
-          # Create a trigger for when an item or group receives a command
-          #
-          # The commands/commands parameters are replicated for DSL fluency
-          #
-          # @param [Array] items Array of items to create trigger for
-          # @param [Array] command commands to match for trigger
-          # @param [Array] commands commands to match for trigger
-          #
-          #
-          def received_command(*items, command: nil, commands: nil)
-            items.flatten.each do |item|
-              logger.trace("Creating received command trigger for item(#{item})"\
-                           "command(#{command}) commands(#{commands})")
-
-              # 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)
-            end
-          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)
-            commands.each do |command|
-              if item.is_a? GroupItems
-                config, trigger = create_group_command_trigger(item)
-              else
-                config, trigger = create_item_command_trigger(item)
-              end
-              config['command'] = command.to_s unless command.nil?
-              append_trigger(trigger, config)
-            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
-
-          #
-          # 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
-
-          #
-          # 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
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/rule/triggers/cron.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require 'java'
-require 'core/dsl/time_of_day'
-require 'core/cron'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Cron type rules
-        #
-        module Triggers
-          java_import org.openhab.core.automation.util.TriggerBuilder
-          java_import org.openhab.core.config.core.Configuration
-
-          include OpenHAB::Core::DSL::Rule
-          extend OpenHAB::Core::Cron
-
-          # @return [Map] 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 [MAP] 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 [Map] 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 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)
-            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)
-          end
-
-          #
-          # Create a OpenHAB Cron trigger
-          #
-          # @param [String] expression OpenHAB style cron expression
-          #
-          def cron(expression)
-            @triggers << Trigger.trigger(type: Trigger::CRON, config: { 'cronExpression' => expression })
-          end
-
-          private
-
-          #
-          # 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 cron_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 cron_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 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 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 at_condition(expression_map, at_time)
-            if at_time
-              tod = at_time.is_a?(TimeOfDay) ? at_time : TimeOfDay.parse(at_time)
-              expression_map = expression_map.merge(hour: tod.hour, minute: tod.minute, second: tod.second)
-            end
-            expression_map
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/rule/triggers/trigger.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-require 'java'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Module holds rule triggers
-        #
-        module Triggers
-          #
-          # Create a trigger for a thing
-          #
-          # @param [Thing] thing to create trigger for
-          # @param [Trigger] trigger to map with thing
-          # @param [State] to for thing
-          # @param [State] from state of thing
-          #
-          # @return [Array] Trigger and config for thing
-          #
-          def trigger_for_thing(thing, trigger, to = nil, from = nil)
-            config = { 'thingUID' => thing.uid.to_s }
-            config['status'] = trigger_state_from_symbol(to).to_s if to
-            config['previousStatus'] = trigger_state_from_symbol(from).to_s if from
-            [trigger, config]
-          end
-
-          #
-          # converts object to upcase string if its a symbol
-          #
-          # @param [sym] sym potential symbol to convert
-          #
-          # @return [String] Upcased symbol as string
-          #
-          def trigger_state_from_symbol(sym)
-            sym.to_s.upcase if (sym.is_a? Symbol) || sym
-          end
-
-          #
-          # Append a trigger to the list of triggeres
-          #
-          # @param [String] type of trigger to create
-          # @param [Map] config map describing trigger configuration
-          #
-          # @return [Trigger] OpenHAB trigger
-          #
-          def append_trigger(type, config)
-            logger.trace("Creating trigger of type #{type} for #{config}")
-            trigger = Trigger.trigger(type: type, config: config)
-            @triggers << trigger
-            trigger
-          end
-
-          #
-          # Class for creating and managing triggers
-          #
-          class Trigger
-            java_import org.openhab.core.automation.util.TriggerBuilder
-            java_import org.openhab.core.config.core.Configuration
-
-            # @return [String] A channel event trigger
-            CHANNEL_EVENT = 'core.ChannelEventTrigger'
-
-            # @return [String] A thing status Change trigger
-            THING_CHANGE = 'core.ThingStatusChangeTrigger'
-
-            # @return [String] A thing status update trigger
-            THING_UPDATE = 'core.ThingStatusUpdateTrigger'
-
-            # @return [String] An item command trigger
-            ITEM_COMMAND = 'core.ItemCommandTrigger'
-
-            # @return [String] An item state update trigger
-            ITEM_STATE_UPDATE = 'core.ItemStateUpdateTrigger'
-
-            # @return [String] An item state change trigger
-            ITEM_STATE_CHANGE = 'core.ItemStateChangeTrigger'
-
-            # @return [String] A group state change trigger for items in the group
-            GROUP_STATE_CHANGE = 'core.GroupStateChangeTrigger'
-
-            # @return [String] A group state update trigger for items in the group
-            GROUP_STATE_UPDATE = 'core.GroupStateUpdateTrigger'
-
-            # @return [String] A group command trigger for items in the group
-            GROUP_COMMAND = 'core.GroupCommandTrigger'
-
-            # @return [String] A time of day trigger
-            TIME_OF_DAY = 'timer.TimeOfDayTrigger'
-
-            # @return [String] A cron trigger
-            CRON = 'timer.GenericCronTrigger'
-
-            #
-            # Create a trigger
-            #
-            # @param [String] type of trigger
-            # @param [Map] config map
-            #
-            # @return [OpenHAB Trigger] configured by type and supplied config
-            #
-            def self.trigger(type:, config:)
-              TriggerBuilder.create
-                            .with_id(uuid)
-                            .with_type_uid(type)
-                            .with_configuration(Configuration.new(config))
-                            .build
-            end
-
-            #
-            # Generate a UUID for triggers
-            #
-            # @return [String] UUID
-            #
-            def self.uuid
-              SecureRandom.uuid
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/openhab/core/dsl/rule/triggers/updated.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'core/log'
-
-module OpenHAB
-  module Core
-    module DSL
-      module Rule
-        #
-        # Module holds rule triggers
-        #
-        module Triggers
-          include Logging
-
-          #
-          # Create a trigger when item, group or thing is updated
-          #
-          # @param [Array] items array to trigger on updated
-          # @param [State] to to match for tigger
-          #
-          # @return [Trigger] Trigger for updated entity
-          #
-          def updated(*items, to: nil)
-            items.flatten.each do |item|
-              logger.trace("Creating updated trigger for item(#{item}) to(#{to})")
-              [to].flatten.each do |to_state|
-                trigger, config = create_update_trigger(item, to_state)
-                append_trigger(trigger, config)
-              end
-            end
-          end
-
-          private
-
-          #
-          # Create a trigger for updates
-          #
-          # @param [Object] item Type of item [Group,Thing,Item] to create update trigger for
-          # @param [State] to_state state restriction on trigger
-          #
-          # @return [Array<Hash,String>] first element is a String specifying trigger type
-          #  second element is a Hash configuring trigger
-          #
-          def create_update_trigger(item, to_state)
-            case item
-            when GroupItems then group_update(item, to_state)
-            when Thing then thing_update(item, to_state)
-            else item_update(item, to_state)
-            end
-          end
-
-          #
-          # Create an update trigger for an item
-          #
-          # @param [Item] item to create trigger for
-          # @param [State] to_state optional state restriction for target
-          #
-          # @return [Array<Hash,String>] first element is a String specifying trigger type
-          #  second element is a Hash configuring trigger
-          #
-          def item_update(item, to_state)
-            config = { 'itemName' => item.name }
-            config['state'] = to_state.to_s unless to_state.nil?
-            trigger = Trigger::ITEM_STATE_UPDATE
-            [trigger, config]
-          end
-
-          #
-          # Create an update trigger for a group
-          #
-          # @param [Item] item to create trigger for
-          # @param [State] to_state optional state restriction for target
-          #
-          # @return [Array<Hash,String>] first element is a String specifying trigger type
-          #  second element is a Hash configuring trigger
-          #
-          def group_update(item, to_state)
-            config = { 'groupName' => item.group.name }
-            config['state'] = to_state.to_s unless to_state.nil?
-            trigger = Trigger::GROUP_STATE_UPDATE
-            [trigger, config]
-          end
-
-          #
-          # Create an update trigger for a thing
-          #
-          # @param [Thing] thing to create trigger for
-          # @param [State] to_state optional state restriction for target
-          #
-          # @return [Array<Hash,String>] first element is a String specifying trigger type
-          #  second element is a Hash configuring trigger
-          #
-          def thing_update(thing, to_state)
-            trigger_for_thing(thing, Trigger::THING_UPDATE, to_state)
-          end
-        end
-      end
-    end
-  end
-end