oeh-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f692b3e09448980d130c5b6f9b031c4238211fe
+  data.tar.gz: 085a267a6504f505244e725b9081f49976f6fe35
+SHA512:
+  metadata.gz: 92571201066617e1bc99fed7bdd627b708a91b6253d82eefc90eb399db8527aab8b7dcc4f5ccceaa24805fc6d0a075e850a0d1e7767346a3ac31483ee14c19e8
+  data.tar.gz: 3b02be0c9729a14531c489b267552ebe8f816ba66707b7c540524d918007905ae52ebf4880413c69a0a3f332c74c22af1bad412ed94ac5262364c5932711a018

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.10.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oeh-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jason Balliet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# OEHClient
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/oehclient`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'oeh-client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install oeh-client
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/oeh-client. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "oeh-client"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/oeh-client.rb

@@ -0,0 +1,2 @@
+# More logical way to require 'rest-client'
+require File.dirname(__FILE__) + '/oehclient'

data/lib/oeh_client.rb

@@ -0,0 +1,2 @@
+# More logical way to require 'rest-client'
+require File.dirname(__FILE__) + '/oehclient'

data/lib/oehclient/config/space.rb

@@ -0,0 +1,59 @@
+class OEHClient::Config::Space
+
+	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
+
+
+	# ---- 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))
+
+		# 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}#{OEHClient::Helper::Request::THUNDERHEAD_DOMAIN}",
+												:scheme => :header})
+		# return the access token
+		return(OAuth::AccessToken.new(oauth_consumer))
+
+	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
+
+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,55 @@
+
+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
+
+	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,75 @@
+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?(:sk) && parameters.has_key?(:api))
+
+				# set the values
+				customer_key 	= parameters[:ck] 
+				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::Helper::Response.handle(OEHClient.get(@space.token,
+								OEHClient::Helper::Request.format_url(self.request_url(api_name), {:sk => @space.site_key, :ck => customer_key})))
+				# dynamically map the response object to a new OEHClient::Data::Structure class
+				OEHClient::Data::Structure.new(response)
+
+			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::THUNDERHEAD_DOMAIN}#{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 token is detected as part of the client-side API calls
+		class InvalidTokenException < ::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,66 @@
+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"
+
+			# 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' , 'Content-Type' =>'application/json', 'X-Requested-With' => 'XMLHttpRequest' }
+			end
+
+
+		end  # module Request
+
+		module Response
+
+			def self.handle(api_response)
+
+				# raise a generic HTTPRequestException if the the status code is not 100 (Continue) or 200 (OK)
+				raise OEHClient::Exception::HTTPRequestException.new(api_response.message, api_response.code) if (api_response.code != "200" && api_response.code != "100")
+				
+				begin
+					# Return the Body of the response for valid requests
+					ActiveSupport::JSON.decode(api_response.body)
+				rescue ActiveSupport::JSON.parse_error
+					# otherwise raise a standard processing exception
+					raise OEHClient::Exception::HTTPRequestException(api.body, 500)
+				end
+
+
+			end
+
+		end # module Response
+
+	end
+
+end

data/lib/oehclient/interaction/interaction.rb

@@ -0,0 +1,286 @@
+
+class OEHClient::Interaction::Interaction
+
+	# 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_TRACKERS		= "trackers"
+	ONE_RESPONSE_CAPTURES		= "captures"
+	
+
+	attr_accessor 	:uri, 					# The full touchpoint/interaction URI used to post the interaction
+					:space, 				# The configured OEHClient::Config::Space object that represents the
+	
+					:timestamp, 			# A millisecond value representing a Time value of the interaction					
+					: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
+
+					:errors					
+
+	###
+	### -------------  Class Methods
+	###
+	class << self
+
+		# post
+		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 => timestamp)		if (!timestamp.nil? && !timestamp.empty?)
+			attributes.merge!(:tid => tid)					if (!tid.nil? && !tid.empty?)
+			attributes.merge!(:ck => customer_key)			if (!customer_key.nil? && !customer_key.empty?)
+
+
+			# create a new interaction using all attributes pass
+			new_interaction = OEHClient::Interaction::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::Interaction::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?)
+			attributes.merge!(:ck => customer_key)			if (!customer_key.nil? && !customer_key.empty?)
+
+			# create a new interaction using all parameters pass
+			new_interaction = OEHClient::Interaction::Interaction.new(attributes)
+			# send the update and return the current object
+			new_interaction.send_update(properties)
+
+		end
+
+	end
+
+	###
+	### -------------  Instance Methods
+	###
+
+	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))
+			@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 		= 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={})
+
+		# call the appropriate method based on the existance of the timestamp value
+		((minimal_parameters? && !@timestamp.nil? && @timestamp > 0) ? send_offline(@space.token) : send_realtime(@space.token, 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::Interaction::Interaction class
+	def send_new(uri, timestamp=nil, 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 = OHEClient::Interaction::Interaction.new({
+														:uri => uri,
+														:ck => @customer_key,
+														:tid => @tid,
+														:session => @session,
+														:sk => @space.site_key,
+														: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={}) 
+
+		# 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 
+		OEHClient::Helper::Response.handle(OEHClient.put(@space.token(), 
+														OEHClient::Helper::Request.format_url(realtime_url, {:sk => @space.site_key}),
+														nil,
+														request_data(properties))) unless properties.empty?
+		# return the current object
+		self
+
+	end
+
+
+	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(token, parameters={})
+
+		response = OEHClient::Helper::Response.handle(OEHClient.post(token, 
+																	OEHClient::Helper::Request.format_url(realtime_url, {:sk => @space.site_key}),
+																	nil,
+																	request_data(parameters))
+													)
+
+		map_response(response)
+
+
+	end
+
+	# send_offline posts a historic interaction, using a specified timestamp
+	def send_offline(token)
+
+		response = OHEClient::Helper::Response.handle(OEHClient.put(token,
+																	OEHClient::Helper::Request.format_url(offline_url, {:sk => @space.site_key}),
+																	nil,
+																	request_data))
+		map_response(response)
+
+
+	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)
+
+
+		# Save the tid and session data if they where not previously used in the request
+		@tid 			= response[ONE_PARAM_TID] 		if (@tid.nil? || (!@tid.blank? && @tid != response[ONE_PARAM_TID]))
+		@session 		= response[ONE_PARAM_SESSION] 	if @session.nil?
+
+		# capture the optimizations returned from the request and map it to the OEHClient::Interaction::Optimization
+		#  class
+
+		# initialize the optimizations collection if it is null
+		@optimizations ||= Array.new
+		# map each of the optimizations to the OEHClient::Interaction::Optmization class
+		response[ONE_RESPONSE_OPTIMIZATIONS].each do | response_optimization |
+			@optimizations << OEHClient::Interaction::Optimization.create(response_optimization)
+		end
+
+		# capture the trackers returned from the request and mpt it to the OEHClient::Interaction::Tracker 
+		# class
+		# TODO:  Create OEHClient::Interaction::Tracker class
+		@trackers 		= response[ONE_RESPONSE_TRACKERS]
+
+		# capture the capture points returned from the request and map it to the OEHClient::Interaction::Capture 
+		# class
+		# TODO:  Create OEHClient::Interaction::Capture class
+		@captures 		= response[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? && !@site_key.nil?
+	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::THUNDERHEAD_DOMAIN}#{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!({ONE_PARAM_CK => @customer_key}) 	if (!@customer_key.nil? && @customer_key.length > 0)
+		parameters.merge!({ONE_PARAM_TID => @tid}) 			if (!@tid.nil? && @tid.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}
+		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/interaction/optimization.rb

@@ -0,0 +1,52 @@
+require 'base64'
+require 'cgi'
+
+class OEHClient::Interaction::Optimization
+
+	# HASH keys based on the response data
+	OPT_RESPONSE_DATA 			= "data"
+	OPT_RESPONSE_PATH			= "path"
+	OPT_RESPONSE_ID 			= "responseId"
+	OPT_RESPONSE_MIME_TYPE 		= "dataMimeType"
+	OPT_RESPONSE_DIRECTIVES 	= "directives"
+
+	# Localized attributes equivalent to the returned Hash object in the response
+	attr_accessor 	:data, 							# Base64 Encoded Asset returned by OEH
+					:path, 							# The path of the optimization based on the OEH Configuration
+					:response_id, 					# The Response ID of the asset based on the OEH Configuration
+					:mime_type, 					# The MIME Type of the asset based on the OEH Configuration
+					:directives
+
+
+	# ---- Class Methods 
+
+	def self.create(properties={})
+
+		# create a new instance of the OEHClient::Interaction::Optimization class
+		optimization_instance = OEHClient::Interaction::Optimization.new()
+
+		# assign all data attributes based on the properties object that is passed
+		optimization_instance.data 			= properties[OPT_RESPONSE_DATA] 		if (properties.has_key?(OPT_RESPONSE_DATA))
+		optimization_instance.path 			= properties[OPT_RESPONSE_PATH] 		if (properties.has_key?(OPT_RESPONSE_PATH))
+		optimization_instance.response_id 	= properties[OPT_RESPONSE_ID]			if (properties.has_key?(OPT_RESPONSE_ID))
+		optimization_instance.mime_type 	= properties[OPT_RESPONSE_MIME_TYPE]	if (properties.has_key?(OPT_RESPONSE_ID))
+		optimization_instance.directives 	= properties[OPT_RESPONSE_DIRECTIVES]	if (properties.has_key?(OPT_RESPONSE_DIRECTIVES))
+
+		#return the new instance of the optimzation class
+		optimization_instance
+
+	end
+
+	# ---- Instance Methods 
+
+	# TODO:  Need to create a series of methods that properly decodes the object based on Mime Type
+	# decodes the Base64 encoded data and returns it raw form
+	def decode_data()
+
+
+		CGI.unescapeHTML(Base64.decode64(@data.to_json))
+
+	end
+
+
+end

data/lib/oehclient/interaction.rb

@@ -0,0 +1,9 @@
+module OEHClient
+
+	module Interaction
+	end
+
+end
+
+require File.dirname(__FILE__) + '/interaction/interaction'
+require File.dirname(__FILE__) + '/interaction/optimization'

data/lib/oehclient/version.rb

@@ -0,0 +1,3 @@
+module OEHClient
+  VERSION = "0.1.0"
+end

data/lib/oehclient.rb

@@ -0,0 +1,81 @@
+require 'oauth'
+require 'csv'
+require 'uuidtools'
+require 'json'
+require 'active_support'
+
+require File.dirname(__FILE__) + '/oehclient/helper'
+require File.dirname(__FILE__) + '/oehclient/exception'
+require File.dirname(__FILE__) + '/oehclient/config'
+
+require File.dirname(__FILE__) + '/oehclient/interaction'
+require File.dirname(__FILE__) + '/oehclient/data'
+
+
+
+module OEHClient
+
+	class << self
+
+		attr_accessor :spaces, :space_mgr
+
+		# configure provides the basic interface for passing tenancy configuration to the gem
+		def configure_space
+
+			# if space_mgr attribute is NIL then return a new instance of the OEHClient::Config::SpaceManager
+			#  singleton class
+			@space_mgr ||= OEHClient::Config::SpaceManager.instance
+			# yield control to the block passed in the configuration
+			yield(@space_mgr)
+
+		end
+
+		# get wraps the GET method of the access token and manages the response that is returned
+		def get(token, url, header={})
+
+			# force the new hash.  Testing in RSPEC uncovered issue with the default not being followed
+			header ||= Hash.new
+
+			# if the token is not a proper OAuth::AccessToken, then raise the Oeh::Exception::InvalidTokenException
+			#  exception to the calling method
+			raise OEHClient::Exception::InvalidTokenException unless (token.kind_of?(OAuth::AccessToken))
+			# send the GET request, manage the returned response, and return the body of the response to the
+			#   calling method
+			token.get(url, header.empty? ? OEHClient::Helper::Request.default_JSON_header() : header)
+
+		end
+
+		# post wraps the POST method of the access token and manages the response that is returned
+		def post(token, url, header={}, body)
+
+			# force the new hash.  Testing in RSPEC uncovered issue with the default not being followed
+			header ||= Hash.new
+
+			# if the token is not a proper OAuth::AccessToken, then raise the Oeh::Exception::InvalidTokenException
+			#  exception to the calling method
+			raise OEHClient::Exception::InvalidTokenException unless (token.kind_of?(OAuth::AccessToken))
+			# send the POST request, manage the returned response, and return the body of the response to the
+			#   calling method
+			token.post(url, ActiveSupport::JSON.encode(body), header.empty? ? OEHClient::Helper::Request.default_JSON_header() : header)
+
+
+		end
+
+		# put wraps the PUT method of the access token and manages the response that is returned
+		def put(token, url, header={}, body)
+
+			# force the new hash.  Testing in RSPEC uncovered issue with the default not being followed
+			header ||= Hash.new
+
+			# if the token is not a proper OAuth::AccessToken, then raise the Oeh::Exception::InvalidTokenException
+			#  exception to the calling method
+			raise OEHClient::Exception::InvalidTokenException unless (token.kind_of?(OAuth::AccessToken))
+			# send the PUT request, manage the returned response, and return the body of the response to the
+			#   calling method
+			token.put(url, ActiveSupport::JSON.encode(body), header.empty? ? OEHClient::Helper::Request.default_JSON_header() : header)
+
+		end
+	
+	end
+
+end

data/oeh-client.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'oehclient/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "oeh-client"
+  spec.version       = OEHClient::VERSION
+  spec.authors       = ["Jason Balliet"]
+  spec.email         = ["jballiet@thunderhead.com"]
+
+  spec.summary       = %q{Simple class-based client for integration to ONE Engagement Hub}
+  spec.description   = %q{A simple set of classes that allow access to Interactions, Documents, and Structures from within Thunderhead's ONE Enagement Hub}
+  spec.homepage      = "https://rubygems.org/gems/oeh-client"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  #else
+  #  raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  #end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec-rails", "~> 3.2"
+
+  spec.add_dependency   "oauth"
+  spec.add_dependency   "json"
+  spec.add_dependency   "uuidtools"
+  spec.add_dependency   "activesupport", "~> 4.2.0"
+  spec.add_dependency   "railties", ">= 4.2.0"
+
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: oeh-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jason Balliet
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+description: A simple set of classes that allow access to Interactions, Documents,
+  and Structures from within Thunderhead's ONE Enagement Hub
+email:
+- jballiet@thunderhead.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/oeh-client.rb
+- lib/oeh_client.rb
+- lib/oehclient.rb
+- lib/oehclient/config.rb
+- lib/oehclient/config/space.rb
+- lib/oehclient/config/space_manager.rb
+- lib/oehclient/data.rb
+- lib/oehclient/data/node.rb
+- lib/oehclient/data/structure.rb
+- lib/oehclient/exception.rb
+- lib/oehclient/helper.rb
+- lib/oehclient/interaction.rb
+- lib/oehclient/interaction/interaction.rb
+- lib/oehclient/interaction/optimization.rb
+- lib/oehclient/version.rb
+- oeh-client-0.1.0.gem
+- oeh-client.gemspec
+homepage: https://rubygems.org/gems/oeh-client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Simple class-based client for integration to ONE Engagement Hub
+test_files: []