myenergi-api 0.0.7-0 → 0.0.8-0

package/package.json

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

package/src/AuthDigest.ts

@@ -0,0 +1,119 @@
+import * as crypto from 'crypto';
+
+export class AuthDigest {
+    private _password?: string | undefined;
+    private _username?: string | undefined;
+    private _initialized: boolean;
+
+    public get username(): string | undefined {
+        return this._username;
+    }
+    private _realm?: string | undefined;
+    public get realm(): string | undefined {
+        return this._realm;
+    }
+    private _nonce?: string | undefined;
+    public get nonce(): string | undefined {
+        return this._nonce;
+    }
+    private _uri?: string | undefined;
+    public get uri(): string | undefined {
+        return this._uri;
+    }
+    private _algorithm?: string | undefined;
+    public get algorithm(): string | undefined {
+        return this._algorithm;
+    }
+    private _response?: string | undefined;
+    public get response(): string | undefined {
+        return this._response;
+    }
+    private _opaque?: string | undefined;
+    public get opaque(): string | undefined {
+        return this._opaque;
+    }
+    private _qop?: string | undefined;
+    public get qop(): string | undefined {
+        return this._qop;
+    }
+    private _nc: number;
+    public get nc(): string | undefined {
+        this._nc++;
+        var myHex = ("0000000" + this._nc?.toString(16)).substr(-8);
+        return myHex;
+    }
+    private _cnonce?: string | undefined;
+    public get cnonce(): string | undefined {
+        this._cnonce = this.md5(String(new Date().getTime()));
+        return this._cnonce;
+    }
+
+    private md5(data: string) {
+        let md5 = crypto.createHash('md5');
+        let result = md5.update(data).digest('hex');
+        return result;
+    }
+
+    constructor(username: string, password: string) {
+        this._username = username;
+        this._password = password;
+        this._nc = 0;
+        this._initialized = false;
+    }
+
+    public init(wwwAuthHeader: string) {
+
+        //let realm, nonce, qop, opaque;
+        let authSplit = wwwAuthHeader.split(',') as string[];
+
+        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);
+            }
+        }
+        this._initialized = true;
+    }
+
+    public getAuthorization(httpMethod: string, path: string): string {
+        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=MD5,`;
+        res += `response="${response}",`;
+        res += `qop="${this.qop}",`;
+        res += `opaque="${this.opaque}"`;
+        return res;
+    }
+}

package/src/Digest.ts

@@ -1,91 +1,35 @@
 import * as https from 'https';
-import * as crypto from 'crypto';
 import { RequestOptions } from 'https';
 import * as url from "url";
+import { AuthDigest } from './AuthDigest';
 
 export class Digest {
-    private _username: string;
-    private _password: string;
-    private _authorization: string | undefined;
+    private _authorization?: AuthDigest;
 
     constructor(username: string, password: string) {
-        this._username = username;
-        this._password = password;
-        this._authorization = '';
+        this._authorization = new AuthDigest(username, password);
     }
 
-    private md5(data: string) {
-        let md5 = crypto.createHash('md5');
-        let result = md5.update(data).digest('hex');
-        return result;
-    }
-
-    private request(options: RequestOptions, data?: any): Promise<any> {
-        return new Promise<any>((resolve, reject) => {
-            const req = https.request(options, (res: any) => {
-                let resData: string = '';
-
-                res.setEncoding('utf8');
-                res.on('data', (chunk: string) => {
-                    resData += chunk;
-                });
-                res.on('end', () => {
-                    resolve(resData);
-                });
-            });
-
-            req.on('error', (e: any) => {
-                console.error(`problem with request: ${e.message}`);
-                reject(e);
-            });
-
-            if (data) {
-                req.write(data);
-            }
-
-            req.end();
-        });
-    }
-
-    private requestDigest(options: RequestOptions, data?: any): Promise<any> {
+    private request(options: RequestOptions, data?: any, retryCount: number = 0): Promise<any> {
         return new Promise<any>((resolve, reject) => {
             let resData: string = '';
+            if (!options.headers)
+                options.headers = {};
+            options.headers.Authorization = this._authorization?.getAuthorization(options.method as string, options.path as string);
             const req = https.request(options, (res: any) => {
 
                 if (res.statusCode == 401) {
-                    let cnonce = this.md5(String(new Date().getTime()));
-                    let auth = res.headers["www-authenticate"];
-                    let realm, nonce, qop;
-                    let authSplit = auth?.split(",") as string[];
-
-                    for (let item of authSplit) {
-                        if (item.indexOf("realm=") >= 0) {
-                            let realmSplit = item.split("=\"");
-                            realm = realmSplit[realmSplit.length - 1];
-                            realm = realm.substring(0, realm.length - 1);
-                        }
-
-                        if (item.indexOf("nonce=") >= 0) {
-                            let nonceSplit = item.split("=\"");
-                            nonce = nonceSplit[nonceSplit.length - 1];
-                            nonce = nonce.substring(0, nonce.length - 1);
-                        }
-
-                        if (item.indexOf("qop=") >= 0) {
-                            let qopSplit = item.split("=\"");
-                            qop = qopSplit[qopSplit.length - 1];
-                            qop = qop.substring(0, qop.length - 1);
-                        }
+                    if (retryCount > 1) {
+                        reject("Authentication failed");
+                        return;
                     }
-
-                    let HA1 = this.md5(this._username + ":" + realm + ":" + this._password);
-                    let HA2 = this.md5(options.method + ":" + options.path);
-                    let response = this.md5(HA1 + ":" + nonce + ":00000001:" + cnonce + ":" + qop + ":" + HA2);
+                    retryCount++;
+                    let auth = res.headers["www-authenticate"];
+                    this._authorization?.init(auth);
                     if (!options.headers)
                         options.headers = {};
-                    this._authorization = "Digest username=\"" + this._username + "\",realm=\"" + realm + "\",nonce=\"" + nonce + "\",uri=\"" + options.path + "\",cnonce=\"" + cnonce + "\",nc=00000001,algorithm=MD5,response=\"" + response + "\",qop=\"" + qop + "\"";
-                    options.headers.Authorization = this._authorization;
-                    return this.requestDigest(options, data).then(value => {
+                    options.headers.Authorization = this._authorization?.getAuthorization(options.method as string, options.path as string);
+                    return this.request(options, data, retryCount).then(value => {
                         resolve(value);
                     }).catch(resaon => {
                         reject(resaon);
@@ -119,7 +63,7 @@ export class Digest {
     }
 
     public get(requestUrl: string, data?: any): Promise<any> {
-        const uri = url.parse(requestUrl);
+        const uri = url.parse(requestUrl, true);
         const options: RequestOptions = {
             hostname: uri.hostname,
             port: uri.port,
@@ -127,12 +71,11 @@ export class Digest {
             method: 'GET',
             headers: {
                 'Connection': 'Keep-Alive',
-                'Content-Type': 'text/plain',
+                'Content-Type': 'application/json',
                 'Host': uri.hostname as string,
-                'Authorization': this._authorization
             }
         };
-        return this.requestDigest(options, data);
+        return this.request(options, data);
     }
 
 }

package/src/MyEnergi.ts

@@ -23,30 +23,28 @@ export class MyEnergi {
         zappi_mode_url: 'https://s18.myenergi.net/cgi-zappi-mode-Z'
         //https://s18.myenergi.net/cgi-jdayhour-Znnnnnnnn-YYYY-MM-DD
     }
-    private _client: any;
-    private _asn: any;
+
+    private _digest: Digest;
 
     constructor(username: string, password: string) {
         this._config.username = username;
         this._config.password = password;
+        this._digest = new Digest(this._config.username, this._config.password);
     }
 
     public async getStatus(): Promise<any> {
-        const digest = new Digest(this._config.username, this._config.password);
-        const data = await digest.get(this._config.status_url);
+        const data = await this._digest.get(this._config.status_url);
         return data;
     }
 
     public async getZappi(): Promise<any> {
-        const digest = new Digest(this._config.username, this._config.password);
-        const data = await digest.get(this._config.zappi_url);
+        const data = await this._digest.get(this._config.zappi_url);
         return data;
     }
 
     public async setZappiChargeMode(serialNo: string, chargeMode: ZappiChargeMode): Promise<any> {
-        const digest = new Digest(this._config.username, this._config.password);
         const url = `${this._config.zappi_mode_url}${serialNo}-${chargeMode}-0-0-0000`;
-        const data = await digest.get(url);
+        const data = await this._digest.get(url);
         return data;
     }
 

package/tests/debug.ts

@@ -13,6 +13,15 @@ myenergi.getStatus().then(val => {
         myenergi.setZappiChargeMode(sno, ZappiChargeMode.Fast).then(x => {
             console.log(x);
             exit();
+        }).catch(err => {
+            console.error(err);
+            exit();
         });
+    }).catch(err => {
+        console.error(err);
+        exit();
     });
+}).catch(err => {
+    console.error(err);
+    exit();
 });