@iobroker/adapter-react/Components/SimpleCron/index.js

React classes to develop admin interfaces for ioBroker with react.

"use strict";

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

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _react = _interopRequireDefault(require("react"));

var _propTypes = _interopRequireDefault(require("prop-types"));

var _styles = require("@material-ui/core/styles");

var _InputLabel = _interopRequireDefault(require("@material-ui/core/InputLabel"));

var _MenuItem = _interopRequireDefault(require("@material-ui/core/MenuItem"));

var _FormControl = _interopRequireDefault(require("@material-ui/core/FormControl"));

var _Select = _interopRequireDefault(require("@material-ui/core/Select"));

var _TextField = _interopRequireDefault(require("@material-ui/core/TextField"));

var _FormControlLabel = _interopRequireDefault(require("@material-ui/core/FormControlLabel"));

var _Checkbox = _interopRequireDefault(require("@material-ui/core/Checkbox"));

var _cronText = _interopRequireDefault(require("./cronText"));

var _i18n = _interopRequireDefault(require("../../i18n"));

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

var styles = function styles(theme) {
  return {
    mainDiv: {
      width: '100%',
      height: '100%',
      overflow: 'auto'
    },
    formControl: {
      margin: 0,
      minWidth: 120
    },
    formControlMarginRight: {
      marginRight: 5
    },
    formControlPaddingTop: {
      paddingTop: 6.2
    }
  };
};

var PERIODIC = {
  once: 'once',
  interval: 'interval',
  intervalBetween: 'intervalBetween',
  specific: 'specific'
};
var PERIODIC_TYPES = {
  seconds: 'seconds',
  minutes: 'minutes' //hours: 'hours',

};
var WEEKDAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];

function padding(num) {
  if (num < 10) {
    return '0' + num;
  } else {
    return '' + num;
  }
}

var DEFAULT_STATE = {
  mode: PERIODIC.interval,
  interval: {
    period: 1,
    unit: PERIODIC_TYPES.minutes
  }
};

