package com.jilongda.manage.authority.controller;
|
|
|
import cn.afterturn.easypoi.excel.ExcelExportUtil;
|
import cn.afterturn.easypoi.excel.ExcelImportUtil;
|
import cn.afterturn.easypoi.excel.entity.ExportParams;
|
import cn.afterturn.easypoi.excel.entity.ImportParams;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.github.xiaoymin.knife4j.core.util.StrUtil;
|
import com.jilongda.common.model.TDept;
|
import com.jilongda.common.redis.RedisAutoTemplate;
|
import com.jilongda.common.utils.CodeGenerateUtils;
|
import com.jilongda.manage.authority.dto.ResetPasswordDTO;
|
import com.jilongda.manage.authority.dto.SecUserDTO;
|
import com.jilongda.manage.authority.dto.SecUserRoleDTO;
|
import com.jilongda.manage.authority.dto.SecUsersDTO;
|
import com.jilongda.manage.authority.model.SecResources;
|
import com.jilongda.manage.authority.model.SecRole;
|
import com.jilongda.manage.authority.model.SecUser;
|
import com.jilongda.manage.authority.model.SecUserRole;
|
import com.jilongda.manage.authority.query.SecUserLowerQuery;
|
import com.jilongda.manage.authority.service.SecResourcesService;
|
import com.jilongda.manage.authority.service.SecRoleService;
|
import com.jilongda.manage.authority.service.SecUserRoleService;
|
import com.jilongda.manage.authority.service.SecUserService;
|
import com.jilongda.manage.authority.vo.SecResourceVO;
|
import com.jilongda.manage.authority.vo.SecUsersVO;
|
import com.jilongda.manage.model.TOptometrist;
|
import com.jilongda.manage.query.TOptometristQuery;
|
import com.jilongda.manage.utils.LoginInfoUtil;
|
import com.jilongda.manage.utils.UserUtil;
|
import com.jilongda.common.basic.ApiResult;
|
import com.jilongda.common.basic.Constant;
|
import com.jilongda.common.basic.PageInfo;
|
import com.jilongda.common.exception.ServiceException;
|
import com.jilongda.common.log.OperationLog;
|
import com.jilongda.common.utils.ImportExcelUtil;
|
import com.jilongda.common.utils.WebUtils;
|
import com.jilongda.manage.vo.UserAddListVO;
|
import com.jilongda.manage.vo.UserLevelVO;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.poi.ss.usermodel.Workbook;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.security.authentication.BadCredentialsException;
|
import org.springframework.security.crypto.password.PasswordEncoder;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.Assert;
|
import org.springframework.util.StringUtils;
|
import org.springframework.validation.annotation.Validated;
|
import org.springframework.web.bind.annotation.*;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.servlet.ServletOutputStream;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.net.URLEncoder;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 前端控制器
|
* </p>
|
*
|
* @author xiaochen
|
* @since 2022-06-08
|
*/
|
@Api(tags = "用户管理")
|
@RestController
|
@Slf4j
|
@RequestMapping("/sec-user")
|
public class SecUserController {
|
|
private final SecUserService secUserService;
|
private final SecRoleService secRoleService;
|
private final SecResourcesService secResourcesService;
|
private final PasswordEncoder passwordEncoder;
|
private final UserUtil userUtil;
|
private final SecUserRoleService secUserRoleService;
|
private final LoginInfoUtil loginInfoUtil;
|
private final RedisAutoTemplate redisAutoTemplate;
|
|
@Autowired
|
public SecUserController(SecUserService secUserService, SecRoleService secRoleService, SecResourcesService secResourcesService, PasswordEncoder passwordEncoder, UserUtil userUtil, SecUserRoleService secUserRoleService, LoginInfoUtil loginInfoUtil, RedisAutoTemplate redisAutoTemplate) {
|
this.secUserService = secUserService;
|
this.secRoleService = secRoleService;
|
this.secResourcesService = secResourcesService;
|
this.passwordEncoder = passwordEncoder;
|
this.userUtil = userUtil;
|
this.secUserRoleService = secUserRoleService;
|
this.loginInfoUtil = loginInfoUtil;
|
this.redisAutoTemplate = redisAutoTemplate;
|
}
|
|
|
/*@ApiOperation(value = "获取用户的资源（菜单及功能）-有层级", notes = "获取用户的资源（菜单及功能）-有层级")
|
@GetMapping("resources/{uid}")
|
public ApiResult<List<SecResourceVO>> userResources(@PathVariable String uid) {
|
// List<SecResourceVO> sysResourceVos = secUserService.selectUserResourcesTag(uid);
|
List<SecResourceVO> sysResourceVos = secUserService.getResourceTag(uid);
|
return ApiResult.success(sysResourceVos);
|
}*/
|
|
|
@ApiOperation(value = "获取用户的资源（菜单及功能）-有层级", notes = "获取用户的资源（菜单及功能）-有层级")
|
@GetMapping("/resources")
|
public ApiResult<List<SecResourceVO>> userResources() {
|
// List<SecResourceVO> sysResourceVos = secUserService.selectUserResourcesTag(uid);
|
SecUser secUser = userUtil.getSecUser();
|
Assert.isTrue(Objects.nonNull(secUser), "当前用户异常,请联系管理员");
|
List<SecResourceVO> sysResourceVos = secUserService.getResourceTag(secUser.getId());
|
return ApiResult.success(sysResourceVos);
|
}
|
|
@ApiOperation(value = "获取用户字典", notes = "获取用户字典")
|
@GetMapping("/dist")
|
public ApiResult<List<SecUser>> dist() {
|
List<SecUser> users = secUserService.list(Wrappers.lambdaQuery(SecUser.class).ne(SecUser::getAccount, Constant.ADMIN));
|
return ApiResult.success(users);
|
}
|
|
@ApiOperation(value = "获取用户的资源（菜单及功能）--- 无层级", notes = "获取用户的资源（菜单及功能）--无层级")
|
@GetMapping("/resources/nolevel/{uid}")
|
public ApiResult<List<SecResources>> nolevel(@PathVariable Long uid) {
|
List<SecResources> sysResources = secResourcesService.getSecResourcesMapper().selectResourceByUid(uid);
|
return ApiResult.success(sysResources);
|
}
|
|
@ApiOperation(value = "获取用户信息", notes = "获取用户信息")
|
@GetMapping("/userinfo/{uid}")
|
public ApiResult<Map<String, Object>> userinfo(@PathVariable Long uid) {
|
Map<String, Object> map = new HashMap<>(2);
|
SecUser secUser = secUserService.getById(uid);
|
// String prefixByUser = salesTierService.getPrefixByUser(secUser.getPersonnelStructureId());
|
// secUser.setChildrenPrefix(prefixByUser);
|
secUser.setPassword(null);
|
map.put("userinfo", secUser);
|
// 角色信息 == 应关联查询，排除为删除状态的
|
List<SecRole> sysRoles = secRoleService.getSecRoleMapper().selectRolesByUid(uid);
|
List<Long> roleIds = sysRoles.stream().map(SecRole::getId).distinct().collect(Collectors.toList());
|
map.put("roleIds", roleIds);
|
return ApiResult.success(map);
|
}
|
|
@ApiOperation("查询-获取用户列表")
|
@PostMapping("/getSysUserList")
|
public ApiResult<PageInfo<SecUsersVO>> getSysUserList(@RequestBody SecUsersDTO dto) {
|
return ApiResult.success(secUserService.getSysUserList(dto));
|
}
|
|
@ApiOperation("查询-获取用户列表-不分页")
|
@PostMapping("/getSysUserListNotPage")
|
public ApiResult<List<SecUser>> getSysUserListNotPage() {
|
return ApiResult.success(secUserService.queryList());
|
}
|
|
@OperationLog(operType = "新增或编辑", operDesc = "新增或编辑用户", operModul = "用户")
|
@ApiOperation("新增-编辑-新增或编辑用户")
|
@PostMapping("/addOrUpdateUser")
|
public ApiResult<String> addOrUpdateUser(@Validated @RequestBody SecUserDTO dto) {
|
secUserService.addOrUpdateUser(dto);
|
return ApiResult.success();
|
}
|
|
@ApiOperation(value = "通过门店id查询验光师列表")
|
@GetMapping(value = "/queryListByStoreId")
|
public ApiResult<List<SecUser>> queryListByStoreId(@RequestParam Integer storeId) {
|
List<SecUser> secUsers = secUserService.list(Wrappers.lambdaQuery(SecUser.class)
|
.eq(SecUser::getStoreId,storeId));
|
return ApiResult.success(secUsers);
|
}
|
|
@OperationLog(operType = "重置", operDesc = "重置密码", operModul = "用户")
|
@ApiOperation("重置(修改)密码 不传密码为重置(123456),传密码为修改")
|
@PostMapping("/resetPassword")
|
public ApiResult<String> resetPassword(@Validated @RequestBody ResetPasswordDTO dto) {
|
// 账号查询用户
|
SecUser secUser = secUserService.getOne(Wrappers.lambdaQuery(SecUser.class)
|
.eq(SecUser::getAccount, dto.getAccount()));
|
Assert.isTrue(Objects.nonNull(secUser), "该账号不存在");
|
if (StrUtil.isNotBlank(dto.getPassword())) {
|
// 根据加密算法加密用户输入的密码，然后和数据库中保存的密码进行比较
|
if (!this.passwordEncoder.matches(dto.getOldPassword(), secUser.getPassword())) {
|
throw new BadCredentialsException("输入原密码不正确");
|
}
|
// 修改密码
|
secUser.setPassword(passwordEncoder.encode(dto.getPassword()));
|
} else {
|
// 重置密码
|
secUser.setPassword(passwordEncoder.encode(Constant.DEF_PASSWORD));
|
}
|
secUserService.updateById(secUser);
|
return ApiResult.success();
|
}
|
|
@OperationLog(operType = "修改", operDesc = "密码修改", operModul = "用户")
|
@ApiOperation("首页密码修改")
|
@PostMapping("/pageResetPassword")
|
public ApiResult<String> pageResetPassword(@Validated @RequestBody ResetPasswordDTO dto) {
|
// 账号查询用户
|
SecUser secUser = secUserService.getOne(Wrappers.lambdaQuery(SecUser.class)
|
.eq(SecUser::getAccount, dto.getAccount()));
|
Assert.isTrue(Objects.nonNull(secUser), "该账号不存在");
|
|
// 校验短信验证码
|
String str = redisAutoTemplate.getStr(secUser.getPhone());
|
if(!StringUtils.hasLength(str)){
|
return ApiResult.failed("验证码已过期!");
|
}
|
if(!str.equals(dto.getCode())){
|
return ApiResult.failed("验证码有误!");
|
}
|
|
if (StrUtil.isNotBlank(dto.getPassword())) {
|
// 根据加密算法加密用户输入的密码，然后和数据库中保存的密码进行比较
|
if (!this.passwordEncoder.matches(dto.getOldPassword(), secUser.getPassword())) {
|
throw new BadCredentialsException("输入原密码不正确");
|
}
|
// 修改密码
|
secUser.setPassword(passwordEncoder.encode(dto.getPassword()));
|
} else {
|
// 重置密码
|
secUser.setPassword(passwordEncoder.encode(Constant.DEF_PASSWORD));
|
}
|
secUserService.updateById(secUser);
|
return ApiResult.success();
|
}
|
|
@OperationLog(operType = "启用禁用", operDesc = "系统用户启用禁用", operModul = "用户")
|
@ApiOperation("系统用户启用禁用 state（0,1） 非0 则为禁用")
|
@PutMapping("/state/{id}/{state}")
|
public ApiResult<String> state(@PathVariable("id") Long id, @PathVariable("state") Boolean state) {
|
SecUser secUser = secUserService.getById(id);
|
if (secUser == null) {
|
return ApiResult.failed(500, "该用户不存在");
|
}
|
secUser.setState(state);
|
secUserService.updateById(secUser);
|
return ApiResult.success();
|
}
|
|
@OperationLog(operType = "删除", operDesc = "删除用户", operModul = "用户")
|
@ApiOperation(value = "删除-删除用户", notes = "删除用户")
|
@DeleteMapping("del/{uid}")
|
public ApiResult<String> delUser(@PathVariable Long uid) {
|
SecUser secUser = secUserService.getById(uid);
|
if (Constant.ADMIN.equals(secUser.getAccount())) {
|
return ApiResult.failed(500, "超级管理员不可删除");
|
}
|
secUserService.removeById(uid);
|
return ApiResult.success();
|
}
|
|
@OperationLog(operType = "批量删除", operDesc = "批量删除用户", operModul = "用户")
|
@ApiOperation(value = "批量删除-删除用户", notes = "批量删除用户")
|
@DeleteMapping("batch-del")
|
public ApiResult<String> batchDelUser(@RequestBody List<Long> uids) {
|
for (Long uid : uids) {
|
delUser(uid);
|
}
|
return ApiResult.success();
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@OperationLog(operType = "新增", operDesc = "人员绑定角色", operModul = "用户")
|
@ApiOperation(value = "人员绑定角色", notes = "人员绑定角色")
|
@PutMapping("userBindRole")
|
public ApiResult<String> userBindRole(@RequestBody SecUserRoleDTO dto) {
|
List<Long> userIds = dto.getUserIds();
|
Assert.isTrue(CollectionUtils.isNotEmpty(userIds), "请选择用户");
|
// 删除该用户所有的角色
|
secUserRoleService.remove(Wrappers.lambdaQuery(SecUserRole.class)
|
.eq(SecUserRole::getRoleId, dto.getRoleId()));
|
long count = secUserRoleService.count(Wrappers.lambdaQuery(SecUserRole.class)
|
.in(SecUserRole::getUserId, userIds));
|
if (count > 0) {
|
throw new ServiceException(500, "选中用户中已有用户关联其他角色，请重新选择!");
|
}
|
List<SecUserRole> secUserRoles = new ArrayList<>(userIds.size());
|
for (Long userId : userIds) {
|
SecUserRole secUserRole = new SecUserRole();
|
secUserRole.setUserId(userId);
|
secUserRole.setRoleId(dto.getRoleId());
|
secUserRoles.add(secUserRole);
|
}
|
secUserRoleService.saveBatch(secUserRoles);
|
return ApiResult.success();
|
}
|
|
@ApiOperation(value = "KAM查看用户下级", notes = "KAM查看用户下级")
|
@PostMapping("queryLower")
|
public ApiResult<PageInfo<SecUser>> queryLower(@RequestBody SecUserLowerQuery query) {
|
PageInfo<SecUser> secUserPageInfo = secUserService.queryLower(query);
|
return ApiResult.success(secUserPageInfo);
|
}
|
|
@ApiOperation(value = "用户导入模板")
|
@GetMapping("/import-template")
|
public void importProduct() {
|
List<SecUser> secUserExcels = new ArrayList<>();
|
Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams("用户导入模板", "用户导入模板"), SecUser.class, secUserExcels);
|
HttpServletResponse response = WebUtils.response();
|
ServletOutputStream outputStream = null;
|
try {
|
String fileName = URLEncoder.encode("用户导入模板.xls", "utf-8");
|
response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
|
response.setHeader("content-Type", "application/vnd.ms-excel");
|
response.setHeader("Pragma", "no-cache");
|
response.setHeader("Cache-Control", "no-cache");
|
outputStream = response.getOutputStream();
|
workbook.write(outputStream);
|
} catch (IOException e) {
|
e.printStackTrace();
|
log.error("用户导入模板下载失败！");
|
} finally {
|
try {
|
outputStream.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
@ApiOperation(value = "用户导入")
|
@PostMapping("/import-user")
|
public ApiResult<String> importUser(@RequestParam("file") MultipartFile file) {
|
ImportParams params = new ImportParams();
|
params.setTitleRows(1);//标题行数
|
params.setHeadRows(1); //表头行数
|
try {
|
InputStream inputStream = file.getInputStream();
|
List<SecUser> secUserList = ExcelImportUtil.importExcel(inputStream, SecUser.class, params);
|
secUserList = secUserList.stream().filter(user -> StringUtils.hasLength(user.getAccount())).collect(Collectors.toList());
|
for (SecUser secUser : secUserList) {
|
log.info("人员数据密码加密处理=========:{}", secUser);
|
String s = secUser.getAccount().replaceAll("\n", "");
|
Pattern p = Pattern.compile("\\s*|\t|\r|\n");
|
Matcher m = p.matcher(s);
|
s = m.replaceAll("");
|
secUser.setAccount(s);
|
// 密码加密
|
secUser.setPassword(passwordEncoder.encode(secUser.getPassword()));
|
}
|
|
log.info("人员数据处理完毕=========:{}", secUserList);
|
List<String> errors = new ArrayList<>();
|
// 去除 listSysRoles 中重复的数据
|
for (int i = 0; i < secUserList.size(); i++) {
|
String accountI = secUserList.get(i).getAccount();
|
for (int j = i + 1; j < secUserList.size(); j++) {
|
String accountJ = secUserList.get(j).getAccount();
|
// 发现重复数据
|
if (accountI.equals(accountJ)) {
|
errors.add("第 " + (j + 1) + " 行的 account 值：" + accountI + " 已存在，忽略导入");
|
secUserList.remove(j);
|
break;
|
}
|
}
|
}
|
// 去掉 sql 中的重复数据
|
Integer errorLines = 0;
|
Integer successLines = 0;
|
// List<String> lis1t = ImportExcelUtil.importDateSave(secUserList, SecUser.class, errors, Constant.PHONE_UNI);
|
for (int i = 0; i < secUserList.size(); i++) {
|
try {
|
log.info("保存前==================================");
|
boolean save = secUserService.save(secUserList.get(i));
|
log.info("保存后==================================");
|
if (!save) {
|
throw new Exception(Constant.PHONE_UNI);
|
}
|
} catch (Exception e) {
|
String message = e.getMessage().toLowerCase();
|
int lineNumber = i + 1;
|
// 通过索引名判断出错信息
|
if (message.contains(Constant.PRODUCT_NUMBER_UNI)) {
|
errors.add("第 " + lineNumber + " 行：商品编号已经存在，忽略导入。");
|
} else if (message.contains(Constant.PHONE_UNI)) {
|
errors.add("第 " + lineNumber + " 行：人员手机号已经存在，忽略导入。");
|
} else if (message.contains(Constant.SHOP_NUMBER_UNI)) {
|
errors.add("第 " + lineNumber + " 行：门店编号已经存在，忽略导入。");
|
} else if (message.contains(Constant.SHOP_OWN_NUMBER_UNI)) {
|
errors.add("第 " + lineNumber + " 行：门店系统生成编号已经存在，忽略导入。");
|
} else {
|
errors.add("第 " + lineNumber + " 行：未知错误，忽略导入");
|
log.error(e.getMessage(), e);
|
}
|
}
|
}
|
errorLines += errors.size();
|
successLines += (secUserList.size() - errorLines);
|
ApiResult<String> stringApiResult = ImportExcelUtil.importReturnMsg(errorLines, successLines, errors);
|
log.info(stringApiResult.getMsg());
|
return stringApiResult;
|
} catch (Exception e) {
|
log.error("用户导入失败!" + e.getMessage());
|
}
|
return ApiResult.success();
|
}
|
|
}
|
