4me-sdk 1.1.8 → 2.0.0

data/lib/sdk4me/client.rb

@@ -13,21 +13,24 @@ require 'sdk4me/client/multipart'
 require 'sdk4me/client/attachments'
 
 # cherry-pick some core extensions from active support
-require 'active_support/core_ext/module/aliasing.rb'
+require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/try.rb'
+require 'active_support/core_ext/object/try'
 require 'active_support/core_ext/hash/indifferent_access'
 
 module Sdk4me
   class Client
     MAX_PAGE_SIZE = 100
-    DEFAULT_HEADER = {'Content-Type' => 'application/json'}
+    DEFAULT_HEADER = {
+      'Content-Type' => 'application/json',
+      'User-Agent' => "4me-sdk-ruby/#{Sdk4me::Client::VERSION}"
+    }.freeze
 
     # Create a new 4me SDK Client
     #
     # Shared configuration for all 4me SDK Clients:
     #   Sdk4me.configure do |config|
-    #     config.api_token = 'd41f5868feb65fc87fa2311a473a8766ea38bc40'
+    #     config.access_token = 'd41f5868feb65fc87fa2311a473a8766ea38bc40'
     #     config.account = 'my-sandbox'
     #     ...
     #   end
@@ -37,13 +40,14 @@ module Sdk4me
     #
     # All options available:
     #  - logger:      The Ruby Logger instance, default: Logger.new(STDOUT)
-    #  - host:        The 4me API host, default: 'https://api.4me.com'
-    #  - api_version: The 4me API version, default: 'v1'
-    #  - api_token:   *required* The 4me API token
+    #  - host:        The 4me REST API host, default: 'https://api.4me.com'
+    #  - api_version: The 4me REST API version, default: 'v1'
+    #  - access_token: *required* The 4me access token
     #  - account:     Specify a different (trusted) account to work with
-    #                 @see http://developer.4me.com/v1/#multiple-accounts
+    #                 @see https://developer.4me.com/v1/#multiple-accounts
     #  - source:      The Source used when creating new records
-    #                 @see http://developer.4me.com/v1/general/source/
+    #                 @see https://developer.4me.com/v1/general/source/
+    #  - user_agent:  The User-Agent header of each request
     #
     #  - max_retry_time: maximum nr of seconds to wait for server to respond (default = 5400 = 1.5 hours)
     #                    the sleep time between retries starts at 2 seconds and doubles after each retry
@@ -51,7 +55,7 @@ module Sdk4me
     #                    one retry will always be performed unless you set the value to -1
     #  - read_timeout:   HTTP GET read timeout in seconds (default = 25)
     #  - block_at_rate_limit: Set to +true+ to block the request until the rate limit is lifted, default: +false+
-    #                         @see http://developer.4me.com/v1/#rate-limiting
+    #                         @see https://developer.4me.com/v1/#rate-limiting
     #
     #  - proxy_host:     Define in case HTTP traffic needs to go through a proxy
     #  - proxy_port:     Port of the proxy, defaults to 8080
@@ -59,12 +63,19 @@ module Sdk4me
     #  - proxy_password: Proxy password
     def initialize(options = {})
       @options = Sdk4me.configuration.current.merge(options)
-      [:host, :api_version, :api_token].each do |required_option|
-        raise ::Sdk4me::Exception.new("Missing required configuration option #{required_option}") if option(required_option).blank?
+      %i[host api_version].each do |required_option|
+        raise ::Sdk4me::Exception, "Missing required configuration option #{required_option}" if option(required_option).blank?
       end
+      @logger = @options[:logger]
       @ssl, @domain, @port = ssl_domain_port_path(option(:host))
+      unless option(:access_token).present?
+        if option(:api_token).blank?
+          raise ::Sdk4me::Exception, 'Missing required configuration option access_token'
+        else
+          @logger.info('DEPRECATED: Use of api_token is deprecated, switch to using access_token instead. -- https://developer.4me.com/v1/#authentication')
+        end
+      end
       @ssl_verify_none = options[:ssl_verify_none]
-      @logger = @options[:logger]
     end
 
     # Retrieve an option
@@ -77,15 +88,16 @@ module Sdk4me
     # Returns total nr of resources yielded (for logging)
     def each(path, params = {}, header = {}, &block)
       # retrieve the resources using the max page size (least nr of API calls)
