queueit_knownuserv3 3.5.1 → 3.6.0

data/.devcontainer/Dockerfile

@@ -0,0 +1,43 @@
+#-------------------------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See https://go.microsoft.com/fwlink/?linkid=2090316 for license information.
+#-------------------------------------------------------------------------------------------------------------
+
+FROM ruby:1.9.3
+
+# Avoid warnings by switching to noninteractive
+ENV DEBIAN_FRONTEND=noninteractive
+
+# This Dockerfile adds a non-root 'vscode' user with sudo access. However, for Linux,
+# this user's GID/UID must match your local user UID/GID to avoid permission issues
+# with bind mounts. Update USER_UID / USER_GID if yours is not 1000. See
+# https://aka.ms/vscode-remote/containers/non-root-user for details.
+ARG USERNAME=vscode
+ARG USER_UID=1000
+ARG USER_GID=$USER_UID
+
+# Configure apt and install packages
+RUN apt-get update \
+    && apt-get -y install --no-install-recommends apt-utils dialog 2>&1 \
+    # Verify git, process tools installed
+    && apt-get -y install git iproute2 procps lsb-release \
+    #
+    # Install ruby-debug-ide and ruby-debug-base19x
+    #&& gem install ruby-debug-ide \
+    #&& gem install ruby-debug-base19x \
+    #
+    # Create a non-root user to use if preferred - see https://aka.ms/vscode-remote/containers/non-root-user.
+    && groupadd --gid $USER_GID $USERNAME \
+    && useradd -s /bin/bash --uid $USER_UID --gid $USER_GID -m $USERNAME \
+    # [Optional] Add sudo support for the non-root user
+    && apt-get install -y sudo \
+    && echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME\
+    && chmod 0440 /etc/sudoers.d/$USERNAME \
+    #
+    # Clean up
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf /var/lib/apt/lists/*
+
+# Switch back to dialog for any ad-hoc use of apt-get
+ENV DEBIAN_FRONTEND=

data/.devcontainer/devcontainer.json

@@ -0,0 +1,30 @@
+// For format details, see https://aka.ms/vscode-remote/devcontainer.json or the definition README at
+// https://github.com/microsoft/vscode-dev-containers/tree/master/containers/ruby-2
+{
+	"name": "Ruby",
+	"dockerFile": "Dockerfile",
+
+	// Use 'settings' to set *default* container specific settings.json values on container create. 
+	// You can edit these settings after create using File > Preferences > Settings > Remote.
+	"settings": { 
+		"terminal.integrated.shell.linux": "/bin/bash"
+	},
+
+	"workspaceMount": "src=${localWorkspaceFolder},dst=/workspace,type=bind,consistency=delegated",
+	"workspaceFolder": "/workspace",
+	// Uncomment the next line if you want to publish any ports.
+	// "appPort": [],
+
+	// Uncomment the next line to run commands after the container is created.
+	"postCreateCommand": "bundle install; gem install ruby-debug-ide -v 0.6.0; gem install ruby-debug-base19x",
+
+	// Uncomment the next line to use a non-root user. On Linux, this will prevent
+	// new files getting created as root, but you may need to update the USER_UID
+	// and USER_GID in .devcontainer/Dockerfile to match your user if not 1000.
+	// "runArgs": [ "-u", "vscode" ],
+
+	// Add the IDs of extensions you want installed when the container is created in the array below.
+	"extensions": [
+		"rebornix.Ruby"
+	]
+}

data/.vs/VSWorkspaceState.json

@@ -0,0 +1,9 @@
+{
+  "ExpandedNodes": [
+    "",
+    "\\test",
+    "\\test\\queueit_knownuserv3"
+  ],
+  "SelectedNode": "\\test\\test_queueit_knownuserv3.rb",
+  "PreviewInSolutionExplorer": false
+}

data/.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug",
+            "type": "Ruby",
+            "request": "launch",
+            "program": "${workspaceRoot}/test/test_queueit_knownuserv3.rb",
+            "cwd": "${workspaceRoot}"
+        }
+    ]
+}

data/ci-build.yml

@@ -0,0 +1,17 @@
+# Starter pipeline
+# Start with a minimal pipeline that you can customize to build and deploy your code.
+# Add steps that build, run tests, deploy, and more:
+# https://aka.ms/yaml
+
+trigger:
+- master
+
+pool:
+  name: 'Default'
+
+steps:
+- task: Docker@2
+  inputs:
+    command: 'buildAndPush'
+    Dockerfile: '**/test/Dockerfile'
+    buildContext: './'

