package com.iplatform.security.controller;
|
|
import com.iplatform.base.SecuritySpi;
|
import com.iplatform.base.SystemController;
|
import com.iplatform.base.cache.MenuCacheProvider;
|
import com.iplatform.base.callback.SecurityCallback;
|
import com.iplatform.base.config.SecurityUserProperties;
|
import com.iplatform.base.config.TcpProperties;
|
import com.iplatform.base.exception.LoginException;
|
import com.iplatform.base.pojo.RequestLogin;
|
import com.iplatform.base.service.MenuServiceImpl;
|
import com.iplatform.base.util.MenuUtils;
|
import com.iplatform.base.util.menu.MenuTree;
|
import com.iplatform.base.util.menu.SystemMenu;
|
import com.iplatform.model.po.S_user_core;
|
import com.iplatform.model.vo.MenuVo;
|
import com.iplatform.model.vo.RouterVo;
|
import com.walker.infrastructure.utils.JsonUtils;
|
import com.walker.infrastructure.utils.StringUtils;
|
import com.walker.web.ResponseValue;
|
import com.walker.web.UserPrincipal;
|
import com.walker.web.UserType;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestBody;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
@RestController
|
public class SecurityController extends SystemController {
|
|
// private CacheProvider<String> captchaCacheProvider;
|
// private AuthenticationManager authenticationManager;
|
// private TokenGenerator tokenGenerator;
|
// private UserOnlineProvider userOnlineProvider;
|
private MenuServiceImpl menuService;
|
private MenuCacheProvider menuCacheProvider;
|
// private WebAgentService webAgentService;
|
// private LogServiceImpl logService;
|
// private LogProperties logProperties;
|
// // 2023-03-22
|
// private LoginServiceImpl loginService;
|
// // 2023-03-28
|
// private SecurityProperties securityProperties;
|
private TcpProperties tcpProperties;
|
|
private SecuritySpi securitySpi;
|
private SecurityUserProperties securityUserProperties;
|
|
@Autowired
|
public SecurityController(
|
// CacheProvider<String> captchaCacheProvider
|
// , AuthenticationManager authenticationManager, TokenGenerator tokenGenerator
|
// , UserOnlineProvider userOnlineProvider
|
MenuServiceImpl menuService, MenuCacheProvider menuCacheProvider
|
// , WebAgentService webAgentService, LogServiceImpl logService, LogProperties logProperties
|
// , LoginServiceImpl loginService
|
// , SecurityProperties securityProperties
|
, TcpProperties tcpProperties, SecuritySpi securitySpi, SecurityUserProperties securityUserProperties){
|
// this.captchaCacheProvider = captchaCacheProvider;
|
// this.authenticationManager = authenticationManager;
|
// this.tokenGenerator = tokenGenerator;
|
// this.userOnlineProvider = userOnlineProvider;
|
this.menuService = menuService;
|
this.menuCacheProvider = menuCacheProvider;
|
// this.webAgentService = webAgentService;
|
// this.logService = logService;
|
// this.logProperties = logProperties;
|
// this.loginService = loginService;
|
// this.securityProperties = securityProperties;
|
this.tcpProperties = tcpProperties;
|
this.securitySpi = securitySpi;
|
this.securityUserProperties = securityUserProperties;
|
}
|
|
@PostMapping("/login")
|
// public ResponseValue login(@RequestBody RequestLogin requestLogin){
|
public ResponseValue login(@RequestBody String raw){
|
logger.debug("login = " + raw);
|
RequestLogin requestLogin = null;
|
try {
|
requestLogin = JsonUtils.jsonStringToObject(raw, RequestLogin.class);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
String username = requestLogin.getUsername();
|
String password = requestLogin.getPassword();
|
|
if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password)){
|
return ResponseValue.error("请输入用户名或密码");
|
}
|
|
/*// 2023-01-26 为了支持多种登录方式，使用登录回调处理具体登录细节。
|
PlatformLoginCallback loginCallback = LoginCallbackUtils.getLoginCallbackBean(LoginType.getType(requestLogin.getLoginType()), true);
|
|
boolean captchaEnabled = this.getArgumentVariable(ArgumentsConstants.KEY_SECURITY_CAPTCHA_ENABLED).getBooleanValue();
|
// 2023-01-26 这里APP端是不需要验证码的
|
if(captchaEnabled){
|
CaptchaProvider<CaptchaResult> captchaProvider = loginCallback.getCaptchaProvider();
|
if(captchaProvider == null){
|
return ResponseValue.error("系统需要验证码，但登录未配置:" + loginCallback.getClass().getName());
|
}
|
if(StringUtils.isEmpty(requestLogin.getVerifyType())){
|
return ResponseValue.error("请求错误：验证码类型为空");
|
}
|
if(!requestLogin.getVerifyType().equals(captchaProvider.getCaptchaType().getIndex())){
|
throw new IllegalArgumentException("前端配置的验证码类型与后台不一致! verifyType = " + captchaProvider.getCaptchaType());
|
}
|
if(loginCallback.isValidateCaptcha()){
|
logger.debug("需要验证码，getCaptchaType={}", loginCallback.getCaptchaProvider().getCaptchaType());
|
String error = this.validateCaptcha(username, requestLogin.getCode(), requestLogin.getUuid(), captchaProvider);
|
if(error != null){
|
return ResponseValue.error(error);
|
}
|
}
|
}
|
|
// 用户验证
|
Authentication authentication = null;
|
|
try{
|
// UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);
|
DefaultAuthenticationToken authenticationToken = new DefaultAuthenticationToken(username, password, requestLogin);
|
// 这里放入线程，后面UserDetailsService会使用
|
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
|
authentication = authenticationManager.authenticate(authenticationToken);
|
|
} catch (Exception e){
|
this.recordLoginInfo(username, String.valueOf(ResponseCode.ERROR.getCode()), "登录未成功认证", 0, null, null);
|
if (e instanceof BadCredentialsException){
|
return ResponseValue.error(ResponseCode.USER_CREDENTIALS_ERROR.getCode(), ResponseCode.USER_CREDENTIALS_ERROR.getMessage());
|
} else {
|
if(e instanceof UsernameNotFoundException){
|
logger.debug(".............用户不存在：" + username);
|
}
|
// 2023-03-20
|
// 登录验证抛出异常，会在这里统一处理，如：PcUserStopAppException。
|
// DefaultAuthenticationProvider
|
return ResponseValue.error(ResponseCode.USER_CREDENTIALS_ERROR.getCode(), e.getMessage());
|
}
|
}
|
|
DefaultUserDetails userDetails = (DefaultUserDetails)authentication.getPrincipal();
|
if(this.logger.isDebugEnabled()){
|
logger.debug(userDetails.getUserPrincipal().toString());
|
}
|
|
// 2023-03-20，对于空验证码类型（登录方式），需要后台自动生成uuid，因为前端没有机会请求验证码获得uuid
|
if(loginCallback.getCaptchaProvider().getCaptchaType() == CaptchaType.None){
|
requestLogin.setUuid(IdUtils.simpleUUID());
|
}
|
|
// 添加token失效时间（从配置获取），2023-03-28
|
long expiredMinutes = SecurityConfigUtils.getTokenExpireMinutes(requestLogin.getClientType(), securityProperties);
|
String token = TokenUtils.generateToken(userDetails.getUserPrincipal().getId()
|
, userDetails.getUsername(), requestLogin.getUuid(), this.tokenGenerator, expiredMinutes);
|
logger.debug("token失效分钟:{}", expiredMinutes);
|
// String token = this.tokenGenerator.createToken(requestLogin.getUuid(), userDetails.getUserPrincipal().getId()
|
// , VariableConstants.DEFAULT_TOKEN_EXPIRED_MINUTES, VariableConstants.TOKEN_SECRET);
|
// 缓存登录信息
|
this.userOnlineProvider.cacheUserPrincipal(requestLogin.getUuid(), userDetails.getUserPrincipal());
|
// 把成功登录日志，与uuid关联保存放一起，在异步中调用。2023-03-23
|
this.recordLoginInfo(username, String.valueOf(ResponseCode.SUCCESS.getCode()), "登录成功"
|
, userDetails.getUserPrincipal().getUserInfo().getId(), requestLogin.getUuid(), requestLogin.getClientType());
|
|
// 2023-05-12，加上用户信息（商户系统用）
|
Map<String, Object> param = new HashMap<>(2);
|
param.put(com.walker.web.Constants.TOKEN_NAME, token);
|
param.put(SecurityConstants.KEY_USER_INFO, UserUtils.acquireClientUserInfo(userDetails.getUserPrincipal().getUserInfo(), token));
|
// */
|
Map<String, Object> param = null;
|
try {
|
param = this.securitySpi.login(requestLogin);
|
return ResponseValue.success(param);
|
} catch (LoginException e) {
|
return ResponseValue.error(e.getMessage());
|
}
|
}
|
|
@RequestMapping("/getInfo")
|
public ResponseValue getUserInfo(){
|
UserPrincipal<S_user_core> userPrincipal = this.getCurrentUserPrincipal();
|
Map<String, Object> data = new HashMap<>(4);
|
|
// 2023-10-13，增加权限自定义加载回调，为业务预留钩子
|
SecurityCallback securityCallback = this.getPlatformCallback(SecurityCallback.class);
|
|
// permissions，
|
// 该集合用于适配若依前端，后续前端将不需要自己保留权限路由，统一后台处理返回错误信息。2022-11-12
|
Set<String> perms = new HashSet<String>();
|
if(userPrincipal.getUserInfo().getUser_type() == UserType.TYPE_SUPER){
|
perms.add("*:*:*");
|
} else {
|
// 获得当前用户所属的角色ID集合
|
List<String> menuIdList = this.menuService.queryRoleMenuIdList(userPrincipal.getRoleIdList());
|
// perms.addAll(this.menuCacheProvider.getPermissionSet(menuIdList));
|
|
if(securityCallback == null){
|
// 2023-06-01 增加顶级单位可使用的菜单范围。
|
int menuScope = this.getDeptCacheProvider().getDept(userPrincipal.getUserInfo().getOrg_id()).getMenu_type();
|
if(menuScope == MenuUtils.MENU_SCOPE_PLATFORM){
|
// 平台菜单，需要根据角色查询
|
perms.addAll(this.menuCacheProvider.getPermissionSet(menuIdList, false, menuScope));
|
} else {
|
// 商户（顶级机构）独立菜单，不需要角色
|
perms.addAll(this.menuCacheProvider.getPermissionSet(null, true, menuScope));
|
}
|
|
} else {
|
// 2023-10-13
|
logger.debug("存在业务自定义权限回调：{}", securityCallback.getClass().getName());
|
Set<String> userPermission = securityCallback.loadUserPermission(userPrincipal.getUserInfo(), menuIdList);
|
if(userPermission != null){
|
perms.addAll(userPermission);
|
}
|
}
|
}
|
logger.debug("用户 permissions = " + perms);
|
|
// data.put("user", userPrincipal.getUserInfo());
|
data.put("roles", userPrincipal.getRoleIdList());
|
data.put("permissions", perms);
|
data.put("isPerfectInfo", true); // 是否已完善信息，暂时没用，仅配合前端展示。2023-03-20
|
// 2023-08-05 是否强制修改密码
|
if(this.securityUserProperties.isPassDefaultModify()){
|
data.put("force_change_pass", userPrincipal.getUserInfo().getModify_pwd().intValue() == 1? false : true);
|
} else {
|
data.put("force_change_pass", false);
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
//~ 适配电商模块，增加其他用户属性。2023-05-12
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
S_user_core user = userPrincipal.getUserInfo();
|
data.put("id", user.getId());
|
data.put("account", user.getUser_name());
|
data.put("realName", user.getNick_name());
|
data.put("roleNames", null);
|
data.put("roleIds", StringUtils.collectionToCommaDelimitedString(userPrincipal.getRoleIdList()));
|
// data.put("Token", null);
|
data.put("phone", user.getPhonenumber());
|
data.put("isSms", true);
|
data.put("merStarLevel", 0);
|
|
// 2023-04-17，websocket连接信息
|
if(!this.tcpProperties.isEnabled()){
|
logger.warn("未开启'WebSocket'");
|
data.put("uri", "-1");
|
} else {
|
data.put("uri", this.tcpProperties.getWebsocketUri());
|
data.put("uid", userPrincipal.getId());
|
}
|
|
if(securityCallback != null){
|
securityCallback.acquireUserInfo(data, user);
|
}
|
return ResponseValue.success(data);
|
}
|
|
/**
|
* 若依前端方法，获取路由权限。暂时废弃
|
* @return
|
*/
|
@Deprecated
|
@GetMapping("/getRouters")
|
public ResponseValue getRouters(){
|
List<SystemMenu> menuList = this.acquireUserMenuList();
|
List<RouterVo> routerList = this.menuCacheProvider.buildMenus(menuList);
|
return ResponseValue.success(routerList);
|
}
|
|
/**
|
* 新界面返回菜单树，组装数据。
|
* @return
|
* @date 2023-05-12
|
*/
|
@GetMapping("/getMenus")
|
public ResponseValue getMenus(){
|
List<SystemMenu> menuList = this.acquireUserMenuList();
|
// logger.debug("acquireUserMenuList = {}", menuList);
|
List<MenuVo> menuVoList = new ArrayList<>(32);
|
if(menuList != null){
|
MenuVo menuVo = null;
|
for(SystemMenu menu: menuList){
|
if(menu.getMenu_type().equals(MenuUtils.MENU_TYPE_BUTTON)){
|
// 这里注意，这次前端不要功能点，只要菜单本身。2023-05-13
|
continue;
|
}
|
menuVo = new MenuVo();
|
menuVo.setId(Long.parseLong(menu.getMenu_id()));
|
menuVo.setPid(Long.parseLong(menu.getParent_id()));
|
menuVo.setName(menu.getMenu_name());
|
menuVo.setPerms(menu.getPerms());
|
menuVo.setComponent(menu.getComponent());
|
menuVo.setSort(menu.getOrder_num());
|
menuVo.setIcon(menu.getIcon());
|
menuVo.setMenuType(menu.getMenu_type());
|
// if(menu.getMenu_type().equals(MenuUtils.MENU_TYPE_FOLDER)){
|
// menuVo.setMenuType(MenuUtils.MENU_TYPE_FOLDER);
|
// } else if(menu.getMenu_type().equals(MenuUtils.MENU_TYPE_ITEM)){
|
// menuVo.setMenuType(MenuUtils.MENU_TYPE_ITEM);
|
// } else {
|
// menuVo.setMenuType(MenuUtils.MENU_TYPE_POINT);
|
// }
|
if(StringUtils.isNotEmpty(menu.getIcon_info())){
|
String[] customIcons = StringUtils.commaDelimitedListToStringArray(menu.getIcon_info());
|
if(customIcons.length != 2){
|
throw new IllegalArgumentException("自定义菜单图标(相对路径)必须配置两个，并用英文逗号分隔，name=" + menu.getMenu_name());
|
}
|
menuVo.setIconNormal(customIcons[0]);
|
menuVo.setIconActive(customIcons[1]);
|
}
|
menuVoList.add(menuVo);
|
}
|
}
|
// logger.debug("menuVoList = {}", menuVoList);
|
MenuTree menuTree = new MenuTree(menuVoList);
|
menuVoList = menuTree.buildTree();
|
return ResponseValue.success(menuVoList);
|
}
|
|
private List<SystemMenu> acquireUserMenuList(){
|
List<SystemMenu> menuList = null;
|
UserPrincipal<S_user_core> userPrincipal = this.getCurrentUserPrincipal();
|
|
// 2023-10-13 当业务配置有自定义菜单加载回调对象时，需要按照业务规则加载。
|
SecurityCallback securityCallback = this.getPlatformCallback(SecurityCallback.class);
|
if(securityCallback == null){
|
if(userPrincipal.getUserInfo().getUser_type() == UserType.TYPE_SUPER){
|
// menuList = this.menuCacheProvider.getMenuTree(null, false, true);
|
menuList = this.menuCacheProvider.getMenuList(null, MenuUtils.MENU_SCOPE_PLATFORM);
|
} else {
|
// 获得当前用户所属的角色ID集合
|
// List<String> menuIdList = this.menuService.queryRoleMenuIdList(userPrincipal.getRoleIdList());
|
// menuList = this.menuCacheProvider.getMenuTree(menuIdList, false, false);
|
// 2023-06-01 增加顶级单位可使用的菜单范围。
|
int menuScope = this.getDeptCacheProvider().getDept(userPrincipal.getUserInfo().getOrg_id()).getMenu_type();
|
if(menuScope == MenuUtils.MENU_SCOPE_PLATFORM){
|
// 平台菜单，需要根据角色查询
|
menuList = this.menuCacheProvider.getMenuList(userPrincipal.getRoleIdList(), menuScope);
|
} else {
|
// 商户（顶级机构）独立菜单，不需要角色
|
menuList = this.menuCacheProvider.getMenuList(null, menuScope);
|
}
|
// menuList = this.menuCacheProvider.getMenuList(userPrincipal.getRoleIdList(), menuScope);
|
}
|
} else {
|
// 2023-10-13
|
menuList = securityCallback.loadUserMenu(userPrincipal.getUserInfo(), userPrincipal.getRoleIdList());
|
if(this.logger.isDebugEnabled()){
|
logger.debug("存在业务自定义菜单回调：{}", menuList);
|
}
|
}
|
if(menuList != null){
|
// 过滤掉按钮权限，前端只需要菜单，按钮权限在permisstion中控制
|
SystemMenu menu = null;
|
for(Iterator<SystemMenu> it = menuList.iterator(); it.hasNext();){
|
menu = it.next();
|
// 1.去掉按钮菜单，同时，停用的菜单也要去掉。2023-05-14
|
// 2.不能展示的也要去掉，is_show = 0
|
if(menu.getMenu_type().equals(MenuUtils.MENU_TYPE_BUTTON)
|
|| menu.getStatus().equals(MenuUtils.MENU_STATUS_DISABLED)
|
|| menu.getVisible().equals(MenuUtils.MENU_INVISIBLE)){
|
it.remove();
|
}
|
}
|
}
|
return menuList;
|
}
|
|
// private String validateCaptcha(String username, String code, String uuid, CaptchaProvider<CaptchaResult> captchaProvider){
|
// if(StringUtils.isEmpty(uuid) || StringUtils.isEmpty(code)){
|
// return "请输入验证码";
|
// }
|
//
|
// CaptchaResult captchaResult = new CaptchaResult();
|
// captchaResult.setUuid(uuid);
|
// captchaResult.setCode(code);
|
// boolean success = captchaProvider.validateCaptcha(captchaResult);
|
//
|
// // 2023-04-07 调整，使用提供者判断验证码是否正确。
|
// this.captchaCacheProvider.removeCacheData(Constants.CAPTCHA_CODE_PREFIX + uuid);// 删除缓存的验证码
|
//
|
// if(!success){
|
// logger.error("验证码校验失败: code = " + code);
|
// return "验证码错误";
|
// }
|
// return null;
|
// }
|
|
// private void recordLoginInfo(String loginId, String status, String message, long userId, String uuid, String clientType){
|
// if(this.logProperties.isLoginEnabled()){
|
// logger.debug("异步记录登录日志，后续要补充:" + status + ", " + message);
|
// AsyncManager.me().execute(this.acquireLoginInfoTask(loginId, status, message, userId, uuid, clientType));
|
// }
|
// }
|
//
|
// private TimerTask acquireLoginInfoTask(String loginId, String status, String message, Long userId
|
// , String uuid, String clientType){
|
// HttpServletRequest request = this.getRequest();
|
// final WebUserAgent webUserAgent = this.webAgentService.getWebUserAgent(request.getHeader("User-Agent"), request);
|
//
|
// return new TimerTask() {
|
// @Override
|
// public void run() {
|
// S_login_info login_info = new S_login_info();
|
// login_info.setLogin_time(Long.parseLong(DateUtils.getDateTimeSecondForShow()));
|
// login_info.setUser_name(loginId);
|
// login_info.setMsg(message);
|
// login_info.setStatus(status);
|
// login_info.setInfo_id(NumberGenerator.getLongSequenceNumber());
|
// if(webUserAgent != null){
|
// login_info.setLogin_location(webUserAgent.getLocation());
|
// login_info.setBrowser(webUserAgent.getBrowserName());
|
// login_info.setIpaddr(webUserAgent.getIp());
|
// login_info.setOs(webUserAgent.getOsName());
|
// }
|
//
|
// // 2023-03-23
|
// if(status.equals(String.valueOf(ResponseCode.SUCCESS.getCode()))){
|
// // 登录成功才记录uuid关联缓存
|
// loginService.execUpdateUserLogin(userId, loginId, uuid, clientType, login_info);
|
// } else {
|
// // 登录失败，仅记录登录日志
|
// logService.execInsertLoginLog(login_info, userId);
|
// }
|
// }
|
// };
|
// }
|
}
|
