@cpzxrobot/sdk 1.2.92 → 1.2.94

package/mobile_platform.ts

@@ -0,0 +1,179 @@
+import { PlatformInterface } from "./platform_interface";
+import { Factory, MyAxiosInstance, Unit } from "./types";
+
+export class MobilePlatform implements PlatformInterface {
+  private platform: {
+    callHandler: Function;
+  };
+  private sseCallbacks: { [key: string]: (data: any) => void } = {};
+  token: string = "";
+  appCode: string = "";
+  baseURL: string = "";
+
+  constructor() {
+    // @ts-ignore
+    this.platform = window.flutter_inappwebview;
+
+    window.addEventListener('message', (event) => {
+      if (event.data == 'capturePort') {
+        const port = event.ports[0];
+        if (port != null) {
+          port.onmessage = (event: MessageEvent) => {
+            if (event.data.id != undefined) {
+              const callback = this.sseCallbacks[event.data.id];
+              callback?.(event.data.data);
+            }
+          };
+        }
+      }
+    }, false);
+  }
+  setSelectedFarm(farm: Factory): void {
+    throw new Error("Method not implemented.");
+  }
+  setSelectedUnit(unit: Unit): void {
+    this.platform.callHandler("selectUnit", unit).then((_res:any) => {
+      // @ts-ignore
+      window._notifyUnitChanged?.(unit);
+    })
+  }
+
+
+  ready() {
+    if (
+      // @ts-ignore
+      window.flutter_inappwebview != null &&
+      // @ts-ignore
+      window.flutter_inappwebview.callHandler != null
+    ) {
+      return Promise.resolve(true);
+    } else {
+      return new Promise<boolean>((resolve, reject) => {
+        window.addEventListener(
+          "flutterInAppWebViewPlatformReady",
+          function () {
+            console.log("flutter android/ios platform is ready");
+            resolve(true);
+          }
+        );
+        setTimeout(() => {
+          console.log("flutter android/ios platform is timeout");
+          reject("timeout");
+        }, 1500);
+      });
+    }
+  }
+
+
+  getAxiosFromMiniApp(): MyAxiosInstance {
+    const that = this;
+    return {
+      get: function (url, data) {
+        return that.platform.callHandler("axios_get", url, data);
+      },
+      post: function (url, data) {
+        return that.platform.callHandler("axios_post", url, data);
+      },
+      getAndSave: function (url, config) {
+        return that.platform.callHandler("axios_getAndSave", url, config);
+      },
+      getAndPreview: function (url, config) {
+        if (config == undefined) {
+          config = {};
+        }
+        if (config.preview == undefined) {
+          config.preview = true;
+        }
+        return that.platform.callHandler("axios_getAndSave", url, config);
+      },
+      upload: function (url, option) {
+        return that.platform.callHandler("axios_upload", url, option);
+      },
+      getAsSse: async function (url, fn, config?) {
+        var randomId = Math.random().toString(36).substring(2);
+        that.sseCallbacks[randomId] = fn;
+        console.log("getAsSse", url, fn, randomId);
+        await that.platform.callHandler("axios_getAsSse", url, config, randomId);
+        delete that.sseCallbacks[randomId];
+      },
+    };
+  }
+
+  async getSelectedFarmFromMiniApp(): Promise<any> {
+    return this.platform.callHandler("getSelectedFarmFromMiniApp");
+  }
+
+  async getSelectedUnitFromMiniApp(): Promise<any> {
+    return this.platform.callHandler("getSelectedUnitFromMiniApp");
+  }
+
+  async jumpToMiniApp(url: string): Promise<void> {
+    return this.platform.callHandler("app.openMiniapp", url);
+  }
+
+  async scanQrcode(): Promise<string> {
+    return this.platform.callHandler("app.scanQrcode");
+  }
+
+  setTitle(title: string): void {
+    this.platform.callHandler("app.setTitle", title);
+  }
+
+  async saveBase64(base64: string, filename: string): Promise<void> {
+    return this.platform.callHandler("app.saveBase64", base64, filename);
+  }
+
+  async saveBlob(blob: Blob, filename: string): Promise<void> {
+    const reader = new FileReader();
+    return new Promise<void>((resolve, reject) => {
+      reader.readAsDataURL(blob);
+      reader.onloadend = async () => {
+        const base64 = reader.result as string;
+        await this.saveBase64(base64, filename);
+        resolve();
+      };
+      reader.onerror = (err) => {
+        reject(err);
+      };
+    });
+  }
+
+  vibrate(time?: number): void {
+    this.platform.callHandler("app.vibrate", time);
+  }
+
+  async showInDeviceManager(deviceId: any, type: string): Promise<void> {
+    return this.platform.callHandler("app.showInDeviceManager", deviceId, type);
+  }
+
+  reloadGroup(group: string): void {
+    this.platform.callHandler("app.reloadGroup", group);
+  }
+
+  async getGeo(): Promise<{ lat: number; lng: number }> {
+    const result = await this.platform.callHandler("app.getGeo");
+    if (result.error) {
+      throw result.error;
+    }
+    return {
+      lat: result.lat,
+      lng: result.lng
+    };
+  }
+
+  setResult(name: string, value: any): void {
+    this.platform.callHandler("app.setResult", name, value);
+  }
+
+  setResultAs(name: string, value: any, type: string): void {
+    this.platform.callHandler("app.setResultAs", name, value, type);
+  }
+
+  setError(message: string): void {
+    this.platform.callHandler("app.setError", message);
+  }
+
+  setProgress(precentage: number): void {
+    this.platform.callHandler("app.setProgress", precentage);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cpzxrobot/sdk",
-  "version": "1.2.92",
+  "version": "1.2.94",
   "description": "提供给上海正芯数智APP第三方H5应用使用的SDK",
   "main": "dist/index.js",
   "scripts": {

package/platform_interface.ts

@@ -0,0 +1,35 @@
+import { Factory, MyAxiosInstance, Unit } from "./types";
+
+export abstract class PlatformInterface {
+
+  token: string;
+  appCode: string;
+  baseURL: string;
+
+  //define constructor(token: string, appCode: string) {
+  constructor(token: string, appCode: string, baseURL: string) {
+    this.token = token;
+    this.appCode = appCode;
+    this.baseURL = baseURL;
+  }
+
+  abstract getSelectedFarmFromMiniApp(): Promise<any>;
+  abstract getSelectedUnitFromMiniApp(): Promise<any>;
+  abstract jumpToMiniApp(url: string): Promise<void>;
+  abstract scanQrcode(): Promise<string>;
+  abstract setTitle(title: string): void;
+  abstract saveBase64(base64: string, filename: string): Promise<void>;
+  abstract saveBlob(blob: Blob, filename: string): Promise<void>;
+  abstract vibrate(time?: number): void;
+  abstract showInDeviceManager(deviceId: any, type: string): Promise<void>;
+  abstract reloadGroup(key: string): void;
+  abstract getGeo(): Promise<{ lat: number; lng: number }>;
+  abstract setResult(name: string, value: any): void;
+  abstract setResultAs(name: string, value: any, type: string): void;
+  abstract setError(message: string): void;
+  abstract setProgress(precentage: number): void;
+  abstract getAxiosFromMiniApp(): MyAxiosInstance;
+  abstract ready(): Promise<boolean>;
+  abstract setSelectedUnit(unit: Unit|String|Number): void;
+  abstract setSelectedFarm(farm: Factory|String|Number): void;
+}

package/types.d.ts

@@ -21,6 +21,7 @@ import { EnergyGateway } from "./energy_gateway";
 import { type ElectricMeterRate } from "./energy_types/electric_meter_gateway";
 import { ConstructionGateway } from "./construction_gateway";
 import { SystemGateway } from "./system_gateway";
+import { PlatformInterface } from "./platform_interface";
 
 type Device = {
   id: number;
@@ -360,18 +361,19 @@ class Cpzxrobot {
   construction: ConstructionGateway;
   system: SystemGateway;
   dict: (key: string) => any;
-  _getSelectedFarmFromMiniApp: () => Promise<Factory>;
-  _getSelectedUnitFromMiniApp: () => Promise<Unit>;
+  platform: PlatformInterface;
+  // _getSelectedFarmFromMiniApp: () => Promise<Factory>;
+  // _getSelectedUnitFromMiniApp: () => Promise<Unit>;
   openMiniApp: (url: string) => void;
   on: (event: string, callback: (data: any) => void) => void;
-  setTitle: (title: string) => void;
-  saveBase64: (base64: string, filename: string) => void;
-  saveBlob: (blob: Blob, filename: string) => void;
-  scanQrcode: () => Promise<string>;
-  vibrate: (time?: number) => void;
-  reloadGroup: (key: string) => void;
-  getGeo: () => Promise<{ lat: number; lng: number }>;
-  showInDeviceManager: (deviceId: number, type: string) => Promise<void>;
+  // setTitle: (title: string) => void;
+  // saveBase64: (base64: string, filename: string) => void;
+  // saveBlob: (blob: Blob, filename: string) => void;
+  // scanQrcode: () => Promise<string>;
+  // vibrate: (time?: number) => void;
+  // reloadGroup: (key: string) => void;
+  // getGeo: () => Promise<{ lat: number; lng: number }>;
+  // showInDeviceManager: (deviceId: number, type: string) => Promise<void>;
 }
 
 declare global {

package/user_gateway.ts

@@ -27,7 +27,7 @@ export class UserGateway extends Object {
           resolve(this._selectedFarm);
           break;
         case "miniapp_in_app":
-          this.context._getSelectedFarmFromMiniApp().then((farm: any) => {
+          this.context.platform.getSelectedFarmFromMiniApp().then((farm: any) => {
             this._selectedFarm = farm;
             resolve(farm);
           });
@@ -42,6 +42,15 @@ export class UserGateway extends Object {
     });
   }
 
+  public async selectUnit(unit: Unit|String|Number) {
+    if ((typeof unit === "string") || (typeof unit === "number")) {
+      var axios = await this.context.ready;
+      this.context.platform.setSelectedUnit(unit);
+    } else {
+      this.context.platform.setSelectedUnit(unit);
+    }
+  }
+
   //获得当前用户选择的单元
   getSelectedUnit() {
     return this.context.ready.then(() => {
@@ -51,7 +60,7 @@ export class UserGateway extends Object {
             resolve(this._selectedUnit);
             break;
           case "miniapp_in_app":
-            this.context._getSelectedUnitFromMiniApp().then((unit: any) => {
+            this.context.platform.getSelectedUnitFromMiniApp().then((unit: any) => {
               this._selectedUnit = unit;
               resolve(unit);
             });
@@ -68,38 +77,11 @@ export class UserGateway extends Object {
   }
 
   set selectedFarm(farm: Factory) {
-    switch (this.context.mode) {
-      case "dev":
-        this._selectedFarm = farm;
-        break;
-      case "miniapp_in_app":
-        console.log("miniapp_in_app mode, ignore");
-        break;
-      case "miniapp_in_web":
-        this._selectedFarm = farm;
-        break;
-      default:
-        console.log("dev mode, ignore");
-        break;
-    }
+    this.context.platform.setSelectedFarm(farm);
   }
 
-  set selectedUnit(farm: Unit) {
-    switch (this.context.mode) {
-      case "dev":
-        this._selectedUnit = farm;
-        break;
-      case "miniapp_in_app":
-        console.log("miniapp_in_app mode, ignore");
-        break;
-      case "miniapp_in_web":
-        this._selectedUnit = farm;
-        console.log("miniapp_in_web mode, ignore");
-        break;
-      default:
-        console.log("dev mode, ignore");
-        break;
-    }
+  set selectedUnit(unit: Unit) {
+    this.context.platform.setSelectedUnit(unit);
   }
 
   async add(user: any) {

package/web_platform.ts

@@ -0,0 +1,322 @@
+import { PlatformInterface } from "./platform_interface";
+import { Factory, MyAxiosInstance, Unit } from "./types";
+
+export class WebPlatform implements PlatformInterface {
+  token: string = "";
+  appCode: string = "";
+  baseURL: string = "";
+  _selectedFarm: Factory | undefined;
+  _selectedUnit: Unit | undefined;
+
+  constructor(token: string, appCode: string, baseURL: string, selectedFarm: Factory | undefined, selectedUnit: Unit | undefined) {
+    this.token = token;
+    this.appCode = appCode;
+    this.baseURL = baseURL;
+    this._selectedFarm = selectedFarm;
+    this._selectedUnit = selectedUnit;
+  }
+  setSelectedFarm(farm: Factory): void {
+    this._selectedFarm = farm;
+  }
+  setSelectedUnit(unit: Unit): void {
+    this._selectedUnit = unit;
+  }
+
+  async fetchWithAuth(input: RequestInfo, init?: RequestInit) {
+    const headers = new Headers(init?.headers);
+    headers.set('Authorization', this.token);
+    headers.set('Miniapp-Code', this.appCode);
+    const response = await fetch(this.baseURL + input.toString(), {
+      ...init,
+      headers
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return response;
+  };
+
+  async streamWithAuth(input: RequestInfo, init?: RequestInit, fn?: Function) {
+    const headers = new Headers(init?.headers);
+    headers.set('Authorization', this.token);
+    headers.set('Miniapp-Code', this.appCode);
+    const response = await fetch(this.baseURL + input.toString(), {
+      ...init,
+      headers
+    });
+
+    var reader = response.body!.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let done = false;
+    var buf: string = "";
+    while (!done) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      const chunkValue = decoder.decode(value);
+
+      //split value to lines
+      // 将值拆分为行
+      buf = buf + chunkValue;
+      var i = buf.indexOf("\n");
+      while (i > -1) {
+        //find first \n
+        var line = buf.substring(0, i);
+        try {
+          if (line === "[DONE]") {
+            break;
+          } else {
+            // remove prefix 'data: '
+            // 移除前缀 'data: '
+            var data = JSON.parse(line.split(": ")[1]);
+            //{"choices":[{"delta":{"content":" </"},"index":0}],"created":1741749068,"id":"chatcmpl-67ccb889154043f5874cbf3a64ec163e","model":"DeepSeek-R1","object":"chat.completion.chunk"}
+            fn?.call(data);
+          }
+        } catch (e) {
+          console.error("解析失败", e);
+        }
+        buf = buf.substring(i + 1);
+        i = buf.indexOf("\n");
+      }
+    };
+    return true;
+  };
+
+  processQueryParams(url: string, config?: any) {
+    if (config && config.params) {
+      const flattenParams = (params: any, prefix = '') => {
+        const result: Record<string, string> = {};
+        Object.keys(params).forEach(key => {
+          const value = params[key];
+          const fullKey = prefix ? `${prefix}[${key}]` : key;
+          if (value && typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(result, flattenParams(value, fullKey));
+          } else if (value) {
+            result[fullKey] = value.toString();
+          }
+        });
+        return result;
+      };
+      const flattened = flattenParams(config.params);
+      url += "?" + new URLSearchParams(flattened).toString();
+      delete config.params;
+    }
+    return url;
+  }
+
+  getAxiosFromMiniApp(): MyAxiosInstance {
+    var instance = this;
+    return {
+      get: async (url: string, config?: any) => {
+        url = instance.processQueryParams(url, config);
+        const response = await this.fetchWithAuth(url, {
+          method: 'GET',
+          headers: config?.headers
+        });
+        return { data: await response.json() };
+      },
+      post: async (url: string, data?: any, config?: any) => {
+        const response = await this.fetchWithAuth(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            ...config?.headers
+          },
+          body: JSON.stringify(data)
+        });
+        return { data: await response.json() };
+      },
+      getAndSave: async function(url: string, config?: any) {
+        url = instance.processQueryParams(url, config);
+        const response = await instance.fetchWithAuth(url, {
+          method: 'GET',
+          headers: config?.headers
+        });
+        const blob = await response.blob();
+
+        // 文件名解析逻辑
+        const contentDisposition = response.headers.get('Content-Disposition');
+        let filename = config?.fileName ?? ""; // 默认文件名
+
+        // 1. 优先使用响应头中的文件名
+        if (filename == "") {
+          if (contentDisposition) {
+            const utf8FilenameMatch = contentDisposition.match(/filename\*=UTF-8''(.+)/i);
+            if (utf8FilenameMatch) {
+              filename = decodeURIComponent(utf8FilenameMatch[1]);
+            } else {
+              const filenameMatch = contentDisposition.match(/filename="?(.+?)"?(;|$)/i);
+              if (filenameMatch) filename = filenameMatch[1];
+            }
+          } else {
+            filename = "file"
+          }
+        }
+        await instance.saveBlob(blob, filename);
+        return { data: blob };
+      },
+      getAndPreview: async function(url: string, config?: {
+        fileName?: string;
+        params?: any;
+        preview?: boolean;
+      }){
+        url = instance.processQueryParams(url, config);
+        return this.getAndSave(url, config);
+      },
+      upload: async (url: string, option?: any) => {
+        return new Promise<any>((resolve, reject) => {
+          const button = document.createElement("input");
+          button.type = "file";
+          button.style.display = "none";
+          button.multiple = option?.multiple || false;
+          document.body.appendChild(button);
+          button.click(); // 手动触发点击
+          button.onchange = async (e: Event) => {
+            const files = (e.target as HTMLInputElement).files;
+            if (files && files.length > 0) {
+              const formData = new FormData();
+              if (option?.multiple) {
+                for (let i = 0; i < files.length; i++) {
+                  formData.append("files[]", files[i]);
+                }
+              } else {
+                formData.append(option?.["fileField"] || "file", files[0]);
+              }
+              for (let key in option?.["data"]) {
+                formData.append(key, option!["data"][key]);
+              }
+              const response = await instance.fetchWithAuth(url, {
+                method: 'POST',
+                body: formData
+              });
+              button.remove();
+              resolve({ data: await response.json() });
+            } else {
+              button.remove();
+              resolve({ data: { Error: "没有选择文件" } });
+            }
+          };
+        });
+      },
+      getAsSse: (url: string, fn: any, config?: {
+        fileName?: string;
+        params?: any;
+        preview?: boolean;
+      }) => {
+        return new Promise<any>((resolve, reject) => {
+          instance.streamWithAuth(url, {
+            method: 'GET',
+          }, fn);
+        });
+      }
+    };
+  }
+  ready(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+  getSelectedFarmFromMiniApp(): Promise<any> {
+    return Promise.resolve(this._selectedFarm);
+  }
+
+  getSelectedUnitFromMiniApp(): Promise<any> {
+    return Promise.resolve(this._selectedUnit);
+  }
+
+  jumpToMiniApp(url: string): Promise<void> {
+    window.location.href = url;
+    return Promise.resolve();
+  }
+
+  scanQrcode(): Promise<string> {
+    throw new Error("Method not available in web platform");
+  }
+
+  setTitle(title: string): void {
+    document.title = title;
+  }
+
+  async saveBase64(base64: string, filename: string): Promise<void> {
+    const byteCharacters = atob(base64);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+      byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], {
+      type: "application/octet-stream",
+    });
+    return this.saveBlob(blob, filename);
+  }
+
+  saveBlob(blob: Blob, filename: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        setTimeout(() => {
+          URL.revokeObjectURL(url);
+          document.body.removeChild(a);
+          resolve();
+        }, 0);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  vibrate(time?: number): void {
+    if (navigator.vibrate) {
+      navigator.vibrate(time || 200);
+    }
+  }
+
+  showInDeviceManager(deviceId: any, type: string): Promise<void> {
+    return Promise.resolve();
+  }
+
+  reloadGroup(key: string): void {
+    // No implementation in web platform
+  }
+
+  getGeo(): Promise<{ lat: number; lng: number }> {
+    return new Promise((resolve, reject) => {
+      if (navigator.geolocation) {
+        navigator.geolocation.getCurrentPosition(
+          (position) => {
+            resolve({
+              lat: position.coords.latitude,
+              lng: position.coords.longitude
+            });
+          },
+          (error) => {
+            reject(error);
+          }
+        );
+      } else {
+        reject(new Error("浏览器不支持获取位置信息"));
+      }
+    });
+  }
+
+  setResult(name: string, value: any): void {
+    // No implementation in web platform
+  }
+
+  setResultAs(name: string, value: any, type: string): void {
+    // No implementation in web platform
+  }
+
+  setError(message: string): void {
+    console.error(message);
+  }
+
+  setProgress(precentage: number): void {
+    // No implementation in web platform
+  }
+}