alula-ruby 2.15.1 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4272ad9dbb49623ad0599bbd6a341c23b3ec55498ff1ddad91f1c2c0716e74ad
-  data.tar.gz: 71995cc0e81d17122f9345e1f9e6da1bd57c2d3477150129c78cdb2738b32cde
+  metadata.gz: 34cf5c0ab11f5e83c244464f016e809a228e2c404cfd05322fcc3876681ab583
+  data.tar.gz: 702f818c5619c276030cb9b3bc75a780e97a58f3237a887de39c693196d42d2c
 SHA512:
-  metadata.gz: 24f89a7f36b094153bf1c0895617d5968bd63e3cc7e2dbe86b68753dab66256861193f5167d37cea0003539d0b6d0bb058ce5d2b8cccc8093f3130c3f55e4403
-  data.tar.gz: c0d78aa748dd7fe7f1c2976d83d87ab178531d4da548b7c26a5d5582667efd7b0c389fc3405022ba09e1a49aa81cd4249fcad3de41f0cf2a4987ecf178d1812f
+  metadata.gz: 3eae60166983ae4dc654739434694b5fa3bbc6e957e605f645763e08ef53caf6926ecc858d92b88804788d95d79316a3d6d8cec682d0d252a055f089342d74bf
+  data.tar.gz: eb340114013a2eebd35aba3794be2e1f6c6f65ea5be3aa691a3feb29bac1737e1be35906980b52f3b7204b8d849eb14c92481e3e89d3c2d10b97dd5b1daef2ac

data/VERSION.md

@@ -2,6 +2,7 @@
 
 | Version | Date        | Description                                                                 |
 | ------- | ------------| --------------------------------------------------------------------------- |
+| v2.16.0 | 2025-06-18  | Add API config template and all DCP entities |
 | v2.15.1 | 2025-07-19  | Rename DCP-synchronizable fields to conform to the schema |
 | v2.15.0 | 2025-06-10  | Add users relationship to stations |
 | v2.14.0 | 2025-04-16  | Add camera reboot and format sd card procs |

data/bin/console

@@ -47,4 +47,5 @@ def setup_client(token)
     c.video_api_key = ENV['VIDEO_API_DOMAIN']
   end
 end
+
 IRB.start(__FILE__)

data/lib/alula/api_resource.rb

@@ -4,7 +4,7 @@ module Alula
     attr_accessor :id, :raw_data, :values, :dirty_attributes, :errors, :links, :link_matchers, :rate_limit
 
     def self.class_name
-      name.split("::")[-1]
+      name.split('::')[-1]
     end
 
     def initialize(id = nil, attributes = {})
@@ -89,21 +89,20 @@ module Alula
     # Fetch known attributes out of the object, collected into a Hash in camelCase format
     # Intended for eventually making its way back up to the API
     def as_json
-      self.field_names.each_with_object({}) do |ruby_key, obj|
-        key      = Util.camelize(ruby_key)
-        val = self.send(ruby_key)
-
-        if self.date_fields.include?(ruby_key) && ![nil, ''].include?(val)
-          if val.respond_to? :strftime
-            obj[key] = val.strftime('%Y-%m-%dT%H:%M:%S.%L%z')
-          else
-            obj[key] = val.to_s
-          end
-        elsif val.is_a? Alula::ObjectField
-          obj[key] = val.as_json
-        else
-          obj[key] = val
-        end
+      field_names.each_with_object({}) do |ruby_key, obj|
+        key = Util.camelize(ruby_key)
+        val = send(ruby_key)
+        obj[key] = if date_fields.include?(ruby_key) && ![nil, ''].include?(val)
+                     if val.respond_to? :strftime
+                       val.strftime('%Y-%m-%dT%H:%M:%S.%L%z')
+                     else
+                       val.to_s
+                     end
+                   elsif val.is_a?(Alula::ObjectField) || val.is_a?(Alula::Dcp::ObjectField)
+                     val.as_json
+                   else
+                     val
+                   end
       end
     end
 
@@ -117,7 +116,7 @@ module Alula
       end
 
       # Remove blank values if creating a new record
-      values = values.select{ |k, v| !v.nil? } unless persisted?
+      values = values.reject { |_k, v| v.nil? } unless persisted?
       values
     end
 
@@ -135,7 +134,7 @@ module Alula
     def cache_links(links)
       @links = links
 
-      @link_matchers = links.each_pair.each_with_object([]) do |(type, link), collection|
+      @link_matchers = links.each_pair.each_with_object([]) do |(_type, link), collection|
         data = link['data']
         next if data.nil?
 
@@ -160,8 +159,6 @@ module Alula
       self.class
     end
 
-    private
-
     class ModelErrors
       include Enumerable
 

data/lib/alula/dcp/resource_attributes.rb

@@ -1,14 +1,26 @@
 # frozen_string_literal: true
 
+require 'byebug'
 module Alula
   module Dcp
     module ResourceAttributes
       def self.extended(base)
         base.class_eval do
