homebridge-foobot-multi/dist/foobot.js

Homebridge plugin for Foobot air quality monitor

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Foobot = void 0;
//const https = require('https');
const https = __importStar(require("https"));
class Foobot {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.BASE_HREF = 'https://api.foobot.io/v2';
        return;
    }
    /**
     * List devices associated with user
     */
    async getDevices(userName) {
        userName = encodeURIComponent(userName);
        const url = `${this.BASE_HREF}/owner/${userName}/devices`;
        return this.request(url);
    }
    /**
     * List devices associated with user
     */
    async getLastDataPoints(uuid, period, averageBy, sensorList) {
        if (!uuid) {
            throw new Error('UUID required');
        }
        uuid = encodeURIComponent(uuid);
        const encodedPeriod = encodeURIComponent(period || 0);
        const encodedAverageBy = encodeURIComponent(averageBy || 0);
        let url = `${this.BASE_HREF}/device/${uuid}/datapoint/${encodedPeriod}/last/${encodedAverageBy}/`;
        if (typeof sensorList !== 'undefined') {
            sensorList = encodeURIComponent(sensorList);
            url += `?sensorList=${sensorList}`;
        }
        return this.request(url);
    }
    async request(url, options) {
        return new Promise((resolve, reject) => {
            if (typeof options === 'undefined') {
                options = {};
            }
            if (typeof options.headers === 'undefined') {
                options.headers = {};
            }
            options.headers['accept'] = 'application/json;charset=UTF-8';
            options.headers['x-api-key-token'] = this.apiKey;
            https.get(url, options, (res) => {
                const { statusCode } = res;
                const contentType = res.headers['content-type'];
                let err;
                if (statusCode && (statusCode < 200 || statusCode >= 300)) {
                    err = new Error(`Request Failed ${statusCode} ${url}`);
                }
                else if (!/^application\/json/.test(contentType)) {
                    err = new Error(`Invalid content-type; Expected application/json; Received ${contentType}; ${url}`);
                }
                if (err) {
                    // Consume response data to free up memory
                    res.resume();
                    reject(err);
                    return;
                }
                res.setEncoding('utf8');
                let rawData = '';
                res.on('data', (chunk) => {
                    rawData += chunk;
                });
                res.on('end', () => {
                    try {
                        const parsedData = JSON.parse(rawData);
                        resolve(parsedData);
                    }
                    catch (err) {
                        reject(err);
                    }
                });
            }).on('error', (err) => {
                reject(err);
            });
        });
    }
}
exports.Foobot = Foobot;
//# sourceMappingURL=foobot.js.map