accountability 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc188f9e13eb05ae4a5f773cc2100210cb23fa06c04eebca820db8fe9bfedce2
-  data.tar.gz: 3b4180229a7be03688f3002db38a8afd792e440f45dec8fc6452a636eb434c4f
+  metadata.gz: f6693805b727a73f703afae26091f1dbbfdaf8361204ae9fa52ba1b4932fd7d0
+  data.tar.gz: b0b4f44c7be9a0e0ea9f5ada14fcfd552048a054ba2ece199fdcf7043dce88b2
 SHA512:
-  metadata.gz: 3e59ae904e993a85976d614dc95a3c7a3ac6d64d4c1439ffceb45e3ce02e3d4a3ec05edb8fe3ec4eab68a8ed9fad8acda2f3dddbf79ea04f86559298d1e59111
-  data.tar.gz: 693b8d283aea6758b5701c6cda8860036901c2d9a3075b138853582c76a4ba1ba4943134fda7f3497080e3391f4afbc1443fa060a09e024c2be3035de90545de
+  metadata.gz: da038e1ec8fbf770e59d58cc06ac0e8503ec2e65951ca39ebb968970d2c71a96e598ff1ba334e2217cb802ff1eb64344cc8e8200450cbb1a668e48e3e61bf725
+  data.tar.gz: 1114f3d2273f1f23a8deff9bcd78b7f075b6dfe15796f1aa5e82d91209d0367f5fc9416a783dcc7659f1b01395c687719288b6cfb6f5e4643441db5276457adf

data/README.md

@@ -8,6 +8,14 @@ To get started, add Accountability to your application's Gemfile.
 gem 'accountability'
 ``` 
 
+Next you must run Bundler, generate the install files, and run migrations.
+
+```bash
+bundle install
+rails generate accountability:install
+rake db:migrate
+```
+
 ### 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`. 
 
@@ -23,17 +31,35 @@ This will generate the following routes:
 * `/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:
+**Note:** Accountability does not have its own `ApplicationController` and will use yours instead. This means that your layouts file will be used. Prepend path helpers with `main_app.` to prevent links from breaking within Accountability's default views.
+
+### Defining billable models
+Billable models (such as a User, Customer, or Organization) need to be declared in order to accrue credits and make payments.  
+
+```ruby
+class User < ApplicationRecord
+  acts_as_billable  
+
+  ...
+```
+
+By default, Accountability identifies the billable entity from the `@current_user` variable. This can be changed from the [initializer file](Customizing configuration options). 
+
+### Defining products
+A "product" associates an "offerable" model in your application with a SKU, name, price, description, and instructions for querying available inventory.
+
+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.
 
-If you want to have multiple offerable categories on the same model, you can set a custom category name:
+You can now visit the `/billing/products/new` page and select the "Basket" category to create a new _product_.
+
+To define additional offerables on the same model, you can set a custom category name:
 ```ruby
 class Basket < ApplicationRecord
   has_offerable :basket
