ubiquity-mediasilo-api-v3 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54cf59a7ea65c7df96f0719811903d39bfcb6c1b97ae5cec0b4f008798f93d2b
+  data.tar.gz: 9cfdf801968ce36e807aa7feda43962694cbe05f26fea7ef5f5edad09797f03a
+SHA512:
+  metadata.gz: 28e4ca082b3acd5e2dc89af4d2279f28aae7106cd5ac811daf7ae383ea967d0a436db49a188bafe5e53cf62be632e212bfe885cd0665be31f67c96e1dd1ec330
+  data.tar.gz: ea6480782a75acaeffff0aedbeeef60aea157936ca61283536407dd4e40c5cb63d680b991619b1dca1f2ae7f84335c808813922d35b9cb184a2818ba8447249c

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/dev/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'json', '~>1.8', :platforms => :mri_18
+
+# Specify your gem's dependencies in ubiquity-mediasilo-api-v3.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 John Whitson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,100 @@
+# Ubiquity::Mediasilo::Api::V3
+
+A Library and Utilities to Interact with the MediaSilo API v3
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ubiquity-mediasilo-api-v3'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ubiquity-mediasilo-api-v3
+
+## MediaSilo API V3 Executable [bin/ubiquity-mediasilo-api-v3](./bin/ubiquity-mediasilo-api-v3)
+An executable to interact with the MediaSilo API
+
+### Usage
+    Usage:
+
+        ubiquity-mediasilo-api-v3 -h | --help
+        ubiquity-mediasilo-api-v3 --hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name <METHOD NAME> --method-arguments <JSON>
+
+    Options:
+            --hostname HOSTNAME          The hostname to authenticate with.
+            --username USERNAME          The username to authenticate with.
+            --password PASSWORD          The password to authenticate with.
+            --method-name METHODNAME     The name of the method to call.
+            --method-arguments JSON      The arguments to pass when calling the method.
+            --pretty-print               Will format the output to be more human readable.
+            --[no-]options-file [FILENAME]
+                                         Path to a file which contains default command line arguments.
+                                          default: ~/.options/ubiquity-mediasilo-api-v3
+        -h, --help                       Display this message.
+
+
+#### Examples
+
+##### [Assets](http://developers.mediasilo.com/assets)
+
+###### Asset Copy to Folder
+
+###### Asset Copy to Project
+
+###### Asset Create ([Create a new asset](http://developers.mediasilo.com/assets))
+
+    ubiquity-mediasilo-api-v3 --hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name asset_create --method-arguments '{"project_id":"<PROJECT ID (GUID)>","source_url":"<SOURCE URL"}'
+
+    - project_id [String] (Required) The ID of the Project this asset belongs to.
+    - folder_id [String] The ID of the Folder this asset belongs to.
+    - title [String] Defaults to filename
+    - description [String] A brief description of the asset
+    - source_url [String] Must be a publicly-accessible URL. NOTE: ** SPACES MUST BE REPLACED WITH a plus '+'
+    - is_private [Boolean] If set to true, only authorized users can view the asset (this value may be overridden by account settings)
+
+###### Asset Delete
+
+    ubiquity-mediasilo-api-v3 --hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name asset_create --method-arguments '{"asset_id":"<ASSET ID (GUID)>"}'
+
+    - asset_id [String] (Required) The id of the asset to delete.
+
+##### Projects
+
+###### Project Create ([Create a project](http://developers.mediasilo.com/projects)])
+
+    ubiquity-mediasilo-api-v3 --hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name project_create --method-arguments '{"name":"<PROJECT NAME>"}'
+
+    - name [String] (Required) Name of the project.
+    - description [String] Description of the project.
+
+###### Project Delete ([Delete a project](http://developers.mediasilo.com/projects)])
+
+    ubiquity-mediasilo-api-v3 --hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name project_delete --method-arguments '{"id":"<PROJECT ID (GUID)>"}'
+
+    - project_id [String] (Required) The id of the project to delete.
+
+###### Project Get by Id ([Retrieve a project](http://developers.mediasilo.com/projects))
+
+    ubiquity-mediasilo-api-v3 --hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name project_get_by_id --method-arguments '{"id":"<PROJECT ID (GUID)>"}'
+
+    - id [String] (Required) Id (GUID) of the project.
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/XPlatform-Consulting/ubiquity-mediasilo-api-v3/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/ubiquity-mediasilo-api-v3

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path) unless $:.include?(lib_path) or !File.exists?(lib_path)
+
+require 'rubygems'
+require 'ubiquity/mediasilo/api/v3/cli'
+
+interactive = ARGV.delete('--interactive')
+begin
+  if interactive
+    def load_cli; load 'ubiquity/mediasilo/api/v3/cli.rb'; @cli = nil end; load_cli
+    require 'irb'; IRB.start
+  else
+    require 'ubiquity/mediasilo/api/v3/cli'
+    ARGV << '--help' if ARGV.empty?
+    cli.run
+  end
+rescue LoadError
+  lib_path = File.expand_path('../../lib', __FILE__)
+  unless $:.include?(lib_path)
+    $:.unshift(lib_path)
+    retry
+  end
+  abort("Failed to load the required file. Exception: #{$!}")
+end
+

