queueit_knownuserv3 3.4.0 → 3.5.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODQxNjM4OTJiYzJhM2I5NjgxNmY0Yzc0MGMzOTExOTA1MGIzYTYyYw==
+    NWIwOWViMTkzYTAzOWQ2OThhYmNiNzM3NTRmOWRlYjYyNjg1YTc4NQ==
   data.tar.gz: !binary |-
-    ZjdiMjNmNjFmNjE3NWRhNzIzYjVlMzhjOTNlMWQ1YjZhNjJjYjFmZg==
+    NmI4ZTJkYTM4MzNjYTcyMDU3N2UxMDdjMmMxNjE1MjRiYTlhZjkwNA==
 SHA512:
   metadata.gz: !binary |-
-    NjM1ZGY3NDU2OWZkMGZjMThmNDkwOGI0Y2E2Y2RkZjA0MTVhNGYxMTFmNGIz
-    OTcwZjNiOGVmOTkzY2ZiYmY1NDc3N2E2MjJmOWVjZjI2YmRlYTIzZWRkODI4
-    YjdmMjMzNzE2MTJlOWFkNmIwOWEwMDQ2ZTliZGE3NDg5YzY0ZmM=
+    ZmQxZGEwYTM5ZWE3ZTc5MzdlYzgzZWNhOWZkZjc2M2JiYTMyY2M0YjM1MDg5
+    ZGE1NTAwM2Q0YTcwMGE4ZWNmYmYyOTNiYzY0Mzk1OGQ5OWUwZjNlNjAyYmU3
+    YTRkN2VlNTg3NjI4ZTk3MTExYmI2MThkZmI4MGRjNWEyMTY5MTY=
   data.tar.gz: !binary |-
-    Zjg4MGQ4Mzg0MmU3ZDlhOTQxOTg4MmJhODVhMmVjOTIwYzIwZGExNTg1NGNh
-    ZDY2ZTM5Y2RkOGQ4MmJkNDEyYzAyZmVkNjAxNTAyNzdmNmRlYzk3MGYyNWY4
-    MTRkYjRhYzBlMTM0YmVjMzQyYWMyZDk5OTMyYWZiMTg5MDg1OTY=
+    ODg3OGY5Mjk4M2ZiMzIwOGRkZWZjZTVlMTA0NTViZmU5OTFiNmNkYzc0ZGU4
+    NTQ1ZTU0MzQ5MTlmMjE1YzYwMzEwZGYzOTkzMDdkMjBkOWY1YjIyMDA3OTI5
+    ZTVkZmE4NGIyZTIxODU2MWJmYjQxMWQ3ZDU4OGRmM2YxNmRlYTc=

data/lib/queueit_knownuserv3/known_user.rb

@@ -1,9 +1,11 @@
+require 'cgi'
 require 'json'
 
 module QueueIt
 	class KnownUser
 		QUEUEIT_TOKEN_KEY = "queueittoken"
 		QUEUEIT_DEBUG_KEY = "queueitdebug"
+		QUEUEIT_AJAX_HEADER_KEY = "x-queueit-ajaxpageurl"
 	
 		@@userInQueueService = nil	
 		def self.getUserInQueueService(cookieJar)
@@ -15,6 +17,19 @@ module QueueIt
 		end
 		private_class_method :getUserInQueueService
 
+		def self.isQueueAjaxCall(request)
+			return request.headers[QUEUEIT_AJAX_HEADER_KEY] != nil
+		end
+		private_class_method :isQueueAjaxCall
+
+		def self.generateTargetUrl(originalTargetUrl, request)
+			unless isQueueAjaxCall(request)
+				return originalTargetUrl
+			end			
+			return CGI::unescape(request.headers[QUEUEIT_AJAX_HEADER_KEY])			
+		end
+		private_class_method :generateTargetUrl
+
 		def self.convertToInt(value)
 			begin
 				converted = Integer(value)
@@ -115,11 +130,15 @@ module QueueIt
 			end
 
 			userInQueueService = getUserInQueueService(request.cookie_jar)
-			userInQueueService.validateQueueRequest(targetUrl, queueitToken, queueConfig, customerId, secretKey)
+			result = userInQueueService.validateQueueRequest(targetUrl, queueitToken, queueConfig, customerId, secretKey)
+			result.isAjaxResult = isQueueAjaxCall(request)
+			
+			return result
 		end
 		private_class_method :_resolveQueueRequestByLocalConfig
 	
 		def self._cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries)
