oeh-client 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4bec0ddd14a97b575b75493774289c2bba409a2d
-  data.tar.gz: 32090d1adabc23a2dffe22e92cc1f57feeaa3bcb
+  metadata.gz: 3f7b97eb02dc3346e3cf60404722416dbb25e92b
+  data.tar.gz: eb3ed9815faf0bd3387507a2d5b676e9fbb5fd8e
 SHA512:
-  metadata.gz: a477d4f83d54c24268550567fb1582060c065e30efd2e5b976e98d743c7db79522d721c4505446ff7226d2e512eff031ccf2e02c22dbd32de81ae35ea77abedd
-  data.tar.gz: 997695f476c2f872011288d98803d05a0fa93a3c45c562a49721fea33701fcb99d93602e93df32f56fc27e2e164eebdc219c5e904c2e2ff7f04da9bbb686ac30
+  metadata.gz: c8f7d75978c452397fa719598ac5b3a1e730f8f75531272ef71a2ff529487894524da0b4d33aea4aeb5c4b8e7f4988fb3df925432086b86edf7854431e984e1e
+  data.tar.gz: efc1479d6c157534cbb49cfcab6ee8cc54fa2194f32f23eb2eeff4a1b6f1a2c3f46de859ebf844e52c03afafbff16da45ad7ab49a19485b29596675aee4f5cbf

data/lib/oehclient/config/space.rb

@@ -0,0 +1,114 @@
+require 'erb'
+require 'rest-client'
+
+class OEHClient::Config::Space
+
+	###
+	### -------------  Constants
+	###
+
+
+	###
+	### -------------  Attributes
+	###
+
+	attr_accessor 	:site_key, 			# The ONE Site KEY Value
+					:host,				# The name of the HOST machine on thunderhead.com (ONEDEMO, EU2, NA4, etc..)
+					:api_key,			# The API key provided in the ONE SETTINGS interface
+					:shared_secret,		# The shared secret value provided in the ONE SETTINGS interface
+					:username,			# The fully-qualified username configured for access to the space
+					:meta_password,		# The password needed to access meta-data from the OEH server
+					:workspace 			# The ONE workspace related to the current space
+
+	###
+	### -------------  Class Methods
+	###
+
+
+	# create builds a new instance of the Site class, populats the attributes using the properties HASH provided
+	#  and returns an instance of the class.  
+	def self.create(properties={})
+
+		# create a new instance of the OHEClient::Space class
+		space_instance = OEHClient::Config::Space.new()
+
+		# assign all attributes from the passed properties hash
+		space_instance.site_key 		= properties[:site_key]			if (properties.has_key?(:site_key))
+		space_instance.host 			= properties[:host]				if (properties.has_key?(:host))
+		space_instance.api_key 			= properties[:api_key]			if (properties.has_key?(:api_key))
+		space_instance.shared_secret 	= properties[:shared_secret]	if (properties.has_key?(:shared_secret))
+		space_instance.username			= properties[:username]			if (properties.has_key?(:username))
+		space_instance.meta_password 	= properties[:meta_password] 	if (properties.has_key?(:meta_password))
+
+		# return the instance of the OEHClient::Site Class
+		space_instance
+
+	end
+
+
+	###
+	### -------------  Instance Methods
+	###
+
+
+	# token is the method used to generate a new OAuth::AccessToken object based on the configuration of
+	#  the related space
+	def token()
+
+		# raise the OEHClient::InvalidSpaceException the current instance is not valid
+		raise OEHClient::Exception::InvalidSpaceConfigException unless is_valid?
+		
+		# Create the consumer and access token 
+		oauth_consumer = OAuth::Consumer.new("#{@api_key}!#{@username}", 
+											@shared_secret,
+											{:site => "#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@host}",
+												:scheme => :header})
+		# return the access token
+		return(OAuth::AccessToken.new(oauth_consumer))
+
+	end
+	# return a new instance of the OAuth::Consumer using the details of the space
+	def oauth_consumer()
+		OAuth::Consumer.new("#{@api_key}!#{@username}", 
+											@shared_secret,
+											{:site => "#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@host}",
+												:scheme => :header})
+	end
+
+	# is_valid determines if the current class has values for all the attributes.  Each attribute is
+	# required with a non-nul / non-blank value to be considered valid
+	def is_valid?()
+		((!@site_key.nil? && !@site_key.empty?) && (!@host.nil? && !@host.empty?) && 
+		(!@api_key.nil? && !@api_key.empty?) && (!@shared_secret.nil? && !@shared_secret.empty?) && 
+		(!@username.nil? && !@username.empty?))
+	end
+
+	# determines if the space configuration appears to be valid for access to the raw meta-data entities.
+	# The method expects the standard valid attributes from is_valid? as well as the meta_password 
+	# attribute
+	def meta_access?()
+		self.is_valid? && (!@meta_password.blank?)
+	end
+
+	# return the hash that 
+	def meta_credentials()
+		{:username => @username, :password => @meta_password, :rememberMe => "false"}
+	end # def meta_credentials
+	# return the URL for the posting a login request
+	def login_url()
+		"#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@host}/one/idm_login"
+	end # def login_url
+	# return the URL for posting a logout request
+	def logout_url()
+		"#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@host}/one/logout"
+	end
+
+	# retrieve the workspace meta-data object from the thinstance in realtime
+	def get_workspace()
+		# create an active session with ONE 
+		workspace = OEHClient::Meta::Session.attach(self).workspace(site_key) 	if (workspace.nil?)
+		# return the active workspace object
+		workspace
+	end
+
+end

