myenergi-api 0.2.0 → 0.6.0

package/dist/AuthDigest.d.ts

@@ -0,0 +1,29 @@
+export declare class AuthDigest {
+    private _password?;
+    private _username?;
+    private _initialized;
+    private _onError?;
+    get username(): string | undefined;
+    private _realm?;
+    get realm(): string | undefined;
+    private _nonce?;
+    get nonce(): string | undefined;
+    private _uri?;
+    get uri(): string | undefined;
+    private _algorithm;
+    get algorithm(): string;
+    private _response?;
+    get response(): string | undefined;
+    private _opaque?;
+    get opaque(): string | undefined;
+    private _qop?;
+    get qop(): string | undefined;
+    private _nc;
+    get nc(): string | undefined;
+    private _cnonce?;
+    get cnonce(): string | undefined;
+    private md5;
+    constructor(username: string, password: string, errorHandler?: (errorMessage: string) => void);
+    init(wwwAuthHeader: string): void;
+    getAuthorization(httpMethod: string, path: string): string;
+}

package/dist/AuthDigest.js

@@ -0,0 +1,128 @@
+"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.AuthDigest = void 0;
+const crypto = __importStar(require("crypto"));
+class AuthDigest {
+    constructor(username, password, errorHandler) {
+        this._username = username;
+        this._password = password;
+        this._nc = 0;
+        this._initialized = false;
+        this._algorithm = 'MD5';
+        if (errorHandler)
+            this._onError = errorHandler;
+    }
+    get username() {
+        return this._username;
+    }
+    get realm() {
+        return this._realm;
+    }
+    get nonce() {
+        return this._nonce;
+    }
+    get uri() {
+        return this._uri;
+    }
+    get algorithm() {
+        return this._algorithm;
+    }
+    get response() {
+        return this._response;
+    }
+    get opaque() {
+        return this._opaque;
+    }
+    get qop() {
+        return this._qop;
+    }
+    get nc() {
+        var _a;
+        this._nc++;
+        var myHex = ('0000000' + ((_a = this._nc) === null || _a === void 0 ? void 0 : _a.toString(16))).substr(-8);
+        return myHex;
+    }
+    get cnonce() {
+        this._cnonce = this.md5(String(new Date().getTime()));
+        return this._cnonce;
+    }
+    md5(data) {
+        let md5 = crypto.createHash('md5');
+        let result = md5.update(data).digest('hex');
+        return result;
+    }
+    init(wwwAuthHeader) {
+        let authSplit = wwwAuthHeader.split(',');
+        for (let item of authSplit) {
+            if (item.indexOf('realm=') >= 0) {
+                let realmSplit = item.split('="');
+                this._realm = realmSplit[realmSplit.length - 1];
+                this._realm = this._realm.substring(0, this._realm.length - 1);
+            }
+            if (item.indexOf('nonce=') >= 0) {
+                let nonceSplit = item.split('="');
+                this._nonce = nonceSplit[nonceSplit.length - 1];
+                this._nonce = this._nonce.substring(0, this._nonce.length - 1);
+            }
+            if (item.indexOf('qop=') >= 0) {
+                let qopSplit = item.split('="');
+                this._qop = qopSplit[qopSplit.length - 1];
+                this._qop = this._qop.substring(0, this._qop.length - 1);
+            }
+            if (item.indexOf('opaque=') >= 0) {
+                let opaqueSplit = item.split('="');
+                this._opaque = opaqueSplit[opaqueSplit.length - 1];
+                this._opaque = this._opaque.substring(0, this._opaque.length - 1);
+            }
+            if (item.indexOf('algorithm=') >= 0) {
+                let algorithmSplit = item.split('=');
+                this._algorithm = algorithmSplit[algorithmSplit.length - 1];
+                this._algorithm = this._algorithm.substring(0, this._algorithm.length);
+                if (this._onError && this.algorithm !== 'MD5') {
+                    this._onError(`Algorithm ${this.algorithm} is ont supported. Only MD5 is supportet`);
+                }
+            }
+        }
+        this._initialized = true;
+    }
+    getAuthorization(httpMethod, path) {
+        if (!this._initialized)
+            return '';
+        const nc = this.nc;
+        const cnonce = this.cnonce;
+        let HA1 = this.md5(this.username + ':' + this.realm + ':' + this._password);
+        let HA2 = this.md5(httpMethod + ':' + path);
+        let response = this.md5(HA1 + ':' + this.nonce + ':' + nc + ':' + cnonce + ':' + this.qop + ':' + HA2);
+        let res = `Digest username="${this.username}",`;
+        res += `realm="${this.realm}",`;
+        res += `nonce="${this.nonce}",`;
+        res += `uri="${path}",`;
+        res += `cnonce="${cnonce}",`;
+        res += `nc=${nc},`;
+        res += `algorithm=${this.algorithm},`;
+        res += `response="${response}",`;
+        res += `qop="${this.qop}",`;
+        res += `opaque="${this.opaque}"`;
+        return res;
+    }
+}
+exports.AuthDigest = AuthDigest;