+			targetUrl = generateTargetUrl(targetUrl, request)
 			isDebug = getIsDebug(queueitToken, secretKey)
 			if(isDebug)
 				debugEntries["TargetUrl"] = targetUrl
@@ -158,7 +177,10 @@ module QueueIt
 			end
 
 			userInQueueService = getUserInQueueService(request.cookie_jar)
-			userInQueueService.validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey)
+			result = userInQueueService.validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey)
+			result.isAjaxResult = isQueueAjaxCall(request)
+			
+			return result
 		end
 		private_class_method :_cancelRequestByLocalConfig
 
@@ -183,6 +205,7 @@ module QueueIt
 		def self.resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request)
 			debugEntries = Hash.new
 			begin
+				targetUrl = generateTargetUrl(targetUrl, request)
 				return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries)
 			ensure
 				setDebugCookie(debugEntries, request.cookie_jar)
@@ -223,20 +246,23 @@ module QueueIt
 				end
 
 				if(matchedConfig == nil)
-					return RequestValidationResult.new(nil, nil, nil, nil)
+					return RequestValidationResult.new(nil, nil, nil, nil, nil)
 				end
 			
 				# unspecified or 'Queue' specified
 				if(!matchedConfig.key?("ActionType") || Utils.isNilOrEmpty(matchedConfig["ActionType"]) || matchedConfig["ActionType"].eql?(ActionTypes::QUEUE))
-					handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
+					return handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
 				
 				elsif(matchedConfig["ActionType"].eql?(ActionTypes::CANCEL))
-					handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
+					return handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
 					
 				# for all unknown types default to 'Ignore'
 				else
 					userInQueueService = getUserInQueueService(request.cookie_jar)
-					userInQueueService.getIgnoreActionResult()
+					result = userInQueueService.getIgnoreActionResult()
+					result.isAjaxResult = isQueueAjaxCall(request)
+					
+					return result
 				end
 
 			rescue StandardError => stdErr
@@ -263,20 +289,20 @@ module QueueIt
 				when "EventTargetUrl"
 					targetUrl = ''
 				else
-					targetUrl = currentUrlWithoutQueueITToken
+					targetUrl = generateTargetUrl(currentUrlWithoutQueueITToken, request)
 			end
 
 			return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries)		
 		end
 
 		def self.handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
-			cancelConfig = CancelEventConfig.new;
+			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, request, debugEntries);
+			return _cancelRequestByLocalConfig(currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries)
 		end
 
 		def self.cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request)
@@ -321,9 +347,9 @@ module QueueIt
 					@cookies.delete(key)
 				else
 					if(noExpire)
-						@cookies[key] = { :value => value }
+						@cookies[key] = { :value => value, :httponly => false }
 					else
-						@cookies[key] = { :value => value, :expires => expire }
+						@cookies[key] = { :value => value, :expires => expire, :httponly => false }
 					end
 				end		
 			else
@@ -331,9 +357,9 @@ module QueueIt
 					@cookies.delete(key, :domain => domain)				
 				else
 					if(noExpire)
-						@cookies[key] = { :value => value, :domain => domain }		
+						@cookies[key] = { :value => value, :domain => domain, :httponly => false }		
 					else
-						@cookies[key] = { :value => value, :expires => expire, :domain => domain }		
+						@cookies[key] = { :value => value, :expires => expire, :domain => domain, :httponly => false }		
 					end
 				end		
 			end		

data/lib/queueit_knownuserv3/models.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module QueueIt
 	class Utils
 		def self.isNilOrEmpty(value)
@@ -70,17 +72,31 @@ module QueueIt
 		attr_reader :eventId
 		attr_reader :queueId
 		attr_reader :redirectUrl
+		attr_reader :redirectType
+		attr_accessor :isAjaxResult
 
-		def initialize(actionType, eventId, queueId, redirectUrl)
+		def initialize(actionType, eventId, queueId, redirectUrl, redirectType)
 			@actionType = actionType
 			@eventId = eventId
 			@queueId = queueId
 			@redirectUrl = redirectUrl
