def verify(customer_id, secret_key, queueit_token): diagnostics = ConnectorDiagnostics() q_params = QueueUrlParams.extractQueueParams(queueit_token) if q_params is None: return diagnostics if q_params.redirectType is None: return diagnostics if q_params.redirectType != "debug": return diagnostics if Utils.isNilOrEmpty(customer_id) or Utils.isNilOrEmpty(secret_key): diagnostics.__setStateWithSetupError() return diagnostics expected_hash = QueueitHelpers.hmacSha256Encode( q_params.queueITTokenWithoutHash, secret_key) if q_params.hashCode != expected_hash: diagnostics.__setStateWithTokenError(customer_id, "hash") return diagnostics if q_params.timeStamp < QueueitHelpers.getCurrentTime(): diagnostics.__setStateWithTokenError(customer_id, "timestamp") return diagnostics diagnostics.isEnabled = True return diagnostics
def __resolveQueueRequestByLocalConfig(target_url, queueit_token, queue_config, customer_id, secret_key, http_context_provider, debug_entries, is_debug): if is_debug: debug_entries["SdkVersion"] = UserInQueueService.SDK_VERSION debug_entries["Connector"] = http_context_provider.getProviderName( ) debug_entries["Runtime"] = KnownUser.__getRunTime() debug_entries["TargetUrl"] = target_url debug_entries["QueueitToken"] = queueit_token debug_entries[ "OriginalUrl"] = http_context_provider.getOriginalRequestUrl() if queue_config is None: debug_entries["QueueConfig"] = "NULL" else: debug_entries["QueueConfig"] = queue_config.toString() KnownUser.__logMoreRequestDetails(debug_entries, http_context_provider) if Utils.isNilOrEmpty(customer_id): raise KnownUserError("customerId can not be none or empty.") if Utils.isNilOrEmpty(secret_key): raise KnownUserError("secretKey can not be none or empty.") if queue_config is None: raise KnownUserError("queueConfig can not be none.") if Utils.isNilOrEmpty(queue_config.eventId): raise KnownUserError( "queueConfig.eventId can not be none or empty.") if Utils.isNilOrEmpty(queue_config.queueDomain): raise KnownUserError( "queueConfig.queueDomain can not be none or empty.") minutes = QueueitHelpers.convertToInt( queue_config.cookieValidityMinute) if minutes <= 0: raise KnownUserError( "queueConfig.cookieValidityMinute should be integer greater than 0." ) if not isinstance(queue_config.extendCookieValidity, bool): raise KnownUserError( "queueConfig.extendCookieValidity should be valid boolean.") user_in_queue_service = KnownUser.__getUserInQueueService( http_context_provider) result = user_in_queue_service.validateQueueRequest( target_url, queueit_token, queue_config, customer_id, secret_key) result.isAjaxResult = KnownUser.__isQueueAjaxCall( http_context_provider) return result
def __cancelRequestByLocalConfig(target_url, queueit_token, cancel_config, customer_id, secret_key, http_context_provider, debug_entries, is_debug): target_url = KnownUser.__generateTargetUrl(target_url, http_context_provider) if is_debug: debug_entries["SdkVersion"] = UserInQueueService.SDK_VERSION debug_entries["Connector"] = http_context_provider.getProviderName( ) debug_entries["Runtime"] = KnownUser.__getRunTime() debug_entries["TargetUrl"] = target_url debug_entries["QueueitToken"] = queueit_token debug_entries[ "OriginalUrl"] = http_context_provider.getOriginalRequestUrl() if cancel_config is None: debug_entries["CancelConfig"] = "NULL" else: debug_entries["CancelConfig"] = cancel_config.toString() KnownUser.__logMoreRequestDetails(debug_entries, http_context_provider) if Utils.isNilOrEmpty(target_url): raise KnownUserError("targetUrl can not be none or empty.") if Utils.isNilOrEmpty(customer_id): raise KnownUserError("customerId can not be none or empty.") if Utils.isNilOrEmpty(secret_key): raise KnownUserError("secretKey can not be none or empty.") if cancel_config is None: raise KnownUserError("cancelConfig can not be none.") if Utils.isNilOrEmpty(cancel_config.eventId): raise KnownUserError( "cancelConfig.eventId can not be none or empty.") if Utils.isNilOrEmpty(cancel_config.queueDomain): raise KnownUserError( "cancelConfig.queueDomain can not be none or empty.") user_in_queue_service = KnownUser.__getUserInQueueService( http_context_provider) result = user_in_queue_service.validateCancelRequest( target_url, cancel_config, customer_id, secret_key) result.isAjaxResult = KnownUser.__isQueueAjaxCall( http_context_provider) return result
def __resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, httpContextProvider, debugEntries): isDebug = KnownUser.__getIsDebug(queueitToken, secretKey) if (isDebug): debugEntries["TargetUrl"] = targetUrl debugEntries["QueueitToken"] = queueitToken debugEntries[ "OriginalUrl"] = httpContextProvider.getOriginalRequestUrl() if (queueConfig == None): debugEntries["QueueConfig"] = "NULL" else: debugEntries["QueueConfig"] = queueConfig.toString() KnownUser.__logMoreRequestDetails(debugEntries, httpContextProvider) if (Utils.isNilOrEmpty(customerId)): raise KnownUserError("customerId can not be none or empty.") if (Utils.isNilOrEmpty(secretKey)): raise KnownUserError("secretKey can not be none or empty.") if (queueConfig == None): raise KnownUserError("queueConfig can not be none.") if (Utils.isNilOrEmpty(queueConfig.eventId)): raise KnownUserError( "queueConfig.eventId can not be none or empty.") if (Utils.isNilOrEmpty(queueConfig.queueDomain)): raise KnownUserError( "queueConfig.queueDomain can not be none or empty.") minutes = QueueitHelpers.convertToInt(queueConfig.cookieValidityMinute) if (minutes <= 0): raise KnownUserError( "queueConfig.cookieValidityMinute should be integer greater than 0." ) if (queueConfig.extendCookieValidity != True and queueConfig.extendCookieValidity != False): raise KnownUserError( "queueConfig.extendCookieValidity should be valid boolean.") userInQueueService = KnownUser.__getUserInQueueService( httpContextProvider) result = userInQueueService.validateQueueRequest( targetUrl, queueitToken, queueConfig, customerId, secretKey) result.isAjaxResult = KnownUser.__isQueueAjaxCall(httpContextProvider) return result
def validateCancelRequest(self, targetUrl, cancelConfig, customerId, secretKey): state = self.userInQueueStateRepository.getState( cancelConfig.eventId, -1, secretKey, False) if (state.isValid): self.userInQueueStateRepository.cancelQueueCookie( cancelConfig.eventId, cancelConfig.cookieDomain) targetUrlParam = "" if (not Utils.isNilOrEmpty(targetUrl)): targetUrlParam = "&r=" + QueueitHelpers.urlEncode( targetUrl) query = self.__getQueryString(customerId, cancelConfig.eventId, cancelConfig.version, None, None) + targetUrlParam domainAlias = cancelConfig.queueDomain if (not domainAlias.endswith("/")): domainAlias = domainAlias + "/" redirectUrl = "https://" + domainAlias + "cancel/" + customerId + "/" + cancelConfig.eventId + "/?" + query return RequestValidationResult(ActionTypes.CANCEL, cancelConfig.eventId, state.queueId, redirectUrl, state.redirectType) else: return RequestValidationResult( ActionTypes.CANCEL, cancelConfig.eventId, None, None, None)
def __getQueueITTokenValidationResult(self, targetUrl, eventId, config, queueParams, customerId, secretKey): calculatedHash = QueueitHelpers.hmacSha256Encode( queueParams.queueITTokenWithoutHash, secretKey) if (calculatedHash.upper() != queueParams.hashCode.upper()): return self.__getVaidationErrorResult(customerId, targetUrl, config, queueParams, "hash") if (queueParams.eventId.upper() != eventId.upper()): return self.__getVaidationErrorResult( customerId, targetUrl, config, queueParams, "eventid") if (queueParams.timeStamp < QueueitHelpers.getCurrentTime()): return self.__getVaidationErrorResult( customerId, targetUrl, config, queueParams, "timestamp") cookieDomain = "" if (not Utils.isNilOrEmpty(config.cookieDomain)): cookieDomain = config.cookieDomain self.userInQueueStateRepository.store( config.eventId, queueParams.queueId, queueParams.cookieValidityMinutes, cookieDomain, queueParams.redirectType, secretKey) return RequestValidationResult(ActionTypes.QUEUE, config.eventId, queueParams.queueId, None, queueParams.redirectType)
def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey, httpContextProvider): if (Utils.isNilOrEmpty(eventId)): raise KnownUserError("eventId can not be none or empty.") if (Utils.isNilOrEmpty(secretKey)): raise KnownUserError("secretKey can not be none or empty.") minutes = QueueitHelpers.convertToInt(cookieValidityMinute) if (minutes <= 0): raise KnownUserError( "cookieValidityMinute should be integer greater than 0.") userInQueueService = KnownUser.__getUserInQueueService( httpContextProvider) userInQueueService.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)
def __cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, httpContextProvider, debugEntries): targetUrl = KnownUser.__generateTargetUrl(targetUrl, httpContextProvider) isDebug = KnownUser.__getIsDebug(queueitToken, secretKey) if (isDebug): debugEntries["TargetUrl"] = targetUrl debugEntries["QueueitToken"] = queueitToken debugEntries[ "OriginalUrl"] = httpContextProvider.getOriginalRequestUrl() if (cancelConfig == None): debugEntries["CancelConfig"] = "NULL" else: debugEntries["CancelConfig"] = cancelConfig.toString() KnownUser.__logMoreRequestDetails(debugEntries, httpContextProvider) if (Utils.isNilOrEmpty(targetUrl)): raise KnownUserError("targetUrl can not be none or empty.") if (Utils.isNilOrEmpty(customerId)): raise KnownUserError("customerId can not be none or empty.") if (Utils.isNilOrEmpty(secretKey)): raise KnownUserError("secretKey can not be none or empty.") if (cancelConfig == None): raise KnownUserError("cancelConfig can not be none.") if (Utils.isNilOrEmpty(cancelConfig.eventId)): raise KnownUserError( "cancelConfig.eventId can not be none or empty.") if (Utils.isNilOrEmpty(cancelConfig.queueDomain)): raise KnownUserError( "cancelConfig.queueDomain can not be none or empty.") userInQueueService = KnownUser.__getUserInQueueService( httpContextProvider) result = userInQueueService.validateCancelRequest( targetUrl, cancelConfig, customerId, secretKey) result.isAjaxResult = KnownUser.__isQueueAjaxCall(httpContextProvider) return result
def __createCookieValue(eventId, queueId, fixedCookieValidityMinutes, redirectType, secretKey): issueTime = Utils.toString(QueueitHelpers.getCurrentTime()) hashValue = UserInQueueStateCookieRepository.__generateHash( eventId, queueId, fixedCookieValidityMinutes, redirectType, issueTime, secretKey) fixedCookieValidityMinutesPart = "" if (not Utils.isNilOrEmpty(fixedCookieValidityMinutes)): fixedCookieValidityMinutesPart = "&FixedValidityMins=" + fixedCookieValidityMinutes cookieValue = "EventId=" + eventId + "&QueueId=" + queueId + fixedCookieValidityMinutesPart + "&RedirectType=" + redirectType + "&IssueTime=" + issueTime + "&Hash=" + hashValue return cookieValue
def extendQueueCookie(event_id, cookie_validity_minute, cookie_domain, is_cookie_http_only, is_cookie_secure, secret_key, http_context_provider): if Utils.isNilOrEmpty(event_id): raise KnownUserError("eventId can not be none or empty.") if Utils.isNilOrEmpty(secret_key): raise KnownUserError("secretKey can not be none or empty.") minutes = QueueitHelpers.convertToInt(cookie_validity_minute) if minutes <= 0: raise KnownUserError( "cookieValidityMinute should be integer greater than 0.") user_in_queue_service = KnownUser.__getUserInQueueService( http_context_provider) user_in_queue_service.extendQueueCookie(event_id, cookie_validity_minute, cookie_domain, is_cookie_http_only, is_cookie_secure, secret_key)
def __getQueueResult(self, target_url, config, customer_id): target_url_param = "" if not Utils.isNilOrEmpty(target_url): target_url_param = "&t={}".format( QueueitHelpers.urlEncode(target_url)) query_string = self.__getQueryString(customer_id, config.eventId, config.version, config.actionName, config.culture, config.layoutName) query = "{}{}".format(query_string, target_url_param) redirect_url = self.__generateRedirectUrl(config.queueDomain, "", query) return RequestValidationResult(ActionTypes.QUEUE, config.eventId, None, redirect_url, None, config.actionName)
def __getQueryString(self, customer_id, event_id, config_version, action_name, culture, layout_name): query_string_list = [ "c=" + QueueitHelpers.urlEncode(customer_id), "e=" + QueueitHelpers.urlEncode(event_id), "ver=" + self.SDK_VERSION, "kupver=" + QueueitHelpers.urlEncode( self.httpContextProvider.getProviderName()) ] if config_version is None: config_version = "-1" query_string_list.append("cver=" + str(config_version)) query_string_list.append("man=" + QueueitHelpers.urlEncode(action_name)) if not Utils.isNilOrEmpty(culture): query_string_list.append("cid=" + QueueitHelpers.urlEncode(culture)) if not Utils.isNilOrEmpty(layout_name): query_string_list.append("l=" + QueueitHelpers.urlEncode(layout_name)) return "&".join(query_string_list)
def __getQueryString(self, customerId, eventId, configVersion, culture, layoutName): queryStringList = [] queryStringList.append( "c=" + QueueitHelpers.urlEncode(customerId)) queryStringList.append( "e=" + QueueitHelpers.urlEncode(eventId)) queryStringList.append("ver=v3-py_" + self.httpContextProvider.getProviderName() + "-" + self.SDK_VERSION) if (configVersion is None): configVersion = "-1" queryStringList.append("cver=" + str(configVersion)) if (not Utils.isNilOrEmpty(culture)): queryStringList.append( "cid=" + QueueitHelpers.urlEncode(culture)) if (not Utils.isNilOrEmpty(layoutName)): queryStringList.append( "l=" + QueueitHelpers.urlEncode(layoutName)) return "&".join(queryStringList)
def __getValidTokenResult(self, config, queue_params, secret_key): cookie_domain = "" if not Utils.isNilOrEmpty(config.cookieDomain): cookie_domain = config.cookieDomain self.userInQueueStateRepository.store( config.eventId, queue_params.queueId, queue_params.cookieValidityMinutes, cookie_domain, config.isCookieHttpOnly, config.isCookieSecure, queue_params.redirectType, secret_key) return RequestValidationResult(ActionTypes.QUEUE, config.eventId, queue_params.queueId, None, queue_params.redirectType, config.actionName)
def __getInQueueRedirectResult(self, targetUrl, config, customerId): targetUrlParam = "" if (not Utils.isNilOrEmpty(targetUrl)): targetUrlParam = "&t=" + QueueitHelpers.urlEncode( targetUrl) domainAlias = config.queueDomain if (not domainAlias.endswith("/")): domainAlias = domainAlias + "/" qs = self.__getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName) redirectUrl = "https://" + domainAlias + "?" + qs + targetUrlParam return RequestValidationResult(ActionTypes.QUEUE, config.eventId, None, redirectUrl, None)
def extractQueueParams(queueitToken): try: if (Utils.isNilOrEmpty(queueitToken)): return None result = QueueUrlParams() result.queueITToken = queueitToken paramsNameValueList = result.queueITToken.split( QueueUrlParams.KEY_VALUE_SEPARATOR_GROUP_CHAR) for pNameValue in paramsNameValueList: paramNameValueArr = pNameValue.split( QueueUrlParams.KEY_VALUE_SEPARATOR_CHAR) if (paramNameValueArr[0] == QueueUrlParams.TIMESTAMP_KEY): try: result.timeStamp = int(paramNameValueArr[1]) except: result.timeStamp = 0 elif (paramNameValueArr[0] == QueueUrlParams.COOKIE_VALIDITY_MINUTES_KEY): try: result.cookieValidityMinutes = int( paramNameValueArr[1]) except: result.cookieValidityMinutes = None elif (paramNameValueArr[0] == QueueUrlParams.EVENT_ID_KEY): result.eventId = paramNameValueArr[1] elif (paramNameValueArr[0] == QueueUrlParams.EXTENDABLE_COOKIE_KEY): if (paramNameValueArr[1].upper() == 'TRUE'): result.extendableCookie = True elif (paramNameValueArr[0] == QueueUrlParams.HASH_KEY): result.hashCode = paramNameValueArr[1] elif (paramNameValueArr[0] == QueueUrlParams.QUEUE_ID_KEY): result.queueId = paramNameValueArr[1] elif (paramNameValueArr[0] == QueueUrlParams.REDIRECT_TYPE_KEY ): result.redirectType = paramNameValueArr[1] hashValue = QueueUrlParams.KEY_VALUE_SEPARATOR_GROUP_CHAR + QueueUrlParams.HASH_KEY \ + QueueUrlParams.KEY_VALUE_SEPARATOR_CHAR \ + result.hashCode result.queueITTokenWithoutHash = result.queueITToken.replace( hashValue, "") return result except: return None
def __isCookieValid(secretKey, cookieNameValueMap, eventId, cookieValidityMinutes, validateTime): try: if ("EventId" not in cookieNameValueMap): return False if ("QueueId" not in cookieNameValueMap): return False if ("RedirectType" not in cookieNameValueMap): return False if ("IssueTime" not in cookieNameValueMap): return False if ("Hash" not in cookieNameValueMap): return False fixedCookieValidityMinutes = "" if ("FixedValidityMins" in cookieNameValueMap): fixedCookieValidityMinutes = cookieNameValueMap[ "FixedValidityMins"] hashValue = UserInQueueStateCookieRepository.__generateHash( cookieNameValueMap["EventId"], cookieNameValueMap["QueueId"], fixedCookieValidityMinutes, cookieNameValueMap["RedirectType"], cookieNameValueMap["IssueTime"], secretKey) if (hashValue != cookieNameValueMap["Hash"]): return False if (eventId.upper() != cookieNameValueMap["EventId"].upper()): return False if (validateTime): validity = cookieValidityMinutes if (not Utils.isNilOrEmpty(fixedCookieValidityMinutes)): validity = int(fixedCookieValidityMinutes) expirationTime = int( cookieNameValueMap["IssueTime"]) + (validity * 60) if (expirationTime < QueueitHelpers.getCurrentTime()): return False return True except: return False
def __isCookieValid(secret_key, cookie_name_value_map, event_id, cookie_validity_minutes, validate_time): try: if "EventId" not in cookie_name_value_map: return False if "QueueId" not in cookie_name_value_map: return False if "RedirectType" not in cookie_name_value_map: return False if "IssueTime" not in cookie_name_value_map: return False if "Hash" not in cookie_name_value_map: return False fixed_cookie_validity_minutes = "" if "FixedValidityMins" in cookie_name_value_map: fixed_cookie_validity_minutes = cookie_name_value_map["FixedValidityMins"] hash_value = UserInQueueStateCookieRepository.__generateHash( cookie_name_value_map["EventId"], cookie_name_value_map["QueueId"], fixed_cookie_validity_minutes, cookie_name_value_map["RedirectType"], cookie_name_value_map["IssueTime"], secret_key) if hash_value != cookie_name_value_map["Hash"]: return False if event_id.upper() != cookie_name_value_map["EventId"].upper(): return False if validate_time: validity = cookie_validity_minutes if not Utils.isNilOrEmpty(fixed_cookie_validity_minutes): validity = int(fixed_cookie_validity_minutes) expiration_time = int(cookie_name_value_map["IssueTime"]) + (validity * 60) if expiration_time < QueueitHelpers.getCurrentTime(): return False return True except: return False
def validateCancelRequest(self, target_url, cancel_config, customer_id, secret_key): state = self.userInQueueStateRepository.getState( cancel_config.eventId, -1, secret_key, False) if state.isValid: self.userInQueueStateRepository.cancelQueueCookie( cancel_config.eventId, cancel_config.cookieDomain, cancel_config.isCookieHttpOnly, cancel_config.isCookieSecure) target_url_param = "" if not Utils.isNilOrEmpty(target_url): target_url_param = "&r={}".format( QueueitHelpers.urlEncode(target_url)) query_string = self.__getQueryString(customer_id, cancel_config.eventId, cancel_config.version, cancel_config.actionName, None, None) query = "{}{}".format(query_string, target_url_param) uri_path = "cancel/{}/{}".format(customer_id, cancel_config.eventId) if state.queueId: uri_path = "{}/{}".format(uri_path, state.queueId) redirect_url = self.__generateRedirectUrl( cancel_config.queueDomain, uri_path, query) return RequestValidationResult(ActionTypes.CANCEL, cancel_config.eventId, state.queueId, redirect_url, state.redirectType, cancel_config.actionName) else: return RequestValidationResult(ActionTypes.CANCEL, cancel_config.eventId, None, None, None, cancel_config.actionName)
def __getVaidationErrorResult(self, customerId, targetUrl, config, qParams, errorCode): targetUrlParam = "" if (not Utils.isNilOrEmpty(targetUrl)): targetUrlParam = "&t=" + QueueitHelpers.urlEncode( targetUrl) query = self.__getQueryString( customerId, config.eventId, config.version, config.culture, config.layoutName ) + "&queueittoken=" + qParams.queueITToken + "&ts=" + str( QueueitHelpers.getCurrentTime()) + targetUrlParam domainAlias = config.queueDomain if (not domainAlias.endswith("/")): domainAlias = domainAlias + "/" redirectUrl = "https://" + domainAlias + "error/" + errorCode + "/?" + query return RequestValidationResult(ActionTypes.QUEUE, config.eventId, None, redirectUrl, None)
def __getErrorResult(self, customer_id, target_url, config, q_params, error_code): time_stamp = str(QueueitHelpers.getCurrentTime()) target_url_param = "" if not Utils.isNilOrEmpty(target_url): target_url_param = "&t={}".format( QueueitHelpers.urlEncode(target_url)) query_string = self.__getQueryString(customer_id, config.eventId, config.version, config.actionName, config.culture, config.layoutName) query = "{}&queueittoken={}&ts={}{}".format(query_string, q_params.queueITToken, time_stamp, target_url_param) redirect_url = self.__generateRedirectUrl( config.queueDomain, "error/{}/".format(error_code), query) return RequestValidationResult(ActionTypes.QUEUE, config.eventId, None, redirect_url, None, config.actionName)
def extractQueueParams(queueit_token): result = QueueUrlParams() if Utils.isNilOrEmpty(queueit_token): return None result.queueITToken = queueit_token params_name_value_list = result.queueITToken.split( QueueUrlParams.KEY_VALUE_SEPARATOR_GROUP_CHAR) for pNameValue in params_name_value_list: param_name_value_arr = pNameValue.split( QueueUrlParams.KEY_VALUE_SEPARATOR_CHAR) if len(param_name_value_arr) != 2: continue param_name = param_name_value_arr[0] param_value = param_name_value_arr[1] if param_name == QueueUrlParams.HASH_KEY: result.hashCode = param_value elif param_name == QueueUrlParams.TIMESTAMP_KEY: if not param_value.isdigit(): continue result.timeStamp = int(param_value) elif param_name == QueueUrlParams.COOKIE_VALIDITY_MINUTES_KEY: if not param_value.isdigit(): continue result.cookieValidityMinutes = int(param_value) elif param_name == QueueUrlParams.EVENT_ID_KEY: result.eventId = param_value elif param_name == QueueUrlParams.EXTENDABLE_COOKIE_KEY: if param_value.upper() == 'TRUE': result.extendableCookie = True elif param_name == QueueUrlParams.QUEUE_ID_KEY: result.queueId = param_value elif param_name == QueueUrlParams.REDIRECT_TYPE_KEY: result.redirectType = param_value hash_value = QueueUrlParams.KEY_VALUE_SEPARATOR_GROUP_CHAR + QueueUrlParams.HASH_KEY \ + QueueUrlParams.KEY_VALUE_SEPARATOR_CHAR \ + result.hashCode result.queueITTokenWithoutHash = result.queueITToken.replace( hash_value, "") return result
def isStateExtendable(self): return self.isValid and Utils.isNilOrEmpty( self.fixedCookieValidityMinutes)
def validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationsConfigString, customerId, secretKey, httpContextProvider): if (Utils.isNilOrEmpty(currentUrlWithoutQueueITToken)): raise KnownUserError( "currentUrlWithoutQueueITToken can not be none or empty.") if (Utils.isNilOrEmpty(integrationsConfigString)): raise KnownUserError( "integrationsConfigString can not be none or empty.") debugEntries = {} try: customerIntegration = QueueitHelpers.jsonParse( integrationsConfigString) isDebug = KnownUser.__getIsDebug(queueitToken, secretKey) if (isDebug): debugEntries["ConfigVersion"] = customerIntegration["Version"] debugEntries["PureUrl"] = currentUrlWithoutQueueITToken debugEntries["QueueitToken"] = queueitToken debugEntries[ "OriginalUrl"] = httpContextProvider.getOriginalRequestUrl( ) KnownUser.__logMoreRequestDetails(debugEntries, httpContextProvider) matchedConfig = IntegrationEvaluator().getMatchedIntegrationConfig( customerIntegration, currentUrlWithoutQueueITToken, httpContextProvider) if (isDebug): if (matchedConfig == None): debugEntries["MatchedConfig"] = "NULL" else: debugEntries["MatchedConfig"] = matchedConfig["Name"] if (matchedConfig is None): return RequestValidationResult(None, None, None, None, None) if (matchedConfig["ActionType"] == ActionTypes.QUEUE): return KnownUser.__handleQueueAction( currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, httpContextProvider, debugEntries) elif (matchedConfig["ActionType"] == ActionTypes.CANCEL): return KnownUser.__handleCancelAction( currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, httpContextProvider, debugEntries) else: # for all unknown types default to 'Ignore' userInQueueService = KnownUser.__getUserInQueueService( httpContextProvider) result = userInQueueService.getIgnoreActionResult() result.isAjaxResult = KnownUser.__isQueueAjaxCall( httpContextProvider) return result except StandardError as stdErr: raise KnownUserError( "integrationConfiguration text was not valid: " + stdErr.message) finally: KnownUser.__setDebugCookie(debugEntries, httpContextProvider) pass
def validateRequestByIntegrationConfig(current_url_without_queueit_token, queueit_token, integration_config_string, customer_id, secret_key, http_context_provider): debug_entries = {} connector_diagnostics = ConnectorDiagnostics.verify( customer_id, secret_key, queueit_token) if connector_diagnostics.hasError: return connector_diagnostics.validationResult try: if connector_diagnostics.isEnabled: debug_entries["SdkVersion"] = UserInQueueService.SDK_VERSION debug_entries[ "Connector"] = http_context_provider.getProviderName() debug_entries["Runtime"] = KnownUser.__getRunTime() debug_entries["PureUrl"] = current_url_without_queueit_token debug_entries["QueueitToken"] = queueit_token debug_entries[ "OriginalUrl"] = http_context_provider.getOriginalRequestUrl( ) KnownUser.__logMoreRequestDetails(debug_entries, http_context_provider) customer_integration = json.loads(integration_config_string) if connector_diagnostics.isEnabled: debug_entries["ConfigVersion"] = "NULL" if customer_integration and "Version" in customer_integration: debug_entries["ConfigVersion"] = customer_integration[ "Version"] if Utils.isNilOrEmpty(current_url_without_queueit_token): raise KnownUserError( "currentUrlWithoutQueueITToken can not be none or empty.") if not customer_integration or not customer_integration["Version"]: raise KnownUserError( "integrationsConfigString can not be none or empty.") matched_config = IntegrationEvaluator( ).getMatchedIntegrationConfig(customer_integration, current_url_without_queueit_token, http_context_provider) if connector_diagnostics.isEnabled: if matched_config is None: debug_entries["MatchedConfig"] = "NULL" else: debug_entries["MatchedConfig"] = matched_config["Name"] if matched_config is None: return RequestValidationResult(None, None, None, None, None, None) if matched_config["ActionType"] == ActionTypes.QUEUE: return KnownUser.__handleQueueAction( current_url_without_queueit_token, queueit_token, customer_integration, customer_id, secret_key, matched_config, http_context_provider, debug_entries, connector_diagnostics.isEnabled) elif matched_config["ActionType"] == ActionTypes.CANCEL: return KnownUser.__handleCancelAction( current_url_without_queueit_token, queueit_token, customer_integration, customer_id, secret_key, matched_config, http_context_provider, debug_entries, connector_diagnostics.isEnabled) else: # for all unknown types default to 'Ignore' user_in_queue_service = KnownUser.__getUserInQueueService( http_context_provider) result = user_in_queue_service.getIgnoreActionResult( matched_config['Name']) result.isAjaxResult = KnownUser.__isQueueAjaxCall( http_context_provider) return result except Exception as e: if connector_diagnostics.isEnabled: debug_entries["Exception"] = e.message raise e finally: KnownUser.__setDebugCookie(debug_entries, http_context_provider) pass