lockstep_rails 0.3.22 → 0.3.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9061d2c0869b6f4178fcd240f0e1337b3cbdc62500d9c8922f9b6c73812359da
-  data.tar.gz: 2ca982684af590994f83a992494e527ef79a29b66102f27fe7021c4e39312e89
+  metadata.gz: e131b1c5966a23df01c75f0c00ba3de1431930d2f834c1ce0a0ee451d349791a
+  data.tar.gz: 7b671b5424eb5873d5bc1b3f654e62c78db6a0268ec25794c62d2592a4d91423
 SHA512:
-  metadata.gz: b7e815ea5d2b411df62b258454d57437cd569181d8da0a3f2fb62b7666aa45dad0181845631e7d0d6f1c0ac0e517dbb00aba1a20075e444bbb94897eb8be5dea
-  data.tar.gz: 107df8a7b2031c9bd00170a64eb0bb0b98e59f3332d3a8bed509b49883b94c2a102ed01db8efd73b8ccecb8f1227162d64950d0d01787c3a3389c6f40cfee4c2
+  metadata.gz: cc421846e47207c7373cd2b109b5b29d8d969099cc112e4b42c12013ddb1695064c1f67fe5ad5388812d6f85ca4a60f0bc34e1a0893d5660c5fd563508252032
+  data.tar.gz: 7d3187d4ef5b9e6f37571d0ce825265f63589a8f65674467f08f96fc31cfe419b1dad59cad8f1d187dccb582659f5bcdcbe9a0c24c925fb06253ce3a6c2755d4

data/app/concepts/lockstep/api_record.rb

@@ -1,15 +1,16 @@
-require "rubygems"
-require "bundler/setup"
-require "active_model"
-require "erb"
-require "dry-types"
-require "json"
-require "active_support/hash_with_indifferent_access"
-require "lockstep/query"
-require "lockstep/query_methods"
-require "lockstep/error"
-require "lockstep/exceptions"
-require "lockstep/relation_array"
+require 'rubygems'
+require 'bundler/setup'
+require 'active_model'
+require 'erb'
+require 'dry-types'
+require 'json'
+require 'active_support/hash_with_indifferent_access'
+require 'lockstep/query'
+require 'lockstep/query_methods'
+require 'lockstep/error'
+require 'lockstep/exceptions'
+require 'lockstep/relation_array'
+require 'pry'
 
 module Lockstep
   class ApiRecord
@@ -42,7 +43,7 @@ module Lockstep
     # @params [Hash], [Boolean] a `Hash` of attributes and a `Boolean` that should be false only if the object already exists
     # @return [Lockstep::ApiRecord] an object that subclasses `Parseresource::Base`
     def initialize(attributes = {}, new = true)
-      #attributes = HashWithIndifferentAccess.new(attributes)
+      # attributes = HashWithIndifferentAccess.new(attributes)
 
       if new
         @unsaved_attributes = attributes
@@ -85,7 +86,7 @@ module Lockstep
       fname = fname.to_sym
       class_eval do
         define_method(fname) do
-          val = get_attribute("#{fname}")
+          val = get_attribute(fname.to_s)
 
           # If enum, substitute with the enum key
           if val.present? && (enum = enum_config[fname]).present?
@@ -95,10 +96,10 @@ module Lockstep
           val
         end
       end
-      unless self.respond_to? "#{fname}="
+      unless respond_to? "#{fname}="
         class_eval do
           define_method("#{fname}=") do |val|
-            set_attribute("#{fname}", val)
+            set_attribute(fname.to_s, val)
 
             val
           end
@@ -125,7 +126,7 @@ module Lockstep
     def self.belongs_to(parent, config = {})
       config = config.with_indifferent_access
       class_name = config[:class_name]
-      raise "Class name cannot be empty in #{parent}: #{self.name}" if class_name.blank?
+      raise "Class name cannot be empty in #{parent}: #{name}" if class_name.blank?
 
       included = config[:included] || false
       primary_key = config[:primary_key]
@@ -139,7 +140,7 @@ module Lockstep
       belongs_to_relations[parent] = {
         name: parent, class_name: class_name,
         included: included, primary_key: primary_key, foreign_key: foreign_key,
-        loader: loader, polymorphic: polymorphic,
+        loader: loader, polymorphic: polymorphic
       }
 
       # define_method("build_#{parent}") do |attributes_hash|
@@ -156,7 +157,7 @@ module Lockstep
     def self.has_many(parent, config = {})
       config = config.with_indifferent_access
       class_name = config[:class_name]
-      raise "Class name cannot be empty in #{parent}: #{self.name}" if class_name.blank?
+      raise "Class name cannot be empty in #{parent}: #{name}" if class_name.blank?
 
       included = config[:included] || false
       primary_key = config[:primary_key]
@@ -164,13 +165,13 @@ module Lockstep
       polymorphic = config[:polymorphic]
       loader = config[:loader]
 
-      primary_key ||= self.id_ref
-      foreign_key ||= self.id_ref
+      primary_key ||= id_ref
+      foreign_key ||= id_ref
       field(parent)
       has_many_relations[parent] = {
         name: parent, class_name: class_name, included: included,
         primary_key: primary_key, foreign_key: foreign_key, polymorphic: polymorphic,
-        loader: loader,
+        loader: loader
       }
     end
 
@@ -182,46 +183,48 @@ module Lockstep
       schema.belongs_to_relations.each do |relation, config|
         params = {}
         config.except(:name).each { |k, v| params[k.to_sym] = v }
-        self.belongs_to(relation, params)
+        belongs_to(relation, params)
       end
 
       schema.has_many_relations.each do |relation, config|
         params = {}
         config.except(:name).each { |k, v| params[k.to_sym] = v }
-        self.has_many(relation, params)
+        has_many(relation, params)
       end
     end
 
     def to_pointer
       klass_name = self.class.model_name.to_s
-      { "__type" => "Pointer", "className" => klass_name.to_s, self.id_ref => self.id }
+      { '__type' => 'Pointer', 'className' => klass_name.to_s, id_ref => id }
     end
 
     def self.to_date_object(date)
       date = date.to_time if date.respond_to?(:to_time)
