alula-ruby 2.15.1 → 2.16.0

data/lib/alula/dcp_resource.rb

@@ -3,21 +3,27 @@
 module Alula
   # Parent class for all DCP objects
   class DcpResource
-    attr_accessor :device_id, :index, :raw_data, :meta, :errors, :rate_limit, :dirty_attributes, :value, :staged
+    attr_accessor :device_id, :raw_data, :values, :meta, :errors, :rate_limit, :dirty_attributes
 
     def self.class_name
       name.split('::')[-1]
     end
 
-    def initialize(device_id, index = nil, attributes = {})
+    def initialize(device_id, attributes = {})
       @raw_data = {}
-      @dirty_attributes = {}
+      @dirty_attributes = Set.new
+      @values = attributes
       @errors = ModelErrors.new(self.class)
-      construct_from(device_id, index, attributes)
+      klass = get_discriminated_class(attributes)
+      if klass != self.class
+        klass.new(device_id, attributes)
+      else
+        construct_from(device_id, attributes)
+      end
     end
 
     def clone
-      self.class.new(@device_id, nil, @raw_data)
+      self.class.new(@device_id, @raw_data)
     end
 
     #
@@ -27,15 +33,13 @@ module Alula
     def self.build(device_id)
       fields = get_fields.keys.map { |k| Util.camelize(k) }
       empty_shell = fields.each_with_object({}) { |f, obj| obj[f] = nil }
-      new(device_id, nil, empty_shell)
+      new(device_id, empty_shell)
     end
 
-    def construct_from(device_id, index, json_object)
-      raise ArgumentError, 'device_id is required' if device_id.empty?
-
+    def construct_from(device_id, json_object)
       @raw_data = json_object.dup
-      assign_meta_value_staged(json_object)
-      self.index = index
+      @values = json_object
+      @meta = Alula::Dcp::Meta.new(@values['meta']) unless empty_value?(@values['meta'])
       self.device_id = device_id
 
       @errors = ModelErrors.new(self.class)
@@ -45,16 +49,41 @@ module Alula
 
     #
     # Take a hash of attributes and apply them to the model
-    def apply_attributes(attributes)
-      attributes.each do |key, value|
-        next unless fields.include?(key)
-
-        @dirty_attributes[key] = value
+    def apply_attributes(attributes, merge_only: false)
+      res = attributes.each do |key, value|
+        json_key = Util.camelize(key.to_s)
+        sym_key = key.to_sym
+        opts = self.class.get_fields[sym_key] || self.class.get_fields[:primitive]
+        if merge_only
+          # merge the value into the existing value
+          if value.is_a?(Array)
+            value.each_index do |index|
+              send(sym_key)[index].apply_attributes(value[index], merge_only: true)
+            end
+          elsif value.is_a?(Hash) && send(sym_key).respond_to?(:apply_attributes)
+            send(sym_key).apply_attributes(value, merge_only: true)
+          elsif value.is_a?(Hash) && send(sym_key).respond_to?(:each)
+            send("#{key}=", value)
+          elsif opts[:type] == :number
+            @values[json_key] = value.to_i
+          elsif opts[:type] == :boolean
+            @values[json_key] = [true, 'true', 1, '1'].include?(value)
+          else
+            @values[json_key] = value
+          end
+        elsif self.class.has_svm
+          send(:staged).send("#{key}=", value) if send(:staged).respond_to?(key)
+        else
+          send("#{key}=", value)
+        end
       end
+      return @values if merge_only
+
+      res
     end
 
-    def reconstruct_from(device_id, index, json_object)
-      construct_from(device_id, index, json_object)
+    def reconstruct_from(device_id, json_object)
+      construct_from(device_id, json_object)
     end
 
     def errors?
@@ -64,7 +93,7 @@ module Alula
     def refresh
       response = Alula::Client.request(:get, resource_url, {}, {})
       if response.ok?
-        model = construct_from(device_id, index, response.data)
+        model = construct_from(device_id, response.data)
         model.rate_limit = response.rate_limit
         model
       else
@@ -80,26 +109,50 @@ module Alula
       field_names.each_with_object({}) do |ruby_key, obj|
         key = Util.camelize(ruby_key)
         val = find_value(ruby_key)
-
+        # we don't want to include nil values in the JSON (for now?)
         next if val.nil?
 
