oeh-client 2.2.2 → 2.2.3

data/lib/oehclient/meta/touchpoint.rb

@@ -0,0 +1,36 @@
+class OEHClient::Meta::Touchpoint < OEHClient::Data::Node
+	include OEHClient::Meta::WorkspaceEntity
+
+	# tell the workspace entity module how to reference within ONE
+	self.entity_uri_stem 	= "touchpoints"
+
+	# create a new instance of the class using the data set and assig the workspace
+	def self.create(workspace, data)
+		# create from the past data structure
+		touchpoint_instance	 			= OEHClient::Meta::Touchpoint.new(data)
+		# assign the local workspace object
+		touchpoint_instance.workspace 	= workspace
+		# return the instance
+		touchpoint_instance
+	end # self.create
+
+	# retrieve the full collection of touchpoints from the curent workspace
+	def interactions()
+		# initialize the collection array
+		interaction_collection 	= Array.new
+		# retrieve the collection from ONE using the workspace reference and current touchpoint
+		OEHClient::Meta::Interaction.get_collection(self.class.session, space: workspace.id, params: {:site => id}).each do | interaction_item |
+			# create the instance of the interaction and add it to the collection
+			interaction_collection << OEHClient::Meta::Interaction.create(workspace, interaction_item)
+		end
+		# return the collection to calling process
+		interaction_collection
+	end # end def interactions
+
+	# retrieve a single touchpoint from the current workspace based on the name
+	def interaction(interaction_name)
+		# create and return the instance of an interaction based on the name, current workspace, and current touchpoint
+		OEHClient::Meta::Interaction.create(workspace, OEHClient::Meta::Interaction.find_by_name(self.class.session, interaction_name, space: workspace.id, params: {:site => id}))
+	end # def interaction
+
+end # class OEHClient::Meta::Touchpoint

data/lib/oehclient/meta/workspace.rb

@@ -0,0 +1,58 @@
+class OEHClient::Meta::Workspace < OEHClient::Data::Node
+	extend OEHClient::Meta::Entity
+
+	# set the ONE entity URI Stem for workspace requests
+	self.entity_uri_stem 			= "workspaces"
+
+	###
+	### -------------  Constants
+	###
+
+	ONE_WORKSPACE_SITE_KEY			= "siteKey"
+
+
+	###
+	### -------------  Attributes
+	###
+					
+	###
+	### -------------  Class Methods
+	###
+
+	def self.find_by_key(active_session, site_key, **args)
+		# default the workspace instance NIL
+		workspace_instance = nil
+		# get the list of workspaces from the thinstance
+		workspace_data = get(active_session, {:name => ONE_WORKSPACE_SITE_KEY, :value => site_key}, **args)
+		unless (workspace_data.blank?)
+			# convert the the workspace instance into a NEW instance of the OEHClient::Meta::Workspace instance
+			workspace_instance = OEHClient::Meta::Workspace.new(workspace_data)
+			# set the session object
+		#	workspace_instance.session = session
+			# return the workspace instance 
+			workspace_instance
+		end # unless workspace_data.blank?
+	end # def self.find_by_key
+
+
+	###
+	### -------------  Instance Methods
+	###
+
+	# retrieve the full collection of touchpoints from the curent workspace
+	def touchpoints()
+		touchpoint_collection 	= Array.new
+		OEHClient::Meta::Touchpoint.get_collection(self.class.session, space: id).each do | touchpoint_item |
+			touchpoint_collection << OEHClient::Meta::Touchpoint.create(self, touchpoint_item)
+		end
+		touchpoint_collection
+	end
+
+	# retrieve a single touchpoint from the current workspace based on the name
+	def touchpoint(touchpoint_name)
+		OEHClient::Meta::Touchpoint.create(self, OEHClient::Meta::Touchpoint.find_by_name(self.class.session, touchpoint_name, space: id))
+	end 
+
+
+
+end

data/lib/oehclient/meta/workspace_entity.rb

