lockstep_rails 0.3.22

data/app/concepts/lockstep/query_methods.rb

@@ -0,0 +1,75 @@
+#require 'parse_resource'
+require "lockstep/query"
+
+module Lockstep
+  module QueryMethods
+    module ClassMethods
+      def query_builder
+        @query_builder = Query.new(self)
+        unless scopes[:default_scope].nil?
+          @query_builder.criteria.deep_merge!(Lockstep::ApiRecord.instance_exec(&scopes[:default_scope]).criteria)
+        end
+
+        @query_builder
+      end
+
+      def unscoped
+        Query.new(self)
+      end
+
+      def none
+        query_builder.none
+      end
+
+      # Include the attributes of a parent ojbect in the results
+      # Similar to ActiveRecord eager loading
+      #
+      def include_object(*associations)
+        query_builder.include_object(*associations)
+      end
+
+      # Add this at the end of a method chain to get the count of objects, instead of an Array of objects
+      def count
+        #https://www.parse.com/docs/rest#queries-counting
+        query_builder.count
+      end
+
+      # Find all Lockstep::ApiRecord objects for that model.
+      #
+      # @return [Array] an `Array` of objects that subclass `Lockstep::ApiRecord`.
+      def all
+        query_builder.all
+      end
+
+      # Find the first object. Fairly random, not based on any specific condition.
+      #
+      def first
+        query_builder.limit(1).first
+      end
+
+      # Limits the number of objects returned
+      #
+      def limit(n)
+        query_builder.limit(n)
+      end
+
+      # Skip the number of objects
+      #
+      def page(n)
+        query_builder.page(n)
+      end
+
+      def order(*attr)
+        query_builder.order(*attr)
+      end
+
+      def reorder(*attr)
+        query_builder.reorder(*attr)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/app/concepts/lockstep/relation_array.rb

@@ -0,0 +1,100 @@
+class Lockstep::RelationArray < Array
+  attr_accessor :delegate, :key, :class_name
+
+  def initialize(delegate, items, key, class_name)
+    super(items)
+    self.delegate = delegate
+    self.key = key
+    self.class_name = class_name
+
+    class_eval do
+      define_method("#{key}_ids") do
+        each.map { |item| item.id }
+      end
+    end
+  end
+
+  def create(attributes_hash = {})
+    object = new(attributes_hash)
+    return false unless object.save
+
+    object
+  end
+
+  def new(attributes_hash = {})
+    # Assign the parent records primary_key to the foreign_key of the association
+    relation_config = delegate.class.lockstep_has_many_relations[key]
+    foreign_key = relation_config[:foreign_key]
+    primary_key = relation_config[:primary_key]
+    attributes_hash[foreign_key] = delegate.send(primary_key)
+    if relation_config[:polymorphic]
+      polymorphic_config = Lockstep::RelationArray.has_many_polymorphic_attributes(self, relation_config[:polymorphic])
+      attributes_hash.merge!(polymorphic_config) if polymorphic_config.is_a?(Hash)
+    end
+    object = self.class_name.constantize.new(attributes_hash)
+    self.push object
+
+    object
+  end
+
+  # @has_many_associations polymorphic properties builder.
+  # Polymorphic properties is used to further scope down the has_many association while querying or creating
+  #
+  def self.has_many_polymorphic_attributes(record, polymorphic_config)
+    return polymorphic_config if polymorphic_config.is_a?(Hash)
+    return record.instance_eval record, &polymorphic_config if polymorphic_config.is_a?(Proc)
+
+    nil
+  end
+
+  def <<(object)
+    if object.is_a? Hash
+      create(object)
+      return object
+    end
+
+    raise Exception.new("This relation only stores objects of type #{class_name.to_s.constantize}") if !object.is_a? class_name.to_s.constantize
+
+    super(object)
+    object
+  end
+
+  def push(object)
+    self << object
+  end
+
+  def delete(object)
+    if object.is_a? Hash
+      object_id = object["objectId"]
+    elsif object.is_a? String
+      object_id = object
+    else
+      object_id = object.id
+    end
+
+    self.each { |item| super(item) if item.id == object_id }
+  end
+
+  def contains?(object)
+    self.each { |item| return true if item.attributes == object.attributes }
+    false
+  end
+
+  def exists?(query)
+    each do |item|
+      conditions_met = true
+      item.attributes.each do |key, value|
+        conditions_met = false if query.has_key?(key) and query[key] != value
+        break
+      end
+      return true if conditions_met
+    end
+    false
+  end
+
+  def find(id_to_find)
+    each do |item|
+      return item if id_to_find == item.id
+    end
+  end
+end

