queueit-knownuser - npm Package Compare versions

Comparing version 3.7.3 to 3.7.4

.mocharc.json

@@ -5,2 +5,2 @@ {
   "require": "ts-node/register"
-}
+}

dist/HttpContextProvider.d.ts

@@ -10,3 +10,3 @@ export interface IHttpRequest {
 export interface IHttpResponse {
-    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: number, httpOnly: boolean, isSecure: boolean): any;
+    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: number, isHttpOnly: boolean, isSecure: boolean): any;
 }
@@ -13,0 +13,0 @@ export interface IHttpContextProvider {

dist/HttpContextProvider.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=HttpContextProvider.js.map

dist/index.d.ts

 export { KnownUser } from "./KnownUser";
 export * from "./Models";
 export { Utils, QueueParameterHelper, QueueUrlParams } from "./QueueITHelpers";

dist/index.js

@@ -0,0 +0,0 @@ "use strict";

dist/IntegrationConfig/IntegrationConfigHelpers.d.ts

@@ -0,0 +0,0 @@ import * as IntegrationModels from './IntegrationConfigModel';

dist/IntegrationConfig/IntegrationConfigHelpers.js

@@ -0,0 +0,0 @@ "use strict";

dist/IntegrationConfig/IntegrationConfigModel.d.ts

@@ -0,0 +0,0 @@ export declare class IntegrationConfigModel {

dist/IntegrationConfig/IntegrationConfigModel.js

@@ -0,0 +0,0 @@ "use strict";

dist/KnownUser.d.ts

@@ -19,3 +19,3 @@ import { UserInQueueService } from './UserInQueueService';
     private static handleIgnoreAction;
-    static extendQueueCookie(eventId: string, cookieValidityMinute: number, cookieDomain: string, secretKey: string, httpContextProvider: IHttpContextProvider): void;
+    static extendQueueCookie(eventId: string, cookieValidityMinute: number, cookieDomain: string, isCookieHttpOnly: boolean, isCookieSecure: boolean, secretKey: string, httpContextProvider: IHttpContextProvider): void;
     static resolveQueueRequestByLocalConfig(targetUrl: string, queueitToken: string, queueConfig: QueueEventConfig, customerId: string, secretKey: string, httpContextProvider: IHttpContextProvider): RequestValidationResult;
@@ -22,0 +22,0 @@ static validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken: string, queueitToken: string, integrationsConfigString: string, customerId: string, secretKey: string, httpContextProvider: IHttpContextProvider): RequestValidationResult;

dist/KnownUser.js

@@ -147,3 +147,3 @@ "use strict";
     };
-    KnownUser.extendQueueCookie = function (eventId, cookieValidityMinute, cookieDomain, secretKey, httpContextProvider) {
+    KnownUser.extendQueueCookie = function (eventId, cookieValidityMinute, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey, httpContextProvider) {
         if (!eventId)
@@ -156,3 +156,3 @@ throw new Models_1.KnownUserException("eventId can not be null or empty.");
         var userInQueueService = this.getUserInQueueService(httpContextProvider);
-        userInQueueService.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey);
+        userInQueueService.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey);
     };
