magento 0.9.1 → 0.13.0

data/lib/magento.rb

@@ -2,10 +2,13 @@
 
 require 'time'
 require 'dry/inflector'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/keys'
 
 require_relative 'magento/errors'
 require_relative 'magento/request'
 require_relative 'magento/model_mapper'
+require_relative 'magento/params'
 require_relative 'magento/polymorphic_model'
 require_relative 'magento/model'
 require_relative 'magento/record_collection'
@@ -17,8 +20,10 @@ require_relative 'magento/customer'
 require_relative 'magento/order'
 require_relative 'magento/invoice'
 require_relative 'magento/guest_cart'
+require_relative 'magento/sales_rule'
 
 Dir[File.expand_path('magento/shared/*.rb', __dir__)].map { |f| require f }
+Dir[File.expand_path('magento/params/*.rb', __dir__)].map { |f| require f }
 
 module Magento
   class << self

data/lib/magento/customer.rb

@@ -1,17 +1,47 @@
 module Magento
   class Customer < Model
+    self.endpoint = 'customers/search'
+
     def fullname
       "#{@firstname} #{@lastname}"
     end
 
+    def update(attributes)
+      raise "id not present" if @id.nil?
+
+      attributes.each { |key, value| send("#{key}=", value) }
+      save
+    end
+
     class << self
       alias_method :find_by_id, :find
 
+      def update(id, attributes)
+        hash = request.put("customers/#{id}", { customer: attributes }).parse
+
+        block_given? ? yield(hash) : build(hash)
+      end
+
+      def create(attributes)
+        attributes.transform_keys!(&:to_sym)
+        password = attributes.delete :password
+        hash = request.post("customers", {
+          customer: attributes,
+          password: password
+        }).parse
+        build(hash)
+      end
+
       def find_by_token(token)
         user_request = Request.new(token: token)
         customer_hash = user_request.get('customers/me').parse
         build(customer_hash)
       end
+
+      def find(id)
+        hash = request.get("customers/#{id}").parse
+        build(hash)
+      end
     end
   end
 end

data/lib/magento/model.rb

@@ -7,13 +7,17 @@ module Magento
     include Magento::ModelParser
 
     def save
-      self.class.update(send(self.class.primary_key), to_h)
+      self.class.update(send(self.class.primary_key), to_h) do |hash|
+        update_attributes(hash)
+      end
     end
     
     def update(attrs)
       raise "#{self.class.name} not saved" if send(self.class.primary_key).nil?
 
-      self.class.update(send(self.class.primary_key), attrs)
+      self.class.update(send(self.class.primary_key), attrs) do |hash|
+        update_attributes(hash)
+      end
     end
 
     def delete
@@ -24,10 +28,15 @@ module Magento
       @id || send(self.class.primary_key)
     end
 
+    protected def update_attributes(hash)
+      ModelMapper.map_hash(self, hash)
+    end
+
     class << self
       extend Forwardable
 
-      def_delegators :query, :all, :page, :per, :page_size, :order, :select, :where
+      def_delegators :query, :all, :page, :per, :page_size, :order, :select, 
+                     :where, :first, :find_by, :count
 
       def find(id)
         hash = request.get("#{api_resource}/#{id}").parse
@@ -47,7 +56,8 @@ module Magento
       def update(id, attributes)
         body = { entity_key => attributes }
         hash = request.put("#{api_resource}/#{id}", body).parse
-        build(hash)
+
+        block_given? ? yield(hash) : build(hash)
       end
 
       def api_resource

data/lib/magento/model_mapper.rb

@@ -17,9 +17,12 @@ module Magento
     end
 
     def self.map_hash(model, values)
-      object = model.new
+      object = model.is_a?(Class) ? model.new : model
       values.each do |key, value|
-        object.singleton_class.instance_eval { attr_accessor key }
+        unless object.respond_to?(key) && object.respond_to?("#{key}=")
+          object.singleton_class.instance_eval { attr_accessor key }
+        end
+
         if value.is_a?(Hash)
           class_name = Magento.inflector.camelize(Magento.inflector.singularize(key))
           value = map_hash(Object.const_get("Magento::#{class_name}"), value)

data/lib/magento/order.rb

@@ -12,7 +12,9 @@ module Magento
     def update(attrs)
       raise "'entity_id' not found" if @entity_id.nil?
 
-      self.class.update(@entity_id, attrs)
+      self.class.update(@entity_id, attrs) do |hash|
+        update_attributes(hash)
+      end
     end
 
     def cancel
@@ -63,7 +65,7 @@ module Magento
       def update(entity_id, attributes)
         attributes[:entity_id] = entity_id
         hash = request.put('orders/create', { entity_key => attributes }).parse
-        build(hash)
+        block_given? ? yield(hash) : build(hash)
       end
 
       # @return {Boolean}

data/lib/magento/params.rb

