demo
/
zhiqi
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

用户管理模块静态数据改接口调用

This commit is contained in:
JenniferW 2025-12-10 17:53:28 +08:00
parent a41214b490
commit 705e34ec1c
6 changed files with 253 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/api/system/config.js
View File

@ -1,80 +1,60 @@
// 模拟静态数据 import request from '@/utils/request'
const mockConfigs = [
{ configId: 1, configName: '系统名称', configKey: 'sys.name', configValue: '智奇品号高效检索系统', configType: 'Y', status: '0', createTime: '2023-01-01' },
{ configId: 2, configName: '系统版本', configKey: 'sys.version', configValue: 'v1.0.0', configType: 'Y', status: '0', createTime: '2023-01-02' }
];
// 查询参数列表 // 查询参数列表
export function listConfig(query) { export function listConfig(query) {
const { pageNum, pageSize, configName, configKey, configType, status } = query; return request({
let filteredConfigs = [...mockConfigs]; url: '/system/config/list',
method: 'get',
if (configName) { params: query
filteredConfigs = filteredConfigs.filter(config => config.configName.includes(configName)); })
}
if (configKey) {
filteredConfigs = filteredConfigs.filter(config => config.configKey.includes(configKey));
}
if (configType) {
filteredConfigs = filteredConfigs.filter(config => config.configType === configType);
}
if (status) {
filteredConfigs = filteredConfigs.filter(config => config.status === status);
}
const total = filteredConfigs.length;
const start = (pageNum - 1) * pageSize;
const end = start + pageSize;
const list = filteredConfigs.slice(start, end);
return Promise.resolve({
total,
rows: list
});
} }
// 查询参数详细 // 查询参数详细
export function getConfig(configId) { export function getConfig(configId) {
const config = mockConfigs.find(c => c.configId === parseInt(configId)); return request({
return Promise.resolve(config || {}); url: '/system/config/' + configId,
method: 'get'
})
} }
// 根据参数键名查询参数值 // 根据参数键名查询参数值
export function getConfigKey(configKey) { export function getConfigKey(configKey) {
const config = mockConfigs.find(c => c.configKey === configKey); return request({
return Promise.resolve(config ? config.configValue : ''); url: '/system/config/configKey/' + configKey,
method: 'get'
})
} }
// 新增参数配置 // 新增参数配置
export function addConfig(data) { export function addConfig(data) {
const newConfig = { return request({
configId: mockConfigs.length + 1, url: '/system/config',
...data, method: 'post',
createTime: new Date().toISOString().split('T')[0] data: data
}; })
mockConfigs.push(newConfig);
return Promise.resolve({ code: 200, msg: '新增成功' });
} }
// 修改参数配置 // 修改参数配置
export function updateConfig(data) { export function updateConfig(data) {
const index = mockConfigs.findIndex(c => c.configId === data.configId); return request({
if (index !== -1) { url: '/system/config',
mockConfigs[index] = { ...mockConfigs[index], ...data }; method: 'put',
} data: data
return Promise.resolve({ code: 200, msg: '修改成功' }); })
} }
// 删除参数配置 // 删除参数配置
export function delConfig(configId) { export function delConfig(configId) {
const index = mockConfigs.findIndex(c => c.configId === parseInt(configId)); return request({
if (index !== -1) { url: '/system/config/' + configId,
mockConfigs.splice(index, 1); method: 'delete'
} })
return Promise.resolve({ code: 200, msg: '删除成功' });
} }
// 刷新参数缓存 // 刷新参数缓存
export function refreshCache() { export function refreshCache() {
return Promise.resolve({ code: 200, msg: '刷新成功' }); return request({
url: '/system/config/refreshCache',
method: 'delete'
})
} }

66
src/api/system/dept.js
View File

