生产管理系前端 - 删除不需要的文件夹,比如apis和utils

This commit is contained in:
2025-10-28 09:55:58 +08:00
parent 59a9743992
commit 88c8bbb2a7
6 changed files with 124 additions and 1400 deletions

View File

@@ -1,126 +0,0 @@
/**
* API 统一入口文件
* 根据不同环境配置不同的API域名和端口
* 统一暴露所有模块的API接口
*/
import { createAPI } from './interceptor.js';
// 环境配置
const ENV_CONFIG = {
development: {
baseURL: 'http://localhost:8080',
timeout: 10000,
enableLogging: true
},
test: {
baseURL: 'http://test-api.smart-crop.com',
timeout: 15000,
enableLogging: true
},
production: {
baseURL: 'https://api.smart-crop.com',
timeout: 20000,
enableLogging: false
}
};
// 获取当前环境
const getEnvironment = () => {
const env = import.meta.env?.MODE || 'development';
// 可以根据其他条件判断环境
if (env === 'production') return 'production';
if (env === 'test') return 'test';
return 'development';
};
// 创建API实例
const currentEnv = getEnvironment();
const envConfig = ENV_CONFIG[currentEnv];
console.log(`🚀 API Environment: ${currentEnv}`);
console.log(`🌐 API Base URL: ${envConfig.baseURL}`);
// 创建API实例
export const api = createAPI({
baseURL: envConfig.baseURL,
timeout: envConfig.timeout,
enableLogging: envConfig.enableLogging
});
// 导入各模块API
import { agriculturalMachineryAPI } from './subModules/agriculturalMachinery.js';
import { landInformationAPI } from './subModules/landInformation.js';
import { farmingOperationAPI } from './subModules/farmingOperation.js';
import { agriculturalAssetAPI } from './subModules/agriculturalAsset.js';
import { aiCropModelAPI } from './subModules/aiCropModel.js';
import { waterFertilizerControlAPI } from './subModules/waterFertilizerControl.js';
import { centralConfigAPI } from './subModules/centralConfig.js';
// 统一导出所有API
export const API = {
// 农机管理模块
agriculturalMachinery: agriculturalMachineryAPI(api),
// 地块信息模块
landInformation: landInformationAPI(api),
// 农事操作模块
farmingOperation: farmingOperationAPI(api),
// 农业资产模块
agriculturalAsset: agriculturalAssetAPI(api),
// AI作物模型模块
aiCropModel: aiCropModelAPI(api),
// 水肥控制模块
waterFertilizerControl: waterFertilizerControlAPI(api),
// 中心配置模块
centralConfig: centralConfigAPI(api),
// 认证相关API (直接暴露,不需要模块化)
auth: {
login: (credentials) => api.post('/auth/login', credentials),
register: (userInfo) => api.post('/auth/register', userInfo),
logout: () => api.post('/auth/logout'),
refreshToken: (refreshToken) => api.post('/auth/refresh-token', { refreshToken }),
getCurrentUser: () => api.get('/auth/me'),
updateProfile: (profileData) => api.put('/auth/profile', profileData),
changePassword: (passwordData) => api.put('/auth/change-password', passwordData)
},
// 通用API
common: {
uploadFile: (fileData) => api.post('/common/upload', fileData, {
headers: { 'Content-Type': 'multipart/form-data' }
}),
downloadFile: (fileId) => api.get(`/common/download/${fileId}`, {
responseType: 'blob'
}),
getSystemConfig: () => api.get('/common/system-config'),
healthCheck: () => api.get('/common/health')
}
};
// 导出默认API实例和配置
export default API;
// 导出环境信息(供调试使用)
export { currentEnv, envConfig };
// API使用示例
/*
import { API } from '@/apis';
// 使用农机管理API
const machineryList = await API.agriculturalMachinery.getMachineryList();
// 使用认证API
const loginResult = await API.auth.login({ username, password });
// 使用通用API
const uploadResult = await API.common.uploadFile(formData);
*/

View File

