I3_YF_SEAT
/
impp-core
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

冲突解决

Browse Source
yun-zuoyi
wynne1005 4 years ago
parent 82dea90825 d4242786ef
commit 252969cbc9
25 changed files with 1252 additions and 480 deletions
Show Stats Download Patch File Download Diff File

10
modules/i3plus-core-api/src/main/java/cn/estsh/i3plus/core/api/iservice/base/ISysLogService.java
Unescape Escape View File

@ -2,7 +2,13 @@ package cn.estsh.i3plus.core.api.iservice.base;
import cn.estsh.i3plus.pojo.base.bean.ListPager; import cn.estsh.i3plus.pojo.base.bean.ListPager;
import cn.estsh.i3plus.pojo.base.common.Pager; import cn.estsh.i3plus.pojo.base.common.Pager;
import cn.estsh.i3plus.pojo.platform.platbean.*; import cn.estsh.i3plus.pojo.model.platform.LogFieldModel;
import cn.estsh.i3plus.pojo.model.platform.SysLogModel;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogConsole;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogException;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogOperate;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogSystem;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogTaskTime;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import java.util.List; import java.util.List;
@ -60,4 +66,6 @@ public interface ISysLogService {
@ApiOperation(value = "查询时间段内各等级日志数量",notes = "查询时间段内各等级日志数量") @ApiOperation(value = "查询时间段内各等级日志数量",notes = "查询时间段内各等级日志数量")
Map<String, Object> querySysLogSystemByLevel(String startTime, String endTime); Map<String, Object> querySysLogSystemByLevel(String startTime, String endTime);
List<LogFieldModel> querySysLog(SysLogModel logModel,Pager pager);
} }

75
modules/i3plus-core-api/src/main/java/cn/estsh/i3plus/core/api/iservice/base/ISystemLoginService.java
Unescape Escape View File

@ -1,11 +1,14 @@
package cn.estsh.i3plus.core.api.iservice.base; package cn.estsh.i3plus.core.api.iservice.base;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken; import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken;
import cn.estsh.i3plus.pojo.base.shirotoken.SaAdminToken; import cn.estsh.i3plus.pojo.base.shirotoken.SaAdminToken;
import cn.estsh.i3plus.pojo.base.shirotoken.UserToken; import cn.estsh.i3plus.pojo.base.shirotoken.UserToken;
import cn.estsh.i3plus.pojo.platform.bean.SessionUser; import cn.estsh.i3plus.pojo.platform.bean.SessionUser;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import javax.servlet.http.HttpServletRequest;
/** /**
* @Description : 用户登陆方法，平台统一登陆 * @Description : 用户登陆方法，平台统一登陆
* @Reference : * @Reference :
@ -17,54 +20,92 @@ public interface ISystemLoginService {
/** /**
* 普通用户登录 * 普通用户登录
* @param loginName 账号 *
* @param loginPwd 密码 * @param loginName 账号
* @param languageCode 登录语言 * @param loginPwd 密码
* @param languageCode 登录语言
* @return 用户会话 * @return 用户会话
*/ */
@ApiOperation(value = "用户登录",notes = "普通用户登录") @ApiOperation(value = "用户登录", notes = "普通用户登录")
SessionUser queryUserLogin(String loginName, String loginPwd, String languageCode); SessionUser queryUserLogin(String loginName, String loginPwd, String languageCode);
/** /**
* 管理员登录 * 管理员登录
* @param loginName 账号 *
* @param loginPwd 密码 * @param loginName 账号
* @param languageCode 登录语言 * @param loginPwd 密码
* @param languageCode 登录语言
* @return 用户会话 * @return 用户会话
*/ */
@ApiOperation(value = "用户登录",notes = "管理用户登录") @ApiOperation(value = "用户登录", notes = "管理用户登录")
SessionUser queryAdminLogin(String loginName, String loginPwd, String languageCode); SessionUser queryAdminLogin(String loginName, String loginPwd, String languageCode);
/** /**
* 用户信息分装 * 用户信息分装
*
* @param authenticationToken * @param authenticationToken
* @return 用户会话 * @return 用户会话
*/ */
@ApiOperation(value = "封装用户",notes = "封装普通用户信息") @ApiOperation(value = "封装用户", notes = "封装普通用户信息")
SessionUser queryCheckUserLogin(UserToken authenticationToken); SessionUser queryCheckUserLogin(UserToken authenticationToken);
/** /**
* 管理员登录 * 管理员登录
* @param authenticationToken 登录信息 *
* @param authenticationToken 登录信息
* @return 用户会话 * @return 用户会话
*/ */
@ApiOperation(value = "封装用户",notes = "封装管理员信息") @ApiOperation(value = "封装用户", notes = "封装管理员信息")
SessionUser queryCheckAdminLogin(AdminToken authenticationToken); SessionUser queryCheckAdminLogin(AdminToken authenticationToken);
/** /**
* 超级管理员登录 * 超级管理员登录
* @param authenticationToken 登录信息 *
* @param authenticationToken 登录信息
* @return 用户会话 * @return 用户会话
*/ */
@ApiOperation(value = "封装用户",notes = "封装超级管理员信息") @ApiOperation(value = "封装用户", notes = "封装超级管理员信息")
SessionUser queryCheckSaAdminLogin(SaAdminToken authenticationToken); SessionUser queryCheckSaAdminLogin(SaAdminToken authenticationToken);
/**
* E9用户单点登录
*
* @param userToken 用户token
* @return 用户会话
*/
@ApiOperation(value = "封装用户", notes = "封装普通用户信息")
SessionUser queryCheckE9UserLogin(UserToken userToken);
/**
* E9Admin单点登录
*
* @param adminToken admin token
* @return 用户会话
*/
@ApiOperation(value = "封装用户", notes = "封装管理员信息")
SessionUser queryCheckE9AdminLogin(AdminToken adminToken);
/**
* E9 SA单点登录
* @param saAdminToken sa token
* @return 用户会话
*/
@ApiOperation(value = "封装用户", notes = "封装超级管理员信息")
SessionUser queryCheckE9SaAdminLogin(SaAdminToken saAdminToken);
/** /**
* 记录登录错误 * 记录登录错误
*
* @param loginName 账号 * @param loginName 账号
* @param sessionId Session ID * @param sessionId Session ID
* @return 用户会话 * @return 用户会话
*/ */
@ApiOperation(value = "登录密码错误",notes = "登录密码错误记录错误次数功能") @ApiOperation(value = "登录密码错误", notes = "登录密码错误记录错误次数功能")
Integer doLoginPasswordError(String loginName,String sessionId); Integer doLoginPasswordError(String loginName, String sessionId);
/**
* 获取登录的平台
*
* @param request http请求
* @return 平台枚举
*/
CommonEnumUtil.LOG_LOGIN_PLATFORM getLoginPlatform(HttpServletRequest request);
} }

21
modules/i3plus-core-api/src/main/java/cn/estsh/i3plus/core/api/iservice/base/ISystemLoginStrategyService.java
Unescape Escape View File

@ -0,0 +1,21 @@
package cn.estsh.i3plus.core.api.iservice.base;
import cn.estsh.i3plus.pojo.model.platform.SysLoginModel;
import cn.estsh.impp.framework.boot.util.ResultBean;
import javax.servlet.http.HttpServletRequest;
import java.util.function.BiFunction;
/**
* @author Wynne.Lu
* @date 2021/1/18 上午10:50
* @desc
*/
public interface ISystemLoginStrategyService {
/**
* @param request
* @param loginModel
* @return
*/
BiFunction<HttpServletRequest, SysLoginModel, ResultBean> login();
}

134
modules/i3plus-core-api/src/main/java/cn/estsh/i3plus/core/api/iservice/busi/ISysUserService.java
Unescape Escape View File

