filestack 2.6.5 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9b1f02595e1bf2a27da2b0462dcc43587f54281c
-  data.tar.gz: 9928b9905494435dbdfdb9b3d3b5c6149da3245e
+SHA256:
+  metadata.gz: 77f23edf489898b7e03305bca017f6eb519cf3995aecd120908a6d01042ca60d
+  data.tar.gz: bcdc3b18c9ecd5ebbc886cfd518a08b2ba0eccdc994f24e673095fdfdc84945f
 SHA512:
-  metadata.gz: 4201ad1145b65b9260825f7a93d2df79d94d83572cd2bbc9cc2c98af63d831a1d69a0c6ee429796ffbc7383b3f6b276bfb0c973535fb1e244dfdbf75f375145a
-  data.tar.gz: 47f97cad0eef7bf7a0b1ab6d979ccce88f1824fdc231e203dd29c55fe6752c5985f80eb52912b7d1c89358e97b10d4efa5e77291f56bf3a762b1df186fcfa686
+  metadata.gz: 596a72ca7995f8ba53a63d78f6ae2b0994f5c02b5b8e38fb273f0b6aefb8f657638544ee2775320d7d8c472dee8879bf5e7765de0f8ecf96ed93c973eeb1707a
+  data.tar.gz: e55b56cfefdfeaa5bffbd52f83af5d9d92ebf7952150c02fec12a43f256a3f8b2e8575627593f12fe826ac1004104e4c42bf45c1e7c8748609730faaf6ced218

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Filestack-Ruby Changelog
 
+## 2.8.1 (October 1, 2020)
+- Add rescue and raises body message on upload
+
+## 2.8.0 (September 29, 2020)
+- Add IO object upload
+
+## 2.7.0 (September 28, 2020)
+- Add workflows
+
+## 2.6.7 (August 4, 2020)
+- Add content disposition task
+
+## 2.6.6 (June 19, 2020)
+- Add compress task to transformations
+
 ## 2.6.5 (January 9, 2020)
 - Updated version of the parallel gem
 

data/README.md

@@ -44,41 +44,70 @@ Or install it yourself as:
 require 'filestack'
 ```
 Intialize the client using your API key, and security if you are using it.
+
 ```ruby
 client = FilestackClient.new('YOUR_API_KEY', security: security_object)
 ```
 ### Uploading
-Filestack uses multipart uploading by default, which is faster for larger files. This can be turned off by passing in ```multipart: false```. Multipart is disabled when uploading external URLs.
 ```ruby
-filelink = client.upload(filepath: '/path/to/file')
+filelink = client.upload(filepath: '/path/to/localfile')
+
+# OR
 
-filelink = client.upload(filepath: '/path/to/file', multipart: false)
+filelink = client.upload(external_url: 'http://domain.com/image.png')
 
 # OR
 
-filelink = client.upload(external_url: 'http://someurl.com')
+file = StringIO.new
+filelink = client.upload(io: file)
 ```
 
-To upload a local and an external file with query parameters:
+To upload a local, an IO object and an external file with following optional options:
+
 ```ruby
-filelink = client.upload(filepath: '/path/to/file', options: {mimetype: 'image/png'})
+options = {
+  filename: 'string',
+  location: 'string',
+  path: 'string',
+  container: 'string',
+  mimetype: 'string',
+  region: 'string',
+  workflows: ['workflow-id-1', 'workflow-id-2'],
+  upload_tags: {
+    key: 'value',
+    key2: 'value'
+  }
+}
+
+filelink = client.upload(filepath: '/path/to/localfile', options: { mimetype: 'image/png', filename: 'custom_filename.png' })
 
-filelink = client.upload(external_url: 'http://someurl.com/image.png', options: {mimetype: 'image/jpeg'})
+filelink = client.upload(external_url: 'http://domain.com/image.png', options: { mimetype: 'image/jpeg', filename: 'custom_filename.png' })
 ```
 
 To store file on `dropbox`, `azure`, `gcs` or `rackspace`, you must have the chosen provider configured in the developer portal to enable this feature. By default the file is stored on `s3`. You can add more details of the storage in `options`.
 
 ```ruby
