class QueueIt::KnownUser

Constants

QUEUEIT_AJAX_HEADER_KEY
QUEUEIT_DEBUG_KEY
QUEUEIT_TOKEN_KEY

Public Class Methods

cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 322
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, connectorDiagnostics.isEnabled)
        rescue Exception => e
                if(connectorDiagnostics.isEnabled)
                        debugEntries["Exception"] = e.message
                end
                raise e
        ensure
                setDebugCookie(debugEntries, request.cookie_jar)
        end
end
extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey, request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 171
def self.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey, request)
        if(Utils.isNilOrEmpty(eventId))
                raise KnownUserError, "eventId can not be nil or empty."
        end

        if(Utils.isNilOrEmpty(secretKey))
                raise KnownUserError, "secretKey can not be nil or empty."
        end

        minutes = convertToInt(cookieValidityMinute)
        if(minutes <= 0)
                raise KnownUserError, "cookieValidityMinute should be integer greater than 0."      
        end

        userInQueueService = getUserInQueueService(request.cookie_jar)
        userInQueueService.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey)
end
getRealOriginalUrl(request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 341
def self.getRealOriginalUrl(request)
        # RoR could modify request.original_url if request contains x-forwarded-host/proto http headers.
        # 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
getRuntime() click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 347
def self.getRuntime()
        return RUBY_VERSION.to_s
end
handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 311
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"]
        cancelConfig.actionName = matchedConfig["Name"]
        
        return _cancelRequestByLocalConfig(currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, isDebug)
end
handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 287
def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug)
        queueConfig = QueueEventConfig.new
        queueConfig.eventId = matchedConfig["EventId"]
        queueConfig.queueDomain = matchedConfig["QueueDomain"]
        queueConfig.layoutName = matchedConfig["LayoutName"]
        queueConfig.culture = matchedConfig["Culture"]
        queueConfig.cookieDomain = matchedConfig["CookieDomain"]
        queueConfig.extendCookieValidity = matchedConfig["ExtendCookieValidity"]
        queueConfig.cookieValidityMinute = matchedConfig["CookieValidityMinute"]
        queueConfig.version = customerIntegration["Version"]
        queueConfig.actionName = matchedConfig["Name"]

        case matchedConfig["RedirectLogic"]
                when "ForcedTargetUrl"
                        targetUrl = matchedConfig["ForcedTargetUrl"]                                       
                when "EventTargetUrl"
                        targetUrl = ''
                else
                        targetUrl = generateTargetUrl(currentUrlWithoutQueueITToken, request)
        end

        return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, isDebug)                
end
resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 189
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, connectorDiagnostics.isEnabled)
        rescue Exception => e
                if(connectorDiagnostics.isEnabled)
                        debugEntries["Exception"] = e.message
                end
                raise e
        ensure
                setDebugCookie(debugEntries, request.cookie_jar)
        end
end
validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationConfigJson, customerId, secretKey, request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 209
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
                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(connectorDiagnostics.isEnabled)
                        if(matchedConfig == nil)
                                debugEntries["MatchedConfig"] = "NULL"
                        else
                                debugEntries["MatchedConfig"] = matchedConfig["Name"]
                        end
                end

                if(matchedConfig == 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, connectorDiagnostics.isEnabled)
                
                elsif(matchedConfig["ActionType"].eql?(ActionTypes::CANCEL))
                        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(matchedConfig["Name"])
                        result.isAjaxResult = isQueueAjaxCall(request)
                        
                        return result
                end
        rescue Exception => e
                if(connectorDiagnostics.isEnabled)
                        debugEntries["Exception"] = e.message
                end
                raise e
        ensure
                setDebugCookie(debugEntries, request.cookie_jar)
        end
end

Private Class Methods

_cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, isDebug) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 122
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)
                if(cancelConfig == nil)
                        debugEntries["CancelConfig"] = "NULL"
                else
                        debugEntries["CancelConfig"] = cancelConfig.toString()
                end
                logMoreRequestDetails(debugEntries, request)
        end

        if(Utils.isNilOrEmpty(targetUrl))
                raise KnownUserError, "targetUrl can not be nil or empty."
        end

        if(Utils.isNilOrEmpty(customerId))
                raise KnownUserError, "customerId can not be nil or empty."
        end

        if(Utils.isNilOrEmpty(secretKey))
                raise KnownUserError, "secretKey can not be nil or empty."
        end

        if(cancelConfig == nil)
                raise KnownUserError, "cancelConfig can not be nil."
        end

        if(Utils.isNilOrEmpty(cancelConfig.eventId))
                raise KnownUserError, "cancelConfig.eventId can not be nil or empty."
        end

        if(Utils.isNilOrEmpty(cancelConfig.queueDomain))
                raise KnownUserError, "cancelConfig.queueDomain can not be nil or empty."
        end

        userInQueueService = getUserInQueueService(request.cookie_jar)
        result = userInQueueService.validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey)
        result.isAjaxResult = isQueueAjaxCall(request)
        
        return result