-      next_path = expand_path(path, {per_page: MAX_PAGE_SIZE, page: 1}.merge(params))
+      next_path = expand_path(path, { per_page: MAX_PAGE_SIZE, page: 1 }.merge(params))
       size = 0
       while next_path
         # retrieve the records (with retry and optionally wait for rate-limit)
         response = get(next_path, {}, header)
         # raise exception in case the response is invalid
-        raise ::Sdk4me::Exception.new(response.message) unless response.valid?
+        raise ::Sdk4me::Exception, response.message unless response.valid?
+
         # yield the resources
-        response.json.each{ |resource| yield resource }
+        response.json.each(&block)
         size += response.json.size
         # go to the next page
         next_path = response.pagination_relative_link(:next)
@@ -104,14 +116,14 @@ module Sdk4me
     end
 
     # send HTTPS PATCH request and return instance of Sdk4me::Response
-    def put(path, data = {}, header = {})
-      _send(json_request(Net::HTTP::Patch, path, data, header))
+    def patch(path, data = {}, header = {})
+      _send(json_request(Net::HTTP::Patch, path, data, expand_header(header)))
     end
-    alias_method :patch, :put
+    alias put patch
 
     # send HTTPS POST request and return instance of Sdk4me::Response
     def post(path, data = {}, header = {})
-      _send(json_request(Net::HTTP::Post, path, data, header))
+      _send(json_request(Net::HTTP::Post, path, data, expand_header(header)))
     end
 
     # upload a CSV file to import
@@ -128,17 +140,19 @@ module Sdk4me
       @logger.info { "Import file '#{csv.path}' successfully uploaded with token '#{response[:token]}'." } if response.valid?
 
       if block_until_completed
-        raise ::Sdk4me::UploadFailed.new("Failed to queue #{type} import. #{response.message}") unless response.valid?
+        raise ::Sdk4me::UploadFailed, "Failed to queue #{type} import. #{response.message}" unless response.valid?
+
         token = response[:token]
-        while true
+        loop do
           response = get("/import/#{token}")
           unless response.valid?
             sleep(5)
             response = get("/import/#{token}") # single retry to recover from a network error
-            raise ::Sdk4me::Exception.new("Unable to monitor progress for #{type} import. #{response.message}") unless response.valid?
+            raise ::Sdk4me::Exception, "Unable to monitor progress for #{type} import. #{response.message}" unless response.valid?
           end
           # wait 30 seconds while the response is OK and import is still busy
-          break unless ['queued', 'processing'].include?(response[:state])
+          break unless %w[queued processing].include?(response[:state])
+
           @logger.debug { "Import of '#{csv.path}' is #{response[:state]}. Checking again in 30 seconds." }
           sleep(30)
         end
@@ -154,7 +168,7 @@ module Sdk4me
     # @param locale: Required for translations export
     # @raise Sdk4me::Exception in case the export progress could not be monitored
     def export(types, from = nil, block_until_completed = false, locale = nil)
-      data = {type: [types].flatten.join(',')}
+      data = { type: [types].flatten.join(',') }
       data[:from] = from unless from.blank?
       data[:locale] = locale unless locale.blank?
       response = post('/export', data)
@@ -167,17 +181,19 @@ module Sdk4me
       end
 
       if block_until_completed
-        raise ::Sdk4me::UploadFailed.new("Failed to queue '#{data[:type]}' export. #{response.message}") unless response.valid?
+        raise ::Sdk4me::UploadFailed, "Failed to queue '#{data[:type]}' export. #{response.message}" unless response.valid?
+
         token = response[:token]
-        while true
+        loop do
           response = get("/export/#{token}")
           unless response.valid?
             sleep(5)
             response = get("/export/#{token}") # single retry to recover from a network error
-            raise ::Sdk4me::Exception.new("Unable to monitor progress for '#{data[:type]}' export. #{response.message}") unless response.valid?
+            raise ::Sdk4me::Exception, "Unable to monitor progress for '#{data[:type]}' export. #{response.message}" unless response.valid?
           end
           # wait 30 seconds while the response is OK and export is still busy
-          break unless ['queued', 'processing'].include?(response[:state])
+          break unless %w[queued processing].include?(response[:state])
+
           @logger.debug { "Export of '#{data[:type]}' is #{response[:state]}. Checking again in 30 seconds." }
           sleep(30)
         end
