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 @@
// 模拟静态数据
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' }
];
import request from '@/utils/request'
// 查询参数列表
export function listConfig(query) {
const { pageNum, pageSize, configName, configKey, configType, status } = query;
let filteredConfigs = [...mockConfigs];
if (configName) {
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
});
return request({
url: '/system/config/list',
method: 'get',
params: query
})
}
// 查询参数详细
export function getConfig(configId) {
const config = mockConfigs.find(c => c.configId === parseInt(configId));
return Promise.resolve(config || {});
return request({
url: '/system/config/' + configId,
method: 'get'
})
}
// 根据参数键名查询参数值
export function getConfigKey(configKey) {
const config = mockConfigs.find(c => c.configKey === configKey);
return Promise.resolve(config ? config.configValue : '');
return request({
url: '/system/config/configKey/' + configKey,
method: 'get'
})
}
// 新增参数配置
export function addConfig(data) {
const newConfig = {
configId: mockConfigs.length + 1,
...data,
createTime: new Date().toISOString().split('T')[0]
};
mockConfigs.push(newConfig);
return Promise.resolve({ code: 200, msg: '新增成功' });
return request({
url: '/system/config',
method: 'post',
data: data
})
}
// 修改参数配置
export function updateConfig(data) {
const index = mockConfigs.findIndex(c => c.configId === data.configId);
if (index !== -1) {
mockConfigs[index] = { ...mockConfigs[index], ...data };
}
return Promise.resolve({ code: 200, msg: '修改成功' });
return request({
url: '/system/config',
method: 'put',
data: data
})
}
// 删除参数配置
export function delConfig(configId) {
const index = mockConfigs.findIndex(c => c.configId === parseInt(configId));
if (index !== -1) {
mockConfigs.splice(index, 1);
}
return Promise.resolve({ code: 200, msg: '删除成功' });
return request({
url: '/system/config/' + configId,
method: 'delete'
})
}
// 刷新参数缓存
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 @@
// 模拟静态数据
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' }
];
import request from '@/utils/request'
// 查询部门列表
export function listDept(query) {
const { deptName, status } = query;
let filteredDepts = [...mockDepts];
if (deptName) {
filteredDepts = filteredDepts.filter(dept => dept.deptName.includes(deptName));
}
if (status) {
filteredDepts = filteredDepts.filter(dept => dept.status === status);
}
return Promise.resolve(filteredDepts);
return request({
url: '/system/dept/list',
method: 'get',
params: query
})
}
// 查询部门列表（排除节点）
export function listDeptExcludeChild(deptId) {
const excludeDepts = mockDepts.filter(dept => dept.deptId !== parseInt(deptId));
return Promise.resolve(excludeDepts);
return request({
url: '/system/dept/list/exclude/' + deptId,
method: 'get'
})
}
// 查询部门详细
export function getDept(deptId) {
const dept = mockDepts.find(d => d.deptId === parseInt(deptId));
return Promise.resolve(dept || {});
return request({
url: '/system/dept/' + deptId,
method: 'get'
})
}
// 新增部门
export function addDept(data) {
const newDept = {
deptId: mockDepts.length + 1,
...data,
createTime: new Date().toISOString().split('T')[0]
};
mockDepts.push(newDept);
return Promise.resolve({ code: 200, msg: '新增成功' });
return request({
url: '/system/dept',
method: 'post',
data: data
})
}
// 修改部门
export function updateDept(data) {
const index = mockDepts.findIndex(d => d.deptId === data.deptId);
if (index !== -1) {
mockDepts[index] = { ...mockDepts[index], ...data };
}
return Promise.resolve({ code: 200, msg: '修改成功' });
return request({
url: '/system/dept',
method: 'put',
data: data
})
}
// 删除部门
export function delDept(deptId) {
const index = mockDepts.findIndex(d => d.deptId === parseInt(deptId));
if (index !== -1) {
mockDepts.splice(index, 1);
}
return Promise.resolve({ code: 200, msg: '删除成功' });
return request({
url: '/system/dept/' + deptId,
method: 'delete'
})
}

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

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

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