+			@redirectType = redirectType
 		end
 
 		def doRedirect
 			return !Utils.isNilOrEmpty(@redirectUrl)
 		end
+
+		def getAjaxQueueRedirectHeaderKey
+			return "x-queueit-redirect"
+		end
+
+		def getAjaxRedirectUrl
+			if !Utils.isNilOrEmpty(@redirectUrl)				
+				return CGI.escape(@redirectUrl)				
+			end
+			return ""		
+		end
 	end
 
 	class KnownUserError < StandardError

data/lib/queueit_knownuserv3/queue_url_params.rb

@@ -3,7 +3,7 @@ module QueueIt
 		KEY_VALUE_SEPARATOR_GROUP_CHAR = '~';
 		KEY_VALUE_SEPARATOR_CHAR = '_';
 		TIMESTAMP_KEY = "ts"
-		COOKIE_VALIDITY_MINUTE_KEY = "cv";
+		COOKIE_VALIDITY_MINUTES_KEY = "cv";
 		EVENT_ID_KEY = "e";
 		EXTENDABLE_COOKIE_KEY = "ce";
 		HASH_KEY = "h";
@@ -14,7 +14,7 @@ module QueueIt
 		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 = ""
@@ -51,11 +51,11 @@ module QueueIt
 							rescue
 								result.timeStamp = 0					
 							end
-						when COOKIE_VALIDITY_MINUTE_KEY
+						when COOKIE_VALIDITY_MINUTES_KEY
 							begin
-								result.cookieValidityMinute = Integer(paramNameValueArr[1])
+								result.cookieValidityMinutes = Integer(paramNameValueArr[1])
 							rescue
-								result.cookieValidityMinute = nil
+								result.cookieValidityMinutes = nil
 							end
 						when EVENT_ID_KEY
 							result.eventId = paramNameValueArr[1]

data/lib/queueit_knownuserv3/user_in_queue_service.rb

@@ -3,25 +3,25 @@ require 'cgi'
 
 module QueueIt
 	class UserInQueueService
-		SDK_VERSION = "3.4.0"
+		SDK_VERSION = "3.5.1"
     
 		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)            			
 			end
         
 			queueParams = QueueUrlParams::extractQueueParams(queueitToken)
@@ -32,22 +32,21 @@ module QueueIt
 			end
 		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)) : "" )
+				@userInQueueStateRepository.cancelQueueCookie(cancelConfig.eventId, cancelConfig.cookieDomain)
+				query = getQueryString(customerId, cancelConfig.eventId, cancelConfig.version, nil, nil) + ( !Utils::isNilOrEmpty(targetUrl) ? ("&r=" +  CGI.escape(targetUrl)) : "" )
 			
-				domainAlias = config.queueDomain
+				domainAlias = cancelConfig.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)			
+				redirectUrl = "https://" + domainAlias + "cancel/" + customerId + "/" + cancelConfig.eventId + "/?" + query
+				return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, state.queueId, redirectUrl, state.redirectType)			
 			else
-				return RequestValidationResult.new(ActionTypes::CANCEL, config.eventId, nil, nil)			
+				return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, nil, nil, nil)			
 			end
 		end 
 
@@ -66,11 +65,11 @@ module QueueIt
 			@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)
 		end
 
 		def getVaidationErrorResult(customerId, targetUrl, config, qParams, errorCode) 
@@ -83,7 +82,7 @@ module QueueIt
 				domainAlias = domainAlias + "/"
 			end
 			redirectUrl = "https://" + domainAlias + "error/" + errorCode + "/?"  + query
-			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl)        
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil)        
 		end
 
 		def getInQueueRedirectResult(targetUrl, config, customerId) 
@@ -91,7 +90,7 @@ module QueueIt
 				"?" + 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)        
+			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil)        
 		end
 
 		def getQueryString(customerId, eventId, configVersion, culture, layoutName) 
@@ -109,12 +108,12 @@ module QueueIt
 			return queryStringList.join("&")
 		end
 
-		def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey) 
-			@userInQueueStateRepository.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)
+		def extendQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey) 
+			@userInQueueStateRepository.reissueQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey)
 		end
 
 		def getIgnoreActionResult()
