alula-ruby 0.50.1

data/lib/alula/query_interface.rb

@@ -0,0 +1,142 @@
+module Alula
+  class QueryInterface
+    extend Forwardable
+
+    def initialize(model_class)
+      @model_class = model_class
+      @filter_builder = Alula::FilterBuilder.new(model_class, self)
+      @filter = {}
+      @page = {}
+      @custom_options = {}
+      @includes = {}
+      @opts = {}
+      @sorts = {}
+    end
+
+    def filter(filter_hash)
+      @filter = Util.deep_merge @filter, filter_hash
+      self
+    end
+
+    def filter_builder(&block)
+      if block_given?
+        yield @filter_builder
+        @filter = Util.deep_merge(@filter, @filter_builder.as_json)
+        self
+      else
+        @filter_builder
+      end
+    end
+
+    def_delegators :filter_builder, :where, :and, :not, :ne, :or, :between, :not_between,
+                                    :builder, :gt, :gte, :lt, :lte, :like, :not_like, :in,
+                                    :not_in, :sort
+
+    def offset(offset)
+      @page = Util.deep_merge(@page, {
+        page: {
+          number: offset,
+        }
+      })
+      self
+    end
+
+    def limit(limit)
+      @page = Util.deep_merge(@page, {
+        page: {
+          size: limit
+        }
+      })
+      self
+    end
+
+    def custom_options(**options)
+      @custom_options = Util.deep_merge(@custom_options, {
+        customOptions: options
+      })
+      self
+    end
+
+    def include_relationships
+      custom_options(omitRelationships: false)
+    end
+
+    def includes(*relationships)
+      relationships = @model_class.get_relationships.keys if relationships == [:all]
+
+      validated_relationships = relationships.map do |relationship|
+        @model_class.check_relationship!(relationship)
+      end
+
+      @includes = Util.deep_merge(@includes, {
+        include: validated_relationships.compact.map { |r| Util.camelize(r) }.join(',')
+      })
+
+      self
+    end
+
+    def query_sort(options)
+      cleaned_sorts = options.each_pair.each_with_object([]) do |(key, value), collector|
+        collector << "#{value == :desc ? '-' : ''}#{key}"
+      end
+
+      @sorts = Util.deep_merge(@sorts, {
+        sort: cleaned_sorts.join(',')
+      })
+      self
+    end
+
+    def as_json
+      JSON.parse(to_json)
+    end
+
+    def to_json
+      JSON.generate(built_query_options)
+    end
+
+    def list(opts = {})
+      @model_class.list(built_query_options, @opts.merge(opts))
+    end
+
+    def list_all(opts = {})
+      # We have defaults we want to use, but if the caller wants to change, we support it
+      size = @page.to_h.dig(:page, :size) || 250
+      number = @page.to_h.dig(:page, :number) || 1
+
+      return to_enum(:list_all, opts) unless block_given?
+
+      page = self.page(number: number, size: size).list(opts)
+      return page unless page.is_a? Alula::ListObject
+
+      loop do
+        yield page
+        break unless page.meta.page.has_next?
+
+        page = self.page(number: number += 1, size: size).list(opts)
+      end
+    end
+
+    def retrieve(id)
+      @model_class.retrieve(id, built_query_options)
+    end
+
+    def page(number: 1, size: 10)
+      @page = Util.deep_merge(@page, {
+        page: {
+          number: number,
+          size: size
+        }
+      })
+      self
+    end
+
+    def built_query_options
+      built = Util.deep_merge({}, @page)
+      built = Util.deep_merge(built, @includes)
+      built = Util.deep_merge(built, @sorts)
+      built = Util.deep_merge(built, @custom_options)
+
+      Util.deep_merge(built, @filter)
+    end
+  end
+end

data/lib/alula/rate_limit.rb

@@ -0,0 +1,11 @@
+module Alula
+  class RateLimit
+    attr_accessor :request_limit, :requests_remaining, :reset_in
+
+    def initialize(headers)
+      self.request_limit = headers["x-rate-limit-limit"].to_i
+      self.requests_remaining = headers["x-rate-limit-remaining"].to_i
+      self.reset_in = headers["x-rate-limit-reset"].to_i
+    end
+  end
+end

