prestashop 2.0.0

data/lib/prestashop/mapper/models/price_range.rb

@@ -0,0 +1,9 @@
+using Prestashop::Mapper::Refinement
+module Prestashop
+  module Mapper
+    class PriceRange < Model
+      resource :price_ranges
+      model :price_range
+    end
+  end
+end

data/lib/prestashop/mapper/models/product.rb

@@ -0,0 +1,198 @@
+using Prestashop::Mapper::Refinement
+module Prestashop
+  module Mapper
+    class Product < Model
+      resource :products
+      model    :product
+
+      attr_accessor :id_manufacturer, :id_supplier, :id_category_default, :new, :cache_default_attribute, :id_tax_rules_group, :position_in_category,
+                    :manufacturer_name, :quantity, :type, :id_shop_default, :supplier_reference, :location, :width, :height, :depth, 
+                    :weight, :quantity_discount, :ean13, :upc, :cache_is_pack, :cache_has_attachment, :is_virtual, :on_sale, :online_only, :ecotax, :minimal_quantity,
+                    :price, :wholesale_price, :unity, :unit_price_ratio, :additional_shipping_cost, :customizable, :text_fields, :uploadable_files, :active,
+                    :redirect_type, :id_product_redirect, :available_for_order, :available_date, :condition, :show_price, :indexed, :visibility, :advanced_stock_management, :description
+      attr_accessor :id_lang, :id_categories, :id_features
+      attr_writer   :id, :name, :description_short, :link_rewrite, :reference, :price, :available_now, :available_later, :meta_description, :meta_keywords, :meta_title
+
+      def initialize args = {}
+        @id                         = args[:id]
+        @id_manufacturer            = args[:id_manufacturer]
+        @id_supplier                = args.fetch(:id_supplier)
+        @id_category_default        = args[:id_category_default]
+        @new                        = args[:new]
+        @cache_default_attribute    = args.fetch(:cache_default_attribute, 0)
+        @id_tax_rules_group         = args[:id_tax_rules_group]
+        @position_in_category       = args.fetch(:position_in_category, 0)
+        @manufacturer_name          = args[:manufacturer_name]
+        @quantity                   = args[:quantity]
+        @type                       = args.fetch(:type, 'simple')
+        @id_shop_default            = args.fetch(:id_shop_default, 1)
+        @reference                  = args.fetch(:reference)
+        @supplier_reference         = args[:supplier_reference]
+        @location                   = args[:location]
+        @width                      = args[:width]
+        @height                     = args[:height]
+        @depth                      = args[:depth]
+        @weight                     = args[:weight]
+        @quantity_discount          = args.fetch(:quantity_discount, 0)
+        @ean13                      = args[:ean13]
+        @upc                        = args[:upc]
+        @cache_is_pack              = args.fetch(:cache_is_pack, 0)
+        @cache_has_attachment       = args.fetch(:cache_has_attachment, 0)
+        @is_virtual                 = args.fetch(:is_virtual, 0)
+        @on_sale                    = args.fetch(:on_sale, 0)
+        @online_only                = args.fetch(:online_only, 0)
+        @ecotax                     = args.fetch(:ecotax, 0)
+        @minimal_quantity           = args.fetch(:minimal_quantity, 1)
+        @price                      = args[:price]
+        @wholesale_price            = args[:wholesale_price]
+        @unity                      = args[:unity]
+        @unit_price_ratio           = args[:unit_price_ratio]
+        @additional_shipping_cost   = args[:additional_shipping_cost]
+        @customizable               = args[:customizable]
+        @text_fields                = args[:text_fields]
+        @uploadable_files           = args[:uploadable_files]
+        @active                     = args[:active]
+        @redirect_type              = args[:redirect_type]
+        @id_product_redirect        = args[:id_product_redirect]
+        @available_for_order        = args[:available_for_order]
+        @available_date             = args.fetch(:available_date, Date.today.strftime("%F"))
+        @condition                  = args.fetch(:condition, 'new')
+        @show_price                 = args[:show_price]
+        @indexed                    = 0
+        @visibility                 = args.fetch(:visibility, 'both')
+        @advanced_stock_management  = args[:advanced_stock_management]
+        # date_add
+        # date_upd
+        @meta_description           = args[:meta_description]
+        @meta_keywords              = args[:meta_keywords]
+        @meta_title                 = args[:meta_title]
+        @link_rewrite               = args[:link_rewrite]
+        @name                       = args.fetch(:name)
+        @description                = args[:description]
+        @description_short          = args[:description_short]
+        @available_now              = args[:available_now]
+        @available_later            = args[:available_later]
+
+        @id_lang                    = args.fetch(:id_lang)
+        @id_categories              = args[:id_categories]
+        @id_features                = args[:id_features]
+      end
+
+      def name
+        @name.plain.truncate(125)
+      end
+
+      def description_short
+        @description_short ? @description_short.restricted.truncate(252) : (description.truncate(252) if description)
+      end
+
+      def link_rewrite
+        @link_rewrite ? @link_rewrite.parameterize : name.parameterize
+      end
+
+      def reference
+        if @reference and not @reference.to_s.empty?
+          @reference.to_s.length > 32 ? Digest::MD5.hexdigest(@reference) : @reference
+        else
+          Digest::MD5.hexdigest(name)
+        end
+      end
+
+      def available_now
+        @available_now.plain.truncate(125)
+      end
+
+      def available_later
+        @available_later.plain.truncate(125)
+      end
+
+      def hash
+        product = { 
+          id_supplier:          id_supplier,
+          id_manufacturer:      id_manufacturer,
+          id_category_default:  id_category_default,
+          id_shop_default:      id_shop_default,
+          id_tax_rules_group:   id_tax_rules_group,
+          on_sale:              on_sale,
+          online_only:          online_only,
+          ean13:                ean13,
+          upc:                  upc,
+          ecotax:               ecotax,
+          minimal_quantity:     minimal_quantity,
+          price:                price,
+          wholesale_price:      wholesale_price,
+          reference:            reference,
+          active:               active,
+          redirect_type:        '404',
+          available_for_order:  available_for_order,
+          condition:            condition,
+          show_price:           show_price,
+          name:                 hash_lang(name, id_lang),
+          description:          hash_lang(description, id_lang),
+          description_short:    hash_lang(description_short, id_lang),
+          link_rewrite:         hash_lang(link_rewrite, id_lang),
+          meta_title:           hash_lang(meta_title, id_lang),
+          meta_description:     hash_lang(meta_description, id_lang),
+          meta_keywords:        hash_lang(meta_keywords, id_lang),
+          available_now:        hash_lang(available_now, id_lang),
+          available_later:      hash_lang(available_later, id_lang),
+          associations: {} }
+        unless id_categories_all.empty?
+          product[:associations][:categories] = {}
+          product[:associations][:categories][:category] = hash_ids(id_categories_all)
+        end
+        if features_hash
+          product[:associations][:product_features] = {}
+          product[:associations][:product_features][:product_feature] = features_hash
+        end
+        product
+      end
+
+      # Find product by +reference+ and +id_supplier+, returns +id+
+      def id
+        @id ||= self.class.find_by 'filter[reference]' => reference, 'filter[id_supplier]' => id_supplier
+      end
+      alias :find? :id
+
+      # Update product with given options
+      def update options = {}
+        self.class.update(id, options)
+      end
+
+      # Generate hash of single feature
+      def feature_hash id_feature, id_feature_value
+        { id: id_feature, id_feature_value: id_feature_value } if id_feature and id_feature_value
+      end
+
+      # Generate hash of features
+      def features_hash
+        id_features.map{|f| feature_hash(f[:id_feature], f[:id_feature_value])} if id_features
+      end
+
+      def id_categories_all
+        [id_category_default, id_categories].flatten.uniq
+      end
+
+      class << self
+        def fixed_hash id
+          product = find id
+          product.delete(:position_in_category)
+          product.delete(:manufacturer_name)
+          product.delete(:quantity)
+          product.delete(:type)
+          product.delete(:associations)
+          product
+        end
+
+        def deactivate id_supplier
+          first = (Date.today-365).strftime("%F")
+          last = (Date.today-1).strftime("%F")
+          products = where 'filter[date_upd]' => "[#{first},#{last}]", date: 1, 'filter[id_supplier]' => id_supplier, 'filter[active]' => 1, limit: 1000
+          if products and !products.empty?
+            products.map{|p| update(p, active: 0)}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prestashop/mapper/models/product_feature.rb