@@ -186,18 +202,16 @@ module Sdk4me
       response
     end
 
-    def logger
-      @logger
-    end
+    attr_reader :logger
 
     private
 
     # create a request (place data in body if the request becomes too large)
-    def json_request(request_class, path, data = {}, header = {})
-      Sdk4me::Attachments.new(self).upload_attachments!(path, data)
-      request = request_class.new(expand_path(path), expand_header(header))
+    def json_request(request_class, path, data, header)
+      Sdk4me::Attachments.new(self, path).upload_attachments!(data)
+      request = request_class.new(expand_path(path), header)
       body = {}
-      data.each{ |k,v| body[k.to_s] = typecast(v, false) }
+      data.each { |k, v| body[k.to_s] = typecast(v, false) }
       request.body = body.to_json
       request
     end
@@ -208,15 +222,18 @@ module Sdk4me
     end
 
     # Expand the given header with the default header
-    def expand_header(header = {})
-      header = DEFAULT_HEADER.merge(header)
+    def expand_header(headers = {})
+      header = DEFAULT_HEADER.dup
       header['X-4me-Account'] = option(:account) if option(:account)
-      token_and_password = option(:api_token).include?(':') ? option(:api_token) : "#{option(:api_token)}:x"
-      header['AUTHORIZATION'] = 'Basic ' + [token_and_password].pack('m*').gsub(/\s/, '')
-      if option(:source)
-        header['X-4me-Source'] = option(:source)
-        header['HTTP_USER_AGENT'] = option(:source)
+      if option(:access_token).present?
+        header['AUTHORIZATION'] = "Bearer #{option(:access_token)}"
+      else
+        token_and_password = option(:api_token).include?(':') ? option(:api_token) : "#{option(:api_token)}:x"
+        header['AUTHORIZATION'] = "Basic #{[token_and_password].pack('m*').gsub(/\s/, '')}"
       end
+      header['X-4me-Source'] = option(:source) if option(:source)
+      header['User-Agent'] = option(:user_agent) if option(:user_agent)
+      header.merge!(headers)
       header
     end
 
@@ -227,8 +244,8 @@ module Sdk4me
     #   fields: ['id', 'created_at', 'sourceID']
     def expand_path(path, params = {})
       path = path.dup
-      path = "/#{path}" unless path =~ /^\// # make sure path starts with /
-      path = "/#{option(:api_version)}#{path}" unless path =~ /^\/v[\d.]+\// # preprend api version
+      path = "/#{path}" unless path =~ %r{^/} # make sure path starts with /
+      path = "/#{option(:api_version)}#{path}" unless path =~ %r{^/v[\d.]+/} # preprend api version
       params.each do |key, value|
         path << (path['?'] ? '&' : '?')
         path << expand_param(key, value)
@@ -247,18 +264,20 @@ module Sdk4me
     # Parameter value typecasting
     def typecast(value, escape = true)
       case value.class.name.to_sym
-        when :NilClass    then ''
-        when :String      then escape ? uri_escape(value) : value
-        when :TrueClass   then 'true'
-        when :FalseClass  then 'false'
-        when :DateTime    then datetime = value.new_offset(0).iso8601; escape ? uri_escape(datetime) : datetime
-        when :Date        then value.strftime("%Y-%m-%d")
-        when :Time        then value.strftime("%H:%M")
+      when :NilClass    then ''
+      when :String      then escape ? uri_escape(value) : value
+      when :TrueClass   then 'true'
+      when :FalseClass  then 'false'
+      when :DateTime
+        datetime = value.new_offset(0).iso8601
+        escape ? uri_escape(datetime) : datetime
+      when :Date        then value.strftime('%Y-%m-%d')
+      when :Time        then value.strftime('%H:%M')
         # do not convert arrays in put/post requests as squashing arrays is only used in filtering
-        when :Array       then escape ? value.map{ |v| typecast(v, escape) }.join(',') : value
+      when :Array       then escape ? value.map { |v| typecast(v, escape) }.join(',') : value
         # TODO: temporary for special constructions to update contact details, see Request #1444166
-        when :Hash        then escape ? value.to_s : value
-        else escape ? value.to_json : value.to_s
+      when :Hash        then escape ? value.to_s : value
+      else escape ? value.to_json : value.to_s
       end
     end
 
