accountability 0.1.0 → 0.1.1

data/app/models/accountability/debit.rb

@@ -0,0 +1,14 @@
+class Accountability::Debit < ApplicationRecord
+  before_validation :set_amount
+
+  belongs_to :account
+  belongs_to :payment, optional: true
+
+  private
+
+  def set_amount
+    return unless amount.zero?
+
+    self.amount = payment.amount
+  end
+end

data/app/models/accountability/deduction.rb

@@ -0,0 +1,17 @@
+class Accountability::Deduction < ApplicationRecord
+  belongs_to :discount
+  belongs_to :credit
+  has_one :coupon, through: :discount, inverse_of: :deductions
+
+  after_initialize :set_amount
+
+  delegate :name, to: :coupon, prefix: true
+
+  private
+
+  def set_amount
+    return if amount.positive?
+
+    self.amount = discount.expected_savings
+  end
+end

data/app/models/accountability/discount.rb

@@ -0,0 +1,36 @@
+class Accountability::Discount < ApplicationRecord
+  belongs_to :coupon
+  belongs_to :order_item
+  has_many :deductions, dependent: :nullify
+
+  delegate :amount, to: :coupon, prefix: true
+
+  def apply(credit)
+    return unless usable?
+
+    credit.deductions.new(discount: self)
+  end
+
+  def usages
+    deductions.count
+  end
+
+  def usable?
+    return false if used_up?
+
+    coupon.usable?
+  end
+
+  def expected_savings
+    percent_off = coupon_amount / 100.00
+    order_item.default_price * percent_off
+  end
+
+  private
+
+  def used_up?
+    return false if coupon.usage_cap.blank?
+
+    usages >= coupon.usage_cap
+  end
+end

data/app/models/accountability/offerable.rb

@@ -0,0 +1,76 @@
+# TODO: Reconsider using names as keys, maybe just arrays?
+
+class Accountability::Offerable
+  cattr_accessor :collection, default: {}
+  attr_accessor :tenant, :category, :class_name, :trait, :scopes, :properties, :callbacks
+
+  def initialize(category, tenant: :default, trait: nil, class_name:)
+    @category = category
+    @tenant = tenant
+    @class_name = class_name
+    @trait = trait
+    @scopes = {}
+    @properties = {}
+    @callbacks = {}
+  end
+
+  def self.add(category, tenant: :default, trait: nil, class_name:)
+    category = category.to_s.underscore.downcase.to_sym
+    offerable = new(category, tenant: tenant, trait: trait, class_name: class_name)
+    collection[category] = offerable
+
+    offerable
+  end
+
+  def add_scope(name, title: name, options: :auto)
+    scopes[name] = { title: title.to_s, options: options, category: category }
+
+    self
+  end
+
+  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
+
+  def add_properties(*names)
+    names.each do |name|
+      add_property(name)
+    end
+
+    self
+  end
+
+  def add_callback(method_name, **options)
+    tense, event = options.slice(:before, :after).flatten
+    trigger = "#{tense}_#{event}".to_sym
+
+    params = if options[:with_options].present?
+               options[:with_options].to_h { |option| [option, option] }
+             else
+               [*options[:with]]
+             end
+
+    callbacks[trigger] ||= []
+    callbacks[trigger] << { method_name: method_name, params: params }
+
+    self
+  end
+
+  def trait?
+    trait.present?
+  end
+
+  private
+
+  # TODO: Abstract this out
+  def current_tenant
+    :default
+  end
+end
+
+# Load all models so offerable items are registered
+Dir[Rails.root + 'app/models/*.rb'].each do |path|
+  require_dependency path
+end

data/app/models/accountability/order_group.rb

@@ -0,0 +1,52 @@
+# OrderGroups are like shopping carts - they group together purchases (ordered items) that were made together.
+# We wanted to name this 'Order', but for obvious reasons that wouldn't work out
+# In the future we can use this for tracking referrals and contracts.
+
+module Accountability
+  class OrderGroup < ApplicationRecord
+    belongs_to :account, optional: true
+
+    has_many :order_items, dependent: :destroy
+
+    enum status: %i[pending complete abandoned]
+
+    validates :account, presence: true, if: :complete?
+
+    def checkout!
+      trigger_callback :before_checkout
+
+      transaction do
+        complete!
+        accrue_credits!
+
+        trigger_callback :after_checkout
+      end
+    end
+
+    def accrue_credits!
+      return unless complete?
+
+      order_items.each(&:accrue_credit!)
+    end
+
+    def add_item!(product)
+      order_items.create! product: product
+    end
+
+    def unassigned?
+      account.nil?
+    end
+
+    def assign_account!(account)
+      update! account: account
+    end
+
+    private
+
+    def trigger_callback(trigger)
+      order_items.each do |item|
+        item.trigger_callback trigger
+      end
+    end
+  end
+end

data/app/models/accountability/order_item.rb

