hy-dispatch-ui-v3 0.2.65 → 0.2.67

package/es/style/theme.scss

@@ -3,6 +3,7 @@
   --hy-add: 44, 232, 152; // 新增
   --hy-success: 44, 232, 152; // 成功
   --hy-success-2: 44, 232, 152; // 成功
+  --hy-success-3: 45, 255, 211; // 成功
   --hy-info: 144, 147, 153; // 灰色
   --hy-warning: 248, 166, 45; // 警告
   --hy-danger: 201, 37, 37; // 删除

package/es/utils/is.mjs

@@ -1,6 +1,8 @@
 import { isRef, isReactive, isReadonly, isProxy } from 'vue';
 import '../hooks/index.mjs';
+import './index.mjs';
 import { usePermissionMap } from '../hooks/usePermissionMap.mjs';
+import { PERMISSION } from './permission.mjs';
 
 const isString = (e) => typeof e === "string";
 const isNumber = (e) => typeof e === "number";
@@ -45,7 +47,7 @@ function isPermission(permission) {
   if (!permission) {
     return true;
   }
-  return permissionMap.value.has(permission);
+  return permissionMap.value.has(PERMISSION[`${permission}`]);
 }
 
 export { isArray, isBoolean, isEmpty, isFile, isFunction, isNull, isNumber, isObject, isOverflowing, isPermission, isString, isSupportH265, isSymbol, isUndefined, isVueProxy };

package/es/utils/map/hook/bigMap.mjs

@@ -343,6 +343,8 @@ class bigMap extends EventEmitter {
       off: function(target, types, fn, context) {
         const wrappedFn = wrappedHandlers.take(types, fn);
         return target.off(types, wrappedFn || fn, context);
+      },
+      satelliteMapFn: function() {
       }
     };
     return createMapProxy(newMap, handlers);
@@ -351,7 +353,15 @@ class bigMap extends EventEmitter {
   layerGroup(map, markers = []) {
     const layerGroup = this.BM.layerGroup(markers);
     layerGroup.addTo(map);
-    return layerGroup;
+    const handlers = {
+      addLayer: function(target, addItem) {
+        return target.addLayer(addItem);
+      },
+      clearLayers: function(target) {
+        return target.clearLayers();
+      }
+    };
+    return createMapProxy(layerGroup, handlers);
   }
   // 自定义图标
   DivIcon(option) {

package/es/utils/map/hook/gaode.mjs

@@ -94,6 +94,7 @@ class Google extends EventEmitter {
       return createMapProxy(polygon, handlers);
     });
     this.initParams = request;
+    this.layerSateGroup = null;
   }
   InitMap(domId, option) {
     const { center } = option;
@@ -110,24 +111,33 @@ class Google extends EventEmitter {
       resizeEnable: true
     });
     newMap.on("complete", (e) => {
-      if (option.completeCallbacks) {
-        option.completeCallbacks(e);
-      }
+      newMap.plugin(
+        [
+          "AMap.MarkerClusterer",
+          "AMap.Scale",
+          "AMap.LayerGroup",
+          "AMap.Circle",
+          "AMap.TileLayer",
+          "AMap.GeometryUtil",
+          "AMap.MouseTool"
+        ],
+        () => {
+          this.layerSateGroup = new window.AMap.LayerGroup([
+            new window.AMap.TileLayer.Satellite()
+          ]);
+          this.layerSateGroup.setMap(newMap);
+          this.layerSateGroup.hide();
+          setTimeout(() => {
+            this.satelliteMapFn(newMap, option.satelliteMap);
+            if (option.completeCallbacks) {
+              option.completeCallbacks(e);
+            }
+          });
+        }
+      );
     });
-    newMap.plugin(
-      [
-        "AMap.MarkerClusterer",
-        "AMap.Scale",
-        "AMap.LayerGroup",
-        "AMap.Circle",
-        "AMap.TileLayer",
-        "AMap.GeometryUtil",
-        "AMap.MouseTool"
-      ],
-      () => {
-      }
-    );
     const wrappedHandlers = createWrappedHandlerStore();
+    const _this = this;
     const handlers = {
       // return 单位：m
       distance: function(target, latAndlng1, latAndlng2) {
@@ -178,15 +188,48 @@ class Google extends EventEmitter {
       // // 四个角
       getBounds: function(target) {
         return wrapBounds(target);
+      },
+      /* 判断地图颜色 */
+      satelliteMapFn: function(target, satelliteMap) {
+        if (satelliteMap === 3) {
+          _this.layerSateGroup.show();
+        } else {
+          if (satelliteMap === 1) {
+            target.setMapStyle(_this.initParams.defaultMapStyle);
+          } else {
+            target.setMapStyle(_this.initParams.currencyMapStyle);
+          }
+          _this.layerSateGroup.hide();
+        }
       }
     };
     return createMapProxy(newMap, handlers);
   }
+  satelliteMapFn(map, satelliteMap) {
+    if (satelliteMap === 3) {
+      this.layerSateGroup.show();
+    } else {
+      if (satelliteMap === 1) {
+        map.setMapStyle(this.initParams.defaultMapStyle);
+      } else {
+        map.setMapStyle(this.initParams.currencyMapStyle);
+      }
+      this.layerSateGroup.hide();
+    }
+  }
   // 地图图层
   layerGroup(map, markers = []) {
     const layerGroup = new window.AMap.LayerGroup(markers);
     layerGroup.setMap(map);
-    return layerGroup;
+    const handlers = {
+      addLayer: function(target, addItem) {
+        return target.addLayer(addItem);
+      },
+      clearLayers: function(target) {
+        return target.clearLayers();
+      }
+    };
+    return createMapProxy(layerGroup, handlers);
   }
   // 自定义图标
   DivIcon(option) {

package/es/utils/map/hook/leafletjs.mjs

@@ -306,6 +306,7 @@ class Leafletjs extends EventEmitter {
       return createMapProxy(polygon, handlers);
     });
     this.initParams = request;
+    this.tileLayerList = [];
   }
   // 初始化地图
   InitMap(domId, option) {
@@ -325,6 +326,7 @@ class Leafletjs extends EventEmitter {
     const newMap = L.map(domId, option);
     newMap.getInitMap = () => newMap;
     const wrappedHandlers = createWrappedHandlerStore();
+    const _this = this;
     const handlers = {
       // 删除地图
       removeMap: function(target, params) {
@@ -400,6 +402,10 @@ class Leafletjs extends EventEmitter {
       off: function(target, types, fn, context) {
         const wrappedFn = wrappedHandlers.take(types, fn);
         return target.off(types, wrappedFn || fn, context);
+      },
+      /* 判断地图颜色 */
+      satelliteMapFn: function(target, satelliteMap) {
+        _this.setLayersUrl(target, satelliteMap !== 2);
       }
     };
     const map = createMapProxy(newMap, handlers);
@@ -409,7 +415,7 @@ class Leafletjs extends EventEmitter {
         option.completeCallbacks();
       }
     });
-    this.setLayersUrl(map);
+    this.setLayersUrl(map, option.satelliteMap !== 2);
     return map;
   }
   // 设置地图瓦片地址
@@ -424,12 +430,18 @@ class Leafletjs extends EventEmitter {
     if (mapServerType === "WMTS" || mapServerType === "Dynamic") {
       return this.createLayers(map, layersUrls);
     }
+    this.tileLayerList.forEach((tileLayer) => {
+      tileLayer?.remove();
+    });
+    this.tileLayerList = [];
     layersUrls.split(",").forEach((layersUrl) => {
+      let tileLayer = null;
       if (changeColorType) {
-        this.createCustomLayers(map, layersUrl);
+        tileLayer = this.createCustomLayers(map, layersUrl);
       } else {
-        this.createLayers(map, layersUrl);
+        tileLayer = this.createLayers(map, layersUrl);
       }
+      this.tileLayerList.push(tileLayer);
     });
   }
   // 超图 WMTS 图层（不适用所有的WMTS图层，目前仅支持超图WMTS，因不同的WMTS服务规范不一样，主要体现在路由访问参数）
@@ -550,7 +562,16 @@ class Leafletjs extends EventEmitter {
   }
   // 地图图层
   layerGroup(map, markers = []) {
-    return L.layerGroup(markers).addTo(getInitMap(map));
+    const layerGroup = L.layerGroup(markers).addTo(getInitMap(map));
+    const handlers = {
+      addLayer: function(target, addItem) {
+        return target.addLayer(addItem);
+      },
+      clearLayers: function(target) {
+        return target.clearLayers();
+      }
+    };
+    return createMapProxy(layerGroup, handlers);
   }
   // 自定义图标
   DivIcon(option) {

package/es/utils/map/index.mjs

@@ -230,7 +230,7 @@ class InitMap extends EventEmitter {
       /*  === leafletjs === */
       ...option
     };
-    return this.map.InitMap(domId, option);
+    return this.map?.InitMap(domId, option);
   }
   // 自定义 h5 图标
   DivIcon(option) {

package/es/version.mjs

@@ -1,3 +1,3 @@
-const version = "0.2.64";
+const version = "0.2.66";
 
 export { version };

package/lib/api/organization.js

@@ -0,0 +1,47 @@
+'use strict';
+
+require('../hooks/index.js');
+var vue = require('vue');
+var useLocale = require('../hooks/useLocale.js');
+var useApi = require('../hooks/useApi.js');
+
+function orgListWithDev3Api(params) {
+  return new Promise((resolve, reject) => {
+    const { t } = useLocale.useLocale();
+    const { api } = useApi.useApi();
+    const http = vue.unref(api);
+    http.post("organization/orgTree", params).then((res) => {
+      resolve(res.data);
+    }).catch((res) => {
+      reject(new Error(t("interfaceError")));
+    });
+  });
+}
+function orgTreeWithGroupAndDeviceApi(params) {
+  return new Promise((resolve, reject) => {
+    const { t } = useLocale.useLocale();
+    const { api } = useApi.useApi();
+    const http = vue.unref(api);
+    http.post("organization/orgTreeWithGroupAndDevice", params).then((res) => {
+      return resolve(res.data);
+    }).catch((res) => {
+      reject(new Error(t("interfaceError")));
+    });
+  });
+}
+function orgTreeWithPlanGroupAndDeviceApi(params) {
+  return new Promise((resolve, reject) => {
+    const { t } = useLocale.useLocale();
+    const { api } = useApi.useApi();
+    const http = vue.unref(api);
+    http.post("organization/orgTreeWithPlanGroupAndDevice", params).then((res) => {
+      return resolve(res.data);
+    }).catch((res) => {
+      reject(new Error(t("interfaceError")));
+    });
+  });
+}
+
+exports.orgListWithDev3Api = orgListWithDev3Api;
+exports.orgTreeWithGroupAndDeviceApi = orgTreeWithGroupAndDeviceApi;
+exports.orgTreeWithPlanGroupAndDeviceApi = orgTreeWithPlanGroupAndDeviceApi;

package/lib/bussiness/hyAcquisitionStationTree/acquisitionStationTree.vue.js

@@ -0,0 +1,249 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+require('../../components/index.js');
+require('../../hooks/index.js');
+var index = require('./js/index.js');
+var useMixins = require('../../hooks/useMixins.js');
+var index$1 = require('../../components/hyTree/index.js');
+
+import "./style/acquisitionStationTree.scss";
+
+const __default__ = vue.defineComponent({
+  name: "HyAcquisitionStationTree"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    // 数据获取类型 custom 自定义数据
+    type: {
+      type: String,
+      default: "default"
+    },
+    // 请求的额外参数
+    requestParams: {
+      type: Object,
+      default: () => ({})
+    },
+    /* 禁止选择 */
+    disableSelection: {
+      type: Array,
+      default: () => {
+        return [];
+      }
+    },
+    // 是否开启按照设备在线和离线状态排序，仅支持 device 和 groupDevice 业务类型
+    deviceOrderSort: {
+      type: Boolean,
+      default: true
+    },
+    // 设置勤务状态
+    getDutyRoster: {
+      type: Boolean,
+      default: false
+    },
+    // 仅展示在线数据
+    showOnlineOnly: {
+      type: Boolean,
+      default: false
+    },
+    /* 是否开启多选框 */
+    showCheckbox: {
+      type: Boolean,
+      default: true
+    },
+    /* 是否开启单选框 */
+    showSinglebox: {
+      type: Boolean,
+      default: false
+    },
+    // 是否清除无数据的部门
+    clearEmptyBusiness: {
+      type: Boolean,
+      default: false
+    },
+    // 是否显示通道节点的选择框
+    isShowChannelSelect: {
+      type: Boolean,
+      default: false
+    },
+    // 是否显示自定义空数据显示
+    showCustomEmpty: {
+      type: Boolean,
+      default: false
+    },
+    placeholder: {
+      type: String,
+      default: "\u8BF7\u8F93\u5165"
+    },
+    // 是否返回默认选择的数据
+    isBackDefaultSelected: {
+      type: Boolean,
+      default: false
+    },
+    /* 默认选中列表 */
+    selectedByDefault: {
+      type: Array,
+      default: () => {
+        return [];
+      }
+    },
+    // 默认需要选中的部门ID
+    defaultSelectedOrgID: {
+      default: null
+    },
+    // 搜索类型
+    searchType: {
+      type: Number,
+      default: 1
+    },
+    // 筛选列表
+    selectFilterList: {
+      type: Array,
+      default: () => []
+    },
+    // 是否高亮选中节点
+    highlight: {
+      type: Boolean,
+      default: false
+    },
+    // 是否严格的遵循父子不互相关联
+    checkStrictly: {
+      type: Boolean,
+      default: false
+    },
+    // 单选时可以取消选中
+    cancelable: {
+      type: Boolean,
+      default: true
+    },
+    // 是否显示多选框或单选框
+    showSelectBox: {
+      type: Boolean,
+      default: true
+    },
+    // 是否在点击节点的时候展开或者收缩节点
+    expandOnClickNode: {
+      type: Boolean,
+      default: true
+    },
+    // 是否在点击节点的时候选中节点
+    checkOnClickNode: {
+      type: Boolean,
+      default: false
+    },
+    // 点击叶节点(最后一个子节点)时是否检查或取消节点
+    checkOnClickLeaf: {
+      type: Boolean,
+      default: true
+    },
+    // 双击父节点会触发选中功能
+    checkOnDblclickParentNode: {
+      type: Boolean,
+      default: true
+    },
+    // 初始化过滤数据
+    filterConfig: {
+      type: Array,
+      default: () => []
+    },
+    // 外部自定义过滤函数
+    filterMethod: {
+      type: Function,
+      default: null
+    }
+  },
+  emits: [
+    "on-load",
+    "onRefreshData",
+    "on-click-delete",
+    "on-click",
+    "on-check-tree",
+    "on-department-click",
+    "on-click-device",
+    "on-contextmenu",
+    "on-dblclick",
+    "on-selectedDataList"
+  ],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const slots = vue.useSlots();
+    const {
+      containerRef,
+      hyTreeRef,
+      treeHeight,
+      setData,
+      getData,
+      onClickDelete,
+      onClick,
+      onCheckTree,
+      onDepartmentClick,
+      onClickDevice,
+      onContextmenu,
+      onDblclick,
+      onSelectedDataList,
+      singleRemovalFn,
+      setCheckedKeys,
+      setChecked,
+      getSelectedDataList,
+      refreshData,
+      getNode
+    } = useMixins.useMixins({ props, emits }, [index.useAcquisitionStationTree]);
+    __expose({
+      getData,
+      singleRemovalFn,
+      setCheckedKeys,
+      setChecked,
+      getSelectedDataList,
+      refreshData,
+      getNode
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(
+        "div",
+        {
+          ref_key: "containerRef",
+          ref: containerRef,
+          class: "w-full h-full"
+        },
+        [
+          vue.createCommentVNode(" HyAcquisitionStationTree \u91C7\u96C6\u7AD9\u6811\u5F62 "),
+          vue.createVNode(vue.unref(index$1.HyTree), vue.mergeProps({
+            ref_key: "hyTreeRef",
+            ref: hyTreeRef
+          }, { ...props }, {
+            treeType: "cs",
+            treeHeight: vue.unref(treeHeight),
+            onOnRefreshData: vue.unref(setData),
+            onOnClickDelete: vue.unref(onClickDelete),
+            onOnClick: vue.unref(onClick),
+            onOnCheckTree: vue.unref(onCheckTree),
+            onOnDepartmentClick: vue.unref(onDepartmentClick),
+            onOnClickDevice: vue.unref(onClickDevice),
+            onOnContextmenu: vue.unref(onContextmenu),
+            onOnDblclick: vue.unref(onDblclick),
+            onOnSelectedDataList: vue.unref(onSelectedDataList)
+          }), vue.createSlots({
+            _: 2
+            /* DYNAMIC */
+          }, [
+            vue.renderList(vue.unref(slots), (_, slotName) => {
+              return {
+                name: slotName,
+                fn: vue.withCtx((scope) => [
+                  vue.renderSlot(_ctx.$slots, slotName, vue.normalizeProps(vue.guardReactiveProps(scope)))
+                ])
+              };
+            })
+          ]), 1040, ["treeHeight", "onOnRefreshData", "onOnClickDelete", "onOnClick", "onOnCheckTree", "onOnDepartmentClick", "onOnClickDevice", "onOnContextmenu", "onOnDblclick", "onOnSelectedDataList"])
+        ],
+        512
+        /* NEED_PATCH */
+      );
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/lib/bussiness/hyAcquisitionStationTree/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var acquisitionStationTree = require('./acquisitionStationTree.vue.js');
+require('../../utils/index.js');
+var handler = require('../../utils/handler.js');
+
+const HyAcquisitionStationTree = handler.withInstall(acquisitionStationTree.default);
+
+exports.HyAcquisitionStationTree = HyAcquisitionStationTree;
+exports.default = HyAcquisitionStationTree;

package/lib/bussiness/hyAcquisitionStationTree/js/index.js

@@ -0,0 +1,126 @@
+'use strict';
+
+var vue = require('vue');
+var organization = require('../../../api/organization.js');
+
+function useAcquisitionStationTree(hy) {
+  const emits = hy.emits;
+  const props = hy.props;
+  const hyTreeRef = vue.useTemplateRef("hyTreeRef");
+  const containerRef = vue.useTemplateRef("containerRef");
+  const treeHeight = vue.ref(400);
+  let resizeObserver;
+  function updateTreeHeight() {
+    const height = hy.containerRef.value?.getBoundingClientRect().height;
+    if (height > 0 && height - 12 !== hy.treeHeight.value) {
+      hy.treeHeight.value = Math.round(height) - 12;
+    }
+  }
+  async function setData() {
+    if (props.type === "custom") {
+      emits("onRefreshData");
+      return;
+    }
+    const data = await organization.orgListWithDev3Api({
+      ...props.requestParams
+    });
+    hy.hyTreeRef.value.getData(data).then(() => {
+      emits("on-load");
+    });
+  }
+  function getData(data) {
+    return new Promise((resolve) => {
+      hy.hyTreeRef.value.getData(data).then(() => {
+        emits("on-load");
+        resolve(200);
+      });
+    });
+  }
+  vue.onMounted(() => {
+    if (props.type !== "custom") {
+      hy.setData();
+    }
+    vue.nextTick(() => {
+      hy.updateTreeHeight();
+      if (typeof ResizeObserver === "function" && hy.containerRef.value) {
+        hy.resizeObserver = new ResizeObserver(hy.updateTreeHeight);
+        hy.resizeObserver.observe(hy.containerRef.value);
+      } else if (typeof window !== "undefined") {
+        window.addEventListener("resize", hy.updateTreeHeight);
+      }
+    });
+  });
+  vue.onUnmounted(() => {
+    hy.resizeObserver?.disconnect();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("resize", hy.updateTreeHeight);
+    }
+  });
+  function onClickDelete(data) {
+    emits("on-click-delete", data);
+  }
+  function onClick(data) {
+    emits("on-click", data);
+  }
+  function onCheckTree(list, checkObj) {
+    emits("on-check-tree", list, checkObj);
+  }
+  function onDepartmentClick(data) {
+    emits("on-department-click", data);
+  }
+  function onClickDevice(data) {
+    emits("on-click-device", data);
+  }
+  function onContextmenu(data) {
+    emits("on-contextmenu", data);
+  }
+  function onDblclick(list) {
+    emits("on-dblclick", list);
+  }
+  function onSelectedDataList(list) {
+    emits("on-selectedDataList", list);
+  }
+  function singleRemovalFn(row, isForce = false) {
+    hy.hyTreeRef.value.singleRemovalFn(row, isForce);
+  }
+  function setCheckedKeys(dataList, isForce = false) {
+    hy.hyTreeRef.value.setCheckedKeys(dataList, isForce);
+  }
+  function setChecked(data, type = true) {
+    hy.hyTreeRef.value.setChecked(data, type);
+  }
+  function getSelectedDataList(leafOnly = false) {
+    return hy.hyTreeRef.value.getSelectedDataList(leafOnly);
+  }
+  function refreshData() {
+    hy.hyTreeRef.value.refreshData();
+  }
+  function getNode(id) {
+    return hy.hyTreeRef.value.getNode(id);
+  }
+  return {
+    hyTreeRef,
+    containerRef,
+    treeHeight,
+    resizeObserver,
+    updateTreeHeight,
+    setData,
+    getData,
+    onClickDelete,
+    onClick,
+    onCheckTree,
+    onDepartmentClick,
+    onClickDevice,
+    onContextmenu,
+    onDblclick,
+    onSelectedDataList,
+    singleRemovalFn,
+    setCheckedKeys,
+    setChecked,
+    getSelectedDataList,
+    refreshData,
+    getNode
+  };
+}
+
+exports.useAcquisitionStationTree = useAcquisitionStationTree;