@@ -266,27 +285,27 @@ module Sdk4me
     # Guaranteed to return a Response, thought it may be +empty?+
     def _send(request, domain = @domain, port = @port, ssl = @ssl)
       @logger.debug { "Sending #{request.method} request to #{domain}:#{port}#{request.path}" }
-      _response = begin
+      response = begin
         http_with_proxy = option(:proxy_host).blank? ? Net::HTTP : Net::HTTP::Proxy(option(:proxy_host), option(:proxy_port), option(:proxy_user), option(:proxy_password))
         http = http_with_proxy.new(domain, port)
         http.read_timeout = option(:read_timeout)
         http.use_ssl = ssl
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ssl_verify_none
-        http.start{ |_http| _http.request(request) }
-      rescue ::Exception => e
+        http.start { |transport| transport.request(request) }
+      rescue StandardError => e
         Struct.new(:body, :message, :code, :header).new(nil, "No Response from Server - #{e.message} for '#{domain}:#{port}#{request.path}'", 500, {})
       end
-      response = Sdk4me::Response.new(request, _response)
-      if response.valid?
-        @logger.debug { "Response:\n#{JSON.pretty_generate(response.json)}" }
-      elsif response.raw.body =~ /^\s*<\?xml/i
-        @logger.debug { "XML response:\n#{response.raw.body}" }
-      elsif '303' == response.raw.code.to_s
-        @logger.debug { "Redirect: #{response.raw.header['Location']}" }
+      resp = Sdk4me::Response.new(request, response)
+      if resp.valid?
+        @logger.debug { "Response:\n#{JSON.pretty_generate(resp.json)}" }
+      elsif resp.raw.body =~ /^\s*<\?xml/i
+        @logger.debug { "XML response:\n#{resp.raw.body}" }
+      elsif resp.raw.code.to_s == '303'
+        @logger.debug { "Redirect: #{resp.raw.header['Location']}" }
       else
-        @logger.error { "#{request.method} request to #{domain}:#{port}#{request.path} failed: #{response.message}" }
+        @logger.error { "#{request.method} request to #{domain}:#{port}#{request.path} failed: #{resp.message}" }
       end
-      response
+      resp
     end
 
     # parse the given URI to [domain, port, ssl, path]
@@ -295,65 +314,70 @@ module Sdk4me
       ssl = uri.scheme == 'https'
       [ssl, uri.host, uri.port, uri.path]
     end
-
   end
 
   module SendWithRateLimitBlock
     # Wraps the _send method with retries when the server does not respond, see +initialize+ option +:rate_limit_block+
     def _send(request, domain = @domain, port = @port, ssl = @ssl)
-      return super(request, domain, port, ssl) unless option(:block_at_rate_limit) && option(:max_throttle_time) > 0
+      return super(request, domain, port, ssl) unless option(:block_at_rate_limit) && option(:max_throttle_time).positive?
+
       now = nil
       timed_out = false
-      begin
-        _response = super(request, domain, port, ssl)
+      response = nil
+      loop do
+        response = super(request, domain, port, ssl)
         now ||= Time.now
-        if _response.throttled?
+        if response.throttled?
           # if no Retry-After is not provided, the 4me server is very busy, wait 5 minutes
-          retry_after = _response.retry_after == 0 ? 300 : [_response.retry_after, 2].max
+          retry_after = response.retry_after.zero? ? 300 : [response.retry_after, 2].max
           if (Time.now - now + retry_after) < option(:max_throttle_time)
-            @logger.warn { "Request throttled, trying again in #{retry_after} seconds: #{_response.message}" }
+            @logger.warn { "Request throttled, trying again in #{retry_after} seconds: #{response.message}" }
             sleep(retry_after)
           else
             timed_out = true
           end
         end
-      end while _response.throttled? && !timed_out
-      _response
+        break unless response.throttled? && !timed_out
+      end
+      response
     end
   end
-  Client.send(:prepend, SendWithRateLimitBlock)
+  Client.prepend SendWithRateLimitBlock
 
   module SendWithRetries
     # Wraps the _send method with retries when the server does not respond, see +initialize+ option +:retries+
     def _send(request, domain = @domain, port = @port, ssl = @ssl)