-      { "__type" => "Date", "iso" => date.getutc.iso8601 } if date && (date.is_a?(Date) || date.is_a?(DateTime) || date.is_a?(Time))
+      if date && (date.is_a?(Date) || date.is_a?(DateTime) || date.is_a?(Time))
+       date.getutc.iso8601(fraction_digits = 3)
+      end
     end
 
     # Creates setter methods for model fields
-    def create_setters!(k, v)
-      unless self.respond_to? "#{k}="
+    def create_setters!(k, _v)
+      unless respond_to? "#{k}="
         self.class.send(:define_method, "#{k}=") do |val|
-          set_attribute("#{k}", val)
+          set_attribute(k.to_s, val)
 
           val
         end
       end
     end
 
-    def method_missing(method, *args, &block)
-      raise StandardError.new("#{method} has not been defined for #{self.class.name}")
+    def method_missing(method, *_args)
+      raise StandardError, "#{method} has not been defined for #{self.class.name}"
       # super
     end
 
     def self.method_missing(method_name, *args)
       method_name = method_name.to_s
-      if method_name.start_with?("find_by_")
-        attrib = method_name.gsub(/^find_by_/, "")
+      if method_name.start_with?('find_by_')
+        attrib = method_name.gsub(/^find_by_/, '')
         finder_name = "find_all_by_#{attrib}"
 
         define_singleton_method(finder_name) do |target_value|
@@ -229,8 +232,8 @@ module Lockstep
         end
 
         send(finder_name, args[0])
-      elsif method_name.start_with?("find_all_by_")
-        attrib = method_name.gsub(/^find_all_by_/, "")
+      elsif method_name.start_with?('find_all_by_')
+        attrib = method_name.gsub(/^find_all_by_/, '')
         finder_name = "find_all_by_#{attrib}"
 
         define_singleton_method(finder_name) do |target_value|
@@ -244,10 +247,10 @@ module Lockstep
     end
 
     # Creates getter methods for model fields
-    def create_getters!(k, v)
-      unless self.respond_to? "#{k}"
-        self.class.send(:define_method, "#{k}") do
-          get_attribute("#{k}")
+    def create_getters!(k, _v)
+      unless respond_to? k.to_s
+        self.class.send(:define_method, k.to_s) do
+          get_attribute(k.to_s)
         end
       end
     end
@@ -283,19 +286,19 @@ module Lockstep
     #   end
     # end
 
-    def self.id_ref=(val)
-      @id_ref = val
+    class << self
+      attr_writer :id_ref
     end
 
     def self.id_ref
-      raise StandardError.new("id_ref has not been defined for #{self.name}") if @id_ref.blank?
+      raise StandardError, "id_ref has not been defined for #{name}" if @id_ref.blank?
 
       @id_ref
     end
 
     # Alias for id_ref. Used by polymorphic association
     def self.primary_key
-      self.id_ref
+      id_ref
     end
 
     def id_ref
@@ -308,8 +311,8 @@ module Lockstep
       @model_name_uri
     end
 
-    def self.model_name_uri
-      @model_name_uri
+    class << self
+      attr_reader :model_name_uri
     end
 
     def self.config
@@ -318,13 +321,16 @@ module Lockstep
 
     # Gets the current class's Lockstep.io base_uri
     def self.model_base_uri
-      raise StandardError.new("Cannot establish connection for auto-generated Schema. Create a new model if you want to retrieve data from Lockstep Platform") if self.name.starts_with?("Schema::")
-      raise StandardError.new("URL Path is not defined for #{self.name}") if model_name_uri.blank?
+      if name.starts_with?('Schema::')
+        raise StandardError,
+              'Cannot establish connection for auto-generated Schema. Create a new model if you want to retrieve data from Lockstep Platform'
+      end
+      raise StandardError, "URL Path is not defined for #{name}" if model_name_uri.blank?
 
       base_url = config[:base_url]
-      base_url += "/" unless base_url.ends_with?("/")
+      base_url += '/' unless base_url.ends_with?('/')
       base_url += model_name_uri
-      base_url += "/" unless base_url.ends_with?("/")
+      base_url += '/' unless base_url.ends_with?('/')
       base_url
     end
 
@@ -339,19 +345,19 @@ module Lockstep
     def self.resource
       # load_settings
 
-      #refactor to settings['app_id'] etc
+      # refactor to settings['app_id'] etc
       # app_id     = @@settings['app_id']
       # master_key = @@settings['master_key']
       # RestClient::Resource.new(self.model_base_uri, app_id, master_key)
-      Lockstep::Client.new(self.model_base_uri)
+      Lockstep::Client.new(model_base_uri)
     end
 
-    def self.query_path=(value)
-      @query_path = value
+    class << self
+      attr_writer :query_path
     end
 
     def self.query_path
-      @query_path || "query"
+      @query_path || 'query'
     end
 
     # Batch requests
@@ -396,6 +402,7 @@ module Lockstep
     def self.merge_all_attributes(objects, response)
       objects.each_with_index do |item, index|
         next unless response[index]
+
         new_attributes = response[index].transform_keys { |key| key.underscore }
         item.merge_attributes(new_attributes)
       end
@@ -417,7 +424,7 @@ module Lockstep
     # end
 
     def self.bulk_import(new_objects, slice_size = 20)
-      return true if new_objects.blank?
+      return [] if new_objects.blank?
 
       # Batch saves seem to fail if they're too big. We'll slice it up into multiple posts if they are.
       new_objects.each_slice(slice_size) do |objects|
@@ -425,46 +432,41 @@ module Lockstep
         batch_json = []
 
         objects.each do |item|
-          raise StandardError.new("Bulk Import cannot only create records at the moment. It cannot update records") unless item.new?
+          unless item.new?
+            raise StandardError,
+                  'Bulk Import cannot only create records at the moment. It cannot update records'
+          end
 
           batch_json << item.attributes_for_saving.transform_keys { |key| key.camelize(:lower) }
         end
 
-        resp = self.resource.post("", body: batch_json)
-        # TODO attach errors if resp code is 400
-
-        if resp.code.to_s == "400"
+        resp = resource.post('', body: batch_json)
+        # TODO: attach errors if resp code is 400
+        if resp.code != '200'
           # Error format in JSON
           #   "errors": {
           #     "[0].EmailAddress": [
           #       "The EmailAddress field is not a valid e-mail address."
           #     ]
           #   }
