market_hub 0.1.0 → 0.23.5

data/lib/market_hub/models/mercado_livre/variation.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module MarketHub
+  module Models
+    module MercadoLivre
+      # Classe que representa uma Variação no Mercado Livre
+      class Variation < MarketHub::Models::Base
+
+        attr_accessor :item_id, :variation_id, :attribute_combinations, :price, :available_quantity, :picture_ids, :catalog_product_id, :attributes
+
+        validates_presence_of :item_id, :attribute_combinations, :price, :available_quantity, message: 'não pode estar em branco.'
+
+        def initialize(client, body = {}, options = {})
+          super(client, body, options)
+          unless body.empty?
+            @id = body.dig(:variation_id) || body.dig('id')
+            @item_id = body.dig(:item_id) || body.dig('item_id')
+            @variation_id = body.dig(:variation_id) || body.dig('id')
+            @attribute_combinations = body.dig(:attribute_combinations) || body.dig('attribute_combinations')
+            @price = (body.dig(:price) || body.dig('price')).to_f
+            @available_quantity = body.dig(:available_quantity) || body.dig('available_quantity')
+            @picture_ids = body.dig(:picture_ids) || body.dig('picture_ids')
+            @catalog_product_id = body.dig(:catalog_product_id) || body.dig('catalog_product_id')
+            @attributes = body.dig(:attributes) || body.dig('attributes')
+          end
+        end
+
+        def variation_id=(value)
+          @id = value
+          @variation_id = value
+        end
+
+        def save
+          if client.connected?
+            if valid?
+              @was_new = new?
+              @was_update = update?
+
+              if new?
+                json = client.variation.create(@item_id, new_layout)
+              else
+                json = client.variation.update(@item_id, @variation_id, update_layout)
+              end
+
+              if json['id']
+                @id = json['id']
+                @variation_id = json['id']
+              elsif json['error']
+                errors.add(:item, (json['cause'].to_a.empty? ? json['message'] : json['cause'].to_a.map { |e| e['message'] }.join('. ')))
+              else
+                errors.add(:item, "Ocorreu um erro ao enviar o item para o marketplace.")
+              end
+            end
+          else
+            errors.add(:client, "não conectado.")
+          end
+
+          errors.size.zero?
+        end
+
+        def destroy
+          if client.connected? && update?
+            client.variation.destroy(@item_id, @variation_id)
+          end
+        end
+
+        def self.find(client, item_id, variation_id)
+          if client.connected?
+            self.new(client, { "item_id" => item_id }.merge(client.variation.find(item_id, variation_id).to_h), { action: 'find' })
+          end
+        end
+
+        private
+
+          def new_layout
+            layout = {}
+            layout[:attribute_combinations] = @attribute_combinations
+            layout[:price] = @price
+            layout[:available_quantity] = @available_quantity
+            layout[:picture_ids] = @picture_ids
+            layout[:catalog_product_id] = @catalog_product_id
+            layout[:attributes] = @attributes
+            layout
+          end
+
+          def update_layout
+            layout = new_layout
+            layout.delete(:catalog_product_id)
+            layout
+          end
+
+      end
+    end
+  end
+end

data/lib/market_hub/utils/error.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module MarketHub
+  module Utils
+    class Error
+
+      include Enumerable
+  
+      CALLBACKS_OPTIONS = %i[if unless on allow_nil allow_blank strict].freeze
+      MESSAGE_OPTIONS = [:message].freeze
+  
+      attr_reader :messages, :details
+  
+      def initialize(base)
+        @base     = base
+        @messages = apply_default_array({})
+        @details = apply_default_array({})
+      end
+  
+      def add(attribute, message = :invalid, options = {})
+        message = message.call if message.respond_to?(:call)
+        detail  = normalize_detail(message, options)
+        message = normalize_message(attribute, message, options)
+        details[attribute.to_sym]  << detail
+        messages[attribute.to_sym] << message
+      end
+  
+      def size
+        @messages.values.flatten.size
+      end
+      alias count size
+  
+      def generate_message(attribute, type = :invalid, _options = {})
+        :"errors.attributes.#{attribute}.#{type}"
+      end
+  
+      def full_messages
+        @messages.values.flatten
+      end
+      alias to_a full_messages
+  
+      private
+  
+        def apply_default_array(hash)
+          hash.default_proc = proc { |h, key| h[key] = [] }
+          hash
+        end
+    
+        def normalize_message(attribute, message, options)
+          case message
+          when Symbol
+            generate_message(attribute, message, except(options, *CALLBACKS_OPTIONS))
+          else
+            if message.start_with?(variable_name(attribute))
+              message
+            else
+              "#{variable_name(attribute)} #{message}"
+            end
+          end
+        end
+    
+        def normalize_detail(message, options)
+          { error: message }.merge(except(options, *CALLBACKS_OPTIONS + MESSAGE_OPTIONS))
+        end
+    
+        def except(hash, *keys)
+          dup = hash.dup
+          keys.each { |key| dup.delete(key) }
+          dup
+        end
+    
+        def variable_name(symbol)
+          symbol.to_s.tr('_', ' ').capitalize
+        end
+
+    end
+  end
+end