@@ -1,285 +0,0 @@
/**
* API 请求拦截器
* 功能:
* 1. 为除登录接口外的所有请求添加身份信息
* 2. 统一错误处理
* 3. 请求/响应日志记录
* 4. 自动刷新token
*/
import axios from 'axios';
import { toast } from 'sonner';
/**
* 创建API实例并配置拦截器
*/
export const createAPI = ({ baseURL, timeout = 10000, enableLogging = false }) => {
// 创建axios实例
const api = axios.create({
baseURL,
timeout,
headers: {
'Content-Type': 'application/json',
},
});
// 获取存储的token和用户信息
const getAuthData = () => {
try {
const authData = localStorage.getItem('authData');
if (authData) {
const { token, user } = JSON.parse(authData);
return { token, user_id: user?.id };
}
} catch (error) {
console.warn('Failed to parse auth data from localStorage:', error);
}
return { token: null, user_id: null };
};
// 请求拦截器
api.interceptors.request.use(
(config) => {
// 添加请求日志
if (enableLogging) {
console.log(`🚀 API Request: ${config.method?.toUpperCase()} ${config.url}`, {
data: config.data,
params: config.params,
});
}
// 为除登录接口外的所有请求添加身份信息
const isLoginRequest = config.url?.includes('/auth/login');
const isRegisterRequest = config.url?.includes('/auth/register');
if (!isLoginRequest && !isRegisterRequest) {
const { token, user_id } = getAuthData();
if (token) {
config.headers['auth'] = token; // JWT token
}
if (user_id) {
config.headers['user_id'] = user_id; // 用户ID
}
}
// 添加请求时间戳
config.metadata = { startTime: new Date() };
return config;
},
(error) => {
console.error('❌ Request Error:', error);
return Promise.reject(error);
}
);
// 响应拦截器
api.interceptors.response.use(
(response) => {
// 添加响应日志
if (enableLogging) {
const duration = new Date() - response.config.metadata.startTime;
console.log(`✅ API Response: ${response.config.method?.toUpperCase()} ${response.config.url}`, {
status: response.status,
duration: `${duration}ms`,
data: response.data,
});
}
// 统一处理成功响应格式
if (response.data && typeof response.data === 'object') {
// 如果后端返回统一格式 { code, message, data }
if ('code' in response.data) {
const { code, message, data } = response.data;
if (code === 200 || code === 0) {
return { ...response, data }; // 返回实际数据
} else {
// 业务错误处理
toast.error(message || '请求失败');
return Promise.reject(new Error(message || '请求失败'));
}
}
}
return response;
},
async (error) => {
const originalRequest = error.config;
// 添加错误日志
if (enableLogging) {
const duration = originalRequest?.metadata?.startTime
? `${new Date() - originalRequest.metadata.startTime}ms`
: 'N/A';
console.error(`❌ API Error: ${originalRequest?.method?.toUpperCase()} ${originalRequest?.url}`, {
status: error.response?.status,
duration,
message: error.message,
data: error.response?.data,
});
}
// 处理不同类型的错误
if (error.response) {
const { status, data } = error.response;
switch (status) {
case 401:
// 未授权 - token过期或无效
return handleUnauthorizedError(originalRequest);
case 403:
// 禁止访问 - 权限不足
toast.error('您没有权限访问此资源');
break;
case 404:
// 资源不存在
toast.error('请求的资源不存在');
break;
case 422:
// 表单验证错误
if (data?.errors) {
Object.values(data.errors).flat().forEach(errorMessage => {
toast.error(errorMessage);
});
} else {
toast.error(data?.message || '请求参数错误');
}
break;
case 429:
// 请求过于频繁
toast.error('请求过于频繁,请稍后再试');
break;
case 500:
// 服务器内部错误
toast.error('服务器内部错误,请稍后再试');
break;
default:
// 其他错误
toast.error(data?.message || `请求失败 (${status})`);
}
} else if (error.request) {
// 网络错误
if (error.code === 'ECONNABORTED') {
toast.error('请求超时,请检查网络连接');
} else {
toast.error('网络连接失败,请检查网络');
}
} else {
// 其他错误
toast.error('请求配置错误');
}
return Promise.reject(error);
}
);
return api;
};
/**
* 处理401未授权错误
* 尝试刷新token或跳转到登录页
*/
const handleUnauthorizedError = async (originalRequest) => {
// 避免重复刷新token
if (originalRequest._retry) {
// 刷新失败,清除本地存储并跳转到登录页
localStorage.removeItem('authData');
window.location.href = '/login';
return Promise.reject(new Error('登录已过期,请重新登录'));
}
originalRequest._retry = true;
try {
// 尝试刷新token
const authData = JSON.parse(localStorage.getItem('authData') || '{}');
const refreshToken = authData.refreshToken;
if (refreshToken) {
const response = await axios.post(`${originalRequest.baseURL}/auth/refresh-token`, {
refreshToken
});
const { token, user } = response.data.data;
// 更新本地存储
localStorage.setItem('authData', JSON.stringify({
token,
refreshToken,
user
}));
// 重新发送原始请求
originalRequest.headers['auth'] = token;
originalRequest.headers['user_id'] = user.id;
return axios(originalRequest);
} else {
// 没有刷新token跳转到登录页
localStorage.removeItem('authData');
window.location.href = '/login';
return Promise.reject(new Error('登录已过期,请重新登录'));
}
} catch (refreshError) {
// 刷新token失败
localStorage.removeItem('authData');
window.location.href = '/login';
return Promise.reject(new Error('登录已过期,请重新登录'));
}
};
/**
* 设置认证信息
* @param {string} token JWT token
* @param {object} user 用户信息
* @param {string} refreshToken 刷新token
*/
export const setAuthData = (token, user, refreshToken) => {
const authData = {
token,
refreshToken: refreshToken || '',
user
};
localStorage.setItem('authData', JSON.stringify(authData));
};
/**
* 清除认证信息
*/
export const clearAuthData = () => {
localStorage.removeItem('authData');
};
/**
* 获取当前认证信息
*/
export const getAuthData = () => {
try {
const authData = localStorage.getItem('authData');
return authData ? JSON.parse(authData) : null;
} catch (error) {
console.warn('Failed to get auth data:', error);
return null;
}
};
/**
* 检查是否已登录
*/
export const isAuthenticated = () => {
const authData = getAuthData();
return !!(authData?.token && authData?.user);
};
export default createAPI;