@@ -0,0 +1,13 @@
+module OEHClient::Meta::WorkspaceEntity
+	
+	def self.included base
+		base.send :include, InstanceMethods
+		base.send :extend, OEHClient::Meta::Entity
+	end
+
+	module InstanceMethods
+		
+		attr_accessor :workspace
+	end
+
+end

data/lib/oehclient/meta.rb

@@ -0,0 +1,14 @@
+
+module OEHClient
+
+	module Meta
+	end
+
+end
+
+require File.dirname(__FILE__) + '/meta/entity'
+require File.dirname(__FILE__) + '/meta/workspace_entity'
+require File.dirname(__FILE__) + '/meta/session'
+require File.dirname(__FILE__) + '/meta/workspace'
+require File.dirname(__FILE__) + '/meta/touchpoint'
+require File.dirname(__FILE__) + '/meta/interaction'

data/lib/oehclient/realtime/event.rb

@@ -0,0 +1,114 @@
+require 'base64'
+
+class OEHClient::Realtime::Event
+
+	URI_RT_TRACK_PART 		= "one/rt/track"
+	URI_EVENTS				= "events"
+	# ONE attributes that are either in the request and/or returned in the response
+	ONE_PARAM_URI 			= "uri"
+	ONE_PARAM_TID 			= "tid"
+	ONE_PARAM_PROPERTIES	= "properties"
+	# Property Hash Keys
+	ONE_PROPERTIES_NAME		= "name"
+	ONE_PROPERTIES_VALUE	= "value"
+
+	#
+	# -------[ CLASS ATTRIBUTES ]
+	#
+
+	attr_accessor 	:uri, 					# The full touchpoint/interaction URI used to post the interaction
+					:space, 				# The configured OEHClient::Config::Space object that represents the OEH workspace
+					:tid 					# The Thunderhead ID (TID) to which this interaction is related
+
+
+	# class-level wrapper to post a new interaction to the OEH server using either the realtime or offline 
+	# API for an anonymous or known prospects/customer
+	def self.post(site_key, uri, properties={})
+
+		# setup the baseline attributes hash with the site_key and interaction URI, which are the 
+		#  minimal values needed for an interaction
+		attributes = {:sk => site_key,:uri => uri}
+
+		# create a new interaction using all attributes pass
+		new_event = OEHClient::Realtime::Event.new(attributes)
+		# Send the interaction for processing and return the instance of the interaction class
+		new_event.send(properties)
+
+	end
+
+	#
+	# -------[ INSTANCE METHODS ]
+	#
+
+	# constructor that allows the passed Ruby Hash to be mapped to the 
+	def initialize(attributes=nil)
+
+		# set the instance attributes is the parameter hash is created
+		if (!attributes.nil? && attributes.kind_of?(Hash))
+
+			@uri 			= attributes[:uri] 															if (attributes.has_key?(:uri))
+			@tid 			= attributes[:tid] 															if (attributes.has_key?(:tid))
+
+			@space 			= OEHClient::Config::SpaceManager.instance.get(attributes[:sk])				if (attributes.has_key?(:sk))
+
+		end
+
+	end
+
+	def send(properties={})
+
+		send_args 			= {:payload => ActiveSupport::JSON.encode(request_data(properties))}
+		send_args[:header] 	= properties[:header]  if (!properties.nil? && properties.has_key?(:header))
+
+		# send the POST or PUT methond along with the arguments to the OEHClient class
+		map_response(OEHClient.send(OEHClient::Helper::Request::POST_METHOD.to_sym, 
+						request_url,
+						nil,
+						send_args))
+
+		self		
+	end
+
+	private
+
+	def request_url
+		"#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@space.host}/#{OEHClient::Realtime::Event::URI_RT_TRACK_PART}/#{@space.site_key}/#{OEHClient::Realtime::Event::URI_EVENTS}"
+	end
+
+	# request_data creates a properly formatted Hash object that represents the body of the request needed
+	#  for POST and PUT operations
+	def request_data(passed_properties={})
+
+		# Initialize the parameters hash
+		parameters ||= Hash.new
+
+		# merge in the different parts of the request data if the values currently exist within
+		#  the instance of the class
+		parameters.merge!({ONE_PARAM_URI => @uri}) 				if (!@uri.nil? && @uri.length > 0)
+
+		# for each of the properties hash entry, build a name/value pair in the properties collection
+		properties = Array.new
+		# merge in the different parts of the request data if the values currently exist within
+		#  the instance of the class
+		passed_properties.each do | key, value |
+			properties << {ONE_PROPERTIES_NAME => key.to_s, ONE_PROPERTIES_VALUE => value} unless (key == :header)
+		end
+		# merge the properties (name / value) connections if there are additonal values to pass
+		parameters.merge!({ONE_PARAM_PROPERTIES => properties})		if (properties.length > 0)
+
+		# return the full parameter hash
+		return(parameters)
+
+	end
+
+	# map_response takes the attributes returned in an interaction response and maps it to exiting
+	#  attributes in the current instance of the interaction object
+	def map_response(response)
+
+		body 			= response[:body]
+
+		# Save the tid and session data if they where not previously used in the request
+		@tid 			= body[ONE_PARAM_TID] 		if (@tid.nil? || (!@tid.blank? && @tid != body[ONE_PARAM_TID]))
+
+	end
+end

