fix(web): 修复代码格式和文件清理问题

清理无用文件和资源,调整代码格式统一双引号,修复部分组件路径引用问题

删除大量无用图片资源和组件文件,统一代码风格使用双引号,修复国际化文件路径引用,调整部分组件逻辑,优化项目结构
This commit is contained in:
zhangtao
2026-05-01 01:05:16 +08:00
parent 80263e98e1
commit b7800e2ddd
595 changed files with 24834 additions and 103011 deletions
-29
View File
@@ -1,29 +0,0 @@
import request from '@/utils/http';
/**
* 登录
* @param params 登录参数
* @returns 登录响应
*/
export function fetchLogin(params: Api.Auth.LoginParams) {
return request.post<Api.Auth.LoginResponse>({
url: '/api/auth/login',
params,
// showSuccessMessage: true // 显示成功消息
// showErrorMessage: false // 不显示错误消息
});
}
/**
* 获取用户信息
* @returns 用户信息
*/
export function fetchGetUserInfo() {
return request.get<Api.Auth.UserInfo>({
url: '/api/user/info',
// 自定义请求头
// headers: {
// 'X-Custom-Header': 'your-custom-value'
// }
});
}
+10 -35
View File
@@ -1,12 +1,8 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/ai/chat';
const API_PATH = "/ai/chat";
export const AiChatAPI = {
/**
* 查询会话列表
* @param query 查询参数
*/
getSessionList(query: {
page_no: number;
page_size: number;
@@ -14,70 +10,49 @@ export const AiChatAPI = {
created_at?: string[];
updated_at?: string[];
}) {
return request<PageResult<ChatSession[]>>({
return request<ApiResponse<PageResult<ChatSession[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 创建会话
* @param body 会话信息
*/
createSession(body: { title: string }) {
return request<ApiResponse<ChatSession>>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新会话
* @param id 会话ID
* @param body 会话信息
*/
updateSession(id: string, body: { title: string }) {
return request<ApiResponse<ChatSession>>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除会话
* @param body 会话ID数组
*/
deleteSession(body: string[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 调用AI模型
* @param body 调用参数
*/
chat(body: { message: string; session_id?: string | null }) {
return request<ApiResponse<AiChatResponse>>({
url: `${API_PATH}/ai-chat`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 查询会话详情
* @param sessionId 会话ID
*/
getSessionDetail(sessionId: string) {
return request<ApiResponse<ChatSessionDetail>>({
url: `${API_PATH}/detail/${sessionId}`,
method: 'get',
method: "get",
});
},
};
@@ -1,6 +1,6 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/application/portal';
const API_PATH = "/application/portal";
export const ApplicationAPI = {
/**
@@ -10,7 +10,7 @@ export const ApplicationAPI = {
detailApp(id: number) {
return request<ApiResponse<ApplicationInfo>>({
url: `${API_PATH}/detail/${id}`,
method: 'get',
method: "get",
});
},
@@ -19,9 +19,9 @@ export const ApplicationAPI = {
* @param query 查询参数
*/
listApp(query: ApplicationPageQuery) {
return request<PageResult<ApplicationInfo[]>>({
return request<ApiResponse<PageResult<ApplicationInfo[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
@@ -31,9 +31,9 @@ export const ApplicationAPI = {
* @param body 应用信息
*/
createApp(body: ApplicationForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
@@ -44,9 +44,9 @@ export const ApplicationAPI = {
* @param body 应用信息
*/
updateApp(id: number, body: ApplicationForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
@@ -56,9 +56,9 @@ export const ApplicationAPI = {
* @param body 应用ID数组
*/
deleteApp(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
@@ -68,9 +68,9 @@ export const ApplicationAPI = {
* @param body 批量操作参数
*/
batchApp(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
+22 -58
View File
@@ -1,115 +1,79 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/example/demo';
const API_PATH = "/example/demo";
const DemoAPI = {
/**
* 查询演示列表
* @param query 查询参数
*/
getDemoList(query: DemoPageQuery) {
return request<PageResult<DemoTable[]>>({
return request<ApiResponse<PageResult<DemoTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 查询演示详情
* @param query 演示ID
*/
getDemoDetail(query: number) {
return request<ApiResponse<DemoTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建演示
* @param body 演示信息
*/
createDemo(body: DemoForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新演示
* @param id 演示ID
* @param body 演示信息
*/
updateDemo(id: number, body: DemoForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除演示
* @param body 演示ID数组
*/
deleteDemo(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量操作演示
* @param body 批量操作参数
*/
batchDemo(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出演示
* @param body 导出参数
*/
exportDemo(body: DemoPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
/**
* 下载演示模板
*/
downloadTemplateDemo() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/download/template`,
method: 'post',
responseType: 'blob',
method: "post",
responseType: "blob",
});
},
/**
* 导入演示
* @param body 导入参数
*/
importDemo(body: FormData) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/import`,
method: 'post',
method: "post",
data: body,
headers: {
'Content-Type': 'multipart/form-data',
"Content-Type": "multipart/form-data",
},
});
},
+22 -58
View File
@@ -1,115 +1,79 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/example/demo01';
const API_PATH = "/example/demo01";
const Demo01API = {
/**
* 查询演示列表
* @param query 查询参数
*/
getDemo01List(query: Demo01PageQuery) {
return request<PageResult<Demo01Table[]>>({
return request<ApiResponse<PageResult<Demo01Table[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 查询演示详情
* @param id 演示ID
*/
getDemo01Detail(id: number) {
return request<ApiResponse<Demo01Table>>({
url: `${API_PATH}/detail/${id}`,
method: 'get',
method: "get",
});
},
/**
* 创建演示
* @param body 演示信息
*/
createDemo01(body: Demo01Form) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新演示
* @param id 演示ID
* @param body 演示信息
*/
updateDemo01(id: number, body: Demo01Form) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除演示
* @param body 演示ID列表
*/
deleteDemo01(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置演示状态
* @param body 批量设置参数
*/
batchDemo01(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出演示
* @param body 漼示参数
*/
exportDemo01(body: Demo01PageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
/**
* 下载演示模板
*/
downloadDemo01Template() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/download/template`,
method: 'post',
responseType: 'blob',
method: "post",
responseType: "blob",
});
},
/**
* 导入演示
* @param body 演示数据
*/
importDemo01(body: FormData) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/import`,
method: 'post',
method: "post",
data: body,
headers: {
'Content-Type': 'multipart/form-data',
"Content-Type": "multipart/form-data",
},
});
},
@@ -1,148 +1,109 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/generator/gencode';
const API_PATH = "/generator/gencode";
const GencodeAPI = {
/**
* 查询生成表列表
* @param query 查询参数
* @returns 生成表列表
*/
// 查询生成表数据
listTable(query: GenTablePageQuery) {
return request<PageResult<GenTableSchema[]>>({
return request<ApiResponse<PageResult<GenTableSchema[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 查询db数据库列表
* @param query 查询参数
* @returns db数据库列表
*/
// 查询db数据库列表
listDbTable(query: DBTablePageQuery) {
return request<PageResult<DBTableSchema[]>>({
return request<ApiResponse<PageResult<DBTableSchema[]>>>({
url: `${API_PATH}/db/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 导入表
* @param table_names 表名列表
*/
// 导入表
importTable(table_names: string[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/import`,
method: 'post',
method: "post",
data: table_names,
});
},
/**
* 查询表详细信息
* @param table_id 表ID
*/
// 查询表详细信息
detailTable(table_id: number) {
return request<ApiResponse<GenTableSchema>>({
url: `${API_PATH}/detail/${table_id}`,
method: 'get',
method: "get",
});
},
/**
* 创建表(与后端 GenCreateTableSqlBody 一致)
* @param sql 表SQL语句
*/
// 创建表(与后端 GenCreateTableSqlBody 一致)
createTable(sql: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: { sql },
});
},
/**
* 更新表信息
* @param data 表数据
* @param table_id 表ID
*/
// 更新表信息
updateTable(data: GenTableSchema, table_id: number) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${table_id}`,
method: 'put',
method: "put",
data,
});
},
/**
* 删除表数据
* @param table_ids 表ID列表
*/
// 删除表数据
deleteTable(table_ids: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: table_ids,
});
},
/**
* 批量生成代码
* @param table_names 表名列表
*/
// 批量生成代码
batchGenCode(table_names: string[]) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/batch/output`,
method: 'patch',
method: "patch",
data: table_names,
responseType: 'blob',
responseType: "blob",
});
},
/**
* 生成代码到指定路径
* @param table_name 表名
*/
// 生成代码到指定路径
genCodeToPath(table_name: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/output/${table_name}`,
method: 'post',
method: "post",
});
},
/**
* 预览生成代码
* @param id 表ID
*/
// 预览生成代码
previewTable(id: number) {
return request<Record<string, string>>({
return request<ApiResponse<Record<string, string>>>({
url: `${API_PATH}/preview/${id}`,
method: 'get',
method: "get",
});
},
/**
* 同步数据库
* @param table_name 表名
*/
// 同步数据库
syncDb(table_name: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/sync_db/${table_name}`,
method: 'post',
method: "post",
});
},
/**
* 同步数据库差异预览(不落库)
* @param table_name 表名
*/
// 同步数据库差异预览(不落库)
syncDbPreview(table_name: string) {
return request<ApiResponse<GenSyncPreviewSchema>>({
url: `${API_PATH}/sync_db/preview/${table_name}`,
method: 'get',
method: "get",
});
},
};
+16 -47
View File
@@ -1,85 +1,54 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/monitor/cache';
const API_PATH = "/monitor/cache";
const CacheAPI = {
/**
* 获取缓存信息
* @returns 缓存信息
*/
getCacheInfo() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/info`,
method: 'get',
method: "get",
});
},
/**
* 获取所有缓存名称
* @returns 所有缓存名称
*/
getCacheNames() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/get/names`,
method: 'get',
method: "get",
});
},
/**
* 获取指定缓存名称下的所有键
* @param cacheName 缓存名称
* @returns 所有键
*/
getCacheKeys(cacheName: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/get/keys/${cacheName}`,
method: 'get',
method: "get",
});
},
/**
* 获取指定缓存名称下的指定键的值
* @param cacheName 缓存名称
* @param cacheKey 键
* @returns 值
*/
getCacheValue(cacheName: string, cacheKey: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/get/value/${cacheName}/${cacheKey}`,
method: 'get',
method: "get",
});
},
/**
* 删除指定缓存名称
* @param cacheName 缓存名称
*/
deleteCacheName(cacheName: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete/name/${cacheName}`,
method: 'delete',
method: "delete",
});
},
/**
* 删除指定缓存名称下的指定键
* @param cacheName 缓存名称
* @param cacheKey 键
*/
deleteCacheKey(cacheKey: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete/key/${cacheKey}`,
method: 'delete',
method: "delete",
});
},
/**
* 删除所有缓存
*/
deleteCacheAll() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete/all`,
method: 'delete',
method: "delete",
});
},
};
+11 -19
View File
@@ -1,39 +1,31 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/monitor/online';
const API_PATH = "/monitor/online";
const OnlineAPI = {
/**
* 查询所有在线用户列表
* @returns 所有在线用户列表
*/
// 查询在线用户列表
listOnline(query: OnlineUserPageQuery) {
return request<PageResult<OnlineUserTable[]>>({
return request<ApiResponse<PageResult<OnlineUserTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 强退用户
* @param body 用户会话ID列表
*/
// 强退用户
deleteOnline(body: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 强退所有在线用户
*/
// 强退用户
clearOnline() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/clear`,
method: 'delete',
method: "delete",
});
},
};
+22 -22
View File
@@ -1,6 +1,6 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/monitor/resource';
const API_PATH = "/monitor/resource";
export const ResourceAPI = {
/**
@@ -8,9 +8,9 @@ export const ResourceAPI = {
* @param query 查询参数
*/
listResource(query: ResourcePageQuery) {
return request<PageResult<ResourceItem[]>>({
return request<ApiResponse<PageResult<ResourceItem[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
@@ -22,9 +22,9 @@ export const ResourceAPI = {
uploadFile(formData: FormData) {
return request<ApiResponse<ResourceUploadSchema>>({
url: `${API_PATH}/upload`,
method: 'post',
method: "post",
data: formData,
headers: { 'Content-Type': 'multipart/form-data' },
headers: { "Content-Type": "multipart/form-data" },
});
},
@@ -33,11 +33,11 @@ export const ResourceAPI = {
* @param path 文件路径
*/
downloadFile(path: string) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/download`,
method: 'get',
method: "get",
params: { path },
responseType: 'blob',
responseType: "blob",
});
},
@@ -46,9 +46,9 @@ export const ResourceAPI = {
* @param body 文件路径数组
*/
deleteResource(body: string[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
@@ -58,9 +58,9 @@ export const ResourceAPI = {
* @param body 移动参数
*/
moveResource(body: ResourceMoveQuery) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/move`,
method: 'post',
method: "post",
data: body,
});
},
@@ -70,9 +70,9 @@ export const ResourceAPI = {
* @param body 复制参数
*/
copyResource(body: ResourceCopyQuery) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/copy`,
method: 'post',
method: "post",
data: body,
});
},
@@ -82,9 +82,9 @@ export const ResourceAPI = {
* @param body 重命名参数
*/
renameResource(body: ResourceRenameQuery) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/rename`,
method: 'post',
method: "post",
data: body,
});
},
@@ -94,9 +94,9 @@ export const ResourceAPI = {
* @param body 创建目录参数
*/
createDirectory(body: ResourceCreateDirQuery) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create-dir`,
method: 'post',
method: "post",
data: body,
});
},
@@ -106,11 +106,11 @@ export const ResourceAPI = {
* @param body 导出条件
*/
exportResource(body: ResourcePageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
};
@@ -1,16 +1,13 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/monitor/server';
const API_PATH = "/monitor/server";
const ServerAPI = {
/**
* 获取当前服务信息
* @returns 服务信息
*/
// 获取服务信息
getServer() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/info`,
method: 'get',
method: "get",
});
},
};
+14 -43
View File
@@ -1,93 +1,64 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/auth';
const API_PATH = "/system/auth";
const AuthAPI = {
/**
* 登录
* @param body 登录表单数据
* @returns 登录响应
*/
login(body: LoginFormData) {
return request<ApiResponse<LoginResult>>({
url: `${API_PATH}/login`,
method: 'post',
method: "post",
headers: {
'Content-Type': 'multipart/form-data',
"Content-Type": "multipart/form-data",
},
data: body,
});
},
/**
* 刷新令牌
* @param body 刷新令牌请求体
* @returns 刷新响应
*/
refreshToken(body: RefreshToekenBody) {
return request<ApiResponse<LoginResult>>({
url: `${API_PATH}/token/refresh`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 获取验证码
* @returns 验证码信息
*/
getCaptcha() {
return request<ApiResponse<CaptchaInfo>>({
url: `${API_PATH}/captcha/get`,
method: 'get',
method: "get",
});
},
/**
* 退出登录
* @param body 退出登录操作
*/
logout(body: LogoutBody) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/logout`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 获取免登录用户列表
* @returns 免登录用户列表
*/
/** 获取免登录用户列表 */
getAutoLoginUsers() {
return request<ApiResponse<AutoLoginUser[]>>({
url: `${API_PATH}/auto-login/users`,
method: 'get',
method: "get",
});
},
/**
* 获取免登录Token
* @param userId 用户ID
* @returns 免登录Token响应
*/
/** 获取免登录Token */
getAutoLoginToken(userId: number) {
return request<ApiResponse<AutoLoginToken>>({
url: `${API_PATH}/auto-login/token`,
method: 'post',
method: "post",
params: { user_id: userId },
});
},
/**
* 免登录
* @param token 免登录Token
* @returns 登录响应
*/
/** 免登录 */
autoLogin(token: string) {
return request<ApiResponse<LoginResult>>({
url: `${API_PATH}/auto-login`,
method: 'post',
method: "post",
params: { token },
});
},
+12 -39
View File
@@ -1,78 +1,51 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/dept';
const API_PATH = "/system/dept";
const DeptAPI = {
/**
* 获取部门树
* @param query 查询参数
* @returns 部门树
*/
listDept(query?: DeptPageQuery) {
return request<ApiResponse<DeptTable[]>>({
url: `${API_PATH}/tree`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取部门详情
* @param query 部门ID
* @returns 部门详情
*/
detailDept(query: number) {
return request<ApiResponse<DeptTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建部门
* @param body 部门信息
*/
createDept(body: DeptForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新部门
* @param id 部门ID
* @param body 部门信息
*/
updateDept(id: number, body: DeptForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除部门
* @param body 部门ID列表
*/
deleteDept(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置部门状态
* @param body 批量设置部门状态请求体
*/
batchDept(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
+34 -107
View File
@@ -1,204 +1,131 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/dict';
const API_PATH = "/system/dict";
const DictAPI = {
/**
* 获取字典类型列表
* @param query 查询参数
* @returns 字典类型列表
*/
listDictType(query: DictPageQuery) {
return request<PageResult<DictTable[]>>({
return request<ApiResponse<PageResult<DictTable[]>>>({
url: `${API_PATH}/type/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取字典类型选项选择列表
* @returns 字典类型选项选择列表
*/
optionDictType() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/type/optionselect`,
method: 'get',
method: "get",
});
},
/**
* 获取字典类型详情
* @param query 字典类型ID
* @returns 字典类型详情
*/
detailDictType(query: number) {
return request<ApiResponse<DictTable>>({
url: `${API_PATH}/type/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建字典类型
* @param body 字典类型信息
*/
createDictType(body: DictForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/type/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新字典类型
* @param id 字典类型ID
* @param body 字典类型信息
*/
updateDictType(id: number, body: DictForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/type/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除字典类型
* @param body 字典类型ID列表
*/
deleteDictType(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/type/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置字典类型状态
* @param body 批量设置字典类型状态请求体
*/
batchDictType(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/type/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出字典类型
* @param body 查询参数
* @returns 字典类型导出文件
*/
exportDictType(body: DictPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/type/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
/**
* 获取字典数据列表
* @param query 查询参数
* @returns 字典数据列表
*/
listDictData(query: DictDataPageQuery) {
return request<PageResult<DictDataTable[]>>({
return request<ApiResponse<PageResult<DictDataTable[]>>>({
url: `${API_PATH}/data/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取字典数据详情
* @param query 字典数据ID
* @returns 字典数据详情
*/
detailDictData(query: number) {
return request<ApiResponse<DictDataTable>>({
url: `${API_PATH}/data/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建字典数据
* @param body 字典数据信息
*/
createDictData(body: DictDataForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/data/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新字典数据
* @param id 字典数据ID
* @param body 字典数据信息
*/
updateDictData(id: number, body: DictDataForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/data/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除字典数据
* @param body 字典数据ID列表
*/
deleteDictData(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/data/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置字典数据状态
* @param body 批量设置字典数据状态请求体
*/
batchDictData(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/data/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出字典数据
* @param body 查询参数
* @returns 字典数据导出文件
*/
exportDictData(body: DictDataPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/data/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
/**
* 获取初始化字典数据
* @param dict_type 字典类型
* @returns 初始化字典数据
*/
getInitDict(dict_type: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/data/info/${dict_type}`,
method: 'get',
method: "get",
});
},
};
+10 -29
View File
@@ -1,56 +1,37 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/log';
const API_PATH = "/system/log";
const LogAPI = {
/**
* 获取日志列表
* @param query 查询参数
* @returns 日志列表
*/
listLog(query: LogPageQuery) {
return request<PageResult<LogTable[]>>({
return request<ApiResponse<PageResult<LogTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取日志详情
* @param query 日志ID
* @returns 日志详情
*/
detailLog(query: number) {
return request<ApiResponse<LogTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 删除日志
* @param body 日志ID列表
*/
deleteLog(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 导出日志
* @param body 查询参数
* @returns 日志导出文件
*/
exportLog(body: LogPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
};
+12 -39
View File
@@ -1,78 +1,51 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/menu';
const API_PATH = "/system/menu";
const MenuAPI = {
/**
* 获取菜单树
* @param query 查询参数
* @returns 菜单树
*/
listMenu(query?: MenuPageQuery) {
return request<ApiResponse<MenuTable[]>>({
url: `${API_PATH}/tree`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取菜单详情
* @param query 菜单ID
* @returns 菜单详情
*/
detailMenu(query: number) {
return request<ApiResponse<MenuTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建菜单
* @param body 菜单信息
*/
createMenu(body: MenuForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新菜单
* @param id 菜单ID
* @param body 菜单信息
*/
updateMenu(id: number, body: MenuForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除菜单
* @param body 菜单ID列表
*/
deleteMenu(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置菜单状态
* @param body 批量操作参数
*/
batchMenu(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
+18 -54
View File
@@ -1,104 +1,68 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/notice';
const API_PATH = "/system/notice";
const NoticeAPI = {
/**
* 获取通知列表
* @param query 查询参数
* @returns 通知列表
*/
listNotice(query: NoticePageQuery) {
return request<PageResult<NoticeTable[]>>({
return request<ApiResponse<PageResult<NoticeTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取可用通知列表
* @returns 通知列表
*/
listNoticeAvailable() {
return request<PageResult<NoticeTable[]>>({
return request<ApiResponse<PageResult<NoticeTable[]>>>({
url: `${API_PATH}/available`,
method: 'get',
method: "get",
});
},
/**
* 获取通知详情
* @param query 通知ID
* @returns 通知详情
*/
detailNotice(query: number) {
return request<ApiResponse<NoticeTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建通知
* @param body 通知信息
*/
createNotice(body: NoticeForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新通知
* @param id 通知ID
* @param body 通知信息
*/
updateNotice(id: number, body: NoticeForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除通知
* @param body 通知ID列表
*/
deleteNotice(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置通知状态
* @param body 批量操作参数
*/
batchNotice(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出通知
* @param body 查询参数
* @returns 通知导出文件
*/
exportNotice(body: NoticePageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
};
+17 -54
View File
@@ -1,106 +1,69 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/param';
const API_PATH = "/system/param";
const ParamsAPI = {
/**
* 上传文件
* @param body 文件数据
* @returns 上传后的文件路径
*/
uploadFile(body: any) {
return request<ApiResponse<UploadFilePath>>({
url: `${API_PATH}/upload`,
method: 'post',
method: "post",
data: body,
headers: { 'Content-Type': 'multipart/form-data' },
headers: { "Content-Type": "multipart/form-data" },
});
},
/**
* 获取初始化配置
* @returns 初始化配置列表
*/
getInitConfig() {
return request<ApiResponse<ConfigTable[]>>({
url: `${API_PATH}/info`,
method: 'get',
method: "get",
});
},
/**
* 获取参数列表
* @param query 查询参数
* @returns 参数列表
*/
listParams(query: ConfigPageQuery) {
return request<PageResult<ConfigTable[]>>({
return request<ApiResponse<PageResult<ConfigTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取参数详情
* @param query 参数ID
* @returns 参数详情
*/
detailParams(query: number) {
return request<ApiResponse<ConfigTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建参数
* @param body 参数信息
*/
createParams(body: ConfigForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新参数
* @param id 参数ID
* @param body 参数信息
*/
updateParams(id: number, body: ConfigForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除参数
* @param body 参数ID列表
*/
deleteParams(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 导出参数
* @param body 查询参数
* @returns 导出的参数文件
*/
exportParams(body: ConfigPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
};
+16 -48
View File
@@ -1,93 +1,61 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/position';
const API_PATH = "/system/position";
const PositionAPI = {
/**
* 获取岗位列表
* @param query 查询参数
* @returns 岗位列表
*/
listPosition(query?: PositionPageQuery) {
return request<PageResult<PositionTable[]>>({
return request<ApiResponse<PageResult<PositionTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取岗位详情
* @param query 岗位ID
* @returns 岗位详情
*/
detailPosition(query: number) {
return request<ApiResponse<PositionTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建岗位
* @param body 岗位信息
*/
createPosition(body: PositionForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新岗位
* @param id 岗位ID
* @param body 岗位信息
*/
updatePosition(id: number, body: PositionForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除岗位
* @param body 岗位ID列表
*/
deletePosition(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置岗位状态
* @param body 批量操作参数
*/
batchPosition(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出岗位
* @param body 查询参数
* @returns 导出的岗位文件
*/
exportPosition(body: PositionPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
};
+21 -57
View File
@@ -1,105 +1,69 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/role';
const API_PATH = "/system/role";
const RoleAPI = {
/**
* 获取角色列表
* @param query 查询参数
* @returns 角色列表
*/
listRole(query?: TablePageQuery) {
return request<PageResult<RoleTable[]>>({
return request<ApiResponse<PageResult<RoleTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取角色详情
* @param query 角色ID
* @returns 角色详情
*/
detailRole(query: number) {
return request<ApiResponse<RoleTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建角色
* @param body 角色信息
*/
createRole(body: RoleForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新角色
* @param id 角色ID
* @param body 角色信息
*/
updateRole(id: number, body: RoleForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除角色
* @param body 角色ID列表
*/
deleteRole(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置角色状态
* @param body 批量操作参数
*/
batchRole(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 批量设置角色权限
* @param body 批量操作参数
*/
setPermission(body: permissionDataType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/permission/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出角色列表
* @param body 查询参数
* @returns 导出的文件
*/
exportRole(body: TablePageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
};
@@ -131,9 +95,9 @@ export interface RoleForm extends BaseFormType {
export interface permissionDataType {
data_scope: number;
role_ids: RoleTable['id'][];
menu_ids: permissionMenuType['id'][];
dept_ids: permissionDeptType['id'][];
role_ids: RoleTable["id"][];
menu_ids: permissionMenuType["id"][];
dept_ids: permissionDeptType["id"][];
}
export interface permissionDeptType {
+13 -40
View File
@@ -1,78 +1,51 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/system/tenant';
const API_PATH = "/system/tenant";
const TenantAPI = {
/**
* 获取租户列表
* @param query 查询参数
* @returns 租户列表
*/
listTenant(query?: TenantPageQuery) {
return request<PageResult<TenantTable[]>>({
return request<ApiResponse<PageResult<TenantTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取租户详情
* @param id 租户ID
* @returns 租户详情
*/
detailTenant(id: number) {
return request<ApiResponse<TenantTable>>({
url: `${API_PATH}/detail/${id}`,
method: 'get',
method: "get",
});
},
/**
* 创建租户
* @param body 租户信息
*/
createTenant(body: TenantCreateForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新租户
* @param id 租户ID
* @param body 租户信息
*/
updateTenant(id: number, body: TenantUpdateForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除租户
* @param body 租户ID列表
*/
deleteTenant(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置租户状态
* @param body 批量操作参数
*/
batchTenant(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
+41 -119
View File
@@ -1,214 +1,136 @@
import request from '@/utils/http';
import { MenuTable, MenuForm } from '@/api/module_system/menu';
import request from "@/utils/request";
import { MenuTable, MenuForm } from "@/api/module_system/menu";
const API_PATH = '/system/user';
const API_PATH = "/system/user";
export const UserAPI = {
/**
* 获取当前用户信息
* @returns 当前用户信息
*/
getCurrentUserInfo() {
return request<ApiResponse<UserInfo>>({
url: `${API_PATH}/current/info`,
method: 'get',
method: "get",
});
},
/**
* 上传当前用户头像
* @param body 头像文件
* @returns 上传后的文件路径
*/
uploadCurrentUserAvatar(body: any) {
return request<ApiResponse<UploadFilePath>>({
url: `${API_PATH}/current/avatar/upload`,
method: 'post',
method: "post",
data: body,
headers: { 'Content-Type': 'multipart/form-data' },
headers: { "Content-Type": "multipart/form-data" },
});
},
/**
* 更新当前用户信息
* @param body 用户信息
* @returns 更新后的用户信息
*/
updateCurrentUserInfo(body: InfoFormState) {
return request<ApiResponse<UserInfo>>({
url: `${API_PATH}/current/info/update`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 更新当前用户密码
* @param body 密码信息
* @returns 更新后的用户信息
*/
changeCurrentUserPassword(body: PasswordFormState) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/current/password/change`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 重置用户密码
* @param body 重置密码信息
* @returns 重置密码后的用户信息
*/
resetUserPassword(body: ResetPasswordForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/reset/password`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 注册用户
* @param body 注册信息
* @returns 注册后的用户信息
*/
registerUser(body: RegisterForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/register`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 忘记密码
* @param body 忘记密码信息
* @returns 忘记密码后的用户信息
*/
forgetPassword(body: ForgetPasswordForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/forget/password`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 获取用户列表
* @param query 查询参数
* @returns 用户列表
*/
listUser(query: UserPageQuery) {
return request<PageResult<UserInfo[]>>({
return request<ApiResponse<PageResult<UserInfo[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取用户详情
* @param id 用户ID
* @returns 用户详情
*/
detailUser(query: number) {
return request<ApiResponse<UserInfo>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建用户
* @param body 用户信息
* @returns 创建后的用户信息
*/
createUser(body: UserForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新用户
* @param id 用户ID
* @param body 用户信息
* @returns 更新后的用户信息
*/
updateUser(id: number, body: UserForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除用户
* @param body 用户ID列表
*/
deleteUser(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 批量设置用户状态
* @param body 批量设置用户状态信息
* @returns 批量设置用户状态后的用户列表
*/
batchUser(body: BatchType) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/available/setting`,
method: 'patch',
method: "patch",
data: body,
});
},
/**
* 导出用户
* @param body 查询参数
* @returns 导出的用户文件
*/
exportUser(body: UserPageQuery) {
return request<ApiResponse<Blob>>({
return request<Blob>({
url: `${API_PATH}/export`,
method: 'post',
method: "post",
data: body,
responseType: 'blob',
responseType: "blob",
});
},
/**
* 下载用户导入模板
* @returns 导入模板文件
*/
downloadTemplateUser() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/import/template`,
method: 'post',
responseType: 'blob',
method: "post",
responseType: "blob",
});
},
/**
* 导入用户数据
* @param body 导入数据文件
* @returns 导入后的用户列表
*/
importUser(body: any) {
return request<ApiResponse<UserInfo[]>>({
return request<ApiResponse>({
url: `${API_PATH}/import/data`,
method: 'post',
method: "post",
data: body,
headers: {
'Content-Type': 'multipart/form-data',
"Content-Type": "multipart/form-data",
},
});
},
@@ -256,14 +178,14 @@ export interface UserInfo extends BaseType {
password?: string;
menus?: MenuTable[];
dept?: deptTreeType;
dept_id?: deptTreeType['id'];
dept_name?: deptTreeType['name'];
dept_id?: deptTreeType["id"];
dept_name?: deptTreeType["name"];
roles?: roleSelectorType[];
role_names?: roleSelectorType['name'][];
role_ids?: roleSelectorType['id'][];
role_names?: roleSelectorType["name"][];
role_ids?: roleSelectorType["id"][];
positions?: positionSelectorType[];
position_names?: positionSelectorType['name'][];
position_ids?: positionSelectorType['id'][];
position_names?: positionSelectorType["name"][];
position_ids?: positionSelectorType["id"][];
is_superuser?: boolean;
last_login?: string;
created_by?: CommonType;
+29 -90
View File
@@ -1,179 +1,118 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/task/cronjob/job';
const API_PATH = "/task/cronjob/job";
const JobAPI = {
/**
* 获取任务调度器状态
* @returns 任务调度器状态
*/
getSchedulerStatus() {
return request<ApiResponse<SchedulerStatus>>({
url: `${API_PATH}/scheduler/status`,
method: 'get',
method: "get",
});
},
/**
* 获取任务调度器所有任务
* @returns 任务调度器所有任务
*/
getSchedulerJobs() {
return request<ApiResponse<SchedulerJob[]>>({
url: `${API_PATH}/scheduler/jobs`,
method: 'get',
method: "get",
});
},
/**
* 启动任务调度器
*/
startScheduler() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/scheduler/start`,
method: 'post',
method: "post",
});
},
/**
* 暂停任务调度器
*/
pauseScheduler() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/scheduler/pause`,
method: 'post',
method: "post",
});
},
/**
* 恢复任务调度器
*/
resumeScheduler() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/scheduler/resume`,
method: 'post',
method: "post",
});
},
/**
* 关闭任务调度器
*/
shutdownScheduler() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/scheduler/shutdown`,
method: 'post',
method: "post",
});
},
/**
* 清除所有任务
*/
clearAllJobs() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/scheduler/jobs/clear`,
method: 'delete',
method: "delete",
});
},
/**
* 获取任务调度器控制台输出
* @returns 任务调度器控制台输出
*/
getSchedulerConsole() {
return request<ApiResponse<string>>({
url: `${API_PATH}/scheduler/console`,
method: 'get',
method: "get",
});
},
/**
* 同步任务到数据库
* @returns 同步任务到数据库的记录数
*/
syncJobsToDb() {
return request<ApiResponse<number>>({
url: `${API_PATH}/scheduler/sync`,
method: 'post',
method: "post",
});
},
/**
* 暂停任务
* @param jobId 任务ID
*/
pauseJob(jobId: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/task/pause/${jobId}`,
method: 'post',
method: "post",
});
},
/**
* 恢复任务
* @param jobId 任务ID
*/
resumeJob(jobId: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/task/resume/${jobId}`,
method: 'post',
method: "post",
});
},
/**
* 立即运行任务
* @param jobId 任务ID
*/
runJobNow(jobId: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/task/run/${jobId}`,
method: 'post',
method: "post",
});
},
/**
* 删除任务
* @param jobId 任务ID
*/
removeJob(jobId: string) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/task/remove/${jobId}`,
method: 'delete',
method: "delete",
});
},
/**
* 获取任务日志列表
* @param query 查询参数
* @returns 任务日志列表
*/
getJobLogList(query: JobLogPageQuery) {
return request<PageResult<JobLogTable[]>>({
return request<ApiResponse<PageResult<JobLogTable[]>>>({
url: `${API_PATH}/log/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取任务日志详情
* @param id 任务日志ID
* @returns 任务日志详情
*/
getJobLogDetail(id: number) {
return request<ApiResponse<JobLogTable>>({
url: `${API_PATH}/log/detail/${id}`,
method: 'get',
method: "get",
});
},
/**
* 删除任务日志
* @param ids 任务日志ID列表
*/
deleteJobLog(ids: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/log/delete`,
method: 'delete',
method: "delete",
data: ids,
});
},
@@ -1,101 +1,65 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/task/cronjob/node';
const API_PATH = "/task/cronjob/node";
const NodeAPI = {
/**
* 获取节点类型选项
* @returns 节点类型选项
*/
getNodeTypeOptions() {
return request<ApiResponse<NodeType[]>>({
url: `${API_PATH}/options`,
method: 'get',
method: "get",
});
},
/**
* 获取节点列表
* @param query 查询参数
* @returns 节点列表
*/
listNode(query: NodePageQuery) {
return request<PageResult<NodeTable[]>>({
return request<ApiResponse<PageResult<NodeTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取节点详情
* @param id 节点ID
* @returns 节点详情
*/
detailNode(query: number) {
return request<ApiResponse<NodeTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建节点
* @param body 节点信息
*/
createNode(body: NodeForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新节点
* @param id 节点ID
* @param body 节点信息
*/
updateNode(id: number, body: NodeForm) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除节点
* @param body 节点ID列表
*/
deleteNode(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 清空所有节点
*/
clearNode() {
return request({
return request<ApiResponse>({
url: `${API_PATH}/clear`,
method: 'delete',
method: "delete",
});
},
/**
* 执行节点
* @param id 节点ID
* @param params 执行参数
* @returns 执行结果
*/
executeNode(id: number, params: ExecuteNodeParams = { trigger: 'now' }) {
executeNode(id: number, params: ExecuteNodeParams = { trigger: "now" }) {
return request<ApiResponse<ExecuteNodeResult>>({
url: `${API_PATH}/execute/${id}`,
method: 'post',
method: "post",
data: params,
});
},
@@ -112,7 +76,7 @@ export interface NodePageQuery extends PageQuery {
updated_time?: string[];
}
export type TriggerType = 'now' | 'cron' | 'interval' | 'date';
export type TriggerType = "now" | "cron" | "interval" | "date";
export interface ExecuteNodeParams {
trigger: TriggerType;
@@ -1,95 +1,60 @@
import request from '@/utils/http';
import request from "@/utils/request";
const API_PATH = '/task/workflow/definition';
/** 对应后端 `plugin.module_task.workflow.definition` */
const API_PATH = "/task/workflow/definition";
const WorkflowDefinitionAPI = {
/**
* 获取工作流列表
* @param query 查询参数
* @returns 工作流列表
*/
getWorkflowList(query: WorkflowPageQuery) {
return request<PageResult<WorkflowTable[]>>({
return request<ApiResponse<PageResult<WorkflowTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取工作流详情
* @param query 工作流ID
* @returns 工作流详情
*/
getWorkflowDetail(query: number) {
return request<ApiResponse<WorkflowTable>>({
url: `${API_PATH}/detail/${query}`,
method: 'get',
method: "get",
});
},
/**
* 创建工作流
* @param body 工作流信息
* @returns 工作流详情
*/
createWorkflow(body: WorkflowForm) {
return request<ApiResponse<WorkflowTable>>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新工作流
* @param id 工作流ID
* @param body 工作流信息
* @returns 工作流详情
*/
updateWorkflow(id: number, body: WorkflowForm) {
return request<ApiResponse<WorkflowTable>>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除工作流
* @param body 工作流ID列表
*/
deleteWorkflow(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
/**
* 发布工作流
* @param id 工作流ID
* @param body 发布参数
* @returns 工作流详情
*/
publishWorkflow(id: number, body: WorkflowPublishForm) {
return request<ApiResponse<WorkflowTable>>({
url: `${API_PATH}/publish/${id}`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 执行工作流
* @param body 执行参数
* @returns 执行结果
*/
executeWorkflow(body: WorkflowExecuteForm) {
return request<ApiResponse<WorkflowExecuteResult>>({
url: `${API_PATH}/execute`,
method: 'post',
method: "post",
data: body,
});
},
@@ -1,82 +1,51 @@
import request from '@/utils/http';
import request from "@/utils/request";
/** 对应后端 `plugin.module_task.workflow.node_type` */
const API_PATH = '/task/workflow/node-type';
const API_PATH = "/task/workflow/node-type";
const WorkflowNodeTypeAPI = {
/**
* 获取编排节点类型选项
* @returns 编排节点类型选项
*/
getWorkflowNodeTypeOptions() {
return request<ApiResponse<WorkflowNodeTypeOption[]>>({
url: `${API_PATH}/options`,
method: 'get',
method: "get",
});
},
/**
* 获取编排节点类型列表
* @param query 查询参数
* @returns 编排节点类型列表
*/
getWorkflowNodeTypeList(query: WorkflowNodeTypePageQuery) {
return request<PageResult<WorkflowNodeTypeTable[]>>({
return request<ApiResponse<PageResult<WorkflowNodeTypeTable[]>>>({
url: `${API_PATH}/list`,
method: 'get',
method: "get",
params: query,
});
},
/**
* 获取编排节点类型详情
* @param id 编排节点类型ID
* @returns 编排节点类型详情
*/
getWorkflowNodeTypeDetail(id: number) {
return request<ApiResponse<WorkflowNodeTypeTable>>({
url: `${API_PATH}/detail/${id}`,
method: 'get',
method: "get",
});
},
/**
* 创建编排节点类型
* @param body 编排节点类型信息
* @returns 编排节点类型详情
*/
createWorkflowNodeType(body: WorkflowNodeTypeForm) {
return request<ApiResponse<WorkflowNodeTypeTable>>({
url: `${API_PATH}/create`,
method: 'post',
method: "post",
data: body,
});
},
/**
* 更新编排节点类型
* @param id 编排节点类型ID
* @param body 编排节点类型信息
* @returns 编排节点类型详情
*/
updateWorkflowNodeType(id: number, body: WorkflowNodeTypeForm) {
return request<ApiResponse<WorkflowNodeTypeTable>>({
url: `${API_PATH}/update/${id}`,
method: 'put',
method: "put",
data: body,
});
},
/**
* 删除编排节点类型
* @param body 编排节点类型ID列表
* @returns 删除结果
* @returns 删除结果
*/
deleteWorkflowNodeType(body: number[]) {
return request({
return request<ApiResponse>({
url: `${API_PATH}/delete`,
method: 'delete',
method: "delete",
data: body,
});
},
-25
View File
@@ -1,25 +0,0 @@
import request from '@/utils/http';
import { AppRouteRecord } from '@/types/router';
// 获取用户列表
export function fetchGetUserList(params: Api.SystemManage.UserSearchParams) {
return request.get<Api.SystemManage.UserList>({
url: '/api/user/list',
params,
});
}
// 获取角色列表
export function fetchGetRoleList(params: Api.SystemManage.RoleSearchParams) {
return request.get<Api.SystemManage.RoleList>({
url: '/api/role/list',
params,
});
}
// 获取菜单列表
export function fetchGetMenuList() {
return request.get<AppRouteRecord[]>({
url: '/api/v3/system/menus',
});
}