queueit_knownuserv3 3.3.0 → 3.6.1

data/lib/queueit_knownuserv3/models.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module QueueIt
 	class Utils
 		def self.isNilOrEmpty(value)
@@ -9,6 +11,12 @@ module QueueIt
 			end
 			return value.to_s
 		end
+		def self.urlEncode(value)
+			return CGI.escape(value).gsub("+", "%20").gsub("%7E", "~")
+		end
+		def self.urlDecode(value)
+			return CGI.unescape(value)
+		end
 	end
 
 	class CancelEventConfig
@@ -16,19 +24,22 @@ module QueueIt
 		attr_accessor :queueDomain
 		attr_accessor :cookieDomain
 		attr_accessor :version
+		attr_accessor :actionName
 
 		def initialize
 			@eventId = nil
 			@queueDomain = nil
 			@cookieDomain = nil
 			@version = nil
+			@actionName = "unspecified"
 		end
 
 		def toString
 			return "EventId:" + Utils.toString(eventId) + 
 				   "&Version:" + Utils.toString(version) +
 				   "&QueueDomain:" + Utils.toString(queueDomain) + 
-				   "&CookieDomain:" + Utils.toString(cookieDomain)
+				   "&CookieDomain:" + Utils.toString(cookieDomain) +
+				   "&ActionName:" + Utils.toString(actionName)
 		end
 	end
 
@@ -41,6 +52,7 @@ module QueueIt
 		attr_accessor :cookieValidityMinute
 		attr_accessor :cookieDomain
 		attr_accessor :version
+		attr_accessor :actionName
 
 		def initialize
 			@eventId = nil
@@ -51,6 +63,7 @@ module QueueIt
 			@cookieValidityMinute = nil
 			@cookieDomain = nil
 			@version = nil
+			@actionName = "unspecified"
 		end
 
 		def toString
@@ -61,7 +74,8 @@ module QueueIt
 				   "&ExtendCookieValidity:" + Utils.toString(extendCookieValidity) +
 				   "&CookieValidityMinute:" + Utils.toString(cookieValidityMinute) + 
 				   "&LayoutName:" + Utils.toString(layoutName) + 
-				   "&Culture:" + Utils.toString(culture)
+				   "&Culture:" + Utils.toString(culture) +
+				   "&ActionName:" + Utils.toString(actionName)
 		end
 	end
 
@@ -70,17 +84,33 @@ module QueueIt
 		attr_reader :eventId
 		attr_reader :queueId
 		attr_reader :redirectUrl
+		attr_reader :redirectType
+		attr_accessor :actionName
+		attr_accessor :isAjaxResult
 
-		def initialize(actionType, eventId, queueId, redirectUrl)
+		def initialize(actionType, eventId, queueId, redirectUrl, redirectType, actionName)
 			@actionType = actionType
 			@eventId = eventId
 			@queueId = queueId
 			@redirectUrl = redirectUrl
+			@redirectType = redirectType
+			@actionName = actionName
 		end
 
 		def doRedirect
 			return !Utils.isNilOrEmpty(@redirectUrl)
 		end
+
+		def getAjaxQueueRedirectHeaderKey
+			return "x-queueit-redirect"
+		end
+
+		def getAjaxRedirectUrl
+			if !Utils.isNilOrEmpty(@redirectUrl)				
+				return Utils.urlEncode(@redirectUrl)				
+			end
+			return ""		
+		end
 	end
 
 	class KnownUserError < StandardError
@@ -92,5 +122,6 @@ module QueueIt
 	class ActionTypes
 		CANCEL = "Cancel"
 		QUEUE = "Queue"
+		IGNORE = "Ignore"
 	end
 end

data/lib/queueit_knownuserv3/queue_url_params.rb

@@ -1,20 +1,20 @@
 module QueueIt
 	class QueueUrlParams
-		KEY_VALUE_SEPARATOR_GROUP_CHAR = '~';
-		KEY_VALUE_SEPARATOR_CHAR = '_';
+		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";
+		COOKIE_VALIDITY_MINUTES_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 :cookieValidityMinutes
 		attr_accessor :queueITToken
 		attr_accessor :queueITTokenWithoutHash
 		attr_accessor :queueId
@@ -25,7 +25,7 @@ module QueueIt
 			@eventId = ""
 			@hashCode = ""
 			@extendableCookie = false
-			@cookieValidityMinute = nil
+			@cookieValidityMinutes = nil
 			@queueITToken = ""
 			@queueITTokenWithoutHash = ""
 			@queueId = ""
