jam-cloud/ruby/lib/jam_ruby/models/sale.rb

module JamRuby

  # a sale is created every time someone tries to buy something
  class Sale < ActiveRecord::Base

    JAMTRACK_SALE = 'jamtrack'

    belongs_to :user, class_name: 'JamRuby::User'
    has_many :sale_line_items, class_name: 'JamRuby::SaleLineItem'

    validates :order_total, numericality: {only_integer: false}
    validates :user, presence: true


    def self.preview_invoice(current_user, shopping_carts)

      line_items = {jam_tracks: []}
      shopping_carts_jam_tracks = []
      shopping_carts_subscriptions = []
      shopping_carts.each do |shopping_cart|

        if shopping_cart.is_jam_track?
          shopping_carts_jam_tracks << shopping_cart
        else
          # XXX: this may have to be revisited when we actually have something other than JamTracks for puchase
          shopping_carts_subscriptions << shopping_cart
        end
      end

      jam_track_items = preview_invoice_jam_tracks(current_user, shopping_carts_jam_tracks)
      line_items[:jam_tracks] = jam_track_items if jam_track_items

      # TODO: process shopping_carts_subscriptions

      line_items
    end

    # place_order will create one or more sales based on the contents of shopping_carts for the current user
    # individual subscriptions will end up create their own sale (you can't have N subscriptions in one sale--recurly limitation)
    # jamtracks however can be piled onto the same sale as adjustments (VRFS-3028)
    # so this method may create 1 or more sales, , where 2 or more sales can occur if there are more than one subscriptions or subscription + jamtrack
    def self.place_order(current_user, shopping_carts)

      sales = []
      shopping_carts_jam_tracks = []
      shopping_carts_subscriptions = []
      shopping_carts.each do |shopping_cart|

        if shopping_cart.is_jam_track?
          shopping_carts_jam_tracks << shopping_cart
        else
          # XXX: this may have to be revisited when we actually have something other than JamTracks for puchase
          shopping_carts_subscriptions << shopping_cart
        end
      end

      jam_track_sale = order_jam_tracks(current_user, shopping_carts_jam_tracks)
      sales << jam_track_sale if jam_track_sale

      # TODO: process shopping_carts_subscriptions

      sales
    end

    def self.preview_invoice_jam_tracks(current_user, shopping_carts_jam_tracks)
      ### XXX TODO;

      # we currently use a fake  plan in Recurly to estimate taxes using the Pricing.Attach  metod in Recurly.js

      # if we were to implement this the right way (ensure adjustments are on the account as necessary), then it would be better (more correct)
      # just a pain to implement
    end

    # this method will either return a valid sale, or throw a RecurlyClientError or ActiveRecord validation error (save! failed)
    # it may return an nil sale if the JamTrack(s) specified by the shopping carts are already owned
    def self.order_jam_tracks(current_user, shopping_carts_jam_tracks)

      client = RecurlyClient.new

      sale = nil
      Sale.transaction do
        sale = create_jam_track_sale(current_user)

        if sale.valid?
          account = client.get_account(current_user)
          if account.present?

            purge_pending_adjustments(account)

            created_adjustments = sale.process_jam_tracks(current_user, shopping_carts_jam_tracks, account)

            # now invoice the sale ... almost done

            begin
              invoice = account.invoice!
              sale.recurly_invoice_id = invoice.uuid
              sale.recurly_invoice_number = invoice.invoice_number

              # now slap in all the real tax/purchase totals
              sale.recurly_subtotal_in_cents = invoice.subtotal_in_cents
              sale.recurly_tax_in_cents = invoice.tax_in_cents
              sale.recurly_total_in_cents = invoice.total_in_cents
              sale.recurly_currency = invoice.currency

              puts "Sale Line Items #{sale.sale_line_items.inspect}"

              puts "----"
              puts "Invoice Line Items #{invoice.line_items.inspect}"
              # and resolve against sale_line_items
              sale.sale_line_items.each do |sale_line_item|
                found_line_item = false
                invoice.line_items.each do |line_item|
                  if line_item.uuid == sale_line_item.recurly_adjustment_uuid
                    sale_line_item.recurly_tax_in_cents = line_item.tax_in_cents
                    sale_line_item.recurly_total_in_cents =line_item.total_in_cents
                    sale_line_item.recurly_currency = line_item.currency
                    sale_line_item.recurly_discount_in_cents = line_item.discount_in_cents
                    found_line_item = true
                    break
                  end

                  if !found_line_item
                    @@loge.error("can't find line item #{sale_line_item.recurly_adjustment_uuid}")
                    puts "CANT FIND LINE ITEM"
                  end

                end
              end

              unless sale.save
                raise RecurlyClientError, "Invalid sale (at end)."
              end
            rescue Recurly::Resource::Invalid => e
              # this exception is thrown by invoice! if the invoice is invalid
              sale.rollback_adjustments(current_user, created_adjustments)
              sale = nil
              raise ActiveRecord::Rollback # kill all db activity, but don't break outside logic
            end
          else
            raise RecurlyClientError, "Could not find account to place order."
          end
        else
          raise RecurlyClientError, "Invalid sale."
        end
      end
      sale
    end

    def process_jam_tracks(current_user, shopping_carts_jam_tracks, account)

      created_adjustments = []

      begin
        shopping_carts_jam_tracks.each do |shopping_cart|
          process_jam_track(current_user, shopping_cart, account, created_adjustments)
        end
      rescue Recurly::Error, NoMethodError => x
        # rollback any adjustments created if error
        rollback_adjustments(user, created_adjustments)
        raise RecurlyClientError, x.to_s
      rescue Exception => e
        # rollback any adjustments created if error
        rollback_adjustments(user, created_adjustments)
        raise e
      end

      created_adjustments
    end


    def process_jam_track(current_user, shopping_cart, account, created_adjustments)
      recurly_adjustment_uuid = nil
      recurly_adjustment_credit_uuid = nil

      # we do this because of ShoppingCart.remove_jam_track_from_cart; if it occurs, which should be rare, we need fresh shopping cart info
      shopping_cart.reload

      # get the JamTrack in this shopping cart
      jam_track = shopping_cart.cart_product

      if jam_track.right_for_user(current_user)
        # if the user already owns the JamTrack, we should just skip this cart item, and destroy it
        # if this occurs, we have to reload every shopping_cart as we iterate.  so, we do at the top of the loop
        ShoppingCart.remove_jam_track_from_cart(current_user, shopping_cart)
        return
      end

      # ask the shopping cart to create the correct Recurly adjustment attributes for a JamTrack
      adjustments = shopping_cart.create_adjustment_attributes(current_user)

      adjustments.each do |adjustment|

        # create the adjustment at Recurly (this may not look like it, but it is a REST API)
        created_adjustment = account.adjustments.new(adjustment)
        created_adjustment.save

        # if the adjustment could not be made, bail
        raise RecurlyClientError.new(created_adjustment.errors) if created_adjustment.errors.any?

        # keep track of adjustments we created for this order, in case we have to roll them back
        created_adjustments << created_adjustment

        if ShoppingCart.is_product_purchase?(adjustment)
          # this was a normal product adjustment, so track it as such
          recurly_adjustment_uuid = created_adjustment.uuid
        else
          # this was a 'credit' adjustment, so track it as such
          recurly_adjustment_credit_uuid = created_adjustment.uuid
        end
      end

      # create one sale line item for every jam track
      sale_line_item = SaleLineItem.create_from_shopping_cart(self, shopping_cart, nil, recurly_adjustment_uuid, recurly_adjustment_credit_uuid)

      # if the sale line item is invalid, blow up the transaction
      unless sale_line_item.valid?
        @log.error("sale item invalid! #{sale_line_item.errors.inspect}")
        puts("sale item invalid! #{sale_line_item.errors.inspect}")
        Stats.write('web.recurly.purchase.sale_invalid', {message: sale_line_item.errors.to_s, value: 1})
        raise RecurlyClientError.new(sale_line_item.errors)
      end

      # create a JamTrackRight (this needs to be in a transaction too to make sure we don't make these by accident)
      jam_track_right = JamRuby::JamTrackRight.find_or_create_by_user_id_and_jam_track_id(current_user.id, jam_track.id) do |jam_track_right|
        jam_track_right.redeemed = shopping_cart.free?
      end

      # also if the purchase was a free one, then update the user record to no longer allow redeemed jamtracks
      User.where(id: current_user.id).update_all(has_redeemable_jamtrack: false) if shopping_cart.free?

      # this can't go in the block above, as it's here to fix bad subscription UUIDs in an update path
      if jam_track_right.recurly_adjustment_uuid != recurly_adjustment_uuid
        jam_track_right.recurly_adjustment_uuid = recurly_adjustment_uuid
        jam_track_right.recurly_adjustment_credit_uuid = recurly_adjustment_credit_uuid
        unless jam_track_right.save
          raise RecurlyClientError.new(jam_track_right.errors)
        end
      end

      # delete the shopping cart; it's been dealt with
      shopping_cart.destroy if shopping_cart

      # blow up the transaction if the JamTrackRight did not get created
      raise RecurlyClientError.new(jam_track_right.errors) if jam_track_right.errors.any?
    end


    def rollback_adjustments(current_user, adjustments)
      begin
        adjustments.each { |adjustment| adjustment.destroy }
      rescue Exception => e
        AdminMailer.alerts({
                               subject: "ACTION REQUIRED: #{current_user.email} did not have all of his adjustments destroyed in rollback",
                               body: "go delete any adjustments on the account that don't belong. error: #{e}\n\nAdjustments: #{adjustments.inspect}"
                           }).deliver

      end
    end

    def self.purge_pending_adjustments(account)
      account.adjustments.pending.find_each do |adjustment|
        # we only pre-emptively destroy pending adjustments if they appear to be created by the server
        adjustment.destroy if ShoppingCart.is_server_pending_adjustment?(adjustment)
      end
    end

    def is_jam_track_sale?
      sale_type == JAMTRACK_SALE
    end

    def self.create_jam_track_sale(user)
      sale = Sale.new
      sale.user = user
      sale.sale_type = JAMTRACK_SALE
      sale.order_total = 0
      sale.save
      sale
    end

    # this checks just jamtrack sales appropriately
    def self.check_integrity_of_jam_track_sales
      Sale.select([:total, :voided]).find_by_sql(
          "SELECT COUNT(sales.id) AS total,
          COUNT(CASE WHEN transactions.transaction_type = '#{RecurlyTransactionWebHook::VOID}' THEN 1 ELSE null END) voided
          FROM sales
          LEFT OUTER JOIN recurly_transaction_web_hooks as transactions ON invoice_id = sales.recurly_invoice_id
          WHERE sale_type = '#{JAMTRACK_SALE}'")
    end
  end
end