gemgento 2.8.0

data/app/models/gemgento/adapter/sellect/product.rb

@@ -0,0 +1,250 @@
+module Gemgento::Adapter::Sellect
+  class Product < ActiveRecord::Base
+    establish_connection("sellect_#{Rails.env}".to_sym) if Gemgento::Config[:sellect]
+
+    def self.import(currency = 'usd', app_root = '/Users/Kevin/Sites/victoria_beckham_sites/vb_old/')
+      #TODO: Unmapped attributes - color, hex_color, available_on, tax_category_id, shipping_category_id, on_sale, sale_price, model_name, size_pictured, product_details, count_on_hand, style_color, is_representative_color, season_id
+      self.table_name = 'sellect_products'
+
+      self.where('deleted_at IS NULL').each do |sellect_product|
+        import_configurable_product(currency, app_root, sellect_product)
+      end
+    end
+
+    def self.import_configurable_product(sellect_product, currency, app_root)
+      product = Gemgento::Product.not_deleted.configurable.find_or_initialize_by(sku: sellect_product.sku)
+
+      product.magento_type = 'configurable'
+      product.sku = sellect_product.sku
+      product.status = 1
+      product.product_attribute_set = Gemgento::ProductAttributeSet.first
+      product.visibility = 4
+      product.sync_needed = false
+      product.save
+
+      product.set_attribute_value('name', sellect_product.name)
+      product.set_attribute_value('short_description', sellect_product.description)
+      product.set_attribute_value('url_key', sellect_product.permalink)
+      product.set_attribute_value('meta_description', sellect_product.meta_description)
+      product.set_attribute_value('meta_keyword', sellect_product.meta_keywords)
+      product.set_attribute_value('description', sellect_product.detail_description)
+      product.set_attribute_value('style_code', sellect_product.style)
+
+      product.stores << Gemgento::Store.current unless product.stores.include? Gemgento::Store.current
+
+      set_categories(sellect_product.id, product)
+
+      simple_products = import_simple_products(sellect_product.id, product, app_root, currency)
+
+      if simple_products.size <= 1 # if one or less simple products, the configurable is not needed
+        product.destroy
+      else # configurable is needed, set configurable attrbitues and simple products
+        set_configurable_attribute(product, 'size')
+        set_configurable_attribute(product, 'color')
+
+        simple_products.each do |simple_product|
+          product.simple_products << simple_product unless product.simple_products.include?(simple_product)
+        end
+
+        product.sync_needed = true
+        product.save
+
+        create_configurable_images(product)
+      end
+    end
+
+    def self.import_simple_products(sellect_id, configurable_product, app_root, currency = 'usd')
+      self.table_name = 'sellect_variants'
+
+      simple_products = []
+      upc = Gemgento::ProductAttribute.find_by(code: 'upc')
+      raise "Missing required product attribute 'UPC'" if upc.nil?
+
+      sellect_variants = self.where('product_id = ?', sellect_id)
+
+      sellect_variants.each do |sellect_variant|
+        product = Gemgento::Product.not_deleted.simple.filter({ attribute: upc, value: sellect_variant.upc }).first_or_initialize
+        product.magento_type = 'simple'
+        product.status = 1
+        product.visibility = sellect_variants.size > 1 ? 1 : 4
+        product.product_attribute_set = configurable_product.product_attribute_set
+        product.sync_needed = false
+        product.save
+
+        product.set_attribute_value('name', configurable_product.name)
+        product.set_attribute_value('short_description', configurable_product.description)
+        product.set_attribute_value('url_key', configurable_product.url_key)
+        product.set_attribute_value('meta_description', configurable_product.meta_description)
+        product.set_attribute_value('meta_keyword', configurable_product.meta_keyword)
+        product.set_attribute_value('description', configurable_product.description)
+        product.set_attribute_value('style_code', configurable_product.style_code)
+        product.set_attribute_value('upc', sellect_variant.upc)
+        product.set_attribute_value('weight', sellect_variant.weight.nil? ? 0 : sellect_variant.weight)
+        product.set_attribute_value('price', get_price(sellect_variant.id, currency))
+        product.stores << Gemgento::Store.current unless product.stores.include? Gemgento::Store.current
+        product.categories = configurable_product.categories
+        product.sync_needed = false
+        product.save
+
+        set_option_values(sellect_variant.id, product)
+
+        product.sku = "#{sellect_variant.sku}_#{product.size}"
+
+        product.sync_needed = true
+        product.save
+
+        set_assets(sellect_variant, product, app_root)
+
+        simple_products << product
+      end
+
+      return simple_products
+    end
+
+    def self.set_option_values(sellect_id, product)
+      self.table_name = 'sellect_option_types'
+
+      self.all.each do |option|
+        attribute = Gemgento::ProductAttribute.find_by(code: option.name.downcase)
+        label = get_option_label(option.id, sellect_id)
+        label = '' if label.nil?
+
+        attribute_option = Gemgento::ProductAttributeOption.find_by(product_attribute_id: attribute.id, label: label)
+
+        if attribute_option.nil?
+          attribute_option = create_attribute_option(attribute, label)
+        end
+
+        product.set_attribute_value(attribute.code, attribute_option.value)
+        product.sync_needed = false
+        product.save
+      end
+    end
+
+    def self.get_option_label(option_id, variant_id)
+      self.table_name = 'sellect_option_values'
+      option_value = self.joins(ActiveRecord::Base.escape_sql(
+                    'INNER JOIN sellect_option_values_variants ON sellect_option_values_variants.option_value_id = sellect_option_values.id ' +
+                        'AND sellect_option_values.option_type_id = ? AND sellect_option_values_variants.variant_id = ?',
+                    option_id,
+                    variant_id
+                )).first
+
+      return option_value.name
+    end
+
+    def self.create_attribute_option(product_attribute, option_label)
+      attribute_option = Gemgento::ProductAttributeOption.new
+      attribute_option.product_attribute = product_attribute
+      attribute_option.label = option_label
+      attribute_option.store = Gemgento::Store.current
+      attribute_option.sync_needed = false
+      attribute_option.save
+
+      attribute_option.sync_needed = true
+      attribute_option.sync_local_to_magento
+      attribute_option.destroy
+
+      return Gemgento::ProductAttributeOption.where(product_attribute: product_attribute, label: option_label).first
+    end
+
+    def self.set_assets(sellect_product, gemgento_product, app_root)
+      self.inheritance_column = :_type_disabled
+      self.table_name = 'sellect_assets'
+
+      self.where(viewable_id: sellect_product.id, viewable_type: 'Sellect::Variant').each do |sellect_asset|
+        file = "#{app_root}/#{sellect_asset.id}/original/#{sellect_asset.attachment_file_name}"
+
+        if File.exist?(file)
+          image = Gemgento::Asset.new
+
+          Gemgento::Asset.unscoped do
+            gemgento_product.assets.reload.each do |asset|
+              if !asset.asset_file.nil? && FileUtils.compare_file(asset.asset_file.file.path(:original), file)
+                image = asset
+                break
+              end
+            end
+          end
+
+          image.product = gemgento_product
+          image.store = Gemgento::Store.current
+          image.position = sellect_asset.position
+          image.label = sellect_asset.alt
+          image.set_file(File.open(file))
+          image.asset_types << Gemgento::AssetType.all
+          image.sync_needed = false
+          image.save
+
+          image.sync_needed = true
+          image.save
+
+          image
+        end
+      end
+    end
+
+    def self.get_price(variant_id, currency)
+      self.table_name = 'sellect_pricings'
+
+      pricing = self.where('variant_id = ? AND currency LIKE ?', variant_id, currency).first
+
+      if pricing.nil?
+        return nil
+      else
+        return pricing.price
+      end
+    end
+
+    def self.set_categories(product_id, product)
+      self.table_name = 'sellect_product_categories'
+
+      self.joins(ActiveRecord::Base.escape_sql(
+                'INNER JOIN sellect_product_positions ON sellect_product_positions.product_category_id = sellect_product_categories.id ' +
+                    'AND sellect_product_positions.product_id = ?',
+                product_id
+            )).each do |sellect_category|
+        categories = Gemgento::Category.where(url_key: sellect_category.permalink)
+
+        categories.each do |category|
+          product.categories << category unless product.categories.include? category
+        end
+      end
+    end
+
+    def self.set_configurable_attribute(product, attribute_code)
+      attribute = Gemgento::ProductAttribute.find_by(code: attribute_code)
+      product.configurable_attributes << attribute unless product.configurable_attributes.include?(attribute)
+    end
+
+    def self.create_configurable_images(configurable_product)
+      default_product = configurable_product.simple_products.first
+
+      default_product.assets.each do |asset|
+
+        asset_copy = Gemgento::Asset.new
+
+        configurable_product.assets.where(store: Gemgento::Store.current).each do |existing_configurable_asset|
+          if !existing_configurable_asset.asset_file.nil? && FileUtils.compare_file(existing_configurable_asset.asset_file.file.path(:original), asset.asset_file.file.path(:original))
+            asset_copy = existing_configurable_asset
+            break
+          end
+        end
+
+        asset_copy.product = configurable_product
+        asset_copy.store = asset.store
+        asset_copy.set_file(File.open(asset.asset_file.file.path(:original)))
+        asset_copy.label = asset.label
+        asset_copy.position = asset.position
+        asset_copy.asset_types = asset.asset_types
+
+        asset_copy.sync_needed = false
+        asset_copy.save
+
+        asset_copy.sync_needed = true
+        asset_copy.save
+      end
+    end
+
+  end
+end