@ -1,62 +1,52 @@
// 模拟静态数据 import request from '@/utils/request'
const mockDepts = [
{ deptId: 1, parentId: 0, deptName: '总公司', orderNum: 1, leader: '张三', phone: '15888888888', status: '0', createTime: '2023-01-01' },
{ deptId: 2, parentId: 1, deptName: '研发部', orderNum: 1, leader: '李四', phone: '15666666666', status: '0', createTime: '2023-01-02' },
{ deptId: 3, parentId: 1, deptName: '市场部', orderNum: 2, leader: '王五', phone: '15555555555', status: '0', createTime: '2023-01-03' }
];
// 查询部门列表 // 查询部门列表
export function listDept(query) { export function listDept(query) {
const { deptName, status } = query; return request({
let filteredDepts = [...mockDepts]; url: '/system/dept/list',
method: 'get',
if (deptName) { params: query
filteredDepts = filteredDepts.filter(dept => dept.deptName.includes(deptName)); })
}
if (status) {
filteredDepts = filteredDepts.filter(dept => dept.status === status);
}
return Promise.resolve(filteredDepts);
} }
// 查询部门列表（排除节点） // 查询部门列表（排除节点）
export function listDeptExcludeChild(deptId) { export function listDeptExcludeChild(deptId) {
const excludeDepts = mockDepts.filter(dept => dept.deptId !== parseInt(deptId)); return request({
return Promise.resolve(excludeDepts); url: '/system/dept/list/exclude/' + deptId,
method: 'get'
})
} }
// 查询部门详细 // 查询部门详细
export function getDept(deptId) { export function getDept(deptId) {
const dept = mockDepts.find(d => d.deptId === parseInt(deptId)); return request({
return Promise.resolve(dept || {}); url: '/system/dept/' + deptId,
method: 'get'
})
} }
// 新增部门 // 新增部门
export function addDept(data) { export function addDept(data) {
const newDept = { return request({
deptId: mockDepts.length + 1, url: '/system/dept',
...data, method: 'post',
createTime: new Date().toISOString().split('T')[0] data: data
}; })
mockDepts.push(newDept);
return Promise.resolve({ code: 200, msg: '新增成功' });
} }
// 修改部门 // 修改部门
export function updateDept(data) { export function updateDept(data) {
const index = mockDepts.findIndex(d => d.deptId === data.deptId); return request({
if (index !== -1) { url: '/system/dept',
mockDepts[index] = { ...mockDepts[index], ...data }; method: 'put',
} data: data
return Promise.resolve({ code: 200, msg: '修改成功' }); })
} }
// 删除部门 // 删除部门
export function delDept(deptId) { export function delDept(deptId) {
const index = mockDepts.findIndex(d => d.deptId === parseInt(deptId)); return request({
if (index !== -1) { url: '/system/dept/' + deptId,
mockDepts.splice(index, 1); method: 'delete'
} })
return Promise.resolve({ code: 200, msg: '删除成功' });
} }

70
src/api/system/notice.js
View File

@ -1,66 +1,44 @@
// 模拟静态数据 import request from '@/utils/request'
const mockNotices = [
{ noticeId: 1, noticeTitle: '系统公告', noticeType: '1', status: '0', createTime: '2023-01-01' },
{ noticeId: 2, noticeTitle: '维护通知', noticeType: '2', status: '0', createTime: '2023-01-02' }
];
// 查询公告列表 // 查询公告列表
export function listNotice(query) { export function listNotice(query) {
const { pageNum, pageSize, noticeTitle, noticeType, status } = query; return request({
let filteredNotices = [...mockNotices]; url: '/system/notice/list',
method: 'get',
if (noticeTitle) { params: query
filteredNotices = filteredNotices.filter(notice => notice.noticeTitle.includes(noticeTitle)); })
}
if (noticeType) {
filteredNotices = filteredNotices.filter(notice => notice.noticeType === noticeType);
}
if (status) {
filteredNotices = filteredNotices.filter(notice => notice.status === status);
}
const total = filteredNotices.length;
const start = (pageNum - 1) * pageSize;
const end = start + pageSize;
const list = filteredNotices.slice(start, end);
return Promise.resolve({
total,
rows: list
});
} }
// 查询公告详细 // 查询公告详细
export function getNotice(noticeId) { export function getNotice(noticeId) {
const notice = mockNotices.find(n => n.noticeId === parseInt(noticeId)); return request({
return Promise.resolve(notice || {}); url: '/system/notice/' + noticeId,
method: 'get'
})
} }
// 新增公告 // 新增公告
export function addNotice(data) { export function addNotice(data) {
const newNotice = { return request({
noticeId: mockNotices.length + 1, url: '/system/notice',
...data, method: 'post',
createTime: new Date().toISOString().split('T')[0] data: data
}; })
mockNotices.push(newNotice);
return Promise.resolve({ code: 200, msg: '新增成功' });
} }
// 修改公告 // 修改公告
export function updateNotice(data) { export function updateNotice(data) {
const index = mockNotices.findIndex(n => n.noticeId === data.noticeId); return request({
if (index !== -1) { url: '/system/notice',
mockNotices[index] = { ...mockNotices[index], ...data }; method: 'put',
} data: data
return Promise.resolve({ code: 200, msg: '修改成功' }); })
} }
// 删除公告 // 删除公告
export function delNotice(noticeId) { export function delNotice(noticeId) {
const index = mockNotices.findIndex(n => n.noticeId === parseInt(noticeId)); return request({
if (index !== -1) { url: '/system/notice/' + noticeId,
mockNotices.splice(index, 1); method: 'delete'
} })
return Promise.resolve({ code: 200, msg: '删除成功' });
} }

