@leaddreamer/inventorylogic 0.0.3-beta.0

package/business/Commodities/index.js

@@ -0,0 +1,240 @@
+/**
+ * Typedefs, constants, support functions and database operations related to Commodity Matrials
+ * users
+ * @module Commodities
+ */
+import {
+  writeRecord,
+  writeBack,
+  updateRecord,
+  fetchRecord,
+  collectRecords,
+  deleteRecord,
+  PaginateFetch,
+} from "@leaddreamer/firebase-wrapper";
+import { Forms, fillForm } from "@leaddreamer/staticforms";
+
+import { UNITS, MATERIAL, COMMODITIES, COMMODITY, COMPONENT_RANGE } from "../boilerplate";
+
+//////////////////////////////////////////////////////////////////////
+// Constants
+
+/**
+ * a record
+ * @typedef {object} Commodity
+ * @property {?string} Id Id of document (redundant for convenience)
+ * @property {?string} refPath if from database, full path to document
+ * @property {!string} description description, e.g. "Wire, Silver, Sterling, 20ga"
+ * @property {!string} unit usage/measurement unit (for unit conversion)
+ * @property {!number} rate the per unit cost of this commodity
+ * @property {string} MATERIAL "base", "highValue" or other value tp be defined
+ * @property {?url} image a reference image for the commodity
+ */
+
+/**
+ * @readonly
+ * @constant
+ * @type {Commodity}
+ * @default
+ */
+const CommodityDefault = {
+  Id: null,
+  refPath: null,
+  description: null,
+  unit: null,
+  rate: 0,
+  [MATERIAL]: null,
+  image: null,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Commodity}
+ * @default
+ */
+const CommodityData = {
+  Id: `string.uuid`,
+  refPath: null,
+  description: `commerce.productDescription`,
+  unit: `lookup:${UNITS}`,
+  rate: `commerce.price:${COMPONENT_RANGE}`,
+  [MATERIAL]: `lookup:${MATERIAL}`,
+  image: null,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Commodity}
+ * @default
+ */
+const CommodityDefaultForm = {
+  description: "text",
+  unit: `lookup:${UNITS}`,
+  rate: "number",
+  [MATERIAL]:`lookup:${MATERIAL}`,
+  image: "url",
+};
+
+Forms.Base[COMMODITIES] = CommodityDefault;
+Forms.BaseForm[COMMODITIES] = CommodityDefaultForm;
+Forms.CreateForm[COMMODITIES] = CommodityDefaultForm;
+Forms.Data[COMMODITIES] = CommodityData;
+Forms.Summarize[COMMODITIES] = summarizeCommodity;
+Forms.Save[COMMODITIES] = updateCommodity;
+Forms.SearchBy[COMMODITIES] = "description";
+
+//////////////////////////////////////////////////////////////////////
+// record operations
+/**
+ * @param {CommodityDefault} commodity
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise<void>}
+ */
+export async function deleteCommodity(commodity, user = null) {
+  return deleteRecord(commodity, COMMODITY, user?.refPath);
+}
+
+/**
+ * @param {CommodityDefault} commodity minimal record of user account
+ * @param {!string} commodity.Id record Id of account
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise<void>}
+ */
+export async function deleteCommodityById(commodity, user = null) {
+  if (!commodity?.Id) return;
+
+  return deleteRecord(commodity, COMMODITY, user?.refPath);
+}
+
+/**
+ * @param {Commodity} commodity minimal record of user account
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise.Commodity}
+ */
+export const createCommodity = (commodity, user = null) => {
+  //need a "no duplicate" function - whatever that means in this context
+  return writeRecord(COMMODITY, commodity, user?.refPath);
+};
+
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {Commodity} commodity a partially-populated commodity record for updates
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {promise.Commodity} a copy of the data written
+ */
+export async function updateCommodityByID(commodity, parent = null) {
+  // will update just the fields provided
+  return writeBack({
+    ...commodity,
+    refPath: `${parent?.refPath}/${COMMODITY}/${commodity.Id}`,
+  });
+}
+
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {Commodity} commodity a partially-populated commodity record for updates
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {promise.Commodity} a copy of the data written
+ */
+export async function updateCommodity(commodity, user = null) {
+  
+  return updateRecord(
+    fillForm(commodity, COMMODITY), //saves only APPROPRIATE fields -does NOT populate missing fields
+    user,
+    COMMODITY
+  );
+}
+
+//////////////////////////////////////////////////////////////////////
+// fetches
+
+/**
+ * Checks if this is a known Commodity Id
+ * @param {!string} Id Id value to check
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise.boolean} true is this Id is in database
+ */
+export async function knownCommodity(Id, user = null) {
+  let exists = true;
+  try {
+    await fetchCommodity(Id);
+  } catch (err) {
+    exists = false;
+  }
+  return exists;
+}
+
+//////////////////////////////////////////////////////////////////////
+// fetches
+
+/**
+ * Fetches ALL Commodity records.  Not very useful
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Array.Commodity}
+ */
+export async function fetchCommodities(user = null) {
+  return collectRecords(COMMODITY, user?.refPath);
+}
+
+/**
+ * An object to allow for paginating a table read from Firestore. REQUIRES a sorting choice
+ * @typedef {object} PaginatedFetch
+ * @property {Query} Query that forms basis for the table read
+ * @property {number} limit page size
+ * @property {QuerySnapshot} snapshot last successful snapshot/page fetched
+ * @property {enum} status status of pagination object
+ * @property {method} PageForward pages the fetch forward
+ * @property {method} PageBack pages the fetch backward
+
+ */
+
+/**
+ * Fetchs an object to fetch pages of commodity data, ascending by name, "limit" at a time
+ * @param {number} limit
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {PaginatedFetch} object with pagination methods
+ */
+
+export async function fetchCommoditiesPaginated(limit, user = null) {
+  return new PaginateFetch(
+    COMMODITY,
+    null, //filter
+    [{ fieldRef: "description", dirStr: "asc" }], //sort
+    user?.refPath, //ref
+    limit,
+  );
+}
+
+/**
+ * Fetches a single Commodity record by Id
+ * @param {!string} commodityId
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise.Commodity}
+ */
+export async function fetchCommodity(commodityId, user = null) {
+  return fetchRecord(COMMODITY, commodityId, user?.refPath);
+}
+
+/**
+ * Fetches and returns the summarized name from a Commodity record
+ * @param {!string} commodityId
+ * @param {UserObject} user minimal record of user this commodity belongs to (if any)
+ * @returns {Promise.string} the summarized name from the record
+ */
+export async function fetchCommodityName(commodityId, user = null) {
+  const commodity = await fetchCommodity(commodityId, user);
+  return summarizeCommodity(commodity);
+}
+
+//////////////////////////////////////////////////////////////////////
+// utilities
+/**
+ * Returns a standardized formatted name string
+ * @param {Commodity}
+ * @returns {string} formatted name string
+ */
+function summarizeCommodity(commodity) {
+  return `${commodity?.description}`;
+}

