utils.js

/* eslint-disable no-undef */
/* eslint-disable guard-for-in */
/* eslint-disable no-plusplus */
/* eslint-disable no-shadow */
/* eslint-disable camelcase */
/* eslint-disable no-restricted-syntax */
/* eslint-disable no-param-reassign */
/**
 * @file Terminus Client Utility Functions
 * @license Apache Version 2
 * Object for bunding up common Terminus Utility Functions
 */
const Utils = {};

Utils.checkValidName = function (str) {
  if (typeof str !== 'string' || str.trim() === '') return false;
  return /^[a-zA-Z0-9_]*$/.test(str);
};

Utils.ACTIONS = {
  CREATE_DATABASE: 'create_database',
  DELETE_DATABASE: 'delete_database',
  SCHEMA_READ_ACCESS: 'schema_read_access',
  SCHEMA_WRITE_ACCESS: 'schema_write_access',
  INSTANCE_READ_ACCESS: 'instance_read_access',
  INSTANCE_WRITE_ACCESS: 'instance_write_access',
  COMMIT_READ_ACCESS: 'commit_read_access',
  COMMIT_WRITE_ACCESS: 'commit_write_access',
  META_READ_ACCESS: 'meta_read_access',
  META_WRITE_ACCESS: 'meta_write_access',
  CLASS_FRAME: 'class_frame',
  BRANCH: 'branch',
  CLONE: 'clone',
  FETCH: 'fetch',
  PUSH: 'push',
  REBASE: 'rebase',
  /* MANAGE_CAPABILITIES: 'manage_capabilities', */
};

// encodeURI() will not encode: ~!@#$&*()=:/,;?+
// =%25team =%team
// terminusDB do not encode =@ too
Utils.encodeURISegment = function (str) {
  if (typeof str !== 'string') return str;
  str = encodeURI(str);
  str = str.replace(/\?/g, '%3F');
  // we not need = because the server does not encode it
  // str = str.replace(/=/g, '%3D');
  // str = str.replace(/@/g, '%40');
  str = str.replace(/&/g, '%26');
  str = str.replace(/\+/g, '%2B');
  str = str.replace(/#/g, '%23');
  return str;
};

Utils.decodeURISegment = function (str) {
  if (typeof str !== 'string') return str;
  str = str.replace(/%3F/g, '?');
  // str = str.replace(/%3D/g, '=');
  // str = str.replace(/%26/g, '&');
  str = str.replace(/%2B/g, '+');
  str = str.replace(/%23/g, '#');
  // str = str.replace(/%40/g, '@');
  str = decodeURI(str);
  return str;
};

Utils.removeDocType = function (str) {
  if (typeof str === 'string' && str.lastIndexOf('/') > -1) {
    return str.substr(str.lastIndexOf('/') + 1);
  }
  return str;
};

// %253D%25team

/**
 * default set of prefixes that will be used for URL compression
 * @type {object}
 */
Utils.standard_urls = {
  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
  xsd: 'http://www.w3.org/2001/XMLSchema#',
  xdd: 'http://terminusdb.com/schema/xdd#',
  owl: 'http://www.w3.org/2002/07/owl#',
  system: 'http://terminusdb.com/schema/system#',
  vio: 'http://terminusdb.com/schema/vio#',
  repo: 'http://terminusdb.com/schema/repository#',
  layer: 'http://terminusdb.com/schema/layer#',
  woql: 'http://terminusdb.com/schema/woql#',
  ref: 'http://terminusdb.com/schema/ref#',
  api: 'http://terminusdb.com/schema/api#',
};

/**
 * Encode document payload for GET
 * @param {string | object} payload
 * @returns {string}
 */
Utils.URIEncodePayload = function (payload) {
  if (typeof payload === 'string') return encodeURIComponent(payload);
  const payloadArr = [];
  for (const key of Object.keys(payload)) {
    if (typeof payload[key] === 'object') {
      for (const keyElement of Object.keys(payload[key])) {
        const valueElement = payload[key][keyElement];
        payloadArr.push(
          `${encodeURIComponent(keyElement)}=${encodeURIComponent(valueElement)}`,
        );
      }
    } else {
      payloadArr.push(`${encodeURIComponent(key)}=${encodeURIComponent(payload[key])}`);
    }
  }
  return payloadArr.join('&');
};

/**
 * Adds an entry to the list of known standard URL prefixes
 * @param {string} prefix
 * @param {string} url
 */
Utils.addURLPrefix = function (prefix, url) {
  this.standard_urls[prefix] = url;
};

/**
 * is the object empty?
 * returns true if the json object is empty
 * @param {object|array} [obj]
 * @returns {boolean}
 */
Utils.empty = function (obj) {
  // null and undefined are "empty"
  if (!obj) return true;
  // Assume if it has a length property with a non-zero value
  // that that property is correct.
  if (obj.length > 0) return false;
  if (obj.length === 0) return true;
  // Otherwise, does it have any properties of its own?
  // Note that this doesn't handle
  // toString and valueOf enumeration bugs in IE < 9
  // for (const key in obj) {
  if (typeof obj === 'object') {
    for (const key of Object.keys(obj)) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) return false;
    }
  }
  return true;
};

