gemgento 2.8.0

data/app/models/gemgento/import.rb

@@ -0,0 +1,125 @@
+module Gemgento
+  class Import < ActiveRecord::Base
+    enum state: { pending: 0, processing: 1, complete: 2, failed: 3 }
+
+    has_attached_file :file
+
+    after_initialize :set_default_options,
+                     :set_default_process_errors
+
+    before_create :set_total_rows
+
+    after_commit :process_later, if: Proc.new { |r| r.transaction_include_any_action?([:create]) }
+
+    validates :file, presence: :true
+    validates_attachment_content_type :file, content_type: [
+        'application/octet-stream', # TODO: remove this once Paperclip fixes this problem wth Chrome and FF
+        'application/vnd.ms-excel', # .xls
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', # .xlsx
+        'application/vnd.ms-excel.sheet.macroEnabled.12', # .xlsm
+        'text/csv', # .csv
+        'application/vnd.oasis.opendocument.spreadsheet', # .ods
+    ]
+
+    attr_accessor :spreadsheet, :header_row, :row
+
+    serialize :options, Hash
+    serialize :process_errors, Array
+
+    def set_default_process_errors
+      self.process_errors ||= []
+    end
+
+    def set_default_options
+      self.options = default_options.merge(self.options || {})
+
+      self.options.keys.each do |key|
+        self.class.send :define_method, key do |*args|
+          self.options[key.to_sym]
+        end
+
+        self.class.send :define_method, "#{key}=" do |*args|
+          self.options[key.to_sym] = args.first
+        end
+      end
+    end
+
+    def default_options
+      {}
+    end
+
+    def set_total_rows
+      self.total_rows = spreadsheet.last_row - spreadsheet.first_row
+    end
+
+    def percentage_complete
+      total_rows > 0 ? ((current_row.to_f / total_rows.to_f) * 100.0) : 0.0
+    end
+
+    def spreadsheet
+      @spreadsheet ||= begin
+        if self.new_record?
+          Roo::Spreadsheet.open(self.file.queued_for_write[:original].path).sheet(0)
+        else
+          Roo::Spreadsheet.open(File.open(self.file.path)).sheet(0)
+        end
+      end
+    end
+
+    def header_row
+      @header_row ||= spreadsheet.row spreadsheet.first_row
+    end
+
+    def process
+      Rails.logger.debug "Start #{self.class}.process"
+      Rails.logger.debug "  header_row: #{self.header_row}"
+
+      self.current_row = 0
+      self.processing!
+
+      while self.current_row < self.total_rows do
+        self.current_row += 1
+
+        self.row = spreadsheet.row(self.current_row + spreadsheet.first_row)
+        Rails.logger.debug "  Working on Row #{self.current_row} - #{self.row}"
+
+        self.process_row
+        self.save!
+      end
+
+      self.complete!
+
+      Rails.logger.debug "Complete #{self.class}.process"
+
+    rescue Exception => e
+      # don't raise so that we have a record of the import and don't cause stacking with retries
+      self.process_errors << e.message
+      self.failed!
+      Rails.logger.error e
+    end
+
+    def process_later
+      Gemgento::ImportJob.perform_later(self)
+    end
+
+    # @return [Range]
+    def content_index_range
+      ((spreadsheet.first_row + 1)..spreadsheet.last_row)
+    end
+
+    def value(code, type = :string)
+      index = header_row.index(code)
+      value = row[index]
+
+      case type
+        when :boolean
+          return value.to_bool
+        when :string
+          return value.to_s.strip
+        else
+          return value
+      end
+    end
+
+  end
+end

data/app/models/gemgento/inventory.rb