data/lib/ubiquity/cli.rb

@@ -0,0 +1,127 @@
+require 'optparse'
+
+module Ubiquity
+
+  class CLI
+
+    def self.define_parameters
+      # To be implemented by the child class
+      argument_parser.on_tail('-h', '--help', 'Display this message.') { puts help; exit }
+    end
+
+    def initialize(args = self.class.parse_arguments)
+      # To be implemented by the child class
+    end
+
+    def self.default_options_file_path
+      File.expand_path(File.basename($0, '.*'), '~/.options')
+    end
+
+    def self.default_arguments
+      @default_arguments ||= {
+        :options_file_path => default_options_file_path,
+      }
+    end
+
+    def self.help_usage
+      # To be implemented by the child class
+      help_usage_default
+    end
+
+    def self.help_usage_append(string = '')
+      usage_string = "\n    #{executable_name} #{string}"
+      @help_usage << usage_string unless (@help_usage ||= help_usage_default).include?(usage_string)
+    end
+
+    def self.help_usage_default
+      "  #{executable_name} -h | --help"
+    end
+
+    def self.help
+      @help_usage ||= help_usage_default
+      argument_parser.banner = <<-BANNER
+Usage:
+  #{help_usage}
+
+Options:
+      BANNER
+      argument_parser
+    end
+
+    ## Methods below this line should not need to be implemented by the child class
+
+
+    class << self
+      attr_writer :argument_parser,
+                  :help_usage,
+                  :default_arguments, :arguments, :arguments_from_command_line, :arguments_from_options_file
+    end
+
+    def self.argument_parser(options = { })
+      return @argument_parser if @argument_parser and !options[:force_new]
+      @argument_parser = OptionParser.new
+      arguments and define_parameters if options.fetch(:define_parameters, true)
+      @argument_parser
+    end
+
+    def self.arguments
+      @arguments ||= begin
+        default_arguments.dup
+      end
+    end
+
+    def self.arguments_from_command_line(array_of_arguments = ARGV)
+      @arguments_from_command_line ||= parse_arguments_from_command_line(array_of_arguments)
+    end
+
+    def self.arguments_from_options_file(options_file_path = arguments[:options_file_path])
+      @arguments_from_options_file ||= parse_arguments_from_options_file(options_file_path)
+    end
+
+    def self.parse_arguments_from_command_line(array_of_arguments = ARGV)
+      arguments_before = arguments.dup
+      arguments.clear
+
+      argument_parser.parse!(array_of_arguments.dup)
+      _arguments_from_options_file = arguments.dup
+      @arguments = arguments_before
+      _arguments_from_options_file
+    end
+
+    def self.parse_arguments_from_options_file(options_file_path = arguments[:options_file_path])
+      arguments_before = arguments.dup
+      arguments.clear
+      argument_parser.load(options_file_path)
+      _arguments_from_options_file = arguments.dup
+      @arguments = arguments_before
+      _arguments_from_options_file
+    end
+
+    def self.parse_arguments
+      argument_parser
+      @arguments = default_arguments.merge(arguments_from_options_file).merge(arguments_from_command_line)
+    end
+
+    def self.clear_cached_arguments
+      @arguments_from_command_line = nil
+      @arguments_from_options_file = nil
+      @arguments = nil
+      @default_arguments = nil
+      argument_parser(:force_new => true)
+      true
+    end
+
+    def self.executable_name
+      @executable_name ||= File.basename($0)
+    end
+
+    def self.run(args = nil, init_options = { }, run_options = { })
+      args ||= parse_arguments
+      new(args, init_options).run(args, run_options)
+    end
+
+    # CLI
+  end
+
+  # Ubiquity
+end

