daniel-san/findBalance.js

a node-based budget-projection engine that helps your routines and finances find balance. The program features aggregates, terminal and file-based reporting output, multi-currency conversion capability and multi-frequency accounting triggers, including: o

"use strict";

var _require = require('./timeStream'),
    TimeStream = _require.TimeStream;

var _require2 = require('./timeZone'),
    timeTravel = _require2.timeTravel;

var _require3 = require('./core/index'),
    buildEvents = _require3.buildEvents,
    executeEvents = _require3.executeEvents,
    cleanUpEvents = _require3.cleanUpEvents;

var _require4 = require('./core/obliterate'),
    discardEventsOutsideDateRange = _require4.discardEventsOutsideDateRange,
    deleteIrrelevantRules = _require4.deleteIrrelevantRules;

var _require5 = require('./core/validation'),
    validateConfig = _require5.validateConfig,
    validateRules = _require5.validateRules;

var _require6 = require('./core/sorting'),
    sortEvents = _require6.sortEvents;

var _require7 = require('./utility/errorHandling'),
    errorDisc = _require7.errorDisc;

var _require8 = require('./utility/dataStructures'),
    deepCopy = _require8.deepCopy;

var findBalance = function findBalance() {
  var danielSan = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  /*
      the first parameter is the entire danielSan bonsai tree of data that you configure.
      the options parameter defines execution options for enhancing performance in appropriate conditions
          if you  know for a fact that your danielSan config and rules are validated/configured according to required specification, then you can skip that phase
          likewise, you can skip deleteIrrelevantRules if you have already removed irrelevant rules manually
          and you can skip time travel when appropriate
          just keep in mind that timeTravel assumes all of the time zone fields in the rules are in sync with
          all of the time zone fields in the danielSan config
          see the options from the object destructuring below
  */
  var _options$skipValidate = options.skipValidateConfig,
      skipValidateConfig = _options$skipValidate === void 0 ? null : _options$skipValidate,
      _options$skipValidate2 = options.skipValidateRules,
      skipValidateRules = _options$skipValidate2 === void 0 ? null : _options$skipValidate2,
      _options$skipDeleteIr = options.skipDeleteIrrelevantRules,
      skipDeleteIrrelevantRules = _options$skipDeleteIr === void 0 ? null : _options$skipDeleteIr,
      _options$skipTimeTrav = options.skipTimeTravel,
      skipTimeTravel = _options$skipTimeTrav === void 0 ? null : _options$skipTimeTrav,
      _options$skipDiscardE = options.skipDiscardEventsOutsideDateRange,
      skipDiscardEventsOutsideDateRange = _options$skipDiscardE === void 0 ? null : _options$skipDiscardE,
      _options$skipCleanUpE = options.skipCleanUpEvents,
      skipCleanUpEvents = _options$skipCleanUpE === void 0 ? null : _options$skipCleanUpE;
  var newDanielSan = deepCopy(danielSan);

  try {
    if (!skipValidateConfig) {
      validateConfig(newDanielSan);
    }

    var timeZone = newDanielSan.config.timeZone;
    var timeZoneType = newDanielSan.config.timeZoneType;
    var effectiveDateStartString = newDanielSan.config.effectiveDateStart;
    var effectiveDateEndString = newDanielSan.config.effectiveDateEnd;
    var timeStartString = newDanielSan.config.timeStart;
    var timeStream = new TimeStream({
      effectiveDateStartString: effectiveDateStartString,
      effectiveDateEndString: effectiveDateEndString,
      timeStartString: timeStartString,
      timeEndString: timeStartString,
      timeZone: timeZone,
      timeZoneType: timeZoneType
    });

    if (!skipValidateRules) {
      validateRules({
        danielSan: newDanielSan,
        date: timeStream.looperDate,
        skipTimeTravel: skipTimeTravel
      });
    }

    if (!skipDeleteIrrelevantRules) {
      deleteIrrelevantRules(newDanielSan); // this follows validateRules just in case time zones were not yet assigned where they needed to be
    }

    do {
      buildEvents({
        danielSan: newDanielSan,
        date: timeStream.looperDate,
        options: options
      });
    } while (timeStream.stream1DayForward()); // note: timezones must be converted prior to sorting and executing events


    if (!skipTimeTravel) {
      timeTravel(newDanielSan);
    }

    sortEvents(newDanielSan.events); // note: events must be sorted prior to executing their linked-list style of sums

    if (!skipDiscardEventsOutsideDateRange) {
      discardEventsOutsideDateRange(newDanielSan);
    }

    executeEvents(newDanielSan);

    if (!skipCleanUpEvents) {
      cleanUpEvents(newDanielSan);
    }

    if (newDanielSan.events.length > 0) {
      newDanielSan.balanceBeginning = newDanielSan.events[0].balanceBeginning;
      newDanielSan.balanceEnding = newDanielSan.events[newDanielSan.events.length - 1].balanceEnding;
    }

    return {
      error: null,
      danielSan: newDanielSan
    };
  } catch (err) {
    return {
      err: errorDisc({
        err: err,
        data: {
          options: options
        }
      })
    };
  }
};

module.exports = findBalance;