@tamu-dor/famis-db 3.0.0-beta.1

package/dist/main.js

@@ -0,0 +1,2141 @@
+import knex from 'knex';
+import { createId } from '@paralleldrive/cuid2';
+import awaity from 'awaity';
+import revisionHash from 'rev-hash';
+import { attachPaginate } from 'knex-paginate';
+import 'knex-with-relations';
+
+attachPaginate();
+const systemPartFields = [
+  "id",
+  "name",
+  "due",
+  "fein",
+  "agency",
+  "checkAddress",
+  "credit",
+  "creditUrl",
+  "creditFee",
+  "part",
+  "abbrev",
+  "aggiebuy",
+  "image"
+];
+const invoiceFields = [
+  "uid",
+  "number",
+  "lab",
+  "totalAmount",
+  "date",
+  "data",
+  "invoiced",
+  "type",
+  "famisInvoiceNumber",
+  "deleted",
+  "customerAccount",
+  "sellingAccount",
+  "postedDate",
+  "emailed",
+  "replace_data"
+];
+const accountFields = [
+  "uid",
+  "account_number",
+  "campus_code",
+  "fiscal_year",
+  "account",
+  "support_account",
+  "budget_support_account",
+  "budget_account_number",
+  "title",
+  "expiration_date",
+  "status",
+  "uin",
+  "responsible_uin",
+  "department",
+  "setup_date",
+  "budget_access",
+  "abr_rule",
+  "idt_allowed",
+  "adloc_campus_code",
+  "adloc_department",
+  "adloc_name",
+  "preferred_first_name",
+  "first_name",
+  "middle_name",
+  "last_name",
+  "email",
+  "work_phone",
+  "active",
+  "default_bank",
+  "bank_override",
+  "srs",
+  "cfda_no",
+  "sponsor_type"
+];
+const departmentFields = [
+  "part",
+  "dept",
+  "sub",
+  "dept_name",
+  "dept_head",
+  "exec_level",
+  "division",
+  "school",
+  "exp_date",
+  "idt_email",
+  "id"
+];
+const accountBalanceFields = [
+  "account_number",
+  "campus_code",
+  "fiscal_year",
+  "account",
+  "support_account",
+  "description",
+  "balance"
+];
+const personFields = [
+  "tamuEduPersonUIN",
+  "tamuEduPersonNetID",
+  "uid",
+  "sn",
+  "givenName",
+  "cn",
+  "displayName",
+  "tamuEduPersonOfficialName",
+  "mail",
+  "postalAddress",
+  "mailStop",
+  "localityName",
+  "stateOrProvinceName",
+  "postalCode",
+  "telephoneNumber",
+  "title",
+  "tamuEduPersonTitleCode",
+  "tamuEduPersonDepartmentName",
+  "tamuEduPersonPrimaryMember",
+  "tamuEduPersonMember",
+  "tamuEduPersonPrimaryMemberName",
+  "tamuEduPersonAffiliation",
+  "eduPersonOrcid",
+  "tamuEduDataFeed",
+  "tamuLastSeenTimestamp",
+  "tamuEduPersonSupervisorUIN",
+  "tamuManualAddRDN"
+];
+const famisInvoiceNumbers = [
+  {
+    start: 300128,
+    end: 399999,
+    prefix: "I",
+    aliases: [
+      "ilabs"
+    ]
+  },
+  {
+    start: 1e5,
+    end: 999999,
+    prefix: "V",
+    aliases: [
+      "mosaic"
+    ]
+  }
+];
+const returningColumns = ["uid", "number", "lab", "totalAmount", "data", "date", "type", "famisInvoiceNumber", "customerAccount", "sellingAccount"];
+const pad = (str, max, right) => {
+  let retVal = str;
+  str = str.toString();
+  if (str.length < max) {
+    retVal = pad("0" + str, max);
+  } else if (str.length > max) {
+    retVal = str.substring(0, max);
+  }
+  if (right) {
+    retVal = retVal.length < max ? pad(retVal + "0", max, right) : retVal;
+  }
+  return retVal;
+};
+const sanitizeAccountNumber = (account) => pad(account.replace(/\D/g, ""), 13, true);
+const getCoreAccountNumber = (famis) => {
+  const { sellingCampusCode, sellingAccountNumber, sellingSupportAccount } = famis;
+  const account = `${sellingCampusCode}${sellingAccountNumber}${sellingSupportAccount}`;
+  return sanitizeAccountNumber(account);
+};
+const sortObjectKeys = (obj) => {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj !== "object") {
+    return obj;
+  }
+  const result = Object.keys(obj).sort().reduce(
+    (acc, key) => {
+      if (Array.isArray(obj[key])) {
+        acc[key] = obj[key].map(sortObjectKeys);
+      } else if (typeof obj[key] === "object") {
+        acc[key] = sortObjectKeys(obj[key]);
+      } else {
+        acc[key] = obj[key];
+      }
+      return acc;
+    },
+    {}
+  );
+  return result;
+};
+class FAMISDb {
+  db;
+  //@ts-ignore
+  people;
+  constructor(config, people) {
+    if (config) {
+      this.init(config, people);
+    }
+  }
+  init(config, people) {
+    this.db = knex({
+      client: "pg",
+      connection: config,
+      debug: true,
+      pool: {
+        min: 0,
+        max: 10,
+        createTimeoutMillis: 3e4,
+        acquireTimeoutMillis: 3e4,
+        idleTimeoutMillis: 3e4,
+        reapIntervalMillis: 1e3,
+        createRetryIntervalMillis: 100
+      }
+    });
+    this.people = people;
+  }
+  /**
+  *
+  * Extract customer account and po number
+  * @param {object} famis
+  * @param {object} replace_data
+  * @returns {object} account number object
+  * @memberof FAMISDb
+  */
+  getAccountNumber(famis, replace_data) {
+    const retVal = {
+      accountNumber: "",
+      poNumber: ""
+    };
+    if (famis.customerAccountNumber || replace_data && replace_data.customerAccountNumber) {
+      retVal.accountNumber = replace_data && replace_data.customerAccountNumber ? replace_data.customerAccountNumber : famis.customerAccountNumber;
+    } else if (famis.customerPONumber.includes("|") || replace_data && replace_data.customerPONumber?.includes("|")) {
+      const result = replace_data && replace_data.customerPONumber?.includes("|") ? replace_data.customerPONumber?.split("|") : famis.customerPONumber.split("|");
+      retVal.accountNumber = sanitizeAccountNumber(result[0]);
+      retVal.poNumber = result[1].trim();
+    } else {
+      retVal.accountNumber = replace_data && replace_data.customerPONumber ? sanitizeAccountNumber(replace_data.customerPONumber) : sanitizeAccountNumber(famis.customerPONumber);
+    }
+    return retVal;
+  }
+  /**
+  *
+  * Process an invoice to have all necessary relationships
+  * @param {object} invoice - the invoice object sent by iLab
+  * @param {boolean} [historical=false] - if true use historical accounts too
+  * @returns {Promise<object>} invoice object
+  * @memberof FAMISDb
+  */
+  async processInvoice(invoice, historical = false) {
+    try {
+      const account = getCoreAccountNumber(invoice.data.details[0].famis);
+      invoice.core = await this.getCoreByAccount(account);
+      if (invoice.core) {
+        invoice.core.systemPart = await this.getSystemById(invoice.core.systemId);
+      } else {
+        const e = Error(`Revenue account ${account} is not associated with a core.`);
+        throw e;
+      }
+      const campus = account.substring(0, 2);
+      const revenueAccount = await this.getByAccountNumber(account, campus, historical);
+      const customerAccountNumber = this.getAccountNumber(invoice.data.details[0].famis, invoice.replace_data);
+      invoice.customerAccountInfo = await this.getByAccountNumber(customerAccountNumber.accountNumber, campus, historical);
+      if (invoice.customerAccountInfo) {
+        let idtAllowed = "idt_allowed" in invoice.customerAccountInfo && invoice.customerAccountInfo.idt_allowed !== null ? invoice.customerAccountInfo.idt_allowed : "parent_account_idt_allowed" in invoice.customerAccountInfo && invoice.customerAccountInfo.parent_account_idt_allowed;
+        idtAllowed = idtAllowed && !(invoice.replace_data && typeof invoice.replace_data === "object" && invoice.replace_data.forcedAr);
+        const isIdt = customerAccountNumber && customerAccountNumber.accountNumber?.substring(0, 2) === account.substring(0, 2) && idtAllowed;
+        invoice.isIdt = isIdt;
+      } else {
+        invoice.isIdt = false;
+      }
+      let poNumber = customerAccountNumber.accountNumber?.substring(0, 2) !== "68" ? `${campus}-${revenueAccount.department}` : customerAccountNumber.poNumber;
+      invoice.poNumber = poNumber;
+      invoice.customerAccount = customerAccountNumber.accountNumber;
+      if (invoice.customerAccountInfo && this.people) {
+        const pi = invoice.customerAccountInfo.uin ? await this.people.getByUin(invoice.customerAccountInfo.uin) : [];
+        if (pi.length) {
+          invoice.pi = JSON.parse(JSON.stringify(pi[0]));
+        }
+      }
+      invoice.highRiskInfo = await this.isSrsHighRisk(invoice);
+      invoice.comments = await this.getInvoiceComments(invoice.uid);
+    } catch (e) {
+      throw e;
+    }
+    return invoice;
+  }
+  /**
+   *
+   * Get invoice by uid
+   * @param {string} uid
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {boolean} [deleted=false]
+   * @param {integer} page - page of results to return
+   * @param {string} perPage - number of results per page to return
+   * @returns {Promise<InvoicePayload>} invoice object
+   * @memberof FAMISDb
+   */
+  async getInvoiceByUid(uid, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    let self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").andWhere("uid", uid).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get invoice by originating system assigned number
+   * @param {string} number
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {boolean} [deleted=false]
+   * @param {integer} page - page of results to return
+   * @param {string} perPage - number of results per page to return
+   * @returns {Promise<InvoicePayload>} invoice object
+   * @memberof FAMISDb
+   */
+  async getInvoiceByNumber(number, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    let self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").andWhere("number", "ILIKE", `${number}%`).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get invoice by fingerprint
+   * @param {string} fingerPrint
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async getInvoiceByFingerPrint(fingerPrint) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db("invoices").where("fingerprint", fingerPrint);
+      if (records.length) {
+        retVal = await this.processInvoice(records[0]);
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get all invoices associated with a specified account number
+   * @param {string} accountNumber
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {boolean} [deleted=false]
+   * @param {integer} page - page of results to return
+   * @param {string} perPage - number of results per page to return
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async getInvoicesByAccount(accountNumber, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    let self = this;
+    let rows;
+    try {
+      const where = Array.isArray(accountNumber) ? `ALL(ARRAY[${accountNumber.map((n) => `'%${n}%'`).join()}])` : `ALL(ARRAY['%${accountNumber}%'])`;
+      rows = await this.db.from("invoices").whereNull("deleted").andWhere(function() {
+        this.where("customerAccount", "ilike", this.db.raw(where));
+        this.orWhere("sellingAccount", "ilike", this.db.raw(where));
+        this.orWhereRaw("replace_data->>'customerAccountNumber' = ?", [accountNumber]);
+        this.orWhereRaw("replace_data->>'customerPONumber' ILIKE ?", [`${accountNumber}%`]);
+      }).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get all invoice ordered by and sorted by parameters passed
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {boolean} [deleted=false]
+   * @param {integer} page - page of results to return
+   * @param {string} perPage - number of results per page to return
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async getAllInvoices(sortColumn = "date", sortDirection = "desc", deleted, page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      const qry = this.db.from("invoices").orderBy(sortColumn, sortDirection).select("*");
+      rows = deleted ? await qry.whereNotNull("deleted").paginate({ perPage, currentPage: page, isLengthAware: true }) : await qry.whereNull("deleted").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Retrieves invoices from the latest date
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} first - corresponds to the first param of the Relay spec
+   * @param {string} after - corresponds to the after param of the Relay spec
+   * @param {integer} last - corresponds to the last param of the Relay spec
+   * @param {string} before - corresponds to the before param of the Relay spec
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async getLatestInvoices(sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").whereNull("deleted").whereIn("date", function() {
+        this.max("date").from("invoices");
+      }).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Returns all held invoices
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} page - corresponds to the first param of the Relay spec
+   * @param {integer} perPage - corresponds to the last param of the Relay spec
+   * @returns {Promise<InvoicePayload>} held invoice objects
+   * @memberof FAMISDb
+   */
+  async getHeldInvoices(sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").whereNull("deleted").andWhere("invoiced", "0").orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Returns all awaiting email invoices
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} first - corresponds to the first param of the Relay spec
+   * @param {string} after - corresponds to the after param of the Relay spec
+   * @param {integer} last - corresponds to the last param of the Relay spec
+   * @param {string} before - corresponds to the before param of the Relay spec
+   * @returns {Promise<InvoicePayload>} awaiting email invoice objects
+   * @memberof FAMISDb
+   */
+  async getInvoicesAwaitingEmail(sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").whereNull("deleted").andWhere("emailed", "False").orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Search invoices by originating system generated invoice number
+   * @param {string} number
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} first - corresponds to the first param of the Relay spec
+   * @param {string} after - corresponds to the after param of the Relay spec
+   * @param {integer} last - corresponds to the last param of the Relay spec
+   * @param {string} before - corresponds to the before param of the Relay spec
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async searchInvoicesByNumber(number, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").whereNull("deleted").andWhere("number", "ilike", `${number}%`).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Search invoices by famis account number
+   * @param {string} account
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} first - corresponds to the first param of the Relay spec
+   * @param {string} after - corresponds to the after param of the Relay spec
+   * @param {integer} last - corresponds to the last param of the Relay spec
+   * @param {string} before - corresponds to the before param of the Relay spec
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async searchInvoicesByAccountNumber(account, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").whereNull("deleted").andWhere((q) => q.where("sellingAccount", "ilike", `${account}%`).orWhere("customerAccount", "ilike", `${account}%`)).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Search invoices by FAMIS invoice number
+   * @param {string} famis
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} page - page of results to return
+   * @param {integer} perPage - number of results per page to return
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async searchInvoicesByFamis(famis, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    try {
+      rows = await this.db.from("invoices").whereNull("deleted").andWhere("famisInvoiceNumber", "ilike", `${famis}%`).orderBy(sortColumn, sortDirection).select("*").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Queries invoices
+   * @param {string} query
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} page - page of results to return
+   * @param {integer} perPage - number of results per page to return
+   * @returns {Promise<InvoicePayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async queryInvoices(query, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    const invFields = invoiceFields.map((f) => `invoices.${f}`);
+    const expenseAccountFields = accountFields.map((f) => `expenseAccount.${f} AS expenseAccount_${f}`);
+    const revenueAccountFields = accountFields.map((f) => `revenueAccount.${f} AS revenueAccount_${f}`);
+    const expenseAccountDeptFields = departmentFields.map((f) => `expenseAccountDepartment.${f} AS expenseAccountDepartment_${f}`);
+    const revenueAccountDeptFields = departmentFields.map((f) => `revenueAccountDepartment.${f} AS revenueAccountDepartment_${f}`);
+    const expenseAccountBalFields = accountBalanceFields.map((f) => `expenseAccountBalance.${f} AS expenseAccountBalance_${f}`);
+    const fields = [
+      ...invFields,
+      ...expenseAccountFields,
+      ...revenueAccountFields,
+      ...expenseAccountDeptFields,
+      ...revenueAccountDeptFields,
+      ...expenseAccountBalFields
+    ];
+    try {
+      rows = await this.db.from("invoices").leftJoin("accounts as expenseAccount", "invoices.customerAccount", "expenseAccount.account_number").leftJoin("accounts as revenueAccount", "invoices.sellingAccount", "revenueAccount.account_number").leftJoin("departments as expenseAccountDepartment", function() {
+        this.on("expenseAccount.department", "=", "expenseAccountDepartment.dept").on("expenseAccountDepartment.part", "=", "expenseAccount.campus_code").andOnVal("expenseAccountDepartment.sub", null);
+      }).leftJoin("departments as revenueAccountDepartment", function() {
+        this.on("revenueAccount.department", "=", "revenueAccountDepartment.dept").on("revenueAccountDepartment.part", "=", "revenueAccount.campus_code");
+      }).leftJoin("account_balances as expenseAccountBalance", function() {
+        this.on("expenseAccountBalance.account_number", "=", "expenseAccount.budget_account_number").on("expenseAccountBalance.fiscal_year", "=", "expenseAccount.fiscal_year");
+      }).where(this.db.raw(query)).whereNull("revenueAccountDepartment.sub").orderBy(sortColumn, sortDirection).select(fields).paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = await Promise.all(
+        rows.data.map(async (row) => {
+          const rec = await self.processInvoice(row);
+          return rec;
+        })
+      );
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Adds an invoice
+   * @param {object} invoice
+   * @param {string} type
+   * @param {string} famisInvoiceNumber
+   * @returns {Promise<object>} invoice
+   * @memberof FAMISDb
+   */
+  async addInvoice(invoice, type, famisInvoiceNumber) {
+    let records;
+    try {
+      famisInvoiceNumber = famisInvoiceNumber ?? void 0;
+      famisInvoiceNumber = famisInvoiceNumber ? famisInvoiceNumber : await this.getNextFAMISInvoiceNumber(type);
+      invoice.details.forEach((d) => {
+        d.famis.invoiceNumber = famisInvoiceNumber;
+        if (!d.other) {
+          d.other = "0.00";
+        }
+        if (!d.comments) {
+          d.comments = null;
+        }
+        if (!d.billingPeriod) {
+          d.billingPeriod = null;
+        }
+      });
+      records = await this.db("invoices").returning(returningColumns).insert({
+        number: invoice.number,
+        lab: invoice.lab,
+        totalAmount: parseFloat(invoice.totalAmount),
+        data: JSON.stringify(invoice),
+        date: invoice.date,
+        uid: createId(),
+        fingerprint: invoice.fingerprint,
+        type,
+        famisInvoiceNumber,
+        customerAccount: this.getAccountNumber(invoice.details[0].famis).accountNumber,
+        sellingAccount: getCoreAccountNumber(invoice.details[0].famis)
+      });
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Updates an invoice
+   * @param {string} uid
+   * @param {object} invoice
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async updateInvoice(uid, invoice) {
+    let records;
+    invoice.details.forEach((d) => {
+      if (!d.other) {
+        d.other = "0.00";
+      }
+      if (!d.comments) {
+        d.comments = null;
+      }
+      if (!d.billingPeriod) {
+        d.billingPeriod = null;
+      }
+    });
+    try {
+      const record = {
+        number: invoice.number,
+        lab: invoice.lab,
+        totalAmount: parseFloat(invoice.totalAmount),
+        data: JSON.stringify(invoice),
+        date: invoice.date,
+        customerAccount: this.getAccountNumber(invoice.details[0].famis).accountNumber,
+        sellingAccount: getCoreAccountNumber(invoice.details[0].famis),
+        fingerprint: invoice.fingerprint ? invoice.fingerprint : null
+      };
+      if (invoice.replace_data) {
+        record.replace_data = invoice.replace_data;
+      }
+      records = await this.db("invoices").returning(returningColumns).update(record).where("uid", uid);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Toggles an invoice as paid
+   * @param {string} uid
+   * @param {boolean} invoiced
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async markInvoiced(uid, invoiced) {
+    let records;
+    try {
+      records = await this.db("invoices").returning(returningColumns).update({
+        invoiced
+      }).where("uid", uid);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Toggles an invoice as emailed
+   * @param {string} uid
+   * @param {boolean} emailed
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async markEmailed(uid, emailed) {
+    let records;
+    try {
+      records = await this.db("invoices").returning(returningColumns).update({
+        emailed
+      }).where("uid", uid);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Sets an invoice's deletion date
+   * @param {string} uid
+   * @param {date} deleted
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async setDeleted(uid, deleted) {
+    let records;
+    try {
+      records = await this.db("invoices").returning(returningColumns).update({
+        deleted
+      }).where("uid", uid);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Sets an invoice's posted date
+   * @param {string} uid
+   * @param {date} postedDate
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async setInvoicePostedDate(uid, postedDate) {
+    let records;
+    try {
+      records = await this.db("invoices").returning(returningColumns).update({
+        postedDate
+      }).where("uid", uid);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Sets an invoice's fingerprint
+   * @param {string} uid
+   * @param {string} fingerprint
+   * @returns {Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async setInvoiceFingerPrint(uid, fingerprint) {
+    let records;
+    try {
+      records = await this.db("invoices").returning(returningColumns).update({
+        fingerprint
+      }).where("uid", uid);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Get PI accounts by account number
+   * @param {string} number
+   * @param {string} campus
+   * @param {boolean} [historical=false]
+   * @returns {Promise<Account>} account object
+   * @memberof FAMISDb
+   */
+  async getByAccountNumber(number, campus = "02", historical = false) {
+    let records;
+    let retVal;
+    let table = historical ? "accounts_all" : "accounts";
+    const self = this;
+    if (!number) {
+      throw Error("Null account number");
+    }
+    try {
+      records = await this.db(`${table}`).leftJoin(
+        "departments",
+        function() {
+          this.on(`${table}.department`, "=", "departments.dept").on("departments.part", "=", self.db.raw("?", [number.substring(0, 2)]));
+        }
+      ).leftJoin(
+        `${table} as parent_account`,
+        function() {
+          this.on(`${table}.campus_code`, "=", "parent_account.campus_code").on(`${table}.account`, "=", "parent_account.account").on("parent_account.support_account", "=", self.db.raw("?", ["00000"])).on(`${table}.fiscal_year`, "=", "parent_account.fiscal_year");
+        }
+      ).select(
+        `${table}.*`,
+        "departments.idt_email as billingEmailId",
+        "parent_account.idt_allowed as parent_account_idt_allowed"
+      ).whereNull("departments.sub").andWhere(function() {
+        this.whereNull("departments.exp_date").orWhere("departments.exp_date", ">", self.db.raw("CURRENT_DATE"));
+      }).andWhere(`${table}.account_number`, number);
+      if (records.length) {
+        retVal = records[0];
+      } else {
+        records = await this.db("customers").where("account_number", number).andWhere("campus_code", campus);
+        if (records.length) {
+          retVal = Object.assign(
+            {},
+            records[0],
+            {
+              idt_allowed: false,
+              parent_account_idt_allowed: false,
+              billingEmailId: records[0].email
+            }
+          );
+        }
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Search PI accounts by partial account number
+   * @param {string|string[]} number
+   * @returns {Promise<AccountPayload>} account object(s)
+   * @memberof FAMISDb
+   */
+  async searchByAccountNumber(number, sortColumn = "account_number", sortDirection = "desc", page = 1, perPage = 50) {
+    let records;
+    const self = this;
+    try {
+      const where = Array.isArray(number) ? `ALL(ARRAY[${number.map((n) => `'%${n}%'`).join()}])` : `ALL(ARRAY['%${number}%'])`;
+      const accounts = await this.db("accounts").leftJoin("departments", function() {
+        this.on("accounts.department", "=", "departments.dept").on("departments.part", "=", "accounts.campus_code");
+      }).leftJoin("account_balances", function() {
+        this.on("account_balances.account_number", "=", "accounts.budget_account_number").on("account_balances.fiscal_year", "=", "accounts.fiscal_year");
+      }).select("accounts.*", "departments.idt_email as billingEmailId", "account_balances.balance").whereNull("departments.sub").andWhere(function() {
+        this.whereNull("departments.exp_date").orWhere("departments.exp_date", ">", self.db.raw("CURRENT_DATE"));
+      }).where("accounts.account_number", "ilike", this.db.raw(where)).unionAll([
+        this.db.select(
+          "NULL as uid",
+          "NULL as campus_code",
+          "NULL as account_number",
+          'NULL as "name" as title',
+          "NULL as email",
+          "NULL as fiscal_year",
+          "NULL as account",
+          "NULL as support_account",
+          "NULL as budget_support_account",
+          "NULL as budget_account_number",
+          "NULL as expiration_date",
+          "NULL as status",
+          "NULL as uin",
+          "NULL as responsible_uin",
+          "NULL as department",
+          "NULL as setup_date",
+          "NULL as budget_access",
+          "NULL as abr_rule",
+          "NULL as idt_allowed",
+          "NULL as adloc_campus_code",
+          "NULL as adloc_department",
+          "NULL as adloc_name",
+          "NULL as preferred_first_name",
+          "NULL as first_name",
+          "NULL as middle_name",
+          "NULL as last_name",
+          "NULL as work_phone",
+          "NULL as active",
+          "NULL as default_bank",
+          "NULL as bank_override",
+          "NULL as last_seen",
+          "NULL as srs",
+          "NULL as cfda_no",
+          "NULL as sponsor_type",
+          "NULL as billingEmailId",
+          "NULL as balance"
+        ).from("customers").where("customers.account_number", "ilike", this.db.raw(where))
+      ]).orderBy(sortColumn, sortDirection).paginate({ perPage, currentPage: page, isLengthAware: true });
+      records = accounts;
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Get PI Accounts by UIN
+   * @param {string|string[]} uin
+   * @returns {Promise<Account[]>} account object array
+   * @memberof FAMISDb
+   */
+  async getAccountsByUin(uin, responsible, sortColumn = "account_number", sortDirection = "desc", page = 1, perPage = 50) {
+    let records;
+    const self = this;
+    try {
+      const where = Array.isArray(uin) ? `ALL(ARRAY[${uin.map((n) => `'%${n}%'`).join()}])` : `ALL(ARRAY['%${uin}%'])`;
+      const qry = this.db("accounts").join("departments", function() {
+        this.on("accounts.department", "=", "departments.dept").on("accounts.campus_code", "=", "departments.part");
+      }, "left").select("accounts.*", "departments.idt_email as billingEmailId").whereNull("departments.sub").andWhere(function() {
+        this.whereNull("departments.exp_date").orWhere("departments.exp_date", ">", self.db.raw("CURRENT_DATE"));
+      }).where("uin", "ilike", this.db.raw(where)).orderBy(sortColumn, sortDirection);
+      records = responsible ? await qry.orWhere("responsible_uin", "ilike", this.db.raw(where)).paginate({ perPage, currentPage: page, isLengthAware: true }) : await qry.paginate({ perPage, currentPage: page, isLengthAware: true });
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Get PI accounts by responsible UIN
+   * @param {string} uin
+   * @returns {Promise<Account[]>} account object array
+   * @memberof FAMISDb
+   */
+  async getAccountsByResponsibleUin(uin) {
+    let records;
+    const self = this;
+    try {
+      const where = Array.isArray(uin) ? `ALL(ARRAY[${uin.map((n) => `'%${n}%'`).join()}])` : `ALL(ARRAY['%${uin}%'])`;
+      records = await this.db("accounts").join("departments", function() {
+        this.on("accounts.department", "=", "departments.dept").on("accounts.campus_code", "=", "departments.part");
+      }, "left").select("accounts.*", "departments.idt_email as billingEmailId").whereNull("departments.sub").andWhere(function() {
+        this.whereNull("departments.exp_date").orWhere("departments.exp_date", ">", self.db.raw("CURRENT_DATE"));
+      }).where("uin", "ilike", this.db.raw(where));
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+  /**
+   *
+   * Queries accounts
+   * @param {string} query
+   * @param {string} [sortColumn='date']
+   * @param {string} [sortDirection='desc']
+   * @param {integer} page - page of results to return
+   * @param {integer} perPage - number of results per page to return
+   * @returns {Promise<AccountPayload>} invoice objects
+   * @memberof FAMISDb
+   */
+  async queryAccounts(query, sortColumn = "date", sortDirection = "desc", page = 1, perPage = 50) {
+    let rows;
+    const acctFields = accountFields.map((f) => `accounts.${f}`);
+    const accountBalFields = accountBalanceFields.map((f) => `accountBalance.${f} AS accountBalance_${f}`);
+    const deptFields = departmentFields.map((f) => `d.${f} AS department_${f}`);
+    const accountantFields = personFields.map((f) => `accountant.${f} AS accountant_${f}`);
+    const fields = [
+      ...acctFields,
+      ...accountBalFields,
+      ...deptFields,
+      ...accountantFields
+      /*
+      ...expenseAccountFields,
+      ...revenueAccountFields,
+      ...expenseAccountDeptFields,
+      ...revenueAccountDeptFields,
+      ...expenseAccountBalFields,
+      */
+    ];
+    try {
+      rows = await this.db.from("accounts").leftJoin("account_balances as accountBalance", function() {
+        this.on("accountBalance.account_number", "=", "accounts.budget_account_number").on("accountBalance.fiscal_year", "=", "accounts.fiscal_year");
+      }).leftJoin("departments as d", function() {
+        this.on("accounts.department", "=", "d.dept").on("accounts.campus_code", "=", "d.part");
+      }).leftJoin("people.current as accountant", function() {
+        this.on("accounts.responsible_uin", "=", "accountant.tamuEduPersonUIN");
+      }).where(this.db.raw(query)).whereNull("d.sub").orderBy(sortColumn, sortDirection).select(fields).paginate({ perPage, currentPage: page, isLengthAware: true });
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get next FAMIS invoice number in sequence for specified invoice type
+   * @param {string} invoice
+   * @returns {Promise<string>} next invoice number in sequence
+   * @memberof FAMISDb
+   */
+  async getNextFAMISInvoiceNumber(type) {
+    let records;
+    let prefix = {
+      start: 0,
+      end: 0,
+      prefix: "",
+      aliases: []
+    };
+    let retVal;
+    famisInvoiceNumbers.forEach((f) => {
+      if (f.aliases.includes(type)) {
+        prefix = f;
+      }
+    });
+    try {
+      retVal = `${prefix.prefix}${prefix.start}`;
+      records = await this.db("invoices").whereIn("type", prefix.aliases).orderBy("famisInvoiceNumber", "desc");
+      if (records.length) {
+        const number = parseInt(records[0].famisInvoiceNumber.substring(1), 10) + 1;
+        retVal = `${prefix.prefix}${number}`;
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get matching expense code for specified revenue code
+   * @param {string} revenue
+   * @returns {Promise<string>} expense code
+   * @memberof FAMISDb
+   */
+  async getExpenseCodeByRevenue(revenue) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db("codes").where("revenue", revenue).orderBy("id", "desc");
+      if (records.length) {
+        retVal = records[0].expense;
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+  * Represents a row in the 'codes' table.
+  * @typedef {Object} Code
+  * @property {number} id - The unique identifier for the code.
+  * @property {string|null} revenue - The revenue code (nullable).
+  * @property {string|null} expense - The expense code (nullable).
+  * @property {boolean} sales - Indicates if the code is associated with sales.
+  * @property {boolean} srs - Indicates if the code is associated with SRS.
+  */
+  /**
+   *
+   * Get revenue code object
+   * @param {string} revenue
+   * @returns {Promise<Code>} revenue code object
+   * @memberof FAMISDb
+   */
+  async getRevenueCode(revenue) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db("codes").where("revenue", revenue).orderBy("id", "desc");
+      if (records.length) {
+        retVal = records[0];
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get expense code object
+   * @param {string} code
+   * @returns {Promise<Code>} expense code object
+   * @memberof FAMISDb
+   */
+  async getExpenseCode(code) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db("codes").where("expense", code).orderBy("id", "desc");
+      if (records.length) {
+        retVal = records[0];
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Check if expense code is within the allowable range for specified account and the specified fiscal year (defaults to the current)
+   * @param {string} accountNumber
+   * @param {string} code
+   * @param {integer} fiscal
+   * @returns {Promise<boolean>} truthy value
+   * @memberof FAMISDb
+   */
+  async allowableExpenseCode(accountNumber, code, fiscal) {
+    let records;
+    let retVal = false;
+    const year = fiscal ? fiscal : this.getCurrentFiscalYear();
+    try {
+      records = await this.db("subcode_edits").select("allowed").where("campus_code", accountNumber.substring(0, 2)).andWhere("account", accountNumber.substring(2, 8)).andWhere("support_account", accountNumber.substring(8, 13)).andWhere("fiscal_year", year).andWhereRaw("? BETWEEN low AND high", [parseInt(code)]);
+      if (records.length) {
+        retVal = records[0].allowed;
+      } else {
+        records = await this.db("abr_rules").select("abr_rules.*").join("accounts", function() {
+          this.on("accounts.abr_rule", "=", "abr_rules.abr_rule").on("accounts.campus_code", "=", "abr_rules.campus_code").on("accounts.fiscal_year", "=", "abr_rules.fiscal_year");
+        }, "left").where("accounts.account_number", accountNumber).andWhere("accounts.fiscal_year", year).andWhereRaw("? BETWEEN abr_rules.low AND abr_rules.high", [parseInt(code)]);
+        if (records.length) {
+          retVal = true;
+        }
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get allowable expense code ranges for the specified account
+   * @param {string} accountNumber
+   * @param {integer} fiscal
+   * @returns {Promise<boolean>} expense code range object(s)
+   * @memberof FAMISDb
+   */
+  async getAllowableExpenseCodes(accountNumber, fiscal) {
+    let abr;
+    let subcode;
+    let disallowed;
+    let retVal = {
+      allowed: [],
+      disallowed: []
+    };
+    const year = fiscal ? fiscal : this.getCurrentFiscalYear();
+    try {
+      subcode = await this.db("subcode_edits").select("low", "high").where("campus_code", accountNumber.substring(0, 2)).andWhere("account", accountNumber.substring(2, 8)).andWhere("support_account", accountNumber.substring(8, 13)).andWhere("fiscal_year", year).andWhere("allowed", true).orderBy("low", "asc");
+      disallowed = await this.db("subcode_edits").select("low", "high").where("campus_code", accountNumber.substring(0, 2)).andWhere("account", accountNumber.substring(2, 8)).andWhere("support_account", accountNumber.substring(8, 13)).andWhere("fiscal_year", year).andWhere("allowed", false).orderBy("low", "asc");
+      abr = await this.db("abr_rules").select("abr_rules.low", "abr_rules.high").join("accounts", function() {
+        this.on("accounts.abr_rule", "=", "abr_rules.abr_rule").on("accounts.campus_code", "=", "abr_rules.campus_code").on("accounts.fiscal_year", "=", "abr_rules.fiscal_year");
+      }, "left").where("accounts.account_number", accountNumber).andWhere("accounts.fiscal_year", year).orderBy("low", "asc");
+      if (abr.length || subcode.length) {
+        const allowed = [...abr, ...subcode];
+        retVal = {
+          allowed,
+          disallowed
+        };
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Query cores
+   * @param {string} query
+   * @param {string} [sortColumn='facility']
+   * @param {string} [sortDirection='asc']
+   * @param {integer} page - page of results to return
+   * @param {integer} perPage - number of results per page to return
+   * @returns {Promise<CorePayload>} core objects
+   * @memberof FAMISDb
+   */
+  async queryCores(query, sortColumn = "facility", sortDirection = "asc", page = 1, perPage = 50) {
+    const self = this;
+    let rows;
+    const systemFields = systemPartFields.map((f) => `system.${f} AS system_${f}`);
+    const fields = [
+      ...systemFields
+      /*
+      ...expenseAccountFields,
+      ...revenueAccountFields,
+      ...expenseAccountDeptFields,
+      ...revenueAccountDeptFields,
+      ...expenseAccountBalFields,
+      */
+    ];
+    try {
+      rows = await this.db.with("coreaccounts", (qb) => {
+        qb.select("accounts.*", "core_accounts.active", "core_accounts.coreId", "core_accounts.effective").from("core_accounts").join("accounts", "core_accounts.account", "accounts.account_number");
+      }).with("coreusers", (qb) => {
+        qb.select("users.*", "user_cores.email", "user_cores.coreId").from("user_cores").join("users", "user_cores.userId", "users.id");
+      }).from("cores").leftJoin("system", "system.id", "cores.systemId").where(this.db.raw(query)).orderBy(sortColumn, sortDirection).leftJoin(
+        this.db.from("user_cores").join("coreusers", { "user_cores.userId": "coreusers.id", "user_cores.coreId": "coreusers.coreId" }).select(
+          "user_cores.coreId",
+          this.db.raw(
+            "case when count(coreusers) = 0 then '[]' else jsonb_agg(coreusers.*) end as users"
+          )
+        ).groupBy(["user_cores.coreId"]).as("user_cores"),
+        "user_cores.coreId",
+        "cores.id"
+      ).leftJoin(
+        this.db.from("core_accounts").join("coreaccounts", { "core_accounts.account": "coreaccounts.account_number", "core_accounts.coreId": "coreaccounts.coreId" }).select(
+          "core_accounts.coreId",
+          this.db.raw(
+            "case when count(coreaccounts) = 0 then '[]' else jsonb_agg(coreaccounts.*) end as accounts"
+          )
+        ).groupBy(["core_accounts.coreId"]).as("core_accounts"),
+        "core_accounts.coreId",
+        "cores.id"
+      ).select([
+        "cores.*",
+        "user_cores.users",
+        "core_accounts.accounts",
+        ...fields
+      ]).paginate({ perPage, currentPage: page, isLengthAware: true });
+      if (self.people) {
+        rows.data = await Promise.all(
+          rows.data.map(async (row) => {
+            const uids = row.users?.map((u) => u.userId);
+            if (uids) {
+              const users = await self.people.bulkGetByUid(uids);
+              if (users) {
+                row.users = row.users?.map((u) => {
+                  let retVal = u;
+                  const user = users.find((u1) => u1.uid === u.userId);
+                  if (user) {
+                    retVal = {
+                      ...u,
+                      ...user
+                    };
+                  } else if (u.role) {
+                    retVal = {
+                      ...u,
+                      sn: u.roleName,
+                      mail: u.roleEmail
+                    };
+                  }
+                  return retVal;
+                });
+              }
+            }
+            return row;
+          })
+        );
+      }
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get core by specified attribute and search term
+   * @param {string} type
+   * @param {string} operator
+   * @param {string} search
+   * @returns {Promise<Core>} core object
+   * @memberof FAMISDb
+   */
+  async getCore(type, operator = "=", search) {
+    let records;
+    let retVal;
+    try {
+      const systemFields = systemPartFields.map((f) => `system.${f} AS system_${f}`);
+      const fields = [
+        ...systemFields
+        /*
+        ...expenseAccountFields,
+        ...revenueAccountFields,
+        ...expenseAccountDeptFields,
+        ...revenueAccountDeptFields,
+        ...expenseAccountBalFields,
+        */
+      ];
+      records = await this.db.with("coreaccounts", (qb) => {
+        qb.select("accounts.*", "core_accounts.coreId", "core_accounts.effective").from("core_accounts").join("accounts", "core_accounts.account", "accounts.account_number");
+      }).with("coreusers", (qb) => {
+        qb.select("users.*", "user_cores.email", "user_cores.coreId").from("user_cores").join("users", "user_cores.userId", "users.id");
+      }).from("cores").leftJoin("system", "system.id", "cores.systemId").where(type, operator, search).leftJoin(
+        this.db.from("user_cores").join("coreusers", { "user_cores.userId": "coreusers.id", "user_cores.coreId": "coreusers.coreId" }).select(
+          "user_cores.coreId",
+          this.db.raw(
+            "case when count(coreusers) = 0 then '[]' else jsonb_agg(coreusers.*) end as users"
+          )
+        ).groupBy(["user_cores.coreId"]).as("user_cores"),
+        "user_cores.coreId",
+        "cores.id"
+      ).leftJoin(
+        this.db.from("core_accounts").join("coreaccounts", { "core_accounts.account": "coreaccounts.account_number", "core_accounts.coreId": "coreaccounts.coreId" }).select(
+          "core_accounts.coreId",
+          this.db.raw(
+            "case when count(coreaccounts) = 0 then '[]' else jsonb_agg(coreaccounts.*) end as accounts"
+          )
+        ).groupBy(["core_accounts.coreId"]).as("core_accounts"),
+        "core_accounts.coreId",
+        "cores.id"
+      ).select([
+        "cores.*",
+        "user_cores.users",
+        "core_accounts.accounts",
+        ...fields
+      ]);
+      if (records.length) {
+        retVal = records[0];
+        if (this.people) {
+          const uids = retVal.users?.map((u) => u.userId);
+          if (uids) {
+            const users = await this.people.bulkGetByUid(uids);
+            if (users) {
+              retVal.users = retVal.users?.map((u) => {
+                let retVal2 = u;
+                const user = users.find((u1) => u1.uid === u.userId);
+                if (user) {
+                  retVal2 = {
+                    ...u,
+                    ...user
+                  };
+                } else if (u.role) {
+                  retVal2 = {
+                    ...u,
+                    sn: u.roleName,
+                    mail: u.roleEmail
+                  };
+                }
+                return retVal2;
+              });
+            }
+          }
+        }
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get core by id
+   * @param {string} id
+   * @returns {Promise<Core>} core object
+   * @memberof FAMISDb
+   */
+  async getCoreById(id) {
+    let retVal;
+    try {
+      retVal = await this.getCore("cores.id", "=", id);
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get core by account number
+   * @param {string} account
+   * @returns {Promise<Core>} core object
+   * @memberof FAMISDb
+   */
+  async getCoreByAccount(account) {
+    let retVal;
+    try {
+      retVal = await this.getCore("core_accounts.accounts", "@>", `[{"account_number": "${account}"}]`);
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Update core
+   * @param {Core} core object
+   * @returns {Promise<Core>} core object
+   * @memberof FAMISDb
+   */
+  async updateCore(core) {
+    let retVal;
+    const columns = ["id", "account", "effective", "facility", "contact", "contactEmail", "systemId", "enabled", "deleted", "coreEmail", "corePhone", "coreAddress", "from_email", "invoice_email"];
+    try {
+      if ("id" in core) {
+        retVal = await this.db("cores").returning(columns).update(core).where("id", core.id);
+        const systemPart = this.getSystemById(retVal.systemId);
+        retVal.systemPart = systemPart;
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Add core
+   * @param {Core} core object
+   * @returns {Promise<Core>} core object
+   * @memberof FAMISDb
+   */
+  async addCore(core) {
+    let retVal;
+    const columns = ["id", "account", "effective", "facility", "contact", "contactEmail", "systemId", "enabled", "deleted", "coreEmail", "corePhone", "coreAddress", "from_email", "invoice_email"];
+    try {
+      retVal = await this.db("cores").returning(columns).insert(core);
+      const systemPart = this.getSystemById(retVal.systemId);
+      retVal.systemPart = systemPart;
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Update core account
+   * @param {CoreAccount} account object
+   * @returns {Promise<CoreAccount>} core_account object
+   * @memberof FAMISDb
+   */
+  async updateCoreAccount(account) {
+    let retVal;
+    const columns = ["id", "account", "effective", "coreId", "active"];
+    try {
+      if ("id" in account) {
+        retVal = await this.db("core_accounts").returning(columns).update(account).where("id", account.id);
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Add core_account
+   * @param {CoreAccount} account object
+   * @returns {Promise<CoreAccount>} core_account object
+   * @memberof FAMISDb
+   */
+  async addCoreAccount(account) {
+    let retVal;
+    const columns = ["id", "account", "effective", "coreId", "active"];
+    try {
+      retVal = await this.db("core_accounts").returning(columns).insert(account);
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get system part by ID
+   * @param {number} id
+   * @returns {Promise<SystemPart>} system part object
+   * @memberof FAMISDb
+   */
+  async getSystemById(id) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db("system").where("id", id).orderBy("id", "desc");
+      if (records.length) {
+        retVal = records[0];
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get system part by two-digit part number
+   * @param {string} number
+   * @returns {Promise<SystemPart>} system part object
+   * @memberof FAMISDb
+   */
+  async getSystemByPartNumber(number) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db("system").where("part", number).orderBy("id", "desc");
+      if (records.length) {
+        retVal = records[0];
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get all enabled cores
+   * @returns {Promise<Core[]>} core objects
+   * @memberof FAMISDb
+   */
+  async getEnabledCores() {
+    let records;
+    let retVal = [];
+    try {
+      records = await this.db("cores").select(
+        "cores.id",
+        "core_accounts.account",
+        "core_accounts.effective",
+        "core_accounts.active",
+        "cores.facility",
+        "cores.contact",
+        "cores.contactEmail",
+        "cores.systemId",
+        "cores.enabled",
+        "cores.deleted",
+        "cores.coreEmail",
+        "cores.corePhone",
+        "cores.coreAddress",
+        "cores.from_email",
+        "cores.invoice_email"
+      ).join("core_accounts", "cores.id", "=", "core_accounts.coreId").where("enabled", "1").andWhere("core_accounts.active", "True").groupBy("cores.id").orderBy("cores.id", "desc");
+      if (records.length) {
+        retVal = records;
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get all cores
+   * @param {string} [sortColumn='facility']
+   * @param {string} [sortDirection='asc']
+   * @param {boolean} [deleted=false]
+   * @param {integer} page - page of results to return
+   * @param {string} perPage - number of results per page to return
+   * @returns {Promise<CorePayload>} core objects
+   * @memberof FAMISDb
+   */
+  async getAllCores(sortColumn = "facility", sortDirection = "asc", deleted, page = 1, perPage = 50) {
+    let rows;
+    try {
+      const systemParts = await this.getAllSystemParts();
+      const qry = this.db("cores").orderBy(sortColumn, sortDirection).select("*");
+      rows = deleted ? await qry.whereNotNull("deleted").paginate({ perPage, currentPage: page, isLengthAware: true }) : await qry.whereNull("deleted").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = rows.data.map((c) => {
+        const systemPart = systemParts.find((s) => s.id === c.systemId);
+        return {
+          ...c,
+          systemPart
+        };
+      });
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get a core's users by core ID
+   * @param {number} coreId
+   * @returns {Promise<Core[]>} user objects
+   * @memberof FAMISDb
+   */
+  async getCoreUsers(coreId) {
+    let retVal;
+    try {
+      retVal = await this.db("user_cores").join("users", "user_cores.userId", "=", "users.id").where("coreId", coreId).select(
+        "users.*",
+        "user_cores.id as userCoreId",
+        "user_cores.coreId",
+        "user_cores.email"
+      );
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+  *
+  * Update core user
+  * @param {CoreUser} user object
+  * @returns {Promise<CoreUser>} user_core object
+  * @memberof FAMISDb
+  */
+  async updateCoreUser(user) {
+    let retVal;
+    const columns = ["id", "userId", "coreId", "email"];
+    try {
+      if ("id" in user) {
+        retVal = await this.db("user_cores").returning(columns).update(user).where("id", user.id);
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Add core user
+   * @param {CoreUser} coreUser core user object
+   * @param {User} user user object
+   * @returns {Promise<CoreUser>} core user object
+   * @memberof FAMISDb
+   */
+  async addCoreUser(coreUser, user) {
+    let retVal;
+    const columns = ["id", "userId", "coreId", "email"];
+    try {
+      let record = {
+        userId: coreUser.userId
+      };
+      const [userInsert] = await this.db("users").insert(record).onConflict("userId").merge().returning("*");
+      if (userInsert) {
+        retVal = await this.db("user_cores").insert({
+          ...coreUser,
+          userId: userInsert.id
+        }).onConflict(["userId", "coreId"]).ignore().returning(columns);
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get a user's cores they manage
+   * @param {string} userId
+   * @param {string} [sortColumn='facility']
+   * @param {string} [sortDirection='asc']
+   * @param {boolean} [deleted=false]
+   * @param {integer} page - page of results to return
+   * @param {string} perPage - number of results per page to return
+   * @returns {Promise<CorePayload]>} core objects
+   * @memberof FAMISDb
+   */
+  async getUserCores(userId, sortColumn = "facility", sortDirection = "asc", deleted, page = 1, perPage = 50) {
+    let rows;
+    try {
+      const systemParts = await this.getAllSystemParts();
+      const qry = this.db("user_cores").join("cores", "user_cores.coreId", "=", "cores.id").join("users", "user_cores.userId", "=", "users.id").where("users.userId", userId).select(
+        "cores.*",
+        "user_cores.id as userCoreId",
+        "user_cores.userId",
+        "user_cores.email"
+      ).orderBy(sortColumn, sortDirection);
+      rows = deleted ? await qry.whereNotNull("cores.deleted").paginate({ perPage, currentPage: page, isLengthAware: true }) : await qry.whereNull("cores.deleted").paginate({ perPage, currentPage: page, isLengthAware: true });
+      rows.data = rows.data.map((c) => {
+        const systemPart = systemParts.find((s) => s.id === c.systemId);
+        return {
+          ...c,
+          systemPart
+        };
+      });
+    } catch (e) {
+      throw e;
+    }
+    return rows;
+  }
+  /**
+   *
+   * Get a system part's users by system ID
+   * @param {number} systemId
+   * @returns {Promise<object[]>} user objects
+   * @memberof FAMISDb
+   */
+  async getSystemUsers(systemId) {
+    let retVal;
+    try {
+      retVal = await this.db("user_systems").join("users", "user_systems.userId", "=", "users.id").where("systemId", systemId).select(
+        "users.*",
+        "user_systems.id as userSystemId",
+        "user_systems.systemId",
+        "user_systems.email"
+      );
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   *
+   * Get a user's system parts they manage
+   * @param {string} userId
+   * @returns {Promise<SystemPart[]>} system objects
+   * @memberof FAMISDb
+   */
+  async getUserSystemParts(userId) {
+    let retVal;
+    try {
+      retVal = await this.db("user_systems").join("system", "user_systems.systemId", "=", "system.id").join("users", "user_systems.userId", "=", "users.id").where("users.userId", userId).select(
+        "system.*",
+        "user_systems.id as userSystemId",
+        "user_systems.userId",
+        "user_systems.email"
+      );
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+  * Represents the "system" table in the public schema.
+  * @typedef {Object} System
+  * @property {number} id - The ID (auto-generated).
+  * @property {string | null} name - The name.
+  * @property {string | null} due - The due text.
+  * @property {string | null} fein - The FEIN (Federal Employer Identification Number).
+  * @property {string | null} agency - The agency.
+  * @property {string | null} checkAddress - The check address.
+  * @property {boolean} credit - Indicates if credit is allowed.
+  * @property {string | null} creditUrl - The credit URL.
+  * @property {string | null} creditFee - The credit fee.
+  * @property {string | null} part - The part.
+  * @property {string | null} abbrev - The abbreviation.
+  * @property {string | null} aggiebuy - The AggieBuy information.
+  * @property {string | null} image - The image URL.
+  */
+  /**
+   * Get all system parts.
+   * @returns {Promise<SystemPart[]>} System objects.
+   * @memberof FAMISDb
+   */
+  async getAllSystemParts() {
+    let retVal;
+    try {
+      retVal = await this.db("system").orderBy("id", "asc");
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   * Get all admin users.
+   * @returns {Promise<object[]>} Array of user objects.
+   * @memberof FAMISDb
+   */
+  async getAdminUsers() {
+    let retVal = [];
+    try {
+      retVal = await this.db("users").where("admin", true);
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   * Get user.
+   * @param {string} userId - User ID.
+   * @returns {Promise<object>} User object.
+   * @memberof FAMISDb
+   */
+  async getUser(userId) {
+    let records;
+    let retVal = null;
+    try {
+      records = await this.db("users").where("userId", userId);
+      if (records.length) {
+        const cores = await this.getUserCores(userId);
+        const systems = await this.getUserSystemParts(userId);
+        retVal = {
+          ...records[0],
+          cores,
+          systems
+        };
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   * Update user.
+   * @param {object} user - User object.
+   * @returns {Promise<object>} Updated user object.
+   * @memberof FAMISDb
+   */
+  async updateUser(user) {
+    let retVal = null;
+    const columns = ["id", "userId", "admin", "role", "roleName", "roleEmail", "deleted"];
+    try {
+      if ("id" in user)
+        retVal = await this.db("users").returning(columns).update(user).where("id", user.id);
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   * Get customer by customer account number.
+   * @param {string} accountNumber - Customer account number.
+   * @param {string} campusCode - Campus code.
+   * @returns {Promise<object>} Customer account object.
+   * @memberof FAMISDb
+   */
+  async getCustomerNumber(accountNumber, campusCode) {
+    let records;
+    let retVal = null;
+    const code = pad(campusCode, 2);
+    try {
+      records = await this.db("customers").where("uid", `${code}${accountNumber}`);
+      if (records.length) {
+        retVal = records[0];
+      }
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+  /**
+   * Get current fiscal year.
+   * @returns {number} Fiscal year.
+   * @memberof FAMISDb
+   */
+  getCurrentFiscalYear() {
+    let year;
+    let today = /* @__PURE__ */ new Date();
+    if (today.getMonth() + 1 >= 9) {
+      year = today.getFullYear() + 1;
+    } else {
+      year = today.getFullYear();
+    }
+    return year;
+  }
+  /**
+   * Return fingerprint of invoice.
+   * @param {object} invoice - JSON object.
+   * @returns {string} Fingerprint.
+   * @memberof FAMISDb
+   */
+  getInvoiceFingerPrint(invoice) {
+    const fingerPrint = revisionHash(
+      JSON.stringify(
+        sortObjectKeys(invoice),
+        (_k, v) => v
+      )
+    );
+    return fingerPrint;
+  }
+  /**
+   * Return formatted account number.
+   * @param {string} accountNumber - Unformatted 13-digit FAMIS account number.
+   * @returns {string} Formatted 13-digit FAMIS account number.
+   * @memberof FAMISDb
+   */
+  formatAccountNumber(accountNumber) {
+    const formatted = accountNumber.replace(/(\d{2})(\d{6})(\d{5})/, "$1-$2-$3");
+    return formatted;
+  }
+  /**
+   * Is invoice flagged by SRS high-risk policies.
+   * @param {object} invoice - JSON object.
+   * @returns {Promise<HighRisk>} High-risk object.
+   * @memberof FAMISDb
+   */
+  async isSrsHighRisk(invoice) {
+    let srsHighRisk = false;
+    const objectCodes = /* @__PURE__ */ new Map();
+    try {
+      await awaity.each(
+        invoice.data.details,
+        async (detail) => {
+          if (detail.famis.customerAccountNumber && detail.famis.sellingCampusCode) {
+            const acct = await this.getByAccountNumber(detail.famis.customerAccountNumber, detail.famis.sellingCampusCode);
+            const objCode = await this.getRevenueCode(detail.sellingObjectCode);
+            const isFederal = acct && acct.cfda_no && (acct.sponsor_type && acct.sponsor_type === "F");
+            const srsApproved = invoice.replace_data && "srs_approved" in invoice.replace_data ? invoice.replace_data.srs_approved : false;
+            if (objCode && objCode.srs && acct && acct.srs && isFederal && !srsApproved && invoice.isIdt) {
+              srsHighRisk = true;
+              let val = [detail];
+              if (objectCodes.has(objCode.expense))
+                val.push(...objectCodes.get(objCode.expense));
+              objectCodes.set(objCode.expense, val);
+            }
+          }
+        }
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    return {
+      isHighRisk: srsHighRisk,
+      flaggedTransactions: Object.fromEntries(objectCodes)
+    };
+  }
+  /**
+   * @typedef {Object} Comment
+   * @property {integer} id - db generated id
+   * @property {string} uid - uid
+   * @property {string} invoice_id - invoice id
+   * @property {string} user_id - user uid
+   * @property {string} comment - text of comment
+   * @property {string} type - type of comment
+   * @property {date} created - created date
+   * @property {date} deleted - deleted date
+   */
+  /**
+   * Create or update an invoice comment.
+   * @param {Comment} comment - JSON object representing the comment
+   * @returns {Promise<Comment>} - Promise that resolves to the comment object
+   * @memberof FAMISDb
+   */
+  async saveComment(comment) {
+    const returningColumns2 = [
+      "id",
+      "uid",
+      "invoice_id",
+      "user_id",
+      "comment",
+      "type",
+      "created",
+      "deleted"
+    ];
+    let response;
+    try {
+      const records = await this.db("invoice_comments").where({ uid: comment.uid });
+      if (records.length) {
+        response = await this.db("invoice_comments").returning(returningColumns2).update(comment).where("uid", comment.uid);
+      } else {
+        response = await this.db("invoice_comments").returning(returningColumns2).insert(comment);
+      }
+      if (response && Array.isArray(response) && response.length) {
+        response = response[0];
+      }
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Get comments associated with an invoice.
+   * @param {string} invoiceUid - Invoice UID
+   * @returns {Promise<Comment[]>} - Promise that resolves to an array of comment objects
+   * @memberof FAMISDb
+   */
+  async getInvoiceComments(invoiceUid) {
+    let self = this;
+    let response;
+    try {
+      const records = await this.db("invoice_comments").select(
+        "invoice_comments.*"
+      ).where({ invoice_id: invoiceUid }).orderBy("created", "desc");
+      response = await awaity.map(
+        records,
+        async (r) => {
+          const retVal = r;
+          const files = await self.getCommentFiles(r.uid);
+          r.files = files;
+          if (self.people) {
+            const user = await self.people.getByUid(r.user_id);
+            if (user) {
+              retVal.user = user;
+            }
+          }
+          return retVal;
+        }
+      );
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * @typedef {Object} CommentFile
+   * @property {integer} id - db generated id
+   * @property {string} uid - uid
+   * @property {string} invoice_id - invoice uid
+   * @property {string} comment_id - comment uid
+   * @property {string} original_filename - original file name
+   * @property {string} filename - generate unique filename on filesystem
+   * @property {date} created - created date
+   * @property {date} deleted - deleted date
+   */
+  /**
+   * Get invoice comment files.
+   * @param {string} commentUid - Comment UID
+   * @returns {Promise<CommentFile[]>} - Promise that resolves to an array of comment file objects
+   * @memberof FAMISDb
+   */
+  async getCommentFiles(commentUid) {
+    let response = [];
+    try {
+      const records = await this.db("invoice_comment_files").where({ comment_id: commentUid }).orderBy("created", "desc");
+      response = records;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Get invoice comment file.
+   * @param {string} fileUid - File UID
+   * @returns {Promise<CommentFile>} - Promise that resolves to a comment file object
+   * @memberof FAMISDb
+   */
+  async getCommentFile(fileUid) {
+    let response = null;
+    try {
+      const records = await this.db("invoice_comment_files").where({ uid: fileUid });
+      if (records.length)
+        response = records[0];
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Represents a row in the public.core_account_emails table.
+   *
+   * @interface CoreAccountEmail
+   * @property {string} uid - The unique identifier for the account email.
+   * @property {number} core_id - The core ID associated with the account email.
+   * @property {string} account_number - The account number associated with the email.
+   * @property {string} email - The email address associated with the account.
+   * @property {Date | null} [created] - The timestamp when the account email was created. Nullable.
+   * @property {Date | null} [deleted] - The timestamp when the account email was deleted. Nullable.
+   */
+  /**
+   * Get additional delivery email to an expense accounts by uid
+   * @param {string} uid - additional delivery email record uid
+   * @returns {Promise<CoreAccountEmail|null>} - Promise that resolves to an account object
+   * @memberof FAMISDb
+   */
+  async getCoreAccountAdditionalEmailByUid(uid) {
+    let response = null;
+    try {
+      const records = await this.db("core_account_emails").where({ uid });
+      response = records.length ? records[0] : records;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Get additional delivery emails to expense accounts for a core by core id
+   * @param {number} coreId - Core ID
+   * @returns {Promise<CoreAccountEmail[]|[]>} - Promise that resolves to an account object
+   * @memberof FAMISDb
+   */
+  async getCoreAccountAdditionalEmailsByCoreId(coreId) {
+    let response = [];
+    try {
+      const records = await this.db("core_account_emails").where({ core_id: coreId });
+      response = records;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Get additional delivery emails to expense accounts for a core by account number
+   * @param {string} accountNumber - 13 digit famis account or customernumber
+   * @returns {Promise<CoreAccountEmail[]|[]>} - Promise that resolves to an account object
+   * @memberof FAMISDb
+   */
+  async getCoreAccountAdditionalEmailsByAccount(accountNumber) {
+    let response = [];
+    try {
+      const records = await this.db("core_account_emails").where({ account_number: accountNumber });
+      response = records;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Add an additional delivery email to an expense account for a core
+   * @param {string} accountNumber - 13 digit famis account or customernumber
+   * @param {number} coreId - Core ID
+   * @param {string} email - email address
+   * @returns {Promise<CoreAccountEmail>} - Promise that resolves to an account object
+   * @memberof FAMISDb
+   */
+  async addCoreAccountAdditionalEmails(accountNumber, coreId, email) {
+    let response = null;
+    const columns = ["uid", "core_id", "account_number", "email", "created", "deleted"];
+    try {
+      const records = await this.db("core_account_emails").returning(columns).insert({
+        core_id: coreId,
+        account_number: accountNumber,
+        email,
+        created: this.db.raw("NOW")
+      });
+      response = records.length ? records[0] : records;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+  /**
+   * Remove an additional delivery email to an expense account for a core
+   * @param {string} uid - uid for core account email record
+   * @returns {Promise<CoreAccountEmail>} - Promise that resolves to an account object
+   * @memberof FAMISDb
+   */
+  async removeCoreAccountAdditionalEmails(uid) {
+    let response = null;
+    const columns = ["uid", "core_id", "account_number", "email", "created", "deleted"];
+    try {
+      const records = await this.db("core_account_emails").returning(columns).update({
+        deleted: this.db.raw("NOW")
+      }).where({ uid });
+      response = records.length ? records[0] : records;
+    } catch (e) {
+      console.log(e);
+      throw e;
+    }
+    return response;
+  }
+}
+
+export { FAMISDb as default };
+//# sourceMappingURL=main.js.map