lockstep_rails 0.3.22

checksums.yaml

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Vivek AG
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,216 @@
+# Lockstep
+A financial service SDK for rails for innovative accounting solutions providers.
+
+### Who are we?
+Lockstep automates accounting workflows to improve your operational efficiency and cash flow. Accelerate payments through automated customer communications, enhanced collections activity management, and innovative forecasting and reporting.
+
+### lockstep_rails
+lockstep_rails makes it easy to interact with lockstep.io's REST API. It adheres to the ActiveRecord pattern. LockstepRails is fully ActiveModel compliant, meaning you can use validations and Rails forms.
+
+Ruby/Rails developers should feel right at home.
+
+If you're used to `Lockstep::Contact.create(:email_address => "test@emaildomain.com")`, then this is for you.
+
+### Features
+*   ActiveRecord-like API, almost no learning curve
+*   Validations
+*   Rails forms and scaffolds **just work**
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lockstep_rails'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install lockstep_rails
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+# Usage
+
+### Available Records
+* Lockstep::Contact
+* Lockstep::Connection
+* Lockstep::Account
+* Lockstep::User
+* Lockstep::Note
+* Lockstep::Invoice
+* Lockstep::InvoiceSummary
+* Lockstep::CustomerSummary
+* Lockstep::Payments
+* Lockstep::PaymentSummary
+
+## ActiveModel Interfaces
+
+`lockstep_rails` supports the standard CRUD interface of ActiveRecord.
+
+### Create
+You can create a record by calling `new` or `create`
+
+```ruby
+Lockstep::Contact.create(email_address: "inbox@companyemail.com")
+```
+
+You can create records from associations as well. This will automatically association the relationship with the parent record
+```ruby
+connection = Lockstep::Connection.find(company_id: "17544da8-7be8-4ee2-8c62-cbd81428c68b")
+connection.contacts.create(email_address: "inbox@companyemail.com")
+```
+
+### Update
+Similar to ActiveRecord, you can update a record by calling `update`, `update_attributes` or `update_attribute`
+
+Examples:
+```ruby
+connection = Lockstep::Connection.find(company_id: "17544da8-7be8-4ee2-8c62-cbd81428c68b")
+connection.update(company_name: "New name")
+
+# Or
+connection.update_attributes(company_name: "New name")
+
+# Or
+connection.update_attribute(:company_name, "New name")
+```
+
+### Find
+Similar to ActiveRecord, you can find a record by calling `find`, `find_by` or `find_by_company_id`
+
+Examples:
+```ruby
+connection = Lockstep::Connection.find(company_id: "17544da8-7be8-4ee2-8c62-cbd81428c68b")
+connection.update(company_name: "New name")
+
+# Or
+connection.update_attributes(company_name: "New name")
+
+# Or
+connection.update_attribute(:company_name, "New name")
+```
+
+### Where
+Similar to ActiveRecord, you can search for records by calling `where`. 
+
+Unless you are accessing the record via `first`, you will have to call `execute` to fetch the records
+
+Examples:
+```ruby
+Lockstep::Connection.where(status: "Active").execute
+```
+
+#### Chaining
+You can chain queries while calling where.
+
+```ruby
+Lockstep::Connection.where(status: "Active").where(default_currency_code: "USD").execute
+```
+
+#### OR Query
+You can build an or query by calling `or`
+
+```ruby
+Lockstep::Connection.where(status: "Active").or(Lockstep::Connection.where(default_currency_code: "USD")).execute
+```
+
+#### Advanced Queries
+[Searchlight](https://developer.lockstep.io/docs/querying-with-searchlight) supports building complex comparisons in the query.
+
+| Suffice      | Searchlight Query     | Example                                           |
+|--------------|-----------------------|---------------------------------------------------|
+| _eq          | Equals                | where(name_eq: "Test Name")                       |
+| _gt          | Greater Than          | where(amount_gt: 100)                             |
+| _ge          | Greater Than Or Equal | where(amount_ge: 100)                             |
+| _lt          | Less Than             | where(amount_lt: 100)                             |
+| _le          | Less Than Or Equal    | where(amount_le: 100)                             |
+| _ne          | Not Equal             | where(name_ne: "tak")                             |
+| _in          | IN                    | where(name_in: ["tik", "tok"])                    |
+| _contains    | CONTAINS              | where(name_contains: "kit")                       |
+| _starts_with | STARTSWITH            | where(name_starts_with: "tik")                    |
+| _ends_with   | ENDSWITH              | where(name_ends_with: "tok")                      |
+| _is          | IS                    | where(name_is: nil) where(name_is: "NOT NULL")    |
+
+#### Searchlight Queries
+Using the rails standard queries generates searchlight compatible queries. 
+if you wish, you can always write raw [Searchlight](https://developer.lockstep.io/docs/querying-with-searchlight) queries by passing a string in the where block
+
+```ruby
+Lockstep::Connection.where("isActive is true OR default_currency_code in ('USD', 'INR')").execute
+```
+
+### Count
+You can fetch the count of available records by calling `count`
+
+```ruby
+Lockstep::Connection.count
+# 1000
+
+Lockstep::Connection.where(status: "Active").count
+# 100
+```
+
+### Limit
+You can limit the number of records being fetched by passing `limit`
+
+The default limit is 200.
+
+```ruby
+Lockstep::Connection.limit(100).execute
+
+Lockstep::Connection.where(status: "Active").limit(100).execute
+```
+
+### Pagination
+You can paginate the records by passing the `page`
+
+```ruby
+Lockstep::Connection.page(2).execute
+
+Lockstep::Connection.where(status: "Active").limit(100).page(2).execute
+```
+
+## Adding relationships with ActiveRecord
+If you would like to link the `Lockstep::ApiRecord` with an `ActiveRecord::Base`, you can do so by including `Lockstep::ActiveRecords::Association`
+
+This gives you access to 2 methods for defining relationships
+* lockstep_has_many
+* lockstep_belongs_to
+
+```ruby
+class User < ActiveRecord::Base
+  include Lockstep::ActiveRecords::Association
+
+  lockstep_has_many :connections, class_name: "Lockstep::Connection", primary_key: 'company_id', foreign_key: "lockstep_company_id"
+  lockstep_belongs_to :account, class_name: "Lockstep::Account", primary_key: 'company_id', foreign_key: "lockstep_company_id"
+  
+end
+```
+
+#### Loader
+You could define your own loader for fetching the records by passing a `loader` Proc
+
+```ruby
+class User < ActiveRecord::Base
+  include Lockstep::ActiveRecords::Association
+
+  lockstep_has_many :connections, class_name: "Lockstep::Connection", loader: -> (record) { Lockstep::Connection.where(is_active: true).where(company_id: record.lockstep_company_id) }
+  lockstep_belongs_to :account, class_name: "Lockstep::Account", loader: -> (record) { Lockstep::Account.where(is_active: true).first }
+  
+end
+```
+
+# Updating API Schema
+
+To update the schema to the latest one on https://api.dev.lockstep.io/swagger/v1/swagger.json, run
+
+```bash
+bundle exec rake update_api_schema
+```

data/Rakefile

@@ -0,0 +1,31 @@
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "LockstepRails"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.md")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+load "lib/tasks/update_api_schema.rake"
+
+task default: :test

data/app/concepts/lockstep/active_records/association.rb

@@ -0,0 +1,78 @@
+module Lockstep::ActiveRecords::Association
+  extend ActiveSupport::Concern
+
+  included do
+
+  end
+
+  class_methods do
+    def lockstep_has_many_relations
+      @lockstep_has_many_relations ||= {}
+    end
+
+    def lockstep_belongs_to_relations
+      @lockstep_belongs_to_relations ||= {}
+    end
+
+    def lockstep_has_many(attribute, class_name:, primary_key: 'lockstep_id', foreign_key: nil, polymorphic: nil, loader: nil)
+      lockstep_has_many_relations[attribute] = {
+        name: attribute, class_name: class_name, primary_key: primary_key,
+        foreign_key: foreign_key, polymorphic: polymorphic, loader: loader
+      }
+
+      define_method(attribute) do
+        return lockstep_attributes[attribute] unless lockstep_attributes[attribute].nil?
+        return nil if lockstep_loaded_associations.include?(attribute)
+
+        lockstep_loaded_associations << attribute
+
+        relation_config = self.class.lockstep_has_many_relations[attribute]
+        if relation_config[:loader].present?
+          lockstep_attributes[attribute] = relation_config[:loader].call(self)
+        else
+          query = { relation_config[:foreign_key] => self.send(relation_config[:primary_key]) }
+          if relation_config[:polymorphic]
+            polymorphic_config = Lockstep::RelationArray.has_many_polymorphic_attributes(self, relation_config[:polymorphic])
+            query.merge!(polymorphic_config)
+          end
+          related_objects = relation_config[:class_name].constantize.send(:where, query).execute
+          lockstep_attributes[attribute] = Lockstep::RelationArray.new self, related_objects, attribute, relation_config[:class_name]
+        end
+
+        lockstep_attributes[attribute]
+      end
+    end
+
+    def lockstep_belongs_to(attribute, class_name:, primary_key: nil, foreign_key: 'lockstep_id', polymorphic: nil, loader: nil)
+      lockstep_belongs_to_relations[attribute] = {
+        name: attribute, class_name: class_name, primary_key: primary_key,
+        foreign_key: foreign_key, polymorphic: polymorphic, loader: loader
+      }
+
+      define_method(attribute) do
+        return lockstep_attributes[attribute] unless lockstep_attributes[attribute].nil?
+        return nil if lockstep_loaded_associations.include?(attribute)
+
+        lockstep_loaded_associations << attribute
+
+        relation_config = self.class.lockstep_belongs_to_relations[attribute]
+        if relation_config[:loader].present?
+          lockstep_attributes[attribute] = relation_config[:loader].call(self)
+        else
+          lockstep_attributes[attribute] = relation_config[:class_name].constantize.send(:find_by, relation_config[:primary_key] => self.send(relation_config[:foreign_key]))
+        end
+
+        lockstep_attributes[attribute]
+      end
+    end
+  end
+
+  def lockstep_loaded_associations
+    @loaded_associations ||= []
+  end
+
+  def lockstep_attributes
+    @lockstep_attributes ||= {}
+  end
+
+end