accountability 0.1.1 → 0.2.1

data/app/models/accountability/product.rb

@@ -5,15 +5,39 @@
 #   Expired - No longer available, but still usable by prior adopters
 #   Terminated - No longer available - even by prior adopters
 
+# rubocop:disable Rails/HasAndBelongsToMany
+
 module Accountability
   class Product < ApplicationRecord
+    RECURRING_SCHEDULES = %i[weekly monthly annually].freeze
+
     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]
+    enum schedule: [:one_time, *RECURRING_SCHEDULES], _prefix: :accrues
+
+    def active?
+      return false unless activation_date.present?
+
+      activation_date.past?
+    end
+
+    def billing_cycle_length
+      case schedule
+      when 'weekly' then 1.week
+      when 'monthly' then 1.month
+      when 'annually' then 1.year
+      end
+    end
+
+    # Returns an Inventory object containing each record within the product's scope.
+    # This method will eventually phase out the `inventory` and `available_inventory` methods.
+    def inventory_items
+      Inventory.new(self)
+    end
 
     def inventory
       return [] if source_class.nil?
@@ -21,6 +45,22 @@ module Accountability
       source_class.where(**source_scope)
     end
 
+    def available_inventory
+      return [] if source_class.nil?
+
+      source_class.where(**source_scope).public_send(offerable_template.whitelist)
+    end
+
+    # TODO: Update offerable_template.scopes to return an array of Scope objects and delegate to that instead
+    def scopes
+      return @scopes if @scopes.present?
+
+      @scopes = offerable_template.scopes.map do |attribute, params|
+        params.merge! source_class: source_class, attribute: attribute
+        Offerable::Scope.new(**params)
+      end
+    end
+
     def offerable_template
       return if offerable_category.nil?
       return @offerable if @offerable.present?
@@ -43,11 +83,11 @@ module Accountability
     end
 
     delegate :callbacks, to: :offerable_template
-  end
 
-  private
+    private
 
-  def raise_offerable_not_found
-    raise 'Offerable not found'
+    def raise_offerable_not_found
+      raise 'Offerable not found'
+    end
   end
 end

data/app/models/accountability/statement.rb

@@ -0,0 +1,46 @@
+# New Credit records are automatically assigned to the latest Statement on their associated Account.
+# If the latest statement is past its :end_date, the credit will build a new one.
+# The new :end_date is determined by the account's :statement_schedule enum.
+
+module Accountability
+  class Statement < ApplicationRecord
+    self.implicit_order_column = 'end_date'
+
+    before_validation :set_end_date
+
+    belongs_to :account
+    has_many :credits, dependent: :destroy
+
+    validates :end_date, presence: true
+
+    delegate :past?, :future?, to: :end_date
+
+    def paid?
+      return false if account.last_balanced_at.nil?
+
+      end_date.before? account.last_balanced_at
+    end
+
+    def total_accrued
+      credits.sum(:amount)
+    end
+
+    def transactions
+      associated_credits = credits.includes(:product, deductions: :discount).references(:order_item)
+
+      Transactions.new(credits: associated_credits)
+    end
+
+    private
+
+    def set_end_date
+      return if account.nil?
+      return if end_date.present?
+
+      self.end_date = case account.statement_schedule
+                      when 'end_of_month' then Time.current.end_of_month
+                      when 'bi_weekly' then 2.weeks.from_now
+                      end
+    end
+  end
+end

data/app/models/accountability/{account/transactions.rb → transactions.rb}

@@ -1,12 +1,12 @@
 require 'forwardable'
 
 module Accountability
-  class Account::Transactions
+  class Transactions
     extend Forwardable
 
     attr_accessor :transactions
 
-    def_delegators :transactions, :each, :sort_by
+    def_delegators :transactions, :each, :sort_by, :any?, :none?
 
     def initialize(debits: [], credits: [])
       debit_transactions = debits.map do |debit|
@@ -38,6 +38,18 @@ module Accountability
       def credit?
         type == :credit
       end
+
+      def base_amount
+        debit? ? base_amount : record.base_price
+      end
+
+      def deductions
+        debit? ? [] : record.deductions
+      end
+
+      def taxes
+        debit? ? 0 : record.taxes
+      end
     end
   end
 end

data/app/models/concerns/accountability/active_merchant_interface.rb

@@ -0,0 +1,15 @@
+module Accountability
+  module ActiveMerchantInterface
+    extend ActiveSupport::Concern
+
+    included do
+      provider = Accountability::Configuration.payment_gateway[:provider]
+      case provider
+      when :stripe
+        include StripeInterface
+      else
+        raise NotImplementedError, "No ActiveMerchantInterface defined for #{provider}"
+      end
+    end
+  end
+end

data/app/models/concerns/accountability/active_merchant_interface/stripe_interface.rb