end
_resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, isDebug) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 69
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)
                if(queueConfig == nil)
                        debugEntries["QueueConfig"] = "NULL"
                else
                        debugEntries["QueueConfig"] = queueConfig.toString()
                end
                logMoreRequestDetails(debugEntries, request)
        end

        if(Utils.isNilOrEmpty(customerId))
                raise KnownUserError, "customerId can not be nil or empty."
        end

        if(Utils.isNilOrEmpty(secretKey))
                raise KnownUserError, "secretKey can not be nil or empty."
        end

        if(queueConfig == nil)
                raise KnownUserError, "queueConfig can not be nil."
        end

        if(Utils.isNilOrEmpty(queueConfig.eventId))
                raise KnownUserError, "queueConfig.eventId can not be nil or empty."
        end

        if(Utils.isNilOrEmpty(queueConfig.queueDomain))
                raise KnownUserError, "queueConfig.queueDomain can not be nil or empty."
        end

        minutes = convertToInt(queueConfig.cookieValidityMinute)
        if(minutes <= 0)
                raise KnownUserError, "queueConfig.cookieValidityMinute should be integer greater than 0."  
        end

        if(![true, false].include? queueConfig.extendCookieValidity)
                raise KnownUserError, "queueConfig.extendCookieValidity should be valid boolean."
        end

        userInQueueService = getUserInQueueService(request.cookie_jar)
        result = userInQueueService.validateQueueRequest(targetUrl, queueitToken, queueConfig, customerId, secretKey)
        result.isAjaxResult = isQueueAjaxCall(request)
        
        return result
end
convertToInt(value) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 33
def self.convertToInt(value)
        begin
                converted = Integer(value)
        rescue
                converted = 0
        end
        return converted
end
generateTargetUrl(originalTargetUrl, request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 25
def self.generateTargetUrl(originalTargetUrl, request)
        unless isQueueAjaxCall(request)
                return originalTargetUrl
        end                  
        return CGI::unescape(request.headers[QUEUEIT_AJAX_HEADER_KEY])                       
end
getUserInQueueService(cookieJar) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 11
def self.getUserInQueueService(cookieJar)
        if (@@userInQueueService == nil)
                return UserInQueueService.new(UserInQueueStateCookieRepository.new(CookieManager.new(cookieJar)))
        end

        return @@userInQueueService
end
isQueueAjaxCall(request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 20
def self.isQueueAjaxCall(request)
        return request.headers[QUEUEIT_AJAX_HEADER_KEY] != nil
end
logMoreRequestDetails(debugEntries, request) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 43
def self.logMoreRequestDetails(debugEntries, request)
        debugEntries["ServerUtcTime"] = Time.now.utc.iso8601
        debugEntries["RequestIP"] = request.remote_ip
        debugEntries["RequestHttpHeader_Via"] = request.headers["via"]
        debugEntries["RequestHttpHeader_Forwarded"] = request.headers["forwarded"]
        debugEntries["RequestHttpHeader_XForwardedFor"] = request.headers["x-forwarded-for"]
        debugEntries["RequestHttpHeader_XForwardedHost"] = request.headers["x-forwarded-host"]
        debugEntries["RequestHttpHeader_XForwardedProto"] = request.headers["x-forwarded-proto"]
end
setDebugCookie(debugEntries, cookieJar) click to toggle source
# File lib/queueit_knownuserv3/known_user.rb, line 54
def self.setDebugCookie(debugEntries, cookieJar)
        if(debugEntries == nil || debugEntries.length == 0)
                return
        end

        cookieManager = CookieManager.new(cookieJar)
        cookieValue = ''
        debugEntries.each do |entry|
                cookieValue << (entry[0].to_s + '=' + entry[1].to_s + '|')
        end
        cookieValue = cookieValue.chop # remove trailing char
        cookieManager.setCookie(QUEUEIT_DEBUG_KEY, cookieValue, nil, nil)
end