cloudinary 1.9.1 → 1.20.0

data/lib/cloudinary/account_api.rb

@@ -0,0 +1,231 @@
+class Cloudinary::AccountApi
+  extend Cloudinary::BaseApi
+
+  # Creates a new sub-account. Any users that have access to all sub-accounts will also automatically have access to the
+  # new sub-account.
+  # @param [String] name The display name as shown in the management console
+  # @param [String] cloud_name A case-insensitive cloud name comprised of alphanumeric and underscore characters.
+  #   Generates an error if the specified cloud name is not unique across all Cloudinary accounts.
+  #   Note: Once created, the name can only be changed for accounts with fewer than 1000 assets.
+  # @param [Object] custom_attributes Any custom attributes you want to associate with the sub-account
+  # @param [Boolean] enabled Whether to create the account as enabled (default is enabled)
+  # @param [String] base_account ID of sub-account from which to copy settings
+  # @param [Object] options additional options
+  def self.create_sub_account(name, cloud_name = nil, custom_attributes = {}, enabled = nil, base_account = nil, options = {})
+    params = {
+      name: name,
+      cloud_name: cloud_name,
+      custom_attributes: custom_attributes,
+      enabled: enabled,
+      base_sub_account_id: base_account
+    }
+
+    call_account_api(:post, 'sub_accounts', params, options.merge(content_type: :json))
+  end
+
+  # Updates the specified details of the sub-account.
+  # @param [String] sub_account_id The ID of the sub-account.
+  # @param [String] name The display name as shown in the management console
+  # @param [String] cloud_name A case-insensitive cloud name comprised of alphanumeric and underscore characters.
+  #   Generates an error if the specified cloud name is not unique across all Cloudinary accounts.
+  #   Note: Once created, the name can only be changed for accounts with fewer than 1000 assets.
+  # @param [Object] custom_attributes Any custom attributes you want to associate with the sub-account, as a map/hash
+  #   of key/value pairs.
+  # @param [Boolean] enabled Whether the sub-account is enabled.
+  # @param [Object] options additional options
+  def self.update_sub_account(sub_account_id, name = nil, cloud_name = nil, custom_attributes = nil, enabled = nil, options = {})
+    params = {
+      name: name,
+      cloud_name: cloud_name,
+      custom_attributes: custom_attributes,
+      enabled: enabled
+    }
+
+    call_account_api(:put, ['sub_accounts', sub_account_id], params, options.merge(content_type: :json))
+  end
+
+  # Lists sub-accounts.
+  # @param [Boolean] enabled Whether to only return enabled sub-accounts (true) or disabled accounts (false).
+  #  Default: all accounts are returned (both enabled and disabled).
+  # @param [Array<String>] ids A list of up to 100 sub-account IDs. When provided, other parameters are ignored.
+  # @param [String] prefix Returns accounts where the name begins with the specified case-insensitive string.
+  # @param [Object] options additional options
+  def self.sub_accounts(enabled = nil, ids = [], prefix = nil, options = {})
+    params = {
+      enabled: enabled,
+      ids: ids,
+      prefix: prefix
+    }
+
+    call_account_api(:get, 'sub_accounts', params, options.merge(content_type: :json))
+  end
+
+  # Retrieves the details of the specified sub-account.
+  # @param [String] sub_account_id The ID of the sub-account.
+  # @param [Object] options additional options
+  def self.sub_account(sub_account_id, options = {})
+    call_account_api(:get, ['sub_accounts', sub_account_id], {}, options.merge(content_type: :json))
+  end
+
+  # Deletes the specified sub-account. Supported only for accounts with fewer than 1000 assets.
+  # @param [String] sub_account_id The ID of the sub-account.
+  # @param [Object] options additional options
+  def self.delete_sub_account(sub_account_id, options = {})
+    call_account_api(:delete, ['sub_accounts', sub_account_id], {}, options)
+  end
+
+  # Creates a new user in the account.
+  # @param [String] name The name of the user.
+  # @param [String] email A unique email address, which serves as the login name and notification address.
+  # @param [String] role The role to assign. Possible values: master_admin, admin, billing, technical_admin, reports,
+  #   media_library_admin, media_library_user
+  # @param [Array<String>] sub_account_ids The list of sub-account IDs that this user can access.
+  #   Note: This parameter is ignored if the role is specified as master_admin.
+  # @param [Object] options additional options
+  def self.create_user(name, email, role, sub_account_ids = [], options = {})
+    params = {
+      name: name,
+      email: email,
+      role: role,
+      sub_account_ids: sub_account_ids
+    }
+
+    call_account_api(:post, 'users', params, options.merge(content_type: :json))
+  end
+
+  # Deletes an existing user.
+  # @param [String] user_id The ID of the user to delete.
+  # @param [Object] options additional options
+  def self.delete_user(user_id, options = {})
+    call_account_api(:delete, ['users', user_id], {}, options)
+  end
+
+  # Updates the details of the specified user.
+  # @param [String] user_id The ID of the user to update.
+  # @param [String] name The name of the user.
+  # @param [String] email A unique email address, which serves as the login name and notification address.
+  # @param [String] role The role to assign. Possible values: master_admin, admin, billing, technical_admin, reports,
+  #   media_library_admin, media_library_user
+  # @param [Array<String>] sub_account_ids The list of sub-account IDs that this user can access.
+  #   Note: This parameter is ignored if the role is specified as master_admin.
+  # @param [Object] options additional options
+  def self.update_user(user_id, name = nil, email = nil, role = nil, sub_account_ids = nil, options = {})
+    params = {
+      name: name,
+      email: email,
+      role: role,
+      sub_account_ids: sub_account_ids
+    }
+
+    call_account_api(:put, ['users', user_id], params, options.merge(content_type: :json))
+  end
+
+  # Returns the user with the specified ID.
+  # @param [String] user_id The ID of the user.
+  # @param [Object] options additional options
+  def self.user(user_id, options = {})
+    call_account_api(:get, ['users', user_id], {}, options.merge(content_type: :json))
+  end
+
+  # Lists users in the account.
+  # @param [Boolean] pending Whether to only return pending users. Default: all users
+  # @param [Array<String>] user_ids A list of up to 100 user IDs. When provided, other parameters are ignored.
+  # @param [String] prefix Returns users where the name or email address begins with the specified case-insensitive string.
+  # @param [String] sub_account_id Only returns users who have access to the specified account.
+  # @param [Object] options additional options
+  def self.users(pending = nil, user_ids = [], prefix = nil, sub_account_id = nil, options = {})
+    params = if user_ids && user_ids.count > 0
+               {
+                 ids: user_ids
+               }
+             else
+               {
+                 prefix: prefix,
+                 sub_account_id: sub_account_id,
+                 pending: pending
+               }
+             end
+
+    call_account_api(:get, 'users', params, options.merge(content_type: :json))
+  end
+
+  # Creates a new user group.
+  # @param [String] name The name for the user group.
+  # @param [Object] options additional options
+  def self.create_user_group(name, options = {})
+    params = {
+      name: name
+    }
+
+    call_account_api(:post, 'user_groups', params, options.merge(content_type: :json))
+  end
+
+  # Updates the specified user group.
+  # @param [String] group_id The ID of the user group to update.
+  # @param [String] name The name for the user group.
+  # @param [Object] options additional options
+  def self.update_user_group(group_id, name, options = {})
+    params = {
+      name: name
+    }
+
+    call_account_api(:put, ['user_groups', group_id], params, options.merge(content_type: :json))
+  end
+
+  # Adds a user to a group with the specified ID.
+  # @param [String] group_id The ID of the user group.
+  # @param [String] user_id The ID of the user.
+  # @param [Object] options additional options
+  def self.add_user_to_group(group_id, user_id, options = {})
+    call_account_api(:post, ['user_groups', group_id, 'users', user_id], {}, options.merge(content_type: :json))
+  end
+
+  # Removes a user from a group with the specified ID.
+  # @param [String] group_id The ID of the user group.
+  # @param [String] user_id The ID of the user.
+  # @param [Object] options additional options
+  def self.remove_user_from_group(group_id, user_id, options = {})
+    call_account_api(:delete, ['user_groups', group_id, 'users', user_id], {}, options.merge(content_type: :json))
+  end
+
+  # Deletes the user group with the specified ID.
+  # @param [String] group_id The ID of the user group to delete.
+  # @param [Object] options additional options
+  def self.delete_user_group(group_id, options = {})
+    call_account_api(:delete, ['user_groups', group_id], {}, options)
+  end
+
+  # Lists user groups in the account.
+  # @param [Object] options additional options
+  def self.user_groups(options = {})
+    call_account_api(:get, 'user_groups', {}, options.merge(content_type: :json))
+  end
+
+  # Retrieves the details of the specified user group.
+  # @param [String] group_id The ID of the user group to retrieve.
+  # @param [Object] options additional options
+  def self.user_group(group_id, options = {})
+    call_account_api(:get, ['user_groups', group_id], {}, options.merge(content_type: :json))
+  end
+
+  # Lists users in the specified user group.
+  # @param [String] group_id The ID of the user group.
+  # @param [Object] options additional options
+  def self.user_group_users(group_id, options = {})
+    call_account_api(:get, ['user_groups', group_id, 'users'], {}, options.merge(content_type: :json))
+  end
+
+  def self.call_account_api(method, uri, params, options)
+    account_id = options[:account_id] || Cloudinary.account_config.account_id || raise('Must supply account_id')
+    api_key    = options[:provisioning_api_key] || Cloudinary.account_config.provisioning_api_key || raise('Must supply provisioning api_key')
+    api_secret = options[:provisioning_api_secret] || Cloudinary.account_config.provisioning_api_secret || raise('Must supply provisioning api_secret')
+
+    params.reject! { |_, v| v.nil? }
+
+    call_cloudinary_api(method, uri, api_key, api_secret, params, options) do |cloudinary, inner_uri|
+      [cloudinary, 'v1_1', 'provisioning', 'accounts', account_id, inner_uri]
+    end
+  end
+
+  private_class_method :call_account_api
+end