package/dist/Digest.d.ts

@@ -0,0 +1,7 @@
+export declare class Digest {
+    private _authDigest?;
+    private _baseUrl;
+    constructor(baseUrl: string, username: string, password: string);
+    private request;
+    get(requestUrl: string, data?: any): Promise<any>;
+}

package/dist/Digest.js

@@ -0,0 +1,148 @@
+"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.Digest = void 0;
+const https = __importStar(require("https"));
+const url = __importStar(require("url"));
+const AuthDigest_1 = require("./AuthDigest");
+class Digest {
+    constructor(baseUrl, username, password) {
+        this._baseUrl = url.parse(baseUrl, true);
+        this._authDigest = new AuthDigest_1.AuthDigest(username, password, (err) => {
+            console.error(err);
+        });
+    }
+    request(options, data, retryCount = 0, redirectCount = 0) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            let resData = '';
+            if (!options.headers)
+                options.headers = {};
+            options.headers.Authorization = (_a = this._authDigest) === null || _a === void 0 ? void 0 : _a.getAuthorization(options.method, options.path);
+            const req = https.request(options, (res) => {
+                var _a, _b;
+                if (res.statusCode == 401) {
+                    if (retryCount > 1) {
+                        reject('Authentication failed');
+                        return;
+                    }
+                    retryCount++;
+                    const wwwAuth = res.headers['www-authenticate'];
+                    if (!wwwAuth.startsWith('Digest')) {
+                        reject('Unsupported authentication method. Supported authentication schemes: Digest');
+                        return;
+                    }
+                    (_a = this._authDigest) === null || _a === void 0 ? void 0 : _a.init(wwwAuth);
+                    if (!options.headers)
+                        options.headers = {};
+                    options.headers.Authorization = (_b = this._authDigest) === null || _b === void 0 ? void 0 : _b.getAuthorization(options.method, options.path);
+                    return this.request(options, data, retryCount)
+                        .then((value) => {
+                        resolve(value);
+                    })
+                        .catch((resaon) => {
+                        reject(resaon);
+                    });
+                }
+                else if (res.statusCode >= 200 && res.statusCode < 300) {
+                    // myenergi asn redirect handler.
+                    const myenergiAsn = res.headers['x_myenergi-asn'];
+                    if (myenergiAsn && myenergiAsn !== 'undefined' && myenergiAsn !== this._baseUrl.host) {
+                        if (redirectCount > 2) {
+                            reject(`Too many redirects: ${myenergiAsn}`);
+                            return;
+                        }
+                        this._baseUrl.host = myenergiAsn;
+                        this._baseUrl.hostname = myenergiAsn;
+                        options.host = myenergiAsn;
+                        options.hostname = myenergiAsn;
+                        redirectCount++;
+                        return this.request(options, data, retryCount, redirectCount)
+                            .then((value) => {
+                            resolve(value);
+                        })
+                            .catch((resaon) => {
+                            reject(resaon);
+                        });
+                    }
+                    // Plain 200 handling
+                    res.setEncoding('utf8');
+                    res.on('data', (chunk) => {
+                        resData += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(resData);
+                    });
+                }
+                else if (res.statusCode >= 300 && res.statusCode < 400) {
+                    if (redirectCount > 2) {
+                        reject(`Too many redirects: ${res.headers['location']}`);
+                        return;
+                    }
+                    const location = res.headers['location'];
+                    const uri = url.parse(location, true);
+                    if (uri.host !== this._baseUrl.host) {
+                        this._baseUrl.host = uri.host;
+                    }
+                    redirectCount++;
+                    return this.request(options, data, retryCount, redirectCount)
+                        .then((value) => {
+                        resolve(value);
+                    })
+                        .catch((resaon) => {
+                        reject(resaon);
+                    });
+                }
+                else {
+                    console.error('status code failed!!');
+                    reject('status code failed!!');
+                    return;
+                }
+            });
+            req.on('error', (e) => {
+                console.error(`problem with request: ${e.message}`);
+                reject(e);
+            });
+            if (data) {
+                req.write(data);
+            }
+            req.end();
+        });
+    }
+    get(requestUrl, data) {
+        const uri = url.parse(requestUrl, true);
+        const options = {
+            hostname: this._baseUrl.hostname,
+            host: this._baseUrl.host,
+            port: this._baseUrl.port,
+            path: uri.path,
+            method: 'GET',
+            headers: {
+                Connection: 'Keep-Alive',
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                Host: uri.hostname,
+            },
+        };
+        return this.request(options, data);
+    }
+}
+exports.Digest = Digest;