-        obj[key] = if val.is_a? Array
-                     val.map { |v| parse_value(v, ruby_key) }
-                   elsif val.is_a? Alula::Dcp::ObjectField
-                     val.as_json
-                   else
-                     parse_value(val, ruby_key)
-                   end
+        # if the key is primitive and the class has svm, use staged as key
+        if key == 'primitive' && self.class.has_svm
+          key = 'staged'
+        elsif self.class.has_svm && key != 'index'
+          # if has_svm and not primitive field need to nest values inside 'staged' or 'value'
+          # index is a special case, it's outside of staged/value
+          obj['staged'] ||= {}
+          obj['staged'][key] = pick_value_for_key(val, ruby_key)
+          next
+        end
+
+        obj[key] = pick_value_for_key(val, ruby_key)
+      end
+    end
+
+    def pick_value_for_key(val, ruby_key)
+      if val.is_a? Array
+        val.map { |v| parse_value(v, ruby_key) }
+      elsif val.is_a?(Alula::Dcp::ObjectField) || val.is_a?(Alula::DcpResource)
+        val.as_json
+      else
+        parse_value(val, ruby_key)
       end
     end
 
     def find_value(key)
+      # index is a special case, it's not in staged or value
+      # must return early to avoid errors when staged/value are primitive type
+      return send(key) if key == :index
+
+      json_key = Util.camelize(key.to_s)
+      return values[json_key] unless self.class.has_svm
+
       # prioritize dirty attributes, then staged, then value
       # ideally we should use only dirty attributes, done by executing .apply_attributes
       return @dirty_attributes[key] if @dirty_attributes.include?(key)
-      return @staged.send(key) if @staged.respond_to?(key)
+      # for primitive types we should just return staged or value
+      return staged || value if key == :primitive
+      return staged.send(key) if staged.respond_to?(key)
 
-      @value.send(key) if @value.respond_to?(key)
+      value.send(key) if value.respond_to?(key)
     end
 
     #
@@ -108,7 +161,6 @@ module Alula
       values = as_json.each_pair.each_with_object({}) do |(key, val), collector|
         collector[key] = val
       end
-
       values.reject { |k, _v| %w[index version].include? k } # blacklist index and version
     end
 
@@ -130,6 +182,20 @@ module Alula
       self.class
     end
 
+    class << self
+      def discriminator(field_name = nil)
+        return @discriminator unless field_name
+
+        @discriminator = field_name
+      end
+
+      def discriminate_by(mapping = nil)
+        return @discriminator_mapping unless mapping
+
+        @discriminator_mapping = mapping
+      end
+    end
+
     # Class for holding model errors
     class ModelErrors
       include Enumerable
@@ -170,54 +236,37 @@ module Alula
 
     private
 
-    def assign_meta_value_staged(json_object)
-      @meta = Alula::Dcp::Meta.new(json_object['meta']) unless empty_value?(json_object['meta'])
-      @value = convert_to_ruby_object(json_object['value'])
-      @staged = convert_to_ruby_object(json_object['staged'])
-    end
-
-    def convert_to_ruby_object(object)
-      return nil if object.nil?
-
-      fields.each_pair.each_with_object({}) do |(field_name, opts), obj|
-        value = object[Util.camelize(field_name.to_s)]
-        if value.nil?
-          # we still need to define the method, even if it's nil
-          obj[field_name] = nil
-          obj.define_singleton_method(field_name) { obj[field_name] }
-          next
-        end
-
-        obj[field_name] =
-          if opts[:type] == :date && ![nil, ''].include?(value)
-            begin
-              DateTime.parse(value)
-            rescue ArgumentError
-              value
-            end
-          elsif opts[:type] == :object && opts[:use] && !value.nil? && value.respond_to?(:each)
-            opts[:use].new(field_name, value)
-          elsif opts[:type] == :array && opts[:use] && !value.nil? && value.respond_to?(:each)
-            # Array of objects, each object is a new instance of the use class
-            value.each_with_object([]) do |item, collector|
-              collector << opts[:use].new(field_name, item)
-            end
-          elsif opts[:type] == :boolean
-            [true, 'true', 1, '1'].include? value
-          elsif opts[:type] == :number
-            value&.to_i
-          else
-            value
-          end
-        obj.define_singleton_method(field_name) { obj[field_name] }
+    def get_discriminated_class(attributes)
+      return self.class unless self.class.respond_to?(:discriminator) && self.class.discriminator
+
+      discriminator_field = self.class.discriminator
+      json_key = Util.camelize(discriminator_field.to_s)
+
+      # Try staged first, then value, then raw attributes
+      discriminator_value = if attributes['staged']&.key?(json_key)
+                              attributes['staged'][json_key]
+                            elsif attributes['value']&.key?(json_key)
+                              attributes['value'][json_key]
+                            else
+                              attributes[json_key]
+                            end
+      if discriminator_value && self.class.discriminate_by&.key?(discriminator_value)
+        Object.const_get(self.class.discriminate_by[discriminator_value])
+      else
+        self.class
       end
     end
 
     def parse_value(value, ruby_key)
