@leaddreamer/inventorylogic 0.0.3-beta.0

package/business/Markups/index.js

@@ -0,0 +1,183 @@
+/**
+ * Typedefs, constants, support functions and database operations related to product creation stages
+ * users
+ * @module Markups
+ */
+import { updateRecord } from "@leaddreamer/firebase-wrapper";
+import { Forms, fillForm } from "@leaddreamer/staticforms";
+
+import { MARKUPS, STAGE, FABRICATION, WHOLESALE, RETAIL, BASE, HIGHVALUE, SERVICE, MATERIAL } from "../boilerplate";
+
+//////////////////////////////////////////////////////////////////////
+// Constants
+/**
+ * Database Structure
+ * Product or User or Fundamentals (document)
+ * \-> Markups (collection)
+ *     \-> [ParentId] (sole document)
+ *         \-> [Stage Name(s)] (field, object)
+ *             \-> [Material Name(s)] (field, value [Markup])
+ */
+/**
+ * @typedef {number} Markup
+ * @typedef {"base"|"highValue"|"service"} MaterialLevels
+ * @typedef {"fabrication"|"wholesale"|"retail"} StageLevels
+ * @typedef {Object.<MaterialLevels, Markup>} Material
+ * @typedef {Object.<StageLevels, Material>} Markups
+ */
+
+/**
+ * @readonly
+ * @constant
+ * @type {Material}
+ * @default
+ */
+const MaterialDefault = {
+  [BASE]: 1.0,
+  [HIGHVALUE]: 1.0,
+  [SERVICE]: 1.0,
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Markups}
+ * @default
+ */
+const MarkupsDefault = {
+  [FABRICATION]: {
+    [BASE]: 1.0,
+    [HIGHVALUE]: 1.0,
+    [SERVICE]: 1.0,
+  },
+  [WHOLESALE]: {
+    [BASE]: 1.0,
+    [HIGHVALUE]: 1.0,
+    [SERVICE]: 1.0,
+  },
+  [RETAIL]: {
+    [BASE]: 1.0,
+    [HIGHVALUE]: 1.0,
+    [SERVICE]: 1.0,
+  },
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Material}
+ * @default
+ */
+const MaterialDefaultForm = {
+  [BASE]: "number",
+  [HIGHVALUE]: "number",
+  [SERVICE]: "number",
+};
+
+/**
+ * @readonly
+ * @constant
+ * @type {Stage}
+ * @default
+ */
+const MarkupsDefaultForm = {
+  [FABRICATION]: `subrecord:${MATERIAL}`,
+  [WHOLESALE]: `subrecord:${MATERIAL}`,
+  [RETAIL]: `subrecord:${MATERIAL}`,
+};
+
+Forms.Base[MATERIAL] = MaterialDefaultForm;
+Forms.BaseForm[MATERIAL] = MaterialDefaultForm;
+Forms.CreateForm[MATERIAL] = MaterialDefaultForm;
+//Forms.Save[MATERIAL] = updateMaterial;
+Forms.SearchBy[MATERIAL] = MATERIAL;
+
+Forms.Base[MARKUPS] = MarkupsDefault;
+Forms.BaseForm[MARKUPS] = MarkupsDefaultForm;
+Forms.CreateForm[MARKUPS] = MarkupsDefaultForm;
+Forms.Save[MARKUPS] = updateMarkups;
+
+/**
+ * @readonly
+ * @constant
+ * @default
+ * 
+ */
+export const MaterialChoices = {
+  [BASE]: {
+    Id: BASE,
+    label: BASE,
+    description: "Base",
+    order: 1,
+  },
+  [HIGHVALUE]: {
+    Id: HIGHVALUE,
+    label: HIGHVALUE,
+    description: "High Value",
+    order: 2,
+  },
+  [SERVICE]: {
+    Id: SERVICE,
+    label: SERVICE,
+    description: "Service",
+    order: 3,
+  },
+};
+
+/**
+ * @readonly
+ * @constant
+ * @default
+ */
+export const StageChoices = {
+  [FABRICATION]: {
+    Id: FABRICATION,
+    label: FABRICATION,
+    description: "Fabrication Stage",
+    order: 1,
+  },
+  [WHOLESALE]: {
+    Id: WHOLESALE,
+    label: WHOLESALE,
+    description: "Wholesale Stage",
+    order: 2,
+  },
+  [RETAIL]: {
+    Id: RETAIL,
+    label: RETAIL,
+    description: "Retail Stage",
+    order: 3,
+  },
+};
+
+/**
+ * @readonly
+ * @constant
+ * @default
+ */
+Forms.Choices[STAGE] = StageChoices;
+
+/**
+ * @readonly
+ * @constant
+ * @default
+ */
+Forms.Choices[MATERIAL] = MaterialChoices
+
+//////////////////////////////////////////////////////////////////////
+// record operations
+/**
+ * writes record back to database.  Assumes only Id is valid
+ * @param {LineItem} stage a partially-populated product record for updates
+ * @param {Record} parent minimal record of product, user (or none) this stage belongs to
+ * @returns {promise.LineItem} a copy of the data written
+ */
+async function updateMarkups(markups, parent = null) {
+  return updateRecord(
+    fillForm(markups, MARKUPS), //saves only APPROPRIATE fields -does NOT populate missing fields
+    parent,
+    MARKUPS
+  );
+}
+
+

