queueit_knownuserv3 3.2.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZTZmYWVkMDlhZmY4NzIwYzBiYjkyMmY0Njg4YTlmYzMyYzczNzI4OQ==
+  data.tar.gz: !binary |-
+    NDE4OTVjYzEyZWJmOGIwMzkwMTFiYWU2Yzg5ZjRiOGMxNGE0ZmMwOA==
+SHA512:
+  metadata.gz: !binary |-
+    YWMzOGU1YTU2NDJjYTQwODJkMzdlNjBjNTU2Y2U2MTA3NWRkNmJmZTFhOGYy
+    MWIzYjY4Y2Q0ZTE1OTBjOTFkODM0NGJiMzIzZDRjNDc2ZTc3MDk2ODIwZmVi
+    YjJkN2QwZWIwODg5NzE0MDg5YmE5MDFlZTZhZWY1NWY3M2FkYTM=
+  data.tar.gz: !binary |-
+    NDQ1MjI5YmZiMDEwNGU3MTFkNWUxYjhhYTIyNjBhZmE5MGRmMmExODAwNWYw
+    NGZiMzM4NzYzN2YyYmEyYjc1YzAwZTc2OTNkZDdiYjg4Njc2YzlkNWI2OGE4
+    MjUwMWUyOTE2NGY2NjYyNWQxMzg1YTA0YjM5OTlmZTY0MDcxMWI=

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "queueit_knownuserv3"
+
+# 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,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/queueit_knownuserv3.rb

@@ -0,0 +1,9 @@
+require_relative "queueit_knownuserv3/known_user"
+require_relative "queueit_knownuserv3/models"
+require_relative "queueit_knownuserv3/queue_url_params"
+require_relative "queueit_knownuserv3/user_in_queue_state_cookie_repository"
+require_relative "queueit_knownuserv3/user_in_queue_service"
+require_relative "queueit_knownuserv3/integration_config_helpers"
+
+module QueueIt
+end

data/lib/queueit_knownuserv3/integration_config_helpers.rb

