Projektstart

backend/node_modules/cron-parser/lib/date.js

@@ -0,0 +1,252 @@
+'use strict';
+
+var luxon = require('luxon');
+
+CronDate.prototype.addYear = function() {
+  this._date = this._date.plus({ years: 1 });
+};
+
+CronDate.prototype.addMonth = function() {
+  this._date = this._date.plus({ months: 1 }).startOf('month');
+};
+
+CronDate.prototype.addDay = function() {
+  this._date = this._date.plus({ days: 1 }).startOf('day');
+};
+
+CronDate.prototype.addHour = function() {
+  var prev = this._date;
+  this._date = this._date.plus({ hours: 1 }).startOf('hour');
+  if (this._date <= prev) {
+    this._date = this._date.plus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.addMinute = function() {
+  var prev = this._date;
+  this._date = this._date.plus({ minutes: 1 }).startOf('minute');
+  if (this._date < prev) {
+    this._date = this._date.plus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.addSecond = function() {
+  var prev = this._date;
+  this._date = this._date.plus({ seconds: 1 }).startOf('second');
+  if (this._date < prev) {
+    this._date = this._date.plus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.subtractYear = function() {
+  this._date = this._date.minus({ years: 1 });
+};
+
+CronDate.prototype.subtractMonth = function() {
+  this._date = this._date
+    .minus({ months: 1 })
+    .endOf('month')
+    .startOf('second');
+};
+
+CronDate.prototype.subtractDay = function() {
+  this._date = this._date
+    .minus({ days: 1 })
+    .endOf('day')
+    .startOf('second');
+};
+
+CronDate.prototype.subtractHour = function() {
+  var prev = this._date;
+  this._date = this._date
+    .minus({ hours: 1 })
+    .endOf('hour')
+    .startOf('second');
+  if (this._date >= prev) {
+    this._date = this._date.minus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.subtractMinute = function() {
+  var prev = this._date;
+  this._date = this._date.minus({ minutes: 1 })
+    .endOf('minute')
+    .startOf('second');
+  if (this._date > prev) {
+    this._date = this._date.minus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.subtractSecond = function() {
+  var prev = this._date;
+  this._date = this._date
+    .minus({ seconds: 1 })
+    .startOf('second');
+  if (this._date > prev) {
+    this._date = this._date.minus({ hours: 1 });
+  }
+};
+
+CronDate.prototype.getDate = function() {
+  return this._date.day;
+};
+
+CronDate.prototype.getFullYear = function() {
+  return this._date.year;
+};
+
+CronDate.prototype.getDay = function() {
+  var weekday = this._date.weekday;
+  return weekday == 7 ? 0 : weekday;
+};
+
+CronDate.prototype.getMonth = function() {
+  return this._date.month - 1;
+};
+
+CronDate.prototype.getHours = function() {
+  return this._date.hour;
+};
+
+CronDate.prototype.getMinutes = function() {
+  return this._date.minute;
+};
+
+CronDate.prototype.getSeconds = function() {
+  return this._date.second;
+};
+
+CronDate.prototype.getMilliseconds = function() {
+  return this._date.millisecond;
+};
+
+CronDate.prototype.getTime = function() {
+  return this._date.valueOf();
+};
+
+CronDate.prototype.getUTCDate = function() {
+  return this._getUTC().day;
+};
+
+CronDate.prototype.getUTCFullYear = function() {
+  return this._getUTC().year;
+};
+
+CronDate.prototype.getUTCDay = function() {
+  var weekday = this._getUTC().weekday;
+  return weekday == 7 ? 0 : weekday;
+};
+
+CronDate.prototype.getUTCMonth = function() {
+  return this._getUTC().month - 1;
+};
+
+CronDate.prototype.getUTCHours = function() {
+  return this._getUTC().hour;
+};
+
+CronDate.prototype.getUTCMinutes = function() {
+  return this._getUTC().minute;
+};
+
+CronDate.prototype.getUTCSeconds = function() {
+  return this._getUTC().second;
+};
+
+CronDate.prototype.toISOString = function() {
+  return this._date.toUTC().toISO();
+};
+
+CronDate.prototype.toJSON = function() {
+  return this._date.toJSON();
+};
+
+CronDate.prototype.setDate = function(d) {
+  this._date = this._date.set({ day: d });
+};
+
+CronDate.prototype.setFullYear = function(y) {
+  this._date = this._date.set({ year: y });
+};
+
+CronDate.prototype.setDay = function(d) {
+  this._date = this._date.set({ weekday: d });
+};
+
+CronDate.prototype.setMonth = function(m) {
+  this._date = this._date.set({ month: m + 1 });
+};
+
+CronDate.prototype.setHours = function(h) {
+  this._date = this._date.set({ hour: h });
+};
+
+CronDate.prototype.setMinutes = function(m) {
+  this._date = this._date.set({ minute: m });
+};
+
+CronDate.prototype.setSeconds = function(s) {
+  this._date = this._date.set({ second: s });
+};
+
+CronDate.prototype.setMilliseconds = function(s) {
+  this._date = this._date.set({ millisecond: s });
+};
+
+CronDate.prototype._getUTC = function() {
+  return this._date.toUTC();
+};
+
+CronDate.prototype.toString = function() {
+  return this.toDate().toString();
+};
+
+CronDate.prototype.toDate = function() {
+  return this._date.toJSDate();
+};
+
+CronDate.prototype.isLastDayOfMonth = function() {
+  //next day
+  var newDate = this._date.plus({ days: 1 }).startOf('day');
+  return this._date.month !== newDate.month;
+};
+
+/**
+ * Returns true when the current weekday is the last occurrence of this weekday
+ * for the present month.
+ */
+CronDate.prototype.isLastWeekdayOfMonth = function() {
+  // Check this by adding 7 days to the current date and seeing if it's
+  // a different month
+  var newDate = this._date.plus({ days: 7 }).startOf('day');
+  return this._date.month !== newDate.month;
+};
+
+function CronDate (timestamp, tz) {
+  var dateOpts = { zone: tz };
+  if (!timestamp) {
+    this._date = luxon.DateTime.local();
+  } else if (timestamp instanceof CronDate) {
+    this._date = timestamp._date;
+  } else if (timestamp instanceof Date) {
+    this._date = luxon.DateTime.fromJSDate(timestamp, dateOpts);
+  } else if (typeof timestamp === 'number') {
+    this._date = luxon.DateTime.fromMillis(timestamp, dateOpts);
+  } else if (typeof timestamp === 'string') {
+    this._date = luxon.DateTime.fromISO(timestamp, dateOpts);
+    this._date.isValid || (this._date = luxon.DateTime.fromRFC2822(timestamp, dateOpts));
+    this._date.isValid || (this._date = luxon.DateTime.fromSQL(timestamp, dateOpts));
+    // RFC2822-like format without the required timezone offset (used in tests)
+    this._date.isValid || (this._date = luxon.DateTime.fromFormat(timestamp, 'EEE, d MMM yyyy HH:mm:ss', dateOpts));
+  }
+
+  if (!this._date || !this._date.isValid) {
+    throw new Error('CronDate: unhandled timestamp: ' + JSON.stringify(timestamp));
+  }
+  
+  if (tz && tz !== this._date.zoneName) {
+    this._date = this._date.setZone(tz);
+  }
+}
+
+module.exports = CronDate;

backend/node_modules/cron-parser/lib/field_compactor.js

@@ -0,0 +1,70 @@
+'use strict';
+
+function buildRange(item) {
+  return {
+    start: item,
+    count: 1
+  };
+}
+
+function completeRangeWithItem(range, item) {
+  range.end = item;
+  range.step = item - range.start;
+  range.count = 2;
+}
+
+function finalizeCurrentRange(results, currentRange, currentItemRange) {
+  if (currentRange) {
+    // Two elements do not form a range so split them into 2 single elements
+    if (currentRange.count === 2) {
+      results.push(buildRange(currentRange.start));
+      results.push(buildRange(currentRange.end));
+    } else {
+      results.push(currentRange);
+    }
+  }
+  if (currentItemRange) {
+    results.push(currentItemRange);
+  }
+}
+
+function compactField(arr) {
+  var results = [];
+  var currentRange = undefined;
+
+  for (var i = 0; i < arr.length; i++) {
+    var currentItem = arr[i];
+    if (typeof currentItem !== 'number') {
+      // String elements can't form a range
+      finalizeCurrentRange(results, currentRange, buildRange(currentItem));
+      currentRange = undefined;
+    } else if (!currentRange) {
+      // Start a new range
+      currentRange = buildRange(currentItem);
+    } else if (currentRange.count === 1) {
+      // Guess that the current item starts a range
+      completeRangeWithItem(currentRange, currentItem);
+    } else {
+      if (currentRange.step === currentItem - currentRange.end) {
+        // We found another item that matches the current range
+        currentRange.count++;
+        currentRange.end = currentItem;
+      } else if (currentRange.count === 2) { // The current range can't be continued
+        // Break the first item of the current range into a single element, and try to start a new range with the second item
+        results.push(buildRange(currentRange.start));
+        currentRange = buildRange(currentRange.end);
+        completeRangeWithItem(currentRange, currentItem);
+      } else {
+        // Persist the current range and start a new one with current item
+        finalizeCurrentRange(results, currentRange);
+        currentRange = buildRange(currentItem);
+      }
+    }
+  }
+
+  finalizeCurrentRange(results, currentRange);
+
+  return results;
+}
+
+module.exports = compactField;

backend/node_modules/cron-parser/lib/field_stringify.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var compactField = require('./field_compactor');
+
+function stringifyField(arr, min, max) {
+  var ranges = compactField(arr);
+  if (ranges.length === 1) {
+    var singleRange = ranges[0];
+    var step = singleRange.step;
+    if (step === 1 && singleRange.start === min && singleRange.end === max) {
+      return '*';
+    }
+    if (step !== 1 && singleRange.start === min && singleRange.end === max - step + 1) {
+      return '*/' + step;
+    }
+  }
+
+  var result = [];
+  for (var i = 0, l = ranges.length; i < l; ++i) {
+    var range = ranges[i];
+    if (range.count === 1) {
+      result.push(range.start);
+      continue;
+    }
+
+    var step = range.step;
+    if (range.step === 1) {
+      result.push(range.start + '-' + range.end);
+      continue;
+    }
+
+    var multiplier = range.start == 0 ? range.count - 1 : range.count;
+    if (range.step * multiplier > range.end) {
+      result = result.concat(
+         Array
+          .from({ length: range.end - range.start + 1 })
+          .map(function (_, index) {
+            var value = range.start + index;
+            if ((value - range.start) % range.step === 0) {
+              return value;
+            }
+            return null;
+          })
+          .filter(function (value) {
+            return value != null;
+          })
+      );
+    } else if (range.end === max - range.step + 1) {
+      result.push(range.start + '/' + range.step);
+    } else {
+      result.push(range.start + '-' + range.end + '/' + range.step);
+    }
+  }
+
+  return result.join(',');
+}
+
+module.exports = stringifyField;

backend/node_modules/cron-parser/lib/parser.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var CronExpression = require('./expression');
+
+function CronParser() {}
+
+/**
+ * Parse crontab entry
+ *
+ * @private
+ * @param {String} entry Crontab file entry/line
+ */
+CronParser._parseEntry = function _parseEntry (entry) {
+  var atoms = entry.split(' ');
+
+  if (atoms.length === 6) {
+    return {
+      interval: CronExpression.parse(entry)
+    };
+  } else if (atoms.length > 6) {
+    return {
+      interval: CronExpression.parse(
+        atoms.slice(0, 6).join(' ')
+      ),
+      command: atoms.slice(6, atoms.length)
+    };
+  } else {
+    throw new Error('Invalid entry: ' + entry);
+  }
+};
+
+/**
+ * Wrapper for CronExpression.parser method
+ *
+ * @public
+ * @param {String} expression Input expression
+ * @param {Object} [options] Parsing options
+ * @return {Object}
+ */
+CronParser.parseExpression = function parseExpression (expression, options) {
+  return CronExpression.parse(expression, options);
+};
+
+/**
+ * Wrapper for CronExpression.fieldsToExpression method
+ *
+ * @public
+ * @param {Object} fields Input fields
+ * @param {Object} [options] Parsing options
+ * @return {Object}
+ */
+CronParser.fieldsToExpression = function fieldsToExpression (fields, options) {
+  return CronExpression.fieldsToExpression(fields, options);
+};
+
+/**
+ * Parse content string
+ *
+ * @public
+ * @param {String} data Crontab content
+ * @return {Object}
+ */
+CronParser.parseString = function parseString (data) {
+  var blocks = data.split('\n');
+
+  var response = {
+    variables: {},
+    expressions: [],
+    errors: {}
+  };
+
+  for (var i = 0, c = blocks.length; i < c; i++) {
+    var block = blocks[i];
+    var matches = null;
+    var entry = block.trim(); // Remove surrounding spaces
+
+    if (entry.length > 0) {
+      if (entry.match(/^#/)) { // Comment
+        continue;
+      } else if ((matches = entry.match(/^(.*)=(.*)$/))) { // Variable
+        response.variables[matches[1]] = matches[2];
+      } else { // Expression?
+        var result = null;
+
+        try {
+          result = CronParser._parseEntry('0 ' + entry);
+          response.expressions.push(result.interval);
+        } catch (err) {
+          response.errors[entry] = err;
+        }
+      }
+    }
+  }
+
+  return response;
+};
+
+/**
+ * Parse crontab file
+ *
+ * @public
+ * @param {String} filePath Path to file
+ * @param {Function} callback
+ */
+CronParser.parseFile = function parseFile (filePath, callback) {
+  require('fs').readFile(filePath, function(err, data) {
+    if (err) {
+      callback(err);
+      return;
+    }
+
+    return callback(null, CronParser.parseString(data.toString()));
+  });
+};
+
+module.exports = CronParser;