ubiquity-iconik 1.1.0

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

@@ -0,0 +1,2 @@
+require 'ubiquity/iconik/api/client/requests/base_request'
+

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

@@ -0,0 +1,270 @@
+require 'cgi'
+require 'uri'
+
+module Ubiquity
+  module Iconik
+    module API
+      class Client
+        module Requests
+
+          class BaseRequest
+
+            HTTP_METHOD = :get
+            HTTP_BASE_PATH = '/API/'
+            HTTP_PATH = ''
+            HTTP_SUCCESS_CODE = '200'
+
+            DEFAULT_PARAMETER_SEND_IN_VALUE = :body
+
+            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_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
+
+            # A method to expose parameter processing
+            #
+            # @param [Hash|Symbol] param The parameter to process
+            # @param [Hash] args ({ }) Arguments to possibly match to the parameter
+            # @param [Hash] args_out ({ }) The processed value of the parameter (if any)
+            # @param [Array] missing_required_arguments ([ ]) If the parameter was required and no argument found then it
+            # will be placed into this array
+            # @param [Hash] processed_parameters ({ }) The parameter will be placed into this array once processed
+            # @param [Symbol] default_parameter_send_in_value (DEFAULT_PARAMETER_SEND_IN_VALUE) The :send_in value that
+            # will be set if the :send_in key is not found
+            # @param [Hash] options
+            # @option options [True|False] :normalize_argument_hash_keys (false)
+            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 }
+            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
+
+              @query = options[:query]
+              @query_arguments = nil
+
+              @body = options[:body]
+              @body_arguments = nil
+
+              @relative_path = nil
+
+              @response = nil
+
+              @initialized = true
+            end
+
+            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
+
+            def after_process_parameters
+              # TO BE IMPLEMENTED IN CHILD CLASS
+            end
+
+            # @!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 logger
+              @logger ||= client.logger
+            end
+
+            def eval_http_path?
+              @eval_http_path
+            end
+
+            def http_path
+              @http_path ||= self.class::HTTP_PATH.dup
+            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 ||= begin
+                _path = File.join(base_path, (eval_http_path? ? eval(%("#{http_path}"), binding, __FILE__, __LINE__) : http_path))
+                _path.concat('/') if !_path.end_with?('/') && http_path.end_with?('/')
+                _path
+              end
+            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
+
+            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 => path, :query => query, :body => body }, options) if client
+            end
+
+            def success?
+              _response = client.http_client.response
+              _response && ( http_success_code.is_a?(Array) ?
+                  http_success_code.include?(_response.code) :
+                  http_success_code == _response.code )
+            end
+
+            # @!endgroup
+
+          end
+
+          # Requests
+        end
+
+        # Client
+      end
+
+      # API
+    end
+
+    # Iconik
+  end
+
+  # Ubiquity
+end

data/lib/ubiquity/iconik/api/utilities.rb