@@ -0,0 +1,88 @@
+# An OrderItem represents a Product that has been (or is being) purchased
+# They are stored in an OrderGroup, which acts like a shopping cart
+
+class Accountability::OrderItem < ApplicationRecord
+  belongs_to :product
+  belongs_to :order_group
+  has_one :account, through: :order_group
+  has_many :credits, dependent: :destroy
+  has_many :discounts, dependent: :destroy
+
+  serialize :source_scope, Hash
+
+  delegate :name, to: :product, prefix: true
+
+  def accrue_credit!
+    return unless accruing?
+
+    credit = credits.new account: account
+    discounts.each { |discount| discount.apply(credit) }
+    credit.save!
+  end
+
+  def terminate!(date: Time.current)
+    update termination_date: date
+  end
+
+  def terminated?
+    return false if termination_date.nil?
+
+    termination_date.past?
+  end
+
+  def accruing?
+    return false unless accruable?
+    return true if credits.none?
+
+    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
+  end
+
+  def accruable?
+    return false if terminated?
+    return false if account.nil?
+
+    order_group.complete?
+  end
+
+  def last_accruement_date
+    credits.maximum(:created_at)
+  end
+
+  def default_price
+    product.price
+  end
+
+  def trigger_callback(trigger)
+    source_records.each do |record|
+      next unless product.callbacks.has_key? trigger
+
+      product.callbacks[trigger].each do |callback|
+        data = { billable: account.billable, offerable_category: product.offerable_template }
+
+        arguments = callback[:params]
+        keyword_arguments = arguments.extract_options!
+
+        arguments = data.values_at(*arguments)
+        keyword_arguments = keyword_arguments.to_h { |keyword, data_type| [keyword, data[data_type]] }
+
+        params = arguments
+        params << keyword_arguments if keyword_arguments.present?
+
+        record.public_send(callback[:method_name], *params)
+      end
+    end
+  end
+
+  def source_records
+    return [] if source_scope.empty?
+    return [] if product.source_class.nil?
+
+    product.source_class.where(**source_scope)
+  end
+end

data/app/models/accountability/payment.rb

@@ -0,0 +1,8 @@
+# TODO: Destroy associated debit when marked as failed
+
+class Accountability::Payment < ApplicationRecord
+  belongs_to :account
+  has_one :debit
+
+  enum status: %i[pending processing complete failed]
+end

data/app/models/accountability/product.rb

@@ -0,0 +1,53 @@
+# A Product defines any product/service/offering available for users to buy.
+# "Private" products can be made for special offers, one-time deals, or contracts.
+# Terminology:
+#   Activation Date - Date at which record becomes usable
+#   Expired - No longer available, but still usable by prior adopters
+#   Terminated - No longer available - even by prior adopters
+
+module Accountability
+  class Product < ApplicationRecord
+    has_and_belongs_to_many :coupons
+    has_many :order_items, dependent: :restrict_with_error
+    has_many :credits, through: :order_items, inverse_of: :product
+
+    serialize :source_scope, Hash
+
+    enum schedule: %i[one_time weekly monthly annually]
+
+    def inventory
+      return [] if source_class.nil?
+
+      source_class.where(**source_scope)
+    end
+
+    def offerable_template
+      return if offerable_category.nil?
+      return @offerable if @offerable.present?
+
+      offerable = Offerable.collection[offerable_category.to_sym]
+
+      return offerable if new_record?
+
+      if offerable.present?
+        @offerable = offerable
+      else
+        raise_offerable_not_found
+      end
+    end
+
+    def source_class
+      return if offerable_template.nil?
+
+      offerable_template.class_name.constantize
+    end
+
+    delegate :callbacks, to: :offerable_template
+  end
+
+  private
+
+  def raise_offerable_not_found
+    raise 'Offerable not found'
+  end
+end

data/app/views/accountability/accounts/index.html.haml

@@ -0,0 +1,13 @@
+%h1 Accounts
+
+%br
+
+- @accounts.each do |account|
+  %h2
+    %b Billable ID:
+    = account.billable.id
+  %p
+    %b Balance:
+    = account.balance
+  = link_to 'Show', accountability_account_path(account)
+  %hr

data/app/views/accountability/accounts/show.html.haml

@@ -0,0 +1,12 @@
+%h1 Account Overview
+
+%br
+
+%h2
+  %b Billable ID:
+  = @account.billable.id
+%p
+  %b Balance:
+  = @account.balance
+
+= link_to 'Back', accountability_accounts_path

data/app/views/accountability/order_groups/new.html.haml

@@ -0,0 +1 @@
+%h1 Add to cart

data/app/views/accountability/order_groups/show.html.haml

@@ -0,0 +1,16 @@
+%h1 Shopping Cart
+= link_to 'Back', accountability_products_path
+
+%p
+  %b Cart ID:
+  = @order_group.id
+
+- @order_group.order_items.includes(:product).each do |order_item|
+  %hr
+  %b= order_item.product_name
+  %br
+  %p
+    Price:
+    = order_item.default_price
+
+= button_to 'Check Out', '#'

data/app/views/accountability/products/edit.html.erb

@@ -0,0 +1 @@
+<h1>Product#edit</h1>

data/app/views/accountability/products/index.html.haml

@@ -0,0 +1,39 @@
+%h1 Products
+
+= link_to 'Shopping Cart', accountability_order_group_path(current_order_group)
+|
+= link_to 'New Product', new_accountability_product_path
+
+%p
+  %b User is admin:
+  = admin_session? ? 'yep' : 'nope'
+
+-# Temporary - we shouldn't assume they're on Devise
+%p
+  %b Email:
+  = current_user&.email
+
+%p
+  %b Account ID (session):
+  = session[:current_account_id]
+
+%p
+  %b Account (db):
+  = current_account
+
+%p
+  %b OrderGroup ID (db):
+  = current_order_group&.id
+
+%br
+%br
+%br
+%br
+%br
+%hr
+
+- @products.each do |product|
+  %h2= product.name
+  %p= product.description
+  = button_to 'Add to cart', add_item_accountability_order_group_path(current_order_group, product_id: product.id)
+  %hr