erp_orders 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e462b6d0534235ea385e6837474e1305e8be2f5
-  data.tar.gz: 1d7127f89c3657cb616464755fc125924572908c
+  metadata.gz: 5b6867785c98bc211e0349e3c5a3c2d7139277ce
+  data.tar.gz: 10720ff3b69094fe0c7c2873eec1eec70c70dad5
 SHA512:
-  metadata.gz: 97c4b54627004f27ff46faa7f4cc49472d28426c63e3191cc76872e87b97f0deb27cf6d848d092ee41d16a01fb983dcf41d1692a6565dcd1abd83dccbfc26358
-  data.tar.gz: d7db617036bd2dac557a01ad6ed246608d466fc1ae7ef9fddc8e4be88cf4cc7131a1e1e3e3e5168d0483f15c856bde9b5045c7149aab561e6634b7987cd31a6d
+  metadata.gz: 9206b5e1533e05612c2e2fc3b5dd21da40bba895deae4b53ec422eba56815b50ce5484deb3f5cad050d00fb6aecf7f546a7838aaa5d6d3d0ecc22e5152e4e9e7
+  data.tar.gz: 75dcd09070cd56edb15ab308878f818b07681b0c21edc4df9d484c50c6a969b9caa103a6163a8533f9d81872593de9009dac17e7b085a0a55e459fe4b8311b59

data/app/models/charge_line.rb

@@ -1,23 +1,41 @@
+# create_table :charge_lines do |t|
+#   t.string      :sti_type
+#   t.references  :money
+#   t.string      :description     #could be expanded to include type information, etc.
+#   t.string      :external_identifier
+#   t.string      :external_id_source
+#
+#   #polymorphic
+#   t.references :charged_item, :polymorphic => true
+#
+#   t.timestamps
+# end
+#
+# add_index :charge_lines, [:charged_item_id, :charged_item_type], :name => 'charged_item_idx'
+
 class ChargeLine < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   belongs_to :charged_item, :polymorphic => true
-  belongs_to :money
-  has_many :charge_line_payment_txns, :dependent => :destroy
-  has_many :financial_txns, :through => :charge_line_payment_txns, :source => :financial_txn,
-           :conditions => ["charge_line_payment_txns.payment_txn_type = ?", 'FinancialTxn']
+  belongs_to :money, :dependent => :destroy
+  belongs_to :charge_type
 
-  def payment_txns
-    self.financial_txns
+  has_many :sales_tax_lines, as: :taxed_record, dependent: :destroy
+
+  def taxed?
+    self.charge_type.try(:taxable)
   end
 
-  def add_payment_txn(payment_txn)
-    charge_line_payment_txn = ChargeLinePaymentTxn.new
-    charge_line_payment_txn.charge_line = self
-    charge_line_payment_txn.payment_txn = payment_txn
-    charge_line_payment_txn.save
-    charge_line_payment_txns << charge_line_payment_txn
-    self.save
+  # calculates tax and save to sales_tax
+  def calculate_tax(ctx={})
+    taxation = ErpOrders::Taxation.new
+
+    self.sales_tax = taxation.calculate_tax(self,
+                                            ctx.merge({
+                                                          amount: money.amount
+                                                      }))
   end
 
 end

data/app/models/charge_type.rb

@@ -0,0 +1,7 @@
+class ChargeType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_erp_type
+
+  has_many :charge_lines
+end

data/app/models/extensions/party.rb

@@ -1,3 +1,16 @@
 Party.class_eval do
   has_many :order_line_item_pty_roles
+
+  def orders(statuses=[])
+    statement = OrderTxn
+
+    unless statuses.empty?
+      statement = statement.with_current_status({'order_statuses' => statuses})
+    end
+
+    statement = statement.joins(:biz_txn_event => :biz_txn_party_roles)
+            .where(:biz_txn_party_roles => {:party_id => self.id})
+
+    statement
+  end
 end