/**
 * Generates a unique node id
 * @param {string} [base]
 * @returns {string}
 */
Utils.genBNID = function (base) {
  base = base || '';
  const r = Math.random()
    .toString(36)
    .substring(7);
  const d = new Date();
  const bnid = `${base}${r}${d.getTime()}`;// `doc:${base}${r}${d.getTime()}`
  return bnid;
};

/**
 * Returns the shorthand version (compressed to prefix:id ) of a url or
 * false if there is none known for that URL
 * @param {object | string} link
 * @returns {string | boolean}
 */

Utils.getShorthand = function (link) {
  // eslint-disable-next-line prefer-destructuring
  if (typeof link === 'object' && link.length) link = link[0];
  if (link && typeof link === 'string') {
    for (const pref of Object.keys(this.standard_urls)) {
      const full = this.standard_urls[pref];
      if (link.substring(0, full.length) === full) {
        const sh = `${pref}:${link.substring(full.length)}`;
        return sh;
      }
    }
  }
  return false;
};

/**
 * Compares 2 IRIs for equality by checking compressed and expanded versions of both sides
 * @param {string} ida
 * @param {string} idb
 * @returns {boolean}
 */
Utils.compareIDs = function (ida, idb) {
  if (ida === idb) return true;
  if (this.unshorten(ida) === idb) return true;
  if (this.shorten(ida) === idb) return true;
  if (this.unshorten(ida) === this.unshorten(idb)) return true;
  return false;
};

/**
 * Shortens a URL to its compressed format - returns the full URL if not possible
 * @param {string} [url]
 * @param {string} [prefixes]
 * @returns {string | undefined}
 */
// we don't have any more visualize prefix
// terminusdb://layer/data/Layer_44ce76721ebe179fdf2c015b0d38eadfa49de3ba
// eslint-disable-next-line no-unused-vars
Utils.shorten = function (url, prefixes) {
  if (!url) return undefined;
  if (url.indexOf('#') !== -1) {
    const urlArr = url.split('#');
    return urlArr.pop();
  }
  if (url.indexOf('terminusdb://') !== -1) {
    const urlArr = url.split('/');
    return urlArr.pop();
  }
  return url;

  /* if (!url) return undefined
    if (typeof url === 'function') return undefined
    prefixes = prefixes || Utils.standard_urls
    for (const pref in prefixes) {
        if (prefixes[pref] === url.substring(0, prefixes[pref].length)) {
            return `${pref}:${url.substring(prefixes[pref].length)}`
        }
    }
    return url */
};

/**
 * Expands a URL to its full URL format - returns the passed string if not possible to expand
 * @param {string} [url]
 * @returns {string | undefined}
 */
Utils.unshorten = function (url) {
  if (!url) return undefined;
  if (this.validURL(url)) return url;
  if (!url) return url;
  const bits = url.split(':');
  if (bits[1]) {
    if (this.standard_urls[bits[0]]) {
      return this.standard_urls[bits[0]] + bits[1];
    }
  }
  return url;
};

/**
 * shortens a jsonld document to its prefixed form
 * @param {array|object|string} jsonld
 * @param {string} [prefixes]
 * @returns {string|array|object}
 */

Utils.json_shorten = function (jsonld, prefixes) {
  const shorten_json_val = (val, prefixes) => {
    if (Array.isArray(val)) {
      const nvals = [];
      for (let i = 0; i < val.length; i++) {
        nvals.push(shorten_json_val(val[i], prefixes));
      }
      return nvals;
    } if (typeof val === 'object') {
      return this.json_shorten(val, prefixes);
    } if (typeof val === 'string') {
      return this.shorten(val, prefixes);
    }
    return val;
  };
  prefixes = prefixes || jsonld['@context'];
  const nujson = {};
  for (const key in jsonld) {
    const nkey = key[0] === '@' ? key : this.shorten(key, prefixes);
    const nval = shorten_json_val(jsonld[key], prefixes);
    nujson[nkey] = nval;
  }
  return nujson;
};