@@ -0,0 +1,174 @@
+require 'ubiquity/iconik/api/client'
+
+module Ubiquity
+  module Iconik
+    module API
+      class Utilities < Client
+
+        # Converts hash keys to symbols
+        #
+        # @param [Hash] value hash
+        # @param [Boolean] recursive Will recurse into any values that are hashes or arrays
+        def symbolize_keys (value, recursive = true)
+          case value
+          when Hash
+            new_val = {}
+            value.each { |k, v|
+              k          = (k.to_sym rescue k)
+              v          = symbolize_keys(v, true) if recursive and (v.is_a? Hash or v.is_a? Array)
+              new_val[k] = v
+            }
+            return new_val
+          when Array
+            return value.map { |v| symbolize_keys(v, true) }
+          else
+            return value
+          end
+        end
+
+        # @param [Object]  args
+        # @option args [Boolean] :create_keyframes (true)
+        # @option args [String] :file_path
+        # @option args [Numeric|String] :file_size (1024)
+        # @option args [String] :file_status ('CLOSED')
+        # @option args [Hash] :metadata
+        # @option args [String] :storage_id
+        # @param [Object]  options
+        # @return [Hash]
+        def asset_add_using_file_path(args = {}, options = {})
+          _args     = symbolize_keys(args, false)
+
+          create_keyframes = _args.fetch(:create_keyframes, true)
+
+          file_path = _args[:file_path]
+          raise ArgumentError, ':file_path is a required argument.' unless file_path
+
+          file_dir  = File.dirname(file_path)
+          if file_dir == '.'
+            file_dir = ''
+          elsif file_dir.start_with?('./')
+            file_dir = file_dir[2..-1]
+          elsif file_dir.start_with?('/')
+            file_dir = file_dir[1..-1]
+          end
+
+          file_name = File.basename(file_path)
+
+          file_size = _args[:file_size] || 1024
+          file_type = 'FILE'
+          metadata  = _args[:metadata]
+
+          # Determine Storage
+          storage_id = _args[:storage_id]
+          raise ArgumentError, ':storage_id is a required argument.' unless storage_id
+
+          asset_id = _args[:asset_id]
+          unless asset_id
+            # Create Asset
+            asset_create_args = {
+                :title => file_name
+            }
+            asset             = asset_create(asset_create_args)
+            asset_id          = asset['id']
+            raise 'Error Creating Asset.' unless asset_id
+          end
+
+
+          format_id = _args[:format_id]
+          unless format_id
+            # Create Asset Format
+            asset_format_create_args = {
+                :asset_id => asset_id
+            }
+            format                   = asset_format_create(asset_format_create_args)
+            format_id                = format['id']
+            raise 'Error Creating Format.' unless format_id
+          end
+
+          file_set_id = _args[:file_set_id]
+          unless file_set_id
+            # Create Asset File Set
+            asset_file_set_create_args = {
+                :asset_id      => asset_id,
+                :storage_id    => storage_id,
+                :format_id     => format_id,
+
+                :name          => file_name,
+                :base_dir      => file_dir,
+                :component_ids => [],
+            }
+            file_set                   = asset_file_set_create(asset_file_set_create_args)
+            file_set_id                = file_set['id']
+            raise 'Error Creating File Set.' unless file_set_id
+          end
+
+          # Create Asset File
+          file_status                 = _args[:file_status] || 'CLOSED'
+          file_create_and_modify_time = Time.now.to_s
+          asset_file_create_args      = {
+              :asset_id           => asset_id,
+              :storage_id         => storage_id,
+              :format_id          => format_id,
+              :file_set_id        => file_set_id,
+
+              :name               => file_name,
+              :original_name      => file_name,
+              :directory_path     => file_dir,
+              :size               => file_size,
+              :type               => file_type,
+              :status             => file_status,
+
+              :file_date_created  => file_create_and_modify_time,
+              :file_date_modified => file_create_and_modify_time,
+
+              :metadata           => {},
+          }
+          file                        = asset_file_create(asset_file_create_args)
+          file_id                     = file['id'] if file.is_a?(Hash)
+          raise "Error Creating File. #{file}" unless file && file_id
+
+          asset_file_keyframes_create(:asset_id => asset_id, :file_id => file_id) if create_keyframes
+
+          if metadata
+            unless metadata.empty?
+              metadata[:asset_id] = asset_id
+              metadata_set        = asset_metadata_set(metadata)
+            end
+          end
+
+          { :asset => asset, :format => format, :file_set => file_set, :file => file, :metadata_set => metadata_set }
+        end
+
+        # @param [Object]  args
+        # @param [Object]  options
+        # @return [Hash]
+        def asset_metadata_set_extended(args = {}, options = {})
+          _args           = symbolize_keys(args, false)
+          asset_id        = _args[:asset_id]
+          default_view_id = _args[:view_id]
+          metadata        = _args[:metadata]
+
+          responses = {}
+          metadata.each do |view|
+            values_out = {}
+            view_id    = view['id'] || view[:id] || default_view_id
+            values     = view['metadata_values'] || view[:metadata_values]
+            values.echo do |k, v|
+              values_out[k] = { :field_values => [v] }
+            end
+            args_out           = {
+                :asset_id        => asset_id,
+                :view_id         => view_id,
+                :metadata_values => values_out
+            }
+            r                  = asset_metadata_set(args_out, options)
+            responses[view_id] = r
+          end
+
+          { :responses => responses }
+        end
+
+      end
+    end
+  end
+end

data/lib/ubiquity/iconik/version.rb

@@ -0,0 +1,5 @@
+module Ubiquity
+  module Iconik
+    VERSION = '1.1.0'
+  end
+end