@@ -0,0 +1,265 @@
+require 'uri'
+
+module QueueIt
+	class IntegrationEvaluator
+		def getMatchedIntegrationConfig(customerIntegration, currentPageUrl, cookieList, userAgent)
+			if (!customerIntegration.kind_of?(Hash) || !customerIntegration.key?("Integrations") ||
+				!customerIntegration["Integrations"].kind_of?(Array))
+				return nil;
+			end
+			customerIntegration["Integrations"].each do |integrationConfig|
+				next if !integrationConfig.kind_of?(Hash) || !integrationConfig.key?("Triggers") || !integrationConfig["Triggers"].kind_of?(Array)
+			
+				integrationConfig["Triggers"].each do |trigger|
+					if(!trigger.kind_of?(Hash))
+						return false
+					end
+					if(evaluateTrigger(trigger, currentPageUrl, cookieList, userAgent))
+						return integrationConfig
+					end
+				end
+			end
+
+			return nil
+		end
+
+		def evaluateTrigger(trigger, currentPageUrl, cookieList, userAgent)
+			if (!trigger.key?("LogicalOperator") ||
+				!trigger.key?("TriggerParts") ||
+				!trigger["TriggerParts"].kind_of?(Array))
+				return false;
+			end
+		
+			if(trigger["LogicalOperator"].eql? "Or")
+				trigger["TriggerParts"].each do |triggerPart|
+					if(!triggerPart.kind_of?(Hash))
+						return false
+					end
+					if(evaluateTriggerPart(triggerPart, currentPageUrl, cookieList, userAgent))
+						return true
+					end
+				end
+				return false
+			else
+				trigger["TriggerParts"].each do |triggerPart|
+					if(!triggerPart.kind_of?(Hash))
+						return false
+					end
+					if(!evaluateTriggerPart(triggerPart, currentPageUrl, cookieList, userAgent))
+						return false
+					end
+				end
+				return true
+			end
+		end
+
+		def evaluateTriggerPart(triggerPart, currentPageUrl, cookieList, userAgent)
+			if (!triggerPart.key?("ValidatorType"))
+				return false
+			end
+
+			case triggerPart["ValidatorType"]
+				when "UrlValidator"
+					return UrlValidatorHelper.evaluate(triggerPart, currentPageUrl)
+				when "CookieValidator"
+					return CookieValidatorHelper.evaluate(triggerPart, cookieList)
+				when "UserAgentValidator"
+					return UserAgentValidatorHelper.evaluate(triggerPart, userAgent)
+				else
+					return false
+			end
+		end
+	end
+
+	class UrlValidatorHelper
+		def self.evaluate(triggerPart, url)
+			if (!triggerPart.key?("Operator") ||
+				!triggerPart.key?("IsNegative") ||
+				!triggerPart.key?("IsIgnoreCase") ||
+				!triggerPart.key?("ValueToCompare") ||
+				!triggerPart.key?("UrlPart"))
+				return false;
+			end
+
+			urlPart = UrlValidatorHelper.getUrlPart(triggerPart["UrlPart"], url)
+
+			return ComparisonOperatorHelper.evaluate(
+				triggerPart["Operator"], 
+				triggerPart["IsNegative"], 
+				triggerPart["IsIgnoreCase"], 
+				urlPart, 
+				triggerPart["ValueToCompare"])
+		end
+
+		def self.getUrlPart(urlPart, url)
+			begin
+				urlParts = URI.parse(url)		
+				case urlPart
+					when "PagePath"
+						return urlParts.path
+					when "PageUrl"
+						return url
+					when "HostName"
+						return urlParts.host
+					else
+						return ''
+				end
+			rescue
+				return ''
+			end
+		end
+	end
+
+	class CookieValidatorHelper
+		def self.evaluate(triggerPart, cookieList)
+			begin
+				if (!triggerPart.key?("Operator") ||
+					!triggerPart.key?("IsNegative") ||
+					!triggerPart.key?("IsIgnoreCase") ||
+					!triggerPart.key?("ValueToCompare") ||
+					!triggerPart.key?("CookieName"))
+					return false;
+				end
+
+				if(cookieList.nil?)
+					return false
+				end
+
+				cookieName = triggerPart["CookieName"]
+				cookieValue = ''
+				if(!cookieName.nil? && !cookieList[cookieName.to_sym].nil?)
+					cookieValue = cookieList[cookieName.to_sym]
+				end
+				return ComparisonOperatorHelper.evaluate(
+					triggerPart["Operator"], 
+					triggerPart["IsNegative"], 
+					triggerPart["IsIgnoreCase"], 
+					cookieValue, 
+					triggerPart["ValueToCompare"])
+			rescue
+				return false
+			end
+		end
+	end
+
+	class UserAgentValidatorHelper
+		def self.evaluate(triggerPart, userAgent)
+			begin
+				if (!triggerPart.key?("Operator") ||
+					!triggerPart.key?("IsNegative") ||
+					!triggerPart.key?("IsIgnoreCase") ||
+					!triggerPart.key?("ValueToCompare"))
+					return false;
+				end
+
+				return ComparisonOperatorHelper.evaluate(
+					triggerPart["Operator"], 
+					triggerPart["IsNegative"], 
+					triggerPart["IsIgnoreCase"], 
+					userAgent, 
+					triggerPart["ValueToCompare"])
+			end
+		end
+	end
+
+	class ComparisonOperatorHelper
+		def self.evaluate(opt, isNegative, ignoreCase, left, right)
+			if(left.nil?)
+				left = ''
+			end
+			if(right.nil?) 
+				right = ''
+			end
+
+			case opt		
+				when "Equals"
+					return ComparisonOperatorHelper.equals(left, right, isNegative, ignoreCase)
+				when "Contains" 
+					return ComparisonOperatorHelper.contains(left, right, isNegative, ignoreCase)
+				when "StartsWith"
+					return ComparisonOperatorHelper.startsWith(left, right, isNegative, ignoreCase)
+				when "EndsWith"
+					return ComparisonOperatorHelper.endsWith(left, right, isNegative, ignoreCase)
+				when "MatchesWith"
+					return ComparisonOperatorHelper.matchesWith(left, right, isNegative, ignoreCase)
+				else
+					return false
+			end
+		end
+
+		def self.equals(left, right, isNegative, ignoreCase)
+			if(ignoreCase)
+				evaluation = left.upcase.eql? right.upcase
+			else
+				evaluation = left.eql? right
+			end
+
+			if(isNegative)
+				return !evaluation
+			else
+				return evaluation
+			end
+		end
+
+		def self.contains(left, right, isNegative, ignoreCase)
+			if(right.eql? "*")
+				return true
+			end
+
+			if(ignoreCase)
+				left = left.upcase
+				right = right.upcase
+			end
+
+			evaluation = left.include? right
+			if(isNegative)
+				return !evaluation
+			else
+				return evaluation
+			end
+		end
+
+		def self.startsWith(left, right, isNegative, ignoreCase)
+			if(ignoreCase)
+				evaluation = left.upcase.start_with? right.upcase
+			else
+				evaluation = left.start_with? right
+			end
+
+			if(isNegative)
+				return !evaluation
+			else
+				return evaluation
+			end
+		end
+
+		def self.endsWith(left, right, isNegative, ignoreCase)
+			if(ignoreCase)
+				evaluation = left.upcase.end_with? right.upcase
+			else
+				evaluation = left.end_with? right
+			end
+
+			if(isNegative)
+				return !evaluation
+			else
+				return evaluation
+			end
+		end
+
+		def self.matchesWith(left, right, isNegative, ignoreCase)
+			if(ignoreCase)
+				pattern = Regexp.new(right, Regexp::IGNORECASE) 
+			else
+				pattern = Regexp.new(right)
+			end
+		
+			evaluation = pattern.match(left) != nil
+			if(isNegative)
+				return !evaluation
+			else
+				return evaluation
+			end
+		end
+	end
+end