@@ -0,0 +1,69 @@
+using Prestashop::Mapper::Refinement
+module Prestashop
+  module Mapper
+    class ProductFeature < Model
+      resource :product_features
+      model :product_feature
+
+      attr_accessor :id, :position
+      attr_writer   :name
+      attr_accessor :id_lang
+
+      def initialize args = {}
+        @id       = args[:id]
+        @position = args[:position]
+        @name     = args.fetch(:name)
+
+        @id_lang  = args.fetch(:id_lang)
+      end
+
+      def name
+        @name.plain
+      end
+
+      def hash
+        validate!
+        { name: hash_lang(name, id_lang) }
+      end
+
+      def find_or_create
+        feature = self.class.find_in_cache name, id_lang
+        unless feature
+          feature = create
+          Client.clear_features_cache
+        end
+        feature[:id]
+      end
+
+      def validate!
+        raise ArgumentError, 'id lang must be number' unless id_lang.kind_of?(Integer)
+        raise ArgumentError, 'name must string' unless name.kind_of?(String)
+      end
+
+      class << self
+        def find_in_cache name, id_lang
+          Client.features_cache.find{|k| k[:name].find_lang(name, id_lang) } if Client.features_cache
+        end
+
+        def cache
+          all display: '[id,name]'
+        end
+
+        def create_from_hash resources, id_lang
+          resources = [resources] if resources.kind_of?(Hash)
+          if resources.kind_of?(Array)
+            features = []
+            resources.each do |resource|
+              if resource[:feature] and !resource[:feature].empty? and resource[:value] and !resource[:value].empty?
+                id_f = new(name: resource[:feature], id_lang: id_lang).find_or_create
+                id_fv = ProductFeatureValue.new(value: resource[:value], id_feature: id_f, id_lang: id_lang).find_or_create
+                features << { id_feature: id_f, id_feature_value: id_fv }
+              end
+            end 
+            features
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prestashop/mapper/models/product_feature_value.rb

