accountability 0.1.1 → 0.2.1

data/app/models/accountability/account.rb

@@ -4,6 +4,7 @@ module Accountability
   class Account < ApplicationRecord
     belongs_to :billable, polymorphic: true
 
+    has_many :statements, dependent: :destroy
     has_many :order_groups, dependent: :destroy
     has_many :order_items, through: :order_groups, inverse_of: :account
     has_many :purchased_order_groups, -> { complete }, class_name: 'OrderGroup', inverse_of: :account
@@ -11,6 +12,22 @@ module Accountability
     has_many :payments, dependent: :nullify
     has_many :credits, dependent: :destroy
     has_many :debits, dependent: :destroy
+    has_many :billing_configurations, dependent: :destroy
+
+    enum statement_schedule: %i[end_of_month bi_weekly]
+
+    def build_billing_configuration_with_active_merchant_data(billing_configuration_params, **options)
+      billing_configuration = billing_configurations.build(billing_configuration_params)
+      # We don't want to run this too often as it does create a charge against the card when verify_card is true.
+      # so we'll only run this when the config is valid.
+      billing_configuration.store_active_merchant_data(**options) if billing_configuration.valid?
+      billing_configuration
+    end
+
+    def billable_record_name
+      name_method = Configuration.billable_name_column
+      billable.public_send(name_method)
+    end
 
     def balance
       accrued_credits = credits.sum(:amount)
@@ -19,10 +36,23 @@ module Accountability
       accrued_debits - accrued_credits
     end
 
+    def balanced?
+      balance >= 0.00
+    end
+
     def transactions
-      associated_credits = credits.includes(:product, :deductions)
+      associated_credits = credits.includes(:product, deductions: :discount).references(:order_item)
 
       Transactions.new(debits: debits, credits: associated_credits)
     end
+
+    def current_statement
+      latest_statement = statements.last
+
+      return if latest_statement.nil?
+      return if latest_statement.past?
+
+      latest_statement
+    end
   end
 end

data/app/models/accountability/application_record.rb

@@ -1,3 +1,27 @@
 class Accountability::ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
+
+  before_validation :validate_validatable_attributes
+  cattr_accessor :validatable_attribute_names, default: []
+
+  def self.validates_attributes(*attribute_names)
+    self.validatable_attribute_names = attribute_names
+  end
+
+  private
+
+  def validate_validatable_attributes
+    validatable_attribute_names.each do |attribute_name|
+      attribute = public_send attribute_name
+
+      next if attribute.blank?
+
+      attribute.validate
+
+      attribute.errors.each do |sub_attribute_name, error_message|
+        target = "#{attribute_name}.#{sub_attribute_name}".to_sym
+        errors.add target, error_message
+      end
+    end
+  end
 end

data/app/models/accountability/billing_configuration.rb

@@ -0,0 +1,41 @@
+module Accountability
+  class BillingConfiguration < ApplicationRecord
+    include Accountability::ActiveMerchantInterface
+    after_initialize :set_provider, if: :new_record?
+
+    belongs_to :account
+    has_many :payments, dependent: :restrict_with_error
+
+    attribute :billing_address, :billing_address, default: {}
+    attribute :active_merchant_data, :json, default: {}
+
+    enum provider: %i[unselected stripe]
+
+    scope :primary, -> { where primary: true }
+
+    validates :configuration_name, presence: true
+    validates :contact_first_name, :contact_last_name,
+              format: { with: Regex::LETTERS_AND_NUMBERS, message: :invalid }, presence: true
+    validates :contact_email, format: { with: Regex::EMAIL_ADDRESS, message: :invalid }
+    validates_attributes :billing_address
+
+    def contact_name
+      "#{contact_first_name} #{contact_last_name}"
+    end
+
+    def primary!
+      return if primary?
+
+      transaction do
+        account.billing_configurations.primary.update_all(primary: false) # rubocop:disable Rails/SkipsModelValidations
+        update!(primary: true)
+      end
+    end
+
+    private
+
+    def set_provider
+      self.provider = Configuration.payment_gateway[:provider]
+    end
+  end
+end

data/app/models/accountability/coupon.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Rails/HasAndBelongsToMany
+
 class Accountability::Coupon < ApplicationRecord
   has_and_belongs_to_many :products
   has_many :discounts, dependent: :restrict_with_error

data/app/models/accountability/credit.rb

@@ -1,46 +1,70 @@
 # A Credit represents a single charge to an Account
 # To preserve data integrity, credits should never be modified
 
-class Accountability::Credit < ApplicationRecord
-  before_validation :set_amount
+module Accountability
+  class Credit < ApplicationRecord
+    before_validation :set_amount, :set_statement
 
-  belongs_to :account
-  belongs_to :order_item
-  has_many :deductions, dependent: :destroy
-  has_one :product, through: :order_item, inverse_of: :credits
+    belongs_to :account
+    belongs_to :statement
+    belongs_to :order_item
+    has_many :deductions, dependent: :destroy
+    has_one :product, through: :order_item, inverse_of: :credits
 