@@ -0,0 +1,60 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class Inventory < ActiveRecord::Base
+    include Gemgento::ProductTouches
+
+    belongs_to :product, class_name: 'Gemgento::Product'
+    belongs_to :store, class_name: 'Gemgento::Store'
+
+    # Inventory.backorder may have one of the following values:
+    # 0 - no backorders
+    # 1 - allow qty below 0
+    # 2 - allow qty below 0 and notify customer
+    validates :backorders, inclusion: 0..2
+    validates :product, uniqueness: { scope: :store }
+
+    before_save :sync_local_to_magento, if: -> { sync_needed? }
+
+    attr_accessor :use_config_manage_stock
+
+    # Push the inventory data to Magento.
+    #
+    # @return [Boolean] true if the inventory data was successfully pushed to Magento
+    def push
+      API::SOAP::CatalogInventory::StockItem.update(self.product);
+    end
+
+    # Determine if the specified quantity is in stock.
+    #
+    # @param quantity [Integer] the required quantity
+    # @return [Boolean] true if the required quantity is in stock
+    def in_stock?(quantity = 1)
+      if !self.manage_stock?
+        return true
+      elsif self.is_in_stock && ((quantity.to_f <= self.quantity.to_f || quantity.to_f == 0) || self.backorders > 0)
+        return true
+      else
+        return false
+      end
+    end
+
+    private
+
+    # Push local inventory changes to magento.
+    #
+    # @return [Void]
+    def sync_local_to_magento
+      response = API::SOAP::CatalogInventory::StockItem.update(self)
+
+      if response.success?
+        self.sync_needed = false
+        return true
+      else
+        errors.add(:base, response.body[:faultstring])
+        return false
+      end
+    end
+
+  end
+end

data/app/models/gemgento/inventory_import.rb

@@ -0,0 +1,51 @@
+require 'spreadsheet'
+require 'open-uri'
+
+module Gemgento
+
+  # @author Gemgento LLC
+  class InventoryImport < Import
+    attr_accessor :product
+
+    validates_with InventoryImportValidator, on: :create
+
+    # Set the Inventory for a Product.
+    #
+    # @return [Void]
+    def process_row
+      self.product = Gemgento::Product.not_deleted.find_by(sku: row[header_row.index('sku').to_i])
+
+      return if self.product.magento_type == 'configurable'
+      Gemgento::Store.all.each do |store|
+        inventory = self.product.inventories.find_or_initialize_by(store: store)
+
+        inventory.use_config_manage_stock = true
+        inventory.use_config_backorders = true
+        inventory.use_config_min_qty = true
+
+        header_row.each do |attribute|
+          next unless Gemgento::Inventory.column_names.include?(attribute)
+
+          value = value(attribute, Gemgento::Inventory.columns_hash[attribute].type)
+          inventory.assign_attributes(attribute => value)
+        end
+
+        inventory.sync_needed = true
+
+        unless inventory.save
+          self.process_errors << "Row ##{current_row}: #{inventory.errors[:base]}"
+        end
+      end
+    rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => e
+      retries ||= 0
+      if retries += 1 <= @stores.count
+        retry
+      else
+        self.process_errors << "Row ##{current_row}: #{e.message}"
+      end
+    rescue Exception => e
+      self.process_errors << "Row ##{current_row}: #{e.message}"
+    end
+
+  end
+end

data/app/models/gemgento/line_item.rb

