ubiquity-mediasilo-api-v3 1.0.0

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

@@ -0,0 +1,133 @@
+class Ubiquity::MediaSilo::API::V3::Client::Paginator
+
+  attr_accessor :api_client
+
+  attr_reader :total_results, :last_page_number, :next_page_number, :prev_page_number, :page_size
+
+  def initialize(api_client)
+    @api_client = api_client
+
+    process_response
+  end
+
+  def logger
+    api_client.logger
+  end
+
+  def http_client
+    api_client.http_client
+  end
+
+  def process_response
+    http_response = http_client.response
+
+    @total_results = http_response['total-results']
+    @paginated = !!total_results
+
+    process_link_header(http_response['link']) if paginated?
+  end
+
+  def process_link_header(link)
+    links = link.split(',')
+    @next_page_number = nil
+    @prev_page_number = nil
+
+    links.map! do |l|
+      href, rel = l.split('; ')
+      rel = rel.match(/"(\w*)/)[1]
+      href = href.match(/<(.*)>/)[1]
+      _, query = href.split('?')
+      query_as_hash = Hash[ query.split('&').map { |v| v.split('=') } ]
+      @page_size = query_as_hash['_pageSize']
+
+      case rel
+        when 'next'
+          @next_page_number = query_as_hash['_page']
+          @next_page_href = href
+        when 'last'
+          @last_page_number = query_as_hash['_page']
+          @last_page_href = href
+        when 'prev'
+          @prev_page_number = query_as_hash['_page']
+          @prev_page_href = href
+      end
+
+      [ rel, href ]
+    end
+    @has_next_page = !!@next_page_number
+    @has_prev_page = !!@prev_page_number
+
+    Hash[links]
+  end
+
+  def request
+    @request ||= api_client.request
+  end
+
+  def request_args_out
+    @request_args_out ||= request.initial_arguments.dup
+  end
+
+  def request_options_out
+    @request_options_out ||= { :client => api_client }.merge request.initial_options.dup
+  end
+
+  def paginated?
+    @paginated
+  end
+
+  def next_page?
+    @has_next_page
+  end
+
+  def next_page_get(_next_page_number = @next_page_number)
+    page_get(_next_page_number)
+  end
+
+  def page_get(page_number)
+    logger.debug { "Getting Page #{page_number} of #{last_page_number}" }
+    new_request = request.class.new(request_args_out.merge('_page' => page_number), request_options_out)
+    _response = new_request.execute
+    process_response
+    _response
+  end
+
+  def pages_get(pages, options = { })
+    consolidate = options.fetch(:consolidate, true)
+    pages = pages.to_a if pages.respond_to?(:to_a)
+    pages_out = pages.map { |v| page_get(v) }
+    pages_out.flatten! if consolidate
+    pages_out
+  end
+
+  def prev_page?
+    @has_prev_page
+  end
+
+  def prev_page_get(_prev_page_number = @prev_page_number)
+    return [ ] unless paginated?
+    page_get(_prev_page_number)
+  end
+
+  def include_remaining_pages
+    response = api_client.response.dup
+    response.concat(remaining_pages_get)
+  end
+
+  def remaining_pages_get
+    return [ ] unless paginated? && next_page?
+    _next_page_number = @next_page_number
+    remaining_results = [ ]
+
+    loop do
+      response = next_page_get(_next_page_number)
+      break unless response.is_a?(Array)
+      remaining_results.concat(response)
+
+      break unless next_page?
+      _next_page_number = next_page_number
+    end
+    remaining_results
+  end
+
+end

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

@@ -0,0 +1,18 @@
+require 'ubiquity/mediasilo/api/v3/client/requests/base_request'
+
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_copy_to_folder'
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_copy_to_project'
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_create'
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_delete'
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_get_by_id'
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_move_to_folder'
+require 'ubiquity/mediasilo/api/v3/client/requests/asset_move_to_project'
+
+require 'ubiquity/mediasilo/api/v3/client/requests/assets_get'
+require 'ubiquity/mediasilo/api/v3/client/requests/assets_get_by_folder_id'
+require 'ubiquity/mediasilo/api/v3/client/requests/assets_get_by_project_id'
+
+require 'ubiquity/mediasilo/api/v3/client/requests/batch'
+
+require 'ubiquity/mediasilo/api/v3/client/requests/quicklink_create'
+require 'ubiquity/mediasilo/api/v3/client/requests/quicklink_share'

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

@@ -0,0 +1,19 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetCopyToFolder < BaseRequest
+
+    HTTP_METHOD = :post
+    HTTP_PATH = '/folders/#{arguments[:destinationFolderId]}/assets/#{arguments[:assetId]}/copy'
+    HTTP_SUCCESS_CODE = 204
+
+    PARAMETERS = [
+      { :name => :destinationFolderId, :required => true, :aliases => [ :folderid ] },
+      { :name => :assetId, :required => true },
+      :includeComments,
+      :includeMetadata,
+      :includeTags
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,19 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetCopyToProject < BaseRequest
+
+    HTTP_METHOD = :post
+    HTTP_PATH = '/projects/#{arguments[:destinationProjectId]}/assets/#{arguments[:assetId]}/copy'
+    HTTP_SUCCESS_CODE = 204
+
+    PARAMETERS = [
+      { :name => :destinationProjectId, :required => true, :aliases => [ :projectid ] },
+      { :name => :assetId, :required => true },
+      :includeComments,
+      :includeMetadata,
+      :includeTags
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,25 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  # @see http://docs.mediasilo.com/v3.0/docs/create-asset
+  class AssetCreate < BaseRequest
+
+    HTTP_METHOD = :post
+    HTTP_PATH = '/assets'
+    DEFAULT_PARAMETER_SEND_IN_VALUE = :body
+
+    PARAMETERS = [
+      { :name => :projectId, :required => true },
+      :folderId,
+      :title,
+      :description,
+      { :name => :sourceUrl, :required => true },
+      :isPrivate
+    ]
+
+    def after_process_parameters
+      arguments.delete(:folderId) if arguments[:folderId].to_s == '0'
+    end
+
+  end
+
+end

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

@@ -0,0 +1,15 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+ class  AssetDelete < BaseRequest
+
+  HTTP_METHOD = :delete
+  HTTP_PATH = '/assets/#{arguments[:assetId]}'
+  HTTP_SUCCESS_CODE = 204
+
+  PARAMETERS = [
+    { :name => :assetId, :aliases => [ :id ], :required => true }
+  ]
+
+ end
+
+end

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

@@ -0,0 +1,14 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetGetById < BaseRequest
+
+    HTTP_METHOD = :get
+    HTTP_PATH = '/assets/#{arguments[:asset_id]}'
+
+    PARAMETERS = [
+      { :name => :asset_id, :aliases => [ :id ], :send_in => :path, :required => true },
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,16 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetMoveToFolder < BaseRequest
+
+    HTTP_METHOD = :post
+    HTTP_PATH = '/folders/#{arguments[:destinationFolderId]}/assets/#{arguments[:assetId]}/move'
+    HTTP_SUCCESS_CODE = 204
+
+    PARAMETERS = [
+      { :name => :destinationFolderId, :required => true, :aliases => [ :folderid ] },
+      { :name => :assetId, :required => true },
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,16 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetMoveToProject < BaseRequest
+
+    HTTP_METHOD = :post
+    HTTP_PATH = '/projects/#{arguments[:destinationProjectId]}/assets/#{arguments[:assetId]}/move'
+    HTTP_SUCCESS_CODE = 204
+
+    PARAMETERS = [
+      { :name => :destinationProjectId, :required => true, :aliases => [ :projectid ] },
+      { :name => :assetId, :required => true },
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,56 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetsGet < BaseRequest
+
+    HTTP_METHOD = :get
+    HTTP_PATH = '/assets'
+
+    PARAMETERS = [
+      # { :name => :_pageSize, :default_value => 250 },
+      :_pageSize,
+      :_page,
+      :_sortBy,
+      :_sort,
+
+      :approvalstatus,
+      :averagerating,
+      :comments,
+      :datecreated,
+      :datemodified,
+      :description,
+      :duration,
+      :filename,
+      :folderid,
+      :hasapprovals,
+      :hascomments,
+      :hasrating,
+      :hastranscript,
+      :height,
+      :metadatakeys,
+      :metadatakeys_exact,
+      :metadatamatch,
+      :metadatavalues,
+      :metadatavalues_exact,
+      :projectid,
+      :rating,
+      :size,
+      :tags,
+      :title,
+      :transcript,
+      :transcriptstatus,
+      :type,
+      # { :name => :type, :default_value => '{"in":"video,image,document,archive,audio"}' },
+      :uploaduser,
+      :width,
+    ]
+
+  end
+
+
+
+  def success?
+    response_code = client.http_client.response.code
+    (response_code == '404' || response_code.start_with?('2'))
+  end
+
+end

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

@@ -0,0 +1,14 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetsGetByFolderId < BaseRequest
+
+    HTTP_METHOD = :get
+    HTTP_PATH = '/folders/#{arguments[:folderId]}/assets'
+
+    PARAMETERS = [
+      { :name => :folderId, :aliases => [ :id ], :required => true },
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,14 @@
+module Ubiquity::MediaSilo::API::V3::Client::Requests
+
+  class AssetsGetByProjectId < BaseRequest
+
+    HTTP_METHOD = :get
+    HTTP_PATH = '/projects/#{arguments[:projectId]}/assets'
+
+    PARAMETERS = [
+      { :name => :projectId, :aliases => [ :id ], :required => true },
+    ]
+
+  end
+
+end

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

@@ -0,0 +1,250 @@
+require 'cgi'
+
+module Ubiquity
+  module MediaSilo
+    class API
+      module V3
+        class Client
+          module Requests
+            class BaseRequest
+
+              HTTP_METHOD = :get
+              HTTP_BASE_PATH = ''
+              HTTP_PATH = ''
+              HTTP_SUCCESS_CODE = 200
+
+              DEFAULT_PARAMETER_SEND_IN_VALUE = :query
+
+              PARAMETERS = [ ]
+
+              attr_accessor :client, :arguments, :options, :initial_arguments, :initial_options, :missing_required_arguments,
+                            :default_parameter_send_in_value, :processed_parameters, :initialized, :response
+
+              attr_writer :parameters, :path, :body, :query
+
+              def self.normalize_argument_hash_keys(hash)
+                return hash unless hash.is_a?(Hash)
+                Hash[ hash.dup.map { |k,v| [ normalize_parameter_name(k), v ] } ]
+              end
+
+              def self.normalize_parameter_name(name)
+                (name || '').respond_to?(:to_s) ? name.to_s.gsub('_', '').gsub('-', '').downcase : name
+              end
+
+              def self.process_parameter(param, args = { }, args_out = { }, missing_required_arguments = [ ], processed_parameters = { }, default_parameter_send_in_value = DEFAULT_PARAMETER_SEND_IN_VALUE, options = { })
+                args = normalize_argument_hash_keys(args) || { } if options.fetch(:normalize_argument_hash_keys, false)
+
+                _k = param.is_a?(Hash) ? param : { :name => param, :required => false, :send_in => default_parameter_send_in_value }
+                _k[:send_in] ||= default_parameter_send_in_value
+
+                proper_parameter_name = _k[:name]
+                param_name = normalize_parameter_name(proper_parameter_name)
+                arg_key = (has_key = args.has_key?(param_name)) ?
+                    param_name :
+                    ( (_k[:aliases] || [ ]).map { |a| normalize_parameter_name(a) }.find { |a| has_key = args.has_key?(a) } || param_name )
+
+                value = has_key ? args[arg_key] : _k[:default_value]
+                is_set = has_key || _k.has_key?(:default_value)
+
+                processed_parameters[proper_parameter_name] = _k.merge(:value => value, :is_set => is_set)
+
+                unless is_set
+                  missing_required_arguments << proper_parameter_name if _k[:required]
+                else
+                  args_out[proper_parameter_name] = value
+                end
+
+                { :arguments_out => args_out, :processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments }
+              rescue => e
+                raise e, "Error Processing Parameter: #{param.inspect} Args: #{args.inspect}. #{e.message}"
+              end
+
+              def self.process_parameters(params, args, options = { })
+                args = normalize_argument_hash_keys(args) || { }
+                args_out = options[:arguments_out] || { }
+                default_parameter_send_in_value = options[:default_parameter_send_in_value] || DEFAULT_PARAMETER_SEND_IN_VALUE
+                processed_parameters = options[:processed_parameters] || { }
+                missing_required_arguments = options[:missing_required_arguments] || [ ]
+
+                params.each do |param|
+                  process_parameter(param, args, args_out, missing_required_arguments, processed_parameters, default_parameter_send_in_value)
+                end
+                { :arguments_out => args_out, :processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments }
+              end
+
+              def initialize(args = { }, options = { })
+                @initial_arguments = args.dup
+                @initial_options = options.dup
+
+                @options = options.dup
+
+                initialize_attributes if options.fetch(:initialize_attributes, true)
+                after_initialize
+              end
+
+              def after_initialize
+                process_parameters if initialized
+              end
+
+              def initialize_attributes
+                @client = options[:client]
+                @missing_required_arguments = [ ]
+                @default_parameter_send_in_value = options[:default_parameter_send_in_value] || self.class::DEFAULT_PARAMETER_SEND_IN_VALUE
+                @processed_parameters = { }
+                @arguments = { }
+                @eval_http_path = options.fetch(:eval_http_path, true)
+                @base_path = options[:base_path]
+
+                @parameters = options[:parameters]
+                @http_method = options[:http_method]
+                @http_path = options[:http_path] ||= options[:path_raw]
+
+                @path = options[:path]
+                @path_arguments = nil
+                @path_only = nil
+
+                @query = options[:query]
+                @query_arguments = nil
+
+                @body = options[:body]
+                @body_arguments = nil
+
+                @response = nil
+
+                @http_success_code = options[:http_success_code] || HTTP_SUCCESS_CODE
+
+                @initialized = true
+              end
+              alias :reset_attributes :initialize_attributes
+
+              def process_parameters(params = parameters, args = @initial_arguments, _options = @options)
+                before_process_parameters unless _options.fetch(:skip_before_process_parameters, false)
+                self.class.process_parameters(params, args, _options.merge(:processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments, :default_parameter_send_in_value => default_parameter_send_in_value, :arguments_out => arguments))
+                after_process_parameters unless _options.fetch(:skip_after_process_parameters, false)
+              end
+
+              def before_process_parameters
+                # TO BE IMPLEMENTED IN CHILD CLASS
+              end
+              alias :pre_process_arguments :before_process_parameters
+
+              def after_process_parameters
+                # TO BE IMPLEMENTED IN CHILD CLASS
+              end
+              alias :post_process_arguments :after_process_parameters
+
+              # @!group Attribute Readers
+
+              def http_success_code
+                @http_success_code
+              end
+
+              def arguments
+                @arguments ||= { }
+              end
+
+              def base_path
+                @base_path ||= self.class::HTTP_BASE_PATH
+              end
+
+              def body_arguments
+                @body_arguments ||= arguments.dup.delete_if { |k,_| processed_parameters[k][:send_in] != :body }
+              end
+
+              def body
+                @body ||= body_arguments.empty? ? nil : body_arguments
+              end
+
+              def client
+                @client ||= options[:client]
+              end
+
+              def eval_http_path?
+                @eval_http_path
+              end
+
+              def http_path
+                @http_path ||= self.class::HTTP_PATH
+              end
+
+              def http_method
+                @http_method ||= self.class::HTTP_METHOD
+              end
+
+              def parameters
+                @parameters ||= self.class::PARAMETERS.dup
+              end
+
+              def relative_path
+                @relative_path ||= (path.start_with?('/') ? path[1..-1] : path)
+              end
+
+              # The URI Path
+              def path
+                @path ||= File.join(base_path, (eval_http_path? ? eval(%("#{http_path}"), binding, __FILE__, __LINE__) : http_path))
+              end
+
+              def path_arguments
+                @path_arguments ||= Hash[
+                    arguments.dup.delete_if { |k, _| processed_parameters[k][:send_in] != :path }.
+                        map { |k,v| [ k, CGI.escape(v.respond_to?(:to_s) ? v.to_s : '').gsub('+', '%20') ] }
+                ]
+              end
+
+              def query
+                @query ||= begin
+                  query_arguments.is_a?(Hash) ? query_arguments.map { |k,v| "#{CGI.escape(k.to_s).gsub('+', '%20')}=#{CGI.escape(v.respond_to?(:to_s) ? v.to_s : v).gsub('+', '%20')}" }.join('&') : query_arguments
+                end
+              end
+
+              def query_arguments
+                @query_arguments ||= arguments.dup.delete_if { |k,_| processed_parameters[k][:send_in] != :query }
+              end
+
+              def uri_request_path
+                [ path ].concat( [*query].delete_if { |v| v.respond_to?(:empty?) and v.empty? } ).join('?')
+              end
+
+              # @!endgroup
+
+              def to_batchable_request
+                _output = { :method => http_method.to_s.upcase, :resourcePath => relative_path }
+                _output[:payload] = body if (![:delete, :get, :options].include?(http_method) & body)
+                _output
+              end
+              alias :as_batchable_request :to_batchable_request
+
+              def to_batchable_request_as_json
+                #%({ "method": #{http_method.upcase}, "resourcePath": #{relative_path}#{(![:delete, :get].include?(http_method) && body) ? %(, "payload": { "body": #{body} }) : ''} })
+                to_batchable_request.to_json
+              end
+              alias :as_batchable_request_as_json :to_batchable_request_as_json
+
+              # def response
+              #   client.response if client
+              # end
+
+              def http_client
+                client.http_client
+              end
+
+              def http_response
+                @http_response ||= http_client.response.dup rescue nil
+              end
+
+              def execute
+                @response = http_client.call_method(http_method, { :path => relative_path, :query => query, :body => body }, options) if client
+              end
+
+              def success?
+                _response = http_response and ([*http_success_code].include?(http_response.code))
+                _response
+              end
+
+            end
+          end
+        end
+      end
+    end
+  end
+end