-  validate :validate_amount_unchanged
+    validates :amount, :taxes, presence: true
+    validate :validate_amount_unchanged
 
-  delegate :name, to: :product, prefix: true
+    delegate :name, to: :product, prefix: true
 
-  def base_price
-    if new_record?
-      order_item.default_price
-    else
-      amount + total_deductions
+    def base_price
+      if new_record?
+        order_item.default_price
+      else
+        amount + total_deductions + taxes
+      end
     end
-  end
 
-  def total_deductions
-    if persisted?
-      deductions.sum(:amount)
-    else
-      deductions.map(&:amount).sum
+    def total_deductions
+      if persisted?
+        deductions.sum(:amount)
+      else
+        deductions.map(&:amount).sum
+      end
     end
-  end
 
-  private
+    private
 
-  def set_amount
-    return if persisted?
+    def set_amount
+      return if persisted?
 
-    self.amount = base_price - total_deductions
-  end
+      pre_tax_total = base_price - total_deductions
+
+      self.taxes = if product.tax_exempt?
+                     0.00
+                   else
+                     pre_tax_total * Configuration.tax_rate / 100
+                   end
+
+      self.amount = pre_tax_total - taxes
+    end
 
-  def validate_amount_unchanged
-    return if new_record?
-    return unless amount_changed?
+    def set_statement
+      return if statement.present?
 
-    errors.add(:amount, 'cannot be changed')
+      current_statement = account.current_statement
+
+      if current_statement.present?
+        self.statement = current_statement
+      else
+        build_statement account: account
+      end
+    end
+
+    def validate_amount_unchanged
+      return if new_record?
+      return unless amount_changed?
+
+      errors.add(:amount, 'cannot be changed')
+    end
   end
 end

data/app/models/accountability/debit.rb

@@ -1,5 +1,9 @@
+# We reset the account's :last_balanced_at after a debit is created.
+# It is very important to make sure that the value is always accurate.
+
 class Accountability::Debit < ApplicationRecord
   before_validation :set_amount
+  after_create :update_last_balanced_at!
 
   belongs_to :account
   belongs_to :payment, optional: true
@@ -11,4 +15,10 @@ class Accountability::Debit < ApplicationRecord
 
     self.amount = payment.amount
   end
+
+  def update_last_balanced_at!
+    return unless account.balanced?
+
+    account.update(last_balanced_at: created_at)
+  end
 end

data/app/models/accountability/inventory.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+
+# The InventoryItems class is conceptually comparable to ActiveRecord's CollectionProxy.
+# It provides an interface for interacting with inventory records within a product's scope.
+#
+# This is an improvement over the original approach of returning a source_class::ActiveRecord_Relation object which
+# lacked any information related to the Accountability::Product record itself.
+#
+# Usage:
+#   inventory = Inventory.new(product)
+#   inventory.active.count
+
+module Accountability
+  class Inventory
+    extend Forwardable
+
+    attr_accessor :product
+
+    def_delegators :product, :source_class, :source_scope, :offerable_template
+    def_delegators :collection, :to_s, :each, :first, :last, :sort_by, :any?, :none?, :count
+
+    def initialize(product, available_only: false)
+      @product = product
+      @scope_availability = available_only
+    end
+
+    def collection
+      records = source_class.where(**source_scope)
+      records = records.public_send(offerable_template.whitelist) if scope_availability?
+
+      records.map { |record| InventoryItem.new(record: record, product: product) }
+    end
+
+    def available
+      @scope_availability = true
+
+      self
+    end
+
+    private
+
+    class InventoryItem
+      attr_accessor :record, :product
+
+      def initialize(record:, product:)
+        @record = record
+        @product = product
+      end
+
+      def price
+        product.price
+      end
+    end
+
+    private
+
+    def scope_availability?
+      @scope_availability
+    end
+  end
+end

data/app/models/accountability/offerable.rb

@@ -2,7 +2,7 @@
 
 class Accountability::Offerable
   cattr_accessor :collection, default: {}
-  attr_accessor :tenant, :category, :class_name, :trait, :scopes, :properties, :callbacks
+  attr_accessor :tenant, :category, :class_name, :trait, :scopes, :properties, :callbacks, :whitelist
 
   def initialize(category, tenant: :default, trait: nil, class_name:)
     @category = category
@@ -12,6 +12,7 @@ class Accountability::Offerable
     @scopes = {}
     @properties = {}
     @callbacks = {}
+    @whitelist = :all
   end
 
   def self.add(category, tenant: :default, trait: nil, class_name:)
@@ -22,18 +23,44 @@ class Accountability::Offerable
     offerable
   end
 
