martial/martial-web
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改前端页面
Some checks failed
continuous-integration/drone/push Build is failing
Details

Browse Source
This commit is contained in:
宅房
2025-12-03 13:51:22 +08:00
parent aa6facf13a
commit ab69968bda
44 changed files with 15366 additions and 890 deletions
Download Patch File Download Diff File Expand all files Collapse all files

211
src/api/martial/activity.js Normal file
View File

@@ -0,0 +1,211 @@
import request from '@/axios';
// ==================== 活动日程管理接口 ====================
/**
* 活动日程分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.activityType - 活动类型(可选)
* @param {String} params.activityName - 活动名称(可选)
* @param {String} params.startDate - 开始日期(可选)
* @param {String} params.endDate - 结束日期(可选)
*/
export const getActivityScheduleList = (current, size, params) => {
return request({
url: '/api/blade-martial/activity-schedule/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取活动日程详情
* @param {Number} id - 活动ID
*/
export const getActivityScheduleDetail = (id) => {
return request({
url: '/api/blade-martial/activity-schedule/detail',
method: 'get',
params: { id }
})
}
/**
* 添加活动日程
* @param {Object} data - 活动数据
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.activityType - 活动类型(opening_ceremony/closing_ceremony/competition/training/meeting/other)
* @param {String} data.activityName - 活动名称
* @param {String} data.description - 活动描述
* @param {String} data.startTime - 开始时间
* @param {String} data.endTime - 结束时间
* @param {String} data.location - 活动地点
* @param {Number} data.venueId - 场地ID(可选)
* @param {String} data.organizer - 组织者
* @param {String} data.participants - 参与人员(可选)
* @param {String} data.remarks - 备注(可选)
*/
export const addActivity = (data) => {
return request({
url: '/api/blade-martial/activity-schedule/add',
method: 'post',
data
})
}
/**
* 修改活动日程
* @param {Object} data - 活动数据
*/
export const updateActivity = (data) => {
return request({
url: '/api/blade-martial/activity-schedule/update',
method: 'post',
data
})
}
/**
* 删除活动日程
* @param {String} ids - 活动ID,多个用逗号分隔
*/
export const removeActivity = (ids) => {
return request({
url: '/api/blade-martial/activity-schedule/remove',
method: 'post',
params: { ids }
})
}
/**
* 获取日历视图数据
* @param {Number} competitionId - 赛事ID
* @param {String} month - 月份(格式: YYYY-MM)
*/
export const getActivityCalendar = (competitionId, month) => {
return request({
url: '/api/blade-martial/activity-schedule/calendar',
method: 'get',
params: { competitionId, month }
})
}
/**
* 检查活动时间冲突
* @param {Object} data - 活动数据
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.startTime - 开始时间
* @param {String} data.endTime - 结束时间
* @param {Number} data.venueId - 场地ID(可选)
* @param {Number} data.excludeId - 排除的活动ID(编辑时使用)
*/
export const checkActivityConflict = (data) => {
return request({
url: '/api/blade-martial/activity-schedule/check-conflict',
method: 'post',
data
})
}
/**
* 复制活动
* @param {Object} data - 复制数据
* @param {Number} data.sourceId - 源活动ID
* @param {String} data.newStartTime - 新开始时间
* @param {String} data.newEndTime - 新结束时间
*/
export const copyActivity = (data) => {
return request({
url: '/api/blade-martial/activity-schedule/copy',
method: 'post',
data
})
}
/**
* 按日期查询活动
* @param {Number} competitionId - 赛事ID
* @param {String} date - 日期(格式: YYYY-MM-DD)
*/
export const getActivitiesByDate = (competitionId, date) => {
return request({
url: '/api/blade-martial/activity-schedule/by-date',
method: 'get',
params: { competitionId, date }
})
}
/**
* 获取活动统计
* @param {Number} competitionId - 赛事ID
*/
export const getActivityStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/activity-schedule/statistics',
method: 'get',
params: { competitionId }
})
}
/**
* 按类型统计活动
* @param {Number} competitionId - 赛事ID
*/
export const getActivityByType = (competitionId) => {
return request({
url: '/api/blade-martial/activity-schedule/statistics-by-type',
method: 'get',
params: { competitionId }
})
}
/**
* 导出活动日程
* @param {Object} params - 导出参数
*/
export const exportActivitySchedule = (params) => {
return request({
url: '/api/blade-martial/activity-schedule/export',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导入活动日程
* @param {File} file - Excel文件
* @param {Number} competitionId - 赛事ID
*/
export const importActivitySchedule = (file, competitionId) => {
const formData = new FormData()
formData.append('file', file)
formData.append('competitionId', competitionId)
return request({
url: '/api/blade-martial/activity-schedule/import',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 批量添加活动
* @param {Array} data - 活动数据数组
*/
export const batchAddActivities = (data) => {
return request({
url: '/api/blade-martial/activity-schedule/batch-add',
method: 'post',
data
})
}

291
src/api/martial/activitySchedule.js Normal file
View File

@@ -0,0 +1,291 @@
import request from '@/axios';
// ==================== 武术赛事活动日程管理接口 ====================
/**
* 活动日程分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.activityDate - 活动日期（可选）
* @param {Number} params.activityType - 活动类型（可选）
*/
export const getActivityScheduleList = (current, size, params) => {
return request({
url: '/api/blade-martial/activitySchedule/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取活动日程详情
* @param {Number} id - 活动日程ID
*/
export const getActivityScheduleDetail = (id) => {
return request({
url: '/api/blade-martial/activitySchedule/detail',
method: 'get',
params: { id }
})
}
/**
* 新增活动日程
* @param {Object} data - 活动日程数据
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.activityDate - 活动日期
* @param {String} data.startTime - 开始时间
* @param {String} data.endTime - 结束时间
* @param {Number} data.activityType - 活动类型（1开幕式2闭幕式3比赛4培训5会议6其他）
* @param {String} data.activityName - 活动名称
* @param {String} data.activityLocation - 活动地点
* @param {String} data.activityDescription - 活动描述
* @param {String} data.organizer - 组织者
* @param {String} data.participants - 参与人员
* @param {Number} data.sortOrder - 排序序号
*/
export const addActivity = (data) => {
return request({
url: '/api/blade-martial/activitySchedule/save',
method: 'post',
data
})
}
/**
* 修改活动日程
* @param {Object} data - 活动日程数据
*/
export const updateActivity = (data) => {
return request({
url: '/api/blade-martial/activitySchedule/update',
method: 'post',
data
})
}
/**
* 删除活动日程
* @param {String} ids - 活动日程ID,多个用逗号分隔
*/
export const removeActivity = (ids) => {
return request({
url: '/api/blade-martial/activitySchedule/remove',
method: 'post',
params: { ids }
})
}
/**
* 批量添加活动日程
* @param {Array} data - 活动日程数据数组
*/
export const batchAddActivities = (data) => {
return request({
url: '/api/blade-martial/activitySchedule/batch-save',
method: 'post',
data
})
}
/**
* 获取某日期的活动日程
* @param {Number} competitionId - 赛事ID
* @param {String} activityDate - 活动日期
*/
export const getActivitiesByDate = (competitionId, activityDate) => {
return request({
url: '/api/blade-martial/activitySchedule/list-by-date',
method: 'get',
params: { competitionId, activityDate }
})
}
/**
* 获取日期范围内的活动日程
* @param {Number} competitionId - 赛事ID
* @param {String} startDate - 开始日期
* @param {String} endDate - 结束日期
*/
export const getActivitiesByDateRange = (competitionId, startDate, endDate) => {
return request({
url: '/api/blade-martial/activitySchedule/list-by-range',
method: 'get',
params: { competitionId, startDate, endDate }
})
}
/**
* 获取某类型的活动日程
* @param {Number} competitionId - 赛事ID
* @param {Number} activityType - 活动类型
*/
export const getActivitiesByType = (competitionId, activityType) => {
return request({
url: '/api/blade-martial/activitySchedule/list-by-type',
method: 'get',
params: { competitionId, activityType }
})
}
/**
* 获取赛事的所有活动日程（不分页）
* @param {Number} competitionId - 赛事ID
*/
export const getAllActivities = (competitionId) => {
return request({
url: '/api/blade-martial/activitySchedule/all',
method: 'get',
params: { competitionId }
})
}
/**
* 调整活动日程顺序
* @param {Object} data - 调整参数
* @param {Number} data.id - 活动日程ID
* @param {Number} data.targetOrder - 目标顺序
*/
export const adjustActivityOrder = (data) => {
return request({
url: '/api/blade-martial/activitySchedule/adjust-order',
method: 'post',
data
})
}
/**
* 检查活动时间冲突
* @param {Object} data - 检查参数
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.activityDate - 活动日期
* @param {String} data.startTime - 开始时间
* @param {String} data.endTime - 结束时间
* @param {String} data.activityLocation - 活动地点
* @param {Number} data.excludeId - 排除的活动ID（编辑时使用）
*/
export const checkActivityConflict = (data) => {
return request({
url: '/api/blade-martial/activitySchedule/check-conflict',
method: 'post',
data
})
}
/**
* 复制活动日程到其他日期
* @param {Object} data - 复制参数
* @param {Number} data.sourceActivityId - 源活动ID
* @param {String} data.targetDate - 目标日期
*/
export const copyActivity = (data) => {
return request({
url: '/api/blade-martial/activitySchedule/copy',
method: 'post',
data
})
}
/**
* 获取活动日程日历视图数据
* @param {Number} competitionId - 赛事ID
* @param {String} month - 月份（格式：YYYY-MM）
*/
export const getActivityCalendar = (competitionId, month) => {
return request({
url: '/api/blade-martial/activitySchedule/calendar',
method: 'get',
params: { competitionId, month }
})
}
/**
* 发布活动日程
* @param {Number} id - 活动日程ID
*/
export const publishActivity = (id) => {
return request({
url: '/api/blade-martial/activitySchedule/publish',
method: 'post',
params: { id }
})
}
/**
* 取消活动日程
* @param {Number} id - 活动日程ID
* @param {String} cancelReason - 取消原因
*/
export const cancelActivity = (id, cancelReason) => {
return request({
url: '/api/blade-martial/activitySchedule/cancel',
method: 'post',
params: { id },
data: { cancelReason }
})
}
/**
* 完成活动日程
* @param {Number} id - 活动日程ID
* @param {String} completionNote - 完成备注
*/
export const completeActivity = (id, completionNote) => {
return request({
url: '/api/blade-martial/activitySchedule/complete',
method: 'post',
params: { id },
data: { completionNote }
})
}
/**
* 导出活动日程
* @param {Object} params - 导出参数
*/
export const exportActivities = (params) => {
return request({
url: '/api/blade-martial/activitySchedule/export',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导入活动日程
* @param {Number} competitionId - 赛事ID
* @param {File} file - Excel文件
*/
export const importActivities = (competitionId, file) => {
const formData = new FormData()
formData.append('competitionId', competitionId)
formData.append('file', file)
return request({
url: '/api/blade-martial/activitySchedule/import',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 打印活动日程表
* @param {Number} competitionId - 赛事ID
*/
export const printActivitySchedule = (competitionId) => {
return request({
url: '/api/blade-martial/activitySchedule/print',
method: 'get',
params: { competitionId },
responseType: 'blob'
})
}

138
src/api/martial/deduction.js Normal file
View File

@@ -0,0 +1,138 @@
import request from '@/axios';
// ==================== 扣分项管理接口 ====================
/**
* 扣分项分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.projectId - 项目ID
* @param {String} params.itemName - 扣分项名称(可选)
*/
export const getDeductionList = (current, size, params) => {
return request({
url: '/api/blade-martial/deductionItem/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取扣分项详情
* @param {Number} id - 扣分项ID
*/
export const getDeductionDetail = (id) => {
return request({
url: '/api/blade-martial/deductionItem/detail',
method: 'get',
params: { id }
})
}
/**
* 新增扣分项
* @param {Object} data - 扣分项数据
* @param {Number} data.projectId - 项目ID
* @param {String} data.itemName - 扣分项名称
* @param {Number} data.deductionPoints - 扣分值
* @param {String} data.description - 描述说明
* @param {Number} data.sortOrder - 排序序号
*/
export const addDeduction = (data) => {
return request({
url: '/api/blade-martial/deductionItem/save',
method: 'post',
data
})
}
/**
* 修改扣分项
* @param {Object} data - 扣分项数据
*/
export const updateDeduction = (data) => {
return request({
url: '/api/blade-martial/deductionItem/update',
method: 'post',
data
})
}
/**
* 删除扣分项
* @param {String} ids - 扣分项ID,多个用逗号分隔
*/
export const removeDeduction = (ids) => {
return request({
url: '/api/blade-martial/deductionItem/remove',
method: 'post',
params: { ids }
})
}
/**
* 获取项目的扣分项列表（不分页）
* @param {Number} projectId - 项目ID
*/
export const getDeductionsByProject = (projectId) => {
return request({
url: '/api/blade-martial/deductionItem/list-by-project',
method: 'get',
params: { projectId }
})
}
/**
* 克隆扣分项
* @param {Object} data - 克隆数据
* @param {Number} data.sourceProjectId - 源项目ID
* @param {Number} data.targetProjectId - 目标项目ID
*/
export const cloneDeductions = (data) => {
return request({
url: '/api/blade-martial/deductionItem/clone',
method: 'post',
data
})
}
/**
* 更新扣分项排序
* @param {Array} sortData - 排序数据数组 [{id, sortOrder}, ...]
*/
export const updateDeductionOrder = (sortData) => {
return request({
url: '/api/blade-martial/deductionItem/update-order',
method: 'post',
data: sortData
})
}
/**
* 导出扣分项模板
*/
export const exportDeductionTemplate = () => {
return request({
url: '/api/blade-martial/deductionItem/export-template',
method: 'get',
responseType: 'blob'
})
}
/**
* 导出扣分项列表
* @param {Object} params - 查询参数
*/
export const exportDeductions = (params) => {
return request({
url: '/api/blade-martial/deductionItem/export',
method: 'get',
params,
responseType: 'blob'
})
}

118
src/api/martial/deductionItem.js Normal file
View File

@@ -0,0 +1,118 @@
import request from '@/axios';
// ==================== 武术赛事扣分项管理接口 ====================
/**
* 扣分项分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.projectId - 项目ID
* @param {String} params.itemName - 扣分项名称(可选)
*/
export const getDeductionList = (current, size, params) => {
return request({
url: '/api/blade-martial/deductionItem/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取扣分项详情
* @param {Number} id - 扣分项ID
*/
export const getDeductionDetail = (id) => {
return request({
url: '/api/blade-martial/deductionItem/detail',
method: 'get',
params: { id }
})
}
/**
* 新增扣分项
* @param {Object} data - 扣分项数据
* @param {Number} data.projectId - 项目ID
* @param {String} data.itemName - 扣分项名称
* @param {Number} data.deductionPoints - 扣分值
* @param {String} data.description - 描述
* @param {Number} data.sortOrder - 排序序号
*/
export const addDeduction = (data) => {
return request({
url: '/api/blade-martial/deductionItem/save',
method: 'post',
data
})
}
/**
* 修改扣分项
* @param {Object} data - 扣分项数据
*/
export const updateDeduction = (data) => {
return request({
url: '/api/blade-martial/deductionItem/update',
method: 'post',
data
})
}
/**
* 删除扣分项
* @param {String} ids - 扣分项ID,多个用逗号分隔
*/
export const removeDeduction = (ids) => {
return request({
url: '/api/blade-martial/deductionItem/remove',
method: 'post',
params: { ids }
})
}
/**
* 获取项目的扣分项列表（不分页）
* @param {Number} projectId - 项目ID
*/
export const getDeductionsByProject = (projectId) => {
return request({
url: '/api/blade-martial/deductionItem/list-by-project',
method: 'get',
params: { projectId }
})
}
/**
* 批量导入扣分项
* @param {Number} projectId - 项目ID
* @param {File} file - Excel文件
*/
export const importDeductions = (projectId, file) => {
const formData = new FormData()
formData.append('projectId', projectId)
formData.append('file', file)
return request({
url: '/api/blade-martial/deductionItem/import',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 导出扣分项模板
*/
export const exportDeductionTemplate = () => {
return request({
url: '/api/blade-martial/deductionItem/export-template',
method: 'get',
responseType: 'blob'
})
}

262
src/api/martial/exception.js Normal file
View File

@@ -0,0 +1,262 @@
import request from '@/axios';
// ==================== 武术赛事异常事件管理接口 ====================
/**
* 异常事件分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.exceptionType - 异常类型（可选）
* @param {Number} params.severity - 严重程度（可选）
* @param {Number} params.status - 处理状态（可选）
*/
export const getExceptionList = (current, size, params) => {
return request({
url: '/api/blade-martial/exception/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取异常事件详情
* @param {Number} id - 异常事件ID
*/
export const getExceptionDetail = (id) => {
return request({
url: '/api/blade-martial/exception/detail',
method: 'get',
params: { id }
})
}
/**
* 上报异常事件
* @param {Object} data - 异常事件数据
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.projectId - 项目ID（可选）
* @param {Number} data.venueId - 场地ID（可选）
* @param {Number} data.exceptionType - 异常类型（1设备故障2人员问题3时间冲突4评分异常5安全事故6其他）
* @param {Number} data.severity - 严重程度（1轻微2一般3严重4紧急）
* @param {String} data.title - 标题
* @param {String} data.description - 描述
* @param {String} data.reporterName - 上报人姓名
* @param {String} data.reporterPhone - 上报人电话
* @param {Array} data.images - 图片URL数组（可选）
*/
export const reportException = (data) => {
return request({
url: '/api/blade-martial/exception/report',
method: 'post',
data
})
}
/**
* 修改异常事件
* @param {Object} data - 异常事件数据
*/
export const updateException = (data) => {
return request({
url: '/api/blade-martial/exception/update',
method: 'post',
data
})
}
/**
* 删除异常事件
* @param {String} ids - 异常事件ID,多个用逗号分隔
*/
export const removeException = (ids) => {
return request({
url: '/api/blade-martial/exception/remove',
method: 'post',
params: { ids }
})
}
/**
* 处理异常事件
* @param {Object} data - 处理数据
* @param {Number} data.id - 异常事件ID
* @param {String} data.handlerName - 处理人姓名
* @param {String} data.handleResult - 处理结果
* @param {String} data.handleNote - 处理备注
*/
export const handleException = (data) => {
return request({
url: '/api/blade-martial/exception/handle',
method: 'post',
data
})
}
/**
* 关闭异常事件
* @param {Number} id - 异常事件ID
* @param {String} closeReason - 关闭原因
*/
export const closeException = (id, closeReason) => {
return request({
url: '/api/blade-martial/exception/close',
method: 'post',
params: { id },
data: { closeReason }
})
}
/**
* 重新打开异常事件
* @param {Number} id - 异常事件ID
* @param {String} reopenReason - 重开原因
*/
export const reopenException = (id, reopenReason) => {
return request({
url: '/api/blade-martial/exception/reopen',
method: 'post',
params: { id },
data: { reopenReason }
})
}
/**
* 分配异常事件
* @param {Object} data - 分配数据
* @param {Number} data.id - 异常事件ID
* @param {String} data.assigneeName - 分配人姓名
* @param {String} data.assigneePhone - 分配人电话
*/
export const assignException = (data) => {
return request({
url: '/api/blade-martial/exception/assign',
method: 'post',
data
})
}
/**
* 获取待处理异常事件列表
* @param {Number} competitionId - 赛事ID
* @param {Number} severity - 严重程度（可选）
*/
export const getPendingExceptions = (competitionId, severity) => {
return request({
url: '/api/blade-martial/exception/pending',
method: 'get',
params: { competitionId, severity }
})
}
/**
* 获取我的异常事件列表
* @param {Number} competitionId - 赛事ID
* @param {String} assigneeName - 分配人姓名
*/
export const getMyExceptions = (competitionId, assigneeName) => {
return request({
url: '/api/blade-martial/exception/my-exceptions',
method: 'get',
params: { competitionId, assigneeName }
})
}
/**
* 获取异常事件统计
* @param {Number} competitionId - 赛事ID
*/
export const getExceptionStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/exception/statistics',
method: 'get',
params: { competitionId }
})
}
/**
* 按类型统计异常事件
* @param {Number} competitionId - 赛事ID
*/
export const getExceptionByType = (competitionId) => {
return request({
url: '/api/blade-martial/exception/statistics-by-type',
method: 'get',
params: { competitionId }
})
}
/**
* 按严重程度统计异常事件
* @param {Number} competitionId - 赛事ID
*/
export const getExceptionBySeverity = (competitionId) => {
return request({
url: '/api/blade-martial/exception/statistics-by-severity',
method: 'get',
params: { competitionId }
})
}
/**
* 上传异常事件图片
* @param {File} file - 图片文件
*/
export const uploadExceptionImage = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/exception/upload-image',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 添加异常处理记录
* @param {Object} data - 处理记录数据
* @param {Number} data.exceptionId - 异常事件ID
* @param {String} data.operatorName - 操作人姓名
* @param {String} data.operationType - 操作类型
* @param {String} data.operationNote - 操作备注
*/
export const addExceptionLog = (data) => {
return request({
url: '/api/blade-martial/exception/add-log',
method: 'post',
data
})
}
/**
* 获取异常处理记录
* @param {Number} exceptionId - 异常事件ID
*/
export const getExceptionLogs = (exceptionId) => {
return request({
url: '/api/blade-martial/exception/logs',
method: 'get',
params: { exceptionId }
})
}
/**
* 导出异常事件报表
* @param {Object} params - 导出参数
*/
export const exportExceptions = (params) => {
return request({
url: '/api/blade-martial/exception/export',
method: 'get',
params,
responseType: 'blob'
})
}

287
src/api/martial/export.js Normal file
View File

@@ -0,0 +1,287 @@
import request from '@/axios';
// ==================== 武术赛事导出打印接口 ====================
/**
* 导出成绩单（Excel）
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
* @param {String} params.category - 分组类别（可选）
* @param {Boolean} params.includeRanking - 是否包含排名（默认true）
* @param {Boolean} params.includeMedal - 是否包含奖牌（默认true）
*/
export const exportResults = (params) => {
return request({
url: '/api/blade-martial/export/results',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导出运动员名单（Excel）
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
* @param {String} params.category - 分组类别（可选）
* @param {String} params.teamName - 团队名称（可选）
* @param {Number} params.status - 报名状态（可选）
*/
export const exportAthletes = (params) => {
return request({
url: '/api/blade-martial/export/athletes',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导出赛程表（Excel）
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.venueId - 场地ID（可选）
* @param {String} params.scheduleDate - 赛程日期（可选）
* @param {Number} params.projectId - 项目ID（可选）
*/
export const exportSchedule = (params) => {
return request({
url: '/api/blade-martial/export/schedule',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导出评分表（Excel）
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
* @param {Number} params.judgeId - 裁判ID（可选）
* @param {String} params.scoreDate - 评分日期（可选）
*/
export const exportScores = (params) => {
return request({
url: '/api/blade-martial/export/scores',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导出裁判名单（Excel）
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.judgeLevel - 裁判等级（可选）
* @param {Number} params.projectId - 项目ID（可选）
*/
export const exportReferees = (params) => {
return request({
url: '/api/blade-martial/export/referees',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导出奖牌榜（Excel）
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.groupBy - 分组方式（team/region）
*/
export const exportMedalRanking = (params) => {
return request({
url: '/api/blade-martial/export/medal-ranking',
method: 'get',
params,
responseType: 'blob'
})
}
// ==================== 证书生成接口 ====================
/**
* 生成单个证书（HTML/PDF）
* @param {Number} resultId - 成绩ID
* @param {String} format - 格式（html/pdf）默认pdf
*/
export const generateCertificate = (resultId, format = 'pdf') => {
return request({
url: `/api/blade-martial/export/certificate/${resultId}`,
method: 'get',
params: { format },
responseType: format === 'pdf' ? 'blob' : 'json'
})
}
/**
* 批量生成证书
* @param {Object} data - 生成参数
* @param {Array} data.resultIds - 成绩ID数组
* @param {Number} data.projectId - 项目ID（可选，为空时使用resultIds）
* @param {Number} data.competitionId - 赛事ID（可选，为空时使用resultIds）
* @param {String} data.format - 格式（html/pdf）默认pdf
* @param {Boolean} data.mergeFiles - 是否合并为一个文件（默认false）
*/
export const batchCertificates = (data) => {
return request({
url: '/api/blade-martial/export/certificates/batch',
method: 'post',
data,
responseType: 'blob'
})
}
/**
* 获取证书数据（用于预览）
* @param {Number} resultId - 成绩ID
*/
export const getCertificateData = (resultId) => {
return request({
url: `/api/blade-martial/export/certificate/data/${resultId}`,
method: 'get'
})
}
/**
* 获取证书模板列表
* @param {Number} competitionId - 赛事ID（可选）
*/
export const getCertificateTemplates = (competitionId) => {
return request({
url: '/api/blade-martial/export/certificate/templates',
method: 'get',
params: { competitionId }
})
}
/**
* 上传证书模板
* @param {File} file - 模板文件
* @param {String} templateName - 模板名称
* @param {Number} competitionId - 赛事ID（可选）
*/
export const uploadCertificateTemplate = (file, templateName, competitionId) => {
const formData = new FormData()
formData.append('file', file)
formData.append('templateName', templateName)
if (competitionId) {
formData.append('competitionId', competitionId)
}
return request({
url: '/api/blade-martial/export/certificate/template/upload',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
// ==================== 报表导出接口 ====================
/**
* 导出赛事统计报表
* @param {Number} competitionId - 赛事ID
*/
export const exportCompetitionReport = (competitionId) => {
return request({
url: '/api/blade-martial/export/competition-report',
method: 'get',
params: { competitionId },
responseType: 'blob'
})
}
/**
* 导出项目统计报表
* @param {Number} projectId - 项目ID
*/
export const exportProjectReport = (projectId) => {
return request({
url: '/api/blade-martial/export/project-report',
method: 'get',
params: { projectId },
responseType: 'blob'
})
}
/**
* 导出裁判工作量统计
* @param {Object} params - 导出参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.startDate - 开始日期（可选）
* @param {String} params.endDate - 结束日期（可选）
*/
export const exportJudgeWorkload = (params) => {
return request({
url: '/api/blade-martial/export/judge-workload',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导出报名统计报表
* @param {Number} competitionId - 赛事ID
*/
export const exportRegistrationReport = (competitionId) => {
return request({
url: '/api/blade-martial/export/registration-report',
method: 'get',
params: { competitionId },
responseType: 'blob'
})
}
// ==================== 打印接口 ====================
/**
* 打印签到表
* @param {Object} params - 打印参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
* @param {String} params.scheduleDate - 赛程日期（可选）
*/
export const printSignInSheet = (params) => {
return request({
url: '/api/blade-martial/export/print/sign-in',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 打印秩序册
* @param {Number} competitionId - 赛事ID
*/
export const printProgramBook = (competitionId) => {
return request({
url: '/api/blade-martial/export/print/program-book',
method: 'get',
params: { competitionId },
responseType: 'blob'
})
}
/**
* 打印成绩公告
* @param {Object} params - 打印参数
* @param {Number} params.projectId - 项目ID
* @param {Number} params.competitionId - 赛事ID
*/
export const printResultAnnouncement = (params) => {
return request({
url: '/api/blade-martial/export/print/result-announcement',
method: 'get',
params,
responseType: 'blob'
})
}

221
src/api/martial/info.js Normal file
View File

@@ -0,0 +1,221 @@
import request from '@/axios';
// ==================== <20>o<EFBFBD><03><06><> ====================
/**
* <20><><EFBFBD>o<EFBFBD>h
* @param {Number} current - SMu ؤ1
* @param {Number} size - <20>up<75> ؤ10
* @param {Object} params - <20><><EFBFBD>p
* @param {Number} params.competitionId - <20>[ID
* @param {String} params.infoType - <20>o{<7B>announcementlJ/notice<1A>/news<77><73>/rules<65>
* @param {String} params.title - <07>!<21>" <0C>
* @param {Number} params.publishStatus - <20><03>0<><30>/1<><31>/2<> <0B> <0C>
* @param {Boolean} params.isTop - /&nv<08>
* @param {Boolean} params.isImportant - /&́<08>
*/
export const getInfoPublishList = (current, size, params) => {
return request({
url: '/api/blade-martial/info-publish/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* <20><><EFBFBD>o<EFBFBD><03><>
* @param {Number} id - <20>oID
*/
export const getInfoPublishDetail = (id) => {
return request({
url: '/api/blade-martial/info-publish/detail',
method: 'get',
params: { id }
})
}
/**
* <20><03>o
* @param {Object} data - <20>opn
* @param {Number} data.competitionId - <20>[ID
* @param {String} data.infoType - <20>o{<7B>
* @param {String} data.title - <07>
* @param {String} data.coverImage - b<>URL<08>
* @param {String} data.summary - X<>
* @param {String} data.content - <20><>̇,
* @param {Array} data.attachments - D<>URLp<4C><08>
* @param {String} data.publishTime - <20><03><><08>
k<19>s<EFBFBD>
* @param {Boolean} data.isTop - /&nv
* @param {Boolean} data.isImportant - /&́
*/
export const publishInfo = (data) => {
return request({
url: '/api/blade-martial/info-publish/publish',
method: 'post',
data
})
}
/**
* <20><><EFBFBD>o
* @param {Object} data - <20>opn
*/
export const updateInfoPublish = (data) => {
return request({
url: '/api/blade-martial/info-publish/update',
method: 'post',
data
})
}
/**
* d<>o
* @param {String} ids - <20>oID *(<17><06>
*/
export const removeInfoPublish = (ids) => {
return request({
url: '/api/blade-martial/info-publish/remove',
method: 'post',
params: { ids }
})
}
/**
* bnv<6E>
* @param {Number} id - <20>oID
* @param {Boolean} isTop - /&nv
*/
export const toggleTop = (id, isTop) => {
return request({
url: '/api/blade-martial/info-publish/toggle-top',
method: 'post',
data: { id, isTop }
})
}
/**
* b́<62>
* @param {Number} id - <20>oID
* @param {Boolean} isImportant - /&́
*/
export const toggleImportant = (id, isImportant) => {
return request({
url: '/api/blade-martial/info-publish/toggle-important',
method: 'post',
data: { id, isImportant }
})
}
/**
*
b<>
* @param {File} file - <20>G<EFBFBD><47>
*/
export const uploadCoverImage = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/info-publish/upload-cover',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
*
D<>
* @param {File} file - D<><44><EFBFBD>
* @param {Function} onProgress -
ۦ<>
*/
export const uploadAttachment = (file, onProgress) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/info-publish/upload-attachment',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
},
onUploadProgress: onProgress
})
}
/**
* y<>
D<>
* @param {Array} files - D<><44><EFBFBD>p<EFBFBD>
*/
export const batchUploadAttachments = (files) => {
const formData = new FormData()
files.forEach(file => {
formData.append('files', file)
})
return request({
url: '/api/blade-martial/info-publish/batch-upload-attachments',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
*
<EFBFBD>/ <0B><>o
* @param {Number} id - <20>oID
* @param {Number} publishStatus - <20><03>1<><31>/2<> <0B>
*/
export const updatePublishStatus = (id, publishStatus) => {
return request({
url: '/api/blade-martial/info-publish/update-status',
method: 'post',
data: { id, publishStatus }
})
}
/**
* <20><><EFBFBD>oߡ
* @param {Number} competitionId - <20>[ID
*/
export const getInfoStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/info-publish/statistics',
method: 'get',
params: { competitionId }
})
}
/**
* <20><><05><>
* @param {Number} id - <20>oID
*/
export const incrementViewCount = (id) => {
return request({
url: '/api/blade-martial/info-publish/increment-view',
method: 'post',
data: { id }
})
}
/**
* <20><><EFBFBD>o<EFBFBD><03>U
* @param {Object} params - <20><><EFBFBD>p
*/
export const exportInfoPublish = (params) => {
return request({
url: '/api/blade-martial/info-publish/export',
method: 'get',
params,
responseType: 'blob'
})

259
src/api/martial/infoPublish.js Normal file
View File

@@ -0,0 +1,259 @@
import request from '@/axios';
// ==================== 武术赛事信息发布管理接口 ====================
/**
* 信息发布分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.infoType - 信息类型（可选）
* @param {Number} params.publishStatus - 发布状态（可选）
* @param {String} params.title - 标题（可选）
*/
export const getInfoPublishList = (current, size, params) => {
return request({
url: '/api/blade-martial/infoPublish/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取信息发布详情
* @param {Number} id - 信息ID
*/
export const getInfoPublishDetail = (id) => {
return request({
url: '/api/blade-martial/infoPublish/detail',
method: 'get',
params: { id }
})
}
/**
* 发布信息
* @param {Object} data - 信息数据
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.infoType - 信息类型（1公告2通知3新闻4规则5其他）
* @param {String} data.title - 标题
* @param {String} data.content - 内容
* @param {String} data.summary - 摘要（可选）
* @param {String} data.coverImage - 封面图片（可选）
* @param {Array} data.attachments - 附件URL数组（可选）
* @param {Number} data.isTop - 是否置顶（0否1是）
* @param {Number} data.isImportant - 是否重要（0否1是）
* @param {String} data.publishTime - 发布时间（可选，为空则立即发布）
*/
export const publishInfo = (data) => {
return request({
url: '/api/blade-martial/infoPublish/publish',
method: 'post',
data
})
}
/**
* 修改信息
* @param {Object} data - 信息数据
*/
export const updateInfo = (data) => {
return request({
url: '/api/blade-martial/infoPublish/update',
method: 'post',
data
})
}
/**
* 删除信息
* @param {String} ids - 信息ID,多个用逗号分隔
*/
export const removeInfo = (ids) => {
return request({
url: '/api/blade-martial/infoPublish/remove',
method: 'post',
params: { ids }
})
}
/**
* 撤回信息
* @param {Number} id - 信息ID
*/
export const withdrawInfo = (id) => {
return request({
url: '/api/blade-martial/infoPublish/withdraw',
method: 'post',
params: { id }
})
}
/**
* 置顶/取消置顶信息
* @param {Number} id - 信息ID
* @param {Number} isTop - 是否置顶（0否1是）
*/
export const toggleTop = (id, isTop) => {
return request({
url: '/api/blade-martial/infoPublish/toggle-top',
method: 'post',
params: { id, isTop }
})
}
/**
* 设置/取消重要信息
* @param {Number} id - 信息ID
* @param {Number} isImportant - 是否重要（0否1是）
*/
export const toggleImportant = (id, isImportant) => {
return request({
url: '/api/blade-martial/infoPublish/toggle-important',
method: 'post',
params: { id, isImportant }
})
}
/**
* 获取已发布信息列表（不分页）
* @param {Number} competitionId - 赛事ID
* @param {Number} infoType - 信息类型（可选）
* @param {Number} limit - 获取数量（默认10）
*/
export const getPublishedInfoList = (competitionId, infoType, limit = 10) => {
return request({
url: '/api/blade-martial/infoPublish/published',
method: 'get',
params: { competitionId, infoType, limit }
})
}
/**
* 获取置顶信息列表
* @param {Number} competitionId - 赛事ID
*/
export const getTopInfoList = (competitionId) => {
return request({
url: '/api/blade-martial/infoPublish/top-info',
method: 'get',
params: { competitionId }
})
}
/**
* 获取重要信息列表
* @param {Number} competitionId - 赛事ID
*/
export const getImportantInfoList = (competitionId) => {
return request({
url: '/api/blade-martial/infoPublish/important-info',
method: 'get',
params: { competitionId }
})
}
/**
* 搜索信息
* @param {Object} params - 搜索参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.keyword - 关键词
* @param {Number} params.infoType - 信息类型（可选）
* @param {String} params.startTime - 开始时间（可选）
* @param {String} params.endTime - 结束时间（可选）
*/
export const searchInfo = (params) => {
return request({
url: '/api/blade-martial/infoPublish/search',
method: 'get',
params
})
}
/**
* 增加阅读量
* @param {Number} id - 信息ID
*/
export const increaseViewCount = (id) => {
return request({
url: '/api/blade-martial/infoPublish/view',
method: 'post',
params: { id }
})
}
/**
* 上传封面图片
* @param {File} file - 图片文件
*/
export const uploadCoverImage = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/infoPublish/upload-cover',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 上传附件
* @param {File} file - 附件文件
*/
export const uploadAttachment = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/infoPublish/upload-attachment',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 下载附件
* @param {String} attachmentUrl - 附件URL
*/
export const downloadAttachment = (attachmentUrl) => {
return request({
url: '/api/blade-martial/infoPublish/download',
method: 'get',
params: { attachmentUrl },
responseType: 'blob'
})
}
/**
* 获取信息统计
* @param {Number} competitionId - 赛事ID
*/
export const getInfoStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/infoPublish/statistics',
method: 'get',
params: { competitionId }
})
}
/**
* 批量发布信息
* @param {Array} data - 信息数据数组
*/
export const batchPublishInfo = (data) => {
return request({
url: '/api/blade-martial/infoPublish/batch-publish',
method: 'post',
data
})
}

213
src/api/martial/judgeInvite.js Normal file
View File

@@ -0,0 +1,213 @@
import request from '@/axios';
// ==================== 武术赛事裁判邀请管理接口 ====================
/**
* 裁判邀请分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.judgeName - 裁判姓名（可选）
* @param {String} params.judgeLevel - 裁判等级（可选）
* @param {Number} params.inviteStatus - 邀请状态（可选）
*/
export const getJudgeInviteList = (current, size, params) => {
return request({
url: '/api/blade-martial/judgeInvite/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取裁判邀请详情
* @param {Number} id - 邀请ID
*/
export const getJudgeInviteDetail = (id) => {
return request({
url: '/api/blade-martial/judgeInvite/detail',
method: 'get',
params: { id }
})
}
/**
* 发送邀请
* @param {Object} data - 邀请数据
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.judgeName - 裁判姓名
* @param {String} data.judgeLevel - 裁判等级
* @param {String} data.contactPhone - 联系电话
* @param {String} data.contactEmail - 联系邮箱
* @param {String} data.inviteMessage - 邀请信息（可选）
*/
export const sendInvite = (data) => {
return request({
url: '/api/blade-martial/judgeInvite/send',
method: 'post',
data
})
}
/**
* 修改邀请
* @param {Object} data - 邀请数据
*/
export const updateInvite = (data) => {
return request({
url: '/api/blade-martial/judgeInvite/update',
method: 'post',
data
})
}
/**
* 删除邀请
* @param {String} ids - 邀请ID,多个用逗号分隔
*/
export const removeInvite = (ids) => {
return request({
url: '/api/blade-martial/judgeInvite/remove',
method: 'post',
params: { ids }
})
}
/**
* 批量发送邀请
* @param {Object} data - 批量邀请参数
* @param {Number} data.competitionId - 赛事ID
* @param {Array} data.judges - 裁判信息数组
* @param {String} data.inviteMessage - 邀请信息（可选）
*/
export const batchSendInvites = (data) => {
return request({
url: '/api/blade-martial/judgeInvite/batch-send',
method: 'post',
data
})
}
/**
* 重新发送邀请
* @param {Number} id - 邀请ID
*/
export const resendInvite = (id) => {
return request({
url: '/api/blade-martial/judgeInvite/resend',
method: 'post',
params: { id }
})
}
/**
* 裁判回复邀请
* @param {Object} data - 回复数据
* @param {Number} data.inviteId - 邀请ID
* @param {String} data.inviteToken - 邀请令牌
* @param {Number} data.replyStatus - 回复状态（1接受2拒绝）
* @param {String} data.replyNote - 回复备注
*/
export const replyInvite = (data) => {
return request({
url: '/api/blade-martial/judgeInvite/reply',
method: 'post',
data
})
}
/**
* 取消邀请
* @param {Number} id - 邀请ID
* @param {String} cancelReason - 取消原因
*/
export const cancelInvite = (id, cancelReason) => {
return request({
url: '/api/blade-martial/judgeInvite/cancel',
method: 'post',
params: { id },
data: { cancelReason }
})
}
/**
* 确认邀请
* @param {Number} id - 邀请ID
*/
export const confirmInvite = (id) => {
return request({
url: '/api/blade-martial/judgeInvite/confirm',
method: 'post',
params: { id }
})
}
/**
* 获取邀请统计
* @param {Number} competitionId - 赛事ID
*/
export const getInviteStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/judgeInvite/statistics',
method: 'get',
params: { competitionId }
})
}
/**
* 获取已接受邀请的裁判列表
* @param {Number} competitionId - 赛事ID
*/
export const getAcceptedJudges = (competitionId) => {
return request({
url: '/api/blade-martial/judgeInvite/accepted-judges',
method: 'get',
params: { competitionId }
})
}
/**
* 从裁判库导入
* @param {Object} data - 导入参数
* @param {Number} data.competitionId - 赛事ID
* @param {Array} data.judgeIds - 裁判ID数组（从裁判库选择）
*/
export const importFromJudgePool = (data) => {
return request({
url: '/api/blade-martial/judgeInvite/import-from-pool',
method: 'post',
data
})
}
/**
* 导出邀请名单
* @param {Object} params - 导出参数
*/
export const exportInvites = (params) => {
return request({
url: '/api/blade-martial/judgeInvite/export',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 发送提醒消息
* @param {Number} id - 邀请ID
* @param {String} reminderMessage - 提醒消息
*/
export const sendReminder = (id, reminderMessage) => {
return request({
url: '/api/blade-martial/judgeInvite/send-reminder',
method: 'post',
params: { id },
data: { reminderMessage }
})
}

248
src/api/martial/judgeProject.js Normal file
View File

@@ -0,0 +1,248 @@
import request from '@/axios';
// ==================== 武术赛事裁判-项目关联管理接口 ====================
/**
* 裁判-项目关联分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.judgeId - 裁判ID（可选）
* @param {Number} params.projectId - 项目ID（可选）
* @param {String} params.role - 角色（可选）
*/
export const getJudgeProjectList = (current, size, params) => {
return request({
url: '/api/blade-martial/judge-project/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取裁判-项目关联详情
* @param {Number} id - 关联ID
*/
export const getJudgeProjectDetail = (id) => {
return request({
url: '/api/blade-martial/judge-project/detail',
method: 'get',
params: { id }
})
}
/**
* 分配裁判到项目
* @param {Object} data - 分配数据
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.judgeId - 裁判ID
* @param {String} data.judgeName - 裁判姓名
* @param {Number} data.projectId - 项目ID
* @param {String} data.projectName - 项目名称
* @param {String} data.role - 角色（主裁、副裁、执裁）
*/
export const assignJudge = (data) => {
return request({
url: '/api/blade-martial/judge-project/assign',
method: 'post',
data
})
}
/**
* 修改分配
* @param {Object} data - 分配数据
*/
export const updateAssignment = (data) => {
return request({
url: '/api/blade-martial/judge-project/update',
method: 'post',
data
})
}
/**
* 删除分配
* @param {String} ids - 关联ID,多个用逗号分隔
*/
export const removeAssignment = (ids) => {
return request({
url: '/api/blade-martial/judge-project/remove',
method: 'post',
params: { ids }
})
}
/**
* 批量分配裁判
* @param {Object} data - 批量分配参数
* @param {Number} data.competitionId - 赛事ID
* @param {Array} data.assignments - 分配信息数组
* @param {Number} data.assignments[].judgeId - 裁判ID
* @param {Number} data.assignments[].projectId - 项目ID
* @param {String} data.assignments[].role - 角色
*/
export const batchAssignJudges = (data) => {
return request({
url: '/api/blade-martial/judge-project/batch-assign',
method: 'post',
data
})
}
/**
* 自动分配裁判
* @param {Object} data - 自动分配参数
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.projectId - 项目ID（可选）
* @param {String} data.strategy - 分配策略（balance负载均衡/level按等级）
*/
export const autoAssignJudges = (data) => {
return request({
url: '/api/blade-martial/judge-project/auto-assign',
method: 'post',
data
})
}
/**
* 获取项目的裁判列表
* @param {Number} projectId - 项目ID
*/
export const getJudgesByProject = (projectId) => {
return request({
url: '/api/blade-martial/judge-project/judges-by-project',
method: 'get',
params: { projectId }
})
}
/**
* 获取裁判的项目列表
* @param {Number} judgeId - 裁判ID
* @param {Number} competitionId - 赛事ID
*/
export const getProjectsByJudge = (judgeId, competitionId) => {
return request({
url: '/api/blade-martial/judge-project/projects-by-judge',
method: 'get',
params: { judgeId, competitionId }
})
}
/**
* 获取裁判工作量统计
* @param {Number} competitionId - 赛事ID
*/
export const getJudgeWorkload = (competitionId) => {
return request({
url: '/api/blade-martial/judge-project/workload',
method: 'get',
params: { competitionId }
})
}
/**
* 检查裁判冲突
* @param {Object} data - 检查参数
* @param {Number} data.judgeId - 裁判ID
* @param {Number} data.projectId - 项目ID
* @param {Number} data.competitionId - 赛事ID
*/
export const checkJudgeConflict = (data) => {
return request({
url: '/api/blade-martial/judge-project/check-conflict',
method: 'post',
data
})
}
/**
* 交换两个裁判的项目分配
* @param {Object} data - 交换参数
* @param {Number} data.assignmentId1 - 分配1的ID
* @param {Number} data.assignmentId2 - 分配2的ID
*/
export const swapJudgeAssignment = (data) => {
return request({
url: '/api/blade-martial/judge-project/swap',
method: 'post',
data
})
}
/**
* 复制分配到其他项目
* @param {Object} data - 复制参数
* @param {Number} data.sourceProjectId - 源项目ID
* @param {Number} data.targetProjectId - 目标项目ID
*/
export const copyAssignment = (data) => {
return request({
url: '/api/blade-martial/judge-project/copy',
method: 'post',
data
})
}
/**
* 获取可分配的裁判列表
* @param {Number} competitionId - 赛事ID
* @param {Number} projectId - 项目ID（可选）
*/
export const getAvailableJudges = (competitionId, projectId) => {
return request({
url: '/api/blade-martial/judge-project/available-judges',
method: 'get',
params: { competitionId, projectId }
})
}
/**
* 获取未分配裁判的项目列表
* @param {Number} competitionId - 赛事ID
*/
export const getUnassignedProjects = (competitionId) => {
return request({
url: '/api/blade-martial/judge-project/unassigned-projects',
method: 'get',
params: { competitionId }
})
}
/**
* 导出裁判分配表
* @param {Object} params - 导出参数
*/
export const exportAssignments = (params) => {
return request({
url: '/api/blade-martial/judge-project/export',
method: 'get',
params,
responseType: 'blob'
})
}
/**
* 导入裁判分配
* @param {Number} competitionId - 赛事ID
* @param {File} file - Excel文件
*/
export const importAssignments = (competitionId, file) => {
const formData = new FormData()
formData.append('competitionId', competitionId)
formData.append('file', file)
return request({
url: '/api/blade-martial/judge-project/import',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}

203
src/api/martial/live.js Normal file
View File

@@ -0,0 +1,203 @@
import request from '@/axios';
// ==================== f/[<5B><><EFBFBD><EFBFBD><06><> ====================
/**
* <20><><EFBFBD><EFBFBD>u<><75>
* @param {Number} current - SMu,ؤ1
* @param {Number} size - <20>uap,ؤ10
* @param {Object} params - <20><><EFBFBD>p
* @param {Number} params.competitionId - [<5B>ID
* @param {String} params.updateType - <20><>{<7B>match[<5B>/result<10>/notice<1A>
* @param {Number} params.projectId - y<>ID<08>
* @param {Number} params.venueId - :0ID<08>
*/
export const getLiveUpdateList = (current, size, params) => {
return request({
url: '/api/blade-martial/live-update/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
* @param {Number} id - <20><>ID
*/
export const getLiveUpdateDetail = (id) => {
return request({
url: '/api/blade-martial/live-update/detail',
method: 'get',
params: { id }
})
}
/**
* <20><03><><EFBFBD><EFBFBD>
* @param {Object} data - <20><><EFBFBD><EFBFBD>pn
* @param {Number} data.competitionId - [<5B>ID
* @param {String} data.title - <07>
* @param {String} data.content - <20><>̇,
* @param {String} data.updateType - <20><>{<7B>
* @param {Number} data.projectId - y<>ID<08>
* @param {Number} data.venueId - :0ID<08>
* @param {Array} data.images - <20>GURLp<4C>
* @param {Array} data.videos - ƑURLp<4C>
* @param {Boolean} data.isTop - /&nv
*/
export const publishLiveUpdate = (data) => {
return request({
url: '/api/blade-martial/live-update/publish',
method: 'post',
data
})
}
/**
* <20>9<EFBFBD><39><EFBFBD><EFBFBD>
* @param {Object} data - <20><><EFBFBD><EFBFBD>pn
*/
export const updateLiveUpdate = (data) => {
return request({
url: '/api/blade-martial/live-update/update',
method: 'post',
data
})
}
/**
* d<><64><EFBFBD><EFBFBD>
* @param {String} ids - <20><>ID,*(<17><06>
*/
export const removeLiveUpdate = (ids) => {
return request({
url: '/api/blade-martial/live-update/remove',
method: 'post',
params: { ids }
})
}
/**
* bnv<6E>
* @param {Number} id - <20><>ID
* @param {Boolean} isTop - /&nv
*/
export const toggleTop = (id, isTop) => {
return request({
url: '/api/blade-martial/live-update/toggle-top',
method: 'post',
data: { id, isTop }
})
}
/**
*
<20><><EFBFBD>G
* @param {File} file - <20>G<EFBFBD><47>
*/
export const uploadLiveImage = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/live-update/upload-image',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
*
<20><>Ƒ
* @param {File} file - Ƒ<><C691>
* @param {Function} onProgress -
ۦ<>
*/
export const uploadLiveVideo = (file, onProgress) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/live-update/upload-video',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
},
onUploadProgress: onProgress
})
}
/**
* y<>
<20>G
* @param {Array} files - <20>G<EFBFBD><47>p<EFBFBD>
*/
export const batchUploadImages = (files) => {
const formData = new FormData()
files.forEach(file => {
formData.append('files', file)
})
return request({
url: '/api/blade-martial/live-update/batch-upload-images',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* <20><><EFBFBD><EFBFBD>ߡpn
* @param {Number} competitionId - [<5B>ID
*/
export const getLiveStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/live-update/statistics',
method: 'get',
params: { competitionId }
})
}
/**
* <20>^<5E><><EFBFBD><EFBFBD>
* @param {Number} id - <20><>ID
*/
export const likeLiveUpdate = (id) => {
return request({
url: '/api/blade-martial/live-update/like',
method: 'post',
data: { id }
})
}
/**
* ֈ<>^
* @param {Number} id - <20><>ID
*/
export const unlikeLiveUpdate = (id) => {
return request({
url: '/api/blade-martial/live-update/unlike',
method: 'post',
data: { id }
})
}
/**
* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
* @param {Number} competitionId - [<5B>ID
* @param {Number} limit - p<>P6
*/
export const getHotLiveUpdates = (competitionId, limit = 10) => {
return request({
url: '/api/blade-martial/live-update/hot',
method: 'get',
params: { competitionId, limit }
})
}

221
src/api/martial/liveUpdate.js Normal file
View File

@@ -0,0 +1,221 @@
import request from '@/axios';
// ==================== 武术赛事直播更新管理接口 ====================
/**
* 直播更新分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
* @param {Number} params.venueId - 场地ID（可选）
* @param {Number} params.updateType - 更新类型（可选）
*/
export const getLiveUpdateList = (current, size, params) => {
return request({
url: '/api/blade-martial/liveUpdate/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取直播更新详情
* @param {Number} id - 更新ID
*/
export const getLiveUpdateDetail = (id) => {
return request({
url: '/api/blade-martial/liveUpdate/detail',
method: 'get',
params: { id }
})
}
/**
* 发布直播更新
* @param {Object} data - 更新数据
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.projectId - 项目ID（可选）
* @param {Number} data.venueId - 场地ID（可选）
* @param {Number} data.updateType - 更新类型（1赛况2成绩3通知4其他）
* @param {String} data.title - 标题
* @param {String} data.content - 内容
* @param {Array} data.images - 图片URL数组（可选）
* @param {String} data.videoUrl - 视频URL（可选）
* @param {Number} data.isTop - 是否置顶（0否1是）
*/
export const publishLiveUpdate = (data) => {
return request({
url: '/api/blade-martial/liveUpdate/publish',
method: 'post',
data
})
}
/**
* 修改直播更新
* @param {Object} data - 更新数据
*/
export const updateLiveUpdate = (data) => {
return request({
url: '/api/blade-martial/liveUpdate/update',
method: 'post',
data
})
}
/**
* 删除直播更新
* @param {String} ids - 更新ID,多个用逗号分隔
*/
export const removeLiveUpdate = (ids) => {
return request({
url: '/api/blade-martial/liveUpdate/remove',
method: 'post',
params: { ids }
})
}
/**
* 批量发布直播更新
* @param {Array} data - 更新数据数组
*/
export const batchPublishLiveUpdates = (data) => {
return request({
url: '/api/blade-martial/liveUpdate/batch-publish',
method: 'post',
data
})
}
/**
* 置顶/取消置顶直播更新
* @param {Number} id - 更新ID
* @param {Number} isTop - 是否置顶（0否1是）
*/
export const toggleTop = (id, isTop) => {
return request({
url: '/api/blade-martial/liveUpdate/toggle-top',
method: 'post',
params: { id, isTop }
})
}
/**
* 获取最新直播更新列表（不分页）
* @param {Number} competitionId - 赛事ID
* @param {Number} limit - 获取数量（默认10）
*/
export const getLatestUpdates = (competitionId, limit = 10) => {
return request({
url: '/api/blade-martial/liveUpdate/latest',
method: 'get',
params: { competitionId, limit }
})
}
/**
* 获取置顶直播更新列表
* @param {Number} competitionId - 赛事ID
*/
export const getTopUpdates = (competitionId) => {
return request({
url: '/api/blade-martial/liveUpdate/top-updates',
method: 'get',
params: { competitionId }
})
}
/**
* 获取项目的直播更新
* @param {Number} projectId - 项目ID
* @param {Number} limit - 获取数量（默认20）
*/
export const getProjectUpdates = (projectId, limit = 20) => {
return request({
url: '/api/blade-martial/liveUpdate/project-updates',
method: 'get',
params: { projectId, limit }
})
}
/**
* 获取场地的直播更新
* @param {Number} venueId - 场地ID
* @param {Number} limit - 获取数量（默认20）
*/
export const getVenueUpdates = (venueId, limit = 20) => {
return request({
url: '/api/blade-martial/liveUpdate/venue-updates',
method: 'get',
params: { venueId, limit }
})
}
/**
* 搜索直播更新
* @param {Object} params - 搜索参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.keyword - 关键词
* @param {Number} params.updateType - 更新类型（可选）
* @param {String} params.startTime - 开始时间（可选）
* @param {String} params.endTime - 结束时间（可选）
*/
export const searchLiveUpdates = (params) => {
return request({
url: '/api/blade-martial/liveUpdate/search',
method: 'get',
params
})
}
/**
* 上传直播图片
* @param {File} file - 图片文件
*/
export const uploadLiveImage = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/liveUpdate/upload-image',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 上传直播视频
* @param {File} file - 视频文件
*/
export const uploadLiveVideo = (file) => {
const formData = new FormData()
formData.append('file', file)
return request({
url: '/api/blade-martial/liveUpdate/upload-video',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 获取直播统计
* @param {Number} competitionId - 赛事ID
*/
export const getLiveStatistics = (competitionId) => {
return request({
url: '/api/blade-martial/liveUpdate/statistics',
method: 'get',
params: { competitionId }
})
}

138
src/api/martial/project.js Normal file
View File

@@ -0,0 +1,138 @@
import request from '@/axios';
// ==================== 武术赛事项目管理接口 ====================
/**
* 项目分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {String} params.projectName - 项目名称(可选)
* @param {String} params.category - 分组类别(可选)
* @param {String} params.eventType - 项目类型(可选)
*/
export const getProjectList = (current, size, params) => {
return request({
url: '/api/blade-martial/project/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取项目详情
* @param {Number} id - 项目ID
*/
export const getProjectDetail = (id) => {
return request({
url: '/api/blade-martial/project/detail',
method: 'get',
params: { id }
})
}
/**
* 新增项目
* @param {Object} data - 项目数据
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.projectName - 项目名称
* @param {String} data.projectCode - 项目编码
* @param {String} data.category - 分组类别（男子、女子、团体）
* @param {String} data.eventType - 项目类型（套路、散打等）
* @param {Number} data.registrationFee - 报名费
* @param {String} data.registrationStartTime - 报名开始时间
* @param {String} data.registrationEndTime - 报名结束时间
* @param {Number} data.maxParticipants - 最大参赛人数
* @param {String} data.rules - 比赛规则
*/
export const addProject = (data) => {
return request({
url: '/api/blade-martial/project/save',
method: 'post',
data
})
}
/**
* 修改项目
* @param {Object} data - 项目数据
*/
export const updateProject = (data) => {
return request({
url: '/api/blade-martial/project/update',
method: 'post',
data
})
}
/**
* 删除项目
* @param {String} ids - 项目ID,多个用逗号分隔
*/
export const removeProject = (ids) => {
return request({
url: '/api/blade-martial/project/remove',
method: 'post',
params: { ids }
})
}
/**
* 获取赛事的项目列表（不分页）
* @param {Number} competitionId - 赛事ID
*/
export const getProjectsByCompetition = (competitionId) => {
return request({
url: '/api/blade-martial/project/list-by-competition',
method: 'get',
params: { competitionId }
})
}
/**
* 批量导入项目
* @param {Number} competitionId - 赛事ID
* @param {File} file - Excel文件
*/
export const importProjects = (competitionId, file) => {
const formData = new FormData()
formData.append('competitionId', competitionId)
formData.append('file', file)
return request({
url: '/api/blade-martial/project/import',
method: 'post',
data: formData,
headers: {
'Content-Type': 'multipart/form-data'
}
})
}
/**
* 导出项目模板
*/
export const exportProjectTemplate = () => {
return request({
url: '/api/blade-martial/project/export-template',
method: 'get',
responseType: 'blob'
})
}
/**
* 导出项目列表
* @param {Object} params - 查询参数
*/
export const exportProjects = (params) => {
return request({
url: '/api/blade-martial/project/export',
method: 'get',
params,
responseType: 'blob'
})
}

234
src/api/martial/result.js Normal file
View File

@@ -0,0 +1,234 @@
import request from '@/axios';
// ==================== 武术赛事成绩管理接口 ====================
/**
* 成绩分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
* @param {Number} params.athleteId - 运动员ID（可选）
* @param {String} params.playerName - 运动员姓名（可选）
* @param {String} params.teamName - 团队名称（可选）
* @param {Number} params.isFinal - 是否最终成绩（可选）
*/
export const getResultList = (current, size, params) => {
return request({
url: '/api/blade-martial/result/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取成绩详情
* @param {Number} id - 成绩ID
*/
export const getResultDetail = (id) => {
return request({
url: '/api/blade-martial/result/detail',
method: 'get',
params: { id }
})
}
/**
* 新增成绩
* @param {Object} data - 成绩数据
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.athleteId - 运动员ID
* @param {Number} data.projectId - 项目ID
* @param {Number} data.venueId - 场地ID
* @param {String} data.playerName - 运动员姓名
* @param {String} data.teamName - 团队名称
* @param {Number} data.totalScore - 总分
* @param {Number} data.difficultyCoefficient - 难度系数
* @param {Number} data.finalScore - 最终成绩
*/
export const addResult = (data) => {
return request({
url: '/api/blade-martial/result/save',
method: 'post',
data
})
}
/**
* 修改成绩
* @param {Object} data - 成绩数据
*/
export const updateResult = (data) => {
return request({
url: '/api/blade-martial/result/update',
method: 'post',
data
})
}
/**
* 删除成绩
* @param {String} ids - 成绩ID,多个用逗号分隔
*/
export const removeResult = (ids) => {
return request({
url: '/api/blade-martial/result/remove',
method: 'post',
params: { ids }
})
}
// ==================== 成绩高级功能接口 ====================
/**
* 计算成绩
* @param {Object} data - 计算参数
* @param {Number} data.athleteId - 运动员ID
* @param {Number} data.projectId - 项目ID
* @param {Number} data.competitionId - 赛事ID
* @param {Boolean} data.autoRanking - 是否自动排名（可选）
*/
export const calculateResult = (data) => {
return request({
url: '/api/blade-martial/result/calculate',
method: 'post',
data
})
}
/**
* 批量计算成绩
* @param {Object} data - 计算参数
* @param {Number} data.projectId - 项目ID
* @param {Number} data.competitionId - 赛事ID
* @param {Array} data.athleteIds - 运动员ID数组（可选，为空时计算所有）
*/
export const batchCalculateResults = (data) => {
return request({
url: '/api/blade-martial/result/batch-calculate',
method: 'post',
data
})
}
/**
* 自动排名
* @param {Object} data - 排名参数
* @param {Number} data.projectId - 项目ID
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.category - 分组类别（可选）
*/
export const autoRanking = (data) => {
return request({
url: '/api/blade-martial/result/ranking',
method: 'post',
data
})
}
/**
* 分配奖牌
* @param {Object} data - 奖牌分配参数
* @param {Number} data.projectId - 项目ID
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.goldCount - 金牌数量
* @param {Number} data.silverCount - 银牌数量
* @param {Number} data.bronzeCount - 铜牌数量
*/
export const allocateMedals = (data) => {
return request({
url: '/api/blade-martial/result/medals',
method: 'post',
data
})
}
/**
* 成绩复核
* @param {Object} data - 复核参数
* @param {Number} data.resultId - 成绩ID
* @param {String} data.reviewNote - 复核说明
* @param {Number} data.reviewStatus - 复核状态（1通过2驳回）
*/
export const reviewResult = (data) => {
return request({
url: '/api/blade-martial/result/review',
method: 'post',
data
})
}
/**
* 发布成绩
* @param {Object} data - 发布参数
* @param {Number} data.projectId - 项目ID（可选）
* @param {Number} data.competitionId - 赛事ID
* @param {Array} data.resultIds - 成绩ID数组（可选）
* @param {Boolean} data.publishAll - 是否发布全部（可选）
*/
export const publishResult = (data) => {
return request({
url: '/api/blade-martial/result/publish',
method: 'post',
data
})
}
/**
* 撤销发布成绩
* @param {Object} data - 撤销参数
* @param {Number} data.projectId - 项目ID（可选）
* @param {Number} data.competitionId - 赛事ID
* @param {Array} data.resultIds - 成绩ID数组（可选）
*/
export const unpublishResult = (data) => {
return request({
url: '/api/blade-martial/result/unpublish',
method: 'post',
data
})
}
/**
* 获取项目成绩统计
* @param {Number} projectId - 项目ID
* @param {Number} competitionId - 赛事ID
*/
export const getResultStatistics = (projectId, competitionId) => {
return request({
url: '/api/blade-martial/result/statistics',
method: 'get',
params: { projectId, competitionId }
})
}
/**
* 获取奖牌榜
* @param {Number} competitionId - 赛事ID
* @param {String} groupBy - 分组方式（team团队/region地区）
*/
export const getMedalRanking = (competitionId, groupBy = 'team') => {
return request({
url: '/api/blade-martial/result/medal-ranking',
method: 'get',
params: { competitionId, groupBy }
})
}
/**
* 导出成绩单
* @param {Object} params - 查询参数
*/
export const exportResults = (params) => {
return request({
url: '/api/blade-martial/result/export',
method: 'get',
params,
responseType: 'blob'
})
}

239
src/api/martial/scheduleAthlete.js Normal file
View File

@@ -0,0 +1,239 @@
import request from '@/axios';
// ==================== 武术赛事赛程选手关联管理接口 ====================
/**
* 赛程选手关联分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.scheduleId - 赛程ID
* @param {Number} params.schedulePlanId - 赛程计划ID（可选）
* @param {Number} params.athleteId - 运动员ID（可选）
* @param {Number} params.status - 状态（可选）
*/
export const getScheduleAthleteList = (current, size, params) => {
return request({
url: '/api/blade-martial/scheduleAthlete/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取赛程选手关联详情
* @param {Number} id - 关联ID
*/
export const getScheduleAthleteDetail = (id) => {
return request({
url: '/api/blade-martial/scheduleAthlete/detail',
method: 'get',
params: { id }
})
}
/**
* 新增赛程选手关联
* @param {Object} data - 关联数据
* @param {Number} data.scheduleId - 赛程ID
* @param {Number} data.schedulePlanId - 赛程计划ID
* @param {Number} data.athleteId - 运动员ID
* @param {String} data.athleteName - 运动员姓名
* @param {Number} data.competitionOrder - 出场顺序
* @param {Number} data.status - 状态（0待出场1进行中2已完成）
*/
export const addScheduleAthlete = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/save',
method: 'post',
data
})
}
/**
* 修改赛程选手关联
* @param {Object} data - 关联数据
*/
export const updateScheduleAthlete = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/update',
method: 'post',
data
})
}
/**
* 删除赛程选手关联
* @param {String} ids - 关联ID,多个用逗号分隔
*/
export const removeScheduleAthlete = (ids) => {
return request({
url: '/api/blade-martial/scheduleAthlete/remove',
method: 'post',
params: { ids }
})
}
/**
* 批量添加赛程选手
* @param {Object} data - 批量添加参数
* @param {Number} data.schedulePlanId - 赛程计划ID
* @param {Array} data.athleteIds - 运动员ID数组
* @param {Boolean} data.autoOrder - 是否自动排序（默认true）
*/
export const batchAddScheduleAthletes = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/batch-save',
method: 'post',
data
})
}
/**
* 自动分配选手到赛程
* @param {Object} data - 分配参数
* @param {Number} data.scheduleId - 赛程ID
* @param {Number} data.projectId - 项目ID
* @param {String} data.allocateStrategy - 分配策略（random随机/order顺序）
*/
export const autoAllocateAthletes = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/auto-allocate',
method: 'post',
data
})
}
/**
* 调整选手出场顺序
* @param {Object} data - 调整参数
* @param {Number} data.id - 关联ID
* @param {Number} data.targetOrder - 目标顺序
*/
export const adjustAthleteOrder = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/adjust-order',
method: 'post',
data
})
}
/**
* 交换两个选手的出场顺序
* @param {Object} data - 交换参数
* @param {Number} data.athleteId1 - 选手1的关联ID
* @param {Number} data.athleteId2 - 选手2的关联ID
*/
export const swapAthleteOrder = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/swap-order',
method: 'post',
data
})
}
/**
* 随机排序选手出场顺序
* @param {Number} schedulePlanId - 赛程计划ID
*/
export const randomizeAthleteOrder = (schedulePlanId) => {
return request({
url: '/api/blade-martial/scheduleAthlete/randomize',
method: 'post',
params: { schedulePlanId }
})
}
/**
* 更新选手状态
* @param {Object} data - 状态更新参数
* @param {Number} data.id - 关联ID
* @param {Number} data.status - 状态（0待出场1进行中2已完成）
*/
export const updateAthleteStatus = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/update-status',
method: 'post',
data
})
}
/**
* 获取赛程计划的选手列表（不分页）
* @param {Number} schedulePlanId - 赛程计划ID
*/
export const getAthletesBySchedulePlan = (schedulePlanId) => {
return request({
url: '/api/blade-martial/scheduleAthlete/list-by-plan',
method: 'get',
params: { schedulePlanId }
})
}
/**
* 获取运动员的赛程安排
* @param {Number} athleteId - 运动员ID
* @param {Number} competitionId - 赛事ID
*/
export const getAthleteSchedules = (athleteId, competitionId) => {
return request({
url: '/api/blade-martial/scheduleAthlete/athlete-schedules',
method: 'get',
params: { athleteId, competitionId }
})
}
/**
* 检查选手时间冲突
* @param {Object} data - 检查参数
* @param {Number} data.athleteId - 运动员ID
* @param {Number} data.schedulePlanId - 赛程计划ID
*/
export const checkAthleteConflict = (data) => {
return request({
url: '/api/blade-martial/scheduleAthlete/check-conflict',
method: 'post',
data
})
}
/**
* 签到选手
* @param {Number} id - 关联ID
*/
export const checkInAthlete = (id) => {
return request({
url: '/api/blade-martial/scheduleAthlete/check-in',
method: 'post',
params: { id }
})
}
/**
* 批量签到选手
* @param {Array} ids - 关联ID数组
*/
export const batchCheckInAthletes = (ids) => {
return request({
url: '/api/blade-martial/scheduleAthlete/batch-check-in',
method: 'post',
data: ids
})
}
/**
* 导出赛程选手名单
* @param {Object} params - 导出参数
*/
export const exportScheduleAthletes = (params) => {
return request({
url: '/api/blade-martial/scheduleAthlete/export',
method: 'get',
params,
responseType: 'blob'
})
}

196
src/api/martial/schedulePlan.js Normal file
View File

@@ -0,0 +1,196 @@
import request from '@/axios';
// ==================== 武术赛事赛程计划管理接口 ====================
/**
* 赛程计划分页查询
* @param {Number} current - 当前页,默认1
* @param {Number} size - 每页条数,默认10
* @param {Object} params - 查询参数
* @param {Number} params.scheduleId - 赛程ID
* @param {Number} params.venueId - 场地ID（可选）
* @param {Number} params.projectId - 项目ID（可选）
* @param {String} params.planDate - 计划日期（可选）
*/
export const getSchedulePlanList = (current, size, params) => {
return request({
url: '/api/blade-martial/schedule-plan/list',
method: 'get',
params: {
current,
size,
...params
}
})
}
/**
* 获取赛程计划详情
* @param {Number} id - 赛程计划ID
*/
export const getSchedulePlanDetail = (id) => {
return request({
url: '/api/blade-martial/schedule-plan/detail',
method: 'get',
params: { id }
})
}
/**
* 新增赛程计划
* @param {Object} data - 赛程计划数据
* @param {Number} data.scheduleId - 赛程ID
* @param {String} data.planDate - 计划日期
* @param {String} data.startTime - 开始时间
* @param {String} data.endTime - 结束时间
* @param {Number} data.venueId - 场地ID
* @param {String} data.venueName - 场地名称
* @param {Number} data.projectId - 项目ID
* @param {String} data.projectName - 项目名称
* @param {Number} data.planOrder - 计划顺序
*/
export const addSchedulePlan = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/save',
method: 'post',
data
})
}
/**
* 修改赛程计划
* @param {Object} data - 赛程计划数据
*/
export const updateSchedulePlan = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/update',
method: 'post',
data
})
}
/**
* 删除赛程计划
* @param {String} ids - 赛程计划ID,多个用逗号分隔
*/
export const removeSchedulePlan = (ids) => {
return request({
url: '/api/blade-martial/schedule-plan/remove',
method: 'post',
params: { ids }
})
}
/**
* 批量添加赛程计划
* @param {Array} data - 赛程计划数据数组
*/
export const batchAddSchedulePlans = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/batch-save',
method: 'post',
data
})
}
/**
* 自动编排赛程
* @param {Object} data - 编排参数
* @param {Number} data.scheduleId - 赛程ID
* @param {Number} data.competitionId - 赛事ID
* @param {String} data.startDate - 开始日期
* @param {String} data.endDate - 结束日期
* @param {Array} data.venueIds - 场地ID数组
* @param {Array} data.projectIds - 项目ID数组
*/
export const autoArrangeSchedule = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/auto-arrange',
method: 'post',
data
})
}
/**
* 调整赛程计划顺序
* @param {Object} data - 调整参数
* @param {Number} data.id - 赛程计划ID
* @param {Number} data.targetOrder - 目标顺序
*/
export const adjustScheduleOrder = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/adjust-order',
method: 'post',
data
})
}
/**
* 获取某日期的赛程计划
* @param {Number} scheduleId - 赛程ID
* @param {String} planDate - 计划日期
*/
export const getSchedulePlansByDate = (scheduleId, planDate) => {
return request({
url: '/api/blade-martial/schedule-plan/list-by-date',
method: 'get',
params: { scheduleId, planDate }
})
}
/**
* 获取某场地的赛程计划
* @param {Number} venueId - 场地ID
* @param {String} planDate - 计划日期（可选）
*/
export const getSchedulePlansByVenue = (venueId, planDate) => {
return request({
url: '/api/blade-martial/schedule-plan/list-by-venue',
method: 'get',
params: { venueId, planDate }
})
}
/**
* 检查时间冲突
* @param {Object} data - 检查参数
* @param {Number} data.venueId - 场地ID
* @param {String} data.planDate - 计划日期
* @param {String} data.startTime - 开始时间
* @param {String} data.endTime - 结束时间
* @param {Number} data.excludeId - 排除的赛程计划ID（编辑时使用）
*/
export const checkTimeConflict = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/check-conflict',
method: 'post',
data
})
}
/**
* 复制赛程计划到其他日期
* @param {Object} data - 复制参数
* @param {Number} data.sourcePlanId - 源赛程计划ID
* @param {String} data.targetDate - 目标日期
*/
export const copySchedulePlan = (data) => {
return request({
url: '/api/blade-martial/schedule-plan/copy',
method: 'post',
data
})
}
/**
* 导出赛程计划
* @param {Object} params - 导出参数
*/
export const exportSchedulePlans = (params) => {
return request({
url: '/api/blade-martial/schedule-plan/export',
method: 'get',
params,
responseType: 'blob'
})
}

91
src/api/martial/score.js
View File

@@ -82,3 +82,94 @@ export const getProjectList = (competitionId, venueId) => {
params: { competitionId, venueId }
})
}
// ==================== 评分提交接口 ====================
/**
* 提交评分
* @param {Object} data - 评分数据
* @param {Number} data.competitionId - 赛事ID
* @param {Number} data.athleteId - 运动员ID
* @param {Number} data.projectId - 项目ID
* @param {Number} data.scheduleId - 赛程ID
* @param {Number} data.venueId - 场地ID
* @param {Number} data.judgeId - 裁判ID
* @param {String} data.judgeName - 裁判姓名
* @param {Number} data.score - 评分
* @param {Number} data.originalScore - 原始分
* @param {Array} data.deductionItems - 扣分项ID数组
* @param {String} data.note - 备注
*/
export const submitScore = (data) => {
return request({
url: '/api/blade-martial/score/submit',
method: 'post',
data
})
}
/**
* 删除评分
* @param {String} ids - 评分ID,多个用逗号分隔
*/
export const removeScore = (ids) => {
return request({
url: '/api/blade-martial/score/remove',
method: 'post',
params: { ids }
})
}
/**
* 获取异常评分列表
* @param {Object} params - 查询参数
* @param {Number} params.competitionId - 赛事ID
* @param {Number} params.projectId - 项目ID（可选）
*/
export const getAnomalies = (params) => {
return request({
url: '/api/blade-martial/score/anomalies',
method: 'get',
params
})
}
/**
* 验证评分
* @param {Object} data - 验证数据
* @param {Number} data.athleteId - 运动员ID
* @param {Number} data.projectId - 项目ID
* @param {Number} data.score - 评分
*/
export const validateScores = (data) => {
return request({
url: '/api/blade-martial/score/validate',
method: 'post',
data
})
}
/**
* 批量提交评分
* @param {Array} data - 评分数据数组
*/
export const batchSubmitScores = (data) => {
return request({
url: '/api/blade-martial/score/batch-submit',
method: 'post',
data
})
}
/**
* 获取裁判待评分列表
* @param {Number} judgeId - 裁判ID
* @param {Number} competitionId - 赛事ID
*/
export const getPendingScores = (judgeId, competitionId) => {
return request({
url: '/api/blade-martial/score/pending',
method: 'get',
params: { judgeId, competitionId }
})
}