package com.landtool.lanbase.modules.sys.controller;
|
|
import java.awt.image.BufferedImage;
|
import java.io.IOException;
|
import java.net.URLEncoder;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import javax.imageio.ImageIO;
|
import javax.servlet.ServletException;
|
import javax.servlet.ServletOutputStream;
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
|
import org.apache.commons.io.IOUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.apache.shiro.session.Session;
|
import org.apache.shiro.subject.Subject;
|
import org.apache.shiro.util.StringUtils;
|
import org.apache.shiro.web.util.SavedRequest;
|
import org.apache.shiro.web.util.WebUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RequestMethod;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import com.alibaba.druid.support.json.JSONUtils;
|
import com.alibaba.fastjson.JSONObject;
|
import com.google.code.kaptcha.Constants;
|
import com.google.code.kaptcha.Producer;
|
import com.landtool.lanbase.common.Constant;
|
import com.landtool.lanbase.common.annotation.LogLogininfo;
|
import com.landtool.lanbase.common.exception.LanbaseException;
|
import com.landtool.lanbase.common.shiro.ShiroToken;
|
import com.landtool.lanbase.common.utils.CoderUtils;
|
import com.landtool.lanbase.common.utils.HttpUtils;
|
import com.landtool.lanbase.common.utils.RedisUtils;
|
import com.landtool.lanbase.common.utils.Result;
|
import com.landtool.lanbase.common.utils.ShiroUtils;
|
import com.landtool.lanbase.config.SysTemPropertyConfig;
|
import com.landtool.lanbase.modules.org.entity.OrgUser;
|
import com.landtool.lanbase.modules.org.service.OrgUserService;
|
import com.landtool.lanbase.modules.sys.redis.OnlineUserRedis;
|
import com.landtool.lanbase.modules.sys.service.SysUserTokenService;
|
|
import springfox.documentation.annotations.ApiIgnore;
|
|
/**
|
* @author lanbase
|
* @Description: TODO(登录相关)
|
* @date 2017-6-23 15:07
|
*/
|
@RestController
|
@ApiIgnore()
|
public class SysLoginController extends AbstractController {
|
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
@Autowired
|
private Producer producer;
|
@Autowired
|
private OrgUserService orgUserService;
|
@Autowired
|
private SysUserTokenService sysUserTokenService;
|
@Autowired
|
private SysTemPropertyConfig sysConfig;
|
|
@Autowired
|
private OnlineUserRedis onlineUserRedis;
|
@Autowired
|
private RedisUtils redisUtils;
|
/**
|
* 在线人数map
|
*/
|
private static ConcurrentHashMap<String,Object> onlineuser=new ConcurrentHashMap<String,Object>();
|
|
|
/**
|
* 首页
|
*
|
* @param request
|
* @param response
|
* @throws IOException
|
*/
|
@RequestMapping(value = "/", method = RequestMethod.GET)
|
public void hutaiadmin(HttpServletRequest request, HttpServletResponse response) throws IOException {
|
response.sendRedirect("/res/ZiYuanZhongXin/index?Menu=ZYZX&menuId=07");
|
// cannot call sendRedirect() after the response has been commited
|
// 1、resopnse 重定向后没有return
|
// 2、重定向后还有重定向，重复的重定向
|
return;
|
}
|
|
@RequestMapping("/captcha.jpg")
|
public void captcha(HttpServletResponse response) throws ServletException, IOException {
|
response.setHeader("Cache-Control", "no-store, no-cache");
|
response.setContentType("image/jpeg");
|
|
// 生成文字验证码
|
String text = producer.createText();
|
// 生成图片验证码
|
BufferedImage image = producer.createImage(text);
|
// 保存到shiro session
|
ShiroUtils.setSessionAttribute(Constants.KAPTCHA_SESSION_KEY, text);
|
|
ServletOutputStream out = response.getOutputStream();
|
ImageIO.write(image, "jpg", out);
|
IOUtils.closeQuietly(out);
|
}
|
|
/**
|
* 获取登录错误次数
|
*/
|
@RequestMapping(value = "/sys/getLoginErrorTimes", method = RequestMethod.GET)
|
public Result getLoginErrorTimes() {
|
Object errorTimes = ShiroUtils.getSessionAttribute(Constant.LOGIN_ERROR_TIMES);
|
return Result.ok().put("errorTimes", errorTimes);
|
}
|
|
/**
|
* 登录
|
*/
|
@LogLogininfo("登录")
|
@RequestMapping(value = "/sys/login", method = RequestMethod.POST)
|
public Result login(String username, String password, String captcha) throws IOException {
|
Object _login_errors = ShiroUtils.getSessionAttribute(Constant.LOGIN_ERROR_TIMES);
|
if (_login_errors == null) {
|
_login_errors = 0;
|
}
|
long errorTimes = Long.valueOf(_login_errors.toString());
|
|
// 用户信息
|
OrgUser user = orgUserService.queryByUserName(username);
|
|
// 账号不存在
|
if (user == null) {
|
ShiroUtils.setSessionAttribute(Constant.LOGIN_ERROR_TIMES, ++errorTimes);
|
return Result.error("账号不存在").put("errorTimes", errorTimes);
|
}
|
|
// 密码错误
|
try {
|
if (!user.getPassword().equals(CoderUtils.lantuEncryptMD5(password))) {
|
ShiroUtils.setSessionAttribute(Constant.LOGIN_ERROR_TIMES, ++errorTimes);
|
return Result.error("密码不正确").put("errorTimes", errorTimes);
|
}
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
}
|
|
// 验证码
|
if (errorTimes >= 3) {
|
String kaptcha = getKaptcha(Constants.KAPTCHA_SESSION_KEY);
|
if (!captcha.equalsIgnoreCase(kaptcha)) {
|
ShiroUtils.setSessionAttribute(Constant.LOGIN_ERROR_TIMES, ++errorTimes);
|
return Result.error("验证码不正确").put("errorTimes", errorTimes);
|
}
|
}
|
|
// 账号锁定
|
if (Constant.UserStatus.DISABLE.getValue() == user.getUserstatus()) {
|
ShiroUtils.setSessionAttribute(Constant.LOGIN_ERROR_TIMES, ++errorTimes);
|
return Result.error("账号已被锁定,请联系管理员").put("errorTimes", errorTimes);
|
}
|
|
// 生成token，并保存到数据库
|
Map<String, Object> result = sysUserTokenService.createToken(user.getUserid());
|
Result r = Result.ok().put(result);
|
return r;
|
}
|
|
private String getLoginNamefromXml(HttpServletRequest request) throws Exception {
|
String username = "";
|
|
Subject subject = SecurityUtils.getSubject();
|
Session session = subject.getSession(true);
|
username = session.getAttribute("shirousername") == null ? ""
|
: session.getAttribute("shirousername").toString();
|
logger.debug("4----shirousername:" + session.getAttribute("shirousername") + (session.getId()));
|
if (org.springframework.util.StringUtils.isEmpty(username)) {
|
String CasHost = sysConfig.getCasHost();// https://cas.nmsmp.com/cas/
|
String loginUrl = sysConfig.getLoginUrl(); // http://127.0.0.1:8082/login
|
|
String ticket = request.getParameter("ticket");
|
|
if (!org.springframework.util.StringUtils.isEmpty(ticket)) {
|
String server = getOldQueryString(request);
|
String url = CasHost.replace("https", "http");
|
String validateurl = url + "serviceValidate?ticket=" + ticket + "&service=" + loginUrl + "?oldurl="
|
+ URLEncoder.encode(server);
|
;
|
|
logger.debug("2----ServiceValidate:" + validateurl);
|
|
String casxml;
|
casxml = HttpUtils.get(validateurl);
|
logger.debug(casxml);
|
Integer index = casxml.indexOf("<cas:user>");
|
Integer end = casxml.indexOf("</cas:user>");
|
|
if (index > 0) {
|
username = casxml.substring(index + 10, end);
|
}
|
}
|
}
|
return username;
|
}
|
|
@LogLogininfo("登录")
|
@RequestMapping(value = "/index", method = RequestMethod.GET)
|
@ResponseBody
|
public void index(HttpServletRequest request, HttpServletResponse response) throws IOException {
|
String username = request.getRemoteUser();
|
response.setCharacterEncoding("utf-8");
|
response.setContentType("text/plain");
|
response.getWriter().write(username + "登陆成功！");
|
}
|
|
/**
|
* oa门户反验证 获取地址上的validatename,调用反验证接口获取结果,为true,则允许登录
|
*/
|
|
public JSONObject portallogin(HttpServletRequest request) {
|
String result = "";
|
String querystring = request.getQueryString();
|
String username = "";
|
if (querystring != null) {
|
String par[] = querystring.split("&");
|
for (int i = 0; i < par.length; i++) {
|
String a = par[i].split("=")[0];
|
String v = par[i].split("=")[1];
|
if (a.equals("validateNumber")) {
|
String validateurl = "http://192.168.4.50/services/PortalLoginService/ValidLoginUser?validateNumber="
|
+ v;
|
try {
|
result = HttpUtils.get(validateurl);
|
} catch (Exception e) {
|
logger.info(result);
|
e.printStackTrace();
|
}
|
}
|
if (a.equals("userName")) {
|
username = v;
|
}
|
}
|
int start = result.indexOf("<ns:return>");
|
int end = result.indexOf("</ns:return>");
|
if (start != -1 && end != -1) {
|
JSONObject json = JSONObject.parseObject(result.substring(start + 11, end));
|
json.put("username", username);
|
|
return json;
|
}
|
}
|
return null;
|
|
}
|
|
/**
|
* CAS登陆成功后调用此方法创建本系统的token
|
*
|
* @param request
|
* @param response
|
* @return
|
* @throws Exception
|
*/
|
@LogLogininfo("登录")
|
@RequestMapping(value = "/login", method = RequestMethod.GET)
|
public void login(HttpServletRequest request, HttpServletResponse response) throws Exception {
|
String username = request.getRemoteUser();
|
if (StringUtils.hasText(username)) {// 已经登录shiro
|
String oldUrl = getOldParameterPath(request);
|
response.sendRedirect(oldUrl);
|
// WebUtils.issueRedirect(request, response, oldUrl);
|
// } else {
|
//
|
// // oa门户登录判断
|
// JSONObject validateresult = portallogin(request);
|
// if (validateresult != null && "true".equals(validateresult.getString("validateResult"))) {
|
// String oldUrl = getOldParameterPath(request);
|
// Subject subject = SecurityUtils.getSubject();
|
// ShiroToken shiroToken = new ShiroToken(validateresult.getString("username"), true);
|
// subject.login(shiroToken);
|
// WebUtils.issueRedirect(request, response, oldUrl);
|
} else {
|
|
username = getLoginNamefromXml(request);
|
// username="kanglinchong";
|
// username="liujin";
|
// username="hanzhicong";
|
|
if (StringUtils.hasText(username)) {
|
OrgUser user = orgUserService.queryByUserName(username);
|
// 账号不存在
|
if (user == null) {
|
response.getWriter().write("[" + username + "]账号不存在或未注册到系统");
|
return;
|
}
|
Subject subject = SecurityUtils.getSubject();
|
ShiroToken shiroToken = new ShiroToken(username, true);
|
|
if (!subject.isAuthenticated()) {
|
subject.login(shiroToken);
|
logger.debug("8----loginshiro:");
|
}
|
//这里算用户登录成功 ,存入名称和当前毫秒数kv入在线map add by zsx
|
|
onlineUserRedis.saveOnlineUser(username,subject.getSession());
|
|
|
Session session = subject.getSession(true);
|
session.setAttribute("shirousername", username);
|
// session.setMaxInactiveInterval(sysConfig.getSessionTimeOut());//
|
// 设置Session的超时时间
|
// 单位秒
|
logger.debug("3----shirousername:" + session.getAttribute("shirousername").toString()
|
+ (session.getId()));
|
String oldUrl = getOldQueryString(request);
|
|
logger.debug("3----RedirectOldurl:" + oldUrl);
|
// WebUtils.issueRedirect(request, response, oldUrl);
|
response.sendRedirect(oldUrl);
|
} else {
|
String CasHost = sysConfig.getCasHost();// https://cas.nmsmp.com/cas/
|
String loginUrl = sysConfig.getLoginUrl(); // http://127.0.0.1:8082/login
|
String oldurl = getOldSessionPath(request);
|
if (StringUtils.hasText(oldurl)) {
|
CasHost += "login?service=" + loginUrl + "?oldurl=" + URLEncoder.encode(oldurl);
|
}
|
logger.debug("1----RedirectCasloginUrl:" + CasHost);
|
response.sendRedirect(CasHost);// 用户名不存在跳转回登录页面
|
}
|
}
|
}
|
|
|
private String getOldQueryString(HttpServletRequest request) {
|
String server = request.getQueryString();
|
String ticket = request.getParameter("ticket");
|
if (!org.springframework.util.StringUtils.isEmpty(ticket)) {
|
server = server.replace("ticket=" + ticket, "");
|
if (server.endsWith("&"))
|
server = server.substring(0, server.length() - 1);
|
}
|
server = server.replace("oldurl=", "");
|
return server;
|
}
|
|
/***
|
* 获取原始访问路径
|
*
|
* @return
|
*/
|
private String getOldParameterPath(HttpServletRequest request) {
|
String oldUrl = request.getParameter("oldurl");
|
oldUrl = (oldUrl == null) ? "/" : oldUrl;
|
return oldUrl;
|
}
|
|
/***
|
* 获取原始访问路径
|
*
|
* @return
|
*/
|
private String getOldSessionPath(HttpServletRequest request) {
|
String oldurl = getOldParameterPath(request);
|
if (oldurl == "/") {
|
Subject subject = SecurityUtils.getSubject();
|
Session session = subject.getSession();
|
SavedRequest req = (SavedRequest) session.getAttribute(WebUtils.SAVED_REQUEST_KEY);
|
oldurl = (req == null) ? "" : req.getRequestUrl();
|
}
|
return oldurl;
|
}
|
|
/**
|
* CAS登陆成功后调用此方法创建本系统的token 返回jsonp
|
*
|
* @param request
|
* @param response
|
* @return
|
*/
|
@LogLogininfo("登录")
|
@RequestMapping(value = "/sys/caslogin2", method = RequestMethod.GET)
|
@ResponseBody
|
public String caslogin2(HttpServletRequest request, HttpServletResponse response) {
|
String callbackFunName = request.getParameter("callback"); // js回调函数名称
|
if (callbackFunName == null || callbackFunName.isEmpty()) {
|
callbackFunName = "casloginCallback";
|
}
|
response.setCharacterEncoding("utf-8");
|
response.setContentType("text/plain");
|
return "";// getJsonp(caslogin(request, response), callbackFunName);
|
}
|
|
/**
|
* 转化为jsonp字符串
|
*
|
* @param map
|
* @param callbackFunName
|
* @return
|
*/
|
private String getJsonp(Map<String, Object> map, String callbackFunName) {
|
String jsonp = JSONUtils.toJSONString(map);
|
return callbackFunName + "(" + jsonp + ")";
|
}
|
|
/**
|
* 退出
|
*
|
* @throws IOException
|
*/
|
@LogLogininfo("登出")
|
@RequestMapping(value = "/logout")
|
public void logout(HttpServletRequest request, HttpServletResponse response) throws IOException {
|
Subject subject = SecurityUtils.getSubject();
|
|
|
subject.logout();
|
////移除在线人数 add by zsx
|
onlineUserRedis.cleanLogoutUser(subject.getSession());
|
|
|
String CasHost = sysConfig.getCasHost();
|
String logoutUrl = CasHost + "logout?service=" + CasHost + "login";
|
WebUtils.issueRedirect(request, response, logoutUrl);
|
|
// sysUserTokenService.logout(getUserId());
|
// return Result.ok();
|
}
|
|
/**
|
* 从session中获取记录的验证码
|
*/
|
private String getKaptcha(String key) {
|
Object kaptcha = ShiroUtils.getSessionAttribute(key);
|
if (kaptcha == null) {
|
throw new LanbaseException("验证码已失效");
|
}
|
ShiroUtils.getSession().removeAttribute(key);
|
return kaptcha.toString();
|
}
|
|
|
// /**
|
// * 定时判断,查询用户最近一次操作时间 若最近一次时间超过5分钟,则判断用户下线
|
// */
|
// @Scheduled(fixedRate=2*60*1000)
|
// public void cleanMayDownUser(){
|
// onlineUserRedis.removeDownlineUser();
|
// }
|
|
}
|