/**
 * Unshortens a jsonld document to its full form
 * @param {array|object|string} jsonld
 * @param {string} [prefixes]
 * @returns {string|array|object}
 */

Utils.json_unshorten = function (jsonld, prefixes) {
  const unshorten_json_val = (val, prefixes) => {
    if (Array.isArray(val)) {
      const nvals = [];
      for (let i = 0; i < val.length; i++) {
        nvals.push(unshorten_json_val(val[i], prefixes));
      }
      return nvals;
    } if (typeof val === 'object') {
      return this.json_unshorten(val, prefixes);
    } if (typeof val === 'string') {
      return this.unshorten(val, prefixes);
    }
    return val;
  };
  prefixes = prefixes || jsonld['@context'];
  const nujson = {};
  for (const key in jsonld) {
    const nkey = key[0] === '@' ? key : this.unshorten(key, prefixes);
    const nval = unshorten_json_val(jsonld[key], prefixes);
    nujson[nkey] = nval;
  }
  return nujson;
};

/**
 * Tests a string to see if it is a valid URL -
 * Valid URLs are those that start with http:// or https://
 */
Utils.validURL = function (str) {
  if (str && typeof str !== 'string') str = `${str}`;
  if (str && (str.substring(0, 7) === 'http://' || str.substring(0, 8) === 'https://')) return true;
  return false;
};

/**
 * Tests a string to see if it is a valid URL -
 * Valid URLs are those that start with http:// or https://
 * @param {string} str
 * @param {string | object} [context]
 * @param {boolean} [allow_shorthand]
 * @returns {boolean}
 */
Utils.isIRI = function (str, context, allow_shorthand) {
  if (!str) return false;
  if (allow_shorthand && context && context[str.split(':')[0]]) return true;
  if (context) {
    for (pref in context) {
      if (str.substring(0, context[pref].length) === context[pref]) return true;
    }
  }
  const prot = str.split(':')[0];
  const valids = ['http', 'https', 'terminusdb'];
  if (valids.indexOf(prot) !== -1) return true;
  return false;
};

/**
 * Generates a text label from a URL
 * @param {string} url
 * @returns {string}
 */
Utils.labelFromURL = function (url) {
  let nurl = this.urlFragment(url);
  nurl = nurl || url;
  if (nurl.lastIndexOf('/') < nurl.length - 1) {
    nurl = nurl.substring(nurl.lastIndexOf('/') + 1);
  }
  nurl = nurl.replace(/_/g, ' ');
  return nurl.charAt(0).toUpperCase() + nurl.slice(1);
};

/**
 * Generates a text label from a URL
 */
Utils.labelFromVariable = function (v) {
  v = v.replace(/_/g, ' ');
  return v.charAt(0).toUpperCase() + v.slice(1);
};

/**
 * returns the fragment part of a URL (whether compressed or not)
 */
Utils.urlFragment = function (url) {
  url = typeof url !== 'string' ? window.location.href : url;
  let bits = url.split('#');
  if (bits.length <= 1) {
    if (!this.validURL(url)) {
      bits = url.split(':');
    }
  }
  if (bits.length >= 1) {
    const [, urlStr] = bits;

    if (urlStr) {
      const [baseUrl] = urlStr.split('?');
      url = baseUrl;
    }
  }
  return url;
};

/**
 * returns the last part of a URL after the last /
 */
Utils.lastURLBit = function (url) {
  url = typeof url === 'undefined' ? window.location.href : url;
  const [urlFirst] = url.split('#');
  const [urlTmp] = urlFirst.split('?');
  url = urlTmp.substring(url.lastIndexOf('/') + 1);
  return url;
};

/**
 * returns the a standard URL associated with a given prefix and extension
 */
Utils.getStdURL = function (pref, ext, url) {
  if (this.standard_urls[pref]) {
    if (url) {
      if (url === this.standard_urls[pref] + ext) return url;
    } else {
      return this.standard_urls[pref] + ext;
    }
  }
  return false;
};

/*
 * Utility function adds v: to variables...
 */
