accountability 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b8115dd4e33d3e29a0ab8c565cf65a2abff5abf19672a31f69fedcf5e460917
-  data.tar.gz: 5d728906709560706013b88cf94bfcaa264e85fe1f902bff332fa0a697b9bc7e
+  metadata.gz: cc188f9e13eb05ae4a5f773cc2100210cb23fa06c04eebca820db8fe9bfedce2
+  data.tar.gz: 3b4180229a7be03688f3002db38a8afd792e440f45dec8fc6452a636eb434c4f
 SHA512:
-  metadata.gz: 4bba25e227a5aeb7f621fdbdf2fdcc77225900e8746db22b7876a067fbe778e55bec4ee84e2c978ac99ff5b143d5886a99d603c11f33d154e17db70d4ff5c1cb
-  data.tar.gz: eac570ee48dd6c4443f417c414d3c2da83252f562e094385440ce38fc08c989098630a02a8b25e19d9f687b40956f442d655a5d42b6987ae003cd5a218042944
+  metadata.gz: 3e59ae904e993a85976d614dc95a3c7a3ac6d64d4c1439ffceb45e3ce02e3d4a3ec05edb8fe3ec4eab68a8ed9fad8acda2f3dddbf79ea04f86559298d1e59111
+  data.tar.gz: 693b8d283aea6758b5701c6cda8860036901c2d9a3075b138853582c76a4ba1ba4943134fda7f3497080e3391f4afbc1443fa060a09e024c2be3035de90545de

data/README.md

@@ -1,28 +1,71 @@
-# ActsAsBillable
-Short description and motivation.
+# Accountability
+An extensible Rails library for easy product & billing management.
 
 ## Usage
-How to use my plugin.
+### Installing the gem
+To get started, add Accountability to your application's Gemfile.
+```ruby
+gem 'accountability'
+``` 
 
-## Installation
-Add this line to your application's Gemfile:
+### Adding routes
+You must specify a path to mount Accountability's engine to from inside your `config/routes.rb` file. In this example, we will mount everything to `/billing`. 
 
 ```ruby
-gem 'acts_as_billable'
+accountability_views_for :admin, :public, path: '/billing'
 ```
 
-And then execute:
-```bash
-$ bundle
-```
+The `accountability_views_for` routing helper can take any number of tenant names as arguments. Specifying tenants is only necessary if your application needs to use Accountability multiple times (such as an app with several e-commerce sites).
+
+This will generate the following routes:
+* `/billing` - Redirects to products page 
+* `/billing/products`
+* `/billing/orders` 
+* `/billing/accounts`
+
+### Creating products
+In order to make a `Product`, at least one model must indicate that it is "offerable." For example, let's say we want to sell baskets:
+```ruby
+class Basket < ApplicationRecord
+  acts_as_offerable
+
+  ...
+```  
+You can now visit the `/billing/products/new` page and select "Basket" category.
 