-filelink = client.upload(filepath: '/path/to/file', storage: 'dropbox', options: {path: 'folder_name/'})
+filelink = client.upload(filepath: '/path/to/file', storage: 's3', options: { path: 'folder_name/', container: 'container_name', location: 's3', region: 'region_name' })
+
+filelink = client.upload(external_url: 'http://someurl.com/image.png', options: { location: 'dropbox', path: 'folder_name' })
+```
+
+### Workflows
+Workflows allow you to wire up conditional logic and image processing to enforce business processes, automate ingest, and save valuable development time. In order to trigger the workflow job for each upload:
+
+```ruby
+filelink = client.upload(filepath: '/path/to/file', options: { workflows: ["workflow_id_1", "workflow_id_2"] })
+
+#OR
 
-filelink = client.upload(external_url: 'http://someurl.com/image.png', storage: 'dropbox', options: {path: 'folder_name/'})
+filelink = client.upload(external_url: 'http://someurl.com/image.png', options: { workflows: ["workflow_id_1"] })
 ```
 
 ### Security
 If security is enabled on your account, or if you are using certain actions that require security (delete, overwrite and certain transformations), you will need to create a security object and pass it into the client on instantiation.
 
 ```ruby
-security = FilestackSecurity.new('YOUR_APP_SECRET', options: {call: %w[read store pick]})
+security = FilestackSecurity.new('YOUR_APP_SECRET', options: {call: %w[read store pick runWorkflow]})
 client = FilestackClient.new('YOUR_API_KEY', security: security)
 ```
 
@@ -123,13 +152,20 @@ Return `default` file if the source of the transformation does not work or the t
 To use fallback, you should provide `handle` of the file that should be returned. Optionally, you can add `cache`, which means number of seconds fallback response should be cached in CDN.
 
 ```ruby
-transform = client.transform_external('https://someurl.com').fallback(handle: 'DEFAULT_HANDLE')
+transform = client.transform_external('https://someurl.com/file.png').fallback(file: 'DEFAULT_HANDLE_OR_FILEPATH')
 ```
 
 If you are using fallback handle that belongs to different application than the one which runs transformation (APIKEY) and it is secured with security policy, appropriate signature and policy with read call should be used:
 
 ```ruby