data/app/models/gemgento/adapter/sellect_adapter.rb

@@ -0,0 +1,16 @@
+module Gemgento::Adapter
+  class SellectAdapter < ActiveRecord::Base
+    establish_connection("sellect_#{Rails.env}".to_sym) if Gemgento::Config[:sellect]
+
+    def self.query(table_name)
+      self.table_name = table_name
+      return self
+    end
+
+    def self.import(store, currency)
+      Gemgento::Store.current = store
+      Gemgento::Adapter::Sellect::Product.import(currency)
+    end
+
+  end
+end

data/app/models/gemgento/adapter/shopify/address.rb

@@ -0,0 +1,40 @@
+module Gemgento::Adapter::Shopify
+  class Address
+
+    # Import Shopify address to Gemgento
+    #
+    # @param address [ShopifyAPI::Address]
+    # @param user [Gemgento::User]
+    # @param skip_existing[Boolean]
+    # @return [Gemgento::Address]
+    def self.import(shopify_address, user, skip_existing = false)
+      if shopify_adapter = Gemgento::Adapter::ShopifyAdapter.find_by_shopify_model(shopify_address)
+        address = shopify_adapter.gemgento_model
+        return address if skip_existing
+      else
+        address = Gemgento::Address.new
+      end
+
+      address.addressable = user
+      address.address1 = shopify_address.address1
+      address.address2 = shopify_address.address2
+      address.city = shopify_address.city
+      address.company = shopify_address.company
+      address.country = Gemgento::Country.find_by(iso2_code: shopify_address.country_code)
+      address.first_name = shopify_address.first_name
+      address.last_name = shopify_address.last_name
+      address.telephone = shopify_address.phone
+      address.region = Gemgento::Region.find_by(code: shopify_address.province_code)
+      address.postcode = shopify_address.zip
+      address.is_billing = shopify_address.default ? true : false
+      address.is_shipping = shopify_address.default ? true : false
+      address.sync_needed = true
+      address.save
+
+      Gemgento::Adapter::ShopifyAdapter.create_association(address, shopify_address) if address.shopify_adapter.nil?
+
+      return address
+    end
+
+  end
+end

