fat_zebra_multi 3.1.0.1

data/lib/fat_zebra/refund.rb

@@ -0,0 +1,27 @@
+module FatZebra
+  ##
+  # == FatZebra \Refund
+  #
+  # Manage refund for the API
+  #
+  # * search
+  # * save
+  # * find
+  # * void
+  #
+  class Refund < APIResource
+
+    include FatZebra::APIOperation::Find
+    include FatZebra::APIOperation::Search
+    include FatZebra::APIOperation::Save
+    include FatZebra::APIOperation::Void
+
+    validates :amount, required: true, on: :create
+    validates :reference, required: true, on: :create
+
+    def declined?
+      refunded == 'Declined'
+    end
+
+  end
+end

data/lib/fat_zebra/request.rb

@@ -0,0 +1,174 @@
+require 'fat_zebra/request/multipart/part'
+require 'fat_zebra/request/multipart/stream'
+require 'fat_zebra/request/multipart/epilogue'
+require 'fat_zebra/request/multipart/file_io'
+require 'fat_zebra/request/multipart/param'
+
+module FatZebra
+  ##
+  # == FatZebra \Request
+  #
+  # Build request
+  class Request
+    class << self
+
+      def execute(params = {})
+        klass = new(params)
+
+        case params[:method]
+        when :post
+          klass.post
+        when :put
+          klass.put
+        when :delete
+          klass.delete
+        when :get
+          klass.get
+        else
+          raise FatZebra::UnknownRequestMethod, "#{params[:method]} hasn't been implemented"
+        end
+      end
+
+      def post(params = {})
+        new(params).post
+      end
+
+      def put(params = {})
+        new(params).put
+      end
+
+      def get(params = {})
+        new(params).get
+      end
+
+      def delete(params = {})
+        new(params).delete
+      end
+    end
+
+    attr_reader :params, :http, :request
+
+    def initialize(params = {})
+      @params = params
+      @http   = Net::HTTP.new(uri.host,
+                              uri.port,
+                              proxy_host,
+                              uri_proxy.port)
+
+      setup_ssl if params[:use_ssl]
+    end
+
+    def post
+      @request = Net::HTTP::Post.new(uri.path)
+
+      setup_auth_basic if params[:basic_auth]
+
+      if params[:payload] && params[:payload][:multipart]
+        build_multipart_post
+      else
+        set_header
+        request.body = params[:payload].to_json
+      end
+
+      handle_request
+    end
+
+    def put
+      @request = Net::HTTP::Put.new(uri.path)
+
+      setup_auth_basic if params[:basic_auth]
+      set_header
+      request.body = params[:payload].to_json
+
+      handle_request
+    end
+
+    def get
+      @request = Net::HTTP::Get.new(uri)
+
+      setup_auth_basic if params[:basic_auth]
+      set_header
+
+      handle_request
+    end
+
+    def delete
+      @request = Net::HTTP::Delete.new(uri.path)
+
+      setup_auth_basic if params[:basic_auth]
+      request.body = params[:payload].to_json
+
+      handle_request
+    end
+
+    private
+
+    def handle_request
+      response = http.request(request)
+
+      case [response.code_type]
+      when [Net::HTTPOK], [Net::HTTPCreated], [Net::HTTPAccepted]
+        response
+      when [Net::HTTPUnauthorized]
+        raise RequestError.new(response, message: 'Unauthorized, please check your authentication username or token')
+      when [Net::HTTPNotFound]
+        raise RequestError.new(response, message: 'Requested Resource not found')
+      when [Net::HTTPRequestTimeOut]
+        raise RequestError.new(response, message: 'Verify the address for the service')
+      when [Net::HTTPInternalServerError]
+        raise RequestError.new(response, message: 'Server Error, please check with service')
+      when [Net::HTTPNotImplemented]
+        raise RequestError.new(response, message: 'Problem processing your request - please check your data')
+      else
+        raise RequestError, response
+      end
+    end
+
+    def build_multipart_post
+      parts = []
+      Util.hash_except(params[:payload], :multipart, :content_type).each do |(key, value)|
+        parts << (value.is_a?(File) ? Multipart::FileIO.new(params[:payload]) : Multipart::Param.new(key, value))
+      end
+      parts << Multipart::Epilogue.new
+
+      request.content_length = parts.inject(0) { |sum, part| sum + part.length }
+      request.content_type = 'multipart/form-data; boundary=' + parts.first.boundary
+      request.body_stream = Multipart::Stream.new(parts.map(&:to_io))
+    end
+
+    def setup_auth_basic
+      request.basic_auth(params[:basic_auth][:user], params[:basic_auth][:password])
+    end
+
+    def set_header
+      params[:headers].each do |(type, value)|
+        formated_type = type.to_s.split(/_/).map(&:capitalize).join('-')
+
+        request[formated_type] = value
+      end
+    end
+
+    def setup_ssl
+      http.use_ssl     = true
+      http.ca_file     = params[:ca_file]
+      http.verify_mode = params[:verify_mode]
+    end
+
+    def uri
+      @uri ||= URI(params[:url])
+    end
+
+    def uri_proxy
+      @uri_proxy ||=
+        if params[:proxy]
+          URI(params[:proxy])
+        else
+          OpenStruct.new
+        end
+    end
+
+    def proxy_host
+      uri_proxy.host || :ENV
+    end
+  end
+end