@@ -0,0 +1,142 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class LineItem < ActiveRecord::Base
+    scope :refunded, -> { where.not(qty_refunded: 0) }
+
+    serialize :options, Hash
+
+    attr_accessor :async, :destroy_quote_after_rollback
+
+    belongs_to :itemizable, polymorphic: true, touch: true
+    belongs_to :product
+
+    has_many :bundle_options, class_name: 'Gemgento::LineItemOption', foreign_key: :line_item_id
+
+    before_save :push_magento_quote_item, if: -> { itemizable_type == 'Gemgento::Quote' && !async.to_bool }
+
+    after_save :push_magento_quote_item_async, if: -> { itemizable_type == 'Gemgento::Quote' && async.to_bool }
+
+    before_destroy :destroy_magento_quote_item, if: -> { itemizable_type == 'Gemgento::Quote' }
+
+    after_rollback :destroy_quote, if: -> { destroy_quote_after_rollback == true && itemizable_type == 'Gemgento::Quote' }
+
+    accepts_nested_attributes_for :bundle_options
+
+    validates :itemizable, :product, presence: true
+    validates :magento_id, uniqueness: { scope: :itemizable_type }, allow_nil: true
+    validates_with InventoryValidator, if: -> { itemizable_type == 'Gemgento::Quote' }
+
+    # JSON representation of the LineItem.
+    #
+    # @param options [Hash]
+    # @return [Void]
+    def as_json(options = nil)
+      result = super
+      result['product'] = self.product.as_json({ store: Store.find(self.itemizable.store.id) })
+      return result
+    end
+
+    # Get the associated Product price.
+    #
+    # @return [BigDecimal]
+    def price
+      return super.to_d unless super.nil?
+
+      if product.magento_type == 'giftvoucher'
+        self.options[:amount].to_d
+      elsif self.options[:custom_price]
+        self.options[:custom_price].to_d
+      else
+        user_group = itemizable.user ? itemizable.user.user_group : nil
+        product.price(user_group, itemizable.store, self.qty_ordered).to_d
+      end
+
+    end
+
+    private
+
+    # Create or Update the associated Magento Quote Item.
+    #
+    # @return [Boolean]
+    def push_magento_quote_item
+      if new_record?
+        response = API::SOAP::Checkout::Product.add(itemizable, [self])
+      else
+        response = API::SOAP::Checkout::Product.update(itemizable, [self])
+      end
+
+      if response.success?
+        return true
+      else
+        handle_magento_response(response)
+        return false
+      end
+    end
+
+    # Create or Update the associated Magento Quote Item asynchronously.
+    #
+    # @return [Void]
+    def push_magento_quote_item_async
+      if id_was.nil?
+        Cart::AddItemWorker.perform_async(self.id)
+      else
+        Cart::UpdateItemWorker.perform_async(self.id, self.qty_ordered_was)
+      end
+    end
+
+    # Destroy the associated Magento Quote Item.
+    #
+    # @return [Boolean]
+    def destroy_magento_quote_item
+      response = API::SOAP::Checkout::Product.remove(itemizable, [self])
+
+      if response.success?
+        return true
+      elsif response.body[:faultcode].to_i == 1026 # item does not belong to quote
+        return true
+      else
+        handle_magento_response(response)
+        return false
+      end
+    end
+
+    # Handle the Magento create/update/destroy response.  Mark quote for destroy if it no longer exists in Magento.
+    #
+    # @param response [Gemgento::MagentoResponse]
+    # @return [Void]
+    def handle_magento_response(response)
+      if response.body[:faultcode].to_i == 1002 && itemizable_type == 'Gemgento::Quote' # quote doesn't exist in Magento.
+        self.destroy_quote_after_rollback = true
+      else
+        self.errors.add(:base, response.body[:faultstring])
+      end
+    end
+
+    # Destroy the associated quote.
+    #
+    # @return [Void]
+    def destroy_quote
+      LineItem.skip_callback(:destroy, :before, :destroy_magento_quote_item)
+      self.itemizable.destroy
+      LineItem.set_callback(:destroy, :before, :destroy_magento_quote_item)
+    end
+
+
+    def self.serialized_attr_accessor(*args)
+      args.each do |method_name|
+        eval "
+        def #{method_name}
+          (self.options || {})[:#{method_name}]
+        end
+        def #{method_name}=(value)
+          self.options ||= {}
+          self.options[:#{method_name}] = value
+        end
+             "
+      end
+    end
+
+
+  end
+end

data/app/models/gemgento/line_item_option.rb

@@ -0,0 +1,10 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class LineItemOption < ActiveRecord::Base
+    belongs_to :line_item, class_name: 'Gemgento::LineItem'
+    belongs_to :bundle_item, class_name: 'Gemgento::Bundle::Item'
+
+    validates :bundle_item, uniqueness: { scope: :line_item }
+  end
+end

data/app/models/gemgento/magento_db.rb

@@ -0,0 +1,35 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class MagentoDB < ActiveRecord::Base
+
+    # Associate configurable and simple Products by reading directly from the Magento table with the association data.
+    #
+    # @param configurable_product [Gemgento::Product]
+    # @return [Array(Gemgento::Product)]
+    def self.associated_simple_products(configurable_product)
+      establish_connection("magento_#{Rails.env}".to_sym)
+
+      self.table_name = "#{Config[:magento][:table_prefix]}catalog_product_super_link"
+      simple_products = []
+
+      self.where('parent_id = ?', configurable_product.magento_id).each do |association|
+        simple_product = Product.where(magento_id: association.product_id).first
+        simple_products << simple_product unless simple_product.nil?
+      end
+
+      simple_products
+    end
+
+    # Query the Magento database using ActiveRecord.
+    #
+    # @param table_name [String]
+    # @return [ActiveRecord::Result]
+    def self.query(table_name)
+      establish_connection("magento_#{Rails.env}".to_sym)
+
+      self.table_name = Config[:magento][:table_prefix] + table_name
+      return self
+    end
+  end
+end

data/app/models/gemgento/magento_response.rb

@@ -0,0 +1,10 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class MagentoResponse < ActiveRecord::Base
+    serialize :request, Hash
+    serialize :body, Hash
+
+    attr_accessor :body_overflow
+  end
+end

data/app/models/gemgento/order.rb

@@ -0,0 +1,56 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class Order < ActiveRecord::Base
+    belongs_to :store, class_name: 'Gemgento::Store'
+    belongs_to :user, class_name: 'Gemgento::User'
+    belongs_to :user_group, class_name: 'Gemgento::UserGroup'
+    belongs_to :quote, class_name: 'Gemgento::Quote'
+
+    has_many :api_jobs, class_name: 'Gemgento::ApiJob', as: :source, dependent: :destroy
+    has_many :line_items, as: :itemizable, class_name: 'Gemgento::LineItem', dependent: :destroy
+    has_many :order_statuses, class_name: 'Gemgento::OrderStatus', dependent: :destroy
+    has_many :products, through: :line_items, class_name: 'Gemgento::Product'
+    has_many :shipments, class_name: 'Gemgento::Shipment', dependent: :destroy
+    has_many :shipment_tracks, class_name: 'Gemgento::ShipmentTrack', through: :shipments
+
+    has_one :payment, as: :payable, class_name: 'Gemgento::Payment', dependent: :destroy
+    has_one :billing_address, -> { where is_billing: true }, class_name: 'Gemgento::Address', as: :addressable, dependent: :destroy
+    has_one :shipping_address, -> { where is_shipping: true }, class_name: 'Gemgento::Address', as: :addressable, dependent: :destroy
+
+    attr_accessor :tax, :total, :push_cart_customer, :subscribe
+
+    validates :customer_email, format: /@/, allow_nil: true
+    validates :status, presence: true
+    validates :increment_id, :magento_id, uniqueness: true
+
+    after_save :mark_quote_converted, if: -> { quote && quote.converted_at.nil? && !state.blank? }
+
+    # Return the increment_id instead of id.  This is for privacy purposes.
+    #
+    # @return [String]
+    def to_param
+      self.increment_id
+    end
+
+    # Set associated quote converted_at.
+    #
+    # @return [Void]
+    def mark_quote_converted
+      quote.update(converted_at: Time.now)
+    end
+
+    # Find or fetch an order by increment_id.
+    #
+    # @param increment_id [String]
+    # @return [Gemgento::Order]
+    def self.find_or_fetch(increment_id)
+      Gemgento::Order.find_by(increment_id: increment_id) || Gemgento::Magento::OrderAdapter.find(increment_id).import
+    end
+
+    def placed_at
+      super || self.created_at
+    end
+
+  end
+end