daniel-san/core/eventGeneration.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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

var moment = require('moment');

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

var _require2 = require('../constants'),
    UTC = _require2.UTC,
    DATE_FORMAT_STRING = _require2.DATE_FORMAT_STRING,
    MODIFIED = _require2.MODIFIED,
    DATE_TIME_DELIMITER = _require2.DATE_TIME_DELIMITER,
    TIME_FORMAT_STRING = _require2.TIME_FORMAT_STRING,
    EVENT = _require2.EVENT;
/* TODO: for some reason, npm was throwing the following warning when attempting
    to require createTimeZone from the timeZone directory, so it had to be redefined here:

    warning message as follows:

    Warning: Accessing non-existent property 'createTimeZone' of module exports inside circular dependency
*/


var createTimeZone = function createTimeZone(_ref) {
  var timeZone = _ref.timeZone,
      timeZoneType = _ref.timeZoneType,
      _ref$date = _ref.date,
      date = _ref$date === void 0 ? null : _ref$date,
      _ref$dateString = _ref.dateString,
      dateString = _ref$dateString === void 0 ? null : _ref$dateString,
      _ref$timeString = _ref.timeString,
      timeString = _ref$timeString === void 0 ? null : _ref$timeString;

  try {
    var DATE_TIME_FORMAT_STRING = timeString ? "".concat(DATE_FORMAT_STRING).concat(DATE_TIME_DELIMITER).concat(TIME_FORMAT_STRING) : DATE_FORMAT_STRING;
    var dateTimeString = timeString ? "".concat(dateString).concat(DATE_TIME_DELIMITER).concat(timeString) : dateString;
    var outputDate = date; // default value

    var thisMoment = timeZoneType === UTC ? moment.utc : moment.tz; // process date

    if (date) {
      outputDate = thisMoment(date, timeZone);
    } else {
      outputDate = thisMoment(dateTimeString, DATE_TIME_FORMAT_STRING, timeZone);
    }

    return outputDate;
  } catch (err) {
    throw errorDisc({
      err: err,
      data: {
        date: date,
        timeZone: timeZone,
        timeZoneType: timeZoneType,
        dateString: dateString,
        timeString: timeString
      }
    });
  }
};

var generateTimeSpan = function generateTimeSpan(_ref2) {
  var event = _ref2.event,
      date = _ref2.date,
      weekday = _ref2.weekday;
  event.weekdayStart = weekday;
  event.timeEnd = null;

  if (event.timeStart) {
    var spanningTime = false;
    var targetTimeEndDateClone = date;

    if (event.spanningMinutes) {
      targetTimeEndDateClone.add(event.spanningMinutes, 'minute');
      spanningTime = true;
    }

    if (event.spanningHours) {
      targetTimeEndDateClone.add(event.spanningHours, 'hour');
      spanningTime = true;
    }

    if (event.spanningDays) {
      targetTimeEndDateClone.add(event.spanningDays, 'day');
      spanningTime = true;
    }

    if (spanningTime) {
      var DATE_TIME_FORMAT_STRING = "".concat(DATE_FORMAT_STRING).concat(DATE_TIME_DELIMITER).concat(TIME_FORMAT_STRING);
      var dateTimeString = targetTimeEndDateClone.format(DATE_TIME_FORMAT_STRING); // lowercase the AM/PM

      var _dateTimeString$split = dateTimeString.split(DATE_TIME_DELIMITER),
          _dateTimeString$split2 = (0, _slicedToArray2["default"])(_dateTimeString$split, 2),
          dateString = _dateTimeString$split2[0],
          newTimeString = _dateTimeString$split2[1];

      event.dateEnd = dateString;
      event.timeEnd = newTimeString.toLowerCase();
      event.weekdayEnd = targetTimeEndDateClone.day();
    }
  }
};

var redefineTimeStartAndTimeSpan = function redefineTimeStartAndTimeSpan(_ref3) {
  var event = _ref3.event,
      _ref3$skipTimeTravel = _ref3.skipTimeTravel,
      skipTimeTravel = _ref3$skipTimeTravel === void 0 ? null : _ref3$skipTimeTravel;

  if (!createTimeZone) {
    // TODO: check to see why this function was undefined at runtime
    createTimeZone = require('../timeZone').createTimeZone; // eslint-disable-line global-require
  }

  var newTargetTimeStartDate = createTimeZone({
    timeZone: event.timeZone,
    timeZoneType: event.timeZoneType,
    dateString: event.dateStart,
    timeString: event.timeStart
  });
  event.dateTimeStartEventSource = newTargetTimeStartDate; // for future convenience, store the full original moment-timezone date from the rule

  event.dateTimeStartObserverSource = newTargetTimeStartDate; // default value (in the event that timeTravel does not execute)
  // note: perform the following only if skipTimeTravel is true since it would otherwise execute the same pattern with converted values
  // define timeStart
  // then define dateEnd / timeEnd IF there is a timeStart

  if (skipTimeTravel) {
    if (event.timeStart) {
      var DATE_TIME_FORMAT_STRING = "".concat(DATE_FORMAT_STRING).concat(DATE_TIME_DELIMITER).concat(TIME_FORMAT_STRING);
      var dateTimeString = newTargetTimeStartDate.format(DATE_TIME_FORMAT_STRING); // lowercase the AM/PM

      var _dateTimeString$split3 = dateTimeString.split(DATE_TIME_DELIMITER),
          _dateTimeString$split4 = (0, _slicedToArray2["default"])(_dateTimeString$split3, 2),
          dateString = _dateTimeString$split4[0],
          newTimeString = _dateTimeString$split4[1];

      event.timeStart = newTimeString;
    } else {
      event.timeStart = null;
    }

    generateTimeSpan({
      event: event,
      date: newTargetTimeStartDate,
      weekday: newTargetTimeStartDate.day()
    });
  }
};
/*
    function: generateEvent
    description:
        when a rule satisfies all of its conditions, the rule gets imprinted as an event in this function

*/


var generateEvent = function generateEvent(_ref4) {
  var danielSan = _ref4.danielSan,
      rule = _ref4.rule,
      date = _ref4.date,
      _ref4$skipTimeTravel = _ref4.skipTimeTravel,
      skipTimeTravel = _ref4$skipTimeTravel === void 0 ? null : _ref4$skipTimeTravel;

  var newEvent = _objectSpread({}, rule);

  newEvent.entityType = EVENT; // can be used to categorize if an object is a rule, event, or an aggregate
  // define dateStart

  newEvent.dateStart = date.format(DATE_FORMAT_STRING); // whether or not we timeTravel, the output timeZone is always assumed to be from OBSERVER_SOURCE

  newEvent.timeZone = danielSan.config.timeZone;
  newEvent.timeZoneType = danielSan.config.timeZoneType; // this is currently redundant since we are auto-assigning the danielSan value to event???
  // however, if we ever want to change that behavior and add additional options, we'd still want to be sure that this value matches the event output???

  newEvent.eventSourceTimeZoneType = newEvent.timeZoneType; // for future convenience

  newEvent.eventSourceTimeZone = newEvent.timeZone; // default value and for future convenience
  // related code block

  redefineTimeStartAndTimeSpan({
    event: newEvent,
    skipTimeTravel: skipTimeTravel
  });
  danielSan.events.push(_objectSpread({}, newEvent));
  var processPhase = MODIFIED;
  return processPhase;
};

module.exports = {
  redefineTimeStartAndTimeSpan: redefineTimeStartAndTimeSpan,
  generateTimeSpan: generateTimeSpan,
  generateEvent: generateEvent
};