+      opts = self.class.get_fields[ruby_key.to_sym]
       if date_fields.include?(ruby_key) && ![nil, ''].include?(value)
         extract_date(value)
       elsif value.is_a? Alula::Dcp::ObjectField
         value.as_json
+      elsif opts[:type] == :boolean
+        [true, 'true', 1, '1'].include? value
+      elsif opts[:type] == :number
+        value&.to_i
       else
         value
       end

data/lib/alula/monkey_patches.rb

@@ -21,4 +21,30 @@ module HTTParty
       end
     end
   end
-end
+end
+
+class Object
+  # should only be used for deeply nested structures
+  def deep_dup
+    case self
+    when Numeric, Symbol, NilClass, TrueClass, FalseClass
+      self # Immutable types don't need duplication
+    when String
+      dup
+    when Array
+      map(&:deep_dup)
+    when Hash
+      each_with_object({}) do |(key, value), duped|
+        duped[key.deep_dup] = value.deep_dup
+      end
+    else
+      # Fall back to the original dup method
+      # Should NOT use marshalling/unmarshalling as this can lead to arbitrary code execution based on user input.
+      begin
+        dup
+      rescue StandardError
+        self
+      end
+    end
+  end
+end

data/lib/alula/resource_attributes.rb

@@ -26,6 +26,7 @@ module Alula
 
     def get_resource_path(id = nil)
       return "#{@resource_path}/#{id}" if id
+
       @resource_path
     end
 
@@ -46,7 +47,7 @@ module Alula
     end
 
     #
-    # Memoizes field names and options 
+    # Memoizes field names and options
     def field(field_name, **opts)
       @fields ||= {}
       @fields[field_name] = opts
@@ -66,6 +67,8 @@ module Alula
             end
           elsif opts[:type] == :object && opts[:use] && !value.nil? && value.respond_to?(:each)
             opts[:use].new(@dirty_attributes, field_name, value)
+          elsif opts[:type] == :dcp_object && opts[:use]
+            opts[:use].new(nil, nil, value)
           elsif opts[:type] == :boolean
             [true, 'true', 1, '1'].include? value
           elsif opts[:symbolize] == true
@@ -93,8 +96,11 @@ module Alula
             new_value = Util.camelize(new_value.to_s)
           elsif opts[:type] == :boolean
             new_value = [true, 'true', 1, '1'].include? new_value
+          elsif opts[:type] == :dcp_object
+            old_val = @values.deep_dup
+            new_value = send(field_name).apply_attributes(new_value, merge_only: true)
+            mark_dirty(field_name, old_val[json_key], new_value)
           end
-
           # Mark the attribute as dirty if the new value is different
           mark_dirty(field_name, @values[json_key], new_value)
           #
@@ -217,22 +223,23 @@ module Alula
       @dirty_attributes = Set.new
 
       return unless properties
+
       valid_fields = self.class.get_fields
 
       properties.dup.each do |key, value|
-        jsonKey = key;
         ruby_key = Alula::Util.underscore(key.to_s)
 
-        self.public_send("#{ruby_key}=", value) if valid_fields.key?(ruby_key.to_sym)
+        public_send("#{ruby_key}=", value) if valid_fields.key?(ruby_key.to_sym)
       end
     end
+
     def mark_dirty(field_name, old_value, new_value)
       @parent_dirty_attributes << @parent_field if old_value != new_value
     end
 
     def as_json
       self.field_names.each_with_object({}) do |ruby_key, obj|
-        key      = Util.camelize(ruby_key)
+        key = Util.camelize(ruby_key)
         val = self.send(ruby_key)
 
         if self.date_fields.include?(ruby_key) && ![nil, ''].include?(val)

