@leaddreamer/inventorylogic 0.0.3-beta.39 → 0.0.3-beta.40

package/business/Utilities/index.js

@@ -334,3 +334,5 @@ export function choicesForm(fieldname) {
     ? Forms.Choices[fieldname]
     : {};
 }
+
+export * from "./other.js";

package/business/Utilities/other.js

@@ -0,0 +1,469 @@
+/**
+ * Typedefs, constants, support functions and database operations for
+ * general Utilities
+ * @module Utilities
+ */
+import dayjs from "dayjs";
+import promisePool from "es6-promise-pool";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
+import {
+  fetchRecordByRefPath,
+  runTransaction,
+  writeBack,
+  deleteRecordByRefPath,
+} from "@leaddreamer/firebase-wrapper";
+//the following inits the dayjs plugins
+
+dayjs.extend(isSameOrAfter);
+dayjs.extend(isSameOrBefore);
+
+/**
+ * A convenience function for some shared artist/host front-end pages
+ * @param {OrganizationType} host
+ * @returns {Promise.OrganizationType}
+ */
+export async function saveHost(host, batch = null) {
+  return writeBack(host, batch);
+}
+
+/**
+ * Simple top-level object compare - assumes objects have similar structure - or
+ * AT LEAST all the fields of object1 are present in object2
+ * @param {object} object1
+ * @param {object} object2
+ * @returns {boolean}
+ */
+export function simpleObjectCompare(object1, object2) {
+  let result = Object.keys(object1).reduce((accumulate, key) => {
+    // eslint-disable-next-line
+    return object1[key] == object2[key] ? accumulate : false;
+  }, true); // note simple (not object) compare
+  return result;
+}
+
+/**
+ * Allows string substitution from an object
+ * field names support Dot notation
+ * field names allow ":" extension for alternate formatting
+ * @param {object} thisItem - object to create formated string from
+ * @param {string} thisFormat - string describing formatted output - fieldname wrapped in {} will be substituted.  DOT notation allowed for fields.
+ * @returns {string}
+ */
+export function formatItem(thisObject, thisFormat) {
+  let final = thisFormat.replace(
+    /{.+?}/g, //global, non-greedy - i.e. multiple {} bracketed elements
+    function (field) {
+      let fieldRaw = field.slice(1, -1);
+      //below allows for DOT notation access within the item object
+      let fieldparts = fieldRaw.split(":");
+      let [fieldname, fieldStyle] = fieldparts;
+      let fieldArray = fieldname.split(".");
+      //below walks into an object - note: ASSUMES an object
+      const bob = fieldArray.reduce((lastObject, nextName) => {
+        return lastObject[nextName];
+      }, thisObject);
+      return bob ? specialFormat(bob, fieldStyle) : "----";
+    }
+  );
+  return final;
+}
+
+/**
+ * @private
+ * @param {any} value
+ * @param {!string} style
+ * @returns {any|string}
+ */
+function specialFormat(value, style) {
+  switch (style) {
+    case "timestamp":
+      return dayjs(value.toDate()).format("MMM DD, YYYY");
+    default:
+      return value;
+  }
+}
+
+/**
+ *  @param {object} thisItem - one of two objects being compared
+ *  @param {object} anotherItem - the other of two objects being compared
+ *  @param {!string} sort - string describing sort - format "fieldName:sortType" - sort Type is "string, "date" or "number" (default)
+ *  @return {string}
+ */
+export function compare(thisItem, anotherItem, sort = "Id:number") {
+  let [field, type] = sort.split(":");
+  type = type ? type : "number";
+  switch (type) {
+    case "string":
+      let nameArray = thisItem[field].split("The ");
+      let anotherArray = anotherItem[field].split("The ");
+      return (nameArray[0] ? nameArray[0] : nameArray[1]).localeCompare(
+        anotherArray[0] ? anotherArray[0] : anotherArray[1]
+      );
+
+    case "date":
+      //if (!thisItem[field] || !anotherItem[field]) return 0;
+      return !thisItem[field] ||
+        dayjs(thisItem[field]).isBefore(anotherItem[field], "day")
+        ? -1
+        : anotherItem[field] &&
+          dayjs(thisItem[field]).isSame(anotherItem[field], "day")
+        ? 0
+        : 1;
+
+    default:
+      return Number(thisItem[field]) - Number(anotherItem[field]);
+  }
+}
+
+/**
+ * An array based compare function - is any entry of findFrom present in findIn
+ * @param {Array.any} findFrom
+ * @param {Array.any} findIn
+ * @returns {boolean}
+ */
+export function anyInAny(findFrom, findIn) {
+  let mapFindIn = new Map();
+
+  findIn.forEach((entry, index) => {
+    mapFindIn.set(entry, true);
+  }); //speed up by avoiding second loop
+
+  const findFromLength = findFrom.length;
+  let found = false;
+  for (
+    let findFromIndex = 0;
+    findFromIndex < findFromLength && !found;
+    findFromIndex++
+  )
+    if (
+      mapFindIn.get(findFrom[findFromIndex].valueOf())
+      //findFrom[findFromIndex].valueOf() === findIn[arrayTwoIndex].valueOf()
+    )
+      found = true; //note this breaks both loops
+
+  return found;
+}
+
+/**
+ * An Action Iterator Generator.  Cycles through the entries in the passed array,
+ * yielding the result of a function for each entry.
+ * Only cares that inputs are an array, and a function that returns a
+ * promise
+ * @generator
+ * @param {Array.any} entryArray
+ * @param {callback} actionFunction
+ * @yields {function}
+ */
+function* generateIterator(entryArray, actionFunction) {
+  let countLimit = entryArray.length;
+  //next is testing remnant
+  //countLimit = lessorOf(10, countLimit);
+  for (let count = 0; count < countLimit; count++) {
+    yield actionFunction(entryArray[count]);
+  }
+}
+
+/**
+ *
+ */
+const PromisePool = promisePool.PromisePool;
+
+/**
+ * @typedef {object} PromiseOptions
+ * @property {number} concurrency
+ * @property {number} rate
+ */
+/**
+ * @readonly
+ * @constant
+ * @type {PromiseOptions}
+ * @default
+ */
+const promiseOptionsDefault = {
+  concurrency: 3, //simultaneous
+  rate: 10, //per second
+};
+
+/**
+ * @param {Array.object} entryArray
+ * @param {callback} actionFunction
+ * @param {PromiseOptions} promiseOptions
+ * @returns {Promise}
+ */
+export async function PromisePoolRunner(
+  entryArray,
+  actionFunction,
+  promiseOptions = promiseOptionsDefault
+) {
+  if (entryArray.length) {
+    const promiseIterator = generateIterator(entryArray, actionFunction);
+    const promisePool = new PromisePool(
+      promiseIterator,
+      promiseOptions.concurrency
+    );
+    return promisePool.start();
+  } else {
+    return Promise.resolve(null);
+  }
+}
+
+/**
+ * A convenience function for legibility
+ * @param {any} args unbounded list of arguments
+ * @returns {number} the least of any of the arguments
+b */
+export function lesserOf(...args) {
+  return Math.min(...args);
+}
+
+/**
+ * @param {any} args unbounded list of arguments
+ * @returns {number} the largest of any of the arguments
+ */
+export function largerOf(...args) {
+  return Math.max(...args);
+}
+
+/**
+ * "Moves" a record from our standard tree structureto a parallel archival
+ * structure, by prepending a "_" to the collection names in the path
+ * This prevents the archived record from appearing in collectionGroup queries
+ * @param {RecordDocument} record
+ * @param {!string} record.refPath
+ * @returns {Promise}
+ */
+export async function archiveRecord(record) {
+  //split the reference path into it's constituent parts
+  const parts = record.refPath.split("/");
+  const partsCount = parts.length;
+  if (Math.floor(partsCount / 2) * 2 !== partsCount) {
+    //throw "safe" error
+    return; //returns a null promise resolved
+  }
+
+  let archivePath = "";
+  let index = 0;
+  //adde a "_" to the start of every collection named in the path
+  //this avoids collectionGroup issues, but follows a parallel path
+  do {
+    archivePath = `${archivePath}/_${parts[index]}/${parts[index + 1]}`;
+    index += 2;
+  } while (index < partsCount);
+  await runTransaction(async (batch) => {
+    //////////////////////////////
+    //Read a current full copy of the record
+    const realRecord = await fetchRecordByRefPath(record.refPath, batch);
+    //Write it to the "archivePath"
+    await writeBack({ ...realRecord, refPath: archivePath }, batch);
+    //delete the original copy
+    await deleteRecordByRefPath(realRecord.refPath, batch);
+  });
+}
+
+/**
+ * uses a passed refPath to create the most basic document record form
+ * @param {!string} refPath - "/" separated document path reference
+ * @returns {RecordDocument}
+ */
+export function refPathToBaseRecord(refPath) {
+  return {
+    Id: refPath.split("/").pop(),
+    refPath: refPath,
+  };
+}
+
+/**
+ * clips value to given bounds
+ * @param {number} value
+ * @param {number} lowerBound
+ * @param {number} upperBound
+ * @returns {number}
+ */
+export function bound(value, lowerBound, upperBound) {
+  return largerOf(lesserOf(value, upperBound), lowerBound);
+}
+
+/**
+ * function to push an element to an array which may not be initialized
+ * @param {Array.object} targetArray
+ * @param {object} newObject
+ * 
+ */
+export function blindPush(targetArray, newObject) {
+  targetArray
+  ? targetArray.push(newObject)
+  : (targetArray = [newObject]);
+  return targetArray;
+}
+
+/**
+ * @param {Array.Array.object} arrayObject
+ * @param {string} key key or index to choose which Array.object to add *this* object to
+ * @param {object} object
+ */
+export function addToArrayObject(arrayObject, key, object) {
+  if (arrayObject[key] && arrayObject[key].length) {
+    //if the key is already present, *and* there are already objects in the keyed array
+    arrayObject[key].push(object); //push the object onto the indexed array
+  } else {
+    arrayObject[key] = [object];
+  }
+}
+
+
+
+/**
+ * @param {string} color name of color
+ * @returns {string} hex value of named color
+ */
+export function makeHexAsNeeded(color) {
+  var colours = {
+    aliceblue: "#f0f8ff",
+    antiquewhite: "#faebd7",
+    aqua: "#00ffff",
+    aquamarine: "#7fffd4",
+    azure: "#f0ffff",
+    beige: "#f5f5dc",
+    bisque: "#ffe4c4",
+    black: "#000000",
+    blanchedalmond: "#ffebcd",
+    blue: "#0000ff",
+    blueviolet: "#8a2be2",
+    brown: "#a52a2a",
+    burlywood: "#deb887",
+    cadetblue: "#5f9ea0",
+    chartreuse: "#7fff00",
+    chocolate: "#d2691e",
+    coral: "#ff7f50",
+    cornflowerblue: "#6495ed",
+    cornsilk: "#fff8dc",
+    crimson: "#dc143c",
+    cyan: "#00ffff",
+    darkblue: "#00008b",
+    darkcyan: "#008b8b",
+    darkgoldenrod: "#b8860b",
+    darkgray: "#a9a9a9",
+    darkgreen: "#006400",
+    darkkhaki: "#bdb76b",
+    darkmagenta: "#8b008b",
+    darkolivegreen: "#556b2f",
+    darkorange: "#ff8c00",
+    darkorchid: "#9932cc",
+    darkred: "#8b0000",
+    darksalmon: "#e9967a",
+    darkseagreen: "#8fbc8f",
+    darkslateblue: "#483d8b",
+    darkslategray: "#2f4f4f",
+    darkturquoise: "#00ced1",
+    darkviolet: "#9400d3",
+    deeppink: "#ff1493",
+    deepskyblue: "#00bfff",
+    dimgray: "#696969",
+    dodgerblue: "#1e90ff",
+    firebrick: "#b22222",
+    floralwhite: "#fffaf0",
+    forestgreen: "#228b22",
+    fuchsia: "#ff00ff",
+    gainsboro: "#dcdcdc",
+    ghostwhite: "#f8f8ff",
+    gold: "#ffd700",
+    goldenrod: "#daa520",
+    gray: "#808080",
+    green: "#008000",
+    greenyellow: "#adff2f",
+    honeydew: "#f0fff0",
+    hotpink: "#ff69b4",
+    "indianred ": "#cd5c5c",
+    indigo: "#4b0082",
+    ivory: "#fffff0",
+    khaki: "#f0e68c",
+    lavender: "#e6e6fa",
+    lavenderblush: "#fff0f5",
+    lawngreen: "#7cfc00",
+    lemonchiffon: "#fffacd",
+    lightblue: "#add8e6",
+    lightcoral: "#f08080",
+    lightcyan: "#e0ffff",
+    lightgoldenrodyellow: "#fafad2",
+    lightgrey: "#d3d3d3",
+    lightgreen: "#90ee90",
+    lightpink: "#ffb6c1",
+    lightsalmon: "#ffa07a",
+    lightseagreen: "#20b2aa",
+    lightskyblue: "#87cefa",
+    lightslategray: "#778899",
+    lightsteelblue: "#b0c4de",
+    lightyellow: "#ffffe0",
+    lime: "#00ff00",
+    limegreen: "#32cd32",
+    linen: "#faf0e6",
+    magenta: "#ff00ff",
+    maroon: "#800000",
+    mediumaquamarine: "#66cdaa",
+    mediumblue: "#0000cd",
+    mediumorchid: "#ba55d3",
+    mediumpurple: "#9370d8",
+    mediumseagreen: "#3cb371",
+    mediumslateblue: "#7b68ee",
+    mediumspringgreen: "#00fa9a",
+    mediumturquoise: "#48d1cc",
+    mediumvioletred: "#c71585",
+    midnightblue: "#191970",
+    mintcream: "#f5fffa",
+    mistyrose: "#ffe4e1",
+    moccasin: "#ffe4b5",
+    navajowhite: "#ffdead",
+    navy: "#000080",
+    oldlace: "#fdf5e6",
+    olive: "#808000",
+    olivedrab: "#6b8e23",
+    orange: "#ffa500",
+    orangered: "#ff4500",
+    orchid: "#da70d6",
+    palegoldenrod: "#eee8aa",
+    palegreen: "#98fb98",
+    paleturquoise: "#afeeee",
+    palevioletred: "#d87093",
+    papayawhip: "#ffefd5",
+    peachpuff: "#ffdab9",
+    peru: "#cd853f",
+    pink: "#ffc0cb",
+    plum: "#dda0dd",
+    powderblue: "#b0e0e6",
+    purple: "#800080",
+    rebeccapurple: "#663399",
+    red: "#ff0000",
+    rosybrown: "#bc8f8f",
+    royalblue: "#4169e1",
+    saddlebrown: "#8b4513",
+    salmon: "#fa8072",
+    sandybrown: "#f4a460",
+    seagreen: "#2e8b57",
+    seashell: "#fff5ee",
+    sienna: "#a0522d",
+    silver: "#c0c0c0",
+    skyblue: "#87ceeb",
+    slateblue: "#6a5acd",
+    slategray: "#708090",
+    snow: "#fffafa",
+    springgreen: "#00ff7f",
+    steelblue: "#4682b4",
+    tan: "#d2b48c",
+    teal: "#008080",
+    thistle: "#d8bfd8",
+    tomato: "#ff6347",
+    turquoise: "#40e0d0",
+    violet: "#ee82ee",
+    wheat: "#f5deb3",
+    white: "#ffffff",
+    whitesmoke: "#f5f5f5",
+    yellow: "#ffff00",
+    yellowgreen: "#9acd32",
+  };
+
+  if (colours[color.toLowerCase()]) return colours[color.toLowerCase()];
+  return color;
+}
+
+export * from "./promise-queue";