data/lib/queueit_knownuserv3/known_user.rb

@@ -0,0 +1,310 @@
+require 'json'
+
+module QueueIt
+	class KnownUser
+		QUEUEIT_TOKEN_KEY = "queueittoken"
+		QUEUEIT_DEBUG_KEY = "queueitdebug"
+	
+		@@userInQueueService = nil	
+		def self.getUserInQueueService(cookieJar)
+			if (@@userInQueueService == nil)
+				return UserInQueueService.new(UserInQueueStateCookieRepository.new(CookieManager.new(cookieJar)))
+			end
+		
+			return @@userInQueueService
+		end
+		private_class_method :getUserInQueueService
+
+		def self.convertToInt(value)
+			begin
+				converted = Integer(value)
+			rescue
+				converted = 0
+			end
+			return converted
+		end
+		private_class_method :convertToInt
+	
+		def self.getIsDebug(queueitToken, secretKey)
+			qParams = QueueUrlParams.extractQueueParams(queueitToken)
+			if(qParams == nil)
+				return false
+			end
+
+			redirectType = qParams.redirectType
+			if(redirectType == nil)
+				return false
+			end
+		
+			if (redirectType.upcase.eql?("DEBUG"))
+				calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, qParams.queueITTokenWithoutHash)
+				valid = qParams.hashCode.eql?(calculatedHash) 
+				return valid
+			end
+			return false
+		end
+		private_class_method :getIsDebug
+
+		def self.setDebugCookie(debugEntries, cookieJar)
+			if(debugEntries == nil || debugEntries.length == 0)
+				return
+			end
+		
+			cookieManager = CookieManager.new(cookieJar)
+			cookieValue = ''
+			debugEntries.each do |entry|
+				cookieValue << (entry[0].to_s + '=' + entry[1].to_s + '|')
+			end
+			cookieValue = cookieValue.chop # remove trailing char		
+			cookieManager.setCookie(QUEUEIT_DEBUG_KEY, cookieValue, nil, nil)
+		end
+		private_class_method :setDebugCookie
+
+		def self._resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, cookieJar, request, debugEntries)
+			isDebug = getIsDebug(queueitToken, secretKey)
+			if(isDebug)
+				debugEntries["TargetUrl"] = targetUrl
+				debugEntries["QueueitToken"] = queueitToken
+				debugEntries["OriginalUrl"] = request.original_url            
+				if(queueConfig == nil)
+					debugEntries["QueueConfig"] = "NULL"
+				else
+					debugEntries["QueueConfig"] = queueConfig.toString()
+				end
+			end
+		
+			if(Utils.isNilOrEmpty(customerId))
+				raise KnownUserError, "customerId can not be nil or empty."
+			end
+		
+			if(Utils.isNilOrEmpty(secretKey))
+				raise KnownUserError, "secretKey can not be nil or empty."
+			end
+		
+			if(queueConfig == nil)
+				raise KnownUserError, "queueConfig can not be nil."
+			end
+		
+			if(Utils.isNilOrEmpty(queueConfig.eventId))
+				raise KnownUserError, "queueConfig.eventId can not be nil or empty."
+			end
+		
+			if(Utils.isNilOrEmpty(queueConfig.queueDomain))
+				raise KnownUserError, "queueConfig.queueDomain can not be nil or empty."
+			end
+		
+			minutes = convertToInt(queueConfig.cookieValidityMinute)
+			if(minutes <= 0)
+				raise KnownUserError, "queueConfig.cookieValidityMinute should be integer greater than 0."	
+			end
+		
+			if(![true, false].include? queueConfig.extendCookieValidity)
+				raise KnownUserError, "queueConfig.extendCookieValidity should be valid boolean."
+			end
+
+			userInQueueService = getUserInQueueService(cookieJar)
+			userInQueueService.validateQueueRequest(targetUrl, queueitToken, queueConfig, customerId, secretKey)
+		end
+		private_class_method :_resolveQueueRequestByLocalConfig
+	
+		def self._cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, cookieJar, request, debugEntries)
+			isDebug = getIsDebug(queueitToken, secretKey)
+			if(isDebug)
+				debugEntries["TargetUrl"] = targetUrl
+				debugEntries["QueueitToken"] = queueitToken
+				debugEntries["OriginalUrl"] = request.original_url
+				if(cancelConfig == nil)
+					debugEntries["CancelConfig"] = "NULL"
+				else
+					debugEntries["CancelConfig"] = cancelConfig.toString()
+				end
+			end
+		
+			if(Utils.isNilOrEmpty(targetUrl))
+				raise KnownUserError, "targetUrl can not be nil or empty."
+			end
+
+			if(Utils.isNilOrEmpty(customerId))
+				raise KnownUserError, "customerId can not be nil or empty."
+			end
+		
+			if(Utils.isNilOrEmpty(secretKey))
+				raise KnownUserError, "secretKey can not be nil or empty."
+			end
+		
+			if(cancelConfig == nil)
+				raise KnownUserError, "cancelConfig can not be nil."
+			end
+		
+			if(Utils.isNilOrEmpty(cancelConfig.eventId))
+				raise KnownUserError, "cancelConfig.eventId can not be nil or empty."
+			end
+		
+			if(Utils.isNilOrEmpty(cancelConfig.queueDomain))
+				raise KnownUserError, "cancelConfig.queueDomain can not be nil or empty."
+			end
+
+			userInQueueService = getUserInQueueService(cookieJar)
+			userInQueueService.validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey)
+		end
+		private_class_method :_cancelRequestByLocalConfig
+
+		def self.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey, cookieJar)
+			if(Utils.isNilOrEmpty(eventId))
+				raise KnownUserError, "eventId can not be nil or empty."
+			end
+		
+			if(Utils.isNilOrEmpty(secretKey))
+				raise KnownUserError, "secretKey can not be nil or empty."
+			end
+
+			minutes = convertToInt(cookieValidityMinute)
+			if(minutes <= 0)
+				raise KnownUserError, "cookieValidityMinute should be integer greater than 0."	
+			end
+
+			userInQueueService = getUserInQueueService(cookieJar)
+			userInQueueService.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)
+		end
+
+		def self.resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, cookieJar, request)
+			debugEntries = Hash.new
+			begin
+				return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, cookieJar, request, debugEntries)
+			ensure
+				setDebugCookie(debugEntries, cookieJar)
+			end
+		end
+
+		def self.validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationsConfigString, customerId, secretKey, cookieJar, request)
+			if(Utils.isNilOrEmpty(currentUrlWithoutQueueITToken))
+				raise KnownUserError, "currentUrlWithoutQueueITToken can not be nil or empty."
+			end
+
+			if(Utils.isNilOrEmpty(integrationsConfigString))
+				raise KnownUserError, "integrationsConfigString can not be nil or empty."
+			end
+
+			begin
+				customerIntegration = JSON.parse(integrationsConfigString)
+			
+				debugEntries = Hash.new		
+				isDebug = getIsDebug(queueitToken, secretKey)
+				if(isDebug)
+					debugEntries["ConfigVersion"] = customerIntegration["Version"]
+					debugEntries["PureUrl"] = currentUrlWithoutQueueITToken
+					debugEntries["QueueitToken"] = queueitToken
+					debugEntries["OriginalUrl"] = request.original_url
+				end
+			
+				integrationEvaluator = IntegrationEvaluator.new
+				matchedConfig = integrationEvaluator.getMatchedIntegrationConfig(customerIntegration, currentUrlWithoutQueueITToken, cookieJar, request.user_agent)
+
+				if(isDebug)
+					if(matchedConfig == nil)
+						debugEntries["MatchedConfig"] = "NULL"
+					else
+						debugEntries["MatchedConfig"] = matchedConfig["Name"]
+					end
+				end
+
+				if(matchedConfig == nil)
+					return RequestValidationResult.new(nil, nil, nil, nil)
+				end
+			
+				if(!matchedConfig.key?("ActionType") || Utils.isNilOrEmpty(matchedConfig["ActionType"]) || matchedConfig["ActionType"].eql?(ActionTypes::QUEUE))
+					queueConfig = QueueEventConfig.new
+					queueConfig.eventId = matchedConfig["EventId"]
+					queueConfig.queueDomain = matchedConfig["QueueDomain"]
+					queueConfig.layoutName = matchedConfig["LayoutName"]
+					queueConfig.culture = matchedConfig["Culture"]
+					queueConfig.cookieDomain = matchedConfig["CookieDomain"]
+					queueConfig.extendCookieValidity = matchedConfig["ExtendCookieValidity"]
+					queueConfig.cookieValidityMinute = matchedConfig["CookieValidityMinute"]
+					queueConfig.version = customerIntegration["Version"]
+			
+					case matchedConfig["RedirectLogic"]
+						when "ForcedTargetUrl"
+							targetUrl = matchedConfig["ForcedTargetUrl"]					
+						when "EventTargetUrl"
+							targetUrl = ''
+						else
+							targetUrl = currentUrlWithoutQueueITToken
+					end
+
+					return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, cookieJar, request, debugEntries)			
+			
+				else # cancel action			
+					cancelConfig = CancelEventConfig.new;
+					cancelConfig.eventId = matchedConfig["EventId"]
+					cancelConfig.queueDomain = matchedConfig["QueueDomain"]
+					cancelConfig.cookieDomain = matchedConfig["CookieDomain"]
+					cancelConfig.version = customerIntegration["Version"]
+            
+					return _cancelRequestByLocalConfig(currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, secretKey, cookieJar, request, debugEntries);
+				end
+			rescue StandardError => stdErr
+				raise KnownUserError, "integrationConfiguration text was not valid: " + stdErr.message
+			ensure
+				setDebugCookie(debugEntries, cookieJar)
+			end
+		end
+
+		def self.cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, cookieJar, request)
+			debugEntries = Hash.new
+			begin
+				return _cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, cookieJar, request, debugEntries)
+			ensure
+				setDebugCookie(debugEntries, cookieJar)
+			end
+		end
+	end
+
+	class CookieManager
+		@cookies = {}
+
+		def initialize(cookieJar)
+			@cookies = cookieJar
+		end
+	
+		def getCookie(name)
+			key = name.to_sym
+			if(!Utils.isNilOrEmpty(@cookies[key]))
+				return @cookies[key]
+			end
+			return nil
+		end
+
+		def setCookie(name, value, expire, domain)
+			key = name.to_sym
+			noDomain = Utils.isNilOrEmpty(domain) 
+			deleteCookie = Utils.isNilOrEmpty(value)
+			noExpire = Utils.isNilOrEmpty(expire)
+
+			if(noDomain)
+				if(deleteCookie)
+					@cookies.delete(key)
+				else
+					if(noExpire)
+						@cookies[key] = { :value => value }
+					else
+						@cookies[key] = { :value => value, :expires => expire }
+					end
+				end		
+			else
+				if(deleteCookie)
+					@cookies.delete(key, :domain => domain)				
+				else
+					if(noExpire)
+						@cookies[key] = { :value => value, :domain => domain }		
+					else
+						@cookies[key] = { :value => value, :expires => expire, :domain => domain }		
+					end
+				end		
+			end		
+		end
+	end
+end
+
+
+