@ -20,123 +20,137 @@ public interface ISysUserService {
/** /**
* 账号登录 * 账号登录
* @param loginName 登录名 *
* @param password 登录密码 * @param loginName 登录名
* @param languageCode 界面语言 * @param password 登录密码
* @param languageCode 界面语言
* @return * @return
*/ */
@ApiOperation(value = "账号登录",notes = "普通账号登录功能") @ApiOperation(value = "账号登录", notes = "普通账号登录功能")
SessionUser queryUserLogin(String loginName, String password, String languageCode,Integer loginPlatform,String deviceId) throws AuthenticationException; SessionUser loginUser(String loginName, String password, String languageCode, Integer loginPlatform, String deviceId) throws AuthenticationException;
@ApiOperation(value = "获取Token",notes = "根据登录名判断是否是管理员") @ApiOperation(value = "获取Token", notes = "根据登录名判断是否是管理员")
BaseToken getToken(String loginName, String password, String languageCode,Integer loginPlatform); BaseToken getToken(String loginName, String password, String languageCode, Integer loginPlatform);
/** /**
* 修改状态 * 修改状态
* @param id 修改账号状态 *
* @param status 状态 * @param id 修改账号状态
* @param user 当前会话账号 * @param status 状态
* @param user 当前会话账号
* @return * @return
*/ */
@ApiOperation(value = "修改状态",notes = "修改指定账号状态") @ApiOperation(value = "修改状态", notes = "修改指定账号状态")
void updateSysUserStatus(Long id, int status, SessionUser user); void updateSysUserStatus(Long id, int status, SessionUser user);
@ApiOperation(value = "锁定用户",notes = "锁定用户") @ApiOperation(value = "锁定用户", notes = "锁定用户")
void doLockSysUserById(Long id); void doLockSysUserById(Long id);
/** /**
* 批量修改账号状态 * 批量修改账号状态
*
* @param ids * @param ids
* @param status * @param status
* @param user * @param user
*/ */
@ApiOperation(value = "修改状态",notes = "批量修改指定账号状态") @ApiOperation(value = "修改状态", notes = "批量修改指定账号状态")
void updateBatchSysUserStatus(Long[] ids, int status, SessionUser user); void updateBatchSysUserStatus(Long[] ids, int status, SessionUser user);
/** /**
* 修改账号信息 * 修改账号信息
*
* @param sysUser * @param sysUser
*/ */
@ApiOperation(value = "修改账号信息",notes = "修改账号信息") @ApiOperation(value = "修改账号信息", notes = "修改账号信息")
void updateSysUser(SysUser sysUser); void updateSysUser(SysUser sysUser);
/** /**
* 修改账号密码 * 修改账号密码
* @param userId 需要修改的账号ID *
* @param password 旧密码 * @param userId 需要修改的账号ID
* @param newPwd 新密码 * @param password 旧密码
* @param newPwd 新密码
*/ */
@ApiOperation(value = "修改号密码",notes = "修改账号的密码信息") @ApiOperation(value = "修改号密码", notes = "修改账号的密码信息")
void updateSysUserPassword(Long userId,String password,String newPwd) throws Exception; void updateSysUserPassword(Long userId, String password, String newPwd) throws Exception;
/** /**
* 刷新账号登录信息 * 刷新账号登录信息
*
* @param userId * @param userId
*/ */
@ApiOperation(value = "刷新账号",notes = "刷新账号登录信息") @ApiOperation(value = "刷新账号", notes = "刷新账号登录信息")
void refreshUserLoginInformation(Long userId); void refreshUserLoginInformation(Long userId);
/** /**
* 新增账号信息 * 新增账号信息
*
* @param sysUser 新增账号 * @param sysUser 新增账号
* @return * @return
*/ */
@ApiOperation(value = "新增账号",notes = "新增账号信息") @ApiOperation(value = "新增账号", notes = "新增账号信息")
SysUser insertSysUser(SysUser sysUser)throws Exception; SysUser insertSysUser(SysUser sysUser) throws Exception;
/** /**
* 添加 账号登录信息 * 添加 账号登录信息
*
* @param sysLogUserLogin * @param sysLogUserLogin
* @return * @return
*/ */
@ApiOperation(value = "新增登录日志",notes = "新增登录日志信息") @ApiOperation(value = "新增登录日志", notes = "新增登录日志信息")
SysLogUserLogin insertSysLogUserLogin(SysLogUserLogin sysLogUserLogin); SysLogUserLogin insertSysLogUserLogin(SysLogUserLogin sysLogUserLogin);
/** /**
* 刷新账号角色关系 * 刷新账号角色关系
*
* @param sysUser * @param sysUser
* @param roleIds * @param roleIds
* @param userName * @param userName
*/ */
@ApiOperation(value = "刷新账号",notes = "刷新账号角色关系") @ApiOperation(value = "刷新账号", notes = "刷新账号角色关系")
void refreshSysRefUserRole(SysUser sysUser, Long[] roleIds , String userName); void refreshSysRefUserRole(SysUser sysUser, Long[] roleIds, String userName);
/** /**
* 根据Key 删除数据 * 根据Key 删除数据
*
* @param id * @param id
* @return * @return
*/ */
@ApiOperation(value = "删除账号",notes = "根据ID 删除张哈信息") @ApiOperation(value = "删除账号", notes = "根据ID 删除张哈信息")
void deleteSysUserById(Long id); void deleteSysUserById(Long id);
/** /**
* 批量删除账号 逻辑删除 * 批量删除账号 逻辑删除
* @param ids 需要删除的账号ID *
* @param user 当前会话账号 * @param ids 需要删除的账号ID
* @param user 当前会话账号
*/ */
@ApiOperation(value = "删除账号",notes = "根据ID 批量删除张哈信息") @ApiOperation(value = "删除账号", notes = "根据ID 批量删除张哈信息")
void deleteBatchSysUserById(Long[] ids, SessionUser user); void deleteBatchSysUserById(Long[] ids, SessionUser user);
/** /**
* 查询所有数据 * 查询所有数据
*
* @return * @return
*/ */
@ApiOperation(value = "查询所有",notes = "查询所有账号信息") @ApiOperation(value = "查询所有", notes = "查询所有账号信息")
List<SysUser> list(); List<SysUser> list();
/** /**
* 查询所有数据 * 查询所有数据
*
* @return * @return
*/ */
@ApiOperation(value = "查询所有",notes = "查询所有账号信息") @ApiOperation(value = "查询所有", notes = "查询所有账号信息")
List<SysUser> listByUserOrganizeCode(); List<SysUser> listByUserOrganizeCode();
/** /**
* 根据角色查询用户信息 * 根据角色查询用户信息
*
* @param roleId 角色ID * @param roleId 角色ID
* @return 获取用户ID 集合 * @return 获取用户ID 集合
*/ */
@ApiOperation(value = "查询用户ID 集合",notes = "根据角色Id 查询用户ID集合") @ApiOperation(value = "查询用户ID 集合", notes = "根据角色Id 查询用户ID集合")
List<Long> findSysUserIdListByRoleId(Long roleId); List<Long> findSysUserIdListByRoleId(Long roleId);
/*** /***
@ -144,105 +158,117 @@ public interface ISysUserService {
* @param idList 部门集合 * @param idList 部门集合
* @return 用户ID集合 * @return 用户ID集合
*/ */
@ApiOperation(value = "查询用户ID 集合",notes = "根据部门Id 查询用户ID集合") @ApiOperation(value = "查询用户ID 集合", notes = "根据部门Id 查询用户ID集合")
List<Long> findSysUserIdListByDepartmentId(List<Long> idList); List<Long> findSysUserIdListByDepartmentId(List<Long> idList);
/** /**
* 复杂查询 * 复杂查询
*
* @param user * @param user
* @param pager * @param pager
* @return * @return
*/ */
@ApiOperation(value = "账号查询",notes = "查询账号信息-复杂查询") @ApiOperation(value = "账号查询", notes = "查询账号信息-复杂查询")
ListPager<SysUser> querySysUserByPager(SysUser user, Pager pager); ListPager<SysUser> querySysUserByPager(SysUser user, Pager pager);
@ApiOperation(value = "账号查询",notes = "查询账号信息-复杂查询") @ApiOperation(value = "账号查询", notes = "查询账号信息-复杂查询")
ListPager<SysUser> querySysUserByPager(SysUser user,List<Long> idList, Pager pager); ListPager<SysUser> querySysUserByPager(SysUser user, List<Long> idList, Pager pager);
/** /**
* 根据id 数据 * 根据id 数据
*
* @param id * @param id
* @return * @return
*/ */
@ApiOperation(value = "账号查询",notes = "查询账号信息-根据ID查询") @ApiOperation(value = "账号查询", notes = "查询账号信息-根据ID查询")
SysUser getSysUserById(Long id); SysUser getSysUserById(Long id);
/** /**
* 获取账号详细信息 * 获取账号详细信息
*
* @param id * @param id
* @return * @return
*/ */
@ApiOperation(value = "获取用户信息",notes = "查询用户信息-根据ID查询") @ApiOperation(value = "获取用户信息", notes = "查询用户信息-根据ID查询")
SysUserInfo getSysUserInfoById(Long id); SysUserInfo getSysUserInfoById(Long id);
/** /**
* 根据登录名称 获取账号信息 * 根据登录名称 获取账号信息
*
* @param loginName * @param loginName
* @return * @return
*/ */
@ApiOperation(value = "获取账号信息",notes = "查询用户信息-根据登录名称查询") @ApiOperation(value = "获取账号信息", notes = "查询用户信息-根据登录名称查询")
SysUser getSysUserByLoginName(String loginName); SysUser getSysUserByLoginName(String loginName);
/** /**
* 根据手机号查询账号 * 根据手机号查询账号
*
* @param email * @param email
* @return * @return
*/ */
@ApiOperation(value = "获取账号信息",notes = "查询用户信息-根据邮箱查询") @ApiOperation(value = "获取账号信息", notes = "查询用户信息-根据邮箱查询")
SysUser getSysUserByEmail(String email); SysUser getSysUserByEmail(String email);
/** /**
* 根据手机号查询账号 * 根据手机号查询账号
*
* @param phone * @param phone
* @return * @return
*/ */
@ApiOperation(value = "获取账号信息",notes = "查询用户信息-根据手机查询") @ApiOperation(value = "获取账号信息", notes = "查询用户信息-根据手机查询")
SysUser getSysUserByPhone(String phone); SysUser getSysUserByPhone(String phone);
/** /**
* 查出账号角色关系 * 查出账号角色关系
*
* @param userId * @param userId
* @return * @return
*/ */
@ApiOperation(value = "获取用户角色信息",notes = "获取指定账号的所有角色信息") @ApiOperation(value = "获取用户角色信息", notes = "获取指定账号的所有角色信息")
List<SysRefUserRole> findSysRefUserRoleByUserId(Long userId); List<SysRefUserRole> findSysRefUserRoleByUserId(Long userId);
/** /**
* 判断账号名是否存在 * 判断账号名是否存在
*
* @param userLoginName * @param userLoginName
* @param id * @param id
* @return * @return
*/ */
@ApiOperation(value = "账号检查",notes = "检查账号的登录名是否重复") @ApiOperation(value = "账号检查", notes = "检查账号的登录名是否重复")
boolean checkSysUserLoginName(String userLoginName, long id); boolean checkSysUserLoginName(String userLoginName, long id);
/** /**
* 判断邮箱是否存在 * 判断邮箱是否存在
*
* @param email * @param email
* @param id * @param id
* @return * @return
*/ */
@ApiOperation(value = "账号检查",notes = "检查账号的邮箱是否重复") @ApiOperation(value = "账号检查", notes = "检查账号的邮箱是否重复")
boolean checkSysUserEmail(String email,long id); boolean checkSysUserEmail(String email, long id);
/** /**
* 判断手机是否存在 * 判断手机是否存在
*
* @param phone * @param phone
* @param id * @param id
* @return * @return
*/ */
@ApiOperation(value = "账号检查",notes = "检查账号的手机号是否重复") @ApiOperation(value = "账号检查", notes = "检查账号的手机号是否重复")
boolean checkSysUserPhone(String phone,long id); boolean checkSysUserPhone(String phone, long id);
/** /**
* 账号唯一教研 * 账号唯一教研
*
* @param user * @param user
*/ */
@ApiOperation(value = "账号检查",notes = "检查账号信息唯一(登录名、邮箱、手机号)") @ApiOperation(value = "账号检查", notes = "检查账号信息唯一(登录名、邮箱、手机号)")
void checkSysUserOnly(SysUser user); void checkSysUserOnly(SysUser user);
/** /**
* 获取用户数量 * 获取用户数量
*
* @return 用户数量 * @return 用户数量
*/ */
@ApiOperation(value = "查询账户数量") @ApiOperation(value = "查询账户数量")
@ -250,23 +276,25 @@ public interface ISysUserService {
/** /**
* 登录封装账号信息 * 登录封装账号信息
*
* @param sessionUser * @param sessionUser
* @param user * @param user
* @param userType * @param userType
* @param languageCode * @param languageCode
* @return * @return
*/ */
@ApiOperation(value = "封装用户信息",notes = "封装登录完成后的用户信息(角色、权限、部门、组织、岗位)") @ApiOperation(value = "封装用户信息", notes = "封装登录完成后的用户信息(角色、权限、部门、组织、岗位)")
SessionUser packSessionUser(SessionUser sessionUser, SysUser user, Integer userType,Integer loginPlatform, String languageCode, String deviceId); SessionUser packSessionUser(SessionUser sessionUser, SysUser user, Integer userType, Integer loginPlatform, String languageCode, String deviceId);
@ApiOperation(value = "封装用户信息",notes = "封装用户列表分页信息") @ApiOperation(value = "封装用户信息", notes = "封装用户列表分页信息")
SessionUser packPageSessionUser(SessionUser sessionUser, SysUser user); SessionUser packPageSessionUser(SessionUser sessionUser, SysUser user);
@ApiOperation(value = "封装用户信息",notes = "封装用户系统配置信息") @ApiOperation(value = "封装用户信息", notes = "封装用户系统配置信息")
SessionUser packConfigSessionUser(SessionUser sessionUser, SysUser user); SessionUser packConfigSessionUser(SessionUser sessionUser, SysUser user);
/** /**
* 根据id查询用户信息 * 根据id查询用户信息
*
* @param ids 用户id * @param ids 用户id
* @return 查询结果 * @return 查询结果
*/ */

8
modules/i3plus-core-apiservice/pom.xml
Unescape Escape View File

@ -210,12 +210,18 @@
<groupId>jaxen</groupId> <groupId>jaxen</groupId>
<artifactId>jaxen</artifactId> <artifactId>jaxen</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.elasticsearch</groupId> <groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId> <artifactId>elasticsearch</artifactId>
<version>7.5.1</version> <version>7.5.1</version>
</dependency> </dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
<version>2.4.2</version>
</dependency>
</dependencies> </dependencies>
<build> <build>

72
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/auth/ShiroAuthConfiguration.java
Unescape Escape View File

@ -4,18 +4,23 @@ import cn.estsh.i3plus.core.apiservice.auth.realm.AdminAuthRealm;
import cn.estsh.i3plus.core.apiservice.auth.realm.DefaultModularRealm; import cn.estsh.i3plus.core.apiservice.auth.realm.DefaultModularRealm;
import cn.estsh.i3plus.core.apiservice.auth.realm.SaAuthRealm; import cn.estsh.i3plus.core.apiservice.auth.realm.SaAuthRealm;
import cn.estsh.i3plus.core.apiservice.auth.realm.UserAuthRealm; import cn.estsh.i3plus.core.apiservice.auth.realm.UserAuthRealm;
import cn.estsh.i3plus.core.apiservice.auth.realm.strategy.e9.E9AdminAuthRealm;
import cn.estsh.i3plus.core.apiservice.auth.realm.strategy.e9.E9SaAuthRealm;
import cn.estsh.i3plus.core.apiservice.auth.realm.strategy.e9.E9UserAuthRealm;
import cn.estsh.i3plus.platform.common.util.CommonConstWords; import cn.estsh.i3plus.platform.common.util.CommonConstWords;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.model.platform.RoleRealmModel;
import cn.estsh.impp.framework.boot.auth.filter.AdminFilter; import cn.estsh.impp.framework.boot.auth.filter.AdminFilter;
import cn.estsh.impp.framework.boot.auth.filter.SaAdminFilter; import cn.estsh.impp.framework.boot.auth.filter.SaAdminFilter;
import cn.estsh.impp.framework.boot.auth.filter.UserFilter; import cn.estsh.impp.framework.boot.auth.filter.UserFilter;
import cn.estsh.impp.framework.boot.configuration.RedisConfig; import cn.estsh.impp.framework.boot.configuration.RedisConfig;
import org.apache.shiro.authc.pam.ModularRealmAuthenticator; import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.cache.CacheManager; import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm; import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean; import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager; import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager; import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -26,9 +31,13 @@ import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource; import javax.annotation.Resource;
import javax.servlet.Filter; import javax.servlet.Filter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap; import java.util.HashMap;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors;
/** /**
* @Description : shiro权限配置 * @Description : shiro权限配置
@ -69,41 +78,72 @@ public class ShiroAuthConfiguration {
private DefaultWebSessionManager getSessionManage; private DefaultWebSessionManager getSessionManage;
@Bean @Bean
public AdminAuthRealm adminAuthRealm(){ public AdminAuthRealm adminAuthRealm() {
return new AdminAuthRealm(); return new AdminAuthRealm();
} }
@Bean @Bean
public SaAuthRealm saAuthRealm(){ public SaAuthRealm saAuthRealm() {
return new SaAuthRealm(); return new SaAuthRealm();
} }
@Bean @Bean
public UserAuthRealm userAuthRealm(){ public UserAuthRealm userAuthRealm() {
return new UserAuthRealm(); return new UserAuthRealm();
} }
public Map<String,Realm> supportRealmMap(){ @Bean
public E9AdminAuthRealm e9AdminAuthRealm() {
return new E9AdminAuthRealm();
}
@Bean
public E9SaAuthRealm e9SaAuthRealm() {
return new E9SaAuthRealm();
}
@Bean
public E9UserAuthRealm e9UserAuthRealm() {
return new E9UserAuthRealm();
}
public Map<String, RoleRealmModel> supportRealmMap() {
//支持的授权规则 //支持的授权规则
Map<String,Realm> realms = new HashMap(); Map<String, RoleRealmModel> realms = new HashMap(8);
realms.put(CommonEnumUtil.USER_TYPE.USER.getCode(),userAuthRealm());
realms.put(CommonEnumUtil.USER_TYPE.ADMIN.getCode(),adminAuthRealm()); RoleRealmModel defaultRoleRealmModel = RoleRealmModel.builder()
realms.put(CommonEnumUtil.USER_TYPE.SA.getCode(),saAuthRealm()); .userRealm(userAuthRealm())
.adminRealm(adminAuthRealm())
.saRealm(saAuthRealm()).build();
realms.put(ImppEnumUtil.AUTH_LOGIN_STRATEGY.ACCOUNT.getCode(), defaultRoleRealmModel);
RoleRealmModel e9RoleRealmModel = RoleRealmModel.builder()
.userRealm(e9UserAuthRealm())
.adminRealm(e9AdminAuthRealm())
.saRealm(e9SaAuthRealm()).build();
realms.put(ImppEnumUtil.AUTH_LOGIN_STRATEGY.E9.getCode(), e9RoleRealmModel);
return realms; return realms;
} }
@Bean @Bean
public ModularRealmAuthenticator modularRealmAuthenticator(){ public ModularRealmAuthenticator modularRealmAuthenticator() {
return new DefaultModularRealm(supportRealmMap()); return new DefaultModularRealm(supportRealmMap());
} }
@Bean @Bean
public SecurityManager securityManager(){ public SecurityManager securityManager() {
LOGGER.info("【app-shiro-加载securityManager】"); LOGGER.info("【app-shiro-加载securityManager】");
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setAuthenticator(modularRealmAuthenticator()); securityManager.setAuthenticator(modularRealmAuthenticator());
securityManager.setRealms(supportRealmMap().values());
List<Realm> allRealmBeans = new ArrayList<>();
supportRealmMap().values().forEach(d -> {
allRealmBeans.add(d.getUserRealm());
allRealmBeans.add(d.getAdminRealm());
allRealmBeans.add(d.getSaRealm());
});
securityManager.setRealms(allRealmBeans);
securityManager.setCacheManager(getEhCacheManage); //缓存管理 securityManager.setCacheManager(getEhCacheManage); //缓存管理
securityManager.setSessionManager(getSessionManage); //会话管理 securityManager.setSessionManager(getSessionManage); //会话管理
//securityManager.setRememberMeManager(getRememberManager()); //securityManager.setRememberMeManager(getRememberManager());
@ -115,7 +155,7 @@ public class ShiroAuthConfiguration {
ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean(); ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
factoryBean.setSecurityManager(securityManager); factoryBean.setSecurityManager(securityManager);
Map<String, Filter> filterMap = new HashMap(); Map<String, Filter> filterMap = new HashMap(8);
filterMap.put("user_filter", new UserFilter()); filterMap.put("user_filter", new UserFilter());
filterMap.put("admin_filter", new AdminFilter()); filterMap.put("admin_filter", new AdminFilter());
filterMap.put("saadmin_filter", new SaAdminFilter()); filterMap.put("saadmin_filter", new SaAdminFilter());
@ -138,7 +178,7 @@ public class ShiroAuthConfiguration {
return factoryBean; return factoryBean;
} }
/** 缓存等配置在impp平台中设置 **/ /** 缓存等配置在impp平台中设置 **/
// /** // /**
// * 缓存管理 // * 缓存管理
// * @return // * @return

45
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/auth/realm/DefaultModularRealm.java
Unescape Escape View File

@ -1,10 +1,13 @@
package cn.estsh.i3plus.core.apiservice.auth.realm; package cn.estsh.i3plus.core.apiservice.auth.realm;
import cn.estsh.i3plus.core.apiservice.controller.DemoAuthController; import cn.estsh.i3plus.platform.common.util.PlatformConstWords;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; import cn.estsh.i3plus.pojo.base.bean.BaseThreadLocal;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken; import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken;
import cn.estsh.i3plus.pojo.base.shirotoken.SaAdminToken; import cn.estsh.i3plus.pojo.base.shirotoken.SaAdminToken;
import cn.estsh.i3plus.pojo.base.shirotoken.UserToken; import cn.estsh.i3plus.pojo.base.shirotoken.UserToken;
import cn.estsh.i3plus.pojo.model.platform.RoleRealmModel;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo; import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken; import org.apache.shiro.authc.AuthenticationToken;
@ -25,9 +28,10 @@ import java.util.Map;
**/ **/
public class DefaultModularRealm extends ModularRealmAuthenticator { public class DefaultModularRealm extends ModularRealmAuthenticator {
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultModularRealm.class); private static final Logger LOGGER = LoggerFactory.getLogger(DefaultModularRealm.class);
private Map<String, Realm> definedRealms;
public DefaultModularRealm(Map<String, Realm> definedRealms) { private Map<String, RoleRealmModel> definedRealms;
public DefaultModularRealm(Map<String, RoleRealmModel> definedRealms) {
this.definedRealms = definedRealms; this.definedRealms = definedRealms;
} }
@ -36,31 +40,38 @@ public class DefaultModularRealm extends ModularRealmAuthenticator {
return super.doMultiRealmAuthentication(realms, token); return super.doMultiRealmAuthentication(realms, token);
} }
public Map<String, Realm> getDefinedRealms() { @Override
return this.definedRealms; protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws AuthenticationException {
} Realm realm;
RoleRealmModel roleRealmModel;
String realmStrategy = (String) BaseThreadLocal.getData(PlatformConstWords.AUTH_LOGIN_STRATEGY);
public void setDefinedRealms(Map<String, Realm> definedRealms) { if (StringUtils.isEmpty(realmStrategy)) {
this.definedRealms = definedRealms; roleRealmModel = this.definedRealms.get(ImppEnumUtil.AUTH_LOGIN_STRATEGY.ACCOUNT.getCode());
} else {
roleRealmModel = this.definedRealms.get(realmStrategy);
}
realm = chooseRealmByUserType(token, roleRealmModel);
return this.doSingleRealmAuthentication(realm, token);
} }
@Override private Realm chooseRealmByUserType(AuthenticationToken token, RoleRealmModel roleRealmModel) {
protected AuthenticationInfo doAuthenticate(AuthenticationToken token) throws AuthenticationException {
Realm realm; Realm realm;
if (token instanceof SaAdminToken) { if (token instanceof SaAdminToken) {
//超级管理员 //超级管理员
realm = (Realm)this.definedRealms.get(CommonEnumUtil.USER_TYPE.SA.getCode()); realm = roleRealmModel.getSaRealm();
} else if (token instanceof AdminToken) { } else if (token instanceof AdminToken) {
//管理员 //管理员
realm = (Realm)this.definedRealms.get(CommonEnumUtil.USER_TYPE.ADMIN.getCode()); realm = roleRealmModel.getAdminRealm();
} else if (token instanceof UserToken) { } else if (token instanceof UserToken) {
//用户 //用户
realm = (Realm)this.definedRealms.get(CommonEnumUtil.USER_TYPE.USER.getCode()); realm = roleRealmModel.getUserRealm();
} else { } else {
throw new AuthenticationException("不存在TOKEN，请联系管理员（"+token+"）"); throw new AuthenticationException("不存在TOKEN，请联系管理员（" + token + "）");
} }
return realm;
return this.doSingleRealmAuthentication(realm, token);
} }
@Override @Override

55
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/auth/realm/strategy/e9/E9AdminAuthRealm.java
Unescape Escape View File

@ -0,0 +1,55 @@
package cn.estsh.i3plus.core.apiservice.auth.realm.strategy.e9;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken;
import cn.estsh.i3plus.pojo.platform.bean.SessionUser;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description : 验证规则
* @Reference :
* @Author : alwaysfrin
* @CreateDate : 2018-10-13 14:04
* @Modify:
**/
public class E9AdminAuthRealm extends AuthorizingRealm {
public static final Logger LOGGER = LoggerFactory.getLogger(E9AdminAuthRealm.class);
@Autowired
private ISystemLoginService systemLoginService;
public E9AdminAuthRealm() {
//添加支持的token
this.setAuthenticationTokenClass(AdminToken.class);
}
//权限验证
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return new SimpleAuthorizationInfo();
}
//令牌确认
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
try {
//管理员令牌
SessionUser sessionUser = systemLoginService.queryCheckE9AdminLogin((AdminToken) authenticationToken);
LOGGER.info("管理员令牌验证：{}", sessionUser);
return new SimpleAuthenticationInfo(sessionUser, ((AdminToken) authenticationToken).getLoginName(), this.getName());
} catch (Exception e) {
e.printStackTrace();
throw new AuthenticationException(e.getMessage());
}
}
}

50
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/auth/realm/strategy/e9/E9SaAuthRealm.java
Unescape Escape View File

@ -0,0 +1,50 @@
package cn.estsh.i3plus.core.apiservice.auth.realm.strategy.e9;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.pojo.base.shirotoken.SaAdminToken;
import cn.estsh.i3plus.pojo.platform.bean.SessionUser;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description : 验证规则
* @Reference :
* @Author : alwaysfrin
* @CreateDate : 2018-10-13 14:04
* @Modify:
**/
public class E9SaAuthRealm extends AuthorizingRealm {
public static final Logger LOGGER = LoggerFactory.getLogger(E9SaAuthRealm.class);
@Autowired
private ISystemLoginService systemLoginService;
public E9SaAuthRealm() {
//添加支持的token
this.setAuthenticationTokenClass(SaAdminToken.class);
}
//权限验证
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return new SimpleAuthorizationInfo();
}
//令牌确认
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
//管理员令牌
SessionUser sessionUser = systemLoginService.queryCheckE9SaAdminLogin((SaAdminToken) authenticationToken);
LOGGER.info("超级管理员令牌验证：{}", sessionUser);
return new SimpleAuthenticationInfo(sessionUser, ((SaAdminToken) authenticationToken).getLoginName(), this.getName());
}
}

57
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/auth/realm/strategy/e9/E9UserAuthRealm.java
Unescape Escape View File

@ -0,0 +1,57 @@
package cn.estsh.i3plus.core.apiservice.auth.realm.strategy.e9;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken;
import cn.estsh.i3plus.pojo.base.shirotoken.UserToken;
import cn.estsh.i3plus.pojo.platform.bean.SessionUser;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @Description : 验证规则
* @Reference :-
* @Author : alwaysfrin
* @CreateDate : 2018-10-13 14:04
* @Modify:
**/
public class E9UserAuthRealm extends AuthorizingRealm {
public static final Logger LOGGER = LoggerFactory.getLogger(E9UserAuthRealm.class);
@Autowired
private ISystemLoginService systemLoginService;
public E9UserAuthRealm() {
//添加支持的token
this.setAuthenticationTokenClass(UserToken.class);
}
//权限验证
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return new SimpleAuthorizationInfo();
}
//令牌确认
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
try {
//管理员令牌
SessionUser sessionUser = systemLoginService.queryCheckE9UserLogin((UserToken) authenticationToken);
LOGGER.info("用户令牌验证：{}", sessionUser);
return new SimpleAuthenticationInfo(sessionUser, ((UserToken) authenticationToken).getLoginName(), this.getName());
} catch (Exception e) {
e.printStackTrace();
throw new AuthenticationException(e.getMessage());
}
}
}

1
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/controller/DemoController.java
Unescape Escape View File