data/app/models/order_line_item.rb

@@ -1,34 +1,170 @@
+# create_table :order_line_items do |t|
+#   t.integer  	  :order_txn_id
+#   t.integer  	  :order_line_item_type_id
+#   t.integer     :product_offer_id
+#   t.string      :product_offer_description
+#   t.integer     :product_instance_id,
+#   t.string      :product_instance_description
+#   t.integer     :product_type_id
+#   t.string      :product_type_description
+#   t.decimal  	  :sold_price, :precision => 8, :scale => 2
+#   t.integer	    :sold_price_uom
+#   t.integer  	  :sold_amount
+#   t.integer     :sold_amount_uom
+#   t.integer     :quantity
+#   t.integer     :unit_of_measurement_id
+#   t.decimal     :unit_price, :precision => 8, :scale => 2
+#   t.boolean     :taxable
+#   t.decimal     :sales_tax, :precision => 8, :scale => 2
+#
+#   t.timestamps
+# end
+#
+# add_index :order_line_items, :order_txn_id
+# add_index :order_line_items, :order_line_item_type_id
+# add_index :order_line_items, :product_instance_id
+# add_index :order_line_items, :product_type_id
+# add_index :order_line_items, :product_offer_id
+
 class OrderLineItem < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
-	belongs_to :order_txn, :class_name => 'OrderTxn'
-	belongs_to :order_line_item_type
-	
-  has_many :charge_lines, :as => :charged_item
+  tracks_created_by_updated_by
+
+  belongs_to :order_txn, :class_name => 'OrderTxn'
+  belongs_to :order_line_item_type
+
+  has_many :charge_lines, :as => :charged_item, :dependent => :destroy
 
   belongs_to :product_instance
   belongs_to :product_type
+  belongs_to :product_offer
 
   has_many :order_line_item_pty_roles, :dependent => :destroy
   has_many :role_types, :through => :order_line_item_pty_roles
+  has_many :sales_tax_lines, as: :taxed_record, dependent: :destroy
 
   ## Allow for polymorphic subtypes of this class
   belongs_to :order_line_record, :polymorphic => true
 
-  def get_total_charges
+  before_destroy :destroy_order_line_item_relationships
+
+  def taxed?
+    line_item_record.taxable?
+  end
+
+  # helper method to get dba_organization related to this order_line_item
+  def dba_organization
+    order_txn.find_party_by_role('dba_org')
+  end
+
+  def destroy_order_line_item_relationships
+    OrderLineItemRelationship.where("order_line_item_id_from = ? or order_line_item_id_to = ?", self.id, self.id).destroy_all
+  end
+
+  # get the total charges for a order_line_item.
+  # The total will be returned as Money.
+  # There may be multiple Monies assocated with an order, such as points and
+  # dollars. To handle this, the method should return an array of Monies
+  # if a currency is passed in return the amount for only that currency
+  def total_amount(currency=Currency.usd)
+    if currency and currency.is_a?(String)
+      currency = Currency.send(currency)
+    end
+
+    charges = {}
+
+    # get sold price
+    # TODO currency will eventually need to be accounted for here.  Solid price should probably be a money record
+    if self.sold_price
+      charges["USD"] ||= {amount: 0}
+      charges["USD"][:amount] += (self.sold_price * (self.quantity || 1))
+    end
+
     # get all of the charge lines associated with the order_line
-    total_hash = Hash.new
     charge_lines.each do |charge|