70
src/api/system/post.js
View File

@ -1,66 +1,44 @@
// 模拟静态数据 import request from '@/utils/request'
const mockPosts = [
{ postId: 1, postName: '总经理', postCode: 'CEO', postSort: 1, status: '0', createTime: '2023-01-01' },
{ postId: 2, postName: '技术总监', postCode: 'CTO', postSort: 2, status: '0', createTime: '2023-01-02' }
];
// 查询岗位列表 // 查询岗位列表
export function listPost(query) { export function listPost(query) {
const { pageNum, pageSize, postName, postCode, status } = query; return request({
let filteredPosts = [...mockPosts]; url: '/system/post/list',
method: 'get',
if (postName) { params: query
filteredPosts = filteredPosts.filter(post => post.postName.includes(postName)); })
}
if (postCode) {
filteredPosts = filteredPosts.filter(post => post.postCode.includes(postCode));
}
if (status) {
filteredPosts = filteredPosts.filter(post => post.status === status);
}
const total = filteredPosts.length;
const start = (pageNum - 1) * pageSize;
const end = start + pageSize;
const list = filteredPosts.slice(start, end);
return Promise.resolve({
total,
rows: list
});
} }
// 查询岗位详细 // 查询岗位详细
export function getPost(postId) { export function getPost(postId) {
const post = mockPosts.find(p => p.postId === parseInt(postId)); return request({
return Promise.resolve(post || {}); url: '/system/post/' + postId,
method: 'get'
})
} }
// 新增岗位 // 新增岗位
export function addPost(data) { export function addPost(data) {
const newPost = { return request({
postId: mockPosts.length + 1, url: '/system/post',
...data, method: 'post',
createTime: new Date().toISOString().split('T')[0] data: data
}; })
mockPosts.push(newPost);
return Promise.resolve({ code: 200, msg: '新增成功' });
} }
// 修改岗位 // 修改岗位
export function updatePost(data) { export function updatePost(data) {
const index = mockPosts.findIndex(p => p.postId === data.postId); return request({
if (index !== -1) { url: '/system/post',
mockPosts[index] = { ...mockPosts[index], ...data }; method: 'put',
} data: data
return Promise.resolve({ code: 200, msg: '修改成功' }); })
} }
// 删除岗位 // 删除岗位
export function delPost(postId) { export function delPost(postId) {
const index = mockPosts.findIndex(p => p.postId === parseInt(postId)); return request({
if (index !== -1) { url: '/system/post/' + postId,
mockPosts.splice(index, 1); method: 'delete'
} })
return Promise.resolve({ code: 200, msg: '删除成功' });
} }

132
src/api/system/role.js
View File