Utils.addNamespacesToVariables = function (vars) {
  const nvars = [];
  for (let i = 0; i < vars.length; i++) {
    if (vars[i]) nvars.push(this.addNamespaceToVariable(vars[i]));
  }
  return nvars;
};

Utils.addNamespaceToVariable = function (v) {
  if (typeof v === 'string' && v.substring(0, 2) !== 'v:') return `v:${v}`;
  return v;
};

/*
 * Utility function removes v: prefix from a variable...
 */
Utils.removeNamespaceFromVariable = function (mvar) {
  if (mvar.substring(0, 2) === 'v:') return mvar.substring(2);
  return mvar;
};

/*
 * Utility function removes v: prefix from an array of variables
 */
Utils.removeNamespacesFromVariables = function (vars) {
  const nvars = [];
  for (let i = 0; i < vars.length; i++) {
    nvars.push(this.removeNamespaceFromVariable(vars[i]));
  }
  return nvars;
};

/*
 * Utility function to extract a value from a config rule - if the value is a variable,
take the value of that variable instead
 */
Utils.getConfigValue = function (val, row) {
  if (typeof val === 'string') val = this.removeNamespaceFromVariable(val);
  if (typeof val === 'string' && row[val]) {
    const rad = row[val];
    if (rad && rad['@value']) return rad['@value'];
    return rad;
  }
  return val;
};

/**
 * TypeHelper bundles together utility functions dealing with datatypes
 */
Utils.TypeHelper = {};

/**
 * Returns true if the passed type is an xsd:string (compressed or not)
 */
Utils.TypeHelper.isStringType = function (stype) {
  if (stype === 'http://www.w3.org/2001/XMLSchema#string') return true;
  if (stype === 'xsd:string') return true;
  return false;
};

Utils.TypeHelper.isDatatype = function (stype) {
  const sh = Utils.shorten(stype);
  if ((sh && sh.substring(0, 4) === 'xsd:') || sh.substring(0, 4) === 'xdd:') return true;
  return false;
};

/**
 * Adds 3 order magnitude separators ( default ,) into big numbers for legibility
 */
Utils.TypeHelper.numberWithCommas = function (value, separator) {
  separator = separator || ',';
  if (value >= 1000 || value <= -1000) {
    const parts = value.toString().split('.');
    if (value <= -1000) parts[0] = parts[0].substring(1);
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, separator);
    if (value <= -1000) value = `-${parts.join('.')}`;
    else value = parts.join('.');
  }
  return value;
};

Utils.TypeHelper.formatBytes = function (bytes, decimals = 2) {
  if (bytes === 0) return '0 Bytes';
  const k = 1024;
  const dm = decimals < 0 ? 0 : decimals;
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
};

/**
 * List of supported datatypes
 */
Utils.TypeHelper.datatypes = [
  'xdd:coordinate',
  'xdd:coordinatePolyline',
  'xdd:coordinatePolygon',
  'xdd:dateRange',
  'xdd:gYearRange',
  'xdd:integerRange',
  'xdd:decimalRange',
  'xdd:cc',
  'xdd:email',
  'xdd:html',
  'xdd:url',
  'xsd:anySimpleType',
  'xsd:string',
  'xsd:boolean',
  'xsd:decimal',
  'xsd:double',
  'xsd:float',
  'xsd:time',
  'xsd:date',
  'xsd:dateTime',
  'xsd:dateTimeStamp',
  'xsd:gYear',
  'xsd:gMonth',
  'xsd:gDay',
  'xsd:gYearMonth',
  'xsd:gMonthDay',
  'xsd:duration',
  'xsd:yearMonthDuration',
  'xsd:dayTimeDuration',
  'xsd:byte',
  'xsd:short',
  'xsd:integer',
  'xsd:long',
  'xsd:unsignedByte',
  'xsd:unsignedInt',
  'xsd:unsignedLong',
  'xsd:nonNegativeInteger',
  'xsd:positiveInteger',
  'xsd:negativeInteger',
  'xsd:nonPositiveInteger',
  'xsd:base64Binary',
  'xsd:anyURI',
  'xsd:language',
  'xsd:normalizedString',
  'xsd:token',
  'xsd:NMTOKEN',
  'xsd:Name',
  'xsd:NCName',
  'xsd:NOTATION',
  'xsd:QName',
  'xsd:ID',
  'xsd:IDREF',
  'xsd:ENTITY',
  'rdf:XMLLiteral',
  'rdf:PlainLiteral',
  'rdfs:Literal',
  'xdd:json',
];