-      cur_money = charge.money
-      cur_total = total_hash[cur_money.currency.internal_identifier]
-      if (cur_total.nil?)
-        cur_total = cur_money.clone
+      charge_money = charge.money
+
+      total_by_currency = charges[charge_money.currency.internal_identifier]
+      unless total_by_currency
+        total_by_currency = {
+            amount: 0
+        }
+      end
+
+      total_by_currency[:amount] += charge_money.amount unless charge_money.amount.nil?
+
+      charges[charge_money.currency.internal_identifier] = total_by_currency
+    end
+
+    # if currency was based only return that amount
+    # if there is only one currency then return that amount
+    # if there is more than once currency return the hash
+    if currency
+      charges[currency.internal_identifier][:amount].round(2)
+    elsif charges.keys.count == 1
+      charges
+    end
+  end
+
+  # calculates tax and save to sales_tax
+  def calculate_tax(ctx={})
+    taxation = ErpOrders::Taxation.new
+    tax = 0
+
+    if self.taxed?
+      tax = taxation.calculate_tax(self,
+                                   ctx.merge({
+                                                 amount: (self.sold_price * (self.quantity || 1))
+                                             }))
+    end
+
+    # only get charges that are USD currency
+    charge_lines.joins(:money).joins(:charge_type)
+        .where('money.currency_id' => Currency.usd)
+        .where('charge_types.taxable' => true).readonly(false).each do |charge_line|
+      tax += charge_line.calculate_tax(ctx)
+    end
+
+    self.sales_tax = tax
+    self.save
+
+    tax
+  end
+
+  # Alias for to_s
+  def to_label
+    to_s
+  end
+
+  # description of line_item_record
+  def to_s
+    if line_item_record
+      line_item_record.description
+    else
+      nil
+    end
+  end
+
+  # determine the record this OrderLineItem pertains to
+  # can be a ProductOffer, ProductInstance or ProductType
+  def line_item_record
+    if product_offer
+      product_offer
+    else
+      if product_instance
+        product_instance
       else
-        cur_total.amount = 0 if cur_total.amount.nil?
-        cur_total.amount += cur_money.amount if !cur_money.amount.nil?
+        product_type
       end
-      total_hash[cur_money.currency.internal_identifier] = cur_total
     end
-    return total_hash.values
   end
+
+  def clone
+    order_line_item_dup = dup
+    order_line_item_dup.order_txn_id = nil
+
+    order_line_item_dup
+  end
+
 end

data/app/models/order_line_item_rel_type.rb

@@ -0,0 +1,6 @@
+class OrderLineItemRelType < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  acts_as_nested_set
+  include ErpTechSvcs::Utils::DefaultNestedSetMethods
+end

data/app/models/order_line_item_relationship.rb

@@ -0,0 +1,8 @@
+class OrderLineItemRelationship < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :order_line_item_from, :class_name => "OrderLineItem", :foreign_key => "order_line_item_id_from"
+  belongs_to :order_line_item_to, :class_name => "OrderLineItem", :foreign_key => "order_line_item_id_to"
+  belongs_to :order_line_item_rel_type
+
+end

data/app/models/order_txn.rb

@@ -1,51 +1,163 @@
+# Table Definition ##########################################
+# create_table :order_txns do |t|
+#   t.column    :description,     		:string
+#   t.column		:order_txn_type_id, 	:integer
+#
+#   # Multi-table inheritance info
+#   t.column    :order_txn_record_id,   :integer
+#   t.column    :order_txn_record_type, :string
+#
+#   # Contact Information
+#   t.column 		:email,              :string
+#   t.column 		:phone_number,       :string
+#
+#   # Shipping Address
+#   t.column 		:ship_to_first_name,     :string
+#   t.column 		:ship_to_last_name,      :string
+#   t.column 		:ship_to_address_line_1, :string
+#   t.column 		:ship_to_address_line_2, :string
+#   t.column 		:ship_to_city,           :string
+#   t.column    :ship_to_state,          :string
+#   t.column 		:ship_to_postal_code,    :string
+#   t.column 		:ship_to_country,        :string
+#
+#   # Private parts
+#   t.column 		:customer_ip, 			    :string
+#   t.column    :order_number,          :string
+#   t.column 		:error_message, 		    :string
+#
+#   t.timestamps
+# end
+#
+# add_index :order_txns, :order_txn_type_id
+# add_index :order_txns, [:order_txn_record_id, :order_txn_record_type], :name => 'order_txn_record_idx'
+#
+# add_index :order_txns, :order_txn_type_id
+# add_index :order_txns, [:order_txn_record_id, :order_txn_record_type], :name => 'order_txn_record_idx'
+
 class OrderTxn < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