package/business/Payment/index.js

@@ -0,0 +1,516 @@
+/**
+ * "Payment Descriptor" handling operations.  These descriptors represent paymentMethods, each tied
+ * to an individual user.  These do not *particularly* represent a paymentProvider - they are meant
+ * as an abstraction above a specific payment processor.
+ * @module Payment
+ */
+import {
+  typedWrite,
+  writeBack,
+  fetchRecord,
+  collectRecords,
+  collectRecordsByFilter,
+  deleteRecord,
+  ownerByChild,
+  ownerByOwnerType,
+  serverTimestampFieldValue,
+} from "@leaddreamer/firebase-wrapper";
+
+import { Forms, cleanType } from "@leaddreamer/staticforms";
+import { PAYMENT, RECEIPTS, CARDS } from "../boilerplate";
+
+//////////////////////////////////////////////////////////////////////
+// definitions
+/**
+ * @constant
+ * @type {{CARD_ERROR: string, VALIDATION_ERROR: string}}
+ * @default
+ */
+export const ERROR_TYPES = {
+  CARD_ERROR: `card_error`,
+  VALIDATION_ERROR: `validation_error`,
+};
+
+/**
+ * @typedef {object} PaymentData
+ * @property {string} Id
+ * @property {string} payment_gateway
+ * @property {string} status
+ */
+/**
+ * @constant
+ * @type {PaymentData}
+ * @default
+ */
+export const PaymentDefault = {
+  Id: null,
+  payment_gateway: null,
+  status: null,
+};
+
+/**
+ * @typedef {object} PaymentDescriptorType
+ * @property {!string} Id document Id of this Card Descriptor (same as fingerprint)
+ * @property {!string} paymentMethod Id of payment system card item
+ * @property {!string} fingerprint Unique hash of card info - for checking uniqueness
+ * @property {!string} label Brand & last4, or other descriptive
+ * @property {!string} expiry expiry date of payment method (if any)
+ * @property {timestamp} timestamp last create or modify server time
+ */
+/**
+ * @typedef {object} PDSummary
+ * @property {!string} Id document Id of this Card Descriptor
+ * @property {!string} label Brand & last4, or other descriptive
+ */
+/**
+ * @constant
+ * @type {PaymentDescriptorType}
+ * @default
+ */
+export const paymentDescriptor = {
+  Id: null,
+  paymentMethod: null,
+  fingerprint: null,
+  label: null,
+  nickname: null,
+};
+
+/**
+ * @typedef {object}  ReceiptType
+ * @property {!string} Id same Id as the associated pledgeTicket
+ * @property {!number} amount
+ * @property {object} payment
+ * @property {!string} link Id of associated payment_intent
+ * @property {!string} paidQ string describing status
+ * @property {?string} description supplemental information
+ */
+/**
+ * @constant
+ * @type {ReceiptType}
+ * @default
+ */
+export const receiptDefault = {
+  Id: null, //pledgeTicketId for user receipts
+  amount: 0,
+  payment: {
+    link: null, //paymentIntentId
+    paidQ: null, //current status
+  },
+  description: null, //supplemental information
+};
+
+Forms.Base[PAYMENT] = PaymentDefault;
+
+//////////////////////////////////////////////////////////////////////
+// Utilities
+
+/**
+ * @typedef {UserObject} AccountObject
+ */
+
+/**
+ * Creates the Organization Payment information document
+ * @async
+ * @function
+ * @param {AccountObject} account
+ * @param {?WriteBatch|Transaction} batch batching object.  Transaction will be added to the batch
+ * @return {Promise<WriteBatch|Transaction|void>} WriteBatch, Transaction or Void
+ */
+export async function createPaymentRecord(account, batch = null) {
+  return typedWrite(
+    cleanType(account, PAYMENT), //sanitized data - unused fields added
+    account, //parent
+    PAYMENT, //type
+    batch,
+  );
+}
+
+/**
+ * Saves a payment data record to a given account (user)
+ * ALL OF fans, artists and venues save the payment data in the same collection
+ *  name under the parent, with the SAME Id as the parent
+ * PaymentData *COMES FROM* payement processor, and should INCLUDE the record Id and
+ * refPath
+ * @param {PaymentDataRecord} paymentData
+ */
+export async function savePaymentData(paymentData) {
+  //ALL OF fans, artists and venues save the payment data in the same collection
+  // name under the parent, with the SAME Id as the parent
+  return writeBack({
+    ...paymentData,
+  });
+}
+
+/**
+ * fetches a paymentData record from the database for an account
+ * ALL OF fans, artists and venues, etc save the payment data in the same collection
+ * name under the parent, with the SAME Id as the parent
+ * @param {AccountType} account
+ * @param {Promise.PaymentData} paymentData
+ */
+export async function fetchPayment(account) {
+  //payment data is saved under the same collection name for fans, artists
+  //and venues, with the parent ID
+  let payment_record = null;
+  try {
+    payment_record = await fetchRecord(PAYMENT, account.Id, account.refPath);
+  } catch (err) { }
+  return payment_record;
+}
+
+/**
+ * fetches a paymentData record from the database for an account when only accountID and type are known
+ * ALL OF fans, artists and venues save the payment data in the same collection
+ * name under the parent, with the SAME Id as the parent
+ * @param {!string} accountId
+ * @param {!string} type
+ * @param {Promise.PaymentData} paymentData
+ */
+export async function fetchPaymentByUser(accountId) {
+  return fetchPayment({
+    Id: accountId,
+    refPath: `${USER}/${accountId}`,
+  });
+}
+
+/**
+ * Adds a specific paymentDescriptor to an account payment data
+ * @param {AccountType} account
+ * @param {!string} account.Id
+ * @param {!string} account.refPath
+ * @param {PaymentDescriptorType} descriptor
+ * @param {!string} descriptor.paymentMethod
+ * @param {!string} descriptor.fingerprint
+ * @param {!string} descriptor.label
+ * @param {?WriteBatch|Transaction} batch batching object.  Transaction will be added to the batch
+ * @return {Promise.PaymentDescriptorType}
+ */
+export async function addPaymentDescriptor(account, descriptor, batch = null) {
+  return typedWrite(
+    {
+      ...descriptor,
+      timestamp: serverTimestampFieldValue,
+    },
+    {
+      //Payment documents BY DEFINITION have the same Id as the parent
+      refPath: `${account.refPath}/${PAYMENT}/${account.Id}`,
+    },
+    CARDS,
+    batch,
+  );
+}
+
+/**
+ * Saves a modified paymentDescriptor back to the database
+ * @param {PaymentDescriptorType} descriptor
+ * @param {!string} descriptor.Id
+ * @param {!string} descriptor.refPath
+ * @return {Promise.PaymentDescriptorType}
+ */
+export async function savePaymentDescriptor(descriptor) {
+  //BOTH fans, artists and venues save the payment data in the same collection
+  // name under the parent, with the SAME Id as the parent
+  return writeBack({
+    ...descriptor,
+    timestamp: serverTimestampFieldValue,
+  });
+}
+
+/**
+ * Removes a paymentDescriptor from an account's paymentData
+ * @param {AccountType} account
+ * @param {PaymentDescriptorType} descriptor
+ * @returns {Promise<void>}
+ */
+export async function removePaymentDescriptor(account, descriptor) {
+  //MASSIVE CAVEAT
+  //A paymentMethod *might* be removed with e same *fingerprint* as a current descriptor
+  //but is still a different *paymentMethod*.  PaymentDescriptors are unique on the fingerprint
+  //Therefore, we need to *first* confirm that is is the same, so...
+  //READ FIRST...
+  const existingPD = await fetchPDByFingerprint(
+    account,
+    descriptor.fingerprint,
+  );
+  //COMPARE PAYEMNTMETHOD, THEN DELETE IF NEEDED
+  return existingPD.paymentMethod === descriptor.paymentMethod
+    ? deleteRecord(
+      descriptor,
+      CARDS,
+      `/${account.refPath}/${PAYMENT}/${account.Id}`,
+    )
+    : Promise.resolve(null); //don't delete if not identical
+}
+
+/**
+ * fetch all customer card records IN OUR DATABASE (not payment database)
+ * @param {AccountType} account
+ * @param {!string} account.refPath
+ * @returns {Promise.Array.PaymentDescriptor}
+ *
+ */
+export async function fetchPaymentDescriptors(account) {
+  return collectRecords(CARDS, `${account.refPath}/${PAYMENT}/${account.Id}`);
+}
+
+/**
+ * fetch the front-end list of paymentDescriptors
+ * @param {AccountType} account
+ * @param {!string} account.Id
+ * @param {!string} account.refPath
+ * @return {Promise.Array.PDSummary}
+ */
+export async function listPDSummaries(account) {
+  const full = await fetchPaymentDescriptors(account);
+  return full.map((pd) => ({
+    Id: pd.Id,
+    label: pd.label,
+    nickname: pd.nickname,
+  }));
+}
+
+/**
+ * @param {AccountType} account
+ * @param {!string} account.Id
+ * @param {!string} account.refPath
+ * @returns {Promise.PaymentDescriptorType}
+ */
+export async function fetchLatestPDSummary(account) {
+  const sortArray = [
+    {
+      fieldRef: "timestamp",
+      dirStr: "desc",
+    },
+  ];
+
+  const shortlist = await collectRecordsByFilter(
+    CARDS,
+    `/${account.refPath}/${PAYMENT}/${account.Id}`,
+    null, //filterArray
+    sortArray,
+    1, //limit
+  );
+  const latest = shortlist?.[0];
+
+  return { Id: latest?.Id, label: latest?.label };
+}
+
+/**
+ * retreives a PD, given the account Id and Type
+ * @param {AccountType} account
+ * @param {!string} fingerprint
+ * @returns {Promise<PDSummary>}
+ */
+export async function fetchPDByFingerprint(account, fingerprint) {
+  return fetchRecord(
+    CARDS, //tableName
+    fingerprint, //Id/DocId
+    `/${account.refPath}/${PAYMENT}/${account.Id}`, //refPath
+  );
+}
+
+/**
+ * retreives a PD, given the account Id and Type
+ * @param {!string} accountId
+ * @param {!string} type
+ * @param {!string} fingerprint
+ * @returns {Promise<PDSummary>}
+ */
+export async function fetchPDByOwnerType(accountId, type, fingerprint) {
+  return fetchRecord(
+    CARDS, //tableName
+    fingerprint, //Id/DocId
+    `/${type}/${accountId}/${PAYMENT}/${accountId}`, //refPath
+  );
+}
+
+/**
+ * Copies a PDSummary tobe the new default (convenience function)
+ * @param {AccountType} account
+ * @param {?PDSummary}  PDSummary
+ * @returns {Promise.AccountObject}
+ */
+export async function replaceDefaultPDSummary(account, PDSummary = null) {
+  //if not passed a PaymentDescriptorType, use the latest available
+  const lastestPayment = await (PDSummary
+    ? Promise.resolve(PDSummary)
+    : fetchLatestPDSummary(account));
+  return writeBack({
+    ...account,
+    payment_method: lastestPayment,
+  });
+}
+
+//////////////////////////////////////////////////////////////////////
+//Receipt support
+
+/**
+ * Savess a Receipt to an account
+ * @param {AccountType} account
+ * @param {?ReceiptType}  receipt
+ * @param {?WriteBatch|Transaction} batch batching object.  Transaction will be added to the batch
+ * @returns {Promise.ReceiptType}
+ */
+export async function saveReceiptRecord(account, receipt, batch = null) {
+  return typedWrite(receipt, account, RECEIPTS, batch);
+}
+
+/**
+ * Updates a (changed?) Receipt record
+ * @param {?ReceiptType}  receipt
+ * @returns {Promise.ReceiptType}
+ */
+export async function updateReceipt(receipt) {
+  return writeBack(receipt);
+}
+
+/**
+ * Saves a new receipt to an account referrred by ID and type
+ * @param {!string} ownerId
+ * @param {string} type either ORGANIZATIONS or USER
+ * @param {ReceiptType} receipt
+ * @param {?WriteBatch|Transaction} batch batching object.  Transaction will be added to the batch
+ * @returns {Promise.ReceiptType}
+ */
+export async function saveReceiptRecordByOwnerType(
+  ownerId,
+  ownerType,
+  receipt,
+  batch = null,
+) {
+  return saveReceiptRecord(
+    ownerByOwnerType(ownerId, ownerType),
+    receipt,
+    batch,
+  );
+}
+
+/**
+ * Fetches an array of receipts in any particular month by monthStampt
+ * @param {AccountObject} account
+ * @param {dateString} monthStamp
+ * @returns {Promise.Array.ReceiptType}
+ */
+export async function anyReceiptsByMonthStamp(account, monthStamp) {
+  const filterArray = [
+    { fieldRef: "monthStamp", opStr: "==", value: monthStamp },
+  ];
+  try {
+    const receipts = await fetchReceiptsFiltered(account, filterArray);
+    return !!receipts.length; //true if more than zero
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Saves a receipt by a child record reference
+ * @param {RecordDocument} child
+ * @param {ReceiptType} receipt
+ * @param {?WriteBatch|Transaction} batch batching object.  Transaction will be added to the batch
+ * @returns {Promise.ReceiptType}
+ */
+export async function saveReceiptRecordByChild(child, receipt, batch = null) {
+  return saveReceiptRecord(ownerByChild(child), receipt, batch);
+}
+
+/**
+ * Fetches receipts based on a filter set
+ * @param {AccountObject} account
+ * @param {!string} account.refPath
+ * @param {Array.filterObject} filterArray
+ * @param {Array.sortObject} sortArray
+ * @param {number} limit
+ * @return {Promise.Array.ReceiptType}
+ */
+export async function fetchReceiptsFiltered(
+  account,
+  filterArray = null,
+  sortArray = null,
+  limit = null,
+) {
+  return collectRecordsByFilter(
+    RECEIPTS, //tablePath
+    account.refPath, //refPath
+    filterArray, //filter array
+    sortArray, //sort Array
+    limit, //limit
+  );
+}
+
+/**
+ * @param {AccountObject} account
+ * @param {!string} account.refPath
+ * @param {!string} receiptId
+ * @return {Promise.ReceiptType}
+ */
+async function fetchReceipt(account, receiptId) {
+  return fetchRecord(RECEIPTS, receiptId, account.refPath);
+}
+
+/**
+ * @param {AccountObject} account
+ * @param {!string} account.refPath
+ * @return {Promise.Array.ReceiptType}
+ */
+export async function fetchProblemReceipts(account) {
+  //const in_status_array = [
+  //`requires_payment_method`,
+  //`requires_confirmation`,
+  //`requires_action`,
+  //`processing`,
+  //`requires_capture`,
+  //`canceled`,
+  //`succeeded`,
+  //`none`
+  //];
+  const not_in_status_array = [`succeeded`, `none`];
+  const filterArray = [
+    { fieldRef: "payment.paidQ", opStr: "not-in", value: not_in_status_array },
+  ];
+  return fetchReceiptsFiltered(account, filterArray, null, null);
+}
+
+/**
+ * Fetches the receipt for a pledgeTicket
+ * @param {PledgeTicket} pledgeTicket
+ * @returns {Promise.ReceiptType}
+ */
+export async function fetchPledgeTicketReceipt(pledgeTicket) {
+  const account = {
+    Id: pledgeTicket.fan.Id,
+    refPath: `/${USER}/${pledgeTicket.fan.Id}`,
+  };
+  const receiptId = pledgeTicket.Id;
+  return fetchReceipt(account, receiptId);
+}
+
+/**
+ * Changes the paidQ label on a receipt associated with a pledgeTicket
+ * @param {pledgeTicketType} pledgeTicket
+ * @param {?string} label
+ * @returns {Promise.ReceiptType}
+ */
+export async function markReceiptFromPledgeTicket(pledgeTicket, label) {
+  const receipt = await fetchPledgeTicketReceipt(pledgeTicket);
+  return markReceipt(receipt, label);
+}
+
+/**
+ * Changes the paidQ label on a receipt associated with a pledgeTicket
+ * @param {receiptType} receipt
+ * @param {?string} label
+ * @returns {Promise.ReceiptType}
+ */
+export async function markReceipt(receipt, label) {
+  return updateReceipt({
+    ...receipt,
+    payment: {
+      ...receipt.payment,
+      paidQ: label,
+    },
+  });
+}
+
+//////////////////////////////////////////////////////////////////////
+// utilities