gemgento 2.8.0

data/app/models/gemgento/asset_file.rb

@@ -0,0 +1,57 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class AssetFile < ActiveRecord::Base
+    has_many :assets
+    has_many :products, through: :assets
+    has_many :stores, through: :assets
+
+    has_attached_file :file, styles: { thumb: "200x", thumb_2x: "400x",
+                                       small: "400x", small_2x: "800x",
+                                       medium: "800x", medium_2x: "1600x",
+                                       large: "1600x", large_2x: "3200x"}
+
+    validates_attachment_content_type :file, content_type: /\Aimage\/.*\Z/
+
+    touch :assets, after_touch: :after_touch
+
+    # Check that a url is valid.  Assumes url is pointing to Magento installation.
+    #
+    # @param url [String]
+    # @return [Boolean]
+    def self.valid_url(url)
+      uri = URI.parse(url)
+      req = Net::HTTP::Get.new(uri)
+
+      unless Gemgento::Config[:magento][:auth_username].blank?
+        req.basic_auth Gemgento::Config[:magento][:auth_username], Gemgento::Config[:magento][:auth_password]
+      end
+
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = uri.port == 443
+      res = http.start  do |http|
+        http.use_ssl = uri.port == 443
+        http.request(req)
+      end
+
+      return res.code == '200'
+    end
+
+    # Get file from Magento.
+    #
+    # @param url [String]
+    # @return [TempFile]
+    def self.from_url(url)
+      if Gemgento::Config[:magento][:auth_username].blank?
+        open(url)
+      else
+        open(url, http_basic_authentication: [
+                    Gemgento::Config[:magento][:auth_username],
+                    Gemgento::Config[:magento][:auth_password]
+                ]
+        )
+      end
+    end
+
+  end
+end

data/app/models/gemgento/asset_type.rb

@@ -0,0 +1,8 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class AssetType < ActiveRecord::Base
+    belongs_to :product_attribute_set, class_name: 'Gemgento::ProductAttributeSet'
+    has_and_belongs_to_many :assets, join_table: 'gemgento_assets_asset_types'
+  end
+end

data/app/models/gemgento/bundle.rb

@@ -0,0 +1,5 @@
+module Gemgento::Bundle
+  def self.table_name_prefix
+    'gemgento_bundle_'
+  end
+end

data/app/models/gemgento/bundle/item.rb

@@ -0,0 +1,17 @@
+module Gemgento
+  module Bundle
+
+    # @author Gemgento LLC
+    class Item < ActiveRecord::Base
+      enum price_type: { fixed: 0, percent: 1 }
+
+      belongs_to :option, class_name: 'Gemgento::Bundle::Option', foreign_key: :bundle_option_id
+      belongs_to :product, class_name: 'Gemgento::Product'
+
+      touch :option, after_touch: :after_touch
+
+      validates :option, :product, presence: true
+      validates :product, uniqueness: { scope: :product }
+    end
+  end
+end

data/app/models/gemgento/bundle/option.rb

@@ -0,0 +1,20 @@
+module Gemgento
+  module Bundle
+
+    # @author Gemgento LLC
+    class Option < ActiveRecord::Base
+      include Gemgento::ProductTouches
+
+      enum input_type: { selection: 0, radio: 1, checkbox: 2, multi: 3 }
+
+      belongs_to :product, class_name: 'Gemgento::Product'
+
+      has_many :items, class_name: 'Gemgento::Bundle::Item', dependent: :destroy, foreign_key: :bundle_option_id
+      has_many :products, through: :items, class_name: 'Gemgento::Product'
+
+      validates :product, presence: true
+
+      default_scope -> { order :position }
+    end
+  end
+end

data/app/models/gemgento/category.rb

