@cpzxrobot/sdk 1.0.0

package/dist/device_filter.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceFilter = void 0;
+class deviceFilter {
+    // private getDetail!: (info: T, id: number, context: Shzx) => Promise<any> | null
+    // axios: MyAxiosInstance;
+    // user: UserGateway;
+    // ready: Promise<boolean>;
+    constructor(context) {
+        this.devices = [];
+        this.context = context;
+    }
+    //如果子类有更多其他属性需要附加到属性列表中，需要实现该方法
+    getDetail(info, _id) {
+        return Promise.resolve(info);
+    }
+    //如果子类需要对返回的数据进行包装，需要实现该方法
+    wrapData(_id, _args, p) {
+        return p;
+    }
+    wrapList(list) {
+        return Promise.resolve(list);
+    }
+    getInfo(id) {
+        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) {
+        return this.context.ready
+            .then(() => this.getInfo(id))
+            .then((info) => {
+            return this.getDetail(info, id);
+        });
+    }
+    // 标记设备状态，部分类型的设备支持标记状态，比如喂料塔可以标记为零点已校准
+    markStatus(id, name) {
+        let action;
+        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, cycle, towerVolume) {
+        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, args = {
+        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) => {
+            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, args = {
+        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 = [];
+            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;
+                        }, {});
+                    });
+                }, {});
+                return Promise.all(allPs).then((res) => {
+                    const data = res.reduce((acc, cur) => {
+                        return Object.assign(Object.assign({}, acc), cur);
+                    }, {});
+                    return {
+                        data,
+                    };
+                });
+            });
+        }
+        return this.context.ready.then((axios) => {
+            return axios.post("/api/v1/device/history", Object.assign({ device_ids: ids }, args));
+        });
+    }
+    formateDateToYYYYMMDD(time) {
+        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) {
+        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) {
+        // if (this.devices.length > 0) {
+        //   return Promise.resolve(this.devices)
+        // } else {
+        let p;
+        if (options === null || options === void 0 ? void 0 : 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 === null || options === void 0 ? void 0 : options.unit,
+                    data: options === null || options === void 0 ? void 0 : options.data,
+                    status: options === null || options === void 0 ? void 0 : 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;
+            }
+        });
+    }
+}
+exports.deviceFilter = deviceFilter;

package/dist/device_gateway.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceGateway = void 0;
+const device_type_gateway_1 = require("./device_type_gateway");
+const feedtower_1 = require("./device_types/feedtower");
+const electricmeter_1 = require("./device_types/electricmeter");
+const normal_type_1 = require("./device_types/normal_type");
+//获得设备数据的网关，所有设备类型的数据都通过这个网关获取, 常见的设备直接通过属性访问，特殊的设备通过子属性访问
+//例如
+// shzx.device.feedTower: 料塔设备的数据获取网关
+// shzx.device.electricMeter：电表设备的数据获取网关
+class DeviceGateway extends Object {
+    constructor(context) {
+        super();
+        this.context = context;
+        // this.devices = []
+        this.type = new device_type_gateway_1.DeviceTypeGateway(context);
+        this.normalFilter = new normal_type_1.NormalGateway(context);
+        this.filters = new Map();
+    }
+    //料塔设备的数据获取网关
+    get feedTower() {
+        return this.getFilter("FeedTower", feedtower_1.FeedTowerGateway);
+    }
+    //电表设备的数据获取网关
+    get electricMeter() {
+        return this.getFilter("ElectricMeter", electricmeter_1.ElectricMeterGateway);
+    }
+    getFilter(type, cls) {
+        if (this.filters.has(type)) {
+            return this.filters.get(type);
+        }
+        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;
+    }
+}
+exports.DeviceGateway = DeviceGateway;

package/dist/device_type_gateway.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceTypeGateway = void 0;
+//缓存设备类型数据
+class DeviceTypeGateway {
+    constructor(context) {
+        this.context = context;
+    }
+    list() {
+        if (this.deviceTypes) {
+            return Promise.resolve(this.deviceTypes);
+        }
+        return this.context.axios.get('/api/device_type/list');
+    }
+    alarmConfigForUnit(unit) {
+        return this.context.ready.then((axios) => {
+            return axios.get(`/api/v1/device/type/alarm`, {
+                params: {
+                    unit_type: unit.type
+                }
+            });
+        });
+    }
+}
+exports.DeviceTypeGateway = DeviceTypeGateway;

package/dist/device_types/electricmeter.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElectricMeterGateway = void 0;
+const device_filter_1 = require("../device_filter");
+class ElectricMeterGateway extends device_filter_1.deviceFilter {
+    // 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;
+            });
+        });
+    }
+}
+exports.ElectricMeterGateway = ElectricMeterGateway;

package/dist/device_types/feedtower.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedTowerGateway = void 0;
+const device_filter_1 = require("../device_filter");
+class FeedTowerGateway extends device_filter_1.deviceFilter {
+    // Add properties and methods specific to the FeedTower type here
+    get deviceType() {
+        return 'FeedTower';
+    }
+    getDetail(info, id) {
+        return this.context.axios
+            .post('/api/v1/pigfarm/device/status/detail?deviceId=' + id)
+            .then((res) => {
+            if (res.data.code != 200) {
+                throw res.data.message;
+            }
+            res.data.data.unit = info.unit;
+            return res.data.data;
+        });
+    }
+    wrapData(id, args, p1) {
+        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) => {
+                        res[0].data[item.date] += item.data;
+                    });
+                }
+                return res[0].data;
+            }
+        });
+    }
+    wrapList(list) {
+        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) => {
+                    const found = list.find((d) => d.id === device.id);
+                    if (found) {
+                        Object.assign(found, device);
+                    }
+                });
+                return list;
+            }
+        });
+    }
+    async enter(data) {
+        const res = await this.context.axios.post('/api/v1/pigfarm/device/fodder/import', data);
+        return res;
+    }
+    async getCar(truck) {
+        const res = await this.context.axios.get('/api/v1/pigfarm/car', {
+            params: {
+                truckCode: truck,
+                random: 1
+            }
+        });
+        return res.data;
+    }
+    async getCarList() {
+        const res = await this.context.axios.get('/api/v1/pigfarm/car/list');
+        return res.data;
+    }
+    async updateZeroTime(id) {
+        const res = await this.context.axios.post('/api/v1/pigfarm/device/status/updateZeroTime' + '?id=' + id);
+        return res;
+    }
+}
+exports.FeedTowerGateway = FeedTowerGateway;

package/dist/device_types/normal_type.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalGateway = void 0;
+const device_filter_1 = require("../device_filter");
+//适配常见设备类型
+class NormalGateway extends device_filter_1.deviceFilter {
+    get deviceType() {
+        return null;
+    }
+}
+exports.NormalGateway = NormalGateway;

package/dist/energy_gateway.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnergyGateway = void 0;
+const electric_meter_gateway_1 = require("./energy_types/electric_meter_gateway");
+//消息助手网关，获取消息助手的信息
+class EnergyGateway extends Object {
+    constructor(context) {
+        super();
+        this._electric = null;
+        this.context = context;
+    }
+    get electricMeter() {
+        if (this._electric) {
+            return this._electric;
+        }
+        return new electric_meter_gateway_1.ElectricMeterGateway(this.context);
+    }
+}
+exports.EnergyGateway = EnergyGateway;

package/dist/energy_types/electric_meter_gateway.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElectricMeterGateway = void 0;
+const __1 = __importDefault(require(".."));
+//消息助手网关，获取消息助手的信息
+class ElectricMeterGateway extends Object {
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    //返回峰谷平电表的阶梯区间
+    getRates() {
+        return (0, __1.default)().ready.then((axios) => {
+            return axios.get('/api/v1/energy/electricRange').then((res) => {
+                if (res.data.code !== 200) {
+                    throw res.data.message;
+                }
+                const list = res.data.data;
+                list.forEach((item) => {
+                    item.endMin || (item.endMin = 0);
+                    item.startMin || (item.startMin = 0);
+                });
+                return list;
+            });
+        });
+    }
+}
+exports.ElectricMeterGateway = ElectricMeterGateway;

package/dist/factory_gateway.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FactoryGateway = void 0;
+class FactoryGateway extends Object {
+    constructor(context) {
+        super();
+        this._selectedFarm = {
+            code: '',
+            name: '',
+            company_code: '',
+            id: 0
+        };
+        this.context = context;
+    }
+    async search(data) {
+        await this.context.ready;
+        const response = await this.context.axios.post('/api/v1/factory/search', data);
+        return response.data;
+    }
+    //获得工厂的单元信息
+    async unit(id) {
+        var axios = await this.context.ready;
+        const response = await axios.get(`/api/v1/workshop/unit/${id}`);
+        return response.data;
+    }
+    //获得工厂的车间信息
+    async workshop(id) {
+        var axios = await this.context.ready;
+        const response = await axios.get(`/api/v1/workshop/${id}`);
+        return response.data;
+    }
+    //获得工厂的所有车间信息
+    async workshops(id) {
+        var axios = await this.context.ready;
+        const response = await axios.get(`/api/v1/factory/${id}/workshops`);
+        return response.data;
+    }
+    //获得工厂的所有单元信息,以车间为单位树状结构
+    async units(id) {
+        var axios = await this.context.ready;
+        const response = await axios.get(`/api/v1/factory/${id}/units`);
+        return response.data;
+    }
+    async company(data) {
+        await this.context.ready;
+        const response = await this.context.axios.get(`/api/v1/factory/${data.id}/organizaion`, data);
+        return response.data;
+    }
+}
+exports.FactoryGateway = FactoryGateway;