data/lib/queueit_knownuserv3.rb

@@ -1,5 +1,6 @@
 require_relative "queueit_knownuserv3/known_user"
 require_relative "queueit_knownuserv3/models"
+require_relative "queueit_knownuserv3/connector_diagnostics"
 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"

data/lib/queueit_knownuserv3/connector_diagnostics.rb

@@ -0,0 +1,69 @@
+module QueueIt
+    class ConnectorDiagnostics
+        attr_accessor :isEnabled
+        attr_accessor :hasError
+        attr_accessor :validationResult
+
+        def initialize
+            @isEnabled = false
+            @hasError = false
+            @validationResult = nil
+        end
+
+        def setStateWithTokenError(customerId, errorCode)
+            @hasError = true
+            @validationResult = RequestValidationResult.new(
+                "ConnectorDiagnosticsRedirect",
+                nil, nil, 
+                "https://" + customerId + ".api2.queue-it.net/" + customerId + "/diagnostics/connector/error/?code=" + errorCode, 
+                nil, nil)
+        end
+
+        def setStateWithSetupError()
+            @hasError = true
+            @validationResult = RequestValidationResult.new(
+                "ConnectorDiagnosticsRedirect",
+                nil, nil, 
+                "https://api2.queue-it.net/diagnostics/connector/error/?code=setup", 
+                nil, nil)
+        end
+
+        def self.verify(customerId, secretKey, queueitToken)
+            diagnostics = ConnectorDiagnostics.new
+
+            qParams = QueueUrlParams.extractQueueParams(queueitToken)
+
+            if(qParams == nil)
+                return diagnostics
+            end
+
+            if(qParams.redirectType == nil)
+                return diagnostics
+            end
+
+            if(not qParams.redirectType.upcase.eql?("DEBUG"))
+                return diagnostics
+            end
+
+            if(Utils.isNilOrEmpty(customerId) or Utils.isNilOrEmpty(secretKey))
+                diagnostics.setStateWithSetupError()
+                return diagnostics
+            end
+
+            calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, qParams.queueITTokenWithoutHash)
+            if(not qParams.hashCode.eql?(calculatedHash))
+                diagnostics.setStateWithTokenError(customerId, "hash")
+                return diagnostics
+            end
+                
+            if(qParams.timeStamp < Time.now.getutc.tv_sec)
+                diagnostics.setStateWithTokenError(customerId, "timestamp")
+                return diagnostics
+			end
+            
+            diagnostics.isEnabled = true
+
+            return diagnostics
+        end            
+    end
+end

data/lib/queueit_knownuserv3/integration_config_helpers.rb

@@ -211,12 +211,6 @@ module QueueIt
 					return ComparisonOperatorHelper.equals(value, valueToCompare, isNegative, ignoreCase)
 				when "Contains" 
 					return ComparisonOperatorHelper.contains(value, valueToCompare, isNegative, ignoreCase)
-				when "StartsWith"
-					return ComparisonOperatorHelper.startsWith(value, valueToCompare, isNegative, ignoreCase)
-				when "EndsWith"
-					return ComparisonOperatorHelper.endsWith(value, valueToCompare, isNegative, ignoreCase)
-				when "MatchesWith"
-					return ComparisonOperatorHelper.matchesWith(value, valueToCompare, isNegative, ignoreCase)
 				when "EqualsAny"
 					return ComparisonOperatorHelper.equalsAny(value, valuesToCompare, isNegative, ignoreCase)
 				when "ContainsAny"
@@ -241,7 +235,7 @@ module QueueIt
 		end
 
 		def self.contains(value, valueToCompare, isNegative, ignoreCase)
-			if(valueToCompare.eql? "*")
+			if((valueToCompare.eql? "*") && !(value.empty? || value.nil?))
 				return true
 			end
 
@@ -258,49 +252,6 @@ module QueueIt
 			end
 		end
 