data/app/models/gemgento/adapter/shopify/category.rb

@@ -0,0 +1,51 @@
+require 'shopify_api'
+
+module Gemgento::Adapter::Shopify
+  class Category
+
+    # Import all Shopify collections.
+    #
+    # @return [void]
+    def self.import
+      page = 1
+      ShopifyAPI::Base.site = Gemgento::Adapter::ShopifyAdapter.api_url
+      shopify_collections = ShopifyAPI::CustomCollection.where(limit: 250, page: page)
+
+      while shopify_collections.any?
+        shopify_collections.each do |collection|
+          sync_shopify_category(collection)
+        end
+
+        page = page + 1
+        shopify_collections = ShopifyAPI::CustomCollection.where(limit: 250, page: page)
+      end
+    end
+
+    # Create Gemgento::Category from Shopify collection.
+    #
+    # @param collection [ShopifyAPI::CustomCollection]
+    # @return [Gemgento::Category]
+    def self.sync_shopify_category(collection)
+      if shopify_adapter = Gemgento::Adapter::ShopifyAdapter.find_by_shopify_model(collection)
+        category = shopify_adapter.gemgento_model
+      else
+        category = Gemgento::Category.new
+      end
+
+      category.url_key = collection.handle
+      category.name = collection.title
+      category.parent = Gemgento::Category.root
+      category.image = URI.parse(collection.image) if collection.has_attribute? :image
+      category.is_active = collection.published_at ? true : false
+      category.include_in_menu = false
+      category.stores = Gemgento::Store.where.not(code: 'admin')
+      category.sync_needed = true
+      category.save
+
+      Gemgento::Adapter::ShopifyAdapter.create_association(category, collection)
+
+      return category
+    end
+
+  end
+end