data/app/helpers/types.rb

@@ -0,0 +1,3 @@
+module Types
+  include Dry.Types()
+end

data/app/models/lockstep/account.rb

@@ -0,0 +1,15 @@
+class Lockstep::Account < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Companies"
+  self.id_ref = "company_id"
+  load_schema(Schema::Company)
+
+  enum company_type: %w(Group)
+
+  has_many :connections, class_name: "Lockstep::Connection", included: false, loader: ->(account) { Lockstep::Connection.all }
+  has_many :contacts, class_name: "Lockstep::Contact", included: false, loader: ->(account) { Lockstep::Contact.all }
+  has_many :users, class_name: "Lockstep::User", included: false
+
+  validates :company_name, presence: true
+
+  default_scope { where(company_type: %w(Group)) }
+end

data/app/models/lockstep/connection.rb

@@ -0,0 +1,19 @@
+class Lockstep::Connection < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Companies"
+  self.id_ref = "company_id"
+  load_schema(Schema::Company)
+
+  enum company_type: %w(Customer Vendor)
+
+  has_many :contacts, class_name: "Lockstep::Contact", included: true
+  belongs_to :created_user, class_name: "Lockstep::User", foreign_key: :created_user_id, primary_key: :user_id
+  belongs_to :modified_user, class_name: "Lockstep::User", foreign_key: :modified_user_id, primary_key: :user_id
+
+  validates :company_name, presence: true
+
+  default_scope { where(company_type: %w(Customer Vendor)).or(where(company_type: nil)) }
+
+  scope :customers, -> { where(company_type: "Customer") }
+  scope :vendors, -> { where(company_type: "Vendor") }
+  scope :company_type_null, -> { where(company_type: nil) }
+end

data/app/models/lockstep/contact.rb

@@ -0,0 +1,9 @@
+class Lockstep::Contact < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Contacts"
+  self.id_ref = "contact_id"
+  load_schema(Schema::Contact)
+
+  validates :email_address, presence: true
+
+  belongs_to :connection, class_name: "Lockstep::Connection", included: false
+end

data/app/models/lockstep/customer_summary.rb

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

data/app/models/lockstep/invoice.rb

@@ -0,0 +1,7 @@
+class Lockstep::Invoice < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Invoices"
+  self.id_ref = "invoice_id"
+  load_schema(Schema::Invoice)
+
+  belongs_to :connection, class_name: "Lockstep::Connection", foreign_key: :customer_id
+end

data/app/models/lockstep/invoice_summary.rb

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

data/app/models/lockstep/invoices/address.rb

@@ -0,0 +1,24 @@
+class Lockstep::Invoices::Address < Lockstep::ApiRecord
+  self.id_ref = "invoice_address_id"
+
+  field :invoice_address_id
+  field :group_key
+  field :invoice_id
+  field :line1
+  field :line2
+  field :line3
+  field :city
+  field :region
+  field :postal_code
+  field :country
+  field :latitude
+  field :longitude
+  field :created, Types::Params::DateTime
+  field :created_user_id
+  field :modified, Types::Params::DateTime
+  field :modified_user_id
+  field :app_enrollment_id
+
+  belongs_to :created_user, class_name: "Lockstep::User", foreign_key: :created_user_id, primary_key: :user_id
+  belongs_to :modified_user, class_name: "Lockstep::User", foreign_key: :modified_user_id, primary_key: :user_id
+end

data/app/models/lockstep/note.rb

@@ -0,0 +1,7 @@
+class Lockstep::Note < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Notes"
+  self.id_ref = "note_id"
+  load_schema(Schema::Note)
+
+  belongs_to :created_user, class_name: "Lockstep::User", foreign_key: :created_user_id, primary_key: :user_id
+end

data/app/models/lockstep/payment.rb

@@ -0,0 +1,7 @@
+class Lockstep::Payment < Lockstep::ApiRecord
+  self.model_name_uri = "v1/Payments"
+  self.id_ref = "payment_id"
+  load_schema(Schema::Payment)
+
+  belongs_to :connection, class_name: "Lockstep::Connection", foreign_key: :company_id
+end

data/app/models/lockstep/payment_summary.rb

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

data/app/models/lockstep/user.rb

