daniel-san/standardEvents/index.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 _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

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

var _require2 = require('../utility/validation'),
    isUndefinedOrNull = _require2.isUndefinedOrNull;

var _require3 = require('./conditional'),
    _28DayCondition = _require3._28DayCondition;

var _require4 = require('../modulusCycle'),
    modulusPhase = _require4.modulusPhase;

var _require5 = require('../core/obliterate'),
    exclusionsPhase = _require5.exclusionsPhase;

var _require6 = require('../core/eventGeneration'),
    generateEvent = _require6.generateEvent;

var _require7 = require('../core/dateUtility'),
    getRelevantDateSegmentByFrequency = _require7.getRelevantDateSegmentByFrequency;

var _require8 = require('../constants'),
    DAILY = _require8.DAILY,
    EVALUATING_RULE_INSERTION = _require8.EVALUATING_RULE_INSERTION,
    EXECUTING_RULE_INSERTION = _require8.EXECUTING_RULE_INSERTION;

var buildStandardEvent = function buildStandardEvent(_ref) {
  var danielSan = _ref.danielSan,
      rule = _ref.rule,
      date = _ref.date,
      skipTimeTravel = _ref.skipTimeTravel,
      _ref$eventGen = _ref.eventGen,
      eventGen = _ref$eventGen === void 0 ? true : _ref$eventGen;
  var processPhase;

  try {
    var relevantDateSegmentByFrequency = getRelevantDateSegmentByFrequency({
      frequency: rule.frequency,
      date: date
    }); // treat every rule.processDate like an array for simplicity

    var processDates = [];

    if (!Array.isArray(rule.processDate)) {
      processDates.push(rule.processDate);
    } else {
      processDates = (0, _toConsumableArray2["default"])(rule.processDate);
    }

    for (var looper = 0; looper < processDates.length; looper++) {
      var processDate = processDates[looper];
      processPhase = EVALUATING_RULE_INSERTION;

      if (rule.frequency === DAILY || isUndefinedOrNull(processDate) || processDate === relevantDateSegmentByFrequency || _28DayCondition({
        processDate: processDate,
        date: date,
        frequency: rule.frequency,
        timeZone: rule.timeZone,
        timeZoneType: rule.timeZoneType
      })) {
        processPhase = exclusionsPhase({
          danielSan: danielSan,
          rule: rule,
          date: date,
          processPhase: processPhase
        });
        processPhase = modulusPhase({
          rule: rule,
          processPhase: processPhase
        });

        if (processPhase === EXECUTING_RULE_INSERTION) {
          // when we are pre-modulating the cycle during validation, we do not want to generate an event
          if (eventGen) {
            processPhase = generateEvent({
              danielSan: danielSan,
              rule: rule,
              date: date,
              skipTimeTravel: skipTimeTravel
            });
          }

          break; // exit loop
        }
      }
    }

    return processPhase;
  } catch (err) {
    throw errorDisc({
      err: err,
      data: {
        rule: rule,
        date: date,
        processPhase: processPhase,
        skipTimeTravel: skipTimeTravel,
        eventGen: eventGen
      }
    });
  }
};

module.exports = {
  buildStandardEvent: buildStandardEvent
};