-		def self.startsWith(value, valueToCompare, isNegative, ignoreCase)
-			if(ignoreCase)
-				evaluation = value.upcase.start_with? valueToCompare.upcase
-			else
-				evaluation = value.start_with? valueToCompare
-			end
-
-			if(isNegative)
-				return !evaluation
-			else
-				return evaluation
-			end
-		end
-
-		def self.endsWith(value, valueToCompare, isNegative, ignoreCase)
-			if(ignoreCase)
-				evaluation = value.upcase.end_with? valueToCompare.upcase
-			else
-				evaluation = value.end_with? valueToCompare
-			end
-
-			if(isNegative)
-				return !evaluation
-			else
-				return evaluation
-			end
-		end
-
-		def self.matchesWith(value, valueToCompare, isNegative, ignoreCase)
-			if(ignoreCase)
-				pattern = Regexp.new(valueToCompare, Regexp::IGNORECASE) 
-			else
-				pattern = Regexp.new(valueToCompare)
-			end
-		
-			evaluation = pattern.match(value) != nil
-			if(isNegative)
-				return !evaluation
-			else
-				return evaluation
-			end
-		end
-
 		def self.equalsAny(value, valuesToCompare, isNegative, ignoreCase)
 			valuesToCompare.each do |valueToCompare|
 				if (ComparisonOperatorHelper.equals(value, valueToCompare, false, ignoreCase))

data/lib/queueit_knownuserv3/known_user.rb

@@ -51,26 +51,6 @@ module QueueIt
 		end
 		private_class_method :logMoreRequestDetails
 
-		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
@@ -86,9 +66,11 @@ module QueueIt
 		end
 		private_class_method :setDebugCookie
 
-		def self._resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries)
-			isDebug = getIsDebug(queueitToken, secretKey)
+		def self._resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, isDebug)
+			
 			if(isDebug)
+				debugEntries["SdkVersion"] = UserInQueueService::SDK_VERSION
+				debugEntries["Runtime"] = getRuntime()
 				debugEntries["TargetUrl"] = targetUrl
 				debugEntries["QueueitToken"] = queueitToken
 				debugEntries["OriginalUrl"] = getRealOriginalUrl(request)
@@ -137,10 +119,12 @@ module QueueIt
 		end
 		private_class_method :_resolveQueueRequestByLocalConfig
 	
-		def self._cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries)
-			targetUrl = generateTargetUrl(targetUrl, request)
-			isDebug = getIsDebug(queueitToken, secretKey)
+		def self._cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, isDebug)
+			targetUrl = generateTargetUrl(targetUrl, request)				
+
 			if(isDebug)
+				debugEntries["SdkVersion"] = UserInQueueService::SDK_VERSION
+				debugEntries["Runtime"] = getRuntime()
 				debugEntries["TargetUrl"] = targetUrl
 				debugEntries["QueueitToken"] = queueitToken
 				debugEntries["OriginalUrl"] = getRealOriginalUrl(request)
@@ -204,40 +188,64 @@ module QueueIt
 
 		def self.resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request)
 			debugEntries = Hash.new
+			connectorDiagnostics = ConnectorDiagnostics.verify(customerId, secretKey, queueitToken)
+			
+			if(connectorDiagnostics.hasError)
+				return connectorDiagnostics.validationResult
+			end
 			begin
 				targetUrl = generateTargetUrl(targetUrl, request)
-				return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries)
+				return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, connectorDiagnostics.isEnabled)
+			rescue Exception => e
+				if(connectorDiagnostics.isEnabled)
+					debugEntries["Exception"] = e.message
+				end
+				raise e
 			ensure
 				setDebugCookie(debugEntries, request.cookie_jar)
 			end
 		end
 
-		def self.validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationsConfigString, customerId, secretKey, 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."
+		def self.validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationConfigJson, customerId, secretKey, request)
+			debugEntries = Hash.new			
+			customerIntegration = Hash.new
+			connectorDiagnostics = ConnectorDiagnostics.verify(customerId, secretKey, queueitToken)
+			
+			if(connectorDiagnostics.hasError)
+				return connectorDiagnostics.validationResult
 			end
-
 			begin
-				customerIntegration = JSON.parse(integrationsConfigString)
-			
-				debugEntries = Hash.new		
-				isDebug = getIsDebug(queueitToken, secretKey)
-				if(isDebug)
-					debugEntries["ConfigVersion"] = customerIntegration["Version"]
+				if(connectorDiagnostics.isEnabled)
+					debugEntries["SdkVersion"] = UserInQueueService::SDK_VERSION
+					debugEntries["Runtime"] = getRuntime()				
 					debugEntries["PureUrl"] = currentUrlWithoutQueueITToken
 					debugEntries["QueueitToken"] = queueitToken
 					debugEntries["OriginalUrl"] = getRealOriginalUrl(request)
 					logMoreRequestDetails(debugEntries, request)
 				end