@@ -0,0 +1,235 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class Category < ActiveRecord::Base
+    has_many :product_categories, class_name: '::Gemgento::ProductCategory', dependent: :destroy
+    has_many :products, -> { distinct }, through: :product_categories
+    has_many :children, foreign_key: 'parent_id', class_name: '::Gemgento::Category'
+
+    has_one :shopify_adapter, class_name: 'Adapter::ShopifyAdapter', as: :gemgento_model
+
+    belongs_to :parent, foreign_key: 'parent_id', class_name: '::Gemgento::Category'
+
+    has_and_belongs_to_many :stores, -> { distinct }, join_table: 'gemgento_categories_stores', class_name: 'Store'
+
+    touch :parent, after_touch: :after_touch
+
+    has_attached_file :image
+
+    default_scope -> { where(deleted_at: nil).order(:position) }
+
+    scope :top_level, -> { where(parent: Gemgento::Category.find_by(parent_id: nil), is_active: true) }
+    scope :bottom_level, -> { where(is_active: true).where.not(id: Gemgento::Category.all.pluck(:parent_id).uniq.compact) }
+    scope :navigation, -> { where(include_in_menu: true) }
+    scope :root, -> { find_by(parent_id: nil) }
+    scope :active, -> { where(is_active: true) }
+
+    validates_attachment_content_type :image, content_type: /\Aimage\/.*\Z/
+
+    after_save :enforce_positioning, if: :position_changed?
+
+    before_save :create_magento_category, if: Proc.new { |category| category.sync_needed? && category.magento_id.nil? }
+    before_save :update_magento_category, if: Proc.new { |category| category.sync_needed? && !category.magento_id.nil? }
+
+    attr_accessor :sync_needed
+
+    # Create a string representation of the path from the root to the Category.
+    #
+    # @return [String]
+    def tree_path
+      root = Category.root
+      parent = self.parent
+      path = self.name
+
+      while !parent.nil? && parent != root do
+        path = "#{parent.name} > #{path}"
+        parent = parent.parent
+      end
+
+      return path
+    end
+
+    def sync_needed?
+      self.sync_needed.to_bool
+    end
+
+    # Create an options array for use in an HTML select input.  Categories are grouped under top level scoped
+    # categories.
+    #
+    # @return [Array(String, Array(Array(String, Integer)))]
+    def self.grouped_options
+      options = []
+
+      Gemgento::Category.top_level.each do |parent|
+
+        child_options = [["#{parent.name} (parent)", parent.id]]
+
+        parent.children.where(is_active: true, parent: parent).each do |child|
+          child_options << [child.name, child.id]
+          child_options << grouped_option(child) if child.children.where(is_active: true).any?
+        end
+
+        options << [parent.name, child_options]
+      end
+
+      return options
+    end
+
+    def descendents
+      @descendents ||= begin
+        children.includes(:children).map do |child|
+          [child] + child.descendents
+        end.flatten
+      end
+    end
+
+    # Ordered list from root to self, excluding self.
+    #
+    # @return [Array(Gemgento::Category)]
+    def hierarchy
+      parents = []
+      parent = self.parent
+
+      while parent && !parent.parent_id.nil?
+        parents << parent
+        parent = parent.parent
+      end
+
+      return parents.reverse
+    end
+
+    # Get the option value and any subsequent child values as a path.
+    #
+    # @param category [Gemgento::Category]
+    # @return [Array(String, Integer)]
+    def self.grouped_option(category)
+      options = []
+
+      category.children.where(is_active: true, parent: category).each do |child|
+        options << [child.name, child.id]
+
+        child.children.where(is_active: true).each do |nested_child|
+          path = nested_child.tree_path
+          path = path.slice((path.index("> #{child.name} >") + 2)..-1)
+          options << [path, nested_child.id]
+        end
+      end
+
+      return options
+    end
+
+    # Sets the deleted_at to the current timestamp.
+    #
+    # @return [void]
+    def mark_deleted
+      self.deleted_at = Time.now
+      self.shopify_adapter.destroy if self.shopify_adapter
+    end
+
+    # Marks the category as deleted and saves.
+    #
+    # @return [void]
+    def mark_deleted!
+      mark_deleted
+      self.save
+    end
+
+    # Increment the position on all categories that come after.  Used to ensure correct positioning after changing the
+    # position of a single category.
+    #
+    # @return [void]
+    def enforce_positioning
+      Category.skip_callback(:save, :after, :enforce_positioning)
+
+      last_position = self.position
+      categories = Category.where('parent_id = ? AND position >= ? AND id != ?', self.parent_id, self.position, self.id)
+      categories.each do |category|
+        break if category.position != last_position
+
+        category.position = category.position + 1
+        category.save
+
+        last_position = category.position
+      end
+
+      Category.set_callback(:save, :after, :enforce_positioning)
+    end
+
+    # Returns list of ancestors, starting from parent until root.
+    #
+    #   subchild1.ancestors # => [child1, root]
+    #
+    # @return [Array(Category)]
+    def ancestors
+      node, nodes = self, []
+      nodes << node = node.parent while node.parent
+      nodes
+    end
+
+    # Get products associated with the category.  Optional scope of store.
+    #
+    # @param store [Store, nil]
+    # @return [ActiveRecord::Associations::CollectionProxy(Product)]
+    def products(store = nil)
+      return super if store.nil?
+
+      Product
+          .joins(:product_categories)
+          .where('gemgento_product_categories.store_id = ? AND gemgento_product_categories.category_id = ?', store.id, self.id)
+          .order('gemgento_product_categories.position ASC')
+          .uniq
+    end
+
+    def after_touch
+      # do nothing, plcaeholder
+    end
+
+    private
+
+    # Create an associated Category in Magento.
+    #
+    # @return [Boolean]
+    def create_magento_category
+      response = API::SOAP::Catalog::Category.create(self, self.stores.first)
+
+      if response.success?
+        self.magento_id = response.body[:attribute_id]
+        self.sync_needed = false
+
+        self.stores.each_with_index do |store, index|
+          next if index == 0
+          response = API::SOAP::Catalog::Category.update(self, store)
+
+          # If there was a problem updating on of the stores, then make sure the product will be synced on next save.
+          # The product needs to be saved regardless, since a Magento product was created and the id must be set.  So,
+          # this will not return false.
+          self.sync_needed = true unless response.success?
+        end
+
+
+        return true
+      else
+        errors.add(:base, response.body[:faultstring])
+        return false
+      end
+    end
+
+    # Update associate Magento category.
+    #
+    # @return [Boolean]
+    def update_magento_category
+      self.stores.each do |store|
+        response = API::SOAP::Catalog::Category.update(self, store)
+
+        unless response.success?
+          errors.add(:base, response.body[:faultstring])
+          return false
+        end
+      end
+
+      self.sync_needed = false
+      return true
+    end
+
+  end
+end

