@cpzxrobot/sdk 1.0.0

package/assistant_gateway.ts

@@ -0,0 +1,19 @@
+//消息助手网关，获取消息助手的信息
+export class AssistantGateway extends Object {
+  context: Shzx
+  constructor(context: Shzx) {
+    super()
+    this.context = context
+  }
+
+  getByLoginUser() {
+    return this.context.ready.then((axios) => {
+      return axios.get('/api/v1/robot/wx').then((res) => {
+        if (res.data.Error) {
+          throw res.data.Error
+        }
+        return res.data
+      })
+    })
+  }
+}

package/camera_gateway.ts

@@ -0,0 +1,28 @@
+export class CameraGateway extends Object {
+  context: Shzx
+  constructor(context: Shzx) {
+    super()
+    this.context = context
+  }
+  //搜索摄像头
+  async search(data: Unit): Promise<any> {
+    await this.context.ready
+    const response = await this.context.axios.post('/api/v1/camera/search', {
+      unit_id: data.id
+    })
+    return response.data
+  }
+
+  //获得摄像头的播放地址
+  async getUrl(data: Camera): Promise<any> {
+    await this.context.ready
+    const response = await this.context.axios.get(`/api/v1/camera/${data.id}/url/wss`)
+    return response.data
+  }
+  //获取工厂天气
+  async weather(id: number): Promise<any> {
+    await this.context.ready
+    const response = await this.context.axios.get(`/api/v1/weather?code=${id}`)
+    return response.data
+  }
+}

package/device_filter.ts

