2417

pending completion

Build # 2417

Build Type

Pull #810

travis-ci-com

Committed by

web-flow

Commit Message

Merge 125df4725 into 586a22741

Pull Request Pull Request #810: Update Italian translation

Run Details

10097 of 20417 branches covered (49.45%)

Branch coverage included in aggregate %.

50 of 55 new or added lines in 6 files covered. (90.91%)

2 existing lines in 2 files now uncovered.

24255 of 40561 relevant lines covered (59.8%)

380209.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.38

/lib/engine/apps/timers.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020-2021 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>, Swee Kiat Lim <sweekiat@stanford.edu>

import { Temporal } from '@js-temporal/polyfill';

import * as ThingTalk from 'thingtalk';
import AsyncQueue from 'consumer-queue';

abstract class BaseTimer {
    private _stopped : boolean;
    private _queue : AsyncQueue<IteratorResult<{ __timestamp : number }, void>>;
    private _timeout : NodeJS.Timeout|null;

    constructor() {
        this._stopped = false;
        this._queue = new AsyncQueue();
        this._timeout = null;
    }

    protected abstract _nextTimeout() : number;

    next() {
        return this._queue.pop();
    }

    end() {
        if (this._stopped)
            return;
        this._stopped = true;
        this._queue.push({ done: true, value: undefined });
    }

    stop() {
        this._stopped = true;
        clearTimeout(this._timeout!);
        this._timeout = null;
    }

    private _reschedule() {
        this._timeout = setTimeout(() => {
            if (this._stopped)
                return;
            this._queue.push({ done: false, value: { __timestamp: Date.now() } });
            this._reschedule();
        }, this._nextTimeout());
    }

    start() {
        this._reschedule();
    }
}

class Timer extends BaseTimer {
    private _base : number;
    private _interval : number;
    private _frequency : number;

    constructor(base : number, interval : number, frequency : number) {
        super();

        this._base = base;
        this._interval = interval;
        this._frequency = frequency;
    }

    toString() {
        return `[Timer ${this._base}, ${this._interval}, ${this._frequency}]`;
    }

    private _setTimems(date : number|Date, timeInms : number) {
        // Takes and returns ms representation
        // 0 sets time to 0:00:00
        // 1000 sets time to 0:00:01
        // 43200000 sets time to 12:00:00
        const dateObj = new Date(date);
        return dateObj.setHours(0, 0, 0, timeInms);
    }

    private _getTimems(date : number) {
        // Takes and returns ms representation
        // SOME_DATE 0:00:00 returns 0
        // SOME_DATE 0:00:01 returns 1000
        // SOME_DATE 12:00:00 returns 43200000
        const dateObj = new Date(date);
        const dateObj0 = new Date(date);
        return dateObj.getTime() - this._setTimems(dateObj0, 0);
    }

    private _setDay(date : number, day : number) {
        // Takes and returns ms representation
        const dateObj = new Date(date);
        const currentDay = dateObj.getDay();
        return date + (day - currentDay) * 86400000;
    }

    private _splitDay(frequency : number) {
        // Takes frequency (per day) and returns reasonable timings

        const REASONABLE_START_TIME = 32400000; // 9AM
        const REASONABLE_INTERVAL = 43200000; // 12h
        const TIME_12PM = 43200000;

        const timings = [];
        if (frequency === null || frequency === 1) {
            // If it's just once a day, set timing as 12pm
            timings.push(TIME_12PM);
        } else {
            // For more than once a day, set interval as 9AM to 9PM
            // and divide equally starting from 9AM onwards
            // e.g. 3 times a day will be [9AM, 3PM, 9PM]
            // 4 times a day will be [9AM, 1PM, 5PM, 9PM]
            // Might want to set a limit on frequency?
            // Like if it is more than once per hour
            // then we just do simple divide
            const interval = REASONABLE_INTERVAL / (frequency - 1);
            for (let i = 0; i < frequency; i++)
                timings.push(Math.round(REASONABLE_START_TIME + i * interval));
        }
        return timings;
    }

    private _splitWeek(frequency : number) {
        // Takes frequency (per week) and returns reasonable days
        // Days of week are 0-indexed, starting from Sunday
        const base_day = new Date(this._base).getDay();
        switch (frequency) {
            case 2:
                return [base_day, (base_day + 4) % 7];
            case 3:
                return [1, 3, 5];
            case 4:
                return [1, 2, 4, 5];
            case 5:
                return [1, 2, 3, 4, 5];
            case 6:
                return [1, 2, 3, 4, 5, 6];
            case 7:
                return [0, 1, 2, 3, 4, 5, 6];
            default:
                throw new Error("Invalid frequency for _splitWeek");
        }
    }