@@ -41,14 +67,50 @@ class Basket < ApplicationRecord
 
   ...
 ```
-
 Note that `has_offerable` is an alias of `acts_as_offerable`.
 
 For additional ways to define offerable content, see the "Advanced Usage" section. 
-### Configuration
+### Customizing configuration options
+To customize Accountability, create a `config/initializers/accountability.rb` file:
+```ruby
+Accountability.configure do |config|
+  # Customize Accountability settings here
+end
+``` 
+
+#### Customer identification
+By default, Accountability will reference the `@current_user` variable when identifying a billable user. 
+This will work for most applications using Devise with a User model representing customers.
+
+You can customize this behavior by defining either a proc or lamda that returns an instance of any "billable" record. A nil response will trigger a new guest session.
+
+You can optionally specify one of the billable record's attributes to reference as a user-friendly name in the views. The ID is used by default.   
+
+```ruby
+config.billable_identifier = -> { current_user&.organization }
+config.billable_name_column = :full_name
+```      
+
+#### Tax rates
+Currently, tax rates are defined statically as a percentage of the product's price. Feel free to open a PR if you require something more complex.
+
+The default value is `0.0`.
+
+```ruby
+config.tax_rate = 9.53
+```
+
+Note that products can be marked as tax exempt.  
+
+#### Debugger tools
+To print helpful session information in the views such as the currently tracked billable entity, enable the dev tools.
+
+```ruby
+config.dev_tools_enabled = true
+```
+
 ## Advanced Usage
-### Defining Offerable Content
-#### Scopes
+### Product 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
@@ -58,7 +120,22 @@ class Basket < ApplicationRecord
     offer.add_scope :style, title: 'Size', options: %i[small large] 
   end
 end
-```  
+```
+
+### Inventory Whitelist
+To hide records from the inventory without de-scoping them from the product, you can specify an existing ActiveRecord scope to define the available inventory with.  
+
+This can be useful for excluding inventory that is sold, reserved, or otherwise unavailable.
+
+```ruby
+class Basket < ApplicationRecord
+  scope :in_warehouse, -> { where arrived_at_warehouse: true }
+  
+  acts_as_offerable do |offer|
+    offer.inventory_whitelist :in_warehouse 
+  end
+end
+```
 
 #### Callbacks
 #### Multi-Tenancy

data/app/controllers/accountability/accounts_controller.rb

@@ -1,8 +1,6 @@
-require_dependency 'accountability/application_controller'
-
 module Accountability
-  class AccountsController < ApplicationController
-    before_action :set_account, except: %i[index new create]
+  class AccountsController < AccountabilityController
+    before_action :set_account, except: %i[index]
 
     def index
       @accounts = Account.all

data/app/controllers/accountability/billing_configurations_controller.rb

@@ -0,0 +1,80 @@
+module Accountability
+  class BillingConfigurationsController < AccountabilityController
+    before_action :set_billing_configuration, except: %i[new create]
+    before_action :set_account, only: %i[create update designate_as_primary]
+
+    def show; end
+
+    def new; end
+
+    def create
+      bc_params = billing_configuration_params
+      @billing_configuration = @account.build_billing_configuration_with_active_merchant_data(bc_params,
+                                                                                              verify_card: true)
+      if @billing_configuration.save
+        message = 'Credit card successfully added.'
+        render json: { status: :success, message: message, updated_elements: updated_billing_elements }
+      else
+        render json: { status: :error, errors: @billing_configuration.errors }
+      end
+    end
+
+    def edit; end
+
+    def update
+      @billing_configuration.update billing_configuration_params
+
+      if @billing_configuration.save
+        message = 'Configuration Updated'
+        render json: { status: :success, message: message, updated_elements: updated_billing_elements }
+      else
+        render json: { status: :error, errors: @billing_configuration.errors }
+      end
+    end
+
+    def destroy
+      if @billing_configuration.destroy
+        render json: {
+          status: :success,
+          message: 'Payment Method Destroyed'
+        }
+      else
+        render json: { status: :error, errors: @billing_configuration.errors }
+      end
+    end
+
+    def designate_as_primary
+      if @billing_configuration.primary!
+        message = 'Payment Method Set As Primary'
+        render json: { status: :success, message: message, updated_elements: updated_billing_elements }
+      else
+        render json: { status: :error, errors: @billing_configuration.errors }
+      end
+    end
+
+    def updated_billing_elements
+      configurations_partial = 'accountability/accounts/billing_configurations/configurations'
+      payment_form_partial = 'accountability/accounts/payment_form'
+
+      {
+        configurations: render_to_string(partial: configurations_partial, layout: false, locals: { account: @account }),
+        payment_form: render_to_string(partial: payment_form_partial, layout: false, locals: { account: @account })
+      }
+    end
+
+    private
+
+    def set_billing_configuration
+      @billing_configuration = BillingConfiguration.find(params[:id])
+    end
+
+    def set_account
+      @account = Account.find(params[:account_id])
+    end
+
+    def billing_configuration_params
+      params.require(:billing_configuration).permit(:token, :configuration_name, :provider, :contact_email,
+                                                    :contact_first_name, :contact_last_name, billing_address: {})
+    end
+  end
+end

data/app/controllers/accountability/order_groups_controller.rb

@@ -1,8 +1,6 @@
-require_dependency 'accountability/application_controller'
-
 module Accountability
-  class OrderGroupsController < ApplicationController
-    before_action :set_order_group, except: %i[new create]
+  class OrderGroupsController < AccountabilityController
+    before_action :set_order_group, except: %i[index new create]
     before_action :track_order, except: %i[index]
 
     def index

data/app/controllers/accountability/payments_controller.rb

@@ -0,0 +1,25 @@
+module Accountability
+  class PaymentsController < AccountabilityController
+    before_action :set_account
+
+    def create
+      @payment = @account.payments.new(payment_params)
+
+      if @payment.save
+        redirect_to accountability_account_path(@account), notice: 'Payment was completed successfully'
+      else
+        render json: { status: :error, errors: @payment.errors }
+      end
+    end
+
+    private
+
+    def payment_params
+      params.require(:payment).permit(:amount, :billing_configuration_id)
+    end
+
+    def set_account
+      @account = Account.find(params[:account_id])
+    end
+  end
+end

data/app/controllers/accountability/products_controller.rb

@@ -1,7 +1,5 @@
-require_dependency 'accountability/application_controller'
-
 module Accountability
-  class ProductsController < ApplicationController
+  class ProductsController < AccountabilityController
     before_action :track_order, only: :index
     before_action :set_product, except: %i[index new create]
 
@@ -11,6 +9,7 @@ module Accountability
 
     def new
       @product = Product.new
+      @stage = 'initial'
     end
 
     def show; end
@@ -20,7 +19,10 @@ module Accountability
     def create
       @product = Product.new(product_params)
 
-      if @product.save
+      if params[:stage] == 'initial'
+        @stage = 'final'
+        render :new
+      elsif @product.save
         redirect_to accountability_products_path, notice: 'Successfully created new product'
       else
         render :new
@@ -50,7 +52,7 @@ module Accountability
     end
 
     def product_params
-      params.require(:product).permit(:name, :sku, :price, :description, :source_class, :source_trait, :source_scope)
+      params.require(:product).permit(:name, :sku, :price, :description, :source_class, :source_trait, :source_scope, :offerable_category)
     end
   end
 end

data/app/controllers/accountability/statements_controller.rb

@@ -0,0 +1,19 @@
+module Accountability
+  class StatementsController < AccountabilityController
+    before_action :set_statement
+
+    def download_pdf
+      end_date = @statement.end_date.strftime('%B %-d, %Y')
+      filename = "Billing Statement - #{end_date}.pdf"
+      pdf = StatementPdf.new(@statement)
+
+      send_data pdf.render, filename: filename, type: 'application/pdf'
+    end
+
+    private
+
+    def set_statement
+      @statement = Statement.find(params[:id])
+    end
+  end
+end

data/app/controllers/accountability_controller.rb

@@ -0,0 +1,47 @@
+# TODO: Set the parent class dynamically (Accountability.parent_controller.constantize)
+
+class AccountabilityController < ApplicationController
+  helper Accountability::Engine.helpers
+
+  protect_from_forgery with: :exception
+
+  private
+
+  def track_order
+    # Check if session is billable (billable_identifier proc returns a record)
+    billable_record = instance_exec(&Accountability::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 = Accountability::OrderGroup.create!
+    session[:current_order_group_id] = current_order_group.id
+  end
+
+  def current_order_group
+    order_group_id = session[:current_order_group_id]
+    Accountability::OrderGroup.find_by(id: order_group_id)
+  end
+end

data/app/helpers/accountability/{application_helper.rb → accountability_helper.rb}

@@ -1,5 +1,5 @@
 module Accountability
-  module ApplicationHelper
+  module AccountabilityHelper
     def admin_session?
       instance_exec(&Configuration.admin_checker)
     end

data/app/helpers/accountability/billing_configurations_helper.rb

@@ -0,0 +1,47 @@
+module Accountability
+  module BillingConfigurationsHelper
+    def payment_gateway_configuration_javascript
+      provider = Accountability::Configuration.payment_gateway[:provider]
+      case provider
+      when :stripe
+        stripe_gateway_javascript
+      else
+        raise NotImplementedError, "No JavaScript tag defined for #{provider}"
+      end
+    end
+
+    def billing_address_preview(billing_address)
+      [billing_address.address_1, "#{billing_address.state}, #{billing_address.zip}"].join(' ')
+    end
+
+    private
+
+    def stripe_gateway_javascript
+      snippets = [stripe_gateway_include, stripe_gateway_config]
+      join_javascript_snippets(snippets)
+    end
+
+    def stripe_gateway_include
+      javascript_include_tag stripe_v3_javascript_url
+    end
+
+    def stripe_gateway_config
+      publishable_key = Accountability::Configuration.payment_gateway.dig(:authentication, :publishable_key)
+      script = <<~SCRIPT
+        ACTIVE_MERCHANT_CONFIG = {
+          STRIPE_PUBLISHABLE_KEY: "#{publishable_key}"
+        }
+      SCRIPT
+      content_tag(:script, format_javascript(script), type: 'text/javascript')
+    end
+
+    def format_javascript(javascript)
+      tabbed_out_js = javascript.split("\n").map { |line| "  #{line}" }.join("\n")
+      "\n#{tabbed_out_js}\n".html_safe # rubocop:disable Rails/OutputSafety
+    end
+
+    def join_javascript_snippets(snippets = [])
+      snippets.join("\n").html_safe # rubocop:disable Rails/OutputSafety
+    end
+  end
+end

data/app/helpers/accountability/products_helper.rb

@@ -0,0 +1,21 @@
+module Accountability
+  module ProductsHelper
+    def source_class_options
+      options = Accountability::Offerable.collection.stringify_keys
+      options.keys.map { |offerable_name| [offerable_name.titleize, offerable_name] }
+    end
+
+    def schedule_options
+      options = Accountability::Product.schedules
+      options.keys.map { |schedule_name| [schedule_name.titleize, schedule_name] }
+    end
+
+    def scope_options(scope)
+      scope.options.map { |option| [option.to_s.titleize, option] }
+    end
+
+    def disable_category_field?
+      @stage != 'initial'
+    end
+  end
+end