+          class << self
+            attr_writer :has_svm
+
+            def has_svm
+              @has_svm ||= false
+            end
+          end
           @resource_path = nil
           @type = nil
           @http_methods = []
           @fields = {}
+
+          def mark_dirty(field_name, old_value, new_value)
+            @dirty_attributes << field_name if old_value != new_value
+          end
         end
         base.include(InstanceMethods)
       end
@@ -49,10 +61,69 @@ module Alula
       def field(field_name, **opts)
         @fields ||= {}
         @fields[field_name] = opts
+        return if has_svm && field_name != :index
+
+        json_key = Alula::Util.camelize(field_name)
+        instance_eval do
+          # Reader method for attribute
+          define_method(field_name) do
+            value = @values[json_key]
+            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)
+              if opts[:use].superclass == Alula::Dcp::ObjectField
+                opts[:use].new({}, field_name, value)
+              elsif respond_to?(:device_id)
+                opts[:use].new(device_id, value)
+              else
+                opts[:use].new(nil, value)
+              end
+            elsif opts[:type] == :array && opts[:of] && !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[:of].new(device_id, item)
+              end
+            elsif opts[:type] == :boolean
+              [true, 'true', 1, '1'].include? value
+            elsif opts[:type] == :number
+              value&.to_i
+            else
+              value
+            end
+          end
+
+          # Setter method
+          define_method("#{field_name}=") do |new_value|
+            #
+            # Coerce 'blank like' fields into a defined blank value
+            # This helps HTML form submissions. A blank text field comes through as an
+            # empty string, instead of a nil as the API validates for.
+            new_value = nil if new_value == ''
+
+            new_value = [true, 'true', 1, '1'].include? new_value if opts[:type] == :boolean
+
+            # Mark the attribute as dirty if the new value is different
+            mark_dirty(field_name, @values[json_key], new_value)
+            #
+            # Assign the new value (always assigned even if a duplicate)
+            @values[json_key] = new_value
+          end
+        end
       end
 
       def get_fields
-        @fields
+        parent_fields = if superclass.respond_to?(:get_fields)
+                          superclass.get_fields
+                        else
+                          {}
+                        end
+
+        @fields ||= {}
+        parent_fields.merge(@fields)
       end
 
       def date_fields
@@ -79,7 +150,9 @@ module Alula
       end
 
       def param_key
-        name.gsub('::', '_').downcase
+        # return only the last part of the class name, in snake_case
+        # e.g. Alula::Dcp::Config::PanelOptions becomes panel_options
+        Util.underscore(name.split('::')[-1])
       end
 
       private
@@ -145,8 +218,11 @@ module Alula
       extend ResourceAttributes
 
       # Assume properties is camel case
-      def initialize(parent_field, properties = nil)
+      def initialize(dirty_attributes, parent_field, properties = nil)
+        @values = properties
         @parent_field = parent_field
+        @parent_dirty_attributes = dirty_attributes
+        @dirty_attributes = Set.new
         return unless properties
 
         valid_fields = self.class.get_fields
@@ -154,12 +230,18 @@ module Alula
           ruby_key = Alula::Util.underscore(key.to_s)
           next unless valid_fields.key?(ruby_key.to_sym)
 
-          instance_variable_set("@#{ruby_key}", value)
-          define_singleton_method(ruby_key) { instance_variable_get("@#{ruby_key}") }
-          define_singleton_method("#{ruby_key}=") { |val| instance_variable_set("@#{ruby_key}", val) }
+          public_send("#{ruby_key}=", value)
         end
       end
 
+      def model_name
+        self.class
+      end
+
+      def present?
+        !@values.nil?
+      end
+
       def as_json
         field_names.each_with_object({}) do |ruby_key, obj|
           key = Util.camelize(ruby_key)
@@ -170,13 +252,52 @@ module Alula
         end
       end
 
+      #
+      # Take a hash of attributes and apply them to the model
+      def apply_attributes(attributes, merge_only: false)
+        res = attributes.each do |key, value|
+          next unless field_names.include?(key.to_sym)
+
+          opts = self.class.get_fields[key.to_sym]
+          json_key = Util.camelize(key.to_s)
+          if merge_only
+            # merge the value into the existing value
+            if value.is_a?(Array)
+              value.each_index do |index|
+                send(key)[index].apply_attributes(value[index], merge_only: true)
+              end
+            elsif value.is_a?(Hash) && send(key).respond_to?(:apply_attributes)
+              send(key).apply_attributes(value, merge_only: true)
+            elsif value.is_a?(Hash) && send(key).respond_to?(:each)
+              send("#{key}=", value[key])
+            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
+          else
+            send("#{key}=", value)
+          end
+        end
+        return @values if merge_only
+
+        res
+      end
+
       private
 
       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
+        elsif value.is_a?(Alula::Dcp::ObjectField) || value.is_a?(Alula::DcpResource)
           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/dcp/resource_state.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    class ResourceState