data/lib/queueit_knownuserv3/models.rb

@@ -0,0 +1,96 @@
+module QueueIt
+	class Utils
+		def self.isNilOrEmpty(value)
+			return !value || value.to_s == ''
+		end
+		def self.toString(value)
+			if(value == nil)
+				return ''
+			end
+			return value.to_s
+		end
+	end
+
+	class CancelEventConfig
+		attr_accessor :eventId	
+		attr_accessor :queueDomain
+		attr_accessor :cookieDomain
+		attr_accessor :version
+
+		def initialize
+			@eventId = nil
+			@queueDomain = nil
+			@cookieDomain = nil
+			@version = nil
+		end
+
+		def toString
+			return "EventId:" + Utils.toString(eventId) + 
+				   "&Version:" + Utils.toString(version) +
+				   "&QueueDomain:" + Utils.toString(queueDomain) + 
+				   "&CookieDomain:" + Utils.toString(cookieDomain)
+		end
+	end
+
+	class QueueEventConfig
+		attr_accessor :eventId	
+		attr_accessor :layoutName
+		attr_accessor :culture
+		attr_accessor :queueDomain
+		attr_accessor :extendCookieValidity
+		attr_accessor :cookieValidityMinute
+		attr_accessor :cookieDomain
+		attr_accessor :version
+
+		def initialize
+			@eventId = nil
+			@layoutName = nil
+			@culture = nil
+			@queueDomain = nil
+			@extendCookieValidity = nil
+			@cookieValidityMinute = nil
+			@cookieDomain = nil
+			@version = nil
+		end
+
+		def toString
+			return "EventId:" + Utils.toString(eventId) + 
+				   "&Version:" + Utils.toString(version) +
+				   "&QueueDomain:" + Utils.toString(queueDomain) + 
+				   "&CookieDomain:" + Utils.toString(cookieDomain) + 
+				   "&ExtendCookieValidity:" + Utils.toString(extendCookieValidity) +
+				   "&CookieValidityMinute:" + Utils.toString(cookieValidityMinute) + 
+				   "&LayoutName:" + Utils.toString(layoutName) + 
+				   "&Culture:" + Utils.toString(culture)
+		end
+	end
+
+	class RequestValidationResult
+		attr_reader :actionType
+		attr_reader :eventId
+		attr_reader :queueId
+		attr_reader :redirectUrl
+
+		def initialize(actionType, eventId, queueId, redirectUrl)
+			@actionType = actionType
+			@eventId = eventId
+			@queueId = queueId
+			@redirectUrl = redirectUrl
+		end
+
+		def doRedirect
+			return !Utils.isNilOrEmpty(@redirectUrl)
+		end
+	end
+
+	class KnownUserError < StandardError
+		def initialize(message)
+			super(message)
+		end
+	end
+
+	class ActionTypes
+		CANCEL = "Cancel"
+		QUEUE = "Queue"
+	end
+end