var SimpleCron = /*#__PURE__*/function (_React$Component) {
  (0, _inherits2["default"])(SimpleCron, _React$Component);

  var _super = _createSuper(SimpleCron);

  function SimpleCron(props) {
    var _this;

    (0, _classCallCheck2["default"])(this, SimpleCron);
    _this = _super.call(this, props);
    var cron = typeof _this.props.cronExpression === 'string' ? _this.props.cronExpression.replace(/^["']/, '').replace(/["']\n?$/, '') : '';

    if (cron[0] === '{') {
      cron = '';
    }

    var state = SimpleCron.cron2state(cron || '* * * * *') || DEFAULT_STATE;
    _this.state = {
      extended: false,
      cron: SimpleCron.state2cron(state),
      mode: 'interval',
      once: {
        time: '00:00',
        date: ''
      },
      interval: {
        period: 1,
        unit: PERIODIC_TYPES.minutes
      },
      intervalBetween: {
        period: 1,
        unit: PERIODIC_TYPES.minutes,
        timeFrom: 0,
        timeTo: 24,
        weekdays: [0, 1, 2, 3, 4, 5, 6]
      },
      specific: {
        time: '00:00',
        weekdays: [0, 1, 2, 3, 4, 5, 6]
      }
    };
    Object.assign(_this.state, state);

    if (_this.state.cron !== _this.props.cronExpression) {
      setTimeout(function () {
        return _this.props.onChange && _this.props.onChange(_this.state.cron);
      }, 100);
    }

    return _this;
  }

  (0, _createClass2["default"])(SimpleCron, [{
    key: "recalcCron",
    value: function recalcCron() {
      this.onChange(SimpleCron.state2cron(this.state));
    }
  }, {
    key: "getControlsWeekdaysElements",
    value: function getControlsWeekdaysElements(type) {
      var _this2 = this;

      var settings = this.state[type];
      return /*#__PURE__*/_react["default"].createElement("div", {
        key: "weekdays",
        style: {
          paddingLeft: 8,
          width: '100%',
          maxWidth: 600
        }
      }, /*#__PURE__*/_react["default"].createElement("h5", null, _i18n["default"].t('ra_On weekdays')), [1, 2, 3, 4, 5, 6, 0].map(function (day) {
        return /*#__PURE__*/_react["default"].createElement(_FormControlLabel["default"], {
          key: WEEKDAYS[day],
          control: /*#__PURE__*/_react["default"].createElement(_Checkbox["default"], {
            checked: settings.weekdays.indexOf(day) !== -1,
            onChange: function onChange(e) {
              var settings = JSON.parse(JSON.stringify(_this2.state[type]));
              var pos = settings.weekdays.indexOf(day);
              e.target.checked && pos === -1 && settings.weekdays.push(day);
              !e.target.checked && pos !== -1 && settings.weekdays.splice(pos, 1);
              settings.weekdays.sort();

              _this2.setState((0, _defineProperty2["default"])({}, type, settings), function () {
                return _this2.recalcCron();
              });
            },
            value: day.toString()
          }),
          label: _i18n["default"].t(WEEKDAYS[day])
        });
      }));
    }
  }, {
    key: "getControlsPeriodElements",
    value: function getControlsPeriodElements(type) {
      var _this3 = this;

      var settings = this.state[type];

      if (this.state.extended) {
        return /*#__PURE__*/_react["default"].createElement("div", {
          key: "period",
          style: {
            paddingLeft: 8,
            display: 'inline-block'
          }
        }, /*#__PURE__*/_react["default"].createElement("h5", {
          style: {
            marginBottom: 5
          }
        }, _i18n["default"].t('sc_period')), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
          style: {
            marginTop: 0,
            marginBottom: 0,
            verticalAlign: 'bottom'
          },
          key: "value",
          label: _i18n["default"].t('sc_minutes'),
          value: settings.minutes,
          onChange: function onChange(e) {
            var settings = JSON.parse(JSON.stringify(_this3.state[type]));
            settings.minutes = parseInt(e.target.value, 10);
            if (settings.minutes < 1) settings.minutes = 1;

            _this3.setState((0, _defineProperty2["default"])({}, type, settings), function () {
              return _this3.recalcCron();
            });
          },
          min: 1,
          max: 60,
          type: "number",
          InputLabelProps: {
            shrink: true
          },
          margin: "normal"
        }), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
          style: {
            marginTop: 0,
            marginBottom: 0,
            verticalAlign: 'bottom'
          },
          key: "value",
          label: _i18n["default"].t('sc_hours'),
          value: settings.hours,
          onChange: function onChange(e) {
            var settings = JSON.parse(JSON.stringify(_this3.state[type]));
            settings.hours = parseInt(e.target.value, 10);
            if (settings.hours < 1) settings.hours = 1;

            _this3.setState((0, _defineProperty2["default"])({}, type, settings), function () {
              return _this3.recalcCron();
            });
          },
          min: 1,
          max: 24,
          type: "number",
          InputLabelProps: {
            shrink: true
          },
          margin: "normal"
        }));
      } else {
        return /*#__PURE__*/_react["default"].createElement("div", {
          key: "period",
          style: {
            paddingLeft: 8,
            display: 'inline-block'
          }
        }, /*#__PURE__*/_react["default"].createElement("h5", {
          style: {
            marginBottom: 5
          }
        }, _i18n["default"].t('sc_period')), /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
          style: {
            marginTop: 0,
            marginBottom: 0,
            verticalAlign: 'bottom'
          },
          key: "value",
          label: _i18n["default"].t('sc_every'),
          value: settings.period,
          onChange: function onChange(e) {
            var settings = JSON.parse(JSON.stringify(_this3.state[type]));
            settings.period = parseInt(e.target.value, 10);
            if (settings.period < 1) settings.period = 1;

            _this3.setState((0, _defineProperty2["default"])({}, type, settings), function () {
              return _this3.recalcCron();
            });
          },
          min: 1,
          max: 60,
          type: "number",
          InputLabelProps: {
            shrink: true
          },
          margin: "normal"
        }), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
          style: {
            verticalAlign: 'bottom'
          },
          value: settings.unit,
          onChange: function onChange(e) {
            var settings = JSON.parse(JSON.stringify(_this3.state[type]));
            settings.unit = e.target.value;

            _this3.setState((0, _defineProperty2["default"])({}, type, settings), function () {
              return _this3.recalcCron();
            });
          }
        }, Object.keys(PERIODIC_TYPES).map(function (mode) {
          return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
            key: PERIODIC_TYPES[mode],
            value: PERIODIC_TYPES[mode]
          }, _i18n["default"].t('sc_' + PERIODIC_TYPES[mode]));
        })));
      }
    }
  }, {
    key: "getControlsTime",
    value: function getControlsTime(type) {
      var _this4 = this;

      var settings = this.state[type];
      return /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
        className: this.props.classes.formControl,
        classes: {
          root: this.props.classes.formControlMarginRight
        }
      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
        key: "at",
        label: _i18n["default"].t('sc_time'),
        value: settings.time,
        type: "time",
        onChange: function onChange(e) {
          var settings = JSON.parse(JSON.stringify(_this4.state[type]));
          settings.time = e.target.value;

          _this4.setState((0, _defineProperty2["default"])({}, type, settings), function () {
            return _this4.recalcCron();
          });
        },
        InputLabelProps: {
          shrink: true
        },
        margin: "normal"
      }));
    }
  }, {
    key: "getControlsDate",
    value: function getControlsDate(type) {
      var _this5 = this;

      var settings = this.state[type];

      if (!settings.date) {
        var d = new Date();
        settings.date = d.getDate() + '.' + padding(d.getMonth() + 1);
      } //<InputLabel htmlFor="formatted-text-mask-input">{I18n.t('sc_at')}</InputLabel>


      return /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
        className: this.props.classes.formControl
      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
        key: "date",
        label: _i18n["default"].t('sc_date'),
        value: settings.date,
        type: "text",
        inputProps: {
          className: this.props.classes.formControlPaddingTop
        },
        onChange: function onChange(e) {
          var settings = JSON.parse(JSON.stringify(_this5.state[type]));
          settings.date = e.target.value;

          _this5.setState((0, _defineProperty2["default"])({}, type, settings), function () {
            return _this5.recalcCron();
          });
        },
        InputLabelProps: {
          shrink: true
        },
        margin: "normal"
      }));
    }
  }, {
    key: "getOnceElements",
    value: function getOnceElements() {
      return /*#__PURE__*/_react["default"].createElement("div", {
        style: {
          marginLeft: 8
        }
      }, this.getControlsTime('once'), this.getControlsDate('once'));
    }
  }, {
    key: "getIntervalElements",
    value: function getIntervalElements() {
      return this.getControlsPeriodElements('interval');
    }
  }, {
    key: "getIntervalBetweenElements",
    value: function getIntervalBetweenElements() {
      var _this6 = this;

      var settings = this.state.intervalBetween;
      return [this.getControlsPeriodElements('intervalBetween'), /*#__PURE__*/_react["default"].createElement("div", {
        key: "between",
        style: {
          paddingLeft: 8,
          display: 'inline-block',
          verticalAlign: 'top'
        }
      }, /*#__PURE__*/_react["default"].createElement("h5", {
        style: {
          marginBottom: 5
        }
      }, _i18n["default"].t('sc_hours')), /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
        className: this.props.classes.formControl
      }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], {
        shrink: true,
        htmlFor: "age-label-placeholder"
      }, _i18n["default"].t('sc_from')), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
        style: {
          width: 100
        },
        value: settings.timeFrom,
        onChange: function onChange(e) {
          var settings = JSON.parse(JSON.stringify(_this6.state.intervalBetween));
          settings.timeFrom = parseInt(e.target.value, 10);

          _this6.setState({
            intervalBetween: settings
          }, function () {
            return _this6.recalcCron();
          });
        }
      }, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23].map(function (hour) {
        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
          key: 'B_' + hour,
          value: hour
        }, padding(hour) + ':00');
      }))), /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
        className: this.props.classes.formControl
      }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], {
        shrink: true,
        htmlFor: "age-label-placeholder"
      }, _i18n["default"].t('sc_to')), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
        style: {
          width: 100
        },
        value: settings.timeTo,
        onChange: function onChange(e) {
          var settings = JSON.parse(JSON.stringify(_this6.state.intervalBetween));
          settings.timeTo = parseInt(e.target.value, 10);

          _this6.setState({
            intervalBetween: settings
          }, function () {
            return _this6.recalcCron();
          });
        }
      }, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24].map(function (hour) {
        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
          key: 'A_' + hour,
          value: hour
        }, padding(hour) + ':00');
      })))), this.getControlsWeekdaysElements('intervalBetween')];
    }
  }, {
    key: "getSpecificTimeElements",
    value: function getSpecificTimeElements() {
      return [/*#__PURE__*/_react["default"].createElement("div", {
        key: "time",
        style: {
          marginLeft: 8
        }
      }, this.getControlsTime('specific')), this.getControlsWeekdaysElements('specific')];
    }
  }, {
    key: "onModeChange",
    value: function onModeChange(mode) {
      var _this7 = this;

      if (mode !== this.state.mode) {
        this.setState({
          mode: mode
        }, function () {
          return _this7.recalcCron();
        });
      }
    }
  }, {
    key: "onChange",
    value: function onChange(cron) {
      if (cron !== this.state.cron) {
        this.setState({
          cron: cron
        });
        this.props.onChange && this.props.onChange(cron);
      }
    }
  }, {
    key: "render",
    value: function render() {
      var _this8 = this;

      return /*#__PURE__*/_react["default"].createElement("div", {
        className: this.props.classes.mainDiv
      }, /*#__PURE__*/_react["default"].createElement("div", {
        style: {
          paddingLeft: 8,
          width: '100%'
        }
      }, /*#__PURE__*/_react["default"].createElement(_TextField["default"], {
        style: {
          width: '100%'
        },
        value: this.state.cron,
        disabled: true
      })), /*#__PURE__*/_react["default"].createElement("div", {
        style: {
          paddingLeft: 8,
          width: '100%',
          height: 60
        }
      }, (0, _cronText["default"])(this.state.cron, this.props.language || 'en')), /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(_FormControl["default"], {
        style: {
          marginLeft: 8,
          marginTop: 8
        },
        className: this.props.classes.formControl
      }, /*#__PURE__*/_react["default"].createElement(_InputLabel["default"], null, _i18n["default"].t('ra_Repeat')), /*#__PURE__*/_react["default"].createElement(_Select["default"], {
        value: this.state.mode,
        onChange: function onChange(e) {
          return _this8.onModeChange(e.target.value);
        },
        inputProps: {
          name: 'mode',
          id: 'mode'
        }
      }, Object.keys(PERIODIC).map(function (mode) {
        return /*#__PURE__*/_react["default"].createElement(_MenuItem["default"], {
          key: PERIODIC[mode],
          value: PERIODIC[mode]
        }, _i18n["default"].t('sc_' + PERIODIC[mode]));
      })))), this.state.mode === PERIODIC.once && this.getOnceElements(), this.state.mode === PERIODIC.interval && this.getIntervalElements(), this.state.mode === PERIODIC.intervalBetween && this.getIntervalBetweenElements(), this.state.mode === PERIODIC.specific && this.getSpecificTimeElements());
    }
  }], [{
    key: "periodArray2text",
    value: function periodArray2text(list, max) {
      max = max || 7;

      if (list.length === max) {
        return '*';
      } else {
        var text = [];
        var start = null;
        var end = null;

        for (var i = 0; i < list.length; i++) {
          if (start === null) {
            start = list[i];
            end = list[i];
          } else if (list[i - 1] + 1 === list[i]) {
            end = list[i];
          } else {
            if (start !== end) {
              text.push(start + '-' + end);
            } else {
              text.push(start);
            }

            start = list[i];
            end = list[i];
          }
        }

        if (start !== end) {
          text.push(start + '-' + end);
        } else {
          text.push(start);
        }

        return text.join(',');
      }
    }
  }, {
    key: "text2weekdays",
    value: function text2weekdays(text) {
      if (text === '*') {
        return [0, 1, 2, 3, 4, 5, 6];
      }

      var parts = text.split(',');
      var list = [];
      parts.forEach(function (part) {
        var _parts = part.split('-');

        if (_parts.length === 2) {
          var start = parseInt(_parts[0], 10);
          var end = parseInt(_parts[1], 10);

          for (var day = start; day <= end; day++) {
            if (list.indexOf(day === 7 ? 0 : day) === -1) {
              list.push(day === 7 ? 0 : day);
            }
          }
        } else {
          if (part === '7') {
            part = 0;
          }

          part = parseInt(part, 10);

          if (list.indexOf(part) === -1) {
            list.push(part);
          }
        }
      });
      list.sort();
      return list;
    }
  }, {
    key: "cron2state",
    value: function cron2state(cron) {
      cron = cron.replace(/['"]/g, '').trim();
      var cronParts = cron.split(' ');
      var options = {};
      var state = {
        mode: ''
      };

      if (cronParts.length === 6) {
        options.seconds = cronParts[0] || '*';
        options.minutes = cronParts[1] || '*';
        options.hours = cronParts[2] || '*';
        options.date = cronParts[3] || '*';
        options.months = cronParts[4] || '*';
        options.dow = cronParts[5] || '*';
      } else {
        options.seconds = null;
        options.minutes = cronParts[0] || '*';
        options.hours = cronParts[1] || '*';
        options.date = cronParts[2] || '*';
        options.months = cronParts[3] || '*';
        options.dow = cronParts[4] || '*';
      } // * * * * *


      if (options.seconds === null && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
        state.mode = PERIODIC.interval;
        state.interval = {
          period: 1,
          unit: PERIODIC_TYPES.minutes
        };
      } // * * * * * *


      if (options.seconds === '*' && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
        state.mode = PERIODIC.interval;
        state.interval = {
          period: 1,
          unit: PERIODIC_TYPES.seconds
        };
      } else // */n * * * *
        if (options.seconds === null && options.minutes.indexOf('/') !== -1 && options.hours === '*' && options.date === '*' && options.months === '*') {
          state.mode = PERIODIC.interval;
          state.interval = {
            period: parseInt(options.minutes.split('/')[1], 10),
            unit: PERIODIC_TYPES.minutes
          };
        } else // */n * * * * *
          if (options.seconds !== null && options.seconds.indexOf('/') !== -1 && options.minutes === '*' && options.hours === '*' && options.date === '*' && options.months === '*') {
            state.mode = PERIODIC.interval;
            state.interval = {
              period: parseInt(options.seconds.split('/')[1], 10),
              unit: PERIODIC_TYPES.seconds
            };
          } else // */n * 1-24 * * 1-7 or  */n * 1-24 * * *
            if (options.seconds !== null && options.seconds.indexOf('/') !== -1 && options.minutes === '*' && options.hours.indexOf('-') !== -1 && options.date === '*' && options.months === '*') {
              state.mode = PERIODIC.intervalBetween;
              state.intervalBetween = {
                period: parseInt(options.seconds.split('/')[1], 10),
                unit: PERIODIC_TYPES.seconds,
                timeFrom: parseInt(options.hours.split('-')[0], 10),
                timeTo: parseInt(options.hours.split('-')[1], 10),
                weekdays: SimpleCron.text2weekdays(options.dow)
              };
            } else // */n 1-24 * * 1-7 or  */n 1-24 * * *
              if (options.seconds === null && options.minutes.indexOf('/') !== -1 && options.hours.indexOf('-') !== -1 && options.date === '*' && options.months === '*') {
                state.mode = PERIODIC.intervalBetween;
                state.intervalBetween = {
                  period: parseInt(options.minutes.split('/')[1], 10),
                  unit: PERIODIC_TYPES.minutes,
                  timeFrom: parseInt(options.hours.split('-')[0], 10),
                  timeTo: parseInt(options.hours.split('-')[1], 10),
                  weekdays: SimpleCron.text2weekdays(options.dow)
                };
              } else // m h * * 1-7 or m h * * *
                if (options.seconds === null && parseInt(options.minutes, 10).toString() === options.minutes && parseInt(options.hours, 10).toString() === options.hours && options.date === '*' && options.months === '*') {
                  state.mode = PERIODIC.specific;
                  state.specific = {
                    time: padding(parseInt(options.hours, 10)) + ':' + padding(parseInt(options.minutes, 10)),
                    weekdays: SimpleCron.text2weekdays(options.dow)
                  };
                } else // m h d M *
                  if (options.seconds === null && parseInt(options.minutes, 10).toString() === options.minutes && parseInt(options.hours, 10).toString() === options.hours && parseInt(options.date, 10).toString() === options.date && parseInt(options.months, 10).toString() === options.months && options.dow === '*') {
                    state.mode = PERIODIC.once;
                    state.once = {
                      time: padding(parseInt(options.hours, 10)) + ':' + padding(parseInt(options.minutes, 10)),
                      date: padding(parseInt(options.date, 10)) + '.' + padding(parseInt(options.months, 10)),
                      // ignored
                      weekdays: SimpleCron.text2weekdays(options.dow)
                    };
                  }

      if (state.mode) {
        return state;
      } else {
        return null;
      }
    }
  }, {
    key: "state2cron",
    value: function state2cron(state) {
      var cron = '* * * * *';

      if (state.mode === PERIODIC.interval) {
        var settings = state.interval || {};
        if (settings.period > 60) settings.period = 60;
        if (settings.period < 1) settings.period = 1;
        if (settings.minutes > 60) settings.minutes = 60;
        if (settings.minutes < 1) settings.minutes = 1;
        if (settings.hours > 24) settings.hours = 24;
        if (settings.hours < 1) settings.hours = 1;

        if (state.extended) {
          cron = "".concat(settings.minutes > 1 ? '*/' + settings.minutes : '*', " ").concat(settings.hours > 1 ? '*/' + settings.hours : '*', " * * *");
        } else {
          switch (settings.unit) {
            case PERIODIC_TYPES.seconds:
              cron = "".concat(settings.period > 1 ? '*/' + settings.period : '*', " * * * * *");
              break;

            case PERIODIC_TYPES.minutes:
              cron = "".concat(settings.period > 1 ? '*/' + settings.period : '*', " * * * *");
              break;

            default:
              break;
          }
        }
      } else if (state.mode === PERIODIC.intervalBetween) {
        var _settings = state.intervalBetween || {};

        var hours;
        _settings.timeFrom = _settings.timeFrom || 0;
        _settings.timeTo = _settings.timeTo === undefined ? 24 : _settings.timeTo;

        if (_settings.timeFrom === 0 && _settings.timeTo === 24) {
          hours = '*';
        } else {
          hours = _settings.timeFrom !== _settings.timeTo ? _settings.timeFrom + '-' + _settings.timeTo : '*';
        }

        if (_settings.period > 60) _settings.period = 60;
        if (_settings.period < 1) _settings.period = 1;
        _settings.unit = _settings.unit || PERIODIC_TYPES.minutes;

        switch (_settings.unit) {
          case PERIODIC_TYPES.seconds:
            cron = "".concat(_settings.period > 1 ? '*/' + _settings.period : '*', " * ").concat(hours, " * * ").concat(this.periodArray2text(_settings.weekdays));
            break;

          case PERIODIC_TYPES.minutes:
            cron = "".concat(_settings.period > 1 ? '*/' + _settings.period : '*', " ").concat(hours, " * * ").concat(this.periodArray2text(_settings.weekdays));
            break;

          default:
            break;
        }
      } else if (state.mode === PERIODIC.specific) {
        var _settings2 = state.specific || {};

        var parts = (_settings2.time || '00:00').split(':');
        var minutes = parseInt(parts[1], 10) || 0;
        if (minutes > 59) minutes = 59;
        if (minutes < 0) minutes = 0;

        var _hours = parseInt(parts[0], 10) || 0;

        if (_hours > 23) _hours = 59;
        if (_hours < 0) _hours = 0;
        cron = "".concat(minutes, " ").concat(_hours, " * * ").concat(this.periodArray2text(_settings2.weekdays || []));
      } else if (state.mode === PERIODIC.once) {
        var _settings3 = state.once || {};

        if (!_settings3.date) {
          _settings3.date = new Date().getDate() + '.' + padding(new Date().getMonth() + 1);
        }

        var _parts2 = (_settings3.time || '00:00').split(':');

        var partsDate = _settings3.date.split('.');

        var _minutes = parseInt(_parts2[1], 10) || 0;

        if (_minutes > 59) _minutes = 59;
        if (_minutes < 0) _minutes = 0;

        var _hours2 = parseInt(_parts2[0], 10) || 0;

        if (_hours2 > 23) _hours2 = 59;
        if (_hours2 < 0) _hours2 = 0;
        var date = parseInt(partsDate[0], 10) || 1;
        if (date > 31) date = 31;
        if (date < 1) _hours2 = 1;
        var month = parseInt(partsDate[1], 10) || 1;
        if (month > 12) month = 12;
        if (month < 1) month = 1;
        cron = "".concat(_minutes, " ").concat(_hours2, " ").concat(date, " ").concat(month, " *");
      }

      return cron;
    }
  }]);
  return SimpleCron;
}(_react["default"].Component);

SimpleCron.propTypes = {
  cronExpression: _propTypes["default"].string,
  onChange: _propTypes["default"].func,
  language: _propTypes["default"].string
};

var _default = (0, _styles.withStyles)(styles)(SimpleCron);

exports["default"] = _default;
//# sourceMappingURL=index.js.map