-			return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil)
+			return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil)
 		end
 	end
 end

data/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb

@@ -12,14 +12,12 @@ module QueueIt
 
 		def cancelQueueCookie(eventId, cookieDomain) 
 			cookieKey = self.class.getCookieKey(eventId)
-			@cookieManager.setCookie(cookieKey, nil, -1, cookieDomain)		
+			@cookieManager.setCookie(cookieKey, nil, -1, cookieDomain)
 		end
 
-		def store(eventId, queueId, isStateExtendable, cookieValidityMinute, cookieDomain, secretKey)
+		def store(eventId, queueId, fixedCookieValidityMinutes, cookieDomain, redirectType, 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)
+			cookieValue = createCookieValue(eventId, queueId, Utils.toString(fixedCookieValidityMinutes), redirectType, secretKey)
 			@cookieManager.setCookie(cookieKey, cookieValue, Time.now + (24*60*60), cookieDomain)
 		end
 
@@ -27,19 +25,22 @@ module QueueIt
 			 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        
+		def createCookieValue(eventId, queueId, fixedCookieValidityMinutes, redirectType, secretKey) 
+			issueTime = Time.now.getutc.tv_sec.to_s
+			hashValue = generateHash(eventId, queueId, fixedCookieValidityMinutes, redirectType, issueTime, secretKey)
+			
+			fixedCookieValidityMinutesPart = ""
+			if(!Utils.isNilOrEmpty(fixedCookieValidityMinutes))
+				fixedCookieValidityMinutesPart = "&FixedValidityMins=" + fixedCookieValidityMinutes
+			end
+		
+			cookieValue = "EventId=" + eventId + "&QueueId=" + queueId + fixedCookieValidityMinutesPart + "&RedirectType=" + redirectType + "&IssueTime=" + issueTime + "&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)
@@ -49,34 +50,72 @@ module QueueIt
 			return result
 		end
 
-		def isCookieValid(cookieNameValueMap, secretKey) 
+		def generateHash(eventId, queueId, fixedCookieValidityMinutes, redirectType, issueTime, secretKey)
+			OpenSSL::HMAC.hexdigest('sha256', secretKey, eventId + queueId + fixedCookieValidityMinutes + redirectType + issueTime)
+		end
+
+		def isCookieValid(secretKey, cookieNameValueMap, eventId, cookieValidityMinutes, validateTime) 
 			begin
-				if (!cookieNameValueMap.key?("IsCookieExtendable")) 
+				if (!cookieNameValueMap.key?("EventId")) 
 					return false
 				end
-				if (!cookieNameValueMap.key?("Expires")) 
+				
+				if (!cookieNameValueMap.key?("QueueId")) 
 					return false
 				end
-				if (!cookieNameValueMap.key?("Hash")) 
+				
+				if (!cookieNameValueMap.key?("RedirectType")) 
 					return false
 				end
-				if (!cookieNameValueMap.key?("QueueId")) 
+				
+				if (!cookieNameValueMap.key?("IssueTime")) 
+					return false
+				end
+				
+				if (!cookieNameValueMap.key?("Hash")) 
 					return false
 				end
-				hashValue = OpenSSL::HMAC.hexdigest('sha256', secretKey, cookieNameValueMap["QueueId"] + cookieNameValueMap["IsCookieExtendable"] + cookieNameValueMap["Expires"]) 
+
+				fixedCookieValidityMinutes = ""
+				if (cookieNameValueMap.key?("FixedValidityMins")) 
+					fixedCookieValidityMinutes = cookieNameValueMap["FixedValidityMins"]
+				end
+				
+				hashValue = generateHash(
+					cookieNameValueMap["EventId"], 
+					cookieNameValueMap["QueueId"],
+					fixedCookieValidityMinutes,
+					cookieNameValueMap["RedirectType"],
+					cookieNameValueMap["IssueTime"],
+					secretKey)
+				
 				if (hashValue != cookieNameValueMap["Hash"]) 
 					return false
-				end		
-				if(Integer(cookieNameValueMap["Expires"]) < Time.now.getutc.tv_sec) 
+				end						
+				
+				if (eventId.upcase != cookieNameValueMap["EventId"].upcase) 
 					return false
 				end
