version 3.6.1

Author: frwiqueueit

SDK/queueit_knownuserv3/user_in_queue_service.py

@@ -5,29 +5,13 @@
 
 
 class UserInQueueService:
-    SDK_VERSION = "v3-python-" + "3.6.0"
+    SDK_VERSION = "v3-python-" + "3.6.1"
 
     def __init__(self, httpContextProvider, userInQueueStateRepository):
         self.httpContextProvider = httpContextProvider
         self.userInQueueStateRepository = userInQueueStateRepository
 
-    def __getQueueITTokenValidationResult(self, targetUrl, eventId, config,
-                                          queueParams, customerId, secretKey):
-        calculatedHash = QueueitHelpers.hmacSha256Encode(
-            queueParams.queueITTokenWithoutHash, secretKey)
-
-        if (calculatedHash.upper() != queueParams.hashCode.upper()):
-            return self.__cancelQueueCookieReturnErrorResult(customerId, targetUrl,
-                                                  config, queueParams, "hash")
-
-        if (queueParams.eventId.upper() != eventId.upper()):
-            return self.__cancelQueueCookieReturnErrorResult(
-                customerId, targetUrl, config, queueParams, "eventid")
-
-        if (queueParams.timeStamp <
-                QueueitHelpers.getCurrentTime()):
-            return self.__cancelQueueCookieReturnErrorResult(
-                customerId, targetUrl, config, queueParams, "timestamp")
+    def __getValidTokenResult(self, config, queueParams, secretKey):
 
         cookieDomain = ""
         if (not Utils.isNilOrEmpty(config.cookieDomain)):
@@ -41,8 +25,7 @@ def __getQueueITTokenValidationResult(self, targetUrl, eventId, config,
                                        queueParams.queueId, None,
                                        queueParams.redirectType, config.actionName)
 
-    def __cancelQueueCookieReturnErrorResult(self, customerId, targetUrl, config, qParams, errorCode):
-        self.userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain)
+    def __getErrorResult(self, customerId, targetUrl, config, qParams, errorCode):
         timeStamp = str(QueueitHelpers.getCurrentTime())
         targetUrlParam = ""
         if (not Utils.isNilOrEmpty(targetUrl)):
@@ -55,8 +38,7 @@ def __cancelQueueCookieReturnErrorResult(self, customerId, targetUrl, config, qP
 
         return RequestValidationResult(ActionTypes.QUEUE, config.eventId, None, redirectUrl, None, config.actionName)
 
-    def __cancelQueueCookieReturnQueueResult(self, targetUrl, config, customerId):
-        self.userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain)
+    def __getQueueResult(self, targetUrl, config, customerId):
         targetUrlParam = ""
         if (not Utils.isNilOrEmpty(targetUrl)):
             targetUrlParam = "&t={}".format(QueueitHelpers.urlEncode(targetUrl))
