@cartesianui/js 1.0.0 → 2.1.0

package/{axis.js → cartesian.js}

@@ -1,39 +1,37 @@
-var axis = {};
-
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.tenancy = axis.tenancy || {};
+  cartesian.tenancy = cartesian.tenancy || {};
 
-  axis.tenancy.isEnabled = false;
-  axis.tenancy.headerAttribute = 'Axis-Host';
-  axis.tenancy.ignoreFeatureCheckForHostUsers = false;
+  cartesian.tenancy.isEnabled = false;
+  cartesian.tenancy.headerAttribute = 'Cartesian-Host';
+  cartesian.tenancy.ignoreFeatureCheckForHostUsers = false;
 
-  axis.tenancy.sides = {
+  cartesian.tenancy.sides = {
     TENANT: 1,
     HOST: 2,
   };
 
-  axis.tenancy.tenantIdCookieName = "Axis.TenantId";
+  cartesian.tenancy.tenantIdCookieName = "Cartesian.TenantId";
 
-  axis.tenancy.setTenantIdCookie = function (tenantId) {
+  cartesian.tenancy.setTenantIdCookie = function (tenantId) {
     if (tenantId) {
-      axis.utils.setCookieValue(
-        axis.tenancy.tenantIdCookieName,
+      cartesian.utils.setCookieValue(
+        cartesian.tenancy.tenantIdCookieName,
         tenantId.toString(),
         new Date(new Date().getTime() + 5 * 365 * 86400000), //5 years
-        axis.appPath,
-        axis.domain
+        cartesian.appPath,
+        cartesian.domain
       );
     } else {
-      axis.utils.deleteCookie(
-        axis.tenancy.tenantIdCookieName,
-        axis.appPath
+      cartesian.utils.deleteCookie(
+        cartesian.tenancy.tenantIdCookieName,
+        cartesian.appPath
       );
     }
   };
 
-  axis.tenancy.getTenantIdCookie = function () {
-    var value = axis.utils.getCookieValue(axis.tenancy.tenantIdCookieName);
+  cartesian.tenancy.getTenantIdCookie = function () {
+    var value = cartesian.utils.getCookieValue(cartesian.tenancy.tenantIdCookieName);
     if (!value) {
       return null;
     }
@@ -42,26 +40,26 @@ var axis = axis || {};
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
 
-  axis.localization = axis.localization || {};
+  cartesian.localization = cartesian.localization || {};
 
-  axis.localization.languages = [];
+  cartesian.localization.languages = [];
 
-  axis.localization.currentLanguage = {};
+  cartesian.localization.currentLanguage = {};
 
-  axis.localization.sources = [];
+  cartesian.localization.sources = [];
 
-  axis.localization.values = {};
+  cartesian.localization.values = {};
 
-  axis.localization.localize = function (key, sourceName) {
-    sourceName = sourceName || axis.localization.defaultSourceName;
+  cartesian.localization.localize = function (key, sourceName) {
+    sourceName = sourceName || cartesian.localization.defaultSourceName;
 
-    var source = axis.localization.values[sourceName];
+    var source = cartesian.localization.values[sourceName];
 
     if (!source) {
-      axis.log.warn("Could not find localization source: " + sourceName);
+      cartesian.log.warn("Could not find localization source: " + sourceName);
       return key;
     }
 
@@ -74,67 +72,104 @@ var axis = axis || {};
     copiedArguments.splice(1, 1);
     copiedArguments[0] = value;
 
-    return axis.utils.formatString.apply(this, copiedArguments);
+    return cartesian.utils.formatString.apply(this, copiedArguments);
   };
 
-  axis.localization.getSource = function (sourceName) {
+  cartesian.localization.getSource = function (sourceName) {
     return function (key) {
       var copiedArguments = Array.prototype.slice.call(arguments, 0);
       copiedArguments.splice(1, 0, sourceName);
-      return axis.localization.localize.apply(this, copiedArguments);
+      return cartesian.localization.localize.apply(this, copiedArguments);
     };
   };
 
-  axis.localization.isCurrentCulture = function (name) {
+  cartesian.localization.isCurrentCulture = function (name) {
     return (
-      axis.localization.currentCulture &&
-      axis.localization.currentCulture.name &&
-      axis.localization.currentCulture.name.indexOf(name) == 0
+      cartesian.localization.currentCulture &&
+      cartesian.localization.currentCulture.name &&
+      cartesian.localization.currentCulture.name.indexOf(name) == 0
     );
   };
 
-  axis.localization.defaultSourceName = undefined;
-  axis.localization.axisWeb = axis.localization.getSource("AxisWeb");
+  cartesian.localization.defaultSourceName = undefined;
+  cartesian.localization.web = cartesian.localization.getSource("web");
 })();
 
-// Implements Authorization API that simplifies usage of authorization scripts generated by Axis.
-var axis = axis || {};
+// Implements Authorization API that simplifies usage of authorization scripts generated by Cartesian.
+var cartesian = cartesian || {};
 (function () {
-  axis.auth = axis.auth || {};
+  cartesian.auth = cartesian.auth || {};
+
+  cartesian.auth.allPermissions = cartesian.auth.allPermissions || {};
 
-  axis.auth.allPermissions = axis.auth.allPermissions || {};
+  cartesian.auth.grantedPermissions = cartesian.auth.grantedPermissions || {};
 
-  axis.auth.grantedPermissions = axis.auth.grantedPermissions || {};
+  cartesian.auth.assignedRoles = cartesian.auth.assignedRoles || [];
 
-  //Deprecated. Use axis.auth.isGranted instead.
-  axis.auth.hasPermission = function (permissionName) {
-    return axis.auth.isGranted.apply(this, arguments);
+  //Deprecated. Use cartesian.auth.isGranted instead.
+  cartesian.auth.hasPermission = function (permissionName) {
+    return cartesian.auth.isGranted.apply(this, arguments);
   };
 
-  //Deprecated. Use axis.auth.isAnyGranted instead.
-  axis.auth.hasAnyOfPermissions = function () {
-    return axis.auth.isAnyGranted.apply(this, arguments);
+  //Deprecated. Use cartesian.auth.isAnyGranted instead.
+  cartesian.auth.hasAnyOfPermissions = function () {
+    return cartesian.auth.isAnyGranted.apply(this, arguments);
   };
 
-  //Deprecated. Use axis.auth.areAllGranted instead.
-  axis.auth.hasAllOfPermissions = function () {
-    return axis.auth.areAllGranted.apply(this, arguments);
+  //Deprecated. Use cartesian.auth.areAllGranted instead.
+  cartesian.auth.hasAllOfPermissions = function () {
+    return cartesian.auth.areAllGranted.apply(this, arguments);
   };
 
-  axis.auth.isGranted = function (permissionName) {
+  cartesian.auth.isGranted = function (permissionName) {
     return (
-        (axis.auth.allPermissions[permissionName] !== undefined && axis.auth.grantedPermissions[permissionName] !== undefined ) ||
-        (axis.auth.allPermissions.indexOf(permissionName) !== -1 && axis.auth.grantedPermissions.indexOf(permissionName) !== -1)
+        (cartesian.auth.allPermissions[permissionName] !== undefined && cartesian.auth.grantedPermissions[permissionName] !== undefined ) ||
+        (cartesian.auth.allPermissions.indexOf(permissionName) !== -1 && cartesian.auth.grantedPermissions.indexOf(permissionName) !== -1)
     );
   };
 
-  axis.auth.isAnyGranted = function () {
+  cartesian.auth.isAnyGranted = function () {
+    if (!arguments || arguments.length <= 0) {
+      return true;
+    }
+
+    for (var i = 0; i < arguments.length; i++) {
+      if (cartesian.auth.isGranted(arguments[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  cartesian.auth.areAllGranted = function () {
+    if (!arguments || arguments.length <= 0) {
+      return true;
+    }
+
+    for (var i = 0; i < arguments.length; i++) {
+      if (!cartesian.auth.isGranted(arguments[i])) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  cartesian.auth.hasRole = function (roleName) {
+    if (!roleName) {
+      return false;
+    }
+    return cartesian.auth.assignedRoles.indexOf(roleName) !== -1;
+  };
+
+  cartesian.auth.hasAnyRole = function () {
     if (!arguments || arguments.length <= 0) {
       return true;
     }
 
     for (var i = 0; i < arguments.length; i++) {
-      if (axis.auth.isGranted(arguments[i])) {
+      if (cartesian.auth.hasRole(arguments[i])) {
         return true;
       }
     }
@@ -142,13 +177,13 @@ var axis = axis || {};
     return false;
   };
 
-  axis.auth.areAllGranted = function () {
+  cartesian.auth.hasAllRoles = function () {
     if (!arguments || arguments.length <= 0) {
       return true;
     }
 
     for (var i = 0; i < arguments.length; i++) {
-      if (!axis.auth.isGranted(arguments[i])) {
+      if (!cartesian.auth.hasRole(arguments[i])) {
         return false;
       }
     }
@@ -156,60 +191,60 @@ var axis = axis || {};
     return true;
   };
 
-  axis.auth.tokenCookieName = "Axis.AuthToken";
+  cartesian.auth.tokenCookieName = "Cartesian.AuthToken";
 
-  axis.auth.setToken = function (authToken, expireDate) {
-    axis.utils.setCookieValue(
-      axis.auth.tokenCookieName,
+  cartesian.auth.setToken = function (authToken, expireDate) {
+    cartesian.utils.setCookieValue(
+      cartesian.auth.tokenCookieName,
       authToken,
       expireDate,
-      axis.appPath,
-      axis.domain
+      cartesian.appPath,
+      cartesian.domain
     );
   };
 
-  axis.auth.getToken = function () {
-    return axis.utils.getCookieValue(axis.auth.tokenCookieName);
+  cartesian.auth.getToken = function () {
+    return cartesian.utils.getCookieValue(cartesian.auth.tokenCookieName);
   };
 
-  axis.auth.clearToken = function () {
-    axis.auth.setToken();
+  cartesian.auth.clearToken = function () {
+    cartesian.auth.setToken();
   };
 
-  axis.auth.refreshTokenCookieName = "Axis.AuthRefreshToken";
+  cartesian.auth.refreshTokenCookieName = "Cartesian.AuthRefreshToken";
 
-  axis.auth.setRefreshToken = function (refreshToken, expireDate) {
-    axis.utils.setCookieValue(
-      axis.auth.refreshTokenCookieName,
+  cartesian.auth.setRefreshToken = function (refreshToken, expireDate) {
+    cartesian.utils.setCookieValue(
+      cartesian.auth.refreshTokenCookieName,
       refreshToken,
       expireDate,
-      axis.appPath,
-      axis.domain
+      cartesian.appPath,
+      cartesian.domain
     );
   };
 
-  axis.auth.getRefreshToken = function () {
-    return axis.utils.getCookieValue(axis.auth.refreshTokenCookieName);
+  cartesian.auth.getRefreshToken = function () {
+    return cartesian.utils.getCookieValue(cartesian.auth.refreshTokenCookieName);
   };
 
-  axis.auth.clearRefreshToken = function () {
-    axis.auth.setRefreshToken();
+  cartesian.auth.clearRefreshToken = function () {
+    cartesian.auth.setRefreshToken();
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  //Implements Features API that simplifies usage of feature scripts generated by Axis.
-  axis.features = axis.features || {};
+  //Implements Features API that simplifies usage of feature scripts generated by Cartesian.
+  cartesian.features = cartesian.features || {};
 
-  axis.features.allFeatures = axis.features.allFeatures || {};
+  cartesian.features.allFeatures = cartesian.features.allFeatures || {};
 
-  axis.features.get = function (name) {
-    return axis.features.allFeatures[name];
+  cartesian.features.get = function (name) {
+    return cartesian.features.allFeatures[name];
   };
 
-  axis.features.getValue = function (name) {
-    var feature = axis.features.get(name);
+  cartesian.features.getValue = function (name) {
+    var feature = cartesian.features.get(name);
     if (feature == undefined) {
       return undefined;
     }
@@ -217,19 +252,19 @@ var axis = axis || {};
     return feature.value;
   };
 
-  axis.features.isEnabled = function (name) {
-    var value = axis.features.getValue(name);
+  cartesian.features.isEnabled = function (name) {
+    var value = cartesian.features.getValue(name);
     return value == "true" || value == "True";
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function (define) {
   define(["jquery"], function ($) {
     // Notification - Defines Notification API, not implements it
-    axis.notifications = axis.notifications || {};
+    cartesian.notifications = cartesian.notifications || {};
 
-    axis.notifications.severity = {
+    cartesian.notifications.severity = {
       INFO: 0,
       SUCCESS: 1,
       WARN: 2,
@@ -237,47 +272,47 @@ var axis = axis || {};
       FATAL: 4,
     };
 
-    axis.notifications.userNotificationState = {
+    cartesian.notifications.userNotificationState = {
       UNREAD: 0,
       READ: 1,
     };
 
-    axis.notifications.getUserNotificationStateAsString = function (
+    cartesian.notifications.getUserNotificationStateAsString = function (
       userNotificationState
     ) {
       switch (userNotificationState) {
-        case axis.notifications.userNotificationState.READ:
+        case cartesian.notifications.userNotificationState.READ:
           return "READ";
-        case axis.notifications.userNotificationState.UNREAD:
+        case cartesian.notifications.userNotificationState.UNREAD:
           return "UNREAD";
         default:
-          axis.log.warn(
+          cartesian.log.warn(
             "Unknown user notification state value: " + userNotificationState
           );
           return "?";
       }
     };
 
-    axis.notifications.getUiNotifyFuncBySeverity = function (severity) {
+    cartesian.notifications.getUiNotifyFuncBySeverity = function (severity) {
       switch (severity) {
-        case axis.notifications.severity.SUCCESS:
-          return axis.notify.success;
-        case axis.notifications.severity.WARN:
-          return axis.notify.warn;
-        case axis.notifications.severity.ERROR:
-          return axis.notify.error;
-        case axis.notifications.severity.FATAL:
-          return axis.notify.error;
-        case axis.notifications.severity.INFO:
+        case cartesian.notifications.severity.SUCCESS:
+          return cartesian.notify.success;
+        case cartesian.notifications.severity.WARN:
+          return cartesian.notify.warn;
+        case cartesian.notifications.severity.ERROR:
+          return cartesian.notify.error;
+        case cartesian.notifications.severity.FATAL:
+          return cartesian.notify.error;
+        case cartesian.notifications.severity.INFO:
         default:
-          return axis.notify.info;
+          return cartesian.notify.info;
       }
     };
 
-    axis.notifications.messageFormatters = {};
+    cartesian.notifications.messageFormatters = {};
 
-    axis.notifications.messageFormatters[
-      "Axis.Notifications.MessageNotificationData"
+    cartesian.notifications.messageFormatters[
+      "Cartesian.Notifications.MessageNotificationData"
     ] = function (userNotification) {
       return (
         userNotification.notification.data.message ||
@@ -285,13 +320,13 @@ var axis = axis || {};
       );
     };
 
-    axis.notifications.messageFormatters[
-      "Axis.Notifications.LocalizableMessageNotificationData"
+    cartesian.notifications.messageFormatters[
+      "Cartesian.Notifications.LocalizableMessageNotificationData"
     ] = function (userNotification) {
       var message =
         userNotification.notification.data.message ||
         userNotification.notification.data.properties.Message;
-      var localizedMessage = axis.localization.localize(
+      var localizedMessage = cartesian.localization.localize(
         message.name,
         message.sourceName
       );
@@ -322,23 +357,23 @@ var axis = axis || {};
       return localizedMessage;
     };
 
-    axis.notifications.getFormattedMessageFromUserNotification = function (
+    cartesian.notifications.getFormattedMessageFromUserNotification = function (
       userNotification
     ) {
       var formatter =
-        axis.notifications.messageFormatters[
+        cartesian.notifications.messageFormatters[
           userNotification.notification.data.type
         ];
       if (!formatter) {
-        axis.log.warn(
+        cartesian.log.warn(
           "No message formatter defined for given data type: " +
             userNotification.notification.data.type
         );
         return "?";
       }
 
-      if (!axis.utils.isFunction(formatter)) {
-        axis.log.warn(
+      if (!cartesian.utils.isFunction(formatter)) {
+        cartesian.log.warn(
           "Message formatter should be a function! It is invalid for data type: " +
             userNotification.notification.data.type
         );
@@ -348,39 +383,39 @@ var axis = axis || {};
       return formatter(userNotification);
     };
 
-    axis.notifications.showUiNotifyForUserNotification = function (
+    cartesian.notifications.showUiNotifyForUserNotification = function (
       userNotification,
       options
     ) {
-      var message = axis.notifications.getFormattedMessageFromUserNotification(
+      var message = cartesian.notifications.getFormattedMessageFromUserNotification(
         userNotification
       );
-      var uiNotifyFunc = axis.notifications.getUiNotifyFuncBySeverity(
+      var uiNotifyFunc = cartesian.notifications.getUiNotifyFuncBySeverity(
         userNotification.notification.severity
       );
       uiNotifyFunc(message, undefined, options);
     };
 
     // Notify - Defines Notification API, not implements it
-    axis.notify = axis.notify || {};
+    cartesian.notify = cartesian.notify || {};
 
-    axis.notify.success = function (message, title, options) {
-      axis.log.warn("axis.notify.success is not implemented!");
+    cartesian.notify.success = function (message, title, options) {
+      cartesian.log.warn("cartesian.notify.success is not implemented!");
     };
 
-    axis.notify.info = function (message, title, options) {
-      axis.log.warn("axis.notify.info is not implemented!");
+    cartesian.notify.info = function (message, title, options) {
+      cartesian.log.warn("cartesian.notify.info is not implemented!");
     };
 
-    axis.notify.warn = function (message, title, options) {
-      axis.log.warn("axis.notify.warn is not implemented!");
+    cartesian.notify.warn = function (message, title, options) {
+      cartesian.log.warn("cartesian.notify.warn is not implemented!");
     };
 
-    axis.notify.error = function (message, title, options) {
-      axis.log.warn("axis.notify.error is not implemented!");
+    cartesian.notify.error = function (message, title, options) {
+      cartesian.log.warn("cartesian.notify.error is not implemented!");
     };
 
-    return axis;
+    return cartesian;
   });
 })(
   typeof define === "function" && define.amd
@@ -389,16 +424,16 @@ var axis = axis || {};
         if (typeof module !== "undefined" && module.exports) {
           module.exports = factory(require("jquery"));
         } else {
-          window.axis = factory(window.jQuery);
+          window.cartesian = factory(window.jQuery);
         }
       }
 );
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.log = axis.log || {};
+  cartesian.log = cartesian.log || {};
 
-  axis.log.levels = {
+  cartesian.log.levels = {
     DEBUG: 1,
     INFO: 2,
     WARN: 3,
@@ -406,57 +441,57 @@ var axis = axis || {};
     FATAL: 5,
   };
 
-  axis.log.level = axis.log.levels.DEBUG;
+  cartesian.log.level = cartesian.log.levels.DEBUG;
 
-  axis.log.log = function (logObject, logLevel) {
+  cartesian.log.log = function (logObject, logLevel) {
     if (!window.console || !window.console.log) {
       return;
     }
 
-    if (logLevel != undefined && logLevel < axis.log.level) {
+    if (logLevel != undefined && logLevel < cartesian.log.level) {
       return;
     }
   };
 
-  axis.log.debug = function (logObject) {
-    axis.log.log("DEBUG: ", axis.log.levels.DEBUG);
-    axis.log.log(logObject, axis.log.levels.DEBUG);
+  cartesian.log.debug = function (logObject) {
+    cartesian.log.log("DEBUG: ", cartesian.log.levels.DEBUG);
+    cartesian.log.log(logObject, cartesian.log.levels.DEBUG);
   };
 
-  axis.log.info = function (logObject) {
-    axis.log.log("INFO: ", axis.log.levels.INFO);
-    axis.log.log(logObject, axis.log.levels.INFO);
+  cartesian.log.info = function (logObject) {
+    cartesian.log.log("INFO: ", cartesian.log.levels.INFO);
+    cartesian.log.log(logObject, cartesian.log.levels.INFO);
   };
 
-  axis.log.warn = function (logObject) {
-    axis.log.log("WARN: ", axis.log.levels.WARN);
-    axis.log.log(logObject, axis.log.levels.WARN);
+  cartesian.log.warn = function (logObject) {
+    cartesian.log.log("WARN: ", cartesian.log.levels.WARN);
+    cartesian.log.log(logObject, cartesian.log.levels.WARN);
   };
 
-  axis.log.error = function (logObject) {
-    axis.log.log("ERROR: ", axis.log.levels.ERROR);
-    axis.log.log(logObject, axis.log.levels.ERROR);
+  cartesian.log.error = function (logObject) {
+    cartesian.log.log("ERROR: ", cartesian.log.levels.ERROR);
+    cartesian.log.log(logObject, cartesian.log.levels.ERROR);
   };
 
-  axis.log.fatal = function (logObject) {
-    axis.log.log("FATAL: ", axis.log.levels.FATAL);
-    axis.log.log(logObject, axis.log.levels.FATAL);
+  cartesian.log.fatal = function (logObject) {
+    cartesian.log.log("FATAL: ", cartesian.log.levels.FATAL);
+    cartesian.log.log(logObject, cartesian.log.levels.FATAL);
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function (define) {
   define(["jquery"], function ($) {
 
     // Messages API - Defines Messages API, not implements it
-    axis.message = axis.message || {};
+    cartesian.message = cartesian.message || {};
 
     var showMessage = function (message, title, options) {
       alert((title || "") + " " + message);
 
       if (!$) {
-        axis.log.warn(
-          "axis.message can not return promise since jQuery is not defined!"
+        cartesian.log.warn(
+          "cartesian.message can not return promise since jQuery is not defined!"
         );
         return null;
       }
@@ -466,35 +501,35 @@ var axis = axis || {};
       });
     };
 
-    axis.message.info = function (message, title, options) {
-      axis.log.warn("axis.message.info is not implemented!");
+    cartesian.message.info = function (message, title, options) {
+      cartesian.log.warn("cartesian.message.info is not implemented!");
       return showMessage(message, title, options);
     };
 
-    axis.message.success = function (message, title, options) {
-      axis.log.warn("axis.message.success is not implemented!");
+    cartesian.message.success = function (message, title, options) {
+      cartesian.log.warn("cartesian.message.success is not implemented!");
       return showMessage(message, title, options);
     };
 
-    axis.message.warn = function (message, title, options) {
-      axis.log.warn("axis.message.warn is not implemented!");
+    cartesian.message.warn = function (message, title, options) {
+      cartesian.log.warn("cartesian.message.warn is not implemented!");
       return showMessage(message, title, options);
     };
 
-    axis.message.error = function (message, title, options) {
-      axis.log.warn("axis.message.error is not implemented!");
+    cartesian.message.error = function (message, title, options) {
+      cartesian.log.warn("cartesian.message.error is not implemented!");
       return showMessage(message, title, options);
     };
 
-    axis.message.confirm = function (message, title, callback, options) {
-      axis.log.warn("axis.message.confirm is not implemented!");
+    cartesian.message.confirm = function (message, title, callback, options) {
+      cartesian.log.warn("cartesian.message.confirm is not implemented!");
 
       var result = confirm(message);
       callback && callback(result);
 
       if (!$) {
-        axis.log.warn(
-          "axis.message can not return promise since jQuery is not defined!"
+        cartesian.log.warn(
+          "cartesian.message can not return promise since jQuery is not defined!"
         );
         return null;
       }
@@ -504,7 +539,7 @@ var axis = axis || {};
       });
     };
 
-    return axis;
+    return cartesian;
   });
 })(
   typeof define === "function" && define.amd
@@ -513,37 +548,37 @@ var axis = axis || {};
         if (typeof module !== "undefined" && module.exports) {
           module.exports = factory(require("jquery"));
         } else {
-          window.axis = factory(window.jQuery);
+          window.cartesian = factory(window.jQuery);
         }
       }
 );
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.ui = axis.ui || {};
+  cartesian.ui = cartesian.ui || {};
 
   // UI Block - Defines UI Block API, not implements it
-  axis.ui.block = function (elm) {
-    axis.log.warn("axis.ui.block is not implemented!");
+  cartesian.ui.block = function (elm) {
+    cartesian.log.warn("cartesian.ui.block is not implemented!");
   };
 
-  axis.ui.unblock = function (elm) {
-    axis.log.warn("axis.ui.unblock is not implemented!");
+  cartesian.ui.unblock = function (elm) {
+    cartesian.log.warn("cartesian.ui.unblock is not implemented!");
   };
 
   // UI BUSY - Defines UI Busy API, not implements it
-  axis.ui.setBusy = function (elm, text, delay) {
-    axis.log.warn("axis.ui.setBusy is not implemented!");
+  cartesian.ui.setBusy = function (elm, text, delay) {
+    cartesian.log.warn("cartesian.ui.setBusy is not implemented!");
   };
 
-  axis.ui.clearBusy = function (elm, delay) {
-    axis.log.warn("axis.ui.clearBusy is not implemented!");
+  cartesian.ui.clearBusy = function (elm, delay) {
+    cartesian.log.warn("cartesian.ui.clearBusy is not implemented!");
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.event = (function () {
+  cartesian.event = (function () {
     var _callbacks = {};
 
     var on = function (eventName, callback) {
@@ -597,18 +632,18 @@ var axis = axis || {};
   })();
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function (define) {
   define(["jquery"], function ($) {
-    axis.utils = axis.utils || {};
+    cartesian.utils = cartesian.utils || {};
 
     /* Creates a name namespace.
      *  Example:
-     *  var taskService = axis.utils.createNamespace(axis, 'services.task');
-     *  taskService will be equal to axis.services.task
+     *  var taskService = cartesian.utils.createNamespace(cartesian, 'services.task');
+     *  taskService will be equal to cartesian.services.task
      *  first argument (root) must be defined first
      ************************************************************/
-    axis.utils.createNamespace = function (root, ns) {
+    cartesian.utils.createNamespace = function (root, ns) {
       var parts = ns.split(".");
       for (var i = 0; i < parts.length; i++) {
         if (typeof root[parts[i]] == "undefined") {
@@ -624,18 +659,18 @@ var axis = axis || {};
     /* Find and replaces a string (search) to another string (replacement) in
      *  given string (str).
      *  Example:
-     *  axis.utils.replaceAll('This is a test string', 'is', 'X') = 'ThX X a test string'
+     *  cartesian.utils.replaceAll('This is a test string', 'is', 'X') = 'ThX X a test string'
      ************************************************************/
-    axis.utils.replaceAll = function (str, search, replacement) {
+    cartesian.utils.replaceAll = function (str, search, replacement) {
       var fix = search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       return str.replace(new RegExp(fix, "g"), replacement);
     };
 
     /* Formats a string just like string.format in C#.
      *  Example:
-     *  axis.utils.formatString('Hello {0}','Tuana') = 'Hello Tuana'
+     *  cartesian.utils.formatString('Hello {0}','Tuana') = 'Hello Tuana'
      ************************************************************/
-    axis.utils.formatString = function () {
+    cartesian.utils.formatString = function () {
       if (arguments.length < 1) {
         return null;
       }
@@ -644,13 +679,13 @@ var axis = axis || {};
 
       for (var i = 1; i < arguments.length; i++) {
         var placeHolder = "{" + (i - 1) + "}";
-        str = axis.utils.replaceAll(str, placeHolder, arguments[i]);
+        str = cartesian.utils.replaceAll(str, placeHolder, arguments[i]);
       }
 
       return str;
     };
 
-    axis.utils.toPascalCase = function (str) {
+    cartesian.utils.toPascalCase = function (str) {
       if (!str || !str.length) {
         return str;
       }
@@ -662,7 +697,7 @@ var axis = axis || {};
       return str.charAt(0).toUpperCase() + str.substr(1);
     };
 
-    axis.utils.toCamelCase = function (str) {
+    cartesian.utils.toCamelCase = function (str) {
       if (!str || !str.length) {
         return str;
       }
@@ -674,7 +709,7 @@ var axis = axis || {};
       return str.charAt(0).toLowerCase() + str.substr(1);
     };
 
-    axis.utils.truncateString = function (str, maxLength) {
+    cartesian.utils.truncateString = function (str, maxLength) {
       if (!str || !str.length || str.length <= maxLength) {
         return str;
       }
@@ -682,7 +717,7 @@ var axis = axis || {};
       return str.substr(0, maxLength);
     };
 
-    axis.utils.truncateStringWithPostfix = function (str, maxLength, postfix) {
+    cartesian.utils.truncateStringWithPostfix = function (str, maxLength, postfix) {
       postfix = postfix || "...";
 
       if (!str || !str.length || str.length <= maxLength) {
@@ -696,7 +731,7 @@ var axis = axis || {};
       return str.substr(0, maxLength - postfix.length) + postfix;
     };
 
-    axis.utils.isFunction = function (obj) {
+    cartesian.utils.isFunction = function (obj) {
       if ($) {
         //Prefer to use jQuery if possible
         return $.isFunction(obj);
@@ -711,7 +746,7 @@ var axis = axis || {};
      * where name is query string parameter name and value is it's value.
      * includeQuestionMark is true by default.
      */
-    axis.utils.buildQueryString = function (
+    cartesian.utils.buildQueryString = function (
       parameterInfos,
       includeQuestionMark
     ) {
@@ -783,14 +818,14 @@ var axis = axis || {};
 
     /**
      * Sets a cookie value for given key.
-     * This is a simple implementation created to be used by ABP.
+     * This is a simple implementation created to be used by Cartesian.
      * Please use a complete cookie library if you need.
      * @param {string} key
      * @param {string} value
      * @param {Date} expireDate (optional). If not specified the cookie will expire at the end of session.
      * @param {string} path (optional)
      */
-    axis.utils.setCookieValue = function (
+    cartesian.utils.setCookieValue = function (
       key,
       value,
       expireDate,
@@ -820,12 +855,12 @@ var axis = axis || {};
 
     /**
      * Gets a cookie with given key.
-     * This is a simple implementation created to be used by ABP.
+     * This is a simple implementation created to be used by Cartesian.
      * Please use a complete cookie library if you need.
      * @param {string} key
      * @returns {string} Cookie value or null
      */
-    axis.utils.getCookieValue = function (key) {
+    cartesian.utils.getCookieValue = function (key) {
       var equalities = document.cookie.split("; ");
       for (var i = 0; i < equalities.length; i++) {
         if (!equalities[i]) {
@@ -847,12 +882,12 @@ var axis = axis || {};
 
     /**
      * Deletes cookie for given key.
-     * This is a simple implementation created to be used by ABP.
+     * This is a simple implementation created to be used by Cartesian.
      * Please use a complete cookie library if you need.
      * @param {string} key
      * @param {string} path (optional)
      */
-    axis.utils.deleteCookie = function (key, path) {
+    cartesian.utils.deleteCookie = function (key, path) {
       var cookieValue = encodeURIComponent(key) + "=";
 
       cookieValue =
@@ -872,13 +907,13 @@ var axis = axis || {};
      * @param {string} url
      * @returns {string}
      */
-    axis.utils.getDomain = function (url) {
+    cartesian.utils.getDomain = function (url) {
       var domainRegex = /(https?:){0,1}\/\/((?:[\w\d-]+\.)+[\w\d]{2,})/i;
       var matches = domainRegex.exec(url);
       return matches && matches[2] ? matches[2] : "";
     };
 
-    return axis;
+    return cartesian;
   });
 })(
   typeof define === "function" && define.amd
@@ -887,16 +922,16 @@ var axis = axis || {};
         if (typeof module !== "undefined" && module.exports) {
           module.exports = factory(require("jquery"));
         } else {
-          window.axis = factory(window.jQuery);
+          window.cartesian = factory(window.jQuery);
         }
       }
 );
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.timing = axis.timing || {};
+  cartesian.timing = cartesian.timing || {};
 
-  axis.timing.utcClockProvider = (function () {
+  cartesian.timing.utcClockProvider = (function () {
     var toUtc = function (date) {
       return Date.UTC(
         date.getUTCFullYear(),
@@ -930,7 +965,7 @@ var axis = axis || {};
     };
   })();
 
-  axis.timing.localClockProvider = (function () {
+  cartesian.timing.localClockProvider = (function () {
     var toLocal = function (date) {
       return new Date(
         date.getFullYear(),
@@ -963,7 +998,7 @@ var axis = axis || {};
     };
   })();
 
-  axis.timing.unspecifiedClockProvider = (function () {
+  cartesian.timing.unspecifiedClockProvider = (function () {
     var now = function () {
       return new Date();
     };
@@ -980,56 +1015,56 @@ var axis = axis || {};
     };
   })();
 
-  axis.timing.convertToUserTimezone = function (date) {
+  cartesian.timing.convertToUserTimezone = function (date) {
     var localTime = date.getTime();
     var utcTime = localTime + date.getTimezoneOffset() * 60000;
     var targetTime =
       parseInt(utcTime) +
-      parseInt(axis.timing.timeZoneInfo.server.currentUtcOffsetInMilliseconds);
+      parseInt(cartesian.timing.timeZoneInfo.server.currentUtcOffsetInMilliseconds);
     return new Date(targetTime);
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.clock = axis.clock || {};
+  cartesian.clock = cartesian.clock || {};
 
-  axis.clock.now = function () {
-    if (axis.clock.provider) {
-      return axis.clock.provider.now();
+  cartesian.clock.now = function () {
+    if (cartesian.clock.provider) {
+      return cartesian.clock.provider.now();
     }
 
     return new Date();
   };
 
-  axis.clock.normalize = function (date) {
-    if (axis.clock.provider) {
-      return axis.clock.provider.normalize(date);
+  cartesian.clock.normalize = function (date) {
+    if (cartesian.clock.provider) {
+      return cartesian.clock.provider.normalize(date);
     }
 
     return date;
   };
 
-  axis.clock.provider = axis.timing.unspecifiedClockProvider;
+  cartesian.clock.provider = cartesian.timing.unspecifiedClockProvider;
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  axis.security = axis.security || {};
-  axis.security.antiForgery = axis.security.antiForgery || {};
+  cartesian.security = cartesian.security || {};
+  cartesian.security.antiForgery = cartesian.security.antiForgery || {};
 
-  axis.security.antiForgery.tokenCookieName = "XSRF-TOKEN";
-  axis.security.antiForgery.tokenHeaderName = "X-XSRF-TOKEN";
+  cartesian.security.antiForgery.tokenCookieName = "XSRF-TOKEN";
+  cartesian.security.antiForgery.tokenHeaderName = "X-XSRF-TOKEN";
 
-  axis.security.antiForgery.getToken = function () {
-    return axis.utils.getCookieValue(axis.security.antiForgery.tokenCookieName);
+  cartesian.security.antiForgery.getToken = function () {
+    return cartesian.utils.getCookieValue(cartesian.security.antiForgery.tokenCookieName);
   };
 
-  axis.security.antiForgery.shouldSendToken = function (settings) {
+  cartesian.security.antiForgery.shouldSendToken = function (settings) {
     if (settings.crossDomain === undefined || settings.crossDomain === null) {
       return (
-        axis.utils.getDomain(location.href) ===
-        axis.utils.getDomain(settings.url)
+        cartesian.utils.getDomain(location.href) ===
+        cartesian.utils.getDomain(settings.url)
       );
     }
 
@@ -1037,64 +1072,64 @@ var axis = axis || {};
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
   // Current application root path (including virtual directory if exists).
-  axis.appPath = axis.appPath || "/";
-  axis.pageLoadTime = new Date();
+  cartesian.appPath = cartesian.appPath || "/";
+  cartesian.pageLoadTime = new Date();
 
-  // Converts given path to absolute path using axis.appPath variable.
-  axis.toAbsAppPath = function (path) {
+  // Converts given path to absolute path using cartesian.appPath variable.
+  cartesian.toAbsAppPath = function (path) {
     if (path.indexOf("/") == 0) {
       path = path.substring(1);
     }
-    return axis.appPath + path;
+    return cartesian.appPath + path;
   };
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-    axis.session = axis.session || {};
+    cartesian.session = cartesian.session || {};
 
-    axis.session.userId = false;
-    axis.session.isAdmin = false;
-    axis.session.hostId = false;
-    axis.session.tenantId = false;
-    axis.session.side = axis.tenancy.sides.TENANT; //1: Tenant, 2: Host
+    cartesian.session.userId = false;
+    cartesian.session.isAdmin = false;
+    cartesian.session.hostId = false;
+    cartesian.session.tenantId = false;
+    cartesian.session.side = cartesian.tenancy.sides.TENANT; //1: Tenant, 2: Host
 
-    axis.session.isHostAdmin = function () {
-        if (axis.session.hostId && axis.session.isAdmin) {
+    cartesian.session.isHostAdmin = function () {
+        if (cartesian.session.hostId && cartesian.session.isAdmin) {
            return true;
         }
 
         return false;
     };
 
-    axis.session.isTenantAdmin = function () {
-        if (axis.session.tenantId && axis.session.isAdmin) {
+    cartesian.session.isTenantAdmin = function () {
+        if (cartesian.session.tenantId && cartesian.session.isAdmin) {
             return true;
         }
 
         return false;
     };
 
-    axis.session.isUserLogged = function () {
-        if (axis.session.userId) {
+    cartesian.session.isUserLogged = function () {
+        if (cartesian.session.userId) {
             return true;
         }
         return false;
     };
 
-    axis.session.isHostSide = function () {
-        if(axis.session.side === axis.tenancy.sides.HOST) {
+    cartesian.session.isHostSide = function () {
+        if(cartesian.session.side === cartesian.tenancy.sides.HOST) {
             return true;
         }
 
         return false;
     }
 
-    axis.session.isTenantSide = function () {
-        if(axis.session.side === axis.tenancy.sides.TENANT) {
+    cartesian.session.isTenantSide = function () {
+        if(cartesian.session.side === cartesian.tenancy.sides.TENANT) {
             return true;
         }
 
@@ -1103,23 +1138,23 @@ var axis = axis || {};
 
 })();
 
-var axis = axis || {};
+var cartesian = cartesian || {};
 (function () {
-  // Implements Settings API that simplifies usage of setting scripts generated by Axis.
-  axis.setting = axis.setting || {};
+  // Implements Settings API that simplifies usage of setting scripts generated by Cartesian.
+  cartesian.setting = cartesian.setting || {};
 
-  axis.setting.values = axis.setting.values || {};
+  cartesian.setting.values = cartesian.setting.values || {};
 
-  axis.setting.get = function (name) {
-    return axis.setting.values[name];
+  cartesian.setting.get = function (name) {
+    return cartesian.setting.values[name];
   };
 
-  axis.setting.getBoolean = function (name) {
-    var value = axis.setting.get(name);
+  cartesian.setting.getBoolean = function (name) {
+    var value = cartesian.setting.get(name);
     return value == "true" || value == "True";
   };
 
-  axis.setting.getInt = function (name) {
-    return parseInt(axis.setting.values[name]);
+  cartesian.setting.getInt = function (name) {
+    return parseInt(cartesian.setting.values[name]);
   };
 })();