@ -1,66 +1,44 @@
// 模拟静态数据
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' }
];
import request from '@/utils/request'
// 查询岗位列表
export function listPost(query) {
const { pageNum, pageSize, postName, postCode, status } = query;
let filteredPosts = [...mockPosts];
if (postName) {
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
});
return request({
url: '/system/post/list',
method: 'get',
params: query
})
}
// 查询岗位详细
export function getPost(postId) {
const post = mockPosts.find(p => p.postId === parseInt(postId));
return Promise.resolve(post || {});
return request({
url: '/system/post/' + postId,
method: 'get'
})
}
// 新增岗位
export function addPost(data) {
const newPost = {
postId: mockPosts.length + 1,
...data,
createTime: new Date().toISOString().split('T')[0]
};
mockPosts.push(newPost);
return Promise.resolve({ code: 200, msg: '新增成功' });
return request({
url: '/system/post',
method: 'post',
data: data
})
}
// 修改岗位
export function updatePost(data) {
const index = mockPosts.findIndex(p => p.postId === data.postId);
if (index !== -1) {
mockPosts[index] = { ...mockPosts[index], ...data };
}
return Promise.resolve({ code: 200, msg: '修改成功' });
return request({
url: '/system/post',
method: 'put',
data: data
})
}
// 删除岗位
export function delPost(postId) {
const index = mockPosts.findIndex(p => p.postId === parseInt(postId));
if (index !== -1) {
mockPosts.splice(index, 1);
}
return Promise.resolve({ code: 200, msg: '删除成功' });
return request({
url: '/system/post/' + postId,
method: 'delete'
})
}

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

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

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

@ -1,125 +1,136 @@
// 模拟静态数据
const mockUsers = [
{ 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' }
];
import request from '@/utils/request'
import { parseStrEmpty } from "@/utils/ruoyi";
// 查询用户列表
export function listUser(query) {
// 模拟分页
const { pageNum, pageSize, userName, phonenumber, status, deptId } = query;
let filteredUsers = [...mockUsers];
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
});
return request({
url: '/system/user/list',
method: 'get',
params: query
})
}
// 查询用户详细
export function getUser(userId) {
const user = mockUsers.find(u => u.userId === parseInt(userId));
return Promise.resolve(user || {});
return request({
url: '/system/user/' + parseStrEmpty(userId),
method: 'get'
})
}
// 新增用户
export function addUser(data) {
const newUser = {
userId: mockUsers.length + 1,
...data,
createTime: new Date().toISOString().split('T')[0]
};
mockUsers.push(newUser);
return Promise.resolve({ code: 200, msg: '新增成功' });
return request({
url: '/system/user',
method: 'post',
data: data
})
}
// 修改用户
export function updateUser(data) {
const index = mockUsers.findIndex(u => u.userId === data.userId);
if (index !== -1) {
mockUsers[index] = { ...mockUsers[index], ...data };
}
return Promise.resolve({ code: 200, msg: '修改成功' });
return request({
url: '/system/user',
method: 'put',
data: data
})
}
// 删除用户
export function delUser(userId) {
const index = mockUsers.findIndex(u => u.userId === parseInt(userId));
if (index !== -1) {
mockUsers.splice(index, 1);
}
return Promise.resolve({ code: 200, msg: '删除成功' });
return request({
url: '/system/user/' + userId,
method: 'delete'
})
}
// 用户密码重置
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) {
const user = mockUsers.find(u => u.userId === parseInt(userId));
if (user) {
user.status = status;
const data = {
userId,
status
}
return Promise.resolve({ code: 200, msg: '修改成功' });
return request({
url: '/system/user/changeStatus',
method: 'put',
data: data
})
}
// 查询用户个人信息
export function getUserProfile() {
return Promise.resolve(mockUsers[0]);
return request({
url: '/system/user/profile',
method: 'get'
})
}
// 修改用户个人信息
export function updateUserProfile(data) {
Object.assign(mockUsers[0], data);
return Promise.resolve({ code: 200, msg: '修改成功' });
return request({
url: '/system/user/profile',
method: 'put',
data: data
})
}
// 用户密码重置
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) {
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) {
return Promise.resolve({
user: mockUsers.find(u => u.userId === parseInt(userId)),
roles: [{ roleId: 1, roleName: '管理员' }]
});
return request({
url: '/system/user/authRole/' + userId,
method: 'get'
})
}
// 保存授权角色
export function updateAuthRole(data) {
return Promise.resolve({ code: 200, msg: '授权成功' });
return request({
url: '/system/user/authRole',
method: 'put',
params: data
})
}
// 查询部门下拉树结构
export function deptTreeSelect() {
return Promise.resolve([
{ id: 1, label: '总公司', children: [{ id: 2, label: '研发部' }] }
]);
return request({
url: '/system/user/deptTree',
method: 'get'
})
}