@@ -93,6 +75,21 @@ def __getQueryString(self, customerId, eventId, configVersion, actionName, cultu
 
         return "&".join(queryStringList)
 
+    def __validateToken(self, config, queueParams, secretKey):
+        calculatedHash = QueueitHelpers.hmacSha256Encode(
+            queueParams.queueITTokenWithoutHash, secretKey)
+
+        if (calculatedHash.upper() != queueParams.hashCode.upper()):
+            return TokenValidationResult(False, "hash")
+
+        if (queueParams.eventId.upper() != config.eventId.upper()):
+            return TokenValidationResult(False, "eventid")
+
+        if (queueParams.timeStamp < QueueitHelpers.getCurrentTime()):
+            return TokenValidationResult(False, "timestamp")
+
+        return TokenValidationResult(True, None)
+
     def validateQueueRequest(self, targetUrl, queueitToken, config, customerId,
                              secretKey):
         state = self.userInQueueStateRepository.getState(
@@ -110,13 +107,24 @@ def validateQueueRequest(self, targetUrl, queueitToken, config, customerId,
             return result
 
         queueParams = QueueUrlParams.extractQueueParams(queueitToken)
+        requestValidationResult = RequestValidationResult(None, None, None, None, None, None)
+        isTokenValid = False
+
         if (queueParams is not None):
-            return self.__getQueueITTokenValidationResult(
-                targetUrl, config.eventId, config, queueParams, customerId,
-                secretKey)
+            tokenValidationResult = self.__validateToken(config, queueParams, secretKey)
+            isTokenValid = tokenValidationResult.isValid
+            if(isTokenValid):
+                requestValidationResult = self.__getValidTokenResult(config, queueParams, secretKey)
+            else:
+                requestValidationResult = self.__getErrorResult(customerId, targetUrl, config, queueParams,
+                                                                tokenValidationResult.errorCode)
         else:
-            return self.__cancelQueueCookieReturnQueueResult(targetUrl, config,
-                                                   customerId)
+            requestValidationResult = self.__getQueueResult(targetUrl, config, customerId)
+
+        if(state.isFound and not isTokenValid):
+            self.userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain)
+
+        return requestValidationResult
 
     def validateCancelRequest(self, targetUrl, cancelConfig, customerId,
                               secretKey):
@@ -148,4 +156,9 @@ def extendQueueCookie(self, eventId, cookieValidityMinutes, cookieDomain,
             eventId, cookieValidityMinutes, cookieDomain, secretKey)
 
     def getIgnoreActionResult(self, actionName):
-        return RequestValidationResult(ActionTypes.IGNORE, None, None, None, None, actionName)
+        return RequestValidationResult(ActionTypes.IGNORE, None, None, None, None, actionName)
+
+class TokenValidationResult:
+    def __init__(self, isValid, errorCode):
+        self.isValid = isValid
+        self.errorCode = errorCode

SDK/queueit_knownuserv3/user_in_queue_state_cookie_repository.py

@@ -108,26 +108,29 @@ def store(self, eventId, queueId, fixedCookieValidityMinutes, cookieDomain,
 
     def getState(self, eventId, cookieValidityMinutes, secretKey,
                  validateTime):
-        cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId)
+        try:
+            cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId)
 
-        if (self.httpContextProvider.getCookie(cookieKey) is None):
-            return StateInfo(False, None, None, None)
+            if (self.httpContextProvider.getCookie(cookieKey) is None):
+                return StateInfo(False, False, None, None, None)
 
-        cookieNameValueMap = UserInQueueStateCookieRepository.__getCookieNameValueMap(
-            self.httpContextProvider.getCookie(cookieKey))
-        if (not UserInQueueStateCookieRepository.__isCookieValid(
-                secretKey, cookieNameValueMap, eventId, cookieValidityMinutes,
-                validateTime)):
-            return StateInfo(False, None, None, None)
+            cookieNameValueMap = UserInQueueStateCookieRepository.__getCookieNameValueMap(
+                self.httpContextProvider.getCookie(cookieKey))
+            if (not UserInQueueStateCookieRepository.__isCookieValid(
+                    secretKey, cookieNameValueMap, eventId, cookieValidityMinutes,
+                    validateTime)):
+                return StateInfo(True, False, None, None, None)
 
-        fixedCookieValidityMinutes = None
-        if ("FixedValidityMins" in cookieNameValueMap):
-            fixedCookieValidityMinutes = int(
-                cookieNameValueMap["FixedValidityMins"])
+            fixedCookieValidityMinutes = None
+            if ("FixedValidityMins" in cookieNameValueMap):
+                fixedCookieValidityMinutes = int(
+                    cookieNameValueMap["FixedValidityMins"])
 
-        return StateInfo(True, cookieNameValueMap["QueueId"],
-                         fixedCookieValidityMinutes,
-                         cookieNameValueMap["RedirectType"])
+            return StateInfo(True, True, cookieNameValueMap["QueueId"],
+                             fixedCookieValidityMinutes,
+                             cookieNameValueMap["RedirectType"])
+        except:
+            return StateInfo(True, False, None, None, None)
 
     def cancelQueueCookie(self, eventId, cookieDomain):
         cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId)
@@ -163,8 +166,9 @@ def reissueQueueCookie(self, eventId, cookieValidityMinutes, cookieDomain,
 
 
 class StateInfo:
-    def __init__(self, isValid, queueId, fixedCookieValidityMinutes,
+    def __init__(self, isFound, isValid, queueId, fixedCookieValidityMinutes,
                  redirectType):
+        self.isFound = isFound
         self.isValid = isValid
         self.queueId = queueId
         self.fixedCookieValidityMinutes = fixedCookieValidityMinutes