iobroker.easee 2.0.0-alpha.0 → 2.0.0

package/lib/observations.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const CHARGER_STATE_OBSERVATION_IDS = [
+  46, 48, 68, 80, 96, 102, 103, 109, 111, 112, 113, 114, 120, 122, 124, 132,
+  182, 183, 184, 185, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 250,
+];
+
+const STATE_FIELDS_BY_OBSERVATION_ID = {
+  46: "ledMode",
+  48: "dynamicChargerCurrent",
+  68: "wiFiAPEnabled",
+  80: "chargerFirmware",
+  96: "reasonForNoCurrent",
+  102: "smartCharging",
+  103: "cableLocked",
+  109: "chargerOpMode",
+  111: "dynamicCircuitCurrentP1",
+  112: "dynamicCircuitCurrentP2",
+  113: "dynamicCircuitCurrentP3",
+  114: "outputCurrent",
+  120: "totalPower",
+  122: "energyPerHour",
+  124: "lifetimeEnergy",
+  132: "wiFiRSSI",
+  182: "inCurrentT2",
+  183: "inCurrentT3",
+  184: "inCurrentT4",
+  185: "inCurrentT5",
+  190: "inVoltageT1T2",
+  191: "inVoltageT1T3",
+  192: "inVoltageT1T4",
+  193: "inVoltageT1T5",
+  194: "inVoltageT2T3",
+  195: "inVoltageT2T4",
+  196: "inVoltageT2T5",
+  197: "inVoltageT3T4",
+  198: "inVoltageT3T5",
+  199: "inVoltageT4T5",
+};
+
+const SUPPLY_VOLTAGE_FIELDS = [
+  "inVoltageT2T3",
+  "inVoltageT1T3",
+  "inVoltageT1T4",
+  "inVoltageT1T5",
+  "inVoltageT2T4",
+  "inVoltageT2T5",
+];
+
+function observationsToChargerState(responseData) {
+  const observations = Array.isArray(responseData?.observations)
+    ? responseData.observations
+    : [];
+  /** @type {Record<string, any>} */
+  const chargerState = Object.fromEntries(
+    Object.values(STATE_FIELDS_BY_OBSERVATION_ID).map((field) => [field, null]),
+  );
+
+  for (const observation of observations) {
+    const field = STATE_FIELDS_BY_OBSERVATION_ID[observation.id];
+    if (field !== undefined) {
+      chargerState[field] = observation.value;
+    }
+  }
+
+  const cloudObservation = observations.find(
+    (observation) => observation.id === 250,
+  );
+  if (cloudObservation) {
+    chargerState.isOnline = Boolean(cloudObservation.value);
+  }
+  chargerState.voltage = null;
+  for (const field of SUPPLY_VOLTAGE_FIELDS) {
+    const value = chargerState[field];
+    if (
+      typeof value === "number" &&
+      Number.isFinite(value) &&
+      value >= 100 &&
+      value <= 300
+    ) {
+      chargerState.voltage = value;
+      break;
+    }
+  }
+
+  return chargerState;
+}
+
+module.exports = { CHARGER_STATE_OBSERVATION_IDS, observationsToChargerState };

package/lib/signalr-http-client.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const axios = require("axios").default;
+const signalR = require("@microsoft/signalr");
+const { CookieJar } = require("tough-cookie");
+
+function hasHeader(headers, name) {
+  return Object.keys(headers).some(
+    (headerName) => headerName.toLowerCase() === name.toLowerCase(),
+  );
+}
+
+class AxiosSignalRHttpClient extends signalR.HttpClient {
+  /** @param {any} [httpClient] */
+  constructor(httpClient = axios) {
+    super();
+    this.httpClient = httpClient;
+    this.cookieJar = new CookieJar();
+  }
+
+  async send(request) {
+    if (!request.url) {
+      throw new Error("SignalR HTTP request URL is missing");
+    }
+    const headers = { ...request.headers };
+    const cookie = this.cookieJar.getCookieStringSync(request.url);
+    if (cookie && !hasHeader(headers, "cookie")) {
+      headers.Cookie = cookie;
+    }
+    const cancelSource = axios.CancelToken.source();
+    const abortHandler = () =>
+      cancelSource.cancel("SignalR HTTP request aborted");
+    if (request.abortSignal) {
+      request.abortSignal.onabort = abortHandler;
+    }
+    try {
+      const response = await this.httpClient.request({
+        method: request.method || "GET",
+        url: request.url,
+        headers,
+        data: request.content,
+        timeout: request.timeout,
+        cancelToken: cancelSource.token,
+        responseType:
+          request.responseType === "arraybuffer" ? "arraybuffer" : "text",
+        transformResponse: [(data) => data],
+        validateStatus: () => true,
+      });
+      for (const setCookie of response.headers?.["set-cookie"] || []) {
+        await this.cookieJar.setCookie(setCookie, request.url, {
+          ignoreError: true,
+        });
+      }
+      let content = response.data;
+      if (Buffer.isBuffer(content) && request.responseType === "arraybuffer") {
+        content = content.buffer.slice(
+          content.byteOffset,
+          content.byteOffset + content.byteLength,
+        );
+      } else if (
+        typeof content !== "string" &&
+        request.responseType !== "arraybuffer"
+      ) {
+        content = content == null ? "" : JSON.stringify(content);
+      }
+      return new signalR.HttpResponse(
+        response.status,
+        response.statusText,
+        content,
+      );
+    } finally {
+      if (request.abortSignal?.onabort === abortHandler) {
+        request.abortSignal.onabort = null;
+      }
+    }
+  }
+
+  getCookieString(url) {
+    return this.cookieJar.getCookieStringSync(url);
+  }
+}
+
+module.exports = AxiosSignalRHttpClient;

package/lib/tools.js

@@ -2,84 +2,96 @@ const axios = require("axios").default;
 
 /**
  * Tests whether the given variable is a real object and not an Array
+ *
  * @param {any} it The variable to test
  * @returns {it is Record<string, any>} True if the variable is an object, false otherwise
  */
 function isObject(it) {
-    return Object.prototype.toString.call(it) === '[object Object]';
+  return Object.prototype.toString.call(it) === "[object Object]";
 }
 
 /**
  * Tests whether the given variable is really an Array
+ *
  * @param {any} it The variable to test
  * @returns {it is any[]} True if the variable is an array, false otherwise
  */
 function isArray(it) {
-    return Array.isArray(it);
+  return Array.isArray(it);
 }
 
 /**
  * Translates text to the target language. Automatically chooses the right translation API.
+ *
  * @param {string} text The text to translate
  * @param {string} targetLang The target language
  * @param {string} [yandexApiKey] The yandex API key. You can create one for free at https://translate.yandex.com/developers
  * @returns {Promise<string>} The translated text
  */
 async function translateText(text, targetLang, yandexApiKey) {
-    if (!text) return '';
-    if (targetLang === 'en') return text;
+  if (!text) {
+    return "";
+  }
+  if (targetLang === "en") {
+    return text;
+  }
 
-    return yandexApiKey
-        ? translateYandex(text, targetLang, yandexApiKey)
-        : translateGoogle(text, targetLang);
+  return yandexApiKey
+    ? translateYandex(text, targetLang, yandexApiKey)
+    : translateGoogle(text, targetLang);
 }
 
 /**
  * Translates text with Yandex API
+ *
  * @param {string} text The text to translate
  * @param {string} targetLang The target language
  * @param {string} apiKey The yandex API key. You can create one for free at https://translate.yandex.com/developers
  * @returns {Promise<string>} The translated text
  */
 async function translateYandex(text, targetLang, apiKey) {
-    if (targetLang === 'zh-cn') targetLang = 'zh';
+  if (targetLang === "zh-cn") {
+    targetLang = "zh";
+  }
 
-    const url = `https://translate.yandex.net/api/v1.5/tr.json/translate?key=${apiKey}&text=${encodeURIComponent(text)}&lang=en-${targetLang}`;
-    try {
-        const response = await axios.get(url, { timeout: 15000 });
-        if (response.data?.text && isArray(response.data.text)) {
-            return response.data.text[0];
-        }
-        throw new Error('Invalid response for translate request');
-    } catch (e) {
-        throw new Error(`Could not translate to "${targetLang}": ${e.message}`);
+  const url = `https://translate.yandex.net/api/v1.5/tr.json/translate?key=${apiKey}&text=${encodeURIComponent(text)}&lang=en-${targetLang}`;
+  try {
+    const response = await axios.get(url, { timeout: 15000 });
+    if (response.data?.text && isArray(response.data.text)) {
+      return response.data.text[0];
     }
+    throw new Error("Invalid response for translate request");
+  } catch (e) {
+    throw new Error(`Could not translate to "${targetLang}": ${e.message}`);
+  }
 }
 
 /**
  * Translates text with Google API
+ *
  * @param {string} text The text to translate
  * @param {string} targetLang The target language
  * @returns {Promise<string>} The translated text
  */
 async function translateGoogle(text, targetLang) {
-    const url = `http://translate.googleapis.com/translate_a/single?client=gtx&sl=en&tl=${targetLang}&dt=t&q=${encodeURIComponent(text)}&ie=UTF-8&oe=UTF-8`;
-    try {
-        const response = await axios.get(url, { timeout: 15000 });
-        if (isArray(response.data)) {
-            return response.data[0][0][0];
-        }
-        throw new Error('Invalid response for translate request');
-    } catch (e) {
-        const errorMessage = e.response?.status === 429
-            ? `Rate-limited by Google Translate`
-            : e.message;
-        throw new Error(`Could not translate to "${targetLang}": ${errorMessage}`);
+  const url = `http://translate.googleapis.com/translate_a/single?client=gtx&sl=en&tl=${targetLang}&dt=t&q=${encodeURIComponent(text)}&ie=UTF-8&oe=UTF-8`;
+  try {
+    const response = await axios.get(url, { timeout: 15000 });
+    if (isArray(response.data)) {
+      return response.data[0][0][0];
     }
+    throw new Error("Invalid response for translate request");
+  } catch (e) {
+    const errorMessage =
+      e.response?.status === 429
+        ? `Rate-limited by Google Translate`
+        : e.message;
+    throw new Error(`Could not translate to "${targetLang}": ${errorMessage}`);
+  }
 }
 
 module.exports = {
-    isArray,
-    isObject,
-    translateText
+  isArray,
+  isObject,
+  translateText,
 };