@@ -0,0 +1,10 @@
+class Lockstep::User < Lockstep::ApiRecord
+  self.model_name_uri = "v1/UserAccounts"
+  self.id_ref = "user_id"
+  load_schema(Schema::UserAccount)
+
+  # # Load the first account
+  belongs_to :account, class_name: "Lockstep::Account", loader: ->(user) { Lockstep::Account.first }
+
+  alias_attribute :last_logged_in, :b2_c_last_logged_in
+end

data/app/platform_api/model_template.rb.erb

@@ -0,0 +1,27 @@
+class Schema::<%= class_name %> < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+<% fields.each do |field_name, config| -%>
+  <%= config["description"].nil? ? nil : "# #{config['description'].gsub("\n", "\n  # ")}"%>
+<% if !config["type"].nil? -%>
+  # @type: <%= config["type"] %>
+<%end -%>
+<% if !config["format"].nil? -%>
+  # @format: <%= config["format"] %>
+<%end -%>
+  field :<%= field_name %><%= config["value_type"].nil? ? nil : ", #{config["value_type"]}"  %>
+
+<%end -%>
+<% belongs_to_relations.each do |relation, config| -%>
+  belongs_to :<%= relation %>, <%= config %>
+<%end -%>
+
+<% has_many_relations.each do |relation, config| -%>
+  has_many :<%= relation %>, <%= config %>
+<%end -%>
+
+end

data/app/platform_api/schema/action_result.rb

@@ -0,0 +1,15 @@
+class Schema::ActionResult < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # If the API call produced messages, this element will contain a list of user-visible
+  # text strings that contain information about what work occurred in the API.
+  # @type: array
+  field :messages
+
+
+
+end

data/app/platform_api/schema/activity.rb

@@ -0,0 +1,141 @@
+class Schema::Activity < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # The unique ID of this record, automatically assigned by Lockstep when this record is
+  # added to the Lockstep platform.
+  # @type: string
+  # @format: uuid
+  field :activity_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.
+  #             
+  # For more information, see [Accounts and GroupKeys](https://developer.lockstep.io/docs/accounts-and-groupkeys).
+  # @type: string
+  # @format: uuid
+  field :group_key
+
+  # The ID of the company to which this activity belongs.
+  # @type: string
+  # @format: uuid
+  field :company_id
+
+  # The type code of the activity
+  # @type: string
+  field :activity_type_code
+
+  # The name of the activity.  The name is a short name provided by the
+  # person who created the activity that can be displayed in a list.
+  # @type: string
+  field :activity_name
+
+  # A description of the activity.  This field contains more detailed text about the
+  # activity and can be lengthy.
+  # @type: string
+  field :activity_description
+
+  # The status of the activity.
+  # @type: string
+  field :activity_status
+
+  # True if this activity is currently "open", which indicates that the activity is
+  # currently in progress.
+  # @type: boolean
+  field :is_open
+
+  # The priority of the activity.
+  # @type: string
+  field :priority
+
+  # The ID of the user the activity is assigned to.
+  # @type: string
+  # @format: uuid
+  field :user_assigned_to
+
+  # The date the activity was assigned.
+  # @type: string
+  # @format: date-time
+  field :date_assigned, Types::Params::DateTime
+
+  # The date the activity was closed.
+  # @type: string
+  # @format: date-time
+  field :date_closed, Types::Params::DateTime
+
+  # If this activity has been "snoozed", this field will be non-null and will contain
+  # the date when the activity will be displayed.  Until that date arrives, the activity
+  # will remain hidden.
+  # @type: string
+  # @format: date-time
+  field :snooze_until_date, Types::Params::DateTime
+
+  # The date on which this activity was created.
+  # @type: string
+  # @format: date-time
+  field :created, Types::Params::DateTime
+
+  # The ID of the user who created this activity.
+  # @type: string
+  # @format: uuid
+  field :created_user_id
+
+  # The date on which this activity was last modified.
+  # @type: string
+  # @format: date-time
+  field :modified, Types::Params::DateTime
+
+  # The ID of the user who last modified this activity.
+  # @type: string
+  # @format: uuid
+  field :modified_user_id
+
+  # Amount collected (if any) for the activity.
+  # @type: number
+  # @format: double
+  field :amount_collected
+
+  # Amount paid (if any) for the activity.
+  # @type: number
+  # @format: double
+  field :amount_paid
+
+  # Credit given (if any) for the activity.
+  # @type: number
+  # @format: double
+  field :credit_given
+
+  # True if this activity is to be shown in an "unread" state.  When an activity
+  # is read by a person it is assigned to, this flag is set to false.
+  # @type: boolean
+  field :is_unread
+
+  # Activities may be archived when they should be hidden from the user.  When
+  # this flag is true, this activity should be hidden.
+  # @type: boolean
+  field :is_archived
+
+  # The company associated with the activity
+  #             
+  # To retrieve this collection, specify `Company` in the "Include" parameter for your query.
+  field :company
+
+  # The name of the user the activity is assigned to
+  # @type: string
+  field :user_assigned_to_name
+
+  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 :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 :attachments, {:class_name=>"Schema::Attachment", :included=>true}
+  has_many :notes, {:class_name=>"Lockstep::Note", :included=>true, :foreign_key=>:object_key, :polymorphic=>{:table_key=>"Activity"}}
+  has_many :custom_field_definitions, {:class_name=>"Schema::CustomFieldDefinition", :included=>true}
+  has_many :custom_field_values, {:class_name=>"Schema::CustomFieldValue", :included=>true}
+  has_many :references, {:class_name=>"Schema::ActivityXRef", :included=>true}
+
+end

