teambition-sdk-socket/models/events/RecurrenceEvent.js

Front-End SDK for Teambition

'use strict';
var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
var index_1 = require("../../utils/index");
var Event_1 = require("../../schemas/Event");
var rrulestr = require('rrule').rrulestr;
var RecurrenceEvent = (function (_super) {
    __extends(RecurrenceEvent, _super);
    function RecurrenceEvent(_event) {
        var _this = _super.call(this) || this;
        _this._isRecurrenceEvent = false;
        var recurrence = _event.recurrence;
        _this._startDate = new Date(_event.startDate);
        _this._interval = new Date(_event.endDate).valueOf() - new Date(_event.startDate).valueOf();
        /** istanbul ignore if */
        if (recurrence && recurrence.length) {
            _this._recurrence = rrulestr(recurrence.join('\n'), { forceset: true });
            _this._interval = new Date(_event.endDate).valueOf() - new Date(_event.startDate).valueOf();
            _this._isRecurrenceEvent = true;
        }
        _this.recurrence = _event.recurrence;
        Object.defineProperty(_this, 'recurrence', {
            get: function () {
                return _event.recurrence;
            },
            set: function (rec) {
                if (rec && rec instanceof Array && rec.length) {
                    this._recurrence = rrulestr(rec.join('\n'), { forceset: true });
                    this._isRecurrenceEvent = true;
                }
                else {
                    this._isRecurrenceEvent = false;
                }
                _event.recurrence = rec;
            }
        });
        index_1.assign(_this, _event);
        return _this;
    }
    RecurrenceEvent.prototype.setStart = function (date) {
        this._checkRecurrence();
        this._startDate = date;
    };
    RecurrenceEvent.prototype.next = function () {
        this._checkRecurrence();
        var result;
        var startDate = this._recurrence.after(this._startDate);
        var startDateObj = new Date(startDate);
        if (startDate) {
            result = this.clone();
            result.startDate = startDate;
            result.endDate = this._genNewEnd(startDateObj);
            // mock 出来的日程 _id 为原始 _id + startDate 的 ISOString
            result._id = (result._id + '&' + startDateObj.toISOString());
            this.setStart(startDateObj);
        }
        return {
            value: result,
            done: !startDate
        };
    };
    RecurrenceEvent.prototype.take = function (count) {
        this._checkRecurrence();
        var i = 0;
        var result = [];
        while (i++ < count) {
            result.push(this.next());
        }
        return result;
    };
    RecurrenceEvent.prototype.takeUntilTime = function (time) {
        this._checkRecurrence();
        var result = [];
        while (new Date(this._startDate).valueOf() < time.valueOf()) {
            result.push(this.next());
        }
        return result;
    };
    RecurrenceEvent.prototype.takeByTime = function (time) {
        this._checkRecurrence();
        var startDate = this.startDate;
        var timeVal = time.valueOf();
        var startVal = new Date(startDate).valueOf();
        while (startVal < timeVal) {
            startDate = this._recurrence.after(new Date(startDate));
            if (!startDate) {
                break;
            }
            startVal = new Date(startDate).valueOf();
        }
        if (startVal === timeVal) {
            var result = index_1.clone(this);
            var startDateObject = new Date(startDate);
            result._id = (this._id + '&' + startDateObject.toISOString());
            result.startDate = startDateObject.toISOString();
            result.endDate = this._genNewEnd(startDateObject);
            return result;
        }
        else {
            return null;
        }
    };
    RecurrenceEvent.prototype.isBetween = function (startDate, endDate) {
        var eventStartDate = new Date(this.startDate).valueOf();
        var eventEndDate = new Date(this.endDate).valueOf();
        if (!this._recurrence) {
            if (endDate === 'feature') {
                return eventStartDate > startDate.valueOf() || eventEndDate > startDate.valueOf();
            }
            else {
                return eventStartDate < startDate.valueOf() || eventEndDate > endDate.valueOf();
            }
        }
        else {
            if (endDate === 'feature') {
                return !!this._recurrence.after(startDate);
            }
            else {
                return !!this._recurrence.between(startDate, endDate).length;
            }
        }
    };
    RecurrenceEvent.prototype.clone = function () {
        return new RecurrenceEvent(this);
    };
    /**
     * 生成新的开始时间，截止时间
     */
    RecurrenceEvent.prototype._genNewEnd = function (newDate) {
        var newEnd = new Date(newDate.valueOf() + this._interval);
        return newEnd.toISOString();
    };
    RecurrenceEvent.prototype._checkRecurrence = function () {
        if (!this._isRecurrenceEvent) {
            throw new Error("this is not a recurrence event: " + JSON.stringify(this.$$data));
        }
    };
    // 普通日程无`_isRecurrenceEvent`字段
    RecurrenceEvent.prototype.checkSchema = function () {
        this.$$keys.delete('_isRecurrenceEvent');
        return !this.$$keys.size;
    };
    return RecurrenceEvent;
}(Event_1.default));
exports.RecurrenceEvent = RecurrenceEvent;
//# sourceMappingURL=RecurrenceEvent.js.map