@@ -199,4 +199,4 @@ KnownUser.resolveQueueRequestByLocalConfig = function (targetUrl, queueitToken, queueConfig, customerId, secretKey, httpContextProvider) {
                 throw new Models_1.KnownUserException("integrationsConfigString can not be null or empty.");
-            var configEvaluater = new IntegrationConfigHelpers.IntegrationEvaluator();
-            var matchedConfig = configEvaluater.getMatchedIntegrationConfig(customerIntegrationInfo, currentUrlWithoutQueueITToken, httpContextProvider.getHttpRequest());
+            var configEvaluator = new IntegrationConfigHelpers.IntegrationEvaluator();
+            var matchedConfig = configEvaluator.getMatchedIntegrationConfig(customerIntegrationInfo, currentUrlWithoutQueueITToken, httpContextProvider.getHttpRequest());
             if (connectorDiagnostics.isEnabled) {
@@ -203,0 +203,0 @@ debugEntries["MatchedConfig"] = matchedConfig ? matchedConfig.Name : "NULL";

dist/Models.d.ts

@@ -0,0 +0,0 @@ export declare class QueueEventConfig {

dist/Models.js

@@ -0,0 +0,0 @@ "use strict";

dist/QueueITHelpers.d.ts

 import { RequestValidationResult } from './Models';
+export declare enum ErrorCode {
+    Hash = "hash",
+    Timestamp = "timestamp",
+    CookieSessionState = "connector/sessionstate"
+}
 export declare class Utils {
@@ -3,0 +8,0 @@ static encodeUrl(url: string): string;

dist/QueueITHelpers.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectorDiagnostics = exports.CookieHelper = exports.QueueParameterHelper = exports.QueueUrlParams = exports.Utils = void 0;
+exports.ConnectorDiagnostics = exports.CookieHelper = exports.QueueParameterHelper = exports.QueueUrlParams = exports.Utils = exports.ErrorCode = void 0;
 var Models_1 = require("./Models");
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["Hash"] = "hash";
+    ErrorCode["Timestamp"] = "timestamp";
+    ErrorCode["CookieSessionState"] = "connector/sessionstate";
+})(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {}));
 var Utils = /** @class */ (function () {
@@ -120,4 +126,3 @@ function Utils() {
             var result = {};
-            var decoded = cookieValue;
-            var items = decoded.split('&');
+            var items = cookieValue.split('&');
             for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
@@ -173,7 +178,7 @@ var item = items_1[_i];
         if (Utils.generateSHA256Hash(secretKey, qParams.queueITTokenWithoutHash) != qParams.hashCode) {
-            diagnostics.setStateWithTokenError(customerId, "hash");
+            diagnostics.setStateWithTokenError(customerId, ErrorCode.Hash);
             return diagnostics;
         }
         if (qParams.timeStamp < Utils.getCurrentTime()) {
-            diagnostics.setStateWithTokenError(customerId, "timestamp");
+            diagnostics.setStateWithTokenError(customerId, ErrorCode.Timestamp);
             return diagnostics;
@@ -180,0 +185,0 @@ }

dist/queueitknownuser.bundle.js

@@ -0,0 +0,0 @@ (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){

dist/UserInQueueService.d.ts

@@ -16,5 +16,5 @@ import { RequestValidationResult, QueueEventConfig, CancelEventConfig } from './Models';
     validateCancelRequest(targetUrl: string, config: CancelEventConfig, customerId: string, secretKey: string): RequestValidationResult;
-    extendQueueCookie(eventId: string, cookieValidityMinutes: number, cookieDomain: string, secretKey: string): void;
+    extendQueueCookie(eventId: string, cookieValidityMinutes: number, cookieDomain: string, isCookieHttpOnly: boolean, isCookieSecure: boolean, secretKey: string): void;
     getIgnoreResult(actionName: string): RequestValidationResult;
     private validateToken;
 }

dist/UserInQueueService.js

@@ -12,8 +12,9 @@ "use strict";
     UserInQueueService.prototype.getValidTokenResult = function (config, queueParams, secretKey) {
-        this.userInQueueStateRepository.store(config.eventId, queueParams.queueId, queueParams.cookieValidityMinutes, config.cookieDomain, config.isCookieHttpOnly, config.isCookieSecure, queueParams.redirectType, secretKey);
+        this.userInQueueStateRepository.store(config.eventId, queueParams.queueId, queueParams.cookieValidityMinutes, config.cookieDomain, config.isCookieHttpOnly, config.isCookieSecure, queueParams.redirectType, queueParams.hashedIp, secretKey);
         return new Models_1.RequestValidationResult(Models_1.ActionTypes.QueueAction, config.eventId, queueParams.queueId, null, queueParams.redirectType, config.actionName);
     };
-    UserInQueueService.prototype.getErrorResult = function (customerId, targetUrl, config, qParams, errorCode) {
-        var query = this.getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName, config.actionName) +
-            ("&queueittoken=" + qParams.queueITToken) +
+    UserInQueueService.prototype.getErrorResult = function (customerId, targetUrl, config, qParams, errorCode, state) {
+        var queueItTokenParam = qParams ? "&queueittoken=" + qParams.queueITToken : '';
+        var query = this.getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName, config.actionName, state.getInvalidCookieReason()) +
+            queueItTokenParam +
             ("&ts=" + QueueITHelpers_1.Utils.getCurrentTime()) +
@@ -25,3 +26,3 @@ (targetUrl ? "&t=" + QueueITHelpers_1.Utils.encodeUrl(targetUrl) : "");
     };
-    UserInQueueService.prototype.getQueueResult = function (targetUrl, config, customerId) {
+    UserInQueueService.prototype.getQueueResult = function (targetUrl, config, customerId, state) {
         var query = this.getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName, config.actionName) +
@@ -32,3 +33,3 @@ (targetUrl ? "&t=" + QueueITHelpers_1.Utils.encodeUrl(targetUrl) : "");
     };
-    UserInQueueService.prototype.getQueryString = function (customerId, eventId, configVersion, culture, layoutName, actionName) {
+    UserInQueueService.prototype.getQueryString = function (customerId, eventId, configVersion, culture, layoutName, actionName, invalidCookieReason) {
         var queryStringList = new Array();
@@ -44,2 +45,4 @@ queryStringList.push("c=" + QueueITHelpers_1.Utils.encodeUrl(customerId));
             queryStringList.push("l=" + QueueITHelpers_1.Utils.encodeUrl(layoutName));
+        if (invalidCookieReason)
+            queryStringList.push("icr=" + QueueITHelpers_1.Utils.encodeUrl(invalidCookieReason));
         return queryStringList.join("&");
@@ -56,21 +59,24 @@ };
             if (state.isStateExtendable() && config.extendCookieValidity) {
-                this.userInQueueStateRepository.store(config.eventId, state.queueId, null, config.cookieDomain, config.isCookieHttpOnly, config.isCookieSecure, state.redirectType, secretKey);
+                this.userInQueueStateRepository.store(config.eventId, state.queueId, null, config.cookieDomain, config.isCookieHttpOnly, config.isCookieSecure, state.redirectType, state.hashedIp, secretKey);
             }
             return new Models_1.RequestValidationResult(Models_1.ActionTypes.QueueAction, config.eventId, state.queueId, null, state.redirectType, config.actionName);
         }
-        var queueParams = QueueITHelpers_1.QueueParameterHelper.extractQueueParams(queueitToken);
+        var queueTokenParams = QueueITHelpers_1.QueueParameterHelper.extractQueueParams(queueitToken);
         var requestValidationResult;
         var isTokenValid = false;
-        if (queueParams != null) {
-            var tokenValidationResult = this.validateToken(config, queueParams, secretKey);
+        if (queueTokenParams) {
+            var tokenValidationResult = this.validateToken(config, queueTokenParams, secretKey);
             isTokenValid = tokenValidationResult.isValid;
             if (isTokenValid) {
-                requestValidationResult = this.getValidTokenResult(config, queueParams, secretKey);
+                requestValidationResult = this.getValidTokenResult(config, queueTokenParams, secretKey);
             }
             else {
-                requestValidationResult = this.getErrorResult(customerId, targetUrl, config, queueParams, tokenValidationResult.errorCode);
+                requestValidationResult = this.getErrorResult(customerId, targetUrl, config, queueTokenParams, tokenValidationResult.errorCode, state);
             }
         }
+        else if (state.isBoundToAnotherIp) {
+            requestValidationResult = this.getErrorResult(customerId, targetUrl, config, queueTokenParams, QueueITHelpers_1.ErrorCode.CookieSessionState, state);
+        }
         else {
-            requestValidationResult = this.getQueueResult(targetUrl, config, customerId);
+            requestValidationResult = this.getQueueResult(targetUrl, config, customerId, state);
         }
@@ -100,4 +106,4 @@ if (state.isFound && !isTokenValid) {
     };
-    UserInQueueService.prototype.extendQueueCookie = function (eventId, cookieValidityMinutes, cookieDomain, secretKey) {
-        this.userInQueueStateRepository.reissueQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey);
+    UserInQueueService.prototype.extendQueueCookie = function (eventId, cookieValidityMinutes, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey) {
+        this.userInQueueStateRepository.reissueQueueCookie(eventId, cookieValidityMinutes, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey);
     };
@@ -124,3 +130,3 @@ UserInQueueService.prototype.getIgnoreResult = function (actionName) {
     };
-    UserInQueueService.SDK_VERSION = "v3-javascript-" + "3.7.3";
+    UserInQueueService.SDK_VERSION = "v3-javascript-" + "3.7.4";
     return UserInQueueService;
@@ -127,0 +133,0 @@ }());

dist/UserInQueueStateCookieRepository.d.ts

 import { IHttpContextProvider } from './HttpContextProvider';
+export declare enum CookieValidationResult {
+    NotFound = 0,
+    Expired = 1,
+    WaitingRoomMismatch = 2,
+    HashMismatch = 3,
+    Error = 4,
+    Valid = 5,
+    IpBindingMismatch = 6
+}
+export declare class QueueItAcceptedCookie {
+    storedHash: string;
+    issueTimeString: string;
+    queueId: string;
+    eventIdFromCookie: string;
+    redirectType: string;
+    fixedCookieValidityMinutes: string;
+    isCookieHttpOnly: boolean;
+    isCookieSecure: boolean;
+    hashedIp: string;
+    constructor(storedHash: string, issueTimeString: string, queueId: string, eventIdFromCookie: string, redirectType: string, fixedCookieValidityMinutes: string, isCookieHttpOnly: boolean, isCookieSecure: boolean, hashedIp: string);
+    static readonly HashKey = "Hash";
+    static readonly IssueTimeKey = "IssueTime";
+    static readonly QueueIdKey = "QueueId";
+    static readonly EventIdKey = "EventId";
+    static readonly RedirectTypeKey = "RedirectType";
+    static readonly FixedCookieValidityMinutesKey = "FixedValidityMins";
+    static readonly IsCookieHttpOnly = "IsCookieHttpOnly";
+    static readonly IsCookieSecure = "IsCookieSecure";
+    static readonly HashedIpKey = "Hip";
+    static fromCookieHeader(cookieHeaderValue: any): QueueItAcceptedCookie;
+}
 export declare class UserInQueueStateCookieRepository {
     private httpContextProvider;
     private static readonly _QueueITDataKey;
-    private static readonly _HashKey;
-    private static readonly _IssueTimeKey;
-    private static readonly _QueueIdKey;
-    private static readonly _EventIdKey;
-    private static readonly _RedirectTypeKey;
-    private static readonly _FixedCookieValidityMinutesKey;
     private static readonly _IsCookieHttpOnly;
     private static readonly _IsCookieSecure;
+    private static readonly _HashedIpKey;
     constructor(httpContextProvider: IHttpContextProvider);
     static getCookieKey(eventId: string): string;
-    store(eventId: string, queueId: string, fixedCookieValidityMinutes: number | null, cookieDomain: string, isHttpOnly: boolean, isSecure: boolean, redirectType: string, secretKey: string): void;
+    store(eventId: string, queueId: string, fixedCookieValidityMinutes: number | null, cookieDomain: string, isCookieHttpOnly: boolean, isCookieSecure: boolean, redirectType: string, hashedIp: string | null, secretKey: string): void;
     private createCookie;
     getState(eventId: string, cookieValidityMinutes: number, secretKey: string, validateTime: boolean): StateInfo;
     private isCookieValid;
-    cancelQueueCookie(eventId: string, cookieDomain: string, isCookieHttpOnly: boolean, isSecure: boolean): void;
-    reissueQueueCookie(eventId: string, cookieValidityMinutes: number, cookieDomain: string, secretKey: string): void;
+    cancelQueueCookie(eventId: string, cookieDomain: string, isCookieHttpOnly: boolean, isCookieSecure: boolean): void;
+    reissueQueueCookie(eventId: string, cookieValidityMinutes: number, cookieDomain: string, isCookieHttpOnly: boolean, isCookieSecure: boolean, secretKey: string): void;
     private generateHash;
 }
 export declare class StateInfo {
-    isFound: any;
-    isValid: boolean;
     queueId: string;
     fixedCookieValidityMinutes: number | null;
     redirectType: string;
-    constructor(isFound: any, isValid: boolean, queueId: string, fixedCookieValidityMinutes: number | null, redirectType: string);
+    hashedIp: string | null;
+    cookieValidationResult: CookieValidationResult;
+    cookie: QueueItAcceptedCookie;
+    constructor(queueId: string, fixedCookieValidityMinutes: number | null, redirectType: string, hashedIp: string | null, cookieValidationResult: CookieValidationResult, cookie: QueueItAcceptedCookie);
+    get isValid(): boolean;
+    get isFound(): boolean;
+    get isBoundToAnotherIp(): boolean;
     isStateExtendable(): boolean;
+    getInvalidCookieReason(): string;
 }

dist/UserInQueueStateCookieRepository.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateInfo = exports.UserInQueueStateCookieRepository = void 0;
+exports.StateInfo = exports.UserInQueueStateCookieRepository = exports.QueueItAcceptedCookie = exports.CookieValidationResult = void 0;
 var QueueITHelpers_1 = require("./QueueITHelpers");
+var CookieValidationResult;
+(function (CookieValidationResult) {
+    CookieValidationResult[CookieValidationResult["NotFound"] = 0] = "NotFound";
+    CookieValidationResult[CookieValidationResult["Expired"] = 1] = "Expired";
+    CookieValidationResult[CookieValidationResult["WaitingRoomMismatch"] = 2] = "WaitingRoomMismatch";
+    CookieValidationResult[CookieValidationResult["HashMismatch"] = 3] = "HashMismatch";
+    CookieValidationResult[CookieValidationResult["Error"] = 4] = "Error";
+    CookieValidationResult[CookieValidationResult["Valid"] = 5] = "Valid";
+    CookieValidationResult[CookieValidationResult["IpBindingMismatch"] = 6] = "IpBindingMismatch";
+})(CookieValidationResult = exports.CookieValidationResult || (exports.CookieValidationResult = {}));
+var QueueItAcceptedCookie = /** @class */ (function () {
+    function QueueItAcceptedCookie(storedHash, issueTimeString, queueId, eventIdFromCookie, redirectType, fixedCookieValidityMinutes, isCookieHttpOnly, isCookieSecure, hashedIp) {
+        this.storedHash = storedHash;
+        this.issueTimeString = issueTimeString;
+        this.queueId = queueId;
+        this.eventIdFromCookie = eventIdFromCookie;
+        this.redirectType = redirectType;
+        this.fixedCookieValidityMinutes = fixedCookieValidityMinutes;
+        this.isCookieHttpOnly = isCookieHttpOnly;
+        this.isCookieSecure = isCookieSecure;
+        this.hashedIp = hashedIp;
+    }
+    QueueItAcceptedCookie.fromCookieHeader = function (cookieHeaderValue) {
+        var cookieValueMap = QueueITHelpers_1.CookieHelper.toMapFromValue(cookieHeaderValue);
+        var storedHash = cookieValueMap[QueueItAcceptedCookie.HashKey] || "";
+        var issueTimeString = cookieValueMap[QueueItAcceptedCookie.IssueTimeKey] || "";
+        var queueId = cookieValueMap[QueueItAcceptedCookie.QueueIdKey] || "";
+        var eventIdFromCookie = cookieValueMap[QueueItAcceptedCookie.EventIdKey] || "";
+        var redirectType = cookieValueMap[QueueItAcceptedCookie.RedirectTypeKey] || "";
+        var fixedCookieValidityMinutes = cookieValueMap[QueueItAcceptedCookie.FixedCookieValidityMinutesKey] || "";
+        var isCookieHttpOnly = cookieValueMap[QueueItAcceptedCookie.IsCookieHttpOnly] || false;
+        var isCookieSecure = cookieValueMap[QueueItAcceptedCookie.IsCookieSecure] || false;
+        var hashedIpValue = cookieValueMap[QueueItAcceptedCookie.HashedIpKey] || "";
+        return new QueueItAcceptedCookie(storedHash, issueTimeString, queueId, eventIdFromCookie, redirectType, fixedCookieValidityMinutes, isCookieHttpOnly, isCookieSecure, hashedIpValue);
+    };
+    QueueItAcceptedCookie.HashKey = "Hash";
+    QueueItAcceptedCookie.IssueTimeKey = "IssueTime";
+    QueueItAcceptedCookie.QueueIdKey = "QueueId";
+    QueueItAcceptedCookie.EventIdKey = "EventId";
+    QueueItAcceptedCookie.RedirectTypeKey = "RedirectType";
+    QueueItAcceptedCookie.FixedCookieValidityMinutesKey = "FixedValidityMins";
+    QueueItAcceptedCookie.IsCookieHttpOnly = "IsCookieHttpOnly";
+    QueueItAcceptedCookie.IsCookieSecure = "IsCookieSecure";
+    QueueItAcceptedCookie.HashedIpKey = "Hip";
+    return QueueItAcceptedCookie;
+}());
+exports.QueueItAcceptedCookie = QueueItAcceptedCookie;
 var UserInQueueStateCookieRepository = /** @class */ (function () {
@@ -12,24 +59,27 @@ function UserInQueueStateCookieRepository(httpContextProvider) {
     };
-    UserInQueueStateCookieRepository.prototype.store = function (eventId, queueId, fixedCookieValidityMinutes, cookieDomain, isHttpOnly, isSecure, redirectType, secretKey) {
-        isHttpOnly = isHttpOnly == null ? false : isHttpOnly;
-        isSecure = isSecure == null ? false : isSecure;
-        this.createCookie(eventId, queueId, fixedCookieValidityMinutes ? fixedCookieValidityMinutes.toString() : "", redirectType, cookieDomain, isHttpOnly, isSecure, secretKey);
+    UserInQueueStateCookieRepository.prototype.store = function (eventId, queueId, fixedCookieValidityMinutes, cookieDomain, isCookieHttpOnly, isCookieSecure, redirectType, hashedIp, secretKey) {
+        isCookieHttpOnly = isCookieHttpOnly == null ? false : isCookieHttpOnly;
+        isCookieSecure = isCookieSecure == null ? false : isCookieSecure;
+        this.createCookie(eventId, queueId, fixedCookieValidityMinutes ? fixedCookieValidityMinutes.toString() : "", redirectType, hashedIp, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey);
     };
-    UserInQueueStateCookieRepository.prototype.createCookie = function (eventId, queueId, fixedCookieValidityMinutes, redirectType, cookieDomain, isHttpOnly, isSecure, secretKey) {
+    UserInQueueStateCookieRepository.prototype.createCookie = function (eventId, queueId, fixedCookieValidityMinutes, redirectType, hashedIp, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey) {
         var cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId);
         var issueTime = QueueITHelpers_1.Utils.getCurrentTime().toString();
         var cookieValues = new Array();
-        cookieValues.push({ key: UserInQueueStateCookieRepository._EventIdKey, value: eventId });
-        cookieValues.push({ key: UserInQueueStateCookieRepository._QueueIdKey, value: queueId });
+        cookieValues.push({ key: QueueItAcceptedCookie.EventIdKey, value: eventId });
+        cookieValues.push({ key: QueueItAcceptedCookie.QueueIdKey, value: queueId });
         if (fixedCookieValidityMinutes) {
             cookieValues.push({
-                key: UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey,
+                key: QueueItAcceptedCookie.FixedCookieValidityMinutesKey,
                 value: fixedCookieValidityMinutes
             });
         }
-        cookieValues.push({ key: UserInQueueStateCookieRepository._RedirectTypeKey, value: redirectType.toLowerCase() });
-        cookieValues.push({ key: UserInQueueStateCookieRepository._IssueTimeKey, value: issueTime });
+        cookieValues.push({ key: QueueItAcceptedCookie.RedirectTypeKey, value: redirectType.toLowerCase() });
+        cookieValues.push({ key: QueueItAcceptedCookie.IssueTimeKey, value: issueTime });
+        if (hashedIp) {
+            cookieValues.push({ key: QueueItAcceptedCookie.HashedIpKey, value: hashedIp });
+        }
         cookieValues.push({
-            key: UserInQueueStateCookieRepository._HashKey,
-            value: this.generateHash(eventId.toLowerCase(), queueId, fixedCookieValidityMinutes, redirectType.toLowerCase(), issueTime, secretKey)
+            key: QueueItAcceptedCookie.HashKey,
+            value: this.generateHash(eventId.toLowerCase(), queueId, fixedCookieValidityMinutes, redirectType.toLowerCase(), issueTime, hashedIp, secretKey)
         });
@@ -39,5 +89,6 @@ var tomorrow = new Date();
         var expire = Math.floor(tomorrow.getTime() / 1000);
-        this.httpContextProvider.getHttpResponse().setCookie(cookieKey, QueueITHelpers_1.CookieHelper.toValueFromKeyValueCollection(cookieValues), cookieDomain, expire, isHttpOnly, isSecure);
+        this.httpContextProvider.getHttpResponse().setCookie(cookieKey, QueueITHelpers_1.CookieHelper.toValueFromKeyValueCollection(cookieValues), cookieDomain, expire, isCookieHttpOnly, isCookieSecure);
     };
     UserInQueueStateCookieRepository.prototype.getState = function (eventId, cookieValidityMinutes, secretKey, validateTime) {
+        var qitAcceptedCookie = null;
         try {
@@ -47,45 +98,48 @@ var cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId);
             if (!cookie)
-                return new StateInfo(false, false, "", null, "");
-            var cookieValues = QueueITHelpers_1.CookieHelper.toMapFromValue(cookie);
-            if (!this.isCookieValid(secretKey, cookieValues, eventId, cookieValidityMinutes, validateTime))
-                return new StateInfo(true, false, "", null, "");
-            return new StateInfo(true, true, cookieValues[UserInQueueStateCookieRepository._QueueIdKey], cookieValues[UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey]
-                ? parseInt(cookieValues[UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey])
-                : null, cookieValues[UserInQueueStateCookieRepository._RedirectTypeKey]);
+                return new StateInfo("", null, "", null, CookieValidationResult.NotFound, null);
+            qitAcceptedCookie = QueueItAcceptedCookie.fromCookieHeader(cookie);
+            var cookieValidationResult = this.isCookieValid(secretKey, qitAcceptedCookie, eventId, cookieValidityMinutes, validateTime);
+            if (cookieValidationResult != CookieValidationResult.Valid) {
+                return new StateInfo("", null, "", qitAcceptedCookie.hashedIp, cookieValidationResult, qitAcceptedCookie);
+            }
+            return new StateInfo(qitAcceptedCookie.queueId, qitAcceptedCookie.fixedCookieValidityMinutes
+                ? parseInt(qitAcceptedCookie.fixedCookieValidityMinutes)
+                : null, qitAcceptedCookie.redirectType, qitAcceptedCookie.hashedIp, CookieValidationResult.Valid, qitAcceptedCookie);
         }
         catch (ex) {
-            return new StateInfo(true, false, "", null, "");
+            return new StateInfo("", null, "", qitAcceptedCookie === null || qitAcceptedCookie === void 0 ? void 0 : qitAcceptedCookie.hashedIp, CookieValidationResult.Error, qitAcceptedCookie);
         }
     };
-    UserInQueueStateCookieRepository.prototype.isCookieValid = function (secretKey, cookieValueMap, eventId, cookieValidityMinutes, validateTime) {
+    UserInQueueStateCookieRepository.prototype.isCookieValid = function (secretKey, cookie, eventId, cookieValidityMinutes, validateTime) {
         try {
-            var storedHash = cookieValueMap[UserInQueueStateCookieRepository._HashKey] || "";
-            var issueTimeString = cookieValueMap[UserInQueueStateCookieRepository._IssueTimeKey] || "";
-            var queueId = cookieValueMap[UserInQueueStateCookieRepository._QueueIdKey] || "";
-            var eventIdFromCookie = cookieValueMap[UserInQueueStateCookieRepository._EventIdKey] || "";
-            var redirectType = cookieValueMap[UserInQueueStateCookieRepository._RedirectTypeKey] || "";
-            var fixedCookieValidityMinutes = cookieValueMap[UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey] || "";
-            var expectedHash = this.generateHash(eventIdFromCookie, queueId, fixedCookieValidityMinutes, redirectType, issueTimeString, secretKey);
-            if (expectedHash !== storedHash)
-                return false;
-            if (eventId.toLowerCase() !== eventIdFromCookie.toLowerCase())
-                return false;
+            var expectedHash = this.generateHash(cookie.eventIdFromCookie, cookie.queueId, cookie.fixedCookieValidityMinutes, cookie.redirectType, cookie.issueTimeString, cookie.hashedIp, secretKey);
+            if (expectedHash !== cookie.storedHash)
+                return CookieValidationResult.HashMismatch;
+            if (eventId.toLowerCase() !== cookie.eventIdFromCookie.toLowerCase())
+                return CookieValidationResult.WaitingRoomMismatch;
             if (validateTime) {
-                var validity = fixedCookieValidityMinutes ? parseInt(fixedCookieValidityMinutes) : cookieValidityMinutes;
-                var expirationTime = parseInt(issueTimeString) + validity * 60;
+                var validity = cookie.fixedCookieValidityMinutes ? parseInt(cookie.fixedCookieValidityMinutes) : cookieValidityMinutes;
+                var expirationTime = parseInt(cookie.issueTimeString) + validity * 60;
                 if (expirationTime < QueueITHelpers_1.Utils.getCurrentTime())
-                    return false;
+                    return CookieValidationResult.Expired;
             }
-            return true;
+            var userHostAddress = this.httpContextProvider.getHttpRequest().getUserHostAddress();
+            if (cookie.hashedIp && userHostAddress) {
+                var hashedUserHostAddress = QueueITHelpers_1.Utils.generateSHA256Hash(secretKey, userHostAddress);
+                if (cookie.hashedIp !== hashedUserHostAddress) {
+                    return CookieValidationResult.IpBindingMismatch;
+                }
+            }
+            return CookieValidationResult.Valid;
         }
         catch (_a) {
-            return false;
+            return CookieValidationResult.Error;
         }
     };
-    UserInQueueStateCookieRepository.prototype.cancelQueueCookie = function (eventId, cookieDomain, isCookieHttpOnly, isSecure) {
+    UserInQueueStateCookieRepository.prototype.cancelQueueCookie = function (eventId, cookieDomain, isCookieHttpOnly, isCookieSecure) {
         var cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId);
         this.httpContextProvider.getHttpResponse()
-            .setCookie(cookieKey, "", cookieDomain, 0, isCookieHttpOnly, isSecure);
+            .setCookie(cookieKey, "", cookieDomain, 0, isCookieHttpOnly, isCookieSecure);
     };
-    UserInQueueStateCookieRepository.prototype.reissueQueueCookie = function (eventId, cookieValidityMinutes, cookieDomain, secretKey) {
+    UserInQueueStateCookieRepository.prototype.reissueQueueCookie = function (eventId, cookieValidityMinutes, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey) {
         var cookieKey = UserInQueueStateCookieRepository.getCookieKey(eventId);
@@ -95,23 +149,23 @@ var cookie = this.httpContextProvider.getHttpRequest().getCookieValue(cookieKey);
             return;
-        var cookieValues = QueueITHelpers_1.CookieHelper.toMapFromValue(cookie);
-        if (!this.isCookieValid(secretKey, cookieValues, eventId, cookieValidityMinutes, true))
+        var qitAcceptedCookie = QueueItAcceptedCookie.fromCookieHeader(cookie);
+        if (!this.isCookieValid(secretKey, qitAcceptedCookie, eventId, cookieValidityMinutes, true))
             return;
         var fixedCookieValidityMinutes = "";
-        if (cookieValues[UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey])
-            fixedCookieValidityMinutes = cookieValues[UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey].toString();
-        this.createCookie(eventId, cookieValues[UserInQueueStateCookieRepository._QueueIdKey], fixedCookieValidityMinutes, cookieValues[UserInQueueStateCookieRepository._RedirectTypeKey], cookieDomain, cookieValues[UserInQueueStateCookieRepository._IsCookieHttpOnly], cookieValues[UserInQueueStateCookieRepository._IsCookieSecure], secretKey);
+        if (qitAcceptedCookie.fixedCookieValidityMinutes)
+            fixedCookieValidityMinutes = qitAcceptedCookie.fixedCookieValidityMinutes.toString();
+        this.createCookie(eventId, qitAcceptedCookie.queueId, fixedCookieValidityMinutes, qitAcceptedCookie.redirectType, qitAcceptedCookie.hashedIp, cookieDomain, isCookieHttpOnly, isCookieSecure, secretKey);
     };
-    UserInQueueStateCookieRepository.prototype.generateHash = function (eventId, queueId, fixedCookieValidityMinutes, redirectType, issueTime, secretKey) {
-        var valueToHash = eventId + queueId + fixedCookieValidityMinutes + redirectType + issueTime;
+    UserInQueueStateCookieRepository.prototype.generateHash = function (eventId, queueId, fixedCookieValidityMinutes, redirectType, issueTime, hashedIp, secretKey) {
+        var valueToHash = eventId
+            + queueId
+            + (fixedCookieValidityMinutes ? fixedCookieValidityMinutes : "")
+            + redirectType
+            + issueTime
+            + (hashedIp ? hashedIp : "");
         return QueueITHelpers_1.Utils.generateSHA256Hash(secretKey, valueToHash);
     };
     UserInQueueStateCookieRepository._QueueITDataKey = "QueueITAccepted-SDFrts345E-V3";
-    UserInQueueStateCookieRepository._HashKey = "Hash";
-    UserInQueueStateCookieRepository._IssueTimeKey = "IssueTime";
-    UserInQueueStateCookieRepository._QueueIdKey = "QueueId";
-    UserInQueueStateCookieRepository._EventIdKey = "EventId";
-    UserInQueueStateCookieRepository._RedirectTypeKey = "RedirectType";
-    UserInQueueStateCookieRepository._FixedCookieValidityMinutesKey = "FixedValidityMins";
     UserInQueueStateCookieRepository._IsCookieHttpOnly = "IsCookieHttpOnly";
     UserInQueueStateCookieRepository._IsCookieSecure = "IsCookieSecure";
+    UserInQueueStateCookieRepository._HashedIpKey = "Hip";
     return UserInQueueStateCookieRepository;
@@ -121,12 +175,68 @@ }());
 var StateInfo = /** @class */ (function () {
-    function StateInfo(isFound, isValid, queueId, fixedCookieValidityMinutes, redirectType) {
-        this.isFound = isFound;
-        this.isValid = isValid;
+    function StateInfo(queueId, fixedCookieValidityMinutes, redirectType, hashedIp, cookieValidationResult, cookie) {
         this.queueId = queueId;
         this.fixedCookieValidityMinutes = fixedCookieValidityMinutes;
         this.redirectType = redirectType;
+        this.hashedIp = hashedIp;
+        this.cookieValidationResult = cookieValidationResult;
+        this.cookie = cookie;
     }
+    Object.defineProperty(StateInfo.prototype, "isValid", {
+        get: function () {
+            return this.cookieValidationResult === CookieValidationResult.Valid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StateInfo.prototype, "isFound", {
+        get: function () {
+            return this.cookieValidationResult !== CookieValidationResult.NotFound;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(StateInfo.prototype, "isBoundToAnotherIp", {
+        get: function () {
+            return this.cookieValidationResult === CookieValidationResult.IpBindingMismatch;
+        },
+        enumerable: false,
+        configurable: true
+    });
     StateInfo.prototype.isStateExtendable = function () {
         return this.isValid && !this.fixedCookieValidityMinutes;
     };
+    StateInfo.prototype.getInvalidCookieReason = function () {
+        if (this.isValid) {
+            return "";
+        }
+        var details = new Array();
+        switch (this.cookieValidationResult) {
+            case CookieValidationResult.HashMismatch:
+                details.push("hash");
+                details.push("h:" + this.cookie.storedHash);
+                break;
+            case CookieValidationResult.Expired:
+                details.push("expired");
+                break;
+            case CookieValidationResult.Error:
+                details.push("error");
+                break;
+            case CookieValidationResult.NotFound:
+                break;
+            case CookieValidationResult.IpBindingMismatch:
+                details.push("ip");
+                details.push("hip:" + this.cookie.hashedIp);
+                break;
+        }
+        if (this.isFound) {
+            if (this.redirectType) {
+                details.push("r:" + this.redirectType);
+            }
+            if (this.queueId) {
+                details.push("q:" + this.queueId);
+            }
+            details.push("st:" + Date.now());
+        }
+        return details.join(",");
+    };
     return StateInfo;
@@ -133,0 +243,0 @@ }());

package.json

 {
   "name": "queueit-knownuser",
-  "version": "3.7.3",
+  "version": "3.7.4",
   "description": "SDK to integrate Queue-it into a javascript based server side application.",
@@ -12,3 +12,5 @@ "main": "dist/index.js",
     "browserify": "browserify . -s QueueIT.KnownUserV3.SDK -o dist/browserified.js",
-    "test": "mocha --recursive"
+    "test": "mocha --recursive",
+    "buildtest": "npm run build && npm run test",
+    "test:watch": "nodemon --watch test -x \"npm run test\""
   },
@@ -22,6 +24,6 @@ "keywords": [],
     "chai-string": "^1.5.0",
-    "mocha": "^9.1.2",
-    "ts-node": "^10.2.1",
-    "typescript": "^4.4.3"
+    "mocha": "^9.1.3",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.4.4"
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No README

Quality

Package does not have a README. This may indicate a failed publish or a low quality package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

268608

increased by13.25%

Number of package files

34

increased by6.25%

Lines of code

3889

increased by7.67%

Number of medium quality alerts

0

decreased by-100%

Number of lines in readme file

327

increased byInfinity%

No dependency changes