@@ -0,0 +1,60 @@
+using Prestashop::Mapper::Refinement
+module Prestashop
+  module Mapper
+    class ProductFeatureValue < Model
+      resource :product_feature_values
+      model :product_feature_value
+
+      attr_accessor :id, :id_feature, :custom
+      attr_writer   :value
+      attr_accessor :id_lang
+
+      def initialize args = {}
+        @id         = args[:id]
+        @id_feature = args.fetch(:id_feature)
+        @custom     = args.fetch(:custom, 0)
+        @value      = args.fetch(:value)
+
+        @id_lang    = args.fetch(:id_lang)
+      end
+
+      def value
+        @value.plain
+      end
+
+      def hash
+        validate!
+
+        { id_feature: id_feature,
+          custom:     custom,
+          value:      hash_lang(value, id_lang) }
+      end
+      
+      def find_or_create
+        result = self.class.find_in_cache id_feature, value, id_lang
+        unless result
+          result = create
+          Client.clear_feature_values_cache
+        end
+        result[:id]
+      end
+
+      def validate!
+        raise ArgumentError, 'id lang must be number' unless id_lang.kind_of?(Integer)
+        raise ArgumentError, 'id feature must string' unless id_feature.kind_of?(Integer)
+        raise ArgumentError, 'custom must be 0 or 1' unless custom == 0 or custom == 1
+        raise ArgumentError, 'value must string' unless value.kind_of?(String)
+      end
+
+      class << self
+        def find_in_cache id_feature, value, id_lang
+          Client.feature_values_cache.find{|v| v[:id_feature] == id_feature and v[:value].find_lang(value, id_lang)} if Client.feature_values_cache
+        end
+
+        def cache
+          all display: '[id,id_feature,value]'
+        end
+      end
+    end
+  end
+end