@@ -0,0 +1,134 @@
+# TODO: Implement #unstore_active_merchant_data
+
+module Accountability
+  module ActiveMerchantInterface::StripeInterface
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :stripe_api_errors, default: []
+      validate :validate_no_stripe_errors
+
+      # It is important to clear these errors after validation
+      # so that store_active_merchant_data will run again.
+      after_validation :clear_stripe_api_errors, on: :create
+      after_save_commit :save_customer_info_to_stripe
+    end
+
+    def charge(amount)
+      gateway = initialize_payment_gateway
+      amount_in_cents = (amount * 100).round
+      card_id = active_merchant_data['authorization']
+
+      response = gateway.purchase(amount_in_cents, card_id)
+
+      return true if response.success?
+
+      error_code = response.error_code || I18n.t('accountability.gateway.errors.unknown_gateway_error')
+      stripe_api_errors.append(error_code)
+      false
+    end
+
+    def store_active_merchant_data(**options)
+      response = store_card_in_gateway
+
+      unless response.success?
+        error_code = response.error_code || I18n.t('accountability.gateway.errors.unknown_gateway_error')
+        stripe_api_errors.append(error_code)
+        return
+      end
+
+      active_merchant_data = extract_active_merchant_data(response)
+      validate_chargeable(**active_merchant_data) if options.fetch(:verify_card)
+
+      self.active_merchant_data = active_merchant_data
+    end
+
+    private
+
+    def store_card_in_gateway(gateway = initialize_payment_gateway)
+      gateway.store(token, description: configuration_name, email: contact_email, set_default: true)
+    end
+
+    def validate_chargeable(gateway = initialize_payment_gateway, **active_merchant_data)
+      authorization = active_merchant_data[:authorization]
+
+      response = gateway.verify(authorization, verification_params)
+      return if response.success?
+
+      error_code = response.error_code || I18n.t('accountability.gateway.errors.unknown_gateway_error')
+      stripe_api_errors.append(error_code)
+    end
+
+    def extract_active_merchant_data(response)
+      customer_id = response.params['id']
+      card_id = response.params['sources']['data'].first['id']
+      authorization = response.authorization
+
+      data = { authorization: authorization, customer_id: customer_id, card_id: card_id }
+      data.symbolize_keys
+    end
+
+    def initialize_payment_gateway
+      secret_key = Accountability::Configuration.payment_gateway.dig(:authentication, :secret_key)
+      ActiveMerchant::Billing::StripeGateway.new(login: secret_key)
+    end
+
+    def add_customer_info(customer_id, gateway = initialize_payment_gateway)
+      response = gateway.update_customer(customer_id, customer_params)
+      return unless response.error_code
+
+      Rails.logger.warn %(Warning: add_customer_info failed for #{self.class}: #{id}; card_id: #{card_id};
+        customer_id: #{customer_id}; Stripe Error: #{add_customer_info_response.error_code}).squish
+    end
+
+    def add_card_info(customer_id, card_id, gateway = initialize_payment_gateway)
+      response = gateway.update(customer_id, card_id, card_params)
+      return unless response.error_code
+
+      Rails.logger.warn %(Warning: add_card_info failed for #{self.class}: #{id}; card_id: #{card_id};
+        customer_id: #{customer_id}; Stripe Error: #{add_customer_info_response.error_code}).squish
+    end
+
+    def save_customer_info_to_stripe(gateway = initialize_payment_gateway)
+      customer_id, card_id = active_merchant_data.with_indifferent_access.values_at(:customer_id, :card_id)
+      return unless customer_id && card_id
+
+      add_customer_info(customer_id, gateway)
+      add_card_info(customer_id, card_id, gateway)
+    end
+
+    def verification_params
+      { description: 'Accountability Verification Charge', statement_description: 'Card Verification' }
+    end
+
+    def card_params
+      { metadata: { billing_configuration_id: id, account_id: account.id },
+        name: contact_name,
+        address_line1: billing_address.address_1,
+        address_line2: billing_address.address_2,
+        address_city: billing_address.city,
+        address_zip: billing_address.zip,
+        address_state: billing_address.state,
+        address_country: billing_address.country }
+    end
+
+    def customer_params
+      { metadata: { billing_configuration_id: id, account_id: account.id },
+        name: contact_name, email: contact_email,
+        address: { line1: billing_address.address_1,
+                   line2: billing_address.address_2,
+                   city: billing_address.city,
+                   postal_code: billing_address.zip,
+                   state: billing_address.state,
+                   country: billing_address.country } }
+    end
+
+    def validate_no_stripe_errors
+      stripe_api_errors.each { |error| errors.add(:base, error) }
+    end
+
+    def clear_stripe_api_errors
+      stripe_api_errors.clear
+    end
+  end
+end

data/app/pdfs/statement_pdf.rb

@@ -0,0 +1,91 @@
+require 'prawn'
+require 'prawn/table'
+require 'date'
+
+class StatementPdf
+  include ActiveSupport::NumberHelper
+  include Prawn::View
+
+  attr_accessor :statement
+
+  def initialize(statement, debug_mode: false)
+    @statement = statement
+    @debug_mode = debug_mode
+
+    draw_document
+  end
+
+  def draw_document
+    font 'Helvetica'
+
+    stroke_axis if debug_mode?
+    draw_header
+    move_down 40
+    draw_transactions_section
+    number_pages '<page>', align: :center, at: [0, -6]
+  end
+
+  def draw_header
+    # Draw upper-left text
+    bounding_box [0, 720], width: 250, height: 70 do
+      move_down 10
+      text 'STATEMENT', size: 18
+      move_down 5
+      text "Ending: #{statement.end_date.strftime('%B %-d, %Y')}", align: :left
+
+      transparent(0.5) { stroke_bounds } if debug_mode?
+    end
+
+    # Draw upper-right logo
+    bounding_box [290, 720], width: 250, height: 70 do
+      logo_path = Accountability::Configuration.logo_path
+      image logo_path, fit: [250, 70], position: :right
+      transparent(0.5) { stroke_bounds } if debug_mode?
+    end
+  end
+
+  def draw_transactions_section
+    text 'Details', style: :bold_italic
+    stroke_horizontal_rule
+    move_down 15
+
+    # Draw transactions table
+    transactions = Accountability::Transactions.new(credits: statement.credits.includes(:product, :deductions))
+    transaction_data = transactions.sort_by(&:date).reverse.map do |transaction|
+      [transaction.date.strftime('%b %-d, %Y'), make_transaction_subtable(transaction)]
+    end
+
+    table transaction_data, column_widths: [100, 440], row_colors: %w[d2e3ed ffffff]
+
+    # Draw statement total in separate table
+    total_data = [[nil, 'Total ', decorate_currency(statement.total_accrued)]]
+    table total_data, cell_style: { borders: [], font_style: :bold }, column_widths: [100, 340, 100] do
+      row(-1).columns(1).style align: :right
+      row(-1).columns(2).borders = %i[bottom left right]
+    end
+  end
+
+  def make_transaction_subtable(transaction)
+    rows = [[transaction.description, decorate_currency(transaction.base_amount)]]
+
+    # Define deduction rows if applicable
+    transaction.deductions.each do |deduction|
+      rows.append([deduction.coupon_name, decorate_currency(-deduction.amount)])
+    end
+
+    # Define tax row if applicable
+    rows.append(['Tax', decorate_currency(transaction.taxes)]) if transaction.taxes.nonzero?
+
+    make_table rows, column_widths: [340, 100]
+  end
+
+  private
+
+  def debug_mode?
+    @debug_mode
+  end
+
+  def decorate_currency(value)
+    number_to_currency value, negative_format: '(%u%n)'
+  end
+end

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

@@ -1,12 +1,24 @@
-%h1 Account Overview
+.container
+  - if Accountability::Configuration.dev_tools_enabled?
+    = render partial: 'accountability/shared/session_info'
 
-%br
+  - if admin_session?
+    = link_to 'Back', accountability_accounts_path, class: 'btn btn-outline-primary float-right'
 
-%h2
-  %b Billable ID:
-  = @account.billable.id
-%p
-  %b Balance:
-  = @account.balance
+  %h1 Billing Info
+  %h4.mb-5= @account.billable_record_name
 
-= link_to 'Back', accountability_accounts_path
+  .row
+    .col-md-6
+      .card
+        .card-header
+          Account Balance
+        .card-body
+          .text-primary= @account.balance
+
+    .col-md-6
+      .card
+        .card-header
+          Payment History
+        .card-body
+          .text-secondary Coming Soon

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

@@ -1,39 +1,22 @@
-%h1 Products
+.container
+  - if Accountability::Configuration.dev_tools_enabled?
+    = render partial: 'accountability/shared/session_info'
 
-= link_to 'Shopping Cart', accountability_order_group_path(current_order_group)
-|
-= link_to 'New Product', new_accountability_product_path
+  - if current_order_group.order_items.any?
+    = link_to 'Shopping Cart', accountability_order_group_path(current_order_group), class: 'btn btn-outline-primary float-right ml-2'
 
-%p
-  %b User is admin:
-  = admin_session? ? 'yep' : 'nope'
+  - if current_account.present?
+    = link_to 'Billing', accountability_account_path(current_account), class: 'btn btn-outline-primary float-right ml-2'
 
--# Temporary - we shouldn't assume they're on Devise
-%p
-  %b Email:
-  = current_user&.email
+  %h1.mb-5 Products
 
-%p
-  %b Account ID (session):
-  = session[:current_account_id]
+  - @products.each do |product|
+    .card.mb-4
+      .card-header
+        = product.name
+      .card-body
+        = product.description
+        = button_to 'Add to cart', add_item_accountability_order_group_path(current_order_group, product_id: product.id), class: 'btn btn-outline-success float-right'
 
-%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
+  - if admin_session?
+    = link_to 'Add New Product', new_accountability_product_path, class: 'btn btn-outline-primary float-right mt-5'