-          error_response = JSON.parse(resp.body)
-          errors = error_response["errors"]
-          errors.each do |key, messages|
-            splits = key.split(".")
-            attribute = splits.last&.underscore
-            # Remove the [] from the first split to get the position in integer
-            position = splits.first[1..(splits.first.size - 2)].to_i
-            messages.each do |message|
-              new_objects[position].errors.add attribute, ": #{message}"
-            end
+          if resp.code == '401'
+            raise Lockstep::Exceptions::UnauthorizedError, 'Unauthorized: Check your App ID & Master Key'
+          elsif resp.code == '400'
+            raise Lockstep::Exceptions::BadRequestError, JSON.parse(resp.body)
+          elsif resp.code == '404'
+            raise Lockstep::Exceptions::RecordNotFound, 'Resource not found in the Platfrom'
           end
-          return false
-        elsif resp.code.to_s != "200"
-          return false
         end
 
         response = JSON.parse(resp.body)
-        if response && response.is_a?(Array) && response.length == objects.length
-          # return response.map { |item|
-          #   Lockstep::Contact.new(item.transform_keys { |key| key.underscore }, false)
-          # }
-          merge_all_attributes(objects, response)
-        end
+        next unless response && response.is_a?(Array) && response.length == objects.length
+
+        # return response.map { |item|
+        #   Lockstep::Contact.new(item.transform_keys { |key| key.underscore }, false)
+        # }
+        merge_all_attributes(objects, response)
       end
-      true
+      new_objects
     end
 
     # def self.load_settings
@@ -516,8 +518,10 @@ module Lockstep
     # @return [Lockstep::ApiRecord] an object that subclasses Lockstep::ApiRecord.
     def self.find(id)
       raise Lockstep::Exceptions::RecordNotFound, "Couldn't find #{name} without an ID" if id.blank?
-      record = where(self.id_ref => id).first
+
+      record = where(id_ref => id).first
       raise Lockstep::Exceptions::RecordNotFound, "Couldn't find #{name} with id: #{id}" if record.blank?
+
       record
     end
 
@@ -525,13 +529,13 @@ module Lockstep
     #
     def self.find_by(*args)
       raise Lockstep::Exceptions::RecordNotFound, "Couldn't find an object without arguments" if args.blank?
+
       key, value = args.first.first
       unless valid_attribute?(key, raise_exception: true)
-        raise StandardError.new("Attribute '#{key}' has not been defined for #{self.name}")
+        raise StandardError, "Attribute '#{key}' has not been defined for #{name}"
       end
 
-      record = where(key => value).first
-      record
+      where(key => value).first
     end
 
     # Find a Lockstep::ApiRecord object by chaining #where method calls.
@@ -576,19 +580,17 @@ module Lockstep
       # Valid only if the record is not an API record.
       # Default scopes build queries using ApiRecord to avoid conflicts. In this case, the query results in an
       # exception as the fields wouldn't have been defined in the ApiRecord
-      return true if self.name == "Lockstep::ApiRecord"
+      return true if name == 'Lockstep::ApiRecord'
 
       attr = key.to_s
       Lockstep::Query::PREDICATES.keys.each do |predicate|
         if attr.end_with?(predicate)
-          attr = attr.gsub(predicate, "")
+          attr = attr.gsub(predicate, '')
           break
         end
       end
       valid = schema.has_key?(attr)
-      if raise_exception && !valid
-        raise StandardError.new("Attribute '#{attr}' has not been defined for #{self.name}")
-      end
+      raise StandardError, "Attribute '#{attr}' has not been defined for #{name}" if raise_exception && !valid
 
       valid
     end
@@ -613,19 +615,19 @@ module Lockstep
     # create RESTful resource for the specific Parse object
     # sends requests to [base_uri]/[classname]/[objectId]
     def instance_resource
-      self.class.resource["#{self.id}"]
+      self.class.resource[id.to_s]
     end
 
     def pointerize(hash)
       new_hash = {}
       hash.each do |k, v|
-        if v.respond_to?(:to_pointer)
-          new_hash[k] = v.to_pointer
-        elsif v.is_a?(Date) || v.is_a?(Time) || v.is_a?(DateTime)
-          new_hash[k] = self.class.to_date_object(v)
-        else
-          new_hash[k] = v
-        end
+        new_hash[k] = if v.respond_to?(:to_pointer)
+                        v.to_pointer
+                      elsif v.is_a?(Date) || v.is_a?(Time) || v.is_a?(DateTime)
+                        self.class.to_date_object(v)
+                      else
+                        v
+                      end
       end
       new_hash
     end
@@ -642,13 +644,13 @@ module Lockstep
       else
         false
       end
-    rescue
+    rescue StandardError
       false
     end
 
     def create
       attrs = attributes_for_saving.transform_keys { |key| key.camelize(:lower) }
-      resp = self.resource.post("", body: [attrs])
+      resp = resource.post('', body: [attrs])
       result = post_result(resp)
     end
 
@@ -659,7 +661,7 @@ module Lockstep
       # put_attrs = attributes_for_saving.to_json
 
       attrs = attributes_for_saving.transform_keys { |key| key.camelize(:lower) }
-      resp = self.resource.patch(self.id, body: attrs)
+      resp = resource.patch(id, body: attrs)
       result = post_result(resp)
     end
 
@@ -681,40 +683,40 @@ module Lockstep
       # the object nor the relations it contains. Make another request here.
       # TODO: @@has_many_relations structure has been changed from array to hash, need to evaluate the impact here
       if has_many_relations.keys.map { |relation| relation.to_s.to_sym }
-        #todo: make this a little smarter by checking if there are any Pointer objects in the objects attributes.
+        # TODO: make this a little smarter by checking if there are any Pointer objects in the objects attributes.
         # @attributes = self.class.to_s.constantize.where(:objectId => @attributes[self.id_ref]).first.attributes
-        @attributes = self.class.to_s.constantize.where(self.id_ref => @attributes[self.id_ref]).first.attributes
+        @attributes = self.class.to_s.constantize.where(id_ref => @attributes[id_ref]).first.attributes
       end
     end
 
     def post_result(resp)