-transform = client.transform_external('https://someurl.com').fallback(handle: 'DEFAULT_HANDLE?policy=HANDLE_APIKEY_POLICY&signature=HANDLE_APIKEY_SIGNATURE', cache: 10)
+transform = client.transform_external('https://someurl.com/file.png').fallback(file: 'DEFAULT_HANDLE_OR_FILEPATH?policy=HANDLE_APIKEY_POLICY&signature=HANDLE_APIKEY_SIGNATURE', cache: 10)
+```
+
+### Content
+Sets `Content-Disposition` header for given file.
+
+```ruby
+transform = filelink.transform.content(filename: 'DEFAULT_FILENAME', type: 'TYPE')
 ```
 
 ### Tagging

data/VERSION

@@ -1 +1 @@
-2.6.5
+2.8.1

data/docs/TransformConfig.html

@@ -114,7 +114,8 @@
 </span><span class='tstring_content'>  partial_pixelate</span><span class='words_sep'> </span><span class='tstring_content'>partial_blur</span><span class='words_sep'> </span><span class='tstring_content'>collage</span><span class='words_sep'> </span><span class='tstring_content'>upscale</span><span class='words_sep'> </span><span class='tstring_content'>enhance</span><span class='words_sep'>
 </span><span class='tstring_content'>  redeye</span><span class='words_sep'> </span><span class='tstring_content'>ascii</span><span class='words_sep'> </span><span class='tstring_content'>filetype_conversion</span><span class='words_sep'> </span><span class='tstring_content'>quality</span><span class='words_sep'> </span><span class='tstring_content'>urlscreenshot</span><span class='words_sep'>
 </span><span class='tstring_content'>  no_metadata</span><span class='words_sep'></span><span class='tstring_content'> fallback</span><span class='words_sep'></span><span class='tstring_content'> pdfinfo</span><span class='words_sep'></span><span class='tstring_content'> pdfconvert</span><span class='words_sep'></span><span class='tstring_content'> cache</span><span class='words_sep'></span><span class='tstring_content'> auto_image</span><span class='words_sep'>
-</span><span class='tstring_content'>  minify_js</span><span class='words_sep'></span><span class='tstring_content'> minify_css</span><span class='words_sep'></span><span class='tstring_content'> animate</span><span class='words_sep'></span><span class='tstring_content'> video_convert</span><span class='words_sep'></span><span class='tstring_content'> video_playlist</span><span class='words_sep'></span>
+</span><span class='tstring_content'>  minify_js</span><span class='words_sep'></span><span class='tstring_content'> minify_css</span><span class='words_sep'></span><span class='tstring_content'> animate</span><span class='words_sep'></span><span class='tstring_content'> video_convert</span><span class='words_sep'></span><span class='tstring_content'> video_playlist</span><span class='words_sep'>
+</span><span class='tstring_content'>  compress</span><span class='words_sep'></span><span class='tstring_content'>  content</span><span class='words_sep'></span>
 <span class='tstring_end'>]</span></span><span class='period'>.</span><span class='id identifier rubyid_freeze'>freeze</span></pre></dd>
 
   </dl>

data/lib/filestack/config.rb

@@ -7,11 +7,6 @@ class FilestackConfig
   CDN_URL = 'https://cdn.filestackcontent.com'.freeze
   PROCESS_URL = 'https://process.filestackapi.com'.freeze
 
-  MULTIPART_START_URL = 'https://upload.filestackapi.com/multipart/start'.freeze
-  MULTIPART_UPLOAD_URL = 'https://upload.filestackapi.com/multipart/upload'.freeze
-  MULTIPART_COMMIT_URL = 'https://upload.filestackapi.com/multipart/commit'.freeze
-  MULTIPART_COMPLETE_URL = 'https://upload.filestackapi.com/multipart/complete'.freeze
-
   MULTIPART_PARAMS = %w[
     store_location store_region store_container
     store_path store_access
@@ -22,10 +17,30 @@ class FilestackConfig
   VERSION = Filestack::Ruby::VERSION
   HEADERS = {
     'User-Agent' => "filestack-ruby #{VERSION}",
-    'Filestack-Source' => "Ruby-#{VERSION}"
+    'Filestack-Source' => "Ruby-#{VERSION}",
+    'Content-Type' => "application/json",
+    'Accept-Encoding' => "application/json"
   }.freeze
 
+  DEFAULT_UPLOAD_MIMETYPE = 'application/octet-stream'
+
   INTELLIGENT_ERROR_MESSAGES = ['BACKEND_SERVER', 'BACKEND_NETWORK', 'S3_SERVER', 'S3_NETWORK']
+
+  def self.multipart_start_url
+    "https://upload.filestackapi.com/multipart/start"
+  end
+
+  def self.multipart_upload_url(base_url)
+    "https://#{base_url}/multipart/upload"
+  end
+
+  def self.multipart_commit_url(base_url)
+    "https://#{base_url}/multipart/commit"
+  end
+
+  def self.multipart_complete_url(base_url)
+    "https://#{base_url}/multipart/complete"
+  end
 end
 
 class TransformConfig
@@ -38,5 +53,6 @@ class TransformConfig
     redeye ascii filetype_conversion quality urlscreenshot
     no_metadata fallback pdfinfo pdfconvert cache auto_image
     minify_js minify_css animate video_convert video_playlist
+    compress content
   ].freeze
 end

data/lib/filestack/models/filestack_client.rb

@@ -23,30 +23,25 @@ class FilestackClient
     @security = security
   end
 
-  # Upload a local file or external url
+  # Upload a local file, external url or IO object
   # @param [String]               filepath         The path of a local file
   # @param [String]               external_url     An external URL
-  # @param [Bool]                 multipart        Switch for miltipart
-  #                                                    (Default: true)
+  # @param [StringIO]             io               The IO object
   # @param [Hash]                 options          User-supplied upload options
+  # @param [Boolean]              intelligent      Upload file using Filestack Intelligent Ingestion
+  # @param [String]               storage          Default storage to be used for uploads
   #
   # return [Filestack::FilestackFilelink]
-  def upload(filepath: nil, external_url: nil, multipart: true, options: {}, storage: 's3', intelligent: false, timeout: 60)
-    if filepath && external_url
-      return 'You cannot upload a URL and file at the same time'
-    end
-    response = if filepath && multipart
-                 multipart_upload(@apikey, filepath, @security, options, timeout, storage, intelligent: intelligent)
+  def upload(filepath: nil, external_url: nil, io: nil, options: {}, intelligent: false, timeout: 60, storage: 'S3')
+    return 'You cannot upload a URL and file at the same time' if (filepath || io) && external_url
+
+    response = if external_url
+                send_upload(@apikey, external_url, @security, options)
                else
-                 send_upload(
-                   @apikey,
-                   filepath: filepath,
-                   external_url: external_url,
-                   options: options,
-                   security: @security,
-                   storage: storage
-                 )
+                return 'You cannot upload IO object and file at the same time' if io && filepath
+                multipart_upload(@apikey, filepath, io, @security, options, timeout, storage, intelligent)
                end
+
     FilestackFilelink.new(response['handle'], security: @security, apikey: @apikey)
   end
   # Transform an external URL

data/lib/filestack/ruby/version.rb

@@ -1,5 +1,5 @@
 module Filestack
   module Ruby
-    VERSION = '2.6.5'.freeze
+    VERSION = '2.8.1'.freeze
   end
 end

data/lib/filestack/utils/multipart_upload_utils.rb

@@ -13,24 +13,23 @@ include UploadUtils
 include IntelligentUtils
 # Includes all the utility functions for Filestack multipart uploads
 module MultipartUploadUtils
-  def get_file_info(file)
-    filename = File.basename(file)
+
+  def get_file_attributes(file, options = {})
+    filename = options[:filename] || File.basename(file)
+    mimetype = options[:mimetype] || MimeMagic.by_magic(File.open(file)) || FilestackConfig::DEFAULT_UPLOAD_MIMETYPE
     filesize = File.size(file)
-    mimetype = MimeMagic.by_magic(File.open(file))
-    if mimetype.nil?
-      mimetype = 'application/octet-stream'
-    end
+
     [filename, filesize, mimetype.to_s]
   end
 
-  def multipart_options(options)
-    [:region, :container, :path, :access].each do |key|
-      if options.has_key?(key)
-        options[:"store_#{key}"] = options[key]
-        options.delete(key)
-      end
-    end
-    return options
+  def get_io_attributes(io, options = {})
+    filename = options[:filename] || 'unnamed_file'
+    mimetype = options[:mimetype] || FilestackConfig::DEFAULT_UPLOAD_MIMETYPE
+
+    io.seek(0, IO::SEEK_END)
+    filesize = io.tell
+
+    [filename, filesize, mimetype.to_s]
   end
 
   # Send start response to multipart endpoint
@@ -41,8 +40,10 @@ module MultipartUploadUtils
   # @param [String]             mimetype      Mimetype of incoming file
   # @param [FilestackSecurity]  security      Security object with
   #                                           policy/signature
+  # @param [String]             storage        Default storage to be used for uploads
   # @param [Hash]               options       User-defined options for
   #                                           multipart uploads
+  # @param [Bool]               intelligent   Upload file using Filestack Intelligent Ingestion
   #
   # @return [Typhoeus::Response]
   def multipart_start(apikey, filename, filesize, mimetype, security, storage, options = {}, intelligent)
@@ -51,23 +52,21 @@ module MultipartUploadUtils
       filename: filename,
       mimetype: mimetype,
       size: filesize,
-      store_location: storage,
-      file: Tempfile.new(filename),
-      multipart: intelligent
+      store: { location: storage },
+      fii: intelligent
     }
 
-    options = multipart_options(options)
-    params = params.merge!(options) if options
+    params[:store].merge!(options) if options
 
     unless security.nil?
       params[:policy] = security.policy
       params[:signature] = security.signature
     end
 
-    response = Typhoeus.post(
-      FilestackConfig::MULTIPART_START_URL, body: params,
-                                            headers: FilestackConfig::HEADERS
-    )
+    response = Typhoeus.post(FilestackConfig.multipart_start_url,
+                             body: params.to_json,
+                             headers: FilestackConfig::HEADERS)
+
     if response.code == 200
       JSON.parse(response.body)
     else
@@ -79,22 +78,21 @@ module MultipartUploadUtils
   #
   # @param [String]             apikey         Filestack API key
   # @param [String]             filename       Name of incoming file
-  # @param [String]             filepath       Local path to file
   # @param [Int]                filesize       Size of incoming file
   # @param [Typhoeus::Response]  start_response Response body from
   #                                            multipart_start
+  # @param [String]             storage        Default storage to be used for uploads
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
   #
   # @return [Array]
-  def create_upload_jobs(apikey, filename, filepath, filesize, start_response, storage, options)
+  def create_upload_jobs(apikey, filename, filesize, start_response, storage, options)
     jobs = []
     part = 1
     seek_point = 0
     while seek_point < filesize
       part_info = {
-        seek: seek_point,
-        filepath: filepath,
+        seek_point: seek_point,
         filename: filename,
         apikey: apikey,
         part: part,
@@ -104,10 +102,10 @@ module MultipartUploadUtils
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
         start_response: start_response,
-        store_location: storage
+        store: { location: storage },
       }
-      options = multipart_options(options)
-      part_info = part_info.merge!(options) if options
+
+      part_info[:store].merge!(options) if options
 
       if seek_point + FilestackConfig::DEFAULT_CHUNK_SIZE > filesize
         size = filesize - (seek_point)
@@ -128,16 +126,17 @@ module MultipartUploadUtils
   # @param [Hash]               job            Hash of options needed
   #                                            to upload a chunk
   # @param [String]             apikey         Filestack API key
-  # @param [String]             location_url   Location url given back
+  # @param [String]             filepath       Location url given back
   #                                            from endpoint
-  # @param [String]             filepath       Local path to file
+  # @param [StringIO]           io             The IO object
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk(job, apikey, filepath, options)
-    file = File.open(filepath)
-    file.seek(job[:seek])
+  def upload_chunk(job, apikey, filepath, io, options, storage)
+    file = filepath ? File.open(filepath) : io
+    file.seek(job[:seek_point])
     chunk = file.read(FilestackConfig::DEFAULT_CHUNK_SIZE)
 
     md5 = Digest::MD5.new
@@ -150,14 +149,13 @@ module MultipartUploadUtils
       uri: job[:uri],
       region: job[:region],
       upload_id: job[:upload_id],
-      store_location: job[:store_location],
-      file: Tempfile.new(job[:filename])
+      store: { location: storage },
     }
     data = data.merge!(options) if options
-    fs_response = Typhoeus.post(
-      FilestackConfig::MULTIPART_UPLOAD_URL, body: data,
-                                             headers: FilestackConfig::HEADERS
-    ).body
+
+    fs_response = Typhoeus.post(FilestackConfig.multipart_upload_url(job[:location_url]),
+                                body: data.to_json,
+                                headers: FilestackConfig::HEADERS).body
     fs_response = JSON.parse(fs_response)
     Typhoeus.put(
       fs_response['url'], headers: fs_response['headers'], body: chunk
@@ -170,19 +168,20 @@ module MultipartUploadUtils
   # @param [String]             filepath       Local path to file
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
   #
   # @return [Array]                            Array of parts/etags strings
-  def run_uploads(jobs, apikey, filepath, options)
+  def run_uploads(jobs, apikey, filepath, io, options, storage)
     bar = ProgressBar.new(jobs.length)
     results = Parallel.map(jobs, in_threads: 4) do |job|
       response = upload_chunk(
-        job, apikey, filepath, options
+        job, apikey, filepath, io, options, storage
       )
       if response.code == 200
         bar.increment!
         part = job[:part]
         etag = response.headers[:etag]
-        "#{part}:#{etag}"
+        { part_number: part, etag: etag }
       end
     end
     results
@@ -202,6 +201,8 @@ module MultipartUploadUtils
   #                                             part numbers
   # @param [Hash]               options         User-defined options for
   #                                             multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
+  # @param [Boolean]            intelligent     Upload file using Filestack Intelligent Ingestion
   #
   # @return [Typhoeus::Response]
   def multipart_complete(apikey, filename, filesize, mimetype, start_response, parts_and_etags, options, storage, intelligent = false)
@@ -213,52 +214,53 @@ module MultipartUploadUtils
       filename: filename,
       size: filesize,
       mimetype: mimetype,
-      store_location: storage,
-      file: Tempfile.new(filename)
+      store: { location: storage },
     }
-    options = multipart_options(options)
-    data.merge!(options) if options
-    data.merge!(intelligent ? { multipart: intelligent } : { parts: parts_and_etags.join(';') })
+    data[:store].merge!(options) if options
+    data.merge!(intelligent ? { fii: intelligent } : { parts: parts_and_etags })
 
-    Typhoeus.post(
-      FilestackConfig::MULTIPART_COMPLETE_URL, body: data,
-                                               headers: FilestackConfig::HEADERS
-    )
+    Typhoeus.post(FilestackConfig.multipart_complete_url(start_response['location_url']),
+                  body: data.to_json,
+                  headers: FilestackConfig::HEADERS)
   end
 
   # Run entire multipart process through with file and options
   #
   # @param [String]             apikey          Filestack API key
   # @param [String]             filename        Name of incoming file
+  # @param [StringIO]           io              The IO object
   # @param [FilestackSecurity]  security        Security object with
   #                                             policy/signature
   # @param [Hash]               options         User-defined options for
   #                                             multipart uploads
+  # @param [String]             storage         Default storage to be used for uploads
+  # @param [Boolean]            intelligent     Upload file using Filestack Intelligent Ingestion
   #
   # @return [Hash]
-  def multipart_upload(apikey, filepath, security, options, timeout, storage, intelligent: false)
-    filename, filesize, mimetype = get_file_info(filepath)
+  def multipart_upload(apikey, filepath, io, security, options, timeout, storage, intelligent = false)
+    filename, filesize, mimetype = if filepath
+                                    get_file_attributes(filepath, options)
+                                   else
+                                    get_io_attributes(io, options)
+                                   end
+
     start_response = multipart_start(
       apikey, filename, filesize, mimetype, security, storage, options, intelligent
     )
 
-    unless start_response['upload_type'].nil?
-      intelligent_enabled = ((start_response['upload_type'].include? 'intelligent_ingestion')) && intelligent
-    end
-
     jobs = create_upload_jobs(
-      apikey, filename, filepath, filesize, start_response, storage, options
+      apikey, filename, filesize, start_response, storage, options
     )
 
-    if intelligent_enabled
+    if intelligent
       state = IntelligentState.new
-      run_intelligent_upload_flow(jobs, state)
+      run_intelligent_upload_flow(jobs, filepath, io, state, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, nil, options, storage, intelligent
       )
     else
-      parts_and_etags = run_uploads(jobs, apikey, filepath, options)
+      parts_and_etags = run_uploads(jobs, apikey, filepath, io, options, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, parts_and_etags, options, storage

data/lib/filestack/utils/utils.rb

@@ -62,41 +62,51 @@ module UploadUtils
     )
   end
 
+  def build_store_task(options = {})
+    return 'store' if options.nil? || options.empty?
+    tasks = []
+    options.each do |key, value|
+      value = case key
+              when :workflows
+                [value.join('","')]
+              when :path
+                "\"#{value}\""
+              else
+                value
+              end
+      tasks.push("#{key}:#{value.to_s.downcase}")
+    end
+    "store=#{tasks.join(',')}"
+  end
+
   # Uploads to v1 REST API (for external URLs or if multipart is turned off)
   #
   # @param [String]             apikey         Filestack API key
-  # @param [String]             filepath       Local path to file
   # @param [String]             external_url   External URL to be uploaded
   # @param [FilestackSecurity]  security       Security object with
   #                                            policy/signature
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
-  # @param [String]             storage        Storage destination
-  #                                            (s3, rackspace, etc)
   # @return [Hash]
-  def send_upload(apikey, filepath: nil, external_url: nil, security: nil, options: nil, storage: 'S3')
-    data = if filepath
-             { fileUpload: File.open(filepath) }
-           else
-             { url: external_url }
-           end
-
-    # adds any user-defined upload options to request payload
-    data = data.merge!(options) unless options.nil?
-    base = "#{FilestackConfig::API_URL}/store/#{storage}?key=#{apikey}"
+  def send_upload(apikey, external_url = nil, security = nil, options = nil)
+    base = "#{FilestackConfig::CDN_URL}/#{apikey}/#{build_store_task(options)}"
 
     if security
       policy = security.policy
       signature = security.signature
-      base = "#{base}&signature=#{signature}&policy=#{policy}"
+      base = "#{base}/security=s:#{signature},p:#{policy}"
     end
 
-    response = Typhoeus.post(base, body: data, headers: FilestackConfig::HEADERS)
+    response = Typhoeus.post("#{base}/#{external_url}", headers: FilestackConfig::HEADERS)
 
     if response.code == 200
-      response_body = JSON.parse(response.body)
-      handle = response_body['url'].split('/').last
-      return { 'handle' => handle }
+      begin
+        response_body = JSON.parse(response.body)
+        handle = response_body['url'].split('/').last
+        return { 'handle' => handle }
+      rescue
+        raise response.body
+      end
     end
     raise response.body
   end
@@ -193,7 +203,7 @@ module IntelligentUtils
   # @param [IntelligentState]    state     An IntelligentState object
   #
   # @return [Array]
-  def run_intelligent_upload_flow(jobs, state)
+  def run_intelligent_upload_flow(jobs, filepath, io, state, storage)
     bar = ProgressBar.new(jobs.length)
     generator = create_intelligent_generator(jobs)
     working_offset = FilestackConfig::DEFAULT_OFFSET_SIZE
@@ -201,7 +211,7 @@ module IntelligentUtils
       batch = get_generator_batch(generator)
       # run parts
       Parallel.map(batch, in_threads: 4) do |part|
-        state = run_intelligent_uploads(part, state)
+        state = run_intelligent_uploads(part, filepath, io, state, storage)
         # condition: a chunk has failed but we have not reached the maximum retries
         while bad_state(state)
           # condition: timeout to S3, requiring offset size to be changed
@@ -213,7 +223,7 @@ module IntelligentUtils
             sleep(state.backoff)
           end
           state.add_retry
-          state = run_intelligent_uploads(part, state)
+          state = run_intelligent_uploads(part, filepath, io, state, storage)
         end
         raise "Upload has failed. Please try again later." unless state.ok
         bar.increment!
@@ -269,14 +279,14 @@ module IntelligentUtils
   #                                             multipart_start
   #
   # @return [Dict]
-  def chunk_job(job, state, apikey, filename, filepath, filesize, start_response)
+  def chunk_job(job, state, apikey, filename, filesize, start_response, storage)
     offset = 0
-    seek_point = job[:seek]
+    seek_point = job[:seek_point]
     chunk_list = []
+
     while (offset < FilestackConfig::DEFAULT_CHUNK_SIZE) && (seek_point + offset) < filesize
       chunk_list.push(
-        seek: seek_point,
-        filepath: filepath,
+        seek_point: seek_point,
         filename: filename,
         apikey: apikey,
         part: job[:part],
@@ -285,7 +295,7 @@ module IntelligentUtils
         region: start_response['region'],
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
-        store_location: job[:store_location],
+        store: { location: storage },
         offset: offset
       )
       offset += state.offset
@@ -300,15 +310,14 @@ module IntelligentUtils
   # @param [IntelligentState]  state     An IntelligentState object
   #
   # @return [IntelligentState]
-  def run_intelligent_uploads(part, state)
+  def run_intelligent_uploads(part, filepath, io, state, storage)
     failed = false
     chunks = chunk_job(
-      part, state, part[:apikey], part[:filename], part[:filepath],
-      part[:filesize], part[:start_response]
+      part, state, part[:apikey], part[:filename], part[:filesize], part[:start_response], storage
     )
     Parallel.map(chunks, in_threads: 3) do |chunk|
       begin
-        upload_chunk_intelligently(chunk, state, part[:apikey], part[:filepath], part[:options])
+        upload_chunk_intelligently(chunk, state, part[:apikey], filepath, io, part[:options], storage)
       rescue => e
         state.error_type = e.message
         failed = true
@@ -322,6 +331,7 @@ module IntelligentUtils
     else
       state.ok = true
     end
+
     commit_params = {
       apikey: part[:apikey],
       uri: part[:uri],
@@ -329,12 +339,14 @@ module IntelligentUtils
       upload_id: part[:upload_id],
       size: part[:filesize],
       part: part[:part],
-      location_url: part[:location_url],
-      store_location: part[:store_location],
-      file: Tempfile.new(part[:filename])
+      location_url: part[:start_response]['location_url'],
+      store: { location: storage }
     }
-    response = Typhoeus.post(FilestackConfig::MULTIPART_COMMIT_URL, body: commit_params,
-                                                                   headers: FilestackConfig::HEADERS)
+
+    response = Typhoeus.post(FilestackConfig.multipart_commit_url(commit_params[:location_url]),
+                             body: commit_params.to_json,
+                             headers: FilestackConfig::HEADERS)
+
     if response.code == 200
       state.reset
     else
@@ -354,9 +366,10 @@ module IntelligentUtils
   #                                             multipart uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk_intelligently(job, state, apikey, filepath, options)
-    file = File.open(filepath)
-    file.seek(job[:seek] + job[:offset])
+  def upload_chunk_intelligently(job, state, apikey, filepath, io, options, storage)
+    file = filepath ? File.open(filepath) : io
+    file.seek(job[:seek_point] + job[:offset])
+
     chunk = file.read(state.offset)
     md5 = Digest::MD5.new
     md5 << chunk
@@ -368,17 +381,17 @@ module IntelligentUtils
       uri: job[:uri],
       region: job[:region],
       upload_id: job[:upload_id],
-      store_location: job[:store_location],
+      store: { location: storage },
       offset: job[:offset],
-      file: Tempfile.new(job[:filename]),
-      'multipart' => 'true'
+      fii: true
     }
 
     data = data.merge!(options) if options
-    fs_response = Typhoeus.post(
-      FilestackConfig::MULTIPART_UPLOAD_URL, body: data,
-                                             headers: FilestackConfig::HEADERS
-    )
+
+    fs_response = Typhoeus.post(FilestackConfig.multipart_upload_url(job[:location_url]),
+                                body: data.to_json,
+                                headers: FilestackConfig::HEADERS)
+
     # POST to multipart/upload
     begin
       unless fs_response.code == 200

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filestack
 version: !ruby/object:Gem::Version
-  version: 2.6.5
+  version: 2.8.1
 platform: ruby
 authors:
 - Filestack
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-01-09 00:00:00.000000000 Z
+date: 2020-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -201,7 +201,7 @@ homepage: https://github.com/filestack/filestack-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -216,9 +216,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Official Ruby SDK for the Filestack API
 test_files: []