@@ -0,0 +1,9 @@
+require 'dry/struct'
+
+module Magento
+  module Params
+    module Type
+      include Dry.Types()
+    end
+  end
+end

data/lib/magento/params/create_category.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Magento
+  module Params
+    class CreateCategoria < Dry::Struct
+      attribute :name,      Type::String
+      attribute :parent_id, Type::String.optional
+      attribute :path,      Type::String.optional
+      attribute :is_active, Type::Bool.default(true)
+
+      def to_h
+        {
+          "name": name,
+          "parent_id": parent_id,
+          "is_active": is_active,
+          "path": path
+        }
+      end
+    end
+  end
+end

data/lib/magento/params/create_custom_attribute.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Magento
+  module Params
+    class CreateCustomAttribute < Dry::Struct
+      attribute :code, Type::String
+      attribute :value, Type::String
+
+      def to_h
+        {
+          "attribute_code": code,
+          "value": value
+        }
+      end
+    end
+  end
+end

data/lib/magento/params/create_image.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'mini_magick'
+
+module Magento
+  module Params
+    class CreateImage < Dry::Struct
+      VARIANTS = {
+        'large'  => { size: '800x800', type: :image },
+        'medium' => { size: '300x300', type: :small_image },
+        'small'  => { size: '100x100', type: :thumbnail }
+      }.freeze
+
+      attribute :title,    Type::String
+      attribute :path,     Type::String
+      attribute :position, Type::Integer
+      attribute :size,     Type::String.default('large').enum(*VARIANTS.keys)
+      attribute :disabled, Type::Bool.default(false)
+      attribute :main,     Type::Bool.default(false)
+
+      def to_h
+        {
+          "disabled": disabled,
+          "media_type": 'image',
+          "label": title,
+          "position": position,
+          "content": {
+            "base64_encoded_data": base64,
+            "type": mini_type,
+            "name": filename
+          },
+          "types": main ? [VARIANTS[size][:type]] : []
+        }
+      end
+
+      def variants
+        VARIANTS.keys.map do |size|
+          CreateImage.new(attributes.merge(size: size, disabled: size != :large))
+        end
+      end
+
+      private
+
+      def base64
+        Base64.strict_encode64(File.open(file.path).read).to_s
+      end
+
+      def file
+        @file ||= MiniMagick::Image.open(path).tap do |b|
+          b.resize VARIANTS[size][:size]
+          b.strip
+        end
+      end
+
+      def filename
+        title.parameterize
+      end
+
+      def mini_type
+        file.mime_type
+      end
+    end
+  end
+end

data/lib/magento/params/create_product.rb