+      attr_reader :key
+
+      def initialize(resource, key)
+        @resource = resource
+        @key = key
+      end
+
+      def model_name
+        @resource.class
+      end
+
+      def apply_attributes(attributes, _opts = {})
+        attributes.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+
+      private
+
+      def method_missing(name, *args)
+        field_name = name.to_s.sub(/=$/, '').to_sym
+        klass = get_discriminated_class(@resource.values)
+        if klass.get_fields.key?(field_name)
+          json_key = Util.camelize(field_name.to_s)
+          opts = klass.get_fields[field_name]
+          if name.to_s.end_with?('=')
+            # Setter method
+            define_singleton_method("#{field_name}=") do |new_value|
+              # transform keys inside new_value to camelCase
+              new_value = new_value.transform_keys { |k| Util.camelize(k.to_s) } if new_value.is_a?(Hash)
+              #
+              # Coerce 'blank like' fields into a defined blank value
+              # This helps HTML form submissions. A blank text field comes through as an
+              # empty string, instead of a nil as the API validates for.
+              new_value = nil if new_value == '' && opts[:type] != :string
+
+              new_value = [true, 'true', 1, '1'].include? new_value if opts[:type] == :boolean
+              new_value = new_value.to_i if opts[:type] == :number
+              if opts[:type] == :object && opts[:use]
+                obj_fields = opts[:use].get_fields
+                new_value.each do |k, v|
+                  next unless obj_fields.key?(k.to_sym)
+
+                  type = obj_fields[k.to_sym][:type]
+                  case type
+                  when :boolean
+                    new_value[k] = [true, 'true', 1, '1'].include? v
+                  when :number
+                    new_value[k] = v.to_i
+                  else
+                    # For other types, just assign the value directly
+                    new_value[k] = v
+                  end
+                end
+              end
+              #
+              # Assign the new value (always assigned even if a duplicate)
+              @resource.values[@key][json_key] = new_value
+            end
+            send("#{field_name}=", *args)
+          else
+            define_singleton_method(field_name) do
+              value = @resource.values[@key][json_key]
+              return nil if value.nil?
+
+              # Regular type handling
+              if opts[:type] == :date && ![nil, ''].include?(value)
+                begin
+                  DateTime.parse(value)
+                rescue ArgumentError
+                  value
+                end
+              elsif opts[:type] == :object && opts[:use]
+                if opts[:use].superclass == Alula::Dcp::ObjectField
+                  opts[:use].new({}, field_name, value)
+                elsif respond_to?(:device_id)
+                  opts[:use].new(device_id, value['index'], value)
+                else
+                  opts[:use].new(nil, nil, value)
+                end
+              elsif opts[:type] == :array && opts[:of]
+                # Array of objects, each object is a new instance of the use class
+                value.each_with_object([]) do |item, collector|
+                  if item.is_a?(Hash) && item['index']
+                    collector << opts[:of].new(device_id, item['index'], item)
+                  else
+                    collector << opts[:of].new(device_id, nil, item)
+                  end
+                end
+              elsif opts[:type] == :boolean
+                [true, 'true', 1, '1'].include? value
+              elsif opts[:type] == :number
+                value&.to_i
+              else
+                value
+              end
+            end
+            send(field_name)
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        field_name = name.to_s.sub(/=$/, '').to_sym
+        get_discriminated_class(@resource.values).get_fields.key?(field_name) || name == 'param_key' || super
+      end
+
+      def get_discriminated_class(attributes)
+        return @resource.class unless @resource.class.respond_to?(:discriminator) && @resource.class.discriminator
+
+        discriminator_field = @resource.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 && @resource.class.discriminate_by&.key?(discriminator_value)
+          Object.const_get(@resource.class.discriminate_by[discriminator_value])
+        else
+          @resource.class
+        end
+      end
+
+      def primitive?(resource)
+        resource.class.get_fields[:primitive]
+      end
+    end
+
+    class StagedState < ResourceState
+      def initialize(resource)
+        super(resource, 'staged')
+      end
+    end
+    class ValueState < ResourceState
+      def initialize(resource)
+        super(resource, 'value')
+      end
+    end
+  end
+end

data/lib/alula/dcp/staged_value_methods.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Alula
+  module Dcp
+    module StagedValueMethods
+      def self.included(base)
+        base.class_eval do
+          class << self
+            attr_writer :has_svm
+
+            def has_svm
+              @has_svm ||= true
+            end
+          end
+        end
+      end
+
+      def staged
+        return nil if values['staged'].nil?
+
+        if primitive?(self)
+          # define setter method for staged value
+          define_singleton_method :staged= do |value|
+            values['staged'] = value
+          end
+          return values['staged']
+        end
+
+        @staged ||= StagedState.new(self)
+      end
+
+      def value
+        return nil if values['value'].nil?
+        if primitive?(self)
+          # define setter method for value
+          define_singleton_method :value= do |value|
+            values['value'] = value
+          end
+          return values['value']
+        end
+
+        @value ||= ValueState.new(self)
+      end
+
+      def primitive?(resource)
+        resource.class.get_fields[:primitive]
+      end
+    end
+  end
+end