data/lib/fat_zebra/request/multipart/epilogue.rb

@@ -0,0 +1,23 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Epilogue
+  #
+  # Add the epilogue to the multipart
+  class Request
+    module Multipart
+      class Epilogue
+        include Part
+
+        def initialize
+          @io = StringIO.new(footer)
+        end
+
+        private
+
+        def footer
+          "--#{boundary}--#{LINE_BREAK}"
+        end
+      end
+    end
+  end
+end

data/lib/fat_zebra/request/multipart/file_io.rb

@@ -0,0 +1,40 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \FileIO
+  #
+  # Add file to the multipart
+  class Request
+    module Multipart
+      class FileIO
+        include Part
+
+        attr_reader :length, :stream
+
+        def initialize(options)
+          @filename     = options[:filename]
+          @file         = options[:file]
+          @content_type = options[:content_type]
+          @options      = options
+          @file_size    = File.size(@file)
+          @footer       = LINE_BREAK
+          @length       = header.bytesize + @file_size + @footer.length
+          @io           = Stream.new(StringIO.new(header), @file, StringIO.new(@footer))
+        end
+
+        def header
+          part = []
+          part << "--#{boundary}"
+          part << "Content-Disposition: form-data; name=\"#{@filename}\"; filename=\"#{@filename}\""
+          part << "Content-Length: #{@size}"
+          part << "Content-Type: #{@content_type}"
+          part << 'Content-Transfer-Encoding: binary'
+          part << LINE_BREAK
+
+          part.join(LINE_BREAK)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/request/multipart/param.rb

@@ -0,0 +1,37 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Param
+  #
+  # Add param to the multipart
+  class Request
+    module Multipart
+      class Param
+        include Part
+
+        def initialize(name, value)
+          @name  = name
+          @value = value
+          @io    = StringIO.new(part)
+        end
+
+        def length
+          part.bytesize
+        end
+
+        private
+
+        def part
+          part = []
+          part << "--#{boundary}"
+          part << "Content-Disposition: form-data; name=\"#{@name}\""
+          part << ''
+          part << @value
+
+          part.join(LINE_BREAK)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/request/multipart/part.rb

@@ -0,0 +1,28 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Part
+  #
+  # Define one part
+  class Request
+    module Multipart
+      module Part
+
+        LINE_BREAK = "\r\n".freeze
+
+        def boundary
+          '----FatZebraMultipartPost'
+        end
+
+        def length
+          @io.length
+        end
+
+        def to_io
+          @io
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/request/multipart/stream.rb

@@ -0,0 +1,57 @@
+module FatZebra
+  ##
+  # == FatZebra \Request \Multipart \Stream
+  #
+  # Steam the multipart
+  class Request
+    module Multipart
+      class Stream
+
+        BINARY_ENCODING = 'BINARY'.freeze
+
+        def initialize(*ios)
+          @ios   = ios.flatten
+          @index = 0
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def read(length = nil, outbuf = nil)
+          got_result = false
+          outbuf = outbuf ? outbuf.replace('') : ''
+
+          while current_io
+            result = current_io.read(length)
+
+            if result
+              got_result ||= !result.nil?
+              result.force_encoding(BINARY_ENCODING) if result.respond_to?(:force_encoding)
+              outbuf << result
+
+              length -= result.length if length
+              break if length == 0
+            end
+
+            next_io
+          end
+
+          !got_result && length ? nil : outbuf
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        private
+
+        def current_io
+          @ios[@index]
+        end
+
+        def next_io
+          @index += 1
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fat_zebra/util.rb

@@ -0,0 +1,71 @@
+module FatZebra
+  module Util
+    class << self
+
+      DATE_FORMAT = '%Y/%m/%d'.freeze
+      REGEXP_HTTP = %r{http[s]?\:\/\/}
+
+      def cleanup_host(uri)
+        uri.gsub(REGEXP_HTTP, '')
+      end
+
+      ##
+      # Remove nil value from hash
+      #
+      # @return [Hash]
+      def compact(hash)
+        # Can use Hash#compact when Ruby 2.3 compatability is dropped
+        hash.reject { |_, value| value.nil? }
+      end
+
+      ##
+      # Convert string to camelize
+      #
+      # @param [String]
+      #
+      # @example
+      #   camelize('my_model') => 'MyModel'
+      def camelize(string)
+        string.split('_').map(&:capitalize).join
+      end
+
+      ##
+      # Convert string to underscore
+      #
+      # @param [String]
+      #
+      # @example
+      #   underscore('MyModel') => 'my_model'
+      def underscore(string)
+        string
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+
+      def hash_except(hash, *keys)
+        copy = hash.dup
+        keys.each { |key| copy.delete(key) }
+        copy
+      end
+
+      ##
+      # Format Date attribute in the params
+      #
+      # @param [Hash] params
+      #
+      # @return [Hash] date formated params
+      def format_dates_in_hash(hash)
+        # Can use Hash#transform_values! when Ruby 2.3 compatablility is dropped
+        hash.each do |(key, value)|
+          hash[key] = value.strftime DATE_FORMAT if value.respond_to? :strftime
+        end
+
+        hash
+      end
+
+    end
+  end
+end