data/lib/queueit_knownuserv3/queue_url_params.rb

@@ -0,0 +1,81 @@
+module QueueIt
+	class QueueUrlParams
+		KEY_VALUE_SEPARATOR_GROUP_CHAR = '~';
+		KEY_VALUE_SEPARATOR_CHAR = '_';
+		TIMESTAMP_KEY = "ts"
+		COOKIE_VALIDITY_MINUTE_KEY = "cv";
+		EVENT_ID_KEY = "e";
+		EXTENDABLE_COOKIE_KEY = "ce";
+		HASH_KEY = "h";
+		QUEUE_ID_KEY = "q";
+		REDIRECT_TYPE_KEY = "rt"
+
+		attr_accessor :timeStamp
+		attr_accessor :eventId
+		attr_accessor :hashCode
+		attr_accessor :extendableCookie
+		attr_accessor :cookieValidityMinute
+		attr_accessor :queueITToken
+		attr_accessor :queueITTokenWithoutHash
+		attr_accessor :queueId
+		attr_accessor :redirectType
+
+		def initialize
+			@timeStamp = 0
+			@eventId = ""
+			@hashCode = ""
+			@extendableCookie = false
+			@cookieValidityMinute = nil
+			@queueITToken = ""
+			@queueITTokenWithoutHash = ""
+			@queueId = ""
+			@redirectType = nil
+		end
+
+		def self.extractQueueParams(queueitToken)
+			begin
+				if(Utils.isNilOrEmpty(queueitToken))
+					return nil
+				end
+				result = QueueUrlParams.new
+				result.queueITToken = queueitToken
+				paramsNameValueList = result.queueITToken.split(KEY_VALUE_SEPARATOR_GROUP_CHAR)
+
+				paramsNameValueList.each do |pNameValue|
+					paramNameValueArr = pNameValue.split(KEY_VALUE_SEPARATOR_CHAR)
+			
+					case paramNameValueArr[0]
+						when TIMESTAMP_KEY 
+							begin
+								result.timeStamp = Integer(paramNameValueArr[1])
+							rescue
+								result.timeStamp = 0					
+							end
+						when COOKIE_VALIDITY_MINUTE_KEY
+							begin
+								result.cookieValidityMinute = Integer(paramNameValueArr[1])
+							rescue
+								result.cookieValidityMinute = nil
+							end
+						when EVENT_ID_KEY
+							result.eventId = paramNameValueArr[1]
+						when EXTENDABLE_COOKIE_KEY
+							if paramNameValueArr[1].upcase.eql? 'TRUE'
+								result.extendableCookie = true
+							end
+						when HASH_KEY
+							result.hashCode = paramNameValueArr[1]
+						when QUEUE_ID_KEY
+							result.queueId = paramNameValueArr[1]
+						when REDIRECT_TYPE_KEY
+							result.redirectType = paramNameValueArr[1] 
+					end		
+				end
+				result.queueITTokenWithoutHash = result.queueITToken.gsub((KEY_VALUE_SEPARATOR_GROUP_CHAR + HASH_KEY + KEY_VALUE_SEPARATOR_CHAR + result.hashCode), "")		
+				return result
+			rescue 
+				return nil
+			end
+		end
+	end
+end