data/lib/oehclient/config/space_manager.rb

@@ -0,0 +1,55 @@
+require 'singleton'
+
+class OEHClient::Config::SpaceManager
+	include Singleton
+
+
+	attr_accessor :spaces
+
+	# Constructor.  Initialize the spaces collection as a new hash
+	def initialize
+		@spaces 	= Hash.new
+	end
+
+	# register_space is a wrapper method that converts the passed Hash object to an instance of the 
+	#  OEHClient::Config::Space object, which is passed to the register method
+	def register_space(space_config={})
+
+		# Pass a new instance of the space object to the register_space method
+		register(OEHClient::Config::Space.create(space_config))
+
+	end
+
+	# get_space returns the instance of the OEHClient::Config::Space
+	def get(site_key)
+
+		# raise the OEHClient::Exception::InvalidSpaceException if the space has not been registered
+		raise OEHClient::Exception::InvalidSpaceException unless (@spaces.has_key?(site_key))
+
+		# return the space configuration instance
+		@spaces[site_key]
+
+	end
+
+	private
+
+	# register adds the instance of the OEHClient::Config::Space object to the spaces hash, using the 
+	#  site_key value as the hash KEY
+	def register(space_instance)
+
+		# Raise OEHClient::Exception::InvalidSpaceException if the space instance is NOT valie
+		raise OEHClient::Exception::InvalidSpaceConfigException unless (space_instance.is_valid?)
+		# Raise the OEHClient::Exception::InvalidSpaceObjectException if the space_instance object is not
+		#  the proper type of object (OEHClient::Config::Space)
+		raise OEHClient::Exception::InvalidSpaceObjectException unless (space_instance.kind_of?(OEHClient::Config::Space))
+
+		# Assign the space instance to the spaces collection
+		@spaces[space_instance.site_key] = space_instance 
+
+	end
+
+
+
+
+
+end

data/lib/oehclient/config.rb

@@ -0,0 +1,11 @@
+
+module OEHClient
+
+	module Config
+	end
+
+end
+
+require File.dirname(__FILE__) + '/config/space'
+require File.dirname(__FILE__) + '/config/space_manager'
+

data/lib/oehclient/data/node.rb