data/app/models/gemgento/adapter/shopify/customer.rb

@@ -0,0 +1,66 @@
+require 'shopify_api'
+
+module Gemgento::Adapter::Shopify
+  class Customer
+
+    # Import all customers from Shopify.
+    #
+    # @param skip_existing [Boolean]
+    # @return [Void]
+    def self.import(skip_existing = false)
+      page = 1
+      ShopifyAPI::Base.site = Gemgento::Adapter::ShopifyAdapter.api_url
+
+      shopify_customers = ShopifyAPI::Customer.where(limit: 250, page: page)
+
+      while shopify_customers.any?
+        shopify_customers.each do |customer|
+          user = create_user(customer, skip_existing)
+          create_addresses(customer, user, skip_existing)
+        end
+
+        page = page + 1
+        shopify_customers = ShopifyAPI::Customer.where(limit: 250, page: page)
+      end
+    end
+
+    # Create a user from Shopify customer.
+    #
+    # @param shopify_customer [ShopifyAPI::Customer]
+    # @param skip_existing [Boolean]
+    # @return [Gemgento::User]
+    def self.create_user(shopify_customer, skip_existing)
+      if shopify_adapter = Gemgento::Adapter::ShopifyAdapter.find_by_shopify_model(shopify_customer)
+        user = shopify_adapter.gemgento_model
+        return user if skip_existing && !user.magento_id.nil?
+      else
+        user = Gemgento::User.new
+      end
+
+      user.email = shopify_customer.email
+      user.first_name = shopify_customer.first_name
+      user.last_name = shopify_customer.last_name
+      user.user_group = Gemgento::UserGroup.find_by(code: 'General')
+      user.stores = Gemgento::Store.all
+      user.sync_needed = true
+      user.save validate: false
+
+      Gemgento::Adapter::ShopifyAdapter.create_association(user, shopify_customer)
+
+      return user
+    end
+
+    # Import all addresses for a shopify customer.
+    #
+    # @param shopify_customer [ShopifyAPI::Customer]
+    # @param user [Gemgento::User]
+    # @param skip_existing [Boolean]
+    # @return [Void]
+    def self.create_addresses(shopify_customer, user, skip_existing)
+      shopify_customer.addresses.each do |shopify_address|
+        Gemgento::Adapter::Shopify::Address.import(shopify_address, user, skip_existing)
+      end
+    end
+
+  end
+end

data/app/models/gemgento/adapter/shopify/order.rb