data/lib/queueit_knownuserv3/user_in_queue_service.rb

@@ -0,0 +1,116 @@
+require 'open-uri'
+require 'cgi'
+
+module QueueIt
+	class UserInQueueService
+		SDK_VERSION = "3.2.3"
+    
+		def initialize(userInQueueStateRepository)
+			@userInQueueStateRepository = userInQueueStateRepository
+		end
+     
+		def validateQueueRequest(targetUrl, queueitToken, config, customerId, secretKey)
+			state = @userInQueueStateRepository.getState(config.eventId, secretKey)
+			if (state.isValid)
+				if (state.isStateExtendable && config.extendCookieValidity) 
+					@userInQueueStateRepository.store(
+						config.eventId,
+						state.queueId,
+						true,
+						config.cookieValidityMinute,
+						!Utils::isNilOrEmpty(config.cookieDomain) ? config.cookieDomain : '',
+						secretKey)
+				end
+				return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, state.queueId, nil)            			
+			end
+        
+			queueParams = QueueUrlParams::extractQueueParams(queueitToken)
+			if(!queueParams.nil?) 
+				return getQueueITTokenValidationResult(targetUrl, config.eventId, config, queueParams, customerId, secretKey)
+			else 
+				return getInQueueRedirectResult(targetUrl, config, customerId)
+			end
+		end
+
+		def validateCancelRequest(targetUrl, config, customerId, secretKey)
+			state = @userInQueueStateRepository.getState(config.eventId, secretKey)
+			if (state.isValid)
+				@userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain)
+
+				query = getQueryString(customerId, config.eventId, config.version, nil, nil) + ( !Utils::isNilOrEmpty(targetUrl) ? ("&r=" +  CGI.escape(targetUrl)) : "" )
+			
+				domainAlias = config.queueDomain
+				if (!domainAlias.end_with?("/") )
+					domainAlias = domainAlias + "/"
+				end
+			
+				redirectUrl = "https://" + domainAlias + "cancel/" + customerId + "/" + config.eventId + "/?" + query;
+				return RequestValidationResult.new(ActionTypes::CANCEL, config.eventId, state.queueId, redirectUrl)			
+			else
+				return RequestValidationResult.new(ActionTypes::CANCEL, config.eventId, nil, nil)			
+			end
+		end 
+
+		def getQueueITTokenValidationResult(targetUrl, eventId, config, queueParams,customerId, secretKey) 
+			calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, queueParams.queueITTokenWithoutHash) 
+			if (calculatedHash.upcase() != queueParams.hashCode.upcase()) 
+				return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "hash")
+			end
+			if (queueParams.eventId.upcase() != eventId.upcase()) 
+				return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "eventid")
+			end
+			if (queueParams.timeStamp < Time.now.getutc.tv_sec) 
+				return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "timestamp")
+			end
+
+			@userInQueueStateRepository.store(
+				config.eventId,
+				queueParams.queueId,
+				queueParams.extendableCookie,
+				!(queueParams.cookieValidityMinute.nil?) ? queueParams.cookieValidityMinute : config.cookieValidityMinute,
+				!Utils::isNilOrEmpty(config.cookieDomain) ? config.cookieDomain : '',
+				secretKey)
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, queueParams.queueId, nil)        		
+		end
+
+		def getVaidationErrorResult(customerId, targetUrl, config, qParams, errorCode) 
+			query = getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName) +
+				"&queueittoken=" + qParams.queueITToken +
+				"&ts=" + Time.now.getutc.tv_sec.to_s +
+				(!Utils::isNilOrEmpty(targetUrl) ? ("&t=" +  CGI.escape(targetUrl)) : "")
+			domainAlias = config.queueDomain
+			if (!domainAlias.end_with?("/") )
+				domainAlias = domainAlias + "/"
+			end
+			redirectUrl = "https://" + domainAlias + "error/" + errorCode + "?"  + query
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl)        
+		end
+
+		def getInQueueRedirectResult(targetUrl, config, customerId) 
+			redirectUrl = "https://" + config.queueDomain + 
+				"?" + getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName) + 
+				(!Utils::isNilOrEmpty(targetUrl) ? "&t=" +  
+				CGI.escape( targetUrl) : "")
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl)        
+		end
+
+		def getQueryString(customerId, eventId, configVersion, culture, layoutName) 
+			queryStringList = Array.new 
+			queryStringList.push("c=" + CGI.escape(customerId))
+			queryStringList.push("e=" + CGI.escape(eventId))
+			queryStringList.push("ver=v3-ruby-" + SDK_VERSION) 
+			queryStringList.push("cver=" + (!configVersion.nil? ? configVersion.to_s : '-1'))
+			if (!Utils::isNilOrEmpty(culture)) 
+				queryStringList.push("cid=" + CGI.escape(culture))
+			end
+			if (!Utils::isNilOrEmpty(layoutName)) 
+				queryStringList.push("l=" + CGI.escape(layoutName))
+			end
+			return queryStringList.join("&")
+		end
+
+		def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey) 
+			@userInQueueStateRepository.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)
+		end
+	end
+end