data/lib/cloudinary/account_config.rb

@@ -0,0 +1,30 @@
+module Cloudinary
+  module AccountConfig
+    include BaseConfig
+
+    ENV_URL = "CLOUDINARY_ACCOUNT_URL"
+    SCHEME = "account"
+
+    def load_config_from_env
+      load_from_url(ENV[ENV_URL]) if ENV[ENV_URL]
+    end
+
+    private
+
+    def env_url
+      ENV_URL
+    end
+
+    def expected_scheme
+      SCHEME
+    end
+
+    def config_from_parsed_url(parsed_url)
+      {
+        "account_id"              => parsed_url.host,
+        "provisioning_api_key"    => parsed_url.user,
+        "provisioning_api_secret" => parsed_url.password
+      }
+    end
+  end
+end

data/lib/cloudinary/api.rb

@@ -1,37 +1,28 @@
-require 'rest_client'
-require 'json'
-
 class Cloudinary::Api
-  class Error < CloudinaryException; end
-  class NotFound < Error; end
-  class NotAllowed < Error; end
-  class AlreadyExists < Error; end
-  class RateLimited < Error; end
-  class BadRequest < Error; end
-  class GeneralError < Error; end
-  class AuthorizationRequired < Error; end
-
-  class Response < Hash
-    attr_reader :rate_limit_reset_at, :rate_limit_remaining, :rate_limit_allowed
-
-    def initialize(response=nil)
-      if response
-        # This sets the instantiated self as the response Hash
-        update Cloudinary::Api.parse_json_response response
-
-        @rate_limit_allowed   = response.headers[:x_featureratelimit_limit].to_i
-        @rate_limit_reset_at  = Time.parse(response.headers[:x_featureratelimit_reset])
-        @rate_limit_remaining = response.headers[:x_featureratelimit_remaining].to_i
-      end
-    end
-  end
+  extend Cloudinary::BaseApi
 
   def self.ping(options={})
     call_api(:get, "ping", {}, options)
   end
 