-  # serialize custom attributes
-  is_json :custom_fields
-
   acts_as_biz_txn_event
 
   belongs_to :order_txn_record, :polymorphic => true
-  has_many   :order_line_items, :dependent => :destroy
-  has_many   :charge_lines, :as => :charged_item
+  has_many :order_line_items, :dependent => :destroy
+  has_many :charge_lines, :as => :charged_item, :dependent => :destroy
 
   alias :line_items :order_line_items
-  
+
   # validation
   validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :on => :update, :allow_nil => true
+  validates :order_number, {uniqueness: true, :allow_nil => true}
+
+  class << self
+    #find a order by given biz txn party role iid and party
+    def find_by_party_role(biz_txn_party_role_type_iid, party)
+      BizTxnPartyRole.where('party_id = ? and biz_txn_party_role_type_id = ?', party.id, BizTxnPartyRoleType.find_by_internal_identifier(biz_txn_party_role_type_iid).id).all.collect { |item| item.biz_txn_event.biz_txn_record }
+    end
+
+    def next_order_number
+      max_id = maximum('id')
+
+      current_order = where(OrderTxn.arel_table[:order_number].matches("%#{max_id}%")).first
 
-  #find a order by given biz txn party role iid and party
-  def self.find_by_party_role(biz_txn_party_role_type_iid, party)
-    BizTxnPartyRole.where('party_id = ? and biz_txn_party_role_type_id = ?', party.id, BizTxnPartyRoleType.find_by_internal_identifier(biz_txn_party_role_type_iid).id).all.collect{|item| item.biz_txn_event.biz_txn_record}
+      if current_order
+        while current_order
+          max_id = max_id + 1
+          current_order = where(OrderTxn.arel_table[:order_number].matches("%#{max_id}%")).first
+        end
+      else
+        if max_id
+          max_id = max_id + 1
+        else
+          max_id = 1
+        end
+      end
+
+      "#{max_id}"
+    end
+  end
+
+  # helper method to get dba_organization related to this order_txn
+  def dba_organization
+    find_party_by_role('dba_org')
   end
 
   # get the total charges for an order.
   # The total will be returned as Money.
-  # There may be multiple Monies assocated with an order, such as points and
+  # There may be multiple Monies associated with an order, such as points and
   # dollars. To handle this, the method should return an array of Monies
-  #
-  def get_total_charges
-    # get all of the charge lines associated with the order and order_lines
-    total_hash = Hash.new
-    all_charges = get_all_charge_lines
-    # loop through all of the charges and combine charges for each money type
-    all_charges.each do |charge|
-      cur_money = charge.money
-      cur_total = total_hash[cur_money.currency.internal_identifier]
-      if (cur_total.nil?)
-        cur_total = cur_money.clone
+  # if a currency is passed in return the amount for only that currency
+  def total_amount(currency=Currency.usd)
+    if currency and currency.is_a?(String)
+      currency = Currency.send(currency)
+    end
+
+
+    charges = {"USD" => {amount: 0}}
+    # get any charges directly on this order_txn or on order_line_items
+    charge_lines.each do |charge|
+      charge_money = charge.money
+
+      total_by_currency = charges[charge_money.currency.internal_identifier]
+      unless total_by_currency
+        total_by_currency = {
+            amount: 0
+        }
+      end
+
+      total_by_currency[:amount] += charge_money.amount unless charge_money.amount.nil?
+
+      charges[charge_money.currency.internal_identifier] = total_by_currency
+    end
+
+    # TODO currency will eventually need to be accounted for here.
+    charges["USD"][:amount] += line_items.sum(&:total_amount).round(2)
+
+    # add tax
+    charges["USD"][:amount] += (self.sales_tax.nil? ? 0 : self.sales_tax)
+
+    if charges.empty?
+      0
+    else
+      # if currency was based only return that amount
+      # if there is only one currency then return that amount
+      # if there is more than once currency return the hash
+      if currency
+        charges[currency.internal_identifier][:amount].round(2)
       else
