effective_orders 5.5.2 → 5.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 496c6b24100359c7121e1903130d345ed5b13fabf41cf1a1e78be20be3d638c8
-  data.tar.gz: a2451ac65694daa46c2386dd13754d6ed43ae2e9b8b34ff16903ec6c9591e888
+  metadata.gz: 4e419a31818cf5abba11e1330c5cf38e7637f144d9eacade387f919de7433973
+  data.tar.gz: 12a61662d772982f6ddff6f00bd990dfdab017a33ce011b55caf7f4507715010
 SHA512:
-  metadata.gz: 24a8a97d2bc9c2b45680fc4e9f8c751245d5e83d69ff085a744f1e16709219cafb04c13c55fd88eda8a2b2707eaeea0dea48a2c9f66c682187720ef334aab1b7
-  data.tar.gz: 14af91d8e9a56efe0e65d07348f4de7c2fc83a14df32d06b3e3cb40306b4469b575dfaf9c629a9f67369226da089b464d46c0be0cda1d3a5ca15a68b3693d6a4
+  metadata.gz: abc379d14277eb75eef1c315ad05d49bbd801211c8f4781951249421c6433f9e1fef5b5ff5e0348859ccab4a185bc4439ae0a06f0ba8e1bdc9b6bf9199f912ce
+  data.tar.gz: b189c07ee57a22ba4f3fb314da7078b7cf7d8f9d25ab85f3d37e6be74c8924cdc6ccac516053bf2ee0bbc182f8c80f1b4b82505cdd310a6d6bde02b0fff17dd2

data/app/controllers/admin/orders_controller.rb

@@ -14,38 +14,11 @@ module Admin
     submit :save, 'Duplicate', redirect: -> { effective_orders.new_admin_order_path(duplicate_id: resource.to_param) }
     submit :save, 'Checkout', redirect: -> { effective_orders.checkout_admin_order_path(resource) }
 
-    def create
-      @user = current_user.class.find_by_id(permitted_params[:user_id])
-      @order = Effective::Order.new(user: @user)
-
-      authorize_effective_order!
-      error = nil
-
-      Effective::Order.transaction do
-        begin
-          (permitted_params[:order_items_attributes] || {}).each do |_, item_attrs|
-            purchasable = Effective::Product.new(item_attrs[:purchasable_attributes])
-            @order.add(purchasable, quantity: item_attrs[:quantity])
-          end
-
-          @order.attributes = permitted_params.except(:order_items_attributes, :user_id)
-          @order.pending!
-
-          message = 'Successfully created order'
-          message << ". A request for payment has been sent to #{@order.emails_send_to}" if @order.send_payment_request_to_buyer?
-          flash[:success] = message
-
-          redirect_to(admin_redirect_path) and return
-        rescue => e
-          error = e.message
-          raise ActiveRecord::Rollback
-        end
-      end
-
-      @page_title = 'New Order'
-      flash.now[:danger] = flash_danger(@order) + error.to_s
-      render :new
-    end
+    submit :save, 'Save', success: -> {
+      message = flash_success(resource, params[:action])
+      message << ". A request for payment has been sent to #{resource.emails_send_to}" if resource.send_payment_request_to_buyer?
+      message
+    }
 
     # The show page posts to this action
     # See Effective::OrdersController checkout
@@ -58,21 +31,19 @@ module Admin
 
       if request.get?
         @order.assign_confirmed_if_valid!
-        render :checkout and return
+        render(:checkout)
+        return
       end
 
-      Effective::Order.transaction do
-        begin
-          @order.assign_attributes(checkout_params)
-          @order.confirm!
-          redirect_to(effective_orders.checkout_admin_order_path(@order)) and return
-        rescue => e
-          raise ActiveRecord::Rollback
-        end
-      end
+      # Otherwise a post
+      @order.assign_attributes(checkout_params)
 