@ -47,6 +47,7 @@ public class DemoController extends CoreBaseController {
@ApiOperation(value = "添加操作日志", notes = "添加操作日志，可用于国际化") @ApiOperation(value = "添加操作日志", notes = "添加操作日志，可用于国际化")
public ResultBean putRedisList(boolean isUpdate) { public ResultBean putRedisList(boolean isUpdate) {
try { try {
int x= 1/0;
// pojoVersionPlanService.refreshCache(isUpdate); // pojoVersionPlanService.refreshCache(isUpdate);
return ResultBean.success("操作成功").setCode(ResourceEnumUtil.MESSAGE.SUCCESS.getCode()); return ResultBean.success("操作成功").setCode(ResourceEnumUtil.MESSAGE.SUCCESS.getCode());
} catch (ImppBusiException busExcep) { } catch (ImppBusiException busExcep) {

91
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/controller/base/SysLogController.java
Unescape Escape View File

@ -0,0 +1,91 @@
package cn.estsh.i3plus.core.apiservice.controller.base;
import cn.estsh.i3plus.core.api.iservice.base.ISysLogService;
import cn.estsh.i3plus.platform.plugin.elasticsearch.ElasticSearchTool;
import cn.estsh.i3plus.pojo.base.common.Pager;
import cn.estsh.i3plus.pojo.model.platform.LogFieldModel;
import cn.estsh.i3plus.pojo.model.platform.SysLogModel;
import cn.estsh.impp.framework.boot.util.ResultBean;
import cn.estsh.impp.framework.boot.util.ValidatorBean;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author Wynne.Lu
* @date 2021/2/20 上午10:49
* @desc
*/
@Slf4j
@Api(tags = "系统日志查询服务")
@RestController
@RequestMapping("/log")
public class SysLogController {
@Autowired
private ISysLogService sysLogService;
@Value(value = "${elasticsearch.host:}")
private String elasticsearchHost;
@GetMapping("/log-query")
@ApiOperation(value = "按条件分页查询日志", notes = "按条件分页查询日志")
public ResultBean queryLogs(SysLogModel sysLogModel, Pager pager) {
try {
ValidatorBean.beginValid(sysLogModel)
.notNull("queryDate", sysLogModel.getQueryDate())
.notNull("queryBeginTime", sysLogModel.getQueryBeginTime())
.notNull("queryEndTime", sysLogModel.getQueryEndTime())
.notNull("level", sysLogModel.getLevel())
.notNull("indexName", sysLogModel.getIndexName());
List<LogFieldModel> list = sysLogService.querySysLog(sysLogModel, pager);
sysLogModel.setLogs(list);
return ResultBean.success(JSON.toJSONString(sysLogModel));
} catch (NoSuchFieldException e) {
log.error("字段缺省 发生异常：", e);
return ResultBean.fail(e.getMessage());
} catch (Exception e) {
log.error("搜索日志 发生异常：", e);
return ResultBean.fail(e.getMessage());
}
}
@GetMapping("/log-count-query")
@ApiOperation(value = "按条件分页查询日志", notes = "按条件分页查询日志")
public ResultBean queryLogsCount(SysLogModel sysLogModel, Pager pager) {
DateHistogramAggregationBuilder dateHistogramAgg = AggregationBuilders.dateHistogram("groupDate").field("@timestamp")
.calendarInterval(DateHistogramInterval.DAY).minDocCount(1);
return null;
}
@GetMapping("/indices-query")
@ApiOperation(value = "所有索引查询", notes = "所有索引查询")
public ResultBean queryIndices(String date) {
if (StringUtils.isEmpty(elasticsearchHost)) {
return ResultBean.fail("未在配置文件中配置Elasticsearch的地址");
}
ElasticSearchTool.init(elasticsearchHost);
List<String> indices = ElasticSearchTool.findMappingMetaData().keySet()
.stream().filter(d -> d.contains(date)).collect(Collectors.toList());
return ResultBean.success(JSON.toJSONString(indices));
}
}

196
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/controller/base/WhiteController.java
Unescape Escape View File

@ -2,13 +2,18 @@ package cn.estsh.i3plus.core.apiservice.controller.base;
import cn.estsh.i3plus.core.api.iservice.base.ISynchronizedService; import cn.estsh.i3plus.core.api.iservice.base.ISynchronizedService;
import cn.estsh.i3plus.core.api.iservice.base.ISystemInitService; import cn.estsh.i3plus.core.api.iservice.base.ISystemInitService;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginStrategyService;
import cn.estsh.i3plus.core.api.iservice.busi.*; import cn.estsh.i3plus.core.api.iservice.busi.*;
import cn.estsh.i3plus.core.apiservice.controller.busi.PersonnelController; import cn.estsh.i3plus.core.apiservice.controller.busi.PersonnelController;
import cn.estsh.i3plus.core.apiservice.controller.busi.SysUserInfoController; import cn.estsh.i3plus.core.apiservice.controller.busi.SysUserInfoController;
import cn.estsh.i3plus.core.apiservice.util.SysUserPasswordUtil; import cn.estsh.i3plus.core.apiservice.util.SysUserPasswordUtil;
import cn.estsh.i3plus.platform.common.convert.ConvertBean; import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum; import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum;
import cn.estsh.i3plus.platform.common.tool.*; import cn.estsh.i3plus.platform.common.tool.JsonUtilTool;
import cn.estsh.i3plus.platform.common.tool.ServletRequestTool;
import cn.estsh.i3plus.platform.common.tool.StringTool;
import cn.estsh.i3plus.platform.common.tool.TimeTool;
import cn.estsh.i3plus.platform.common.util.CommonConstWords; import cn.estsh.i3plus.platform.common.util.CommonConstWords;
import cn.estsh.i3plus.platform.common.util.PlatformConstWords; import cn.estsh.i3plus.platform.common.util.PlatformConstWords;
import cn.estsh.i3plus.pojo.base.annotation.AnnoIgnoreLog; import cn.estsh.i3plus.pojo.base.annotation.AnnoIgnoreLog;
@ -16,9 +21,11 @@ import cn.estsh.i3plus.pojo.base.bean.BaseConstWords;
import cn.estsh.i3plus.pojo.base.bean.BaseThreadLocal; import cn.estsh.i3plus.pojo.base.bean.BaseThreadLocal;
import cn.estsh.i3plus.pojo.base.bean.ListPager; import cn.estsh.i3plus.pojo.base.bean.ListPager;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.ResourceEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.ResourceEnumUtil;
import cn.estsh.i3plus.pojo.model.common.CloudPagerModel; import cn.estsh.i3plus.pojo.model.common.CloudPagerModel;
import cn.estsh.i3plus.pojo.model.license.ImppLicense; import cn.estsh.i3plus.pojo.model.license.ImppLicense;
import cn.estsh.i3plus.pojo.model.platform.SysLoginModel;
import cn.estsh.i3plus.pojo.model.platform.UserDetailModel; import cn.estsh.i3plus.pojo.model.platform.UserDetailModel;
import cn.estsh.i3plus.pojo.model.platform.UserDetailPagerModel; import cn.estsh.i3plus.pojo.model.platform.UserDetailPagerModel;
import cn.estsh.i3plus.pojo.platform.bean.*; import cn.estsh.i3plus.pojo.platform.bean.*;
@ -28,24 +35,48 @@ import cn.estsh.impp.framework.boot.exception.ImppBusiException;
import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder; import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
import cn.estsh.impp.framework.boot.license.ImppLicenseTool; import cn.estsh.impp.framework.boot.license.ImppLicenseTool;
import cn.estsh.impp.framework.boot.license.serviceimpl.ImppLicenseDecoder; import cn.estsh.impp.framework.boot.license.serviceimpl.ImppLicenseDecoder;
import cn.estsh.impp.framework.boot.util.*; import cn.estsh.impp.framework.boot.util.ImppRedis;
import cn.estsh.impp.framework.boot.util.LocaleUtils;
import cn.estsh.impp.framework.boot.util.RedisCacheTool;
import cn.estsh.impp.framework.boot.util.ResultBean;
import cn.estsh.impp.framework.boot.util.SpringContextsUtil;
import cn.estsh.impp.framework.boot.util.ValidatorBean;
import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.authc.*; import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.CredentialsException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.UnknownAccountException;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource; import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.util.*; import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import static cn.estsh.i3plus.platform.common.util.CommonConstWords.DEFAULT_LANGUAGE;
/** /**
* @Description : * @Description :
* @Reference : * @Reference :
@ -100,6 +131,9 @@ public class WhiteController extends CoreBaseController {
private ISysConfigService configService; private ISysConfigService configService;
@Autowired @Autowired
private ISystemLoginService loginService;
@Autowired
private SysUserPasswordUtil userPasswordUtil; private SysUserPasswordUtil userPasswordUtil;
@Resource(name = CommonConstWords.IMPP_REDIS_RES) @Resource(name = CommonConstWords.IMPP_REDIS_RES)
@ -114,7 +148,6 @@ public class WhiteController extends CoreBaseController {
@Autowired @Autowired
private RabbitTemplate rabbitTemplate; private RabbitTemplate rabbitTemplate;
@GetMapping(value = "/sys-locale-language/list") @GetMapping(value = "/sys-locale-language/list")
@ApiOperation(value = "查询可用语言", notes = "查询可用语言") @ApiOperation(value = "查询可用语言", notes = "查询可用语言")
public ResultBean listSysLocaleLanguage() { public ResultBean listSysLocaleLanguage() {
@ -140,6 +173,19 @@ public class WhiteController extends CoreBaseController {
} }
} }
@GetMapping(value = "/session-user")
@ApiOperation(value = "获取用户信息", notes = "获取当前登录用户账号详细信息")
public ResultBean getSession() {
LOGGER.info("获取用户信息...lang:{}", AuthUtil.getSessionAttribute("languageCode"));
try {
SessionUser sUser = AuthUtil.getSessionUser();
LOGGER.info("用户：{}", sUser);
return new ResultBean(true, "", sUser);
} catch (ImppBusiException e) {
return new ResultBean(false, e.getErrorDetail() + "-[解决]" + e.getErrorSolution());
}
}
/** /**
* @return * @return
*/ */
@ -155,97 +201,109 @@ public class WhiteController extends CoreBaseController {
} }
} }
@GetMapping(value = "/auth/login") @GetMapping(value = "/auth/{loginStrategy}/sso-login")
@ApiOperation(value = "登陆", notes = "登陆") @ApiOperation(value = "登录", notes = "登录")
public ResultBean login(HttpServletRequest request, String loginName, String loginPwd, public ResultBean ssoLogin(HttpServletRequest request, @PathVariable(name = "loginStrategy") String loginStrategy) throws NoSuchFieldException {
@RequestParam(required = false) String languageCode, String fieldMapping = RedisCacheTool.getSysConfigStrVal(PlatformConstWords.SSO_REQUEST_MAPPING);
@RequestParam(required = false) String deviceId) { if (StringUtils.isEmpty(fieldMapping)) {
Long startTime = System.currentTimeMillis(); return ResultBean.fail("请在平台数据库中配置表添加字段映射配置");
startMultiService(); }
licenseClickService.checkLicenseNumberLogin();
LOGGER.info("用户登陆 loginName:{} loginPwd:{} languageCode:{}", loginName, loginPwd, languageCode); SysLoginModel loginModel = assembleLoginModelByRequest(request, fieldMapping);
ResultBean result = null; loginModel.setLoginStrategy(loginStrategy);
CommonEnumUtil.USER_LOGIN_STATUS userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.LOGIN_SUCCESS;
try { ValidatorBean.beginValid(loginModel)
ValidatorBean.checkNotNull(languageCode, "语言不能为空"); .notNull("loginStrategy", loginModel.getLoginStrategy())
// TODO 后期移除，暂时用于避免自动登录后前台没有正确的传输组织代码信息 .notNull("loginName", loginModel.getLoginName());
if ("null".equals(languageCode)) { String beanName = ImppEnumUtil.AUTH_LOGIN_STRATEGY.codeOfStrategyName(loginModel.getLoginStrategy());
languageCode = DEFAULT_LANGUAGE; ISystemLoginStrategyService loginStrategyService = (ISystemLoginStrategyService) SpringContextsUtil.getBean(beanName);
}
// 设置语言代码 BaseThreadLocal.setData(PlatformConstWords.IS_SSO_LOGIN, true);
BaseThreadLocal.setData(BaseThreadLocal.LANGUAGE_CODE, languageCode);
ValidatorBean.checkNotNull(loginName, "用户名不能为空"); return loginByStrategy(request, loginModel, loginStrategyService.login());
ValidatorBean.checkNotNull(loginPwd, "密码不能为空"); }
int sessionMode = RedisCacheTool.getSysConfigIntVal(CommonConstWords.CONFIG_SESSION_MODE, CommonConstWords.CONFIG_SESSION_MODE_DEFAULT); private SysLoginModel assembleLoginModelByRequest(HttpServletRequest request, String fieldMapping) {
if (sessionMode != CommonEnumUtil.SESSION_MODE.SEIZE.getValue()) { JSONObject mappingObject = (JSONObject) JSONObject.parse(fieldMapping);
logout();
}
SessionUser user = userService.queryUserLogin(loginName.trim(), loginPwd.trim(), languageCode, getLoginPlatform().getValue(), deviceId); SysLoginModel loginModel = new SysLoginModel();
getJsonObjectParameterFromRequest("loginName", request, mappingObject).ifPresent(d -> loginModel.setLoginName(d.toString()));
getJsonObjectParameterFromRequest("loginPwd", request, mappingObject).ifPresent(d -> loginModel.setLoginPwd(d.toString()));
getJsonObjectParameterFromRequest("appId", request, mappingObject).ifPresent(d -> loginModel.setAppId(d.toString()));
getJsonObjectParameterFromRequest("languageCode", request, mappingObject).ifPresent(d -> loginModel.setLanguageCode(d.toString()));
getJsonObjectParameterFromRequest("deviceId", request, mappingObject).ifPresent(d -> loginModel.setDeviceId(d.toString()));
String redisKey = CommonConstWords.USER_LOGIN_ERROR + "_" + user.getUser().getId(); return loginModel;
redisCore.deleteKey(redisKey); }
// LOGGER.info("会员登陆：{}",user); private Optional<Object> getJsonObjectParameterFromRequest(String key, HttpServletRequest request, JSONObject mappingObject) {
Object data = request.getParameter(mappingObject.get(key) == null ? "" : mappingObject.get(key).toString());
return Optional.ofNullable(data);
}
result = new ResultBean(true, AuthUtil.getSession().getId().toString(), AuthUtil.getSessionUser()); @GetMapping(value = "/auth/login")
result.setUrl("/"); @ApiOperation(value = "登录", notes = "登录")
public ResultBean login(HttpServletRequest request, String loginName, String loginPwd,
@RequestParam(required = false) String languageCode,
@RequestParam(required = false) String deviceId) {
SysLoginModel loginModel = SysLoginModel.builder()
.loginName(loginName)
.loginPwd(loginPwd)
.languageCode(languageCode)
.deviceId(deviceId)
.loginStrategy(ImppEnumUtil.AUTH_LOGIN_STRATEGY.ACCOUNT.getCode()).build();
String beanName = ImppEnumUtil.AUTH_LOGIN_STRATEGY.codeOfStrategyName(loginModel.getLoginStrategy());
ISystemLoginStrategyService loginStrategyService = (ISystemLoginStrategyService) SpringContextsUtil.getBean(beanName);
return loginByStrategy(request, loginModel, loginStrategyService.login());
}
// 记录登录记录
recordSysUserLog(user.getUser().getUserInfoId(), loginName, CommonEnumUtil.USER_LOGIN_STATUS.LOGIN_SUCCESS.getValue()); private ResultBean loginByStrategy(HttpServletRequest request, SysLoginModel loginModel, BiFunction<HttpServletRequest, SysLoginModel, ResultBean> loginStrategy) {
AuthUtil.setOrganize(user.getUser().getOrganize()); long startTime = System.currentTimeMillis();
licenseClickService.checkLicenseNumberLogin();
LOGGER.info("用户登陆 loginName:{} loginPwd:{} languageCode:{}", loginModel.getLoginName(), loginModel.getLoginPwd(), loginModel.getLanguageCode());
ResultBean result = null;
CommonEnumUtil.USER_LOGIN_STATUS userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.LOGIN_SUCCESS;
try {
result = loginStrategy.apply(request, loginModel);
} catch (IncorrectCredentialsException e) { } catch (IncorrectCredentialsException e) {
result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_PASSWORD); result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_PASSWORD);
userPasswordUtil.checkLoginErrorNumber(loginName, result, e); userPasswordUtil.checkLoginErrorNumber(loginModel.getLoginName(), result, e);
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.WRONG_PASSWORD; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.WRONG_PASSWORD;
} catch (CredentialsException e) { } catch (CredentialsException e) {
// 用户名或密码错误 // 用户名或密码错误
result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_NAME); result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_NAME);
// 记录登录记录
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.WRONG_USERNAME_OR_PASSWORD; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.WRONG_USERNAME_OR_PASSWORD;
} catch (LockedAccountException e) { } catch (LockedAccountException e) {
// 账号已锁定 // 账号已锁定
result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_LOCKING); result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_LOCKING);
// 记录登录记录
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.USER_LOGIN_LOCKING; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.USER_LOGIN_LOCKING;
} catch (UnknownAccountException e) { } catch (UnknownAccountException e) {
// 用户信息不存在 // 用户信息不存在
result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_INFO_NULL); result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_INFO_NULL);
// 记录登录记录
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.USER_INFO_NULL; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.USER_INFO_NULL;
} catch (AuthenticationException e) { } catch (AuthenticationException e) {
// 系统异常 // 系统异常
result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_PASSWORD.getDescription()).setCode(ImppExceptionEnum.LOGIN_EXCEPTION_USER_PASSWORD.getCode()); result = ResultBean.fail(ImppExceptionEnum.LOGIN_EXCEPTION_USER_PASSWORD.getDescription()).setCode(ImppExceptionEnum.LOGIN_EXCEPTION_USER_PASSWORD.getCode());
result.setErrorMsg(e.getMessage()); result.setErrorMsg(e.getMessage());
// 记录登录记录
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.SYSTEM_ERROR; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.SYSTEM_ERROR;
} catch (ImppBusiException e) { } catch (ImppBusiException e) {
result = ResultBean.fail(e); result = ResultBean.fail(e);
// 记录登录记录
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.SYSTEM_ERROR; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.SYSTEM_ERROR;
} catch (Exception e) { } catch (Exception e) {
result = ResultBean.fail(e.getMessage()).setCode(ImppExceptionEnum.SYSTEM_EXCEPTION.getCode()) result = ResultBean.fail(e.getMessage()).setCode(ImppExceptionEnum.SYSTEM_EXCEPTION.getCode())
.setErrorMsg(LocaleUtils.getEnumLocaleResDesc(ImppExceptionEnum.SYSTEM_EXCEPTION, ImppExceptionEnum.SYSTEM_EXCEPTION.getDescription())); .setErrorMsg(LocaleUtils.getEnumLocaleResDesc(ImppExceptionEnum.SYSTEM_EXCEPTION, ImppExceptionEnum.SYSTEM_EXCEPTION.getDescription()));
// 记录登录记录
userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.SYSTEM_ERROR; userLoginStatus = CommonEnumUtil.USER_LOGIN_STATUS.SYSTEM_ERROR;
} finally { } finally {
// 记录登录记录 // 记录登录记录
recordSysUserLog(null, loginName, userLoginStatus.getValue()); recordSysUserLog(null, loginModel.getLoginName(), userLoginStatus.getValue());
} }
LOGGER.info("会员{}登陆登录完成 ,语言：{} , 登录耗时:{}", loginName, BaseThreadLocal.getThreadLanguageCode(), (System.currentTimeMillis() - startTime)); LOGGER.info("会员{}登陆登录完成 ,语言：{} , 登录耗时:{}", loginModel.getLoginName(), BaseThreadLocal.getThreadLanguageCode(), (System.currentTimeMillis() - startTime));
return result; return result;
} }
@ -493,30 +551,6 @@ public class WhiteController extends CoreBaseController {
Arrays.asList(CommonEnumUtil.LOG_LOGIN_PLATFORM.values())); Arrays.asList(CommonEnumUtil.LOG_LOGIN_PLATFORM.values()));
} }
/**
* 获取登录平台信息
*
* @return
*/
private CommonEnumUtil.LOG_LOGIN_PLATFORM getLoginPlatform() {
String value = CookieTool.getCookieValue(request, CommonConstWords.SESSION_LOGIN_PLATFORM);
if (StringUtils.isBlank(value)) {
value = CommonEnumUtil.LOG_LOGIN_PLATFORM.PC_IMPP_CORE.getValue() + "";
} else {
try {
Integer.parseInt(value);
} catch (Exception e) {
throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode())
.setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_FORMAT.getCode())
.setErrorDetail("平台登录标识转换错误")
.setErrorSolution("请重新操作")
.build();
}
}
CommonEnumUtil.LOG_LOGIN_PLATFORM platform = CommonEnumUtil.LOG_LOGIN_PLATFORM.valueOf(Integer.parseInt(value));
return platform == null ? CommonEnumUtil.LOG_LOGIN_PLATFORM.PC_IMPP_CORE : platform;
}
@GetMapping("/sys-organize/list") @GetMapping("/sys-organize/list")
@ApiOperation(value = "获取全部组织", notes = "获取全部组织") @ApiOperation(value = "获取全部组织", notes = "获取全部组织")

9
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/controller/busi/SysEnumController.java
Unescape Escape View File

@ -63,7 +63,7 @@ public class SysEnumController extends CoreBaseController {
List<CommonEnumUtil.DATA_STATUS> enumList = new ArrayList(); List<CommonEnumUtil.DATA_STATUS> enumList = new ArrayList();
enumList.add(CommonEnumUtil.DATA_STATUS.ENABLE); enumList.add(CommonEnumUtil.DATA_STATUS.ENABLE);
enumList.add(CommonEnumUtil.DATA_STATUS.DISABLE); enumList.add(CommonEnumUtil.DATA_STATUS.DISABLE);
return new ResultBean(true, "操作成功", LocaleUtils.getEnumLocaleResValueList(enumList)); return new ResultBean(true, "操作成功", LocaleUtils.getEnumLocaleResValueList(enumList));
} }
/** /**
@ -268,7 +268,6 @@ public class SysEnumController extends CoreBaseController {
} }
/** /**
* @return 处理结果 * @return 处理结果
*/ */
@ -288,11 +287,12 @@ public class SysEnumController extends CoreBaseController {
List<ImppEnumUtil.MESSAGE_TYPE> list = new ArrayList<>(); List<ImppEnumUtil.MESSAGE_TYPE> list = new ArrayList<>();
list.add(ImppEnumUtil.MESSAGE_TYPE.MAIL); list.add(ImppEnumUtil.MESSAGE_TYPE.MAIL);
list.add(ImppEnumUtil.MESSAGE_TYPE.LETTER); list.add(ImppEnumUtil.MESSAGE_TYPE.LETTER);
return new ResultBean(true, "操作成功", LocaleUtils.getEnumLocaleResValueList(list)); return new ResultBean(true, "操作成功", LocaleUtils.getEnumLocaleResValueList(list));
} }
/** /**
* 外部通知方式 * 外部通知方式
*
* @return 处理结果 * @return 处理结果
*/ */
@GetMapping("/external-notice-method") @GetMapping("/external-notice-method")
@ -300,11 +300,12 @@ public class SysEnumController extends CoreBaseController {
public ResultBean getExternalNoticeMethod() { public ResultBean getExternalNoticeMethod() {
List<ImppEnumUtil.MESSAGE_TYPE> list = new ArrayList<>(); List<ImppEnumUtil.MESSAGE_TYPE> list = new ArrayList<>();
list.add(ImppEnumUtil.MESSAGE_TYPE.MAIL); list.add(ImppEnumUtil.MESSAGE_TYPE.MAIL);
return new ResultBean(true, "操作成功", LocaleUtils.getEnumLocaleResValueList(list)); return new ResultBean(true, "操作成功", LocaleUtils.getEnumLocaleResValueList(list));
} }
/** /**
* 字典分组 * 字典分组
*
* @return 处理结果 * @return 处理结果
*/ */
@GetMapping("/dictionary-group") @GetMapping("/dictionary-group")

125
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/base/SysLogElasticSearchService.java
Unescape Escape View File

@ -9,7 +9,13 @@ import cn.estsh.i3plus.platform.plugin.elasticsearch.ElasticSearchTool;
import cn.estsh.i3plus.pojo.base.bean.ListPager; import cn.estsh.i3plus.pojo.base.bean.ListPager;
import cn.estsh.i3plus.pojo.base.common.Pager; import cn.estsh.i3plus.pojo.base.common.Pager;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.platform.platbean.*; import cn.estsh.i3plus.pojo.model.platform.LogFieldModel;
import cn.estsh.i3plus.pojo.model.platform.SysLogModel;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogConsole;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogException;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogOperate;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogSystem;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogTaskTime;
import cn.estsh.impp.framework.boot.log.ImppLog; import cn.estsh.impp.framework.boot.log.ImppLog;
import org.elasticsearch.search.aggregations.Aggregation; import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedTerms; import org.elasticsearch.search.aggregations.bucket.terms.ParsedTerms;
@ -18,7 +24,9 @@ import org.elasticsearch.search.aggregations.metrics.ParsedAvg;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
@ -40,19 +48,22 @@ public class SysLogElasticSearchService implements ISysLogService {
@Autowired @Autowired
private ImppLog imppLog; private ImppLog imppLog;
@Value(value = "${elasticsearch.host:}")
private String elasticsearchHost;
@Override @Override
public ListPager<SysLogException> queryLogExceptionPager(SysLogException log, Pager pager) { public ListPager<SysLogException> queryLogExceptionPager(SysLogException log, Pager pager) {
return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogException(log),pager,SysLogException.class); return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogException(log), pager, SysLogException.class);
} }
@Override @Override
public List<SysLogException> findLogExceptionList(SysLogException log, Pager pager) { public List<SysLogException> findLogExceptionList(SysLogException log, Pager pager) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogException(log),pager,SysLogException.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogException(log), pager, SysLogException.class);
} }
@Override @Override
public List<SysLogException> findLogExceptionList(SysLogException log) { public List<SysLogException> findLogExceptionList(SysLogException log) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogException(log),SysLogException.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogException(log), SysLogException.class);
} }
@Override @Override
@ -63,7 +74,7 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public SysLogException getLogException(SysLogException log) { public SysLogException getLogException(SysLogException log) {
return ElasticSearchTool.getPrimaryKey(log.getId(),SysLogException.class); return ElasticSearchTool.getPrimaryKey(log.getId(), SysLogException.class);
} }
@Override @Override
@ -73,17 +84,17 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public ListPager<SysLogOperate> queryLogOperatePager(SysLogOperate log, Pager pager) { public ListPager<SysLogOperate> queryLogOperatePager(SysLogOperate log, Pager pager) {
return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogOperate(log),pager,SysLogOperate.class); return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogOperate(log), pager, SysLogOperate.class);
} }
@Override @Override
public List<SysLogOperate> findLogOperateList(SysLogOperate log, Pager pager) { public List<SysLogOperate> findLogOperateList(SysLogOperate log, Pager pager) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogOperate(log),pager,SysLogOperate.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogOperate(log), pager, SysLogOperate.class);
} }
@Override @Override
public List<SysLogOperate> findLogOperateList(SysLogOperate log) { public List<SysLogOperate> findLogOperateList(SysLogOperate log) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogOperate(log),SysLogOperate.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogOperate(log), SysLogOperate.class);
} }
@Override @Override
@ -94,7 +105,7 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public SysLogOperate getLogOperate(SysLogOperate log) { public SysLogOperate getLogOperate(SysLogOperate log) {
return ElasticSearchTool.getPrimaryKey(log.getId(),SysLogOperate.class); return ElasticSearchTool.getPrimaryKey(log.getId(), SysLogOperate.class);
} }
@Override @Override
@ -104,12 +115,12 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public ListPager<SysLogSystem> queryLogSystemPager(SysLogSystem log, Pager pager) { public ListPager<SysLogSystem> queryLogSystemPager(SysLogSystem log, Pager pager) {
return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogSystem(log),pager,SysLogSystem.class); return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogSystem(log), pager, SysLogSystem.class);
} }
@Override @Override
public List<SysLogSystem> findLogSystemList(SysLogSystem log, Pager pager) { public List<SysLogSystem> findLogSystemList(SysLogSystem log, Pager pager) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogSystem(log),pager,SysLogSystem.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogSystem(log), pager, SysLogSystem.class);
} }
@Override @Override
@ -125,7 +136,7 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public SysLogSystem getLogSystem(SysLogSystem log) { public SysLogSystem getLogSystem(SysLogSystem log) {
return ElasticSearchTool.getPrimaryKey(log.getId(),SysLogSystem.class); return ElasticSearchTool.getPrimaryKey(log.getId(), SysLogSystem.class);
} }
@Override @Override
@ -135,17 +146,17 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public ListPager<SysLogTaskTime> queryLogTaskTimePager(SysLogTaskTime log, Pager pager) { public ListPager<SysLogTaskTime> queryLogTaskTimePager(SysLogTaskTime log, Pager pager) {
return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogTaskTime(log),pager,SysLogTaskTime.class); return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogTaskTime(log), pager, SysLogTaskTime.class);
} }
@Override @Override
public List<SysLogTaskTime> findLogTaskTimeList(SysLogTaskTime log, Pager pager) { public List<SysLogTaskTime> findLogTaskTimeList(SysLogTaskTime log, Pager pager) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogTaskTime(log),pager,SysLogTaskTime.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogTaskTime(log), pager, SysLogTaskTime.class);
} }
@Override @Override
public List<SysLogTaskTime> findLogTaskTimeList(SysLogTaskTime log) { public List<SysLogTaskTime> findLogTaskTimeList(SysLogTaskTime log) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogTaskTime(log),SysLogTaskTime.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogTaskTime(log), SysLogTaskTime.class);
} }
@Override @Override
@ -156,12 +167,12 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public SysLogTaskTime getLogTaskTime(SysLogTaskTime log) { public SysLogTaskTime getLogTaskTime(SysLogTaskTime log) {
return ElasticSearchTool.getPrimaryKey(log.getId(),SysLogTaskTime.class); return ElasticSearchTool.getPrimaryKey(log.getId(), SysLogTaskTime.class);
} }
@Override @Override
public void deleteLogTaskTime(SysLogTaskTime log) { public void deleteLogTaskTime(SysLogTaskTime log) {
ElasticSearchTool.deleteQuery(NoSqlPack.packEsSysLogTaskTime(log)); ElasticSearchTool.deleteQuery(NoSqlPack.packEsSysLogTaskTime(log));
} }
/******************************************************* 定时任务日志 End *********************************************************/ /******************************************************* 定时任务日志 End *********************************************************/
@ -170,29 +181,29 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public ListPager<SysLogConsole> queryLogConsolePager(SysLogConsole log, Pager pager) { public ListPager<SysLogConsole> queryLogConsolePager(SysLogConsole log, Pager pager) {
return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogConsole(log),pager,SysLogConsole.class); return ElasticSearchTool.searchPager(NoSqlPack.packEsSysLogConsole(log), pager, SysLogConsole.class);
} }
@Override @Override
public List<SysLogConsole> findLogConsoleList(SysLogConsole log, Pager pager) { public List<SysLogConsole> findLogConsoleList(SysLogConsole log, Pager pager) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogConsole(log),pager,SysLogConsole.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogConsole(log), pager, SysLogConsole.class);
} }
@Override @Override
public List<SysLogConsole> findLogConsoleList(SysLogConsole log) { public List<SysLogConsole> findLogConsoleList(SysLogConsole log) {
return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogConsole(log),SysLogConsole.class); return ElasticSearchTool.searchList(NoSqlPack.packEsSysLogConsole(log), SysLogConsole.class);
} }
@Override @Override
public SysLogConsole insertLogConsoleTime(SysLogConsole log) { public SysLogConsole insertLogConsoleTime(SysLogConsole log) {
ElasticSearchPack pack = ElasticSearchPack.imppBuild(TimeTool.parseDate(log.getCreateDatetime()), SysLogConsole.class); ElasticSearchPack pack = ElasticSearchPack.imppBuild(TimeTool.parseDate(log.getCreateDatetime()), SysLogConsole.class);
ElasticSearchTool.insert(pack.getIndexName(),log); ElasticSearchTool.insert(pack.getIndexName(), log);
return log; return log;
} }
@Override @Override
public SysLogConsole getLogConsoleTime(SysLogConsole log) { public SysLogConsole getLogConsoleTime(SysLogConsole log) {
return ElasticSearchTool.getPrimaryKey(log.getId(),SysLogConsole.class); return ElasticSearchTool.getPrimaryKey(log.getId(), SysLogConsole.class);
} }
@Override @Override
@ -206,24 +217,24 @@ public class SysLogElasticSearchService implements ISysLogService {
@Override @Override
public void actionCleanLog(String startTime, String endTime) { public void actionCleanLog(String startTime, String endTime) {
try { try {
ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogSystem.class),startTime,endTime); ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogSystem.class), startTime, endTime);
}catch (Exception e){ } catch (Exception e) {
LOGGER.error("清除系统日志异常",e); LOGGER.error("清除系统日志异常", e);
} }
try { try {
ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogOperate.class),startTime,endTime); ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogOperate.class), startTime, endTime);
}catch (Exception e){ } catch (Exception e) {
LOGGER.error("清除系统操作日志异常",e); LOGGER.error("清除系统操作日志异常", e);
} }
try { try {
ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogException.class),startTime,endTime); ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogException.class), startTime, endTime);
}catch (Exception e){ } catch (Exception e) {
LOGGER.error("清除系统异常日志异常",e); LOGGER.error("清除系统异常日志异常", e);
} }
try { try {
ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogTaskTime.class),startTime,endTime); ElasticSearchTool.deleteIndex(ElasticSearchPack.getIndexName(SysLogTaskTime.class), startTime, endTime);
}catch (Exception e){ } catch (Exception e) {
LOGGER.error("清除定时任务日志异常",e); LOGGER.error("清除定时任务日志异常", e);
} }
} }
@ -232,18 +243,18 @@ public class SysLogElasticSearchService implements ISysLogService {
Map resultData = new LinkedHashMap(); Map resultData = new LinkedHashMap();
ElasticSearchPack pack = ElasticSearchPack.imppBuild(SysLogSystem.class); ElasticSearchPack pack = ElasticSearchPack.imppBuild(SysLogSystem.class);
pack.pager(CommonConstWords.getDefaultPager()); pack.pager(CommonConstWords.getDefaultPager());
pack.andStringDateTimeBetween("createDatetime",startTime,endTime); pack.andStringDateTimeBetween("createDatetime", startTime, endTime);
pack.group("createDatetime").avg("executeTime").buildAggregation(); pack.group("createDatetime").avg("executeTime").buildAggregation();
Map<String, Aggregation> aggregationMap = ElasticSearchTool.searchAggregationMap(pack); Map<String, Aggregation> aggregationMap = ElasticSearchTool.searchAggregationMap(pack);
ParsedTerms parsedTerms = (ParsedTerms)aggregationMap.get("group_createDatetime"); ParsedTerms parsedTerms = (ParsedTerms) aggregationMap.get("group_createDatetime");
if(Objects.nonNull(parsedTerms)){ if (Objects.nonNull(parsedTerms)) {
for (Terms.Bucket bucket : parsedTerms.getBuckets()) { for (Terms.Bucket bucket : parsedTerms.getBuckets()) {
try { try {
String key = bucket.getKeyAsString(); String key = bucket.getKeyAsString();
Double value = ((ParsedAvg) bucket.getAggregations().get("avg_executeTime")).getValue(); Double value = ((ParsedAvg) bucket.getAggregations().get("avg_executeTime")).getValue();
resultData.put(key,value.intValue()); resultData.put(key, value.intValue());
}catch (Exception e){ } catch (Exception e) {
} }
} }
} }
@ -256,18 +267,18 @@ public class SysLogElasticSearchService implements ISysLogService {
Map resultData = new LinkedHashMap(); Map resultData = new LinkedHashMap();
ElasticSearchPack pack = ElasticSearchPack.imppBuild(SysLogSystem.class); ElasticSearchPack pack = ElasticSearchPack.imppBuild(SysLogSystem.class);
pack.pager(CommonConstWords.getDefaultPager()); pack.pager(CommonConstWords.getDefaultPager());
pack.andStringDateTimeBetween("createDatetime",startTime,endTime); pack.andStringDateTimeBetween("createDatetime", startTime, endTime);
pack.group("logLevel").count("id").buildAggregation(); pack.group("logLevel").count("id").buildAggregation();
Map<String, Aggregation> aggregationMap = ElasticSearchTool.searchAggregationMap(pack); Map<String, Aggregation> aggregationMap = ElasticSearchTool.searchAggregationMap(pack);
ParsedTerms parsedTerms = (ParsedTerms)aggregationMap.get("group_logLevel"); ParsedTerms parsedTerms = (ParsedTerms) aggregationMap.get("group_logLevel");
if(Objects.nonNull(parsedTerms)){ if (Objects.nonNull(parsedTerms)) {
for (Terms.Bucket bucket : parsedTerms.getBuckets()) { for (Terms.Bucket bucket : parsedTerms.getBuckets()) {
try { try {
String key = bucket.getKeyAsString(); String key = bucket.getKeyAsString();
resultData.put(ImppEnumUtil.LOG_LEVEL.valueOfName(Integer.parseInt(key)),bucket.getDocCount()); resultData.put(ImppEnumUtil.LOG_LEVEL.valueOfName(Integer.parseInt(key)), bucket.getDocCount());
}catch (Exception e){ } catch (Exception e) {
} }
} }
} }
@ -275,6 +286,32 @@ public class SysLogElasticSearchService implements ISysLogService {
return resultData; return resultData;
} }
@Override
public List<LogFieldModel> querySysLog(SysLogModel sysLogModel, Pager pager) {
final String time = "time";
ElasticSearchTool.init(elasticsearchHost);
ElasticSearchPack pack = new ElasticSearchPack(sysLogModel.getIndexName());
pack.andKeywordEquals("level", sysLogModel.getLevel());
if (!StringUtils.isEmpty(sysLogModel.getHostId())) {
pack.andKeywordEquals("hostId", sysLogModel.getHostId());
}
if (!StringUtils.isEmpty(sysLogModel.getIndexType())) {
pack.andKeywordEquals("indexType", sysLogModel.getIndexType());
}
if (!StringUtils.isEmpty(sysLogModel.getThread())) {
pack.andKeywordEquals("thread", sysLogModel.getThread());
}
pack.andKeywordDateTimeBetween(time,
sysLogModel.getQueryDate().trim() + " " + sysLogModel.getQueryBeginTime(),
sysLogModel.getQueryDate().trim() + " " + sysLogModel.getQueryEndTime());
pack.orderKeywordDesc(time);
ListPager<LogFieldModel> listPager = ElasticSearchTool.searchPager(pack, pager, LogFieldModel.class);
return listPager.getObjectList();
}
/******************************************************* 系统异常日志 End *********************************************************/ /******************************************************* 系统异常日志 End *********************************************************/

47
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/base/SysLogFactory.java
Unescape Escape View File

@ -6,7 +6,13 @@ import cn.estsh.i3plus.pojo.base.bean.ListPager;
import cn.estsh.i3plus.pojo.base.common.Pager; import cn.estsh.i3plus.pojo.base.common.Pager;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.platform.platbean.*; import cn.estsh.i3plus.pojo.model.platform.LogFieldModel;
import cn.estsh.i3plus.pojo.model.platform.SysLogModel;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogConsole;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogException;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogOperate;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogSystem;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogTaskTime;
import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder; import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
import cn.estsh.impp.framework.boot.log.ImppLog; import cn.estsh.impp.framework.boot.log.ImppLog;
import cn.estsh.impp.framework.boot.util.ImppSwitchUtil; import cn.estsh.impp.framework.boot.util.ImppSwitchUtil;
@ -41,7 +47,7 @@ public class SysLogFactory implements ISysLogService {
@Autowired @Autowired
private ImppLog imppLog; private ImppLog imppLog;
private ISysLogService getSysLogService(){ private ISysLogService getSysLogService() {
ImppEnumUtil.LOG_STORAGE storage = imppLog.getLogStorageCase(); ImppEnumUtil.LOG_STORAGE storage = imppLog.getLogStorageCase();
// if(ImppEnumUtil.LOG_STORAGE.MONGO.equals(storage)){ // if(ImppEnumUtil.LOG_STORAGE.MONGO.equals(storage)){
@ -56,10 +62,10 @@ public class SysLogFactory implements ISysLogService {
// .build(); // .build();
// } // }
// }else // }else
if(ImppEnumUtil.LOG_STORAGE.ELASTICSEARCH.equals(storage)){ if (ImppEnumUtil.LOG_STORAGE.ELASTICSEARCH.equals(storage)) {
if(ImppSwitchUtil.isElasticSearchSwitch() && elasticSearchService != null){ if (ImppSwitchUtil.isElasticSearchSwitch() && elasticSearchService != null) {
return elasticSearchService; return elasticSearchService;
}else{ } else {
throw ImppExceptionBuilder.newInstance() throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.IMPP.getCode()) .setSystemID(CommonEnumUtil.SOFT_TYPE.IMPP.getCode())
.setErrorCode(ImppExceptionEnum.LOG_SAVE_STORAGE_ERROR.getCode()) .setErrorCode(ImppExceptionEnum.LOG_SAVE_STORAGE_ERROR.getCode())
@ -79,12 +85,12 @@ public class SysLogFactory implements ISysLogService {
@Override @Override
public ListPager<SysLogException> queryLogExceptionPager(SysLogException log, Pager pager) { public ListPager<SysLogException> queryLogExceptionPager(SysLogException log, Pager pager) {
return getSysLogService().queryLogExceptionPager(log,pager); return getSysLogService().queryLogExceptionPager(log, pager);
} }
@Override @Override
public List<SysLogException> findLogExceptionList(SysLogException log, Pager pager) { public List<SysLogException> findLogExceptionList(SysLogException log, Pager pager) {
return getSysLogService().findLogExceptionList(log,pager); return getSysLogService().findLogExceptionList(log, pager);
} }
@Override @Override
@ -109,12 +115,12 @@ public class SysLogFactory implements ISysLogService {
@Override @Override
public ListPager<SysLogOperate> queryLogOperatePager(SysLogOperate log, Pager pager) { public ListPager<SysLogOperate> queryLogOperatePager(SysLogOperate log, Pager pager) {
return getSysLogService().queryLogOperatePager(log,pager); return getSysLogService().queryLogOperatePager(log, pager);
} }
@Override @Override
public List<SysLogOperate> findLogOperateList(SysLogOperate log, Pager pager) { public List<SysLogOperate> findLogOperateList(SysLogOperate log, Pager pager) {
return getSysLogService().findLogOperateList(log,pager); return getSysLogService().findLogOperateList(log, pager);
} }
@Override @Override
@ -134,17 +140,17 @@ public class SysLogFactory implements ISysLogService {
@Override @Override
public void deleteLogOperate(SysLogOperate log) { public void deleteLogOperate(SysLogOperate log) {
getSysLogService().deleteLogOperate(log); getSysLogService().deleteLogOperate(log);
} }
@Override @Override
public ListPager<SysLogSystem> queryLogSystemPager(SysLogSystem log, Pager pager) { public ListPager<SysLogSystem> queryLogSystemPager(SysLogSystem log, Pager pager) {
return getSysLogService().queryLogSystemPager(log,pager); return getSysLogService().queryLogSystemPager(log, pager);
} }
@Override @Override
public List<SysLogSystem> findLogSystemList(SysLogSystem log, Pager pager) { public List<SysLogSystem> findLogSystemList(SysLogSystem log, Pager pager) {
return getSysLogService().findLogSystemList(log,pager); return getSysLogService().findLogSystemList(log, pager);
} }
@Override @Override
@ -169,12 +175,12 @@ public class SysLogFactory implements ISysLogService {
@Override @Override
public ListPager<SysLogTaskTime> queryLogTaskTimePager(SysLogTaskTime log, Pager pager) { public ListPager<SysLogTaskTime> queryLogTaskTimePager(SysLogTaskTime log, Pager pager) {
return getSysLogService().queryLogTaskTimePager(log,pager); return getSysLogService().queryLogTaskTimePager(log, pager);
} }
@Override @Override
public List<SysLogTaskTime> findLogTaskTimeList(SysLogTaskTime log, Pager pager) { public List<SysLogTaskTime> findLogTaskTimeList(SysLogTaskTime log, Pager pager) {
return getSysLogService().findLogTaskTimeList(log,pager); return getSysLogService().findLogTaskTimeList(log, pager);
} }
@Override @Override
@ -194,18 +200,18 @@ public class SysLogFactory implements ISysLogService {
@Override @Override
public void deleteLogTaskTime(SysLogTaskTime log) { public void deleteLogTaskTime(SysLogTaskTime log) {
getSysLogService().deleteLogTaskTime(log); getSysLogService().deleteLogTaskTime(log);
} }
@Override @Override
public ListPager<SysLogConsole> queryLogConsolePager(SysLogConsole log, Pager pager) { public ListPager<SysLogConsole> queryLogConsolePager(SysLogConsole log, Pager pager) {
return getSysLogService().queryLogConsolePager(log,pager); return getSysLogService().queryLogConsolePager(log, pager);
} }
@Override @Override
public List<SysLogConsole> findLogConsoleList(SysLogConsole log, Pager pager) { public List<SysLogConsole> findLogConsoleList(SysLogConsole log, Pager pager) {
return getSysLogService().findLogConsoleList(log,pager); return getSysLogService().findLogConsoleList(log, pager);
} }
@Override @Override
@ -233,7 +239,7 @@ public class SysLogFactory implements ISysLogService {
@Override @Override
public void actionCleanLog(String startTime, String endTime) { public void actionCleanLog(String startTime, String endTime) {
getSysLogService().actionCleanLog(startTime,endTime); getSysLogService().actionCleanLog(startTime, endTime);
} }
@Override @Override
@ -246,6 +252,11 @@ public class SysLogFactory implements ISysLogService {
return getSysLogService().querySysLogSystemByLevel(startTime, endTime); return getSysLogService().querySysLogSystemByLevel(startTime, endTime);
} }
@Override
public List<LogFieldModel> querySysLog(SysLogModel logModel, Pager pager) {
return getSysLogService().querySysLog(logModel, pager);
}
/******************************************************* 系统异常日志 End *********************************************************/ /******************************************************* 系统异常日志 End *********************************************************/

41
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/base/SysLogMongoService.java
Unescape Escape View File

@ -11,7 +11,13 @@ import cn.estsh.i3plus.pojo.base.common.Pager;
import cn.estsh.i3plus.pojo.base.common.PagerHelper; import cn.estsh.i3plus.pojo.base.common.PagerHelper;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.platform.platbean.*; import cn.estsh.i3plus.pojo.model.platform.LogFieldModel;
import cn.estsh.i3plus.pojo.model.platform.SysLogModel;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogConsole;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogException;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogOperate;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogSystem;
import cn.estsh.i3plus.pojo.platform.platbean.SysLogTaskTime;
import cn.estsh.i3plus.pojo.platform.platrepositorymongo.SysLogExceptionRepository; import cn.estsh.i3plus.pojo.platform.platrepositorymongo.SysLogExceptionRepository;
import cn.estsh.i3plus.pojo.platform.platrepositorymongo.SysLogOperateRepository; import cn.estsh.i3plus.pojo.platform.platrepositorymongo.SysLogOperateRepository;
import cn.estsh.i3plus.pojo.platform.platrepositorymongo.SysLogSystemRepository; import cn.estsh.i3plus.pojo.platform.platrepositorymongo.SysLogSystemRepository;
@ -56,7 +62,7 @@ public class SysLogMongoService implements ISysLogService {
if (logTaskTimeRDao == null && ImppSwitchUtil.isSwitchMongo()) { if (logTaskTimeRDao == null && ImppSwitchUtil.isSwitchMongo()) {
try { try {
logTaskTimeRDao = SpringContextsUtil.getBean(SysLogTaskTimeRepository.class); logTaskTimeRDao = SpringContextsUtil.getBean(SysLogTaskTimeRepository.class);
}catch (Exception e){ } catch (Exception e) {
} }
} }
@ -76,7 +82,7 @@ public class SysLogMongoService implements ISysLogService {
if (logSystemRDao == null && ImppSwitchUtil.isSwitchMongo()) { if (logSystemRDao == null && ImppSwitchUtil.isSwitchMongo()) {
try { try {
logSystemRDao = SpringContextsUtil.getBean(SysLogSystemRepository.class); logSystemRDao = SpringContextsUtil.getBean(SysLogSystemRepository.class);
}catch (Exception e){ } catch (Exception e) {
} }
} }
@ -96,7 +102,7 @@ public class SysLogMongoService implements ISysLogService {
if (logOperateRDao == null && ImppSwitchUtil.isSwitchMongo()) { if (logOperateRDao == null && ImppSwitchUtil.isSwitchMongo()) {
try { try {
logOperateRDao = SpringContextsUtil.getBean(SysLogOperateRepository.class); logOperateRDao = SpringContextsUtil.getBean(SysLogOperateRepository.class);
}catch (Exception e){ } catch (Exception e) {
} }
} }
@ -116,7 +122,7 @@ public class SysLogMongoService implements ISysLogService {
if (logExceptionRDao == null && ImppSwitchUtil.isSwitchMongo()) { if (logExceptionRDao == null && ImppSwitchUtil.isSwitchMongo()) {
try { try {
logExceptionRDao = SpringContextsUtil.getBean(SysLogExceptionRepository.class); logExceptionRDao = SpringContextsUtil.getBean(SysLogExceptionRepository.class);
}catch (Exception e){ } catch (Exception e) {
} }
} }
@ -136,7 +142,7 @@ public class SysLogMongoService implements ISysLogService {
if (mongoDbFactory == null && ImppSwitchUtil.isSwitchMongo()) { if (mongoDbFactory == null && ImppSwitchUtil.isSwitchMongo()) {
try { try {
mongoDbFactory = SpringContextsUtil.getBean(MongoDbFactory.class); mongoDbFactory = SpringContextsUtil.getBean(MongoDbFactory.class);
}catch (Exception e){ } catch (Exception e) {
} }
} }
@ -153,7 +159,6 @@ public class SysLogMongoService implements ISysLogService {
} }
@Override @Override
public ListPager<SysLogException> queryLogExceptionPager(SysLogException log, Pager pager) { public ListPager<SysLogException> queryLogExceptionPager(SysLogException log, Pager pager) {
Bson bson = NoSqlPack.packMongoBySysLogException(log); Bson bson = NoSqlPack.packMongoBySysLogException(log);
@ -355,13 +360,13 @@ public class SysLogMongoService implements ISysLogService {
@Override @Override
public void actionCleanLog(String startTime, String endTime) { public void actionCleanLog(String startTime, String endTime) {
try{ try {
SysLogOperate operate = new SysLogOperate(); SysLogOperate operate = new SysLogOperate();
operate.setCreateDatetime(startTime); operate.setCreateDatetime(startTime);
operate.setCreateDateTimeStart(startTime); operate.setCreateDateTimeStart(startTime);
operate.setCreateDateTimeEnd(endTime); operate.setCreateDateTimeEnd(endTime);
deleteLogOperate(operate); deleteLogOperate(operate);
}catch (Exception e){ } catch (Exception e) {
} }
try { try {
@ -370,7 +375,7 @@ public class SysLogMongoService implements ISysLogService {
system.setCreateDateTimeStart(startTime); system.setCreateDateTimeStart(startTime);
system.setCreateDateTimeEnd(endTime); system.setCreateDateTimeEnd(endTime);
deleteLogSystem(system); deleteLogSystem(system);
}catch (Exception e){ } catch (Exception e) {
} }
try { try {
@ -379,7 +384,7 @@ public class SysLogMongoService implements ISysLogService {
exception.setCreateDateTimeStart(startTime); exception.setCreateDateTimeStart(startTime);
exception.setCreateDateTimeEnd(endTime); exception.setCreateDateTimeEnd(endTime);
deleteLogException(exception); deleteLogException(exception);
}catch (Exception e){ } catch (Exception e) {
} }
try { try {
@ -388,7 +393,7 @@ public class SysLogMongoService implements ISysLogService {
taskTime.setCreateDateTimeStart(startTime); taskTime.setCreateDateTimeStart(startTime);
taskTime.setCreateDateTimeEnd(endTime); taskTime.setCreateDateTimeEnd(endTime);
deleteLogTaskTime(taskTime); deleteLogTaskTime(taskTime);
}catch (Exception e){ } catch (Exception e) {
} }
try { try {
@ -397,7 +402,7 @@ public class SysLogMongoService implements ISysLogService {
console.setCreateDateTimeStart(startTime); console.setCreateDateTimeStart(startTime);
console.setCreateDateTimeEnd(endTime); console.setCreateDateTimeEnd(endTime);
deleteLogConsoleTime(console); deleteLogConsoleTime(console);
}catch (Exception e){ } catch (Exception e) {
} }
} }
@ -467,6 +472,16 @@ public class SysLogMongoService implements ISysLogService {
return resultData; return resultData;
} }
@Override
public List<LogFieldModel> querySysLog(SysLogModel logModel, Pager pager) {
throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode())
.setErrorCode(cn.estsh.impp.framework.boot.exception.ImppExceptionEnum.DATABASE_EXCEPTION.getCode())
.setErrorDetail("querySysLog 为elasticsearch使用方法")
.setErrorSolution("请联系管理人员")
.build();
}
/******************************************************* 系统异常日志 End *********************************************************/ /******************************************************* 系统异常日志 End *********************************************************/

171
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/base/SystemLoginService.java
Unescape Escape View File

@ -4,7 +4,8 @@ import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.core.api.iservice.busi.ISysUserPasswordService; import cn.estsh.i3plus.core.api.iservice.busi.ISysUserPasswordService;
import cn.estsh.i3plus.core.apiservice.util.SysUserPasswordUtil; import cn.estsh.i3plus.core.apiservice.util.SysUserPasswordUtil;
import cn.estsh.i3plus.platform.common.convert.ConvertBean; import cn.estsh.i3plus.platform.common.convert.ConvertBean;
import cn.estsh.i3plus.platform.common.tool.EncryptTool; import cn.estsh.i3plus.platform.common.exception.ImppExceptionEnum;
import cn.estsh.i3plus.platform.common.tool.CookieTool;
import cn.estsh.i3plus.platform.common.util.CommonConstWords; import cn.estsh.i3plus.platform.common.util.CommonConstWords;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil; import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken; import cn.estsh.i3plus.pojo.base.shirotoken.AdminToken;
@ -16,13 +17,11 @@ import cn.estsh.i3plus.pojo.platform.bean.SysUserPassword;
import cn.estsh.i3plus.pojo.platform.repository.SysUserRepository; import cn.estsh.i3plus.pojo.platform.repository.SysUserRepository;
import cn.estsh.impp.framework.boot.auth.AuthUtil; import cn.estsh.impp.framework.boot.auth.AuthUtil;
import cn.estsh.impp.framework.boot.exception.ImppBusiException; import cn.estsh.impp.framework.boot.exception.ImppBusiException;
import cn.estsh.impp.framework.boot.util.ImppLdapUtils; import cn.estsh.impp.framework.boot.exception.ImppExceptionBuilder;
import cn.estsh.impp.framework.boot.util.ImppRedis; import cn.estsh.impp.framework.boot.util.ImppRedis;
import cn.estsh.impp.framework.boot.util.ImppSwitchUtil; import cn.estsh.impp.framework.boot.util.ImppSwitchUtil;
import cn.estsh.impp.framework.boot.util.ValidatorBean;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.shiro.authc.CredentialsException; import org.apache.shiro.authc.CredentialsException;
import org.apache.shiro.authc.IncorrectCredentialsException; import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException; import org.apache.shiro.authc.LockedAccountException;
@ -33,8 +32,7 @@ import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.Resource; import javax.annotation.Resource;
import java.io.UnsupportedEncodingException; import javax.servlet.http.HttpServletRequest;
import java.security.NoSuchAlgorithmException;
import java.util.Objects; import java.util.Objects;
/** /**
@ -66,65 +64,95 @@ public class SystemLoginService implements ISystemLoginService {
protected ImppRedis redisCore; protected ImppRedis redisCore;
@Override @Override
@ApiOperation(value = "用户登录",notes = "普通用户登录") @ApiOperation(value = "用户登录", notes = "普通用户登录")
public SessionUser queryUserLogin(String loginName, String loginPwd, String languageCode) { public SessionUser queryUserLogin(String loginName, String loginPwd, String languageCode) {
//生成令牌 //生成令牌
UserToken ut = new UserToken(loginName,loginPwd,languageCode); UserToken ut = new UserToken(loginName, loginPwd, languageCode);
//token验证 //token验证
return AuthUtil.login(ut); return AuthUtil.login(ut);
} }
public static void main(String[] args) {
System.out.println(1+2+"a");
}
@Override @Override
@ApiOperation(value = "用户登录",notes = "管理用户登录") @ApiOperation(value = "用户登录", notes = "管理用户登录")
public SessionUser queryAdminLogin(String loginName, String loginPwd, String languageCode) { public SessionUser queryAdminLogin(String loginName, String loginPwd, String languageCode) {
//生成令牌 //生成令牌
AdminToken adminToken = new AdminToken(loginName,loginPwd,languageCode); AdminToken adminToken = new AdminToken(loginName, loginPwd, languageCode);
//token验证 //token验证
return AuthUtil.login(adminToken); return AuthUtil.login(adminToken);
} }
@Override @Override
@ApiOperation(value = "封装用户",notes = "封装普通用户信息") @ApiOperation(value = "封装用户", notes = "封装普通用户信息")
public SessionUser queryCheckUserLogin(UserToken userToken) { public SessionUser queryCheckUserLogin(UserToken userToken) {
//验证用户 //验证用户
SysUser user = getUserLoginInfo(userToken.getLoginName(),userToken.getLoginPwd()); SysUser user = getUserLoginInfo(userToken.getLoginName(), userToken.getLoginPwd());
LOGGER.info("【验证用户checkUserLogin】{}",user); LOGGER.info("【验证用户checkUserLogin】{}", user);
//用户单地登录 //用户单地登录
return packSessionUser(user,CommonEnumUtil.USER_TYPE.USER.getCode(),userToken.getLanguageCode()); return packSessionUser(user, CommonEnumUtil.USER_TYPE.USER.getCode(), userToken.getLanguageCode());
} }
@Override @Override
@ApiOperation(value = "封装用户",notes = "封装管理员信息") @ApiOperation(value = "封装用户", notes = "封装管理员信息")
public SessionUser queryCheckAdminLogin(AdminToken adminToken) { public SessionUser queryCheckAdminLogin(AdminToken adminToken) {
//验证用户 //验证用户
SysUser user = getUserLoginInfo(adminToken.getLoginName(),adminToken.getLoginPwd()); SysUser user = getUserLoginInfo(adminToken.getLoginName(), adminToken.getLoginPwd());
//未抛异常，封装用户 //未抛异常，封装用户
return packSessionUser(user,CommonEnumUtil.USER_TYPE.ADMIN.getCode(),adminToken.getLanguageCode()); return packSessionUser(user, CommonEnumUtil.USER_TYPE.ADMIN.getCode(), adminToken.getLanguageCode());
} }
@Override @Override
@ApiOperation(value = "封装用户",notes = "封装超级管理员信息") @ApiOperation(value = "封装用户", notes = "封装超级管理员信息")
public SessionUser queryCheckSaAdminLogin(SaAdminToken saAdminToken) { public SessionUser queryCheckSaAdminLogin(SaAdminToken saAdminToken) {
SysUser user = getUserLoginInfo(saAdminToken.getLoginName(),saAdminToken.getLoginPwd()); SysUser user = getUserLoginInfo(saAdminToken.getLoginName(), saAdminToken.getLoginPwd());
return packSessionUser(user,CommonEnumUtil.USER_TYPE.SA.getCode(),saAdminToken.getLanguageCode()); return packSessionUser(user, CommonEnumUtil.USER_TYPE.SA.getCode(), saAdminToken.getLanguageCode());
}
@Override
@ApiOperation(value = "封装用户", notes = "封装普通用户信息")
public SessionUser queryCheckE9UserLogin(UserToken userToken) {
//验证用户
SysUser user = getUserLoginInfo(userToken.getLoginName());
LOGGER.info("【验证用户checkUserLogin】{}", user);
//用户单地登录
return packSessionUser(user, CommonEnumUtil.USER_TYPE.USER.getCode(), userToken.getLanguageCode());
} }
@Override @Override
@ApiOperation(value = "登录密码错误",notes = "登录密码错误记录错误次数功能") @ApiOperation(value = "封装用户", notes = "封装管理员信息")
public Integer doLoginPasswordError(String loginName,String sessionId) { public SessionUser queryCheckE9AdminLogin(AdminToken adminToken) {
//验证用户
SysUser user = getUserLoginInfo(adminToken.getLoginName());
//未抛异常，封装用户
return packSessionUser(user, CommonEnumUtil.USER_TYPE.ADMIN.getCode(), adminToken.getLanguageCode());
}
@Override
@ApiOperation(value = "封装用户", notes = "封装超级管理员信息")
public SessionUser queryCheckE9SaAdminLogin(SaAdminToken saAdminToken) {
SysUser user = getUserLoginInfo(saAdminToken.getLoginName());
return packSessionUser(user, CommonEnumUtil.USER_TYPE.SA.getCode(), saAdminToken.getLanguageCode());
}
@Override
@ApiOperation(value = "登录密码错误", notes = "登录密码错误记录错误次数功能")
public Integer doLoginPasswordError(String loginName, String sessionId) {
SysUser user = sysUserRDao.getByProperty(new String[]{"userLoginName", "isValid"}, SysUser user = sysUserRDao.getByProperty(new String[]{"userLoginName", "isValid"},
new Object[]{loginName, CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()}); new Object[]{loginName, CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()});
if(user != null){ if (user != null) {
String redisKey = CommonConstWords.USER_LOGIN_ERROR + "_" + sessionId + "_" + user.getId(); String redisKey = CommonConstWords.USER_LOGIN_ERROR + "_" + sessionId + "_" + user.getId();
Object redisValue = redisCore.getObject(redisKey); Object redisValue = redisCore.getObject(redisKey);
Integer num = redisValue == null ? 1 : Integer.parseInt(redisValue.toString()) + 1; Integer num = redisValue == null ? 1 : Integer.parseInt(redisValue.toString()) + 1;
if(num >= CommonConstWords.USER_LOGIN_ERROR_MAX_NUM){ if (num >= CommonConstWords.USER_LOGIN_ERROR_MAX_NUM) {
user.setUserStatus(CommonEnumUtil.USER_STATUS.LOCKING.getValue()); user.setUserStatus(CommonEnumUtil.USER_STATUS.LOCKING.getValue());
redisCore.deleteKey(redisKey); redisCore.deleteKey(redisKey);
sysUserRDao.update(user); sysUserRDao.update(user);
}else{ } else {
redisCore.putObject(redisKey,num,CommonConstWords.REDIS_TIME_DAY_ONE); redisCore.putObject(redisKey, num, CommonConstWords.REDIS_TIME_DAY_ONE);
} }
return num; return num;
} }
@ -132,39 +160,57 @@ public class SystemLoginService implements ISystemLoginService {
} }
/** /**
* 获取登录平台信息
*
* @return
*/
@Override
public CommonEnumUtil.LOG_LOGIN_PLATFORM getLoginPlatform(HttpServletRequest request) {
String value = CookieTool.getCookieValue(request, CommonConstWords.SESSION_LOGIN_PLATFORM);
if (StringUtils.isBlank(value)) {
value = CommonEnumUtil.LOG_LOGIN_PLATFORM.PC_IMPP_CORE.getValue() + "";
} else {
try {
Integer.parseInt(value);
} catch (Exception e) {
throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode())
.setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_FORMAT.getCode())
.setErrorDetail("平台登录标识转换错误")
.setErrorSolution("请重新操作")
.build();
}
}
CommonEnumUtil.LOG_LOGIN_PLATFORM platform = CommonEnumUtil.LOG_LOGIN_PLATFORM.valueOf(Integer.parseInt(value));
return platform == null ? CommonEnumUtil.LOG_LOGIN_PLATFORM.PC_IMPP_CORE : platform;
}
/**
* 根据用户名密码查询用户 * 根据用户名密码查询用户
*
* @param loginName * @param loginName
* @param pwd * @param pwd
* @return * @return
*/ */
public SysUser getUserLoginInfo(String loginName,String pwd) { public SysUser getUserLoginInfo(String loginName, String pwd) {
SysUser user = sysUserRDao.getByProperty( SysUser user = getValidUserByName(loginName);
new String[]{"userLoginName","isValid"},
new Object[]{loginName,CommonEnumUtil.IS_VAILD.VAILD.getValue()});
if(user == null){ //用户不存在
throw new CredentialsException("用户不存在");
}
if(user.getUserStatus() != CommonEnumUtil.USER_STATUS.ENABLE.getValue()){
throw new LockedAccountException("账号已被锁定");
}
// 登录AD 域检查 // 登录AD 域检查
if(ImppSwitchUtil.isLoginActiveDirectory()){ if (ImppSwitchUtil.isLoginActiveDirectory()) {
userPasswordUtil.checkActiveDirectory(user); userPasswordUtil.checkActiveDirectory(user);
return user; return user;
} }
SysUserPassword password = null; SysUserPassword password = null;
String passwordStr = user.getUserLoginPassword(); String passwordStr = user.getUserLoginPassword();
try { try {
if(Objects.nonNull(user.getUserLoginPasswordId()) && user.getUserLoginPasswordId() > 0){ if (Objects.nonNull(user.getUserLoginPasswordId()) && user.getUserLoginPasswordId() > 0) {
password = passwordService.get(user.getUserLoginPasswordId()); password = passwordService.get(user.getUserLoginPasswordId());
}else{ } else {
if(StringUtils.equals(user.getUserLoginPassword(),SysUserPasswordUtil.encoder(pwd))){ if (StringUtils.equals(user.getUserLoginPassword(), SysUserPasswordUtil.encoder(pwd))) {
SysUserPassword userPassword = new SysUserPassword(user.getId(), SysUserPasswordUtil.encoder(pwd)); SysUserPassword userPassword = new SysUserPassword(user.getId(), SysUserPasswordUtil.encoder(pwd));
ConvertBean.serviceModelInitialize(userPassword,user.getUserName()); ConvertBean.serviceModelInitialize(userPassword, user.getUserName());
password = passwordService.insert(userPassword); password = passwordService.insert(userPassword);
user.setUserLoginPassword(null); user.setUserLoginPassword(null);
@ -173,12 +219,12 @@ public class SystemLoginService implements ISystemLoginService {
sysUserRDao.save(user); sysUserRDao.save(user);
} }
} }
if(Objects.nonNull(password)){ if (Objects.nonNull(password)) {
passwordStr = password.getUserPassword(); passwordStr = password.getUserPassword();
} }
if (StringUtils.equals(passwordStr,SysUserPasswordUtil.encoder(pwd))){ if (StringUtils.equals(passwordStr, SysUserPasswordUtil.encoder(pwd))) {
userPasswordUtil.checkSysUserLogin(user); userPasswordUtil.checkSysUserLogin(user);
return user; return user;
} }
@ -192,14 +238,43 @@ public class SystemLoginService implements ISystemLoginService {
throw new IncorrectCredentialsException("登陆密码错误"); throw new IncorrectCredentialsException("登陆密码错误");
} }
public SysUser getUserLoginInfo(String loginName) {
SysUser user = getValidUserByName(loginName);
// 登录AD 域检查
if (ImppSwitchUtil.isLoginActiveDirectory()) {
userPasswordUtil.checkActiveDirectory(user);
return user;
}
userPasswordUtil.checkSysUserLogin(user);
return user;
}
public SysUser getValidUserByName(String loginName) {
SysUser user = sysUserRDao.getByProperty(
new String[]{"userLoginName", "isValid"},
new Object[]{loginName, CommonEnumUtil.IS_VAILD.VAILD.getValue()});
if (user == null) {
throw new CredentialsException("用户不存在");
}
if (user.getUserStatus() != CommonEnumUtil.USER_STATUS.ENABLE.getValue()) {
throw new LockedAccountException("账号已被锁定");
}
return user;
}
/** /**
* 封装用户登陆信息 * 封装用户登陆信息
*
* @param user * @param user
* @param userType * @param userType
* @param languageCode * @param languageCode
* @return * @return
*/ */
private SessionUser packSessionUser(SysUser user,String userType, String languageCode) { private SessionUser packSessionUser(SysUser user, String userType, String languageCode) {
SessionUser sessionUser = new SessionUser(); SessionUser sessionUser = new SessionUser();
sessionUser.setLanguageCode(languageCode); sessionUser.setLanguageCode(languageCode);
sessionUser.setUserName(user.getUserName()); sessionUser.setUserName(user.getUserName());

87
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/base/login/strategy/DefaultLoginStrategy.java
Unescape Escape View File

@ -0,0 +1,87 @@
package cn.estsh.i3plus.core.apiservice.serviceimpl.base.login.strategy;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginStrategyService;
import cn.estsh.i3plus.core.api.iservice.busi.ILicenseClickService;
import cn.estsh.i3plus.core.api.iservice.busi.ISysUserService;
import cn.estsh.i3plus.platform.common.util.CommonConstWords;
import cn.estsh.i3plus.pojo.base.bean.BaseThreadLocal;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.model.platform.SysLoginModel;
import cn.estsh.i3plus.pojo.platform.bean.SessionUser;
import cn.estsh.impp.framework.boot.auth.AuthUtil;
import cn.estsh.impp.framework.boot.util.ImppRedis;
import cn.estsh.impp.framework.boot.util.RedisCacheTool;
import cn.estsh.impp.framework.boot.util.ResultBean;
import cn.estsh.impp.framework.boot.util.ValidatorBean;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.function.BiFunction;
import static cn.estsh.i3plus.platform.common.util.CommonConstWords.DEFAULT_LANGUAGE;
/**
* @author Wynne.Lu
* @date 2021/1/18 下午4:39
* @desc
*/
@Slf4j
@Service
public class DefaultLoginStrategy implements ISystemLoginStrategyService {
@Resource(name = "redisCore")
protected ImppRedis redisCore;
@Autowired
private ILicenseClickService licenseClickService;
@Autowired
private ISysUserService userService;
@Autowired
private ISystemLoginService loginService;
@Override
public BiFunction<HttpServletRequest, SysLoginModel, ResultBean> login() {
return (request, loginModel) -> {
ResultBean result;
ValidatorBean.checkNotNull(loginModel.getLanguageCode(), "语言不能为空");
// TODO 后期移除，暂时用于避免自动登录后前台没有正确的传输组织代码信息
if ("null".equals(loginModel.getLanguageCode())) {
loginModel.setLanguageCode(DEFAULT_LANGUAGE);
}
// 设置语言代码
BaseThreadLocal.setData(BaseThreadLocal.LANGUAGE_CODE, loginModel.getLanguageCode());
ValidatorBean.checkNotNull(loginModel.getLoginName(), "用户名不能为空");
ValidatorBean.checkNotNull(loginModel.getLoginPwd(), "密码不能为空");
int sessionMode = RedisCacheTool.getSysConfigIntVal(CommonConstWords.CONFIG_SESSION_MODE, CommonConstWords.CONFIG_SESSION_MODE_DEFAULT);
if (sessionMode != CommonEnumUtil.SESSION_MODE.SEIZE.getValue()) {
AuthUtil.logout();
}
SessionUser user = userService.loginUser(
loginModel.getLoginName().trim(),
loginModel.getLoginPwd().trim(),
loginModel.getLanguageCode(),
loginService.getLoginPlatform(request).getValue(),
loginModel.getDeviceId()
);
String redisKey = CommonConstWords.USER_LOGIN_ERROR + "_" + user.getUser().getId();
redisCore.deleteKey(redisKey);
result = new ResultBean(true, AuthUtil.getSession().getId().toString(), AuthUtil.getSessionUser());
result.setUrl("/");
AuthUtil.setOrganize(user.getUser().getOrganize());
return result;
};
}
}

104
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/base/login/strategy/E9LoginStrategy.java
Unescape Escape View File

@ -0,0 +1,104 @@
package cn.estsh.i3plus.core.apiservice.serviceimpl.base.login.strategy;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginService;
import cn.estsh.i3plus.core.api.iservice.base.ISystemLoginStrategyService;
import cn.estsh.i3plus.core.api.iservice.busi.ILicenseClickService;
import cn.estsh.i3plus.core.api.iservice.busi.ISysUserService;
import cn.estsh.i3plus.platform.common.tool.ServletRequestTool;
import cn.estsh.i3plus.platform.common.util.CommonConstWords;
import cn.estsh.i3plus.platform.common.util.PlatformConstWords;
import cn.estsh.i3plus.pojo.base.bean.BaseThreadLocal;
import cn.estsh.i3plus.pojo.base.enumutil.CommonEnumUtil;
import cn.estsh.i3plus.pojo.base.enumutil.ImppEnumUtil;
import cn.estsh.i3plus.pojo.model.platform.SysLoginModel;
import cn.estsh.i3plus.pojo.platform.bean.SessionUser;
import cn.estsh.impp.framework.boot.auth.AuthUtil;
import cn.estsh.impp.framework.boot.util.ImppRedis;
import cn.estsh.impp.framework.boot.util.RedisCacheTool;
import cn.estsh.impp.framework.boot.util.ResultBean;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.function.BiFunction;
import static cn.estsh.i3plus.platform.common.util.CommonConstWords.DEFAULT_LANGUAGE;
/**
* @author Wynne.Lu
* @date 2021/1/18 上午10:53
* @desc
*/
@Lazy
@Slf4j
@Service
public class E9LoginStrategy implements ISystemLoginStrategyService {
@Resource(name = "redisCore")
protected ImppRedis redisCore;
@Autowired
private ILicenseClickService licenseClickService;
@Autowired
private ISysUserService userService;
@Autowired
private ISystemLoginService loginService;
@Override
public BiFunction<HttpServletRequest, SysLoginModel, ResultBean> login() {
return (request, loginModel) -> {
boolean isRequestFromSpecificIp = validateHost(request);
if (!isRequestFromSpecificIp) {
return ResultBean.fail("单点登录请求未从指定授权服务器发送，校验失败。");
}
licenseClickService.checkLicenseNumberLogin();
// TODO 后期移除，暂时用于避免自动登录后前台没有正确的传输组织代码信息
if ("null".equals(loginModel.getLanguageCode())|| StringUtils.isEmpty(loginModel.getLanguageCode())) {
loginModel.setLanguageCode(DEFAULT_LANGUAGE);
}
// 设置语言代码
BaseThreadLocal.setData(BaseThreadLocal.LANGUAGE_CODE, loginModel.getLanguageCode());
BaseThreadLocal.setData(PlatformConstWords.AUTH_LOGIN_STRATEGY, ImppEnumUtil.AUTH_LOGIN_STRATEGY.E9.getCode());
int sessionMode = RedisCacheTool.getSysConfigIntVal(CommonConstWords.CONFIG_SESSION_MODE, CommonConstWords.CONFIG_SESSION_MODE_DEFAULT);
if (sessionMode != CommonEnumUtil.SESSION_MODE.SEIZE.getValue()) {
AuthUtil.logout();
}
SessionUser user = userService.loginUser(
loginModel.getLoginName().trim(),
loginModel.getLoginName().trim(),
loginModel.getLanguageCode(),
loginService.getLoginPlatform(request).getValue(),
loginModel.getDeviceId()
);
String redisKey = CommonConstWords.USER_LOGIN_ERROR + "_" + user.getUser().getId();
redisCore.deleteKey(redisKey);
ResultBean result = new ResultBean(true, AuthUtil.getSession().getId().toString(), AuthUtil.getSessionUser());
result.setUrl("/");
AuthUtil.setOrganize(user.getUser().getOrganize());
return result;
};
}
private boolean validateHost(HttpServletRequest request) {
final String delimiter = ",";
String hostsConfig = RedisCacheTool.getSysConfigStrVal(PlatformConstWords.SSO_REQUEST_HOST);
String[] hosts = hostsConfig.split(delimiter);
String requestHost = ServletRequestTool.getRequestHost(request);
return Arrays.stream(hosts).anyMatch(d -> requestHost.equals(d));
}
}

316
modules/i3plus-core-apiservice/src/main/java/cn/estsh/i3plus/core/apiservice/serviceimpl/busi/SysUserService.java
Unescape Escape View File

@ -65,15 +65,6 @@ public class SysUserService implements ISysUserService {
private SysUserInfoRepository sysUserInfoRDao; private SysUserInfoRepository sysUserInfoRDao;
@Autowired @Autowired
private IUserPermissionDao userPermissionDao;
// @Autowired
// private SysOrganizeRepository organizeRDao;
//
// @Autowired
// private SysRoleRepository sysRoleRDao;
@Autowired
private SysRefUserRoleRepository refUserRoleRDao; private SysRefUserRoleRepository refUserRoleRDao;
@Autowired @Autowired
@ -83,15 +74,6 @@ public class SysUserService implements ISysUserService {
private SysRefUserPositionRepository refUserPositionRDao; private SysRefUserPositionRepository refUserPositionRDao;
@Autowired @Autowired
private SysFileRepository sysFileRDao;
//
// @Autowired
// private SysDepartmentRepository departmentRDao;
//
// @Autowired
// private SysPositionRepository sysPositionRDao;
@Autowired
private ISysUserInfoService sysUserInfoService; private ISysUserInfoService sysUserInfoService;
@Autowired @Autowired
@ -119,42 +101,37 @@ public class SysUserService implements ISysUserService {
private ISysMenuService menuService; private ISysMenuService menuService;
@Autowired @Autowired
private ICoreMemTreeService memTreeService;
@Autowired
private ISysFileService fileService; private ISysFileService fileService;
@Autowired @Autowired
private SysUserPasswordUtil passwordUtil; private SysUserPasswordUtil passwordUtil;
@Autowired ISysUserPasswordService userPasswordService; @Autowired
ISysUserPasswordService userPasswordService;
@Resource(name = CommonConstWords.IMPP_REDIS_RES)
private ImppRedis redisRes;
/** /**
* 缓存 * 缓存
*/ */
@Resource(name= CommonConstWords.IMPP_REDIS_SESSION) @Resource(name = CommonConstWords.IMPP_REDIS_SESSION)
private ImppRedis redisSession; private ImppRedis redisSession;
@Override @Override
@ApiOperation(value = "用户登录", notes = "用户登录功能实现") @ApiOperation(value = "用户登录", notes = "用户登录功能实现")
@Transactional(propagation = Propagation.REQUIRED) @Transactional(propagation = Propagation.REQUIRED)
public SessionUser queryUserLogin(String loginName, String password, String languageCode,Integer loginPlatform,String deviceId) throws AuthenticationException { public SessionUser loginUser(String loginName, String password, String languageCode, Integer loginPlatform, String deviceId) throws AuthenticationException {
LOGGER.debug("平台用户 SYS_USER loginName:{} \t password:{} \t languageCode:{}", loginName, password, languageCode); LOGGER.debug("平台用户 SYS_USER loginName:{} \t password:{} \t languageCode:{}", loginName, password, languageCode);
BaseToken token = getToken(loginName, password, languageCode, loginPlatform); BaseToken token = getToken(loginName, password, languageCode, loginPlatform);
SessionUser sessionUser = AuthUtil.login(token); SessionUser sessionUser = AuthUtil.login(token);
SysUser user = this.getSysUserByLoginName(loginName); SysUser user = this.getSysUserByLoginName(loginName);
if(user == null){ if (user == null) {
throw new CredentialsException("用户不存在"); throw new CredentialsException("用户不存在");
} }
// 判断会话模式 // 判断会话模式
checkSessionMode(loginPlatform,user.getId()); checkSessionMode(loginPlatform, user.getId());
packSessionUser(sessionUser, user, user.getUserType(),loginPlatform, languageCode,deviceId); packSessionUser(sessionUser, user, user.getUserType(), loginPlatform, languageCode, deviceId);
packConfigSessionUser(sessionUser, user); packConfigSessionUser(sessionUser, user);
AuthUtil.setSessionUser(sessionUser); AuthUtil.setSessionUser(sessionUser);
refreshUserLoginInformation(user.getId()); refreshUserLoginInformation(user.getId());
@ -163,12 +140,12 @@ public class SysUserService implements ISysUserService {
return sessionUser; return sessionUser;
} }
private void checkSessionMode(Integer loginPlatform,Long userId){ private void checkSessionMode(Integer loginPlatform, Long userId) {
int sessionMode = RedisCacheTool.getSysConfigIntVal(CommonConstWords.CONFIG_SESSION_MODE,CommonConstWords.CONFIG_SESSION_MODE_DEFAULT); int sessionMode = RedisCacheTool.getSysConfigIntVal(CommonConstWords.CONFIG_SESSION_MODE, CommonConstWords.CONFIG_SESSION_MODE_DEFAULT);
String redisKey; String redisKey;
if (sessionMode == CommonEnumUtil.SESSION_MODE.SEIZE.getValue()) { if (sessionMode == CommonEnumUtil.SESSION_MODE.SEIZE.getValue()) {
redisKey = CommonConstWords.SESSION_USER + ":*_" + userId; redisKey = CommonConstWords.SESSION_USER + ":*_" + userId;
}else { } else {
return; return;
} }
@ -186,15 +163,15 @@ public class SysUserService implements ISysUserService {
@Override @Override
public BaseToken getToken(String loginName, String password, String languageCode, Integer loginPlatform) { public BaseToken getToken(String loginName, String password, String languageCode, Integer loginPlatform) {
SysUser user = this.getSysUserByLoginName(loginName); SysUser user = this.getSysUserByLoginName(loginName);
if(user != null){ if (user != null) {
if(user.getUserType().equals(CommonEnumUtil.USER_TYPE.ADMIN.getValue())){ if (user.getUserType().equals(CommonEnumUtil.USER_TYPE.ADMIN.getValue())) {
return new AdminToken(loginName,password,languageCode,loginPlatform); return new AdminToken(loginName, password, languageCode, loginPlatform);
}else if(user.getUserType().equals(CommonEnumUtil.USER_TYPE.SA.getValue())){ } else if (user.getUserType().equals(CommonEnumUtil.USER_TYPE.SA.getValue())) {
return new SaAdminToken(loginName,password,languageCode,loginPlatform); return new SaAdminToken(loginName, password, languageCode, loginPlatform);
}else { } else {
return new UserToken(loginName,password,languageCode,loginPlatform); return new UserToken(loginName, password, languageCode, loginPlatform);
} }
}else { } else {
throw new CredentialsException("用户不存在"); throw new CredentialsException("用户不存在");
} }
} }
@ -212,7 +189,7 @@ public class SysUserService implements ISysUserService {
@Override @Override
public void doLockSysUserById(Long id) { public void doLockSysUserById(Long id) {
SysUser user = userRDao.getById(id); SysUser user = userRDao.getById(id);
if(Objects.nonNull(user)){ if (Objects.nonNull(user)) {
user.setUserStatus(CommonEnumUtil.USER_STATUS.LOCKING.getValue()); user.setUserStatus(CommonEnumUtil.USER_STATUS.LOCKING.getValue());
userRDao.save(user); userRDao.save(user);
} }
@ -221,15 +198,15 @@ public class SysUserService implements ISysUserService {
@Override @Override
@ApiOperation(value = "修改账号", notes = "批量修改账号状态") @ApiOperation(value = "修改账号", notes = "批量修改账号状态")
public void updateBatchSysUserStatus(Long[] ids, int status, SessionUser user) { public void updateBatchSysUserStatus(Long[] ids, int status, SessionUser user) {
LOGGER.debug("平台用户 SYS_USER DELETE By ids :{} status:{}, SessionUser :{}", ids,status,user); LOGGER.debug("平台用户 SYS_USER DELETE By ids :{} status:{}, SessionUser :{}", ids, status, user);
String where = CoreHqlPack.packHqlIds("id", ids); String where = CoreHqlPack.packHqlIds("id", ids);
List<SysUser> list = userRDao.findByHqlWhere(where); List<SysUser> list = userRDao.findByHqlWhere(where);
if(null != list && list.size() > 0){ if (null != list && list.size() > 0) {
for (SysUser sysUser : list) { for (SysUser sysUser : list) {
sysUser.setUserStatus(status); sysUser.setUserStatus(status);
sysUser.setIsValid(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue()); sysUser.setIsValid(CommonEnumUtil.TRUE_OR_FALSE.TRUE.getValue());
ConvertBean.modelUpdate(sysUser,user); ConvertBean.modelUpdate(sysUser, user);
} }
userRDao.saveAll(list); userRDao.saveAll(list);
} }
@ -245,9 +222,9 @@ public class SysUserService implements ISysUserService {
@Override @Override
@ApiOperation(value = "修改账号", notes = "修改账号登录密码") @ApiOperation(value = "修改账号", notes = "修改账号登录密码")
public void updateSysUserPassword(Long userId, String password, String newPwd) throws Exception { public void updateSysUserPassword(Long userId, String password, String newPwd) throws Exception {
LOGGER.debug("平台用户 SYS_USER Override:{} password:{} newPwd:{}", userId,password,newPwd); LOGGER.debug("平台用户 SYS_USER Override:{} password:{} newPwd:{}", userId, password, newPwd);
SysUser user = userRDao.getById(userId); SysUser user = userRDao.getById(userId);
ValidatorBean.checkNotNull(user,"用户不存在"); ValidatorBean.checkNotNull(user, "用户不存在");
user.setUserLoginPassword(newPwd); user.setUserLoginPassword(newPwd);
passwordUtil.checkPasswordSave(user); passwordUtil.checkPasswordSave(user);
@ -294,7 +271,7 @@ public class SysUserService implements ISysUserService {
@Override @Override
@ApiOperation(value = "新增账号", notes = "新增账号信息") @ApiOperation(value = "新增账号", notes = "新增账号信息")
public SysUser insertSysUser(SysUser sysUser)throws Exception { public SysUser insertSysUser(SysUser sysUser) throws Exception {
LOGGER.debug("平台用户 SYS_USER SysUser:{}", sysUser); LOGGER.debug("平台用户 SYS_USER SysUser:{}", sysUser);
SysUser loginUser = getSysUserByLoginName(sysUser.getUserLoginName()); SysUser loginUser = getSysUserByLoginName(sysUser.getUserLoginName());
@ -314,7 +291,7 @@ public class SysUserService implements ISysUserService {
} }
@Override @Override
@ApiOperation(value = "新增登录日志",notes = "新增登录日志信息") @ApiOperation(value = "新增登录日志", notes = "新增登录日志信息")
public SysLogUserLogin insertSysLogUserLogin(SysLogUserLogin sysLogUserLogin) { public SysLogUserLogin insertSysLogUserLogin(SysLogUserLogin sysLogUserLogin) {
LOGGER.debug("平台用户登录记录 SysLogUserLogin sysLogUserLogin:{}", sysLogUserLogin); LOGGER.debug("平台用户登录记录 SysLogUserLogin sysLogUserLogin:{}", sysLogUserLogin);
return logUserLoginRDao.insert(sysLogUserLogin); return logUserLoginRDao.insert(sysLogUserLogin);
@ -332,7 +309,7 @@ public class SysUserService implements ISysUserService {
// 删除角色关系信息 // 删除角色关系信息
refUserRoleRDao.deleteByProperty("userId", sysUser.getId()); // 删除用户角色关系 refUserRoleRDao.deleteByProperty("userId", sysUser.getId()); // 删除用户角色关系
if(null != list && list.size() > 0){ if (null != list && list.size() > 0) {
// 新增用户角色关系 // 新增用户角色关系
List<SysRefUserRole> refUserRoles = new ArrayList<>(); List<SysRefUserRole> refUserRoles = new ArrayList<>();
List<String> roleNameList = new ArrayList<>(); List<String> roleNameList = new ArrayList<>();
@ -380,19 +357,19 @@ public class SysUserService implements ISysUserService {
@Override @Override
@ApiOperation(value = "删除账号", notes = "批量删除账号信息，逻辑删除，账号关系业务物理删除") @ApiOperation(value = "删除账号", notes = "批量删除账号信息，逻辑删除，账号关系业务物理删除")
public void deleteBatchSysUserById(Long[] ids,SessionUser user) { public void deleteBatchSysUserById(Long[] ids, SessionUser user) {
LOGGER.debug("平台用户 SYS_USER DELETE By ids :{}", ids); LOGGER.debug("平台用户 SYS_USER DELETE By ids :{}", ids);
// 标记用户已删除 // 标记用户已删除
String where = CoreHqlPack.packHqlIds("id", ids); String where = CoreHqlPack.packHqlIds("id", ids);
List<SysUser> list = userRDao.findByHqlWhere(where); List<SysUser> list = userRDao.findByHqlWhere(where);
if(null != list && list.size() > 0){ if (null != list && list.size() > 0) {
for (SysUser sysUser : list) { for (SysUser sysUser : list) {
sysUser.setIsValid(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue()); sysUser.setIsValid(CommonEnumUtil.TRUE_OR_FALSE.FALSE.getValue());
} }
userRDao.saveAll(list); userRDao.saveAll(list);
refUserRoleRDao.deleteByPropertyIn("userId",ids); refUserRoleRDao.deleteByPropertyIn("userId", ids);
} }
} }
@ -401,7 +378,7 @@ public class SysUserService implements ISysUserService {
public List<SysUser> list() { public List<SysUser> list() {
LOGGER.debug("平台用户 SYS_USER find All"); LOGGER.debug("平台用户 SYS_USER find All");
return userRDao.findByProperty( return userRDao.findByProperty(
new String[]{"isDeleted","isValid"}, new String[]{"isDeleted", "isValid"},
new Object[]{ new Object[]{
CommonEnumUtil.IS_DEAL.NO.getValue(), CommonEnumUtil.IS_DEAL.NO.getValue(),
CommonEnumUtil.IS_VAILD.VAILD.getValue() CommonEnumUtil.IS_VAILD.VAILD.getValue()
@ -417,7 +394,7 @@ public class SysUserService implements ISysUserService {
public List<SysUser> listByUserOrganizeCode() { public List<SysUser> listByUserOrganizeCode() {
LOGGER.debug("平台用户 SYS_USER listByUserOrganizeCode"); LOGGER.debug("平台用户 SYS_USER listByUserOrganizeCode");
return userRDao.findByProperty( return userRDao.findByProperty(
new String[]{"isDeleted","isValid","organizeCode"}, new String[]{"isDeleted", "isValid", "organizeCode"},
new Object[]{ new Object[]{
CommonEnumUtil.IS_DEAL.NO.getValue(), CommonEnumUtil.IS_DEAL.NO.getValue(),
CommonEnumUtil.IS_VAILD.VAILD.getValue(), CommonEnumUtil.IS_VAILD.VAILD.getValue(),
@ -426,14 +403,14 @@ public class SysUserService implements ISysUserService {
} }
@Override @Override
@ApiOperation(value = "查询用户ID 集合",notes = "根据角色Id 查询用户ID集合") @ApiOperation(value = "查询用户ID 集合", notes = "根据角色Id 查询用户ID集合")
public List<Long> findSysUserIdListByRoleId(Long roleId) { public List<Long> findSysUserIdListByRoleId(Long roleId) {
List<Long> result = new ArrayList<>(); List<Long> result = new ArrayList<>();
if(roleId != null){ if (roleId != null) {
List<SysRefUserRole> list = refUserRoleRDao.findByProperty( List<SysRefUserRole> list = refUserRoleRDao.findByProperty(
new String[]{"roleId","isValid"}, new String[]{"roleId", "isValid"},
new Object[]{roleId,CommonEnumUtil.IS_VAILD.VAILD.getValue()}); new Object[]{roleId, CommonEnumUtil.IS_VAILD.VAILD.getValue()});
if(list != null && list.size() > 0){ if (list != null && list.size() > 0) {
for (SysRefUserRole ref : list) { for (SysRefUserRole ref : list) {
result.add(ref.getUserId()); result.add(ref.getUserId());
} }
@ -443,14 +420,14 @@ public class SysUserService implements ISysUserService {
} }
@Override @Override
@ApiOperation(value = "查询用户ID 集合",notes = "根据部门Id 查询用户ID集合") @ApiOperation(value = "查询用户ID 集合", notes = "根据部门Id 查询用户ID集合")
public List<Long> findSysUserIdListByDepartmentId(List<Long> idList) { public List<Long> findSysUserIdListByDepartmentId(List<Long> idList) {
List<Long> result = new ArrayList<>(); List<Long> result = new ArrayList<>();
if(idList != null && idList.size() > 0){ if (idList != null && idList.size() > 0) {
StringBuffer hqlWhere = new StringBuffer(); StringBuffer hqlWhere = new StringBuffer();
HqlPack.getInPack(StringUtils.join(idList, ","), "departmentId", hqlWhere); HqlPack.getInPack(StringUtils.join(idList, ","), "departmentId", hqlWhere);
List<SysRefUserDepartment> list = refUserDepartmentRDao.findByHqlWhere(hqlWhere.toString()); List<SysRefUserDepartment> list = refUserDepartmentRDao.findByHqlWhere(hqlWhere.toString());
if(list != null && list.size() > 0){ if (list != null && list.size() > 0) {
for (SysRefUserDepartment ref : list) { for (SysRefUserDepartment ref : list) {
result.add(ref.getUserId()); result.add(ref.getUserId());
} }
@ -465,20 +442,20 @@ public class SysUserService implements ISysUserService {
LOGGER.debug("系统用户 SysUser find user :{} page :{}", user, pager); LOGGER.debug("系统用户 SysUser find user :{} page :{}", user, pager);
// 角色查询 // 角色查询
if(user.getRoleId() != null){ if (user.getRoleId() != null) {
List<Long> ids = findSysUserIdListByRoleId(user.getRoleId()); List<Long> ids = findSysUserIdListByRoleId(user.getRoleId());
user.setRoleIdList(StringTool.getListString(ids)); user.setRoleIdList(StringTool.getListString(ids));
} }
List<Long> departmentIdList = new ArrayList<>(); List<Long> departmentIdList = new ArrayList<>();
if(user.getOrganizeId() != null){ if (user.getOrganizeId() != null) {
// 查出所有组织 ID 集合 // 查出所有组织 ID 集合
SysOrganize parent = coreTreeService.getSysOrganizeTreeById(user.getOrganizeId()); SysOrganize parent = coreTreeService.getSysOrganizeTreeById(user.getOrganizeId());
List<Long> childIds = coreTreeService.findSysOrganizeChildIds(parent); List<Long> childIds = coreTreeService.findSysOrganizeChildIds(parent);
// 查询所有部门 ID 集合 // 查询所有部门 ID 集合
if(childIds != null && childIds.size() > 0){ if (childIds != null && childIds.size() > 0) {
for (Long organizeId : childIds) { for (Long organizeId : childIds) {
List<Long> ids = coreTreeService.findSysDepartmentIdByOrganizeId(organizeId); List<Long> ids = coreTreeService.findSysDepartmentIdByOrganizeId(organizeId);
departmentIdList.addAll(ids); departmentIdList.addAll(ids);
@ -487,7 +464,7 @@ public class SysUserService implements ISysUserService {
} }
// 封装部门 ID 信息 // 封装部门 ID 信息
if(user.getDepartmentId() != null){ if (user.getDepartmentId() != null) {
SysDepartment department = departmentService.get(user.getDepartmentId()); SysDepartment department = departmentService.get(user.getDepartmentId());
departmentIdList.addAll(coreTreeService.findSysDepartmentChildIds(department)); departmentIdList.addAll(coreTreeService.findSysDepartmentChildIds(department));
} }
@ -518,7 +495,7 @@ public class SysUserService implements ISysUserService {
@Override @Override
@ApiOperation(value = "用户查询", notes = "根据ID 查询用户信息") @ApiOperation(value = "用户查询", notes = "根据ID 查询用户信息")
public SysUserInfo getSysUserInfoById(Long id) { public SysUserInfo getSysUserInfoById(Long id) {
return sysUserInfoRDao.getByProperty("id",id); return sysUserInfoRDao.getByProperty("id", id);
} }
@Override @Override
@ -547,63 +524,63 @@ public class SysUserService implements ISysUserService {
@Override @Override
@ApiOperation(value = "账号角色", notes = "根据账号ID查询账号角色关系") @ApiOperation(value = "账号角色", notes = "根据账号ID查询账号角色关系")
public List<SysRefUserRole> findSysRefUserRoleByUserId(Long userId) { public List<SysRefUserRole> findSysRefUserRoleByUserId(Long userId) {
return refUserRoleRDao.findByProperty("userId",userId); return refUserRoleRDao.findByProperty("userId", userId);
} }
@Override @Override
@ApiOperation(value = "检查-账号登录名", notes = "判断账号是否存在") @ApiOperation(value = "检查-账号登录名", notes = "判断账号是否存在")
public boolean checkSysUserLoginName(String userLoginName, long id) { public boolean checkSysUserLoginName(String userLoginName, long id) {
int count = 0; int count = 0;
if(id > 0){ if (id > 0) {
StringBuffer sw = new StringBuffer(); StringBuffer sw = new StringBuffer();
HqlPack.getStringEqualPack(userLoginName,"userLoginName",sw); HqlPack.getStringEqualPack(userLoginName, "userLoginName", sw);
HqlPack.getNumNOEqualPack(id,"id",sw); HqlPack.getNumNOEqualPack(id, "id", sw);
count = userRDao.findByHqlWhereCount(sw.toString()); count = userRDao.findByHqlWhereCount(sw.toString());
}else{ } else {
count = userRDao.findByPropertyCount("userLoginName",userLoginName); count = userRDao.findByPropertyCount("userLoginName", userLoginName);
} }
return count <= 0 ; return count <= 0;
} }
@Override @Override
@ApiOperation(value = "检查-账号邮箱", notes = "判断邮箱是否存在") @ApiOperation(value = "检查-账号邮箱", notes = "判断邮箱是否存在")
public boolean checkSysUserEmail(String email, long id) { public boolean checkSysUserEmail(String email, long id) {
int count; int count;
if(id > 0){ if (id > 0) {
StringBuffer sw = new StringBuffer(); StringBuffer sw = new StringBuffer();
HqlPack.getStringEqualPack(email,"userEmail",sw); HqlPack.getStringEqualPack(email, "userEmail", sw);
HqlPack.getNumNOEqualPack(id,"id",sw); HqlPack.getNumNOEqualPack(id, "id", sw);
count = userRDao.findByHqlWhereCount(sw.toString()); count = userRDao.findByHqlWhereCount(sw.toString());
}else{ } else {
count = userRDao.findByPropertyCount("userEmail",email); count = userRDao.findByPropertyCount("userEmail", email);
} }
return count <= 0 ; return count <= 0;
} }
@Override @Override
@ApiOperation(value = "检查-账号手机", notes = "判断手机是否存在") @ApiOperation(value = "检查-账号手机", notes = "判断手机是否存在")
public boolean checkSysUserPhone(String phone, long id) { public boolean checkSysUserPhone(String phone, long id) {
int count; int count;
if(id > 0){ if (id > 0) {
StringBuffer sw = new StringBuffer(); StringBuffer sw = new StringBuffer();
HqlPack.getStringEqualPack(phone,"userPhone",sw); HqlPack.getStringEqualPack(phone, "userPhone", sw);
HqlPack.getNumNOEqualPack(id,"id",sw); HqlPack.getNumNOEqualPack(id, "id", sw);
count = userRDao.findByHqlWhereCount(sw.toString()); count = userRDao.findByHqlWhereCount(sw.toString());
}else{ } else {
count = userRDao.findByPropertyCount("userPhone",phone); count = userRDao.findByPropertyCount("userPhone", phone);
} }
return count <= 0 ; return count <= 0;
} }
@Override @Override
@ApiOperation(value = "检查-账号唯一", notes = "账号唯一性校验") @ApiOperation(value = "检查-账号唯一", notes = "账号唯一性校验")
public void checkSysUserOnly(SysUser user) { public void checkSysUserOnly(SysUser user) {
if(user != null){ if (user != null) {
// 登录名唯一教研 // 登录名唯一教研
if(!checkSysUserLoginName(user.getUserLoginName(), user.getId() == null ? 0 : user.getId())){ if (!checkSysUserLoginName(user.getUserLoginName(), user.getId() == null ? 0 : user.getId())) {
throw ImppExceptionBuilder.newInstance() throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode()) .setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode())
.setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_EXIT.getCode()) .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_EXIT.getCode())
@ -613,7 +590,7 @@ public class SysUserService implements ISysUserService {
} }
// 登录名唯一教研 // 登录名唯一教研
if(!checkSysUserEmail(user.getUserEmail(),user.getId() == null ? 0 : user.getId())){ if (!checkSysUserEmail(user.getUserEmail(), user.getId() == null ? 0 : user.getId())) {
throw ImppExceptionBuilder.newInstance() throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode()) .setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode())
.setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_EXIT.getCode()) .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_EXIT.getCode())
@ -623,7 +600,7 @@ public class SysUserService implements ISysUserService {
} }
// 登录名唯一教研 // 登录名唯一教研
if(!checkSysUserPhone(user.getUserPhone(),user.getId() == null ? 0 : user.getId())){ if (!checkSysUserPhone(user.getUserPhone(), user.getId() == null ? 0 : user.getId())) {
throw ImppExceptionBuilder.newInstance() throw ImppExceptionBuilder.newInstance()
.setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode()) .setSystemID(CommonEnumUtil.SOFT_TYPE.CORE.getCode())
.setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_EXIT.getCode()) .setErrorCode(ImppExceptionEnum.VARIFY_EXCEPTION_DATA_EXIT.getCode())
@ -650,12 +627,12 @@ public class SysUserService implements ISysUserService {
* @return * @return
*/ */
@Override @Override
@ApiOperation(value = "封装用户信息",notes = "封装登录完成后的用户信息(角色、权限、部门、组织、岗位)") @ApiOperation(value = "封装用户信息", notes = "封装登录完成后的用户信息(角色、权限、部门、组织、岗位)")
public SessionUser packSessionUser(SessionUser sessionUser, SysUser user,Integer userType,Integer loginPlatform, String languageCode, String deviceId) { public SessionUser packSessionUser(SessionUser sessionUser, SysUser user, Integer userType, Integer loginPlatform, String languageCode, String deviceId) {
LOGGER.debug("平台用户 SYS_USER user id :{}", user.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", user.getId());
SysUserInfo userInfo = sysUserInfoRDao.getById(user.getUserInfoId()); SysUserInfo userInfo = sysUserInfoRDao.getById(user.getUserInfoId());
if(userInfo == null){ if (userInfo == null) {
throw new UnknownAccountException("用户信息不存在"); throw new UnknownAccountException("用户信息不存在");
} }
@ -692,27 +669,27 @@ public class SysUserService implements ISysUserService {
public SessionUser packPageSessionUser(SessionUser sessionUser, SysUser user) { public SessionUser packPageSessionUser(SessionUser sessionUser, SysUser user) {
SysConfig configPageList = RedisCacheTool.getSysConfigByConfigCode(CommonConstWords.CONFIG_PAGE_SIZE_LIST); SysConfig configPageList = RedisCacheTool.getSysConfigByConfigCode(CommonConstWords.CONFIG_PAGE_SIZE_LIST);
try { try {
if(configPageList != null && StringUtils.isNotBlank(configPageList.getConfigValue())){ if (configPageList != null && StringUtils.isNotBlank(configPageList.getConfigValue())) {
String[] split = configPageList.getConfigValue().split(","); String[] split = configPageList.getConfigValue().split(",");
int[] ints = Arrays.stream(split).mapToInt(Integer::parseInt).toArray(); int[] ints = Arrays.stream(split).mapToInt(Integer::parseInt).toArray();
sessionUser.setPageSizeArray(Arrays.stream(ints).boxed().toArray(Integer[]::new)); sessionUser.setPageSizeArray(Arrays.stream(ints).boxed().toArray(Integer[]::new));
} }
}catch (Exception e){ } catch (Exception e) {
} }
if(sessionUser.getPageSizeArray() == null){ if (sessionUser.getPageSizeArray() == null) {
sessionUser.setPageSizeArray(CommonConstWords.CONFIG_PAGE_SIZE_LIST_DEFAULT); sessionUser.setPageSizeArray(CommonConstWords.CONFIG_PAGE_SIZE_LIST_DEFAULT);
} }
SysConfig configPageSize = RedisCacheTool.getSysConfigByConfigCode(CommonConstWords.CONFIG_PAGE_DEFAULT_SIZE); SysConfig configPageSize = RedisCacheTool.getSysConfigByConfigCode(CommonConstWords.CONFIG_PAGE_DEFAULT_SIZE);
try { try {
if(configPageSize != null && StringUtils.isNotBlank(configPageSize.getConfigValue())){ if (configPageSize != null && StringUtils.isNotBlank(configPageSize.getConfigValue())) {
sessionUser.setPageDefaultSize(Integer.parseInt(configPageSize.getConfigValue())); sessionUser.setPageDefaultSize(Integer.parseInt(configPageSize.getConfigValue()));
} }
}catch (Exception ignored){ } catch (Exception ignored) {
} }
if(sessionUser.getPageDefaultSize() == null || sessionUser.getPageDefaultSize() <= 0){ if (sessionUser.getPageDefaultSize() == null || sessionUser.getPageDefaultSize() <= 0) {
sessionUser.setPageDefaultSize(CommonConstWords.CONFIG_PAGE_DEFAULT); sessionUser.setPageDefaultSize(CommonConstWords.CONFIG_PAGE_DEFAULT);
} }
@ -737,50 +714,52 @@ public class SysUserService implements ISysUserService {
/** /**
* 账号数据排序 * 账号数据排序
* 创建时间 角色升序 * 创建时间 角色升序
* 序号倒叙 + 编号升序 菜单 * 序号倒叙 + 编号升序 菜单
* 创建时间 组织升序 * 创建时间 组织升序
* 创建时间 部门升序 * 创建时间 部门升序
*
* @param user * @param user
*/ */
public void packSysUserSort(SysUser user){ public void packSysUserSort(SysUser user) {
if(user != null){ if (user != null) {
// 创建时间升序 // 创建时间升序
if(user.getRoleList() != null){ if (user.getRoleList() != null) {
user.getRoleList().sort(Comparator.comparing(SysRole::getCreateDatetime)); user.getRoleList().sort(Comparator.comparing(SysRole::getCreateDatetime));
} }
if(user.getMenuList() != null){ if (user.getMenuList() != null) {
user.getMenuList().sort(Comparator.comparing(SysMenu::getMenuSort).reversed() // 倒序 user.getMenuList().sort(Comparator.comparing(SysMenu::getMenuSort).reversed() // 倒序
.thenComparing(SysMenu::getMenuCode)); //升序 .thenComparing(SysMenu::getMenuCode)); //升序
} }
if(user.getOrganizeList() != null){ if (user.getOrganizeList() != null) {
user.getOrganizeList().sort(Comparator.comparing(SysOrganize::getCreateDatetime)); user.getOrganizeList().sort(Comparator.comparing(SysOrganize::getCreateDatetime));
} }
if(user.getDepartmentList() != null){ if (user.getDepartmentList() != null) {
user.getDepartmentList().sort(Comparator.comparing(SysDepartment::getCreateDatetime)); user.getDepartmentList().sort(Comparator.comparing(SysDepartment::getCreateDatetime));
} }
} }
} }
/** /**
* 用户数据排序 * 用户数据排序
* 岗位创建时间 升序 * 岗位创建时间 升序
* 部门创建时间 升序 * 部门创建时间 升序
* 组织创建时间 升序 * 组织创建时间 升序
*
* @param info * @param info
*/ */
public void packSysUserInfoSort(SysUserInfo info){ public void packSysUserInfoSort(SysUserInfo info) {
if(info != null){ if (info != null) {
if(info.getPositionList() != null){ if (info.getPositionList() != null) {
info.getPositionList().sort(Comparator.comparing(SysPosition::getCreateDatetime)); info.getPositionList().sort(Comparator.comparing(SysPosition::getCreateDatetime));
} }
if(info.getDepartmentList() != null){ if (info.getDepartmentList() != null) {
info.getDepartmentList().sort(Comparator.comparing(SysDepartment::getCreateDatetime)); info.getDepartmentList().sort(Comparator.comparing(SysDepartment::getCreateDatetime));
} }
if(info.getOrganizeList() != null){ if (info.getOrganizeList() != null) {
info.getOrganizeList().sort(Comparator.comparing(SysOrganize::getCreateDatetime)); info.getOrganizeList().sort(Comparator.comparing(SysOrganize::getCreateDatetime));
} }
} }
@ -788,15 +767,16 @@ public class SysUserService implements ISysUserService {
/** /**
* 封装用户角色信息 * 封装用户角色信息
*
* @param user * @param user
* @return * @return
*/ */
public void packSysUserRole(SysUser user){ public void packSysUserRole(SysUser user) {
SysRefUserRole refUserRole = new SysRefUserRole(); SysRefUserRole refUserRole = new SysRefUserRole();
refUserRole.setUserId(user.getId()); refUserRole.setUserId(user.getId());
List<SysRefUserRole> refUserRoleList = refUserRoleRDao.findByHqlWhere(CoreHqlPack.packDdlBeanSysRefUserRole(refUserRole)); List<SysRefUserRole> refUserRoleList = refUserRoleRDao.findByHqlWhere(CoreHqlPack.packDdlBeanSysRefUserRole(refUserRole));
if(Objects.nonNull(refUserRoleList)){ if (Objects.nonNull(refUserRoleList)) {
List<Long> idList = new ArrayList<>(); List<Long> idList = new ArrayList<>();
refUserRoleList.forEach(ref -> idList.add(ref.getRoleId())); refUserRoleList.forEach(ref -> idList.add(ref.getRoleId()));
user.setRoleList(roleService.findByIdList(idList)); user.setRoleList(roleService.findByIdList(idList));
@ -805,14 +785,15 @@ public class SysUserService implements ISysUserService {
/** /**
* 封装用户 菜单信息 * 封装用户 菜单信息
*
* @param user * @param user
* @return * @return
*/ */
public void packSysUserMenu(SysUser user){ public void packSysUserMenu(SysUser user) {
List<SysMenu> list = new ArrayList<>(); List<SysMenu> list = new ArrayList<>();
try { try {
LOGGER.info("平台用户 SYS_USER user id :{}", user.getUserInfoId()); LOGGER.info("平台用户 SYS_USER user id :{}", user.getUserInfoId());
if(user.getRoleList() != null && user.getRoleList().size() > 0){ if (user.getRoleList() != null && user.getRoleList().size() > 0) {
List<Long> ids = new ArrayList<>(); List<Long> ids = new ArrayList<>();
Set<Long> menuIdList = new HashSet<>(); Set<Long> menuIdList = new HashSet<>();
user.getRoleList().forEach(role -> { user.getRoleList().forEach(role -> {
@ -826,17 +807,17 @@ public class SysUserService implements ISysUserService {
} }
}); });
List<SysMenu> menuList = menuService.findByIdList(new ArrayList<>(menuIdList)); List<SysMenu> menuList = menuService.findByIdList(new ArrayList<>(menuIdList));
if(CollectionUtils.isNotEmpty(menuList)){ if (CollectionUtils.isNotEmpty(menuList)) {
for (SysMenu menu : menuList) { for (SysMenu menu : menuList) {
if(CommonConstWords.SYSTEM_MENU_ROOT_ID.equals(menu.getParentId())){ if (CommonConstWords.SYSTEM_MENU_ROOT_ID.equals(menu.getParentId())) {
menu.getChildList().clear(); menu.getChildList().clear();
list.add(menu); list.add(menu);
} }
} }
} }
} }
}catch (Exception e){ } catch (Exception e) {
LOGGER.error(" SysUser Peck Menu information Error userId : {} Exception Message : {} " ,user.getUserInfoId(),e.getMessage()); LOGGER.error(" SysUser Peck Menu information Error userId : {} Exception Message : {} ", user.getUserInfoId(), e.getMessage());
e.printStackTrace(); e.printStackTrace();
} }
@ -872,141 +853,150 @@ public class SysUserService implements ISysUserService {
/** /**
* 封装用户 部门信息封装 * 封装用户 部门信息封装
*
* @param userInfo * @param userInfo
* @return * @return
*/ */
public void packSysUserInfoDepartment(SysUserInfo userInfo){ public void packSysUserInfoDepartment(SysUserInfo userInfo) {
try { try {
LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId());
personnelService.findSysRefUserInfoDepartmentById(userInfo.id); personnelService.findSysRefUserInfoDepartmentById(userInfo.id);
userInfo.setDepartment(departmentService.get(userInfo.getDepartmentId())); userInfo.setDepartment(departmentService.get(userInfo.getDepartmentId()));
userInfo.setDepartmentList(personnelService.findSysUserInfoDepartmentByInfoId(userInfo.getId())); userInfo.setDepartmentList(personnelService.findSysUserInfoDepartmentByInfoId(userInfo.getId()));
}catch (Exception e){ } catch (Exception e) {
LOGGER.error(" SysUser Peck Department information Error userId : {} Exception Message : {} " ,userInfo.getId(),e.getMessage()); LOGGER.error(" SysUser Peck Department information Error userId : {} Exception Message : {} ", userInfo.getId(), e.getMessage());
e.printStackTrace(); e.printStackTrace();
} }
} }
/** /**
* 封装用户 部门信息封装 * 封装用户 部门信息封装
*
* @param user * @param user
* @return * @return
*/ */
public void packSysUserDepartment(SysUser user){ public void packSysUserDepartment(SysUser user) {
try { try {
LOGGER.debug("平台用户 SYS_USER user id :{}", user.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", user.getId());
user.setDepartment(departmentService.get(user.getDepartmentId())); user.setDepartment(departmentService.get(user.getDepartmentId()));
user.setDepartmentList(personnelService.findSysUserDepartmentByInfoId(user.id)); user.setDepartmentList(personnelService.findSysUserDepartmentByInfoId(user.id));
}catch (Exception e){ } catch (Exception e) {
LOGGER.error(" SysUser Peck Department information Error userId : {} Exception Message : {} " ,user.getId(),e.getMessage()); LOGGER.error(" SysUser Peck Department information Error userId : {} Exception Message : {} ", user.getId(), e.getMessage());
e.printStackTrace(); e.printStackTrace();
} }
} }
/** /**
* 封装用户 岗位信息封装 * 封装用户 岗位信息封装
*
* @param userInfo * @param userInfo
* @return * @return
*/ */
public void packSysUserInfoPosition(SysUserInfo userInfo){ public void packSysUserInfoPosition(SysUserInfo userInfo) {
try { try {
LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId());
SysRefUserPosition refUserPosition = new SysRefUserPosition(); SysRefUserPosition refUserPosition = new SysRefUserPosition();
refUserPosition.setUserId(userInfo.getId()); refUserPosition.setUserId(userInfo.getId());
List<SysRefUserPosition> refUserPositionList = refUserPositionRDao.findByHqlWhere(CoreHqlPack.packHqlSysRefUserPosition(refUserPosition)); List<SysRefUserPosition> refUserPositionList = refUserPositionRDao.findByHqlWhere(CoreHqlPack.packHqlSysRefUserPosition(refUserPosition));
if(CollectionUtils.isNotEmpty(refUserPositionList)){ if (CollectionUtils.isNotEmpty(refUserPositionList)) {
List<Long> idList = new ArrayList<>(); List<Long> idList = new ArrayList<>();
refUserPositionList.forEach(ref -> idList.add(ref.getPositionId())); refUserPositionList.forEach(ref -> idList.add(ref.getPositionId()));
userInfo.setPositionList(positionService.findByIdList(idList)); userInfo.setPositionList(positionService.findByIdList(idList));
} }
userInfo.setPosition(positionService.get(userInfo.getPositionId())); userInfo.setPosition(positionService.get(userInfo.getPositionId()));
}catch (Exception e){ } catch (Exception e) {
LOGGER.error(" SysUser Peck Position information Error userId : {} Exception Message : {} " ,userInfo.getId(),e.getMessage()); LOGGER.error(" SysUser Peck Position information Error userId : {} Exception Message : {} ", userInfo.getId(), e.getMessage());
} }
} }
/** /**
* 封装用户 组织信息封装 * 封装用户 组织信息封装
*
* @param userInfo * @param userInfo
* @return * @return
*/ */
public void packSysUserInfoOrganize(SysUserInfo userInfo){ public void packSysUserInfoOrganize(SysUserInfo userInfo) {
try { try {
LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId());
userInfo.setOrganize(organizeService.get(userInfo.getOrganizeId())); userInfo.setOrganize(organizeService.get(userInfo.getOrganizeId()));
userInfo.setOrganizeList(personnelService.findSysUserInfoOrganize(userInfo.getId()));; userInfo.setOrganizeList(personnelService.findSysUserInfoOrganize(userInfo.getId()));
}catch (Exception e){ ;
LOGGER.error(" SysUser Peck Organize information Error userId : {} Exception Message : {} " ,userInfo.getId(),e.getMessage()); } catch (Exception e) {
LOGGER.error(" SysUser Peck Organize information Error userId : {} Exception Message : {} ", userInfo.getId(), e.getMessage());
} }
} }
/** /**
* 封装用户 组织信息封装 * 封装用户 组织信息封装
*
* @param userInfo * @param userInfo
* @return * @return
*/ */
public void packSysUserInfoImage(SysUserInfo userInfo){ public void packSysUserInfoImage(SysUserInfo userInfo) {
try { try {
LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", userInfo.getId());
if(Objects.nonNull(userInfo.getUserImageId())){ if (Objects.nonNull(userInfo.getUserImageId())) {
SysFile file = fileService.getSysFileById(userInfo.getUserImageId()); SysFile file = fileService.getSysFileById(userInfo.getUserImageId());
if(Objects.nonNull(file)){ if (Objects.nonNull(file)) {
userInfo.setImageFileUrl(file.getFilePath()); userInfo.setImageFileUrl(file.getFilePath());
} }
} }
}catch (Exception e){ } catch (Exception e) {
LOGGER.error(" SysUser Peck Organize information Error userId : {} Exception Message : {} " ,userInfo.getId(),e.getMessage()); LOGGER.error(" SysUser Peck Organize information Error userId : {} Exception Message : {} ", userInfo.getId(), e.getMessage());
} }
} }
/** /**
* 封装用户 组织信息封装 * 封装用户 组织信息封装
*
* @param user * @param user
* @return * @return
*/ */
public void packSysUserOrganize(SysUser user){ public void packSysUserOrganize(SysUser user) {
try { try {
LOGGER.debug("平台用户 SYS_USER user id :{}", user.getId()); LOGGER.debug("平台用户 SYS_USER user id :{}", user.getId());
user.setOrganize(organizeService.get(user.getOrganizeId())); user.setOrganize(organizeService.get(user.getOrganizeId()));
user.setOrganizeList(personnelService.findSysUserOrganize(user.getId()));; user.setOrganizeList(personnelService.findSysUserOrganize(user.getId()));
}catch (Exception e){ ;
LOGGER.error(" SysUser Peck Organize information Error userId : {} Exception Message : {} " ,user.getId(),e.getMessage()); } catch (Exception e) {
LOGGER.error(" SysUser Peck Organize information Error userId : {} Exception Message : {} ", user.getId(), e.getMessage());
} }
} }
/** /**
* 获取集合中的Root Id * 获取集合中的Root Id
*
* @param menus * @param menus
* @return * @return
*/ */
private List<SysMenu> getSysMenuRootIds(List<SysMenu> menus){ private List<SysMenu> getSysMenuRootIds(List<SysMenu> menus) {
Map<Long,SysMenu> map = new HashMap<>(); Map<Long, SysMenu> map = new HashMap<>();
List<SysMenu> result = new ArrayList<>(); List<SysMenu> result = new ArrayList<>();
SysMenu parentMenu = null; SysMenu parentMenu = null;
// 获取所有顶级节点 ParentId 不存在的对象 // 获取所有顶级节点 ParentId 不存在的对象
for (SysMenu menu : menus) { for (SysMenu menu : menus) {
parentMenu = map.get(menu.getParentId()); parentMenu = map.get(menu.getParentId());
if(parentMenu == null){ if (parentMenu == null) {
for (SysMenu sysMenu : menus) { for (SysMenu sysMenu : menus) {
if(sysMenu.getId().longValue() == menu.getParentId().longValue()){ if (sysMenu.getId().longValue() == menu.getParentId().longValue()) {
parentMenu = sysMenu; parentMenu = sysMenu;
} }
} }
} }
map.put(menu.getParentId(),parentMenu); map.put(menu.getParentId(), parentMenu);
} }
// 封装返回对象 // 封装返回对象
for (Long parentId : map.keySet()) { for (Long parentId : map.keySet()) {
if(map.get(parentId) == null){ if (map.get(parentId) == null) {
for (SysMenu sysMenu : menus) { for (SysMenu sysMenu : menus) {
if(sysMenu.getParentId().longValue() == parentId.longValue()){ if (sysMenu.getParentId().longValue() == parentId.longValue()) {
result.add(sysMenu); result.add(sysMenu);
} }
} }

2
modules/i3plus-core-apiservice/src/main/resources/application-dev.properties
Unescape Escape View File

@ -25,6 +25,8 @@ impp.config.fileserver=fastdfs
impp.log.detail.controller=true impp.log.detail.controller=true
#\u662F\u5426\u5BF9\u8C03\u7528\u670D\u52A1\u8FDB\u884C\u8BE6\u7EC6\u65E5\u5FD7\u5206\u6790 #\u662F\u5426\u5BF9\u8C03\u7528\u670D\u52A1\u8FDB\u884C\u8BE6\u7EC6\u65E5\u5FD7\u5206\u6790
impp.log.detail.service=true impp.log.detail.service=true
# elasticsearch\u641C\u7D22\u670D\u52A1
impp.config.elasticsearch=true
#\u662F\u5426\u5F00\u542F\u5FAE\u670D #\u662F\u5426\u5F00\u542F\u5FAE\u670D
eureka.client.enabled=true eureka.client.enabled=true
#\u6253\u5F00feign\u7684\u7194\u65AD #\u6253\u5F00feign\u7684\u7194\u65AD

2
modules/i3plus-core-apiservice/src/main/resources/log4j2-spring-dev.xml
Unescape Escape View File

@ -7,7 +7,7 @@
<Property name="log4j2.level" value="INFO"/> <Property name="log4j2.level" value="INFO"/>
<!-- 日志输出格式 --> <!-- 日志输出格式 -->
<Property name="info_pattern">[%p] %d{yyyy-MM-dd HH:mm:ss-SSS} %c(%M:%L) 信息:%m%n</Property> <Property name="info_pattern">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %p %c(%M:%L) - %m%n</Property>
</Properties> </Properties>
<appenders> <appenders>

4
modules/i3plus-core-apiservice/src/main/resources/log4j2-spring.xml
Unescape Escape View File

@ -9,8 +9,8 @@
<Property name="logFileRootPath" value="../logs"/> <Property name="logFileRootPath" value="../logs"/>
<!-- 日志输出格式 --> <!-- 日志输出格式 -->
<Property name="info_pattern">[%p] %d{yyyy-MM-dd HH:mm:ss-SSS} %c(%M:%L) 信息:%m%n</Property> <Property name="info_pattern">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %p %c(%M:%L) - %m%n</Property>
<Property name="file_pattern">[%p] %d{yyyy-MM-dd HH:mm:ss-SSS} %-5level %class{36} %L %M - %msg%xEx%n</Property> <Property name="file_pattern">%d{yyyy-MM-dd HH:mm:s.SSS} %p %-5level %class{36} %L %M - %msg%xEx%n</Property>
</Properties> </Properties>
<appenders> <appenders>

9
pom.xml
Unescape Escape View File

@ -22,7 +22,7 @@
<properties> <properties>
<!--项目坝称，坂照CommonEnumUtil.SOFT_TYPE--> <!--项目坝称，坂照CommonEnumUtil.SOFT_TYPE-->
<project.name>i3core</project.name> <project.name>i3core-W</project.name>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version> <java.version>1.8</java.version>
@ -199,6 +199,13 @@
<version>12.2.0.1</version> <version>12.2.0.1</version>
</dependency> </dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
<version>2.4.2</version>
</dependency>
<!-- sqlserver --> <!-- sqlserver -->
<dependency> <dependency>
<groupId>com.microsoft.sqlserver</groupId> <groupId>com.microsoft.sqlserver</groupId>

Write Preview
Loading…
Cancel
Save