data/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb

@@ -0,0 +1,125 @@
+require 'openssl' 
+require 'base64'
+require 'date'
+
+module QueueIt
+	class UserInQueueStateCookieRepository 
+		QUEUEIT_DATA_KEY = "QueueITAccepted-SDFrts345E-V3"
+    
+		def initialize(cookieManager)
+			@cookieManager = cookieManager
+		end
+
+		def cancelQueueCookie(eventId, cookieDomain) 
+			cookieKey = self.class.getCookieKey(eventId)
+			@cookieManager.setCookie(cookieKey, nil, -1, cookieDomain)		
+		end
+
+		def store(eventId, queueId, isStateExtendable, cookieValidityMinute, cookieDomain, secretKey)
+			cookieKey = self.class.getCookieKey(eventId)
+			expirationTime = (Time.now.getutc.tv_sec + (cookieValidityMinute * 60)).to_s
+			isStateExtendableString = (isStateExtendable) ? 'true' : 'false'
+			cookieValue = createCookieValue(queueId, isStateExtendableString, expirationTime, secretKey)
+			@cookieManager.setCookie(cookieKey, cookieValue, Time.now + (24*60*60), cookieDomain)
+		end
+
+		def self.getCookieKey(eventId)
+			 return QUEUEIT_DATA_KEY + '_' + eventId
+		end
+
+		def createCookieValue(queueId, isStateExtendable, expirationTime, secretKey) 
+			hashValue = OpenSSL::HMAC.hexdigest('sha256', secretKey, queueId + isStateExtendable + expirationTime) 
+			cookieValue = "QueueId=" + queueId + "&IsCookieExtendable=" + isStateExtendable + "&Expires=" + expirationTime + "&Hash=" + hashValue        
+			return cookieValue
+		end
+    
+		def getCookieNameValueMap(cookieValue) 
+			result = Hash.new 
+			cookieNameValues = cookieValue.split("&")
+			if (cookieNameValues.length != 4) 
+				return result
+			end
+
+			cookieNameValues.each do |item|
+				arr = item.split("=")
+				if(arr.length == 2)
+					result[arr[0]] = arr[1]
+				end
+			end
+			return result
+		end
+
+		def isCookieValid(cookieNameValueMap, secretKey) 
+			begin
+				if (!cookieNameValueMap.key?("IsCookieExtendable")) 
+					return false
+				end
+				if (!cookieNameValueMap.key?("Expires")) 
+					return false
+				end
+				if (!cookieNameValueMap.key?("Hash")) 
+					return false
+				end
+				if (!cookieNameValueMap.key?("QueueId")) 
+					return false
+				end
+				hashValue = OpenSSL::HMAC.hexdigest('sha256', secretKey, cookieNameValueMap["QueueId"] + cookieNameValueMap["IsCookieExtendable"] + cookieNameValueMap["Expires"]) 
+				if (hashValue != cookieNameValueMap["Hash"]) 
+					return false
+				end		
+				if(Integer(cookieNameValueMap["Expires"]) < Time.now.getutc.tv_sec) 
+					return false
+				end
+				return true
+			rescue
+				return false
+			end
+		end
+
+		def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)       
+			cookieKey = self.class.getCookieKey(eventId)
+			cookieValue = @cookieManager.getCookie(cookieKey)
+			if (cookieValue.nil?) 
+				return
+			end
+       
+			cookieNameValueMap = getCookieNameValueMap(cookieValue)
+			if (!isCookieValid(cookieNameValueMap, secretKey)) 
+				return 
+			end
+			expirationTime = (Time.now.getutc.tv_sec + (cookieValidityMinute * 60)).to_s
+			cookieValue = createCookieValue(cookieNameValueMap["QueueId"], cookieNameValueMap["IsCookieExtendable"], expirationTime, secretKey)
+			@cookieManager.setCookie(cookieKey, cookieValue, Time.now + (24*60*60), cookieDomain)
+		end
+
+		def getState(eventId, secretKey) 
+			cookieKey = cookieKey = self.class.getCookieKey(eventId)
+			if (@cookieManager.getCookie(cookieKey).nil?) 
+				return StateInfo.new(false, nil, false, 0)
+			end
+			cookieNameValueMap = getCookieNameValueMap(@cookieManager.getCookie(cookieKey))
+			if (!isCookieValid(cookieNameValueMap, secretKey))
+				return StateInfo.new(false, nil, false,0)
+			end
+			return StateInfo.new(
+				true, 
+				cookieNameValueMap["QueueId"], 
+				cookieNameValueMap["IsCookieExtendable"] == 'true',
+				Integer(cookieNameValueMap["Expires"]))
+		end
+	end
+
+	class StateInfo 
+		attr_reader :isValid
+		attr_reader :queueId
+		attr_reader :isStateExtendable    
+		attr_reader :expires # used just for unit tests
+
+		def initialize(isValid, queueId, isStateExtendable, expires) 
+			@isValid = isValid
+			@queueId = queueId
+			@isStateExtendable = isStateExtendable
+			@expires = expires
+		end
+	end
+end

