Add support for download_backedup_asset helper method

Author: RTLcoil

lib/cloudinary/api.rb

@@ -82,15 +82,16 @@ def self.resource(public_id, options={})
                   :phash,
                   :quality_analysis,
                   :derived_next_cursor,
-                  :accessibility_analysis
+                  :accessibility_analysis,
+                  :versions
              ), options)
   end
 
   def self.restore(public_ids, options={})
     resource_type = options[:resource_type] || "image"
     type          = options[:type] || "upload"
     uri           = "resources/#{resource_type}/#{type}/restore"
-    call_api(:post, uri, { :public_ids => public_ids }, options)
+    call_api(:post, uri, { :public_ids => public_ids, :versions => options[:versions] }, options)
   end
 
   def self.update(public_id, options={})

lib/cloudinary/utils.rb

@@ -159,6 +159,8 @@ class Cloudinary::Utils
   LONG_URL_SIGNATURE_LENGTH = 32
   SHORT_URL_SIGNATURE_LENGTH = 8
 
+  UPLOAD_PREFIX = 'https://api.cloudinary.com'
+
   ALGO_SHA1 = :sha1
   ALGO_SHA256 = :sha256
 
@@ -688,11 +690,23 @@ def self.unsigned_download_url_prefix(source, cloud_name, private_cdn, cdn_subdo
     prefix
   end
 
+  # Creates a base URL for the cloudinary api
+  #
+  # @param [Object] path  Resource name
+  # @param [Hash] options Additional options
+  #
+  # @return [String]
+  def self.base_api_url(path, options = {})
+    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || UPLOAD_PREFIX
+    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, 'Must supply cloud_name')
+
+    [cloudinary, 'v1_1', cloud_name, path].join('/')
+  end
+
   def self.cloudinary_api_url(action = 'upload', options = {})
-    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
-    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise(CloudinaryException, "Must supply cloud_name")
-    resource_type = options[:resource_type] || "image"
-    return [cloudinary, "v1_1", cloud_name, resource_type, action].join("/")
+    resource_type = options[:resource_type] || 'image'
+
+    base_api_url([resource_type, action], options)
   end
 
   def self.sign_request(params, options={})
@@ -1177,6 +1191,25 @@ def self.is_remote?(url)
     REMOTE_URL_REGEX === url
   end
 
+  # The returned url should allow downloading the backedup asset based on the version and asset id
+  #
+  # asset and version id are returned with resource(<PUBLIC_ID1>, { versions: true })
+  #
+  # @param [String] asset_id   Asset identifier
+  # @param [String] version_id Specific version of asset to download
+  # @param [Hash] options      Additional options
+  #
+  # @return [String] An url for downloading a file
+  def self.download_backedup_asset(asset_id, version_id, options = {})
+    params = Cloudinary::Utils.sign_request({
+      :timestamp => (options[:timestamp] || Time.now.to_i),
+      :asset_id => asset_id,
+      :version_id => version_id
+    }, options)
+
+    "#{Cloudinary::Utils.base_api_url("download_backup", options)}?#{Cloudinary::Utils.hash_query_params((params))}"
+  end
+
   # Format date in a format accepted by the usage API (e.g., 31-12-2020) if
   # passed value is of type Date, otherwise return the string representation of
   # the input.

spec/api_spec.rb

@@ -4,9 +4,14 @@
 describe Cloudinary::Api do
   break puts("Please setup environment for api test to run") if Cloudinary.config.api_secret.blank?
   include_context "cleanup", TIMESTAMP_TAG
+
+  prefix = "api_test_#{SUFFIX}"
+
   TEST_WIDTH = rand(1000)
   TEST_TRANSFOMATION = "c_scale,w_#{TEST_WIDTH}"
-  prefix = "api_test_#{SUFFIX}"
+  PUBLIC_ID_BACKUP_1 = "#{prefix}backup_1#{Time.now.to_i}"
+  PUBLIC_ID_BACKUP_2 = "#{prefix}backup_2#{Time.now.to_i}"
+
   test_id_1 = "#{prefix}_1"
   test_id_2   = "#{prefix}_2"
   test_id_3   = "#{prefix}_3"
@@ -230,6 +235,28 @@
     expect(tags).to be_blank
   end
 
+  describe "backup resource" do
+    let(:public_id) { "api_test_backup_#{SUFFIX}" }
+
+    before(:each) do
+      Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG], :public_id => public_id, :backup => true)
+      response = @api.resource(public_id)
+      expect(response).not_to be_nil
+    end
+
+    it "should return the asset details together with all of its backed up versions when versions is true" do
+      resource = @api.resource(public_id, :versions => true)
+
+      expect(resource["versions"]).to be_an_instance_of(Array)
+    end
+
+    it "should return the asset details together without backed up versions when versions is false" do
+      resource = @api.resource(public_id, :versions => false)
+
+      expect(resource["versions"]).to be_nil
+    end
+  end
+
   describe 'transformations' do
     it "should allow listing transformations" do
       transformations = @api.transformations()["transformations"]
@@ -507,9 +534,117 @@
   end
 
   describe '.restore'  do
+    let(:public_id) { "api_test_restore#{SUFFIX}" }
+
+    before(:each) do
+      Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG], :public_id => public_id, :backup => true)
+      sleep(2)
+
+      resource = @api.resource(public_id)
+      expect(resource).not_to be_nil
+      expect(resource["bytes"]).to eq(3381)
+
+      @api.delete_resources(public_id)
+
+      resource = @api.resource(public_id)
+      expect(resource).not_to be_nil
+      expect(resource["bytes"]).to eq(0)
+      expect(resource["placeholder"]).to eq(true)
+    end
+
     it 'should restore a deleted resource' do