-        cur_total.amount = 0 if cur_total.amount.nil?
-        cur_total.amount += cur_money.amount if !cur_money.amount.nil?
+        charges
       end
-      total_hash[cur_money.currency.internal_identifier] = cur_total
     end
-    return total_hash.values
   end
 
-  #get all charge lines on order and order line items
-  def get_all_charge_lines
+  def sub_total(currency=Currency.usd)
+    line_items.collect { |item| item.total_amount(currency) }.inject(:+)
+  end
+
+  # gets the total amount of payments made against this order via charge line payments
+  def total_payment_amount
+    amount = all_charge_lines.collect(&:total_payments).inject(:+)
+    if amount.nil?
+      0
+    else
+      amount
+    end
+
+  end
+
+  # gets total amount due (total_amount - total_payments)
+  # only returns Currency USD
+  def total_amount_due
+    if total_amount(Currency.usd)
+      total_amount(Currency.usd) - total_payment_amount
+    else
+      0
+    end
+  end
+
+  # get all charge lines on order and order line items
+  def all_charge_lines
     all_charges = []
     all_charges.concat(charge_lines)
     order_line_items.each do |line_item|
@@ -54,32 +166,78 @@ class OrderTxn < ActiveRecord::Base
     all_charges
   end
 
-  def submit
-    #Template Method
+  # get the total quantity of this order
+  def total_quantity
+    order_line_items.pluck(:quantity).inject(:+)
+  end
+
+  # calculates tax for each line item and save to sales_tax
+  def calculate_tax(ctx)
+    tax = 0
+    order_line_items.select { |line_item| line_item.taxed? }.each do |line_item|
+      tax += line_item.calculate_tax(ctx)
+    end
+
+    # only get charges that are USD currency
+    charge_lines.joins(:money)
+        .joins(:charge_type)
+        .where('money.currency_id' => Currency.usd)
+        .where('charge_types.taxable' => true).readonly(false).each do |charge_line|
+      tax += charge_line.calculate_tax(ctx)
+    end
+
+    self.sales_tax = tax
+    self.save
+
+    tax
   end
 
   #add product_type or product_instance line item
   def add_line_item(object, reln_type = nil, to_role = nil, from_role = nil)
-    class_name = object.class.name
     if object.is_a?(Array)
-	    class_name = object.first.class.name
-	  else
-	    class_name = object.class.name
-	  end
-
-	  case class_name
-    when 'ProductType'
-      return add_product_type_line_item(object, reln_type, to_role, from_role)
-    when 'ProductInstance'
-      return add_product_instance_line_item(object, reln_type, to_role, from_role)
-	  end
+      class_name = object.first.class.name
+    else
+      class_name = object.class.name
+    end
+
+    case class_name
+      when 'ProductType'
+        add_product_type_line_item(object, reln_type, to_role, from_role)
+      when 'ProductInstance'
+        add_product_instance_line_item(object, reln_type, to_role, from_role)
+      when 'SimpleProductOffer'
+        add_simple_product_offer_line_item(object)
+    end
   end
 
-	def add_product_type_line_item(product_type, reln_type = nil, to_role = nil, from_role = nil)
+  def add_simple_product_offer_line_item(simple_product_offer)
 
-    li = OrderLineItem.new
+    line_item = get_line_item_for_simple_product_offer(simple_product_offer)
 