-      return super(request, domain, port, ssl) unless option(:max_retry_time) > 0
+      return super(request, domain, port, ssl) unless option(:max_retry_time).positive?
+
       retries = 0
       sleep_time = 1
       now = nil
       timed_out = false
-      begin
-        _response = super(request, domain, port, ssl)
+      response = nil
+      loop do
+        response = super(request, domain, port, ssl)
         now ||= Time.now
-        if _response.failure?
+        if response.failure?
           sleep_time *= 2
           if (Time.now - now + sleep_time) < option(:max_retry_time)
-            @logger.warn { "Request failed, retry ##{retries += 1} in #{sleep_time} seconds: #{_response.message}" }
+            @logger.warn { "Request failed, retry ##{retries += 1} in #{sleep_time} seconds: #{response.message}" }
             sleep(sleep_time)
           else
             timed_out = true
           end
         end
-      end while _response.failure? && !timed_out
-      _response
+        break unless response.failure? && !timed_out
+      end
+      response
     end
   end
-  Client.send(:prepend, SendWithRetries)
+  Client.prepend SendWithRetries
 end
 
 # HTTPS with certificate bundle
 module Net
   class HTTP
-    alias_method :original_use_ssl=, :use_ssl=
+    alias original_use_ssl= use_ssl=
 
     def use_ssl=(flag)
       self.ca_file = File.expand_path(Sdk4me.configuration.current[:ca_file], __FILE__) if flag
@@ -362,4 +386,3 @@ module Net
     end
   end
 end
-

data/lib/sdk4me/client/attachments.rb

@@ -1,152 +1,143 @@
 module Sdk4me
   class Attachments
+    S3_PROVIDER = 's3'.freeze
+    FILENAME_TEMPLATE = '${filename}'.freeze
 
-    AWS_PROVIDER = 'aws'
-    FILENAME_TEMPLATE = '${filename}'
-
-    def initialize(client)
+    def initialize(client, path)
       @client = client
+      @path = path
     end
 
-    # upload the attachments and return the data with the uploaded attachment info
-    # Two flavours available
-    #  * data[:attachments]
-    #  * data[:note] containing text with '[attachment:/tmp/images/green_fuzz.jpg]'
-    def upload_attachments!(path, data)
-      upload_options = {
-        raise_exceptions: !!data.delete(:attachments_exception),
-        attachments_field: attachments_field(path),
-      }
-      uploaded_attachments = upload_normal_attachments!(path, data, upload_options)
-      uploaded_attachments += upload_inline_attachments!(path, data, upload_options)
-      # jsonify the attachments, if any were uploaded
-      data[upload_options[:attachments_field]] = uploaded_attachments.compact.to_json if uploaded_attachments.compact.any?
-    end
-
-    private
-
-    # upload the attachments in :attachments to 4me and return the data with the uploaded attachment info
-    def upload_normal_attachments!(path, data, upload_options)
-      attachments = [data.delete(:attachments)].flatten.compact
-      return [] if attachments.empty?
-
-      upload_options[:storage] ||= storage(path, upload_options[:raise_exceptions])
-      return [] unless upload_options[:storage]
-
-      attachments.map do |attachment|
-        upload_attachment(upload_options[:storage], attachment, upload_options[:raise_exceptions])
+    # Upload attachments and replace the data inline with the uploaded
+    # attachments info.
+    #
+    # To upload field attachments:
+    #  * data[:note_attachments] = ['/tmp/test.doc', '/tmp/test.log']
+    #
+    # To upload inline images:
+    #  * data[:note] containing text referring to inline images in
+    #    data[:note_attachments] by their array index, with the index being
+    #    zero-based. Text can only refer to inline images in its own
+    #    attachments collection. For example:
+    #
+    #      data = {
+    #        note: "Hello [note_attachments: 0] and [note_attachments: 1]",
+    #        note_attachments: ['/tmp/jip.png', '/tmp/janneke.png'],
+    #        ...
+    #      }
+    #
+    # After calling this method the data that will be posted to update the
+    # 4me record would look similar to:
+    #
+    #      data = {
+    #        note: "Hello ![](storage/abc/adjhajdhjaadf.png) and ![](storage/abc/fskdhakjfkjdssdf.png])",
+    #        note_attachments: [
+    #          { key: 'storage/abc/fskdhakjfkjdssdf.png', filesize: 12345, inline: true },
+    #          { key: 'storage/abc/fskdhakjfkjdssdf.png'], filesize: 98765, inline: true }
+    #        ],
+    #        ...
+    #      }
+    def upload_attachments!(data)
+      # Field attachments
+      field_attachments = []
+      data.each do |field, value|
+        next unless field.to_s.end_with?('_attachments')
+        next unless value.is_a?(Enumerable) && value.any?
+
+        value.map! { |attachment| upload_attachment(attachment) }.compact!
+        field_attachments << field if value.any?
       end
