h54s/dist/h54s.js

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.h54s = f()}})(function(){var define,module,exports;return (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){
/*
* h54s error constructor
* @constructor
*
*@param {string} type - Error type
*@param {string} message - Error message
*@param {string} status - Error status returned from SAS
*
*/
function h54sError(type, message, status) {
  if(Error.captureStackTrace) {
    Error.captureStackTrace(this);
  }
  this.message = message;
  this.type    = type;
  this.status  = status;
}

h54sError.prototype = Object.create(Error.prototype, {
  constructor: {
    configurable: false,
    enumerable: false,
    writable: false,
    value: h54sError
  },
  name: {
    configurable: false,
    enumerable: false,
    writable: false,
    value: 'h54sError'
  }
});

module.exports = h54sError;

},{}],2:[function(require,module,exports){
const h54sError = require('../error.js');

/**
* h54s SAS Files object constructor
* @constructor
*
*@param {file} file - File added when object is created
*@param {string} macroName - macro name
*
*/
function Files(file, macroName) {
  this._files = {};

  Files.prototype.add.call(this, file, macroName);
}

/**
* Add file to files object
* @param {file} file - Instance of JavaScript File object
* @param {string} macroName - Sas macro name
*
*/
Files.prototype.add = function(file, macroName) {
  if(file && macroName) {
    if(!(file instanceof File || file instanceof Blob)) {
      throw new h54sError('argumentError', 'First argument must be instance of File object');
    }
    if(typeof macroName !== 'string') {
      throw new h54sError('argumentError', 'Second argument must be string');
    }
    if(!isNaN(macroName[macroName.length - 1])) {
      throw new h54sError('argumentError', 'Macro name cannot have number at the end');
    }
  } else {
    throw new h54sError('argumentError', 'Missing arguments');
  }

  this._files[macroName] = [
    'FILE',
    file
  ];
};

module.exports = Files;

},{"../error.js":1}],3:[function(require,module,exports){
const h54sError = require('./error.js');

const sasVersionMap = {
	v9: {
    url: '/SASStoredProcess/do',
    loginUrl: '/SASLogon/login',
		logoutUrl: '/SASStoredProcess/do?_action=logoff',
    RESTAuthLoginUrl: '/SASLogon/v1/tickets'
	},
	viya: {
		url: '/SASJobExecution/',
    loginUrl: '/SASLogon/login.do',
		logoutUrl: '/SASLogon/logout.do?',
    RESTAuthLoginUrl: ''
	}
}

/**
*
* @constructor
* @param {Object} config - Configuration object for the H54S SAS Adapter
* @param {String} config.sasVersion - Version of SAS, either 'v9' or 'viya'
* @param {Boolean} config.debug - Whether debug mode is enabled, sets _debug=131
* @param {String} config.metadataRoot - Base path of all project services to be prepended to _program path
* @param {String} config.url - URI of the job executor - SPWA or JES
* @param {String} config.loginUrl - URI of the SASLogon web login path - overridden by form action
* @param {String} config.logoutUrl - URI of the logout action
* @param {String} config.RESTauth - Boolean to toggle use of REST authentication in SAS v9
* @param {String} config.RESTauthLoginUrl - Address of SASLogon tickets endpoint for REST auth
* @param {Boolean} config.retryAfterLogin - Whether to resume requests which were parked with login redirect after a successful re-login
* @param {Number} config.maxXhrRetries - If a program call fails, attempt to call it again N times until it succeeds
* @param {Number} config.ajaxTimeout - Number of milliseconds to wait for a response before closing the request
* @param {Boolean} config.useMultipartFormData - Whether to use multipart for POST - for legacy backend support
* @param {String} config.csrf - CSRF token for JES
* @
*
*/
const h54s = module.exports = function(config) {
  // Default config values, overridden by anything in the config object
	this.sasVersion           = (config && config.sasVersion) || 'v9' //use v9 as default=
  this.debug                = (config && config.debug) || false;
  this.metadataRoot					= (config && config.metadataRoot) || '';
  this.url                  = sasVersionMap[this.sasVersion].url;
  this.loginUrl             = sasVersionMap[this.sasVersion].loginUrl;
  this.logoutUrl            = sasVersionMap[this.sasVersion].logoutUrl;
  this.RESTauth             = false;
  this.RESTauthLoginUrl     = sasVersionMap[this.sasVersion].RESTAuthLoginUrl;
  this.retryAfterLogin      = true;
  this.maxXhrRetries        = 5;
  this.ajaxTimeout          = (config && config.ajaxTimeout) || 300000;
  this.useMultipartFormData = (config && config.useMultipartFormData) || true;
  this.csrf                 = ''
  this.isViya								= this.sasVersion === 'viya';

  // Initialising callback stacks for when authentication is paused
  this.remoteConfigUpdateCallbacks = [];
  this._pendingCalls = [];
  this._customPendingCalls = [];
  this._disableCalls = false
  this._ajax = require('./methods/ajax.js')();

  _setConfig.call(this, config);

  // If this instance was deployed with a standalone config external to the build use that
  if(config && config.isRemoteConfig) {
    const self = this;

    this._disableCalls = true;

    // 'h54sConfig.json' is for the testing with karma
    //replaced by gulp in dev build (defined in gulpfile under proxies)
    this._ajax.get('h54sConfig.json').success(function(res) {
      const remoteConfig = JSON.parse(res.responseText)

			// Save local config before updating it with remote config
			const localConfig = Object.assign({}, config)
			const oldMetadataRoot = localConfig.metadataRoot;

      for(let key in remoteConfig) {
        if(remoteConfig.hasOwnProperty(key) && key !== 'isRemoteConfig') {
          config[key] = remoteConfig[key];
        }
      }

      _setConfig.call(self, config);

      // Execute callbacks when overrides from remote config are applied
      for(let i = 0, n = self.remoteConfigUpdateCallbacks.length; i < n; i++) {
        const fn = self.remoteConfigUpdateCallbacks[i];
        fn();
      }

      // Execute sas calls disabled while waiting for the config
      self._disableCalls = false;
      while(self._pendingCalls.length > 0) {
        const pendingCall = self._pendingCalls.shift();
				const sasProgram = pendingCall.options.sasProgram;
				const callbackPending = pendingCall.options.callback;
				const params = pendingCall.params;
				//update debug because it may change in the meantime
				params._debug = self.debug ? 131 : 0;

        // Update program path with metadataRoot if it's not set
        if(self.metadataRoot && params._program.indexOf(self.metadataRoot) === -1) {
          params._program = self.metadataRoot.replace(/\/?$/, '/') + params._program.replace(oldMetadataRoot, '').replace(/^\//, '');
        }

        // Update debug because it may change in the meantime
        params._debug = self.debug ? 131 : 0;

        self.call(sasProgram, null, callbackPending, params);
      }

      // Execute custom calls that we made while waitinf for the config
       while(self._customPendingCalls.length > 0) {
      	const pendingCall = self._customPendingCalls.shift()
				const callMethod = pendingCall.callMethod
				const _url = pendingCall._url
				const options = pendingCall.options;
        ///update program with metadataRoot if it's not set
        if(self.metadataRoot && options.params && options.params._program.indexOf(self.metadataRoot) === -1) {
          options.params._program = self.metadataRoot.replace(/\/?$/, '/') + options.params._program.replace(oldMetadataRoot, '').replace(/^\//, '');
        }
        //update debug because it also may have changed from remoteConfig
				if (options.params) {
					options.params._debug = self.debug ? 131 : 0;
				}
				self.managedRequest(callMethod, _url, options);
      }
    }).error(function (err) {
      throw new h54sError('ajaxError', 'Remote config file cannot be loaded. Http status code: ' + err.status);
    });
  }

  // private function to set h54s instance properties
  function _setConfig(config) {
    if(!config) {
      this._ajax.setTimeout(this.ajaxTimeout);
      return;
    } else if(typeof config !== 'object') {
      throw new h54sError('argumentError', 'First parameter should be config object');
    }

    //merge config object from parameter with this
    for(let key in config) {
      if(config.hasOwnProperty(key)) {
        if((key === 'url' || key === 'loginUrl') && config[key].charAt(0) !== '/') {
          config[key] = '/' + config[key];
        }
        this[key] = config[key];
      }
    }

    //if server is remote use the full server url
    //NOTE: This requires CORS and is here for legacy support
    if(config.hostUrl) {
      if(config.hostUrl.charAt(config.hostUrl.length - 1) === '/') {
        config.hostUrl = config.hostUrl.slice(0, -1);
      }
      this.hostUrl = config.hostUrl;
      if (!this.url.includes(this.hostUrl)) {
				this.url = config.hostUrl + this.url;
			}
			if (!this.loginUrl.includes(this.hostUrl)) {
				this.loginUrl = config.hostUrl + this.loginUrl;
			}
			if (!this.RESTauthLoginUrl.includes(this.hostUrl)) {
				this.RESTauthLoginUrl = config.hostUrl + this.RESTauthLoginUrl;
			}
    }

    this._ajax.setTimeout(this.ajaxTimeout);
  }
};

// replaced by gulp with real version at build time
h54s.version = '2.2.5';


h54s.prototype = require('./methods');

h54s.Tables = require('./tables');
h54s.Files = require('./files');
h54s.SasData = require('./sasData.js');

h54s.fromSasDateTime = require('./methods/utils.js').fromSasDateTime;
h54s.toSasDateTime = require('./tables/utils.js').toSasDateTime;

//self invoked function module
require('./ie_polyfills.js');

},{"./error.js":1,"./files":2,"./ie_polyfills.js":4,"./methods":7,"./methods/ajax.js":6,"./methods/utils.js":8,"./sasData.js":9,"./tables":10,"./tables/utils.js":11}],4:[function(require,module,exports){
module.exports = function() {
  if (!Object.create) {
    Object.create = function(proto, props) {
      if (typeof props !== "undefined") {
        throw "The multiple-argument version of Object.create is not provided by this browser and cannot be shimmed.";
      }
      function ctor() { }
      ctor.prototype = proto;
      return new ctor();
    };
  }


  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
  if (!Object.keys) {
    Object.keys = (function () {
      'use strict';
      var hasOwnProperty = Object.prototype.hasOwnProperty,
          hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
          dontEnums = [
            'toString',
            'toLocaleString',
            'valueOf',
            'hasOwnProperty',
            'isPrototypeOf',
            'propertyIsEnumerable',
            'constructor'
          ],
          dontEnumsLength = dontEnums.length;

      return function (obj) {
        if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
          throw new TypeError('Object.keys called on non-object');
        }

        var result = [], prop, i;

        for (prop in obj) {
          if (hasOwnProperty.call(obj, prop)) {
            result.push(prop);
          }
        }

        if (hasDontEnumBug) {
          for (i = 0; i < dontEnumsLength; i++) {
            if (hasOwnProperty.call(obj, dontEnums[i])) {
              result.push(dontEnums[i]);
            }
          }
        }
        return result;
      };
    }());
  }

  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
  if (!Array.prototype.lastIndexOf) {
    Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) {
      'use strict';

      if (this === void 0 || this === null) {
        throw new TypeError();
      }

      var n, k,
        t = Object(this),
        len = t.length >>> 0;
      if (len === 0) {
        return -1;
      }

      n = len - 1;
      if (arguments.length > 1) {
        n = Number(arguments[1]);
        if (n != n) {
          n = 0;
        }
        else if (n !== 0 && n != (1 / 0) && n != -(1 / 0)) {
          n = (n > 0 || -1) * Math.floor(Math.abs(n));
        }
      }

      for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {
        if (k in t && t[k] === searchElement) {
          return k;
        }
      }
      return -1;
    };
  }
}();

if (window.NodeList && !NodeList.prototype.forEach) {
   NodeList.prototype.forEach = Array.prototype.forEach;
}
},{}],5:[function(require,module,exports){
const logs = {
  applicationLogs: [],
  debugData: [],
  sasErrors: [],
  failedRequests: []
};

const limits = {
  applicationLogs: 100,
  debugData: 20,
  failedRequests: 20,
  sasErrors: 100
};

module.exports.get = {
  getSasErrors: function() {
    return logs.sasErrors;
  },
  getApplicationLogs: function() {
    return logs.applicationLogs;
  },
  getDebugData: function() {
    return logs.debugData;
  },
  getFailedRequests: function() {
    return logs.failedRequests;
  },
  getAllLogs: function () {
    return {
      sasErrors: logs.sasErrors,
      applicationLogs: logs.applicationLogs,
      debugData: logs.debugData,
      failedRequests: logs.failedRequests
    }
  }
};

module.exports.clear = {
  clearApplicationLogs: function() {
    logs.applicationLogs.splice(0, logs.applicationLogs.length);
  },
  clearDebugData: function() {
    logs.debugData.splice(0, logs.debugData.length);
  },
  clearSasErrors: function() {
    logs.sasErrors.splice(0, logs.sasErrors.length);
  },
  clearFailedRequests: function() {
    logs.failedRequests.splice(0, logs.failedRequests.length);
  },
  clearAllLogs: function() {
    this.clearApplicationLogs();
    this.clearDebugData();
    this.clearSasErrors();
    this.clearFailedRequests();
  }
};

/**
*  Adds application logs to an array of logs
*
* @param {String} message - Message to add to applicationLogs
* @param {String} sasProgram - Header - which request did message come from
*
*/
module.exports.addApplicationLog = function(message, sasProgram) {
  if(message === 'blank') {
    return;
  }
  const log = {
    message:    message,
    time:       new Date(),
    sasProgram: sasProgram
  };
  logs.applicationLogs.push(log);

  if(logs.applicationLogs.length > limits.applicationLogs) {
    logs.applicationLogs.shift();
  }
};

/**
* Adds debug data to an array of logs
*
* @param {String} htmlData - Full html log from executor
* @param {String} debugText - Debug text that came after data output
* @param {String} sasProgram - Which program request did message come from
* @param {String} params - Web app params that were received
*
*/
module.exports.addDebugData = function(htmlData, debugText, sasProgram, params) {
  logs.debugData.push({
    debugHtml:  htmlData,
    debugText:  debugText,
    sasProgram: sasProgram,
    params:     params,
    time:       new Date()
  });

  if(logs.debugData.length > limits.debugData) {
    logs.debugData.shift();
  }
};

/**
* Adds failed requests to an array of failed request logs
*
* @param {String} responseText - Full html output from executor
* @param {String} debugText - Debug text that came after data output
* @param {String} sasProgram - Which program request did message come from
*
*/
module.exports.addFailedRequest = function(responseText, debugText, sasProgram) {
  logs.failedRequests.push({
    responseHtml: responseText,
    responseText: debugText,
    sasProgram:   sasProgram,
    time:         new Date()
  });

  //max 20 failed requests
  if(logs.failedRequests.length > limits.failedRequests) {
    logs.failedRequests.shift();
  }
};

/**
* Adds SAS errors to an array of logs
*
* @param {Array} errors - Array of errors to concat to main log
*
*/
module.exports.addSasErrors = function(errors) {
  logs.sasErrors = logs.sasErrors.concat(errors);

  while(logs.sasErrors.length > limits.sasErrors) {
    logs.sasErrors.shift();
  }
};

},{}],6:[function(require,module,exports){
module.exports = function () {
  let timeout = 30000;
  let timeoutHandle;

  const xhr = function (type, url, data, multipartFormData, headers = {}) {
    const methods = {
      success: function () {
      },
      error: function () {
      }
    };

    const XHR = XMLHttpRequest;
    const request = new XHR('MSXML2.XMLHTTP.3.0');

    request.open(type, url, true);

    //multipart/form-data is set automatically so no need for else block
    // Content-Type header has to be explicitly set up
    if (!multipartFormData) {
      if (headers['Content-Type']) {
        request.setRequestHeader('Content-Type', headers['Content-Type'])
      } else {
        request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
      }
    }
    Object.keys(headers).forEach(key => {
      if (key !== 'Content-Type') {
        request.setRequestHeader(key, headers[key])
      }
    })
    request.onreadystatechange = function () {
      if (request.readyState === 4) {
        clearTimeout(timeoutHandle);
        if (request.status >= 200 && request.status < 300) {
          methods.success.call(methods, request);
        } else {
          methods.error.call(methods, request);
        }
      }
    };

    if (timeout > 0) {
      timeoutHandle = setTimeout(function () {
        request.abort();
      }, timeout);
    }

    request.send(data);

    return {
      success: function (callback) {
        methods.success = callback;
        return this;
      },
      error: function (callback) {
        methods.error = callback;
        return this;
      }
    };
  };

  const serialize = function (obj) {
    const str = [];
    for (let p in obj) {
      if (obj.hasOwnProperty(p)) {
        if (obj[p] instanceof Array) {
          for (let i = 0, n = obj[p].length; i < n; i++) {
            str.push(encodeURIComponent(p) + "=" + encodeURIComponent(obj[p][i]));
          }
        } else {
          str.push(encodeURIComponent(p) + "=" + encodeURIComponent(obj[p]));
        }
      }
    }
    return str.join("&");
  };

  const createMultipartFormDataPayload = function (obj) {
    let data = new FormData();
    for (let p in obj) {
      if (obj.hasOwnProperty(p)) {
        if (obj[p] instanceof Array && p !== 'file') {
          for (let i = 0, n = obj[p].length; i < n; i++) {
            data.append(p, obj[p][i]);
          }
        } else if (p === 'file') {
          data.append(p, obj[p][0], obj[p][1]);
        } else {
          data.append(p, obj[p]);
        }
      }
    }
    return data;
  };

  return {
    get: function (url, data, multipartFormData, headers) {
      let dataStr;
      if (typeof data === 'object') {
        dataStr = serialize(data);
      }
      const urlWithParams = dataStr ? (url + '?' + dataStr) : url;
      return xhr('GET', urlWithParams, null, multipartFormData, headers);
    },
		post: function(url, data, multipartFormData, headers) {
      let payload = data;
      if(typeof data === 'object') {
        if(multipartFormData) {
          payload = createMultipartFormDataPayload(data);
        } else {
          payload = serialize(data);
        }
      }
      return xhr('POST', url, payload, multipartFormData, headers);
    },
    put: function(url, data, multipartFormData, headers) {
      let payload = data;
      if(typeof data === 'object') {
        if(multipartFormData) {
          payload = createMultipartFormDataPayload(data);
        }
      }
      return xhr('PUT', url, payload, multipartFormData, headers);
    },
		delete: function(url, payload, multipartFormData, headers) {
    	return xhr('DELETE', url, payload, null, headers);
    },
    patch: function(url, data, multipartFormData, headers) {
      let payload = data;
      if(typeof data === 'object') {
        if(multipartFormData) {
          payload = createMultipartFormDataPayload(data);
        }
      }
      return xhr('PATCH', url, payload, multipartFormData, headers);
    },
    setTimeout: function (t) {
      timeout = t;
    },
    serialize
  };
};

},{}],7:[function(require,module,exports){
const h54sError = require('../error.js');
const logs = require('../logs.js');
const Tables = require('../tables');
const SasData = require('../sasData.js');
const Files = require('../files');

/**
* Call Sas program
*
* @param {string} sasProgram - Path of the sas program
* @param {Object} dataObj - Instance of Tables object with data added
* @param {function} callback - Callback function called when ajax call is finished
* @param {Object} params - object containing additional program parameters
*
*/
module.exports.call = function (sasProgram, dataObj, callback, params) {
	const self = this;
	let retryCount = 0;
	const dbg = this.debug
	const csrf = this.csrf;

	if (!callback || typeof callback !== 'function') {
		throw new h54sError('argumentError', 'You must provide a callback');
	}
	if (!sasProgram) {
		throw new h54sError('argumentError', 'You must provide Sas program file path');
	}
	if (typeof sasProgram !== 'string') {
		throw new h54sError('argumentError', 'First parameter should be string');
	}
	if (this.useMultipartFormData === false && !(dataObj instanceof Tables)) {
		throw new h54sError('argumentError', 'Cannot send files using application/x-www-form-urlencoded. Please use Tables or default value for useMultipartFormData');
	}

	if (!params) {
		params = {
			_program: this._utils.getFullProgramPath(this.metadataRoot, sasProgram),
			_debug: this.debug ? 131 : 0,
			_service: 'default',
			_csrf: csrf
		};
	} else {
		params = Object.assign({}, params, {_csrf: csrf})
	}

	if (dataObj) {
		let key, dataProvider;
		if (dataObj instanceof Tables) {
			dataProvider = dataObj._tables;
		} else if (dataObj instanceof Files || dataObj instanceof SasData) {
			dataProvider = dataObj._files;
		} else {
			console.log(new h54sError('argumentError', 'Wrong type of tables object'))
		}
		for (key in dataProvider) {
			if (dataProvider.hasOwnProperty(key)) {
				params[key] = dataProvider[key];
			}
		}
	}

	if (this._disableCalls) {
		this._pendingCalls.push({
			params,
			options: {
				sasProgram,
				dataObj,
				callback
			}
		});
		return;
	}

	this._ajax.post(this.url, params, this.useMultipartFormData).success(async function (res) {
		if (self._utils.needToLogin.call(self, res)) {
			//remember the call for latter use
			self._pendingCalls.push({
				params,
				options: {
					sasProgram,
					dataObj,
					callback
				}
			});

			//there's no need to continue if previous call returned login error
			if (self._disableCalls) {
				return;
			} else {
				self._disableCalls = true;
			}

			callback(new h54sError('notLoggedinError', 'You are not logged in'));
		} else {
			let resObj, unescapedResObj, err;
			let done = false;

			if (!dbg) {
				try {
					resObj = self._utils.parseRes(res.responseText, sasProgram, params);
					logs.addApplicationLog(resObj.logmessage, sasProgram);

					if (dataObj instanceof Tables) {
						unescapedResObj = self._utils.unescapeValues(resObj);
					} else {
						unescapedResObj = resObj;
					}

					if (resObj.status !== 'success') {
						err = new h54sError('programError', resObj.errormessage, resObj.status);
					}

					done = true;
				} catch (e) {
					if (e instanceof SyntaxError) {
						if (retryCount < self.maxXhrRetries) {
							done = false;
							self._ajax.post(self.url, params, self.useMultipartFormData).success(this.success).error(this.error);
							retryCount++;
							logs.addApplicationLog("Retrying #" + retryCount, sasProgram);
						} else {
							self._utils.parseErrorResponse(res.responseText, sasProgram);
							self._utils.addFailedResponse(res.responseText, sasProgram);
							err = new h54sError('parseError', 'Unable to parse response json');
							done = true;
						}
					} else if (e instanceof h54sError) {
						self._utils.parseErrorResponse(res.responseText, sasProgram);
						self._utils.addFailedResponse(res.responseText, sasProgram);
						err = e;
						done = true;
					} else {
						self._utils.parseErrorResponse(res.responseText, sasProgram);
						self._utils.addFailedResponse(res.responseText, sasProgram);
						err = new h54sError('unknownError', e.message);
						err.stack = e.stack;
						done = true;
					}
				} finally {
					if (done) {
						callback(err, unescapedResObj);
					}
				}
			} else {
				try {
					resObj = await self._utils.parseDebugRes(res.responseText, sasProgram, params, self.hostUrl, self.isViya);
					logs.addApplicationLog(resObj.logmessage, sasProgram);

					if (dataObj instanceof Tables) {
						unescapedResObj = self._utils.unescapeValues(resObj);
					} else {
						unescapedResObj = resObj;
					}

					if (resObj.status !== 'success') {
						err = new h54sError('programError', resObj.errormessage, resObj.status);
					}

					done = true;
				} catch (e) {
					if (e instanceof SyntaxError) {
						err = new h54sError('parseError', e.message);
						done = true;
					} else if (e instanceof h54sError) {
						if (e.type === 'parseError' && retryCount < 1) {
							done = false;
							self._ajax.post(self.url, params, self.useMultipartFormData).success(this.success).error(this.error);
							retryCount++;
							logs.addApplicationLog("Retrying #" + retryCount, sasProgram);
						} else {
							if (e instanceof h54sError) {
								err = e;
							} else {
								err = new h54sError('parseError', 'Unable to parse response json');
							}
							done = true;
						}
					} else {
						err = new h54sError('unknownError', e.message);
						err.stack = e.stack;
						done = true;
					}
				} finally {
					if (done) {
						callback(err, unescapedResObj);
					}
				}
			}
		}
	}).error(function (res) {
		let _csrf
		if (res.status === 449 || (res.status === 403 && (res.responseText.includes('_csrf') || res.getResponseHeader('X-Forbidden-Reason') === 'CSRF') && (_csrf = res.getResponseHeader(res.getResponseHeader('X-CSRF-HEADER'))))) {
			params['_csrf'] = _csrf;
			self.csrf = _csrf
			if (retryCount < self.maxXhrRetries) {
				self._ajax.post(self.url, params, true).success(this.success).error(this.error);
				retryCount++;
				logs.addApplicationLog("Retrying #" + retryCount, sasProgram);
			} else {
				self._utils.parseErrorResponse(res.responseText, sasProgram);
				self._utils.addFailedResponse(res.responseText, sasProgram);
				callback(new h54sError('parseError', 'Unable to parse response json'));
			}
		} else {
			logs.addApplicationLog('Request failed with status: ' + res.status, sasProgram);
			// if request has error text else callback
			callback(new h54sError('httpError', res.statusText));
		}
	});
};

/**
* Login method
*
* @param {string} user - Login username
* @param {string} pass - Login password
* @param {function} callback - Callback function called when ajax call is finished
*
* OR
*
* @param {function} callback - Callback function called when ajax call is finished
*
*/
module.exports.login = function (user, pass, callback) {
	if (!user || !pass) {
		throw new h54sError('argumentError', 'Credentials not set');
	}
	if (typeof user !== 'string' || typeof pass !== 'string') {
		throw new h54sError('argumentError', 'User and pass parameters must be strings');
	}
	//NOTE: callback optional?
	if (!callback || typeof callback !== 'function') {
		throw new h54sError('argumentError', 'You must provide callback');
	}

	if (!this.RESTauth) {
		handleSasLogon.call(this, user, pass, callback);
	} else {
		handleRestLogon.call(this, user, pass, callback);
	}
};

/**
* ManagedRequest method
*
* @param {string} callMethod - get, post,
* @param {string} _url - URL to make request to
* @param {object} options - callback function as callback paramter in options object is required
*
*/
module.exports.managedRequest = function (callMethod = 'get', _url, options = {
	callback: () => console.log('Missing callback function')
}) {
	const self = this;
	const csrf = this.csrf;
	let retryCount = 0;
	const {useMultipartFormData, sasProgram, dataObj, params, callback, headers} = options

	if (sasProgram) {
		return self.call(sasProgram, dataObj, callback, params)
	}

	let url = _url
	if (!_url.startsWith('http')) {
		url = self.hostUrl + _url
	}

	const _headers = Object.assign({}, headers, {
		'X-CSRF-TOKEN': csrf
	})
	const _options = Object.assign({}, options, {
		headers: _headers
	})

	if (this._disableCalls) {
		this._customPendingCalls.push({
			callMethod,
			_url,
			options: _options
		});
		return;
	}

	self._ajax[callMethod](url, params, useMultipartFormData, _headers).success(function (res) {
		if (self._utils.needToLogin.call(self, res)) {
			//remember the call for latter use
			self._customPendingCalls.push({
				callMethod,
				_url,
				options: _options
			});

			//there's no need to continue if previous call returned login error
			if (self._disableCalls) {
				return;
			} else {
				self._disableCalls = true;
			}

			callback(new h54sError('notLoggedinError', 'You are not logged in'));
		} else {
			let resObj, err;
			let done = false;

			try {
				const arr = res.getAllResponseHeaders().split('\r\n');
				const resHeaders = arr.reduce(function (acc, current, i) {
					let parts = current.split(': ');
					acc[parts[0]] = parts[1];
					return acc;
				}, {});
				let body = res.responseText
				try {
					body = JSON.parse(body)
				} catch (e) {
					console.log('response is not JSON string')
				} finally {
					resObj = Object.assign({}, {
						headers: resHeaders,
						status: res.status,
						statusText: res.statusText,
						body
					})
					done = true;
				}
			} catch (e) {
				err = new h54sError('unknownError', e.message);
				err.stack = e.stack;
				done = true;

			} finally {
				if (done) {
					callback(err, resObj)
				}
			}
		}
	}).error(function (res) {
		let _csrf
		if (res.status == 449 || (res.status == 403 && (res.responseText.includes('_csrf') || res.getResponseHeader('X-Forbidden-Reason') === 'CSRF') && (_csrf = res.getResponseHeader(res.getResponseHeader('X-CSRF-HEADER'))))) {
			self.csrf = _csrf
			const _headers = Object.assign({}, headers, {[res.getResponseHeader('X-CSRF-HEADER')]: _csrf})
			if (retryCount < self.maxXhrRetries) {
				self._ajax[callMethod](url, params, useMultipartFormData, _headers).success(this.success).error(this.error);
				retryCount++;
			} else {
				callback(new h54sError('parseError', 'Unable to parse response json'));
			}
		} else {
			logs.addApplicationLog('Managed request failed with status: ' + res.status, _url);
			// if request has error text else callback
			callback(new h54sError('httpError', res.responseText, res.status));
		}
	});
}

/**
 * Log on to SAS if we are asked to
 * @param {String} user - Username of user
 * @param {String} pass - Password of user
 * @param {function} callback - what to do after
 */
function handleSasLogon(user, pass, callback) {
	const self = this;

	const loginParams = {
		_service: 'default',
		//for SAS 9.4,
		username: user,
		password: pass
	};

	for (let key in this._aditionalLoginParams) {
		loginParams[key] = this._aditionalLoginParams[key];
	}

	this._loginAttempts = 0;

	this._ajax.post(this.loginUrl, loginParams)
		.success(handleSasLogonSuccess)
		.error(handleSasLogonError);

	function handleSasLogonError(res) {
		if (res.status == 449) {
			handleSasLogonSuccess(res);
			return;
		}

		logs.addApplicationLog('Login failed with status code: ' + res.status);
		callback(res.status);
	}

	function handleSasLogonSuccess(res) {
		if (++self._loginAttempts === 3) {
			return callback(-2);
		}
		if (self._utils.needToLogin.call(self, res)) {
			//we are getting form again after redirect
			//and need to login again using the new url
			//_loginChanged is set in needToLogin function
			//but if login url is not different, we are checking if there are aditional parameters
			if (self._loginChanged || (self._isNewLoginPage && !self._aditionalLoginParams)) {
				delete self._loginChanged;
				const inputs = res.responseText.match(/<input.*"hidden"[^>]*>/g);
				if (inputs) {
					inputs.forEach(function (inputStr) {
						const valueMatch = inputStr.match(/name="([^"]*)"\svalue="([^"]*)/);
						loginParams[valueMatch[1]] = valueMatch[2];
					});
				}
				self._ajax.post(self.loginUrl, loginParams).success(function () {
					//we need this get request because of the sas 9.4 security checks
					self._ajax.get(self.url).success(handleSasLogonSuccess).error(handleSasLogonError);
				}).error(handleSasLogonError);
			}
			else {
				//getting form again, but it wasn't a redirect
				logs.addApplicationLog('Wrong username or password');
				callback(-1);
			}
		}
		else {
			self._disableCalls = false;
			callback(res.status);
			while (self._pendingCalls.length > 0) {
				const pendingCall = self._pendingCalls.shift();
				const method = pendingCall.method || self.call.bind(self);
				const sasProgram = pendingCall.options.sasProgram;
				const callbackPending = pendingCall.options.callback;
				const params = pendingCall.params;
				//update debug because it may change in the meantime
				params._debug = self.debug ? 131 : 0;
				if (self.retryAfterLogin) {
					method(sasProgram, null, callbackPending, params);
				}
			}
		}
	}
}
/**
 * REST logon for 9.4 v1 ticket based auth
 * @param {String} user -
 * @param {String} pass
 * @param {function} callback
 */
function handleRestLogon(user, pass, callback) {
	const self = this;

	const loginParams = {
		username: user,
		password: pass
	};

	this._ajax.post(this.RESTauthLoginUrl, loginParams).success(function (res) {
		const location = res.getResponseHeader('Location');

		self._ajax.post(location, {
			service: self.url
		}).success(function (res) {
			if (self.url.indexOf('?') === -1) {
				self.url += '?ticket=' + res.responseText;
			} else {
				if (self.url.indexOf('ticket') !== -1) {
					self.url = self.url.replace(/ticket=[^&]+/, 'ticket=' + res.responseText);
				} else {
					self.url += '&ticket=' + res.responseText;
				}
			}

			callback(res.status);
		}).error(function (res) {
			logs.addApplicationLog('Login failed with status code: ' + res.status);
			callback(res.status);
		});
	}).error(function (res) {
		if (res.responseText === 'error.authentication.credentials.bad') {
			callback(-1);
		} else {
			logs.addApplicationLog('Login failed with status code: ' + res.status);
			callback(res.status);
		}
	});
}

/**
* Logout method
*
* @param {function} callback - Callback function called when logout is done
*
*/

module.exports.logout = function (callback) {
	const baseUrl = this.hostUrl || '';
	const url = baseUrl + this.logoutUrl;

	this._ajax.get(url).success(function (res) {
		this._disableCalls = true
		callback();
	}).error(function (res) {
		logs.addApplicationLog('Logout failed with status code: ' + res.status);
		callback(res.status);
	});
};

/*
* Enter debug mode
*
*/
module.exports.setDebugMode = function () {
	this.debug = true;
};

/*
* Exit debug mode and clear logs
*
*/
module.exports.unsetDebugMode = function () {
	this.debug = false;
};

for (let key in logs.get) {
	if (logs.get.hasOwnProperty(key)) {
		module.exports[key] = logs.get[key];
	}
}

for (let key in logs.clear) {
	if (logs.clear.hasOwnProperty(key)) {
		module.exports[key] = logs.clear[key];
	}
}

/*
* Add callback functions executed when properties are updated with remote config
*
*@callback - callback pushed to array
*
*/
module.exports.onRemoteConfigUpdate = function (callback) {
	this.remoteConfigUpdateCallbacks.push(callback);
};

module.exports._utils = require('./utils.js');

/**
 * Login call which returns a promise
 * @param {String} user - Username
 * @param {String} pass - Password
 */
module.exports.promiseLogin = function (user, pass) {
	return new Promise((resolve, reject) => {
		if (!user || !pass) {
			reject(new h54sError('argumentError', 'Credentials not set'))
		}
		if (typeof user !== 'string' || typeof pass !== 'string') {
			reject(new h54sError('argumentError', 'User and pass parameters must be strings'))
		}
		if (!this.RESTauth) {
			customHandleSasLogon.call(this, user, pass, resolve);
		} else {
			customHandleRestLogon.call(this, user, pass, resolve);
		}
	})
}

/**
 *
 * @param {String} user - Username
 * @param {String} pass - Password
 * @param {function} callback - function to call when successful
 */
function customHandleSasLogon(user, pass, callback) {
	const self = this;
	let loginParams = {
		_service: 'default',
		//for SAS 9.4,
		username: user,
		password: pass
	};

	for (let key in this._aditionalLoginParams) {
		loginParams[key] = this._aditionalLoginParams[key];
	}

	this._loginAttempts = 0;
	loginParams = this._ajax.serialize(loginParams)

	this._ajax.post(this.loginUrl, loginParams)
		.success(handleSasLogonSuccess)
		.error(handleSasLogonError);

	function handleSasLogonError(res) {
		if (res.status == 449) {
			handleSasLogonSuccess(res);
			// resolve(res.status);
		} else {
			logs.addApplicationLog('Login failed with status code: ' + res.status);
			callback(res.status);
		}
	}

	function handleSasLogonSuccess(res) {
		if (++self._loginAttempts === 3) {
			callback(-2);
		}

		if (self._utils.needToLogin.call(self, res)) {
			//we are getting form again after redirect
			//and need to login again using the new url
			//_loginChanged is set in needToLogin function
			//but if login url is not different, we are checking if there are aditional parameters
			if (self._loginChanged || (self._isNewLoginPage && !self._aditionalLoginParams)) {
				delete self._loginChanged;
				const inputs = res.responseText.match(/<input.*"hidden"[^>]*>/g);
				if (inputs) {
					inputs.forEach(function (inputStr) {
						const valueMatch = inputStr.match(/name="([^"]*)"\svalue="([^"]*)/);
						loginParams[valueMatch[1]] = valueMatch[2];
					});
				}
				self._ajax.post(self.loginUrl, loginParams).success(function () {
					handleSasLogonSuccess()
				}).error(handleSasLogonError);
			}
			else {
				//getting form again, but it wasn't a redirect
				logs.addApplicationLog('Wrong username or password');
				callback(-1);
			}
		}
		else {
			self._disableCalls = false;
			callback(res.status);
			while (self._customPendingCalls.length > 0) {
				const pendingCall = self._customPendingCalls.shift()
				const method = pendingCall.method || self.managedRequest.bind(self);
				const callMethod = pendingCall.callMethod
				const _url = pendingCall._url
				const options = pendingCall.options;
				//update debug because it may change in the meantime
				if (options.params) {
					options.params._debug = self.debug ? 131 : 0;
				}
				if (self.retryAfterLogin) {
					method(callMethod, _url, options);
				}
			}

			while (self._pendingCalls.length > 0) {
				const pendingCall = self._pendingCalls.shift();
				const method = pendingCall.method || self.call.bind(self);
				const sasProgram = pendingCall.options.sasProgram;
				const callbackPending = pendingCall.options.callback;
				const params = pendingCall.params;
				//update debug because it may change in the meantime
				params._debug = self.debug ? 131 : 0;
				if (self.retryAfterLogin) {
					method(sasProgram, null, callbackPending, params);
				}
			}
		}
	};
}

/**
 * To be used with future managed metadata calls
 * @param {String} user - Username
 * @param {String} pass - Password
 * @param {function} callback - what to call after
 * @param {String} callbackUrl - where to navigate after getting ticket
 */
function customHandleRestLogon(user, pass, callback, callbackUrl) {
	const self = this;

	const loginParams = {
		username: user,
		password: pass
	};

	this._ajax.post(this.RESTauthLoginUrl, loginParams).success(function (res) {
		const location = res.getResponseHeader('Location');

		self._ajax.post(location, {
			service: callbackUrl
		}).success(function (res) {
			if (callbackUrl.indexOf('?') === -1) {
				callbackUrl += '?ticket=' + res.responseText;
			} else {
				if (callbackUrl.indexOf('ticket') !== -1) {
					callbackUrl = callbackUrl.replace(/ticket=[^&]+/, 'ticket=' + res.responseText);
				} else {
					callbackUrl += '&ticket=' + res.responseText;
				}
			}

			callback(res.status);
		}).error(function (res) {
			logs.addApplicationLog('Login failed with status code: ' + res.status);
			callback(res.status);
		});
	}).error(function (res) {
		if (res.responseText === 'error.authentication.credentials.bad') {
			callback(-1);
		} else {
			logs.addApplicationLog('Login failed with status code: ' + res.status);
			callback(res.status);
		}
	});
}


// Utilility functions for handling files and folders on VIYA
/**
 * Returns the details of a folder from folder service
 * @param {String} folderName - Full path of folder to be found
 * @param {Object} options - Options object for managedRequest
 */
module.exports.getFolderDetails = function (folderName, options) {
	// First call to get folder's id
	let url = "/folders/folders/@item?path=" + folderName
	return this.managedRequest('get', url, options);
}

/**
 * Returns the details of a file from files service
 * @param {String} fileUri - Full path of file to be found
 * @param {Object} options - Options object for managedRequest: cacheBust forces browser to fetch new file
 */
module.exports.getFileDetails = function (fileUri, options) {
	const cacheBust = options.cacheBust
	if (cacheBust) {
		fileUri += '?cacheBust=' + new Date().getTime()
	}
	return this.managedRequest('get', fileUri, options);
}

/**
 * Returns the contents of a file from files service
 * @param {String} fileUri - Full path of file to be downloaded
 * @param {Object} options - Options object for managedRequest: cacheBust forces browser to fetch new file
 */
module.exports.getFileContent = function (fileUri, options) {
	const cacheBust = options.cacheBust
	let uri = fileUri + '/content'
	if (cacheBust) {
		uri += '?cacheBust=' + new Date().getTime()
	}
	return this.managedRequest('get', uri, options);
}


// Util functions for working with files and folders
/**
 * Returns details about folder it self and it's members with details
 * @param {String} folderName - Full path of folder to be found
 * @param {Object} options - Options object for managedRequest
 */
module.exports.getFolderContents = async function (folderName, options) {
	const self = this
	const {callback} = options

	// Second call to get folder's memebers
	const _callback = (err, data) => {
		// handle error of the first call
		if(err) {
			callback(err, data)
			return
		}
		let id = data.body.id
		let membersUrl = '/folders/folders/' + id + '/members' + '/?limit=10000000';
		return self.managedRequest('get', membersUrl, {callback})
	}

	// First call to get folder's id
	let url = "/folders/folders/@item?path=" + folderName
	const optionsObj = Object.assign({}, options, {
		callback: _callback
	})
	this.managedRequest('get', url, optionsObj)
}

/**
 * Creates a folder
 * @param {String} parentUri - The uri of the folder where the new child is being created
 * @param {String} folderName - Full path of folder to be found
 * @param {Object} options - Options object for managedRequest
 */
module.exports.createNewFolder = function (parentUri, folderName, options) {
	const headers = {
		'Accept': 'application/json, text/javascript, */*; q=0.01',
		'Content-Type': 'application/json',
	}

	const url = '/folders/folders?parentFolderUri=' + parentUri;
	const data = {
		'name': folderName,
		'type': "folder"
	}

	const optionsObj = Object.assign({}, options, {
		params: JSON.stringify(data),
		headers,
		useMultipartFormData: false
	})

	return this.managedRequest('post', url, optionsObj);
}

/**
 * Deletes a folder
 * @param {String} folderId - Full URI of folder to be deleted
 * @param {Object} options - Options object for managedRequest
 */
module.exports.deleteFolderById = function (folderId, options) {
	const url = '/folders/folders/' + folderId;
	return this.managedRequest('delete', url, options)
}

/**
 * Creates a new file
 * @param {String} fileName - Name of the file being created
 * @param {String} fileBlob - Content of the file
 * @param {String} parentFOlderUri - URI of the parent folder where the file is to be created
 * @param {Object} options - Options object for managedRequest
 */
module.exports.createNewFile = function (fileName, fileBlob, parentFolderUri, options) {
	let url = "/files/files#multipartUpload";
	let dataObj = {
		file: [fileBlob, fileName],
		parentFolderUri
	}

	const optionsObj = Object.assign({}, options, {
		params: dataObj,
		useMultipartFormData: true,
	})
	return this.managedRequest('post', url, optionsObj);
}

/**
 * Generic delete function that deletes by URI
 * @param {String} itemUri - Name of the item being deleted
 * @param {Object} options - Options object for managedRequest
 */
module.exports.deleteItem = function (itemUri, options) {
	return this.managedRequest('delete', itemUri, options)
}


/**
 * Updates contents of a file
 * @param {String} fileName - Name of the file being updated
 * @param {Object | Blob} dataObj - New content of the file (Object must contain file key)
 * Object example {
 *   file: [<blob>, <fileName>]
 * }
 * @param {String} lastModified - the last-modified header string that matches that of file being overwritten
 * @param {Object} options - Options object for managedRequest
 */
module.exports.updateFile = function (itemUri, dataObj, lastModified, options) {
	const url = itemUri + '/content'
	console.log('URL', url)
	let headers = {
		'Content-Type': 'application/vnd.sas.file',
		'If-Unmodified-Since': lastModified
	}
	const isBlob = dataObj instanceof Blob
	const useMultipartFormData = !isBlob // set useMultipartFormData to true if dataObj is not Blob

	const optionsObj = Object.assign({}, options, {
		params: dataObj,
		headers,
		useMultipartFormData
	})
	return this.managedRequest('put', url, optionsObj);
}

/**
 Updates file Metadata 
 * @param {String} fileName - Name of the file being updated
 * @param {String} lastModified - the last-modified header string that matches that of file being updated
 * @param {Object | Blob} dataObj - objects containing the fields that are being changed
 * @param {Object} options - Options object for managedRequest
 */
module.exports.updateFileMetadata = function (itemUri, dataObj, lastModified, options) {
  let headers = {
    'Content-Type':'application/vnd.sas.file+json',
		'If-Unmodified-Since': lastModified
  }
  const isBlob = dataObj instanceof Blob
  const useMultipartFormData = !isBlob // set useMultipartFormData to true if dataObj is not Blob
  
  const optionsObj = Object.assign({}, options, {
    params: dataObj,
    headers,
    useMultipartFormData
  })

  return this.managedRequest('patch', itemUri, optionsObj);
}

/**
 * Updates folder info
 * @param {String} folderUri - uri of the folder that is being changed
 * @param {String} lastModified - the last-modified header string that matches that of the folder being updated
 * @param {Object | Blob} dataObj - object thats is either the whole folder or partial data
 * @param {Object} options - Options object for managedRequest
 */
module.exports.updateFolderMetadata = function (folderUri, dataObj, lastModified, options) {

  /**
    @constant {Boolean} partialData - indicates wether dataObj containts all the data that needs to be send to the server
    or partial data which contatins only the fields that need to be updated, in which case a call needs to be made to the server for 
    the rest of the data before the update can be done
   */
  const {partialData} = options;

  const headers = {
    'Content-Type': "application/vnd.sas.content.folder+json",
    'If-Unmodified-Since': lastModified,
  }

  if (partialData) {

    const _callback = (err, res) => {
      if (res) {

        const folder = Object.assign({}, res.body, dataObj);

        let forBlob = JSON.stringify(folder);
        let data = new Blob([forBlob], {type: "octet/stream"});

        const optionsObj = Object.assign({}, options, {
          params: data,
          headers,
          useMultipartFormData : false,
        })

        return this.managedRequest('put', folderUri, optionsObj);
      }
      
      return options.callback(err);
    }
    const getOptionsObj = Object.assign({}, options, {
      headers: {'Content-Type': "application/vnd.sas.content.folder+json"},
      callback: _callback
    })

    return this.managedRequest('get', folderUri, getOptionsObj);
  }
  else {
    if ( !(dataObj instanceof Blob)) {
      let forBlob = JSON.stringify(dataObj);
      dataObj = new Blob([forBlob], {type: "octet/stream"});
    }

    const optionsObj = Object.assign({}, options, {
      params: dataObj,
      headers,
      useMultipartFormData : false,
    })
    return this.managedRequest('put', folderUri, optionsObj);
  }
}
},{"../error.js":1,"../files":2,"../logs.js":5,"../sasData.js":9,"../tables":10,"./utils.js":8}],8:[function(require,module,exports){
const logs = require('../logs.js');
const h54sError = require('../error.js');

const programNotFoundPatt = /<title>(Stored Process Error|SASStoredProcess)<\/title>[\s\S]*<h2>(Stored process not found:.*|.*not a valid stored process path.)<\/h2>/;
const badJobDefinition = "<h2>Parameter Error <br/>Unable to get job definition.</h2>";

const responseReplace = function(res) {
  return res
};

/**
* Parse response from server
*
* @param {object} responseText - response html from the server
* @param {string} sasProgram - sas program path
* @param {object} params - params sent to sas program with addTable
*
*/
module.exports.parseRes = function(responseText, sasProgram, params) {
  const matches = responseText.match(programNotFoundPatt);
  if(matches) {
    throw new h54sError('programNotFound', 'You have not been granted permission to perform this action, or the STP is missing.');
  }
  //remove new lines in json response
  //replace \\(d) with \(d) - SAS json parser is escaping it
  return JSON.parse(responseReplace(responseText));
};

/**
* Parse response from server in debug mode
*
* @param {object} responseText - response html from the server
* @param {string} sasProgram - sas program path
* @param {object} params - params sent to sas program with addTable
* @param {string} hostUrl - same as in h54s constructor
* @param {bool} isViya - same as in h54s constructor
*
*/
module.exports.parseDebugRes = function (responseText, sasProgram, params, hostUrl, isViya) {
	const self = this
	let matches = responseText.match(programNotFoundPatt);
	if (matches) {
		throw new h54sError('programNotFound', 'Sas program completed with errors');
	}

	if (isViya) {
		const matchesWrongJob = responseText.match(badJobDefinition);
		if (matchesWrongJob) {
			throw new h54sError('programNotFound', 'Sas program completed with errors. Unable to get job definition.');
		}
	}

	//find json
	let patt = isViya ? /^(.?<iframe.*src=")([^"]+)(.*iframe>)/m : /^(.?--h54s-data-start--)([\S\s]*?)(--h54s-data-end--)/m;
	matches = responseText.match(patt);

	const page = responseText.replace(patt, '');
	const htmlBodyPatt = /<body.*>([\s\S]*)<\/body>/;
	const bodyMatches = page.match(htmlBodyPatt);
	//remove html tags
	let debugText = bodyMatches[1].replace(/<[^>]*>/g, '');
	debugText = this.decodeHTMLEntities(debugText);

	logs.addDebugData(bodyMatches[1], debugText, sasProgram, params);

  if (isViya && this.parseErrorResponse(responseText, sasProgram)) {
		throw new h54sError('sasError', 'Sas program completed with errors');
	}
	if (!matches) {
		throw new h54sError('parseError', 'Unable to parse response json');
	}


	const promise = new Promise(function (resolve, reject) {
		let jsonObj
		if (isViya) {
			const xhr = new XMLHttpRequest();
			const baseUrl = hostUrl || "";
			xhr.open("GET", baseUrl + matches[2]);
			xhr.onload = function () {
				if (this.status >= 200 && this.status < 300) {
					resolve(JSON.parse(xhr.responseText.replace(/(\r\n|\r|\n)/g, '')));
				} else {
					reject(new h54sError('fetchError', xhr.statusText, this.status))
				}
			};
			xhr.onerror = function () {
				reject(new h54sError('fetchError', xhr.statusText))
			};
			xhr.send();
		} else {
			try {
				jsonObj = JSON.parse(responseReplace(matches[2]));
			} catch (e) {
				reject(new h54sError('parseError', 'Unable to parse response json'))
			}

			if (jsonObj && jsonObj.h54sAbort) {
				resolve(jsonObj);
			} else if (self.parseErrorResponse(responseText, sasProgram)) {
				reject(new h54sError('sasError', 'Sas program completed with errors'))
			} else {
				resolve(jsonObj);
			}
		}
	});

	return promise;
};

/**
* Add failed response to logs - used only if debug=false
*
* @param {string} responseText - response html from the server
* @param {string} sasProgram - sas program path
*
*/
module.exports.addFailedResponse = function(responseText, sasProgram) {
  const patt      = /<script([\s\S]*)\/form>/;
  const patt2     = /display\s?:\s?none;?\s?/;
  //remove script with form for toggling the logs and "display:none" from style
  responseText  = responseText.replace(patt, '').replace(patt2, '');
  let debugText = responseText.replace(/<[^>]*>/g, '');
  debugText = this.decodeHTMLEntities(debugText);

  logs.addFailedRequest(responseText, debugText, sasProgram);
};

/**
* Unescape all string values in returned object
*
* @param {object} obj
*
*/
module.exports.unescapeValues = function(obj) {
  for (let key in obj) {
    if (typeof obj[key] === 'string') {
      obj[key] = decodeURIComponent(obj[key]);
    } else if(typeof obj === 'object') {
      this.unescapeValues(obj[key]);
    }
  }
  return obj;
};

/**
* Parse error response from server and save errors in memory
*
* @param {string} res - server response
* @param {string} sasProgram - sas program which returned the response
*
*/
module.exports.parseErrorResponse = function(res, sasProgram) {
  //capture 'ERROR: [text].' or 'ERROR xx [text].'
  const patt    = /^ERROR(:\s|\s\d\d)(.*\.|.*\n.*\.)/gm;
  let errors  = res.replace(/(<([^>]+)>)/ig, '').match(patt);
  if(!errors) {
    return;
  }

  let errMessage;
  for(let i = 0, n = errors.length; i < n; i++) {
    errMessage  = errors[i].replace(/<[^>]*>/g, '').replace(/(\n|\s{2,})/g, ' ');
    errMessage  = this.decodeHTMLEntities(errMessage);
    errors[i]   = {
      sasProgram: sasProgram,
      message:    errMessage,
      time:       new Date()
    };
  }

  logs.addSasErrors(errors);

  return true;
};

/**
* Decode HTML entities - old utility function
*
* @param {string} res - server response
*
*/
module.exports.decodeHTMLEntities = function (html) {
  const tempElement = document.createElement('span');
  let str	= html.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z]+);/gi,
    function (str) {
      tempElement.innerHTML = str;
      str = tempElement.textContent || tempElement.innerText;
      return str;
    }
  );
  return str;
};

/**
* Convert sas time to javascript date
*
* @param {number} sasDate - sas Tate object
*
*/
module.exports.fromSasDateTime = function (sasDate) {
  const basedate = new Date("January 1, 1960 00:00:00");
  const currdate = sasDate;

  // offsets for UTC and timezones and BST
  const baseOffset = basedate.getTimezoneOffset(); // in minutes

  // convert sas datetime to a current valid javascript date
  const basedateMs  = basedate.getTime(); // in ms
  const currdateMs  = currdate * 1000; // to ms
  const sasDatetime = currdateMs + basedateMs;
  const jsDate      = new Date();
  jsDate.setTime(sasDatetime); // first time to get offset BST daylight savings etc
  const currOffset  = jsDate.getTimezoneOffset(); // adjust for offset in minutes
  const offsetVar   = (baseOffset - currOffset) * 60 * 1000; // difference in milliseconds
  const offsetTime  = sasDatetime - offsetVar; // finding BST and daylight savings
  jsDate.setTime(offsetTime); // update with offset
  return jsDate;
};

/**
 * Checks whether response object is a login redirect
 * @param {Object} responseObj xhr response to be checked for logon redirect
 */
module.exports.needToLogin = function(responseObj) {
	const isSASLogon = responseObj.responseURL && responseObj.responseURL.includes('SASLogon')
	if (isSASLogon === false) {
		return false
	}

  const patt = /<form.+action="(.*Logon[^"]*).*>/;
  const matches = patt.exec(responseObj.responseText);
  let newLoginUrl;

  if(!matches) {
    //there's no form, we are in. hooray!
    return false;
  } else {
    const actionUrl = matches[1].replace(/\?.*/, '');
    if(actionUrl.charAt(0) === '/') {
      newLoginUrl = this.hostUrl ? this.hostUrl + actionUrl : actionUrl;
      if(newLoginUrl !== this.loginUrl) {
        this._loginChanged = true;
        this.loginUrl = newLoginUrl;
      }
    } else {
      //relative path

      const lastIndOfSlash = responseObj.responseURL.lastIndexOf('/') + 1;
      //remove everything after the last slash, and everything until the first
      const relativeLoginUrl = responseObj.responseURL.substr(0, lastIndOfSlash).replace(/.*\/{2}[^\/]*/, '') + actionUrl;
      newLoginUrl = this.hostUrl ? this.hostUrl + relativeLoginUrl : relativeLoginUrl;
      if(newLoginUrl !== this.loginUrl) {
        this._loginChanged = true;
        this.loginUrl = newLoginUrl;
      }
    }

    //save parameters from hidden form fields
    const parser = new DOMParser();
    const doc = parser.parseFromString(responseObj.responseText,"text/html");
    const res = doc.querySelectorAll("input[type='hidden']");
    const hiddenFormParams = {};
    if(res) {
      //it's new login page if we have these additional parameters
      this._isNewLoginPage = true;
      res.forEach(function(node) {
        hiddenFormParams[node.name] = node.value;
      });
      this._aditionalLoginParams = hiddenFormParams;
    }
    return true;
  }
};