@ -1,119 +1,119 @@
// 模拟静态数据 import request from '@/utils/request'
const mockRoles = [
{ roleId: 1, roleName: '管理员', roleKey: 'admin', roleSort: 1, status: '0', createTime: '2023-01-01' },
{ roleId: 2, roleName: '普通角色', roleKey: 'common', roleSort: 2, status: '0', createTime: '2023-01-02' }
];
// 查询角色列表 // 查询角色列表
export function listRole(query) { export function listRole(query) {
// 模拟分页 return request({
const { pageNum, pageSize, roleName, roleKey, status } = query; url: '/system/role/list',
let filteredRoles = [...mockRoles]; method: 'get',
params: query
if (roleName) { })
filteredRoles = filteredRoles.filter(role => role.roleName.includes(roleName));
}
if (roleKey) {
filteredRoles = filteredRoles.filter(role => role.roleKey.includes(roleKey));
}
if (status) {
filteredRoles = filteredRoles.filter(role => role.status === status);
}
const total = filteredRoles.length;
const start = (pageNum - 1) * pageSize;
const end = start + pageSize;
const list = filteredRoles.slice(start, end);
return Promise.resolve({
total,
rows: list
});
} }
// 查询角色详细 // 查询角色详细
export function getRole(roleId) { export function getRole(roleId) {
const role = mockRoles.find(r => r.roleId === parseInt(roleId)); return request({
return Promise.resolve(role || {}); url: '/system/role/' + roleId,
method: 'get'
})
} }
// 新增角色 // 新增角色
export function addRole(data) { export function addRole(data) {
const newRole = { return request({
roleId: mockRoles.length + 1, url: '/system/role',
...data, method: 'post',
createTime: new Date().toISOString().split('T')[0] data: data
}; })
mockRoles.push(newRole);
return Promise.resolve({ code: 200, msg: '新增成功' });
} }
// 修改角色 // 修改角色
export function updateRole(data) { export function updateRole(data) {
const index = mockRoles.findIndex(r => r.roleId === data.roleId); return request({
if (index !== -1) { url: '/system/role',
mockRoles[index] = { ...mockRoles[index], ...data }; method: 'put',
} data: data
return Promise.resolve({ code: 200, msg: '修改成功' }); })
} }
// 角色数据权限 // 角色数据权限
export function dataScope(data) { export function dataScope(data) {
return Promise.resolve({ code: 200, msg: '修改成功' }); return request({
url: '/system/role/dataScope',
method: 'put',
data: data
})
} }
// 角色状态修改 // 角色状态修改
export function changeRoleStatus(roleId, status) { export function changeRoleStatus(roleId, status) {
const role = mockRoles.find(r => r.roleId === parseInt(roleId)); const data = {
if (role) { roleId,
role.status = status; status
} }
return Promise.resolve({ code: 200, msg: '修改成功' }); return request({
url: '/system/role/changeStatus',
method: 'put',
data: data
})
} }
// 删除角色 // 删除角色
export function delRole(roleId) { export function delRole(roleId) {
const index = mockRoles.findIndex(r => r.roleId === parseInt(roleId)); return request({
if (index !== -1) { url: '/system/role/' + roleId,
mockRoles.splice(index, 1); method: 'delete'
} })
return Promise.resolve({ code: 200, msg: '删除成功' });
} }
// 查询角色已授权用户列表 // 查询角色已授权用户列表
export function allocatedUserList(query) { export function allocatedUserList(query) {
return Promise.resolve({ return request({
total: 1, url: '/system/role/authUser/allocatedList',
rows: [{ userId: 1, userName: 'admin', nickName: '管理员' }] method: 'get',
}); params: query
})
} }
// 查询角色未授权用户列表 // 查询角色未授权用户列表
export function unallocatedUserList(query) { export function unallocatedUserList(query) {
return Promise.resolve({ return request({
total: 1, url: '/system/role/authUser/unallocatedList',
rows: [{ userId: 2, userName: 'test', nickName: '测试用户' }] method: 'get',
}); params: query
})
} }
// 取消用户授权角色 // 取消用户授权角色
export function authUserCancel(data) { export function authUserCancel(data) {
return Promise.resolve({ code: 200, msg: '取消授权成功' }); return request({
url: '/system/role/authUser/cancel',
method: 'put',
data: data
})
} }
// 批量取消用户授权角色 // 批量取消用户授权角色
export function authUserCancelAll(data) { export function authUserCancelAll(data) {
return Promise.resolve({ code: 200, msg: '批量取消授权成功' }); return request({
url: '/system/role/authUser/cancelAll',
method: 'put',
params: data
})
} }
// 授权用户选择 // 授权用户选择
export function authUserSelectAll(data) { export function authUserSelectAll(data) {
return Promise.resolve({ code: 200, msg: '授权成功' }); return request({
url: '/system/role/authUser/selectAll',
method: 'put',
params: data
})
} }
// 根据角色ID查询部门树结构 // 根据角色ID查询部门树结构
export function deptTreeSelect(roleId) { export function deptTreeSelect(roleId) {
return Promise.resolve([ return request({
{ id: 1, label: '总公司', children: [{ id: 2, label: '研发部' }] } url: '/system/role/deptTree/' + roleId,
]); method: 'get'
})
} }

147
src/api/system/user.js
View File