@@ -0,0 +1,334 @@
+require 'csv'
+require 'shopify_api'
+
+module Gemgento::Adapter::Shopify
+  class Order
+
+    # Export all shopify orders to a CSV.
+    #
+    # @return [Void]
+    def self.export
+      ShopifyAPI::Base.site = Gemgento::Adapter::ShopifyAdapter.api_url
+      page = 1
+      shopify_orders = ShopifyAPI::Order.where(limit: 250, page: page)
+
+      CSV.open('orders.csv', 'wb') do |csv|
+        csv << order_export_headers
+
+        while shopify_orders.any?
+          shopify_orders.each do |shopify_order|
+            csv << order_row(shopify_order)
+          end
+
+          page = page + 1
+          shopify_orders = ShopifyAPI::Order.where(limit: 250, page: page)
+        end
+      end
+    end
+
+    # Generate CSV headers for an order export.
+    #
+    # @return [Array(String)]
+    def self.order_export_headers
+      %w[
+          order_id website email password group_id store_id payment_method shipping_method
+          billing_prefix billing_firstname billing_middlename billing_lastname billing_suffix
+          billing_street_full billing_city billing_region billing_country billing_postcode
+          billing_telephone billing_company billing_fax shipping_prefix shipping_firstname
+          shipping_middlename shipping_lastname shipping_suffix shipping_street_full shipping_city
+          shipping_region shipping_country shipping_postcode shipping_telephone shipping_company
+          shipping_fax created_in is_subscribed customer_id created_at updated_at tax_amount
+          shipping_amount discount_amount subtotal grand_total total_paid total_refunded
+          total_qty_ordered total_canceled total_invoiced total_online_refunded total_offline_refunded
+          base_tax_amount base_shipping_amount base_discount_amount base_subtotal base_grand_total
+          base_total_paid base_total_refunded base_total_qty_ordered base_total_canceled base_total_invoiced
+          base_total_online_refunded base_total_offline_refunded subtotal_refunded subtotal_canceled
+          discount_refunded discount_invoiced tax_refunded tax_canceled shipping_refunded shipping_canceled
+          base_subtotal_refunded base_subtotal_canceled base_discount_refunded base_discount_canceled
+          base_discount_invoiced base_tax_refunded base_tax_canceled base_shipping_refunded
+          base_shipping_canceled subtotal_invoiced tax_invoiced shipping_invoiced base_subtotal_invoiced
+          base_tax_invoiced base_shipping_invoiced shipping_tax_amount base_shipping_tax_amount
+          shipping_tax_refunded base_shipping_tax_refunded products_ordered order_status
+      ]
+    end
+
+    # Create a row for the given order.
+    #
+    # @param order [ShopifyAPI::Order]
+    # @return [Array(String)]
+    def self.order_row(order)
+      user = Gemgento::User.find_by(email: order.email)
+      store = store(order)
+
+      begin
+        shipping_address = order.shipping_address
+      rescue
+        shipping_address = nil
+      end
+
+      begin
+        billing_address = order.billing_address
+      rescue
+        billing_address = nil
+      end
+
+      totals = totals(order)
+      line_items = order.line_items
+
+      [
+          order.order_number, # order_id
+          store.code, # website
+          order.email, # email
+          '', # password
+          user_group(user), # group_id
+          store.magento_id, # store_id
+          'payment_cryozonic_stripe', # payment_method
+          'flatrate_flatrate', # shipping_method
+          '', # billing_prefix
+          (billing_address ? billing_address.first_name : ''), # billing_firstname
+          '', # billing_middlename
+          (billing_address ? billing_address.last_name : ''), # billing_lastname
+          '', # billing_suffix
+          (billing_address ? street(billing_address) : ''), # billing_street_full
+          (billing_address ? billing_address.city : ''), # billing_city
+          (billing_address ? billing_address.province : ''), # billing_region
+          (billing_address ? billing_address.country : ''), # billing_country
+          (billing_address ? billing_address.zip : ''), # billing_postcode
+          (billing_address ? billing_address.phone : ''), # billing_telephone
+          (billing_address ? billing_address.company : ''), # billing_company
+          '', # billing_fax
+          '', # shipping_prefix
+          (shipping_address ? shipping_address.first_name : ''), # shipping_firstname
+          '', # shipping_middlename
+          (shipping_address ? shipping_address.last_name : ''), # shipping_lastname
+          '', # shipping_suffix
+          (shipping_address ? street(shipping_address) : ''), # shipping_street_full
+          (shipping_address ? shipping_address.city : ''), # shipping_city
+          (shipping_address ? shipping_address.province : ''), # shipping_region
+          (shipping_address ? shipping_address.country : ''), # shipping_country
+          (shipping_address ? shipping_address.zip : ''), # shipping_postcode
+          (shipping_address ? shipping_address.phone : ''), # shipping_telephone
+          (shipping_address ? shipping_address.company : ''), # shipping_company
+          '', # shipping_fax
+          store.name, # created_in
+          (order.buyer_accepts_marketing ? 1 : 0), # is_subscribed
+          (user.nil? ? nil : user.magento_id), # customer_id
+          order.created_at, # created_at
+          order.updated_at, # updated_at
+          totals[:tax], # tax_amount
+          totals[:shipping], # shipping_amount
+          totals[:discount], # discount_amount
+          totals[:subtotal], # subtotal
+          totals[:grand], # grand_total
+          totals[:paid], # total_paid
+          totals[:refunded], # total_refunded
+          quantity_ordered(order), # total_qty_ordered
+          totals[:canceled], # total_canceled
+          totals[:grand], # total_invoiced
+          totals[:refunded], # total_online_refunded
+          0, # total_offline_refunded
+          totals[:tax], # base_tax_amount
+          totals[:shipping], # base_shipping_amount
+          totals[:discount], # base_discount_amount
+          totals[:subtotal], # base_subtotal
+          totals[:grand], # base_grand_total
+          totals[:paid], # base_total_paid
+          totals[:refunded], # base_total_refunded
+          quantity_ordered(order), # base_total_qty_ordered
+          totals[:canceled], # base_total_canceled
+          totals[:grand], # base_total_invoiced
+          totals[:refunded], # base_total_online_refunded
+          0, # base_total_offline_refunded
+          totals[:refunded], # subtotal_refunded
+          totals[:canceled], # subtotal_canceled
+          0, # discount_refunded
+          0, # discount_invoiced
+          0, # tax_refunded
+          0, # tax_canceled
+          0, # shipping_refunded
+          0, # shipping_canceled
+          totals[:refunded], # base_subtotal_refunded
+          totals[:canceled], # base_subtotal_canceled
+          0, # base_discount_refunded
+          0, # base_discount_canceled
+          0, # base_discount_invoiced
+          0, # base_tax_refunded
+          0, # base_tax_canceled
+          0, # base_shipping_refunded
+          0, # base_shipping_canceled
+          totals[:subtotal], # subtotal_invoiced
+          totals[:tax], # tax_invoiced
+          totals[:shipping], # shipping_invoiced
+          totals[:subtotal], # base_subtotal_invoiced
+          totals[:tax], # base_tax_invoiced
+          totals[:shipping], # base_shipping_invoiced
+          0, # shipping_tax_amount
+          0, # base_shipping_tax_amount
+          0, # shipping_tax_refunded
+          0, # base_shipping_tax_refunded
+          products_ordered(line_items, store), # products_ordered
+          order_status(order) # order_status
+      ]
+    end
+
+    # Retrieve the store related to the order.
+    #
+    # @param order [ShopifyAPI::Order]
+    # @return [Gemgento::Store]
+    def self.store(order)
+      return Gemgento::Store.current
+    end
+
+    # Calculate the various totals for an order.
+    #
+    # @param [ShopifyAPI::Order]
+    # @return [Hash(Double)]
+    def self.totals(order)
+      totals = {}
+      totals[:subtotal] = order.subtotal_price
+      totals[:tax] = order.total_tax
+      totals[:shipping] = shipping_amount(order)
+      totals[:discount] = order.total_discounts
+      totals[:grand] = order.total_price
+      totals[:refunded] = refund_amount(order)
+      totals[:paid] = paid_amount(order)
+      totals[:canceled] = (order.financial_status == 'voided') ? totals[:paid] : 0.0
+
+      return totals
+    end
+
+    # Get the user group from the provided user.  Default to NOT LOGGED IN.
+    #
+    # @param user [Gemgento::User, nil]
+    # @return [String]
+    def self.user_group(user)
+      if user.nil?
+        return Gemgento::UserGroup.find_by(magento_id: 0).code
+      else
+        return user.user_group.code
+      end
+    end
+
+    # Get a formatted street attribute from an address.
+    #
+    # @param address [ShopifyAPI::ShippingAddress, ShopifyAPI::BillingAddress]
+    # @return [String]
+    def self.street(address)
+      street = address.address1
+      street = "#{street}\n#{address.address2}" unless address.address2.blank?
+
+      return street
+    end
+
+    # Calculate the amount paid for an order.
+    #
+    # @param order [ShopifyAPI::Order]
+    # @return [Float]
+    def self.paid_amount(order)
+      return order.total_price if order.financial_status == 'paid'
+
+      begin
+        total = 0.0
+
+        order.transactions.each do |transaction|
+          total = total + transaction.amount.to_f if (transaction.kind == 'capture' && transaction.status == 'success')
+        end
+
+        return total
+      rescue
+        return 0.0
+      end
+    end
+
+    # Calculate total shipping cost for shopify order.
+    #
+    # @param order [ShopifyAPI::Order]
+    # @return [Float]
+    def self.shipping_amount(order)
+      total = 0.0
+
+      order.shipping_lines.each do |shipping_line|
+        total = total + shipping_line.price.to_f
+      end
+
+      return total
+    end
+
+    # Calculate the total amount refunded.
+    #
+    # @param order [ShopifyAPI::Order]
+    # @return [Float]
+    def self.refund_amount(order)
+      total = 0.0
+
+      order.refunds.each do |refund|
+        refund.transactions.each do |transaction|
+          total = total + transaction.amount.to_f if transaction.kind = 'refund'
+        end
+      end
+
+      return total
+    end
+
+    # Calculate total quantity of ordered items.
+    #
+    # @param [ShopifyAPI::Order]
+    # @return [Float]
+    def self.quantity_ordered(order)
+      total = 0.0
+
+      order.line_items.each do |line_item|
+        total = total + line_item.quantity.to_f
+      end
+
+      return total
+    end
+
+    # Generate a string of line item details for the order.
+    #
+    # @param line_items [ShopifyAPI::LineItem]
+    # @param store [Gemgento::Store]
+    def self.products_ordered(line_items, store)
+      ordered = []
+
+      line_items.each do |line_item|
+        if shopify_adapter = Gemgento::Adapter::ShopifyAdapter.find_by(shopify_model_type: 'ShopifyAPI::Variant', shopify_model_id: line_item.variant_id)
+          product = shopify_adapter.gemgento_model
+        else
+          product = Gemgento::Product.find_by(sku: Gemgento::Adapter::Shopify::Product.normalize_sku(line_item.sku))
+        end
+
+        if product
+          ordered << "#{product.sku}:#{line_item.quantity}:#{line_item.price}"
+        else
+          ordered << "#{Gemgento::Adapter::Shopify::Product.normalize_sku(line_item.sku)}:#{line_item.quantity}:#{line_item.price}"
+        end
+      end
+
+      return ordered.join('|')
+    end
+
+    # Determine the Magento order status from a Shopify order.
+    #
+    # @param order [ShopifyAPI::Order]
+    # @return [String]
+    def self.order_status(order)
+      if %w[paid refunded partially_refunded].include? order.financial_status
+        if order.fulfillment_status == 'shipped'
+          return 'complete'
+        elsif %w[refunded partially_refunded].include? order.financial_status
+          return 'complete'
+        else
+          return 'pending'
+        end
+      elsif order.financial_status == 'pending'
+        return 'pending'
+      elsif order.financial_status == 'voided'
+        return 'canceled'
+      else
+        return 'complete'
+      end
+    end
+
+  end
+end