/**
* Get full program path from metadata root and relative path
*
* @param {string} metadataRoot - Metadata root (path where all programs for the project are located)
* @param {string} sasProgramPath - Sas program path
*
*/
module.exports.getFullProgramPath = function(metadataRoot, sasProgramPath) {
  return metadataRoot ? metadataRoot.replace(/\/?$/, '/') + sasProgramPath.replace(/^\//, '') : sasProgramPath;
};

// Returns object where table rows are groupped by key
module.exports.getObjOfTable = function (table, key, value = null) {
	const obj = {}
	table.forEach(row => {
		if (!obj[row[key]]) {
			obj[row[key]] = []
			obj[row[key]].push(value ? row[value] : row)
		} else {
			obj[row[key]].push(value ? row[value] : row)
		}
	})
	return obj
}

// Returns self uri out of links array
module.exports.getSelfUri = function (links) {
	return links
		.filter(e => e.rel === 'self')
		.map(e => e.uri)
		.shift();
}

},{"../error.js":1,"../logs.js":5}],9:[function(require,module,exports){
const h54sError = require('./error.js');
const logs      = require('./logs.js');
const Tables    = require('./tables');
const Files     = require('./files');
const toSasDateTime = require('./tables/utils.js').toSasDateTime;

/**
 * Checks whether a given table name is a valid SAS macro name
 * @param {String} macroName The SAS macro name to be given to this table
 */
function validateMacro(macroName) {
  if(macroName.length > 32) {
    throw new h54sError('argumentError', 'Table name too long. Maximum is 32 characters');
  }

  const charCodeAt0 = macroName.charCodeAt(0);
  // validate it starts with A-Z, a-z, or _
  if((charCodeAt0 < 65 || charCodeAt0 > 90) && (charCodeAt0 < 97 || charCodeAt0 > 122) && macroName[0] !== '_') {
    throw new h54sError('argumentError', 'Table name starting with number or special characters');
  }

  for(let i = 0; i < macroName.length; i++) {
    const charCode = macroName.charCodeAt(i);

    if((charCode < 48 || charCode > 57) &&
      (charCode < 65 || charCode > 90) &&
      (charCode < 97 || charCode > 122) &&
      macroName[i] !== '_')
    {
      throw new h54sError('argumentError', 'Table name has unsupported characters');
    }
  }
}

/**
* h54s SAS data object constructor
* @constructor
*
* @param {array|file} data - Table or file added when object is created
* @param {String} macroName The SAS macro name to be given to this table
* @param {number} parameterThreshold - size of data objects sent to SAS (legacy)
*
*/
function SasData(data, macroName, specs) {
  if(data instanceof Array) {
    this._files = {};
    this.addTable(data, macroName, specs);
  } else if(data instanceof File || data instanceof Blob) {
    Files.call(this, data, macroName);
  } else {
    throw new h54sError('argumentError', 'Data argument wrong type or missing');
  }
}

/**
* Add table to tables object
* @param {array} table - Array of table objects
* @param {String} macroName The SAS macro name to be given to this table
*
*/
SasData.prototype.addTable = function(table, macroName, specs) {
  const isSpecsProvided = !!specs;
  if(table && macroName) {
    if(!(table instanceof Array)) {
      throw new h54sError('argumentError', 'First argument must be array');
    }
    if(typeof macroName !== 'string') {
      throw new h54sError('argumentError', 'Second argument must be string');
    }

    validateMacro(macroName);
  } else {
    throw new h54sError('argumentError', 'Missing arguments');
  }

  if (typeof table !== 'object' || !(table instanceof Array)) {
    throw new h54sError('argumentError', 'Table argument is not an array');
  }

  let key;
  if(specs) {
    if(specs.constructor !== Object) {
      throw new h54sError('argumentError', 'Specs data type wrong. Object expected.');
    }
    for(key in table[0]) {
      if(!specs[key]) {
        throw new h54sError('argumentError', 'Missing columns in specs data.');
      }
    }
    for(key in specs) {
      if(specs[key].constructor !== Object) {
        throw new h54sError('argumentError', 'Wrong column descriptor in specs data.');
      }
      if(!specs[key].colType || !specs[key].colLength) {
        throw new h54sError('argumentError', 'Missing columns in specs descriptor.');
      }
    }
  }

  let i, j, //counters used latter in code
      row, val, type,
      specKeys = [];
	const specialChars = ['"', '\\', '/', '\n', '\t', '\f', '\r', '\b'];

  if(!specs) {
    specs = {};

    for (i = 0; i < table.length; i++) {
      row = table[i];

      if(typeof row !== 'object') {
        throw new h54sError('argumentError', 'Table item is not an object');
      }

      for(key in row) {
        if(row.hasOwnProperty(key)) {
          val  = row[key];
          type = typeof val;

          if(specs[key] === undefined) {
            specKeys.push(key);
            specs[key] = {};

            if (type === 'number') {
              if(val < Number.MIN_SAFE_INTEGER || val > Number.MAX_SAFE_INTEGER) {
                logs.addApplicationLog('Object[' + i + '].' + key + ' - This value exceeds expected numeric precision.');
              }
              specs[key].colType   = 'num';
              specs[key].colLength = 8;
            } else if (type === 'string' && !(val instanceof Date)) { // straightforward string
              specs[key].colType    = 'string';
              specs[key].colLength  = val.length;
            } else if(val instanceof Date) {
              specs[key].colType   = 'date';
              specs[key].colLength = 8;
            } else if (type === 'object') {
              specs[key].colType   = 'json';
              specs[key].colLength = JSON.stringify(val).length;
            }
          }
        }
      }
    }
  } else {
    specKeys = Object.keys(specs);
  }

  let sasCsv = '';

  // we need two loops - the first one is creating specs and validating
  for (i = 0; i < table.length; i++) {
    row = table[i];
    for(j = 0; j < specKeys.length; j++) {
      key = specKeys[j];
      if(row.hasOwnProperty(key)) {
        val  = row[key];
        type = typeof val;

        if(type === 'number' && isNaN(val)) {
          throw new h54sError('typeError', 'NaN value in one of the values (columns) is not allowed');
        }
        if(val === -Infinity || val === Infinity) {
          throw new h54sError('typeError', val.toString() + ' value in one of the values (columns) is not allowed');
        }
        if(val === true || val === false) {
          throw new h54sError('typeError', 'Boolean value in one of the values (columns) is not allowed');
        }
        if(type === 'string' && val.indexOf('\r\n') !== -1) {
          throw new h54sError('typeError', 'New line character is not supported');
        }

        // convert null to '.' for numbers and to '' for strings
        if(val === null) {
          if(specs[key].colType === 'string') {
            val = '';
            type = 'string';
          } else if(specs[key].colType === 'num') {
            val = '.';
            type = 'number';
          } else {
            throw new h54sError('typeError', 'Cannot convert null value');
          }
        }


        if ((type === 'number' && specs[key].colType !== 'num' && val !== '.') ||
          ((type === 'string' && !(val instanceof Date) && specs[key].colType !== 'string') &&
          (type === 'string' && specs[key].colType == 'num' && val !== '.')) ||
          (val instanceof Date && specs[key].colType !== 'date') ||
          ((type === 'object' && val.constructor !== Date) && specs[key].colType !== 'json'))
        {
          throw new h54sError('typeError', 'There is a specs type mismatch in the array between values (columns) of the same name.' +
            ' type/colType/val = ' + type +'/' + specs[key].colType + '/' + val );
        } else if(!isSpecsProvided && type === 'string' && specs[key].colLength < val.length) {
          specs[key].colLength = val.length;
        } else if((type === 'string' && specs[key].colLength < val.length) || (type !== 'string' && specs[key].colLength !== 8)) {
          throw new h54sError('typeError', 'There is a specs length mismatch in the array between values (columns) of the same name.' +
            ' type/colType/val = ' + type +'/' + specs[key].colType + '/' + val );
        }

        if (val instanceof Date) {
          val = toSasDateTime(val);
        }

        switch(specs[key].colType) {
          case 'num':
          case 'date':
            sasCsv += val;
            break;
          case 'string':
            sasCsv += '"' + val.replace(/"/g, '""') + '"';
            let colLength = val.length;
            for(let k = 0; k < val.length; k++) {
              if(specialChars.indexOf(val[k]) !== -1) {
                colLength++;
              } else {
                let code = val.charCodeAt(k);
                if(code > 0xffff) {
                  colLength += 3;
                } else if(code > 0x7ff) {
                  colLength += 2;
                } else if(code > 0x7f) {
                  colLength += 1;
                }
              }
            }
            // use maximum value between max previous, current value and 1 (first two can be 0 wich is not supported)
            specs[key].colLength = Math.max(specs[key].colLength, colLength, 1);
            break;
          case 'object':
            sasCsv += '"' + JSON.stringify(val).replace(/"/g, '""') + '"';
            break;
        }
      }
      // do not insert if it's the last column
      if(j < specKeys.length - 1) {
        sasCsv += ',';
      }
    }
    if(i < table.length - 1) {
      sasCsv += '\r\n';
    }
  }

  //convert specs to csv with pipes
  const specString = specKeys.map(function(key) {
    return key + ',' + specs[key].colType + ',' + specs[key].colLength;
  }).join('|');

  this._files[macroName] = [
    specString,
    new Blob([sasCsv], {type: 'text/csv;charset=UTF-8'})
  ];
};

/**
 * Add file as a verbatim blob file uplaod
 * @param {Blob} file - the blob that will be uploaded as file
 * @param {String} macroName - the SAS webin name given to this file
 */
SasData.prototype.addFile  = function(file, macroName) {
  Files.prototype.add.call(this, file, macroName);
};

module.exports = SasData;

},{"./error.js":1,"./files":2,"./logs.js":5,"./tables":10,"./tables/utils.js":11}],10:[function(require,module,exports){
const h54sError = require('../error.js');

/*
* h54s tables object constructor
* @constructor
*
*@param {array} table - Table added when object is created
*@param {string} macroName - macro name
*@param {number} parameterThreshold - size of data objects sent to SAS
*
*/
function Tables(table, macroName, parameterThreshold) {
  this._tables = {};
  this._parameterThreshold = parameterThreshold || 30000;

  Tables.prototype.add.call(this, table, macroName);
}

/*
* Add table to tables object
* @param {array} table - Array of table objects
* @param {string} macroName - Sas macro name
*
*/
Tables.prototype.add = function(table, macroName) {
  if(table && macroName) {
    if(!(table instanceof Array)) {
      throw new h54sError('argumentError', 'First argument must be array');
    }
    if(typeof macroName !== 'string') {
      throw new h54sError('argumentError', 'Second argument must be string');
    }
    if(!isNaN(macroName[macroName.length - 1])) {
      throw new h54sError('argumentError', 'Macro name cannot have number at the end');
    }
  } else {
    throw new h54sError('argumentError', 'Missing arguments');
  }

  const result = this._utils.convertTableObject(table, this._parameterThreshold);

  const tableArray = [];
  tableArray.push(JSON.stringify(result.spec));
  for (let numberOfTables = 0; numberOfTables < result.data.length; numberOfTables++) {
    const outString = JSON.stringify(result.data[numberOfTables]);
    tableArray.push(outString);
  }
  this._tables[macroName] = tableArray;
};

Tables.prototype._utils = require('./utils.js');

module.exports = Tables;

},{"../error.js":1,"./utils.js":11}],11:[function(require,module,exports){
const h54sError = require('../error.js');
const logs = require('../logs.js');

/*
* Convert table object to Sas readable object
*
* @param {object} inObject - Object to convert
*
*/
module.exports.convertTableObject = function(inObject, chunkThreshold) {
  const self            = this;

  if(chunkThreshold > 30000) {
    console.warn('You should not set threshold larger than 30kb because of the SAS limitations');
  }

  // first check that the object is an array
  if (typeof (inObject) !== 'object') {
    throw new h54sError('argumentError', 'The parameter passed to checkAndGetTypeObject is not an object');
  }

  const arrayLength = inObject.length;
  if (typeof (arrayLength) !== 'number') {
    throw new h54sError('argumentError', 'The parameter passed to checkAndGetTypeObject does not have a valid length and is most likely not an array');
  }

  const existingCols = {}; // this is just to make lookup easier rather than traversing array each time. Will transform after

  // function checkAndSetArray - this will check an inObject current key against the existing typeArray and either return -1 if there
  // is a type mismatch or add an element and update/increment the length if needed

  function checkAndIncrement(colSpec) {
    if (typeof (existingCols[colSpec.colName]) === 'undefined') {
      existingCols[colSpec.colName]           = {};
      existingCols[colSpec.colName].colName   = colSpec.colName;
      existingCols[colSpec.colName].colType   = colSpec.colType;
      existingCols[colSpec.colName].colLength = colSpec.colLength > 0 ? colSpec.colLength : 1;
      return 0; // all ok
    }
    // check type match
    if (existingCols[colSpec.colName].colType !== colSpec.colType) {
      return -1; // there is a fudge in the typing
    }
    if (existingCols[colSpec.colName].colLength < colSpec.colLength) {
      existingCols[colSpec.colName].colLength = colSpec.colLength > 0 ? colSpec.colLength : 1; // increment the max length of this column
      return 0;
    }
  }
  let chunkArrayCount         = 0; // this is for keeping tabs on how long the current array string would be
  const targetArray           = []; // this is the array of target arrays
  let currentTarget           = 0;
  targetArray[currentTarget]  = [];
  let j                       = 0;
  for (let i = 0; i < inObject.length; i++) {
    targetArray[currentTarget][j] = {};
    let chunkRowCount             = 0;

    for (let key in inObject[i]) {
      const thisSpec  = {};
      const thisValue = inObject[i][key];

      //skip undefined values
      if(thisValue === undefined || thisValue === null) {
        continue;
      }

      //throw an error if there's NaN value
      if(typeof thisValue === 'number' && isNaN(thisValue)) {
        throw new h54sError('typeError', 'NaN value in one of the values (columns) is not allowed');
      }

      if(thisValue === -Infinity || thisValue === Infinity) {
        throw new h54sError('typeError', thisValue.toString() + ' value in one of the values (columns) is not allowed');
      }

      if(thisValue === true || thisValue === false) {
        throw new h54sError('typeError', 'Boolean value in one of the values (columns) is not allowed');
      }

      // get type... if it is an object then convert it to json and store as a string
      const thisType  = typeof (thisValue);

      if (thisType === 'number') { // straightforward number
        if(thisValue < Number.MIN_SAFE_INTEGER || thisValue > Number.MAX_SAFE_INTEGER) {
          logs.addApplicationLog('Object[' + i + '].' + key + ' - This value exceeds expected numeric precision.');
        }
        thisSpec.colName                    = key;
        thisSpec.colType                    = 'num';
        thisSpec.colLength                  = 8;
        thisSpec.encodedLength              = thisValue.toString().length;
        targetArray[currentTarget][j][key]  = thisValue;
      } else if (thisType === 'string') {
        thisSpec.colName    = key;
        thisSpec.colType    = 'string';
        thisSpec.colLength  = thisValue.length;

        if (thisValue === "") {
          targetArray[currentTarget][j][key] = " ";
        } else {
          targetArray[currentTarget][j][key] = encodeURIComponent(thisValue).replace(/'/g, '%27');
        }
        thisSpec.encodedLength = targetArray[currentTarget][j][key].length;
      } else if(thisValue instanceof Date) {
      	console.log("ERROR VALUE ", thisValue)
      	console.log("TYPEOF VALUE ", typeof thisValue)
        throw new h54sError('typeError', 'Date type not supported. Please use h54s.toSasDateTime function to convert it');
      } else if (thisType == 'object') {
        thisSpec.colName                    = key;
        thisSpec.colType                    = 'json';
        thisSpec.colLength                  = JSON.stringify(thisValue).length;
        targetArray[currentTarget][j][key]  = encodeURIComponent(JSON.stringify(thisValue)).replace(/'/g, '%27');
        thisSpec.encodedLength              = targetArray[currentTarget][j][key].length;
      }

      chunkRowCount = chunkRowCount + 6 + key.length + thisSpec.encodedLength;

      if (checkAndIncrement(thisSpec) == -1) {
        throw new h54sError('typeError', 'There is a type mismatch in the array between values (columns) of the same name.');
      }
    }

    //remove last added row if it's empty
    if(Object.keys(targetArray[currentTarget][j]).length === 0) {
      targetArray[currentTarget].splice(j, 1);
      continue;
    }

    if (chunkRowCount > chunkThreshold) {
      throw new h54sError('argumentError', 'Row ' + j + ' exceeds size limit of 32kb');
    } else if(chunkArrayCount + chunkRowCount > chunkThreshold) {
      //create new array if this one is full and move the last item to the new array
      const lastRow = targetArray[currentTarget].pop(); // get rid of that last row
      currentTarget++; // move onto the next array
      targetArray[currentTarget]  = [lastRow]; // make it an array
      j                           = 0; // initialise new row counter for new array - it will be incremented at the end of the function
      chunkArrayCount             = chunkRowCount; // this is the new chunk max size
    } else {
      chunkArrayCount = chunkArrayCount + chunkRowCount;
    }
    j++;
  }

  // reformat existingCols into an array so sas can parse it;
  const specArray = [];
  for (let k in existingCols) {
    specArray.push(existingCols[k]);
  }
  return {
    spec:       specArray,
    data:       targetArray,
    jsonLength: chunkArrayCount
  }; // the spec will be the macro[0], with the data split into arrays of macro[1-n]
  // means in terms of dojo xhr object at least they need to go into the same array
};

/*
* Convert javascript date to sas time
*
* @param {object} jsDate - javascript Date object
*
*/
module.exports.toSasDateTime = function (jsDate) {
  const basedate = new Date("January 1, 1960 00:00:00");
  const currdate = jsDate;

  // offsets for UTC and timezones and BST
  const baseOffset = basedate.getTimezoneOffset(); // in minutes
  const currOffset = currdate.getTimezoneOffset(); // in minutes

  // convert currdate to a sas datetime
  const offsetSecs    = (currOffset - baseOffset) * 60; // offsetDiff is in minutes to start with
  const baseDateSecs  = basedate.getTime() / 1000; // get rid of ms
  const currdateSecs  = currdate.getTime() / 1000; // get rid of ms
  const sasDatetime   = Math.round(currdateSecs - baseDateSecs - offsetSecs); // adjust

  return sasDatetime;
};

},{"../error.js":1,"../logs.js":5}]},{},[3])(3)
});

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/error.js","src/files/index.js","src/h54s.js","src/ie_polyfills.js","src/logs.js","src/methods/ajax.js","src/methods/index.js","src/methods/utils.js","src/sasData.js","src/tables/index.js","src/tables/utils.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACl8BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(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})()","/*\n* h54s error constructor\n* @constructor\n*\n*@param {string} type - Error type\n*@param {string} message - Error message\n*@param {string} status - Error status returned from SAS\n*\n*/\nfunction h54sError(type, message, status) {\n  if(Error.captureStackTrace) {\n    Error.captureStackTrace(this);\n  }\n  this.message = message;\n  this.type    = type;\n  this.status  = status;\n}\n\nh54sError.prototype = Object.create(Error.prototype, {\n  constructor: {\n    configurable: false,\n    enumerable: false,\n    writable: false,\n    value: h54sError\n  },\n  name: {\n    configurable: false,\n    enumerable: false,\n    writable: false,\n    value: 'h54sError'\n  }\n});\n\nmodule.exports = h54sError;\n","const h54sError = require('../error.js');\n\n/**\n* h54s SAS Files object constructor\n* @constructor\n*\n*@param {file} file - File added when object is created\n*@param {string} macroName - macro name\n*\n*/\nfunction Files(file, macroName) {\n  this._files = {};\n\n  Files.prototype.add.call(this, file, macroName);\n}\n\n/**\n* Add file to files object\n* @param {file} file - Instance of JavaScript File object\n* @param {string} macroName - Sas macro name\n*\n*/\nFiles.prototype.add = function(file, macroName) {\n  if(file && macroName) {\n    if(!(file instanceof File || file instanceof Blob)) {\n      throw new h54sError('argumentError', 'First argument must be instance of File object');\n    }\n    if(typeof macroName !== 'string') {\n      throw new h54sError('argumentError', 'Second argument must be string');\n    }\n    if(!isNaN(macroName[macroName.length - 1])) {\n      throw new h54sError('argumentError', 'Macro name cannot have number at the end');\n    }\n  } else {\n    throw new h54sError('argumentError', 'Missing arguments');\n  }\n\n  this._files[macroName] = [\n    'FILE',\n    file\n  ];\n};\n\nmodule.exports = Files;\n","const h54sError = require('./error.js');\n\nconst sasVersionMap = {\n\tv9: {\n    url: '/SASStoredProcess/do',\n    loginUrl: '/SASLogon/login',\n\t\tlogoutUrl: '/SASStoredProcess/do?_action=logoff',\n    RESTAuthLoginUrl: '/SASLogon/v1/tickets'\n\t},\n\tviya: {\n\t\turl: '/SASJobExecution/',\n    loginUrl: '/SASLogon/login.do',\n\t\tlogoutUrl: '/SASLogon/logout.do?',\n    RESTAuthLoginUrl: ''\n\t}\n}\n\n/**\n*\n* @constructor\n* @param {Object} config - Configuration object for the H54S SAS Adapter\n* @param {String} config.sasVersion - Version of SAS, either 'v9' or 'viya'\n* @param {Boolean} config.debug - Whether debug mode is enabled, sets _debug=131\n* @param {String} config.metadataRoot - Base path of all project services to be prepended to _program path\n* @param {String} config.url - URI of the job executor - SPWA or JES\n* @param {String} config.loginUrl - URI of the SASLogon web login path - overridden by form action\n* @param {String} config.logoutUrl - URI of the logout action\n* @param {String} config.RESTauth - Boolean to toggle use of REST authentication in SAS v9\n* @param {String} config.RESTauthLoginUrl - Address of SASLogon tickets endpoint for REST auth\n* @param {Boolean} config.retryAfterLogin - Whether to resume requests which were parked with login redirect after a successful re-login\n* @param {Number} config.maxXhrRetries - If a program call fails, attempt to call it again N times until it succeeds\n* @param {Number} config.ajaxTimeout - Number of milliseconds to wait for a response before closing the request\n* @param {Boolean} config.useMultipartFormData - Whether to use multipart for POST - for legacy backend support\n* @param {String} config.csrf - CSRF token for JES\n* @\n*\n*/\nconst h54s = module.exports = function(config) {\n  // Default config values, overridden by anything in the config object\n\tthis.sasVersion           = (config && config.sasVersion) || 'v9' //use v9 as default=\n  this.debug                = (config && config.debug) || false;\n  this.metadataRoot\t\t\t\t\t= (config && config.metadataRoot) || '';\n  this.url                  = sasVersionMap[this.sasVersion].url;\n  this.loginUrl             = sasVersionMap[this.sasVersion].loginUrl;\n  this.logoutUrl            = sasVersionMap[this.sasVersion].logoutUrl;\n  this.RESTauth             = false;\n  this.RESTauthLoginUrl     = sasVersionMap[this.sasVersion].RESTAuthLoginUrl;\n  this.retryAfterLogin      = true;\n  this.maxXhrRetries        = 5;\n  this.ajaxTimeout          = (config && config.ajaxTimeout) || 300000;\n  this.useMultipartFormData = (config && config.useMultipartFormData) || true;\n  this.csrf                 = ''\n  this.isViya\t\t\t\t\t\t\t\t= this.sasVersion === 'viya';\n\n  // Initialising callback stacks for when authentication is paused\n  this.remoteConfigUpdateCallbacks = [];\n  this._pendingCalls = [];\n  this._customPendingCalls = [];\n  this._disableCalls = false\n  this._ajax = require('./methods/ajax.js')();\n\n  _setConfig.call(this, config);\n\n  // If this instance was deployed with a standalone config external to the build use that\n  if(config && config.isRemoteConfig) {\n    const self = this;\n\n    this._disableCalls = true;\n\n    // 'h54sConfig.json' is for the testing with karma\n    //replaced by gulp in dev build (defined in gulpfile under proxies)\n    this._ajax.get('h54sConfig.json').success(function(res) {\n      const remoteConfig = JSON.parse(res.responseText)\n\n\t\t\t// Save local config before updating it with remote config\n\t\t\tconst localConfig = Object.assign({}, config)\n\t\t\tconst oldMetadataRoot = localConfig.metadataRoot;\n\n      for(let key in remoteConfig) {\n        if(remoteConfig.hasOwnProperty(key) && key !== 'isRemoteConfig') {\n          config[key] = remoteConfig[key];\n        }\n      }\n\n      _setConfig.call(self, config);\n\n      // Execute callbacks when overrides from remote config are applied\n      for(let i = 0, n = self.remoteConfigUpdateCallbacks.length; i < n; i++) {\n        const fn = self.remoteConfigUpdateCallbacks[i];\n        fn();\n      }\n\n      // Execute sas calls disabled while waiting for the config\n      self._disableCalls = false;\n      while(self._pendingCalls.length > 0) {\n        const pendingCall = self._pendingCalls.shift();\n\t\t\t\tconst sasProgram = pendingCall.options.sasProgram;\n\t\t\t\tconst callbackPending = pendingCall.options.callback;\n\t\t\t\tconst params = pendingCall.params;\n\t\t\t\t//update debug because it may change in the meantime\n\t\t\t\tparams._debug = self.debug ? 131 : 0;\n\n        // Update program path with metadataRoot if it's not set\n        if(self.metadataRoot && params._program.indexOf(self.metadataRoot) === -1) {\n          params._program = self.metadataRoot.replace(/\\/?$/, '/') + params._program.replace(oldMetadataRoot, '').replace(/^\\//, '');\n        }\n\n        // Update debug because it may change in the meantime\n        params._debug = self.debug ? 131 : 0;\n\n        self.call(sasProgram, null, callbackPending, params);\n      }\n\n      // Execute custom calls that we made while waitinf for the config\n       while(self._customPendingCalls.length > 0) {\n      \tconst pendingCall = self._customPendingCalls.shift()\n\t\t\t\tconst callMethod = pendingCall.callMethod\n\t\t\t\tconst _url = pendingCall._url\n\t\t\t\tconst options = pendingCall.options;\n        ///update program with metadataRoot if it's not set\n        if(self.metadataRoot && options.params && options.params._program.indexOf(self.metadataRoot) === -1) {\n          options.params._program = self.metadataRoot.replace(/\\/?$/, '/') + options.params._program.replace(oldMetadataRoot, '').replace(/^\\//, '');\n        }\n        //update debug because it also may have changed from remoteConfig\n\t\t\t\tif (options.params) {\n\t\t\t\t\toptions.params._debug = self.debug ? 131 : 0;\n\t\t\t\t}\n\t\t\t\tself.managedRequest(callMethod, _url, options);\n      }\n    }).error(function (err) {\n      throw new h54sError('ajaxError', 'Remote config file cannot be loaded. Http status code: ' + err.status);\n    });\n  }\n\n  // private function to set h54s instance properties\n  function _setConfig(config) {\n    if(!config) {\n      this._ajax.setTimeout(this.ajaxTimeout);\n      return;\n    } else if(typeof config !== 'object') {\n      throw new h54sError('argumentError', 'First parameter should be config object');\n    }\n\n    //merge config object from parameter with this\n    for(let key in config) {\n      if(config.hasOwnProperty(key)) {\n        if((key === 'url' || key === 'loginUrl') && config[key].charAt(0) !== '/') {\n          config[key] = '/' + config[key];\n        }\n        this[key] = config[key];\n      }\n    }\n\n    //if server is remote use the full server url\n    //NOTE: This requires CORS and is here for legacy support\n    if(config.hostUrl) {\n      if(config.hostUrl.charAt(config.hostUrl.length - 1) === '/') {\n        config.hostUrl = config.hostUrl.slice(0, -1);\n      }\n      this.hostUrl = config.hostUrl;\n      if (!this.url.includes(this.hostUrl)) {\n\t\t\t\tthis.url = config.hostUrl + this.url;\n\t\t\t}\n\t\t\tif (!this.loginUrl.includes(this.hostUrl)) {\n\t\t\t\tthis.loginUrl = config.hostUrl + this.loginUrl;\n\t\t\t}\n\t\t\tif (!this.RESTauthLoginUrl.includes(this.hostUrl)) {\n\t\t\t\tthis.RESTauthLoginUrl = config.hostUrl + this.RESTauthLoginUrl;\n\t\t\t}\n    }\n\n    this._ajax.setTimeout(this.ajaxTimeout);\n  }\n};\n\n// replaced by gulp with real version at build time\nh54s.version = '__version__';\n\n\nh54s.prototype = require('./methods');\n\nh54s.Tables = require('./tables');\nh54s.Files = require('./files');\nh54s.SasData = require('./sasData.js');\n\nh54s.fromSasDateTime = require('./methods/utils.js').fromSasDateTime;\nh54s.toSasDateTime = require('./tables/utils.js').toSasDateTime;\n\n//self invoked function module\nrequire('./ie_polyfills.js');\n","module.exports = function() {\n  if (!Object.create) {\n    Object.create = function(proto, props) {\n      if (typeof props !== \"undefined\") {\n        throw \"The multiple-argument version of Object.create is not provided by this browser and cannot be shimmed.\";\n      }\n      function ctor() { }\n      ctor.prototype = proto;\n      return new ctor();\n    };\n  }\n\n\n  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys\n  if (!Object.keys) {\n    Object.keys = (function () {\n      'use strict';\n      var hasOwnProperty = Object.prototype.hasOwnProperty,\n          hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),\n          dontEnums = [\n            'toString',\n            'toLocaleString',\n            'valueOf',\n            'hasOwnProperty',\n            'isPrototypeOf',\n            'propertyIsEnumerable',\n            'constructor'\n          ],\n          dontEnumsLength = dontEnums.length;\n\n      return function (obj) {\n        if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {\n          throw new TypeError('Object.keys called on non-object');\n        }\n\n        var result = [], prop, i;\n\n        for (prop in obj) {\n          if (hasOwnProperty.call(obj, prop)) {\n            result.push(prop);\n          }\n        }\n\n        if (hasDontEnumBug) {\n          for (i = 0; i < dontEnumsLength; i++) {\n            if (hasOwnProperty.call(obj, dontEnums[i])) {\n              result.push(dontEnums[i]);\n            }\n          }\n        }\n        return result;\n      };\n    }());\n  }\n\n  // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf\n  if (!Array.prototype.lastIndexOf) {\n    Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) {\n      'use strict';\n\n      if (this === void 0 || this === null) {\n        throw new TypeError();\n      }\n\n      var n, k,\n        t = Object(this),\n        len = t.length >>> 0;\n      if (len === 0) {\n        return -1;\n      }\n\n      n = len - 1;\n      if (arguments.length > 1) {\n        n = Number(arguments[1]);\n        if (n != n) {\n          n = 0;\n        }\n        else if (n !== 0 && n != (1 / 0) && n != -(1 / 0)) {\n          n = (n > 0 || -1) * Math.floor(Math.abs(n));\n        }\n      }\n\n      for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) {\n        if (k in t && t[k] === searchElement) {\n          return k;\n        }\n      }\n      return -1;\n    };\n  }\n}();\n\nif (window.NodeList && !NodeList.prototype.forEach) {\n   NodeList.prototype.forEach = Array.prototype.forEach;\n}","const logs = {\n  applicationLogs: [],\n  debugData: [],\n  sasErrors: [],\n  failedRequests: []\n};\n\nconst limits = {\n  applicationLogs: 100,\n  debugData: 20,\n  failedRequests: 20,\n  sasErrors: 100\n};\n\nmodule.exports.get = {\n  getSasErrors: function() {\n    return logs.sasErrors;\n  },\n  getApplicationLogs: function() {\n    return logs.applicationLogs;\n  },\n  getDebugData: function() {\n    return logs.debugData;\n  },\n  getFailedRequests: function() {\n    return logs.failedRequests;\n  },\n  getAllLogs: function () {\n    return {\n      sasErrors: logs.sasErrors,\n      applicationLogs: logs.applicationLogs,\n      debugData: logs.debugData,\n      failedRequests: logs.failedRequests\n    }\n  }\n};\n\nmodule.exports.clear = {\n  clearApplicationLogs: function() {\n    logs.applicationLogs.splice(0, logs.applicationLogs.length);\n  },\n  clearDebugData: function() {\n    logs.debugData.splice(0, logs.debugData.length);\n  },\n  clearSasErrors: function() {\n    logs.sasErrors.splice(0, logs.sasErrors.length);\n  },\n  clearFailedRequests: function() {\n    logs.failedRequests.splice(0, logs.failedRequests.length);\n  },\n  clearAllLogs: function() {\n    this.clearApplicationLogs();\n    this.clearDebugData();\n    this.clearSasErrors();\n    this.clearFailedRequests();\n  }\n};\n\n/**\n*  Adds application logs to an array of logs\n*\n* @param {String} message - Message to add to applicationLogs\n* @param {String} sasProgram - Header - which request did message come from\n*\n*/\nmodule.exports.addApplicationLog = function(message, sasProgram) {\n  if(message === 'blank') {\n    return;\n  }\n  const log = {\n    message:    message,\n    time:       new Date(),\n    sasProgram: sasProgram\n  };\n  logs.applicationLogs.push(log);\n\n  if(logs.applicationLogs.length > limits.applicationLogs) {\n    logs.applicationLogs.shift();\n  }\n};\n\n/**\n* Adds debug data to an array of logs\n*\n* @param {String} htmlData - Full html log from executor\n* @param {String} debugText - Debug text that came after data output\n* @param {String} sasProgram - Which program request did message come from\n* @param {String} params - Web app params that were received\n*\n*/\nmodule.exports.addDebugData = function(htmlData, debugText, sasProgram, params) {\n  logs.debugData.push({\n    debugHtml:  htmlData,\n    debugText:  debugText,\n    sasProgram: sasProgram,\n    params:     params,\n    time:       new Date()\n  });\n\n  if(logs.debugData.length > limits.debugData) {\n    logs.debugData.shift();\n  }\n};\n\n/**\n* Adds failed requests to an array of failed request logs\n*\n* @param {String} responseText - Full html output from executor\n* @param {String} debugText - Debug text that came after data output\n* @param {String} sasProgram - Which program request did message come from\n*\n*/\nmodule.exports.addFailedRequest = function(responseText, debugText, sasProgram) {\n  logs.failedRequests.push({\n    responseHtml: responseText,\n    responseText: debugText,\n    sasProgram:   sasProgram,\n    time:         new Date()\n  });\n\n  //max 20 failed requests\n  if(logs.failedRequests.length > limits.failedRequests) {\n    logs.failedRequests.shift();\n  }\n};\n\n/**\n* Adds SAS errors to an array of logs\n*\n* @param {Array} errors - Array of errors to concat to main log\n*\n*/\nmodule.exports.addSasErrors = function(errors) {\n  logs.sasErrors = logs.sasErrors.concat(errors);\n\n  while(logs.sasErrors.length > limits.sasErrors) {\n    logs.sasErrors.shift();\n  }\n};\n","module.exports = function () {\n  let timeout = 30000;\n  let timeoutHandle;\n\n  const xhr = function (type, url, data, multipartFormData, headers = {}) {\n    const methods = {\n      success: function () {\n      },\n      error: function () {\n      }\n    };\n\n    const XHR = XMLHttpRequest;\n    const request = new XHR('MSXML2.XMLHTTP.3.0');\n\n    request.open(type, url, true);\n\n    //multipart/form-data is set automatically so no need for else block\n    // Content-Type header has to be explicitly set up\n    if (!multipartFormData) {\n      if (headers['Content-Type']) {\n        request.setRequestHeader('Content-Type', headers['Content-Type'])\n      } else {\n        request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n      }\n    }\n    Object.keys(headers).forEach(key => {\n      if (key !== 'Content-Type') {\n        request.setRequestHeader(key, headers[key])\n      }\n    })\n    request.onreadystatechange = function () {\n      if (request.readyState === 4) {\n        clearTimeout(timeoutHandle);\n        if (request.status >= 200 && request.status < 300) {\n          methods.success.call(methods, request);\n        } else {\n          methods.error.call(methods, request);\n        }\n      }\n    };\n\n    if (timeout > 0) {\n      timeoutHandle = setTimeout(function () {\n        request.abort();\n      }, timeout);\n    }\n\n    request.send(data);\n\n    return {\n      success: function (callback) {\n        methods.success = callback;\n        return this;\n      },\n      error: function (callback) {\n        methods.error = callback;\n        return this;\n      }\n    };\n  };\n\n  const serialize = function (obj) {\n    const str = [];\n    for (let p in obj) {\n      if (obj.hasOwnProperty(p)) {\n        if (obj[p] instanceof Array) {\n          for (let i = 0, n = obj[p].length; i < n; i++) {\n            str.push(encodeURIComponent(p) + \"=\" + encodeURIComponent(obj[p][i]));\n          }\n        } else {\n          str.push(encodeURIComponent(p) + \"=\" + encodeURIComponent(obj[p]));\n        }\n      }\n    }\n    return str.join(\"&\");\n  };\n\n  const createMultipartFormDataPayload = function (obj) {\n    let data = new FormData();\n    for (let p in obj) {\n      if (obj.hasOwnProperty(p)) {\n        if (obj[p] instanceof Array && p !== 'file') {\n          for (let i = 0, n = obj[p].length; i < n; i++) {\n            data.append(p, obj[p][i]);\n          }\n        } else if (p === 'file') {\n          data.append(p, obj[p][0], obj[p][1]);\n        } else {\n          data.append(p, obj[p]);\n        }\n      }\n    }\n    return data;\n  };\n\n  return {\n    get: function (url, data, multipartFormData, headers) {\n      let dataStr;\n      if (typeof data === 'object') {\n        dataStr = serialize(data);\n      }\n      const urlWithParams = dataStr ? (url + '?' + dataStr) : url;\n      return xhr('GET', urlWithParams, null, multipartFormData, headers);\n    },\n\t\tpost: function(url, data, multipartFormData, headers) {\n      let payload = data;\n      if(typeof data === 'object') {\n        if(multipartFormData) {\n          payload = createMultipartFormDataPayload(data);\n        } else {\n          payload = serialize(data);\n        }\n      }\n      return xhr('POST', url, payload, multipartFormData, headers);\n    },\n    put: function(url, data, multipartFormData, headers) {\n      let payload = data;\n      if(typeof data === 'object') {\n        if(multipartFormData) {\n          payload = createMultipartFormDataPayload(data);\n        }\n      }\n      return xhr('PUT', url, payload, multipartFormData, headers);\n    },\n\t\tdelete: function(url, payload, multipartFormData, headers) {\n    \treturn xhr('DELETE', url, payload, null, headers);\n    },\n    patch: function(url, data, multipartFormData, headers) {\n      let payload = data;\n      if(typeof data === 'object') {\n        if(multipartFormData) {\n          payload = createMultipartFormDataPayload(data);\n        }\n      }\n      return xhr('PATCH', url, payload, multipartFormData, headers);\n    },\n    setTimeout: function (t) {\n      timeout = t;\n    },\n    serialize\n  };\n};\n","const h54sError = require('../error.js');\nconst logs = require('../logs.js');\nconst Tables = require('../tables');\nconst SasData = require('../sasData.js');\nconst Files = require('../files');\n\n/**\n* Call Sas program\n*\n* @param {string} sasProgram - Path of the sas program\n* @param {Object} dataObj - Instance of Tables object with data added\n* @param {function} callback - Callback function called when ajax call is finished\n* @param {Object} params - object containing additional program parameters\n*\n*/\nmodule.exports.call = function (sasProgram, dataObj, callback, params) {\n\tconst self = this;\n\tlet retryCount = 0;\n\tconst dbg = this.debug\n\tconst csrf = this.csrf;\n\n\tif (!callback || typeof callback !== 'function') {\n\t\tthrow new h54sError('argumentError', 'You must provide a callback');\n\t}\n\tif (!sasProgram) {\n\t\tthrow new h54sError('argumentError', 'You must provide Sas program file path');\n\t}\n\tif (typeof sasProgram !== 'string') {\n\t\tthrow new h54sError('argumentError', 'First parameter should be string');\n\t}\n\tif (this.useMultipartFormData === false && !(dataObj instanceof Tables)) {\n\t\tthrow new h54sError('argumentError', 'Cannot send files using application/x-www-form-urlencoded. Please use Tables or default value for useMultipartFormData');\n\t}\n\n\tif (!params) {\n\t\tparams = {\n\t\t\t_program: this._utils.getFullProgramPath(this.metadataRoot, sasProgram),\n\t\t\t_debug: this.debug ? 131 : 0,\n\t\t\t_service: 'default',\n\t\t\t_csrf: csrf\n\t\t};\n\t} else {\n\t\tparams = Object.assign({}, params, {_csrf: csrf})\n\t}\n\n\tif (dataObj) {\n\t\tlet key, dataProvider;\n\t\tif (dataObj instanceof Tables) {\n\t\t\tdataProvider = dataObj._tables;\n\t\t} else if (dataObj instanceof Files || dataObj instanceof SasData) {\n\t\t\tdataProvider = dataObj._files;\n\t\t} else {\n\t\t\tconsole.log(new h54sError('argumentError', 'Wrong type of tables object'))\n\t\t}\n\t\tfor (key in dataProvider) {\n\t\t\tif (dataProvider.hasOwnProperty(key)) {\n\t\t\t\tparams[key] = dataProvider[key];\n\t\t\t}\n\t\t}\n\t}\n\n\tif (this._disableCalls) {\n\t\tthis._pendingCalls.push({\n\t\t\tparams,\n\t\t\toptions: {\n\t\t\t\tsasProgram,\n\t\t\t\tdataObj,\n\t\t\t\tcallback\n\t\t\t}\n\t\t});\n\t\treturn;\n\t}\n\n\tthis._ajax.post(this.url, params, this.useMultipartFormData).success(async function (res) {\n\t\tif (self._utils.needToLogin.call(self, res)) {\n\t\t\t//remember the call for latter use\n\t\t\tself._pendingCalls.push({\n\t\t\t\tparams,\n\t\t\t\toptions: {\n\t\t\t\t\tsasProgram,\n\t\t\t\t\tdataObj,\n\t\t\t\t\tcallback\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t//there's no need to continue if previous call returned login error\n\t\t\tif (self._disableCalls) {\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tself._disableCalls = true;\n\t\t\t}\n\n\t\t\tcallback(new h54sError('notLoggedinError', 'You are not logged in'));\n\t\t} else {\n\t\t\tlet resObj, unescapedResObj, err;\n\t\t\tlet done = false;\n\n\t\t\tif (!dbg) {\n\t\t\t\ttry {\n\t\t\t\t\tresObj = self._utils.parseRes(res.responseText, sasProgram, params);\n\t\t\t\t\tlogs.addApplicationLog(resObj.logmessage, sasProgram);\n\n\t\t\t\t\tif (dataObj instanceof Tables) {\n\t\t\t\t\t\tunescapedResObj = self._utils.unescapeValues(resObj);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tunescapedResObj = resObj;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (resObj.status !== 'success') {\n\t\t\t\t\t\terr = new h54sError('programError', resObj.errormessage, resObj.status);\n\t\t\t\t\t}\n\n\t\t\t\t\tdone = true;\n\t\t\t\t} catch (e) {\n\t\t\t\t\tif (e instanceof SyntaxError) {\n\t\t\t\t\t\tif (retryCount < self.maxXhrRetries) {\n\t\t\t\t\t\t\tdone = false;\n\t\t\t\t\t\t\tself._ajax.post(self.url, params, self.useMultipartFormData).success(this.success).error(this.error);\n\t\t\t\t\t\t\tretryCount++;\n\t\t\t\t\t\t\tlogs.addApplicationLog(\"Retrying #\" + retryCount, sasProgram);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._utils.parseErrorResponse(res.responseText, sasProgram);\n\t\t\t\t\t\t\tself._utils.addFailedResponse(res.responseText, sasProgram);\n\t\t\t\t\t\t\terr = new h54sError('parseError', 'Unable to parse response json');\n\t\t\t\t\t\t\tdone = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (e instanceof h54sError) {\n\t\t\t\t\t\tself._utils.parseErrorResponse(res.responseText, sasProgram);\n\t\t\t\t\t\tself._utils.addFailedResponse(res.responseText, sasProgram);\n\t\t\t\t\t\terr = e;\n\t\t\t\t\t\tdone = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself._utils.parseErrorResponse(res.responseText, sasProgram);\n\t\t\t\t\t\tself._utils.addFailedResponse(res.responseText, sasProgram);\n\t\t\t\t\t\terr = new h54sError('unknownError', e.message);\n\t\t\t\t\t\terr.stack = e.stack;\n\t\t\t\t\t\tdone = true;\n\t\t\t\t\t}\n\t\t\t\t} finally {\n\t\t\t\t\tif (done) {\n\t\t\t\t\t\tcallback(err, unescapedResObj);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\ttry {\n\t\t\t\t\tresObj = await self._utils.parseDebugRes(res.responseText, sasProgram, params, self.hostUrl, self.isViya);\n\t\t\t\t\tlogs.addApplicationLog(resObj.logmessage, sasProgram);\n\n\t\t\t\t\tif (dataObj instanceof Tables) {\n\t\t\t\t\t\tunescapedResObj = self._utils.unescapeValues(resObj);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tunescapedResObj = resObj;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (resObj.status !== 'success') {\n\t\t\t\t\t\terr = new h54sError('programError', resObj.errormessage, resObj.status);\n\t\t\t\t\t}\n\n\t\t\t\t\tdone = true;\n\t\t\t\t} catch (e) {\n\t\t\t\t\tif (e instanceof SyntaxError) {\n\t\t\t\t\t\terr = new h54sError('parseError', e.message);\n\t\t\t\t\t\tdone = true;\n\t\t\t\t\t} else if (e instanceof h54sError) {\n\t\t\t\t\t\tif (e.type === 'parseError' && retryCount < 1) {\n\t\t\t\t\t\t\tdone = false;\n\t\t\t\t\t\t\tself._ajax.post(self.url, params, self.useMultipartFormData).success(this.success).error(this.error);\n\t\t\t\t\t\t\tretryCount++;\n\t\t\t\t\t\t\tlogs.addApplicationLog(\"Retrying #\" + retryCount, sasProgram);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tif (e instanceof h54sError) {\n\t\t\t\t\t\t\t\terr = e;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\terr = new h54sError('parseError', 'Unable to parse response json');\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tdone = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\terr = new h54sError('unknownError', e.message);\n\t\t\t\t\t\terr.stack = e.stack;\n\t\t\t\t\t\tdone = true;\n\t\t\t\t\t}\n\t\t\t\t} finally {\n\t\t\t\t\tif (done) {\n\t\t\t\t\t\tcallback(err, unescapedResObj);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}).error(function (res) {\n\t\tlet _csrf\n\t\tif (res.status === 449 || (res.status === 403 && (res.responseText.includes('_csrf') || res.getResponseHeader('X-Forbidden-Reason') === 'CSRF') && (_csrf = res.getResponseHeader(res.getResponseHeader('X-CSRF-HEADER'))))) {\n\t\t\tparams['_csrf'] = _csrf;\n\t\t\tself.csrf = _csrf\n\t\t\tif (retryCount < self.maxXhrRetries) {\n\t\t\t\tself._ajax.post(self.url, params, true).success(this.success).error(this.error);\n\t\t\t\tretryCount++;\n\t\t\t\tlogs.addApplicationLog(\"Retrying #\" + retryCount, sasProgram);\n\t\t\t} else {\n\t\t\t\tself._utils.parseErrorResponse(res.responseText, sasProgram);\n\t\t\t\tself._utils.addFailedResponse(res.responseText, sasProgram);\n\t\t\t\tcallback(new h54sError('parseError', 'Unable to parse response json'));\n\t\t\t}\n\t\t} else {\n\t\t\tlogs.addApplicationLog('Request failed with status: ' + res.status, sasProgram);\n\t\t\t// if request has error text else callback\n\t\t\tcallback(new h54sError('httpError', res.statusText));\n\t\t}\n\t});\n};\n\n/**\n* Login method\n*\n* @param {string} user - Login username\n* @param {string} pass - Login password\n* @param {function} callback - Callback function called when ajax call is finished\n*\n* OR\n*\n* @param {function} callback - Callback function called when ajax call is finished\n*\n*/\nmodule.exports.login = function (user, pass, callback) {\n\tif (!user || !pass) {\n\t\tthrow new h54sError('argumentError', 'Credentials not set');\n\t}\n\tif (typeof user !== 'string' || typeof pass !== 'string') {\n\t\tthrow new h54sError('argumentError', 'User and pass parameters must be strings');\n\t}\n\t//NOTE: callback optional?\n\tif (!callback || typeof callback !== 'function') {\n\t\tthrow new h54sError('argumentError', 'You must provide callback');\n\t}\n\n\tif (!this.RESTauth) {\n\t\thandleSasLogon.call(this, user, pass, callback);\n\t} else {\n\t\thandleRestLogon.call(this, user, pass, callback);\n\t}\n};\n\n/**\n* ManagedRequest method\n*\n* @param {string} callMethod - get, post,\n* @param {string} _url - URL to make request to\n* @param {object} options - callback function as callback paramter in options object is required\n*\n*/\nmodule.exports.managedRequest = function (callMethod = 'get', _url, options = {\n\tcallback: () => console.log('Missing callback function')\n}) {\n\tconst self = this;\n\tconst csrf = this.csrf;\n\tlet retryCount = 0;\n\tconst {useMultipartFormData, sasProgram, dataObj, params, callback, headers} = options\n\n\tif (sasProgram) {\n\t\treturn self.call(sasProgram, dataObj, callback, params)\n\t}\n\n\tlet url = _url\n\tif (!_url.startsWith('http')) {\n\t\turl = self.hostUrl + _url\n\t}\n\n\tconst _headers = Object.assign({}, headers, {\n\t\t'X-CSRF-TOKEN': csrf\n\t})\n\tconst _options = Object.assign({}, options, {\n\t\theaders: _headers\n\t})\n\n\tif (this._disableCalls) {\n\t\tthis._customPendingCalls.push({\n\t\t\tcallMethod,\n\t\t\t_url,\n\t\t\toptions: _options\n\t\t});\n\t\treturn;\n\t}\n\n\tself._ajax[callMethod](url, params, useMultipartFormData, _headers).success(function (res) {\n\t\tif (self._utils.needToLogin.call(self, res)) {\n\t\t\t//remember the call for latter use\n\t\t\tself._customPendingCalls.push({\n\t\t\t\tcallMethod,\n\t\t\t\t_url,\n\t\t\t\toptions: _options\n\t\t\t});\n\n\t\t\t//there's no need to continue if previous call returned login error\n\t\t\tif (self._disableCalls) {\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tself._disableCalls = true;\n\t\t\t}\n\n\t\t\tcallback(new h54sError('notLoggedinError', 'You are not logged in'));\n\t\t} else {\n\t\t\tlet resObj, err;\n\t\t\tlet done = false;\n\n\t\t\ttry {\n\t\t\t\tconst arr = res.getAllResponseHeaders().split('\\r\\n');\n\t\t\t\tconst resHeaders = arr.reduce(function (acc, current, i) {\n\t\t\t\t\tlet parts = current.split(': ');\n\t\t\t\t\tacc[parts[0]] = parts[1];\n\t\t\t\t\treturn acc;\n\t\t\t\t}, {});\n\t\t\t\tlet body = res.responseText\n\t\t\t\ttry {\n\t\t\t\t\tbody = JSON.parse(body)\n\t\t\t\t} catch (e) {\n\t\t\t\t\tconsole.log('response is not JSON string')\n\t\t\t\t} finally {\n\t\t\t\t\tresObj = Object.assign({}, {\n\t\t\t\t\t\theaders: resHeaders,\n\t\t\t\t\t\tstatus: res.status,\n\t\t\t\t\t\tstatusText: res.statusText,\n\t\t\t\t\t\tbody\n\t\t\t\t\t})\n\t\t\t\t\tdone = true;\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\terr = new h54sError('unknownError', e.message);\n\t\t\t\terr.stack = e.stack;\n\t\t\t\tdone = true;\n\n\t\t\t} finally {\n\t\t\t\tif (done) {\n\t\t\t\t\tcallback(err, resObj)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}).error(function (res) {\n\t\tlet _csrf\n\t\tif (res.status == 449 || (res.status == 403 && (res.responseText.includes('_csrf') || res.getResponseHeader('X-Forbidden-Reason') === 'CSRF') && (_csrf = res.getResponseHeader(res.getResponseHeader('X-CSRF-HEADER'))))) {\n\t\t\tself.csrf = _csrf\n\t\t\tconst _headers = Object.assign({}, headers, {[res.getResponseHeader('X-CSRF-HEADER')]: _csrf})\n\t\t\tif (retryCount < self.maxXhrRetries) {\n\t\t\t\tself._ajax[callMethod](url, params, useMultipartFormData, _headers).success(this.success).error(this.error);\n\t\t\t\tretryCount++;\n\t\t\t} else {\n\t\t\t\tcallback(new h54sError('parseError', 'Unable to parse response json'));\n\t\t\t}\n\t\t} else {\n\t\t\tlogs.addApplicationLog('Managed request failed with status: ' + res.status, _url);\n\t\t\t// if request has error text else callback\n\t\t\tcallback(new h54sError('httpError', res.responseText, res.status));\n\t\t}\n\t});\n}\n\n/**\n * Log on to SAS if we are asked to\n * @param {String} user - Username of user\n * @param {String} pass - Password of user\n * @param {function} callback - what to do after\n */\nfunction handleSasLogon(user, pass, callback) {\n\tconst self = this;\n\n\tconst loginParams = {\n\t\t_service: 'default',\n\t\t//for SAS 9.4,\n\t\tusername: user,\n\t\tpassword: pass\n\t};\n\n\tfor (let key in this._aditionalLoginParams) {\n\t\tloginParams[key] = this._aditionalLoginParams[key];\n\t}\n\n\tthis._loginAttempts = 0;\n\n\tthis._ajax.post(this.loginUrl, loginParams)\n\t\t.success(handleSasLogonSuccess)\n\t\t.error(handleSasLogonError);\n\n\tfunction handleSasLogonError(res) {\n\t\tif (res.status == 449) {\n\t\t\thandleSasLogonSuccess(res);\n\t\t\treturn;\n\t\t}\n\n\t\tlogs.addApplicationLog('Login failed with status code: ' + res.status);\n\t\tcallback(res.status);\n\t}\n\n\tfunction handleSasLogonSuccess(res) {\n\t\tif (++self._loginAttempts === 3) {\n\t\t\treturn callback(-2);\n\t\t}\n\t\tif (self._utils.needToLogin.call(self, res)) {\n\t\t\t//we are getting form again after redirect\n\t\t\t//and need to login again using the new url\n\t\t\t//_loginChanged is set in needToLogin function\n\t\t\t//but if login url is not different, we are checking if there are aditional parameters\n\t\t\tif (self._loginChanged || (self._isNewLoginPage && !self._aditionalLoginParams)) {\n\t\t\t\tdelete self._loginChanged;\n\t\t\t\tconst inputs = res.responseText.match(/<input.*\"hidden\"[^>]*>/g);\n\t\t\t\tif (inputs) {\n\t\t\t\t\tinputs.forEach(function (inputStr) {\n\t\t\t\t\t\tconst valueMatch = inputStr.match(/name=\"([^\"]*)\"\\svalue=\"([^\"]*)/);\n\t\t\t\t\t\tloginParams[valueMatch[1]] = valueMatch[2];\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tself._ajax.post(self.loginUrl, loginParams).success(function () {\n\t\t\t\t\t//we need this get request because of the sas 9.4 security checks\n\t\t\t\t\tself._ajax.get(self.url).success(handleSasLogonSuccess).error(handleSasLogonError);\n\t\t\t\t}).error(handleSasLogonError);\n\t\t\t}\n\t\t\telse {\n\t\t\t\t//getting form again, but it wasn't a redirect\n\t\t\t\tlogs.addApplicationLog('Wrong username or password');\n\t\t\t\tcallback(-1);\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tself._disableCalls = false;\n\t\t\tcallback(res.status);\n\t\t\twhile (self._pendingCalls.length > 0) {\n\t\t\t\tconst pendingCall = self._pendingCalls.shift();\n\t\t\t\tconst method = pendingCall.method || self.call.bind(self);\n\t\t\t\tconst sasProgram = pendingCall.options.sasProgram;\n\t\t\t\tconst callbackPending = pendingCall.options.callback;\n\t\t\t\tconst params = pendingCall.params;\n\t\t\t\t//update debug because it may change in the meantime\n\t\t\t\tparams._debug = self.debug ? 131 : 0;\n\t\t\t\tif (self.retryAfterLogin) {\n\t\t\t\t\tmethod(sasProgram, null, callbackPending, params);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n/**\n * REST logon for 9.4 v1 ticket based auth\n * @param {String} user -\n * @param {String} pass\n * @param {function} callback\n */\nfunction handleRestLogon(user, pass, callback) {\n\tconst self = this;\n\n\tconst loginParams = {\n\t\tusername: user,\n\t\tpassword: pass\n\t};\n\n\tthis._ajax.post(this.RESTauthLoginUrl, loginParams).success(function (res) {\n\t\tconst location = res.getResponseHeader('Location');\n\n\t\tself._ajax.post(location, {\n\t\t\tservice: self.url\n\t\t}).success(function (res) {\n\t\t\tif (self.url.indexOf('?') === -1) {\n\t\t\t\tself.url += '?ticket=' + res.responseText;\n\t\t\t} else {\n\t\t\t\tif (self.url.indexOf('ticket') !== -1) {\n\t\t\t\t\tself.url = self.url.replace(/ticket=[^&]+/, 'ticket=' + res.responseText);\n\t\t\t\t} else {\n\t\t\t\t\tself.url += '&ticket=' + res.responseText;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tcallback(res.status);\n\t\t}).error(function (res) {\n\t\t\tlogs.addApplicationLog('Login failed with status code: ' + res.status);\n\t\t\tcallback(res.status);\n\t\t});\n\t}).error(function (res) {\n\t\tif (res.responseText === 'error.authentication.credentials.bad') {\n\t\t\tcallback(-1);\n\t\t} else {\n\t\t\tlogs.addApplicationLog('Login failed with status code: ' + res.status);\n\t\t\tcallback(res.status);\n\t\t}\n\t});\n}\n\n/**\n* Logout method\n*\n* @param {function} callback - Callback function called when logout is done\n*\n*/\n\nmodule.exports.logout = function (callback) {\n\tconst baseUrl = this.hostUrl || '';\n\tconst url = baseUrl + this.logoutUrl;\n\n\tthis._ajax.get(url).success(function (res) {\n\t\tthis._disableCalls = true\n\t\tcallback();\n\t}).error(function (res) {\n\t\tlogs.addApplicationLog('Logout failed with status code: ' + res.status);\n\t\tcallback(res.status);\n\t});\n};\n\n/*\n* Enter debug mode\n*\n*/\nmodule.exports.setDebugMode = function () {\n\tthis.debug = true;\n};\n\n/*\n* Exit debug mode and clear logs\n*\n*/\nmodule.exports.unsetDebugMode = function () {\n\tthis.debug = false;\n};\n\nfor (let key in logs.get) {\n\tif (logs.get.hasOwnProperty(key)) {\n\t\tmodule.exports[key] = logs.get[key];\n\t}\n}\n\nfor (let key in logs.clear) {\n\tif (logs.clear.hasOwnProperty(key)) {\n\t\tmodule.exports[key] = logs.clear[key];\n\t}\n}\n\n/*\n* Add callback functions executed when properties are updated with remote config\n*\n*@callback - callback pushed to array\n*\n*/\nmodule.exports.onRemoteConfigUpdate = function (callback) {\n\tthis.remoteConfigUpdateCallbacks.push(callback);\n};\n\nmodule.exports._utils = require('./utils.js');\n\n/**\n * Login call which returns a promise\n * @param {String} user - Username\n * @param {String} pass - Password\n */\nmodule.exports.promiseLogin = function (user, pass) {\n\treturn new Promise((resolve, reject) => {\n\t\tif (!user || !pass) {\n\t\t\treject(new h54sError('argumentError', 'Credentials not set'))\n\t\t}\n\t\tif (typeof user !== 'string' || typeof pass !== 'string') {\n\t\t\treject(new h54sError('argumentError', 'User and pass parameters must be strings'))\n\t\t}\n\t\tif (!this.RESTauth) {\n\t\t\tcustomHandleSasLogon.call(this, user, pass, resolve);\n\t\t} else {\n\t\t\tcustomHandleRestLogon.call(this, user, pass, resolve);\n\t\t}\n\t})\n}\n\n/**\n *\n * @param {String} user - Username\n * @param {String} pass - Password\n * @param {function} callback - function to call when successful\n */\nfunction customHandleSasLogon(user, pass, callback) {\n\tconst self = this;\n\tlet loginParams = {\n\t\t_service: 'default',\n\t\t//for SAS 9.4,\n\t\tusername: user,\n\t\tpassword: pass\n\t};\n\n\tfor (let key in this._aditionalLoginParams) {\n\t\tloginParams[key] = this._aditionalLoginParams[key];\n\t}\n\n\tthis._loginAttempts = 0;\n\tloginParams = this._ajax.serialize(loginParams)\n\n\tthis._ajax.post(this.loginUrl, loginParams)\n\t\t.success(handleSasLogonSuccess)\n\t\t.error(handleSasLogonError);\n\n\tfunction handleSasLogonError(res) {\n\t\tif (res.status == 449) {\n\t\t\thandleSasLogonSuccess(res);\n\t\t\t// resolve(res.status);\n\t\t} else {\n\t\t\tlogs.addApplicationLog('Login failed with status code: ' + res.status);\n\t\t\tcallback(res.status);\n\t\t}\n\t}\n\n\tfunction handleSasLogonSuccess(res) {\n\t\tif (++self._loginAttempts === 3) {\n\t\t\tcallback(-2);\n\t\t}\n\n\t\tif (self._utils.needToLogin.call(self, res)) {\n\t\t\t//we are getting form again after redirect\n\t\t\t//and need to login again using the new url\n\t\t\t//_loginChanged is set in needToLogin function\n\t\t\t//but if login url is not different, we are checking if there are aditional parameters\n\t\t\tif (self._loginChanged || (self._isNewLoginPage && !self._aditionalLoginParams)) {\n\t\t\t\tdelete self._loginChanged;\n\t\t\t\tconst inputs = res.responseText.match(/<input.*\"hidden\"[^>]*>/g);\n\t\t\t\tif (inputs) {\n\t\t\t\t\tinputs.forEach(function (inputStr) {\n\t\t\t\t\t\tconst valueMatch = inputStr.match(/name=\"([^\"]*)\"\\svalue=\"([^\"]*)/);\n\t\t\t\t\t\tloginParams[valueMatch[1]] = valueMatch[2];\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tself._ajax.post(self.loginUrl, loginParams).success(function () {\n\t\t\t\t\thandleSasLogonSuccess()\n\t\t\t\t}).error(handleSasLogonError);\n\t\t\t}\n\t\t\telse {\n\t\t\t\t//getting form again, but it wasn't a redirect\n\t\t\t\tlogs.addApplicationLog('Wrong username or password');\n\t\t\t\tcallback(-1);\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tself._disableCalls = false;\n\t\t\tcallback(res.status);\n\t\t\twhile (self._customPendingCalls.length > 0) {\n\t\t\t\tconst pendingCall = self._customPendingCalls.shift()\n\t\t\t\tconst method = pendingCall.method || self.managedRequest.bind(self);\n\t\t\t\tconst callMethod = pendingCall.callMethod\n\t\t\t\tconst _url = pendingCall._url\n\t\t\t\tconst options = pendingCall.options;\n\t\t\t\t//update debug because it may change in the meantime\n\t\t\t\tif (options.params) {\n\t\t\t\t\toptions.params._debug = self.debug ? 131 : 0;\n\t\t\t\t}\n\t\t\t\tif (self.retryAfterLogin) {\n\t\t\t\t\tmethod(callMethod, _url, options);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\twhile (self._pendingCalls.length > 0) {\n\t\t\t\tconst pendingCall = self._pendingCalls.shift();\n\t\t\t\tconst method = pendingCall.method || self.call.bind(self);\n\t\t\t\tconst sasProgram = pendingCall.options.sasProgram;\n\t\t\t\tconst callbackPending = pendingCall.options.callback;\n\t\t\t\tconst params = pendingCall.params;\n\t\t\t\t//update debug because it may change in the meantime\n\t\t\t\tparams._debug = self.debug ? 131 : 0;\n\t\t\t\tif (self.retryAfterLogin) {\n\t\t\t\t\tmethod(sasProgram, null, callbackPending, params);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n/**\n * To be used with future managed metadata calls\n * @param {String} user - Username\n * @param {String} pass - Password\n * @param {function} callback - what to call after\n * @param {String} callbackUrl - where to navigate after getting ticket\n */\nfunction customHandleRestLogon(user, pass, callback, callbackUrl) {\n\tconst self = this;\n\n\tconst loginParams = {\n\t\tusername: user,\n\t\tpassword: pass\n\t};\n\n\tthis._ajax.post(this.RESTauthLoginUrl, loginParams).success(function (res) {\n\t\tconst location = res.getResponseHeader('Location');\n\n\t\tself._ajax.post(location, {\n\t\t\tservice: callbackUrl\n\t\t}).success(function (res) {\n\t\t\tif (callbackUrl.indexOf('?') === -1) {\n\t\t\t\tcallbackUrl += '?ticket=' + res.responseText;\n\t\t\t} else {\n\t\t\t\tif (callbackUrl.indexOf('ticket') !== -1) {\n\t\t\t\t\tcallbackUrl = callbackUrl.replace(/ticket=[^&]+/, 'ticket=' + res.responseText);\n\t\t\t\t} else {\n\t\t\t\t\tcallbackUrl += '&ticket=' + res.responseText;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tcallback(res.status);\n\t\t}).error(function (res) {\n\t\t\tlogs.addApplicationLog('Login failed with status code: ' + res.status);\n\t\t\tcallback(res.status);\n\t\t});\n\t}).error(function (res) {\n\t\tif (res.responseText === 'error.authentication.credentials.bad') {\n\t\t\tcallback(-1);\n\t\t} else {\n\t\t\tlogs.addApplicationLog('Login failed with status code: ' + res.status);\n\t\t\tcallback(res.status);\n\t\t}\n\t});\n}\n\n\n// Utilility functions for handling files and folders on VIYA\n/**\n * Returns the details of a folder from folder service\n * @param {String} folderName - Full path of folder to be found\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.getFolderDetails = function (folderName, options) {\n\t// First call to get folder's id\n\tlet url = \"/folders/folders/@item?path=\" + folderName\n\treturn this.managedRequest('get', url, options);\n}\n\n/**\n * Returns the details of a file from files service\n * @param {String} fileUri - Full path of file to be found\n * @param {Object} options - Options object for managedRequest: cacheBust forces browser to fetch new file\n */\nmodule.exports.getFileDetails = function (fileUri, options) {\n\tconst cacheBust = options.cacheBust\n\tif (cacheBust) {\n\t\tfileUri += '?cacheBust=' + new Date().getTime()\n\t}\n\treturn this.managedRequest('get', fileUri, options);\n}\n\n/**\n * Returns the contents of a file from files service\n * @param {String} fileUri - Full path of file to be downloaded\n * @param {Object} options - Options object for managedRequest: cacheBust forces browser to fetch new file\n */\nmodule.exports.getFileContent = function (fileUri, options) {\n\tconst cacheBust = options.cacheBust\n\tlet uri = fileUri + '/content'\n\tif (cacheBust) {\n\t\turi += '?cacheBust=' + new Date().getTime()\n\t}\n\treturn this.managedRequest('get', uri, options);\n}\n\n\n// Util functions for working with files and folders\n/**\n * Returns details about folder it self and it's members with details\n * @param {String} folderName - Full path of folder to be found\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.getFolderContents = async function (folderName, options) {\n\tconst self = this\n\tconst {callback} = options\n\n\t// Second call to get folder's memebers\n\tconst _callback = (err, data) => {\n\t\t// handle error of the first call\n\t\tif(err) {\n\t\t\tcallback(err, data)\n\t\t\treturn\n\t\t}\n\t\tlet id = data.body.id\n\t\tlet membersUrl = '/folders/folders/' + id + '/members' + '/?limit=10000000';\n\t\treturn self.managedRequest('get', membersUrl, {callback})\n\t}\n\n\t// First call to get folder's id\n\tlet url = \"/folders/folders/@item?path=\" + folderName\n\tconst optionsObj = Object.assign({}, options, {\n\t\tcallback: _callback\n\t})\n\tthis.managedRequest('get', url, optionsObj)\n}\n\n/**\n * Creates a folder\n * @param {String} parentUri - The uri of the folder where the new child is being created\n * @param {String} folderName - Full path of folder to be found\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.createNewFolder = function (parentUri, folderName, options) {\n\tconst headers = {\n\t\t'Accept': 'application/json, text/javascript, */*; q=0.01',\n\t\t'Content-Type': 'application/json',\n\t}\n\n\tconst url = '/folders/folders?parentFolderUri=' + parentUri;\n\tconst data = {\n\t\t'name': folderName,\n\t\t'type': \"folder\"\n\t}\n\n\tconst optionsObj = Object.assign({}, options, {\n\t\tparams: JSON.stringify(data),\n\t\theaders,\n\t\tuseMultipartFormData: false\n\t})\n\n\treturn this.managedRequest('post', url, optionsObj);\n}\n\n/**\n * Deletes a folder\n * @param {String} folderId - Full URI of folder to be deleted\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.deleteFolderById = function (folderId, options) {\n\tconst url = '/folders/folders/' + folderId;\n\treturn this.managedRequest('delete', url, options)\n}\n\n/**\n * Creates a new file\n * @param {String} fileName - Name of the file being created\n * @param {String} fileBlob - Content of the file\n * @param {String} parentFOlderUri - URI of the parent folder where the file is to be created\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.createNewFile = function (fileName, fileBlob, parentFolderUri, options) {\n\tlet url = \"/files/files#multipartUpload\";\n\tlet dataObj = {\n\t\tfile: [fileBlob, fileName],\n\t\tparentFolderUri\n\t}\n\n\tconst optionsObj = Object.assign({}, options, {\n\t\tparams: dataObj,\n\t\tuseMultipartFormData: true,\n\t})\n\treturn this.managedRequest('post', url, optionsObj);\n}\n\n/**\n * Generic delete function that deletes by URI\n * @param {String} itemUri - Name of the item being deleted\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.deleteItem = function (itemUri, options) {\n\treturn this.managedRequest('delete', itemUri, options)\n}\n\n\n/**\n * Updates contents of a file\n * @param {String} fileName - Name of the file being updated\n * @param {Object | Blob} dataObj - New content of the file (Object must contain file key)\n * Object example {\n *   file: [<blob>, <fileName>]\n * }\n * @param {String} lastModified - the last-modified header string that matches that of file being overwritten\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.updateFile = function (itemUri, dataObj, lastModified, options) {\n\tconst url = itemUri + '/content'\n\tconsole.log('URL', url)\n\tlet headers = {\n\t\t'Content-Type': 'application/vnd.sas.file',\n\t\t'If-Unmodified-Since': lastModified\n\t}\n\tconst isBlob = dataObj instanceof Blob\n\tconst useMultipartFormData = !isBlob // set useMultipartFormData to true if dataObj is not Blob\n\n\tconst optionsObj = Object.assign({}, options, {\n\t\tparams: dataObj,\n\t\theaders,\n\t\tuseMultipartFormData\n\t})\n\treturn this.managedRequest('put', url, optionsObj);\n}\n\n/**\n Updates file Metadata \n * @param {String} fileName - Name of the file being updated\n * @param {String} lastModified - the last-modified header string that matches that of file being updated\n * @param {Object | Blob} dataObj - objects containing the fields that are being changed\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.updateFileMetadata = function (itemUri, dataObj, lastModified, options) {\n  let headers = {\n    'Content-Type':'application/vnd.sas.file+json',\n\t\t'If-Unmodified-Since': lastModified\n  }\n  const isBlob = dataObj instanceof Blob\n  const useMultipartFormData = !isBlob // set useMultipartFormData to true if dataObj is not Blob\n  \n  const optionsObj = Object.assign({}, options, {\n    params: dataObj,\n    headers,\n    useMultipartFormData\n  })\n\n  return this.managedRequest('patch', itemUri, optionsObj);\n}\n\n/**\n * Updates folder info\n * @param {String} folderUri - uri of the folder that is being changed\n * @param {String} lastModified - the last-modified header string that matches that of the folder being updated\n * @param {Object | Blob} dataObj - object thats is either the whole folder or partial data\n * @param {Object} options - Options object for managedRequest\n */\nmodule.exports.updateFolderMetadata = function (folderUri, dataObj, lastModified, options) {\n\n  /**\n    @constant {Boolean} partialData - indicates wether dataObj containts all the data that needs to be send to the server\n    or partial data which contatins only the fields that need to be updated, in which case a call needs to be made to the server for \n    the rest of the data before the update can be done\n   */\n  const {partialData} = options;\n\n  const headers = {\n    'Content-Type': \"application/vnd.sas.content.folder+json\",\n    'If-Unmodified-Since': lastModified,\n  }\n\n  if (partialData) {\n\n    const _callback = (err, res) => {\n      if (res) {\n\n        const folder = Object.assign({}, res.body, dataObj);\n\n        let forBlob = JSON.stringify(folder);\n        let data = new Blob([forBlob], {type: \"octet/stream\"});\n\n        const optionsObj = Object.assign({}, options, {\n          params: data,\n          headers,\n          useMultipartFormData : false,\n        })\n\n        return this.managedRequest('put', folderUri, optionsObj);\n      }\n      \n      return options.callback(err);\n    }\n    const getOptionsObj = Object.assign({}, options, {\n      headers: {'Content-Type': \"application/vnd.sas.content.folder+json\"},\n      callback: _callback\n    })\n\n    return this.managedRequest('get', folderUri, getOptionsObj);\n  }\n  else {\n    if ( !(dataObj instanceof Blob)) {\n      let forBlob = JSON.stringify(dataObj);\n      dataObj = new Blob([forBlob], {type: \"octet/stream\"});\n    }\n\n    const optionsObj = Object.assign({}, options, {\n      params: dataObj,\n      headers,\n      useMultipartFormData : false,\n    })\n    return this.managedRequest('put', folderUri, optionsObj);\n  }\n}","const logs = require('../logs.js');\nconst h54sError = require('../error.js');\n\nconst programNotFoundPatt = /<title>(Stored Process Error|SASStoredProcess)<\\/title>[\\s\\S]*<h2>(Stored process not found:.*|.*not a valid stored process path.)<\\/h2>/;\nconst badJobDefinition = \"<h2>Parameter Error <br/>Unable to get job definition.</h2>\";\n\nconst responseReplace = function(res) {\n  return res\n};\n\n/**\n* Parse response from server\n*\n* @param {object} responseText - response html from the server\n* @param {string} sasProgram - sas program path\n* @param {object} params - params sent to sas program with addTable\n*\n*/\nmodule.exports.parseRes = function(responseText, sasProgram, params) {\n  const matches = responseText.match(programNotFoundPatt);\n  if(matches) {\n    throw new h54sError('programNotFound', 'You have not been granted permission to perform this action, or the STP is missing.');\n  }\n  //remove new lines in json response\n  //replace \\\\(d) with \\(d) - SAS json parser is escaping it\n  return JSON.parse(responseReplace(responseText));\n};\n\n/**\n* Parse response from server in debug mode\n*\n* @param {object} responseText - response html from the server\n* @param {string} sasProgram - sas program path\n* @param {object} params - params sent to sas program with addTable\n* @param {string} hostUrl - same as in h54s constructor\n* @param {bool} isViya - same as in h54s constructor\n*\n*/\nmodule.exports.parseDebugRes = function (responseText, sasProgram, params, hostUrl, isViya) {\n\tconst self = this\n\tlet matches = responseText.match(programNotFoundPatt);\n\tif (matches) {\n\t\tthrow new h54sError('programNotFound', 'Sas program completed with errors');\n\t}\n\n\tif (isViya) {\n\t\tconst matchesWrongJob = responseText.match(badJobDefinition);\n\t\tif (matchesWrongJob) {\n\t\t\tthrow new h54sError('programNotFound', 'Sas program completed with errors. Unable to get job definition.');\n\t\t}\n\t}\n\n\t//find json\n\tlet patt = isViya ? /^(.?<iframe.*src=\")([^\"]+)(.*iframe>)/m : /^(.?--h54s-data-start--)([\\S\\s]*?)(--h54s-data-end--)/m;\n\tmatches = responseText.match(patt);\n\n\tconst page = responseText.replace(patt, '');\n\tconst htmlBodyPatt = /<body.*>([\\s\\S]*)<\\/body>/;\n\tconst bodyMatches = page.match(htmlBodyPatt);\n\t//remove html tags\n\tlet debugText = bodyMatches[1].replace(/<[^>]*>/g, '');\n\tdebugText = this.decodeHTMLEntities(debugText);\n\n\tlogs.addDebugData(bodyMatches[1], debugText, sasProgram, params);\n\n  if (isViya && this.parseErrorResponse(responseText, sasProgram)) {\n\t\tthrow new h54sError('sasError', 'Sas program completed with errors');\n\t}\n\tif (!matches) {\n\t\tthrow new h54sError('parseError', 'Unable to parse response json');\n\t}\n\n\n\tconst promise = new Promise(function (resolve, reject) {\n\t\tlet jsonObj\n\t\tif (isViya) {\n\t\t\tconst xhr = new XMLHttpRequest();\n\t\t\tconst baseUrl = hostUrl || \"\";\n\t\t\txhr.open(\"GET\", baseUrl + matches[2]);\n\t\t\txhr.onload = function () {\n\t\t\t\tif (this.status >= 200 && this.status < 300) {\n\t\t\t\t\tresolve(JSON.parse(xhr.responseText.replace(/(\\r\\n|\\r|\\n)/g, '')));\n\t\t\t\t} else {\n\t\t\t\t\treject(new h54sError('fetchError', xhr.statusText, this.status))\n\t\t\t\t}\n\t\t\t};\n\t\t\txhr.onerror = function () {\n\t\t\t\treject(new h54sError('fetchError', xhr.statusText))\n\t\t\t};\n\t\t\txhr.send();\n\t\t} else {\n\t\t\ttry {\n\t\t\t\tjsonObj = JSON.parse(responseReplace(matches[2]));\n\t\t\t} catch (e) {\n\t\t\t\treject(new h54sError('parseError', 'Unable to parse response json'))\n\t\t\t}\n\n\t\t\tif (jsonObj && jsonObj.h54sAbort) {\n\t\t\t\tresolve(jsonObj);\n\t\t\t} else if (self.parseErrorResponse(responseText, sasProgram)) {\n\t\t\t\treject(new h54sError('sasError', 'Sas program completed with errors'))\n\t\t\t} else {\n\t\t\t\tresolve(jsonObj);\n\t\t\t}\n\t\t}\n\t});\n\n\treturn promise;\n};\n\n/**\n* Add failed response to logs - used only if debug=false\n*\n* @param {string} responseText - response html from the server\n* @param {string} sasProgram - sas program path\n*\n*/\nmodule.exports.addFailedResponse = function(responseText, sasProgram) {\n  const patt      = /<script([\\s\\S]*)\\/form>/;\n  const patt2     = /display\\s?:\\s?none;?\\s?/;\n  //remove script with form for toggling the logs and \"display:none\" from style\n  responseText  = responseText.replace(patt, '').replace(patt2, '');\n  let debugText = responseText.replace(/<[^>]*>/g, '');\n  debugText = this.decodeHTMLEntities(debugText);\n\n  logs.addFailedRequest(responseText, debugText, sasProgram);\n};\n\n/**\n* Unescape all string values in returned object\n*\n* @param {object} obj\n*\n*/\nmodule.exports.unescapeValues = function(obj) {\n  for (let key in obj) {\n    if (typeof obj[key] === 'string') {\n      obj[key] = decodeURIComponent(obj[key]);\n    } else if(typeof obj === 'object') {\n      this.unescapeValues(obj[key]);\n    }\n  }\n  return obj;\n};\n\n/**\n* Parse error response from server and save errors in memory\n*\n* @param {string} res - server response\n* @param {string} sasProgram - sas program which returned the response\n*\n*/\nmodule.exports.parseErrorResponse = function(res, sasProgram) {\n  //capture 'ERROR: [text].' or 'ERROR xx [text].'\n  const patt    = /^ERROR(:\\s|\\s\\d\\d)(.*\\.|.*\\n.*\\.)/gm;\n  let errors  = res.replace(/(<([^>]+)>)/ig, '').match(patt);\n  if(!errors) {\n    return;\n  }\n\n  let errMessage;\n  for(let i = 0, n = errors.length; i < n; i++) {\n    errMessage  = errors[i].replace(/<[^>]*>/g, '').replace(/(\\n|\\s{2,})/g, ' ');\n    errMessage  = this.decodeHTMLEntities(errMessage);\n    errors[i]   = {\n      sasProgram: sasProgram,\n      message:    errMessage,\n      time:       new Date()\n    };\n  }\n\n  logs.addSasErrors(errors);\n\n  return true;\n};\n\n/**\n* Decode HTML entities - old utility function\n*\n* @param {string} res - server response\n*\n*/\nmodule.exports.decodeHTMLEntities = function (html) {\n  const tempElement = document.createElement('span');\n  let str\t= html.replace(/&(#(?:x[0-9a-f]+|\\d+)|[a-z]+);/gi,\n    function (str) {\n      tempElement.innerHTML = str;\n      str = tempElement.textContent || tempElement.innerText;\n      return str;\n    }\n  );\n  return str;\n};\n\n/**\n* Convert sas time to javascript date\n*\n* @param {number} sasDate - sas Tate object\n*\n*/\nmodule.exports.fromSasDateTime = function (sasDate) {\n  const basedate = new Date(\"January 1, 1960 00:00:00\");\n  const currdate = sasDate;\n\n  // offsets for UTC and timezones and BST\n  const baseOffset = basedate.getTimezoneOffset(); // in minutes\n\n  // convert sas datetime to a current valid javascript date\n  const basedateMs  = basedate.getTime(); // in ms\n  const currdateMs  = currdate * 1000; // to ms\n  const sasDatetime = currdateMs + basedateMs;\n  const jsDate      = new Date();\n  jsDate.setTime(sasDatetime); // first time to get offset BST daylight savings etc\n  const currOffset  = jsDate.getTimezoneOffset(); // adjust for offset in minutes\n  const offsetVar   = (baseOffset - currOffset) * 60 * 1000; // difference in milliseconds\n  const offsetTime  = sasDatetime - offsetVar; // finding BST and daylight savings\n  jsDate.setTime(offsetTime); // update with offset\n  return jsDate;\n};\n\n/**\n * Checks whether response object is a login redirect\n * @param {Object} responseObj xhr response to be checked for logon redirect\n */\nmodule.exports.needToLogin = function(responseObj) {\n\tconst isSASLogon = responseObj.responseURL && responseObj.responseURL.includes('SASLogon')\n\tif (isSASLogon === false) {\n\t\treturn false\n\t}\n\n  const patt = /<form.+action=\"(.*Logon[^\"]*).*>/;\n  const matches = patt.exec(responseObj.responseText);\n  let newLoginUrl;\n\n  if(!matches) {\n    //there's no form, we are in. hooray!\n    return false;\n  } else {\n    const actionUrl = matches[1].replace(/\\?.*/, '');\n    if(actionUrl.charAt(0) === '/') {\n      newLoginUrl = this.hostUrl ? this.hostUrl + actionUrl : actionUrl;\n      if(newLoginUrl !== this.loginUrl) {\n        this._loginChanged = true;\n        this.loginUrl = newLoginUrl;\n      }\n    } else {\n      //relative path\n\n      const lastIndOfSlash = responseObj.responseURL.lastIndexOf('/') + 1;\n      //remove everything after the last slash, and everything until the first\n      const relativeLoginUrl = responseObj.responseURL.substr(0, lastIndOfSlash).replace(/.*\\/{2}[^\\/]*/, '') + actionUrl;\n      newLoginUrl = this.hostUrl ? this.hostUrl + relativeLoginUrl : relativeLoginUrl;\n      if(newLoginUrl !== this.loginUrl) {\n        this._loginChanged = true;\n        this.loginUrl = newLoginUrl;\n      }\n    }\n\n    //save parameters from hidden form fields\n    const parser = new DOMParser();\n    const doc = parser.parseFromString(responseObj.responseText,\"text/html\");\n    const res = doc.querySelectorAll(\"input[type='hidden']\");\n    const hiddenFormParams = {};\n    if(res) {\n      //it's new login page if we have these additional parameters\n      this._isNewLoginPage = true;\n      res.forEach(function(node) {\n        hiddenFormParams[node.name] = node.value;\n      });\n      this._aditionalLoginParams = hiddenFormParams;\n    }\n    return true;\n  }\n};\n\n/**\n* Get full program path from metadata root and relative path\n*\n* @param {string} metadataRoot - Metadata root (path where all programs for the project are located)\n* @param {string} sasProgramPath - Sas program path\n*\n*/\nmodule.exports.getFullProgramPath = function(metadataRoot, sasProgramPath) {\n  return metadataRoot ? metadataRoot.replace(/\\/?$/, '/') + sasProgramPath.replace(/^\\//, '') : sasProgramPath;\n};\n\n// Returns object where table rows are groupped by key\nmodule.exports.getObjOfTable = function (table, key, value = null) {\n\tconst obj = {}\n\ttable.forEach(row => {\n\t\tif (!obj[row[key]]) {\n\t\t\tobj[row[key]] = []\n\t\t\tobj[row[key]].push(value ? row[value] : row)\n\t\t} else {\n\t\t\tobj[row[key]].push(value ? row[value] : row)\n\t\t}\n\t})\n\treturn obj\n}\n\n// Returns self uri out of links array\nmodule.exports.getSelfUri = function (links) {\n\treturn links\n\t\t.filter(e => e.rel === 'self')\n\t\t.map(e => e.uri)\n\t\t.shift();\n}\n","const h54sError = require('./error.js');\nconst logs      = require('./logs.js');\nconst Tables    = require('./tables');\nconst Files     = require('./files');\nconst toSasDateTime = require('./tables/utils.js').toSasDateTime;\n\n/**\n * Checks whether a given table name is a valid SAS macro name\n * @param {String} macroName The SAS macro name to be given to this table\n */\nfunction validateMacro(macroName) {\n  if(macroName.length > 32) {\n    throw new h54sError('argumentError', 'Table name too long. Maximum is 32 characters');\n  }\n\n  const charCodeAt0 = macroName.charCodeAt(0);\n  // validate it starts with A-Z, a-z, or _\n  if((charCodeAt0 < 65 || charCodeAt0 > 90) && (charCodeAt0 < 97 || charCodeAt0 > 122) && macroName[0] !== '_') {\n    throw new h54sError('argumentError', 'Table name starting with number or special characters');\n  }\n\n  for(let i = 0; i < macroName.length; i++) {\n    const charCode = macroName.charCodeAt(i);\n\n    if((charCode < 48 || charCode > 57) &&\n      (charCode < 65 || charCode > 90) &&\n      (charCode < 97 || charCode > 122) &&\n      macroName[i] !== '_')\n    {\n      throw new h54sError('argumentError', 'Table name has unsupported characters');\n    }\n  }\n}\n\n/**\n* h54s SAS data object constructor\n* @constructor\n*\n* @param {array|file} data - Table or file added when object is created\n* @param {String} macroName The SAS macro name to be given to this table\n* @param {number} parameterThreshold - size of data objects sent to SAS (legacy)\n*\n*/\nfunction SasData(data, macroName, specs) {\n  if(data instanceof Array) {\n    this._files = {};\n    this.addTable(data, macroName, specs);\n  } else if(data instanceof File || data instanceof Blob) {\n    Files.call(this, data, macroName);\n  } else {\n    throw new h54sError('argumentError', 'Data argument wrong type or missing');\n  }\n}\n\n/**\n* Add table to tables object\n* @param {array} table - Array of table objects\n* @param {String} macroName The SAS macro name to be given to this table\n*\n*/\nSasData.prototype.addTable = function(table, macroName, specs) {\n  const isSpecsProvided = !!specs;\n  if(table && macroName) {\n    if(!(table instanceof Array)) {\n      throw new h54sError('argumentError', 'First argument must be array');\n    }\n    if(typeof macroName !== 'string') {\n      throw new h54sError('argumentError', 'Second argument must be string');\n    }\n\n    validateMacro(macroName);\n  } else {\n    throw new h54sError('argumentError', 'Missing arguments');\n  }\n\n  if (typeof table !== 'object' || !(table instanceof Array)) {\n    throw new h54sError('argumentError', 'Table argument is not an array');\n  }\n\n  let key;\n  if(specs) {\n    if(specs.constructor !== Object) {\n      throw new h54sError('argumentError', 'Specs data type wrong. Object expected.');\n    }\n    for(key in table[0]) {\n      if(!specs[key]) {\n        throw new h54sError('argumentError', 'Missing columns in specs data.');\n      }\n    }\n    for(key in specs) {\n      if(specs[key].constructor !== Object) {\n        throw new h54sError('argumentError', 'Wrong column descriptor in specs data.');\n      }\n      if(!specs[key].colType || !specs[key].colLength) {\n        throw new h54sError('argumentError', 'Missing columns in specs descriptor.');\n      }\n    }\n  }\n\n  let i, j, //counters used latter in code\n      row, val, type,\n      specKeys = [];\n\tconst specialChars = ['\"', '\\\\', '/', '\\n', '\\t', '\\f', '\\r', '\\b'];\n\n  if(!specs) {\n    specs = {};\n\n    for (i = 0; i < table.length; i++) {\n      row = table[i];\n\n      if(typeof row !== 'object') {\n        throw new h54sError('argumentError', 'Table item is not an object');\n      }\n\n      for(key in row) {\n        if(row.hasOwnProperty(key)) {\n          val  = row[key];\n          type = typeof val;\n\n          if(specs[key] === undefined) {\n            specKeys.push(key);\n            specs[key] = {};\n\n            if (type === 'number') {\n              if(val < Number.MIN_SAFE_INTEGER || val > Number.MAX_SAFE_INTEGER) {\n                logs.addApplicationLog('Object[' + i + '].' + key + ' - This value exceeds expected numeric precision.');\n              }\n              specs[key].colType   = 'num';\n              specs[key].colLength = 8;\n            } else if (type === 'string' && !(val instanceof Date)) { // straightforward string\n              specs[key].colType    = 'string';\n              specs[key].colLength  = val.length;\n            } else if(val instanceof Date) {\n              specs[key].colType   = 'date';\n              specs[key].colLength = 8;\n            } else if (type === 'object') {\n              specs[key].colType   = 'json';\n              specs[key].colLength = JSON.stringify(val).length;\n            }\n          }\n        }\n      }\n    }\n  } else {\n    specKeys = Object.keys(specs);\n  }\n\n  let sasCsv = '';\n\n  // we need two loops - the first one is creating specs and validating\n  for (i = 0; i < table.length; i++) {\n    row = table[i];\n    for(j = 0; j < specKeys.length; j++) {\n      key = specKeys[j];\n      if(row.hasOwnProperty(key)) {\n        val  = row[key];\n        type = typeof val;\n\n        if(type === 'number' && isNaN(val)) {\n          throw new h54sError('typeError', 'NaN value in one of the values (columns) is not allowed');\n        }\n        if(val === -Infinity || val === Infinity) {\n          throw new h54sError('typeError', val.toString() + ' value in one of the values (columns) is not allowed');\n        }\n        if(val === true || val === false) {\n          throw new h54sError('typeError', 'Boolean value in one of the values (columns) is not allowed');\n        }\n        if(type === 'string' && val.indexOf('\\r\\n') !== -1) {\n          throw new h54sError('typeError', 'New line character is not supported');\n        }\n\n        // convert null to '.' for numbers and to '' for strings\n        if(val === null) {\n          if(specs[key].colType === 'string') {\n            val = '';\n            type = 'string';\n          } else if(specs[key].colType === 'num') {\n            val = '.';\n            type = 'number';\n          } else {\n            throw new h54sError('typeError', 'Cannot convert null value');\n          }\n        }\n\n\n        if ((type === 'number' && specs[key].colType !== 'num' && val !== '.') ||\n          ((type === 'string' && !(val instanceof Date) && specs[key].colType !== 'string') &&\n          (type === 'string' && specs[key].colType == 'num' && val !== '.')) ||\n          (val instanceof Date && specs[key].colType !== 'date') ||\n          ((type === 'object' && val.constructor !== Date) && specs[key].colType !== 'json'))\n        {\n          throw new h54sError('typeError', 'There is a specs type mismatch in the array between values (columns) of the same name.' +\n            ' type/colType/val = ' + type +'/' + specs[key].colType + '/' + val );\n        } else if(!isSpecsProvided && type === 'string' && specs[key].colLength < val.length) {\n          specs[key].colLength = val.length;\n        } else if((type === 'string' && specs[key].colLength < val.length) || (type !== 'string' && specs[key].colLength !== 8)) {\n          throw new h54sError('typeError', 'There is a specs length mismatch in the array between values (columns) of the same name.' +\n            ' type/colType/val = ' + type +'/' + specs[key].colType + '/' + val );\n        }\n\n        if (val instanceof Date) {\n          val = toSasDateTime(val);\n        }\n\n        switch(specs[key].colType) {\n          case 'num':\n          case 'date':\n            sasCsv += val;\n            break;\n          case 'string':\n            sasCsv += '\"' + val.replace(/\"/g, '\"\"') + '\"';\n            let colLength = val.length;\n            for(let k = 0; k < val.length; k++) {\n              if(specialChars.indexOf(val[k]) !== -1) {\n                colLength++;\n              } else {\n                let code = val.charCodeAt(k);\n                if(code > 0xffff) {\n                  colLength += 3;\n                } else if(code > 0x7ff) {\n                  colLength += 2;\n                } else if(code > 0x7f) {\n                  colLength += 1;\n                }\n              }\n            }\n            // use maximum value between max previous, current value and 1 (first two can be 0 wich is not supported)\n            specs[key].colLength = Math.max(specs[key].colLength, colLength, 1);\n            break;\n          case 'object':\n            sasCsv += '\"' + JSON.stringify(val).replace(/\"/g, '\"\"') + '\"';\n            break;\n        }\n      }\n      // do not insert if it's the last column\n      if(j < specKeys.length - 1) {\n        sasCsv += ',';\n      }\n    }\n    if(i < table.length - 1) {\n      sasCsv += '\\r\\n';\n    }\n  }\n\n  //convert specs to csv with pipes\n  const specString = specKeys.map(function(key) {\n    return key + ',' + specs[key].colType + ',' + specs[key].colLength;\n  }).join('|');\n\n  this._files[macroName] = [\n    specString,\n    new Blob([sasCsv], {type: 'text/csv;charset=UTF-8'})\n  ];\n};\n\n/**\n * Add file as a verbatim blob file uplaod\n * @param {Blob} file - the blob that will be uploaded as file\n * @param {String} macroName - the SAS webin name given to this file\n */\nSasData.prototype.addFile  = function(file, macroName) {\n  Files.prototype.add.call(this, file, macroName);\n};\n\nmodule.exports = SasData;\n","const h54sError = require('../error.js');\n\n/*\n* h54s tables object constructor\n* @constructor\n*\n*@param {array} table - Table added when object is created\n*@param {string} macroName - macro name\n*@param {number} parameterThreshold - size of data objects sent to SAS\n*\n*/\nfunction Tables(table, macroName, parameterThreshold) {\n  this._tables = {};\n  this._parameterThreshold = parameterThreshold || 30000;\n\n  Tables.prototype.add.call(this, table, macroName);\n}\n\n/*\n* Add table to tables object\n* @param {array} table - Array of table objects\n* @param {string} macroName - Sas macro name\n*\n*/\nTables.prototype.add = function(table, macroName) {\n  if(table && macroName) {\n    if(!(table instanceof Array)) {\n      throw new h54sError('argumentError', 'First argument must be array');\n    }\n    if(typeof macroName !== 'string') {\n      throw new h54sError('argumentError', 'Second argument must be string');\n    }\n    if(!isNaN(macroName[macroName.length - 1])) {\n      throw new h54sError('argumentError', 'Macro name cannot have number at the end');\n    }\n  } else {\n    throw new h54sError('argumentError', 'Missing arguments');\n  }\n\n  const result = this._utils.convertTableObject(table, this._parameterThreshold);\n\n  const tableArray = [];\n  tableArray.push(JSON.stringify(result.spec));\n  for (let numberOfTables = 0; numberOfTables < result.data.length; numberOfTables++) {\n    const outString = JSON.stringify(result.data[numberOfTables]);\n    tableArray.push(outString);\n  }\n  this._tables[macroName] = tableArray;\n};\n\nTables.prototype._utils = require('./utils.js');\n\nmodule.exports = Tables;\n","const h54sError = require('../error.js');\nconst logs = require('../logs.js');\n\n/*\n* Convert table object to Sas readable object\n*\n* @param {object} inObject - Object to convert\n*\n*/\nmodule.exports.convertTableObject = function(inObject, chunkThreshold) {\n  const self            = this;\n\n  if(chunkThreshold > 30000) {\n    console.warn('You should not set threshold larger than 30kb because of the SAS limitations');\n  }\n\n  // first check that the object is an array\n  if (typeof (inObject) !== 'object') {\n    throw new h54sError('argumentError', 'The parameter passed to checkAndGetTypeObject is not an object');\n  }\n\n  const arrayLength = inObject.length;\n  if (typeof (arrayLength) !== 'number') {\n    throw new h54sError('argumentError', 'The parameter passed to checkAndGetTypeObject does not have a valid length and is most likely not an array');\n  }\n\n  const existingCols = {}; // this is just to make lookup easier rather than traversing array each time. Will transform after\n\n  // function checkAndSetArray - this will check an inObject current key against the existing typeArray and either return -1 if there\n  // is a type mismatch or add an element and update/increment the length if needed\n\n  function checkAndIncrement(colSpec) {\n    if (typeof (existingCols[colSpec.colName]) === 'undefined') {\n      existingCols[colSpec.colName]           = {};\n      existingCols[colSpec.colName].colName   = colSpec.colName;\n      existingCols[colSpec.colName].colType   = colSpec.colType;\n      existingCols[colSpec.colName].colLength = colSpec.colLength > 0 ? colSpec.colLength : 1;\n      return 0; // all ok\n    }\n    // check type match\n    if (existingCols[colSpec.colName].colType !== colSpec.colType) {\n      return -1; // there is a fudge in the typing\n    }\n    if (existingCols[colSpec.colName].colLength < colSpec.colLength) {\n      existingCols[colSpec.colName].colLength = colSpec.colLength > 0 ? colSpec.colLength : 1; // increment the max length of this column\n      return 0;\n    }\n  }\n  let chunkArrayCount         = 0; // this is for keeping tabs on how long the current array string would be\n  const targetArray           = []; // this is the array of target arrays\n  let currentTarget           = 0;\n  targetArray[currentTarget]  = [];\n  let j                       = 0;\n  for (let i = 0; i < inObject.length; i++) {\n    targetArray[currentTarget][j] = {};\n    let chunkRowCount             = 0;\n\n    for (let key in inObject[i]) {\n      const thisSpec  = {};\n      const thisValue = inObject[i][key];\n\n      //skip undefined values\n      if(thisValue === undefined || thisValue === null) {\n        continue;\n      }\n\n      //throw an error if there's NaN value\n      if(typeof thisValue === 'number' && isNaN(thisValue)) {\n        throw new h54sError('typeError', 'NaN value in one of the values (columns) is not allowed');\n      }\n\n      if(thisValue === -Infinity || thisValue === Infinity) {\n        throw new h54sError('typeError', thisValue.toString() + ' value in one of the values (columns) is not allowed');\n      }\n\n      if(thisValue === true || thisValue === false) {\n        throw new h54sError('typeError', 'Boolean value in one of the values (columns) is not allowed');\n      }\n\n      // get type... if it is an object then convert it to json and store as a string\n      const thisType  = typeof (thisValue);\n\n      if (thisType === 'number') { // straightforward number\n        if(thisValue < Number.MIN_SAFE_INTEGER || thisValue > Number.MAX_SAFE_INTEGER) {\n          logs.addApplicationLog('Object[' + i + '].' + key + ' - This value exceeds expected numeric precision.');\n        }\n        thisSpec.colName                    = key;\n        thisSpec.colType                    = 'num';\n        thisSpec.colLength                  = 8;\n        thisSpec.encodedLength              = thisValue.toString().length;\n        targetArray[currentTarget][j][key]  = thisValue;\n      } else if (thisType === 'string') {\n        thisSpec.colName    = key;\n        thisSpec.colType    = 'string';\n        thisSpec.colLength  = thisValue.length;\n\n        if (thisValue === \"\") {\n          targetArray[currentTarget][j][key] = \" \";\n        } else {\n          targetArray[currentTarget][j][key] = encodeURIComponent(thisValue).replace(/'/g, '%27');\n        }\n        thisSpec.encodedLength = targetArray[currentTarget][j][key].length;\n      } else if(thisValue instanceof Date) {\n      \tconsole.log(\"ERROR VALUE \", thisValue)\n      \tconsole.log(\"TYPEOF VALUE \", typeof thisValue)\n        throw new h54sError('typeError', 'Date type not supported. Please use h54s.toSasDateTime function to convert it');\n      } else if (thisType == 'object') {\n        thisSpec.colName                    = key;\n        thisSpec.colType                    = 'json';\n        thisSpec.colLength                  = JSON.stringify(thisValue).length;\n        targetArray[currentTarget][j][key]  = encodeURIComponent(JSON.stringify(thisValue)).replace(/'/g, '%27');\n        thisSpec.encodedLength              = targetArray[currentTarget][j][key].length;\n      }\n\n      chunkRowCount = chunkRowCount + 6 + key.length + thisSpec.encodedLength;\n\n      if (checkAndIncrement(thisSpec) == -1) {\n        throw new h54sError('typeError', 'There is a type mismatch in the array between values (columns) of the same name.');\n      }\n    }\n\n    //remove last added row if it's empty\n    if(Object.keys(targetArray[currentTarget][j]).length === 0) {\n      targetArray[currentTarget].splice(j, 1);\n      continue;\n    }\n\n    if (chunkRowCount > chunkThreshold) {\n      throw new h54sError('argumentError', 'Row ' + j + ' exceeds size limit of 32kb');\n    } else if(chunkArrayCount + chunkRowCount > chunkThreshold) {\n      //create new array if this one is full and move the last item to the new array\n      const lastRow = targetArray[currentTarget].pop(); // get rid of that last row\n      currentTarget++; // move onto the next array\n      targetArray[currentTarget]  = [lastRow]; // make it an array\n      j                           = 0; // initialise new row counter for new array - it will be incremented at the end of the function\n      chunkArrayCount             = chunkRowCount; // this is the new chunk max size\n    } else {\n      chunkArrayCount = chunkArrayCount + chunkRowCount;\n    }\n    j++;\n  }\n\n  // reformat existingCols into an array so sas can parse it;\n  const specArray = [];\n  for (let k in existingCols) {\n    specArray.push(existingCols[k]);\n  }\n  return {\n    spec:       specArray,\n    data:       targetArray,\n    jsonLength: chunkArrayCount\n  }; // the spec will be the macro[0], with the data split into arrays of macro[1-n]\n  // means in terms of dojo xhr object at least they need to go into the same array\n};\n\n/*\n* Convert javascript date to sas time\n*\n* @param {object} jsDate - javascript Date object\n*\n*/\nmodule.exports.toSasDateTime = function (jsDate) {\n  const basedate = new Date(\"January 1, 1960 00:00:00\");\n  const currdate = jsDate;\n\n  // offsets for UTC and timezones and BST\n  const baseOffset = basedate.getTimezoneOffset(); // in minutes\n  const currOffset = currdate.getTimezoneOffset(); // in minutes\n\n  // convert currdate to a sas datetime\n  const offsetSecs    = (currOffset - baseOffset) * 60; // offsetDiff is in minutes to start with\n  const baseDateSecs  = basedate.getTime() / 1000; // get rid of ms\n  const currdateSecs  = currdate.getTime() / 1000; // get rid of ms\n  const sasDatetime   = Math.round(currdateSecs - baseDateSecs - offsetSecs); // adjust\n\n  return sasDatetime;\n};\n"]}