data/lib/alula/resources/config_template.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Alula
+  class ConfigTemplate < Alula::RestResource
+    extend Alula::ResourceAttributes
+    extend Alula::ApiOperations::Request
+    extend Alula::ApiOperations::List
+    extend Alula::ApiOperations::Save
+    extend Alula::ApiOperations::Delete
+
+    resource_path 'devices/config/templates'
+    type 'devices-config-templates'
+
+    class Alula::Dcp::Template < Alula::Dcp::ObjectField
+      field :timers, type: :object, use: Alula::Dcp::Config::Timers
+      field :panel_options, type: :object, use: Alula::Dcp::Config::PanelOptions
+      field :comm_data, type: :object, use: Alula::Dcp::Config::CommData
+      field :siren_data, type: :object, use: Alula::Dcp::Config::SirenData
+      field :bus_modules, type: :object, use: Alula::Dcp::Config::BusModules
+      field :partitions, type: :object, use: Alula::Dcp::Config::Partitions
+      field :users_data, type: :object, use: Alula::Dcp::Config::UsersData
+    end
+
+    field :dealer_id,
+          type: :string,
+          patchable_by: %i[system station dealer],
+          creatable_by: %i[system station dealer],
+          filterable: true,
+          sortable: true
+
+    field :program_id,
+          type: :number,
+          patchable_by: %i[system station dealer],
+          creatable_by: %i[system station dealer],
+          filterable: true,
+          sortable: true
+
+    field :name,
+          type: :string,
+          patchable_by: %i[system station dealer],
+          creatable_by: %i[system station dealer]
+
+    field :template,
+          type: :dcp_object,
+          use: Alula::Dcp::Template,
+          patchable_by: %i[system station dealer],
+          creatable_by: %i[system station dealer]
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/bus_module.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class Config
+      class BusModules < Alula::Dcp::BaseResource
+        class BusModule < Alula::Dcp::BaseResource
+          extend Alula::Dcp::ResourceAttributes
+          extend Alula::DcpOperations::Request
+          extend Alula::DcpOperations::Save
+          extend Alula::DcpOperations::Delete
+          extend Alula::DcpOperations::DeleteStaged
+          include Alula::Dcp::StagedValueMethods
+
+          resource_name 'config/busModules/busModule'
+
+          field :index, type: :number
+          field :id, type: :number
+          field :module_type, type: :string
+          field :address, type: :number
+          field :supervision_time, type: :number
+          field :wall_tamper_enabled, type: :boolean
+          field :module_enabled, type: :boolean
+          field :name, type: :string
+
+          discriminator :module_type
+          discriminate_by(
+            'DWS' => 'Alula::Dcp::Config::BusModules::DwsBusModule',
+            'ISM Transceiver Module' => 'Alula::Dcp::Config::BusModules::IsmTransceiverBusModule',
+            'Input Module - 8 Inputs' => 'Alula::Dcp::Config::BusModules::InputBusModule',
+            'Output Module - X Outputs' => 'Alula::Dcp::Config::BusModules::OutputBusModule',
+            'Touchpad Module' => 'Alula::Dcp::Config::BusModules::TouchpadBusModule',
+            'Zwave Module' => 'Alula::Dcp::Config::BusModules::ZwaveBusModule'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/dws_bus_module.rb

@@ -0,0 +1,12 @@
+module Alula
+  module Dcp
+    class Config
+      class BusModules
+        # DWS Bus Module
+        # id: 0 (indicates unused index)
+        class DwsBusModule < Alula::Dcp::Config::BusModules::BusModule
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/input_bus_module.rb

@@ -0,0 +1,12 @@
+module Alula
+  module Dcp
+    class Config
+      class BusModules
+        # Input Module - 8 Inputs
+        # id range: 0x81000000 - 0x81FFFFFF (2164260864 - 2181038079)
+        class InputBusModule < BusModule
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/ism_transceiver_bus_module.rb

@@ -0,0 +1,18 @@
+module Alula
+  module Dcp
+    class Config
+      class BusModules
+        # ISM Transceiver Bus Module
+        # id range: 0x80000000 - 0x80FFFFFF (2147483648 - 2164260863)
+        class IsmTransceiverBusModule < BusModule
+          class TranslatorProtocol < Alula::Dcp::ObjectField
+            field :primary, type: :string
+            field :secondary, type: :string
+          end
+
+          field :translator_protocol, type: :object, use: TranslatorProtocol
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/output_bus_module.rb

@@ -0,0 +1,12 @@
+module Alula
+  module Dcp
+    class Config
+      class BusModules
+        # Output Module - X Outputs
+        # id range: 0x82000000 - 0x82FFFFFF (2181038080 - 2197815295)
+        class OutputBusModule < BusModule
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/touchpad_bus_module.rb

@@ -0,0 +1,17 @@
+module Alula
+  module Dcp
+    class Config
+      class BusModules
+        # Touchpad Module
+        # id range: 0x83000000 - 0x83FFFFFF (2197815296 - 2214592511)
+        class TouchpadBusModule < BusModule
+          class TouchpadData < Alula::Dcp::ObjectField
+            field :power_source, type: :string
+          end
+
+          field :data, type: :object, use: TouchpadData
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules/zwave_bus_module.rb

@@ -0,0 +1,12 @@
+module Alula
+  module Dcp
+    class Config
+      class BusModules
+        # Zwave Module
+        # id range: 0x84000000 - 0x84FFFFFF (2214592512 - 2231369727)
+        class ZwaveBusModule < BusModule
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/bus_modules.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class Config
+      class BusModules < Alula::Dcp::BaseResource
+        extend Alula::Dcp::ResourceAttributes
+        extend Alula::DcpOperations::Request
+        extend Alula::DcpOperations::Save
+        extend Alula::DcpOperations::Delete
+        extend Alula::DcpOperations::DeleteStaged
+
+        resource_name 'config/busModules'
+
+        field :bus_module,
+              type: :array,
+              of: Alula::Dcp::Config::BusModules::BusModule
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/comm_data/auto_comm_test_interval.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class Config
+      class CommData
+        class AutoCommTestInterval < Alula::Dcp::BaseResource
+          extend Alula::Dcp::ResourceAttributes
+          extend Alula::DcpOperations::Request
+          extend Alula::DcpOperations::Save
+          extend Alula::DcpOperations::Delete
+          extend Alula::DcpOperations::DeleteStaged
+          include Alula::Dcp::StagedValueMethods
+
+          resource_name 'config/commData/autoCommTestInterval'
+          field :index,
+                type: :number
+          field :primitive,
+                type: :number
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/comm_data/server_heartbeats.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class Config < Alula::Dcp::BaseResource
+      class CommData < Alula::Dcp::BaseResource
+        class ServerHeartbeats < Alula::Dcp::BaseResource
+          extend Alula::Dcp::ResourceAttributes
+          extend Alula::DcpOperations::Request
+          extend Alula::DcpOperations::Save
+          extend Alula::DcpOperations::Delete
+          extend Alula::DcpOperations::DeleteStaged
+          include Alula::Dcp::StagedValueMethods
+
+          resource_name 'config/commData/serverHeartbeats'
+
+          field :server_heartbeat,
+                type: :number
+          field :server_heartbeat_gsm_cdma,
+                type: :number
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/comm_data/server_keep_alives.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class Config
+      class CommData
+        class ServerKeepAlives < Alula::Dcp::BaseResource
+          extend Alula::Dcp::ResourceAttributes
+          extend Alula::DcpOperations::Request
+          extend Alula::DcpOperations::Save
+          extend Alula::DcpOperations::Delete
+          extend Alula::DcpOperations::DeleteStaged
+          include Alula::Dcp::StagedValueMethods
+
+          resource_name 'config/commData/serverKeepAlives'
+
+          field :server_keep_alive,
+                type: :number
+          field :server_keep_alive_gsm_cdma,
+                type: :number
+        end
+      end
+    end
+  end
+end

data/lib/alula/resources/dcp/config/comm_data.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class Config < Alula::Dcp::BaseResource
+      class CommData < Alula::Dcp::BaseResource
+        extend Alula::Dcp::ResourceAttributes
+        extend Alula::DcpOperations::Request
+        extend Alula::DcpOperations::Save
+        extend Alula::DcpOperations::Delete
+        extend Alula::DcpOperations::DeleteStaged
+
+        resource_name 'config/commData'
+
+        field :server_heartbeats,
+              type: :object,
+              use: Alula::Dcp::Config::CommData::ServerHeartbeats
+        field :server_keep_alives,
+              type: :object,
+              use: Alula::Dcp::Config::CommData::ServerKeepAlives
+        field :auto_comm_test_interval,
+              type: :array,
+              of: Alula::Dcp::Config::CommData::AutoCommTestInterval
+      end
+    end
+  end
+end