data/app/models/gemgento/country.rb

@@ -0,0 +1,21 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class Country < ActiveRecord::Base
+    has_many :regions
+
+    default_scope -> { order :name }
+
+    # JSON representation of the Country.
+    #
+    # @param options [Hash]
+    # @return [Hash]
+    def as_json(options = nil)
+      result = super
+      result[:regions] = self.regions if self.regions.loaded?
+
+      return result
+    end
+
+  end
+end

data/app/models/gemgento/gift_message.rb

@@ -0,0 +1,8 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class GiftMessage < ActiveRecord::Base
+    #belongs_to :line_item
+    #belongs_to :order
+  end
+end

data/app/models/gemgento/image_import.rb

@@ -0,0 +1,141 @@
+require 'spreadsheet'
+require 'open-uri'
+
+module Gemgento
+
+  # @author Gemgento LLC
+  class ImageImport < Import
+    attr_accessor :product
+    
+    validates_with ImageImportValidator
+
+    def default_options
+      {
+          image_labels: [],
+          image_file_extensions: [],
+          image_types: [],
+          image_path: nil,
+          store_id: nil,
+          destroy_existing: false
+      }
+    end
+
+    def image_labels_raw
+      image_labels.join("\n")
+    end
+
+    def image_labels_raw=(values)
+      options[:image_labels] = values.gsub("\r", '').split("\n")
+    end
+
+    def image_file_extensions_raw
+      image_file_extensions.join(', ')
+    end
+
+    def image_file_extensions_raw=(values)
+      options[:image_file_extensions] = values.gsub(' ', '').split(',')
+    end
+
+    def image_types_raw
+      image_types.join("\n")
+    end
+
+    def image_types_raw=(values)
+      options[:image_types] = []
+      options[:image_types] = values.gsub("\r", '').split("\n").map { |t| t.split(',').collect(&:strip) }
+    end
+
+    def store
+      if options[:store_id].nil?
+        nil
+      else
+        @store ||= Gemgento::Store.find(options[:store_id])
+      end
+    end
+
+    def destroy_existing?
+      options[:destroy_existing].to_bool
+    end
+
+    def process_row
+      sku = value('sku')
+      self.product = Product.not_deleted.find_by(sku: sku)
+      return if self.product.nil?
+
+      API::SOAP::Catalog::ProductAttributeMedia.fetch(self.product, store)
+      destroy_existing_assets if destroy_existing?
+      create_images
+    end
+
+    # Destroy all Assets associated with self.product.
+    #
+    # @return [Void]
+    def destroy_existing_assets
+      self.product.assets.where(store: store).find_each do |asset|
+        begin
+          asset.destroy
+        rescue
+          # just making sure we don't have a problem if file no longer exists
+        end
+      end
+    end
+
+    # Search for and create all possible images for a product.
+    #
+    # @return [Void]
+    def create_images
+      # find the correct image file name and path
+      self.image_labels.each_with_index do |label, position|
+
+        self.image_file_extensions.each do |extension|
+          file_name = self.image_path + value('image') + '_' + label + extension
+          next unless File.exist?(file_name)
+
+          types = []
+
+          unless self.image_types[position].nil?
+            types = Gemgento::AssetType.where(product_attribute_set:  self.product.product_attribute_set, code: self.image_types[position])
+          end
+
+          unless types.is_a? Array
+            types = [types]
+          end
+
+          create_image(file_name, types, position, label)
+        end
+      end
+
+      # clear the cache
+      Rails.cache.clear
+    end
+
+    # Create an image for the product.
+    #
+    # @param file_name [String]
+    # @param types [Array(String)]
+    # @param position [Integer]
+    # @param label [String]
+    # @return [Void]
+    def create_image(file_name, types, position, label)
+      asset = Asset.new
+      asset.product = self.product
+      asset.store = store
+      asset.position = position
+      asset.label = label
+      asset.set_file(File.open(file_name))
+
+      types.each do |type|
+        asset.asset_types << type
+      end
+
+      asset.sync_needed = false
+      asset.save
+
+      asset.sync_needed = true
+
+      unless asset.save
+        self.process_errors << "Row #{current_row}: #{asset.errors[:base]}"
+      end
+    end
+  end
+end