@@ -0,0 +1,66 @@
+
+class OEHClient::Data::Node
+
+	attr_accessor :nodes
+
+	def initialize(data)
+
+		# Raise an exception if the data passed is not already a hash
+
+		# based on the type of object that is passed, create the proper attribute accessor
+		#  to allow easy access to data.  For example, a simple value in the structure called
+		#  firstName will be represented in the object as my_structure.first_name.  Simple
+		#  object are represented as related node classes.  For example a Preference node with
+		#  an attribute of nonSmokingRoom will be represented as my_structure.preference.non_smoking_room
+		data.each do | key, value |
+			(value.kind_of?(Array) ? add_collection(key, value) : add_attribute(key, value))
+		end
+
+	end
+
+	# return the names of each of the attributes of the current nodes of the structure
+	def attribute_names()
+		name_collection = Array.new
+		instance_variable_names.each do | structure_attribute | 
+			structure_attribute.slice!(0)
+			name_collection << structure_attribute
+		end
+		name_collection
+	end # def attribute_names
+
+
+	private 
+
+	# add_collection dynamically create an attr_accessor as an array of Oeh::Structure::Node
+	#  classes related to the current instance of the object. 
+	def add_collection(name, value_collection)
+
+		# initialize the array object that will act as the value of the attribute
+		node_collection = []
+
+		# for each hash in the array, add a new structure node 
+		value_collection.each do | structure_node | 
+			node_collection << OEHClient::Data::Structure.new(structure_node)
+		end
+		# add the arry of node objects to the accessor
+		add_attribute(name, node_collection)
+
+	end
+
+	# add_attribute dynamically creates an attr_accessor for the passed key_value pair either 
+	#  as a simple value attribute or as an instance of another Node class
+	def add_attribute(name, value)
+		
+		# generate a ruby-friendly attribute accessor based on the name of the 
+		#  structure attribute
+		accessor_name = name.underscore
+		accessor_name.gsub!(/( )/, '_') if (accessor_name.match(/\s/))
+		# create the accessor in the current class and set the value based on the type
+		#  of object that represents the value
+		self.class.send(:attr_accessor, accessor_name)
+		instance_variable_set("@#{accessor_name}", (value.kind_of?(Hash) ? OEHClient::Data::Node.new(value) : value))
+
+	end		
+
+
+end

data/lib/oehclient/data/structure.rb

@@ -0,0 +1,82 @@
+class OEHClient::Data::Structure < OEHClient::Data::Node
+
+	API_PROFILES = "/profiles"
+
+	LABEL_CUSTOMER_KEY 	= "Customer Key"
+	LABEL_SITE_KEY 		= "Site Key"
+	LABEL_API_NAME 		= "API Name"
+
+	#
+	# Class Methods
+	#
+
+	# fetch makes the request to OEH for the structure and returns an instance of the structure
+	#  based on the data in the configured structure
+	def self.fetch(parameters={})
+
+		# force the parameters empty hash if needed
+		parameters ||= Hash.new
+
+		# validate the parameters.  The implementation expects a Hash object
+		if (!parameters.empty?)
+			# implementation expects a Hash that contains the Customer Key (:ck), 
+			#  Site Key (:sk), and API Name (:api) because they are required to get 
+			#  structure from OEH
+			if ((parameters.has_key?(:ck) || parameters.has_key?(:tid)) && parameters.has_key?(:sk) && parameters.has_key?(:api))
+
+				oeh_params 		= {:sk => parameters[:sk]}
+
+				# set the values based on passed parameters
+				oeh_params.merge!({:ck => parameters[:ck]})				if (parameters.has_key?(:ck))
+				oeh_params.merge!({:keyname => parameters[:keyname]})	if (parameters.has_key?(:keyname))
+				oeh_params.merge!({:tid => parameters[:tid]})			if (parameters.has_key?(:tid))
+
+				# grab the API Name
+				api_name 		= parameters[:api]
+
+				# set the space based on the site key value that was passed
+				@space 			= OEHClient::Config::SpaceManager.instance.get(parameters[:sk])		if (parameters.has_key?(:sk))
+
+				# Use the OEHClient object to call OEH profiles API and create an instance
+				#  of this class (OEHClient::Data::Structure) as the return value
+				response = OEHClient.get(self.request_url(api_name),
+											@space.oauth_consumer, 
+											:params => oeh_params)
+				# dynamically map the response object to a new OEHClient::Data::Structure class
+				OEHClient::Data::Structure.new(response[:body])
+
+			else
+
+				# If the calling application passed a parameter Hash, but is missing key attributes,
+				#  raise the Oeh::Exception::MissingParameterException with the name of each 
+				#  parameter 
+				missing_parameters = []
+
+				missing_parameters << LABEL_CUSTOMER_KEY 	unless (parameters.has_key?(:ck))
+				missing_parameters << LABEL_SITE_KEY 		unless (parameters.has_key?(:sk))
+				missing_parameters << LABEL_API_NAME		unless (parameters.has_key?(:api))
+
+				# raise the OEHClient::Exception::MIssingParameterException using the list of missing parameter
+				# labels that have been added to the collection
+				raise OEHClient::Exception::MissingParameterException.new(missing_parameters)
+
+			end
+
+		else
+
+			# if the parameters object is NIL then raise the OEHClient::Exception::MissingParameterException,
+			#  passing the full set of expected parameter names
+			raise OEHClient::Exception::MissingParameterException.new([LABEL_CUSTOMER_KEY, LABEL_SITE_KEY, LABEL_API_NAME])
+					
+		end
+
+
+	end
+
+	# request_url returns the fully-qualified URL to return a given structure
+	def self.request_url(api_name)
+		"#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@space.host}#{OEHClient::Helper::Request::ONE_URI_PART}#{OEHClient::Helper::Request::API_URI_PART}#{OEHClient::Helper::Request::API_VERSION}#{API_PROFILES}/#{api_name}"
+	end
+
+
+end