-      if resp.code.to_s == "200" || resp.code.to_s == "201"
+      if resp.code.to_s == '200' || resp.code.to_s == '201'
         body = JSON.parse(resp.body)
         # Create method always responds with an array, whereas update responds with the object
         body = body.first if body.is_a?(Array)
 
         merge_attributes(body)
 
-        return true
-      elsif resp.code.to_s == "400"
+        true
+      elsif resp.code.to_s == '400'
         error_response = JSON.parse(resp.body)
-        errors = error_response["errors"]
+        errors = error_response['errors']
         errors.each do |key, messages|
-          attribute = key.split(".").last&.underscore
+          attribute = key.split('.').last&.underscore
           messages.each do |message|
             self.errors.add attribute, ": #{message}"
           end
         end
       else
         error_response = JSON.parse(resp.body)
-        if error_response["error"]
-          pe = LockstepError.new(error_response["code"], error_response["error"])
-        else
-          pe = LockstepError.new(resp.code.to_s)
-        end
+        pe = if error_response['error']
+               LockstepError.new(error_response['code'], error_response['error'])
+             else
+               LockstepError.new(resp.code.to_s)
+             end
         self.errors.add(pe.code.to_s.to_sym, pe.msg)
-        self.error_instances << pe
-        return false
+        error_instances << pe
+        false
       end
     end
 
@@ -724,9 +726,9 @@ module Lockstep
 
       put_attrs = relations_for_saving(put_attrs)
 
-      put_attrs.delete(self.id_ref)
-      put_attrs.delete("created")
-      put_attrs.delete("modified")
+      put_attrs.delete(id_ref)
+      put_attrs.delete('created')
+      put_attrs.delete('modified')
       put_attrs
     end
 
@@ -734,25 +736,28 @@ module Lockstep
       all_add_item_queries = {}
       all_remove_item_queries = {}
       @unsaved_attributes.each_pair do |key, value|
-        next if !value.is_a? Array
+        next unless value.is_a? Array
 
         # Go through the array in unsaved and check if they are in array in attributes (saved stuff)
         add_item_ops = []
         @unsaved_attributes[key].each do |item|
           found_item_in_saved = false
           @attributes[key].each do |item_in_saved|
-            if !!(defined? item.attributes) && item.attributes[self.id_ref] == item_in_saved.attributes[self.id_ref]
+            if !!(defined? item.attributes) && item.attributes[id_ref] == item_in_saved.attributes[id_ref]
               found_item_in_saved = true
             end
           end
 
-          if !found_item_in_saved && !!(defined? item.id)
-            # need to send additem operation to parse
-            put_attrs.delete(key) # arrays should not be sent along with REST to parse api
-            add_item_ops << { "__type" => "Pointer", "className" => item.class.to_s, self.id_ref => item.id }
-          end
+          next unless !found_item_in_saved && !!(defined? item.id)
+
+          # need to send additem operation to parse
+          put_attrs.delete(key) # arrays should not be sent along with REST to parse api
+          add_item_ops << { '__type' => 'Pointer', 'className' => item.class.to_s, id_ref => item.id }
+        end
+        unless add_item_ops.empty?
+          all_add_item_queries.merge!({ key => { '__op' => 'Add',
+                                                 'objects' => add_item_ops } })
         end
-        all_add_item_queries.merge!({ key => { "__op" => "Add", "objects" => add_item_ops } }) if !add_item_ops.empty?
 
         # Go through saved and if it isn't in unsaved perform a removeitem operation
         remove_item_ops = []
@@ -760,28 +765,31 @@ module Lockstep
           @attributes[key].each do |item|
             found_item_in_unsaved = false
             @unsaved_attributes[key].each do |item_in_unsaved|
-              if !!(defined? item.attributes) && item.attributes[self.id_ref] == item_in_unsaved.attributes[self.id_ref]
+              if !!(defined? item.attributes) && item.attributes[id_ref] == item_in_unsaved.attributes[id_ref]
                 found_item_in_unsaved = true
               end
             end
 
             if !found_item_in_unsaved && !!(defined? item.id)
               # need to send removeitem operation to parse
-              remove_item_ops << { "__type" => "Pointer", "className" => item.class.to_s, self.id_ref => item.id }
+              remove_item_ops << { '__type' => 'Pointer', 'className' => item.class.to_s, id_ref => item.id }
             end
           end
         end
-        all_remove_item_queries.merge!({ key => { "__op" => "Remove", "objects" => remove_item_ops } }) if !remove_item_ops.empty?
+        unless remove_item_ops.empty?
+          all_remove_item_queries.merge!({ key => { '__op' => 'Remove',
+                                                    'objects' => remove_item_ops } })
+        end
       end
 
-      # TODO figure out a more elegant way to get this working. the remove_item merge overwrites the add.
+      # TODO: figure out a more elegant way to get this working. the remove_item merge overwrites the add.
       # Use a seperate query to add objects to the relation.
-      #if !all_add_item_queries.empty?
+      # if !all_add_item_queries.empty?
       #  #result = self.instance_resource.put(all_add_item_queries.to_json, {:content_type => "application/json"}) do |resp, req, res, &block|
       #  #  return puts(resp, req, res, false, &block)
       #  #end
       #  puts result
-      #end
+      # end
 
       put_attrs.merge!(all_add_item_queries) unless all_add_item_queries.empty?
       put_attrs.merge!(all_remove_item_queries) unless all_remove_item_queries.empty?
@@ -789,17 +797,17 @@ module Lockstep
     end
 
     def update_attributes(attributes = {})
-      self.update(attributes)
+      update(attributes)
     end
 
     def update_attribute(key, value)
-      send(key.to_s + "=", value)
+      send(key.to_s + '=', value)
       update
     end
 
     def destroy
-      resp = self.resource.delete(self.id)
-      if resp.code.to_s == "200"
+      resp = resource.delete(id)
+      if resp.code.to_s == '200'
         @attributes = {}
         @unsaved_attributes = {}
         return true
@@ -812,7 +820,7 @@ module Lockstep
 
       fresh_object = self.class.find(id)
       @attributes = {}