data/lib/oehclient/realtime/interaction.rb

@@ -0,0 +1,355 @@
+require 'base64'
+
+class OEHClient::Realtime::Interaction
+
+	#
+	# -------[ CONSTANTS ]
+	#
+
+	# constants used to construct the restful API Request URL
+	API_REALTIME 					= "/interaction"
+	API_OFFLINE 					= "/offline"
+	# ONE attributes that are either in the request and/or returned in the response
+	ONE_PARAM_URI 					= "uri"
+	ONE_PARAM_CK					= "customerKey"
+	ONE_PARAM_TID 					= "tid"
+	ONE_PARAM_SESSION 				= "session"
+	ONE_PARAM_SK					= "sk"
+	ONE_PARAM_TS					= "timestamp"
+	ONE_PARAM_PROPERTIES			= "properties"
+	# Property Hash Keys
+	ONE_PROPERTIES_NAME				= "name"
+	ONE_PROPERTIES_VALUE			= "value"
+	# Collection objects returned in the response
+	ONE_RESPONSE_OPTIMIZATIONS 		= "optimizations"
+	ONE_RESPONSE_OPTIMIZATION_DATA 	= "data"
+	ONE_RESPONSE_ACTIONS			= "actions"
+	ONE_RESPONSE_TRACKERS			= "trackers"
+	ONE_RESPONSE_CAPTURES			= "captures"
+	
+
+	#
+	# -------[ CLASS ATTRIBUTES ]
+	#
+
+	attr_accessor 	:uri, 					# The full touchpoint/interaction URI used to post the interaction
+					:space, 				# The configured OEHClient::Config::Space object that represents the OEH workspace
+	
+					:timestamp, 			# A millisecond value representing a Time value of the interaction
+					:keyname,				# The customer keyname to use based on multi-key configuration.  Default is customerKey					
+					:customer_key, 			# The customer to which this interaction is related
+					:tid, 					# The Thunderhead ID (TID) to which this interaction is related
+					:session, 				# The session id to which this interaction is related
+
+					:optimizations,			# The collection of optimizations that are relevent for the interaction 
+					:trackers, 				# The collection of tracking point data that are relevant for the interaction
+					:captures, 				# The collection of capture point data that are relevant for the interactions
+
+					:cookies				# The JSON object of cookies returned within a ONE Request					
+
+	#
+	# -------[ CLASS METHODS ]
+	#
+
+	class << self
+
+		# class-level wrapper to post a new interaction to the OEH server using either the realtime or offline 
+		# API for an anonymous or known prospects/customer
+		def post(site_key, uri, timestamp=nil, tid=nil, customer_key=nil, properties={})
+
+			# setup the baseline attributes hash with the site_key and interaction URI, which are the 
+			#  minimal values needed for an interaction
+			attributes = {
+							:sk => site_key,
+							:uri => uri
+						 }
+
+			# conditionally merge the rest of the attributes if they are passed
+			attributes.merge!(:timestamp => OEHClient::Helper::Timestamp.to_one_timestamp(timestamp))		unless(timestamp.blank?)
+			attributes.merge!(:tid => tid)																	unless(timestamp.blank?)
+
+			if (customer_key.is_a?(Hash))
+				attributes.merge!(:ck => customer_key[:value])												if (customer_key.has_key?(:value))
+				attributes.merge!(:keyname => customer_key[:keyname])										if (customer_key.has_key?(:keyname))
+			else
+				attributes.merge!(:ck => customer_key)														unless(customer_key.blank?)
+			end
+
+
+
+			# create a new interaction using all attributes pass
+			new_interaction = OEHClient::Realtime::Interaction.new(attributes)
+			# Send the interaction for processing and return the instance of the interaction class
+			new_interaction.send(properties)
+
+		end
+
+		# class-level wrapper to create a new instance of the OEHClient::Realtime::Interaction class, call the
+		#  send_update method, and return the resulting instance of the same class
+		def update(site_key, uri, properties={}, tid=nil, customer_key=nil)
+
+			# setup the baseline attributes hash with the site_key and interaction URI, which are the 
+			#  minimal values needed for an interaction
+			attributes = {
+							:sk => site_key,
+							:uri => uri
+						 }
+
+			# conditionally merge the rest of the attributes if they are passed
+			attributes.merge!(:tid => tid)					if (!tid.nil? && !tid.empty?)
+
+			if (customer_key.is_a?(Hash))
+				attributes.merge!(:ck => customer_key[:value])												if (customer_key.has_key?(:value))
+				attributes.merge!(:keyname => customer_key[:keyname])										if (customer_key.has_key?(:keyname))
+			else
+				attributes.merge!(:ck => customer_key)														unless(customer_key.blank?)
+			end
+
+			# create a new interaction using all parameters pass
+			new_interaction = OEHClient::Realtime::Interaction.new(attributes)
+			# send the update and return the current object
+			new_interaction.send_update(properties)
+
+		end
+
+	end
+
+	#
+	# -------[ INSTANCE METHODS ]
+	#
+
+	# constructor that allows the passed Ruby Hash to be mapped to the 
+	def initialize(attributes=nil)
+
+		# set the instance attributes is the parameter hash is created
+		if (!attributes.nil? && attributes.kind_of?(Hash))
+
+			@uri 			= attributes[:uri] 															if (attributes.has_key?(:uri))
+			@keyname 		= attributes[:keyname]														if (attributes.has_key?(:keyname))
+			@customer_key 	= attributes[:ck] 															if (attributes.has_key?(:ck))
+			@tid 			= attributes[:tid] 															if (attributes.has_key?(:tid))
+			@session 		= attributes[:session]														if (attributes.has_key?(:session))
+			@timestamp 		= OEHClient::Helper::Timestamp.to_one_timestamp(attributes[:timestamp]) 	if (attributes.has_key?(:timestamp))
+
+			@space 			= OEHClient::Config::SpaceManager.instance.get(attributes[:sk])				if (attributes.has_key?(:sk))
+
+		end
+
+	end
+
+	# send() will post a new interaction using either the realtime (current timestamp) or the offline (historic)
+	#  API interface based on the existence of a timestamp value
+	def send(parameters={})
+		# raise the MissingParameterException when one (or more) of the miminal parameters are missing
+		raise OEHClient::Exception::MissingParameterException.new(missing_minimal_parameters) 	unless (minimal_parameters?)
+
+		# call the appropriate method based on the existance of the timestamp value
+		#((!@timestamp.nil?) ? send_offline(parameters) : send_realtime(parameters))
+		send_realtime(parameters)
+		# return the current instance interacton
+		self
+	end
+
+	# send_new posts a new interaction using the existing instance data, but for a different touchpoint 
+	#   URI.  The method returns a new instance of the OEHClient::Realtime::Interaction class
+	def send_new(uri, timestamp=nil, parameters={})
+		# raise the MissingParameterException when one (or more) of the miminal parameters are missing
+		raise OEHClient::Exception::MissingParameterException.new(missing_minimal_parameters) 	unless (minimal_parameters?)
+
+		# protect against NIL by creating a new Hash object if the parameters, for any reason is 
+		#  NIL
+		parameters ||= Hash.new
+
+		# create a new interaction using all parameters from the existing other than the new touchpoint
+		#  URI and timestamp of the current Interaction instance.  The method can be used to submit new
+		#  requests for the same customer, tid, & session
+		new_interaction = OEHClient::Realtime::Interaction.new({
+														:uri => uri,
+														:ck => @customer_key,
+														:tid => @tid,
+														:session => @session,
+														:sk => @space.site_key,
+														:timestamp => OEHClient::Helper::Timestamp.to_one_timestamp(timestamp)
+													})
+
+		# Send the interaction for processing and return the current instance
+		new_interaction.send(parameters)
+	end
+
+	# send_update allows the system to update the capture and tracking properties that are defined as 
+	#  part of the existing interaction
+	def send_update(properties={}) 
+		# raise the MissingParameterException when one (or more) of the miminal parameters are missing
+		raise OEHClient::Exception::MissingParameterException.new(missing_minimal_parameters) 	unless (minimal_parameters?)
+
+		# force the properties object to be an empty Hash if, for any reason, it is NIL
+		properties ||= Hash.new
+
+		# Call the PUT method to update the 
+		send_request(OEHClient::Helper::Request::PUT_METHOD, realtime_url, properties) unless properties.empty?
+
+		# return the current object
+		self
+	end
+
+
+	#
+	# -------[ PRIVATE METHODS ]
+	#
+
+	private
+
+
+	# send_realtime posts a new interaction occuring at the moment (in realtime).  The response attributes
+	#  are mapped to the current instance attributes for all valid requests
+	def send_realtime(properties={})
+		# Put timestamp in the header if it has been provides
+		properties[:header] = {'X-ONE-Timestamp' => @timestamp}.merge!(OEHClient::Helper::Request.default_JSON_header()) unless (@timestamp.nil?)
+		# POST the realtime interaction method
+		response = send_request(OEHClient::Helper::Request::POST_METHOD, realtime_url, properties)
+		# map the response message to the current instance attributes
+		map_response(response)
+	end
+
+	# send_offline posts a historic interaction, using a specified timestamp
+	def send_offline(properties={})
+		# PUT the offline interaction method
+		response = send_request(OEHClient::Helper::Request::PUT_METHOD, offline_url, properties)	
+		# map the response message to the current instance attributes
+		map_response(response)
+	end
+
+	# send_request acts as the wrapper to send all client requests to the ONE server in a unified manner
+	def send_request(method, url, properties={})
+		# set the URL parameters for the site_key and the tid, of the value exists
+		url_parameters = {:sk => @space.site_key}		
+		url_parameters.merge!({:tid => @tid})				unless (@tid.blank?)
+		#url_parameters.merge!({:timestamp => @timestamp})	unless (@timestamp.nil?)
+
+		send_args 			= {:params => url_parameters, :payload => ActiveSupport::JSON.encode(request_data(properties))}
+		send_args[:header] 	= properties[:header]  if (!properties.nil? && properties.has_key?(:header))
+
+		# send the POST or PUT methond along with the arguments to the OEHClient class
+		OEHClient.send(method.downcase.to_sym, 
+						url,
+						@space.oauth_consumer,
+						send_args)
+
+	end
+
+	# map_response takes the attributes returned in an interaction response and maps it to exiting
+	#  attributes in the current instance of the interaction object
+	def map_response(response)
+
+		body = response[:body]
+
+		# Save the tid and session data if they where not previously used in the request
+		@tid 			= body[ONE_PARAM_TID] 		if (@tid.nil? || (!@tid.blank? && @tid != body[ONE_PARAM_TID]))
+		@session 		= body[ONE_PARAM_SESSION] 	if @session.nil?
+
+		# capture the optimizations returned from the request and map it to the OEHClient::Realtime::Optimization
+		#  class
+
+		# initialize the optimizations collection if it is null
+		@optimizations ||= Array.new
+		# map each of the optimizations to the OEHClient::Realtime::Optmization class
+		body[ONE_RESPONSE_OPTIMIZATIONS].each do | response_optimization |
+			# decode the data of the optimization
+			optimization_data = ActiveSupport::JSON.decode(Base64.decode64(response_optimization[ONE_RESPONSE_OPTIMIZATION_DATA]))
+			# get the actions for each optimization
+			optimization_data[ONE_RESPONSE_ACTIONS].each do | one_action |
+				@optimizations << OEHClient::Realtime::Optimization.create(self, one_action)
+			end
+		end
+
+		# store the cookies passed back by the system
+		@cookies = response[:cookies]
+
+		# capture the trackers returned from the request and mpt it to the OEHClient::Realtime::Tracker 
+		# class
+		# TODO:  Create OEHClient::Realtime::Tracker class
+		@trackers 		= body[ONE_RESPONSE_TRACKERS]
+
+		# capture the capture points returned from the request and map it to the OEHClient::Realtime::Capture 
+		# class
+		# TODO:  Create OEHClient::Realtime::Capture class
+		@captures 		= body[ONE_RESPONSE_CAPTURES]
+
+
+
+	end
+
+	# minimal_parameters? determines if the minimal number of request parameters (uri & site_key) are 
+	#  present in the current instance of the interaction class. This is a helper method that is used
+	#  before making any request
+	def minimal_parameters?()
+		((!@uri.nil? && !@uri.empty?) && !@space.nil?)
+	end
+
+	# missing_minimal_parameters returns an array of the minimal attributes that are missing  from the current
+	#  instance of OEHClient::Realtime::Interaction class
+	def missing_minimal_parameters
+
+		missing_parameters = []
+
+		missing_parameters << "site_key"	if (!minimal_parameters? && @site_key.nil?)
+		missing_parameters << "uri"			if (!minimal_parameters? && @uri.nil?)
+
+		missing_parameters
+
+	end
+
+	# request_url returns the base of the request URL used to make either a realtime or offline request
+	#   through published API
+	def request_url()
+		"#{OEHClient::Helper::Request::ONE_PROTOCOL}#{@space.host}#{OEHClient::Helper::Request::ONE_URI_PART}#{OEHClient::Helper::Request::API_URI_PART}#{OEHClient::Helper::Request::API_VERSION}"
+	end
+
+	# realtime_url is the interaction part of the API URI 
+	def realtime_url()
+		"#{request_url}#{API_REALTIME}"
+	end
+
+	# offline_url appends the /offiline URI part to add support for historic data loading of interactions
+	def offline_url()
+		"#{realtime_url}#{API_OFFLINE}"
+	end
+
+	# request_data creates a properly formatted Hash object that represents the body of the request needed
+	#  for POST and PUT operations
+	def request_data(passed_properties={})
+
+		# protect agains a NIL value in the passed_properties Hash
+		passed_properties ||= Hash.new
+
+		# Initialize the parameters hash
+		parameters ||= Hash.new
+
+		# merge in the different parts of the request data if the values currently exist within
+		#  the instance of the class
+		parameters.merge!({ONE_PARAM_URI => @uri}) 				if (!@uri.nil? && @uri.length > 0)
+
+		parameters.merge!({"customerKeyName" => @keyname}) 		if (!@keyname.nil? && @keyname.length > 0)
+		parameters.merge!({"customerKey" => @customer_key}) 	if (!@customer_key.nil? && @customer_key.length > 0)
+
+
+		parameters.merge!({ONE_PARAM_SESSION => @session}) 		if (!@session.nil? && @session.length > 0)
+		#parameters.merge!({ONE_PARAM_TS => @timestamp}) 	if (!@timestamp.nil?)
+
+		# for each of the properties hash entry, build a name/value pair in the properties collection
+		properties = Array.new
+		passed_properties.each do | key, value |
+			properties << {ONE_PROPERTIES_NAME => key.to_s, ONE_PROPERTIES_VALUE => value} unless (key == :header)
+		end
+		# merge the properties (name / value) connections if there are additonal values to pass
+		parameters.merge!({ONE_PARAM_PROPERTIES => properties})		if (properties.length > 0)
+
+		# return the full parameter hash
+		return(parameters)
+
+	end
+
+
+
+
+end