data/lib/oehclient/data.rb

@@ -0,0 +1,10 @@
+
+module OEHClient
+
+	module Data
+	end
+
+end
+
+require File.dirname(__FILE__) + '/data/node'
+require File.dirname(__FILE__) + '/data/structure'

data/lib/oehclient/exception.rb

@@ -0,0 +1,64 @@
+module OEHClient
+
+	module Exception
+
+		# Used when an invalid OAuth consumer is detected as part of the client-side API calls
+		class InvalidConsumerException < ::Exception
+
+		end
+
+		# InvalidSpaceConfigException is used when a OEHClient::Space instance is missing one or more
+		#  of the key data attributes
+		class InvalidSpaceConfigException < ::Exception
+
+		end
+
+		# InvalidSpaceException is used when a space is not configured
+		class InvalidSpaceException < ::Exception
+
+		end
+
+		# InvalideSpaceObjectException is used when a method expects a OEHClient::Config::Space object and
+		#  the object passed is not of the same type
+		class InvalidSpaceObjectException < ::Exception
+
+		end
+
+		# HTTPRequestException is used to manage any REST error code that is returned by the OEH
+		#  server
+		class HTTPRequestException < ::Exception
+
+			attr_accessor :http_code
+
+			# override the constructor to add the code value to exception class
+			def initialize(msg, code)
+				super(msg)
+				@http_code = code
+			end
+			
+		end
+
+		# Missing ParameterException is used to identify the list of parameters that are required, but missing
+		#  by a key method 
+		class MissingParameterException < ::Exception
+
+			def initialize(parameter_list)
+
+				super("Missing the required parameters #{parameter_list.join(', ')}")
+			end
+			
+		end
+
+		class IncorrectParameterTypeException < ::Exception
+
+
+			def initialize(expected_kind, passed_kind)
+
+				super("Incorrect Parameter Type.  Expected #{expected_kind} but received #{passed_kind}")
+			end
+			
+		end
+
+	end
+
+end

data/lib/oehclient/helper.rb