-    if(product_type.is_a?(Array))
+    product_type = simple_product_offer.product_type
+
+    if line_item
+      ActiveRecord::Base.transaction do
+        line_item.quantity += 1
+        line_item.save
+      end
+    else
+      ActiveRecord::Base.transaction do
+        line_item = OrderLineItem.new
+        line_item.product_type = product_type
+        line_item.product_offer = simple_product_offer.product_offer
+        line_item.sold_price = simple_product_offer.get_current_simple_plan.money_amount
+        line_item.quantity = 1
+        line_item.save
+        line_items << line_item
+      end
+    end
+
+    line_item
+  end
+
+  def add_product_type_line_item(product_type, reln_type = nil, to_role = nil, from_role = nil)
+    if (product_type.is_a?(Array))
       if (product_type.size == 0)
         return
       elsif (product_type.size == 1)
@@ -107,17 +265,32 @@ class OrderTxn < ActiveRecord::Base
       product_type_for_line_item = product_type
     end
 
-    li.product_type = product_type_for_line_item
-    self.line_items << li
-    li.save
-    return li
-	end
+    line_item = get_line_item_for_product_type(product_type_for_line_item)
+
+    if line_item
+      ActiveRecord::Base.transaction do
+        line_item.quantity += 1
+        line_item.save
+      end
+    else
+      ActiveRecord::Base.transaction do
+        line_item = OrderLineItem.new
+        line_item.product_type = product_type_for_line_item
+        line_item.sold_price = product_type_for_line_item.get_current_simple_plan.money_amount
+        line_item.quantity = 1
+        line_item.save
+        line_items << line_item
+      end
+    end
+
+    line_item
+  end
 
   def add_product_instance_line_item(product_instance, reln_type = nil, to_role = nil, from_role = nil)
 
     li = OrderLineItem.new
 
-    if(product_instance.is_a?(Array))
+    if (product_instance.is_a?(Array))
       if (product_instance.size == 0)
         return
       elsif (product_instance.size == 1)
@@ -149,13 +322,24 @@ class OrderTxn < ActiveRecord::Base
     li.product_instance = product_instance_for_line_item
     self.line_items << li
     li.save
-    return li
+
+    li
+  end
+
+  def get_line_item_for_product_type(product_type)
+    line_items.detect { |oli| oli.product_type == product_type }
+  end
+
+  def get_line_item_for_simple_product_offer(simple_product_offer)
+    line_items.detect { |oli| oli.product_offer.product_offer_record == simple_product_offer }
   end
 
   def find_party_by_role(role_type_iid)
     party = nil
 
-    tpr = self.root_txn.biz_txn_party_roles.find(:first, :include => :biz_txn_party_role_type, :conditions => ['biz_txn_party_role_types.internal_identifier = ?',role_type_iid])
+    tpr = self.root_txn.biz_txn_party_roles.includes(:biz_txn_party_role_type)
+              .where('biz_txn_party_role_types.internal_identifier = ?', role_type_iid).first
+
     party = tpr.party unless tpr.nil?
 
     party
@@ -172,9 +356,23 @@ class OrderTxn < ActiveRecord::Base
       self.ship_to_city = shipping_address.city
       self.ship_to_state = shipping_address.state
       self.ship_to_postal_code = shipping_address.zip
