zhouhui.jiang / test_cursor

Go to a project
Toggle navigation Toggle navigation pinning
zhouhui.jiang
b6b47458 1 parent 0b10de4b

添加 用户管理、角色管理、菜单管理、字典管理、日志管理

Expand all
Inline Side-by-side
Showing 35 changed files with 1654 additions and 547 deletions
This diff is collapsed. Click to expand it.
......@@ -5,8 +5,11 @@ import com.apple.erp.dto.request.RoleQueryReq;
import com.apple.erp.dto.request.RoleUpdateReq;
import com.apple.erp.dto.response.ApiRes;
import com.apple.erp.dto.response.RoleRes;
import com.apple.erp.dto.response.MenuRes;
import com.apple.erp.entity.SysRole;
import com.apple.erp.entity.SysMenu;
import com.apple.erp.service.SysRoleService;
import com.apple.erp.mapper.SysMenuMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.v3.oas.annotations.Operation;
......@@ -21,7 +24,6 @@ import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
......@@ -40,6 +42,9 @@ public class SysRoleController {
@Autowired
private SysRoleService sysRoleService;
@Autowired
private SysMenuMapper sysMenuMapper;
/**
* 获取角色列表
......@@ -156,7 +161,7 @@ public class SysRoleController {
* @throws RuntimeException 当角色编码或名称已存在时
*/
@Operation(summary = "新增角色", description = "创建新角色，包括角色基本信息和菜单权限分配")
@PostMapping
@PostMapping("/add")
@PreAuthorize("hasAuthority('sys:role:add')")
public ApiRes<Void> add(
@Parameter(description = "角色新增请求，包含角色基本信息和菜单ID列表", required = true)
......@@ -222,7 +227,7 @@ public class SysRoleController {
* @throws RuntimeException 当角色不存在或角色编码/名称已存在时
*/
@Operation(summary = "修改角色", description = "更新角色基本信息，包括角色资料和菜单权限分配")
@PutMapping
@PostMapping("/edit")
@PreAuthorize("hasAuthority('sys:role:edit')")
public ApiRes<Void> edit(
@Parameter(description = "角色更新请求，包含角色ID、基本信息和菜单ID列表", required = true)
......@@ -329,7 +334,7 @@ public class SysRoleController {
* @throws RuntimeException 当尝试修改超级管理员角色状态时
*/
@Operation(summary = "修改角色状态", description = "启用或停用角色")
@PutMapping("/changeStatus")
@PostMapping("/changeStatus")
@PreAuthorize("hasAuthority('sys:role:edit')")
public ApiRes<Void> changeStatus(
@Parameter(description = "角色信息，主要使用角色ID和状态字段", required = true) @RequestBody SysRole role) {
......@@ -358,6 +363,53 @@ public class SysRoleController {
roleRes.setStatusText(role.getStatus() == 1 ? "正常" : "停用");
}
// 获取角色菜单权限
if (role.getRoleId() != null) {
List<SysMenu> menuList = sysMenuMapper.selectMenuTreeByRoleId(role.getRoleId());
if (menuList != null && !menuList.isEmpty()) {
List<MenuRes> menuResList = menuList.stream()
.map(this::convertToMenuRes)
.collect(Collectors.toList());
roleRes.setMenus(menuResList);
}
}
return roleRes;
}
/**
* 转换菜单实体为菜单响应DTO
*
* @param menu 菜单实体
* @return 菜单响应DTO
*/
private MenuRes convertToMenuRes(SysMenu menu) {
MenuRes menuRes = new MenuRes();
BeanUtils.copyProperties(menu, menuRes);
// 设置菜单类型描述
if (menu.getMenuType() != null) {
switch (menu.getMenuType()) {
case "0":
menuRes.setMenuTypeText("目录");
break;
case "1":
menuRes.setMenuTypeText("菜单");
break;
case "2":
menuRes.setMenuTypeText("按钮");
break;
default:
menuRes.setMenuTypeText("未知");
break;
}
}
// 设置状态描述
if (menu.getStatus() != null) {
menuRes.setStatusText(menu.getStatus().equals(1) ? "显示" : "隐藏");
}
return menuRes;
}
}
......
......@@ -8,6 +8,7 @@ import com.apple.erp.dto.response.ApiRes;
import com.apple.erp.dto.response.UserRes;
import com.apple.erp.entity.SysUser;
import com.apple.erp.service.SysUserService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.v3.oas.annotations.Operation;
......@@ -17,6 +18,7 @@ import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
......@@ -53,7 +55,7 @@ public class SysUserController {
* @apiNote 接口路径: GET /api/system/user/list
* @apiNote 权限要求: sys:user:list
* @apiNote 支持分页参数: pageNum(页码), pageSize(每页大小)
* @apiNote 支持筛选条件: username(用户名), realName(真实姓名), phone(手机号), email(邮箱), status(状态)
* @apiNote 支持筛选条件: username(用户名), realName(真实姓名), phone(手机号), email(邮箱), status(状态), startTime(开始时间), endTime(结束时间)
*
* @param queryReq 用户查询条件，包含分页参数和筛选条件
* - pageNum: 页码，默认1
......@@ -63,6 +65,8 @@ public class SysUserController {
* - phone: 手机号，支持模糊查询
* - email: 邮箱，支持模糊查询
* - status: 用户状态，0-停用，1-启用
* - startTime: 开始时间，创建时间范围查询的起始时间
* - endTime: 结束时间，创建时间范围查询的结束时间
* @return 分页的用户列表数据
* - code: 响应码，200表示成功
* - message: 响应消息
......@@ -73,18 +77,17 @@ public class SysUserController {
* - size: 每页大小
* @throws SecurityException 当用户没有sys:user:list权限时
*/
@Operation(summary = "获取用户列表", description = "支持分页查询和条件筛选，包括用户名、真实姓名、手机号、邮箱、状态等条件")
@Operation(summary = "获取用户列表", description = "支持分页查询和条件筛选，包括用户名、真实姓名、手机号、邮箱、状态、创建时间范围等条件")
@GetMapping("/list")
@PreAuthorize("hasAuthority('sys:user:list')")
public ApiRes<IPage<UserRes>> list(
@Parameter(description = "用户查询条件，包含分页参数和筛选条件") UserQueryReq queryReq) {
Page<SysUser> page = new Page<>(queryReq.getPageNum(), queryReq.getPageSize());
// 构建查询条件
SysUser queryUser = new SysUser();
BeanUtils.copyProperties(queryReq, queryUser);
// 获取查询条件包装器（包含所有查询条件）
LambdaQueryWrapper<SysUser> wrapper = sysUserService.getQueryWrapper(queryReq);
IPage<SysUser> userPage = sysUserService.page(page, sysUserService.getQueryWrapper(queryUser));
IPage<SysUser> userPage = sysUserService.page(page, wrapper);
// 转换为响应DTO
List<UserRes> userResList = userPage.getRecords().stream()
......@@ -143,7 +146,7 @@ public class SysUserController {
* 新增用户
* 创建新用户，包括用户基本信息和角色分配
*
* @apiNote 接口路径: POST /api/system/user
* @apiNote 接口路径: POST /api/system/user/add
* @apiNote 权限要求: sys:user:add
* @apiNote 功能说明: 创建新用户账户，支持同时分配角色权限
* @apiNote 数据验证: 用户名唯一性检查，密码强度验证，邮箱格式验证
......@@ -165,8 +168,9 @@ public class SysUserController {
* @throws RuntimeException 当用户名已存在时
*/
@Operation(summary = "新增用户", description = "创建新用户，包括用户基本信息和角色分配")
@PostMapping
@PostMapping("/add")
@PreAuthorize("hasAuthority('sys:user:add')")
@Transactional(rollbackFor = Exception.class)
public ApiRes<Void> add(
@Parameter(description = "用户新增请求，包含用户基本信息和角色ID列表", required = true)
@Valid @RequestBody UserAddReq addReq) {
......@@ -198,7 +202,7 @@ public class SysUserController {
* 修改用户
* 更新用户基本信息，包括用户资料和角色分配
*
* @apiNote 接口路径: PUT /api/system/user
* @apiNote 接口路径: POST /api/system/user/edit
* @apiNote 权限要求: sys:user:edit
* @apiNote 功能说明: 更新现有用户的基本信息和角色分配
* @apiNote 数据验证: 用户存在性检查，邮箱格式验证，角色有效性验证
......@@ -219,8 +223,9 @@ public class SysUserController {
* @throws RuntimeException 当用户不存在时
*/
@Operation(summary = "修改用户", description = "更新用户基本信息，包括用户资料和角色分配")
@PutMapping
@PostMapping("/edit")
@PreAuthorize("hasAuthority('sys:user:edit')")
@Transactional(rollbackFor = Exception.class)
public ApiRes<Void> edit(
@Parameter(description = "用户更新请求，包含用户ID、基本信息和角色ID列表", required = true)
@Valid @RequestBody UserUpdateReq updateReq) {
......@@ -274,6 +279,7 @@ public class SysUserController {
@Operation(summary = "删除用户", description = "批量删除用户，会同时清理用户角色关联关系")
@DeleteMapping("/{userIds}")
@PreAuthorize("hasAuthority('sys:user:remove')")
@Transactional(rollbackFor = Exception.class)
public ApiRes<Void> remove(
@Parameter(description = "需要删除的用户ID数组", required = true) @PathVariable Long[] userIds) {
// 检查是否包含超级管理员
......@@ -341,7 +347,7 @@ public class SysUserController {
* 状态修改
* 启用或停用用户账户
*
* @apiNote 接口路径: PUT /api/system/user/changeStatus
* @apiNote 接口路径: POST /api/system/user/changeStatus
* @apiNote 权限要求: sys:user:edit
* @apiNote 功能说明: 修改用户账户状态，支持启用或停用用户
* @apiNote 安全限制: 不允许修改超级管理员用户状态
......@@ -358,7 +364,7 @@ public class SysUserController {
* @throws RuntimeException 当尝试修改超级管理员状态时
*/
@Operation(summary = "修改用户状态", description = "启用或停用用户账户")
@PutMapping("/changeStatus")
@PostMapping("/changeStatus")
@PreAuthorize("hasAuthority('sys:user:edit')")
public ApiRes<Void> changeStatus(
@Parameter(description = "用户信息，主要使用用户ID和状态字段", required = true) @RequestBody SysUser user) {
......@@ -392,4 +398,4 @@ public class SysUserController {
return userRes;
}
}
}
\ No newline at end of file
......
......@@ -2,6 +2,7 @@ package com.apple.erp.dto.request;
import lombok.Data;
/**
* 用户查询请求DTO
*
......@@ -38,6 +39,16 @@ public class UserQueryReq {
private Integer status;
/**
* 开始时间（创建时间范围查询）
*/
private String startTime;
/**
* 结束时间（创建时间范围查询）
*/
private String endTime;
/**
* 页码
*/
private Integer pageNum = 1;
......
......@@ -33,8 +33,9 @@ public interface SysUserMapper extends BaseMapper<SysUser> {
/**
* 根据用户名查询用户基本信息
* 用于用户名唯一性检查，需要查询所有状态的用户（包括停用用户）
*/
@Select("SELECT * FROM t_sys_user WHERE username = #{username} AND del_flag = '0' AND status = 1")
@Select("SELECT * FROM t_sys_user WHERE username = #{username} AND del_flag = '0'")
SysUser findByUsername(@Param("username") String username);
/**
......@@ -47,4 +48,4 @@ public interface SysUserMapper extends BaseMapper<SysUser> {
*/
@Update("UPDATE t_sys_user SET last_login_time = NOW(), last_login_ip = #{ip} WHERE user_id = #{userId}")
void updateLastLoginInfo(@Param("userId") Long userId, @Param("ip") String ip);
}
}
\ No newline at end of file
......
package com.apple.erp.service;
import com.apple.erp.dto.request.UserQueryReq;
import com.apple.erp.dto.response.RoleRes;
import com.apple.erp.entity.SysUser;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
......@@ -38,12 +39,12 @@ public interface SysUserService extends IService<SysUser> {
/**
* 获取用户查询条件包装器
* 根据用户信息构建MyBatis Plus查询条件，支持用户名、真实姓名、手机号、邮箱、状态的模糊查询
* 根据查询请求构建MyBatis Plus查询条件，支持用户名、真实姓名、手机号、邮箱、状态、创建时间范围等条件
*
* @param user 用户查询条件对象
* @param queryReq 用户查询请求对象
* @return MyBatis Plus查询条件包装器
*/
LambdaQueryWrapper<SysUser> getQueryWrapper(SysUser user);
LambdaQueryWrapper<SysUser> getQueryWrapper(UserQueryReq queryReq);
/**
* 获取用户角色列表
......
package com.apple.erp.service.impl;
import com.apple.erp.dto.request.UserQueryReq;
import com.apple.erp.dto.response.RoleRes;
import com.apple.erp.entity.SysRole;
import com.apple.erp.entity.SysUser;
......@@ -17,6 +18,8 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
......@@ -93,39 +96,55 @@ public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> impl
/**
* 获取用户查询条件包装器
* 根据用户信息构建MyBatis Plus查询条件，支持用户名、真实姓名、手机号、邮箱、状态的模糊查询
* 根据查询请求构建MyBatis Plus查询条件，支持用户名、真实姓名、手机号、邮箱、状态、创建时间范围等条件
* 优化判空规则，兼容空字符串和null的情况
*
* @param user 用户查询条件对象
* @param queryReq 用户查询请求对象
* @return MyBatis Plus查询条件包装器
*/
@Override
public LambdaQueryWrapper<SysUser> getQueryWrapper(SysUser user) {
public LambdaQueryWrapper<SysUser> getQueryWrapper(UserQueryReq queryReq) {
LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
// 用户名：支持模糊查询，过滤空字符串和null
if (StringUtils.isNotEmpty(user.getUsername())) {
wrapper.like(SysUser::getUsername, user.getUsername());
if (StringUtils.isNotEmpty(queryReq.getUsername())) {
wrapper.like(SysUser::getUsername, queryReq.getUsername());
}
// 真实姓名：支持模糊查询，过滤空字符串和null
if (StringUtils.isNotEmpty(user.getRealName())) {
wrapper.like(SysUser::getRealName, user.getRealName());
if (StringUtils.isNotEmpty(queryReq.getRealName())) {
wrapper.like(SysUser::getRealName, queryReq.getRealName());
}
// 手机号：支持模糊查询，过滤空字符串和null
if (StringUtils.isNotEmpty(user.getPhone())) {
wrapper.like(SysUser::getPhone, user.getPhone());
if (StringUtils.isNotEmpty(queryReq.getPhone())) {
wrapper.like(SysUser::getPhone, queryReq.getPhone());
}
// 邮箱：支持模糊查询，过滤空字符串和null
if (StringUtils.isNotEmpty(user.getEmail())) {
wrapper.like(SysUser::getEmail, user.getEmail());
if (StringUtils.isNotEmpty(queryReq.getEmail())) {
wrapper.like(SysUser::getEmail, queryReq.getEmail());
}
// 状态：精确查询
if (user.getStatus() != null) {
wrapper.eq(SysUser::getStatus, user.getStatus());
if (queryReq.getStatus() != null) {
wrapper.eq(SysUser::getStatus, queryReq.getStatus());
}
// 开始时间：创建时间 >= 开始时间
if (StringUtils.isNotEmpty(queryReq.getStartTime())) {
LocalDateTime startDateTime = parseDateTime(queryReq.getStartTime());
if (startDateTime != null) {
wrapper.ge(SysUser::getCreateTime, startDateTime);
}
}
// 结束时间：创建时间 <= 结束时间
if (StringUtils.isNotEmpty(queryReq.getEndTime())) {
LocalDateTime endDateTime = parseDateTime(queryReq.getEndTime());
if (endDateTime != null) {
wrapper.le(SysUser::getCreateTime, endDateTime);
}
}
// 固定条件：未删除
......@@ -138,6 +157,44 @@ public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> impl
}
/**
* 解析时间字符串为LocalDateTime
* 支持格式：yyyy-MM-dd, yyyy-MM-dd HH:mm:ss
*
* @param dateTimeStr 时间字符串
* @return LocalDateTime对象，解析失败返回null
*/
private LocalDateTime parseDateTime(String dateTimeStr) {
if (StringUtils.isEmpty(dateTimeStr)) {
return null;
}
// 支持的时间格式
DateTimeFormatter[] formatters = {
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
DateTimeFormatter.ofPattern("yyyy-MM-dd")
};
// 尝试各种格式解析
for (DateTimeFormatter formatter : formatters) {
try {
if (formatter.toString().contains("HH:mm:ss")) {
// 完整时间格式
return LocalDateTime.parse(dateTimeStr, formatter);
} else {
// 仅日期格式，转换为当天的00:00:00
return LocalDateTime.parse(dateTimeStr + " 00:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
} catch (DateTimeParseException e) {
continue;
}
}
// 解析失败，记录日志
System.err.println("时间格式解析失败: " + dateTimeStr);
return null;
}
/**
* 获取用户角色列表
* 查询指定用户拥有的所有角色信息，包含角色基本信息和状态描述
*
......
......@@ -54,7 +54,7 @@
select distinct m.menu_id, m.parent_id, m.menu_name, m.path, m.menu_type, m.status, m.perms, m.icon, m.create_by, m.create_time, m.update_by, m.update_time, m.del_flag
from t_sys_menu m
left join t_sys_role_menu rm on m.menu_id = rm.menu_id
where rm.role_id = #{roleId} and m.menu_type in ('0','1') and m.status = 1 and m.del_flag = '0'
where rm.role_id = #{roleId} and m.status = 1 and m.del_flag = '0'
order by m.parent_id, m.sort
</select>
......
......@@ -34,7 +34,7 @@
<!-- 根据用户名查询用户基本信息 -->
<select id="findByUsername" resultType="com.apple.erp.entity.SysUser">
SELECT * FROM t_sys_user
WHERE username = #{username} AND del_flag = '0' AND status = 1
WHERE username = #{username}
</select>
<!-- 根据用户ID查询菜单权限标识列表 -->
......
......@@ -79,9 +79,3 @@ declare global {
const watchPostEffect: typeof import('vue')['watchPostEffect']
const watchSyncEffect: typeof import('vue')['watchSyncEffect']
}
// for type re-export
declare global {
// @ts-ignore
export type { Component, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from 'vue'
import('vue')
}
......
......@@ -7,10 +7,21 @@ export {}
declare module 'vue' {
export interface GlobalComponents {
ActionBar: typeof import('./src/components/common/ActionBar.vue')['default']
DataTable: typeof import('./src/components/common/DataTable.vue')['default']
ElButton: typeof import('element-plus/es')['ElButton']
ElCheckbox: typeof import('element-plus/es')['ElCheckbox']
ElForm: typeof import('element-plus/es')['ElForm']
ElFormItem: typeof import('element-plus/es')['ElFormItem']
ElInput: typeof import('element-plus/es')['ElInput']
ElLink: typeof import('element-plus/es')['ElLink']
Header: typeof import('./src/components/layout/Header.vue')['default']
Pagination: typeof import('./src/components/common/Pagination.vue')['default']
RouterLink: typeof import('vue-router')['RouterLink']
RouterView: typeof import('vue-router')['RouterView']
SearchBar: typeof import('./src/components/common/SearchBar.vue')['default']
Sidebar: typeof import('./src/components/layout/Sidebar.vue')['default']
SidebarItem: typeof import('./src/components/layout/SidebarItem.vue')['default']
TableToolbar: typeof import('./src/components/common/TableToolbar.vue')['default']
}
}
......
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/vite.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Apple经销商ERP系统</title>
<meta name="description" content="Apple经销商ERP系统前端应用" />
<meta name="keywords" content="Apple,ERP,经销商,管理系统" />
</head>
<body>
<div id="app"></div>
<script type="module" src="/src/main.ts"></script>
</body>
</html>
<template>
<div id="app">
<!-- <div id="app">
<h1>Vue应用已启动</h1>
<p>如果您能看到这个页面，说明Vue应用正常运行</p>
<p>当前时间: {{ currentTime }}</p>
</div>
</div> -->
<router-view/>
</template>
<script setup lang="ts">
......@@ -18,9 +19,23 @@ onMounted(() => {
</script>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
html, body {
margin: 0;
padding: 0;
height: 100%;
overflow-x: hidden;
}
#app {
height: 100vh;
font-family: Arial, sans-serif;
padding: 20px;
margin: 0;
padding: 0;
}
</style>
......
import { request } from '@/utils/request'
import type { DictType, DictItem, PageRequest, PageResponse } from '@/types'
// 字典类型相关API
// 获取字典类型列表
export function getDictTypeListApi(): Promise<DictType[]> {
return request.get('/api/sys/dict/type/list')
}
// 获取字典类型分页列表
export function getDictTypePageApi(params: PageRequest & {
dictName?: string
import axios from 'axios'
const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8083'
const api = axios.create({
baseURL: API_BASE_URL,
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
api.interceptors.request.use(
(config) => {
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
return config
},
(error) => {
return Promise.reject(error)
}
)
api.interceptors.response.use(
(response) => {
return response.data
},
(error) => {
console.error('API请求错误:', error)
return Promise.reject(error)
}
)
export interface DictType {
dictTypeId: number
dictType: string
dictName: string
status: number
statusText: string
remark?: string
createBy?: string
createTime: string
updateBy?: string
updateTime: string
}
export interface DictItem {
dictItemId: number
dictTypeId: number
dictType: string
dictLabel: string
dictValue: string
sort: number
remark?: string
createBy?: string
createTime: string
updateBy?: string
updateTime: string
}
export interface DictTypeSearchParams {
dictType?: string
dictName?: string
status?: number
}): Promise<PageResponse<DictType>> {
return request.get('/api/sys/dict/type/page', params)
}
// 获取字典类型详情
export function getDictTypeDetailApi(dictId: number): Promise<DictType> {
return request.get(`/api/sys/dict/type/${dictId}`)
}
// 新增字典类型
export function addDictTypeApi(data: Partial<DictType>): Promise<void> {
return request.post('/api/sys/dict/type', data)
}
// 更新字典类型
export function updateDictTypeApi(data: Partial<DictType>): Promise<void> {
return request.put('/api/sys/dict/type', data)
}
// 删除字典类型
export function deleteDictTypeApi(dictId: number): Promise<void> {
return request.delete(`/api/sys/dict/type/${dictId}`)
}
// 批量删除字典类型
export function deleteBatchDictTypeApi(dictIds: number[]): Promise<void> {
return request.delete('/api/sys/dict/type/batch', { dictIds })
}
// 刷新字典缓存
export function refreshDictCacheApi(): Promise<void> {
return request.post('/api/sys/dict/type/refreshCache')
pageNum?: number
pageSize?: number
}
// 字典项相关API
// 获取字典项列表
export function getDictItemListApi(dictTypeId: number): Promise<DictItem[]> {
return request.get('/api/sys/dict/item/list', { dictTypeId })
}
// 获取字典项分页列表
export function getDictItemPageApi(params: PageRequest & {
export interface DictItemSearchParams {
dictTypeId?: number
dictLabel?: string
dictValue?: string
status?: number
}): Promise<PageResponse<DictItem>> {
return request.get('/api/sys/dict/item/page', params)
}
// 获取字典项详情
export function getDictItemDetailApi(dictItemId: number): Promise<DictItem> {
return request.get(`/api/sys/dict/item/${dictItemId}`)
}
// 新增字典项
export function addDictItemApi(data: Partial<DictItem>): Promise<void> {
return request.post('/api/sys/dict/item', data)
}
// 更新字典项
export function updateDictItemApi(data: Partial<DictItem>): Promise<void> {
return request.put('/api/sys/dict/item', data)
}
// 删除字典项
export function deleteDictItemApi(dictItemId: number): Promise<void> {
return request.delete(`/api/sys/dict/item/${dictItemId}`)
}
// 批量删除字典项
export function deleteBatchDictItemApi(dictItemIds: number[]): Promise<void> {
return request.delete('/api/sys/dict/item/batch', { dictItemIds })
}
// 根据字典类型获取字典项
export function getDictItemsByTypeApi(dictType: string): Promise<DictItem[]> {
return request.get(`/api/sys/dict/item/type/${dictType}`)
}
pageNum?: number
pageSize?: number
}
export interface DictTypeAddReq {
dictType: string
dictName: string
status: number
remark?: string
}
export interface DictTypeUpdateReq extends DictTypeAddReq {
dictTypeId: number
}
export interface DictItemAddReq {
dictTypeId: number
dictLabel: string
dictValue: string
sort?: number
remark?: string
}
export interface DictItemUpdateReq extends DictItemAddReq {
dictItemId: number
}
export interface ApiResponse<T = any> {
code: number
message: string
data: T
}
export interface PageResponse<T> {
records: T[]
total: number
size: number
current: number
orders: any[]
optimizeCountSql: boolean
searchCount: boolean
maxLimit: any
countId: any
pages: number
}
export const dictApi = {
// 字典类型管理
// 获取字典类型列表
getDictTypes: (params: DictTypeSearchParams): Promise<ApiResponse<PageResponse<DictType>>> => {
return api.get('/api/system/dict/type/list', { params })
},
// 获取字典类型详情
getDictTypeById: (dictTypeId: number): Promise<ApiResponse<DictType>> => {
return api.get(`/api/system/dict/type/${dictTypeId}`)
},
// 新增字典类型
createDictType: (dictTypeData: DictTypeAddReq): Promise<ApiResponse<any>> => {
return api.post('/api/system/dict/type', dictTypeData)
},
// 修改字典类型
updateDictType: (dictTypeData: DictTypeUpdateReq): Promise<ApiResponse<any>> => {
return api.put('/api/system/dict/type', dictTypeData)
},
// 删除字典类型
deleteDictTypes: (dictTypeIds: number[]): Promise<ApiResponse<any>> => {
return api.delete(`/api/system/dict/type/${dictTypeIds.join(',')}`)
},
// 获取字典类型选择框列表
getDictTypeOptions: (): Promise<ApiResponse<DictType[]>> => {
return api.get('/api/system/dict/type/optionselect')
},
// 刷新字典缓存
refreshDictCache: (): Promise<ApiResponse<any>> => {
return api.delete('/api/system/dict/type/refreshCache')
},
// 字典项管理
// 获取字典项列表
getDictItems: (params: DictItemSearchParams): Promise<ApiResponse<PageResponse<DictItem>>> => {
return api.get('/api/system/dict/item/list', { params })
},
// 根据字典类型获取字典项列表
getDictItemsByType: (dictType: string): Promise<ApiResponse<DictItem[]>> => {
return api.get(`/api/system/dict/item/type/${dictType}`)
},
// 获取字典项详情
getDictItemById: (dictItemId: number): Promise<ApiResponse<DictItem>> => {
return api.get(`/api/system/dict/item/${dictItemId}`)
},
// 新增字典项
createDictItem: (dictItemData: DictItemAddReq): Promise<ApiResponse<any>> => {
return api.post('/api/system/dict/item', dictItemData)
},
// 修改字典项
updateDictItem: (dictItemData: DictItemUpdateReq): Promise<ApiResponse<any>> => {
return api.put('/api/system/dict/item', dictItemData)
},
// 删除字典项
deleteDictItems: (dictItemIds: number[]): Promise<ApiResponse<any>> => {
return api.delete(`/api/system/dict/item/${dictItemIds.join(',')}`)
},
}
\ No newline at end of file
......
import axios from 'axios'
// 创建axios实例
const api = axios.create({
baseURL: 'http://localhost:8083/api/system/dict/item',
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
// 请求拦截器
api.interceptors.request.use(
(config) => {
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
return config
},
(error) => {
return Promise.reject(error)
}
)
// 响应拦截器
api.interceptors.response.use(
(response) => {
return response.data
},
(error) => {
console.error('API请求错误:', error)
if (error.response?.status === 401) {
localStorage.removeItem('token')
localStorage.removeItem('userInfo')
window.location.href = '/login'
}
return Promise.reject(error)
}
)
// 字典项接口类型定义
export interface DictItem {
dictItemId: number
dictTypeId: number
dictType: string
dictLabel: string
dictValue: string
sort: number
remark: string
createBy: string
createTime: string
updateBy: string
updateTime: string
}
export interface DictItemSearchParams {
pageNum: number
pageSize: number
dictTypeId?: number
dictLabel?: string
dictValue?: string
}
export interface DictItemAddReq {
dictTypeId: number
dictLabel: string
dictValue: string
sort?: number
remark?: string
}
export interface DictItemUpdateReq {
dictItemId: number
dictTypeId: number
dictLabel: string
dictValue: string
sort?: number
remark?: string
}
export interface ApiResponse<T> {
code: number
message: string
data: T
}
export interface PageData<T> {
records: T[]
total: number
current: number
size: number
pages: number
}
// API调用方法
export const dictItemApi = {
// 获取字典项列表
getDictItemList: (params: DictItemSearchParams): Promise<ApiResponse<PageData<DictItem>>> => {
return api.get('/list', { params })
},
// 根据字典类型获取字典项列表
getDictItemsByType: (dictType: string): Promise<ApiResponse<DictItem[]>> => {
return api.get(`/type/${dictType}`)
},
// 获取字典项详情
getDictItemById: (dictItemId: number): Promise<ApiResponse<DictItem>> => {
return api.get(`/${dictItemId}`)
},
// 新增字典项
createDictItem: (dictItemData: DictItemAddReq): Promise<ApiResponse<any>> => {
return api.post('/', dictItemData)
},
// 修改字典项
updateDictItem: (dictItemData: DictItemUpdateReq): Promise<ApiResponse<any>> => {
return api.put('/', dictItemData)
},
// 删除字典项
deleteDictItem: (dictItemIds: number[]): Promise<ApiResponse<any>> => {
const ids = dictItemIds.join(',')
return api.delete(`/${ids}`)
}
}
export default dictItemApi
import { request } from '@/utils/request'
import type { Log, PageRequest, PageResponse } from '@/types'
import axios from 'axios'
// 获取日志分页列表
export function getLogPageApi(params: PageRequest & {
title?: string
// 创建axios实例
const api = axios.create({
baseURL: 'http://localhost:8083/api/system/log',
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
// 请求拦截器
api.interceptors.request.use(
(config) => {
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
return config
},
(error) => {
return Promise.reject(error)
}
)
// 响应拦截器
api.interceptors.response.use(
(response) => {
return response.data
},
(error) => {
console.error('API请求错误:', error)
if (error.response?.status === 401) {
localStorage.removeItem('token')
localStorage.removeItem('userInfo')
window.location.href = '/login'
}
return Promise.reject(error)
}
)
// 日志接口类型定义
export interface Log {
logId: number
logType: string
logTypeText: string
userId: number
username: string
module: string
operation: string
ip: string
logTime: string
status: number
statusText: string
errorMsg: string
requestParam: string
createBy: string
createTime: string
updateBy: string
updateTime: string
}
export interface LogDetail {
logId: number
logType: string
logTypeText: string
userId: number
username: string
module: string
operation: string
ip: string
logTime: string
status: number
statusText: string
errorMsg: string
requestParam: string
createBy: string
createTime: string
updateBy: string
updateTime: string
}
export interface LogSearchParams {
pageNum: number
pageSize: number
logType?: string
userId?: number
username?: string
module?: string
operation?: string
ip?: string
status?: number
startTime?: string
endTime?: string
}): Promise<PageResponse<Log>> {
return request.get('/api/sys/log/page', params)
}
// 获取日志详情
export function getLogDetailApi(logId: number): Promise<Log> {
return request.get(`/api/sys/log/${logId}`)
export interface ApiResponse<T> {
code: number
message: string
data: T
}
// 删除日志
export function deleteLogApi(logId: number): Promise<void> {
return request.delete(`/api/sys/log/${logId}`)
export interface PageData<T> {
records: T[]
total: number
current: number
size: number
pages: number
}
// 批量删除日志
export function deleteBatchLogApi(logIds: number[]): Promise<void> {
return request.delete('/api/sys/log/batch', { logIds })
}
// API调用方法
export const logApi = {
// 获取日志列表
getLogList: (params: LogSearchParams): Promise<ApiResponse<PageData<Log>>> => {
return api.get('/page', { params })
},
// 清理过期日志
export function cleanExpiredLogsApi(days: number): Promise<void> {
return request.post('/api/sys/log/clean', { days })
}
// 获取日志详情
getLogDetail: (logId: number): Promise<ApiResponse<LogDetail>> => {
return api.get(`/${logId}`)
},
// 获取日志统计
export function getLogCountApi(params: {
logType?: string
startTime?: string
endTime?: string
}): Promise<{ total: number; success: number; error: number }> {
return request.get('/api/sys/log/count', params)
}
// 获取用户登录日志
getLoginLogsByUserId: (userId: number, startTime?: string, endTime?: string): Promise<ApiResponse<Log[]>> => {
return api.get(`/login/${userId}`, {
params: {
startTime,
endTime
}
})
},
// 获取用户登录日志
export function getUserLoginLogsApi(params: PageRequest & {
userId: number
startTime?: string
endTime?: string
}): Promise<PageResponse<Log>> {
return request.get('/api/sys/log/login', params)
// 清理过期日志
cleanExpiredLogs: (expireDays: number): Promise<ApiResponse<string>> => {
return api.delete('/clean', {
params: {
expireDays
}
})
},
// 统计日志数量
countLogs: (logType?: string, startTime?: string, endTime?: string): Promise<ApiResponse<number>> => {
return api.get('/count', {
params: {
logType,
startTime,
endTime
}
})
},
// 删除日志
deleteLog: (logId: number): Promise<ApiResponse<string>> => {
return api.delete(`/${logId}`)
},
// 批量删除日志
deleteLogs: (logIds: number[]): Promise<ApiResponse<string>> => {
return api.delete('/batch', { data: logIds })
}
}
export default logApi
\ No newline at end of file
......
import { request } from '@/utils/request'
import type { Menu, PageRequest, PageResponse } from '@/types'
import axios from 'axios'
// 获取菜单列表
export function getMenuListApi(): Promise<Menu[]> {
return request.get('/api/sys/menu/list')
}
// API基础配置
const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8083'
// 获取菜单树
export function getMenuTreeApi(userId?: number): Promise<Menu[]> {
return request.get('/api/sys/menu/tree', { userId })
}
// 创建axios实例
const api = axios.create({
baseURL: API_BASE_URL,
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
// 获取菜单分页列表
export function getMenuPageApi(params: PageRequest & {
menuName?: string
console.log('菜单API实例创建，baseURL:', API_BASE_URL)
// 请求拦截器 - 添加token
api.interceptors.request.use(
(config) => {
console.log('菜单API请求:', {
url: config.url,
baseURL: config.baseURL,
method: config.method,
params: config.params,
fullURL: `${config.baseURL}${config.url}`
})
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
return config
},
(error) => {
return Promise.reject(error)
}
)
// 响应拦截器
api.interceptors.response.use(
(response) => {
return response.data
},
(error) => {
console.error('API请求错误:', error)
return Promise.reject(error)
}
)
// 菜单接口类型定义
export interface Menu {
menuId: number
parentId?: number
menuName: string
menuType: string
menuTypeText: string
path?: string
menuType?: string
icon?: string
sort: number
status: number
statusText: string
perms?: string
}): Promise<PageResponse<Menu>> {
return request.get('/api/sys/menu/page', params)
component?: string
isFrame?: number
remark?: string
level?: number
createTime: string
updateTime: string
children?: Menu[]
}
// 获取菜单详情
export function getMenuDetailApi(menuId: number): Promise<Menu> {
return request.get(`/api/sys/menu/${menuId}`)
export interface MenuSearchParams {
menuName?: string
menuType?: string
status?: number
pageNum?: number
pageSize?: number
}
// 新增菜单
export function addMenuApi(data: Partial<Menu>): Promise<void> {
return request.post('/api/sys/menu', data)
export interface ApiResponse<T = any> {
code: number
message: string
data: T
}
// 更新菜单
export function updateMenuApi(data: Partial<Menu>): Promise<void> {
return request.put('/api/sys/menu', data)
export interface PageResponse<T> {
records: T[]
total: number
size: number
current: number
orders: any[]
optimizeCountSql: boolean
searchCount: boolean
maxLimit: any
countId: any
pages: number
}
// 删除菜单
export function deleteMenuApi(menuId: number): Promise<void> {
return request.delete(`/api/sys/menu/${menuId}`)
}
// 菜单API接口
export const menuApi = {
// 获取菜单列表
getMenuList: (params: MenuSearchParams): Promise<ApiResponse<PageResponse<Menu>>> => {
return api.get('/api/system/menu/list', { params })
},
// 批量删除菜单
export function deleteBatchMenuApi(menuIds: number[]): Promise<void> {
return request.delete('/api/sys/menu/batch', { menuIds })
}
// 获取菜单树列表
getMenuTree: (userId?: number): Promise<ApiResponse<Menu[]>> => {
return api.get('/api/system/menu/tree', { params: { userId } })
},
// 获取角色菜单树
export function getRoleMenuTreeApi(roleId: number): Promise<Menu[]> {
return request.get(`/api/sys/menu/roleMenuTree/${roleId}`)
}
// 获取菜单详情
getMenuById: (menuId: number): Promise<ApiResponse<Menu>> => {
return api.get(`/api/system/menu/${menuId}`)
},
// 新增菜单
createMenu: (menuData: any): Promise<ApiResponse<any>> => {
return api.post('/api/system/menu', menuData)
},
// 获取菜单选择树
export function getMenuSelectTreeApi(): Promise<Menu[]> {
return request.get('/api/sys/menu/treeselect')
// 修改菜单
updateMenu: (menuData: any): Promise<ApiResponse<any>> => {
return api.put('/api/system/menu', menuData)
},
// 删除菜单
deleteMenu: (menuIds: number[]): Promise<ApiResponse<any>> => {
return api.delete(`/api/system/menu/${menuIds.join(',')}`)
},
// 获取菜单下拉树选择
getMenuTreeSelect: (): Promise<ApiResponse<Menu[]>> => {
return api.get('/api/system/menu/treeselect')
},
// 根据角色ID获取菜单下拉树选择
getMenuTreeSelectByRole: (roleId: number): Promise<ApiResponse<Menu[]>> => {
return api.get(`/api/system/menu/roleMenuTreeselect/${roleId}`)
}
}
export default menuApi
\ No newline at end of file
......
import { request } from '@/utils/request'
import type { Role, PageRequest, PageResponse } from '@/types'
import axios from 'axios'
// 获取角色列表
export function getRoleListApi(): Promise<Role[]> {
return request.get('/api/sys/role/list')
// API基础配置
const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8083'
// 创建axios实例
const api = axios.create({
baseURL: API_BASE_URL,
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
console.log('角色API实例创建，baseURL:', API_BASE_URL)
// 请求拦截器 - 添加token
api.interceptors.request.use(
(config) => {
console.log('角色API请求:', {
url: config.url,
baseURL: config.baseURL,
method: config.method,
params: config.params,
fullURL: `${config.baseURL}${config.url}`
})
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
return config
},
(error) => {
return Promise.reject(error)
}
)
// 响应拦截器
api.interceptors.response.use(
(response) => {
return response.data
},
(error) => {
console.error('API请求错误:', error)
return Promise.reject(error)
}
)
// 菜单接口类型定义
export interface Menu {
menuId: number
parentId?: number
menuName: string
menuType: string
menuTypeText: string
path?: string
icon?: string
sort: number
status: number
statusText: string
perms?: string
createTime: string
updateTime: string
children?: Menu[]
}
// 获取角色分页列表
export function getRolePageApi(params: PageRequest & {
// 角色接口类型定义
export interface Role {
roleId: number
roleCode: string
roleName: string
status: number
statusText: string
remark: string
createTime: string
updateTime: string
menuIds?: number[]
menus?: Menu[]
}
export interface RoleSearchParams {
roleCode?: string
roleName?: string
roleKey?: string
status?: number
}): Promise<PageResponse<Role>> {
return request.get('/api/sys/role/page', params)
pageNum?: number
pageSize?: number
}
// 获取角色详情
export function getRoleDetailApi(roleId: number): Promise<Role> {
return request.get(`/api/sys/role/${roleId}`)
export interface ApiResponse<T = any> {
code: number
message: string
data: T
}
// 新增角色
export function addRoleApi(data: Partial<Role>): Promise<void> {
return request.post('/api/sys/role', data)
export interface PageResponse<T> {
records: T[]
total: number
size: number
current: number
orders: any[]
optimizeCountSql: boolean
searchCount: boolean
maxLimit: any
countId: any
pages: number
}
// 更新角色
export function updateRoleApi(data: Partial<Role>): Promise<void> {
return request.put('/api/sys/role', data)
}
// 角色API接口
export const roleApi = {
// 获取角色列表
getRoleList: (params?: RoleSearchParams): Promise<ApiResponse<PageResponse<Role>>> => {
return api.get('/api/system/role/list', { params })
},
// 删除角色
export function deleteRoleApi(roleId: number): Promise<void> {
return request.delete(`/api/sys/role/${roleId}`)
}
// 获取所有角色（不分页，用于下拉选择）
getAllRoles: (): Promise<ApiResponse<Role[]>> => {
return api.get('/api/system/role/list', {
params: { status: 1, pageSize: 9999 }
})
},
// 批量删除角色
export function deleteBatchRoleApi(roleIds: number[]): Promise<void> {
return request.delete('/api/sys/role/batch', { roleIds })
}
// 根据ID获取角色详情
getRoleById: (roleId: number): Promise<ApiResponse<Role>> => {
return api.get(`/api/system/role/${roleId}`)
},
// 修改角色状态
export function changeRoleStatusApi(data: {
roleId: number
status: number
}): Promise<void> {
return request.post('/api/sys/role/changeStatus', data)
}
// 创建角色
createRole: (roleData: any): Promise<ApiResponse<any>> => {
return api.post('/api/system/role/add', roleData)
},
// 分配权限
export function assignPermissionsApi(data: {
roleId: number
menuIds: number[]
}): Promise<void> {
return request.post('/api/sys/role/assignPermissions', data)
}
// 更新角色
updateRole: (roleData: any): Promise<ApiResponse<any>> => {
return api.post('/api/system/role/edit', roleData)
},
// 删除角色（单个或批量）
deleteRole: (roleIds: number[]): Promise<ApiResponse<any>> => {
return api.delete(`/api/system/role/${roleIds.join(',')}`)
},
// 更新角色状态
updateRoleStatus: (roleId: number, status: number): Promise<ApiResponse<any>> => {
return api.post('/api/system/role/changeStatus', {
roleId: roleId,
status: status
})
},
// 获取菜单树列表
getMenuTree: (): Promise<ApiResponse<Menu[]>> => {
return api.get('/api/system/menu/tree')
},
// 测试角色列表接口参数格式
testRoleListParams: (): RoleSearchParams => {
return {
roleCode: "",
roleName: "",
status: 1, // 默认获取有效角色
pageNum: 1,
pageSize: 9999 // 获取全部有效角色
}
}
}
\ No newline at end of file
......
import { request } from '@/utils/request'
import type { User, PageRequest, PageResponse } from '@/types'
import axios from 'axios'
// 获取用户列表
export function getUserListApi(): Promise<User[]> {
return request.get('/api/sys/user/list')
// API基础配置
const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8083'
// 创建axios实例
const api = axios.create({
baseURL: API_BASE_URL,
timeout: 10000,
headers: {
'Content-Type': 'application/json'
}
})
// 请求拦截器 - 添加token
api.interceptors.request.use(
(config) => {
const token = localStorage.getItem('token')
if (token) {
config.headers.Authorization = `Bearer ${token}`
}
return config
},
(error) => {
return Promise.reject(error)
}
)
// 响应拦截器 - 处理错误
api.interceptors.response.use(
(response) => {
return response
},
(error) => {
if (error.response?.status === 401) {
// token过期，跳转到登录页
localStorage.removeItem('token')
localStorage.removeItem('userInfo')
window.location.href = '/'
}
return Promise.reject(error)
}
)
// 用户数据类型
export interface User {
userId: number
username: string
realName: string
phone: string
email: string
status: number
statusText: string
remark: string
createBy: string
createTime: string
updateBy: string
updateTime: string
lastLoginTime: string | null
lastLoginIp: string | null
roles: Role[]
}
// 获取用户分页列表
export function getUserPageApi(params: PageRequest & {
// 角色类型
export interface Role {
roleId: number
roleCode: string
roleName: string
status: number
statusText: string
remark: string
createBy: string
createTime: string
updateBy: string
updateTime: string
menus: any
}
// 搜索参数类型
export interface UserSearchParams {
username?: string
realName?: string
phone?: string
email?: string
status?: number
}): Promise<PageResponse<User>> {
return request.get('/api/sys/user/page', params)
startTime?: string
endTime?: string
page?: number
pageSize?: number
}
// 获取用户详情
export function getUserDetailApi(userId: number): Promise<User> {
return request.get(`/api/sys/user/${userId}`)
// 用户表单类型
export interface UserForm {
userId?: number
username: string
realName: string
phone: string
email: string
status: number
remark: string
roleIds: number[]
password?: string
}
// 新增用户
export function addUserApi(data: Partial<User>): Promise<void> {
return request.post('/api/sys/user', data)
// API响应类型
export interface ApiResponse<T> {
code: number
message: string
data: T
}
// 更新用户
export function updateUserApi(data: Partial<User>): Promise<void> {
return request.put('/api/sys/user', data)
// 分页响应类型
export interface PageResponse<T> {
records: T[]
total: number
size: number
current: number
orders: any[]
optimizeCountSql: boolean
searchCount: boolean
maxLimit: any
countId: any
pages: number
}
// 删除用户
export function deleteUserApi(userId: number): Promise<void> {
return request.delete(`/api/sys/user/${userId}`)
}
// 用户API接口
export const userApi = {
// 获取用户列表
getUserList: async (params: UserSearchParams = {}) => {
try {
const response = await api.get<ApiResponse<PageResponse<User>>>('/api/system/user/list', { params })
return response.data
} catch (error) {
console.error('获取用户列表失败:', error)
throw error
}
},
// 批量删除用户
export function deleteBatchUserApi(userIds: number[]): Promise<void> {
return request.delete('/api/sys/user/batch', { userIds })
}
// 获取用户详情
getUserById: async (id: number) => {
try {
const response = await api.get<ApiResponse<User>>(`/api/system/user/${id}`)
return response.data
} catch (error) {
console.error('获取用户详情失败:', error)
throw error
}
},
// 重置密码
export function resetPasswordApi(data: {
userId: number
newPassword: string
}): Promise<void> {
return request.post('/api/sys/user/resetPassword', data)
}
// 创建用户
createUser: async (userData: UserForm) => {
try {
const response = await api.post<ApiResponse<User>>('/api/system/user/add', userData)
return response.data
} catch (error) {
console.error('创建用户失败:', error)
throw error
}
},
// 修改用户状态
export function changeUserStatusApi(data: {
userId: number
status: number
}): Promise<void> {
return request.post('/api/sys/user/changeStatus', data)
}
// 更新用户
updateUser: async (id: number, userData: UserForm) => {
try {
const response = await api.post<ApiResponse<User>>('/api/system/user/edit', userData)
return response.data
} catch (error) {
console.error('更新用户失败:', error)
throw error
}
},
// 删除用户（单个或批量）
deleteUser: async (id: number) => {
try {
const response = await api.delete<ApiResponse<void>>(`/api/system/user/${id}`)
return response.data
} catch (error) {
console.error('删除用户失败:', error)
throw error
}
},
// 批量删除用户
batchDeleteUsers: async (ids: number[]) => {
try {
const response = await api.delete<ApiResponse<void>>(`/api/system/user/${ids.join(',')}`)
return response.data
} catch (error) {
console.error('批量删除用户失败:', error)
throw error
}
},
// 更新用户状态
updateUserStatus: async (id: number, status: number) => {
try {
const response = await api.post<ApiResponse<void>>('/api/system/user/changeStatus', {
userId: id,
status: status
})
return response.data
} catch (error) {
console.error('更新用户状态失败:', error)
throw error
}
},
// 分配角色
export function assignRolesApi(data: {
userId: number
roleIds: number[]
}): Promise<void> {
return request.post('/api/sys/user/assignRoles', data)
}
export default userApi
\ No newline at end of file
......
This diff is collapsed. Click to expand it.
import { createApp } from 'vue'
import { createPinia } from 'pinia'
import App from './App.vue'
import router from './router'
// 创建应用实例
const app = createApp(App)
const pinia = createPinia()
app.use(pinia)
app.use(router)
// 挂载应用
app.mount('#app')
......
import { createRouter, createWebHistory } from 'vue-router'
import type { RouteRecordRaw } from 'vue-router'
import Login from '@/views/login/index.vue'
import MainLayout from '@/layouts/MainLayout.vue'
import Dashboard from '@/views/dashboard/index.vue'
import Users from '@/views/users/index.vue'
import Test from '@/views/Test.vue'
import NProgress from 'nprogress'
import 'nprogress/nprogress.css'
......@@ -11,6 +15,115 @@ NProgress.configure({ showSpinner: false })
const staticRoutes: RouteRecordRaw[] = [
{
path: '/',
name: 'Login',
component: Login,
meta: {
title: '登录',
requiresAuth: false
}
},
{
path: '/main',
component: MainLayout,
children: [
{
path: 'dashboard',
name: 'Dashboard',
component: Dashboard,
meta: {
title: '首页',
requiresAuth: true
}
},
{
path: 'users',
name: 'Users',
component: Users,
meta: {
title: '用户管理',
requiresAuth: true
}
},
{
path: 'sys/role',
name: 'Role',
component: () => import('@/views/sys/role/index.vue'),
meta: {
title: '角色管理',
requiresAuth: true
}
},
{
path: 'sys/menu',
name: 'Menu',
component: () => import('@/views/sys/menu/index.vue'),
meta: {
title: '菜单管理',
requiresAuth: true
}
},
{
path: 'sys/dict',
name: 'Dict',
component: () => import('@/views/sys/dict/index.vue'),
meta: {
title: '字典管理',
requiresAuth: true
}
},
{
path: 'sys/dict-item',
name: 'DictItem',
component: () => import('@/views/sys/dict-item/index.vue'),
meta: {
title: '字典项管理',
requiresAuth: true
}
},
{
path: 'sys/log',
name: 'Log',
component: () => import('@/views/sys/log/index.vue'),
meta: {
title: '日志管理',
requiresAuth: true
}
},
{
path: 'dicts',
name: 'Dicts',
component: () => import('@/views/dicts/index.vue'),
meta: {
title: '字典管理',
requiresAuth: true
}
},
{
path: 'logs',
name: 'Logs',
component: () => import('@/views/logs/index.vue'),
meta: {
title: '日志管理',
requiresAuth: true
}
},
{
path: 'settings',
name: 'Settings',
component: () => import('@/views/settings/index.vue'),
meta: {
title: '系统设置',
requiresAuth: true
}
}
]
},
{
path: '/dashboard',
redirect: '/main/dashboard'
},
{
path: '/test',
name: 'Test',
component: Test,
meta: {
......@@ -27,8 +140,13 @@ const router = createRouter({
scrollBehavior: () => ({ top: 0 })
})
// 路由守卫
router.beforeEach(async (to, from, next) => {
// 优化的路由守卫
router.beforeEach((to, from, next) => {
// 只在路由真正变化时记录日志
if (to.path !== from.path) {
console.log('路由变化:', { from: from.path, to: to.path })
}
// 开始进度条
NProgress.start()
......@@ -37,7 +155,24 @@ router.beforeEach(async (to, from, next) => {
document.title = `${to.meta.title} - Apple经销商ERP系统`
}
// 暂时跳过所有权限检查，直接放行
// 检查认证状态
if (to.meta.requiresAuth) {
const token = localStorage.getItem('token')
if (!token) {
console.log('未认证，跳转到登录页')
next('/')
return
}
}
// 如果已登录且访问登录页，跳转到首页
if (to.path === '/' && localStorage.getItem('token')) {
console.log('已登录，跳转到首页')
next('/main/dashboard')
return
}
// 继续导航
next()
})
......@@ -52,4 +187,4 @@ router.onError((error) => {
NProgress.done()
})
export default router
export default router
\ No newline at end of file
......
......@@ -12,9 +12,19 @@ const service: AxiosInstance = axios.create({
}
})
console.log('Axios实例创建，baseURL:', import.meta.env.VITE_API_BASE_URL)
// 请求拦截器
service.interceptors.request.use(
(config: any) => {
console.log('请求拦截器 - 请求配置:', {
url: config.url,
baseURL: config.baseURL,
method: config.method,
params: config.params,
headers: config.headers
})
const userStore = useUserStore()
// 添加token到请求头
......@@ -105,6 +115,7 @@ service.interceptors.response.use(
// 请求方法封装
export const request = {
get<T = any>(url: string, params?: any): Promise<T> {
console.log('Request GET:', url, params)
return service.get(url, { params })
},
......
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
<template>
<div class="user-management">
<!-- 搜索表单 -->
<el-card class="search-form">
<el-form :model="searchForm" inline>
<el-form-item label="用户名">
<el-input v-model="searchForm.username" placeholder="请输入用户名" clearable />
</el-form-item>
<el-form-item label="真实姓名">
<el-input v-model="searchForm.realName" placeholder="请输入真实姓名" clearable />
</el-form-item>
<el-form-item label="状态">
<el-select v-model="searchForm.status" placeholder="请选择状态" clearable>
<el-option label="正常" :value="1" />
<el-option label="停用" :value="0" />
</el-select>
</el-form-item>
<el-form-item>
<el-button type="primary" @click="handleSearch">
<el-icon><Search /></el-icon>
搜索
</el-button>
<el-button @click="handleReset">
<el-icon><Refresh /></el-icon>
重置
</el-button>
</el-form-item>
</el-form>
</el-card>
<!-- 操作按钮 -->
<el-card class="operation-buttons">
<el-button type="primary" @click="handleAdd">
<el-icon><Plus /></el-icon>
新增用户
</el-button>
<el-button type="danger" :disabled="!multipleSelection.length" @click="handleBatchDelete">
<el-icon><Delete /></el-icon>
批量删除
</el-button>
</el-card>
<!-- 数据表格 -->
<el-card class="table-container">
<el-table
v-loading="loading"
:data="tableData"
@selection-change="handleSelectionChange"
>
<el-table-column type="selection" width="55" />
<el-table-column prop="userId" label="用户ID" width="80" />
<el-table-column prop="username" label="用户名" width="120" />
<el-table-column prop="realName" label="真实姓名" width="120" />
<el-table-column prop="email" label="邮箱" width="200" />
<el-table-column prop="phone" label="手机号" width="120" />
<el-table-column prop="status" label="状态" width="80">
<template #default="{ row }">
<el-tag :type="row.status === 1 ? 'success' : 'danger'">
{{ row.status === 1 ? '正常' : '停用' }}
</el-tag>
</template>
</el-table-column>
<el-table-column prop="createTime" label="创建时间" width="180" />
<el-table-column label="操作" width="200" fixed="right">
<template #default="{ row }">
<el-button type="primary" size="small" @click="handleEdit(row)">
编辑
</el-button>
<el-button type="danger" size="small" @click="handleDelete(row)">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<!-- 分页 -->
<el-pagination
v-model:current-page="pagination.current"
v-model:page-size="pagination.size"
:total="pagination.total"
:page-sizes="[10, 20, 50, 100]"
layout="total, sizes, prev, pager, next, jumper"
@size-change="handleSizeChange"
@current-change="handleCurrentChange"
/>
</el-card>
</div>
</template>
<script setup lang="ts">
import { ref, reactive, onMounted } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import type { User } from '@/types'
// 搜索表单
const searchForm = reactive({
username: '',
realName: '',
status: undefined
})
// 表格数据
const tableData = ref<User[]>([])
const loading = ref(false)
const multipleSelection = ref<User[]>([])
// 分页
const pagination = reactive({
current: 1,
size: 10,
total: 0
})
// 获取用户列表
const getUserList = async () => {
loading.value = true
try {
// 这里应该调用API
// const response = await getUserPageApi({ ...searchForm, ...pagination })
// tableData.value = response.records
// pagination.total = response.total
// 模拟数据
tableData.value = [
{
userId: 1,
username: 'admin',
realName: '管理员',
email: 'admin@example.com',
phone: '13800138000',
status: 1,
createTime: '2024-01-01 10:00:00',
updateTime: '2024-01-01 10:00:00',
roles: [],
permissions: []
}
]
pagination.total = 1
} catch (error) {
ElMessage.error('获取用户列表失败')
} finally {
loading.value = false
}
}
// 搜索
const handleSearch = () => {
pagination.current = 1
getUserList()
}
// 重置
const handleReset = () => {
Object.assign(searchForm, {
username: '',
realName: '',
status: undefined
})
handleSearch()
}
// 新增用户
const handleAdd = () => {
ElMessage.info('新增用户功能待实现')
}
// 编辑用户
const handleEdit = (row: User) => {
ElMessage.info(`编辑用户: ${row.username}`)
}
// 删除用户
const handleDelete = async (row: User) => {
try {
await ElMessageBox.confirm(`确定要删除用户 "${row.username}" 吗？`, '提示', {
confirmButtonText: '确定',
cancelButtonText: '取消',
type: 'warning'
})
ElMessage.success('删除成功')
getUserList()
} catch (error) {
// 用户取消删除
}
}
// 批量删除
const handleBatchDelete = async () => {
try {
await ElMessageBox.confirm(`确定要删除选中的 ${multipleSelection.value.length} 个用户吗？`, '提示', {
confirmButtonText: '确定',
cancelButtonText: '取消',
type: 'warning'
})
ElMessage.success('批量删除成功')
getUserList()
} catch (error) {
// 用户取消删除
}
}
// 选择变化
const handleSelectionChange = (selection: User[]) => {
multipleSelection.value = selection
}
// 分页大小变化
const handleSizeChange = (size: number) => {
pagination.size = size
getUserList()
}
// 当前页变化
const handleCurrentChange = (current: number) => {
pagination.current = current
getUserList()
}
// 组件挂载时获取数据
onMounted(() => {
getUserList()
})
</script>
<style lang="scss" scoped>
.user-management {
.search-form {
margin-bottom: 16px;
}
.operation-buttons {
margin-bottom: 16px;
}
.table-container {
.el-pagination {
margin-top: 16px;
text-align: right;
}
}
}
</style>
This diff is collapsed. Click to expand it.
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import { resolve } from 'path'
import AutoImport from 'unplugin-auto-import/vite'
import Components from 'unplugin-vue-components/vite'
import { ElementPlusResolver } from 'unplugin-vue-components/resolvers'
// https://vitejs.dev/config/
export default defineConfig({
plugins: [vue()],
plugins: [
vue(),
AutoImport({
resolvers: [ElementPlusResolver()],
}),
Components({
resolvers: [ElementPlusResolver()],
}),
],
resolve: {
alias: {
'@': resolve(__dirname, 'src')
......
# 字段验证错误显示功能说明
## 功能概述
前端用户管理页面现在支持显示后端返回的详细字段验证错误信息，提供更好的用户体验。
## 功能特性
### 1. 字段级错误显示
- 当后端返回 `400` 状态码和详细的字段错误信息时，前端会自动解析并在对应字段下方显示错误信息
- 支持的错误格式：`{"code":400,"message":"参数验证失败","data":{"email":"邮箱格式不正确"}}`
### 2. 视觉反馈
- 有错误的字段会显示红色边框
- 错误信息以红色文字显示在字段下方
- 错误信息字体较小，不影响整体布局
### 3. 错误清除机制
- 打开新增/编辑对话框时自动清除之前的错误信息
- 重新提交表单时清除之前的错误信息
## 支持的字段
以下字段支持错误显示：
- `username` - 用户名
- `realName` - 真实姓名
- `phone` - 手机号
- `email` - 邮箱
- `remark` - 备注
## 后端错误格式要求
后端需要返回以下格式的错误信息：
```json
{
"code": 400,
"message": "参数验证失败",
"data": {
"username": "用户名已存在",
"email": "邮箱格式不正确",
"phone": "手机号格式不正确"
}
}
```
## 使用示例
### 1. 邮箱格式错误
当用户输入无效邮箱时：
- 邮箱输入框显示红色边框
- 输入框下方显示"邮箱格式不正确"
### 2. 用户名重复
当用户名已存在时：
- 用户名输入框显示红色边框
- 输入框下方显示"用户名已存在"
### 3. 多个字段错误
当多个字段都有错误时：
- 所有有错误的字段都会显示红色边框
- 每个字段下方显示对应的错误信息
## 技术实现
### 1. 响应式错误状态
```javascript
const fieldErrors = reactive<Record<string, string>>({})
```
### 2. 错误解析函数
```javascript
const parseFieldErrors = (errorData: any) => {
clearFieldErrors()
if (errorData && typeof errorData === 'object') {
Object.keys(errorData).forEach(field => {
fieldErrors[field] = errorData[field]
})
}
}
```
### 3. 模板绑定
```vue
<input
v-model="userForm.email"
type="email"
class="form-input"
:class="{ 'error': fieldErrors.email }"
/>
<div v-if="fieldErrors.email" class="field-error">{{ fieldErrors.email }}</div>
```
## 样式说明
### 错误状态样式
```css
.form-input.error, .form-select.error {
border-color: #ff4d4f;
box-shadow: 0 0 0 2px rgba(255, 77, 79, 0.2);
}
.field-error {
color: #ff4d4f;
font-size: 11px;
margin-top: 4px;
display: block;
line-height: 1.4;
}
```
## 测试方法
1. 打开用户管理页面
2. 点击"新增用户"按钮
3. 输入无效的邮箱格式（如：`invalid-email`）
4. 点击保存
5. 观察邮箱字段是否显示红色边框和错误信息
## 注意事项
1. 错误信息会在用户重新打开对话框时自动清除
2. 只有后端返回 `400` 状态码且包含 `data` 字段时才会显示字段级错误
3. 如果后端返回其他格式的错误，仍会显示通用错误信息
4. 错误信息支持中文，建议后端返回中文错误信息以提供更好的用户体验
# 用户管理时间格式修改说明
## 修改内容
将用户管理列表中的创建时间格式从 ISO 格式改为更易读的格式：
- **修改前**: `2025-09-23T17:49:06`
- **修改后**: `2025-09-23 17:49:06`
## 技术实现
### 1. 添加时间格式化函数
```javascript
// 格式化时间显示
const formatDateTime = (dateTime: string | undefined): string => {
if (!dateTime) return ''
// 将 ISO 格式的时间字符串转换为可读格式
// 例如: 2025-09-23T17:49:06 -> 2025-09-23 17:49:06
return dateTime.replace('T', ' ')
}
```
### 2. 修改模板显示
```vue
<!-- 修改前 -->
<td>{{ user.createTime }}</td>
<!-- 修改后 -->
<td>{{ formatDateTime(user.createTime) }}</td>
```
## 功能特点
1. **空值处理**: 如果时间字段为空或未定义，返回空字符串
2. **简单替换**: 使用 `replace('T', ' ')` 将 ISO 格式中的 `T` 替换为空格
3. **类型安全**: 使用 TypeScript 确保类型安全
4. **性能优化**: 简单的字符串替换，性能开销很小
## 影响范围
- **用户管理列表**: 创建时间列显示格式已修改
- **其他时间字段**: 目前只修改了 `createTime` 字段
- **搜索功能**: 时间搜索功能不受影响
## 测试方法
1. 打开用户管理页面
2. 查看用户列表中的"创建时间"列
3. 确认时间格式显示为 `2025-09-23 17:49:06` 而不是 `2025-09-23T17:49:06`
## 扩展说明
如果需要修改其他时间字段（如 `updateTime`），可以按照相同的方式：
```vue
<td>{{ formatDateTime(user.updateTime) }}</td>
```
## 注意事项
1. 这个修改只影响前端显示，不影响后端数据存储格式
2. 时间搜索功能仍然使用原始的 ISO 格式
3. 如果后端返回的时间格式发生变化，这个函数仍然可以正常工作
# 时间选择器功能说明
## 功能概述
用户管理页面的时间搜索组件已升级为具有悬停弹出选项功能的高级时间选择器，提供更便捷的时间范围选择体验。
## 功能特性
### 1. 悬停弹出选项
- 鼠标悬停在时间输入框上时，自动弹出时间选项菜单
- 支持快速选择常用的时间范围
- 提供直观的视觉反馈
### 2. 预设时间选项
- **今天**: 选择当前日期
- **昨天**: 选择昨天的日期
- **本周**: 选择本周开始日期（周一）
- **上周**: 选择上周的时间范围
- **本月**: 选择本月开始日期
- **上月**: 选择上月的时间范围
- **自定义**: 打开原生日期选择器
### 3. 智能时间范围
- 开始时间和结束时间都有独立的选项菜单
- 结束时间会自动选择合理的结束日期
- 支持时间范围的逻辑验证
## 技术实现
### 1. 组件结构
```vue
<div class="date-picker-container">
<input
v-model="searchForm.startTime"
type="text"
class="date-input"
readonly
@mouseenter="showStartDateOptions = true"
@mouseleave="hideStartDateOptions"
/>
<div v-if="showStartDateOptions" class="date-options">
<!-- 时间选项列表 -->
</div>
</div>
```
### 2. 状态管理
```javascript
// 时间选择器状态
const showStartDateOptions = ref(false)
const showEndDateOptions = ref(false)
const showStartDatePicker = ref(false)
const showEndDatePicker = ref(false)
```
### 3. 时间计算函数
- `getCurrentDate()`: 获取当前日期
- `getDateBefore(days)`: 获取指定天数前的日期
- `getWeekStart()`: 获取本周开始日期
- `getMonthStart()`: 获取本月开始日期
- `getLastMonthStart()`: 获取上月开始日期
- `getLastMonthEnd()`: 获取上月结束日期
## 使用方法
### 1. 快速选择时间
1. 将鼠标悬停在"开始时间"或"结束时间"输入框上
2. 在弹出的选项菜单中选择所需的时间范围
3. 系统自动填充对应的日期
### 2. 自定义时间选择
1. 悬停在时间输入框上
2. 选择"自定义"选项
3. 使用原生日期选择器选择具体日期
### 3. 时间范围搜索
1. 选择开始时间和结束时间
2. 点击"搜索"按钮执行查询
3. 系统会搜索指定时间范围内的用户
## 样式设计
### 1. 选项菜单样式
```css
.date-options {
position: absolute;
top: 100%;
background: white;
border: 1px solid #d9d9d9;
border-radius: 4px;
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
z-index: 1000;
}
```
### 2. 选项项样式
```css
.date-option {
padding: 8px 12px;
cursor: pointer;
transition: background-color 0.2s;
}
.date-option:hover {
background-color: #f5f5f5;
color: #1890ff;
}
```
## 交互逻辑
### 1. 悬停显示
- 鼠标进入输入框时显示选项菜单
- 鼠标离开输入框时延迟隐藏菜单（200ms）
- 鼠标进入选项菜单时保持显示状态
### 2. 选择处理
- 点击选项后自动填充对应日期
- 选择"自定义"时显示原生日期选择器
- 选择完成后自动隐藏选项菜单
### 3. 时间范围逻辑
- 开始时间不能晚于结束时间
- 结束时间不能早于开始时间
- 支持空值选择（只选择开始时间或结束时间）
## 兼容性
- 支持现代浏览器的原生日期选择器
- 降级到文本输入框（readonly）
- 响应式设计，适配不同屏幕尺寸
## 扩展功能
### 1. 可添加的选项
- 最近7天
- 最近30天
- 最近3个月
- 最近一年
### 2. 可优化的功能
- 时间范围验证
- 快捷清除功能
- 时间格式显示优化
## 测试方法
1. 打开用户管理页面
2. 将鼠标悬停在"创建时间"的输入框上
3. 观察是否弹出选项菜单
4. 点击不同选项测试功能
5. 选择"自定义"测试原生日期选择器
6. 执行搜索验证时间范围功能
## 注意事项
1. 时间格式统一使用 YYYY-MM-DD 格式
2. 时区处理基于浏览器本地时间
3. 选项菜单的 z-index 设置为 1000，确保显示在最上层
4. 延迟隐藏机制避免鼠标快速移动时菜单闪烁