-    end
 
-    INLINE_ATTACHMENT_REGEXP = /\[attachment:([^\]]+)\]/.freeze
-    # upload any '[attachment:/tmp/images/green_fuzz.jpg]' in :note text field to 4me as inline attachment and add the s3 key to the text
-    def upload_inline_attachments!(path, data, upload_options)
-      text_field = upload_options[:attachments_field].to_s.gsub('_attachments', '').to_sym
-      return [] unless (data[text_field] || '') =~ INLINE_ATTACHMENT_REGEXP
-
-      upload_options[:storage] ||= storage(path, upload_options[:raise_exceptions])
-      return [] unless upload_options[:storage]
-
-      attachments = []
-      data[text_field] = data[text_field].gsub(INLINE_ATTACHMENT_REGEXP) do |full_match|
-        attachment_details = upload_attachment(upload_options[:storage], $~[1], upload_options[:raise_exceptions])
-        if attachment_details
-          attachments << attachment_details.merge(inline: true)
-          "![](#{attachment_details[:key]})" # magic markdown for inline attachments
-        else
-          full_match
+      # Rich text inline attachments
+      field_attachments.each do |field_attachment|
+        field = field_attachment.to_s.sub(/_attachments$/, '')
+        value = data[field.to_sym] || data[field]
+        next unless value.is_a?(String)
+
+        value.gsub!(/\[#{field_attachment}:\s?(\d+)\]/) do |match|
+          idx = Regexp.last_match(1).to_i
+          attachment = data[field_attachment][idx]
+          if attachment
+            attachment[:inline] = true
+            "![](#{attachment[:key]})" # magic markdown for inline attachments
+          else
+            match
+          end
         end
       end
-      attachments
     end
 
-    def storage(path, raise_exceptions)
-      # retrieve the upload configuration for this record from 4me
-      storage = @client.get(path =~ /\d+$/ ? path : "#{path}/new", {attachment_upload_token: true}, @client.send(:expand_header))[:storage_upload]
-      report_error("Attachments not allowed for #{path}", raise_exceptions) unless storage
-      storage
-    end
+    private
 
-    def attachments_field(path)
-      case path
-      when /cis/, /contracts/, /flsas/, /service_instances/, /slas/
-        :remarks_attachments
-      when /service_offerings/
-        :summary_attachments
-      else
-        :note_attachments
-      end
+    def raise_error(message)
+      @client.logger.error { message }
+      raise Sdk4me::UploadFailed, message
     end
 
-    def report_error(message, raise_exceptions)
-      if raise_exceptions
-        raise Sdk4me::UploadFailed.new(message)
-      else
-        @client.logger.error{ message }
-      end
+    def storage
+      @storage ||= @client.get('/attachments/storage').json.with_indifferent_access
     end
 
-    # upload a single attachment and return the data for the note_attachments
-    # returns nil and provides an error in case the attachment upload failed
-    def upload_attachment(storage, attachment, raise_exceptions)
-      begin
-        # attachment is already a file or we need to open the file from disk
-        unless attachment.respond_to?(:path) && attachment.respond_to?(:read)
-          raise "file does not exist: #{attachment}" unless File.exists?(attachment)
-          attachment = File.open(attachment, 'rb')
-        end
+    # Upload a single attachment and return the data that should be submitted
+    # back to 4me. Returns nil and provides an error in case the attachment
+    # upload failed.
+    def upload_attachment(attachment)
+      return nil unless attachment
+
+      provider = storage[:provider]
+      raise 'No provider found' unless provider
 
-        # there are two different upload methods: AWS S3 and 4me local storage
-        key_template = "#{storage[:upload_path]}#{FILENAME_TEMPLATE}"
-        key = key_template.gsub(FILENAME_TEMPLATE, File.basename(attachment.path))
-        upload_method = storage[:provider] == AWS_PROVIDER ? :aws_upload : :upload_to_4me
-        send(upload_method, storage, key_template, key, attachment)
-
-        # return the values for the note_attachments param
-        {key: key, filesize: File.size(attachment.path)}
-      rescue ::Exception => e
-        report_error("Attachment upload failed: #{e.message}", raise_exceptions)
-        nil
+      # attachment is already a file or we need to open the file from disk
+      unless attachment.respond_to?(:path) && attachment.respond_to?(:read)
+        raise "file does not exist: #{attachment}" unless File.exist?(attachment)
+
+        attachment = File.open(attachment, 'rb')
       end
+
+      key_template = storage[provider][:key]
+      key = key_template.sub(FILENAME_TEMPLATE, File.basename(attachment.path))
+
+      key = if provider == S3_PROVIDER
+              upload_to_s3(key, attachment)
+            else
+              upload_to_4me_local(key, attachment)
+            end
+
+      # return the values for the attachments param
+      { key: key, filesize: File.size(attachment.path) }
+    rescue StandardError => e
+      raise_error("Attachment upload failed: #{e.message}")
     end
 
-    def aws_upload(aws, key_template, key, attachment)
-      # upload the file to AWS
-      response = send_file(aws[:upload_uri], {
-        :'x-amz-server-side-encryption' => 'AES256',
-        key: key_template,
-        AWSAccessKeyId: aws[:access_key],
-        acl: 'private',
-        signature: aws[:signature],
-        success_action_status: 201,
-        policy: aws[:policy],
-        file: attachment # file must be last
-      })
+    # Upload the file to AWS S3 storage
+    def upload_to_s3(key, attachment)
+      uri = storage[:upload_uri]
+      response = send_file(uri, storage[:s3].merge({ file: attachment }))
+
       # this is a bit of a hack, but Amazon S3 returns only XML :(
-      xml = response.raw.body || ''
-      error = xml[/<Error>.*<Message>(.*)<\/Message>.*<\/Error>/, 1]
-      raise "AWS upload to #{aws[:upload_uri]} for #{key} failed: #{error}" if error
+      xml = response.body || ''
+      error = xml[%r{<Error>.*<Message>(.*)</Message>.*</Error>}, 1]
+      raise "AWS S3 upload to #{uri} for #{key} failed: #{error}" if error
 
-      # inform 4me of the successful upload
-      response = @client.get(aws[:success_url].split('/').last, {key: key}, @client.send(:expand_header))
-      raise "4me confirmation #{aws[:success_url].split('/').last} for #{key} failed: #{response.message}" unless response.valid?
+      xml[%r{<Key>(.*)</Key>}, 1]
     end
 
-    # upload the file directly to 4me
-    def upload_to_4me(storage, key_template, key, attachment)
-      uri = storage[:upload_uri] =~ /\/v1/ ? storage[:upload_uri] : storage[:upload_uri].gsub('/attachments', '/v1/attachments')
-      response = send_file(uri, {file: attachment, key: key_template}, @client.send(:expand_header))
-      raise "4me upload to #{storage[:upload_uri]} for #{key} failed: #{response.message}" unless response.valid?
+    # Upload the file directly to 4me local storage
+    def upload_to_4me_local(key, attachment)
+      uri = storage[:upload_uri]
+      response = send_file(uri, storage[:local].merge({ file: attachment }), @client.send(:expand_header))
+      raise "4me upload to #{uri} for #{key} failed: #{response.message}" unless response.valid?
+
+      JSON.parse(response.body)['key']
     end
 
     def send_file(uri, params, basic_auth_header = {})
-      params = {:'Content-Type' => MIME::Types.type_for(params[:key])[0] || MIME::Types["application/octet-stream"][0]}.merge(params)
+      params = { 'Content-Type': MIME::Types.type_for(params[:key])[0] || MIME::Types['application/octet-stream'][0] }.merge(params)
       data, header = Sdk4me::Multipart::Post.prepare_query(params)
       ssl, domain, port, path = @client.send(:ssl_domain_port_path, uri)
       request = Net::HTTP::Post.new(path, basic_auth_header.merge(header))
       request.body = data
       @client.send(:_send, request, domain, port, ssl)
     end
-
   end
 end