package/business/Utilities/promise-queue/index.js

@@ -0,0 +1,231 @@
+/**
+ * Typedefs, constants, support functions and database operations related to Promise getQueueSize
+ * Thes era euseful for scheduling large serial asynchronous operations
+ * @module PromiseQueue
+ */
+(function () {
+  /**
+   * Creates a new rate limited queue. The queue is created with stopped state, i.e. you have to call start() to run jobs.
+   * @param {number} maxCallsPerSecond=1 - The rate limit of this queue in maximum calls per seconds which may be executed at any time. Pass values less than 1 to have less than one call per second, e.g. 1/3 for 3 one call in three seconds at maximum.
+   * @param logger
+   * @constructor
+   */
+  function PromiseQueue(maxCallsPerSecond, logger) {
+    this.maxCallsPerSecond =
+      typeof maxCallsPerSecond === "undefined" ? 1 : maxCallsPerSecond;
+    this.logger = logger;
+
+    this.tasks = [];
+    this.isActive = false;
+    this.jobIntervalMillis = 1000 / maxCallsPerSecond;
+
+    this.lastTaskTimestamp = null;
+    this.currentTaskTimeoutId = null;
+  }
+
+  /**
+   * Processes the next task and returns the id of the time used to wait for the next invocation of this method.
+   * @private
+   */
+  PromiseQueue.prototype.updateTaskSchedule = function () {
+    if (this.logger && this.logger.debug) {
+      this.logger.debug("PromiseQueue.updateTaskSchedule");
+    }
+
+    if (this.isEmpty() || this.isStopped()) {
+      return;
+    }
+
+    const queue = this;
+
+    function processNextTask() {
+      if (queue.logger && queue.logger.debug) {
+        queue.logger.debug("PromiseQueue.processNextTask", queue.tasks.length);
+      }
+
+      var nextTaskItem = queue.tasks.shift();
+      if (nextTaskItem) {
+        try {
+          const result = nextTaskItem.task.call();
+
+          if (queue.logger && queue.logger.debug) {
+            queue.logger.debug(
+              "Resolving queued promise",
+              result,
+              result instanceof Promise
+            );
+          }
+
+          nextTaskItem.resolve(result);
+        } catch (e) {
+          queue.logger.info("rejecting queued promise result", e);
+          nextTaskItem.reject(e);
+        }
+      }
+    }
+
+    function scheduleNext(timeoutMillisOverride) {
+      if (queue.logger && queue.logger.debug) {
+        queue.logger.debug("PromiseQueue.scheduleNext", timeoutMillisOverride);
+      }
+
+      if (queue.isEmpty()) {
+        queue.currentTaskTimeoutId = null;
+        return;
+      }
+
+      queue.currentTaskTimeoutId = setTimeout(function () {
+        queue.lastTaskTimestamp = Date.now();
+        processNextTask();
+
+        scheduleNext(queue.jobIntervalMillis);
+      }, timeoutMillisOverride);
+    }
+
+    if (this.currentTaskTimeoutId == null) {
+      if (this.lastTaskTimestamp) {
+        let passedTime = Date.now() - this.lastTaskTimestamp;
+        if (passedTime > this.jobIntervalMillis) {
+          scheduleNext(this.jobIntervalMillis);
+        } else {
+          scheduleNext(Math.max(0, this.jobIntervalMillis - passedTime));
+        }
+      } else {
+        scheduleNext(0);
+      }
+    }
+  };
+
+  /**
+   * Starts the task processing of this queue.
+   *
+   * If it is already started, then false will be returned.
+   * If it is not yet started then the first task will be processed in the background and true will be returned.
+   *
+   * @return {boolean} true if this queue wasn't started before and now started to process tasks.
+   */
+  PromiseQueue.prototype.start = function () {
+    if (this.isActive) {
+      return false;
+    }
+
+    this.isActive = true;
+
+    this.updateTaskSchedule();
+
+    return true;
+  };
+
+  /**
+   * Stops the processing of this queue.
+   * @return true if the queue was started and is now stopped. false if it was already stopped.
+   */
+  PromiseQueue.prototype.stop = function () {
+    if (this.isActive) {
+      this.isActive = false;
+
+      if (this.currentTaskTimeoutId) {
+        clearInterval(this.currentTaskTimeoutId);
+        this.currentTaskTimeoutId = null;
+        this.lastTaskTimestamp = null;
+      }
+    }
+  };
+
+  PromiseQueue.prototype.getMaxCallsPerSecond = function () {
+    return this.maxCallsPerSecond;
+  };
+
+  PromiseQueue.prototype.isStarted = function () {
+    return this.isActive;
+  };
+
+  PromiseQueue.prototype.isStopped = function () {
+    return !this.isStarted();
+  };
+
+  /**
+   * @returns {boolean} true if this queue is currently empty, i.e. if it has no tasks in the queue.
+   */
+  PromiseQueue.prototype.isEmpty = function () {
+    return this.tasks.length === 0;
+  };
+
+  /**
+   * @returns {boolean} true if this queue has one or more entries.
+   */
+  PromiseQueue.prototype.isNotEmpty = function () {
+    return !this.isEmpty();
+  };
+
+  /**
+   * @param {function} task - The task to add.
+   * @param {boolean} append - if the task should be appended or prepended to the list of queued tasks
+   * @return {Promise} A promise which is resolved/rejected when the task was executed by the queue.
+   */
+  PromiseQueue.prototype.add = function (task, append) {
+    var self = this;
+
+    var promise = new Promise(function (resolve, reject) {
+      var newTaskItem = { task: task, resolve: resolve, reject: reject };
+
+      if (self.isEmpty() || append) {
+        self.tasks.push(newTaskItem);
+      } else {
+        self.tasks.unshift(newTaskItem);
+      }
+    });
+
+    self.updateTaskSchedule();
+
+    return promise;
+  };
+
+  /**
+   * Appends a new task at the end of the queue.
+   * @param {function} task - The task to perform. This function will be called with no arguments.
+   * @return {Promise} A promise which is resolved/rejected When the task was executed by the queue
+   */
+  PromiseQueue.prototype.append = function (task) {
+    return this.add(task, true);
+  };
+
+  /**
+   * Adds a new task as first item in the queue.
+   * @param task
+   * @return {Promise} A promise which is resolved/rejected When the task was executed by the queue
+   */
+  PromiseQueue.prototype.prepend = function (task) {
+    return this.add(task, false);
+  };
+
+  /**
+   * Removes the task from the qeueue. If the task is contained more than one time then all occurrences will be removed.
+   * @param {function} task - The task to remove.
+   * @return {number} - The number of items which were removed.
+   */
+  PromiseQueue.prototype.remove = function (task) {
+    if (this.isEmpty()) {
+      return 0;
+    }
+
+    var removedItems = 0;
+    for (var i = this.tasks.length - 1; i >= 0; i--) {
+      if (this.tasks[i].task === task) {
+        this.tasks.splice(i, 1);
+        removedItems++;
+      }
+    }
+
+    return removedItems;
+  };
+
+  /**
+   * @returns {Number} - The number of queued/waiting tasks in the queue.
+   */
+  PromiseQueue.prototype.getQueueSize = function () {
+    return this.tasks.length;
+  };
+
+  module.exports = PromiseQueue;
+})();