@@ -33,49 +33,49 @@ module QueueIt
 		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)
+			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		
+			paramsNameValueList.each do |pNameValue|
+				paramNameValueArr = pNameValue.split(KEY_VALUE_SEPARATOR_CHAR)
+				
+				if(!paramNameValueArr.length().eql? 2)
+					next
 				end
-				result.queueITTokenWithoutHash = result.queueITToken.gsub((KEY_VALUE_SEPARATOR_GROUP_CHAR + HASH_KEY + KEY_VALUE_SEPARATOR_CHAR + result.hashCode), "")		
-				return result
-			rescue 
-				return nil
+
+				case paramNameValueArr[0]
+					when HASH_KEY
+						result.hashCode = paramNameValueArr[1]
+					when TIMESTAMP_KEY
+						if paramNameValueArr[1] !~ /\D/
+							result.timeStamp = paramNameValueArr[1].to_i
+						else
+							result.timeStamp = 0
+						end
+					when COOKIE_VALIDITY_MINUTES_KEY
+						if paramNameValueArr[1] !~ /\D/
+							result.cookieValidityMinutes = paramNameValueArr[1].to_i
+						else
+							result.cookieValidityMinutes = 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 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
 		end
 	end
 end

data/lib/queueit_knownuserv3/user_in_queue_service.rb

@@ -3,114 +3,155 @@ require 'cgi'
 
 module QueueIt
 	class UserInQueueService
-		SDK_VERSION = "3.3.0"
+		SDK_VERSION_NO = "3.6.1"
+		SDK_VERSION = "v3-ruby-" + SDK_VERSION_NO
     
 		def initialize(userInQueueStateRepository)
 			@userInQueueStateRepository = userInQueueStateRepository
 		end
      
 		def validateQueueRequest(targetUrl, queueitToken, config, customerId, secretKey)
-			state = @userInQueueStateRepository.getState(config.eventId, secretKey)
+			state = @userInQueueStateRepository.getState(config.eventId, config.cookieValidityMinute, secretKey, true)
 			if (state.isValid)
-				if (state.isStateExtendable && config.extendCookieValidity) 
+				if (state.isStateExtendable && config.extendCookieValidity)
 					@userInQueueStateRepository.store(
 						config.eventId,
 						state.queueId,
-						true,
-						config.cookieValidityMinute,
+						nil,
 						!Utils::isNilOrEmpty(config.cookieDomain) ? config.cookieDomain : '',
+						state.redirectType,
 						secretKey)
 				end
-				return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, state.queueId, nil)            			
+				return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, state.queueId, nil, state.redirectType, config.actionName)            			
 			end
-        
+
 			queueParams = QueueUrlParams::extractQueueParams(queueitToken)
-			if(!queueParams.nil?) 
-				return getQueueITTokenValidationResult(targetUrl, config.eventId, config, queueParams, customerId, secretKey)
+
+			requestValidationResult = nil
+            isTokenValid = false
+
+			if (!queueParams.nil?) 
+				tokenValidationResult = validateToken(config, queueParams, secretKey)
+				isTokenValid = tokenValidationResult.isValid
+
+				if (isTokenValid)
+					requestValidationResult = getValidTokenResult(config, queueParams, secretKey)
+				else
+					requestValidationResult = getErrorResult(customerId, targetUrl, config, queueParams, tokenValidationResult.errorCode)
+				end
 			else 
-				return getInQueueRedirectResult(targetUrl, config, customerId)
+				requestValidationResult = getQueueResult(targetUrl, config, customerId)
+            end
+            
+			if (state.isFound && !isTokenValid)
+				@userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain);
 			end
+            
+            return requestValidationResult;
 		end
 
-		def validateCancelRequest(targetUrl, config, customerId, secretKey)
-			state = @userInQueueStateRepository.getState(config.eventId, secretKey)
+		def validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey)
+			state = @userInQueueStateRepository.getState(cancelConfig.eventId, -1, secretKey, false)
 			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)			
+				@userInQueueStateRepository.cancelQueueCookie(cancelConfig.eventId, cancelConfig.cookieDomain)
+				query = getQueryString(customerId, cancelConfig.eventId, cancelConfig.version, cancelConfig.actionName, nil, nil) + 
+							(!Utils::isNilOrEmpty(targetUrl) ? ("&r=" +  Utils.urlEncode(targetUrl)) : "" )						
+				uriPath = "cancel/" + customerId + "/" + cancelConfig.eventId + "/"
+				
+				redirectUrl = generateRedirectUrl(cancelConfig.queueDomain, uriPath, query)
+				return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, state.queueId, redirectUrl, state.redirectType, cancelConfig.actionName)			
 			else
