merchi_sdk_js 0.0.1

package/dist/merchi.js

@@ -0,0 +1,1004 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.merchi = merchi;
+var _browserOrNode = require("browser-or-node");
+var _uuid = require("./uuid.js");
+var _helpers = require("./helpers.js");
+var _model = require("./model.js");
+var _job_status = require("./job_status.js");
+var _roles = require("./roles.js");
+var _domain_types = require("./domain_types.js");
+var _product_types = require("./product_types.js");
+var _payment_types = require("./payment_types.js");
+var _dictionary = require("./dictionary.js");
+var _field_types = require("./field_types.js");
+var _notification_types = require("./notification_types.js");
+var _address = require("./address.js");
+var _assignment = require("./assignment.js");
+var _automatic_payment_relationship = require("./automatic_payment_relationship.js");
+var _backup = require("./backup.js");
+var _bank = require("./bank.js");
+var _category = require("./category.js");
+var _cart = require("./cart.js");
+var _cart_item = require("./cart_item.js");
+var _country_tax = require("./country_tax.js");
+var _company = require("./company.js");
+var _company_invitation = require("./company_invitation.js");
+var _component = require("./component.js");
+var _component_tag = require("./component_tag.js");
+var _discount = require("./discount.js");
+var _discount_group = require("./discount_group.js");
+var _domain = require("./domain.js");
+var _domain_tag = require("./domain_tag.js");
+var _domain_invitation = require("./domain_invitation.js");
+var _draft = require("./draft.js");
+var _draft_template = require("./draft_template.js");
+var _draft_comment = require("./draft_comment.js");
+var _enrolled_domain = require("./enrolled_domain.js");
+var _email_address = require("./email_address.js");
+var _email_counter = require("./email_counter.js");
+var _exchange_rate = require("./exchange_rate.js");
+var _item = require("./item.js");
+var _inventory = require("./inventory.js");
+var _inventory_unit_variation = require("./inventory_unit_variation.js");
+var _matching_inventory = require("./matching_inventory.js");
+var _notification = require("./notification.js");
+var _invoice = require("./invoice.js");
+var _job = require("./job.js");
+var _job_comment = require("./job_comment.js");
+var _merchi_file = require("./merchi_file.js");
+var _menu = require("./menu.js");
+var _menu_item = require("./menu_item.js");
+var _page = require("./page.js");
+var _payment = require("./payment.js");
+var _product = require("./product.js");
+var _production_comment = require("./production_comment.js");
+var _phone_number = require("./phone_number.js");
+var _session = require("./session.js");
+var _shipment = require("./shipment.js");
+var _shipment_method = require("./shipment_method.js");
+var _shipment_method_variation = require("./shipment_method_variation.js");
+var _subscription_plan = require("./subscription_plan.js");
+var _supply_domain = require("./supply_domain.js");
+var _system_role = require("./system_role.js");
+var _theme = require("./theme.js");
+var _user = require("./user.js");
+var _user_types = require("./user_types.js");
+var _user_company = require("./user_company.js");
+var _variation = require("./variation.js");
+var _variation_field = require("./variation_field.js");
+var _variation_fields_option = require("./variation_fields_option.js");
+var _variations_group = require("./variations_group.js");
+var _quote_item = require("./quote_item.js");
+var _quote = require("./quote.js");
+var _internal_tag = require("./internal_tag.js");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function merchi(backendUri, websocketUri) {
+  (0, _helpers.getGlobal)().merchiJsonpHandlers = {};
+  (0, _helpers.getGlobal)().merchiBackendUri = backendUri;
+  (0, _helpers.getGlobal)().merchiSubscriptionManager = new SubscriptionManager();
+  function isJSON(x) {
+    return _typeof(x) === 'object' && x !== null && !(x instanceof Array) && !(x instanceof Date);
+  }
+  function isFunction(x) {
+    return typeof x === 'function';
+  }
+  function indexOfEntityInArrayByAttribute(attributeName, array, entity) {
+    return array.findIndex(function (ent) {
+      return entity[attributeName]() === ent[attributeName]();
+    });
+  }
+  function indexOfEntityInArrayById(array, entity) {
+    return indexOfEntityInArrayByAttribute('id', array, entity);
+  }
+  function indexOfEntityInArrayByName(array, entity) {
+    return indexOfEntityInArrayByAttribute('name', array, entity);
+  }
+  function displayMoney(amount) {
+    return parseFloat(amount).toFixed(2);
+  }
+  function SubscriptionManager() {
+    var socket = null,
+      subscriptions = new _dictionary.Dictionary();
+    function handleUpdate(data) {
+      var handler = subscriptions.get(data.subscriptionToken, null);
+      if (handler !== null) {
+        handler(data.statusCode, data.data);
+      }
+    }
+    function getSocket() {
+      if (socket === null) {
+        socket = io.connect(websocketUri);
+        socket.on('update', handleUpdate);
+      }
+      return socket;
+    }
+    function emit(name, data) {
+      getSocket().emit(name, data);
+    }
+    this.subscribe = function (eventTypes, uri, method, onUpdate) {
+      var subscriptionToken = (0, _uuid.generateUUID)();
+      subscriptions.add(subscriptionToken, onUpdate);
+      emit('subscribe', {
+        eventTypes: eventTypes,
+        method: method,
+        subscriptionToken: subscriptionToken,
+        uri: uri
+      });
+      return subscriptionToken;
+    };
+    this.unsubscribe = function (subscriptionToken) {
+      subscriptions.remove(subscriptionToken);
+      emit('unsubscribe', {
+        subscriptionToken: subscriptionToken
+      });
+    };
+  }
+
+  /** Closures and file scope vars **/
+  var roleStrings = new _dictionary.Dictionary(),
+    roleCssClass = new _dictionary.Dictionary(),
+    rights = new _dictionary.Dictionary(),
+    eventTypes = new _dictionary.Dictionary(),
+    itemTypes = new _dictionary.Dictionary(),
+    priorityLevels = new _dictionary.Dictionary(),
+    priorityLevelsOptions = new _dictionary.Dictionary(),
+    shipmentCompanies = new _dictionary.Dictionary(),
+    productTypesSeller = new _dictionary.Dictionary(),
+    notificationAvatar = new _dictionary.Dictionary(),
+    inventoryStatuses = new _dictionary.Dictionary(),
+    themeFoundation = new _dictionary.Dictionary(),
+    inputTypes = new _dictionary.Dictionary(),
+    fieldTypesString = new _dictionary.Dictionary(),
+    menuType = new _dictionary.Dictionary(),
+    menuTypeCodes = new _dictionary.Dictionary(),
+    menuItemType = new _dictionary.Dictionary(),
+    menuItemTypeCodes = new _dictionary.Dictionary(),
+    currentUserEmbed = {
+      'emailAddresses': {},
+      'profilePicture': {},
+      'userCompanies': {
+        "company": {}
+      },
+      'enrolledDomains': {
+        'domain': {}
+      }
+    },
+    platformName = 'Merchi',
+    platformCopyright = 2023,
+    platformSellerDomain = 'merchi.co',
+    platformSellerDomainPlus = 'merchi.co',
+    backendImgUri = backendUri + 'static/img/',
+    platformIcon = backendImgUri + 'merchi-monster-blue.png',
+    platformLogo = backendImgUri + 'merchi-master-colour-with-monster.png',
+    defaultUserAvatar = backendImgUri + 'default-user-32px.jpg',
+    STATUS = {
+      PROD: ['Init', 'Rejected', 'Quoteding', 'Waiting Quote', 'Close Deadline', 'Assigned', 'Questioning', 'Commenced', 'Finish', 'Shipped'],
+      DESIGN: ['not start', 'started', 'changes request', 'waiting for check', 'approved'],
+      PAYMENT: ['Not Paid', 'Partially Paid', 'Fully Paid']
+    },
+    GSTrate = 0.1,
+    DEFAULT_RIGHTS = [];
+  _roles.roles.each(function (key, value) {
+    roleStrings.add(value, key);
+  });
+  roleCssClass.add(_roles.roles.get('public'), 'default');
+  roleCssClass.add(_roles.roles.get('admin'), 'inverse');
+  roleCssClass.add(_roles.roles.get('sales'), 'success');
+  roleCssClass.add(_roles.roles.get('designer'), 'success');
+  roleCssClass.add(_roles.roles.get('supplier'), 'warning');
+  roleCssClass.add(_roles.roles.get('client'), 'danger');
+  roleCssClass.add(_roles.roles.get('manager'), 'primary');
+  roleCssClass.add(_roles.roles.get('accountant'), 'info');
+  inputTypes.add(1, "text");
+  inputTypes.add(2, "select");
+  inputTypes.add(3, "file");
+  inputTypes.add(4, "textarea");
+  inputTypes.add(5, "number");
+  inputTypes.add(6, "checkbox");
+  inputTypes.add(7, "radio");
+  inputTypes.add(8, "instructions");
+  inputTypes.add(9, "image select");
+  inputTypes.add(10, "colour picker");
+  inputTypes.add(11, "colour select");
+  fieldTypesString.add(1, "TEXT_INPUT");
+  fieldTypesString.add(2, "SELECT");
+  themeFoundation.add("NO_FOUNDATION", 0);
+  themeFoundation.add("BOOTSTRAP_3", 1);
+  themeFoundation.add("BOOTSTRAP_4", 2);
+  themeFoundation.add("BOOTSTRAP_5", 3);
+  shipmentCompanies.add(0, 'DHL');
+  shipmentCompanies.add(1, 'UPS');
+  shipmentCompanies.add(2, 'EMS');
+  shipmentCompanies.add(3, 'FedEx');
+  shipmentCompanies.add(4, 'Australia Post');
+  shipmentCompanies.add(5, 'StarTrack');
+  shipmentCompanies.add(6, 'Toll');
+  shipmentCompanies.add(7, 'TNT');
+  shipmentCompanies.add(8, 'Custom Track Link');
+  shipmentCompanies.add(9, 'Aramex');
+  shipmentCompanies.add(10, 'realtime express');
+  shipmentCompanies.add(11, 'Uber');
+  shipmentCompanies.add(12, 'Civic Transport Couriers');
+  inventoryStatuses.add("DEDUCTED", 0);
+  inventoryStatuses.add("CAN_DEDUCT", 1);
+  inventoryStatuses.add("NOT_SUFFICIENT", 2);
+  inventoryStatuses.add("NO_MATCHING_INVENTORY", 3);
+  productTypesSeller.add(2, 'seller');
+  productTypesSeller.add(3, 'seller (made on demand)');
+  priorityLevels.add("URGENT_JOB_PRIORITY", 1);
+  priorityLevels.add("HIGH_JOB_PRIORITY", 2);
+  priorityLevels.add("MEDIUM_JOB_PRIORITY", 3);
+  priorityLevels.add("LOW_JOB_PRIORITY", 4);
+  priorityLevelsOptions.add(1, 'Urgent');
+  priorityLevelsOptions.add(2, 'High');
+  priorityLevelsOptions.add(3, 'Medium');
+  priorityLevelsOptions.add(4, 'Low');
+  rights.add('canAccess', 1);
+  rights.add('canEdit', 2);
+  rights.add('canDelete', 3);
+  eventTypes.add('POST', 0);
+  eventTypes.add('PATCH', 1);
+  eventTypes.add('DELETE', 2);
+  itemTypes.add('custom', 0);
+  itemTypes.add('shipping', 1);
+  itemTypes.add('tax', 2);
+  menuType.add(0, 'Main menu');
+  menuType.add(1, 'Footer menu');
+  menuType.add(2, 'Other menu');
+  menuType.each(function (key, value) {
+    menuTypeCodes.add(value, parseInt(key, 10));
+  });
+  menuItemType.add(0, 'Redirect');
+  menuItemType.add(1, 'Internal');
+  menuItemType.each(function (key, value) {
+    menuItemTypeCodes.add(value, parseInt(key, 10));
+  });
+  DEFAULT_RIGHTS = [rights.get("canAccess"), rights.get("canEdit"), rights.get("canDelete")];
+  function toJsonList(objs) {
+    var result = [],
+      i,
+      obj,
+      obj_dict;
+    for (i = 0; i < objs.length; i++) {
+      obj = objs[i];
+      obj_dict = toJson(obj);
+      result.push(obj_dict);
+    }
+    return result;
+  }
+  function toJson(model) {
+    var json = {},
+      value,
+      dict;
+    (0, _model.forEachProperty)(model, function (propName, Type) {
+      var propNameCamel = propName.replace(/_([a-z])/g, function (g) {
+        return g[1].toUpperCase();
+      });
+      try {
+        value = model[propName]();
+        if (value !== null && (!Type || typeof value === 'number')) {
+          // if the value is default value skip from to json
+          // Prop is untyped or only id received
+          json[propNameCamel] = value;
+        } else if (!(0, _helpers.isUndefinedOrNull)(value)) {
+          // Prop is typed and other thing rather than
+          // single id received
+          if (value instanceof Array) {
+            if (value.length > 0) {
+              if (value[0] instanceof Object) {
+                // value is a array of objs
+                dict = toJsonList(value);
+              } else {
+                // value is a array of id
+                dict = value;
+              }
+              json[propNameCamel] = dict;
+            } else {
+              json[propNameCamel] = [];
+            }
+          } else {
+            // Embed Object received
+            dict = toJson(value);
+            json[propNameCamel] = dict;
+          }
+        }
+      } catch (ignore) {}
+    });
+    json.rights = model.rights;
+    return json;
+  }
+  function entAsBlank(obj) {
+    /* Return a copy of obj with only obj.id() set */
+    var newEnt = Object.create(Object.getPrototypeOf(obj));
+    Object.assign(newEnt, obj);
+    function copyProp(propertyName, propertyType) {
+      (0, _model.addPropertyTo)(newEnt, propertyName, propertyType);
+      if (propertyName === 'id') {
+        newEnt[propertyName](obj.id());
+      } else {
+        newEnt["_" + propertyName] = undefined;
+      }
+    }
+    (0, _model.forEachProperty)(obj, copyProp);
+    return newEnt;
+  }
+  function cleanEntities(entityArray) {
+    var newArray = [];
+    entityArray.map(function (entity) {
+      newArray.push(entAsBlank(entity));
+    });
+    return newArray;
+  }
+  ;
+  function copyEnt(obj) {
+    var newEnt = Object.create(Object.getPrototypeOf(obj));
+    Object.assign(newEnt, obj);
+    function copyProp(propertyName, propertyType) {
+      var propertyValue = obj[propertyName](),
+        newValue;
+      (0, _model.addPropertyTo)(newEnt, propertyName, propertyType);
+      if (!!propertyType) {
+        if (!!propertyValue) {
+          if (propertyValue instanceof Array) {
+            newValue = propertyValue.map(copyEnt);
+          } else {
+            newValue = copyEnt(propertyValue);
+          }
+        }
+      } else {
+        newValue = propertyValue;
+      }
+      newEnt[propertyName](newValue);
+    }
+    (0, _model.forEachProperty)(obj, copyProp);
+    return newEnt;
+  }
+  function copyEntIfNotNullOrUndefined(obj) {
+    var entCopy = obj ? copyEnt(obj) : null;
+    if (entCopy) {
+      entCopy.id(null);
+    }
+    return entCopy;
+  }
+  function updateEntNonEmbeddableAttrbibutes(ent, newEnt) {
+    function notArrayOrEmbeddableAttr(attrVal) {
+      return attrVal && !Array.isArray(attrVal) && !attrVal.json;
+    }
+    function copyProp(propertyName, propertyType) {
+      var entAttr = ent[propertyName](),
+        newEntAttr = newEnt[propertyName]();
+      if (notArrayOrEmbeddableAttr(entAttr) && notArrayOrEmbeddableAttr(newEntAttr)) {
+        ent[propertyName](newEntAttr);
+      }
+    }
+    (0, _model.forEachProperty)(newEnt, copyProp);
+    return ent;
+  }
+  function updateEntAttributes(ent, newEnt, attrs) {
+    var updatedEnt = updateEntNonEmbeddableAttrbibutes(ent, newEnt),
+      i;
+    for (i = 0; i < attrs.length; i++) {
+      var attributeName = attrs[i];
+      updatedEnt[attributeName](newEnt[attributeName]());
+    }
+    return updatedEnt;
+  }
+  function ignoreAttributesUpdateEnt(ent, newEnt, ignoredAttrs) {
+    /* Update an entity with new values from an updated entity
+       but ignore specified attributes
+    */
+    var updatedEnt = newEnt,
+      i;
+    for (i = 0; i < ignoredAttrs.length; i++) {
+      var attributeName = ignoredAttrs[i];
+      updatedEnt[attributeName](ent[attributeName]());
+    }
+    return updatedEnt;
+  }
+  function getCookie(name, defaultValue) {
+    var searchPrefix = name + '=',
+      cookies = document.cookie.split(';'),
+      i,
+      cookie;
+    for (i = 0; i < cookies.length; ++i) {
+      cookie = cookies[i];
+      cookie = cookie.replace(/^\s*/, '');
+      if (cookie.indexOf(searchPrefix) === 0) {
+        return cookie.substring(searchPrefix.length, cookie.length);
+      }
+    }
+    if ((0, _helpers.isUndefined)(defaultValue)) {
+      throw 'no such cookie present';
+    } else {
+      return defaultValue;
+    }
+  }
+  function getCartCookie(storeId) {
+    var idAndToken = getCookie('cart-' + String(storeId), null);
+    return idAndToken ? idAndToken.split(',') : null;
+  }
+  function setSessionCookie(name, value, domain) {
+    var cookie = name + '=' + value;
+    if (!!domain) {
+      // remove port, if it exists
+      var n = domain.indexOf(':');
+      domain = domain.substring(0, n != -1 ? n : domain.length);
+      // remove trailing slash and path, if they exists
+      n = domain.indexOf('/');
+      domain = domain.substring(0, n != -1 ? n : domain.length);
+      cookie += '; Domain=' + domain;
+    } else {
+      cookie += '; Domain=' + '.' + location.hostname;
+    }
+    cookie += '; path=/';
+    document.cookie = cookie;
+  }
+  function setCartCookie(storeId, cart, domain) {
+    var cookieValue = cart ? cart.id() + ',' + cart.token() : '';
+    setSessionCookie('cart-' + String(storeId), cookieValue, domain);
+  }
+  function logout() {
+    if (Boolean((0, _helpers.getGlobal)().currentSession)) {
+      (0, _helpers.getGlobal)().currentSession.remove(_helpers.id, _helpers.id);
+      (0, _helpers.getGlobal)().loggedInUser = null;
+      (0, _helpers.getGlobal)().currentSession = null;
+    }
+  }
+  function removeUnstoredFiles(files, removeAll) {
+    var count = 1,
+      i;
+    if (Boolean(removeAll)) {
+      count = files.filter(function (file) {
+        return (0, _helpers.isUndefinedOrNull)(file.id());
+      }).length;
+    }
+    for (i = 0; i < count; i++) {
+      files.splice(files.findIndex(function (obj) {
+        return obj.id() === null;
+      }), 1);
+    }
+    return files;
+  }
+  function toUnix(date) {
+    return Math.floor(date.getTime() / 1000);
+  }
+  function forquoteEdit(rights) {
+    var forbitEdit = false;
+    if (rights.indexOf(rights.get("canEdit")) === -1) {
+      forbitEdit = true;
+    }
+    return forbitEdit;
+  }
+  function forquoteDelete(rights) {
+    var forbitDelete = false;
+    if (rights.indexOf(rights.get("canDelete")) === -1) {
+      forbitDelete = true;
+    }
+    return forbitDelete;
+  }
+  function getRights(data) {
+    var return_rights;
+    if (data.rights !== undefined && data.rights !== null) {
+      return_rights = data.rights;
+    } else {
+      return_rights = DEFAULT_RIGHTS;
+    }
+    return return_rights;
+  }
+  function canEditAttributes(rights) {
+    var canEdit = false;
+    if (rights.indexOf(rights.get("canEdit")) !== -1) {
+      canEdit = true;
+    }
+    return canEdit;
+  }
+  function editAttributes(rights) {
+    var disableCommand = '';
+    if (!canEditAttributes(rights)) {
+      disableCommand += " disabled=disabled ";
+    }
+    return disableCommand;
+  }
+  function getQuote(productId, quantity, success, error) {
+    var request = new _model.Request(),
+      data = new _dictionary.Dictionary();
+    request.resource('/estimate/');
+    request.method('POST');
+    data.add('product', productId);
+    data.add('quantity', quantity);
+    request.query().add('skip_rights', true);
+    request.data().merge(data);
+    function handleResponse(status, data) {
+      if (status === 200) {
+        success(data);
+      } else {
+        error(data);
+      }
+    }
+    function handleError() {
+      error({
+        message: 'could not connect to server',
+        errorCode: 0
+      });
+    }
+    request.responseHandler(handleResponse).errorHandler(handleError);
+    request.send();
+  }
+  function getJobQuote(job, success, error) {
+    var slimProduct = new _product.Product().id(job.product().id()),
+      slimJob = job.domain(new _domain.Domain()).product(slimProduct),
+      request = new _model.Request(),
+      data = (0, _model.serialise)(slimJob)[0];
+    request.resource('/specialised-order-estimate/');
+    request.method('POST');
+    request.data().merge(data);
+    request.query().add('skip_rights', true);
+    // add this to helping backend to know what the product id is
+    request.query().add('product_id', job.product().id());
+    function handleResponse(status, data) {
+      if (status === 201) {
+        success(data);
+      } else {
+        error(data);
+      }
+    }
+    function handleError() {
+      error({
+        message: 'could not connect to server',
+        errorCode: 0
+      });
+    }
+    request.responseHandler(handleResponse).errorHandler(handleError);
+    request.send();
+  }
+  function initSessionByToken(tokenStringForUser, success, error, embed) {
+    if (!(0, _helpers.getGlobal)().currentSession) {
+      (0, _helpers.getGlobal)().currentSession = new _session.Session();
+    }
+    if (!embed) {
+      embed = {};
+    }
+    (0, _helpers.getGlobal)().currentSession.token(tokenStringForUser).get(success, error, {
+      'user': embed
+    });
+  }
+  function getCurrentUser(success, error, embed) {
+    var tokenStringForUser;
+    if (!!(0, _helpers.getGlobal)().loggedInUser && !embed) {
+      success((0, _helpers.getGlobal)().loggedInUser);
+      return;
+    }
+    function haveToken(token) {
+      (0, _helpers.getGlobal)().loggedInUser = token.user();
+      success((0, _helpers.getGlobal)().loggedInUser);
+    }
+    try {
+      tokenStringForUser = getCookie('session_token');
+    } catch (e) {
+      error(e);
+    }
+    if (Boolean(tokenStringForUser)) {
+      initSessionByToken(tokenStringForUser, haveToken, error, embed);
+    }
+  }
+  function checkUserInfo(args) {
+    var request = new _model.Request(),
+      data = new _dictionary.Dictionary();
+    function handleResponse(status, data) {
+      if (status === 200) {
+        args.success(data);
+      } else {
+        args.error(data);
+      }
+    }
+    function handleError() {
+      args.error({
+        message: 'could not connect to server',
+        errorCode: 0
+      });
+    }
+    if (isNaN(args.user_id)) {
+      args.error({
+        message: 'User id is not a number.'
+      });
+    } else {
+      data.add('subdomain', args.subdomain);
+      data.add('name', args.user_name);
+      data.add('email_address', args.user_email);
+      request.data().merge(data);
+      request.resource('/user-check/' + args.user_id + '/');
+      request.method('POST');
+      request.responseHandler(handleResponse).errorHandler(handleError);
+      request.send();
+    }
+  }
+  function getUpdateNotifications(optionsDict) {
+    var request = new _model.Request(),
+      data = new _dictionary.Dictionary();
+    function checkDictKey(optionsDict, key, checker, alerter) {
+      var checkObject = Object.prototype.hasOwnProperty.call(optionsDict, key) ? optionsDict[key] : [];
+      if (checker(checkObject)) {
+        return checkObject;
+      }
+      alerter();
+      return null;
+    }
+    function checkDictKeyForArray(optionsDict, key) {
+      return checkDictKey(optionsDict, key, _helpers.isArray, function () {
+        alert(key + " is not an array.");
+      });
+    }
+    function checkDictKeyForDict(optionsDict, key) {
+      return checkDictKey(optionsDict, key, isJSON, function () {
+        alert(key + " is not a dictionary.");
+      });
+    }
+    function checkDictKeyForFunction(optionsDict, key) {
+      return checkDictKey(optionsDict, key, isFunction, function () {
+        alert(key + " is not a function.");
+      });
+    }
+    function serlialiseEntitiesArray(optionsDict, key) {
+      var entitiesArray = checkDictKeyForArray(optionsDict, key),
+        arrayWithObjects = [],
+        entityObject,
+        i;
+      for (i = 0; i < entitiesArray.length; i++) {
+        entityObject = entitiesArray[i];
+        if (Boolean(entityObject)) {
+          arrayWithObjects.push({
+            type: entityObject.json,
+            id: entityObject.id()
+          });
+        }
+      }
+      return arrayWithObjects;
+    }
+    request.resource('/notifications-check-update/');
+    request.method('POST');
+    data.add('sections', JSON.stringify(checkDictKeyForArray(optionsDict, 'sections')));
+    data.add('entities', JSON.stringify(serlialiseEntitiesArray(optionsDict, 'entities')));
+    data.add('notificationTypes', JSON.stringify(checkDictKeyForDict(optionsDict, 'notificationTypes')));
+    request.data().merge(data);
+    request.query().add('skip_rights', 'y');
+    function handleResponse(status, data) {
+      if (status === 200) {
+        checkDictKeyForFunction(optionsDict, 'success')(data);
+      } else {
+        checkDictKeyForFunction(optionsDict, 'error')(data);
+      }
+    }
+    function handleError() {
+      alert('could not connect to server');
+    }
+    request.responseHandler(handleResponse).errorHandler(handleError);
+    request.send();
+  }
+  function checkAndUpdateNotifications(related_object_id, section, senderId, success, error) {
+    var request = new _model.Request(),
+      data = new _dictionary.Dictionary();
+    request.resource('/notifications-toast/');
+    request.method('POST');
+    data.add('related_object_id', related_object_id);
+    data.add('section', section);
+    data.add('sender_id', senderId);
+    request.query().add('skip_rights', 'y');
+    request.data().merge(data);
+    function handleResponse(status, data) {
+      if (status === 200) {
+        success(data);
+      } else {
+        error(data);
+      }
+    }
+    function handleError() {
+      error({
+        message: 'could not connect to server',
+        errorCode: 0
+      });
+    }
+    request.responseHandler(handleResponse).errorHandler(handleError);
+    request.send();
+    (0, _helpers.getGlobal)().merchiSubscriptionManager.subscribe([eventTypes.get('POST')], request.path(), "POST", handleResponse);
+  }
+  function escapeHtml(dangerousString) {
+    var entityMap = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': '&quot;',
+      "'": '&#39;',
+      "/": '&#x2F;'
+    };
+    return String(dangerousString).replace(/[&<>"'/]/g, function (s) {
+      return entityMap[s];
+    });
+  }
+  function getQueryStringValue(name) {
+    if (_browserOrNode.isBrowser) {
+      var query = window.location.search.substring(1),
+        vars = query.split("&"),
+        pair,
+        i;
+      for (i = 0; i < vars.length; i++) {
+        pair = vars[i].split("=");
+        if (pair[0] === name) {
+          return decodeURIComponent(pair[1]);
+        }
+      }
+    }
+    return undefined;
+  }
+  function getUserIdByEmail(emailAddress, success, error) {
+    var request = new _model.Request(),
+      data = new _dictionary.Dictionary();
+    request.resource('/user-check-email/');
+    request.method('POST');
+    data.add('email_address', emailAddress);
+    request.data().merge(data);
+    function handleResponse(status, data) {
+      if (status === 200) {
+        success(data);
+      } else {
+        error(status, data);
+      }
+    }
+    request.responseHandler(handleResponse).errorHandler(error);
+    request.send();
+  }
+  function placeOrder(clientId, quantity, product, address, variations, success, error) {
+    var request = new _model.Request(),
+      productId = product.id(),
+      data = new _dictionary.Dictionary();
+    data.add('client_id', clientId);
+    data.add('quantity', quantity);
+    data.add('product_id', productId);
+    data.add('variation_notes', variations);
+    if (address !== null) {
+      data = (0, _model.serialise)(address, data)[0];
+    }
+    request.resource('/public-order/');
+    request.method('POST');
+    request.data().merge(data);
+    function handleResponse(status, data) {
+      if (status === 200) {
+        success(data);
+      } else {
+        error(data);
+      }
+    }
+    function handleError() {
+      error({
+        message: 'could not connect to server',
+        errorCode: 0
+      });
+    }
+    request.responseHandler(handleResponse).errorHandler(handleError);
+    request.send();
+  }
+  function getProductShipmentOptions(productId, quantity, address, success, error) {
+    var request = new _model.Request(),
+      data = new _dictionary.Dictionary();
+    data.add('quantity', quantity);
+    data = (0, _model.serialise)(address, data, 'address')[0];
+    request.resource("/products/".concat(productId, "/shipment_options/"));
+    request.method('POST');
+    request.data().merge(data);
+    function handleResponse(status, data) {
+      if (status === 200) {
+        success(data);
+      } else {
+        error(data);
+      }
+    }
+    function handleError() {
+      error({
+        message: 'could not connect to server',
+        errorCode: 0
+      });
+    }
+    request.responseHandler(handleResponse).errorHandler(handleError);
+    request.send();
+  }
+  if (!(0, _helpers.getGlobal)().currentUser) getCurrentUser(_helpers.id, _helpers.id, currentUserEmbed);
+  return {
+    'roles': _roles.roles,
+    'roleStrings': roleStrings,
+    'systemRoles': _roles.systemRoles,
+    'roleCssClass': roleCssClass,
+    'eventTypes': eventTypes,
+    'getGlobal': _helpers.getGlobal,
+    'logout': logout,
+    'canEditAttributes': canEditAttributes,
+    'editAttributes': editAttributes,
+    'forquoteEdit': forquoteEdit,
+    'getRights': getRights,
+    'forquoteDelete': forquoteDelete,
+    'DEFAULT_RIGHTS': DEFAULT_RIGHTS,
+    'priorityLevels': priorityLevels,
+    'URGENT_JOB_PRIORITY': priorityLevels.get('URGENT_JOB_PRIORITY'),
+    'HIGH_JOB_PRIORITY': priorityLevels.get('HIGH_JOB_PRIORITY'),
+    'MEDIUM_JOB_PRIORITY': priorityLevels.get('MEDIUM_JOB_PRIORITY'),
+    'LOW_JOB_PRIORITY': priorityLevels.get('LOW_JOB_PRIORITY'),
+    'priorityLevelsOptions': priorityLevelsOptions,
+    'PhoneNumber': _phone_number.PhoneNumber,
+    'Dictionary': _dictionary.Dictionary,
+    'phoneNumbers': new _phone_number.PhoneNumbers(),
+    'EmailAddress': _email_address.EmailAddress,
+    'emailAddresses': new _email_address.EmailAddresses(),
+    'EmailCounter': _email_counter.EmailCounter,
+    'emailCounters': new _email_counter.EmailCounters(),
+    'Address': _address.Address,
+    'addresses': new _address.Addresses(),
+    'User': _user.User,
+    'users': new _user.Users(),
+    'Domain': _domain.Domain,
+    'domains': new _domain.Domains(),
+    'DomainInvitation': _domain_invitation.DomainInvitation,
+    'Draft': _draft.Draft,
+    'drafts': new _draft.Drafts(),
+    'DraftComment': _draft_comment.DraftComment,
+    'DraftTemplate': _draft_template.DraftTemplate,
+    'ExchangeRate': _exchange_rate.ExchangeRate,
+    'exchangeRates': new _exchange_rate.ExchangeRates(),
+    'Theme': _theme.Theme,
+    'themes': new _theme.Themes(),
+    'EnrolledDomain': _enrolled_domain.EnrolledDomain,
+    'enrolledDomains': new _enrolled_domain.EnrolledDomains(),
+    'AutomaticPaymentRelationship': _automatic_payment_relationship.AutomaticPaymentRelationship,
+    'automaticPaymentRelationships': new _automatic_payment_relationship.AutomaticPaymentRelationships(),
+    'Company': _company.Company,
+    'companies': new _company.Companies(),
+    'CompanyInvitation': _company_invitation.CompanyInvitation,
+    'companyInvitations': new _company_invitation.CompanyInvitations(),
+    'UserCompany': _user_company.UserCompany,
+    'Category': _category.Category,
+    'categories': new _category.Categories(),
+    'Component': _component.Component,
+    'components': new _component.Components(),
+    'ComponentTag': _component_tag.ComponentTag,
+    'componentTags': new _component_tag.ComponentTags(),
+    'DomainTag': _domain_tag.DomainTag,
+    'domainTags': new _domain_tag.DomainTags(),
+    'Product': _product.Product,
+    'products': new _product.Products(),
+    'ProductionComment': _production_comment.ProductionComment,
+    'Inventory': _inventory.Inventory,
+    'inventories': new _inventory.Inventories(),
+    'InventoryUnitVariation': _inventory_unit_variation.InventoryUnitVariation,
+    'matchiingInventory': _matching_inventory.MatchingInventory,
+    'InternalTag': _internal_tag.InternalTag,
+    'internalTags': new _internal_tag.InternalTags(),
+    'Invoice': _invoice.Invoice,
+    'invoices': new _invoice.Invoices(),
+    'Job': _job.Job,
+    'jobs': new _job.Jobs(),
+    'JobComment': _job_comment.JobComment,
+    'Cart': _cart.Cart,
+    'CartItem': _cart_item.CartItem,
+    'Bank': _bank.Bank,
+    'QuoteItem': _quote_item.QuoteItem,
+    'QuoteItems': new _quote_item.QuoteItems(),
+    'Quote': _quote.Quote,
+    'Quotes': new _quote.Quotes(),
+    'Assignment': _assignment.Assignment,
+    'Assignments': new _assignment.Assignments(),
+    'File': _merchi_file.MerchiFile,
+    'files': new _merchi_file.MerchiFiles(),
+    'Backup': _backup.Backup,
+    'backups': new _backup.Backups(),
+    'removeUnstoredFiles': removeUnstoredFiles,
+    'Shipment': _shipment.Shipment,
+    'shipments': new _shipment.Shipments(),
+    'ShipmentMethod': _shipment_method.ShipmentMethod,
+    'shipmentMethods': new _shipment_method.ShipmentMethods(),
+    'ShipmentMethodVariation': _shipment_method_variation.ShipmentMethodVariation,
+    'shipmentMethodVariations': new _shipment_method_variation.ShipmentMethodVariations(),
+    'CountryTax': _country_tax.CountryTax,
+    'countryTaxes': new _country_tax.CountryTaxes(),
+    'Discount': _discount.Discount,
+    'DiscountGroups': _discount_group.DiscountGroup,
+    'SupplyDomain': _supply_domain.SupplyDomain,
+    'SupplyDomains': new _supply_domain.SupplyDomains(),
+    'initSessionByToken': initSessionByToken,
+    'getCurrentUser': getCurrentUser,
+    'Payment': _payment.Payment,
+    'Item': _item.Item,
+    'Session': _session.Session,
+    'sessions': new _session.Sessions(),
+    'serialise': _model.serialise,
+    'SystemRole': _system_role.SystemRole,
+    'toJson': toJson,
+    'toJsonList': toJsonList,
+    'rights': rights,
+    'itemTypes': itemTypes,
+    'Request': _model.Request,
+    'STATUS': STATUS,
+    'GSTrate': GSTrate,
+    'Notification': _notification.Notification,
+    'notifications': new _notification.Notifications(),
+    'SubscriptionPlan': _subscription_plan.SubscriptionPlan,
+    'subscriptionPlans': new _subscription_plan.SubscriptionPlans(),
+    'VariationField': _variation_field.VariationField,
+    'Variation': _variation.Variation,
+    'VariationsGroup': _variations_group.VariationsGroup,
+    'VariationFieldsOption': _variation_fields_option.VariationFieldsOption,
+    'Menu': _menu.Menu,
+    'MenuItem': _menu_item.MenuItem,
+    'notificationTypes': _notification_types.notificationTypes,
+    'paymentTypes': _payment_types.paymentTypes,
+    'paymentTypeIds': _payment_types.paymentTypeIds,
+    'Page': _page.Page,
+    'toUnix': toUnix,
+    'id': _helpers.id,
+    'isUndefined': _helpers.isUndefined,
+    'isNull': _helpers.isNull,
+    'isUndefinedOrNull': _helpers.isUndefinedOrNull,
+    'indexOfEntityInArrayById': indexOfEntityInArrayById,
+    'indexOfEntityInArrayByName': indexOfEntityInArrayByName,
+    'jobStatusProduction': _job_status.jobStatusProduction,
+    'jobPriority': _job_status.jobPriority,
+    'notEmptyArray': _helpers.notEmptyArray,
+    'displayMoney': displayMoney,
+    'sortArrayByObjectKey': _helpers.sortArrayByObjectKey,
+    'fromJson': _model.fromJson,
+    'fromJsonList': _model.fromJsonList,
+    'setSessionCookie': setSessionCookie,
+    'setCartCookie': setCartCookie,
+    'getQuote': getQuote,
+    'checkAndUpdateNotifications': checkAndUpdateNotifications,
+    'escapeHtml': escapeHtml,
+    'getQueryStringValue': getQueryStringValue,
+    'NoTaxEntity': _country_tax.NoTaxEntity,
+    'notificationSectionCodes': _notification_types.notificationSectionCodes,
+    'notificationSectionClass': _notification_types.notificationSectionClass,
+    'notificationSectionIconClass': _notification_types.notificationSectionIconClass,
+    'notificationSection': _notification_types.notificationSection,
+    'notificationSectionKey': _notification_types.notificationSectionKey,
+    'notificationAvatar': notificationAvatar,
+    'fieldTypes': _field_types.fieldTypes,
+    'fieldTypesString': fieldTypesString,
+    'inputTypes': inputTypes,
+    'domainTypes': _domain_types.domainTypes,
+    'getCookie': getCookie,
+    'getCartCookie': getCartCookie,
+    'getUserIdByEmail': getUserIdByEmail,
+    'placeOrder': placeOrder,
+    'platformName': platformName,
+    'platformSellerDomain': platformSellerDomain,
+    'platformSellerDomainPlus': platformSellerDomainPlus,
+    'platformCopyright': platformCopyright,
+    'platformIcon': platformIcon,
+    'defaultUserAvatar': defaultUserAvatar,
+    'platformLogo': platformLogo,
+    'menuItemType': menuItemType,
+    'menuItemTypeCodes': menuItemTypeCodes,
+    'menuType': menuType,
+    'menuTypeCodes': menuTypeCodes,
+    'checkUserInfo': checkUserInfo,
+    'getJobQuote': getJobQuote,
+    'removeObjectFromArrayWithIntegerValue': _helpers.removeObjectFromArrayWithIntegerValue,
+    'shipmentCompanies': shipmentCompanies,
+    'generateUUID': _uuid.generateUUID,
+    'getUpdateNotifications': getUpdateNotifications,
+    'currentUserEmbed': currentUserEmbed,
+    'create': _model.create,
+    'copyEnt': copyEnt,
+    'copyEntIfNotNullOrUndefined': copyEntIfNotNullOrUndefined,
+    'entAsBlank': entAsBlank,
+    'cleanEntities': cleanEntities,
+    'userTypes': _user_types.userTypes,
+    'updateEntNonEmbeddableAttrbibutes': updateEntNonEmbeddableAttrbibutes,
+    'updateEntAttributes': updateEntAttributes,
+    'ignoreAttributesUpdateEnt': ignoreAttributesUpdateEnt,
+    'inventoryStatuses': inventoryStatuses,
+    'productTypes': _product_types.productTypes,
+    'productTypesInts': _product_types.productTypesInts,
+    'productTypesSeller': productTypesSeller,
+    'getProductShipmentOptions': getProductShipmentOptions
+  };
+}