    private _getEarliest(base : number, timings : number[]) {
        // Returns earliest valid timing after base
        // e.g. if timings = [9am, 3pm, 9pm] and base = 1st Jan 1pm
        // then next timing should be 1st Jan 3pm
        // if base = 1st Jan 10pm, next timing should be 2nd Jan 9am
        let earliest = null;
        for (let n = 0; n < timings.length; n++) {
            earliest = this._setTimems(base, timings[n]);
            if (earliest >= base)
                return earliest;
        }
        // If base is already past latest timing, return next day's timings[0]
        return this._setTimems(base + 86400000, timings[0]);
    }

    protected _nextTimeout(_now : number|null = null) {
        // Should we check for cases where frequency > interval?
        let interval = this._interval;
        const base = this._base;
        const now = _now === null ? Date.now() : _now; // used for testing
        const frequency = this._frequency === null ? 1 : this._frequency;
        const DAY = 86400000;
        const WEEK = 7 * DAY;

        let nextTiming = 0;
        if (frequency === 0) { // End timer because it will never execute
            this.end();
            return 0;
        }
        else if ((this._interval / frequency) < 2000) {
            throw new Error(`Timer with total interval ${this._interval} and frequency ${this._frequency} will have intervals of ${this._interval / this._frequency}. Minimum interval is 2 seconds.`);
        }
        // Special case if interval is 1 day
        else if (this._interval === DAY) {
            const timings = this._splitDay(frequency);
            nextTiming = this._getEarliest(Math.max(now, base), timings);
        }
        // Special case if interval is 1 week
        else if (this._interval === WEEK) {
            if (base > now) {
                nextTiming = base;
            } else if (frequency === 1) {
                nextTiming = now + WEEK - ((now - base) % WEEK);
            } else if (frequency < 8) {
                // Hardcoded cases
                const days = this._splitWeek(frequency);
                const baseTime = this._getTimems(base);
                for (let n = 0; n < days.length; n++) {
                    nextTiming = this._setDay(now, days[n]);
                    nextTiming = this._setTimems(nextTiming, baseTime);
                    if (nextTiming >= now)
                        break;
                }
                if (nextTiming < now)
                    nextTiming = this._setDay(now + WEEK, days[0]);
                    nextTiming = this._setTimems(nextTiming, baseTime);
            } else {
                // Simple divide
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
            }
        }
        // Otherwise, just try to call at consistent times
        else if (this._interval > DAY) {
            if (base > now) {
                nextTiming = base;
            } else if (frequency <= (this._interval / DAY)) {
                // In this case, we are calling at most once a day
                // So just call at consistent time
                const baseTime = this._getTimems(base);
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
                nextTiming = this._setTimems(nextTiming, baseTime);
            } else {
                // Calling more than once a day.
                // Just do a simple divide
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
            }
        }
        // Just do simple divide if interval is less than a day
        else if (this._interval < DAY) {
            if (base > now) {
                nextTiming = base;
            } else {
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
            }
        }
        return nextTiming - now;
    }
}

class AtTimer extends BaseTimer {
    private _times : ThingTalk.Builtin.Time[];
    private _expiration_date : Date|null|undefined;
    private _timezone : string;

    constructor(times : ThingTalk.Builtin.Time[], expiration_date : Date|null|undefined, timezone : string) {
        super();

        this._times = times;
        this._expiration_date = expiration_date;
        this._timezone = timezone;
    }

    toString() {
        return `[AtTimer [${this._times}], ${this._expiration_date}]`;
    }

    protected _nextTimeout() {
        const now = Temporal.Now.zonedDateTime('iso8601', this._timezone);

        if (this._expiration_date !== undefined && this._expiration_date !== null &&
            this._expiration_date.getTime() < now.epochMilliseconds) {
            console.log('AtTimer to the times ' + this._times + ': has hit expiration date of ' + this._expiration_date);
            this.end();
            return 86400000;
        }

        let interval = 86400000; // Tomorrow
        for (let i = 0; i < this._times.length; i++) {
            const target = now.withPlainTime(new Temporal.PlainTime(this._times[i].hour,
                this._times[i].minute, this._times[i].second, 0));
            const newInterval = target.epochMilliseconds - now.epochMilliseconds;
            if (newInterval < interval && newInterval >= 0)
                interval = newInterval;
        }

        console.log('AtTimer to the times ' + this._times + ': polling again in ' + interval + ' ms');
        return interval;
    }
}

