新版

lixuliang

2024-08-29 7cde297f0a99e060aea9bce60d1c121a14ae74d7

 src/store/index.js

@@ -1,272 +1,14 @@
import Vue from "vue";
import Vuex from "vuex";
import createPersistedState from "vuex-persistedstate"; //持久化所有state
// import { login } from '@/api/api';
// var encrypt = new JSEncrypt();
import Vue from 'vue'
import Vuex from 'vuex'
import user from './modules/user'

Vue.use(Vuex);

// 遍历节点
function ergodicNode(nodes) {
  if (nodes && nodes.length) {
    nodes.forEach(item => {
      item.rename = false;
      item.children && ergodicNode(item.children);
    });
  }
}
Vue.use(Vuex)

let store = new Vuex.Store({
  state: {
    viewer1Show: false,
    qyEchartsShow: false,
    layerTreeTwoScreen: false,
    yqfk: false,
    dlbm: false,
    ndlbm: false,
    treeData: [],
    cesiumInit: false, //地图是否初始化完成
    showSetting: false,
    isShowHistory: false,
    description: {},
    selectedLayers: [],
    // layerData: {}
const store = new Vuex.Store({
  modules: {
    user,
  },
  mutations: {
    selectedLayer(state, b) {
      state.selectedLayers = b
    },
    showHistory(state, b) {
      state.isShowHistory = b
    },
    // saveData(state, b) {
    //   state.layerData = b
    // },
    setCesiumInit(state, b) {
      state.cesiumInit = b
    },
    setViewer1Show(state, b) {
      state.viewer1Show = b;
    },
    setqyEchartsShow(state, b) {
      state.qyEchartsShow = b;
      console.log(b);
    },
    setLayerTreeTwoScreen(state, b) {
      state.layerTreeTwoScreen = b;
    },
    setYqfk(state, b) {
      state.yqfk = b;
    },

    GeoCode(state, b) {
      state.dlbm = b;
    },
    ReGeoCode(state, b) {
      state.ndlbm = b;
    },
    description(state, b) {
      state.description = b;
    },
    showSetBox(state, b) {
      state.showSetting = b;
    },

    // 定义工程树数据
    setTreeData(state, data = []) {
      ergodicNode(data);
      state.treeData = data;
    },
    // 树指定位置增加子节点（必须标识为key）
    addTreeChildren({
      treeData
    }, {
      parentNode,
      pid,
      item
    }) {
      if (!pid) {
        treeData.push(item);
        return;
      }
      (parentNode || treeData).forEach(ele => {
        if (ele.id === pid) {
          if (ele.children) {
            ele.children.push(item);
          } else {
            (parentNode || treeData).push(item);
          }

          return;
        } else {
          if (ele.children) {
            store.commit("addTreeChildren", {
              parentNode: ele.children,
              pid,
              item
            });
          }
        }
      });
    },
    // 勾选节点
    checkTreeNode({
      treeData
    }, {
      parentNode,
      id,
      checked
    }) {
      (parentNode || treeData).forEach(ele => {
        if (!id || (id && ele.id === id)) {
          // id不存，勾选所有子节点，id存在，勾选当前节点
          ele.checked = checked;
          if (ele.children) {
            store.commit("checkTreeNode", {
              parentNode: ele.children,
              checked
            });
          } else if (ele._children) {
            store.commit("checkTreeNode", {
              parentNode: ele._children,
              checked
            });
          }
          if (id) {
            return;
          }
        } else {
          // 递归
          if (ele.children) {
            store.commit("checkTreeNode", {
              parentNode: ele.children,
              id,
              checked
            });
          }
        }
      });
    },
    // 更新节点数据
    updataTreeNode({
      treeData
    }, {
      parentNode,
      id,
      nodeValue,
      key,
      value
    }) {
      (parentNode || treeData).forEach(ele => {
        if (ele.id === id) {
          if (nodeValue) {
            for (let _key in nodeValue) {
              if (nodeValue[_key] === undefined) {
                delete ele[_key];
              } else {
                ele[_key] = nodeValue[_key];
              }
            }
          } else {
            ele[key] = value;
          }
          return;
        } else {
          if (ele.children) {
            store.commit("updataTreeNode", {
              parentNode: ele.children,
              id,
              nodeValue,
              key,
              value
            });
          }
        }
      });
    },
    // 移除节点
    removeTreeNode({
      treeData
    }, {
      id,
      parentNode
    }) {
      (parentNode || treeData).forEach((ele, index) => {
        if (ele.id === id) {
          (parentNode || treeData).splice(index, 1);
          return;
        } else {
          if (ele.children) {
            store.commit("removeTreeNode", {
              id,
              parentNode: ele.children
            });
          }
        }
      });
    }
  },
  plugins: [
    createPersistedState({
      storage: window.sessionStorage, //存储到localStorage
      reducer(val) {
        return {
          // 只存储state中的userData          
          treeData: val.treeData,
          // selectedLayer: val.selectedLayer
        }
      }

    })
  ],
  actions: {
    // // 用户登录 login
    // login({ commit, state }, userInfo) {
    //   return new Promise((resolve, reject) => {
    //     // var data = {
    //     //   uid: encrypt.encrypt(userInfo.uid),
    //     //   pwd: encrypt.encrypt(userInfo.pwd),
    //     // };
    //     login(data)
    //       .then((response) => {
    //         const data = response;
    //         if (data.code !== 200) {
    //           resolve(data);
    //           return
    //           // return Message({
    //           //   message: data.msg,
    //           //   type: 'error',
    //           //   duration: 5 * 1000,
    //           // });
    //         }
    //         // commit('SET_UNAME', data.result.uname);
    //         // commit('SET_TOKEN', data.result.token);

    //         // setToken(data.result.token);
    //         resolve(data);
    //       })
    //       .catch((error) => {
    //         reject(error);
    //       });
    //   });
    // },
    // getpublickey({ commit, state }, userInfo) {
    //   return new Promise((resolve, reject) => {
    //     getPublicKey(userInfo)
    //       .then((response) => {
    //         const data = response;
    //         // commit('SET_KEY', data.result);
    //         encrypt.setPublicKey(data.result); // 设置公钥
    //         resolve();
    //       })
    //       .catch((error) => {
    //         reject(error);
    //       });
    //   });
    // },
  }
});



export default store