View File

@@ -1,333 +0,0 @@
/**
* 智能农机管理系统 API 接口
* AgriculturalMachinery System API
*/
/**
* 农机档案管理 API
*/
export const createMachineryArchiveAPI = (api) => ({
// 获取农机列表
getMachineryList: (params = {}) => {
return api.get('/agricultural/machinery/archive/list', { params });
},
// 获取农机详情
getMachineryDetail: (id) => {
return api.get(`/agricultural/machinery/archive/detail/${id}`);
},
// 创建农机档案
createMachinery: (machineryData) => {
return api.post('/agricultural/machinery/archive/create', machineryData);
},
// 更新农机档案
updateMachinery: (id, machineryData) => {
return api.put(`/agricultural/machinery/archive/update/${id}`, machineryData);
},
// 删除农机档案
deleteMachinery: (id) => {
return api.delete(`/agricultural/machinery/archive/delete/${id}`);
},
// 批量删除农机
batchDeleteMachinery: (ids) => {
return api.post('/agricultural/machinery/archive/batch-delete', { ids });
},
// 农机分类管理
getMachineryCategories: () => {
return api.get('/agricultural/machinery/archive/categories');
},
createMachineryCategory: (categoryData) => {
return api.post('/agricultural/machinery/archive/categories/create', categoryData);
},
// QR码管理
generateQRCode: (machineryId) => {
return api.post(`/agricultural/machinery/archive/qrcode/generate/${machineryId}`);
},
downloadQRCode: (machineryId) => {
return api.get(`/agricultural/machinery/archive/qrcode/download/${machineryId}`, {
responseType: 'blob'
});
}
});
/**
* 驾驶员档案管理 API
*/
export const createDriverArchiveAPI = (api) => ({
// 获取驾驶员列表
getDriverList: (params = {}) => {
return api.get('/agricultural/driver/archive/list', { params });
},
// 获取驾驶员详情
getDriverDetail: (id) => {
return api.get(`/agricultural/driver/archive/detail/${id}`);
},
// 创建驾驶员档案
createDriver: (driverData) => {
return api.post('/agricultural/driver/archive/create', driverData);
},
// 更新驾驶员档案
updateDriver: (id, driverData) => {
return api.put(`/agricultural/driver/archive/update/${id}`, driverData);
},
// 删除驾驶员档案
deleteDriver: (id) => {
return api.delete(`/agricultural/driver/archive/delete/${id}`);
},
// 驾驶员任务管理
getDriverTasks: (driverId, params = {}) => {
return api.get(`/agricultural/driver/tasks/${driverId}`, { params });
},
assignTaskToDriver: (driverId, taskData) => {
return api.post(`/agricultural/driver/tasks/assign/${driverId}`, taskData);
}
});
/**
* 负载管理 API
*/
export const createLoadManagementAPI = (api) => ({
// 获取负载设备列表
getLoadDevices: (params = {}) => {
return api.get('/agricultural/load/devices/list', { params });
},
// 创建负载设备
createLoadDevice: (deviceData) => {
return api.post('/agricultural/load/devices/create', deviceData);
},
// 获取负载类型
getLoadTypes: () => {
return api.get('/agricultural/load/types');
},
// 获取负载参数
getLoadParameters: (deviceId) => {
return api.get(`/agricultural/load/parameters/${deviceId}`);
},
// 设置负载参数
setLoadParameters: (deviceId, parameters) => {
return api.put(`/agricultural/load/parameters/${deviceId}`, parameters);
}
});
/**
* 实时监控 API
*/
export const createMonitoringAPI = (api) => ({
// 获取实时位置
getRealTimeLocation: (machineryId) => {
return api.get(`/agricultural/monitoring/location/${machineryId}`);
},
// 获取多个设备位置
getBatchLocations: (machineryIds) => {
return api.post('/agricultural/monitoring/locations/batch', { machineryIds });
},
// 获取工作状态
getWorkStatus: (machineryId) => {
return api.get(`/agricultural/monitoring/status/${machineryId}`);
},
// 获取作业数据
getOperationData: (machineryId, params = {}) => {
return api.get(`/agricultural/monitoring/operation-data/${machineryId}`, { params });
},
// 历史轨迹
getHistoryTracks: (machineryId, params = {}) => {
return api.get(`/agricultural/monitoring/tracks/${machineryId}`, { params });
}
});
/**
* 故障诊断 API
*/
export const createFaultDiagnosisAPI = (api) => ({
// 获取故障列表
getFaultList: (params = {}) => {
return api.get('/agricultural/fault/list', { params });
},
// 获取故障详情
getFaultDetail: (faultId) => {
return api.get(`/agricultural/fault/detail/${faultId}`);
},
// 创建故障报告
createFaultReport: (faultData) => {
return api.post('/agricultural/fault/report', faultData);
},
// 获取健康评估
getHealthAssessment: (machineryId) => {
return api.get(`/agricultural/fault/health/${machineryId}`);
},
// 获取运行参数
getRunningParameters: (machineryId) => {
return api.get(`/agricultural/fault/parameters/${machineryId}`);
}
});
/**
* 精准作业 API
*/
export const createPrecisionOperationAPI = (api) => ({
// 获取作业记录
getOperationRecords: (params = {}) => {
return api.get('/agricultural/operation/records', { params });
},
// 创建作业记录
createOperationRecord: (recordData) => {
return api.post('/agricultural/operation/records/create', recordData);
},
// 路线规划
planRoute: (routeData) => {
return api.post('/agricultural/operation/route/plan', routeData);
},
// 获取路线
getRoute: (routeId) => {
return api.get(`/agricultural/operation/route/${routeId}`);
},
// 方案下发
dispatchPlan: (planData) => {
return api.post('/agricultural/operation/dispatch', planData);
},
// 驾驶舱数据
getCockpitData: (machineryId) => {
return api.get(`/agricultural/operation/cockpit/${machineryId}`);
}
});
/**
* 数据分析 API
*/
export const createDataAnalysisAPI = (api) => ({
// 作业数据分析
getOperationAnalysis: (params = {}) => {
return api.get('/agricultural/analysis/operation', { params });
},
// 历史数据对比
getHistoricalComparison: (params = {}) => {
return api.get('/agricultural/analysis/history', { params });
},
// 统计报表
getStatisticsReport: (params = {}) => {
return api.get('/agricultural/analysis/statistics', { params });
},
// 导出报表
exportReport: (reportType, params = {}) => {
return api.get(`/agricultural/analysis/export/${reportType}`, {
params,
responseType: 'blob'
});
}
});
/**
* 调度管理 API
*/
export const createSchedulingAPI = (api) => ({
// 任务分配
getTaskAssignments: (params = {}) => {
return api.get('/agricultural/scheduling/assignments', { params });
},
// 创建任务分配
createTaskAssignment: (assignmentData) => {
return api.post('/agricultural/scheduling/assignments/create', assignmentData);
},
// 实时调度
getRealTimeDispatch: (params = {}) => {
return api.get('/agricultural/scheduling/dispatch/realtime', { params });
},
// 轨迹回放
getTrackPlayback: (machineryId, params = {}) => {
return api.get(`/agricultural/scheduling/playback/${machineryId}`, { params });
}
});
/**
* 安全安防 API
*/
export const createSecurityAPI = (api) => ({
// 电子围栏
getGeoFences: (params = {}) => {
return api.get('/agricultural/security/geo-fence', { params });
},
// 创建电子围栏
createGeoFence: (fenceData) => {
return api.post('/agricultural/security/geo-fence/create', fenceData);
},
// 更新电子围栏
updateGeoFence: (fenceId, fenceData) => {
return api.put(`/agricultural/security/geo-fence/${fenceId}`, fenceData);
},
// 删除电子围栏
deleteGeoFence: (fenceId) => {
return api.delete(`/agricultural/security/geo-fence/${fenceId}`);
}
});
/**
* 导出农机管理系统的所有API
*/
export const agriculturalMachineryAPI = (api) => ({
// 农机档案
archive: createMachineryArchiveAPI(api),
// 驾驶员档案
driver: createDriverArchiveAPI(api),
// 负载管理
load: createLoadManagementAPI(api),
// 实时监控
monitoring: createMonitoringAPI(api),
// 故障诊断
fault: createFaultDiagnosisAPI(api),
// 精准作业
operation: createPrecisionOperationAPI(api),
// 数据分析
analysis: createDataAnalysisAPI(api),
// 调度管理
scheduling: createSchedulingAPI(api),
// 安全安防
security: createSecurityAPI(api)
});