+  # Used when creating a product to define queries identifying saleable records from the host table.
+  # This can be used to de-scope sold inventory, but it is recommended to define a whitelist for that instead.
+  #
+  # CONSIDER: Add a parameter for indicating optional scopes
   def add_scope(name, title: name, options: :auto)
     scopes[name] = { title: title.to_s, options: options, category: category }
 
     self
   end
 
+  # Used for limiting the product's full inventory scope to a subset.
+  # Non-whitelisted records will be treated the same as a private product's inventory.
+  #
+  # The method takes the name of a pre-defined ActiveRecord scope as an argument.
+  # If no whitelist is specified, :all will be used instead.
+  def inventory_whitelist(whitelist_scope)
+    self.whitelist = whitelist_scope.to_sym
+
+    self
+  end
+
+  # Used to differentiate records within a product's scope/inventory.
+  # For example, consider a co-location that allows customers to choose their own cabinet:
+  #   `offer.add_property :cabinet_location_column, title: 'Asset Tag'`
+  #
+  # Use the `position` column if it is important that the properties display in a specific order.
+  #
+  # CONSIDER: Add support for property-specific pricing
   def add_property(name, title: name, position: nil)
     position = properties.size.next if position.nil?
     properties[name] = { title: title.to_s, position: position }
+
     self
   end
 
+  # Used for setting multiple properties in a single line.
+  # Column names will be used as titles, and property order retained.
+  # `offer.add_properties :asset_tag, :room_number, :color`
   def add_properties(*names)
     names.each do |name|
       add_property(name)

data/app/models/accountability/offerable/scope.rb

@@ -0,0 +1,48 @@
+# Scope objects represent an offerable's scoping options as defined by `offer.add_scope`
+# The plan is to replace the Offerable#scopes hash attribute with an array of scope objects
+
+class Accountability::Offerable::Scope
+  attr_accessor :source_class, :category, :attribute, :title
+  attr_writer :options
+
+  def initialize(source_class:, category:, attribute:, title: nil, options: :auto)
+    @source_class = source_class
+    @category = category
+    @attribute = attribute
+    @title = title.presence || attribute.to_s.titleize
+    @options = options
+  end
+
+  # Returns an array of values to choose from when defining the scope for a new product.
+  # The product's `source_scope` column stores a hash mapping each scopes' @attribute with the selected options.
+  #
+  # For example, if an offerable called 'Bucket' has a scoped :color attribute with options %w[red green black grey],
+  # a "colored bucket" product can be created with a `source_scope` of `{ color: %w[red green] }`.
+  # Buckets available for purchase would be automatically found by querying `Bucket.where(color: %w[red green])`.
+  #
+  # When an offerable's scope has no options, it defaults to `:auto` and is generated automatically based on the
+  # attribute type when `#options` is called instead.
+  #    String  - Returns a unique array of values plucked from the attribute's column
+  #    Enum    - Returns am array containing each valid enum value
+  #    Boolean - Returns [true, false]
+  # Any other attribute type will return an empty array.
+  def options
+    return @options unless @options == :auto
+
+    @options = case attribute_type
+               when ActiveModel::Type::String
+                 source_class.distinct.pluck(attribute)
+               when ActiveRecord::Enum::EnumType
+                 enums = source_class.defined_enums.with_indifferent_access
+                 enums[attribute].keys
+               when ActiveModel::Type::Boolean
+                 [true, false]
+               else
+                 []
+               end
+  end
+
+  def attribute_type
+    source_class.type_for_attribute(attribute)
+  end
+end

data/app/models/accountability/order_item.rb

@@ -33,14 +33,10 @@ class Accountability::OrderItem < ApplicationRecord
   def accruing?
     return false unless accruable?
     return true if credits.none?
+    return false if product.accrues_one_time?
 
-    threshold = case product.schedule
-                when 'weekly' then 1.week.ago
-                when 'monthly' then 1.month.ago
-                when 'annually' then 1.year.ago
-                end
-
-    last_accruement_date.before? threshold
+    billing_cycle_threshold = product.billing_cycle_length.ago
+    last_accruement_date.before? billing_cycle_threshold
   end
 
   def accruable?

data/app/models/accountability/payment.rb

@@ -1,8 +1,27 @@
-# TODO: Destroy associated debit when marked as failed
-
 class Accountability::Payment < ApplicationRecord
+  after_validation :process_transaction!, if: :pending?
+
   belongs_to :account
-  has_one :debit
+  belongs_to :billing_configuration
+
+  has_one :debit, dependent: :restrict_with_error
 
   enum status: %i[pending processing complete failed]
+
+  validates :amount, presence: true, numericality: { greater_than: 10.00 }
+
+  def process_transaction!
+    return if debit.present?
+    return if errors.present?
+
+    if billing_configuration.charge(amount)
+      self.status = :complete
+      build_debit(account: account, amount: amount)
+    elsif billing_configuration.invalid?
+      self.status = :failed
+      billing_configuration.errors.full_messages.each { |error| errors.add(:base, error.titleize) }
+    else
+      self.status = :failed
+    end
+  end
 end