1738

pending completion

Build # 1738

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

com.yelp: properly implement distance filters (#456)

If the user searches for a restaurant within X miles of a place,
use that place as the search location in the Yelp API. This is
now possible because ThingTalk finally gives us distance operators.

Run Details

502 of 1552 branches covered (32.35%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

1381 of 3173 relevant lines covered (43.52%)

28.35 hits per line

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

69.5

/main/org.thingpedia.weather/index.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// Copyright 2016 Giovanni Campagna <gcampagn@cs.stanford.edu>
//                Silei Xu <silei@cs.stanford.edu>
//                Andrei Bajenov <abajenov@stanford.edu>
//                Darshan Kapashi <darshank@stanford.edu>
//
// See LICENSE for details
"use strict";

const Redis = require("redis");
const Tp = require('thingpedia');
const Logging = require("@stanford-oval/logging");
const Winston = require("winston");
const { Temporal, toTemporalInstant } = require('@js-temporal/polyfill');

const LogFactory = new Logging.Factory({
    runRoot: __dirname,
    level: "http",
    envVarPrefix: "TP_WEATHER_LOG",
    transports: [
        new Winston.transports.Console({
            format: Logging.Format.prettySimple({ colorize: true }),
        }),
    ],
});

const LOG = LogFactory.get(__filename);

const SUNRISE_URL = 'https://api.met.no/weatherapi/sunrise/2.0/?lat=%f&lon=%f&date=%04d-%02d-%02d&offset=-00:00';
const WEATHER_URL = 'https://api.met.no/weatherapi/locationforecast/2.0/classic?lat=%f;lon=%f';


class ForecastError extends Error {
    constructor(code, message) {
        super(message);
        this.code = code;
    }
}

function hasRedis() {
    return (
        typeof process.env.REDIS_HOST === "string"
        && process.env.REDIS_HOST.length > 0
    );
}

function getRedisURL() {
    let url = "redis://";
    if (process.env.REDIS_USER !== null) {
        url += process.env.REDIS_USER;
        if (process.env.REDIS_PASSWORD !== null)
            url += `:${process.env.REDIS_PASSWORD}`;
        url += "@";
    }
    url += process.env.REDIS_HOST;
    return url;
}

module.exports = class WeatherAPIDevice extends Tp.BaseDevice {
    constructor(engine, state) {
        super(engine, state);
        this.redisClient = hasRedis() ? Redis.createClient({ url: getRedisURL() }) : undefined;
    }

    async start() {
        LOG.debug("Starting...");
        if (this.redisClient) await this.redisClient.connect();
        LOG.debug("Started.");
    }

    async _getCached(key) {
        if (!this.redisClient) return null;
        const cached = await this.redisClient.GET(key);
        if (cached === null)
            LOG.info("CACHE MISS", { key });
        else
            LOG.info("CACHE HIT", { key });
        return cached;
    }

    async _setCached(key, data) {
        if (!this.redisClient) return;
        LOG.info("CACHE SET", { key });
        await this.redisClient.SET(key, data, { EX: 30 * 60 });
    }

    async _get(url) {
        const key = `org.thingpedia.weather:${url}`;
        const cached = await this._getCached(key);
        let xml;
        if (cached === null) {
            xml = await Tp.Helpers.Http.get(url);
            await this._setCached(key, xml);
        } else {
            xml = cached;
        }
        return Tp.Helpers.Xml.parseString(xml);
    }

    async _sunrise_data(location, date) {
        const url = SUNRISE_URL.format(location.y, location.x, date.year, date.month, date.day);
        console.log('Loading sunrise data from ' + url);
        const parsed = await this._get(url);
        return parsed.astrodata.location[0].time[0];
    }

    async _weather_data(location) {
        const url = WEATHER_URL.format(location.y, location.x);
        console.log('Loading weather data from ' + url);
        const parsed = await this._get(url);
        return parsed.weatherdata.product[0].time;
    }

    // the weather details is stored in the entry where time $.from === $.to
    // however it contains no status information, which is available in the following entries
    // (which have the same $.to, but different $.from)
    // this function takes the entry with $.from === $.to for details, and one following entry for status info
    async _extract_weather(entry1, entry2) {
        const details = entry1.location[0];
        const weather_id = parseInt(entry2.location[0].symbol[0].$.number);

        // although symbol comes with a string, we still map it to a fixed set to simply natural language
        // for example, "a cloudy day" can be LightCloud/PartlyCloud/Cloud in status
        // for the full list of status, see: https://api.met.no/weatherapi/weathericon/1.1/documentation
        let status;
        if (weather_id === 1)
            status = 'sunny';
        else if (weather_id === 15)
            status = 'foggy';
        else if ([2, 3, 4].indexOf(weather_id) >= 0)
            status = 'cloudy';
        else if ([5, 6, 9, 10, 11, 22, 41].indexOf(weather_id) >= 0)
            status = 'raining';
        else if ([24, 30, 40, 46].indexOf(weather_id) >= 0)
            status = 'drizzling';
        else if ([8, 13, 14, 21, 28, 29, 33, 34, 44, 45, 49, 50].indexOf(weather_id) >= 0)
            status = 'snowy';
        else if ([7, 12, 20, 23, 26, 27, 31, 32, 42, 43, 47, 48].indexOf(weather_id) >= 0)
            status = 'sleety';

        return {
            temperature: parseFloat(details.temperature ? details.temperature[0].$.value : 0),
            wind_speed: parseFloat(details.windSpeed ? details.windSpeed[0].$.mps || 0 : 0),
            humidity: parseFloat(details.humidity ? details.humidity[0].$.value || 0 : 0),
            cloudiness: parseFloat(details.cloudiness ? details.cloudiness[0].$.percent || 0 : 0),
            fog: parseFloat(details.fog ? details.fog[0].$.percent || 0 : 0),
            status,
            icon: `http://api.met.no/weatherapi/weathericon/1.1/?symbol=${weather_id};content_type=image/png`
        };
    }

    async get_sunrise({ location, date }) {
        if (date === undefined || date === null)
            date = new Date();
        const datetz = toTemporalInstant.call(date).toZonedDateTimeISO(this.platform.timezone);
        const data = await this._sunrise_data(location, datetz);

        // the api might return sunset/sunrise time from the previous day
        // we will need to convert to the same date first before comparison
        let rise = Temporal.Instant.from(data.sunrise[0].$.time).toZonedDateTimeISO(this.platform.timezone);
        if (rise.day !== datetz.day)
            rise = rise.subtract({ seconds: 86400 });
        let set = Temporal.Instant.from(data.sunset[0].$.time).toZonedDateTimeISO(this.platform.timezone);
        if (set.day !== datetz.day)
            set = set.subtract({ seconds: 86400 });

        const now = Temporal.Now.instant();
        return [{
            location,
            date,
            sunrise_time: new Tp.Value.Time(rise.hour, rise.minute, rise.second),
            sunset_time: new Tp.Value.Time(set.hour, set.minute, set.second),
            sunrisen: Temporal.Instant.compare(now, rise.toInstant()) > 0,
            sunset: Temporal.Instant.compare(now, set.toInstant()) > 0
        }];
    }

    async get_moon({ location, date }) {
        if (date === undefined || date === null)
            date = new Date();
        const datetz = toTemporalInstant.call(date).toZonedDateTimeISO(this.platform.timezone);
        const data = await this._sunrise_data(location, datetz);
        const phase = /(?:\()([a-z ]*)(?:\))/g.exec(data.moonphase[0].$.desc)[1].replace(/ /g, '_');
        return [{ location, date, phase }];
    }

    async get_current({ location }) {
        const data = await this._weather_data(location);
        const current = await this._extract_weather(data[0], data[1]);

        current.location = location;
        return [ current ];
    }

    async get_forecast({ date, location }) {
        const data = await this._weather_data(location);
        const now = Temporal.Now.zonedDateTimeISO(this.platform.timezone);
        const today = now.withPlainTime({ hour: 0, minute: 0 });

        let datetz;
        // do forecast for tomorrow if time is unspecified
        if (date)
            datetz = toTemporalInstant.call(date).toZonedDateTimeISO(this.platform.timezone);
        else
            datetz = today.add({ days: 1 });

        if (Temporal.Instant.compare(datetz.toInstant(), now.toInstant()) < 0)
            throw new ForecastError('no_past_forecast', `Invalid date ${date}: is in the past`);

        // find the weather closest to the time the user asked for

        // if the time is midnight (ie the user specified a date without a time), we do 2pm,
        // which is usually the hottest time of the day
        //
        // FIXME: we should do 2pm local-time of the location we're asking the weather for,
        // but that's a bit difficult so we just 2pm local-time to the server
        // (which is 2pm pacific for cloud, and 2pm local-time to the user for server/gnome)

        let comparetime = datetz;
        if (comparetime.hour === 0 && comparetime.minute === 0 &&
            comparetime.second === 0)
            comparetime = datetz.withPlainTime({ hour: 14, minute: 0, seconds: 0 });
        console.log(`Searching for weather forecast at ${comparetime}`);

        let best = undefined, bestdelta = undefined;
        for (let i = 0; i < data.length; i++) {
            if (data[i].$.from !== data[i].$.to)
                continue;
            const datetime = Temporal.Instant.from(data[i].$.from).toZonedDateTimeISO(this.platform.timezone);

            // never select a forecast for the wrong day
            if (datetime.day !== comparetime.day ||
                datetime.month !== comparetime.month ||
                datetime.year !== comparetime.year)
                continue;

            let delta = Math.abs(datetime.epochMilliseconds - comparetime.epochMilliseconds);
            if (bestdelta === undefined || delta < bestdelta) {
                best = await this._extract_weather(data[i], data[i+1]);
                best.date = date;
                //best.date = new Date(datetime.epochMilliseconds);
                bestdelta = delta;
            }
        }
        if (!best)
            throw new ForecastError('not_available', `Forecast for ${date} not available yet`);

        return [best];
    }
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// Copyright 2016 Giovanni Campagna <gcampagn@cs.stanford.edu>
4	// Silei Xu <silei@cs.stanford.edu>
5	// Andrei Bajenov <abajenov@stanford.edu>
6	// Darshan Kapashi <darshank@stanford.edu>
7	//
8	// See LICENSE for details
9	"use strict";
10
11	const Redis = require("redis");	2✔
12	const Tp = require('thingpedia');	2✔
13	const Logging = require("@stanford-oval/logging");	2✔
14	const Winston = require("winston");	2✔
15	const { Temporal, toTemporalInstant } = require('@js-temporal/polyfill');	2✔
16
17	const LogFactory = new Logging.Factory({	2✔
18	runRoot: __dirname,
19	level: "http",
20	envVarPrefix: "TP_WEATHER_LOG",
21	transports: [
22	new Winston.transports.Console({
23	format: Logging.Format.prettySimple({ colorize: true }),
24	}),
25	],
26	});
27
28	const LOG = LogFactory.get(__filename);	2✔
29
30	const SUNRISE_URL = 'https://api.met.no/weatherapi/sunrise/2.0/?lat=%f&lon=%f&date=%04d-%02d-%02d&offset=-00:00';	2✔
31	const WEATHER_URL = 'https://api.met.no/weatherapi/locationforecast/2.0/classic?lat=%f;lon=%f';	2✔
32
33
34	class ForecastError extends Error {
35	constructor(code, message) {
36	super(message);	2✔
37	this.code = code;	2✔
38	}
39	}
40
41	function hasRedis() {
42	return (	2✔
43	typeof process.env.REDIS_HOST === "string"	2!
44	&& process.env.REDIS_HOST.length > 0
45	);
46	}
47
48	function getRedisURL() {
49	let url = "redis://";	×
50	if (process.env.REDIS_USER !== null) {	×
51	url += process.env.REDIS_USER;	×
52	if (process.env.REDIS_PASSWORD !== null)	×
53	url += `:${process.env.REDIS_PASSWORD}`;	×
54	url += "@";	×
55	}
56	url += process.env.REDIS_HOST;	×
57	return url;	×
58	}
59
60	module.exports = class WeatherAPIDevice extends Tp.BaseDevice {	2✔
61	constructor(engine, state) {
62	super(engine, state);	2✔
63	this.redisClient = hasRedis() ? Redis.createClient({ url: getRedisURL() }) : undefined;	2!
64	}
65
66	async start() {
67	LOG.debug("Starting...");	2✔
68	if (this.redisClient) await this.redisClient.connect();	2!
69	LOG.debug("Started.");	2✔
70	}
71
72	async _getCached(key) {
73	if (!this.redisClient) return null;	9!
74	const cached = await this.redisClient.GET(key);	×
75	if (cached === null)	×
76	LOG.info("CACHE MISS", { key });	×
77	else
78	LOG.info("CACHE HIT", { key });	×
79	return cached;	×
80	}
81
82	async _setCached(key, data) {
83	if (!this.redisClient) return;	9!
84	LOG.info("CACHE SET", { key });	×
85	await this.redisClient.SET(key, data, { EX: 30 * 60 });	×
86	}
87
88	async _get(url) {
89	const key = `org.thingpedia.weather:${url}`;	9✔
90	const cached = await this._getCached(key);	9✔
91	let xml;
92	if (cached === null) {	9!
93	xml = await Tp.Helpers.Http.get(url);	9✔
94	await this._setCached(key, xml);	9✔
95	} else {
96	xml = cached;	×
97	}
98	return Tp.Helpers.Xml.parseString(xml);	9✔
99	}
100
101	async _sunrise_data(location, date) {
102	const url = SUNRISE_URL.format(location.y, location.x, date.year, date.month, date.day);	2✔
103	console.log('Loading sunrise data from ' + url);	2✔
104	const parsed = await this._get(url);	2✔
105	return parsed.astrodata.location[0].time[0];	2✔
106	}
107
108	async _weather_data(location) {
109	const url = WEATHER_URL.format(location.y, location.x);	7✔
110	console.log('Loading weather data from ' + url);	7✔
111	const parsed = await this._get(url);	7✔
112	return parsed.weatherdata.product[0].time;	7✔
113	}
114
115	// the weather details is stored in the entry where time $.from === $.to
116	// however it contains no status information, which is available in the following entries
117	// (which have the same $.to, but different $.from)
118	// this function takes the entry with $.from === $.to for details, and one following entry for status info
119	async _extract_weather(entry1, entry2) {
120	const details = entry1.location[0];	21✔
121	const weather_id = parseInt(entry2.location[0].symbol[0].$.number);	21✔
122
123	// although symbol comes with a string, we still map it to a fixed set to simply natural language
124	// for example, "a cloudy day" can be LightCloud/PartlyCloud/Cloud in status
125	// for the full list of status, see: https://api.met.no/weatherapi/weathericon/1.1/documentation
126	let status;
127	if (weather_id === 1)	21✔
128	status = 'sunny';	1✔
129	else if (weather_id === 15)	20!
130	status = 'foggy';	×
131	else if ([2, 3, 4].indexOf(weather_id) >= 0)	20✔
132	status = 'cloudy';	4✔
133	else if ([5, 6, 9, 10, 11, 22, 41].indexOf(weather_id) >= 0)	16!
134	status = 'raining';	16✔
UNCOV 135	else if ([24, 30, 40, 46].indexOf(weather_id) >= 0)	×
UNCOV 136	status = 'drizzling';	×
137	else if ([8, 13, 14, 21, 28, 29, 33, 34, 44, 45, 49, 50].indexOf(weather_id) >= 0)	×
138	status = 'snowy';	×
139	else if ([7, 12, 20, 23, 26, 27, 31, 32, 42, 43, 47, 48].indexOf(weather_id) >= 0)	×
140	status = 'sleety';	×
141
142	return {	21✔
143	temperature: parseFloat(details.temperature ? details.temperature[0].$.value : 0),	21!
144	wind_speed: parseFloat(details.windSpeed ? details.windSpeed[0].$.mps \|\| 0 : 0),	42!
145	humidity: parseFloat(details.humidity ? details.humidity[0].$.value \|\| 0 : 0),	42!
146	cloudiness: parseFloat(details.cloudiness ? details.cloudiness[0].$.percent \|\| 0 : 0),	42!
147	fog: parseFloat(details.fog ? details.fog[0].$.percent \|\| 0 : 0),	39!
148	status,
149	icon: `http://api.met.no/weatherapi/weathericon/1.1/?symbol=${weather_id};content_type=image/png`
150	};
151	}
152
153	async get_sunrise({ location, date }) {
154	if (date === undefined \|\| date === null)	1!
155	date = new Date();	×
156	const datetz = toTemporalInstant.call(date).toZonedDateTimeISO(this.platform.timezone);	1✔
157	const data = await this._sunrise_data(location, datetz);	1✔
158
159	// the api might return sunset/sunrise time from the previous day
160	// we will need to convert to the same date first before comparison
161	let rise = Temporal.Instant.from(data.sunrise[0].$.time).toZonedDateTimeISO(this.platform.timezone);	1✔
162	if (rise.day !== datetz.day)	1!
163	rise = rise.subtract({ seconds: 86400 });	×
164	let set = Temporal.Instant.from(data.sunset[0].$.time).toZonedDateTimeISO(this.platform.timezone);	1✔
165	if (set.day !== datetz.day)	1!
166	set = set.subtract({ seconds: 86400 });	1✔
167
168	const now = Temporal.Now.instant();	1✔
169	return [{	1✔
170	location,
171	date,
172	sunrise_time: new Tp.Value.Time(rise.hour, rise.minute, rise.second),
173	sunset_time: new Tp.Value.Time(set.hour, set.minute, set.second),
174	sunrisen: Temporal.Instant.compare(now, rise.toInstant()) > 0,
175	sunset: Temporal.Instant.compare(now, set.toInstant()) > 0
176	}];
177	}
178
179	async get_moon({ location, date }) {
180	if (date === undefined \|\| date === null)	1!
181	date = new Date();	×
182	const datetz = toTemporalInstant.call(date).toZonedDateTimeISO(this.platform.timezone);	1✔
183	const data = await this._sunrise_data(location, datetz);	1✔
184	const phase = /(?:\()([a-z ]*)(?:\))/g.exec(data.moonphase[0].$.desc)[1].replace(/ /g, '_');	1✔
185	return [{ location, date, phase }];	1✔
186	}
187
188	async get_current({ location }) {
189	const data = await this._weather_data(location);	3✔
190	const current = await this._extract_weather(data[0], data[1]);	3✔
191
192	current.location = location;	3✔
193	return [ current ];	3✔
194	}
195
196	async get_forecast({ date, location }) {
197	const data = await this._weather_data(location);	4✔
198	const now = Temporal.Now.zonedDateTimeISO(this.platform.timezone);	4✔
199	const today = now.withPlainTime({ hour: 0, minute: 0 });	4✔
200
201	let datetz;
202	// do forecast for tomorrow if time is unspecified
203	if (date)	4!
204	datetz = toTemporalInstant.call(date).toZonedDateTimeISO(this.platform.timezone);	4✔
205	else
206	datetz = today.add({ days: 1 });	×
207
208	if (Temporal.Instant.compare(datetz.toInstant(), now.toInstant()) < 0)	4✔
209	throw new ForecastError('no_past_forecast', `Invalid date ${date}: is in the past`);	1✔
210
211	// find the weather closest to the time the user asked for
212
213	// if the time is midnight (ie the user specified a date without a time), we do 2pm,
214	// which is usually the hottest time of the day
215	//
216	// FIXME: we should do 2pm local-time of the location we're asking the weather for,
217	// but that's a bit difficult so we just 2pm local-time to the server
218	// (which is 2pm pacific for cloud, and 2pm local-time to the user for server/gnome)
219
220	let comparetime = datetz;	3✔
221	if (comparetime.hour === 0 && comparetime.minute === 0 &&	3!
222	comparetime.second === 0)
223	comparetime = datetz.withPlainTime({ hour: 14, minute: 0, seconds: 0 });	3✔
224	console.log(`Searching for weather forecast at ${comparetime}`);	3✔
225
226	let best = undefined, bestdelta = undefined;	3✔
227	for (let i = 0; i < data.length; i++) {	3✔
228	if (data[i].$.from !== data[i].$.to)	720✔
229	continue;	453✔
230	const datetime = Temporal.Instant.from(data[i].$.from).toZonedDateTimeISO(this.platform.timezone);	267✔
231
232	// never select a forecast for the wrong day
233	if (datetime.day !== comparetime.day \|\|	267✔
234	datetime.month !== comparetime.month \|\|
235	datetime.year !== comparetime.year)
236	continue;	239✔
237
238	let delta = Math.abs(datetime.epochMilliseconds - comparetime.epochMilliseconds);	28✔
239	if (bestdelta === undefined \|\| delta < bestdelta) {	28✔
240	best = await this._extract_weather(data[i], data[i+1]);	18✔
241	best.date = date;	18✔
242	//best.date = new Date(datetime.epochMilliseconds);
243	bestdelta = delta;	18✔
244	}
245	}
246	if (!best)	3✔
247	throw new ForecastError('not_available', `Forecast for ${date} not available yet`);	1✔
248
249	return [best];	2✔
250	}
251	};

stanford-oval / thingpedia-common-devices / 1738

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