View File

@@ -1,357 +0,0 @@
/**
* 农事操作管理系统 API 接口
* Farming Operation System API
*/
/**
* 农事计划 API
*/
export const createFarmingPlanAPI = (api) => ({
// 计划制定
getFarmingPlans: (params = {}) => {
return api.get('/farming/operation/planning/list', { params });
},
createFarmingPlan: (planData) => {
return api.post('/farming/operation/planning/create', planData);
},
updateFarmingPlan: (planId, planData) => {
return api.put(`/farming/operation/planning/update/${planId}`, planData);
},
deleteFarmingPlan: (planId) => {
return api.delete(`/farming/operation/planning/delete/${planId}`);
},
// 资源分配规划
getResourceAllocation: (planId) => {
return api.get(`/farming/operation/planning/allocation/${planId}`);
},
createResourceAllocation: (allocationData) => {
return api.post('/farming/operation/planning/allocation/create', allocationData);
},
// 计划进度跟踪
getPlanProgress: (planId) => {
return api.get(`/farming/operation/planning/progress/${planId}`);
},
updatePlanProgress: (planId, progressData) => {
return api.put(`/farming/operation/planning/progress/${planId}`, progressData);
}
});
/**
* 农事任务 API
*/
export const createFarmingTaskAPI = (api) => ({
// 任务管理
getFarmingTasks: (params = {}) => {
return api.get('/farming/operation/task/list', { params });
},
createFarmingTask: (taskData) => {
return api.post('/farming/operation/task/create', taskData);
},
updateFarmingTask: (taskId, taskData) => {
return api.put(`/farming/operation/task/update/${taskId}`, taskData);
},
deleteFarmingTask: (taskId) => {
return api.delete(`/farming/operation/task/delete/${taskId}`);
},
// 任务分配与派发
assignTask: (taskId, assignmentData) => {
return api.post(`/farming/operation/task/assign/${taskId}`, assignmentData);
},
dispatchTask: (taskId, dispatchData) => {
return api.post(`/farming/operation/task/dispatch/${taskId}`, dispatchData);
},
// 任务状态监控
getTaskStatus: (taskId) => {
return api.get(`/farming/operation/task/status/${taskId}`);
},
updateTaskStatus: (taskId, statusData) => {
return api.put(`/farming/operation/task/status/${taskId}`, statusData);
},
// 历史与统计
getTaskHistory: (params = {}) => {
return api.get('/farming/operation/task/history', { params });
},
getTaskStatistics: (params = {}) => {
return api.get('/farming/operation/task/statistics', { params });
}
});
/**
* 农事执行 API
*/
export const createFarmingExecutionAPI = (api) => ({
// 农事类型
getFarmingTypes: () => {
return api.get('/farming/operation/execution/types');
},
createFarmingType: (typeData) => {
return api.post('/farming/operation/execution/types/create', typeData);
},
// 操作录入
createOperationRecord: (recordData) => {
return api.post('/farming/operation/execution/record/create', recordData);
},
getOperationRecords: (params = {}) => {
return api.get('/farming/operation/execution/records', { params });
},
updateOperationRecord: (recordId, recordData) => {
return api.put(`/farming/operation/execution/record/${recordId}`, recordData);
},
// 日志多维查询
queryOperationLogs: (queryParams) => {
return api.post('/farming/operation/execution/logs/query', queryParams);
},
getOperationLogs: (params = {}) => {
return api.get('/farming/operation/execution/logs', { params });
}
});
/**
* 农事日历 API
*/
export const createFarmingCalendarAPI = (api) => ({
// 可视化视图
getCalendarView: (params = {}) => {
return api.get('/farming/operation/calendar/view', { params });
},
// 甘特图
getGanttChart: (params = {}) => {
return api.get('/farming/operation/calendar/gantt', { params });
},
updateGanttChart: (chartData) => {
return api.put('/farming/operation/calendar/gantt/update', chartData);
},
// 进度状态可视化
getProgressVisualization: (params = {}) => {
return api.get('/farming/operation/calendar/progress', { params });
},
// 日历事件管理
createCalendarEvent: (eventData) => {
return api.post('/farming/operation/calendar/event/create', eventData);
},
updateCalendarEvent: (eventId, eventData) => {
return api.put(`/farming/operation/calendar/event/${eventId}`, eventData);
},
deleteCalendarEvent: (eventId) => {
return api.delete(`/farming/operation/calendar/event/${eventId}`);
}
});
/**
* 农事档案 API
*/
export const createFarmingArchiveAPI = (api) => ({
// 档案归集与生成
getArchives: (params = {}) => {
return api.get('/farming/operation/archive/list', { params });
},
generateArchive: (archiveConfig) => {
return api.post('/farming/operation/archive/generate', archiveConfig);
},
// 全维度数据视图
getArchiveView: (archiveId) => {
return api.get(`/farming/operation/archive/view/${archiveId}`);
},
updateArchiveView: (archiveId, viewData) => {
return api.put(`/farming/operation/archive/view/${archiveId}`, viewData);
},
// 追踪与溯源
getTraceability: (params = {}) => {
return api.get('/farming/operation/archive/traceability', { params });
},
createTraceabilityRecord: (traceData) => {
return api.post('/farming/operation/archive/traceability/create', traceData);
}
});
/**
* 农事知识库 API
*/
export const createFarmingKnowledgeAPI = (api) => ({
// 多模态知识内容管理
getKnowledgeBase: (params = {}) => {
return api.get('/farming/operation/knowledge/list', { params });
},
createKnowledgeContent: (contentData) => {
return api.post('/farming/operation/knowledge/create', contentData);
},
updateKnowledgeContent: (knowledgeId, contentData) => {
return api.put(`/farming/operation/knowledge/update/${knowledgeId}`, contentData);
},
deleteKnowledgeContent: (knowledgeId) => {
return api.delete(`/farming/operation/knowledge/delete/${knowledgeId}`);
},
// 分类与标签
getKnowledgeCategories: () => {
return api.get('/farming/operation/knowledge/categories');
},
getKnowledgeTags: () => {
return api.get('/farming/operation/knowledge/tags');
},
// 智能检索
searchKnowledge: (searchData) => {
return api.post('/farming/operation/knowledge/search', searchData);
},
getSearchSuggestions: (query) => {
return api.get('/farming/operation/knowledge/suggestions', { params: { query } });
}
});
/**
* 绩效管理 API
*/
export const createFarmingPerformanceAPI = (api) => ({
// 人员管理
getStaffList: (params = {}) => {
return api.get('/farming/operation/performance/staff', { params });
},
createStaff: (staffData) => {
return api.post('/farming/operation/performance/staff/create', staffData);
},
updateStaff: (staffId, staffData) => {
return api.put(`/farming/operation/performance/staff/${staffId}`, staffData);
},
// 工时记录
getWorkHours: (params = {}) => {
return api.get('/farming/operation/performance/hours', { params });
},
createWorkHourRecord: (hourData) => {
return api.post('/farming/operation/performance/hours/create', hourData);
},
// 绩效统计
getPerformanceStatistics: (params = {}) => {
return api.get('/farming/operation/performance/statistics', { params });
},
generatePerformanceReport: (reportConfig) => {
return api.post('/farming/operation/performance/report/generate', reportConfig);
},
// 排班管理
getScheduleList: (params = {}) => {
return api.get('/farming/operation/performance/schedule', { params });
},
createSchedule: (scheduleData) => {
return api.post('/farming/operation/performance/schedule/create', scheduleData);
},
updateSchedule: (scheduleId, scheduleData) => {
return api.put(`/farming/operation/performance/schedule/${scheduleId}`, scheduleData);
}
});
/**
* 农事问题协同 API
*/
export const createFarmingIssueAPI = (api) => ({
// 问题一键上报
reportIssue: (issueData) => {
return api.post('/farming/operation/issue/report', issueData);
},
getIssueList: (params = {}) => {
return api.get('/farming/operation/issue/list', { params });
},
// 问题处理与分派
assignIssue: (issueId, assignmentData) => {
return api.post(`/farming/operation/issue/assign/${issueId}`, assignmentData);
},
updateIssueStatus: (issueId, statusData) => {
return api.put(`/farming/operation/issue/status/${issueId}`, statusData);
},
// 在线协同
getCollaborationData: (issueId) => {
return api.get(`/farming/operation/issue/collaboration/${issueId}`);
},
createCollaborationRecord: (collaborationData) => {
return api.post('/farming/operation/issue/collaboration/create', collaborationData);
},
// 问题解决方案
getIssueSolutions: (params = {}) => {
return api.get('/farming/operation/issue/solutions', { params });
},
createSolution: (solutionData) => {
return api.post('/farming/operation/issue/solution/create', solutionData);
}
});
/**
* 导出农事操作管理系统的所有API
*/
export const farmingOperationAPI = (api) => ({
// 农事计划
planning: createFarmingPlanAPI(api),
// 农事任务
task: createFarmingTaskAPI(api),
// 农事执行
execution: createFarmingExecutionAPI(api),
// 农事日历
calendar: createFarmingCalendarAPI(api),
// 农事档案
archive: createFarmingArchiveAPI(api),
// 农事知识库
knowledge: createFarmingKnowledgeAPI(api),
// 绩效管理
performance: createFarmingPerformanceAPI(api),
// 农事问题协同
issue: createFarmingIssueAPI(api)
});

