myenergi-api 2.9.0 → 2.10.0

package/README.md

@@ -134,6 +134,22 @@ console.log(result);
 ```
 
 
+### Libbi charge from grid (myenergi account)
+Charge from grid is not available through the hub serial and API key. It uses the myenergi account API, which needs the email and password of your myenergi account. Unlike `MyEnergi`, the methods of `MyEnergiAccount` throw a `MyEnergiAccountError` when a request fails.
+
+The Libbi only charges from the grid up to its charge target, and only during the cheap periods of the tariff configured in the myenergi app.
+```typescript
+const account = new MyEnergiAccount("me@example.com", "!3uper3ecretPassw0rd");
+const sno = '1234567';
+
+const enabled: boolean = await account.getLibbiChargeFromGrid(sno);
+await account.setLibbiChargeFromGrid(sno, true);
+
+// Charge target in Wh
+const setup: LibbiChargeSetup = await account.getLibbiChargeSetup(sno);
+await account.setLibbiChargeTarget(sno, 4600);
+```
+
 ## From myenergi documentation
 <a name="myenergi_documentation"></a>
 <a name="charge_mode"></a>

package/dist/src/MyEnergiAccount.d.ts

@@ -0,0 +1,22 @@
+import { LibbiChargeSetup } from "./models/LibbiChargeSetup";
+export declare class MyEnergiAccountError extends Error {
+    statusCode?: number;
+    authFailed: boolean;
+    constructor(message: string, statusCode?: number, authFailed?: boolean);
+}
+export declare class MyEnergiAccount {
+    private _config;
+    private _accessToken?;
+    private _refreshToken?;
+    private _expiresAt;
+    constructor(email: string, password: string, accountBaseUrl?: string, authUrl?: string);
+    login(): Promise<void>;
+    getLibbiChargeFromGrid(serialNo: string): Promise<boolean>;
+    setLibbiChargeFromGrid(serialNo: string, chargeFromGrid: boolean): Promise<void>;
+    getLibbiChargeSetup(serialNo: string): Promise<LibbiChargeSetup>;
+    setLibbiChargeTarget(serialNo: string, targetEnergyWh: number): Promise<void>;
+    private call;
+    private getAccessToken;
+    private authenticate;
+    private request;
+}

package/dist/src/MyEnergiAccount.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+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.MyEnergiAccount = exports.MyEnergiAccountError = void 0;
+const https = __importStar(require("https"));
+class MyEnergiAccountError extends Error {
+    constructor(message, statusCode, authFailed = false) {
+        super(message);
+        this.name = "MyEnergiAccountError";
+        this.statusCode = statusCode;
+        this.authFailed = authFailed;
+    }
+}
+exports.MyEnergiAccountError = MyEnergiAccountError;
+class MyEnergiAccount {
+    constructor(email, password, accountBaseUrl, authUrl) {
+        this._config = {
+            email: "",
+            password: "",
+            base_url: "https://myaccount.myenergi.com",
+            auth_url: "https://cognito-idp.eu-west-2.amazonaws.com/",
+            client_id: "2fup0dhufn5vurmprjkj599041",
+            libbi_mode_url: "/api/AccountAccess/LibbiMode",
+            account_access_url: "/api/AccountAccess/",
+        };
+        this._expiresAt = 0;
+        this._config.email = email;
+        this._config.password = password;
+        if (accountBaseUrl)
+            this._config.base_url = accountBaseUrl;
+        if (authUrl)
+            this._config.auth_url = authUrl;
+    }
+    login() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.authenticate("USER_PASSWORD_AUTH", { USERNAME: this._config.email, PASSWORD: this._config.password });
+        });
+    }
+    getLibbiChargeFromGrid(serialNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", `${this._config.libbi_mode_url}?serialNo=${encodeURIComponent(serialNo)}`);
+            return !!(content && content[serialNo]);
+        });
+    }
+    setLibbiChargeFromGrid(serialNo, chargeFromGrid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call("PUT", `${this._config.libbi_mode_url}?chargeFromGrid=${chargeFromGrid}&serialNo=${encodeURIComponent(serialNo)}`);
+        });
+    }
+    getLibbiChargeSetup(serialNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", `${this._config.account_access_url}${encodeURIComponent(serialNo)}/LibbiChargeSetup`);
+            return Object.assign({}, content);
+        });
+    }
+    setLibbiChargeTarget(serialNo, targetEnergyWh) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call("PUT", `${this._config.account_access_url}${encodeURIComponent(serialNo)}/TargetEnergy?targetEnergy=${Math.round(targetEnergyWh)}`);
+        });
+    }
+    call(method, path, retry = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield this.getAccessToken();
+            const res = yield this.request(method, new URL(path, this._config.base_url), { Authorization: `Bearer ${token}`, Accept: "application/json" });
+            if (res.statusCode == 401 && retry) {
+                this._accessToken = undefined;
+                this._refreshToken = undefined;
+                return this.call(method, path, false);
+            }
+            let jsonData = {};
+            try {
+                jsonData = JSON.parse(res.body);
+            }
+            catch (error) {
+            }
+            if (res.statusCode < 200 || res.statusCode >= 300 || jsonData.status !== true) {
+                throw new MyEnergiAccountError(jsonData.message || `Request failed with status code ${res.statusCode}`, res.statusCode, res.statusCode == 401);
+            }
+            return jsonData.content;
+        });
+    }
+    getAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._accessToken || Date.now() >= this._expiresAt) {
+                if (this._refreshToken) {
+                    try {
+                        yield this.authenticate("REFRESH_TOKEN_AUTH", { REFRESH_TOKEN: this._refreshToken });
+                    }
+                    catch (error) {
+                        this._refreshToken = undefined;
+                        yield this.login();
+                    }
+                }
+                else {
+                    yield this.login();
+                }
+            }
+            return this._accessToken;
+        });
+    }
+    authenticate(authFlow, authParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.request("POST", new URL(this._config.auth_url), {
+                "Content-Type": "application/x-amz-json-1.1",
+                "X-Amz-Target": "AWSCognitoIdentityProviderService.InitiateAuth",
+            }, JSON.stringify({ AuthFlow: authFlow, AuthParameters: authParameters, ClientId: this._config.client_id }));
+            let jsonData = {};
+            try {
+                jsonData = JSON.parse(res.body);
+            }
+            catch (error) {
+            }
+            const result = jsonData.AuthenticationResult;
+            if (res.statusCode != 200 || !result || !result.AccessToken) {
+                const authFailed = jsonData.__type === "NotAuthorizedException" || jsonData.__type === "UserNotFoundException";
+                const message = jsonData.ChallengeName
+                    ? `Unsupported sign in challenge: ${jsonData.ChallengeName}`
+                    : jsonData.message || `Sign in failed with status code ${res.statusCode}`;
+                throw new MyEnergiAccountError(message, res.statusCode, authFailed);
+            }
+            this._accessToken = result.AccessToken;
+            this._expiresAt = Date.now() + ((result.ExpiresIn || 3600) - 60) * 1000;
+            if (result.RefreshToken)
+                this._refreshToken = result.RefreshToken;
+        });
+    }
+    request(method, url, headers, data) {
+        return new Promise((resolve, reject) => {
+            if (data !== undefined)
+                headers["Content-Length"] = `${Buffer.byteLength(data)}`;
+            const req = https.request(url, { method, headers }, (res) => {
+                let resData = "";
+                res.setEncoding("utf8");
+                res.on("data", (chunk) => {
+                    resData += chunk;
+                });
+                res.on("end", () => {
+                    resolve({ statusCode: res.statusCode || 0, body: resData });
+                });
+            });
+            req.setTimeout(20000, () => {
+                req.destroy(new Error("Request timed out"));
+            });
+            req.on("error", (e) => {
+                reject(e);
+            });
+            if (data !== undefined) {
+                req.write(data);
+            }
+            req.end();
+        });
+    }
+}
+exports.MyEnergiAccount = MyEnergiAccount;

package/dist/src/index.d.ts

@@ -2,7 +2,9 @@ import { Eddi } from "./models/Eddi";
 import { Harvi } from "./models/Harvi";
 import { HistoryRecord } from "./models/HistoryRecord";
 import { Libbi } from "./models/Libbi";
+import { LibbiChargeSetup } from "./models/LibbiChargeSetup";
 import { EddiBoost, EddiHeaterStatus, EddiMode, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus } from "./models/Types";
 import { Zappi } from "./models/Zappi";
 import { MyEnergi } from "./MyEnergi";
-export { MyEnergi, Eddi, Zappi, Harvi, Libbi, HistoryRecord, EddiBoost, EddiMode, EddiHeaterStatus, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus };
+import { MyEnergiAccount, MyEnergiAccountError } from "./MyEnergiAccount";
+export { MyEnergi, MyEnergiAccount, MyEnergiAccountError, Eddi, Zappi, Harvi, Libbi, LibbiChargeSetup, HistoryRecord, EddiBoost, EddiMode, EddiHeaterStatus, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus };

package/dist/src/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZappiStatus = exports.ZappiPhaseSetting = exports.ZappiChargeMode = exports.ZappiBoostMode = exports.LibbiMode = exports.EddiHeaterStatus = exports.EddiMode = exports.EddiBoost = exports.MyEnergi = void 0;
+exports.ZappiStatus = exports.ZappiPhaseSetting = exports.ZappiChargeMode = exports.ZappiBoostMode = exports.LibbiMode = exports.EddiHeaterStatus = exports.EddiMode = exports.EddiBoost = exports.MyEnergiAccountError = exports.MyEnergiAccount = exports.MyEnergi = void 0;
 const Types_1 = require("./models/Types");
 Object.defineProperty(exports, "EddiBoost", { enumerable: true, get: function () { return Types_1.EddiBoost; } });
 Object.defineProperty(exports, "EddiHeaterStatus", { enumerable: true, get: function () { return Types_1.EddiHeaterStatus; } });
@@ -12,3 +12,6 @@ Object.defineProperty(exports, "ZappiPhaseSetting", { enumerable: true, get: fun
 Object.defineProperty(exports, "ZappiStatus", { enumerable: true, get: function () { return Types_1.ZappiStatus; } });
 const MyEnergi_1 = require("./MyEnergi");
 Object.defineProperty(exports, "MyEnergi", { enumerable: true, get: function () { return MyEnergi_1.MyEnergi; } });
+const MyEnergiAccount_1 = require("./MyEnergiAccount");
+Object.defineProperty(exports, "MyEnergiAccount", { enumerable: true, get: function () { return MyEnergiAccount_1.MyEnergiAccount; } });
+Object.defineProperty(exports, "MyEnergiAccountError", { enumerable: true, get: function () { return MyEnergiAccount_1.MyEnergiAccountError; } });

package/dist/src/models/LibbiChargeSetup.d.ts

@@ -0,0 +1,5 @@
+export interface LibbiChargeSetup {
+    deviceSerial: string;
+    chargeFromGrid: boolean;
+    energyTarget: number;
+}

package/dist/src/models/LibbiChargeSetup.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myenergi-api",
-    "version": "2.9.0",
+    "version": "2.10.0",
     "description": "NodeJS implementation of MyEnergi API for controlling Zappi, Eddi and other MyEnergi products",
     "main": "dist/src/index.js",
     "types": "dist/src/index.d.ts",