data/lib/alula/relationship_attributes.rb

@@ -0,0 +1,107 @@
+module Alula
+  module RelationshipAttributes
+    def self.extended(base)
+      base.class_eval do
+        @relationships = {}
+      end
+      base.include(InstanceMethods)
+    end
+
+    # TODO: Walk the relationships and define methods to allow an instance to
+    #       request a relationship with dot notation... Dealer.fetch(id).devices, etc
+    def relationship(name, **opts)
+      @relationships ||= {}
+      @relationships[name] = opts.merge(name: name)
+      
+      # Define a getter for our relationship name
+      instance_eval do
+        define_method(name) do
+          @related_models[name]
+        end
+      end
+
+      if opts[:cardinality] == 'To-one'
+        instance_eval do
+          define_method("#{name}=") do |new_model|
+            @related_models[name] = new_model
+          end
+        end
+      elsif opts[:cardinality] == 'To-many'
+        instance_eval do
+          define_method("#{name}<<") do |new_model|
+            @related_models[name] ||= ListObject.new(self.class)
+            @related_models[name] << new_model
+          end
+        end
+      end
+
+      @relationships
+    end
+
+    def get_relationships
+      @relationships
+    end
+
+    def get_relationship(name)
+      identifier = name.is_a?(Symbol) ? :name : :type
+      relationship = get_relationships.find { |_key, opts| opts[identifier] == name }
+      raise "Unknown relationship #{identifier} #{name} for class #{self}" unless relationship
+      relationship.last
+    end
+
+    def relationship_exists?(possible_r)
+      get_relationships.keys.include?(possible_r.to_sym)
+    end
+
+    def check_relationship!(possible_r)
+      cleaned_relationship = Util.underscore(possible_r).to_sym
+
+      unless self.relationship_exists?(cleaned_relationship)
+        error = "Invalid relationship #{cleaned_relationship} for class #{self}. "\
+                "Please use one of #{get_relationships.keys.join(', ')}"
+        raise Alula::InvalidRelationshipError.new(error)
+      end
+
+      cleaned_relationship
+    end
+
+    module InstanceMethods
+      def get_relationships
+        self.class.get_relationships
+      end
+
+      def get_relationship(name)
+        self.class.get_relationship(name)
+      end
+
+      def add_model_to_relationship(model)        
+        relation = get_relationship(model.get_type)
+        unless relation
+          raise "Unknown model relationship #{model.get_type} for model #{self.class}"
+        end
+
+        if relation[:cardinality] == 'To-one'
+          self.send("#{relation[:name]}=", model)
+
+        elsif relation[:cardinality] == 'To-many'
+          if self.send(relation[:name]).nil?
+            list = Alula::ListObject.new(model.class)
+            list << model
+          end
+
+          self.send("#{relation[:name]}<<", model)
+        else
+          raise "Unknown relationship cardinality for relationship #{relation.inspect}"
+        end
+      end
+
+      def relationship_exists?(relationship)
+        self.class.relationship_exists?(relationship)
+      end
+
+      def check_relationship!(relationship)
+        self.class.check_relationship!(relationship)
+      end
+    end
+  end
+end

data/lib/alula/resource_attributes.rb