data/queueit_knownuserv3.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'queueit_knownuserv3/user_in_queue_service'
+
+Gem::Specification.new do |spec|
+  spec.name          = "queueit_knownuserv3"
+  spec.version       = QueueIt::UserInQueueService::SDK_VERSION
+  spec.authors       = ["Queue-it"]
+  spec.email         = ["support@queue-it.com"]
+  spec.licenses      = "LGPL-3.0"
+  spec.summary       = %q{ Gem for implementing Queue-it KnownUser V3}
+  spec.homepage      = "https://www.queue-it.com/"
+
+  # 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.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: queueit_knownuserv3
+version: !ruby/object:Gem::Version
+  version: 3.2.3
+platform: ruby
+authors:
+- Queue-it
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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'
+description: 
+email:
+- support@queue-it.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- bin/console
+- bin/setup
+- lib/queueit_knownuserv3.rb
+- lib/queueit_knownuserv3/integration_config_helpers.rb
+- lib/queueit_knownuserv3/known_user.rb
+- lib/queueit_knownuserv3/models.rb
+- lib/queueit_knownuserv3/queue_url_params.rb
+- lib/queueit_knownuserv3/user_in_queue_service.rb
+- lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb
+- queueit_knownuserv3.gemspec
+homepage: https://www.queue-it.com/
+licenses:
+- LGPL-3.0
+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.6.13
+signing_key: 
+specification_version: 4
+summary: Gem for implementing Queue-it KnownUser V3
+test_files: []