+  # Gets account usage details
+  #
+  # Get a report on the status of your Cloudinary account usage details, including
+  # storage, bandwidth, requests, number of resources, and add-on usage.
+  # Note that numbers are updated periodically.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#get_account_usage_details Get account usage details
+  #
+  # @param [Hash] options Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api:Error]
   def self.usage(options={})
-    call_api(:get, "usage", {}, options)
+    uri = 'usage'
+    date = options[:date]
+
+    uri += "/#{Cloudinary::Utils.to_usage_api_date_format(date)}" unless date.nil?
+
+    call_api(:get, uri, {}, options)
   end
 
   def self.resource_types(options={})
@@ -78,14 +69,29 @@ class Cloudinary::Api
     resource_type = options[:resource_type] || "image"
     type          = options[:type] || "upload"
     uri           = "resources/#{resource_type}/#{type}/#{public_id}"
-    call_api(:get, uri, only(options, :colors, :exif, :faces, :image_metadata, :pages, :phash, :coordinates, :max_results), options)
+    call_api(:get, uri,
+             only(options,
+                  :cinemagraph_analysis,
+                  :colors,
+                  :coordinates,
+                  :exif,
+                  :faces,
+                  :image_metadata,
+                  :max_results,
+                  :pages,
+                  :phash,
+                  :quality_analysis,
+                  :derived_next_cursor,
+                  :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={})
@@ -94,19 +100,20 @@ class Cloudinary::Api
     uri            = "resources/#{resource_type}/#{type}/#{public_id}"
     update_options = {
       :access_control     => Cloudinary::Utils.json_array_param(options[:access_control]),
-      :tags               => options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(","),
+      :auto_tagging       => options[:auto_tagging] && options[:auto_tagging].to_f,
+      :background_removal => options[:background_removal],
+      :categorization     => options[:categorization],
       :context            => Cloudinary::Utils.encode_context(options[:context]),
-      :face_coordinates   => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
       :custom_coordinates => Cloudinary::Utils.encode_double_array(options[:custom_coordinates]),
+      :detection          => options[:detection],
+      :face_coordinates   => Cloudinary::Utils.encode_double_array(options[:face_coordinates]),
       :moderation_status  => options[:moderation_status],
-      :raw_convert        => options[:raw_convert],
+      :notification_url   => options[:notification_url],
+      :quality_override   => options[:quality_override],
       :ocr                => options[:ocr],
-      :categorization     => options[:categorization],
-      :detection          => options[:detection],
+      :raw_convert        => options[:raw_convert],
       :similarity_search  => options[:similarity_search],
-      :background_removal => options[:background_removal],
-      :auto_tagging       => options[:auto_tagging] && options[:auto_tagging].to_f,
-      :notification_url   => options[:notification_url]
+      :tags               => options[:tags] && Cloudinary::Utils.build_array(options[:tags]).join(",")
     }
     call_api(:post, uri, update_options, options)
   end
@@ -214,11 +221,21 @@ class Cloudinary::Api
   end
 
   def self.root_folders(options={})
-    call_api(:get, "folders", {}, options)
+    params = only(options, :max_results, :next_cursor)
+    call_api(:get, "folders", params, options)
   end
 
   def self.subfolders(of_folder_path, options={})
-    call_api(:get, "folders/#{of_folder_path}", {}, options)
+    params = only(options, :max_results, :next_cursor)
+    call_api(:get, "folders/#{of_folder_path}", params, options)
+  end
+
+  def self.delete_folder(path, options={})
+    call_api(:delete, "folders/#{path}", {}, options)
+  end
+
+  def self.create_folder(folder_name, options={})
+    call_api(:post, "folders/#{folder_name}", {}, options)
   end
 
   def self.upload_mappings(options={})
@@ -311,40 +328,165 @@ class Cloudinary::Api
       update_resources_access_mode(access_mode, :public_ids, public_ids, options)
   end
 
+  def self.get_breakpoints(public_id, options)
+    local_options = options.clone
+    base_transformation = Cloudinary::Utils.generate_transformation_string(local_options)
+    srcset = local_options[:srcset]
+    breakpoints = [:min_width, :max_width, :bytes_step, :max_images].map {|k| srcset[k]}.join('_')
+
+
+    local_options[:transformation] = [base_transformation, width: "auto:breakpoints_#{breakpoints}:json"]
+    json_url = Cloudinary::Utils.cloudinary_url public_id, local_options
+    call_json_api('GET', json_url, {}, 60, {})
+  end
+
+  # Returns a list of all metadata field definitions.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#get_metadata_fields Get metadata fields API reference
+  #
+  # @param [Hash] options Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.list_metadata_fields(options = {})
+    call_metadata_api(:get, [], {}, options)
+  end
+
+  # Gets a metadata field by external id.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#get_a_metadata_field_by_external_id Get metadata field by external ID API reference
+  #
+  # @param [String] field_external_id The ID of the metadata field to retrieve
+  # @param [Hash]   options           Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.metadata_field_by_field_id(field_external_id, options = {})
+    uri = [field_external_id]
+
+    call_metadata_api(:get, uri, {}, options)
+  end
+
+  # Creates a new metadata field definition.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#create_a_metadata_field Create metadata field API reference
+  #
+  # @param [Hash] field   The field to add
+  # @param [Hash] options Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.add_metadata_field(field, options = {})
+    params = only(field, :type, :external_id, :label, :mandatory, :default_value, :validation, :datasource)
+
+    call_metadata_api(:post, [], params, options)
+  end
+
+  # Updates a metadata field by external id.
+  #
+  # Updates a metadata field definition (partially, no need to pass the entire object) passed as JSON data.
+  # See https://cloudinary.com/documentation/admin_api#generic_structure_of_a_metadata_field for the generic structure
+  # of a metadata field.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#update_a_metadata_field_by_external_id Update metadata field API reference
+  #
+  # @param [String] field_external_id The id of the metadata field to update
+  # @param [Hash]   field             The field definition
+  # @param [Hash]   options           Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.update_metadata_field(field_external_id, field, options = {})
+    uri = [field_external_id]
+    params = only(field, :label, :mandatory, :default_value, :validation)
+
+    call_metadata_api(:put, uri, params, options)
+  end
+
+  # Deletes a metadata field definition.
+  #
+  # The field should no longer be considered a valid candidate for all other endpoints.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#delete_a_metadata_field_by_external_id Delete metadata field API reference
+  #
+  # @param [String] field_external_id The external id of the field to delete
+  # @param [Hash]   options           Additional options
+  # @return [Cloudinary::Api::Response] A hash with a "message" key. "ok" value indicates a successful deletion
+  # @raise [Cloudinary::Api::Error]
+  def self.delete_metadata_field(field_external_id, options = {})
+    uri = [field_external_id]
+
+    call_metadata_api(:delete, uri, {}, options)
+  end
+
+  # Deletes entries in a metadata field datasource.
+  #
+  # Deletes (blocks) the datasource entries for a specified metadata field definition. Sets the state of the
+  # entries to inactive. This is a soft delete, the entries still exist under the hood and can be activated
+  # again with the restore datasource entries method.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#delete_entries_in_a_metadata_field_datasource Delete entries in a metadata field datasource API reference
+  #
+  # @param [String] field_external_id    The id of the field to update
+  # @param [Array]  entries_external_id  The ids of all the entries to delete from the datasource
+  # @param [Hash]   options              Additional options
+  # @return [Cloudinary::Api::Response] The remaining datasource entries
+  # @raise [Cloudinary::Api::Error]
+  def self.delete_datasource_entries(field_external_id, entries_external_id, options = {})
+    uri = [field_external_id, "datasource"]
+    params = {:external_ids => entries_external_id }
+
+    call_metadata_api(:delete, uri, params, options)
+  end
+
+  # Updates a metadata field datasource.
+  #
+  # Updates the datasource of a supported field type (currently only enum and set), passed as JSON data. The
+  # update is partial: datasource entries with an existing external_id will be updated and entries with new
+  # external_id’s (or without external_id’s) will be appended.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#update_a_metadata_field_datasource Update a metadata field datasource API reference
+  #
+  # @param [String] field_external_id   The external id of the field to update
+  # @param [Array]  entries_external_id
+  # @param [Hash]   options             Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.update_metadata_field_datasource(field_external_id, entries_external_id, options = {})
+    uri = [field_external_id, "datasource"]
+
+    params = entries_external_id.each_with_object({:values => [] }) do |item, hash|
+      item = only(item, :external_id, :value)
+      hash[:values ] << item if item.present?
+    end
+
+    call_metadata_api(:put, uri, params, options)
+  end
+
+  # Restores entries in a metadata field datasource.
+  #
+  # Restores (unblocks) any previously deleted datasource entries for a specified metadata field definition.
+  # Sets the state of the entries to active.
+  #
+  # @see https://cloudinary.com/documentation/admin_api#restore_entries_in_a_metadata_field_datasource Restore entries in a metadata field datasource API reference
+  #
+  # @param [String] field_external_id    The ID of the metadata field
+  # @param [Array]  entries_external_ids An array of IDs of datasource entries to restore (unblock)
+  # @param [Hash]   options              Additional options
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.restore_metadata_field_datasource(field_external_id, entries_external_ids, options = {})
+    uri = [field_external_id, "datasource_restore"]
+    params = {:external_ids => entries_external_ids }
+
+    call_metadata_api(:post, uri, params, options)
+  end
+
   protected
 
   def self.call_api(method, uri, params, options)
-    cloudinary = options[:upload_prefix] || Cloudinary.config.upload_prefix || "https://api.cloudinary.com"
-    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise("Must supply cloud_name")
-    api_key    = options[:api_key] || Cloudinary.config.api_key || raise("Must supply api_key")
-    api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise("Must supply api_secret")
-    timeout    = options[:timeout] || Cloudinary.config.timeout || 60
-    api_url    = [cloudinary, "v1_1", cloud_name, uri].join("/")
-    # Add authentication
-    api_url.sub!(%r(^(https?://)), "\\1#{api_key}:#{api_secret}@")
-
-    headers = { "User-Agent" => Cloudinary::USER_AGENT }
-    if options[:content_type]== :json
-      payload = params.to_json
-      headers.merge!("Content-Type"=> 'application/json', "Accept"=> 'application/json')
-    else
-      payload = params.reject { |k, v| v.nil? || v=="" }
-    end
-    RestClient::Request.execute(:method => method, :url => api_url, :payload => payload, :timeout => timeout, :headers => headers) do
-    |response, request, tmpresult|
-      return Response.new(response) if response.code == 200
-      exception_class = case response.code
-      when 400 then BadRequest
-      when 401 then AuthorizationRequired
-      when 403 then NotAllowed
-      when 404 then NotFound
-      when 409 then AlreadyExists
-      when 420 then RateLimited
-      when 500 then GeneralError
-      else raise GeneralError.new("Server returned unexpected status code - #{response.code} - #{response.body}")
-      end
-      json = parse_json_response(response)
-      raise exception_class.new(json["error"]["message"])
+    cloud_name = options[:cloud_name] || Cloudinary.config.cloud_name || raise('Must supply cloud_name')
+    api_key    = options[:api_key] || Cloudinary.config.api_key || raise('Must supply api_key')
+    api_secret = options[:api_secret] || Cloudinary.config.api_secret || raise('Must supply api_secret')
+
+    call_cloudinary_api(method, uri, api_key, api_secret, params, options) do |cloudinary, inner_uri|
+      [cloudinary, 'v1_1', cloud_name, inner_uri]
     end
   end
 
@@ -355,6 +497,22 @@ class Cloudinary::Api
     raise GeneralError.new("Error parsing server response (#{response.code}) - #{response.body}. Got - #{e}")
   end
 
+  # Protected function that assists with performing an API call to the metadata_fields part of the Admin API.
+  #
+  # @protected
+  # @param [Symbol] method  The HTTP method. Valid methods: get, post, put, delete
+  # @param [Array]  uri     REST endpoint of the API (without 'metadata_fields')
+  # @param [Hash]   params  Query/body parameters passed to the method
+  # @param [Hash]   options Additional options. Can be an override of the configuration, headers, etc.
+  # @return [Cloudinary::Api::Response]
+  # @raise [Cloudinary::Api::Error]
+  def self.call_metadata_api(method, uri, params, options)
+    options[:content_type] = :json
+    uri = ["metadata_fields", uri].reject(&:empty?).join("/")
+
+    call_api(method, uri, params, options)
+  end
+
   def self.only(hash, *keys)
     result = {}
     keys.each do |key|
@@ -398,5 +556,4 @@ class Cloudinary::Api
     params[by_key] = value
     call_api("post", "resources/#{resource_type}/#{type}/update_access_mode", params, options)
   end
-
 end