-			
+
+				customerIntegration = JSON.parse(integrationConfigJson)
+				
+				if(connectorDiagnostics.isEnabled)
+					if(customerIntegration.length != 0 and customerIntegration["Version"] != nil)
+						debugEntries["ConfigVersion"] = customerIntegration["Version"]
+					else
+						debugEntries["ConfigVersion"] = "NULL"
+					end
+				end
+
+				if(Utils.isNilOrEmpty(currentUrlWithoutQueueITToken))
+					raise KnownUserError, "currentUrlWithoutQueueITToken can not be nil or empty."
+				end
+
+				if(customerIntegration.length == 0 || customerIntegration["Version"] == nil)
+					raise KnownUserError, "integrationConfigJson is not valid json."
+				end
+
 				integrationEvaluator = IntegrationEvaluator.new
 				matchedConfig = integrationEvaluator.getMatchedIntegrationConfig(customerIntegration, currentUrlWithoutQueueITToken, request)
 
-				if(isDebug)
+				if(connectorDiagnostics.isEnabled)
 					if(matchedConfig == nil)
 						debugEntries["MatchedConfig"] = "NULL"
 					else
@@ -246,33 +254,37 @@ module QueueIt
 				end
 
 				if(matchedConfig == nil)
-					return RequestValidationResult.new(nil, nil, nil, nil, nil)
+					return RequestValidationResult.new(nil, nil, nil, nil, nil, nil)
 				end
 			
 				# unspecified or 'Queue' specified
 				if(!matchedConfig.key?("ActionType") || Utils.isNilOrEmpty(matchedConfig["ActionType"]) || matchedConfig["ActionType"].eql?(ActionTypes::QUEUE))
-					return handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
+					return handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, 
+								customerId, secretKey, matchedConfig, request, debugEntries, connectorDiagnostics.isEnabled)
 				
 				elsif(matchedConfig["ActionType"].eql?(ActionTypes::CANCEL))
-					return handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
+					return handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, 
+								customerId, secretKey, matchedConfig, request, debugEntries, connectorDiagnostics.isEnabled)
 					
 				# for all unknown types default to 'Ignore'
 				else
 					userInQueueService = getUserInQueueService(request.cookie_jar)
-					result = userInQueueService.getIgnoreActionResult()
+					result = userInQueueService.getIgnoreActionResult(matchedConfig["Name"])
 					result.isAjaxResult = isQueueAjaxCall(request)
 					
 					return result
 				end
-
-			rescue StandardError => stdErr
-				raise KnownUserError, "integrationConfiguration text was not valid: " + stdErr.message
+			rescue Exception => e
+				if(connectorDiagnostics.isEnabled)
+					debugEntries["Exception"] = e.message
+				end
+				raise e
 			ensure
 				setDebugCookie(debugEntries, request.cookie_jar)
 			end
 		end
 
-		def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
+		def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug)
 			queueConfig = QueueEventConfig.new
 			queueConfig.eventId = matchedConfig["EventId"]
 			queueConfig.queueDomain = matchedConfig["QueueDomain"]
@@ -282,7 +294,8 @@ module QueueIt
 			queueConfig.extendCookieValidity = matchedConfig["ExtendCookieValidity"]
 			queueConfig.cookieValidityMinute = matchedConfig["CookieValidityMinute"]
 			queueConfig.version = customerIntegration["Version"]
-			
+			queueConfig.actionName = matchedConfig["Name"]
+
 			case matchedConfig["RedirectLogic"]
 				when "ForcedTargetUrl"
 					targetUrl = matchedConfig["ForcedTargetUrl"]					
@@ -292,23 +305,34 @@ module QueueIt
 					targetUrl = generateTargetUrl(currentUrlWithoutQueueITToken, request)
 			end
 
-			return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries)		
+			return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, isDebug)		
 		end
 
-		def self.handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries)
+		def self.handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug)
 			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)
+			cancelConfig.actionName = matchedConfig["Name"]
+			
+			return _cancelRequestByLocalConfig(currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, isDebug)
 		end
 
 		def self.cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request)
 			debugEntries = Hash.new
+			connectorDiagnostics = ConnectorDiagnostics.verify(customerId, secretKey, queueitToken)
+			
+			if(connectorDiagnostics.hasError)
+				return connectorDiagnostics.validationResult
+			end
 			begin
-				return _cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries)
+				return _cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, connectorDiagnostics.isEnabled)
+			rescue Exception => e
+				if(connectorDiagnostics.isEnabled)
+					debugEntries["Exception"] = e.message
+				end
+				raise e
 			ensure
 				setDebugCookie(debugEntries, request.cookie_jar)
 			end