@ -1,125 +1,136 @@
// 模拟静态数据 import request from '@/utils/request'
const mockUsers = [ import { parseStrEmpty } from "@/utils/ruoyi";
{ userId: 1, userName: 'admin', nickName: '管理员', dept: { deptName: '总公司' }, phonenumber: '15888888888', status: '0', createTime: '2023-01-01' },
{ userId: 2, userName: 'test', nickName: '测试用户', dept: { deptName: '研发部' }, phonenumber: '15666666666', status: '0', createTime: '2023-01-02' }
];
// 查询用户列表 // 查询用户列表
export function listUser(query) { export function listUser(query) {
// 模拟分页 return request({
const { pageNum, pageSize, userName, phonenumber, status, deptId } = query; url: '/system/user/list',
let filteredUsers = [...mockUsers]; method: 'get',
params: query
if (userName) { })
filteredUsers = filteredUsers.filter(user => user.userName.includes(userName));
}
if (phonenumber) {
filteredUsers = filteredUsers.filter(user => user.phonenumber.includes(phonenumber));
}
if (status) {
filteredUsers = filteredUsers.filter(user => user.status === status);
}
if (deptId) {
filteredUsers = filteredUsers.filter(user => user.dept.deptId === deptId);
}
const total = filteredUsers.length;
const start = (pageNum - 1) * pageSize;
const end = start + pageSize;
const list = filteredUsers.slice(start, end);
return Promise.resolve({
total,
rows: list
});
} }
// 查询用户详细 // 查询用户详细
export function getUser(userId) { export function getUser(userId) {
const user = mockUsers.find(u => u.userId === parseInt(userId)); return request({
return Promise.resolve(user || {}); url: '/system/user/' + parseStrEmpty(userId),
method: 'get'
})
} }
// 新增用户 // 新增用户
export function addUser(data) { export function addUser(data) {
const newUser = { return request({
userId: mockUsers.length + 1, url: '/system/user',
...data, method: 'post',
createTime: new Date().toISOString().split('T')[0] data: data
}; })
mockUsers.push(newUser);
return Promise.resolve({ code: 200, msg: '新增成功' });
} }
// 修改用户 // 修改用户
export function updateUser(data) { export function updateUser(data) {
const index = mockUsers.findIndex(u => u.userId === data.userId); return request({
if (index !== -1) { url: '/system/user',
mockUsers[index] = { ...mockUsers[index], ...data }; method: 'put',
} data: data
return Promise.resolve({ code: 200, msg: '修改成功' }); })
} }
// 删除用户 // 删除用户
export function delUser(userId) { export function delUser(userId) {
const index = mockUsers.findIndex(u => u.userId === parseInt(userId)); return request({
if (index !== -1) { url: '/system/user/' + userId,
mockUsers.splice(index, 1); method: 'delete'
} })
return Promise.resolve({ code: 200, msg: '删除成功' });
} }
// 用户密码重置 // 用户密码重置
export function resetUserPwd(userId, password) { export function resetUserPwd(userId, password) {
return Promise.resolve({ code: 200, msg: '重置成功' }); const data = {
userId,
password
}
return request({
url: '/system/user/resetPwd',
method: 'put',
data: data
})
} }
// 用户状态修改 // 用户状态修改
export function changeUserStatus(userId, status) { export function changeUserStatus(userId, status) {
const user = mockUsers.find(u => u.userId === parseInt(userId)); const data = {
if (user) { userId,
user.status = status; status
} }
return Promise.resolve({ code: 200, msg: '修改成功' }); return request({
url: '/system/user/changeStatus',
method: 'put',
data: data
})
} }
// 查询用户个人信息 // 查询用户个人信息
export function getUserProfile() { export function getUserProfile() {
return Promise.resolve(mockUsers[0]); return request({
url: '/system/user/profile',
method: 'get'
})
} }
// 修改用户个人信息 // 修改用户个人信息
export function updateUserProfile(data) { export function updateUserProfile(data) {
Object.assign(mockUsers[0], data); return request({
return Promise.resolve({ code: 200, msg: '修改成功' }); url: '/system/user/profile',
method: 'put',
data: data
})
} }
// 用户密码重置 // 用户密码重置
export function updateUserPwd(oldPassword, newPassword) { export function updateUserPwd(oldPassword, newPassword) {
return Promise.resolve({ code: 200, msg: '修改成功' }); const data = {
oldPassword,
newPassword
}
return request({
url: '/system/user/profile/updatePwd',
method: 'put',
data: data
})
} }
// 用户头像上传 // 用户头像上传
export function uploadAvatar(data) { export function uploadAvatar(data) {
return Promise.resolve({ code: 200, msg: '上传成功' }); return request({
url: '/system/user/profile/avatar',
method: 'post',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
data: data
})
} }
// 查询授权角色 // 查询授权角色
export function getAuthRole(userId) { export function getAuthRole(userId) {
return Promise.resolve({ return request({
user: mockUsers.find(u => u.userId === parseInt(userId)), url: '/system/user/authRole/' + userId,
roles: [{ roleId: 1, roleName: '管理员' }] method: 'get'
}); })
} }
// 保存授权角色 // 保存授权角色
export function updateAuthRole(data) { export function updateAuthRole(data) {
return Promise.resolve({ code: 200, msg: '授权成功' }); return request({
url: '/system/user/authRole',
method: 'put',
params: data
})
} }
// 查询部门下拉树结构 // 查询部门下拉树结构
export function deptTreeSelect() { export function deptTreeSelect() {
return Promise.resolve([ return request({
{ id: 1, label: '总公司', children: [{ id: 2, label: '研发部' }] } url: '/system/user/deptTree',
]); method: 'get'
})
} }