-      @attributes.update(fresh_object.instance_variable_get("@attributes"))
+      @attributes.update(fresh_object.instance_variable_get('@attributes'))
       @unsaved_attributes = {}
 
       self
@@ -845,27 +853,30 @@ module Lockstep
       attrs = @unsaved_attributes[k.to_s] ? @unsaved_attributes : @attributes
       case attrs[k]
       when Hash
-        klass_name = attrs[k]["className"]
-        klass_name = "User" if klass_name == "_User"
-        case attrs[k]["__type"]
-        when "Pointer"
-          result = klass_name.to_s.constantize.find(attrs[k][self.id_ref])
-        when "Object"
+        klass_name = attrs[k]['className']
+        klass_name = 'User' if klass_name == '_User'
+        case attrs[k]['__type']
+        when 'Pointer'
+          result = klass_name.to_s.constantize.find(attrs[k][id_ref])
+        when 'Object'
           result = klass_name.to_s.constantize.new(attrs[k], false)
-        when "Date"
-          result = DateTime.parse(attrs[k]["iso"]).in_time_zone
-        when "File"
-          result = attrs[k]["url"]
-        when "Relation"
-          objects_related_to_self = klass_name.constantize.where("$relatedTo" => { "object" => { "__type" => "Pointer", "className" => self.class.to_s, self.id_ref => self.id }, "key" => k }).all
+        when 'Date'
+          result = DateTime.parse(attrs[k]['iso']).in_time_zone
+        when 'File'
+          result = attrs[k]['url']
+        when 'Relation'
+          objects_related_to_self = klass_name.constantize.where('$relatedTo' => {
+            'object' => { '__type' => 'Pointer',
+                          'className' => self.class.to_s, id_ref => id }, 'key' => k
+          }).all
           attrs[k] = Lockstep::RelationArray.new self, objects_related_to_self, k, klass_name
           @unsaved_attributes[k] = Lockstep::RelationArray.new self, objects_related_to_self, k, klass_name
           result = @unsaved_attributes[k]
         end
       else
-        # TODO changed from @@has_many_relations to @@has_many_relations.keys as we have changed the has_many_relations
+        # TODO: changed from @@has_many_relations to @@has_many_relations.keys as we have changed the has_many_relations
         #     from array to hash to capture more data points. Not sure of the impact of this.
-        #relation will assign itself if an array, this will add to unsave_attributes
+        # relation will assign itself if an array, this will add to unsave_attributes
         if has_many_relations.keys.index(k.to_s)
           if attrs[k].nil?
             # result = nil
@@ -883,7 +894,7 @@ module Lockstep
             result = @unsaved_attributes[k]
           end
         else
-          result = attrs["#{k}"]
+          result = attrs[k.to_s]
         end
       end
       result
@@ -938,24 +949,28 @@ module Lockstep
     end
 
     def primary_key
-      self.id_ref
+      id_ref
     end
 
     # aliasing for idiomatic Ruby
     def id
-      get_attribute(self.id_ref) rescue nil
+      get_attribute(id_ref)
+    rescue StandardError
+      nil
     end
 
     def objectId
-      get_attribute(self.id_ref) rescue nil
+      get_attribute(id_ref)
+    rescue StandardError
+      nil
     end
 
     def created_at
-      get_attribute("created")
+      get_attribute('created')
     end
 
     def updated_at
-      get_attribute("modified")
+      get_attribute('modified')
     end
 
     def self.included(base)
@@ -965,10 +980,10 @@ module Lockstep
     module ClassMethods
     end
 
-    #if we are comparing objects, use id if they are both Lockstep::ApiRecord objects
-    def ==(another_object)
-      if another_object.class <= Lockstep::ApiRecord
-        self.id == another_object.id
+    # if we are comparing objects, use id if they are both Lockstep::ApiRecord objects
+    def ==(other)
+      if other.class <= Lockstep::ApiRecord
+        id == other.id
       else
         super
       end
@@ -989,12 +1004,14 @@ module Lockstep
           val = relation_config[:loader].call(self)
         else
           return val unless relation_config[:foreign_key].present? and relation_config[:primary_key].present?
+
           relation_klass = relation_config[:class_name].constantize
           return val unless relation_klass.model_name_uri.present?
 
-          query = { relation_config[:foreign_key] => self.send(relation_config[:primary_key]) }
+          query = { relation_config[:foreign_key] => send(relation_config[:primary_key]) }
           if relation_config[:polymorphic]
-            polymorphic_config = Lockstep::RelationArray.has_many_polymorphic_attributes(self, relation_config[:polymorphic])
+            polymorphic_config = Lockstep::RelationArray.has_many_polymorphic_attributes(self,
+                                                                                         relation_config[:polymorphic])
             query.merge!(polymorphic_config)
           end
           related_objects = relation_klass.send(:where, query).execute
@@ -1005,7 +1022,8 @@ module Lockstep
         if relation_config[:loader].present?
           val = relation_config[:loader].call(self)
         else
-          val = relation_config[:class_name].constantize.send(:find_by, relation_config[:primary_key] => self.send(relation_config[:foreign_key]))
+          val = relation_config[:class_name].constantize.send(:find_by,
+                                                              relation_config[:primary_key] => send(relation_config[:foreign_key]))
         end
       end
 
@@ -1060,7 +1078,7 @@ module Lockstep
         elsif values.is_a?(Hash)
           value_map = values.with_indifferent_access
         else
-          raise StandardError.new("Invalid values for enum #{attribute}")
+          raise StandardError, "Invalid values for enum #{attribute}"
         end
 
         # Convert values to string if the value is symbol
@@ -1089,9 +1107,21 @@ module Lockstep
         value = get_attribute(attribute)
         next if value.nil?
 
-        unless values_map.values.include?(value)
-          errors.add attribute, "has an invalid value"
-        end
+        errors.add attribute, 'has an invalid value' unless values_map.values.include?(value)
+      end
+    end
+
+    def self.single_record!
+      define_singleton_method :record do
+        resp = resource.get('')
+
+        return [] if %w(404).include?(resp.code.to_s)
+        # TODO handle non 200 response code. Throwing an exception for now
+        raise StandardError.new("#{resp.code} error while fetching: #{resp.body}") unless %w(201 200).include?(resp.code.to_s)
+
+        result = JSON.parse(resp.body)
+        r = result.transform_keys { |key| key.underscore }
+        model_name.to_s.constantize.new(r, false)
       end
     end
 