Utils.TypeHelper.parseRangeValue = function (val, dividor) {
  dividor = dividor || ',';
  let vals = [];
  if (typeof val === 'object' && val.length) {
    vals = val;
  } else if (val) {
    if (typeof val !== 'string') {
      val = `${val}`;
    }
    if (val.length && val.charAt(0) === '[' && val.charAt(val.length - 1) === ']') {
      vals.push(val.substring(1, val.indexOf(dividor)));
      vals.push(val.substring(val.indexOf(dividor) + 1, val.length - 1));
    } else {
      vals.push(val);
    }
  }
  return vals;
};

/**
 * DateHelper bundles together utility functions dealing with xsd date types
 */
Utils.DateHelper = {};

/**
 * Takes an xsd time string and returns a structure {hour: HH, minute: MM,
 * second ss.ssssss, timezone: tz}
 */
Utils.DateHelper.parseXsdTime = function (val) {
  if (!val) return {};
  const tz = this.extractXsdTimezone(val);
  if (tz) {
    val = val.substring(0, val.length - tz.length);
  }
  const parsed = {
    hour: val.substring(0, 2),
    minute: val.substring(3, 5),
    second: val.substring(6),
    timezone: tz,
  };
  return parsed;
};

/**
 * Takes an xsd time string and returns a structure {year: [-]YYYY, month: MM, day: dd}
 */
Utils.DateHelper.parseXsdDate = function (val) {
  const tz = this.extractXsdTimezone(val);
  if (tz) {
    val = val.substring(0, val.length - tz.length);
  }
  let year;
  if (val.substring(0, 1) === '-') {
    year = val.substring(0, 5);
  } else {
    year = val.substring(0, 4);
  }
  let parsed;
  if (year && Math.abs(year) < 10000) {
    let month = val.substring(year.length + 1, year.length + 3);
    if (month) {
      month = parseInt(month, 10);
    } else return false;
    let day = val.substring(year.length + 4);
    if (day) day = parseInt(day, 10);
    else return false;
    parsed = {
      year,
      month,
      day,
      timezone: tz,
    };
  }
  return parsed;
};

/**
 * Parses a date string of type ty
 */
Utils.DateHelper.parseDate = function (ty, value) {
  let parsed;
  if (ty === 'xsd:date') {
    parsed = this.parseXsdDate(value);
  } else if (ty === 'xsd:time') {
    parsed = this.parseXsdTime(value);
  } else if (ty === 'xsd:dateTime') {
    parsed = this.parseXsdDateTime(value);
  } else if (ty === 'xsd:gYear') {
    parsed = { year: value };
  } else if (ty === 'xsd:gYearRange') {
    parsed = { year: value };
  } else if (ty === 'xsd:gMonth') {
    parsed = { month: value.substring(2) };
  } else if (ty === 'xsd:gDay') {
    parsed = { day: value };
  } else if (ty === 'xsd:gYearMonth') {
    const bits = value.split('-');
    while (bits.length < 2) bits.push('');
    parsed = { year: bits[0], month: bits[1] };
  } else if (ty === 'xsd:gMonthDay') {
    const bits = value.split('-');
    while (bits.length < 2) bits.push('');
    parsed = { month: bits[0], day: bits[1] };
  } else if (ty === 'xsd:dateTimeStamp') {
    parsed = this.parseXsdDateTime(value);
  }
  return parsed;
};

/**
 * adds appropriate padding to date type for xsd rules
 */