package/business/LineItem/index.js

@@ -0,0 +1,328 @@
+/**
+ * Typedefs, constants, support functions and database operations related to LineItem Matrials
+ * users
+ * @module LineItem
+ */
+import {
+  writeRecord,
+  updateRecord,
+  fetchRecord,
+  collectRecordsByFilter,
+  deleteRecord,
+  PaginateFetch,
+} from "@leaddreamer/firebase-wrapper";
+import { Forms, fillForm } from "@leaddreamer/staticforms";
+
+import {
+  COMMODITY,
+  LINEITEM,
+  STAGE,
+  MATERIAL,
+  UNITS,
+  COMPONENT_RANGE,
+  COMPONENT_COUNT_RANGE,
+} from "../boilerplate";
+import {StageLevels, MaterialLevels} from "../Markups";
+
+//////////////////////////////////////////////////////////////////////
+// Constants
+
+/**
+ * a record
+ * @typedef {object} LineItem
+ * @property {string} Id Id of document (redundant for convenience)
+ * @property {string} refPath if from database, full path to document
+ * @property {StageLevels} STAGE "fabrication", "wholesale", "retail" or other to be defined
+ * @property {MaterialLevels} MATERIAL "base", "highValue", "service" or other value to be defined
+ * @property {null|string} commodity Id of a commodity item/material (optional)
+ * @property {string|null} description description, e.g. "Wire, Silver, Sterling, 20ga"
+ *                          //can be overwritten by commodity
+ * @property {string|null} unit usage/measurement unit (for unit conversion)
+ *                          //can be overwritten by commodity
+ * @property {number} rate the per unit cost of this lineItem
+ *                          //can be overwritten by commodity
+ * @property {number} amount amount of material/item useed
+ * @property {datetime} timestamp initial time of creation for sorting
+ * @property {url|null} image a reference image for the lineItem
+ */
+/**
+ * Default/Blank Form for LineItem data records
+ * @readonly
+ * @constant
+ * @type {LineItem}
+ * @default
+ */
+const LineItemDefault = {
+  Id: null,
+  refPath: null,
+  [STAGE]: null,
+  [MATERIAL]: null,
+  commodity: null,
+  description: null,
+  unit: null,
+  rate: 0,
+  count: 0,
+  image: null,
+};
+
+/**
+ * Form for generating placeholder LineItem data.
+ * @readonly
+ * @constant
+ * @type {LineItem}
+ * @default
+ */
+const LineItemData = {
+  Id: `string.uuid`,
+  refPath: null,
+  [STAGE]: `lookupChoices:${STAGE}`,
+  [MATERIAL]: `lookupChoices:${MATERIAL}`,
+  commodity: `lookupLevels:${COMMODITY}`,
+  description: `commerce.productDescription`,
+  count: `number.int:${COMPONENT_COUNT_RANGE}`,
+  unit: `lookupLink:units`,
+  rate: `commerce.price:${COMPONENT_RANGE}`,
+  line_total: `commerce.price:${COMPONENT_RANGE}`,
+  image: null,
+};
+
+/**
+ * Form for driving an Editor form for LineItem Data
+ * @readonly
+ * @constant
+ * @type {LineItem}
+ * @default
+ */
+const LineItemDefaultForm = {
+  [STAGE]: `lookupChoices:${STAGE}`,
+  [MATERIAL]: `lookupChoices:${MATERIAL}`,
+  commodity: `lookupLevels:${COMMODITY}`,
+  description: `text`,
+  count: `number`,
+  unit: `lookupLink:${UNITS}`,
+  rate: `number`,
+  line_total: `lineSum`,
+  image: `url`,
+};
+
+Forms.Base[LINEITEM] = LineItemDefault;
+Forms.BaseForm[LINEITEM] = LineItemDefaultForm;
+Forms.CreateForm[LINEITEM] = LineItemDefaultForm;
+Forms.Data[LINEITEM] = LineItemData;
+Forms.Summarize[LINEITEM] = summarizeLineItem;
+Forms.Save[LINEITEM] = updateLineItem;
+Forms.SearchBy[LINEITEM] = "description";
+Forms.LineSum[LINEITEM] = lineItem_lineSum; //FUNCTION
+Forms.UpdateChange[LINEITEM] = UpdateChange;
+
+
+//////////////////////////////////////////////////////////////////////
+// record operations
+/**
+ * deletes a lineItem.  Product required if lineItem is missing refPath
+ * from database
+ * @param {LineItemDefault} lineItem lineItem record
+ * @param {!string} lineItem.Id at least Id is required to identify record
+ * @param {string|null} lineItem.refPath refpath will be used if present
+ * @param {Product|null} product
+ * @returns {Promise<void>}
+ */
+export async function deleteLineItem(lineItem, product = null) {
+  return deleteRecord(lineItem, LINEITEM, product?.refPath);
+}
+
+/**
+ * @param {LineItemDefault} lineItem minimal record of lineItem in question
+ * @param {!string} lineItem.Id record Id of account
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @param {!string} product.refPath required as a minimum
+ * @returns {Promise<void>}
+ */
+export async function deleteLineItemById(lineItem, product) {
+  if (!lineItem?.Id) return;
+
+  return deleteRecord(lineItem, LINEITEM, product?.refPath);
+}
+
+/**
+ * @param {LineItem} lineItem minimal record of user account
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @returns {Promise.LineItem}
+ */
+export const createLineItem = (lineItem) => {
+  //need a "no duplicate" function - whatever that means in this context
+  return writeRecord(LINEITEM, lineItem, product.refPath);
+};
+
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {LineItem} lineItem a partially-populated lineItem record for updates
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @returns {promise.LineItem} a copy of the data written
+ */
+async function updateLineItem(lineItem, product = null) {
+  if (!(lineItem?.refPath || product?.refPath)) {
+    console.log("no product specified to save LineItem");
+    //no root lineItems
+    return null;
+  };
+
+
+  return updateRecord(
+    fillForm(lineItem, LINEITEM), //saves only APPROPRIATE fields -does NOT populate missing fields
+    product,
+    LINEITEM
+  );
+}
+
+//////////////////////////////////////////////////////////////////////
+// fetches
+
+/**
+ * Checks if this is a known LineItem Id
+ * @param {!string} Id Id value to check
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @returns {Promise.boolean} true is this Id is in database
+ */
+export async function knownLineItem(Id, product) {
+  let exists = true;
+  try {
+    await fetchLineItem(Id, product);
+  } catch (err) {
+    exists = false;
+  }
+  return exists;
+}
+
+//////////////////////////////////////////////////////////////////////
+// fetches
+
+/**
+ * Fetches ALL LineItem records.  Not very useful
+ * @returns {Array.LineItem}
+ */
+export async function fetchLineItems() {
+  return collectRecordsInGroup(LINEITEM);
+}
+
+/**
+ * Fetches ALL LineItem records for a specific product.  Not very useful
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @param {?Stage} stage optional stage selection, to get a subset of the line items
+ * @returns {Array.LineItem}
+ */
+export async function fetchProductLineItems(product, stage = null) {
+  const filterArray = stage
+    ? [{ fieldRef: "stage", opStr: "==", value: stage.name }]
+    : null;
+  return collectRecordsByFilter(
+    LINEITEM, //table
+    product.refPath, //refPath
+    filterArray, //filterArray
+    null, //sort
+  );
+}
+
+/**
+ * An object to allow for paginating a table read from Firestore. REQUIRES a sorting choice
+ * @typedef {object} PaginatedFetch
+ * @property {Query} Query that forms basis for the table read
+ * @property {number} limit page size
+ * @property {QuerySnapshot} snapshot last successful snapshot/page fetched
+ * @property {enum} status status of pagination object
+ * @property {method} PageForward pages the fetch forward
+ * @property {method} PageBack pages the fetch backward
+ 
+ */
+
+/**
+ * Fetchs an object to fetch pages of lineItem data, ascending by name, "limit" at a time
+ * NOT a "listener"
+ * @param {Product} product
+ * @param {?Stage} stage optional stage selection, to get a subset of the line items
+ * @param {number} limit
+ * @returns {PaginatedFetch} object with pagination methods
+ */
+
+export async function paginateProductLineItems(
+  product,
+  stage = null,
+  limit = null,
+) {
+  const filterArray = stage
+    ? [{ fieldRef: "stage", opStr: "==", value: stage.name }]
+    : null;
+
+  return new PaginateFetch(
+    LINEITEM,
+    filterArray, //filter
+    [{ fieldRef: "timestamp", dirStr: "asc" }], //sort
+    product.refPath, //ref
+    limit,
+  );
+}
+
+/**
+ * Fetches a single LineItem record by Id
+ * @param {!string} lineItemId
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @returns {Promise.LineItem}
+ */
+export async function fetchLineItem(lineItemId, product) {
+  return fetchRecord(LINEITEM, lineItemId, product.refPath);
+}
+
+/**
+ * Fetches and returns the summarized name from a LineItem record
+ * @param {!string} lineItemId
+ * @param {Product} product minimal record of product this lineItem belongs to
+ * @returns {Promise.string} the summarized name from the record
+ */
+export async function fetchLineItemName(lineItemId, product) {
+  const lineItem = await fetchLineItem(lineItemId, product);
+  return summarizeLineItem(lineItem);
+}
+
+//////////////////////////////////////////////////////////////////////
+// utilities
+/**
+ * Returns a standardized formatted name string
+ * @param {LineItem}
+ * @returns {string} formatted name string
+ */
+function summarizeLineItem(lineItem) {
+  return `${lineItem?.description}`;
+}
+
+/**
+ * calculates line-sums for display in reactdatagrid tables
+ * @param {CustomRenderProps} customRenderProps
+ * @returns {number | string} for display
+ */
+
+/**
+ * Calculates the lineSum (total) for a lineItem
+ * @param {object} lineItem 
+ * @param {?number} lineItem.rate
+ * @param {?number} lineItem.count
+ * @returns {number}
+ */
+function lineItem_lineSum(lineItem) {
+  return lineItem?.rate * lineItem?.count;
+}
+
+/**
+ * checks for cross-dependencies - in this case, adjusting the "count" if the UNIT changes
+ * @param {object} prev
+ * @param {object} value
+ * @param {string} itemFor
+ * @param {object} fullChoiceObject
+ * @returns {object}
+ */
+function UpdateChange(prevItem, newValue, itemFor, fullChoiceObject) {
+  console.log("LineItem UpdateChange", prevItem, newValue, itemFor, fullChoiceObject);
+  return {
+    ...prevItem,
+    [itemFor]: value
+  }
+}