-				return true
+				
+				if(validateTime)
+					validity = cookieValidityMinutes
+					if(!Utils.isNilOrEmpty(fixedCookieValidityMinutes))
+						validity = fixedCookieValidityMinutes.to_i
+					end
+					
+					expirationTime = cookieNameValueMap["IssueTime"].to_i + (validity*60)
+					if(expirationTime < Time.now.getutc.tv_sec)
+						return false
+					end
+				end        		
+				
+				return true			
 			rescue
 				return false
 			end
 		end
 
-		def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)       
+		def reissueQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey)       
 			cookieKey = self.class.getCookieKey(eventId)
 			cookieValue = @cookieManager.getCookie(cookieKey)
 			if (cookieValue.nil?) 
@@ -84,42 +123,63 @@ module QueueIt
 			end
        
 			cookieNameValueMap = getCookieNameValueMap(cookieValue)
-			if (!isCookieValid(cookieNameValueMap, secretKey)) 
+			if (!isCookieValid(secretKey, cookieNameValueMap, eventId, cookieValidityMinutes, true)) 
 				return 
 			end
-			expirationTime = (Time.now.getutc.tv_sec + (cookieValidityMinute * 60)).to_s
-			cookieValue = createCookieValue(cookieNameValueMap["QueueId"], cookieNameValueMap["IsCookieExtendable"], expirationTime, secretKey)
+
+			fixedCookieValidityMinutes = ""
+			if (cookieNameValueMap.key?("FixedValidityMins")) 
+				fixedCookieValidityMinutes = cookieNameValueMap["FixedValidityMins"]
+			end
+
+			cookieValue = createCookieValue(
+				eventId, 
+				cookieNameValueMap["QueueId"], 
+				fixedCookieValidityMinutes, 
+				cookieNameValueMap["RedirectType"], 
+				secretKey)
+			
 			@cookieManager.setCookie(cookieKey, cookieValue, Time.now + (24*60*60), cookieDomain)
 		end
 
-		def getState(eventId, secretKey) 
+		def getState(eventId, cookieValidityMinutes, secretKey, validateTime) 
 			cookieKey = cookieKey = self.class.getCookieKey(eventId)
 			if (@cookieManager.getCookie(cookieKey).nil?) 
-				return StateInfo.new(false, nil, false, 0)
+				return StateInfo.new(false, nil, nil, nil)
 			end
 			cookieNameValueMap = getCookieNameValueMap(@cookieManager.getCookie(cookieKey))
-			if (!isCookieValid(cookieNameValueMap, secretKey))
-				return StateInfo.new(false, nil, false,0)
+			if (!isCookieValid(secretKey, cookieNameValueMap, eventId, cookieValidityMinutes, validateTime))
+				return StateInfo.new(false, nil, nil, nil)
 			end
+
+			fixedCookieValidityMinutes = nil
+			if (cookieNameValueMap.key?("FixedValidityMins")) 
+				fixedCookieValidityMinutes = cookieNameValueMap["FixedValidityMins"].to_i
+			end
+
 			return StateInfo.new(
 				true, 
 				cookieNameValueMap["QueueId"], 
-				cookieNameValueMap["IsCookieExtendable"] == 'true',
-				Integer(cookieNameValueMap["Expires"]))
+				fixedCookieValidityMinutes,
+				cookieNameValueMap["RedirectType"])
 		end
 	end
 
 	class StateInfo 
 		attr_reader :isValid
 		attr_reader :queueId
-		attr_reader :isStateExtendable    
-		attr_reader :expires # used just for unit tests
+		attr_reader :fixedCookieValidityMinutes
+		attr_reader :redirectType
 
-		def initialize(isValid, queueId, isStateExtendable, expires) 
+		def initialize(isValid, queueId, fixedCookieValidityMinutes, redirectType) 
 			@isValid = isValid
 			@queueId = queueId
-			@isStateExtendable = isStateExtendable
-			@expires = expires
+			@fixedCookieValidityMinutes = fixedCookieValidityMinutes
+			@redirectType = redirectType
+		end
+
+		def isStateExtendable
+			return @isValid && @fixedCookieValidityMinutes.nil?
 		end
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queueit_knownuserv3
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.5.1
 platform: ruby
 authors:
 - Queue-it
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-18 00:00:00.000000000 Z
+date: 2018-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler