myenergi-api 0.0.4-0 → 0.1.0

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "myenergi-api",
-    "version": "0.0.4-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",
     "scripts": {
         "build": "tsc",
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "env TS_NODE_PROJECT='tsconfig.testing.json' mocha -r ts-node/register tests/**/*-spec.ts"
     },
     "repository": {
         "type": "git",
@@ -24,11 +24,17 @@
         "url": "https://github.com/bisand/myenergi-api/issues"
     },
     "homepage": "https://github.com/bisand/myenergi-api#readme",
+    "dependencies": {
+        "dotenv": "^10.0.0"
+    },
     "devDependencies": {
-        "@types/node": "^16.11.8",
+        "@types/chai": "^4.2.22",
+        "@types/mocha": "^9.0.0",
+        "@types/node": "^16.11.9",
+        "chai": "^4.3.4",
+        "mocha": "^9.1.3",
+        "ts-node": "^10.4.0",
+        "tslint": "^6.1.3",
         "typescript": "^4.5.2"
-    },
-    "dependencies": {
-        "digest-fetch": "^1.2.1"
     }
 }

package/src/AuthDigest.ts

@@ -0,0 +1,131 @@
+import * as crypto from 'crypto';
+
+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;
+    }
+    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;
+    public get algorithm(): string {
+        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, 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) {
+
+        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);
+            }
+
+            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)
+            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;
+    }
+}

package/src/Digest.ts

@@ -0,0 +1,88 @@
+import * as https from 'https';
+import { RequestOptions } from 'https';
+import * as url from "url";
+import { AuthDigest } from './AuthDigest';
+
+export class Digest {
+    private _authDigest?: AuthDigest;
+
+    constructor(username: string, password: string) {
+        this._authDigest = new AuthDigest(username, password, (err) => {
+            console.error(err);
+        });
+    }
+
+    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._authDigest?.getAuthorization(options.method as string, options.path as string);
+            const req = https.request(options, (res: any) => {
+
+                if (res.statusCode == 401) {
+                    if (retryCount > 1) {
+                        reject("Authentication failed");
+                        return;
+                    }
+                    retryCount++;
+                    const wwwAuth = res.headers["www-authenticate"] as string;
+                    if (!wwwAuth.startsWith('Digest')) {
+                        reject('Unsupported authentication method. Supported authentication schemes: Digest');
+                        return;
+                    }
+                    this._authDigest?.init(wwwAuth);
+                    if (!options.headers)
+                        options.headers = {};
+                    options.headers.Authorization = this._authDigest?.getAuthorization(options.method as string, options.path as string);
+                    return this.request(options, data, retryCount).then(value => {
+                        resolve(value);
+                    }).catch(resaon => {
+                        reject(resaon);
+                    });
+                } else if (res.statusCode >= 200 && res.statusCode < 300) {
+                    res.setEncoding('utf8');
+                    res.on('data', (chunk: string) => {
+                        resData += chunk;
+                    });
+                    res.on('end', () => {
+                        resolve(resData);
+                    });
+                } else {
+                    console.error("status code failed!!");
+                    reject("status code failed!!");
+                    return;
+                }
+            });
+
+            req.on('error', (e: any) => {
+                console.error(`problem with request: ${e.message}`);
+                reject(e);
+            });
+
+            if (data) {
+                req.write(data);
+            }
+
+            req.end();
+        });
+    }
+
+    public get(requestUrl: string, data?: any): Promise<any> {
+        const uri = url.parse(requestUrl, true);
+        const options: RequestOptions = {
+            hostname: uri.hostname,
+            port: uri.port,
+            path: uri.pathname,
+            method: 'GET',
+            headers: {
+                'Connection': 'Keep-Alive',
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'Host': uri.hostname as string,
+            }
+        };
+        return this.request(options, data);
+    }
+
+}

package/src/MyEnergi.ts

@@ -1,4 +1,18 @@
-import DigestFetch from 'digest-fetch';
+import { Digest } from './Digest';
+import { Zappi } from './models/Zappi';
+
+export enum ZappiChargeMode {
+    Off = 4,
+    Fast = 1,
+    Eco = 2,
+    EcoPlus = 3
+}
+
+export enum ZappiBoostMode {
+    Manual = 10,
+    Smart = 11,
+    Stop = 2
+}
 
 export class MyEnergi {
     private _config = {
@@ -8,12 +22,70 @@ export class MyEnergi {
         zappi_url: 'https://s18.myenergi.net/cgi-jstatus-Z',
         harvi_url: 'https://s18.myenergi.net/cgi-jstatus-H',
         status_url: 'https://s18.myenergi.net/cgi-jstatus-*',
-        dayhour_url: 'https://s18.myenergi.net/cgi-jdayhour-'
+        dayhour_url: 'https://s18.myenergi.net/cgi-jdayhour-',
+        zappi_mode_url: 'https://s18.myenergi.net/cgi-zappi-mode-Z',
+        zappi_min_green_url: 'https://s18.myenergi.net/cgi-set-min-green-Z'
         //https://s18.myenergi.net/cgi-jdayhour-Znnnnnnnn-YYYY-MM-DD
     }
 
+    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 getStatusAll(): Promise<any> {
+        const data = await this._digest.get(this._config.status_url);
+        return data;
+    }
+
+    public async getStatusZappiAll(): Promise<Zappi[]> {
+        const data = await this._digest.get(this._config.zappi_url);
+        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> {
+        const url = `${this._config.zappi_mode_url}${serialNo}-${chargeMode}-0-0-0000`;
+        const data = await this._digest.get(url);
+        return data;
+    }
+
+    public async setZappiBoostMode(serialNo: string, boostMode: ZappiBoostMode, kwh: number = 0, completeTime: string = '0000'): Promise<any> {
+        if (boostMode === ZappiBoostMode.Stop) {
+            kwh = 0;
+            completeTime = '0000';
+        }
+        const url = `${this._config.zappi_mode_url}${serialNo}-0-${boostMode}-${kwh}-${completeTime}`;
+        const data = await this._digest.get(url);
+        return data;
+    }
+
+    public async setZappiGreenLevel(serialNo: string, percentage: number): Promise<any> {
+        const url = `${this._config.zappi_min_green_url}${serialNo}-${percentage}`;
+        const data = await this._digest.get(url);
+        return data;
+    }
+
 }

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

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

package/tests/debug.ts

@@ -0,0 +1,45 @@
+import { exit } from 'process';
+import { MyEnergi } from '../src';
+import * as dotenv from 'dotenv';
+import { ZappiBoostMode, ZappiChargeMode } from '../src/MyEnergi';
+
+dotenv.config();
+const myenergi = new MyEnergi(process.env.USERNAME as string, process.env.PASSWORD as string);
+myenergi.getStatusAll().then(val => {
+    console.log(val);
+    myenergi.getStatusZappiAll().then(v => {
+        console.log(v);
+        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);
+                    myenergi.getStatusZappi(sno).then(x => {
+                        console.log(x);
+                        exit();
+                    }).catch(err => {
+                        console.error(err);
+                        exit();
+                    });
+                }).catch(err => {
+                    console.error(err);
+                    exit();
+                });
+            }).catch(err => {
+                console.error(err);
+                exit();
+            });
+        }).catch(err => {
+            console.error(err);
+            exit();
+        });
+    }).catch(err => {
+        console.error(err);
+        exit();
+    });
+}).catch(err => {
+    console.error(err);
+    exit();
+});

package/tsconfig.testing.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+      "module": "commonjs",
+      "target": "es2015",
+      "lib": ["es2017"],
+      "outDir": "./dist",
+      "declaration": false,
+      "noImplicitAny": false,
+      "removeComments": true,
+      "inlineSourceMap": true,
+      "moduleResolution": "node",
+    },
+    "include": ["src/**/*.ts", "src/**/*.d.ts", "tests/**/*.ts"]
+  }

package/dist/MyEnergi.d.ts

@@ -1,4 +0,0 @@
-export declare class MyEnergi {
-    private _config;
-    constructor(username: string, password: string);
-}

package/dist/MyEnergi.js

@@ -1,16 +0,0 @@
-export class MyEnergi {
-    constructor(username, password) {
-        this._config = {
-            username: '',
-            password: '',
-            eddi_url: 'https://s18.myenergi.net/cgi-jstatus-E',
-            zappi_url: 'https://s18.myenergi.net/cgi-jstatus-Z',
-            harvi_url: 'https://s18.myenergi.net/cgi-jstatus-H',
-            status_url: 'https://s18.myenergi.net/cgi-jstatus-*',
-            dayhour_url: 'https://s18.myenergi.net/cgi-jdayhour-'
-            //https://s18.myenergi.net/cgi-jdayhour-Znnnnnnnn-YYYY-MM-DD
-        };
-        this._config.username = username;
-        this._config.password = password;
-    }
-}

package/dist/index.d.ts

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

package/dist/index.js

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

package/npm-publish.sh

@@ -1,73 +0,0 @@
-#!/bin/sh
-
-DEV_BRANCH_NAME="develop"
-MASTER_BRANCH_NAME="master"
-RELEASE_TYPE="$1"
-
-confirm() {
-    # call with a prompt string or use a default
-    read -r -p "${1:-Are you sure? [y/N]} " response
-    case "$response" in
-        [yY][eE][sS]|[yY])
-            true
-            ;;
-        *)
-            false
-            ;;
-    esac
-}
-
-execute() {
-    if git checkout ${DEV_BRANCH_NAME} &&
-        git fetch origin ${DEV_BRANCH_NAME} &&
-        # [ `git rev-list HEAD...origin/${DEV_BRANCH_NAME} --count` != 0 ] &&
-        git merge origin/${DEV_BRANCH_NAME}
-    then
-        npm install
-        echo "Performing ${RELEASE_TYPE} release preparations..."
-        if npm version ${RELEASE_TYPE} -m "Release version %s"
-        then
-            echo "NPM version done. Proceeding with git operations..."
-            if git add . &&
-                git push &&
-                git checkout origin/${MASTER_BRANCH_NAME} &&
-                git pull &&
-                git merge ${DEV_BRANCH_NAME} &&
-                git push &&
-                git push --tags
-            then
-                git checkout origin/${DEV_BRANCH_NAME}
-                git merge ${MASTER_BRANCH_NAME}
-                git push
-                echo "Changes merged to ${MASTER_BRANCH_NAME} branch and pushed to origin."
-                true
-            else
-                echo "Failed to merge to ${MASTER_BRANCH_NAME} branch and push to origin."
-                false
-            fi
-        else
-            echo "NPM version failed!"
-            false
-        fi
-    else
-        echo "Could not prepare for new release. Please make sure the repository is up to date with the origin before you continue."
-        false
-    fi
-}
-
-run() {
-    if confirm && execute
-    then
-        echo "Successfully completed!"
-    else
-        echo "Failed to complete!"
-    fi
-}
-
-if [ "${RELEASE_TYPE}" = "patch" ] || [ "${RELEASE_TYPE}" = "minor" ] || [ "${RELEASE_TYPE}" = "major" ] ||
-    [ "${RELEASE_TYPE}" = "prepatch" ] || [ "${RELEASE_TYPE}" = "preminor" ] || [ "${RELEASE_TYPE}" = "premajor" ] || [ "${RELEASE_TYPE}" = "prerelease" ]
-then
-    run
-else
-    echo "'${RELEASE_TYPE}' is not a valid release type. Please use 'patch', 'minor', 'major', 'prepatch', 'preminor' or 'premajor'"
-fi

package/src/types/digest-fetch.d.ts

@@ -1 +0,0 @@
-declare module "digest-fetch";

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2015",
-        "module": "ES2020",
-        "declaration": true,
-        "outDir": "./dist",
-        "forceConsistentCasingInFileNames": true,
-        "moduleResolution": "node",
-        "esModuleInterop": true,
-        "strict": true
-    },
-    "include": [
-        "./src"
-    ]
-}