@tamu-dor/famis-db 1.3.0

package/index.js

@@ -0,0 +1,1497 @@
+const knex = require('knex');
+const cuid = require('cuid');
+const { map } = require('awaity');
+const revisionHash = require('rev-hash');
+
+const famisInvoiceNumbers = [
+  {
+    start: 300128,
+    end: 399999,
+    prefix: 'I',
+    aliases: [
+      'ilabs',
+    ]
+  },
+  {
+    start: 100000,
+    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 === undefined) {
+    return obj;
+  }
+  if (typeof obj !== 'object') {
+    // it is a primitive: number/string (in an array)
+    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 {
+  constructor(config, people) {
+    if (config) {
+      this.init(config, people);
+    }
+  }
+
+  init(config, people) {
+    this.db = knex({
+      client: 'pg',
+      connection: config,
+    });
+    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: null,
+      poNumber: null,
+    };
+
+    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
+   * @returns{Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async processInvoice(invoice) {
+    // console.log(invoice);
+    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 customerAccountNumber = this.getAccountNumber(invoice.data.details[0].famis, invoice.replace_data);
+    invoice.isIdt = customerAccountNumber && (customerAccountNumber.accountNumber.substring(0,2) === account.substring(0,2));
+    invoice.customerAccountInfo = await this.getByAccountNumber(customerAccountNumber.accountNumber);
+    invoice.poNumber = customerAccountNumber.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]));
+      }
+    }
+    return invoice;
+  }
+
+
+  /**
+   *
+   * Get invoice by uid
+   * @param {string} uid
+   * @returns{Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async getInvoiceByUid(uid) {
+    let records;
+    let retVal;
+
+    try {
+      records = await this.db('invoices').where('uid', uid);
+      if (records.length) {
+        retVal = this.processInvoice(records[0]);
+      } 
+    } catch (e) {
+      throw e;
+    }
+  
+    return retVal;
+  }
+
+  /**
+   *
+   * Get invoice by originating system assigned number
+   * @param {string} number
+   * @returns{Promise<object>} invoice object
+   * @memberof FAMISDb
+   */
+  async getInvoiceByNumber(number) {
+    let records;
+    let retVal;
+
+    try {
+      records = await this.db('invoices').where('number', number);
+      if (records.length) {
+        retVal = this.processInvoice(records[0]);
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * 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 = this.processInvoice(records[0]);
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get all invoices associated with a specified account number
+   * @param {string} accountNumber
+   * @returns{Promise<array>} invoice objects
+   * @memberof FAMISDb
+   */
+  async getInvoicesByAccount(accountNumber) {
+    const self = this;
+    let records;
+    let retVal;
+
+    try {
+      let records = await this.db('invoices')
+        .whereNull('deleted')
+        .andWhere(function() {
+          this.where('customerAccount', accountNumber);
+          this.orWhere('sellingAccount', accountNumber);
+          this.orWhereRaw("replace_data->>'customerAccountNumber' = ?",[accountNumber]);
+          this.orWhereRaw("replace_data->>'customerPONumber' LIKE ?",[`${accountNumber}%`]);
+        });
+      if (records.length) {
+        records = await map(
+          records,
+          async (record) => {
+            const rec = self.processInvoice(record);
+            return rec;
+          }
+        );
+      } 
+      retVal = records;
+    } catch (e) {
+      throw e;
+    }
+  
+    return retVal;
+  }
+
+  /**
+   *
+   * Get all invoice ordered by and sorted by paramaters passed
+   * @param {string} [orderBy='date']
+   * @param {string} [dir='desc']
+   * @param {boolean} [deleted=false]
+   * @returns{Promise<array>} invoice objects
+   * @memberof FAMISDb
+   */
+  async getAllInvoices(orderBy='date', dir='desc', deleted=false) {
+    const self = this;
+    let records;
+    try {
+      const sql = this.db('invoices')
+      if (!deleted) {
+        sql.whereNull('deleted')
+      }
+      records = await sql.orderBy(orderBy, dir);
+      records = await map(
+        records,
+        async (record) => {
+          const rec = self.processInvoice(record);
+          return rec;
+        }
+      );
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * Retreives invoices from the latest date
+   * @returns{Promise<array>} invoice objects
+   * @memberof FAMISDb
+   */
+  async getLatestInvoices() {
+    const self = this;
+    let records;
+
+    try {
+      records = await this.db('invoices')
+        .whereNull('deleted')
+        .whereIn('date', function() {
+          this.max('date').from('invoices');
+        });
+      records = await map(
+        records,
+        async (record) => {
+          const rec = self.processInvoice(record);
+          return rec;
+        }
+      );
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * Returns all held invoices
+   * @returns{Promise<array>} held invoice objects 
+   * @memberof FAMISDb
+   */
+  async getHeldInvoices() {
+    const self = this;
+    let records;
+
+    try {
+      records = await this.db('invoices')
+        .whereNull('deleted')
+        .andWhere('invoiced', '0');
+      records = await map(
+        records,
+        async (record) => {
+          const rec = self.processInvoice(record);
+          return rec;
+        }
+      );
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * Returns all awaiting email invoices
+   * @returns{Promise<array>} awaiting email invoice objects 
+   * @memberof FAMISDb
+   */
+  async getInvoicesAwaitingEmail() {
+    const self = this;
+    let records;
+
+    try {
+      records = await this.db('invoices')
+        .whereNull('deleted')
+        .andWhere('emailed', 'False');
+      records = await map(
+        records,
+        async (record) => {
+          const rec = self.processInvoice(record);
+          return rec;
+        }
+      );
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * Search invoices by originating system generated invoice number
+   * @param {string} number
+   * @returns{Promise<array>} invoice objects
+   * @memberof FAMISDb
+   */
+  async searchInvoicesByNumber(number) {
+    const self = this;
+    let records;
+    let retVal;
+
+    try {
+      records = await this.db('invoices')
+        .whereNull('deleted')
+        .andWhere('number', 'ilike', `${number}%`);
+      if (records.length) {
+        retVal = await map(
+          records,
+          async (record) => {
+            const rec = self.processInvoice(record);
+            return rec;
+          }
+        );
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Search invoices by FAMIS invoice number
+   * @param {string} famis
+   * @returns{Promise<array>} invoice objects
+   * @memberof FAMISDb
+   */
+  async searchInvoicesByFamis(famis) {
+    const self = this;
+    let records;
+    let retVal;
+
+    try {
+      records = await this.db('invoices')
+        .whereNull('deleted')
+        .andWhere('famisInvoiceNumber', 'ilike', `${famis}%`);
+      if (records.length) {
+        retVal = await map(
+          records,
+          async (record) => {
+            const rec = self.processInvoice(record);
+            return rec;
+          }
+        );
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * 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 = (typeof famisInvoiceNumber === 'undefined') ? null : famisInvoiceNumber;
+      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: cuid(),
+          fingerprint: invoice.fingerprint,
+          type: type,
+          famisInvoiceNumber: 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 {
+      records = await this.db('invoices')
+        .returning(returningColumns)
+        .update({
+          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,
+        })
+        .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
+   * @returns{Promise<object>} account object
+   * @memberof FAMISDb
+   */
+  async getByAccountNumber(number) {
+    let records;
+    let retVal;
+    const self = this;
+
+    if (!number) console.log('Null account number');
+    try {
+      records = await this.db('accounts')
+        .leftJoin('departments',
+          function() {
+            this
+              .on('accounts.department', '=', 'departments.dept')
+              .on('departments.part', '=', self.db.raw('?', [number.substring(0,2)]))
+          }
+        )
+        .leftJoin('accounts as parent_account',
+          function() {
+            this
+              .on('accounts.campus_code', '=', 'parent_account.campus_code')
+              .on('accounts.account', '=', 'parent_account.account')
+              .on('parent_account.support_account', '=', self.db.raw('?', ["00000"]))
+              .on('accounts.fiscal_year', '=', 'parent_account.fiscal_year')
+          }
+        )
+        .select(
+          'accounts.*',
+          '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('accounts.account_number', number);
+      if (records.length) {
+        retVal = records[0];
+      } else {
+        records = await this.db('customers')
+          .where('account_number', number);
+        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} number
+   * @returns{Promise<array>} account object(s)
+   * @memberof FAMISDb
+   */
+  async searchByAccountNumber(number) {
+    let records;
+    const self = this;
+
+    try {
+      const pis = await this.db('accounts')
+        .leftJoin('departments',
+          function() {
+            this
+              .on('accounts.department', '=', 'departments.dept')
+              .on('departments.part', '=', self.db.raw('?', [number.substring(0,2)]))
+          }
+        )
+        .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', `%${number}%`);
+      const customers = await this.db('customers')
+        .where('customers.account_number', 'ilike', `%${number}%`)
+        .whereNotIn('customers.account_number', pis.map(p => p.account_number));
+      records = [...customers, ...pis];
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * Get PI Accounts by UIN
+   * @param {string} uin
+   * @returns{Promise<array>} account object array
+   * @memberof FAMISDb
+   */
+  async getAccountsByUin(uin) {
+    let records;
+    const self = this;
+
+    try {
+      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', uin);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * Get PI accounts by responsible UIN
+   * @param {string} uin
+   * @returns{Promise<array>} account object array
+   * @memberof FAMISDb
+   */
+  async getAccountsByResponsibleUin(uin) {
+    let records;
+    const self = this;
+
+    try {
+      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('responsible_uin', uin);
+    } catch (e) {
+      throw e;
+    }
+    return records;
+  }
+
+  /**
+   *
+   * 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;
+    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('uid', '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 getExpenseCode(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;
+  }
+
+  /**
+   *
+   * Get revenue code object
+   * @param {string} revenue
+   * @returns{Promise<object>} 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;
+  }
+
+  /**
+   *
+   * Check if expense code is within the allowable range for specified account and the specified fiscal year (defaults to current)
+   * @param {string} account
+   * @param {string} code
+   * @param {integer} fiscal
+   * @returns{Promise<boolean>} truthy value
+   * @memberof FAMISDb
+   */
+  async allowableExpenseCode(accountNumber, code, fiscal) {
+    let records;
+    let retVal = false;
+    let d = new Date();
+    let 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 specified account
+   * @param {string} account
+   * @returns{Promise<boolean>} expense code range object(s)
+   * @memberof FAMISDb
+   */
+  async getAllowableExpenseCodes(accountNumber, fiscal) {
+    let abr;
+    let subcode;
+    let disallowed;
+    let retVal = {
+      allowed: [],
+      disallowed: [],
+    };
+    let 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;
+  }
+
+   /**
+   *
+   * Get core by id
+   * @param {string} id
+   * @returns{Promise<object>} core object
+   * @memberof FAMISDb
+   */
+  async getCoreById(id) {
+    let records;
+    let retVal;
+    try {
+      const maxDates = this.db('core_accounts')
+        .select(
+          'coreId'
+        )
+        .max('effective', {as: 'effective'})
+        .groupBy('coreId')
+        .where('effective', '<=', this.db.raw('now()'))
+        .as("max_dates");
+      const accounts = this.db('core_accounts')
+        .select(
+          'core_accounts.coreId',
+          'core_accounts.account',
+          'core_accounts.effective',
+        )
+        .join(maxDates,
+          function() {
+            this
+              .on('core_accounts.coreId', '=', 'max_dates.coreId')
+              .andOn('core_accounts.effective', '=', 'max_dates.effective')
+          }
+        )
+        .as("core_accounts");
+      records = await this.db('cores')
+        .select(
+          'cores.id',
+          'core_accounts.account',
+          'core_accounts.effective',
+          'cores.facility',
+          'cores.contact',
+          'cores.contactEmail',
+          'cores.systemId',
+          'system.name as partName',
+          'system.part as partNumber',
+          'cores.enabled',
+          'cores.deleted',
+          'cores.coreEmail',
+          'cores.corePhone',
+          'cores.coreAddress',
+          'cores.from_email',
+          'cores.invoice_email'
+        )
+        .join(accounts, 'cores.id', '=', 'core_accounts.coreId')
+        .join('system', 'cores.systemId', '=', 'system.id')
+        .where('cores.id', id)
+        .orderBy('cores.id', 'desc');
+      if (records.length) {
+        retVal = records[0];
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get core by account number
+   * @param {string} account
+   * @returns{Promise<object>} core object
+   * @memberof FAMISDb
+   */
+  async getCoreByAccount(account) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db('cores')
+        .select(
+          'cores.id',
+          'core_accounts.account',
+          'core_accounts.effective',
+          '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('core_accounts.account', account)
+        .orderBy('cores.id', 'desc');
+      if (records.length) {
+        retVal = records[0];
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get core current revenue account number
+   * @param {string} coreId
+   * @returns{Promise<object>} core object
+   * @memberof FAMISDb
+   */
+  async getCoreCurrentAccount(coreId) {
+    let records;
+    let retVal;
+    try {
+      const maxDates = this.db('core_accounts')
+        .select(
+          'coreId'
+        )
+        .max('effective', {as: 'effective'})
+        .groupBy('coreId')
+        .where('effective', '<=', this.db.raw('now()'))
+        .andWhere('coreId', '=', coreId)
+        .as("max_dates");
+      const accounts = this.db('core_accounts')
+        .select(
+          'core_accounts.coreId',
+          'core_accounts.account',
+          'core_accounts.effective',
+        )
+        .join(maxDates,
+          function() {
+            this
+              .on('core_accounts.coreId', '=', 'max_dates.coreId')
+              .andOn('core_accounts.effective', '=', 'max_dates.effective')
+          }
+        )
+        .as("core_accounts");
+      records = await this.db('cores')
+        .select(
+          'cores.id',
+          'core_accounts.account',
+          'core_accounts.effective',
+          '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(accounts, 'cores.id', '=', 'core_accounts.coreId')
+        .orderBy('cores.id', 'desc');
+      if (records.length) {
+        retVal = records[0];
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get system part by ID
+   * @param {number} id
+   * @returns{Promise<object>} 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<object>} 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
+   * @param {string} date
+   * @returns{Promise<array>} core objects
+   * @memberof FAMISDb
+   */
+  async getEnabledCores(date) {
+    let records;
+    let retVal = [];
+    try {
+      const maxDates = this.db('core_accounts')
+        .select(
+          'coreId'
+        )
+        .max('effective', {as: 'effective'})
+        .groupBy('coreId')
+        .where('effective', '<=', date ? date : this.db.raw('now()'))
+        .as("max_dates");
+      const accounts = this.db('core_accounts')
+        .select(
+          'core_accounts.coreId',
+          'core_accounts.account',
+          'core_accounts.effective',
+        )
+        .join(maxDates,
+          function() {
+            this
+              .on('core_accounts.coreId', '=', 'max_dates.coreId')
+              .andOn('core_accounts.effective', '=', 'max_dates.effective')
+          }
+        )
+        .as("core_accounts");
+      records = await this.db('cores')
+        .select(
+          'cores.id',
+          'core_accounts.account',
+          'core_accounts.effective',
+          '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(accounts, 'cores.id', '=', 'core_accounts.coreId')
+        .where('enabled', '1')
+        .orderBy('cores.id', 'desc');
+      if (records.length) {
+        retVal = records;
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get all cores
+   * @returns{Promise<array>} core objects
+   * @memberof FAMISDb
+   */
+  async getAllCores() {
+    let records;
+    let retVal = [];
+    try {
+      records = await this.db('cores').orderBy('id', 'asc');
+      if (records.length) {
+        retVal = records;
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get a core's users by core ID
+   * @param {number} coreId
+   * @returns{Promise<array>} 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;
+  }
+
+  /**
+   *
+   * Get a user's cores they manage
+   * @param {string} userId
+   * @returns{Promise<array>} core objects
+   * @memberof FAMISDb
+   */
+  async getUserCores(userId) {
+    let retVal;
+    try {
+      retVal = await 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',
+        );
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get a system part's users by system ID
+   * @param {number} systemId
+   * @returns{Promise<array>} 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 {*} userId
+   * @returns{Promise<object>} system objects
+   * @memberof FAMISDb
+   */
+  async getUserSystemParts(userId) {
+    let records;
+    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;
+  }
+
+  /**
+   *
+   * Get all system parts
+   * @returns{Promise<object>} system objects
+   * @memberof FAMISDb
+   */
+  async getAllSystemParts() {
+    let records;
+    let retVal;
+    try {
+      retVal = await this.db('system').orderBy('id', 'asc');
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get user
+   * @param {string} userId
+   * @returns{Promise<object>} user object
+   * @memberof FAMISDb
+   */
+  async getUser(userId) {
+    let records;
+    let retVal;
+    try {
+      records = await this.db('users').where('userId', userId);
+      if (records.length) {
+        retVal = records[0];
+        retVal.cores = await this.getUserCores(userId);
+        retVal.systems = await this.getUserSystemParts(userId);
+      } 
+    } catch (e) {
+      throw e;
+    }
+    return retVal;
+  }
+
+  /**
+   *
+   * Get customer by customer account number
+   * @param {string} accountNumber
+   * @param {string} campusCode
+   * @returns{Promise<object>} customer account object
+   * @memberof FAMISDb
+   */
+  async getCustomerNumber(accountNumber, campusCode) {
+    let records;
+    let retVal;
+    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{<integer>} fiscal year
+   * @memberof FAMISDb
+   */
+  getCurrentFiscalYear() {
+    let year;
+    let today = 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) => undefined ? "undef" : v
+      )
+    );
+    return fingerPrint;
+  }
+
+  /**
+   *
+   * Return formatted account number
+   * @param {string} accountNumber unformatted 13 digit famis account number
+   * @returns{<string>} formatted 13 digits famis account number
+   * @memberof FAMISDb
+   */
+  formatAccountNumber(accountNumber) {
+    const formatted = accountNumber.replace(/(\d{2})(\d{6})(\d{5})/, "$1-$2-$3");
+
+    return formatted;
+  }
+}
+
+module.exports = FAMISDb;