-Or install it yourself as:
-```bash
-$ gem install acts_as_billable
+If you want to have multiple offerable categories on the same model, you can set a custom category name:
+```ruby
+class Basket < ApplicationRecord
+  has_offerable :basket
+  has_offerable :bucket
+
+  ...
 ```
 
-## Contributing
-Contribution directions go here.
+Note that `has_offerable` is an alias of `acts_as_offerable`.
+
+For additional ways to define offerable content, see the "Advanced Usage" section. 
+### Configuration
+## Advanced Usage
+### Defining Offerable Content
+#### Scopes
+Scoping options can be defined to constrain products to a narrower set of records. Let's say that we want to sell both large and small baskets:
+```ruby
+class Basket < ApplicationRecord
+  enum style: %i[small large narrow deep]
+  
+  acts_as_offerable do |offer|
+    offer.add_scope :style, title: 'Size', options: %i[small large] 
+  end
+end
+```  
+
+#### Callbacks
+#### Multi-Tenancy
+#### Dynamic Pricing
+AKA traits
 
-## License
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+## TODO
+- [ ] Finish implementing multi-tenanting features
+- [ ] Add support for controller overrides
+- [ ] Implement product creation workflow in views

data/app/assets/config/accountability_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/accountability .css

data/app/assets/stylesheets/{acts_as_billable → accountability}/application.css

@@ -10,6 +10,6 @@
  * files in this directory. Styles in this file should be added after the last require_* statement.
  * It is generally better to create a new file per style scope.
  *
- * require_tree acts_as_billable
+ * require_tree accountability
  *= require_self
  */

data/app/controllers/accountability/accounts_controller.rb

@@ -0,0 +1,19 @@
+require_dependency 'accountability/application_controller'
+
+module Accountability
+  class AccountsController < ApplicationController
+    before_action :set_account, except: %i[index new create]
+
+    def index
+      @accounts = Account.all
+    end
+
+    def show; end
+
+    private
+
+    def set_account
+      @account = Account.find(params[:id])
+    end
+  end
+end

data/app/controllers/accountability/application_controller.rb

@@ -0,0 +1,45 @@
+module Accountability
+  class ApplicationController < ::ApplicationController
+    protect_from_forgery with: :exception
+
+    private
+
+    def track_order
+      # Check if session is billable (billable_identifier proc returns )
+      billable_record = instance_exec(&Configuration.billable_identifier)
+
+      if billable_record.present?
+        track_user_session(billable_record)
+      else
+        track_guest_session
+      end
+    end
+
+    def track_user_session(billable_record)
+      raise 'Record not billable' unless billable_record.acts_as.billable?
+
+      current_account = billable_record.accounts.first_or_create!
+      session[:current_account_id] = current_account.id
+
+      if current_order_group&.unassigned?
+        current_order_group.assign_account! current_account
+      else
+        current_order_group = current_account.order_groups.pending.first_or_create!
+        session[:current_order_group_id] = current_order_group.id
+      end
+    end
+
+    def track_guest_session
+      # Check if the order already belongs to someone
+      return if current_order_group&.unassigned?
+
+      current_order_group = OrderGroup.create!
+      session[:current_order_group_id] = current_order_group.id
+    end
+
+    def current_order_group
+      order_group_id = session[:current_order_group_id]
+      OrderGroup.find_by(id: order_group_id)
+    end
+  end
+end

data/app/controllers/accountability/order_groups_controller.rb

@@ -0,0 +1,65 @@
+require_dependency 'accountability/application_controller'
+
+module Accountability
+  class OrderGroupsController < ApplicationController
+    before_action :set_order_group, except: %i[new create]
+    before_action :track_order, except: %i[index]
+
+    def index
+      @order_groups = OrderGroup.all
+    end
+
+    def new
+      redirect_to accountability_order_group_path(current_order_group)
+    end
+
+    def show; end
+
+    def edit; end
+
+    def create
+      @order_group = OrderGroup.new(order_group_params)
+
+      if @order_group.save
+        redirect_to accountability_order_groups_path, notice: 'Successfully created new order_group'
+      else
+        render :new
+      end
+    end
+
+    def update
+      if @order_group.update(order_group_params)
+        redirect_to accountability_order_groups_path, notice: 'Successfully updated order_group'
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      if @order_group.destroy
+        redirect_to accountability_order_groups_path, notice: 'Successfully destroyed order_group'
+      else
+        redirect_to accountability_order_groups_path, alert: 'There was an issue destroying order_group'
+      end
+    end
+
+    def add_item
+      product = Product.find(params[:product_id])
+      if @order_group.add_item! product
+        redirect_to accountability_order_group_path(current_order_group), notice: 'Successfully added to cart'
+      else
+        redirect_back fallback_location: accountability_order_groups_path, alert: 'Failed to add to cart'
+      end
+    end
+
+    private
+
+    def set_order_group
+      @order_group = OrderGroup.find(params[:id])
+    end
+
+    def order_group_params
+      params.require(:order_group).permit
+    end
+  end
+end

data/app/controllers/accountability/products_controller.rb

@@ -0,0 +1,56 @@
+require_dependency 'accountability/application_controller'
+
+module Accountability
+  class ProductsController < ApplicationController
+    before_action :track_order, only: :index
+    before_action :set_product, except: %i[index new create]
+
+    def index
+      @products = Product.all
+    end
+
+    def new
+      @product = Product.new
+    end
+
+    def show; end
+
+    def edit; end
+
+    def create
+      @product = Product.new(product_params)
+
+      if @product.save
+        redirect_to accountability_products_path, notice: 'Successfully created new product'
+      else
+        render :new
+      end
+    end
+
+    def update
+      if @product.update(product_params)
+        redirect_to accountability_products_path, notice: 'Successfully updated product'
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      if @product.destroy
+        redirect_to accountability_products_path, notice: 'Successfully destroyed product'
+      else
+        redirect_to accountability_products_path, alert: 'There was an issue destroying product'
+      end
+    end
+
+    private
+
+    def set_product
+      @product = Product.find(params[:id])
+    end
+
+    def product_params
+      params.require(:product).permit(:name, :sku, :price, :description, :source_class, :source_trait, :source_scope)
+    end
+  end
+end

data/app/helpers/accountability/application_helper.rb

@@ -0,0 +1,19 @@
+module Accountability
+  module ApplicationHelper
+    def admin_session?
+      instance_exec(&Configuration.admin_checker)
+    end
+
+    def current_account
+      return if session[:current_account_id].nil?
+
+      Account.find_by(id: session[:current_account_id])
+    end
+
+    def current_order_group
+      return if session[:current_order_group_id].nil?
+
+      OrderGroup.find_by(id: session[:current_order_group_id])
+    end
+  end
+end

data/app/models/accountability/account.rb

@@ -0,0 +1,28 @@
+# The Account class acts as a ledger. It compares the accrued credits (expenses) and debits (deposits).
+
+module Accountability
+  class Account < ApplicationRecord
+    belongs_to :billable, polymorphic: true
+
+    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
+    has_many :purchased_order_items, through: :purchased_order_groups, source: :order_items, inverse_of: :account
+    has_many :payments, dependent: :nullify
+    has_many :credits, dependent: :destroy
+    has_many :debits, dependent: :destroy
+
+    def balance
+      accrued_credits = credits.sum(:amount)
+      accrued_debits = debits.sum(:amount)
+
+      accrued_debits - accrued_credits
+    end
+
+    def transactions
+      associated_credits = credits.includes(:product, :deductions)
+
+      Transactions.new(debits: debits, credits: associated_credits)
+    end
+  end
+end

data/app/models/accountability/account/transactions.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+
+module Accountability
+  class Account::Transactions
+    extend Forwardable
+
+    attr_accessor :transactions
+
+    def_delegators :transactions, :each, :sort_by
+
+    def initialize(debits: [], credits: [])
+      debit_transactions = debits.map do |debit|
+        Transaction.new(:debit, record: debit, amount: debit.amount, description: 'Payment')
+      end
+
+      credit_transactions = credits.map do |credit|
+        Transaction.new(:credit, record: credit, amount: credit.amount, description: credit.product_name)
+      end
+
+      @transactions = debit_transactions + credit_transactions
+    end
+
+    class Transaction
+      attr_accessor :type, :record, :description, :amount, :date
+
+      def initialize(type, record:, amount:, description:, date: nil)
+        @type = type
+        @record = record
+        @amount = amount
+        @description = description
+        @date = date.presence || record.created_at
+      end
+
+      def debit?
+        type == :debit
+      end
+
+      def credit?
+        type == :credit
+      end
+    end
+  end
+end

data/app/models/accountability/application_record.rb

@@ -0,0 +1,3 @@
+class Accountability::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/accountability/coupon.rb

@@ -0,0 +1,39 @@
+class Accountability::Coupon < ApplicationRecord
+  has_and_belongs_to_many :products
+  has_many :discounts, dependent: :restrict_with_error
+  has_many :deductions, through: :discounts, inverse_of: :coupon
+
+  validates :name, :amount, presence: true
+
+  def usable?
+    return false if used_up?
+
+    active?
+  end
+
+  def active?
+    return false if activation_date.blank?
+    return false if expired?
+
+    activation_date.past?
+  end
+
+  def expired?
+    return false if expiration_date.blank?
+    return false if terminated?
+
+    expiration_date.past?
+  end
+
+  def terminated?
+    return false if termination_date.blank?
+
+    termination_date.past?
+  end
+
+  def used_up?
+    return false if limit.nil?
+
+    discounts.count >= limit
+  end
+end

data/app/models/accountability/credit.rb

@@ -0,0 +1,46 @@
+# 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
+
+  belongs_to :account
+  belongs_to :order_item
+  has_many :deductions, dependent: :destroy
+  has_one :product, through: :order_item, inverse_of: :credits
+
+  validate :validate_amount_unchanged
+
+  delegate :name, to: :product, prefix: true
+
+  def base_price
+    if new_record?
+      order_item.default_price
+    else
+      amount + total_deductions
+    end
+  end
+
+  def total_deductions
+    if persisted?
+      deductions.sum(:amount)
+    else
+      deductions.map(&:amount).sum
+    end
+  end
+
+  private
+
+  def set_amount
+    return if persisted?
+
+    self.amount = base_price - total_deductions
+  end
+
+  def validate_amount_unchanged
+    return if new_record?
+    return unless amount_changed?
+
+    errors.add(:amount, 'cannot be changed')
+  end
+end