data/lib/prestashop/mapper/models/product_option.rb

@@ -0,0 +1,72 @@
+using Prestashop::Mapper::Refinement
+module Prestashop
+  module Mapper
+    class ProductOption < Model
+      resource :product_options
+      model :product_option
+
+      attr_accessor :id, :is_color_group, :group_type, :position, :name
+      attr_writer   :public_name
+      attr_accessor :id_lang
+
+      def initialize args = {}
+        @id             = args[:id]
+        @is_color_group = args.fetch(:is_color_group, 0)
+        @group_type     = args.fetch(:group_type, 'select')
+        @position       = args[:position]
+        @name           = args.fetch(:name)
+        @public_name    = args[:public_name]
+
+        @id_lang        = args.fetch(:id_lang)
+      end
+
+      def public_name
+        @public_name ? @public_name : name
+      end
+
+      def hash
+        validate!
+
+        { is_color_group: is_color_group,
+          position: position,
+          group_type: group_type,
+          name: hash_lang(name, id_lang),
+          public_name: hash_lang(public_name, id_lang) }
+      end
+
+      def find_or_create
+        option = self.class.find_in_cache name, id_lang
+        unless option
+          option = create
+          Client.clear_options_cache
+        end
+        option[:id]
+      end
+
+      def validate!
+        raise ArgumentError, 'id lang must be number' unless id_lang.kind_of?(Integer)
+        raise ArgumentError, 'name must string' unless name.kind_of?(String)
+        raise ArgumentError, 'group_type must string' unless group_type.kind_of?(String)
+      end
+
+      class << self
+        def create_from_hash product_options, id_lang
+          result = []
+          product_options.each do |product_option|
+            id_o = ProductOption.new(name: product_option[:name], id_lang: id_lang).find_or_create
+            result << ProductOptionValue.new(name: product_option[:value], id_attribute_group: id_o, id_lang: id_lang).find_or_create
+          end if product_options
+          result
+        end
+
+        def find_in_cache name, id_lang
+          Client.options_cache.find{|k| k[:name].find_lang(name, id_lang) } if Client.options_cache
+        end
+
+        def cache
+          all display: '[id,name]'
+        end
+      end
+    end
+  end
+end

data/lib/prestashop/mapper/models/product_option_value.rb

@@ -0,0 +1,56 @@
+using Prestashop::Mapper::Refinement
+module Prestashop
+  module Mapper
+    class ProductOptionValue < Model
+      resource :product_option_values
+      model :product_option_value
+
+      attr_accessor :id, :id_attribute_group, :color, :position, :name
+      attr_accessor :id_lang
+
+      def initialize args = {}
+        @id                 = args[:id]
+        @id_attribute_group = args.fetch(:id_attribute_group)
+        @color              = args.fetch(:color, 0)
+        @position           = args[:position]
+        @name               = args.fetch(:name)
+
+        @id_lang            = args.fetch(:id_lang)
+      end
+
+      def hash
+        validate!
+        { name:               hash_lang(name, id_lang),
+          id_attribute_group: id_attribute_group,
+          color:              color }
+      end
+
+      def find_or_create
+        result = self.class.find_in_cache id_attribute_group, name, id_lang
+        unless result
+          result = create
+          Client.clear_option_values_cache
+        end
+        result[:id]
+      end
+
+      # Supplier must have 1/0 as active and name must be string
+      def validate!
+        raise ArgumentError, 'id lang must be number' unless id_lang.kind_of?(Integer)
+        raise ArgumentError, 'name must string' unless name.kind_of?(String)
+        raise ArgumentError, 'id attribute group must be number' unless id_attribute_group.kind_of?(Integer)
+        raise ArgumentError, 'color must be true or false' unless color == 1 or color == 0
+      end
+
+      class << self
+        def find_in_cache id_attribute_group, name, id_lang
+          Client.option_values_cache.find{|v| v[:id_attribute_group] == id_attribute_group and v[:name].find_lang(name, id_lang)} if Client.option_values_cache
+        end
+
+        def cache
+          all display: '[id,id_attribute_group,name]'
+        end
+      end
+    end
+  end
+end