-      flash.now[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
-      render :checkout
+      if (@order.confirm! rescue false)
+        redirect_to(effective_orders.checkout_admin_order_path(@order))
+      else
+        flash.now[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
+        render :checkout
+      end
     end
 
     def destroy
@@ -124,15 +95,7 @@ module Admin
     private
 
     def permitted_params
-      params.require(:effective_order).permit(:user_id, :user_type, :cc,
-        :send_payment_request_to_buyer, :note_internal, :note_to_buyer,
-        :payment_provider, :payment_card, :payment, :send_mark_as_paid_email_to_buyer,
-        order_items_attributes: [
-          :quantity, :_destroy, purchasable_attributes: [
-            :name, :qb_item_name, :price, :tax_exempt
-          ]
-        ]
-      )
+      params.require(:effective_order).permit!
     end
 
     def checkout_params
@@ -143,17 +106,5 @@ module Admin
       EffectiveResources.authorize!(self, action_name.to_sym, @order || Effective::Order)
     end
 
-    def admin_redirect_path
-      case params[:commit].to_s
-      when 'Save'               ; effective_orders.admin_order_path(@order)
-      when 'Continue'           ; effective_orders.admin_orders_path
-      when 'Add New'            ; effective_orders.new_admin_order_path(user_id: @order.user.try(:to_param))
-      when 'Duplicate'          ; effective_orders.new_admin_order_path(duplicate_id: @order.to_param)
-      when 'Checkout'           ; effective_orders.checkout_admin_order_path(@order.to_param)
-      else
-        effective_orders.admin_order_path(@order)
-      end
-    end
-
   end
 end

data/app/models/effective/order.rb

@@ -30,10 +30,10 @@ module Effective
     belongs_to :parent, polymorphic: true, optional: true
 
     belongs_to :user, polymorphic: true, validate: false  # This is the buyer/user of the order. We validate it below.
-    has_many :order_items, -> { order(:id) }, inverse_of: :order, dependent: :delete_all
+    accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
 
+    has_many :order_items, -> { order(:id) }, inverse_of: :order, dependent: :delete_all
     accepts_nested_attributes_for :order_items, allow_destroy: false, reject_if: :all_blank
-    accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
 
     # Attributes
     effective_resource do
@@ -63,18 +63,30 @@ module Effective
 
     serialize :payment, Hash
 
-    before_validation { assign_order_totals }
-    before_validation { assign_billing_name }
-    before_validation { assign_email }
-    before_validation { assign_user_address }
-    before_validation { assign_last_address }
+    scope :deep, -> { includes(:addresses, :user, order_items: :purchasable) }
+    scope :sorted, -> { order(:id) }
+
+    scope :purchased, -> { where(state: EffectiveOrders::PURCHASED) }
+    scope :purchased_by, lambda { |user| purchased.where(user: user) }
+    scope :not_purchased, -> { where.not(state: EffectiveOrders::PURCHASED) }
+
+    scope :pending, -> { where(state: EffectiveOrders::PENDING) }
+    scope :confirmed, -> { where(state: EffectiveOrders::CONFIRMED) }
+    scope :deferred, -> { where(state: EffectiveOrders::DEFERRED) }
+    scope :declined, -> { where(state: EffectiveOrders::DECLINED) }
+    scope :abandoned, -> { where(state: EffectiveOrders::ABANDONED) }
+    scope :refunds, -> { purchased.where('total < ?', 0) }
 
-    before_validation(if: -> { confirmed_checkout }) do
-      assign_attributes(state: EffectiveOrders::CONFIRMED) if pending?
+    before_validation do
+      self.state ||= EffectiveOrders::PENDING
+      self.state = EffectiveOrders::CONFIRMED if pending? && confirmed_checkout
     end
 
-    before_save(if: -> { state_was == EffectiveOrders::PURCHASED }) do
-      raise EffectiveOrders::AlreadyPurchasedException.new('cannot unpurchase an order') unless purchased?
+    with_options(unless: -> { done? }) do
+      before_validation { assign_email }
+      before_validation { assign_user_address }
+      before_validation { assign_billing_name }
+      before_validation { assign_order_totals }
     end
 
     # Order validations
@@ -84,6 +96,8 @@ module Effective
 
     validates :order_items, presence: { message: 'No items are present. Please add additional items.' }
     validates :state, inclusion: { in: EffectiveOrders::STATES.keys }
+
+    # Price validations
     validates :subtotal, presence: true
 
     with_options(if: -> { EffectiveOrders.minimum_charge.to_i > 0 }) do
@@ -91,7 +105,7 @@ module Effective
 
       validate(unless: -> { (free? && EffectiveOrders.free?) || (refund? && EffectiveOrders.refund?) }) do
         if total.present? && total < EffectiveOrders.minimum_charge
-          self.errors.add(:total, "must be $#{'%0.2f' % (EffectiveOrders.minimum_charge.to_i / 100.0)} or more. Please add additional items.")
+          errors.add(:total, "must be $#{'%0.2f' % (EffectiveOrders.minimum_charge.to_i / 100.0)} or more. Please add additional items.")
         end
       end
     end
@@ -118,11 +132,6 @@ module Effective
       validates :payment, presence: true
 
       validates :payment_provider, presence: true
-
-      validate do
-        self.errors.add(:payment_provider, "unknown payment provider") unless (EffectiveOrders.payment_providers + EffectiveOrders.admin_payment_providers).include?(payment_provider)
-      end
-
       validates :payment_card, presence: true
     end
 
@@ -130,23 +139,17 @@ module Effective
       validates :payment_provider, presence: true
 
       validate do
-        self.errors.add(:payment_provider, "unknown deferred payment provider") unless EffectiveOrders.deferred_providers.include?(payment_provider)
+        errors.add(:payment_provider, "unknown deferred payment provider") unless EffectiveOrders.deferred_providers.include?(payment_provider)
       end
     end
 
-    scope :deep, -> { includes(:addresses, :user, order_items: :purchasable) }
-    scope :sorted, -> { order(:id) }
-
-    scope :purchased, -> { where(state: EffectiveOrders::PURCHASED) }
-    scope :purchased_by, lambda { |user| purchased.where(user: user) }
-    scope :not_purchased, -> { where.not(state: EffectiveOrders::PURCHASED) }
+    before_save(if: -> { state_was == EffectiveOrders::PURCHASED }) do
+      raise EffectiveOrders::AlreadyPurchasedException.new('cannot unpurchase an order') unless purchased?
+    end
 
-    scope :pending, -> { where(state: EffectiveOrders::PENDING) }
-    scope :confirmed, -> { where(state: EffectiveOrders::CONFIRMED) }
-    scope :deferred, -> { where(state: EffectiveOrders::DEFERRED) }
-    scope :declined, -> { where(state: EffectiveOrders::DECLINED) }
-    scope :abandoned, -> { where(state: EffectiveOrders::ABANDONED) }
-    scope :refunds, -> { purchased.where('total < ?', 0) }
+    before_save(if: -> { done? }) do
+      raise('cannot change total of a purchased order') if changes[:total].present?
+    end
 
     # Effective::Order.new()
     # Effective::Order.new(Product.first)
@@ -165,7 +168,7 @@ module Effective
       if atts.kind_of?(Hash)
         items = Array(atts[:item]) + Array(atts[:items])
 
-        self.user = atts[:user] || (items.first.user if items.first.respond_to?(:user))
+        self.user = atts[:user] || items.first.try(:user)
 
         if (address = atts[:billing_address]).present?
           self.billing_address = address
@@ -280,7 +283,7 @@ module Effective
         if purchasable.blank? || purchasable.marked_for_destruction?
           item.mark_for_destruction
         else
-          item.price = purchasable.price
+          item.assign_purchasable_attributes
         end
       end
 
@@ -386,6 +389,20 @@ module Effective
       state == EffectiveOrders::DEFERRED
     end
 
+    def in_progress?
+      pending? || confirmed? || deferred?
+    end
+
+    def done?
+      persisted? && (purchased? || declined?)
+    end
+
+    # A custom order is one that was created by an admin
+    # We allow custom orders to have their order items updated
+    def custom_order?
+      order_items.all? { |oi| oi.purchasable_type == 'Effective::Product' }
+    end
+
     def purchased?(provider = nil)
       return false if (state != EffectiveOrders::PURCHASED)
       return true if provider.nil? || payment_provider == provider.to_s
@@ -548,6 +565,10 @@ module Effective
       true
     end
 
+    def skip_quickbooks!
+      sync_quickbooks!(skip: true)
+    end
+
     def defer!(provider: 'none', email: true)
       return false if purchased?
 
@@ -624,10 +645,6 @@ module Effective
       EffectiveOrders.send_email(:refund_notification_to_admin, self) if purchased? && refund?
     end
 
-    def skip_qb_sync!
-      EffectiveOrders.use_effective_qb_sync ? EffectiveQbSync.skip_order!(self) : true
-    end
-
     protected
 
     def get_tax_rate
@@ -651,56 +668,42 @@ module Effective
       order_items.reject { |oi| oi.marked_for_destruction? }
     end
 
-    def assign_order_totals
-      self.subtotal = present_order_items.map { |oi| oi.subtotal }.sum
-      self.tax_rate = get_tax_rate()
-      self.tax = get_tax()
-      self.total = subtotal + (tax || 0)
-    end
-
     def assign_billing_name
-      self.billing_name = [(billing_address.full_name.presence if billing_address.present?), (user.to_s.presence)].compact.first
+      self.billing_name = billing_address.try(:full_name).presence || user.to_s.presence
     end
 
     def assign_email
-      self.email = user&.email if user&.email.present?
-    end
-
-    def assign_last_address
-      return unless user.present?
-      return unless (EffectiveOrders.billing_address || EffectiveOrders.shipping_address)
-      return if EffectiveOrders.billing_address && billing_address.present?
-      return if EffectiveOrders.shipping_address && shipping_address.present?
-
-      last_order = Effective::Order.sorted.where(user: user).last
-      return unless last_order.present?
-
-      if EffectiveOrders.billing_address && last_order.billing_address.present?
-        self.billing_address = last_order.billing_address
-      end
-
-      if EffectiveOrders.shipping_address && last_order.shipping_address.present?
-        self.shipping_address = last_order.shipping_address
-      end
+      self.email = user.email if user.try(:email).present?
     end
 
     def assign_user_address
       return unless user.present?
-      return unless (EffectiveOrders.billing_address || EffectiveOrders.shipping_address)
-      return if EffectiveOrders.billing_address && billing_address.present?
-      return if EffectiveOrders.shipping_address && shipping_address.present?
 
-      if billing_address.blank? && user.respond_to?(:billing_address) && user.billing_address.present?
+      if EffectiveOrders.billing_address && billing_address.blank? && user.try(:billing_address).present?
         self.billing_address = user.billing_address
         self.billing_address.full_name ||= user.to_s.presence
       end
 
-      if shipping_address.blank? && user.respond_to?(:shipping_address) && user.shipping_address.present?
+      if EffectiveOrders.shipping_address && shipping_address.blank? && user.try(:shipping_address).present?
         self.shipping_address = user.shipping_address
         self.shipping_address.full_name ||= user.to_s.presence
       end
     end
 
+    # This overwrites the prices, taxes, etc on every save.
+    def assign_order_totals
+      # Copies prices from purchasable into order items
+      present_order_items.each { |oi| oi.assign_purchasable_attributes }
+
+      # Sum of order item subtotals
+      subtotal = present_order_items.map { |oi| oi.subtotal }.sum
+
+      self.subtotal = subtotal
+      self.tax_rate = get_tax_rate()
+      self.tax = get_tax()
+      self.total = subtotal + (tax || 0)
+    end
+
     def update_purchasables_purchased_order!
       order_items.each { |oi| oi.purchasable&.update_column(:purchased_order_id, self.id) }
     end

data/app/models/effective/order_item.rb

@@ -3,7 +3,9 @@ module Effective
     self.table_name = EffectiveOrders.order_items_table_name.to_s
 
     belongs_to :order
+
     belongs_to :purchasable, polymorphic: true
+    accepts_nested_attributes_for :purchasable, allow_destroy: false
 
     if defined?(EffectiveQbSync)
       has_one :qb_order_item
@@ -18,21 +20,27 @@ module Effective
       timestamps
     end
 
-    validates :purchasable, associated: true, presence: true
-    accepts_nested_attributes_for :purchasable
+    scope :purchased, -> { where(order_id: Effective::Order.purchased) }
+    scope :purchased_by, lambda { |user| where(order_id: Effective::Order.purchased_by(user)) }
 
     validates :name, presence: true
     validates :quantity, presence: true, numericality: { greater_than: 0 }
     validates :price, presence: true
     validates :tax_exempt, inclusion: { in: [true, false] }
 
-    scope :purchased, -> { where(order_id: Effective::Order.purchased) }
-    scope :purchased_by, lambda { |user| where(order_id: Effective::Order.purchased_by(user)) }
-
     def to_s
       ((quantity || 0) > 1 ? "#{quantity}x #{name}" : name) || 'order item'
     end
 
+    # This method is called in a before_validation in order.assign_order_totals()
+    def assign_purchasable_attributes
+      assign_attributes(name: purchasable.purchasable_name, price: purchasable.price, tax_exempt: purchasable.tax_exempt) if purchasable
+    end
+
+    def build_purchasable(atts = {})
+      (self.purchasable ||= Effective::Product.new).tap { |purchasable| purchasable.assign_attributes(atts) }
+    end
+
     def purchased_download_url
       purchasable&.purchased_download_url
     end
@@ -58,16 +66,13 @@ module Effective
     end
 
     def price=(value)
-      if value.kind_of?(Integer)
-        super
-      else
-        raise 'expected price to be an Integer representing the number of cents.'
-      end
+      raise 'expected price to be an Integer representing the number of cents.' unless value.kind_of?(Integer)
+      super
     end
 
     # first or build
     def qb_item_name
-      raise('expected EffectiveQbSync gem') unless defined?(EffectiveQbSync)
+      raise('expected Effective Quickbooks gem') unless defined?(EffectiveQbSync) || defined?(EffectiveQbOnline)
       (qb_order_item || build_qb_order_item(name: purchasable&.qb_item_name)).name
     end
 

data/app/models/effective/product.rb

@@ -4,7 +4,7 @@ module Effective
 
     acts_as_purchasable
 
-    # belongs_to :purchased_order_id
+    has_many :order_items, as: :purchasable
 
     effective_resource do
       name          :string

data/app/views/admin/orders/_form.html.haml

@@ -1,22 +1,24 @@
-= effective_form_with(model: [:admin, order], url: (order.persisted? ? effective_orders.admin_order_path(order) : effective_orders.admin_orders_path)) do |f|
-  - if f.object.new_record?
-    - user_collection = current_user.class.respond_to?(:sorted) ? current_user.class.sorted : current_user.class.all
-
-    = f.select :user_id, (@users || user_collection),
-      label: 'Buyer', required: true, hint: 'The user that should purchase this order.'
+= effective_form_with(model: [:admin, order], engine: true) do |f|
+  = f.hidden_field :user_type, value: (f.object.user || current_user).class.name
 
-    = f.email_cc_field :cc, hint: "Cc the above on any emailed receipts or payment requests."
+  - collection = (@users || current_user.class.try(:sorted) || current_user.class.all)
+  = f.select :user_id, collection, label: 'Buyer', required: true, hint: 'The user that should purchase this order.'
 
-    %h2 Order Items
-    = f.has_many :order_items, remove: f.object.new_record? do |fc|
-      = render 'order_item_fields', f: fc
-
-    %hr
+  = f.email_cc_field :cc, hint: "Cc the above on any emailed receipts or payment requests."
 
+  - if f.object.new_record?
     = f.check_box :send_payment_request_to_buyer,
       label: 'Yes, send a payment request email to the buyer and any cc.',
       value: (f.object.send_payment_request_to_buyer.nil? ? EffectiveOrders.send_payment_request_to_buyer : f.object.send_payment_request_to_buyer?)
 
+  %hr
+
+  %h2 Order Items
+  = f.has_many :order_items, remove: true do |fc|
+    = render 'order_item_fields', f: fc
+
+  %hr
+
   .row
     .col-md-6.effective-order-note-to-buyer
       %h2 Note to Buyer

data/app/views/admin/orders/_order_item_fields.html.haml

@@ -1,10 +1,19 @@
 .row.align-items-center
-  = f.fields_for :purchasable, (f.object.purchasable || Effective::Product.new) do |pf|
-    .col= f.number_field :quantity, input_html: { value: f.object.quantity || 1, min: 1 }
-    .col= pf.text_field :name
+  = f.fields_for :purchasable, (f.object.purchasable || f.object.build_purchasable) do |pf|
+    -# Order item fields
+    .col
+      = f.hidden_field :purchasable_id
+      = f.hidden_field :purchasable_type
+      = f.number_field :quantity, input_html: { value: f.object.quantity || 1, min: 1 }
+
+    -# Purchasable fields
+    .col
+      = pf.hidden_field :id
+      = pf.text_field :name
+
     .col= pf.price_field :price
 
-    - if EffectiveOrders.use_effective_qb_sync
+    - if EffectiveOrders.qb_sync? || EffectiveOrders.qb_online?
       .col= pf.text_field :qb_item_name, label: 'Quickbooks Item'
 
     .col= pf.check_box :tax_exempt, label: "Tax Exempt", title: 'When checked, tax will not be applied to this item'

data/app/views/admin/orders/edit.html.haml

@@ -1,6 +1,15 @@
 %h1.effective-admin-heading= @page_title
 
-= render partial: 'effective/orders/order', locals: { order: @order }
+- if @order.custom_order? && @order.in_progress?
+  = render 'effective/orders/order_actions', order: @order
 
-.effective-order
-  = render partial: 'form', locals: { order: @order }
+  .mb-4
+    = collapse('show order') do
+      = render 'effective/orders/order', order: @order, no_order_actions: true
+
+  = render 'admin/orders/form', order: @order
+
+- else
+  - # Same as the show action
+  = render 'effective/orders/order', order: @order
+  = render 'admin/orders/form_note_internal', order: @order

data/app/views/admin/orders/new.html.haml

@@ -1,4 +1,3 @@
 %h1.effective-admin-heading= @page_title
 
-.effective-order
-  = render partial: 'form', locals: { order: @order }
+= render 'admin/orders/form', order: @order

data/app/views/admin/orders/show.html.haml

@@ -1,4 +1,4 @@
 %h1.effective-admin-heading= @page_title
 
-= render partial: 'effective/orders/order', locals: { order: @order }
-= render partial: 'admin/orders/form_note_internal', locals: { order: @order }
+= render 'effective/orders/order', order: @order
+= render 'admin/orders/form_note_internal', order: @order

data/app/views/effective/orders/_order_actions.html.haml

@@ -7,8 +7,14 @@
       class: 'btn btn-secondary',
       data: { method: :post, confirm: "Send receipt to #{order.emails_send_to}?" }
 
-  - if order.persisted? && EffectiveResources.authorized?(controller, :admin, :effective_orders)
-    - if order.pending? || order.confirmed? || order.deferred?
+  - if controller_path.include?('admin/') && (EffectiveResources.authorized?(controller, :admin, :effective_orders) rescue false)
+    - if order.persisted? && order.in_progress?
+      - if params[:action] == 'show'
+        = link_to('Edit', effective_orders.edit_admin_order_path(order), class: 'btn btn-primary')
+
+      - if params[:action] == 'edit'
+        = link_to('Show', effective_orders.admin_order_path(order), class: 'btn btn-primary')
+
       = link_to 'Email request for payment to buyer', effective_orders.send_payment_request_admin_order_path(order),
         class: 'btn btn-secondary',
         data: { method: :post, confirm: "Send request for payment to #{order.emails_send_to}?" }

data/app/views/effective/orders/mark_as_paid/_form.html.haml

@@ -13,15 +13,15 @@
         label: 'Payment card type, cheque or transaction number',
         hint: 'Do not enter credit card numbers here, or anywhere.'
 
+      = f.check_box :send_mark_as_paid_email_to_buyer,
+        label: 'Yes, send a receipt email to the buyer.',
+        input_html: { checked: (f.object.send_mark_as_paid_email_to_buyer.nil? ? EffectiveOrders.send_order_receipts_when_mark_as_paid : f.object.send_mark_as_paid_email_to_buyer?) }
+
+
       .row
         .col
           = f.text_area :note_to_buyer, hint: 'This message will be displayed to the buyer on the receipt.'
         .col
           = f.text_area :note_internal, hint: 'For or internal admin use only. This note will never be displayed to the buyer.'
 
-      = f.check_box :send_mark_as_paid_email_to_buyer,
-        label: 'Yes, send a receipt email to the buyer.',
-        input_html: { checked: (f.object.send_mark_as_paid_email_to_buyer.nil? ? EffectiveOrders.send_order_receipts_when_mark_as_paid : f.object.send_mark_as_paid_email_to_buyer?) }
-
-
       = f.submit order_checkout_label(order.refund? ? :refund : :mark_as_paid)

data/lib/effective_orders/version.rb

@@ -1,3 +1,3 @@
 module EffectiveOrders
-  VERSION = '5.5.2'.freeze
+  VERSION = '5.6.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_orders
 version: !ruby/object:Gem::Version
-  version: 5.5.2
+  version: 5.6.2
 platform: ruby
 authors:
 - Code and Effect
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-16 00:00:00.000000000 Z
+date: 2022-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails