myenergi-api 0.0.9-0 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myenergi-api",
-    "version": "0.0.9-0",
+    "version": "0.1.0",
     "description": "NodeJS implementation of MyEnergi API for controlling Zappi, Eddi and other MyEnergi products",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -25,13 +25,12 @@
     },
     "homepage": "https://github.com/bisand/myenergi-api#readme",
     "dependencies": {
-        "dotenv": "^10.0.0",
-        "node-digest-auth-client": "^1.0.6"
+        "dotenv": "^10.0.0"
     },
     "devDependencies": {
+        "@types/chai": "^4.2.22",
         "@types/mocha": "^9.0.0",
         "@types/node": "^16.11.9",
-        "assert": "^2.0.0",
         "chai": "^4.3.4",
         "mocha": "^9.1.3",
         "ts-node": "^10.4.0",

package/src/AuthDigest.ts

@@ -4,6 +4,7 @@ export class AuthDigest {
     private _password?: string | undefined;
     private _username?: string | undefined;
     private _initialized: boolean;
+    private _onError?: (errorMessage: string) => void;
 
     public get username(): string | undefined {
         return this._username;
@@ -20,8 +21,8 @@ export class AuthDigest {
     public get uri(): string | undefined {
         return this._uri;
     }
-    private _algorithm?: string | undefined;
-    public get algorithm(): string | undefined {
+    private _algorithm: string;
+    public get algorithm(): string {
         return this._algorithm;
     }
     private _response?: string | undefined;
@@ -54,11 +55,14 @@ export class AuthDigest {
         return result;
     }
 
-    constructor(username: string, password: string) {
+    constructor(username: string, password: string, errorHandler?: (errorMessage: string) => void) {
         this._username = username;
         this._password = password;
         this._nc = 0;
         this._initialized = false;
+        this._algorithm = 'MD5';
+        if (errorHandler)
+            this._onError = errorHandler;
     }
 
     public init(wwwAuthHeader: string) {
@@ -89,19 +93,28 @@ export class AuthDigest {
                 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;
     }
 
     public getAuthorization(httpMethod: string, path: string): string {
-        if(!this._initialized)
+        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 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}",`;
@@ -109,7 +122,7 @@ export class AuthDigest {
         res += `uri="${path}",`;
         res += `cnonce="${cnonce}",`;
         res += `nc=${nc},`;
-        res += `algorithm=MD5,`;
+        res += `algorithm=${this.algorithm},`;
         res += `response="${response}",`;
         res += `qop="${this.qop}",`;
         res += `opaque="${this.opaque}"`;

package/src/Digest.ts

@@ -7,7 +7,9 @@ export class Digest {
     private _authDigest?: AuthDigest;
 
     constructor(username: string, password: string) {
-        this._authDigest = new AuthDigest(username, password);
+        this._authDigest = new AuthDigest(username, password, (err) => {
+            console.error(err);
+        });
     }
 
     private request(options: RequestOptions, data?: any, retryCount: number = 0): Promise<any> {
@@ -25,8 +27,7 @@ export class Digest {
                     }
                     retryCount++;
                     const wwwAuth = res.headers["www-authenticate"] as string;
-                    if(!wwwAuth.startsWith('Digest'))
-                    {
+                    if (!wwwAuth.startsWith('Digest')) {
                         reject('Unsupported authentication method. Supported authentication schemes: Digest');
                         return;
                     }

package/src/MyEnergi.ts

@@ -1,4 +1,5 @@
 import { Digest } from './Digest';
+import { Zappi } from './models/Zappi';
 
 export enum ZappiChargeMode {
     Off = 4,
@@ -35,14 +36,34 @@ export class MyEnergi {
         this._digest = new Digest(this._config.username, this._config.password);
     }
 
-    public async getStatus(): Promise<any> {
+    public async getStatusAll(): Promise<any> {
         const data = await this._digest.get(this._config.status_url);
         return data;
     }
 
-    public async getZappi(): Promise<any> {
+    public async getStatusZappiAll(): Promise<Zappi[]> {
         const data = await this._digest.get(this._config.zappi_url);
-        return data;
+        const jsonData = JSON.parse(data);
+        if (jsonData.zappi)
+            return Object.assign<Zappi[], any>([] as Zappi[], jsonData.zappi);
+        else
+            return [] as Zappi[];
+    }
+
+    public async getStatusZappi(serialNumber: string): Promise<Zappi | null> {
+        const data = await this._digest.get(this._config.zappi_url);
+        const jsonData = JSON.parse(data);
+        if (jsonData.zappi) {
+            const zappi = (Object.assign<Zappi[], any>([] as Zappi[], jsonData.zappi) as Zappi[]).find(zappi => {
+                return zappi.sno === serialNumber;
+            });
+            if (zappi)
+                return Object.assign<Zappi, any>({} as Zappi, zappi);
+            else
+                return null;
+        }
+        else
+            return null;
     }
 
     public async setZappiChargeMode(serialNo: string, chargeMode: ZappiChargeMode): Promise<any> {

package/src/models/Zappi.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/tests/MyEnergi-spec.ts

@@ -1,10 +1,9 @@
 import { MyEnergi } from '../src/MyEnergi'
-import { equal } from "assert";
 import { expect } from 'chai'
 
 describe("MyEnergi Tests", () => {
   it("should be able to test", () => {
-    equal(true, true);
+    expect(true).to.be.true;
   });
   it("should be able to create instance", () => {
     const myenergi = new MyEnergi('test', 'pwd');

package/tests/debug.ts

@@ -5,18 +5,24 @@ import { ZappiBoostMode, ZappiChargeMode } from '../src/MyEnergi';
 
 dotenv.config();
 const myenergi = new MyEnergi(process.env.USERNAME as string, process.env.PASSWORD as string);
-myenergi.getStatus().then(val => {
+myenergi.getStatusAll().then(val => {
     console.log(val);
-    myenergi.getZappi().then(v => {
+    myenergi.getStatusZappiAll().then(v => {
         console.log(v);
-        const sno: string = JSON.parse(v).zappi[0].sno;
+        const sno: string = v[0].sno;
         myenergi.setZappiChargeMode(sno, ZappiChargeMode.Fast).then(x => {
             console.log(x);
             myenergi.setZappiBoostMode(sno, ZappiBoostMode.Stop).then(x => {
                 console.log(x);
                 myenergi.setZappiGreenLevel(sno, 0).then(x => {
                     console.log(x);
-                    exit();
+                    myenergi.getStatusZappi(sno).then(x => {
+                        console.log(x);
+                        exit();
+                    }).catch(err => {
+                        console.error(err);
+                        exit();
+                    });
                 }).catch(err => {
                     console.error(err);
                     exit();