data/app/platform_api/schema/activity_fetch_result.rb

@@ -0,0 +1,26 @@
+class Schema::ActivityFetchResult < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  
+  # @type: integer
+  # @format: int32
+  field :total_count
+
+  
+  # @type: integer
+  # @format: int32
+  field :page_size
+
+  
+  # @type: integer
+  # @format: int32
+  field :page_number
+
+
+  has_many :records, {:class_name=>"Schema::Activity", :included=>true}
+
+end

data/app/platform_api/schema/activity_stream_item.rb

@@ -0,0 +1,58 @@
+class Schema::ActivityStreamItem < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # The object key of the activity stream item.
+  # @type: string
+  # @format: uuid
+  field :object_key
+
+  # The type code of the activity stream item.
+  # @type: string
+  field :activity_stream_type
+
+  # The text body description for this Activity Stream Item.
+  # @type: string
+  field :text_value
+
+  # The date on which this activity stream item was created.
+  # @type: string
+  # @format: date-time
+  field :created, Types::Params::DateTime
+
+  # The ID of the user who created this activity.
+  # @type: string
+  # @format: uuid
+  field :created_user_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.
+  #             
+  # For more information, see [Accounts and GroupKeys](https://developer.lockstep.io/docs/accounts-and-groupkeys).
+  # @type: string
+  # @format: uuid
+  field :group_key
+
+  # The sender's email address if activity stream item is an Email.
+  # @type: string
+  field :from_email_address
+
+  # The recipient's email address if activity stream item is an Email.
+  # @type: string
+  field :to_email_address
+
+  # The name of the contact sending the activity otherwise null.
+  # @type: string
+  field :from_contact_name
+
+  # The name of the contact sending the activity otherwise null.
+  # @type: string
+  field :to_contact_name
+
+  belongs_to :created_user, {:class_name=>"Lockstep::User", :primary_key=>:user_id, :foreign_key=>"created_user_id"}
+
+
+end

data/app/platform_api/schema/activity_x_ref.rb

@@ -0,0 +1,37 @@
+class Schema::ActivityXRef < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # The unique ID of this record, automatically assigned by Lockstep when this is
+  # added to the Lockstep platform.
+  # @type: string
+  # @format: uuid
+  field :activity_x_ref_id
+
+  # The ID of the activity to which this reference belongs.
+  # @type: string
+  # @format: uuid
+  field :activity_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.
+  #             
+  # For more information, see [Accounts and GroupKeys](https://developer.lockstep.io/docs/accounts-and-groupkeys).
+  # @type: string
+  # @format: uuid
+  field :group_key
+
+  # The name of the table the activity reference is associated with
+  # @type: string
+  field :table_key
+
+  # The ID of the object the activity reference is associated with
+  # @type: string
+  field :object_key
+
+
+
+end

data/app/platform_api/schema/aging.rb

@@ -0,0 +1,24 @@
+class Schema::Aging < Lockstep::ApiRecord
+
+# ApiRecord will crash unless `id_ref` is defined
+def self.id_ref
+  nil
+end
+
+  # Aging bucket of outstanding balance data (days past due date of invoice)
+  # @type: integer
+  # @format: int32
+  field :bucket
+
+  # Currency code of aging bucket
+  # @type: string
+  field :currency_code
+
+  # Outstanding balance for the given aging bucket
+  # @type: number
+  # @format: double
+  field :outstanding_balance
+
+
+
+end