Utils.DateHelper.addXsdPadding = function (parsed) {
  const nparsed = {};
  if (typeof parsed.year !== 'undefined' && parsed.year !== false && parsed.year < 1000) {
    if (Math.abs(parsed.year) < 10) nparsed.year = parsed.year < 0 ? `-000${Math.abs(parsed.year)}` : `000${parsed.year}`;
    else if (Math.abs(parsed.year) < 100) nparsed.year = parsed.year < 0 ? `-00${Math.abs(parsed.year)}` : `00${parsed.year}`;
    else nparsed.year = parsed.year < 0 ? `-0${Math.abs(parsed.year)}` : `0${parsed.year}`;
  } else if (parsed.year) {
    nparsed.year = parsed.year;
  }
  if (typeof parsed.month !== 'undefined' && parsed.month !== false && parsed.month < 10) {
    nparsed.month = `0${parsed.month}`;
  } else if (parsed.month) {
    nparsed.month = parsed.month;
  }
  if (typeof parsed.day !== 'undefined' && parsed.day !== false && parsed.day < 10) {
    nparsed.day = `0${parsed.day}`;
  } else if (parsed.day) {
    nparsed.day = parsed.day;
  }
  if (typeof parsed.hour !== 'undefined' && parsed.hour !== false && parsed.hour < 10) {
    nparsed.hour = `0${parsed.hour}`;
  } else if (parsed.hour) {
    nparsed.hour = parsed.hour;
  }
  if (typeof parsed.minute !== 'undefined' && parsed.minute !== false && parsed.minute < 10) {
    nparsed.minute = `0${parsed.minute}`;
  } else if (parsed.minute) {
    nparsed.minute = parsed.minute;
  }
  if (typeof parsed.second !== 'undefined' && parsed.second !== false && parsed.second < 10) {
    nparsed.second = `0${parsed.second}`;
  } else if (parsed.second) {
    nparsed.second = parsed.second;
  }
  return nparsed;
};

/**
 * generates an xsd string of type ty for the passed parsed structure (year, month, day, hour,
 * minute, second, timezone)
 */
Utils.DateHelper.xsdFromParsed = function (parsed, ty) {
  const xparsed = this.addXsdPadding(parsed);
  let ret;
  if (ty === 'xsd:gYear') {
    ret = xparsed.year ? xparsed.year : false;
  } else if (ty === 'xsd:time') {
    return xparsed.hour && xparsed.minute && xparsed.second
      ? `${xparsed.hour}:${xparsed.minute}:${xparsed.second}`
      : false;
  } else if (ty === 'xsd:date') {
    return xparsed.year && xparsed.month && xparsed.day
      ? `${xparsed.year}-${xparsed.month}-${xparsed.day}`
      : false;
  } else if (ty === 'xsd:dateTime' || ty === 'xsd:dateTimeStamp') {
    ret = xparsed.year && xparsed.month && xparsed.day
      ? `${xparsed.year}-${xparsed.month}-${xparsed.day}T`
      : false;
    if (ret) {
      ret += `${xparsed.hour ? xparsed.hour : '12'}:${
        xparsed.minute ? xparsed.minute : '00'
      }:${xparsed.second ? xparsed.second : '00'}`;
    }
  } else if (ty === 'xsd:gMonth') {
    ret = xparsed.month ? `--${xparsed.month}` : false;
  } else if (ty === 'xsd:gDay') {
    ret = xparsed.day ? `---${xparsed.day}` : false;
  } else if (ty === 'xsd:gYearMonth') {
    ret = xparsed.year && xparsed.month ? `${xparsed.year}-${xparsed.month}` : false;
  } else if (ty === 'xsd:gMonthDay') {
    ret = xparsed.day && xparsed.month ? `--${xparsed.month}-${xparsed.day}` : false;
  }
  if (xparsed.timezone) {
    ret += xparsed.timezone;
  }
  return ret;
};

/**
 * Converts between a unix timestamp and a parsed structure
 */
Utils.DateHelper.convertTimestampToXsd = function (val) {
  const a = new Date(val * 1000);
  const parsed = {
    year: a.getFullYear(),
    month: a.getMonth() + 1,
    day: a.getDate(),
    hour: a.getHours(),
    minute: a.getMinutes(),
    second: a.getSeconds(),
  };
  return parsed;
};

/**
 * Parses an xsd date time into a structure
 */
Utils.DateHelper.parseXsdDateTime = function (val) {
  if (!val) return {};
  if (typeof val === 'number') {
    return this.convertTimestampToXsd(val);
  }
  const tz = this.extractXsdTimezone(val);
  if (tz) {
    val = val.substring(0, val.length - tz.length);
  }
  const datetime = this.parseXsdDate(val);
  const ptime = this.parseXsdTime(val.substring(val.indexOf('T') + 1));

  for (const i of Object.keys(ptime)) {
    datetime[i] = ptime[i];
  }
  datetime.timezone = tz;
  return datetime;
};

/**
 * Extracts the timezone data from an xsd date string
 */
Utils.DateHelper.extractXsdTimezone = function (val) {
  if (typeof val === 'string' && val.endsWith('Z')) {
    return 'Z';
  }
  if (typeof val === 'string' && (val.charAt(val.length - 6) === '+' || val.charAt(val.length - 6) === '-')) {
    val.substring(val.length - 6);
  }
  return false;
};

module.exports = Utils;