data/lib/oehclient/realtime/optimization.rb

@@ -0,0 +1,55 @@
+require 'base64'
+require 'cgi'
+
+class OEHClient::Realtime::Optimization
+
+	# HASH keys based on the response data
+	OPT_RESPONSE_NAME			= "name"
+	OPT_RESPONSE_ASSET			= "asset"
+	OPT_RESPONSE_CONTENT		= "content"
+	OPT_RESPONSE_CONTENT_URL	= "contentUrl"
+	OPT_RESPONSE_MIME_TYPE 		= "mimeType"
+	OPT_RESPONSE_PROPOSITION 	= "proposition"
+	OPT_RESPONSE_RESPONSES		= "responses"
+
+	# Localized attributes equivalent to the returned Hash object in the response
+	attr_accessor 	:name,							# The name of the action
+					:content,						# The decoded content of the asset
+					:content_url,					# The URL to the referential asset
+					:mime_type,						# The MIME Type of the asset based on the OEH Configuration
+					:proposition,					# The code of the proposition, related to the optimization
+					:responses,						# The collection of responses valid for this optmization
+					:interaction 					# The parent interaction object
+
+	# ---- Class Methods 
+
+	def self.create(interaction, properties={})
+
+		one_asset = properties[OPT_RESPONSE_ASSET]
+
+		# create a new instance of the OEHClient::Realtime::Optimization class
+		optimization_instance = OEHClient::Realtime::Optimization.new()
+
+		# assign all data attributes based on the properties object that is passed
+		optimization_instance.name 			= properties[OPT_RESPONSE_NAME] 						if (properties.has_key?(OPT_RESPONSE_NAME))
+		optimization_instance.proposition	= properties[OPT_RESPONSE_PROPOSITION]					if (properties.has_key?(OPT_RESPONSE_PROPOSITION))
+		# map the asset data to the class instance variables
+		optimization_instance.content		= CGI.unescapeHTML(one_asset[OPT_RESPONSE_CONTENT])		if (one_asset.has_key?(OPT_RESPONSE_CONTENT))
+		optimization_instance.content_url	= one_asset[OPT_RESPONSE_CONTENT_URL] 					if (one_asset.has_key?(OPT_RESPONSE_CONTENT_URL))
+		optimization_instance.mime_type		= one_asset[OPT_RESPONSE_MIME_TYPE] 					if (one_asset.has_key?(OPT_RESPONSE_MIME_TYPE))
+		# map each of the respones to the response object
+		optimization_instance.responses ||= Array.new
+		one_asset[OPT_RESPONSE_RESPONSES].each do | asset_response |
+			optimization_instance.responses << OEHClient::Realtime::Response.create(optimization_instance, asset_response)
+		end
+		# set the parent interaction object
+		optimization_instance.interaction = interaction
+		#return the new instance of the optimzation class
+		optimization_instance
+
+	end
+
+	# ---- Instance Methods 
+
+
+end