ubiquity-envoi 1.0.0

data/lib/ubiquity/envoi/api/client/http_client.rb

@@ -0,0 +1,282 @@
+require 'json'
+require 'net/https'
+
+module Ubiquity
+  module Envoi
+    module API
+      class Client
+
+        class HTTPClient
+
+          attr_accessor :logger, :http, :http_host_address, :http_host_port, :base_uri
+          attr_accessor :username, :password
+
+          attr_accessor :default_request_headers,
+                        :authorization_header_key, :authorization_header_value
+
+          attr_accessor :log_request_body, :log_response_body, :log_pretty_print_body
+
+          attr_accessor :request, :response
+
+          DEFAULT_HTTP_HOST_ADDRESS = 'localhost'
+          DEFAULT_HTTP_HOST_PORT    = 80
+
+          DEFAULT_BASE_PATH = '/api/'
+
+          DEFAULT_HEADER_CONTENT_TYPE = 'application/json; charset=utf-8'
+          DEFAULT_HEADER_ACCEPTS      = 'application/json'
+
+          def initialize(args = {})
+            args = args.dup
+            initialize_logger(args)
+            initialize_http(args)
+
+            logger.debug { "#{self.class.name}::#{__method__} Arguments: #{args.inspect}" }
+
+            @username = args[:api_key] || args[:username]
+            @password = args[:api_password] || args[:password]
+
+            @base_uri                   = args[:base_uri] || "http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}"
+            @default_base_path          = args[:default_base_path] || DEFAULT_BASE_PATH
+
+            # @user_agent_default = "#{@hostname}:#{@username} Ruby SDK Version #{Vidispine::VERSION}"
+
+            @authorization_header_key   ||= 'Authorization'
+            @authorization_header_value ||= %(Basic #{["#{username}:#{password}"].pack('m').delete("\r\n")})
+
+            content_type = args[:content_type_header] ||= DEFAULT_HEADER_CONTENT_TYPE
+            accepts      = args[:accepts_header] ||= args[:accept_header] || DEFAULT_HEADER_ACCEPTS
+
+            @default_request_headers = {
+                'Content-Type'           => content_type,
+                'Accept'                 => accepts,
+                authorization_header_key => authorization_header_value,
+            }
+
+            @log_request_body      = args.fetch(:log_request_body, true)
+            @log_response_body     = args.fetch(:log_response_body, true)
+            @log_pretty_print_body = args.fetch(:log_pretty_print_body, true)
+
+            @parse_response = args.fetch(:parse_response, true)
+          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(args = {})
+            @http_host_address = args[:http_host_address] ||= DEFAULT_HTTP_HOST_ADDRESS
+            @http_host_port    = args[:http_host_port] ||= DEFAULT_HTTP_HOST_PORT
+            @http = Net::HTTP.new(@http_host_address, @http_host_port)
+
+            use_ssl = args[:http_host_use_ssl]
+            @http.use_ssl = true if use_ssl
+
+            @http
+          end
+
+          # Formats a HTTPRequest or HTTPResponse body for log output.
+          # @param [HTTPRequest|HTTPResponse] obj
+          # @return [String]
+          def format_body_for_log_output(obj)
+            if obj.content_type == 'application/json'
+              if @log_pretty_print_body
+                _body = obj.body
+                output = JSON.pretty_generate(JSON.parse(_body)) rescue _body
+                return output
+              else
+                return obj.body
+              end
+            elsif obj.content_type == 'application/xml'
+              return obj.body
+            else
+              return obj.body.inspect
+            end
+          end
+
+          # @param [HTTPRequest] request
+          def send_request(request)
+            @response_parsed = nil
+            @request         = request
+            logger.debug { %(REQUEST: #{request.method} http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}#{request.path} HEADERS: #{request.to_hash.inspect} #{log_request_body and request.request_body_permitted? ? "\n-- BODY BEGIN --\n#{format_body_for_log_output(request)}\n-- BODY END --" : ''}) }
+
+            @response = http.request(request)
+            logger.debug { %(RESPONSE: #{response.inspect} HEADERS: #{response.to_hash.inspect} #{log_response_body and response.respond_to?(:body) ? "\n-- BODY BEGIN --\n#{format_body_for_log_output(response)}\n-- BODY END--" : ''}) }
+            #logger.debug { "Parse Response? #{@parse_response}" }
+            @parse_response ? response_parsed : response.body
+          end
+
+          def response_parsed
+            @response_parsed ||= begin
+              logger.debug { "Parsing Response. #{response.body.inspect}" }
+              case response.content_type
+                when 'application/json'
+                  JSON.parse(response.body) # rescue response
+                else
+                  response.body
+              end
+            end
+          end
+
+          # @param [String] path
+          # @param [Hash|String|Nil] query
+          # @return [URI]
+          def build_uri(path = '', query = nil)
+            _query = query.is_a?(Hash) ? query.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.respond_to?(:to_s) ? v.to_s : v)}" }.join('&') : query
+            _path  = "#{path}#{_query and _query.respond_to?(:empty?) and !_query.empty? ? "?#{_query}" : ''}"
+            URI.parse(File.join(base_uri, @default_base_path, _path))
+          end
+
+          if RUBY_VERSION.start_with? '1.8.'
+            def request_method_name_to_class_name(method_name)
+              method_name.to_s.capitalize
+            end
+          else
+            def request_method_name_to_class_name(method_name)
+              method_name.to_s.capitalize.to_sym
+            end
+          end
+
+          # @param [Symbol] method_name (:get)
+          # @param [Hash] args
+          # @option args [Hash] :headers ({})
+          # @option args [String] :path ('')
+          # @option args [Hash] :query ({})
+          # @option args [Any] :body (nil)
+          # @param [Hash] options
+          # @option options [Hash] :default_request_headers (@default_request_headers)
+          def call_method(method_name = :get, args = {}, options = {})
+            headers                  = args[:headers] || options[:headers] || {}
+            path                     = args[:path] || ''
+            query                    = args[:query] || {}
+            body                     = args[:body]
+
+            # Allow the default request headers to be overridden
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers)
+            _default_request_headers ||= {}
+            _headers                 = _default_request_headers.merge(headers)
+
+            @uri       = build_uri(path, query)
+            klass_name = request_method_name_to_class_name(method_name)
+            klass      = Net::HTTP.const_get(klass_name)
+
+            request = klass.new(@uri.request_uri, _headers)
+
+            if request.request_body_permitted?
+              _body = (body and !body.is_a?(String)) ? JSON.generate(body) : body
+              logger.debug { "Processing Body: '#{_body}'" }
+              request.body = _body if _body
+            end
+
+            send_request(request)
+          end
+
+          def delete(path, options = {})
+            query     = options.fetch(:query, {})
+            # base_path = options[:base_path] || @default_base_path
+            # _path = File.join(base_path, path)
+            @uri      = build_uri(path, query)
+            request   = Net::HTTP::Delete.new(@uri.request_uri, default_request_headers)
+            send_request(request)
+          end
+
+          def get(path, options = {})
+            # Allow the default request headers to be overridden
+            headers                  = options[:headers] || {}
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || {}
+            _headers                 = _default_request_headers.merge(headers)
+
+            query     ||= options.fetch(:query, {})
+            # base_path = options[:base_path] || @default_base_path
+            # _path = File.join(base_path, path)
+            @uri      = build_uri(path, query)
+            request   = Net::HTTP::Get.new(@uri.request_uri, _headers)
+            send_request(request)
+          end
+
+          def head(path, options = {})
+            # Allow the default request headers to be overridden
+            headers                  = options[:headers] || {}
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || {}
+            _headers                 = _default_request_headers.merge(headers)
+
+            query     ||= options.fetch(:query, {})
+            # base_path = options[:base_path] || @default_base_path
+            # _path = File.join(base_path, path)
+            @uri      = build_uri(path, query)
+
+            request = Net::HTTP::Head.new(@uri.request_uri, _headers)
+            send_request(request)
+          end
+
+          def options(path, options = {})
+            # Allow the default request headers to be overridden
+            headers                  = options[:headers] || {}
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || {}
+            _headers                 = _default_request_headers.merge(headers)
+
+            query     ||= options.fetch(:query, {})
+            # base_path = options[:base_path] || @default_base_path
+            # _path = File.join(base_path, path)
+            @uri      = build_uri(path, query)
+            request   = Net::HTTP::Options.new(@uri.request_uri, _headers)
+            send_request(request)
+          end
+
+          def put(path, body, options = {})
+            # Allow the default request headers to be overridden
+            headers                  = options[:headers] || {}
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || {}
+            _headers                 = _default_request_headers.merge(headers)
+
+            query        = options.fetch(:query, {})
+            # base_path    = options[:base_path] || @default_base_path
+            # _path = File.join(base_path, path)
+            @uri         = build_uri(path, query)
+            request      = Net::HTTP::Put.new(@uri.request_uri, _headers)
+
+            body         = JSON.generate(body) if body and !body.is_a?(String)
+
+            request.body = body if body
+            send_request(request)
+          end
+
+          def post(path, body, options = {})
+            # Allow the default request headers to be overridden
+            headers                  = options[:headers] || {}
+            _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || {}
+            _headers                 = _default_request_headers.merge(headers)
+
+            query        = options.fetch(:query, {})
+            # base_path    = options[:base_path] || @default_base_path
+            # _path = File.join(base_path, path)
+            @uri         = build_uri(path, query)
+
+            request      = Net::HTTP::Post.new(@uri.request_uri, _headers)
+
+            body         = JSON.generate(body) if body and !body.is_a?(String)
+
+            request.body = body if body
+            send_request(request)
+          end
+
+          # HTTPClient
+        end
+
+        # Client
+      end
+
+      # API
+    end
+
+    # Envoi
+  end
+
+  # Ubiquity
+end

data/lib/ubiquity/envoi/api/client/paginator.rb

@@ -0,0 +1,143 @@
+class Ubiquity::Envoi::API::Client::Paginator
+
+  attr_accessor :api_client, :logger
+
+  def initialize(api_client, options = { })
+    @api_client = api_client
+    initialize_logger(options)
+  end
+
+  def initialize_logger(args = {})
+    @logger   = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+    log_level = args[:log_level]
+    if log_level
+      _logger = @logger.dup
+      _logger.level = log_level
+      @logger = _logger
+    end
+    @logger
+  end
+
+  def current_page
+    @current_page ||= last_response['page']
+  end
+
+  def http_client
+    api_client.http_client
+  end
+
+  def include_remaining_pages
+    # response = api_client.response.dup
+    @first_page = current_page
+    _results = last_results
+    _results.concat(remaining_pages_get)
+    _per_page = _results.length
+    last_response.merge({ 'page' => @first_page, 'perPage' => _per_page, 'results' => _results })
+  end
+
+  def last_response
+    @last_response ||= api_client.http_client.response_parsed
+  end
+
+  def last_results
+    @last_results ||= last_response['results']
+  end
+
+  def next_page?
+    current_page < total_pages
+  end
+
+  def next_page_get(_next_page_number = nil)
+    _next_page_number ||= next_page_number
+    page_get(_next_page_number)
+  end
+
+  def next_page_number
+    @next_page_number ||= current_page + 1
+  end
+
+  def page_size
+    @page_size ||= last_response['perPage']
+  end
+
+  def page_get(page_number)
+    logger.debug { "Getting Page #{page_number} of #{total_pages}" }
+    new_request = request.class.new(request_args_out.merge('_page' => page_number), request_options_out)
+    _response = new_request.execute
+    process_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 paginated?
+    @paginated = !!total_results
+  end
+
+  def process_request
+    @current_page = nil
+    @total_results = nil
+    @has_next_page = nill
+  end
+
+  def process_response
+    @current_page = nil
+    @last_response = nil
+    @next_page_number = nil
+    @page_size = nil
+    @total_pages = nil
+    @total_results = nil
+    @paginated = !!total_results
+
+    @last_results = last_response['results']
+  end
+
+  def 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 total_pages
+    @total_pages ||= begin
+      logger.debug { "Page Size: #{page_size}" }
+      logger.debug { "Total Results: #{total_results}" }
+
+      div = total_results / page_size
+      mod = total_results % page_size
+      remainder = div == mod ? 0 : 1
+      _total_pages = div + remainder
+      logger.debug { "Total Pages: #{_total_pages}" }
+      _total_pages
+    end
+  end
+
+  def total_results
+    @total_results ||= last_response['total']
+  end
+
+  def remaining_pages_get
+    return [ ] unless paginated? && next_page?
+    remaining_results = [ ]
+
+    loop do
+      response = next_page_get
+      remaining_results.concat(response)
+
+      break unless next_page?
+    end
+    remaining_results
+  end
+
+end

data/lib/ubiquity/envoi/api/client/requests.rb

@@ -0,0 +1,7 @@
+require 'ubiquity/envoi/api/client/requests/base_request'
+
+require 'ubiquity/envoi/api/client/requests/media_file_create'
+require 'ubiquity/envoi/api/client/requests/media_file_add_file'
+require 'ubiquity/envoi/api/client/requests/media_file_update'
+
+

data/lib/ubiquity/envoi/api/client/requests/base_request.rb

@@ -0,0 +1,245 @@
+require 'cgi'
+
+module Ubiquity
+  module Envoi
+    module API
+      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]
+              @http_success_code = options[:http_success_code] || HTTP_SUCCESS_CODE
+
+              @path = options[:path]
+              @path_arguments = nil
+              @path_only = nil
+
+              @query = options[:query]
+              @query_arguments = nil
+
+              @body = options[:body]
+              @body_arguments = nil
+
+              @response = nil
+
+
+              @relative_path = nil
+
+              @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_arguments.empty? ? @body : body_arguments
+
+              _body = @body
+              _body_arguments = body_arguments
+              return _body unless _body_arguments
+              if _body.is_a?(Hash) && _body_arguments.is_a?(Hash)
+                return _body.merge(_body_arguments)
+              end
+              _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 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