@@ -0,0 +1,97 @@
+require 'erb'
+
+module OEHClient
+
+	module Helper
+
+		module Request
+
+			ONE_PROTOCOL 			= "https://"
+			THUNDERHEAD_DOMAIN 		= ".thunderhead.com"
+			ONE_URI_PART 			= "/one/oauth1"
+
+			API_URI_PART 			= "/rt/api"
+			API_VERSION 			= "/2.0"
+
+			POST_METHOD				= "post"
+			PUT_METHOD				= "put"
+
+			# request_url builds the target request URL with the passed parameters, URL encoding the parameters
+			#  as necessary to create a valid request
+			def self.format_url(url, params)
+
+				# for each of the parameters, build a single query parameter string
+				parameter_part = ""
+				params.each do |key, value|
+					# if there is more than one argument, add the apppropriate separator (&) between 
+					#  query parameters
+					parameter_part << "&" if (parameter_part.length > 0)
+					# URL Encode the value of the property
+					parameter_part << "#{key.to_s}=#{ERB::Util.url_encode(value)}"
+
+				end
+				# return the fully-qualified URL with parameters (if passsed)
+				(parameter_part.length > 0 ? "#{url}?#{parameter_part}" : "#{url}")
+
+			end
+
+			# default_JSON_header is the default header that is passed to any OEH Request if not provided explicitly by the 
+			#  calling methods
+			def self.default_JSON_header()
+				{'Accept' => 'application/json' , 'dataMimeType' => 'application/json','Content-Type' =>'application/json', 'X-Requested-With' => 'XMLHttpRequest' }
+			end
+
+
+		end  # module Request
+
+		module Response
+
+			# determine if the string that was passed is valid JSON syntax and can be parsed by the the 
+			# ActiveSupport::JSON.decode method
+			def self.valid_json?(json)
+  				valid_indicator = true
+  				begin
+    				ActiveSupport::JSON.decode(json)
+  				rescue ActiveSupport::JSON.parse_error
+    				valid_indicator = false
+  				end
+  			end
+
+
+			def self.handle(rest_response)
+
+				valid_response_codes = [100, 200, 204, 302]
+				# raise a generic HTTPRequestException if the the status code is not 100 (Continue) or 200 (OK)
+				raise OEHClient::Exception::HTTPRequestException.new("HTTP Request Exception with code #{rest_response.code} -- details: #{rest_response.body}", rest_response.code) unless (valid_response_codes.include?(rest_response.code))
+
+				api_response = Hash.new
+
+				api_response[:body] 	= (rest_response.code == 204 ? {} : (OEHClient::Helper::Response.valid_json?(rest_response.body) ? ActiveSupport::JSON.decode(rest_response.body) : rest_response.body))
+				api_response[:cookies] 	= rest_response.cookies
+
+				api_response
+
+			end
+
+		end # module Response
+
+
+		module Timestamp
+
+			# convert the time value from a Time, DateTime, String, or Integer to a proper ONE timestamp value
+			# format (UTC Milliseconds)
+			def self.to_one_timestamp(timevalue)
+
+				one_timestamp = timevalue												if (timevalue.is_a?(Integer))
+				one_timestamp = timevalue.utc.strftime("%s%L").to_i 					if (timevalue.is_a?(Time) || timevalue.is_a?(DateTime))
+				one_timestamp = Time.parse(timevalue).utc.strftime("%s%L").to_i 		if (timevalue.is_a?(String))
+
+				one_timestamp
+
+			end
+
+		end
+
+	end
+
+end

data/lib/oehclient/meta/entity.rb