data/lib/market_hub/utils/http.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MarketHub
+  # Módulo que simplifica as requisições HTTP/HTTPS
+  module HTTP
+
+    def self.get(uri, headers: {})
+      request = Net::HTTP::Get.new(uri)
+      MarketHub::HTTP.execute(uri, request, headers)
+    end
+
+    def self.post(uri, headers: {}, body: {})
+      request = Net::HTTP::Post.new(uri)
+      MarketHub::HTTP.execute(uri, request, headers, body)
+    end
+
+    def self.post_form(uri, headers: {}, body: {}, files: nil)
+      request = Net::HTTP::Post.new(uri)
+      type = :form_data
+      MarketHub::HTTP.execute(uri, request, headers, body, type, files)
+    end
+
+    def self.put(uri, headers: {}, body: {})
+      request = Net::HTTP::Put.new(uri)
+      MarketHub::HTTP.execute(uri, request, headers, body)
+    end
+
+    def self.put_form(uri, headers: {}, body: {}, files: nil)
+      request = Net::HTTP::Put.new(uri)
+      type = :form_data
+      MarketHub::HTTP.execute(uri, request, headers, body, type, files)
+    end
+
+    def self.delete(uri, headers: {})
+      request = Net::HTTP::Delete.new(uri)
+      MarketHub::HTTP.execute(uri, request, headers)
+    end
+
+    def self.execute(uri, request, headers = nil, body = nil, type = :raw_data, files = nil)
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        case type
+        when :raw_data
+          request.body = (body.is_a?(Hash) ? body.to_json : body) if body
+        when :form_data
+          request.form_data = body if body
+          request.set_form(files.map { |file| ['file', file, { filename: File.basename(file) }] }, 'multipart/form-data') if files
+        end
+
+        headers.each { |header, value| request[header] = value } if headers
+        http.request(request)
+      end
+    end
+
+  end
+end

data/lib/market_hub/utils/o_auth_20.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MarketHub
+  # Classe para autorização utilizando método OAuth 2.0
+  class OAuth20
+
+    attr_accessor :client_id
+    attr_accessor :client_secret
+    attr_accessor :redirect_uri
+
+    def initialize(client_id, client_secret, redirect_uri)
+      @client_id = client_id
+      @client_secret = client_secret
+      @redirect_uri = redirect_uri
+    end
+
+    def authorize_url(site, path, state = nil)
+      endpoint = URI::HTTPS.build(host: site, path: path)
+      endpoint.query = ["response_type=code", "client_id=#{@client_id}", "redirect_uri=#{@redirect_uri}"].join('&')
+      endpoint.query = [endpoint.query, "state=#{state}"].join('&') unless state.nil?
+      endpoint.to_s
+    end
+
+    def get_token(site, path, code)
+      endpoint = URI::HTTPS.build(host: site, path: path)
+      body = {  grant_type: 'authorization_code', client_id: @client_id,
+                client_secret: @client_secret, code: code, redirect_uri: @redirect_uri }
+      response = MarketHub::HTTP.post_form(endpoint, body: body)
+      JSON.parse(response.body)
+    end
+
+    def renew_token(site, path, refresh_token)
+      endpoint = URI::HTTPS.build(host: site, path: path)
+      body = {  grant_type: 'refresh_token', client_id: @client_id,
+                client_secret: @client_secret, refresh_token: refresh_token }
+      response = MarketHub::HTTP.post_form(endpoint, body: body)
+      JSON.parse(response.body)
+    end
+
+  end
+end