data/lib/ubiquity/mediasilo/api/v3.rb

@@ -0,0 +1,11 @@
+require 'ubiquity/mediasilo/api/v3/version'
+
+module Ubiquity
+  module Mediasilo
+    class API
+      module V3
+
+      end
+    end
+  end
+end

data/lib/ubiquity/mediasilo/api/v3/cli.rb

@@ -0,0 +1,94 @@
+require 'ubiquity/cli'
+
+require 'ubiquity/mediasilo/api/v3/client'
+
+class Ubiquity::MediaSilo::API::V3::CLI < Ubiquity::CLI
+
+  def self.help_usage
+    help_usage_append '--hostname <HOSTNAME> --username <USERNAME> --password <PASSWORD> --method-name <METHODNAME> --method-arguments <JSON>'
+  end
+
+  def self.define_parameters
+    argument_parser.on('--hostname HOSTNAME', 'The account hostname to authenticate with.') { |v| arguments[:hostname] = v }
+    argument_parser.on('--username USERNAME', 'The account username to authenticate with.') { |v| arguments[:username] = v }
+    argument_parser.on('--password PASSWORD', 'The account password to authenticate with.') { |v| arguments[:password] = v }
+
+    argument_parser.on('--method-name METHODNAME', 'The name of the method to call.') { |v| arguments[:method_name] = v }
+    argument_parser.on('--method-arguments JSON', 'The arguments to pass when calling the method.') { |v| arguments[:method_arguments] = v }
+    argument_parser.on('--pretty-print', 'Will format the output to be more human readable.') { |v| arguments[:pretty_print] = v }
+
+    argument_parser.on('--[no-]options-file [FILENAME]', 'Path to a file which contains default command line arguments.', "\tdefault: #{arguments[:options_file_path]}" ) { |v| arguments[:options_file_path] = v}
+    argument_parser.on_tail('-h', '--help', 'Display this message.') { puts help; exit }
+  end
+
+  attr_accessor :logger, :api
+
+  def initialize(args = self.class.arguments, options = { })
+    @initial_args = args.dup
+    initialize_logger(args)
+    initialize_api(args)
+  end
+
+  # @param [Hash] args
+  # @option args [Logger]     :logger A logger to be used
+  # @option args [IO, String] :log_to An IO device or file to log to
+  # @option args [Integer]    :log_level (Logger::DEBUG) The logging level to be set to the logger
+  def initialize_logger(args = { })
+    @logger = args[:logger] ||= Logger.new(args[:log_to] ||= STDERR)
+    @logger.level = (log_level = args[:log_level]) ? log_level : Logger::WARN
+    args[:logger] = @logger
+    args[:log_level] ||= @logger.level
+    @logger
+  end
+
+  def initialize_api(args = { })
+    @api = Ubiquity::MediaSilo::API::V3::Client.new(args.merge(:parse_response => false))
+  end
+
+  def send(method_name, method_arguments, params = {})
+    method_name = method_name.to_sym
+    logger.debug { "Executing Method: #{method_name}" }
+
+    send_arguments = [ method_name ]
+
+    if method_arguments
+      method_arguments = JSON.parse(method_arguments, :symbolize_names => true) if method_arguments.is_a?(String) and method_arguments.start_with?('{', '[')
+      send_arguments << method_arguments
+    end
+
+    response = api.__send__(*send_arguments)
+
+    # if aa.response.code.to_i.between?(500,599)
+    #   puts aa.parsed_response
+    #   exit
+    # end
+    #
+    # if ResponseHandler.respond_to?(method_name)
+    #   ResponseHandler.aa = aa
+    #   ResponseHandler.response = response
+    #   response = ResponseHandler.__send__(*send_arguments)
+    # end
+
+    if params[:pretty_print]
+      if response.is_a?(String) and response.lstrip.start_with?('{', '[')
+        puts JSON.pretty_generate(JSON.parse(response))
+      else
+        pp response
+      end
+    else
+      response = JSON.generate(response) if response.is_a?(Hash) or response.is_a?(Array)
+      puts response
+    end
+    # send
+  end
+
+  def run(args = self.class.arguments, options = { })
+    #puts "#{__FILE__}:#{__LINE__}:#{args}"
+    method_name = args[:method_name]
+    send(method_name, args[:method_arguments], :pretty_print => args[:pretty_print]) if method_name
+
+    self
+  end
+
+end
+def cli; @cli ||= Ubiquity::MediaSilo::API::V3::CLI end