@@ -0,0 +1,147 @@
+require_relative 'create_image'
+require_relative 'create_custom_attribute'
+
+module Magento
+  module Params
+    # Example
+    # 
+    # params = Magento::Params::CreateProduct.new(
+    #   sku: '556-teste-builder',
+    #   name: 'REFRIGERANTE PET COCA-COLA 1,5L ORIGINAL',
+    #   description: 'Descrição do produto',
+    #   brand: 'Coca-Cola',
+    #   price: 4.99,
+    #   special_price: 3.49,
+    #   quantity: 2,
+    #   weight: 0.3,
+    #   attribute_set_id: 4,
+    #   images: [
+    #     *Magento::Params::CreateImage.new(
+    #       path: 'https://urltoimage.com/image.jpg',
+    #       title: 'REFRIGERANTE PET COCA-COLA 1,5L ORIGINAL',
+    #       position: 0,
+    #       main: true
+    #     ).variants, # it's generate all variants thumbnail => '100x100', small_image => '300x300' and image => '800x800'
+    #     Magento::Params::CreateImage.new(
+    #       path: '/path/to/image.jpg',
+    #       title: 'REFRIGERANTE PET COCA-COLA 1,5L ORIGINAL',
+    #       position: 1
+    #     )
+    #   ]
+    # )
+    #
+    # Magento::Product.create(params.to_h)
+    # 
+    class CreateProduct < Dry::Struct
+      ProductTypes = Type::String.default('simple'.freeze).enum(
+        'simple',
+        'bundle',
+        'configurable',
+        'downloadable',
+        'grouped',
+        'Virtual'
+      )
+
+      Visibilities = Type::String.default('catalog_and_search'.freeze).enum(
+        'not_visible_individually' => 1,
+        'catalog' => 1,
+        'search' => 3,
+        'catalog_and_search' => 4
+      )
+
+      Statuses = Type::String.default('enabled'.freeze).enum('enabled' => 1, 'disabled' => 2)
+
+      attribute :sku,               Type::String
+      attribute :name,              Type::String
+      attribute :description,       Type::String
+      attribute :brand,             Type::String
+      attribute :price,             Type::Coercible::Float
+      attribute :special_price,     Type::Float.optional.default(nil)
+      attribute :attribute_set_id,  Type::Integer
+      attribute :status,            Statuses
+      attribute :visibility,        Visibilities
+      attribute :type_id,           ProductTypes
+      attribute :weight,            Type::Coercible::Float
+      attribute :quantity,          Type::Coercible::Float
+      attribute :featured,          Type::String.default('0'.freeze).enum('0', '1')
+      attribute :is_qty_decimal,    Type::Bool.default(false)
+      attribute :manage_stock,      Type::Bool.default(true)
+      attribute :category_ids,      Type::Array.of(Type::Integer).default([].freeze)
+      attribute :images,            Type::Array.of(Type::Instance(CreateImage)).default([].freeze)
+      attribute :website_ids,       Type::Array.of(Type::Integer).default([0].freeze)
+      attribute :custom_attributes, Type::Array.default([], shared: true) do
+        attribute :attribute_code,  Type::String
+        attribute :value,           Type::Coercible::String
+      end
+
+      alias orig_custom_attributes custom_attributes
+
+      def to_h
+        {
+          sku: sku,
+          name: name.titlecase,
+          price: price,
+          status: Statuses.mapping[status],
+          visibility: Visibilities.mapping[visibility],
+          type_id: type_id,
+          weight: weight,
+          attribute_set_id: attribute_set_id,
+          extension_attributes: {
+            website_ids: website_ids,
+            category_links: categories,
+            stock_item: stock
+          },
+          media_gallery_entries: images.map(&:to_h),
+          custom_attributes: custom_attributes.map(&:to_h)
+        }
+      end
+
+      def stock
+        {
+          qty: quantity,
+          is_in_stock: quantity.to_i > 0,
+          is_qty_decimal: is_qty_decimal,
+          show_default_notification_message: false,
+          use_config_min_qty: true,
+          min_qty: 1,
+          use_config_min_sale_qty: 0,
+          min_sale_qty: 0,
+          use_config_max_sale_qty: true,
+          max_sale_qty: 0,
+          use_config_backorders: true,
+          backorders: 0,
+          use_config_notify_stock_qty: true,
+          notify_stock_qty: 0,
+          use_config_qty_increments: true,
+          qty_increments: 0,
+          use_config_enable_qty_inc: true,
+          enable_qty_increments: true,
+          use_config_manage_stock: true,
+          manage_stock: manage_stock,
+          low_stock_date: 'string',
+          is_decimal_divided: is_qty_decimal,
+          stock_status_changed_auto: 0
+        }
+      end
+
+      def custom_attributes
+        default_attributes = [
+          CustomAttribute.new(attribute_code: 'description', value: description),
+          CustomAttribute.new(attribute_code: 'url_key', value: name.parameterize ),
+          CustomAttribute.new(attribute_code: 'product_brand', value: brand ),
+          CustomAttribute.new(attribute_code: 'featured', value: featured)
+        ]
+
+        if special_price.to_f > 0
+          default_attributes << CustomAttribute.new(attribute_code: 'special_price', value: special_price.to_s)
+        end
+
+        default_attributes + orig_custom_attributes
+      end
+
+      def categories
+        category_ids.map { |c| { "category_id": c, "position": 0 } }
+      end
+    end
+  end
+end

data/lib/magento/product.rb

@@ -2,6 +2,20 @@ module Magento
   class Product < Model
     self.primary_key = :sku
 
+    def method_missing(m)
+      attr(m) || super
+    end
+
+    # returns custom_attribute value by custom_attribute code
+    # return nil if custom_attribute is not present
+    def attr(attribute_code)
+      @custom_attributes&.find { |a| a.attribute_code == attribute_code.to_s }&.value
+    end
+
+    def respond_to?(attribute_code)
+      super || @custom_attributes&.any? { |a| a.attribute_code == attribute_code.to_s }
+    end
+
     class << self
       alias_method :find_by_sku, :find
     end

data/lib/magento/query.rb

@@ -89,6 +89,18 @@ module Magento
       RecordCollection.from_magento_response(result, model: model, iterable_field: field)
     end
 
+    def first
+      page_size(1).page(1).all.first
+    end
+
+    def find_by(attributes)
+      where(attributes).first
+    end
+
+    def count
+      select(:id).page_size(1).page(1).all.total_count
+    end
+
     private
 
     attr_accessor :current_page, :filter_groups, :request, :sort_orders, :model, :fields
@@ -119,10 +131,11 @@ module Magento
 
     def parse_filter(key)
       patter = /(.*)_([a-z]+)$/
-      raise 'Invalid format' unless key.match(patter)
-      raise 'Condition not accepted' unless ACCEPTED_CONDITIONS.include?(key.match(patter)[2])
+      match = key.match(patter)
+
+      return match.to_a[1..2] if match && ACCEPTED_CONDITIONS.include?(match[2])
 
-      key.match(patter).to_a[1..2]
+      [key, 'eq']
     end
 
     def parse_value_filter(condition, value)