@@ -319,6 +343,10 @@ module QueueIt
 			# Therefore we need this method to be able to access the 'real' original url.
 			return request.env["rack.url_scheme"] + "://" + request.env["HTTP_HOST"] + request.original_fullpath
 		end
+
+		def self.getRuntime()
+			return RUBY_VERSION.to_s
+		end
 	end
 
 	class CookieManager

data/lib/queueit_knownuserv3/models.rb

@@ -11,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
@@ -18,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
 
@@ -43,6 +52,7 @@ module QueueIt
 		attr_accessor :cookieValidityMinute
 		attr_accessor :cookieDomain
 		attr_accessor :version
+		attr_accessor :actionName
 
 		def initialize
 			@eventId = nil
@@ -53,6 +63,7 @@ module QueueIt
 			@cookieValidityMinute = nil
 			@cookieDomain = nil
 			@version = nil
+			@actionName = "unspecified"
 		end
 
 		def toString
@@ -63,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
 
@@ -73,14 +85,16 @@ module QueueIt
 		attr_reader :queueId
 		attr_reader :redirectUrl
 		attr_reader :redirectType
+		attr_accessor :actionName
 		attr_accessor :isAjaxResult
 
-		def initialize(actionType, eventId, queueId, redirectUrl, redirectType)
+		def initialize(actionType, eventId, queueId, redirectUrl, redirectType, actionName)
 			@actionType = actionType
 			@eventId = eventId
 			@queueId = queueId
 			@redirectUrl = redirectUrl
 			@redirectType = redirectType
+			@actionName = actionName
 		end
 
 		def doRedirect
@@ -93,7 +107,7 @@ module QueueIt
 
 		def getAjaxRedirectUrl
 			if !Utils.isNilOrEmpty(@redirectUrl)				
-				return CGI.escape(@redirectUrl)				
+				return Utils.urlEncode(@redirectUrl)				
 			end
 			return ""		
 		end

data/lib/queueit_knownuserv3/queue_url_params.rb

@@ -1,13 +1,13 @@
 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_MINUTES_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
@@ -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_MINUTES_KEY
-							begin
-								result.cookieValidityMinutes = Integer(paramNameValueArr[1])
-							rescue
-								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 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,7 +3,8 @@ require 'cgi'
 
 module QueueIt
 	class UserInQueueService
-		SDK_VERSION = "3.5.1"
+		SDK_VERSION_NO = "3.6.0"
+		SDK_VERSION = "v3-ruby-" + SDK_VERSION_NO
     
 		def initialize(userInQueueStateRepository)
 			@userInQueueStateRepository = userInQueueStateRepository
@@ -21,14 +22,15 @@ module QueueIt
 						state.redirectType,
 						secretKey)
 				end
-				return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, state.queueId, nil, state.redirectType)            			
+				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)
+				return getQueueITTokenValidationResult(targetUrl, config, queueParams, customerId, secretKey)
 			else 
-				return getInQueueRedirectResult(targetUrl, config, customerId)
+				return cancelQueueCookieReturnQueueResult(targetUrl, config, customerId)
 			end
 		end
 
@@ -36,30 +38,27 @@ module QueueIt
 			state = @userInQueueStateRepository.getState(cancelConfig.eventId, -1, secretKey, false)
 			if (state.isValid)
 				@userInQueueStateRepository.cancelQueueCookie(cancelConfig.eventId, cancelConfig.cookieDomain)
-				query = getQueryString(customerId, cancelConfig.eventId, cancelConfig.version, nil, nil) + ( !Utils::isNilOrEmpty(targetUrl) ? ("&r=" +  CGI.escape(targetUrl)) : "" )
-			
-				domainAlias = cancelConfig.queueDomain
-				if (!domainAlias.end_with?("/") )
-					domainAlias = domainAlias + "/"
-				end
-			
-				redirectUrl = "https://" + domainAlias + "cancel/" + customerId + "/" + cancelConfig.eventId + "/?" + query
-				return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, state.queueId, redirectUrl, state.redirectType)			
+				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, cancelConfig.eventId, nil, nil, nil)			
+				return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, nil, nil, nil, cancelConfig.actionName)			
 			end
 		end 
 
-		def getQueueITTokenValidationResult(targetUrl, eventId, config, queueParams,customerId, secretKey) 
+		def getQueueITTokenValidationResult(targetUrl, 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")
+				return cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, queueParams, "hash")
 			end