data/lib/market_hub/utils/validation.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module MarketHub
+  module Utils
+    module Validation
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+  
+      module ClassMethods
+        attr_reader :presences, :lengths, :numericals, :inclusions, :eachs
+  
+        def validates_presence_of(*attr_names)
+          @presences ||= []
+          @presences = @presences << attr_names
+        end
+  
+        def validates_length_of(*attr_names)
+          @lengths ||= []
+          @lengths = @lengths << attr_names
+        end
+  
+        def validates_numericality_of(*attr_names)
+          @numericals ||= []
+          @numericals = @numericals << attr_names
+        end
+  
+        def validates_inclusion_of(*attr_names)
+          @inclusions ||= []
+          @inclusions = @inclusions << attr_names
+        end
+  
+        def validates_each(*attr_names, &block)
+          @eachs ||= {}
+          attr_names.each do |attr_name|
+            @eachs[attr_name] = block
+          end
+        end
+  
+        def with_options(options, &block); end
+      end
+  
+      def errors
+        @errors ||= MarketHub::Utils::Error.new(self)
+      end
+  
+      def valid?
+        @errors = MarketHub::Utils::Error.new(self)
+
+        all_valid = true
+        all_valid = false unless check_eachs
+        all_valid = false unless check_presences
+        all_valid = false unless check_numericals
+        all_valid = false unless check_lengths
+        all_valid = false unless check_inclusions
+        all_valid
+      end
+  
+      def invalid?
+        !valid?
+      end
+  
+      private
+
+        def check_eachs
+          eachs = {}
+          eachs.merge!(self.class.superclass.superclass.eachs || {}) if self.class.superclass.superclass.respond_to?(:eachs)
+          eachs.merge!(self.class.superclass.eachs || {}) if self.class.superclass.respond_to?(:eachs)
+          eachs.merge!(self.class.eachs) if self.class.eachs
+          return true if eachs.keys.size.zero?
+    
+          eachs.each do |attr_name, block|
+            value = ''
+            begin
+              value = send(attr_name)
+            rescue StandardError
+            end
+            block.call(self, attr_name, value)
+          end
+          errors.size.zero?
+        end
+    
+        def check_presences
+          presences = []
+          if self.class.superclass.superclass.respond_to?(:presences)
+            presences = self.class.superclass.superclass.presences || []
+          end
+          presences += self.class.superclass.presences || [] if self.class.superclass.respond_to?(:presences)
+          presences += self.class.presences if self.class.presences
+          all_present = true
+          presences.each do |presence|
+            presence.select { |p| p.is_a? Symbol }.each do |variable|
+              if blank?(send(variable))
+                all_present = false
+                errors.add variable, presence[-1][:message]
+              end
+            end
+          end
+          all_present
+        end
+    
+        def check_numericals
+          numericals = []
+          numericals = self.class.superclass.numericals || [] if self.class.superclass.respond_to?(:numericals)
+          numericals += self.class.numericals if self.class.numericals
+          return true unless numericals
+    
+          all_numerical = true
+          numericals.each do |numerical|
+            numerical.select { |p| p.is_a? Symbol }.each do |variable|
+              if respond_to?(variable) && send(variable) && (send(variable).to_s =~ /\A[+-]?\d+\z/).nil?
+                all_numerical = false
+                errors.add variable, numerical[-1][:message]
+              end
+            end
+          end
+          all_numerical
+        end
+    
+        def check_lengths
+          lengths = []
+          lengths = self.class.superclass.superclass.lengths || [] if self.class.superclass.superclass.respond_to?(:lengths)
+          lengths += self.class.superclass.lengths || [] if self.class.superclass.respond_to?(:lengths)
+          lengths += self.class.lengths if self.class.lengths
+          return true unless lengths
+    
+          all_checked = true
+          lengths.each do |rule|
+            variable = rule[0]
+            next unless respond_to?(variable)
+    
+            value = send(variable)
+            if rule[-1][:in]
+              if !value
+                all_checked = false
+                errors.add variable, rule[-1][:message]
+              elsif value.size < rule[-1][:in].first || value.size > rule[-1][:in].last
+                all_checked = false
+                errors.add variable, rule[-1][:message]
+              end
+            end
+            if rule[-1][:is]
+              if !value
+                all_checked = false
+                errors.add variable, rule[-1][:message]
+              elsif value.to_s.size != rule[-1][:is]
+                all_checked = false
+                errors.add variable, rule[-1][:message]
+              end
+            end
+            if rule[-1][:minimum] && rule[-1][:maximum]
+              if !value || value.size < rule[-1][:minimum] || value.size > rule[-1][:maximum]
+                all_checked = false
+                errors.add variable, rule[-1][:message]
+              end
+            elsif rule[-1][:maximum]
+              if value && value.size > rule[-1][:maximum]
+                all_checked = false
+                errors.add variable, rule[-1][:message]
+              end
+            end
+          end
+          all_checked
+        end
+    
+        def check_inclusions
+          inclusions = []
+          if self.class.superclass.superclass.respond_to?(:inclusions)
+            inclusions = self.class.superclass.superclass.inclusions || []
+          end
+          inclusions += self.class.superclass.inclusions || [] if self.class.superclass.respond_to?(:inclusions)
+          inclusions += self.class.inclusions if self.class.inclusions
+          return true unless inclusions
+    
+          all_checked = true
+          inclusions.each do |rule|
+            variable = rule[0]
+            next unless respond_to?(variable)
+    
+            value = send(variable)
+            next unless value
+    
+            next unless rule[-1][:in]
+    
+            unless rule[-1][:in].include?(value)
+              all_checked = false
+              errors.add variable, rule[-1][:message]
+            end
+          end
+          all_checked
+        end
+    
+        def variable_name(symbol)
+          symbol.to_s.tr('_', ' ').capitalize
+        end
+    
+        def blank?(obj)
+          return obj !~ /\S/ if obj.is_a? String
+    
+          obj.respond_to?(:empty?) ? obj.empty? : !obj
+        end
+      end
+
+  end
+end

data/lib/market_hub/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MarketHub
-  VERSION = "0.1.0"
+  VERSION = "0.23.5"
 end

data/lib/market_hub.rb

@@ -1,8 +1,53 @@
 # frozen_string_literal: true
 
-require_relative "market_hub/version"
+require 'json'
+require 'net/http'
+require 'uri'
+
+require 'market_hub/base'
+require 'market_hub/configuration'
+require 'market_hub/exception'
+require 'market_hub/version'
+
+require 'market_hub/utils/error'
+require 'market_hub/utils/http'
+require 'market_hub/utils/o_auth_20'
+require 'market_hub/utils/validation'
+
+require 'market_hub/models/base'
+require 'market_hub/models/mercado_livre/item'
+require 'market_hub/models/mercado_livre/variation'
+
+require 'market_hub/api/base'
+require 'market_hub/api/mercado_livre/client'
+require 'market_hub/api/mercado_livre/authorization'
+require 'market_hub/api/mercado_livre/category'
+require 'market_hub/api/mercado_livre/publication_type'
+require 'market_hub/api/mercado_livre/item'
+require 'market_hub/api/mercado_livre/description'
+require 'market_hub/api/mercado_livre/image'
+require 'market_hub/api/mercado_livre/user'
+require 'market_hub/api/mercado_livre/catalog'
+require 'market_hub/api/mercado_livre/variation'
+require 'market_hub/api/mercado_livre/question_answer'
+require 'market_hub/api/mercado_livre/order'
+require 'market_hub/api/mercado_livre/shipment'
+require 'market_hub/api/mercado_livre/invoice'
+
+require 'market_hub/client'
 
 module MarketHub
-  class Error < StandardError; end
-  # Your code goes here...
+  # Personalize as configurações padrão da biblioteca usando bloco
+  #   MarketHub.configure do |config|
+  #     config.meli_client_id = "xxx"
+  #     config.meli_client_secret = "xxx"
+  #   end
+  # Se nenhum bloco for fornecido, retorna o objeto de configuração padrão
+  def self.configure
+    if block_given?
+      yield(Configuration.default)
+    else
+      Configuration.default
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: market_hub
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.23.5
 platform: ruby
 authors:
 - Henrique Shiraishi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-10 00:00:00.000000000 Z
+date: 2024-10-14 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -22,6 +22,32 @@ files:
 - README.md
 - Rakefile
 - lib/market_hub.rb
+- lib/market_hub/api/base.rb
+- lib/market_hub/api/mercado_livre/authorization.rb
+- lib/market_hub/api/mercado_livre/catalog.rb
+- lib/market_hub/api/mercado_livre/category.rb
+- lib/market_hub/api/mercado_livre/client.rb
+- lib/market_hub/api/mercado_livre/description.rb
+- lib/market_hub/api/mercado_livre/image.rb
+- lib/market_hub/api/mercado_livre/invoice.rb
+- lib/market_hub/api/mercado_livre/item.rb
+- lib/market_hub/api/mercado_livre/order.rb
+- lib/market_hub/api/mercado_livre/publication_type.rb
+- lib/market_hub/api/mercado_livre/question_answer.rb
+- lib/market_hub/api/mercado_livre/shipment.rb
+- lib/market_hub/api/mercado_livre/user.rb
+- lib/market_hub/api/mercado_livre/variation.rb
+- lib/market_hub/base.rb
+- lib/market_hub/client.rb
+- lib/market_hub/configuration.rb
+- lib/market_hub/exception.rb
+- lib/market_hub/models/base.rb
+- lib/market_hub/models/mercado_livre/item.rb
+- lib/market_hub/models/mercado_livre/variation.rb
+- lib/market_hub/utils/error.rb
+- lib/market_hub/utils/http.rb
+- lib/market_hub/utils/o_auth_20.rb
+- lib/market_hub/utils/validation.rb
 - lib/market_hub/version.rb
 - sig/market_hub.rbs
 homepage: https://github.com/henriqueshiraishi/ruby-market_hub