myenergi-api 2.10.0 → 2.11.0

package/README.md

@@ -150,6 +150,43 @@ const setup: LibbiChargeSetup = await account.getLibbiChargeSetup(sno);
 await account.setLibbiChargeTarget(sno, 4600);
 ```
 
+### Other myenergi account functions
+`MyEnergiAccount` also covers the rest of the known account API. Hubs and devices are identified by their account id here, not by serial number.
+```typescript
+const hubs = await account.getHubs();                     // includes serial number and API key per hub
+const hubId = hubs[0].hubId;
+const zappi = await account.getDevice('1234567');         // look up a device's account id by serial number
+const locations = await account.getLocations();           // sites, with address and energy setup
+const vehicles = await account.getVehicles();             // vehicle profiles
+const schedules = await account.getChargeSchedules();     // all charge schedules, per hub and device
+const history = await account.getHubHourlyHistory(hubId, new Date());
+const tariff = await account.getDualTariff(hubId);
+await account.saveDualTariff(tariff);                     // overwrites the tariff set in the myenergi app
+```
+`saveDualTariff` has not been verified against the live API.
+
+For a location you were invited to as a guest, set `account.invitationId` to the `invitationData.invitationId` of that location.
+
+### Zappi single charge (myenergi account)
+A single charge is a one-off, date-specific charge: myenergi picks the cheapest times in the window from the tariff on the account. It is not the same as a smart boost. A Zappi that does not support schedules is not listed by `getChargeSchedules`.
+```typescript
+const zappi = await account.getDevice('1234567');
+const vehicles = await account.getVehicles();
+
+// Adds to the single charges the Zappi already has
+await account.addZappiSingleCharge(zappi.id, {
+    name: 'Homey',
+    vehicleId: vehicles[0].id,
+    kWh: 10,
+    date: new Date(2026, 9, 12),
+    fromTime: '22:00',
+    toTime: '07:00',
+});
+
+await account.clearZappiSingleCharges(zappi.id);
+```
+The API only replaces the complete list of a schedule type; `saveChargeSchedules` gives direct access to that call.
+
 ## From myenergi documentation
 <a name="myenergi_documentation"></a>
 <a name="charge_mode"></a>

package/dist/src/MyEnergiAccount.d.ts

@@ -1,3 +1,5 @@
+import { AccountDevice, AccountHub, AccountHubsAndDevices, AccountLocation, AccountVehicle, DeviceChargeSchedules, DualTariff, HubChargeSchedules, ZappiSingleCharge } from "./models/Account";
+import { HistoryRecord } from "./models/HistoryRecord";
 import { LibbiChargeSetup } from "./models/LibbiChargeSetup";
 export declare class MyEnergiAccountError extends Error {
     statusCode?: number;
@@ -6,17 +8,38 @@ export declare class MyEnergiAccountError extends Error {
 }
 export declare class MyEnergiAccount {
     private _config;
+    invitationId?: string;
     private _accessToken?;
     private _refreshToken?;
     private _expiresAt;
+    private _signingIn?;
     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>;
+    getHubs(): Promise<AccountHub[]>;
+    getHubsAndDevices(): Promise<AccountHubsAndDevices>;
+    getDevice(serialNo: string): Promise<AccountDevice | null>;
+    getLocations(): Promise<AccountLocation[]>;
+    getVehicles(): Promise<AccountVehicle[]>;
+    getChargeSchedules(): Promise<HubChargeSchedules[]>;
+    getDeviceChargeSchedules(deviceId: string): Promise<DeviceChargeSchedules | null>;
+    hasTariffPrices(hubId: string): Promise<boolean>;
+    saveChargeSchedules(deviceId: string, scheduleType: string, chargeSchedules: any[], isActive?: boolean): Promise<unknown>;
+    addZappiSingleCharge(deviceId: string, charge: ZappiSingleCharge): Promise<unknown>;
+    clearZappiSingleCharges(deviceId: string): Promise<unknown>;
+    getDualTariff(hubId: string): Promise<DualTariff[]>;
+    saveDualTariff(tariffs: DualTariff[]): Promise<unknown>;
+    getHubHourlyHistory(hubId: string, day: Date, hours?: number): Promise<{
+        [key: string]: HistoryRecord[];
+    }>;
+    private toSingleChargeRequest;
+    private formatDay;
     private call;
     private getAccessToken;
+    private renewAccessToken;
     private authenticate;
     private request;
 }

package/dist/src/MyEnergiAccount.js

@@ -53,6 +53,16 @@ class MyEnergiAccount {
             client_id: "2fup0dhufn5vurmprjkj599041",
             libbi_mode_url: "/api/AccountAccess/LibbiMode",
             account_access_url: "/api/AccountAccess/",
+            hubs_url: "/api/AccountAccess/Hubs",
+            hubs_and_devices_url: "/api/Product/UserHubsAndDevices",
+            location_url: "/api/Location",
+            vehicles_url: "/api/Vehicle/UserVehicles",
+            schedules_url: "/api/ChargeSchedules/GetAllSchedules",
+            display_schedules_url: "/api/ChargeSchedules/DisplaySchedules",
+            save_schedules_url: "/api/ChargeSchedules/SaveSchedules",
+            get_tariff_url: "/api/EnergySetup/GetDualTariffEnergyPrices",
+            save_tariff_url: "/api/EnergySetup/SaveDualTariffEnergyPrices",
+            hourly_data_url: "/api/Graphs/DevicesOfHubDataHourly",
         };
         this._expiresAt = 0;
         this._config.email = email;
@@ -89,14 +99,146 @@ class MyEnergiAccount {
             yield this.call("PUT", `${this._config.account_access_url}${encodeURIComponent(serialNo)}/TargetEnergy?targetEnergy=${Math.round(targetEnergyWh)}`);
         });
     }
-    call(method, path, retry = true) {
+    getHubs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", this._config.hubs_url);
+            return (content && content.hubs) || [];
+        });
+    }
+    getHubsAndDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign({ hubs: [], devices: [], offlineDevices: [] }, yield this.call("GET", this._config.hubs_and_devices_url));
+        });
+    }
+    getDevice(serialNo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { devices } = yield this.getHubsAndDevices();
+            const found = devices.find((d) => d.device && d.device.serialNumber == serialNo);
+            return found ? found.device : null;
+        });
+    }
+    getLocations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", this._config.location_url)) || [];
+        });
+    }
+    getVehicles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", this._config.vehicles_url)) || [];
+        });
+    }
+    getChargeSchedules() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", this._config.schedules_url)) || [];
+        });
+    }
+    getDeviceChargeSchedules(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const hub of yield this.getChargeSchedules()) {
+                const device = (hub.devices || []).find((d) => d.deviceId == deviceId);
+                if (device)
+                    return device;
+            }
+            return null;
+        });
+    }
+    hasTariffPrices(hubId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const content = yield this.call("GET", `${this._config.display_schedules_url}?hubId=${encodeURIComponent(hubId)}`);
+            return !!(content && content.hasTariffResponse);
+        });
+    }
+    saveChargeSchedules(deviceId, scheduleType, chargeSchedules, isActive = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.call("POST", this._config.save_schedules_url, { chargeSchedules, deviceId, isActive, scheduleType });
+        });
+    }
+    addZappiSingleCharge(deviceId, charge) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [device, vehicles] = yield Promise.all([this.getDeviceChargeSchedules(deviceId), this.getVehicles()]);
+            if (!device)
+                throw new MyEnergiAccountError("The device does not support charge schedules.");
+            const existing = (device.singleCharges || []).map((c) => this.toSingleChargeRequest(c, vehicles));
+            const added = this.toSingleChargeRequest({
+                scheduleType: "Single",
+                scheduleNickName: charge.name,
+                chargingOutputName: charge.vehicleId,
+                chargeAmountMinutes: 0,
+                chargeAmountKWh: charge.kWh,
+                fromTime: charge.fromTime,
+                toTime: charge.toTime,
+                singleChargeDay: typeof charge.date === "string" ? charge.date : this.formatDay(charge.date),
+            }, vehicles);
+            return this.saveChargeSchedules(deviceId, "Single", [...existing, added]);
+        });
+    }
+    clearZappiSingleCharges(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.saveChargeSchedules(deviceId, "Single", []);
+        });
+    }
+    getDualTariff(hubId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.call("GET", `${this._config.get_tariff_url}?hubId=${encodeURIComponent(hubId)}`)) || [];
+        });
+    }
+    saveDualTariff(tariffs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = tariffs.map((t) => ({
+                days: t.days,
+                energySetupId: t.energySetupId,
+                tariffs: t.tariffs.map((b) => ({ fromMinutes: b.fromMinutes, price: b.price, toMinutes: b.toMinutes })),
+            }));
+            return this.call("POST", this._config.save_tariff_url, body);
+        });
+    }
+    getHubHourlyHistory(hubId, day, hours = 24) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const start = Date.UTC(day.getUTCFullYear(), day.getUTCMonth(), day.getUTCDate());
+            const content = yield this.call("POST", this._config.hourly_data_url, { hubId, dayTimestampsUtc: [start], duration: hours });
+            return content || {};
+        });
+    }
+    toSingleChargeRequest(charge, vehicles) {
+        const vehicle = vehicles.find((v) => v.id == charge.chargingOutputName);
+        if (!vehicle)
+            throw new MyEnergiAccountError(`Unknown vehicle profile: ${charge.chargingOutputName}`);
+        const day = `${charge.singleChargeDay || ""}`;
+        const usDate = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(day);
+        const request = {
+            scheduleNickName: charge.scheduleNickName,
+            vehicle: { id: vehicle.id, manufacturer: vehicle.manufacturer, model: vehicle.model, batterySize: vehicle.batterySize, chargeRate: vehicle.chargeRate },
+            power: charge.chargeAmountKWh,
+            singleChargeDay: usDate ? `${usDate[2]}-${usDate[1]}-${usDate[3]}` : day,
+            fromTime: charge.fromTime,
+            toTime: charge.toTime,
+            chargeAmountMinutes: Math.round(charge.chargeAmountKWh / vehicle.chargeRate * 60),
+            chargingOutputName: vehicle.id,
+            scheduleType: "Single",
+            chargeAmountKWh: charge.chargeAmountKWh,
+        };
+        if (charge.id)
+            request.id = charge.id;
+        return request;
+    }
+    formatDay(date) {
+        const pad = (n) => `${n}`.padStart(2, "0");
+        return `${pad(date.getDate())}-${pad(date.getMonth() + 1)}-${date.getFullYear()}`;
+    }
+    call(method, path, body, 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" });
+            const url = new URL(path, this._config.base_url);
+            if (this.invitationId)
+                url.searchParams.set("invitationId", this.invitationId);
+            const headers = { Authorization: `Bearer ${token}`, Accept: "application/json" };
+            if (body !== undefined)
+                headers["Content-Type"] = "application/json";
+            const res = yield this.request(method, url, headers, body !== undefined ? JSON.stringify(body) : undefined);
             if (res.statusCode == 401 && retry) {
                 this._accessToken = undefined;
                 this._refreshToken = undefined;
-                return this.call(method, path, false);
+                return this.call(method, path, body, false);
             }
             let jsonData = {};
             try {
@@ -113,22 +255,28 @@ class MyEnergiAccount {
     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();
+                if (!this._signingIn) {
+                    this._signingIn = this.renewAccessToken().then(() => { this._signingIn = undefined; }, (error) => { this._signingIn = undefined; throw error; });
                 }
+                yield this._signingIn;
             }
             return this._accessToken;
         });
     }
+    renewAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._refreshToken) {
+                try {
+                    yield this.authenticate("REFRESH_TOKEN_AUTH", { REFRESH_TOKEN: this._refreshToken });
+                    return;
+                }
+                catch (error) {
+                    this._refreshToken = undefined;
+                }
+            }
+            yield this.login();
+        });
+    }
     authenticate(authFlow, authParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.request("POST", new URL(this._config.auth_url), {

package/dist/src/index.d.ts

@@ -1,3 +1,4 @@
+import { AccountDevice, AccountHub, AccountHubsAndDevices, AccountLocation, AccountVehicle, ChargeSchedule, DeviceChargeSchedules, DualTariff, HubChargeSchedules, TariffBand, ZappiSingleCharge } from "./models/Account";
 import { Eddi } from "./models/Eddi";
 import { Harvi } from "./models/Harvi";
 import { HistoryRecord } from "./models/HistoryRecord";
@@ -7,4 +8,4 @@ import { EddiBoost, EddiHeaterStatus, EddiMode, LibbiMode, ZappiBoostMode, Zappi
 import { Zappi } from "./models/Zappi";
 import { MyEnergi } from "./MyEnergi";
 import { MyEnergiAccount, MyEnergiAccountError } from "./MyEnergiAccount";
-export { MyEnergi, MyEnergiAccount, MyEnergiAccountError, Eddi, Zappi, Harvi, Libbi, LibbiChargeSetup, HistoryRecord, EddiBoost, EddiMode, EddiHeaterStatus, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus };
+export { MyEnergi, MyEnergiAccount, MyEnergiAccountError, Eddi, Zappi, Harvi, Libbi, LibbiChargeSetup, AccountDevice, AccountHub, AccountHubsAndDevices, AccountLocation, AccountVehicle, ChargeSchedule, DeviceChargeSchedules, DualTariff, HubChargeSchedules, TariffBand, ZappiSingleCharge, HistoryRecord, EddiBoost, EddiMode, EddiHeaterStatus, LibbiMode, ZappiBoostMode, ZappiChargeMode, ZappiPhaseSetting, ZappiStatus };

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

@@ -0,0 +1,125 @@
+export interface AccountHub {
+    hubId: string;
+    hubName: string;
+    serialNo: string;
+    hubPassword: string;
+    locationId: string;
+    locationName: string;
+    isVHub: boolean;
+    server: string;
+    devices: string[];
+}
+export interface AccountDevice {
+    id: string;
+    deviceName: string;
+    deviceType: string;
+    serialNumber: string;
+    firmware: string;
+    status: number;
+    locationId?: string;
+}
+export interface AccountHubsAndDevices {
+    hubs: {
+        hub: {
+            id: string;
+            serialNo: string;
+            nickName: string;
+            firmware: string;
+            isVHub: boolean;
+        };
+        deviceIds: string[];
+        locationId: string;
+    }[];
+    devices: {
+        device: AccountDevice;
+        locationId: string;
+        isVHub: boolean;
+    }[];
+    offlineDevices: unknown[];
+}
+export interface AccountLocation {
+    address: {
+        id: string;
+        siteName: string;
+        countryCode: string;
+        currency: string;
+        [key: string]: unknown;
+    };
+    energySetup: {
+        id: string;
+        energyProvider: string;
+        energyTariff: string;
+        tariffFriendlyName: string;
+        isEconomy: boolean;
+        isActive: boolean;
+        [key: string]: unknown;
+    };
+    isGuestLocation: boolean;
+    invitationData?: {
+        invitationId: string;
+        [key: string]: unknown;
+    };
+    ownerEmail: string;
+}
+export interface AccountVehicle {
+    id: string;
+    manufacturer: string;
+    model: string;
+    batterySize: number;
+    chargeRate: number;
+    manufacturingYear?: number;
+    ownership?: number;
+}
+export interface ChargeSchedule {
+    id?: string;
+    scheduleType: string;
+    scheduleNickName: string;
+    chargingOutputName: string;
+    chargeAmountMinutes: number;
+    chargeAmountKWh: number;
+    fromTime: string;
+    toTime: string;
+    singleChargeDay?: string;
+    isActive?: boolean;
+    [key: string]: unknown;
+}
+export interface DeviceChargeSchedules {
+    deviceId: string;
+    deviceName: string;
+    deviceType: string;
+    firmware: string;
+    scheduleCharges: ChargeSchedule[];
+    scheduleChargesActive: boolean;
+    budgetCharges: ChargeSchedule[];
+    budgetChargesActive: boolean;
+    singleCharges: ChargeSchedule[];
+    singleChargesActive: boolean;
+}
+export interface HubChargeSchedules {
+    hubId: string;
+    hubNickName: string;
+    energySetupProvider: string;
+    energySetupTarrif: string;
+    isEconomy: boolean;
+    isGuestUser: boolean;
+    devices: DeviceChargeSchedules[];
+}
+export interface ZappiSingleCharge {
+    name: string;
+    vehicleId: string;
+    kWh: number;
+    date: Date | string;
+    fromTime: string;
+    toTime: string;
+}
+export interface TariffBand {
+    id?: string;
+    fromMinutes: number;
+    toMinutes: number;
+    price: number;
+}
+export interface DualTariff {
+    energySetupId: string;
+    days: number[];
+    tariffs: TariffBand[];
+}

package/dist/src/models/Account.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.10.0",
+    "version": "2.11.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",