View File

@@ -1,299 +0,0 @@
/**
* 地块信息管理系统 API 接口
* Land Information System API
*/
/**
* 地块档案管理 API
*/
export const createFieldArchiveAPI = (api) => ({
// 获取地块列表
getFieldList: (params = {}) => {
return api.get('/land/field/archive/list', { params });
},
// 获取地块详情
getFieldDetail: (fieldId) => {
return api.get(`/land/field/archive/detail/${fieldId}`);
},
// 创建地块档案
createField: (fieldData) => {
return api.post('/land/field/archive/create', fieldData);
},
// 更新地块档案
updateField: (fieldId, fieldData) => {
return api.put(`/land/field/archive/update/${fieldId}`, fieldData);
},
// 删除地块档案
deleteField: (fieldId) => {
return api.delete(`/land/field/archive/delete/${fieldId}`);
},
// 地块分类标签
getFieldCategories: () => {
return api.get('/land/field/archive/categories');
},
getFieldTags: () => {
return api.get('/land/field/archive/tags');
},
// 批量操作
batchDeleteFields: (fieldIds) => {
return api.post('/land/field/archive/batch-delete', { fieldIds });
}
});
/**
* 地块数字化地图管理 API
*/
export const createFieldMapAPI = (api) => ({
// GIS地图管理
getGISMapData: (params = {}) => {
return api.get('/land/field/map/gis', { params });
},
// 上传地块边界数据
uploadFieldBoundary: (fieldId, boundaryData) => {
return api.post(`/land/field/map/boundary/upload/${fieldId}`, boundaryData);
},
// 数字化绘制与编辑
saveFieldDrawing: (drawingData) => {
return api.post('/land/field/map/drawing/save', drawingData);
},
getFieldDrawing: (fieldId) => {
return api.get(`/land/field/map/drawing/${fieldId}`);
},
// 空间数据管理
getSpatialData: (params = {}) => {
return api.get('/land/field/map/spatial-data', { params });
},
// 空间查询
spatialQuery: (queryData) => {
return api.post('/land/field/map/spatial-query', queryData);
},
// 地块影像
getSatelliteImages: (fieldId, params = {}) => {
return api.get(`/land/field/map/satellite/${fieldId}`, { params });
},
// 地图瓦片
getMapTiles: (params = {}) => {
return api.get('/land/field/map/tiles', { params });
}
});
/**
* 空间分析与决策支持 API
*/
export const createFieldAnalysisAPI = (api) => ({
// 土壤基础数据
getSoilData: (fieldId) => {
return api.get(`/land/field/analysis/soil-data/${fieldId}`);
},
updateSoilData: (fieldId, soilData) => {
return api.put(`/land/field/analysis/soil-data/${fieldId}`, soilData);
},
// 分层采样分析
getLayerSampling: (fieldId, params = {}) => {
return api.get(`/land/field/analysis/layer-sampling/${fieldId}`, { params });
},
createLayerSampling: (samplingData) => {
return api.post('/land/field/analysis/layer-sampling/create', samplingData);
},
// 土壤质量评价
getSoilQualityAssessment: (fieldId) => {
return api.get(`/land/field/analysis/soil-quality/${fieldId}`);
},
generateSoilQualityReport: (fieldId) => {
return api.post(`/land/field/analysis/soil-quality/report/${fieldId}`);
}
});
/**
* 地块环境监测 API
*/
export const createFieldMonitoringAPI = (api) => ({
// 气象监测
getWeatherData: (params = {}) => {
return api.get('/land/field/monitoring/weather', { params });
},
getWeatherForecast: (fieldId, days = 7) => {
return api.get(`/land/field/monitoring/forecast/${fieldId}`, { params: { days } });
},
// 环境监测
getEnvironmentalData: (fieldId, params = {}) => {
return api.get(`/land/field/monitoring/environment/${fieldId}`, { params });
},
// 传感器数据
getSensorData: (fieldId, sensorType) => {
return api.get(`/land/field/monitoring/sensors/${fieldId}`, { params: { type: sensorType } });
},
// 监测历史数据
getMonitoringHistory: (fieldId, params = {}) => {
return api.get(`/land/field/monitoring/history/${fieldId}`, { params });
}
});
/**
* 地块适宜性评价 API
*/
export const createFieldSuitabilityAPI = (api) => ({
// 多因子综合评价
getComprehensiveEvaluation: (fieldId) => {
return api.get(`/land/field/suitability/comprehensive/${fieldId}`);
},
generateComprehensiveEvaluation: (fieldId, factors) => {
return api.post(`/land/field/suitability/comprehensive/generate/${fieldId}`, { factors });
},
// 自动化空间分析
getBatchAnalysis: (params = {}) => {
return api.get('/land/field/suitability/batch-analysis', { params });
},
startBatchAnalysis: (analysisConfig) => {
return api.post('/land/field/suitability/batch-analysis/start', analysisConfig);
},
// 作物适配推荐
getCropRecommendation: (fieldId) => {
return api.get(`/land/field/suitability/crop/${fieldId}`);
},
generateCropRecommendation: (fieldId, preferences) => {
return api.post(`/land/field/suitability/crop/generate/${fieldId}`, preferences);
},
// 权重配置
getWeightConfig: () => {
return api.get('/land/field/suitability/weight-config');
},
updateWeightConfig: (configData) => {
return api.put('/land/field/suitability/weight-config', configData);
}
});
/**
* 地块对比分析 API
*/
export const createFieldComparisonAPI = (api) => ({
// 多维度指标看板
getMultiIndicatorDashboard: (fieldIds, params = {}) => {
return api.post('/land/field/comparison/indicator', { fieldIds, ...params });
},
// 可视化图表分析
getChartAnalysis: (comparisonData) => {
return api.post('/land/field/comparison/chart', comparisonData);
},
// 对比报告生成
generateComparisonReport: (reportConfig) => {
return api.post('/land/field/comparison/report/generate', reportConfig);
},
getComparisonReport: (reportId) => {
return api.get(`/land/field/comparison/report/${reportId}`);
},
// 导出对比报告
exportComparisonReport: (reportId, format = 'pdf') => {
return api.get(`/land/field/comparison/report/export/${reportId}`, {
params: { format },
responseType: 'blob'
});
}
});
/**
* 地块风险预警 API
*/
export const createFieldRiskAPI = (api) => ({
// 实时风险监测
getRiskMonitoring: (fieldId) => {
return api.get(`/land/field/risk/monitoring/${fieldId}`);
},
// 获取风险等级
getRiskLevel: (fieldId, riskType) => {
return api.get(`/land/field/risk/level/${fieldId}`, { params: { type: riskType } });
},
// 预警推送管理
getWarningPushSettings: (fieldId) => {
return api.get(`/land/field/risk/push-settings/${fieldId}`);
},
updateWarningPushSettings: (fieldId, settings) => {
return api.put(`/land/field/risk/push-settings/${fieldId}`, settings);
},
// 预警记录
getWarningHistory: (params = {}) => {
return api.get('/land/field/risk/warning-history', { params });
},
// 预警处置跟踪
getDisposalTracking: (warningId) => {
return api.get(`/land/field/risk/disposal/${warningId}`);
},
updateDisposalStatus: (warningId, disposalData) => {
return api.put(`/land/field/risk/disposal/${warningId}`, disposalData);
},
// 创建预警规则
createWarningRule: (ruleData) => {
return api.post('/land/field/risk/warning-rules/create', ruleData);
},
getWarningRules: (params = {}) => {
return api.get('/land/field/risk/warning-rules', { params });
}
});
/**
* 导出地块信息管理系统的所有API
*/
export const landInformationAPI = (api) => ({
// 地块档案
archive: createFieldArchiveAPI(api),
// 地图管理
map: createFieldMapAPI(api),
// 空间分析
analysis: createFieldAnalysisAPI(api),
// 环境监测
monitoring: createFieldMonitoringAPI(api),
// 适宜性评价
suitability: createFieldSuitabilityAPI(api),
// 对比分析
comparison: createFieldComparisonAPI(api),
// 风险预警
risk: createFieldRiskAPI(api)
});