data/lib/ubiquity/mediasilo/api/v3/client.rb

@@ -0,0 +1,712 @@
+require 'ubiquity/mediasilo/api/v3/http_client'
+require 'ubiquity/mediasilo/api/v3/client/requests'
+require 'ubiquity/mediasilo/api/v3/client/paginator'
+
+class Ubiquity::MediaSilo::API::V3::Client
+
+  attr_accessor :logger
+
+  attr_accessor :http_client, :request, :response, :batch_requests, :http_response
+
+  def initialize(args = { })
+    initialize_logger(args)
+    initialize_http_client(args)
+
+    @batch_mode = false
+    @batch_requests = [ ]
+  end
+
+  def initialize_logger(args = { })
+    @logger = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+    log_level = args[:log_level]
+    if log_level
+      @logger.level = log_level
+      args[:logger] = @logger
+    end
+    @logger
+  end
+
+  def initialize_http_client(args = { })
+    @http_client = Ubiquity::MediaSilo::API::V3::HTTPClient.new(args)
+  end
+
+  def error_message
+    response.is_a?(String) ? response.gsub(/<[^>]*>/ui,'') : ''
+  end
+
+  def success?
+    return request.success? if request.respond_to?(:success?)
+
+    _code = http_client.response.code
+    _code and _code.start_with?('2')
+  end
+
+  # @param [Requests::BaseRequest] request
+  # @param [Hash, nil] options
+  # @option options [Boolean] :execute_request (true) Will execute the request
+  # @option options [Boolean] :return_request (true) Will return the request instance instead of nil. Only applies if
+  #   execute_request is false.
+  def process_request(request, options = nil)
+    @paginator = nil
+    @response = nil
+    @request = request
+    logger.warn { "Request is Missing Required Arguments: #{request.missing_required_arguments.inspect}" } unless request.missing_required_arguments.empty?
+
+    if batch_mode
+      logger.debug { "Adding Request to Batch. #{request.inspect}" }
+      @batch_requests << request
+      return batch_requests
+    end
+
+    if ([:all, 'all'].include?(request.arguments[:_page]))
+      request.arguments[:_page] = 1
+      include_remaining_pages = true
+    else
+      include_remaining_pages = false
+    end
+
+    request.client = self unless request.client
+    options ||= request.options
+
+    return (options.fetch(:return_request, true) ? request : nil) unless options.fetch(:execute_request, true)
+
+    #@response = http_client.call_method(request.http_method, { :path => request.path, :query => request.query, :body => request.body }, options)
+    @response = request.execute
+
+    if include_remaining_pages
+      return paginator.include_remaining_pages
+    end
+
+    @response
+  end
+
+  def paginator
+    @paginator ||= Paginator.new(self) if @response
+  end
+
+  def process_request_using_class(request_class, args = { }, options = { })
+    @response = nil
+    @request = request_class.new(args, options)
+    process_request(request, options)
+  end
+
+  # ################################################################################################################## #
+  # @!group API Methods
+
+  # @see https://phoenix.readme.io/docs/aspera-file-download
+  def aspera_file_download_ticket_create(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'aspera/download/#{path_arguments[:asset_id]}/#{path_arguments[:target]}',
+        :http_method => :post,
+        :parameters => [
+          { :name => :asset_id, :send_in => :path },
+          { :name => :target, :send_in => :path } # Either 'source' or 'proxy'
+        ]
+      }
+    )
+    response = process_request(_request, options)
+    response
+  end
+
+  # @see https://phoenix.readme.io/docs/aspera-file-upload
+  def aspera_file_upload_ticket_create(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'aspera/upload',
+        :http_method => :post,
+        :parameters => [
+          { :name => :fileName, :send_in => :body }
+        ]
+      }
+    )
+
+    response = process_request(_request, options)
+    response
+  end
+
+  def asset_copy_to_folder(args = { }, options = { })
+    process_request_using_class(Requests::AssetCopyToFolder, args, options)
+  end
+
+  def asset_copy_to_project(args = { }, options = { })
+    process_request_using_class(Requests::AssetCopyToProject, args, options)
+  end
+
+  # @see http://docs.mediasilo.com/v3.0/docs/create-asset
+  def asset_create(args = { }, options = { })
+    # args_out = Requests::AssetCreate.new(args, options).arguments
+    # @response = http_client.post('/assets', args_out)
+    process_request_using_class(Requests::AssetCreate, args, options)
+  end
+
+  def asset_delete_by_id(args = { }, options = { })
+    # asset_id = asset_id[:id] if asset_id.is_a?(Hash)
+    # @response = http_client.delete('/assets/%s' % asset_id)
+
+    args = { :assetId => args } if args.is_a?(String)
+    # _request = Requests::AssetDelete.new(args, options)
+    # @response = http_client.delete(_request.path)
+    process_request_using_class(Requests::AssetDelete, args, options)
+  end
+  alias :asset_delete :asset_delete_by_id
+
+  # @see http://docs.mediasilo.com/v3.0/docs/edit-asset
+  def asset_edit(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_method => :put,
+        :http_path => 'assets/#{path_arguments[:asset_id]}',
+        :http_success_code => 204,
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          { :name => :title, :send_in => :body },
+          { :name => :description, :send_in => :body }
+        ]
+      }
+    )
+    process_request(_request, options)
+  end
+
+  # @see http://docs.mediasilo.com/v3.0/docs/asset-detail
+  def asset_get_by_id(args = { }, options = { })
+    args = { :asset_id => args } if args.is_a?(String)
+    process_request_using_class(Requests::AssetGetById, args, options)
+  end
+
+  # @see http://docs.mediasilo.com/v3.0/docs/all-assets
+  def assets_get(args = { }, options = { })
+    # query = options[:query] || { :type => '{"in":"video,image,document,archive,audio"}' }
+    # @response = http_client.get('/assets', query)
+    _response = process_request_using_class(Requests::AssetsGet, args, options)
+    _response = [ ] unless _response.is_a?(Array)
+    _response
+  end
+
+  # @note This will get all assets for a folder
+  # @param [Hash] args
+  # @option args [String] folder_id The Id of the folder to get the assets for
+  # @return [Array]
+  # @see http://docs.mediasilo.com/v3.0/docs/assets-in-folder
+  def assets_get_by_folder_id(args = { }, options = { })
+    args = { :id => args } if args.is_a?(String)
+
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'folders/#{path_arguments[:folder_id]}/assets',
+        :parameters => [
+          { :name => :folder_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          {
+            :name => :type,
+            # Received a 500 Request Failed error if 'type' was not set so we default it
+            # :default_value => '{"in":"video,image,document,archive,audio"}',
+            :send_in => :query
+          },
+          { :name => :_page, :aliases => [ :page ], :send_in => :query },
+          { :name => :_pageSize, :aliases => [ :page_size ], :send_in => :query },
+          { :name => :_sort, :aliases => [ :sort ], :send_in => :query },
+          { :name => :_sortBy, :aliases => [ :sort_by ], :send_in => :query }
+        ]
+      }
+    )
+    response = process_request(_request, options)
+    response
+  end
+
+
+  # @note This will get all assets for a project
+  # @param [Hash] args
+  # @option args [String] project_id The Id of the project to get the assets for
+  # @return [Array]
+  # @see http://docs.mediasilo.com/v3.0/docs/assets-in-project
+  def assets_get_by_project_id(args = { }, options = { })
+    args = { :id => args } if args.is_a?(String)
+
+    # return_all_results = options.fetch(:return_all_results, false)
+
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects/#{path_arguments[:project_id]}/assets',
+        :parameters => [
+          { :name => :project_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          {
+            :name => :type,
+            # Received a 500 Request Failed error if 'type' was not set so we default it
+            # :default_value => '{"in":"video,image,document,archive,audio"}',
+            :send_in => :query
+          },
+          { :name => :_page, :aliases => [ :page ], :send_in => :query },
+          { :name => :_pageSize, :aliases => [ :page_size ], :send_in => :query },
+          { :name => :_sort, :aliases => [ :sort ], :send_in => :query },
+          { :name => :_sortBy, :aliases => [ :sort_by ], :send_in => :query }
+        ]
+      }
+    )
+    response = process_request(_request, args)
+
+    # response.delete_if { |asset| asset['folderId'] } if response.is_a?(Array) &&!return_all_results
+
+    response
+  end
+
+  def asset_move_to_folder(args = { }, options = { })
+    process_request_using_class(Requests::AssetMoveToFolder, args, options)
+  end
+
+  def asset_move_to_project(args = { }, options = { })
+    process_request_using_class(Requests::AssetMoveToProject, args, options)
+  end
+
+  # @see http://docs.mediasilo.com/v3.0/docs/add-tag-to-asset
+  def asset_tag_add(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_method => :post,
+        :http_success_code => '204',
+        :http_path => 'assets/#{path_arguments[:asset_id]}/tags',
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          { :name => :tags, :aliases => [ :tag ], :send_in => :body },
+        ]
+      }
+    )
+    _tags = _request.arguments[:tags]
+    _request.arguments[:tags] = [*_tags] unless _tags.is_a?(Array)
+
+    process_request(_request, options)
+  end
+  alias :asset_tags_add :asset_tag_add
+  alias :asset_add_tag :asset_tag_add
+
+  def asset_tag_delete(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_method => :delete,
+        :http_success_code => '204',
+        :http_path => 'assets/#{path_arguments[:asset_id]}/tags/#{path_arguments[:tag]}',
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          { :name => :tag, :send_in => :path },
+        ]
+      }
+    )
+    process_request(_request, options)
+  end
+  alias :asset_tag_remove :asset_tag_delete
+
+  def asset_upload_ticket_create(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_method => :post,
+        :http_path => 'assets/upload',
+        :parameters => [
+          { :name => :fileName, :send_in => :body }
+        ]
+      }
+    )
+    process_request(_request, options)
+  end
+
+  def asset_upload(args = { }, options = { })
+
+  end
+
+  # This endpoint is available to admins on any user id, or the current user on their own user id. It returns
+  # immediately, and watermarking runs in the background. To check whether the watermarking is done, you need to get
+  # the ‘proxy’ derivative our of the asset response model and check the ‘progress’ key. Be careful, because there are
+  # also ‘progress’ values at the base of the asset response model as well as in the ‘preroll’ derivative. You want
+  # the ‘proxy’ one. When that hits 100, the video is ready to play back.
+  #
+  # @param [Hash] args ({ })
+  # @option args [String] :asset_id
+  # @option args [String] :user_id
+  def asset_watermark_trigger(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+        args,
+        {
+            :http_method => :post,
+            :http_success_code => '204',
+            :http_path => 'assets/#{path_arguments[:asset_id]}/watermark/#{path_arguments[:user_id]}',
+            :parameters => [
+                { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+                { :name => :user_id, :send_in => :path },
+            ]
+        }
+    )
+    process_request(_request, options)
+  end
+
+  # Executes the queued requests as a batch
+  # @param [Array] requests (@batch_requests)
+  # @param [Hash] options
+  def batch_execute(requests = nil, options = { })
+    if block_given?
+      @batch_mode = true
+      yield
+      _requests = @batch_requests + (requests || [ ])
+    else
+      _requests = requests.nil? ? @batch_requests.dup : requests.dup
+    end
+    @batch_mode = false
+    return [ ] if _requests.empty?
+    _requests.map! { |req| req.respond_to?(:to_batchable_request) ? req.to_batchable_request : req }
+    _response = [ ]
+
+    if requests.nil? and options.fetch(:clear_requests, true)
+      @batch_requests = [ ]
+    else
+      requests = [ ]
+    end
+
+    # @request_history.concat(_requests)
+    _requests.each_slice(50) do |_req|
+      process_request_using_class(Requests::Batch, { :requests => _req }, options)
+      _response << @response
+    end
+    @response = _response
+  end
+
+  # Sets the batch mode
+  # @param [True,False] value
+  def batch_mode=(value, options = { })
+    @batch_mode = value
+    @batch_requests = [ ] if value and options.fetch(:clear_requests, true)
+    @batch_mode
+  end
+
+  # Returns true if the client is currently batching requests
+  def batch_mode?
+    @batch_mode
+  end
+  alias :batch_mode :batch_mode?
+
+  def batch_mode_enable
+    self.batch_mode = true
+  end
+
+  # @see http://docs.mediasilo.com/v3.0/docs/create-folder
+  def folder_create(args = { }, options = { })
+    # @response = http_client.post('/folders', args)
+
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_method => :post,
+        :http_path => 'folders',
+        :parameters => [
+          { :name => :name, :send_in => :body },
+          { :name => :projectId, :send_in => :body },
+          { :name => :parentId, :default_value => 0, :send_in => :body }
+        ]
+      }
+    )
+
+    # arguments = _request.arguments
+    # parent_id = arguments[:parentId]
+    #
+    # if parent_id && parent_id != 0
+    #   logger.debug { 'Unsetting projectId because parentId is set.'  }
+    #   arguments.delete(:projectId)
+    # end
+    #
+    # _request.arguments = arguments
+
+    process_request(_request, options)
+  end
+
+  def folder_delete(args = { }, options = { })
+    # folder_id = folder_id[:id] if folder_id.is_a?(Hash)
+    # @response = http_client.delete('/folders/%s' % folder_id)
+
+    args = { :folder_id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_method => :delete,
+        :http_path => 'folders/#{path_arguments[:folder_id]}',
+        :parameters => [
+          { :name => :folder_id, :aliases => [ :id ], :send_in => :path }
+        ]
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def folder_get_by_id(args = { }, options = { })
+    args = { :folder_id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'folders/#{path_arguments[:folder_id]}',
+        :parameters => [
+          { :name => :folder_id, :aliases => [ :id ], :send_in => :path }
+        ]
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def folders_get_by_parent_id(args = { })
+    folder_id = case args
+                  when String; args
+                  when Hash; args[:id] || args[:parent_id]
+                end
+    @response = http_client.get('/folders/%s/subfolders' % folder_id)
+  end
+
+  def folders_get_by_project_id(args = { })
+    project_id = case args
+                   when String; args
+                   when Hash; args[:id] || args[:project_id]
+                 end
+    @response = http_client.get('/projects/%s/folders' % project_id)
+  end
+
+  def metadata_get(args = { }, options = { })
+    return_as_hash = options.delete(:return_as_hash) { false }
+
+    args = { :asset_id => args } unless args.is_a?(Hash)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets/#{path_arguments[:asset_id]}/metadata',
+        :http_success_code => %w(200 404),
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path }
+        ]
+      }.merge(options)
+    )
+    _response = process_request(_request, options)
+
+    return (return_as_hash ? {} : []) if _request.client.http_client.response.code == '404'
+    return false unless _response.is_a?(Array)
+
+    return Hash[ _response.map { |m| [ m['key'], m['value'] ] } ] if return_as_hash
+
+    _response
+  end
+  alias :metadata_get_by_asset_id :metadata_get
+  alias :metadata_get_by_asset_uuid :metadata_get
+
+  # @see http://docs.mediasilo.com/v3.0/docs/add-metadata
+  def metadata_create_or_update(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets/#{path_arguments[:asset_id]}/metadata',
+        :http_method => :post,
+        :http_success_code => 204,
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          { :name => :key, :send_in => :body},
+          { :name => :value, :send_in => :body},
+          { :name => :metadata, :send_in => :body},
+        ]
+      }.merge(options)
+    )
+    metadata = _request.body_arguments.delete(:metadata) { }
+    metadata = metadata.map { |k,v| { 'key' => k, 'value' => v } } if metadata.is_a?(Hash)
+
+    _request.body = metadata.delete_if { |h| v = h['value']; (v.respond_to?(:empty?) && v.empty?) } if metadata
+    process_request(_request, options)
+  end
+  alias :metadata_set :metadata_create_or_update
+  alias :metadata_add :metadata_create_or_update
+  alias :metadata_create_if_not_exists :metadata_create_or_update
+
+  # @see http://docs.mediasilo.com/v3.0/docs/delete
+  def metadata_delete(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets/#{path_arguments[:asset_id]}/metadata/#{path_arguments[:metadata_key]}',
+        :http_method => :delete,
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          { :name => :metadata_key, :aliases => [ :key ], :send_in => :path },
+        ]
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  # @see http://docs.mediasilo.com/v3.0/docs/update
+  def metadata_replace(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'assets/#{path_arguments[:asset_id]}/metadata',
+        :http_method => :put,
+        :parameters => [
+          { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+          { :name => :key, :send_in => :body },
+          { :name => :value, :send_in => :body },
+          { :name => :metadata, :send_in => :body },
+        ]
+      }.merge(options)
+    )
+    metadata = _request.body_arguments.delete(:metadata) { }
+    metadata = metadata.map { |k,v| { 'key' => k, 'value' => v} } if metadata.is_a?(Hash)
+    _request.body = metadata if metadata
+    process_request(_request, options)
+  end
+  alias :metadata_mirror :metadata_replace
+
+  # @see http://docs.mediasilo.com/v3.0/docs/create-project
+  def project_create(args = { }, options = { })
+    args = { :name => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects',
+        :http_method => :post,
+        :parameters => [
+          { :name => :name, :send_in => :body, :required => true },
+          { :name => :description, :send_in => :body }
+        ]
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def project_delete(args = { }, options = { })
+    args = { :project_id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects/#{path_arguments[:project_id]}',
+        :http_method => :delete,
+        :parameters => [
+          { :name => :project_id, :aliases => [ :id ], :send_in => :path }
+        ]
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def project_get_by_id(args = { }, options = { })
+    # project_id = project_id[:id] if project_id.is_a?(Hash)
+    # @response = http_client.get('/projects/%s' % project_id)
+
+    args = { :project_id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'projects/#{path_arguments[:project_id]}',
+        :parameters => [
+          { :name => :project_id, :aliases => [ :id ], :send_in => :path }
+        ]
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def projects_get(options = { })
+    #@response = http_client.get('/projects')
+
+    _request = Requests::BaseRequest.new(
+      { },
+      {
+        :http_path => 'projects',
+        :http_success_code => %w(200 404),
+      }.merge(options)
+    )
+    _response = process_request(_request, options)
+    return [] if _request.client.http_client.response.code == '404'
+
+    return _response
+  end
+
+  def project_watermark_settings_get(args = { }, options = { })
+    args = { :project_id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+        args,
+        {
+            :http_path => 'projects/#{path_arguments[:project_id]}/watermarkSettings',
+            :parameters => [
+                { :name => :project_id, :aliases => [ :id ], :send_in => :path }
+            ]
+        }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def project_watermark_settings_set(args = { }, options = { })
+    args = { :project_id => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+        args,
+        {
+            :http_path => 'projects/#{body_arguments[:context]}/watermarkSettings',
+            :http_method => 'PUT',
+            :parameters => [
+                { :name => :context, :aliases => [ :project_id ], :send_in => :body },
+                { :name => :id, :send_in => :body },
+                { :name => :settings, :send_in => :body },
+                { :name => :enabled, :send_in => :body },
+            ]
+        }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def quicklink_create(args = { }, options = { })
+    process_request_using_class(Requests::QuicklinkCreate, args, options)
+  end
+
+  def quicklink_share(args = { }, options = { })
+    process_request_using_class(Requests::QuicklinkShare, args, options)
+  end
+
+  def tag_edit(args = { }, options = { })
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => 'tags',
+        :http_method => :put,
+        :http_success_code => '204',
+        :parameters => [
+          { :name => :currentName, :required => true, :send_in => :body },
+          { :name => :newName, :required => true, :send_in => :body }
+        ]
+        # :http_success_code => %w(200 404),
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def tags_get
+    http_client.get('tags')
+  end
+
+  def user_delete(args = { }, options = { })
+    args = { :userId => args } if args.is_a?(String)
+    _request = Requests::BaseRequest.new(
+      args,
+      {
+        :http_path => '/users/#{arguments[:userId]}',
+        :http_method => :delete,
+        :http_success_code => '204',
+        :parameters => [
+          { :name => :userId, :required => true, :send_in => :query },
+        ]
+        # :http_success_code => %w(200 404),
+      }.merge(options)
+    )
+    process_request(_request, options)
+  end
+
+  def users_get(args = { }, options = { })
+    http_client.get('users?_pageSize=250')
+  end
+
+
+
+end