-      expect(RestClient::Request).to receive(:execute).with(deep_hash_value( [:payload, :public_ids] => "api_test_restore", [:url] => /.*\/restore$/))
-      Cloudinary::Api.restore("api_test_restore")
+      response = @api.restore([public_id])
+
+      info = response[public_id]
+      expect(info).not_to be_nil
+      expect(info["bytes"]).to eq(3381)
+
+      resource = @api.resource(public_id)
+      expect(resource).not_to be_nil
+      expect(resource["bytes"]).to eq(3381)
+    end
+
+    it "should restore different versions of a deleted asset" do
+      # Upload the same file twice (upload->delete->upload->delete)
+
+      # Upload and delete a file
+      first_upload = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG], :public_id => PUBLIC_ID_BACKUP_1, :backup => true)
+      sleep(1)
+
+      first_delete = @api.delete_resources([PUBLIC_ID_BACKUP_1])
+
+      # Upload and delete it again, this time add angle to create a different 'version'
+      second_upload = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG], :public_id => PUBLIC_ID_BACKUP_1, :transformation => { :angle => 0 }, :backup => true)
+      sleep(1)
+
+      second_delete = @api.delete_resources([PUBLIC_ID_BACKUP_1])
+      sleep(1)
+
+      # Ensure all files were uploaded correctly
+      expect(first_upload).not_to be_nil
+      expect(second_upload).not_to be_nil
+
+      # Sanity, ensure these uploads are different before we continue
+      expect(first_upload["bytes"]).not_to equal(second_upload["bytes"])
+
+      # Ensure all files were deleted correctly
+      expect(first_delete).to have_key("deleted")
+      expect(second_delete).to have_key("deleted")
+
+      # Get the versions of the deleted asset
+      get_versions_resp = @api.resource(PUBLIC_ID_BACKUP_1, :versions => true)
+
+      first_asset_version = get_versions_resp["versions"][0]["version_id"]
+      second_asset_version = get_versions_resp["versions"][1]["version_id"]
+
+      # Restore first version, ensure it's equal to the upload size
+      sleep(1)
+      first_ver_restore = @api.restore([PUBLIC_ID_BACKUP_1], :versions => [first_asset_version])
+      expect(first_ver_restore[PUBLIC_ID_BACKUP_1]["bytes"]).to eq(first_upload["bytes"])
+
+      # Restore second version, ensure it's equal to the upload size
+      sleep(1)
+      second_ver_restore = @api.restore([PUBLIC_ID_BACKUP_1], { :versions => [second_asset_version] })
+      expect(second_ver_restore[PUBLIC_ID_BACKUP_1]["bytes"]).to eq(second_upload["bytes"])
+
+      # Cleanup
+      final_delete_resp = @api.delete_resources([PUBLIC_ID_BACKUP_1])
+      expect(final_delete_resp).to have_key("deleted")
+    end
+
+    it "should restore two different deleted assets" do
+      # Upload two different files
+      first_upload = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG], :public_id => PUBLIC_ID_BACKUP_1, :backup => true)
+      second_upload = Cloudinary::Uploader.upload(TEST_IMG, :tags => [TEST_TAG, TIMESTAMP_TAG], :public_id => PUBLIC_ID_BACKUP_2, :transformation => { :angle => 0 }, :backup => true)
+
+      # delete both resources
+      delete_all = @api.delete_resources([PUBLIC_ID_BACKUP_1, PUBLIC_ID_BACKUP_2])
+
+      # Expect correct deletion of the assets
+      expect(delete_all["deleted"][PUBLIC_ID_BACKUP_1]).to eq("deleted")
+      expect(delete_all["deleted"][PUBLIC_ID_BACKUP_2]).to eq("deleted")
+
+      get_first_asset_version = @api.resource(PUBLIC_ID_BACKUP_1, :versions => true)
+      get_second_asset_version = @api.resource(PUBLIC_ID_BACKUP_2, :versions => true)
+
+      first_asset_version = get_first_asset_version["versions"][0]["version_id"]
+      second_asset_version = get_second_asset_version["versions"][0]["version_id"]
+
+      ids_to_restore = [PUBLIC_ID_BACKUP_1, PUBLIC_ID_BACKUP_2]
+      versions_to_restore = [first_asset_version, second_asset_version]
+
+      restore = @api.restore(ids_to_restore, :versions => versions_to_restore)
+
+      # Expect correct restorations
+      expect(restore[PUBLIC_ID_BACKUP_1]["bytes"]).to eq(first_upload["bytes"])
+      expect(restore[PUBLIC_ID_BACKUP_2]["bytes"]).to eq(second_upload["bytes"])
+
+      # Cleanup
+      final_delete = @api.delete_resources([PUBLIC_ID_BACKUP_1, PUBLIC_ID_BACKUP_2])
+
+      # Expect correct deletion of the assets
+      expect(final_delete["deleted"][PUBLIC_ID_BACKUP_1]).to eq("deleted")
+      expect(final_delete["deleted"][PUBLIC_ID_BACKUP_2]).to eq("deleted")
     end
   end
 

spec/archive_spec.rb

@@ -61,6 +61,15 @@
       end
     end
   end
+
+  describe "download_backedup_asset" do
+    it "should return url with asset and version id" do
+      download_backedup_asset_url = Cloudinary::Utils.download_backedup_asset("b71b23d9c89a81a254b88a91a9dad8cd", "0e493356d8a40b856c4863c026891a4e")
+
+      expect(download_backedup_asset_url).to include("asset_id")
+      expect(download_backedup_asset_url).to include("version_id")
+    end
+  end
 end
 
 describe Cloudinary::Uploader do