View File

@@ -46,6 +46,113 @@ function logInfo(message) {
logInfo(`当前环境: ${process.env.NODE_ENV || 'development'}`);
logInfo(`API 服务器: ${process.env.API_BASE_URL || 'http://localhost:8080'}`);
/**
* 检查自定义文件是否存在
* 如果某些文件已经被自定义,我们不希望覆盖它们
*/
function checkCustomFiles() {
const customFiles = [
'client.gen.ts' // 客户端文件通常是自定义的
];
const outputDir = path.join(process.cwd(), 'src', 'lib', 'api');
const existingCustomFiles = [];
for (const file of customFiles) {
const filePath = path.join(outputDir, file);
if (fs.existsSync(filePath)) {
// 检查文件是否包含自定义内容的标识
const content = fs.readFileSync(filePath, 'utf8');
// 检查是否有自定义配置的标识
const customIndicators = [
'getBaseUrl',
'createDynamicClient',
'getCurrentClientConfig',
// 可以添加更多自定义标识
];
const hasCustomContent = customIndicators.some(indicator =>
content.includes(indicator)
);
if (hasCustomContent) {
existingCustomFiles.push(file);
logWarning(`检测到自定义文件: ${file}`);
}
}
}
return existingCustomFiles;
}
/**
* 备份自定义文件
*/
function backupCustomFiles(customFiles) {
if (customFiles.length === 0) return;
logInfo('备份自定义文件...');
const outputDir = path.join(process.cwd(), 'src', 'lib', 'api');
const backupDir = path.join(process.cwd(), 'src', 'lib', 'api', 'backup');
// 创建备份目录
if (!fs.existsSync(backupDir)) {
fs.mkdirSync(backupDir, { recursive: true });
}
const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
const timestampedBackupDir = path.join(backupDir, `backup-${timestamp}`);
fs.mkdirSync(timestampedBackupDir);
for (const file of customFiles) {
const srcPath = path.join(outputDir, file);
const destPath = path.join(timestampedBackupDir, file);
fs.copyFileSync(srcPath, destPath);
logInfo(` 备份: ${file} -> backup/${timestamp}/${file}`);
}
logSuccess(`自定义文件已备份到: backup/${timestamp}/`);
}
/**
* 恢复自定义文件
*/
function restoreCustomFiles(customFiles) {
if (customFiles.length === 0) return;
logInfo('恢复自定义文件...');
const outputDir = path.join(process.cwd(), 'src', 'lib', 'api');
const backupDir = path.join(process.cwd(), 'src', 'lib', 'api', 'backup');
// 找到最新的备份目录
const backupDirs = fs.existsSync(backupDir)
? fs.readdirSync(backupDir)
.filter(name => name.startsWith('backup-'))
.sort()
.reverse()
: [];
if (backupDirs.length === 0) {
logWarning('没有找到备份文件,跳过恢复');
return;
}
const latestBackupDir = path.join(backupDir, backupDirs[0]);
for (const file of customFiles) {
const srcPath = path.join(latestBackupDir, file);
const destPath = path.join(outputDir, file);
if (fs.existsSync(srcPath)) {
fs.copyFileSync(srcPath, destPath);
logInfo(` 恢复: ${file}`);
}
}
logSuccess('自定义文件已恢复');
}
/**
* 使用 openapi-ts 命令生成客户端代码
*/
@@ -144,9 +251,22 @@ async function main() {
log('='.repeat(60), 'cyan');
try {
// 检查是否有自定义文件
const customFiles = checkCustomFiles();
if (customFiles.length > 0) {
logInfo('检测到自定义文件,将在生成前进行备份');
backupCustomFiles(customFiles);
}
// 使用 openapi-ts 生成代码
await generateWithOpenApiTS();
// 恢复自定义文件
if (customFiles.length > 0) {
restoreCustomFiles(customFiles);
}
// 验证生成的文件
if (!validateGeneratedFiles()) {
logWarning('文件验证发现问题,但生成过程已完成');
@@ -156,6 +276,10 @@ async function main() {
logSuccess(`API 客户端代码生成完成!总耗时: ${totalTime}ms`);
logSuccess('生成的文件位于 src/lib/api/ 目录');
if (customFiles.length > 0) {
logInfo('自定义文件已保持不变,避免覆盖手动配置');
}
} catch (error) {
const totalTime = Date.now() - startTime;
logError(`脚本执行失败 (${totalTime}ms): ${error.message}`);