-			if (queueParams.eventId.upcase() != eventId.upcase()) 
-				return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "eventid")
+			if (queueParams.eventId.upcase() != config.eventId.upcase()) 
+				return cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, queueParams, "eventid")
 			end
 			if (queueParams.timeStamp < Time.now.getutc.tv_sec) 
-				return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "timestamp")
+				return cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, queueParams, "timestamp")
 			end
 
 			@userInQueueStateRepository.store(
@@ -69,51 +68,63 @@ module QueueIt
 				!Utils::isNilOrEmpty(config.cookieDomain) ? config.cookieDomain : '',
 				queueParams.redirectType,
 				secretKey)
-			return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, queueParams.queueId, nil, queueParams.redirectType)
+			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 cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, qParams, errorCode) 
+			@userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain)
+
+			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, nil)        
+				(!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, nil)        
+		def cancelQueueCookieReturnQueueResult(targetUrl, config, customerId) 
+			@userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain)
+
+			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 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()
-			return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil)
+		def getIgnoreActionResult(actionName)
+			return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil, actionName)
 		end
 	end
 end

data/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb

@@ -143,7 +143,7 @@ module QueueIt
 		end
 
 		def getState(eventId, cookieValidityMinutes, secretKey, validateTime) 
-			cookieKey = cookieKey = self.class.getCookieKey(eventId)
+			cookieKey = self.class.getCookieKey(eventId)
 			if (@cookieManager.getCookie(cookieKey).nil?) 
 				return StateInfo.new(false, nil, nil, nil)
 			end

data/license.txt

@@ -0,0 +1,165 @@
+GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/queueit_knownuserv3.gemspec

@@ -5,7 +5,7 @@ require 'queueit_knownuserv3/user_in_queue_service'
 
 Gem::Specification.new do |spec|
   spec.name          = "queueit_knownuserv3"
-  spec.version       = QueueIt::UserInQueueService::SDK_VERSION
+  spec.version       = QueueIt::UserInQueueService::SDK_VERSION_NO
   spec.authors       = ["Queue-it"]
   spec.email         = ["support@queue-it.com"]
   spec.licenses      = "LGPL-3.0"
@@ -25,7 +25,4 @@ Gem::Specification.new do |spec|
   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

@@ -1,43 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: queueit_knownuserv3
 version: !ruby/object:Gem::Version
-  version: 3.5.1
+  version: 3.6.0
+  prerelease: 
 platform: ruby
 authors:
 - Queue-it
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-20 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'
+date: 2020-03-02 00:00:00.000000000 Z
+dependencies: []
 description: 
 email:
 - support@queue-it.com
@@ -45,40 +18,50 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .devcontainer/Dockerfile
+- .devcontainer/devcontainer.json
+- .vs/VSWorkspaceState.json
+- .vs/knownuser-v3-ruby/v16/.suo
+- .vs/slnx.sqlite
+- .vscode/launch.json
 - Gemfile
 - Rakefile
 - bin/console
 - bin/setup
+- ci-build.yml
 - lib/queueit_knownuserv3.rb
+- lib/queueit_knownuserv3/connector_diagnostics.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
+- license.txt
 - 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
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 1.8.23.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Gem for implementing Queue-it KnownUser V3
 test_files: []

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NWIwOWViMTkzYTAzOWQ2OThhYmNiNzM3NTRmOWRlYjYyNjg1YTc4NQ==
-  data.tar.gz: !binary |-
-    NmI4ZTJkYTM4MzNjYTcyMDU3N2UxMDdjMmMxNjE1MjRiYTlhZjkwNA==
-SHA512:
-  metadata.gz: !binary |-
-    ZmQxZGEwYTM5ZWE3ZTc5MzdlYzgzZWNhOWZkZjc2M2JiYTMyY2M0YjM1MDg5
-    ZGE1NTAwM2Q0YTcwMGE4ZWNmYmYyOTNiYzY0Mzk1OGQ5OWUwZjNlNjAyYmU3
-    YTRkN2VlNTg3NjI4ZTk3MTExYmI2MThkZmI4MGRjNWEyMTY5MTY=
-  data.tar.gz: !binary |-
-    ODg3OGY5Mjk4M2ZiMzIwOGRkZWZjZTVlMTA0NTViZmU5OTFiNmNkYzc0ZGU4
-    NTQ1ZTU0MzQ5MTlmMjE1YzYwMzEwZGYzOTkzMDdkMjBkOWY1YjIyMDA3OTI5
-    ZTVkZmE4NGIyZTIxODU2MWJmYjQxMWQ3ZDU4OGRmM2YxNmRlYTc=