@@ -0,0 +1,206 @@
+# A mixin pulled into ImportedResources with which to define resource methods
+module Alula
+  module ResourceAttributes
+    def self.extended(base)
+      base.class_eval do
+        @resource_path = nil
+        @type = nil
+        @http_methods = []
+        @fields = {}
+      end
+      base.include(InstanceMethods)
+    end
+
+
+    #
+    # Class methods for defining how fields and types work
+    # NOTE: We're not using real getters and setters here. I want the method signature
+    #       to match how most other Ruby class configuration is done, and that is with
+    #       simple methods that take params.
+
+
+    def resource_path(name)
+      @resource_path = name
+    end
+
+    def get_resource_path(id = nil)
+      return "#{@resource_path}/#{id}" if id
+      @resource_path
+    end
+
+    def type(type)
+      @type = type
+    end
+
+    def get_type
+      @type
+    end
+
+    def http_methods(methods)
+      @http_methods = methods
+    end
+
+    def get_http_methods
+      @http_methods
+    end
+
+    #
+    # Memoizes field names and options 
+    def field(field_name, **opts)
+      @fields ||= {}
+      @fields[field_name] = opts
+
+      self.instance_eval do
+        jsonKey = Util.camelize(field_name)
+
+        # Reader method for attribute
+        define_method(field_name) do
+          value = @values[jsonKey]
+
+          if opts[:type] == :date && ![nil, ''].include?(value)
+            begin
+              DateTime.parse(value)
+            rescue ArgumentError
+              value
+            end
+          elsif opts[:type] == :boolean
+            [true, 'true', 1, '1'].include? value
+          elsif opts[:symbolize] == true
+            # API sends a camelCase string; provide symbol to Client
+            value ? Util.underscore(value).to_sym : nil
+          elsif opts[:hex_convert_required] == true
+            Util.convert_hex_crc?(self.program_id) ? value.to_s(16) : value
+          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 == ''
+
+          if opts[:symbolize] == true
+            # Client provides a symbol; send camelCase string to API
+            new_value = Util.camelize(new_value.to_s)
+          elsif opts[:type] == :boolean
+            new_value = [true, 'true', 1, '1'].include? new_value
+          end
+
+          #
+          # Mark the attribute as dirty if the new value is different
+          @dirty_attributes << field_name if @values[jsonKey] != new_value
+
+          #
+          # Assign the new value (always assigned even if a duplicate)
+          @values[jsonKey] = new_value
+        end
+
+
+      end
+    end
+
+    def get_fields
+      @fields
+    end
+
+    def read_only_attributes(record_persisted = false)
+      get_fields.each_pair.each_with_object([]) do |(field_name, opts), collector|
+        collector << field_name if !field_patchable?(opts, record_persisted)
+      end
+    end
+
+    def date_fields
+      get_fields.each_pair.each_with_object([]) do |(field_name, opts), collector|
+        collector << field_name if opts[:type].to_sym == :date
+      end
+    end
+
+    def filterable_fields
+      get_fields.each_pair.each_with_object([]) do |(field_name, opts), collector|
+        collector << field_name if opts[:filterable] == true
+      end
+    end
+
+    def sortable_fields
+      get_fields.each_pair.each_with_object([]) do |(field_name, opts), collector|
+        collector << field_name if opts[:sortable] == true
+      end
+    end
+
+    def field_names
+      get_fields.keys
+    end
+
+    def param_key
+      self.name.gsub('::', '_').downcase
+    end
+
+    private
+
+    def metaclass
+      class << self
+        self
+      end
+    end
+
+    def field_patchable?(opts, record_persisted)
+      user_role = Alula::Client.role
+
+      # different permission arrays are used for updates vs creates
+      perm_key = record_persisted == true ? :patchable_by : :creatable_by
+
+      return true if opts[perm_key].include? :all
+
+      opts[perm_key].include? user_role
+    end
+
+    #
+    # Extensions to allow instances to get at their class config, either raw or
+    # reduced to a useable format for a specific task.
+    module InstanceMethods
+      # Instance method extensions
+      def resource_path
+        self.class.resource_path
+      end
+
+      def type(arg)
+        self.class.type(arg)
+      end
+
+      def get_type
+        self.class.get_type
+      end
+
+      def fields
+        self.class.fields
+      end
+
+      def field_names
+        self.class.field_names
+      end
+
+      def persisted?
+        !self.id.nil?
+      end
+
+      def read_only_attributes
+        self.class.read_only_attributes(persisted?)
+      end
+
+      #
+      # Return the names of each field configured as a date type
+      def date_fields
+        self.class.date_fields
+      end
+
+      def to_key
+        key = respond_to?(:id) && id
+        key ? [key] : nil
+      end
+    end
+  end
+end

data/lib/alula/resources/admin_user.rb

@@ -0,0 +1,207 @@
+module Alula
+  class AdminUser < Alula::User
+    extend Alula::ResourceAttributes
+    extend Alula::RelationshipAttributes
+    extend Alula::ApiOperations::Request
+    extend Alula::ApiOperations::List
+    extend Alula::ApiOperations::Save
+
+    resource_path 'admins/users'
+    type 'admins-users'
+
+    relationship :devices, type: 'devices', cardinality: 'To-many'
+    relationship :dealer, type: 'dealers', cardinality: 'To-one'
+    relationship :phone, type: 'users-phones', cardinality: 'To-one'
+    relationship :address, type: 'users-addresses', cardinality: 'To-one'
+    relationship :pushtokens, type: 'users-pushtokens', cardinality: 'To-many'
+    relationship :preferences, type: 'users-preferences', cardinality: 'To-one'
+    relationship :videoprofiles, type: 'users-videoprofiles', cardinality: 'To-many'
+
+    # Resource Fields
+    # Not all params are used at the moment. See Alula::ResourceAttributes for details
+    # on how params are parsed,
+    field :id,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :username,
+          type: :string,
+          sortable: true,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: [:system, :station, :dealer, :technician, :user, :sub_user]
+
+    field :password,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: []
+
+    field :u_type,
+          type: :string,
+          sortable: false,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: []
+
+    field :user_type,
+          type: :string,
+          sortable: false,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: [],
+          symbolize: true
+
+    field :u_level,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :parent_id,
+          type: :string,
+          sortable: false,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: []
+
+    field :dealer_id,
+          type: :string,
+          sortable: false,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: []
+
+    field :station_id,
+          type: :string,
+          sortable: false,
+          filterable: true,
+          creatable_by: [],
+          patchable_by: []
+
+    field :last_login,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :date_entered,
+          type: :date,
+          sortable: true,
+          filterable: true,
+          creatable_by: [],
+          patchable_by: []
+
+    field :date_modified,
+          type: :date,
+          sortable: true,
+          filterable: true,
+          creatable_by: [],
+          patchable_by: []
+
+    field :entered_by,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :modified_by,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :pwch,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :features_selected,
+          type: :object,
+          sortable: false,
+          filterable: false,
+          creatable_by: [:system, :station, :dealer, :technician],
+          patchable_by: [:system, :station, :dealer, :technician]
+
+    field :eula,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: [:system, :station, :dealer, :technician, :user, :sub_user]
+
+    field :def_mod,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :rg_activated,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :company_name,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :name_first,
+          type: :string,
+          sortable: true,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: [:system, :station, :dealer, :technician, :user, :sub_user]
+
+    field :name_last,
+          type: :string,
+          sortable: true,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: [:system, :station, :dealer, :technician, :user, :sub_user]
+
+    field :email,
+          type: :string,
+          sortable: true,
+          filterable: true,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: [:system, :station, :dealer, :technician, :user, :sub_user]
+
+    field :time_offset,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :timezone,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [:system, :station, :dealer, :technician, :user],
+          patchable_by: [:system, :station, :dealer, :technician, :user, :sub_user]
+
+    field :hidden,
+          type: :boolean,
+          sortable: true,
+          filterable: true,
+          creatable_by: [:system],
+          patchable_by: [:system]
+
+  end
+end

data/lib/alula/resources/billing_program.rb

@@ -0,0 +1,41 @@
+module Alula
+  class BillingProgram < Alula::RestResource
+    extend Alula::ResourceAttributes
+    extend Alula::ApiOperations::Request
+    extend Alula::ApiOperations::List
+
+    resource_path 'billing/programs'
+    type 'billing-program'
+
+    # Resource Fields
+    # Not all params are used at the moment. See Alula::ResourceAttributes for details
+    # on how params are parsed,
+    field :id,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :name,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+    
+    field :description,
+          type: :string,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+
+    field :params_schema,
+          type: :object,
+          sortable: false,
+          filterable: false,
+          creatable_by: [],
+          patchable_by: []
+  end
+end