-      #self.ship_to_country_name = shipping_address.country_name
-      #self.ship_to_country = shipping_address.country
+      # self.ship_to_country_name = shipping_address.country_name
+      self.ship_to_country = shipping_address.country
+    end
+  end
+
+  # Get shipping info formatted for HTML
+  #
+  def shipping_info
+    info = %(#{ship_to_first_name} #{ship_to_last_name}<br>#{ship_to_address_line_1})
+
+    if ship_to_address_line_2.present?
+      info << "<br>#{ship_to_address_line_2}"
     end
+
+    info << %(<br>#{ship_to_city} #{ship_to_state} #{ship_to_postal_code}<br>#{ship_to_country})
+
+    info
   end
 
   def set_billing_info(party)
@@ -191,11 +389,25 @@ class OrderTxn < ActiveRecord::Base
       self.bill_to_city = billing_address.city
       self.bill_to_state = billing_address.state
       self.bill_to_postal_code = billing_address.zip
-      #self.bill_to_country_name = billing_address.country_name
-      #self.bill_to_country = billing_address.country
+      # self.bill_to_country_name = billing_address.country_name
+      self.bill_to_country = billing_address.country
     end
   end
 
+  # Get billing info formatted for HTML
+  #
+  def billing_info
+    info = %(#{bill_to_first_name} #{bill_to_last_name}<br>#{bill_to_address_line_1}<br>)
+
+    if bill_to_address_line_2.present?
+      info << "<br>#{bill_to_address_line_2}"
+    end
+
+    info << %(<br>#{bill_to_city} #{bill_to_state} #{bill_to_postal_code}<br>#{bill_to_country})
+
+    info
+  end
+
   def determine_txn_party_roles
     #Template Method
   end
@@ -212,8 +424,8 @@ class OrderTxn < ActiveRecord::Base
   #BizTxnEvent Overrides
   ###############################################################################
   def create_dependent_txns
-	  #Template Method
-	end
+    #Template Method
+  end
 
   ################################################################
   ################################################################
@@ -274,9 +486,9 @@ class OrderTxn < ActiveRecord::Base
     unless use_delayed_jobs
       authorized_txns.each do |financial_txn|
         result = financial_txn.capture(credit_card, gateway, gateway_options)
-        unless(result[:success])
+        unless (result[:success])
           all_txns_captured = false
-          gateway_message   = result[:gateway_message]
+          gateway_message = result[:gateway_message]
           break
         end
       end
@@ -312,7 +524,7 @@ class OrderTxn < ActiveRecord::Base
     unless use_delayed_jobs
       authorized_txns.each do |financial_txn|
         result = financial_txn.reverse_authorization(credit_card, gateway, gateway_options)
-        unless(result[:success])
+        unless (result[:success])
           all_txns_rolledback = false
         end
       end
@@ -379,4 +591,45 @@ class OrderTxn < ActiveRecord::Base
     return result, message, authorized_txns
   end
 
+  def clone
+    ActiveRecord::Base.transaction do
+      order_txn_dup = dup
+      order_txn_dup.order_txn_record_id = nil
+      order_txn_dup.order_txn_record_type = nil
+      order_txn_dup.order_number = OrderTxn.next_order_number
+      order_txn_dup.error_message = nil
+      order_txn_dup.payment_gateway_txn_id = nil
+      order_txn_dup.credit_card_id = nil
+      order_txn_dup.initialize_biz_txn_event
+      order_txn_dup.biz_txn_event.description = self.biz_txn_event.description
+
+      # add a relationship describing the original and the clone
+      biz_txn_rel_type = BizTxnRelType.find_or_create('cloned_from', 'Cloned From', nil)
+      BizTxnRelationship.create(txn_event_to: self.root_txn,
+                                txn_event_from: order_txn_dup.root_txn,
+                                biz_txn_rel_type: biz_txn_rel_type)
+
+
+      order_line_item_rel_type = OrderLineItemRelType.find_or_create('cloned_from', 'Cloned From', nil)
+
+      self.order_line_items.each do |order_line_item|
+        order_line_item_clone = order_line_item.clone
+        order_txn_dup.order_line_items << order_line_item_clone
+
+        OrderLineItemRelationship.create(order_line_item_from: order_line_item_clone,
+                                         order_line_item_to: order_line_item,
+                                         order_line_item_rel_type: order_line_item_rel_type)
+
+      end
+      order_txn_dup.save!
+      order_txn_dup.current_status = self.current_status
+
+      order_txn_dup
+    end
+
+  end
+
+  def to_label
+    self.order_number
+  end
 end