@@ -1111,7 +1141,7 @@ module Lockstep
       as_json(options).to_json
     end
 
-    def as_json(options = {})
+    def as_json(_options = {})
       @attributes.merge(@unsaved_attributes).as_json
     end
   end

data/app/concepts/lockstep/exceptions.rb

@@ -1,4 +1,5 @@
-class Lockstep::Exceptions
-  class Lockstep::Exceptions::RecordNotFound < ArgumentError
-  end
+module Lockstep::Exceptions
+  class UnauthorizedError < StandardError; end
+  class BadRequestError < StandardError; end
+  class RecordNotFound < StandardError; end
 end

data/app/concepts/lockstep/query.rb

@@ -225,11 +225,15 @@ class Lockstep::Query
     # TODO handle non 200 response code. Throwing an exception for now
     raise StandardError.new("#{resp.code} error while fetching: #{resp.body}") unless %w(201 200).include?(resp.code.to_s)
 
+    parsed_response = JSON.parse(resp.body)
+
     if criteria[:count]
-      results = JSON.parse(resp.body)["totalCount"]
+      raise StandardError.new("Count is not supported for #{@klass}") if parsed_response.is_a?(Array)
+
+      results = parsed_response["totalCount"]
       return results.to_i
     else
-      results = JSON.parse(resp.body)["records"]
+      results = parsed_response.is_a?(Array) ? parsed_response : parsed_response["records"]
       results = results[0..(criteria[:limit] - 1)] if criteria[:limit]
       get_relation_objects results.map { |r|
         # Convert camelcase to snake-case

data/app/models/lockstep/report_ar_aging_header.rb

@@ -0,0 +1,7 @@
+class Lockstep::ReportArAgingHeader < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Reports/ar-aging-header"
+  self.id_ref = "group_key"
+  self.query_path=""
+  load_schema(Schema::ArAgingHeaderInfo)
+
+end

data/app/models/lockstep/report_cashflow.rb

@@ -0,0 +1,7 @@
+class Lockstep::ReportCashflow < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Reports/cashflow"
+  self.query_path=""
+  load_schema(Schema::CashflowReport)
+  single_record!
+
+end

data/app/models/lockstep/report_daily_sales_outstanding.rb

@@ -0,0 +1,6 @@
+class Lockstep::ReportDailySalesOutstanding < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Reports/dailysalesoutstanding"
+  self.query_path=""
+  load_schema(Schema::DailySalesOutstandingReport)
+
+end

data/app/models/lockstep/report_risk_rate.rb

@@ -0,0 +1,7 @@
+class Lockstep::ReportRiskRate < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Reports/riskrates"
+  self.id_ref = "group_key"
+  self.query_path=""
+  load_schema(Schema::RiskRate)
+
+end

data/app/models/lockstep/vendor_summary.rb

@@ -0,0 +1,6 @@
+class Lockstep::VendorSummary < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Companies/views/vendor-summary"
+  self.id_ref = "vendor_id"
+  self.query_path = ""
+  load_schema(Schema::VendorSummary)
+end

data/app/models/lockstep/webhook.rb

@@ -0,0 +1,5 @@
+class Lockstep::Webhook < Lockstep::ApiRecord
+  self.model_name_uri = "/v1/Webhooks/"
+  self.id_ref = "webhook_id"
+  load_schema(Schema::Webhook)
+end

data/app/platform_api/schema/invoice.rb

@@ -1,21 +1,21 @@
 class Schema::Invoice < Lockstep::ApiRecord
 
-  # ApiRecord will crash unless `id_ref` is defined
-  def self.id_ref
-    nil
-  end
-
-  # The GroupKey uniquely identifies a single Lockstep Platform account.  All records for this
-  # account will share the same GroupKey value.  GroupKey values cannot be changed once created.
-  #
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # The GroupKey uniquely identifies a single Lockstep Platform account.  All records for this
+  # account will share the same GroupKey value.  GroupKey values cannot be changed once created.
+  #             
   # For more information, see [Accounts and GroupKeys](https://developer.lockstep.io/docs/accounts-and-groupkeys).
   # @type: string
   # @format: uuid
   field :group_key
 
-  # The unique ID of this record, automatically assigned by Lockstep when this record is
-  # added to the Lockstep platform.
-  #
+  # The unique ID of this record, automatically assigned by Lockstep when this record is
+  # added to the Lockstep platform.
+  #             
   # For the ID of this record in its originating financial system, see `ErpKey`.
   # @type: string
   # @format: uuid
@@ -31,23 +31,23 @@ class Schema::Invoice < Lockstep::ApiRecord
   # @format: uuid
   field :customer_id
 
-  # The unique ID of this record as it was known in its originating financial system.
-  #
-  # If this company record was imported from a financial system, it will have the value `ErpKey`
-  # set to the original primary key number of the record as it was known in the originating financial
-  # system.  If this record was not imported, this value will be `null`.
-  #
+  # The unique ID of this record as it was known in its originating financial system.
+  #             
+  # If this company record was imported from a financial system, it will have the value `ErpKey`
+  # set to the original primary key number of the record as it was known in the originating financial
+  # system.  If this record was not imported, this value will be `null`.
+  #             
   # For more information, see [Identity Columns](https://developer.lockstep.io/docs/identity-columns).
   # @type: string
   field :erp_key
 
-  # The "Purchase Order Code" is a code that is sometimes used by companies to refer to the original PO
-  # that was sent that caused this invoice to be written.  If a customer sends a purchase order to a vendor,
+  # The "Purchase Order Code" is a code that is sometimes used by companies to refer to the original PO
+  # that was sent that caused this invoice to be written.  If a customer sends a purchase order to a vendor,
   # the vendor can then create an invoice and refer back to the originating purchase order using this field.
   # @type: string
   field :purchase_order_code
 
-  # An additional reference code that is sometimes used to identify this invoice.
+  # An additional reference code that is sometimes used to identify this invoice.
   # The meaning of this field is specific to the ERP or accounting system used by the user.
   # @type: string
   field :reference_code
@@ -60,24 +60,24 @@ class Schema::Invoice < Lockstep::ApiRecord
   # @type: string
   field :salesperson_name
 
-  # A code identifying the type of this invoice.
-  #
-  # Recognized Invoice types are:
-  # * `Invoice` - Represents an invoice sent by Company to the Customer
-  # * `AP Invoice` - Represents an invoice sent by Customer to the Company
+  # A code identifying the type of this invoice.
+  #             
+  # Recognized Invoice types are:
+  # * `Invoice` - Represents an invoice sent by Company to the Customer
+  # * `AP Invoice` - Represents an invoice sent by Customer to the Company
   # * `Credit Memo` - Represents a credit memo generated by Customer given to Company
   # @type: string
   field :invoice_type_code
 
-  # A code identifying the status of this invoice.
-  #
-  # Recognized Invoice status codes are:
-  # * `Open` - Represents an invoice that is considered open and needs more work to complete
+  # A code identifying the status of this invoice.
+  #             
+  # Recognized Invoice status codes are:
+  # * `Open` - Represents an invoice that is considered open and needs more work to complete
   # * `Closed` - Represents an invoice that is considered closed and resolved
   # @type: string
   field :invoice_status_code
 
-  # A code identifying the terms given to the purchaser.  This field is imported directly from the originating
+  # A code identifying the terms given to the purchaser.  This field is imported directly from the originating
   # financial system and does not follow a specified format.
   # @type: string
   field :terms_code
@@ -125,7 +125,7 @@ class Schema::Invoice < Lockstep::ApiRecord
   # @format: date
   field :posted_date
 
-  # The date when the invoice was closed and finalized after completion of all payments and delivery of all products and
+  # The date when the invoice was closed and finalized after completion of all payments and delivery of all products and
   # services.
   # @type: string
   # @format: date
@@ -176,9 +176,9 @@ class Schema::Invoice < Lockstep::ApiRecord
   # @format: uuid
   field :modified_user_id
 
-  # The AppEnrollmentId of the application that imported this record.  For accounts
-  # with more than one financial system connected, this field identifies the originating
-  # financial system that produced this record.  This value is null if this record
+  # The AppEnrollmentId of the application that imported this record.  For accounts
+  # with more than one financial system connected, this field identifies the originating
+  # financial system that produced this record.  This value is null if this record
   # was not loaded from an external ERP or financial system.
   # @type: string
   # @format: uuid
@@ -196,31 +196,32 @@ class Schema::Invoice < Lockstep::ApiRecord
   # @type: boolean
   field :exclude_from_aging
 
-  # The Company associated to this invoice.
+  # The Company associated to this invoice.
   # To retrieve this item, specify `Company` in the "Include" parameter for your query.
   field :company
 
-  # The Customer associated to the invoice customer
+  # The Customer associated to the invoice customer
   # To retrieve this item, specify `Customer` in the "Include" parameter for your query.
   field :customer
 
-  # The Contact associated to the invoice customer
+  # The Contact associated to the invoice customer
   # To retrieve this item, specify `Customer` in the "Include" parameter for your query.
   field :customer_primary_contact
 
-  belongs_to :company, { :class_name => "Lockstep::Account", :primary_key => :company_id, :foreign_key => "company_id" }
-  belongs_to :account, { :class_name => "Lockstep::Account", :primary_key => :company_id, :foreign_key => "company_id" }
-  belongs_to :customer, { :class_name => "Lockstep::Connection", :primary_key => :company_id, :foreign_key => "customer_id" }
-  belongs_to :connection, { :class_name => "Lockstep::Connection", :primary_key => :company_id, :foreign_key => "customer_id" }
-  belongs_to :created_user, { :class_name => "Lockstep::User", :primary_key => :user_id, :foreign_key => "created_user_id" }
-  belongs_to :modified_user, { :class_name => "Lockstep::User", :primary_key => :user_id, :foreign_key => "modified_user_id" }
-
-  has_many :addresses, { :class_name => "Schema::InvoiceAddress", :included => true }
-  has_many :lines, { :class_name => "Schema::InvoiceLine", :included => true }
-  has_many :payments, { :class_name => "Schema::InvoicePaymentDetail", :included => true }
-  has_many :notes, { :class_name => "Lockstep::Note", :included => true, :foreign_key => :object_key, :polymorphic => { :table_key => "Invoice" } }
-  has_many :attachments, { :class_name => "Schema::Attachment", :included => true }
-  has_many :credit_memos, { :class_name => "Schema::CreditMemoInvoice", :included => true }
-  has_many :custom_field_values, { :class_name => "Schema::CustomFieldValue", :included => true }
-  has_many :custom_field_definitions, { :class_name => "Schema::CustomFieldDefinition", :included => true }
-end
+  belongs_to :company, {:class_name=>"Lockstep::Account", :primary_key=>:company_id, :foreign_key=>"company_id"}
+  belongs_to :account, {:class_name=>"Lockstep::Account", :primary_key=>:company_id, :foreign_key=>"company_id"}
+  belongs_to :customer, {:class_name=>"Lockstep::Connection", :primary_key=>:company_id, :foreign_key=>"customer_id"}
+  belongs_to :connection, {:class_name=>"Lockstep::Connection", :primary_key=>:company_id, :foreign_key=>"customer_id"}
+  belongs_to :created_user, {:class_name=>"Lockstep::User", :primary_key=>:user_id, :foreign_key=>"created_user_id"}
+  belongs_to :modified_user, {:class_name=>"Lockstep::User", :primary_key=>:user_id, :foreign_key=>"modified_user_id"}
+
+  has_many :addresses, {:class_name=>"Schema::InvoiceAddress", :included=>true}
+  has_many :lines, {:class_name=>"Schema::InvoiceLine", :included=>true}
+  has_many :payments, {:class_name=>"Schema::InvoicePaymentDetail", :included=>true}
+  has_many :notes, {:class_name=>"Lockstep::Note", :included=>true, :foreign_key=>:object_key, :polymorphic=>{:table_key=>"Invoice"}}
+  has_many :attachments, {:class_name=>"Schema::Attachment", :included=>true}
+  has_many :credit_memos, {:class_name=>"Schema::CreditMemoInvoice", :included=>true}
+  has_many :custom_field_values, {:class_name=>"Schema::CustomFieldValue", :included=>true}
+  has_many :custom_field_definitions, {:class_name=>"Schema::CustomFieldDefinition", :included=>true}
+
+end

data/app/platform_api/schema/vendor_summary.rb

@@ -0,0 +1,78 @@
+class Schema::VendorSummary < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # The GroupKey uniquely identifies a single Lockstep Platform account.  All records for this
+  # account will share the same GroupKey value.  GroupKey values cannot be changed once created.
+  # 
+  # For more information, see [Accounts and GroupKeys](https://developer.lockstep.io/docs/accounts-and-groupkeys).
+  # @type: string
+  # @format: uuid
+  field :group_key
+
+  # The unique ID of this company.
+  # @type: string
+  # @format: uuid
+  field :vendor_id
+
+  # The name of the company.
+  # @type: string
+  field :vendor_name
+
+  # The app enrollment ID this Vendor is associated with
+  # @type: string
+  # @format: uuid
+  field :app_enrollment_id
+
+  # The name of this Vendor's primary contact
+  # @type: string
+  field :primary_contact_name
+
+  # This Vendor's primary contact id
+  # @type: string
+  # @format: uuid
+  field :primary_contact_id
+
+  # The amount paid to this Vendor in the last 30 days
+  # @type: double
+  field :amount_paid_last30
+
+  # The outstanding advance pay balance with this Vendor
+  # @type: number
+  # @format: double
+  field :advance_pay_outstanding
+
+  # The amount billed from this Vendor in the last 30 days
+  # @type: number
+  # @format: double
+  field :amount_billed_last30
+
+  # The outstanding balance with this Vendor
+  # @type: number
+  # @format: double
+  field :amount_billed_outstanding
+
+  # The number of open bills with this Vendor
+  # @type: integer
+  # @format: int32
+  field :open_bill_count
+
+  # The number of bills paid to this Vendor in the last 30 days
+  # @type: integer
+  # @format: int32
+  field :paid_bill_count
+
+  # The total count of open bills and those paid in the last 30 days
+  # @type: integer
+  # @format: int32
+  field :total_bill_count
+
+
+  belongs_to :company, {:class_name=>"Lockstep::Account", :primary_key=>:company_id, :foreign_key=>"company_id"}
+  belongs_to :account, {:class_name=>"Lockstep::Account", :primary_key=>:company_id, :foreign_key=>"company_id"}
+
+
+end

data/app/platform_api/schema/webhook.rb

@@ -5,15 +5,15 @@ def self.id_ref
   nil
 end
 
-  # The unique ID of this record, automatically assigned by Lockstep when this record is
+  # The unique ID of this record, automatically assigned by Lockstep when this record is
   # added to the Lockstep platform.
   # @type: string
   # @format: uuid
   field :webhook_id
 
-  # The GroupKey uniquely identifies a single Lockstep Platform account.  All records for this
-  # account will share the same GroupKey value.  GroupKey values cannot be changed once created.
-  #             
+  # The GroupKey uniquely identifies a single Lockstep Platform account.  All records for this
+  # account will share the same GroupKey value.  GroupKey values cannot be changed once created.
+  #             
   # For more information, see [Accounts and GroupKeys](https://developer.lockstep.io/docs/accounts-and-groupkeys).
   # @type: string
   # @format: uuid
@@ -31,7 +31,7 @@ end
   # @type: string
   field :status_message
 
-  # An secret set during webhook creation that can be used to verify that the notification
+  # An secret set during webhook creation that can be used to verify that the notification
   # is coming from the Lockstep API.
   # @type: string
   field :client_secret
@@ -44,17 +44,17 @@ end
   # @type: string
   field :callback_http_method
 
-  # The URL where the notification will be sent via the method set in CallbackHttpMethod.
-  #             
-  # When creating a webhook, the Lockstep API will make a call to this url via the method
-  # set in the CallbackHttpMethod property with a query parameter of "code" set to an encoded
-  # string. To successfully create the webhook, the call must return a successful status code
+  # The URL where the notification will be sent via the method set in CallbackHttpMethod.
+  #             
+  # When creating a webhook, the Lockstep API will make a call to this url via the method
+  # set in the CallbackHttpMethod property with a query parameter of "code" set to an encoded
+  # string. To successfully create the webhook, the call must return a successful status code
   # with the query parameter's value as the plain text content.
   # @type: string
   # @format: uri
   field :callback_url
 
-  # The expiration date for the given webhook subscription. Once the expiration date passes,
+  # The expiration date for the given webhook subscription. Once the expiration date passes,
   # notifications will no longer be sent to the callback url.
   # @type: string
   # @format: date-time

data/lib/lockstep_rails/version.rb

@@ -1,3 +1,3 @@
 module LockstepRails
-  VERSION = "0.3.22"
+  VERSION = "0.3.26"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lockstep_rails
 version: !ruby/object:Gem::Version
-  version: 0.3.22
+  version: 0.3.26
 platform: ruby
 authors:
 - Vivek AG
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-15 00:00:00.000000000 Z
+date: 2022-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -55,7 +55,13 @@ files:
 - app/models/lockstep/note.rb
 - app/models/lockstep/payment.rb
 - app/models/lockstep/payment_summary.rb
+- app/models/lockstep/report_ar_aging_header.rb
+- app/models/lockstep/report_cashflow.rb
+- app/models/lockstep/report_daily_sales_outstanding.rb
+- app/models/lockstep/report_risk_rate.rb
 - app/models/lockstep/user.rb
+- app/models/lockstep/vendor_summary.rb
+- app/models/lockstep/webhook.rb
 - app/platform_api/model_template.rb.erb
 - app/platform_api/schema/action_result.rb
 - app/platform_api/schema/activity.rb
@@ -192,6 +198,7 @@ files:
 - app/platform_api/schema/user_account_fetch_result.rb
 - app/platform_api/schema/user_role.rb
 - app/platform_api/schema/user_role_fetch_result.rb
+- app/platform_api/schema/vendor_summary.rb
 - app/platform_api/schema/webhook.rb
 - app/platform_api/schema/webhook_fetch_result.rb
 - app/platform_api/schema/webhook_history_table_storage.rb