package/dist/MyEnergi.d.ts

@@ -0,0 +1,26 @@
+import { Harvi } from './models/Harvi';
+import { Zappi } from './models/Zappi';
+export declare enum ZappiChargeMode {
+    Off = 4,
+    Fast = 1,
+    Eco = 2,
+    EcoPlus = 3
+}
+export declare enum ZappiBoostMode {
+    Manual = 10,
+    Smart = 11,
+    Stop = 2
+}
+export declare class MyEnergi {
+    private _config;
+    private _digest;
+    constructor(username: string, password: string);
+    getStatusAll(): Promise<any>;
+    getStatusZappiAll(): Promise<Zappi[]>;
+    getStatusZappi(serialNumber: string): Promise<Zappi | null>;
+    setZappiChargeMode(serialNo: string, chargeMode: ZappiChargeMode): Promise<any>;
+    setZappiBoostMode(serialNo: string, boostMode: ZappiBoostMode, kwh?: number, completeTime?: string): Promise<any>;
+    setZappiGreenLevel(serialNo: string, percentage: number): Promise<any>;
+    getStatusHarviAll(): Promise<Harvi[]>;
+    getStatusHarvi(serialNumber: string): Promise<Harvi | null>;
+}

package/dist/MyEnergi.js

@@ -0,0 +1,136 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyEnergi = exports.ZappiBoostMode = exports.ZappiChargeMode = void 0;
+const Digest_1 = require("./Digest");
+var ZappiChargeMode;
+(function (ZappiChargeMode) {
+    ZappiChargeMode[ZappiChargeMode["Off"] = 4] = "Off";
+    ZappiChargeMode[ZappiChargeMode["Fast"] = 1] = "Fast";
+    ZappiChargeMode[ZappiChargeMode["Eco"] = 2] = "Eco";
+    ZappiChargeMode[ZappiChargeMode["EcoPlus"] = 3] = "EcoPlus";
+})(ZappiChargeMode = exports.ZappiChargeMode || (exports.ZappiChargeMode = {}));
+var ZappiBoostMode;
+(function (ZappiBoostMode) {
+    ZappiBoostMode[ZappiBoostMode["Manual"] = 10] = "Manual";
+    ZappiBoostMode[ZappiBoostMode["Smart"] = 11] = "Smart";
+    ZappiBoostMode[ZappiBoostMode["Stop"] = 2] = "Stop";
+})(ZappiBoostMode = exports.ZappiBoostMode || (exports.ZappiBoostMode = {}));
+class MyEnergi {
+    constructor(username, password) {
+        this._config = {
+            username: '',
+            password: '',
+            base_url: 'https://s18.myenergi.net',
+            eddi_url: '/cgi-jstatus-E',
+            zappi_url: '/cgi-jstatus-Z',
+            harvi_url: '/cgi-jstatus-H',
+            status_url: '/cgi-jstatus-*',
+            dayhour_url: '/cgi-jdayhour-',
+            zappi_mode_url: '/cgi-zappi-mode-Z',
+            zappi_min_green_url: '/cgi-set-min-green-Z',
+            //https://s18.myenergi.net/cgi-jdayhour-Znnnnnnnn-YYYY-MM-DD
+        };
+        this._config.username = username;
+        this._config.password = password;
+        this._digest = new Digest_1.Digest(this._config.base_url, this._config.username, this._config.password);
+    }
+    getStatusAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._digest.get(this._config.status_url);
+            const jsonData = JSON.parse(data);
+            return jsonData;
+        });
+    }
+    getStatusZappiAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._digest.get(this._config.zappi_url);
+            const jsonData = JSON.parse(data);
+            if (jsonData.zappi)
+                return Object.assign([], jsonData.zappi);
+            else
+                return [];
+        });
+    }
+    getStatusZappi(serialNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._digest.get(this._config.zappi_url);
+            const jsonData = JSON.parse(data);
+            if (jsonData.zappi) {
+                const zappi = Object.assign([], jsonData.zappi).find((zappi) => {
+                    return zappi.sno === serialNumber;
+                });
+                if (zappi)
+                    return Object.assign({}, zappi);
+                else
+                    return null;
+            }
+            else
+                return null;
+        });
+    }
+    setZappiChargeMode(serialNo, chargeMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this._config.zappi_mode_url}${serialNo}-${chargeMode}-0-0-0000`;
+            const data = yield this._digest.get(url);
+            const jsonData = JSON.parse(data);
+            return jsonData;
+        });
+    }
+    setZappiBoostMode(serialNo, boostMode, kwh = 0, completeTime = '0000') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (boostMode === ZappiBoostMode.Stop) {
+                kwh = 0;
+                completeTime = '0000';
+            }
+            const url = `${this._config.zappi_mode_url}${serialNo}-0-${boostMode}-${kwh}-${completeTime}`;
+            const data = yield this._digest.get(url);
+            const jsonData = JSON.parse(data);
+            return jsonData;
+        });
+    }
+    setZappiGreenLevel(serialNo, percentage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this._config.zappi_min_green_url}${serialNo}-${percentage}`;
+            const data = yield this._digest.get(url);
+            const jsonData = JSON.parse(data);
+            return jsonData;
+        });
+    }
+    getStatusHarviAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._digest.get(this._config.harvi_url);
+            const jsonData = JSON.parse(data);
+            if (jsonData.harvi)
+                return Object.assign([], jsonData.harvi);
+            else
+                return [];
+        });
+    }
+    getStatusHarvi(serialNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this._digest.get(this._config.harvi_url);
+            const jsonData = JSON.parse(data);
+            if (jsonData.harvi) {
+                const harvi = Object.assign([], jsonData.harvi).find((harvi) => {
+                    return harvi.sno === serialNumber;
+                });
+                if (harvi)
+                    return Object.assign({}, harvi);
+                else
+                    return null;
+            }
+            else
+                return null;
+        });
+    }
+}
+exports.MyEnergi = MyEnergi;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { MyEnergi } from './MyEnergi';
+export { MyEnergi };

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyEnergi = void 0;
+const MyEnergi_1 = require("./MyEnergi");
+Object.defineProperty(exports, "MyEnergi", { enumerable: true, get: function () { return MyEnergi_1.MyEnergi; } });