-				return RequestValidationResult.new(ActionTypes::CANCEL, config.eventId, nil, nil)			
+				return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, nil, nil, nil, cancelConfig.actionName)			
 			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
-
+		def getValidTokenResult(config, queueParams, secretKey) 
 			@userInQueueStateRepository.store(
 				config.eventId,
 				queueParams.queueId,
-				queueParams.extendableCookie,
-				!(queueParams.cookieValidityMinute.nil?) ? queueParams.cookieValidityMinute : config.cookieValidityMinute,
+				queueParams.cookieValidityMinutes,				
 				!Utils::isNilOrEmpty(config.cookieDomain) ? config.cookieDomain : '',
+				queueParams.redirectType,
 				secretKey)
-			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, queueParams.queueId, nil)        		
+
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, queueParams.queueId, nil, queueParams.redirectType, config.actionName)
 		end
 
-		def getVaidationErrorResult(customerId, targetUrl, config, qParams, errorCode) 
-			query = getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName) +
+		def getErrorResult(customerId, targetUrl, config, qParams, errorCode) 
+			query = getQueryString(customerId, config.eventId, config.version, config.actionName, 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)        
+				(!Utils::isNilOrEmpty(targetUrl) ? ("&t=" +  Utils.urlEncode(targetUrl)) : "")
+			
+			redirectUrl = generateRedirectUrl(config.queueDomain, "error/" + errorCode + "/", query)
+
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil, config.actionName)        
 		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)        
+		def getQueueResult(targetUrl, config, customerId) 
+			query = getQueryString(customerId, config.eventId, config.version, config.actionName, config.culture, config.layoutName) + 
+							(!Utils::isNilOrEmpty(targetUrl) ? "&t=" + Utils.urlEncode( targetUrl) : "")		
+
+			redirectUrl = generateRedirectUrl(config.queueDomain, "", query)
+
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil, config.actionName)        
 		end
 
-		def getQueryString(customerId, eventId, configVersion, culture, layoutName) 
+		def getQueryString(customerId, eventId, configVersion, actionName, 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("c=" + Utils.urlEncode(customerId))
+			queryStringList.push("e=" + Utils.urlEncode(eventId))
+			queryStringList.push("ver=" + SDK_VERSION) 
 			queryStringList.push("cver=" + (!configVersion.nil? ? configVersion.to_s : '-1'))
+			queryStringList.push("man=" + Utils.urlEncode(actionName))
+
 			if (!Utils::isNilOrEmpty(culture)) 
-				queryStringList.push("cid=" + CGI.escape(culture))
+				queryStringList.push("cid=" + Utils.urlEncode(culture))
 			end
 			if (!Utils::isNilOrEmpty(layoutName)) 
-				queryStringList.push("l=" + CGI.escape(layoutName))
+				queryStringList.push("l=" + Utils.urlEncode(layoutName))
 			end
 			return queryStringList.join("&")
 		end
 
-		def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey) 
-			@userInQueueStateRepository.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)
+		def generateRedirectUrl(queueDomain, uriPath, query)
+			if (!queueDomain.end_with?("/") )
+				queueDomain = queueDomain + "/"
+			end		
+			return "https://" + queueDomain + uriPath + "?" + query
+		end
+
+		def extendQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey) 
+			@userInQueueStateRepository.reissueQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey)
+		end
+
+		def getIgnoreActionResult(actionName)
+			return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil, actionName)
+		end
+
+		def validateToken(config, queueParams, secretKey)
+			calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, queueParams.queueITTokenWithoutHash) 
+			if (calculatedHash.upcase() != queueParams.hashCode.upcase()) 
+				return TokenValidationResult.new(false, "hash")
+			end
+			if (queueParams.eventId.upcase() != config.eventId.upcase()) 
+				return TokenValidationResult.new(false, "eventid")
+			end
+			if (queueParams.timeStamp < Time.now.getutc.tv_sec) 
+				return TokenValidationResult.new(false, "timestamp")
+			end
+
+			return TokenValidationResult.new(true, nil)
+		end
+
+		class TokenValidationResult
+			attr_reader :isValid
+			attr_reader :errorCode
+
+			def initialize(isValid, errorCode)
+				@isValid = isValid
+				@errorCode = errorCode
+			end
 		end
 	end
 end