@@ -0,0 +1,97 @@
+module OEHClient::Meta::Entity
+
+	###
+	### -------------  Constants
+	###
+
+	ONE_PARAM_DATA 				= "data"
+	ONE_PARAM_SUCCESS			= "success"
+	ONE_PARAM_ID				= "id"
+	ONE_PARAM_NAME				= "name"
+	ONE_PARAM_CREATED_ON		= "createdDate"
+	ONE_PARAM_CREATED_BY 		= "createdBy"
+
+	ONE_PARAM_ITEMS				= "items"
+
+	###
+	### -------------  Class Attributes 
+	###
+
+	def entity_uri_stem=(uri_stem)
+		@entity_stem = uri_stem
+	end
+
+	def entity_uri_stem
+		@entity_stem
+	end
+
+	def session=(session_instance)
+		@session = session_instance
+	end
+
+	def session
+		@session
+	end
+
+	###
+	### -------------  Helper Class Methods
+	###
+
+	def create()
+	end # def self.create
+
+	def find_by_name(active_session, name,  **args)
+		get(active_session, {:name => ONE_PARAM_NAME, :value => name}, args)
+	end
+
+	###
+	### -------------  Core Class Methods
+	###
+
+	def get_collection(active_session, **args)
+		# store the active session object for future use
+		self.session = active_session 	if (session.nil?)
+		# get the list of args
+		entity_uri = (args.has_key?(:space)) ? "workspaces/#{args[:space]}/#{entity_uri_stem}" : "#{entity_uri_stem}" 
+		# construct the URL for retrieving the entity
+		url = "#{OEHClient::Helper::Request::ONE_PROTOCOL}#{self.session.space.host}/one/services/api/#{entity_uri}"
+		# set the header information
+		header = (!self.session.cookies.nil? ? {:cookies => self.session.cookies}.merge!(OEHClient::Helper::Request.default_JSON_header()) : OEHClient::Helper::Request.default_JSON_header())
+		# construct the request params using the header and params (if passed)
+		request_params = {:header => header}
+		request_params.merge!({:params => args[:params]}) 		if (args.has_key?(:params))
+		# GET the data
+		collection_response = OEHClient.get(url, nil, request_params)
+		# return the data object for valid requests or a blank array otherwise
+		((collection_response.has_key?(:body) && collection_response[:body][ONE_PARAM_SUCCESS]) ? (collection_response[:body][ONE_PARAM_DATA].is_a?(Hash) ? collection_response[:body][ONE_PARAM_DATA][ONE_PARAM_ITEMS] : collection_response[:body][ONE_PARAM_DATA]) : [] )
+	end # def get_collection
+
+	def get(active_session, attribute_nvp, **args)
+		# store the active session object for future use
+		session = active_session 	if (session.nil?)
+		# initialize the entity instance as a blank hash
+		entity_instance = Hash.new
+		# Get the collection of objects requested
+		get_collection(session, **args).each do | collection_instance |
+			# find the matching entry and assign the entity instance
+			entity_instance = collection_instance if (collection_instance[attribute_nvp[:name]].casecmp(attribute_nvp[:value]) == 0)
+		end # Each OEHClient::Meta::Entity.get_collection
+		# return the copy of the entity instance data
+		entity_instance
+	end # def get
+
+	###
+	### -------------  Instance Attributes
+	###
+
+	###
+	### -------------  Instance Methods
+	###
+
+	###
+	### -------------  Protected Class Methods
+	###
+
+	protected 
+
+end

data/lib/oehclient/meta/interaction.rb

@@ -0,0 +1,14 @@
+class OEHClient::Meta::Interaction < OEHClient::Data::Node
+	include OEHClient::Meta::WorkspaceEntity
+
+	self.entity_uri_stem 	= "pageCfg/pages"
+
+
+	def self.create(workspace, data)
+		interaction_instance	 			= OEHClient::Meta::Interaction.new(data)
+		interaction_instance.workspace 	= workspace
+
+		interaction_instance
+	end
+
+end

data/lib/oehclient/meta/session.rb

@@ -0,0 +1,36 @@
+class OEHClient::Meta::Session
+
+	attr_accessor :cookies, :space
+
+	def self.attach(space)
+		# post the login request
+		response = OEHClient.post(space.login_url, nil, :payload => space.meta_credentials)
+		# create a new session object
+		session_instance = OEHClient::Meta::Session.new()
+		# assign the space object
+		session_instance.space 		= space
+		# store the cookies if they are returned in the response
+		session_instance.cookies 	= response[:cookies]  if (response.has_key?(:cookies))
+		# return the session instance
+		session_instance
+	end
+
+	def detach()
+		# construct a header object, merging cookies (if present) wit the default JSON header
+		header = Hash.new
+		header.merge!(:cookies => @cookies)								unless (@cookies.blank?)
+		header.merge!(OEHClient::Helper::Request.default_JSON_header)
+		# post the logout request
+		OEHClient.post(@space.logout_url, nil, :header => header)
+		# remove the cookies if the logout is posted successfully
+		@cookies = nil	
+	end
+
+	# retrieve the workspace meta-data object from the thinstance in realtime
+	def workspace(site_key)
+		# get the workspace object using the site key, the host value, and the exisitng cookies 
+		OEHClient::Meta::Workspace.find_by_key(self, site_key)
+	end
+
+
+end