package/dist/models/Harvi.d.ts

@@ -0,0 +1,15 @@
+export interface Harvi {
+    sno: string;
+    dat: string;
+    tim: string;
+    ectp1: number;
+    ectp2: number;
+    ectp3: number;
+    ectt1: string;
+    ectt2: string;
+    ectt3: string;
+    ect1p: number;
+    ect2p: number;
+    ect3p: number;
+    fwv: string;
+}

package/dist/models/Harvi.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Zappi.d.ts

@@ -0,0 +1,41 @@
+export interface Zappi {
+    sno: string;
+    dat: string;
+    tim: string;
+    ectp1: number;
+    ectp2: number;
+    ectp3: number;
+    ectp4: number;
+    ectp5: number;
+    ectp6: number;
+    ectt1: string;
+    ectt2: string;
+    ectt3: string;
+    ectt4: string;
+    ectt5: string;
+    ectt6: string;
+    bsm: number;
+    bst: number;
+    cmt: number;
+    dst: number;
+    div: number;
+    frq: number;
+    fwv: string;
+    gen: number;
+    grd: number;
+    pha: number;
+    pri: number;
+    sta: number;
+    tz: number;
+    vol: number;
+    che: number;
+    bss: number;
+    lck: number;
+    pst: string;
+    zmo: number;
+    zs: number;
+    rdc: number;
+    rac: number;
+    rrac: number;
+    zsl: number;
+}

package/dist/models/Zappi.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myenergi-api",
-    "version": "0.2.0",
+    "version": "0.6.0",
     "description": "NodeJS implementation of MyEnergi API for controlling Zappi, Eddi and other MyEnergi products",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -11,7 +11,11 @@
         "build": "tsc",
         "test": "env TS_NODE_PROJECT='tsconfig.testing.json' mocha -r ts-node/register tests/**/*-spec.ts",
         "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-        "lint": "tslint -p tsconfig.json"
+        "lint": "tslint -p tsconfig.json",
+        "prepare": "tsc",
+        "preversion": "npm test",
+        "version": "",
+        "postversion": ""
     },
     "repository": {
         "type": "git",