class OnTimer extends BaseTimer {
    private _dates : Date[];

    constructor(dates : Date[]) {
        super();

        this._dates = dates;
    }

    toString() {
        return `[OnTimer [${this._dates}]]`;
    }

    protected _nextTimeout(_now : number|null = null) {
        const now = _now === null ? new Date() : new Date(_now); // used for testing

        let target = new Date(this._dates[0]);
        for (let i = 1; i < this._dates.length; i++) {
            const temp = new Date(this._dates[i]);

            if (temp.getTime() > now.getTime() && (temp.getTime() < target.getTime() || now.getTime() > target.getTime()))
                target = temp;
        }
        const interval = target.getTime() - now.getTime();
        if (interval > 0)
            return interval;

        this.end();
        return 0;
    }
}

export {
    Timer,
    AtTimer,
    OnTimer
};

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020-2021 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>, Swee Kiat Lim <sweekiat@stanford.edu>
20
21	import { Temporal } from '@js-temporal/polyfill';	95✔
22
23	import * as ThingTalk from 'thingtalk';
24	import AsyncQueue from 'consumer-queue';	95✔
25
26	abstract class BaseTimer {
27	private _stopped : boolean;
28	private _queue : AsyncQueue<IteratorResult<{ __timestamp : number }, void>>;
29	private _timeout : NodeJS.Timeout\|null;
30
31	constructor() {
32	this._stopped = false;	12✔
33	this._queue = new AsyncQueue();	12✔
34	this._timeout = null;	12✔
35	}
36
37	protected abstract _nextTimeout() : number;
38
39	next() {
40	return this._queue.pop();	9✔
41	}
42
43	end() {
44	if (this._stopped)	2!
45	return;	×
46	this._stopped = true;	2✔
47	this._queue.push({ done: true, value: undefined });	2✔
48	}
49
50	stop() {
51	this._stopped = true;	4✔
52	clearTimeout(this._timeout!);	4✔
53	this._timeout = null;	4✔
54	}
55
56	private _reschedule() {
57	this._timeout = setTimeout(() => {	9✔
58	if (this._stopped)	5!
59	return;	×
60	this._queue.push({ done: false, value: { __timestamp: Date.now() } });	5✔
61	this._reschedule();	5✔
62	}, this._nextTimeout());
63	}
64
65	start() {
66	this._reschedule();	4✔
67	}
68	}
69
70	class Timer extends BaseTimer {
71	private _base : number;
72	private _interval : number;
73	private _frequency : number;
74
75	constructor(base : number, interval : number, frequency : number) {
76	super();	10✔
77
78	this._base = base;	10✔
79	this._interval = interval;	10✔
80	this._frequency = frequency;	10✔
81	}
82
83	toString() {
84	return `[Timer ${this._base}, ${this._interval}, ${this._frequency}]`;	×
85	}
86
87	private _setTimems(date : number\|Date, timeInms : number) {
88	// Takes and returns ms representation
89	// 0 sets time to 0:00:00
90	// 1000 sets time to 0:00:01
91	// 43200000 sets time to 12:00:00
92	const dateObj = new Date(date);	148✔
93	return dateObj.setHours(0, 0, 0, timeInms);	148✔
94	}
95
96	private _getTimems(date : number) {
97	// Takes and returns ms representation
98	// SOME_DATE 0:00:00 returns 0
99	// SOME_DATE 0:00:01 returns 1000
100	// SOME_DATE 12:00:00 returns 43200000
101	const dateObj = new Date(date);	29✔
102	const dateObj0 = new Date(date);	29✔
103	return dateObj.getTime() - this._setTimems(dateObj0, 0);	29✔
104	}
105
106	private _setDay(date : number, day : number) {
107	// Takes and returns ms representation
108	const dateObj = new Date(date);	68✔
109	const currentDay = dateObj.getDay();	68✔
110	return date + (day - currentDay) * 86400000;	68✔
111	}
112
113	private _splitDay(frequency : number) {
114	// Takes frequency (per day) and returns reasonable timings
115
116	const REASONABLE_START_TIME = 32400000; // 9AM	14✔
117	const REASONABLE_INTERVAL = 43200000; // 12h	14✔
118	const TIME_12PM = 43200000;	14✔
119
120	const timings = [];	14✔
121	if (frequency === null \|\| frequency === 1) {	14✔
122	// If it's just once a day, set timing as 12pm
123	timings.push(TIME_12PM);	5✔
124	} else {
125	// For more than once a day, set interval as 9AM to 9PM
126	// and divide equally starting from 9AM onwards
127	// e.g. 3 times a day will be [9AM, 3PM, 9PM]
128	// 4 times a day will be [9AM, 1PM, 5PM, 9PM]
129	// Might want to set a limit on frequency?
130	// Like if it is more than once per hour
131	// then we just do simple divide
132	const interval = REASONABLE_INTERVAL / (frequency - 1);	9✔
133	for (let i = 0; i < frequency; i++)	9✔
134	timings.push(Math.round(REASONABLE_START_TIME + i * interval));	58✔
135	}
136	return timings;	14✔
137	}
138
139	private _splitWeek(frequency : number) {
140	// Takes frequency (per week) and returns reasonable days
141	// Days of week are 0-indexed, starting from Sunday
142	const base_day = new Date(this._base).getDay();	25✔
143	switch (frequency) {	25✔
144	case 2:	25✔
145	return [base_day, (base_day + 4) % 7];	2✔
146	case 3:
147	return [1, 3, 5];	3✔
148	case 4:
149	return [1, 2, 4, 5];	4✔
150	case 5:
151	return [1, 2, 3, 4, 5];	5✔
152	case 6:
153	return [1, 2, 3, 4, 5, 6];	7✔
154	case 7:
155	return [0, 1, 2, 3, 4, 5, 6];	3✔
156	default:
157	throw new Error("Invalid frequency for _splitWeek");	1✔
158	}
159	}
160
161	private _getEarliest(base : number, timings : number[]) {
162	// Returns earliest valid timing after base
163	// e.g. if timings = [9am, 3pm, 9pm] and base = 1st Jan 1pm
164	// then next timing should be 1st Jan 3pm
165	// if base = 1st Jan 10pm, next timing should be 2nd Jan 9am
166	let earliest = null;	13✔
167	for (let n = 0; n < timings.length; n++) {	13✔
168	earliest = this._setTimems(base, timings[n]);	19✔
169	if (earliest >= base)	19✔
170	return earliest;	11✔
171	}
172	// If base is already past latest timing, return next day's timings[0]
173	return this._setTimems(base + 86400000, timings[0]);	2✔
174	}
175
176	protected _nextTimeout(_now : number\|null = null) {	8✔
177	// Should we check for cases where frequency > interval?
178	let interval = this._interval;	49✔
179	const base = this._base;	49✔
180	const now = _now === null ? Date.now() : _now; // used for testing	49✔
181	const frequency = this._frequency === null ? 1 : this._frequency;	49✔
182	const DAY = 86400000;	49✔
183	const WEEK = 7 * DAY;	49✔
184
185	let nextTiming = 0;	49✔
186	if (frequency === 0) { // End timer because it will never execute	49✔
187	this.end();	1✔
188	return 0;	1✔
189	}
190	else if ((this._interval / frequency) < 2000) {	48✔
191	throw new Error(`Timer with total interval ${this._interval} and frequency ${this._frequency} will have intervals of ${this._interval / this._frequency}. Minimum interval is 2 seconds.`);	1✔
192	}
193	// Special case if interval is 1 day
194	else if (this._interval === DAY) {	47✔
195	const timings = this._splitDay(frequency);	9✔
196	nextTiming = this._getEarliest(Math.max(now, base), timings);	9✔
197	}
198	// Special case if interval is 1 week
199	else if (this._interval === WEEK) {	38✔
200	if (base > now) {	26✔
201	nextTiming = base;	1✔
202	} else if (frequency === 1) {	25✔
203	nextTiming = now + WEEK - ((now - base) % WEEK);	1✔
204	} else if (frequency < 8) {	24!
205	// Hardcoded cases
206	const days = this._splitWeek(frequency);	24✔
207	const baseTime = this._getTimems(base);	24✔
208	for (let n = 0; n < days.length; n++) {	24✔
209	nextTiming = this._setDay(now, days[n]);	68✔
210	nextTiming = this._setTimems(nextTiming, baseTime);	68✔
211	if (nextTiming >= now)	68✔
212	break;	24✔
213	}
214	if (nextTiming < now)	24!
215	nextTiming = this._setDay(now + WEEK, days[0]);	×
216	nextTiming = this._setTimems(nextTiming, baseTime);	24✔
217	} else {
218	// Simple divide
219	interval /= frequency;	×
220	nextTiming = Math.round(now + interval - ((now - base) % interval));	×
221	}
222	}
223	// Otherwise, just try to call at consistent times
224	else if (this._interval > DAY) {	12✔
225	if (base > now) {	2!
226	nextTiming = base;	×
227	} else if (frequency <= (this._interval / DAY)) {	2!
228	// In this case, we are calling at most once a day
229	// So just call at consistent time
230	const baseTime = this._getTimems(base);	2✔
231	interval /= frequency;	2✔
232	nextTiming = Math.round(now + interval - ((now - base) % interval));	2✔
233	nextTiming = this._setTimems(nextTiming, baseTime);	2✔
234	} else {
235	// Calling more than once a day.
236	// Just do a simple divide
237	interval /= frequency;	×
238	nextTiming = Math.round(now + interval - ((now - base) % interval));	×
239	}
240	}
241	// Just do simple divide if interval is less than a day
242	else if (this._interval < DAY) {	10!
243	if (base > now) {	10!
244	nextTiming = base;	×
245	} else {
246	interval /= frequency;	10✔
247	nextTiming = Math.round(now + interval - ((now - base) % interval));	10✔
248	}
249	}
250	return nextTiming - now;	47✔
251	}
252	}
253
254	class AtTimer extends BaseTimer {
255	private _times : ThingTalk.Builtin.Time[];
256	private _expiration_date : Date\|null\|undefined;
257	private _timezone : string;
258
259	constructor(times : ThingTalk.Builtin.Time[], expiration_date : Date\|null\|undefined, timezone : string) {
260	super();	1✔
261
262	this._times = times;	1✔
263	this._expiration_date = expiration_date;	1✔
264	this._timezone = timezone;	1✔
265	}
266
267	toString() {
268	return `[AtTimer [${this._times}], ${this._expiration_date}]`;	×
269	}
270
271	protected _nextTimeout() {
272	const now = Temporal.Now.zonedDateTime('iso8601', this._timezone);	1✔
273
274	if (this._expiration_date !== undefined && this._expiration_date !== null &&	1!
275	this._expiration_date.getTime() < now.epochMilliseconds) {
276	console.log('AtTimer to the times ' + this._times + ': has hit expiration date of ' + this._expiration_date);	×
277	this.end();	×
278	return 86400000;	×
279	}
280
281	let interval = 86400000; // Tomorrow	1✔
282	for (let i = 0; i < this._times.length; i++) {	1✔
283	const target = now.withPlainTime(new Temporal.PlainTime(this._times[i].hour,	1✔
284	this._times[i].minute, this._times[i].second, 0));
285	const newInterval = target.epochMilliseconds - now.epochMilliseconds;	1✔
286	if (newInterval < interval && newInterval >= 0)	1!
UNCOV 287	interval = newInterval;	×
288	}
289
290	console.log('AtTimer to the times ' + this._times + ': polling again in ' + interval + ' ms');	1✔
291	return interval;	1✔
292	}
293	}
294
295	class OnTimer extends BaseTimer {
296	private _dates : Date[];
297
298	constructor(dates : Date[]) {
299	super();	1✔
300
301	this._dates = dates;	1✔
302	}
303
304	toString() {
305	return `[OnTimer [${this._dates}]]`;	×
306	}
307
308	protected _nextTimeout(_now : number\|null = null) {	×
309	const now = _now === null ? new Date() : new Date(_now); // used for testing	3!
310
311	let target = new Date(this._dates[0]);	3✔
312	for (let i = 1; i < this._dates.length; i++) {	3✔
313	const temp = new Date(this._dates[i]);	×
314
315	if (temp.getTime() > now.getTime() && (temp.getTime() < target.getTime() \|\| now.getTime() > target.getTime()))	×
316	target = temp;	×
317	}
318	const interval = target.getTime() - now.getTime();	3✔
319	if (interval > 0)	3✔
320	return interval;	2✔
321
322	this.end();	1✔
323	return 0;	1✔
324	}
325	}
326
327	export {
328	Timer,	95✔
329	AtTimer,	95✔
330	OnTimer	95✔
331	};

stanford-oval / genie-toolkit / 2417

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous