451 lines
12 KiB
JavaScript
451 lines
12 KiB
JavaScript
// Vuex状态管理
|
|
import { createStore } from 'vuex';
|
|
import { authAPI, userAPI, deviceAPI } from '../services/api.js';
|
|
// src/store/index.js
|
|
import { defineStore } from 'pinia';
|
|
export const useStore = defineStore('main', { /* 配置 */ });
|
|
|
|
|
|
// 用户模块
|
|
const user = {
|
|
namespaced: true,
|
|
state: () => ({
|
|
userInfo: null,
|
|
companyList: [],
|
|
currentCompany: null,
|
|
token: localStorage.getItem('token') || null,
|
|
loginInfo: null
|
|
}),
|
|
|
|
mutations: {
|
|
SET_USER_INFO(state, userInfo) {
|
|
state.userInfo = userInfo;
|
|
},
|
|
|
|
SET_COMPANY_LIST(state, companyList) {
|
|
state.companyList = companyList;
|
|
},
|
|
|
|
SET_CURRENT_COMPANY(state, company) {
|
|
state.currentCompany = company;
|
|
},
|
|
|
|
SET_TOKEN(state, token) {
|
|
state.token = token;
|
|
if (token) {
|
|
localStorage.setItem('token', token);
|
|
} else {
|
|
localStorage.removeItem('token');
|
|
}
|
|
},
|
|
|
|
SET_LOGIN_INFO(state, loginInfo) {
|
|
state.loginInfo = loginInfo;
|
|
},
|
|
|
|
CLEAR_USER_DATA(state) {
|
|
state.userInfo = null;
|
|
state.companyList = [];
|
|
state.currentCompany = null;
|
|
state.token = null;
|
|
state.loginInfo = null;
|
|
localStorage.removeItem('token');
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
// 获取用户基本信息
|
|
async fetchUserInfo({ commit }) {
|
|
try {
|
|
const response = await userAPI.getUserInfo();
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_USER_INFO', result.data);
|
|
return { success: true, data: result.data };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取用户信息失败:', error);
|
|
return { success: false, message: '获取用户信息失败' };
|
|
}
|
|
},
|
|
|
|
// 获取用户公司列表
|
|
async fetchCompanyList({ commit }) {
|
|
try {
|
|
const response = await userAPI.getCompanyList();
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_COMPANY_LIST', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取公司列表失败:', error);
|
|
return { success: false, message: '获取公司列表失败' };
|
|
}
|
|
},
|
|
|
|
// 设置当前公司
|
|
setCurrentCompany({ commit }, company) {
|
|
commit('SET_CURRENT_COMPANY', company);
|
|
},
|
|
|
|
// 设置token
|
|
setToken({ commit }, token) {
|
|
commit('SET_TOKEN', token);
|
|
},
|
|
|
|
// 设置登录信息
|
|
setLoginInfo({ commit }, loginInfo) {
|
|
commit('SET_LOGIN_INFO', loginInfo);
|
|
},
|
|
|
|
// 用户登出
|
|
async userLogout({ commit }) {
|
|
commit('CLEAR_USER_DATA');
|
|
}
|
|
},
|
|
|
|
getters: {
|
|
isLoggedIn: state => !!state.token,
|
|
userName: state => state.userInfo?.name || '',
|
|
companyName: state => state.currentCompany?.name || ''
|
|
}
|
|
};
|
|
|
|
// VPN状态模块
|
|
const vpn = {
|
|
namespaced: true,
|
|
state: () => ({
|
|
isConnectVPN: false,
|
|
vpnStatus: 'disconnected', // disconnected, connecting, connected, error
|
|
vpnConfig: null,
|
|
connectionHistory: []
|
|
}),
|
|
|
|
mutations: {
|
|
SET_VPN_STATUS(state, status) {
|
|
state.isConnectVPN = status
|
|
state.vpnStatus = status ? 'connected' : 'disconnected'
|
|
},
|
|
|
|
SET_VPN_CONFIG(state, config) {
|
|
state.vpnConfig = config
|
|
},
|
|
|
|
ADD_CONNECTION_HISTORY(state, record) {
|
|
state.connectionHistory.push({
|
|
timestamp: new Date().toISOString(),
|
|
...record
|
|
})
|
|
},
|
|
|
|
CLEAR_CONNECTION_HISTORY(state) {
|
|
state.connectionHistory = []
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
// 设置VPN连接状态
|
|
setVPNStatus({ commit }, status) {
|
|
commit('SET_VPN_STATUS', status)
|
|
|
|
commit('ADD_CONNECTION_HISTORY', {
|
|
action: status ? 'connected' : 'disconnected'
|
|
})
|
|
},
|
|
|
|
// 设置VPN配置
|
|
setVPNConfig({ commit }, config) {
|
|
commit('SET_VPN_CONFIG', config)
|
|
},
|
|
|
|
// 清除连接历史
|
|
clearConnectionHistory({ commit }) {
|
|
commit('CLEAR_CONNECTION_HISTORY')
|
|
}
|
|
},
|
|
|
|
getters: {
|
|
vpnStatusText: (state) => {
|
|
const statusMap = {
|
|
disconnected: '未连接',
|
|
connecting: '连接中...',
|
|
connected: '已连接',
|
|
error: '连接失败'
|
|
}
|
|
return statusMap[state.vpnStatus] || '未知状态'
|
|
},
|
|
|
|
isVPNConnected: (state) => state.isConnectVPN
|
|
}
|
|
};
|
|
|
|
// 设备模块
|
|
const device = {
|
|
namespaced: true,
|
|
state: () => ({
|
|
deviceList: [],
|
|
deviceTypes: [],
|
|
currentDevice: null,
|
|
deviceLogs: [],
|
|
purposeList: [],
|
|
deviceTimeList: [],
|
|
connectedDevices: new Map(),
|
|
deviceStatus: {}
|
|
}),
|
|
|
|
mutations: {
|
|
SET_DEVICE_LIST(state, devices) {
|
|
state.deviceList = devices;
|
|
},
|
|
|
|
SET_DEVICE_TYPES(state, types) {
|
|
state.deviceTypes = types;
|
|
},
|
|
|
|
SET_CURRENT_DEVICE(state, device) {
|
|
state.currentDevice = device;
|
|
},
|
|
|
|
SET_DEVICE_LOGS(state, logs) {
|
|
state.deviceLogs = logs;
|
|
},
|
|
|
|
SET_PURPOSE_LIST(state, purposes) {
|
|
state.purposeList = purposes;
|
|
},
|
|
|
|
SET_DEVICE_TIME_LIST(state, timeList) {
|
|
state.deviceTimeList = timeList;
|
|
},
|
|
|
|
SET_DEVICE_STATUS(state, { deviceId, status }) {
|
|
state.deviceStatus[deviceId] = status;
|
|
},
|
|
|
|
ADD_CONNECTED_DEVICE(state, { deviceId, connectionInfo }) {
|
|
state.connectedDevices.set(deviceId, connectionInfo);
|
|
},
|
|
|
|
REMOVE_CONNECTED_DEVICE(state, deviceId) {
|
|
state.connectedDevices.delete(deviceId);
|
|
},
|
|
|
|
UPDATE_DEVICE_STATUS(state, { deviceId, status }) {
|
|
const device = state.deviceList.find(d => d.id === deviceId);
|
|
if (device) {
|
|
device.status = status;
|
|
}
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
// 获取设备列表数据
|
|
async fetchDeviceList({ commit }, params = {}) {
|
|
try {
|
|
const response = await deviceAPI.getDeviceList(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_DEVICE_LIST', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取设备列表失败:', error);
|
|
return { success: false, message: '获取设备列表失败' };
|
|
}
|
|
},
|
|
|
|
// 获取设备类型列表
|
|
async fetchDeviceTypes({ commit }, params = {}) {
|
|
try {
|
|
const response = await deviceAPI.getDeviceTypes(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_DEVICE_TYPES', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取设备类型失败:', error);
|
|
return { success: false, message: '获取设备类型失败' };
|
|
}
|
|
},
|
|
|
|
// 连接指定设备
|
|
async connectToDevice({ commit }, params) {
|
|
try {
|
|
const response = await deviceAPI.connectDevice(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_DEVICE_STATUS', {
|
|
deviceId: params.device_id,
|
|
status: 'connected'
|
|
});
|
|
commit('ADD_CONNECTED_DEVICE', {
|
|
deviceId: params.device_id,
|
|
connectionInfo: result.data
|
|
});
|
|
return { success: true, data: result.data };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('连接设备失败:', error);
|
|
return { success: false, message: '连接设备失败' };
|
|
}
|
|
},
|
|
|
|
// 获取设备使用日志
|
|
async fetchDeviceLogs({ commit }, params) {
|
|
try {
|
|
const response = await deviceAPI.getDeviceLogs(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_DEVICE_LOGS', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取设备日志失败:', error);
|
|
return { success: false, message: '获取设备日志失败' };
|
|
}
|
|
},
|
|
|
|
// 获取设备使用用途列表
|
|
async fetchPurposeList({ commit }, params) {
|
|
try {
|
|
const response = await deviceAPI.getPurposeList(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_PURPOSE_LIST', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取用途列表失败:', error);
|
|
return { success: false, message: '获取用途列表失败' };
|
|
}
|
|
},
|
|
|
|
// 获取设备使用时间列表
|
|
async fetchDeviceTimeList({ commit }, params) {
|
|
try {
|
|
const response = await deviceAPI.getDeviceTimeList(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_DEVICE_TIME_LIST', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取设备使用时间列表失败:', error);
|
|
return { success: false, message: '获取设备使用时间列表失败' };
|
|
}
|
|
},
|
|
|
|
// 设置当前设备
|
|
setCurrentDevice({ commit }, device) {
|
|
commit('SET_CURRENT_DEVICE', device);
|
|
},
|
|
|
|
// 更新设备状态
|
|
updateDeviceStatus({ commit }, { deviceId, status }) {
|
|
commit('UPDATE_DEVICE_STATUS', { deviceId, status });
|
|
}
|
|
},
|
|
|
|
getters: {
|
|
availableDevices: state => state.deviceList.filter(d => d.status === 'available'),
|
|
connectedDeviceCount: state => state.connectedDevices.size,
|
|
getDeviceById: state => id => state.deviceList.find(d => d.id === id)
|
|
}
|
|
};
|
|
|
|
// 端口模块
|
|
const port = {
|
|
namespaced: true,
|
|
state: () => ({
|
|
portList: [],
|
|
currentPort: null,
|
|
portStatus: {},
|
|
isLoading: false
|
|
}),
|
|
|
|
mutations: {
|
|
SET_PORT_LIST(state, ports) {
|
|
state.portList = ports;
|
|
},
|
|
|
|
SET_CURRENT_PORT(state, port) {
|
|
state.currentPort = port;
|
|
},
|
|
|
|
SET_PORT_STATUS(state, { portId, status }) {
|
|
state.portStatus[portId] = status;
|
|
},
|
|
|
|
SET_LOADING(state, loading) {
|
|
state.isLoading = loading;
|
|
}
|
|
},
|
|
|
|
actions: {
|
|
// 获取端口列表
|
|
async fetchPortList({ commit }, params = {}) {
|
|
try {
|
|
const response = await deviceAPI.getPortList(params);
|
|
const result = response.data;
|
|
|
|
if (result.code === 200) {
|
|
commit('SET_PORT_LIST', result.data || []);
|
|
return { success: true, data: result.data || [] };
|
|
} else {
|
|
return { success: false, message: result.message };
|
|
}
|
|
} catch (error) {
|
|
console.error('获取端口列表失败:', error);
|
|
return { success: false, message: '获取端口列表失败' };
|
|
}
|
|
},
|
|
|
|
// 设置当前端口
|
|
setCurrentPort({ commit }, port) {
|
|
commit('SET_CURRENT_PORT', port);
|
|
}
|
|
},
|
|
|
|
getters: {
|
|
availablePorts: state => state.portList.filter(p => p.status === 'available'),
|
|
occupiedPorts: state => state.portList.filter(p => p.status === 'occupied'),
|
|
totalPorts: state => state.portList.length
|
|
}
|
|
};
|
|
|
|
// 创建store实例
|
|
export default createStore({
|
|
modules: {
|
|
user,
|
|
vpn,
|
|
device,
|
|
port
|
|
},
|
|
strict: process.env.NODE_ENV !== 'production'
|
|
}); |