@@ -0,0 +1,318 @@
+import type { AxiosResponse } from "axios";
+
+export interface DataQueryArgs {
+  start?: string;
+  stop?: string;
+  type?:
+    | "diffPerDay"
+    | "sumPerDay"
+    | "latest"
+    | "latestInRangePerDay"
+    | "last"
+    | "difference";
+  period?: "1mo" | "1d" | null;
+  [key: string]: any;
+}
+
+export abstract class deviceFilter<T extends { id: number }> {
+  context: Shzx;
+  protected devices: T[] = [];
+
+  // private getDetail!: (info: T, id: number, context: Shzx) => Promise<any> | null
+  // axios: MyAxiosInstance;
+  // user: UserGateway;
+  // ready: Promise<boolean>;
+
+  constructor(context: Shzx) {
+    this.context = context;
+  }
+
+  abstract get deviceType(): string | null;
+
+  //如果子类有更多其他属性需要附加到属性列表中，需要实现该方法
+  getDetail(info: T, _id: number): Promise<any> {
+    return Promise.resolve(info);
+  }
+
+  //如果子类需要对返回的数据进行包装，需要实现该方法
+  wrapData(_id: number, _args: DataQueryArgs, p: Promise<any>): Promise<any> {
+    return p;
+  }
+
+  wrapList(list: T[]): Promise<T[]> {
+    return Promise.resolve(list);
+  }
+
+  getInfo(id: number): Promise<T> {
+    if (this.devices) {
+      const one = this.devices.find((device) => device.id == id);
+      if (one) {
+        return Promise.resolve(one);
+      }
+    }
+    return this.context.axios
+      .get(`/api/v1/device/${id}/detail?latest=true`)
+      .then((res) => {
+        if (res.data.Error) {
+          throw res.data.Error;
+        }
+        return res.data;
+      });
+  }
+
+  //获得单个设备的详细信息和状态，包括设备的基本信息和跟业务类型相关的附加状态信息
+  //不应单独使用getInfo和getDetail，应使用getStatus
+  getStatus(id: number) {
+    return this.context.ready
+      .then(() => this.getInfo(id))
+      .then((info) => {
+        return this.getDetail(info, id);
+      });
+  }
+
+  // 标记设备状态，部分类型的设备支持标记状态，比如喂料塔可以标记为零点已校准
+  markStatus(id: number, name: string) {
+    let action: string;
+    switch (name) {
+      case "zero-calibrated": // 标记为零点已校准状态
+        action = "/updateZeroTime";
+        break;
+      default:
+        throw new Error("Method not implemented.");
+    }
+    return this.context.ready.then(() =>
+      this.context.axios
+        .post("/api/v1/pigfarm/device/status" + action + "?id=" + id)
+        .then((res) => {
+          if (res.data.code != 200) {
+            throw res.data.message;
+          }
+          return res.data;
+        })
+    );
+  }
+
+  update(deviceId: number, cycle?: number, towerVolume?: number) {
+    return this.context.ready.then(() => {
+      this.context.axios
+        .post("/api/v1/pigfarm/device/status/update", {
+          deviceId,
+          cycle,
+          towerVolume,
+        })
+        .then((res) => {
+          if (res.data.code != 200) {
+            throw res.data.message;
+          }
+          return res.data;
+        });
+    });
+  }
+
+  getData(
+    id: number,
+    args: DataQueryArgs = {
+      start: "",
+      stop: "",
+      type: "diffPerDay", // diffPerDay, sumPerDay, latest
+    }
+  ) {
+    if (args.stop == "") {
+      args.stop = this.formateDateToYYYYMMDD(new Date());
+    }
+    if (args.start == "") {
+      const sevenDaysAgo = new Date();
+      sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+      args.start = this.formateDateToYYYYMMDD(sevenDaysAgo);
+    }
+
+    return this.context.ready
+      .then(() => {
+        const p1 = this.context.axios.get(
+          `/api/v1/device/${id}/data/${args.type}`,
+          {
+            params: args,
+          }
+        );
+
+        return this.wrapData(id, args, p1);
+      })
+      .then((res: AxiosResponse) => {
+        if (res.data.Error) {
+          throw res.data.Error;
+        }
+        // this.devices.push(res.data);
+        return res.data;
+      });
+  }
+
+  //按月获取数据：period = '1mo'，按天获取数据：period = '1d'
+  //获取数据类型：latestInRangePerDay（按周期获得每天的数据,只用于峰谷平）
+  // 不再使用：diffPerDay（每天差值），sumPerDay（每日汇总），last(每个周期最新)
+  // difference(每个周期差值,根据period的不同，差值的计算方式不同
+  getHistoryDatas(
+    ids: number[],
+    args: DataQueryArgs = {
+      start: "",
+      stop: "",
+      period: null,
+      type: "latestInRangePerDay",
+    }
+  ) {
+    // 对period = '1mo'的情况, 进行特殊优化
+    if (args.period == "1mo") {
+      //按start获得每个月
+      let d;
+      if (args.start && args.start![0] == "-") {
+        //args.start like '-1y'
+        const matcher = args.start.match(/-(\d+)(\w+)/);
+        if (matcher) {
+          d = new Date();
+          const num = parseInt(matcher[1]);
+          const unit = matcher[2];
+          if (unit == "y") {
+            d.setFullYear(d.getFullYear() - num);
+          } else if (unit == "m") {
+            d.setMonth(d.getMonth() - num);
+          } else if (unit == "d") {
+            d.setDate(d.getDate() - num);
+          }
+        }
+      } else {
+        //args.start is a date string
+        d = new Date(args.start!);
+      }
+      //获取从d开始，到现在的每个月的数据
+      const now = new Date();
+      const months: string[] = [];
+      while (d! < now) {
+        months.push(this.formateDateToYYYYMM(d!));
+        d!.setMonth(d!.getMonth() + 1);
+      }
+      return this.context.ready.then((axios) => {
+        const allPs = ids.map((id) => {
+          const promises = months.map((month) => {
+            return axios
+              .get(`/api/v1/device/history/monthly/${month}/${args.type}/${id}`)
+              .then((res) => {
+                return {
+                  month: month,
+                  id: id,
+                  data: res.data,
+                };
+              });
+          });
+          return Promise.all(promises).then((res) => {
+            return res.reduce((acc, cur) => {
+              const singleIds = acc[cur.id] || {};
+              const values = Object.values(cur.data);
+              if (values.length > 0) {
+                singleIds[cur.month] = values[0];
+              }
+              acc[cur.id] = singleIds;
+              return acc;
+            }, {} as any);
+          });
+        }, {} as any);
+        return Promise.all(allPs).then((res) => {
+          const data = res.reduce((acc, cur) => {
+            return {
+              ...acc,
+              ...cur,
+            };
+          }, {} as any);
+          return {
+            data,
+          };
+        });
+      });
+    }
+
+    return this.context.ready.then((axios) => {
+      return axios.post("/api/v1/device/history", {
+        device_ids: ids,
+        ...args,
+      });
+    });
+  }
+
+  formateDateToYYYYMMDD(time: Date) {
+    const year = time.getFullYear();
+    const month = time.getMonth() + 1; // getMonth() 返回的月份从0开始
+    const date = time.getDate();
+
+    // 使用 `padStart` 方法来确保月份和日期总是两位数
+    return `${year}-${String(month).padStart(2, "0")}-${String(date).padStart(
+      2,
+      "0"
+    )}`;
+  }
+
+  formateDateToYYYYMM(time: Date) {
+    const year = time.getFullYear();
+    const month = time.getMonth() + 1; // getMonth() 返回的月份从0开始
+    // const date = time.getDate()
+
+    // 使用 `padStart` 方法来确保月份和日期总是两位数
+    return `${year}-${String(month).padStart(2, "0")}`;
+  }
+
+  //获取设备列表，如果options.id为空，则获取用户选中工厂的设备列表，否则获取指定id的工厂的设备
+  //last:获取最新数据
+  // rangeToday:获取今天的第一个数据和最后一个数据
+  list(
+    options:
+      | undefined
+      | {
+          id?: Number | null | undefined;
+          data?:
+            | "diffPerDay"
+            | "sumPerDay"
+            | "latest"
+            | "weekoverweek"
+            | "last"
+            | "rangeToday"
+            | null; //如果data为null，则不获取数据，只获取设备列表，否则获取设备列表和数据
+          status?: string;
+          unit?: Number;
+        } = undefined
+  ): Promise<T[]> {
+    // if (this.devices.length > 0) {
+    //   return Promise.resolve(this.devices)
+    // } else {
+    let p;
+    if (options?.id) {
+      p = Promise.resolve({ id: options.id });
+    } else {
+      p = this.context.ready.then(() => {
+        return this.context.user.getSelectedFarm();
+      });
+    }
+    const rand = Math.random();
+    const type = this.deviceType;
+    return p
+      .then((farm) => {
+        console.log("type", type);
+        return this.context.axios.get("/api/v1/device/list?rand=" + rand, {
+          params: {
+            location: farm,
+            type: this.deviceType,
+            unit: options?.unit,
+            data: options?.data,
+            status: options?.status,
+          },
+        });
+      })
+      .then((res) => {
+        if (res.data.Error) {
+          throw res.data.Error;
+        } else {
+          if (options == undefined || options.id == undefined) {
+            //当id为空时（获取用户选中工厂的设备），将所有设备保存到devices中
+            this.devices = res.data;
+          }
+          return res.data;
+        }
+      });
+  }
+}

package/device_gateway.ts

@@ -0,0 +1,74 @@
+import { DeviceTypeGateway } from "./device_type_gateway";
+import { deviceFilter } from "./device_filter";
+import type { FeedTower, ElectricMeter } from ".";
+import { FeedTowerGateway } from "./device_types/feedtower";
+import { ElectricMeterGateway } from "./device_types/electricmeter";
+import { NormalGateway } from "./device_types/normal_type";
+
+//获得设备数据的网关，所有设备类型的数据都通过这个网关获取, 常见的设备直接通过属性访问，特殊的设备通过子属性访问
+//例如
+// shzx.device.feedTower: 料塔设备的数据获取网关
+// shzx.device.electricMeter：电表设备的数据获取网关
+export class DeviceGateway extends Object {
+  // private devices: Device[]
+  public type: DeviceTypeGateway;
+  filters: Map<string, deviceFilter<any>>;
+  normalFilter: NormalGateway;
+  context: Shzx;
+
+  constructor(context: Shzx) {
+    super();
+    this.context = context;
+    // this.devices = []
+    this.type = new DeviceTypeGateway(context);
+    this.normalFilter = new NormalGateway(context);
+    this.filters = new Map();
+  }
+
+  //料塔设备的数据获取网关
+  get feedTower(): deviceFilter<FeedTower> {
+    return this.getFilter("FeedTower", FeedTowerGateway);
+  }
+
+  //电表设备的数据获取网关
+  get electricMeter(): deviceFilter<ElectricMeter> {
+    return this.getFilter("ElectricMeter", ElectricMeterGateway);
+  }
+
+  private getFilter<T extends { id: number }>(
+    type: string,
+    cls: new (context: Shzx) => deviceFilter<T>
+  ): deviceFilter<T> {
+    if (this.filters.has(type)) {
+      return this.filters.get(type) as deviceFilter<T>;
+    }
+    const filter = new cls(this.context);
+    this.filters.set(type, filter);
+    return filter;
+  }
+
+  // addDevice(device: Device) {
+  //   this.devices.push(device)
+  // }
+
+  // removeDevice(device: Device) {
+  //   const index = this.devices.indexOf(device)
+  //   if (index !== -1) {
+  //     this.devices.splice(index, 1)
+  //   }
+  // }
+
+  // getDevices() {
+  //   return this.devices
+  // }
+
+  //获取设备列表，注意特殊类型，比如electricMeter和feedTower，需要通过属性访问
+  get list() {
+    return this.normalFilter.list;
+  }
+
+  get getHistoryDatas() {
+    return this.normalFilter.getHistoryDatas;
+  }
+  
+}

package/device_type_gateway.ts

@@ -0,0 +1,27 @@
+//缓存设备类型数据
+export class DeviceTypeGateway {
+  deviceTypes: any
+  // axios: MyAxiosInstance;
+  context: Shzx
+
+  constructor(context: Shzx) {
+    this.context = context
+  }
+
+  list(): Promise<[]> {
+    if (this.deviceTypes) {
+      return Promise.resolve(this.deviceTypes)
+    }
+    return this.context.axios.get('/api/device_type/list')
+  }
+
+  alarmConfigForUnit(unit: Unit): Promise<any> {
+    return this.context.ready.then((axios) => {
+      return axios.get(`/api/v1/device/type/alarm`, {
+        params: {
+          unit_type: unit.type
+        }
+      })
+    });
+  }
+}

package/device_types/electricmeter.ts

@@ -0,0 +1,22 @@
+import { type ElectricMeter } from "..";
+import { deviceFilter } from "../device_filter";
+
+export class ElectricMeterGateway extends deviceFilter<ElectricMeter> {
+  // Add properties and methods specific to the FeedTower type here
+
+  get deviceType() {
+    return "Electric";
+  }
+
+  //获取能耗关系
+  getEnergyRelation() {
+    return this.context.ready.then(() => {
+      return this.context.axios.get("/api/v1/energy/flow ").then((res) => {
+        if (res.data.code != 200) {
+          throw res.data.message;
+        }
+        return res.data;
+      });
+    });
+  }
+}

package/device_types/feedtower.ts

@@ -0,0 +1,92 @@
+import { type FeedTower } from '..'
+import { deviceFilter, type DataQueryArgs } from '../device_filter'
+
+export class FeedTowerGateway extends deviceFilter<FeedTower> {
+  // Add properties and methods specific to the FeedTower type here
+
+  get deviceType() {
+    return 'FeedTower'
+  }
+
+  getDetail(info: FeedTower, id: number) {
+    return this.context.axios
+      .post('/api/v1/pigfarm/device/status/detail?deviceId=' + id)
+      .then((res: any) => {
+        if (res.data.code != 200) {
+          throw res.data.message
+        }
+        res.data.data.unit = info.unit
+        return res.data.data
+      })
+  }
+
+  wrapData(id: number, args: DataQueryArgs, p1: Promise<any>) {
+    const ps = [p1]
+    if (!args.ingoreInput) {
+      ps.push(
+        this.context.axios.post(`/api/v1/pigfarm/device/fodder`, {
+          device: id,
+          times: [args.start, args.stop]
+        })
+      )
+    }
+
+    return Promise.all(ps).then((res) => {
+      if (res[0].data.Error) {
+        throw res[0].data.Error
+      } else {
+        if (!args.ingoreInput) {
+          res[1].data.data.list.forEach((item: any) => {
+            res[0].data[item.date] += item.data
+          })
+        }
+        return res[0].data
+      }
+    })
+  }
+
+  wrapList(list: FeedTower[]): Promise<FeedTower[]> {
+    const ids = this.devices.map((device) => device.id)
+    //TODO 其他设备的详情需要支持，目前只有喂料塔
+    return this.context.axios
+      .post('/api/v1/pigfarm/device/status/list', ids)
+      .then((res) => {
+        if (res.data.code != 200) {
+          throw res.data.message
+        } else {
+          res.data.data.forEach((device: FeedTowerExtraInfo) => {
+            const found = list.find((d) => d.id === device.id)
+            if (found) {
+              Object.assign(found, device)
+            }
+          })
+          return list
+        }
+      })
+  }
+
+
+  async enter(data: FodderAdd): Promise<any> {
+    const res = await this.context.axios.post('/api/v1/pigfarm/device/fodder/import', data)
+    return res
+  }
+  async getCar(truck: string): Promise<any> {
+    const res = await this.context.axios.get('/api/v1/pigfarm/car', {
+      params: {
+        truckCode: truck,
+        random: 1
+      }
+    })
+    return res.data
+  }
+  async getCarList(): Promise<any> {
+    const res = await this.context.axios.get('/api/v1/pigfarm/car/list')
+    return res.data
+  }
+  async updateZeroTime(id: Number): Promise<any> {
+    const res = await this.context.axios.post(
+      '/api/v1/pigfarm/device/status/updateZeroTime' + '?id=' + id
+    )
+    return res
+  }
+}

package/device_types/normal_type.ts

@@ -0,0 +1,8 @@
+import { deviceFilter } from "../device_filter";
+
+//适配常见设备类型
+export class NormalGateway extends deviceFilter<Device> {
+  get deviceType() {
+    return null;
+  }
+}

package/device_types/readme.md

@@ -0,0 +1,3 @@
+# 分类型的设备获取类
+
+## 最简易模型参考[这里](./normal.ts)

package/dist/assistant_gateway.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssistantGateway = void 0;
+//消息助手网关，获取消息助手的信息
+class AssistantGateway extends Object {
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    getByLoginUser() {
+        return this.context.ready.then((axios) => {
+            return axios.get('/api/v1/robot/wx').then((res) => {
+                if (res.data.Error) {
+                    throw res.data.Error;
+                }
+                return res.data;
+            });
+        });
+    }
+}
+exports.AssistantGateway = AssistantGateway;

package/dist/camera_gateway.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraGateway = void 0;
+class CameraGateway extends Object {
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    //搜索摄像头
+    async search(data) {
+        await this.context.ready;
+        const response = await this.context.axios.post('/api/v1/camera/search', {
+            unit_id: data.id
+        });
+        return response.data;
+    }
+    //获得摄像头的播放地址
+    async getUrl(data) {
+        await this.context.ready;
+        const response = await this.context.axios.get(`/api/v1/camera/${data.id}/url/wss`);
+        return response.data;
+    }
+    //获取工厂天气
+    async weather(id) {
+        await this.context.ready;
+        const response = await this.context.axios.get(`/api/v1/weather?code=${id}`);
+        return response.data;
+    }
+}
+exports.CameraGateway = CameraGateway;