package com.system.user.controller;
|
|
|
import java.net.URLDecoder;
|
import java.util.Arrays;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import javax.servlet.http.HttpServletResponse;
|
|
import com.system.user.dao.SysUserDao;
|
import org.apache.commons.codec.digest.DigestUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.apache.shiro.authc.*;
|
import org.apache.shiro.cache.Cache;
|
import org.apache.shiro.cache.ehcache.EhCacheManager;
|
import org.apache.shiro.subject.Subject;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.RequestBody;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RequestMethod;
|
import org.springframework.web.bind.annotation.RequestParam;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import com.app.aspect.MyLog;
|
import com.app.base.control.WebController;
|
import com.app.base.data.ApiResponseResult;
|
import com.app.base.utils.MD5Util;
|
import com.app.config.annotation.UserLoginToken;
|
import com.app.config.service.TokenService;
|
import com.system.role.service.SysRoleService;
|
import com.system.user.entity.SysUser;
|
import com.system.user.service.SysUserService;
|
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiImplicitParam;
|
import io.swagger.annotations.ApiImplicitParams;
|
import io.swagger.annotations.ApiOperation;
|
import io.swagger.models.Model;
|
|
|
@Api(description = "登录管理模块")
|
@RestController
|
public class LoginController extends WebController{
|
|
@Autowired
|
private SysUserDao sysUserDao;
|
|
@Autowired
|
private SysUserService sysUserService;
|
|
@Autowired
|
TokenService tokenService;
|
@Autowired
|
private EhCacheManager ecm;
|
|
protected Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
@ApiOperation(value = "登录", notes = "登录")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "username", value = "编码", dataType = "Long", paramType = "query", defaultValue = ""),
|
@ApiImplicitParam(name = "password", value = "密码", dataType = "Long", paramType = "query", defaultValue = "")
|
})
|
@MyLog(value = "登录")
|
@GetMapping("/login1")
|
public ApiResponseResult login(@RequestParam(value = "username",required=false) String username, @RequestParam(value = "password",required=false) String password,
|
@RequestParam(value = "rememberMe", required = false) boolean rememberMe) {
|
String method = "/login1";String methodName ="登录";
|
try {
|
username = username.toUpperCase();//用户名转换成大写
|
|
if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password)){
|
getSysLogService().error(method,methodName,"用户名或密码为空");
|
return ApiResponseResult.failure("用户名或密码不能为空！");
|
}
|
|
//用户是否存在
|
/*SysUser userForBase = sysUserDao.findByFcode(username);
|
if(userForBase == null){
|
getSysLogService().error(method,methodName,"用户不存在");
|
return ApiResponseResult.failure("该用户不存在，请联系管理员！");
|
}*/
|
|
//用户登录
|
try {
|
// 1、 封装用户名、密码、是否记住我到token令牌对象 [支持记住我]
|
AuthenticationToken token = new UsernamePasswordToken(
|
username, DigestUtils.md5Hex(password),
|
rememberMe);
|
// 2、 Subject调用login
|
Subject subject = SecurityUtils.getSubject();
|
// 在调用了login方法后,SecurityManager会收到AuthenticationToken,并将其发送给已配置的Realm执行必须的认证检查
|
// 每个Realm都能在必要时对提交的AuthenticationTokens作出反应
|
// 所以这一步在调用login(token)方法时,它会走到MyRealm.doGetAuthenticationInfo()方法中,具体验证方式详见此方法
|
logger.debug("用户登录，用户验证开始！user=" + username);
|
subject.login(token);
|
logger.info("用户登录，用户验证通过！user=" + username);
|
getSysLogService().success(method,methodName,"");
|
} catch (UnknownAccountException uae) {
|
logger.error("用户登录，用户验证未通过：未知用户！user=" + username, uae);
|
getSysLogService().error(method,methodName,"用户不存在");
|
return ApiResponseResult.failure("该用户不存在，请联系管理员！");
|
} catch (IncorrectCredentialsException ice) {
|
// 获取输错次数
|
logger.error("用户登录，用户验证未通过：错误的凭证，密码输入错误！user=" + username, ice);
|
getSysLogService().error(method,methodName,"用户验证未通过");
|
return ApiResponseResult.failure("用户名或密码不正确！");
|
} catch (LockedAccountException lae) {
|
logger.error("用户登录，用户验证未通过：账户已锁定！user=" + username, lae);
|
getSysLogService().error(method,methodName,"账户已锁定");
|
return ApiResponseResult.failure("账户已锁定！");
|
} catch (ExcessiveAttemptsException eae) {
|
logger.error(
|
"用户登录，用户验证未通过：错误次数大于5次,账户已锁定！user=" + username, eae);
|
getSysLogService().error(method,methodName,"用户名或密码错误次数大于5次,账户已锁定");
|
return ApiResponseResult.failure("用户名或密码错误次数大于5次,账户已锁定!</br><span style='color:red;font-weight:bold; '>2分钟后可再次登录，或联系管理员解锁</span>");
|
// 这里结合了，另一种密码输错限制的实现，基于redis或mysql的实现；也可以直接使用RetryLimitHashedCredentialsMatcher限制5次
|
} catch (DisabledAccountException sae){
|
logger.error("用户登录，用户验证未通过：帐号已经禁止登录！user=" +username, sae);
|
return ApiResponseResult.failure("帐号已经禁止登录！");
|
}catch (AuthenticationException ae) {
|
// 通过处理Shiro的运行时AuthenticationException就可以控制用户登录失败或密码错误时的情景
|
logger.error("用户登录，用户验证未通过：认证异常，异常信息如下！user=" + username, ae);
|
getSysLogService().error(method,methodName,"用户名或密码不正确");
|
return ApiResponseResult.failure("用户名或密码不正确！");
|
} catch (Exception e) {
|
logger.error("用户登录，用户验证未通过：操作异常，异常信息如下！user=" + username, e);
|
getSysLogService().error(method,methodName,"用户登录失败");
|
return ApiResponseResult.failure("用户登录失败，请您稍后再试！");
|
}
|
Cache<String, AtomicInteger> passwordRetryCache = ecm
|
.getCache("passwordRetryCache");
|
// if (null != passwordRetryCache) {
|
// int retryNum = (passwordRetryCache.get(userForBase.getMobile()) == null ? 0
|
// : passwordRetryCache.get(userForBase.getMobile())).intValue();
|
// logger.debug("输错次数：" + retryNum);
|
// if (retryNum > 0 && retryNum < 6) {
|
// return ApiResponseResult.failure("用户名或密码错误" + retryNum + "次,再输错" + (6 - retryNum) + "次账号将锁定");
|
// }
|
// }
|
return ApiResponseResult.success("用户登录成功！");
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("用户登录失败！");
|
}
|
// return ApiResponseResult.failure();
|
}
|
|
@UserLoginToken
|
@GetMapping("/getMessage")
|
public String getMessage(){
|
return "你已通过验证";
|
}
|
|
@RequestMapping(value = "/console")
|
public String console(){
|
return "/console";
|
}
|
|
@ApiOperation(value = "用户登录验证", notes = "根据用户Id验证用户密码是否正确，进行登录验证; 登录成功后，置为上线")
|
@ApiImplicitParam(name = "username", value = "用户Id", paramType = "Query", required = true, dataType = "String")
|
@RequestMapping(value = "/login", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult login(@RequestBody Map<String, Object> params) {
|
try {
|
String username = params.get("username").toString().toUpperCase();
|
String password = params.get("password").toString();
|
|
if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password)){
|
return ApiResponseResult.failure("用户名或密码不能为空！");
|
}
|
|
List<Map<String, Object>> userForBase=sysUserService.findByUserCode(username);
|
if(userForBase.size() == 0){
|
return ApiResponseResult.failure("用户不存在！");
|
}else {
|
//验证密码
|
String p = userForBase.get(0).get("FPASSWORD").toString();
|
p =proPass(p);
|
if(!p.equals(password)){
|
return ApiResponseResult.failure("用户名或者密码不正确！");
|
}else{
|
return ApiResponseResult.success("登录成功！").data(userForBase.get(0));
|
}
|
}
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("用户登录失败！"+e.toString());
|
}
|
}
|
|
// 解密算法
|
private String proPass(String src) throws Exception {
|
String result = "";
|
int first = new Integer(src.substring(0, 1)).intValue();
|
String src_tem = src.substring(1);
|
byte[] b = src_tem.getBytes("iso8859-1");
|
byte[] temp = b;
|
int i = 0;
|
for (; i < b.length; i++) {
|
temp[i] = new Integer(new Integer(temp[i]).intValue() ^ (first + 18))
|
.byteValue();
|
}
|
result = new String(temp);
|
return result;
|
}
|
|
|
@ApiOperation(value = "查询版本号", notes = "查询版本号")
|
@RequestMapping(value = "/queryVersion", method = RequestMethod.GET, produces = "application/json")
|
public ApiResponseResult queryVersion() {
|
try {
|
List<Map<String, Object>> userForBase=sysUserService.queryVersion();
|
if(userForBase.size() == 0){
|
return ApiResponseResult.failure("版本号不存在！");
|
}else {
|
return ApiResponseResult.success("查询版本号成功！").data(userForBase);
|
}
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("查询版本号失败！");
|
}
|
}
|
|
@ApiOperation(value = "查询运行环境", notes = "查询运行环境")
|
@RequestMapping(value = "/queryRunEnv", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult queryRunEnv() {
|
try {
|
List<Map<String, Object>> userForBase=sysUserService.queryRunEnv();
|
if(userForBase.size() == 0){
|
return ApiResponseResult.failure("运行环境不存在！");
|
}else {
|
return ApiResponseResult.success("查询运行环境成功！").data(userForBase);
|
}
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("查询运行环境失败！");
|
}
|
}
|
|
@ApiOperation(value = "查询权限", notes = "查询权限")
|
@ApiImplicitParam(name = "userno", value = "用户Id", paramType = "Query", required = true, dataType = "String")
|
@RequestMapping(value = "/queryPurview", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult queryPurview(@RequestParam(value = "userno") String userno) {
|
try {
|
List<Map<String, Object>> userForBase=sysUserService.queryPurview(userno);
|
if(userForBase.size() == 0){
|
return ApiResponseResult.failure("权限不存在！");
|
}else {
|
return ApiResponseResult.success("查询权限成功！").data(userForBase);
|
}
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("查询权限失败！");
|
}
|
}
|
|
@ApiOperation(value = "功能界面", notes = "功能界面")
|
@ApiImplicitParam(name = "functionName", value = "方法名称", paramType = "Query", required = true, dataType = "String")
|
@RequestMapping(value = "/getRfSetup", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult getRfSetup(@RequestParam(value = "functionName") String functionName) {
|
try {
|
System.out.println(functionName);
|
String username = URLDecoder.decode(functionName,"UTF-8");
|
return sysUserService.getRfSetup(functionName);
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("查询功能界面失败！");
|
}
|
}
|
|
@ApiOperation(value = "功能执行存储过程 ", notes = "功能执行存储过程 ")
|
@ApiImplicitParam(name = "functionName", value = "方法名称", paramType = "Query", required = true, dataType = "String")
|
@RequestMapping(value = "/getExcProc", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult getExcProc(@RequestParam(value = "functionName") String functionName,
|
@RequestParam(value = "fileName") String fileName,@RequestParam(value = "pmachtype") String pmachtype,
|
@RequestParam(value = "fileValue") String fileValue,@RequestParam(value = "outFiles") String outFiles) {
|
try {
|
System.out.println(functionName);
|
functionName = URLDecoder.decode(functionName,"UTF-8");
|
return sysUserService.getExcProc(functionName,fileName,pmachtype,fileValue,outFiles);
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("查询功能界面失败！");
|
}
|
}
|
|
@ApiOperation(value = "列表功能返回游标 ", notes = "列表功能返回游标 ")
|
@ApiImplicitParam(name = "functionName", value = "方法名称", paramType = "Query", required = true, dataType = "String")
|
@RequestMapping(value = "/getCursor", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult getCursor( @RequestParam(value = "functionName") String functionName,
|
@RequestParam(value = "fileName") String fileName,@RequestParam(value = "pmachtype") String pmachtype,
|
@RequestParam(value = "fileValue") String fileValue,@RequestParam(value = "outFiles") String outFiles) {
|
try {
|
functionName = URLDecoder.decode(functionName,"UTF-8");
|
return sysUserService.getCursor(functionName,fileName,pmachtype,fileValue,outFiles);
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("获取列表失败！");
|
}
|
}
|
|
|
@ApiOperation(value = "查询app版本号", notes = "查询app版本号")
|
@RequestMapping(value = "/queryAppVersion", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult queryAppVersion() {
|
try {
|
return sysUserService.queryAppVersion();
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("查询版本号失败！");
|
}
|
}
|
|
|
@ApiOperation(value = "修改密码", notes = "修改密码")
|
@RequestMapping(value = "/changPsw", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult changPsw(@RequestParam(value = "usercode") String usercode,@RequestParam(value = "oldp") String oldp,@RequestParam(value = "newp") String newp) {
|
try {
|
|
if(StringUtils.isEmpty(usercode) || StringUtils.isEmpty(oldp) || StringUtils.isEmpty(newp)){
|
return ApiResponseResult.failure("用户名或密码不能为空！");
|
}
|
|
List<Map<String, Object>> userForBase=sysUserService.findByUserCode(usercode);
|
if(userForBase.size() == 0){
|
return ApiResponseResult.failure("用户不存在！");
|
}else {
|
//验证密码
|
String p = userForBase.get(0).get("FPASSWORD").toString();
|
p =proPass(p);
|
if(!p.equals(oldp)){
|
return ApiResponseResult.failure("用户名或者密码不正确！");
|
}else{
|
return sysUserService.changPsw(usercode, encryptPass(newp));
|
//return ApiResponseResult.success("登录成功！").data(userForBase.get(0));
|
}
|
}
|
} catch (Exception e) {
|
System.out.println(e.toString());
|
return ApiResponseResult.failure("用户登录失败！"+e.toString());
|
}
|
}
|
|
// 解密算法
|
private String encryptPass(String str) throws Exception {
|
//byte[] temp = new byte[255] ;
|
byte[] b = str.getBytes("iso8859-1");
|
byte[] temp =b;
|
int i = 0;
|
for (; i < b.length; i++) {
|
temp[i] = new Integer(new Integer(b[i]).intValue() ^ (8 + 18))
|
.byteValue();
|
}
|
String result = 8 + new String(temp);
|
return result;
|
}
|
|
|
@ApiOperation(value = "根据SQL查询内容 ", notes = "根据SQL查询内容 ")
|
@RequestMapping(value = "/getExcuteSql", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult getExcuteSql(@RequestParam(value = "str") String str) {
|
try {
|
return sysUserService.getExcuteSql(str);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ApiResponseResult.failure("查询SQL内容失败！");
|
}
|
}
|
|
@ApiOperation(value = "根据Id查询打印内容 ", notes = "根据Id查询打印内容 ")
|
@RequestMapping(value = "/getPrintInfoById", method = RequestMethod.POST, produces = "application/json")
|
public ApiResponseResult getPrintInfoById(@RequestParam(value = "ids") String ids) {
|
try {
|
if(StringUtils.isNotEmpty(ids)) {
|
List<String> list = Arrays.asList(ids.split(","));
|
return sysUserService.getPrintInfo(list);
|
}else {
|
return ApiResponseResult.failure("id不能为空！");
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
return ApiResponseResult.failure("查询打印内容失败！");
|
}
|
}
|
}
|
