package com.iplatform.base;
|
|
import com.iplatform.base.cache.DictCacheProvider;
|
import com.iplatform.base.di.PlatformDataImportEngine;
|
import com.iplatform.base.di.TemplateInfo;
|
import com.iplatform.base.service.DeptServiceImpl;
|
import com.iplatform.base.service.LogServiceImpl;
|
import com.iplatform.base.service.UserServiceImpl;
|
import com.iplatform.base.support.strategy.LoginStrategyManager;
|
import com.iplatform.base.util.MenuUtils;
|
import com.iplatform.core.BeanContextAware;
|
import com.iplatform.model.po.S_dept;
|
import com.iplatform.model.po.S_dict_data;
|
import com.iplatform.model.po.S_oper_log;
|
import com.iplatform.model.po.S_user_core;
|
import com.iplatform.model.po.S_user_login;
|
import com.walker.cache.CacheProvider;
|
import com.walker.infrastructure.utils.DateUtils;
|
import com.walker.infrastructure.utils.FileCopyUtils;
|
import com.walker.infrastructure.utils.NumberGenerator;
|
import com.walker.infrastructure.utils.PhoneNumberUtils;
|
import com.walker.infrastructure.utils.StringUtils;
|
import com.walker.push.PushManager;
|
import com.walker.web.CaptchaProvider;
|
import com.walker.web.CaptchaResult;
|
import com.walker.web.OrgType;
|
import com.walker.web.ResponseCode;
|
import com.walker.web.UserOnlineProvider;
|
import com.walker.web.UserPrincipal;
|
import com.walker.web.UserType;
|
import com.walker.web.WebAgentService;
|
import com.walker.web.WebUserAgent;
|
import com.walker.web.log.BusinessType;
|
import com.walker.web.log.OperateUser;
|
import com.walker.web.util.IdUtils;
|
import com.walker.web.util.ServletUtils;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.io.File;
|
import java.io.IOException;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TimerTask;
|
|
/**
|
* 系统控制器对象，业务所有 <code>Controller</code> 对象，都要继承该对象。
|
* @author 时克英
|
* @date 2022-12-01
|
*/
|
public abstract class SystemController extends AbstractFileOperateSpiController{
|
|
/**
|
* 更新给定用户登录缓存中的角色集合内容，roleIds。
|
* <pre>
|
* 1) 当用户变更角色后，可以直接刷新界面（重新请求用户信息）获取新的对应菜单权限。
|
* </pre>
|
* @param userId 用户ID
|
* @author 时克英
|
* @date 2023-12-28
|
*/
|
protected void updateLoginUserRoleListInCache(Long userId){
|
S_user_core userCore = this.getUser(userId);
|
if(userCore == null){
|
throw new PlatformRuntimeException("缓存中未查找到用户，这不正常，userId = " + userId, null);
|
}
|
S_user_login userLogin = this.getLoginStrategyManager().getUserLogin(userCore.getUser_name());
|
if(userLogin == null){
|
if(this.logger.isDebugEnabled()){
|
this.logger.debug("用户：{}不存在登录缓存，无需更新角色（roleId）缓存，userName={}", userId, userCore.getUser_name());
|
}
|
return;
|
}
|
|
UserPrincipal<?> existUserPrincipal = BeanContextAware.getBeanByType(UserOnlineProvider.class).getUserPrincipal(userLogin.getUuid());
|
List<String> existRoleIdList = existUserPrincipal.getRoleIdList();
|
|
List<String> roleIdList = this.getUserService().queryUserRoleIdList(userId);
|
if(this.logger.isDebugEnabled()){
|
this.logger.debug("给定用户：{}，包含的角色：{}", userId, roleIdList);
|
}
|
if(StringUtils.isEmptyList(roleIdList)){
|
roleIdList = new ArrayList<>(4);
|
}
|
// 把原来用户已有的系统级权限角色重新写入，否则用户会重新让登录
|
if(existRoleIdList != null){
|
for(String securityRoleName : existRoleIdList){
|
if(securityRoleName.equals(SecurityConstants.ROLE_USER)
|
|| securityRoleName.equals(SecurityConstants.ROLE_ADMIN)
|
|| securityRoleName.equals(SecurityConstants.ROLE_SUPER_ADMIN)
|
|| securityRoleName.equals(SecurityConstants.ROLE_MERCHANT)){
|
roleIdList.add(securityRoleName);
|
}
|
}
|
}
|
|
DefaultUserPrincipal userPrincipal = new DefaultUserPrincipal(userCore);
|
userPrincipal.setRoleIdList(roleIdList);
|
// 更新缓存的登录信息
|
BeanContextAware.getBeanByType(UserOnlineProvider.class).cacheUserPrincipal(userLogin.getUuid(), userPrincipal, VariableConstants.DEFAULT_TOKEN_EXPIRED_MINUTES);
|
}
|
|
protected UserLoginCache getUserLoginCache(){
|
return BeanContextAware.getBeanByType(UserLoginCache.class);
|
}
|
|
/**
|
* 获得通知提醒模板配置缓存。
|
* @return
|
* @date 2023-08-25
|
*/
|
protected NotificationTemplateCache getNotificationTemplateCache(){
|
return BeanContextAware.getBeanByType(NotificationTemplateCache.class);
|
}
|
|
/**
|
* 写入成功操作日志
|
* @param userName 当前用户名，可以是登录ID或名字，可选
|
* @param operateUser 操作用户类型
|
* @param businessType 业务类型
|
* @param title 标题描述，可选
|
* @param input 输入参数，可选
|
* @param output 输出参数，可选
|
* @date 2023-08-13
|
*/
|
protected void systemLogSuccess(String userName, OperateUser operateUser, BusinessType businessType
|
, String title, String input, String output){
|
S_oper_log s_oper_log = this.acquireSystemLog(userName, operateUser, businessType, title, input, output);
|
AsyncManager.me().execute(new TimerTask() {
|
@Override
|
public void run() {
|
BeanContextAware.getBeanByType(LogServiceImpl.class).execInsertOperateLog(s_oper_log);
|
}
|
});
|
}
|
|
/**
|
* 写入错误日志
|
* @param userName 当前用户名，可以是登录ID或名字，可选
|
* @param operateUser 操作用户类型，可选
|
* @param businessType 业务类型，可选
|
* @param title 标题描述，可选
|
* @param input 输入参数，可选
|
* @param error 错误内容，必填
|
* @date 2023-08-13
|
*/
|
protected void systemLogError(String userName, OperateUser operateUser, BusinessType businessType, String title, String input, String error){
|
if(StringUtils.isEmpty(error)){
|
logger.warn("调用写入错误日志，但未提供错误内容，日志将不会保存：systemLogError --> error is null!");
|
return;
|
}
|
S_oper_log s_oper_log = this.acquireSystemLog(userName, operateUser, businessType, title, input, null);
|
s_oper_log.setStatus(ResponseCode.ERROR.getCode());
|
s_oper_log.setError_msg(StringUtils.substring(error, 0, Constants.LOG_ERROR_MAX_SIZE));
|
AsyncManager.me().execute(new TimerTask() {
|
@Override
|
public void run() {
|
BeanContextAware.getBeanByType(LogServiceImpl.class).execInsertOperateLog(s_oper_log);
|
}
|
});
|
}
|
|
private S_oper_log acquireSystemLog(String userName, OperateUser operateUser, BusinessType businessType
|
, String title, String input, String output){
|
if(operateUser == null){
|
operateUser = OperateUser.Manage;
|
}
|
if(businessType == null){
|
businessType = BusinessType.Other;
|
}
|
WebUserAgent agent = this.getCurrentWebUserAgent();
|
S_oper_log s_oper_log = new S_oper_log();
|
s_oper_log.setOper_id(NumberGenerator.getLongSequenceNumber());
|
s_oper_log.setOper_time(DateUtils.getDateTimeNumber());
|
s_oper_log.setStatus(ResponseCode.SUCCESS.getCode());
|
s_oper_log.setOper_name(userName);
|
s_oper_log.setOperate_user(operateUser.getIndex());
|
s_oper_log.setBusiness_type(businessType.getIndex());
|
s_oper_log.setOper_ip(agent.getIp());
|
s_oper_log.setOper_location(agent.getLocation());
|
s_oper_log.setRequest_method(agent.getMethod());
|
s_oper_log.setOper_url(agent.getUrl());
|
s_oper_log.setTitle(title);
|
if(StringUtils.isNotEmpty(input)){
|
s_oper_log.setOper_param(input);
|
}
|
if(StringUtils.isNotEmpty(output)){
|
s_oper_log.setJson_result(output);
|
}
|
return s_oper_log;
|
}
|
|
/**
|
* 返回登录策略管理器对象
|
* @return
|
* @date 2023-08-05
|
*/
|
protected LoginStrategyManager getLoginStrategyManager(){
|
return BeanContextAware.getBeanByType(LoginStrategyManager.class);
|
}
|
|
/**
|
* 返回当前web浏览器代理对象。
|
* @return
|
* @date 2023-07-25
|
*/
|
protected WebUserAgent getCurrentWebUserAgent(){
|
HttpServletRequest request = this.getRequest();
|
return this.getWebAgentService().getWebUserAgent(request.getHeader("User-Agent"), request);
|
}
|
|
protected WebAgentService getWebAgentService(){
|
return BeanContextAware.getBeanByType(WebAgentService.class);
|
}
|
|
/**
|
* 判断短信验证码是否正确。
|
* @param code 验证码
|
* @param uuid 请求验证码标识
|
* @return
|
* @date 2023-08-07
|
*/
|
protected boolean validateSmsCode(String code, String uuid){
|
CaptchaResult captchaResult = new CaptchaResult();
|
captchaResult.setCode(code);
|
captchaResult.setUuid(uuid);
|
return this.smsCaptchaProvider.validateCaptcha(captchaResult);
|
}
|
|
/**
|
* 发送短信验证码。
|
* @param phoneNumber 手机号
|
* @return 返回前端需要的uuid，提交登录使用
|
* @throws PlatformRuntimeException
|
* @date 2023-06-28
|
*/
|
protected Map<String, Object> sendSmsCodeValidation(String phoneNumber){
|
if(!PhoneNumberUtils.isCellPhoneNumber(phoneNumber)){
|
throw new PlatformRuntimeException("手机号码格式错误：" + phoneNumber);
|
}
|
String uuid = IdUtils.simpleUUID();
|
Map<String, Object> data = new HashMap<>(4);
|
data.put("uuid", uuid);
|
String verifyKey = Constants.CAPTCHA_CODE_PREFIX + uuid;
|
CaptchaResult captchaResult = this.smsCaptchaProvider.generateCaptcha(phoneNumber);
|
if(captchaResult == null){
|
// return ResponseValue.error("短信验证码生成错误, null");
|
throw new PlatformRuntimeException("短信验证码生成错误, null");
|
}
|
// 写入验证码 key 和 code 到缓存中
|
this.captchaCacheProvider.putCacheData(verifyKey, captchaResult.getCode(), 120);
|
if(this.logger.isDebugEnabled()){
|
this.logger.debug("生成短信验证码:{}, uuid:{}", captchaResult.getCode(), uuid);
|
}
|
data.put("message", "短信验证码已发送");
|
return data;
|
}
|
|
/**
|
* 返回用户归属值，如果是平台为'-1'，如果为租户（商户）则为定义的商户ID。
|
* <pre>
|
* 注意要点：
|
* 1）因为系统框架中用户是长整形（Long），但商户中是（int）因此在实际添加商户数据时，需要按照序列来计算，这样只需要整形即可。
|
* </pre>
|
* @return
|
* @date 2023-06-05
|
*/
|
protected long getOwner(){
|
S_user_core user = this.getCurrentUser();
|
int userType = user.getUser_type();
|
if(userType == UserType.TYPE_SUPER){
|
return Constants.OWNER_PLATFORM;
|
}
|
// 其他人需要根据机构中"menu_type"字段区分是平台机构，还是业务独立机构
|
S_dept dept = this.getDept(user.getOrg_id());
|
if(dept.getMenu_type().intValue() == MenuUtils.MENU_SCOPE_PLATFORM){
|
return Constants.OWNER_PLATFORM;
|
}
|
// 机构ID就是业务创建的独立编号（如：商户id），这里商户是int，但系统机构中仍然使用bigint
|
return dept.getId();
|
}
|
|
/**
|
* 返回当前用户所在顶级单位，使用的菜单范围：平台0，商户（顶级独立单位菜单范围）4，后续可能会有其他值。
|
* @return
|
* @date 2023-06-01
|
*/
|
protected int getCurrentOrgMenuScope(){
|
long orgId = this.getCurrentUser().getOrg_id();
|
if(orgId == Constants.SUPERVISOR_ID){
|
// 超级管理员，返回平台菜单范围
|
return MenuUtils.MENU_SCOPE_PLATFORM;
|
}
|
return this.getDeptCacheProvider().getDept(orgId).getMenu_type();
|
}
|
|
/**
|
* 根据字典数据code，返回字典项名称。
|
* @param dictCode 字典项编码（主键）
|
* @return
|
* @date 2023-03-26
|
*/
|
protected String getDictName(long dictCode){
|
S_dict_data dict_data = this.getDictCacheProvider().getCacheData(String.valueOf(dictCode));
|
if(dict_data == null){
|
throw new IllegalStateException("缓存中未找到字典名称，dict_code = " + dictCode);
|
}
|
return dict_data.getDict_label();
|
}
|
|
/**
|
* 返回给定机构的名字。
|
* @param deptId 机构ID
|
* @return
|
* @date 2023-03-23
|
*/
|
protected String getDeptName(long deptId){
|
S_dept dept = this.getDept(deptId);
|
return dept == null ? "None":dept.getDept_name();
|
}
|
|
/**
|
* 返回给定id的部门对象
|
* @param deptId 部门ID
|
* @return
|
* @author 时克英
|
* @date 2023-03-23
|
*/
|
protected S_dept getDept(long deptId){
|
return this.getDeptCacheProvider().getDept(deptId);
|
}
|
|
/**
|
* 从缓存中返回给定的用户
|
* @param userId 用户id
|
* @return
|
* @date 2023-03-22
|
*/
|
public S_user_core getUser(long userId){
|
return this.getUserCacheProvider().getUser(userId);
|
}
|
|
/**
|
* 下载数据导入模板，该模板由系统自动生成。<br>
|
* 业务需要提供数据库对应的'表名称'，如：s_user_core
|
* @param tableName 表名
|
* @date 2023-03-18
|
*/
|
protected void downloadLocalImportTemplate(String tableName){
|
if(StringUtils.isEmpty(tableName)){
|
throw new IllegalArgumentException("请提供要导入数据的'表名称'!");
|
}
|
// 本地文件存储根路径，如: d:/temp/
|
String templatePath = this.acquireFileOperateSpi().getFileRootConfig();
|
// 生成的模板文件名称，如：demo.xlsx
|
String templateFileName = Constants.TEMPLATE_IMPORT_PREFIX + tableName + "_" + DateUtils.getDateTimeSecondForShow() + ".xlsx";
|
TemplateInfo templateInfo = new TemplateInfo();
|
// 2023-05-07 设置模板生成具体路径。
|
templateInfo.setTemplatePath(templatePath + templateFileName);
|
templateInfo.setTableName(tableName);
|
|
logger.debug("templateInfo = {}", templateInfo);
|
|
File templateFile = this.getDataImportEngine().generateTemplate(templateInfo);
|
try {
|
this.downloadSimpleFile(FileCopyUtils.copyToByteArray(templateFile), templateFileName);
|
} catch (IOException e) {
|
logger.error("下载模板错误:" + e.getMessage() + ", tableName=" + tableName, e);
|
ServletUtils.renderString(getResponse(), "下载模板错误:" + e.getMessage() + ", tableName=" + tableName);
|
}
|
}
|
|
/**
|
* 返回数据字典缓存对象。<p></p>
|
* 注意：这种写法后续要改掉，统一由平台自动注入，无需单独设置。
|
* @return
|
* @date 2023-03-10
|
*/
|
protected DictCacheProvider getDictCacheProvider(){
|
// if(this.dictCacheProvider == null){
|
// this.dictCacheProvider = BeanContextAware.getBeanByType(DictCacheProvider.class);
|
// }
|
return this.dictCacheProvider;
|
}
|
|
/**
|
* 返回数据导入引擎实现对象，用来完成 Excel 导入功能。
|
* @return
|
* @date 2023-02-07
|
*/
|
protected PlatformDataImportEngine getDataImportEngine(){
|
// return BeanContextAware.getBeanByType(PlatformDataImportEngine.class);
|
return this.platformDataImportEngine;
|
}
|
|
public UserCacheProvider getUserCacheProvider() {
|
// if(this.userCacheProvider == null){
|
// this.userCacheProvider = BeanContextAware.getBeanByType(UserCacheProvider.class);
|
// }
|
return userCacheProvider;
|
}
|
|
public DeptCacheProvider getDeptCacheProvider() {
|
// if(this.deptCacheProvider == null){
|
// this.deptCacheProvider = BeanContextAware.getBeanByType(DeptCacheProvider.class);
|
// }
|
return deptCacheProvider;
|
}
|
|
/**
|
* 返回给定用户的顶级机构ID。
|
* @param userId
|
* @return
|
* @date 2022-12-15
|
*/
|
protected long getUserRootOrgId(long userId){
|
this.checkUserCacheProvider();
|
S_user_core user_core = this.userCacheProvider.getUser(userId);
|
if(user_core == null){
|
throw new IllegalStateException("缓存中未找到用户: " + userId);
|
}
|
return user_core.getOrg_id();
|
}
|
|
/**
|
* 根据机构(部门等非顶级ID)返回顶级机构ID。
|
* @param deptId
|
* @return
|
* @date 2022-12-12
|
*/
|
protected long getRootOrgIdByDept(long deptId){
|
if(this.deptCacheProvider == null){
|
throw new IllegalArgumentException("请先设置controller对象: deptCacheProvider");
|
}
|
S_dept dept = this.deptCacheProvider.getDept(deptId);
|
if(dept == null){
|
throw new IllegalStateException("缓存中未找到机构: " + deptId);
|
}
|
return dept.getOrg_id();
|
}
|
|
/**
|
* 返回当前登录用户可选择的根机构列表，即:第一级机构，通常是集团公司等。<p></p>
|
* 这些也称为多租户，系统提供多单位(独立)维护，不同独立单位由各自管理员自行维护。
|
* <pre>
|
* 1.超级管理员可以看到所有独立机构列表
|
* 2.单位用户只能看到本单位(一个机构)
|
* </pre>
|
* @return
|
* @date 2022-12-01
|
*/
|
protected List<S_dept> getOrgListScope(){
|
DeptServiceImpl deptService = BeanContextAware.getBeanByType(DeptServiceImpl.class);
|
S_user_core currentUser = this.getCurrentUser();
|
List<S_dept> list = null;
|
if(currentUser.getUser_type().intValue() == UserType.TYPE_SUPER){
|
list = deptService.queryRootOrgList(0);
|
} else {
|
list = deptService.queryRootOrgList(currentUser.getOrg_id().longValue());
|
}
|
if(StringUtils.isEmptyList(list)){
|
// 不存在任何机构(数据库没有记录)，需要创建默认机构
|
list = new ArrayList<>(2);
|
list.add(this.createDefaultOrg());
|
}
|
return list;
|
}
|
|
private void checkUserCacheProvider(){
|
if(this.userCacheProvider == null){
|
throw new IllegalStateException("UserCacheProvider 必须先设置到控制器中。");
|
}
|
}
|
|
private S_dept createDefaultOrg(){
|
S_dept root = new S_dept();
|
root.setId(0L);
|
root.setParent_id(0L);
|
root.setOrg_type(OrgType.TYPE_ORG);
|
root.setOrder_num(1);
|
root.setDept_name(Constants.DEFAULT_ORG_NAME);
|
return root;
|
}
|
|
public void setDeptCacheProvider(DeptCacheProvider deptCacheProvider) {
|
this.deptCacheProvider = deptCacheProvider;
|
}
|
|
public void setUserCacheProvider(UserCacheProvider userCacheProvider) {
|
this.userCacheProvider = userCacheProvider;
|
}
|
|
public void setPlatformDataImportEngine(PlatformDataImportEngine platformDataImportEngine) {
|
this.platformDataImportEngine = platformDataImportEngine;
|
}
|
|
public void setDictCacheProvider(DictCacheProvider dictCacheProvider) {
|
this.dictCacheProvider = dictCacheProvider;
|
}
|
|
public void setPushManager(PushManager pushManager) {
|
this.pushManager = pushManager;
|
}
|
|
public void setSmsCaptchaProvider(CaptchaProvider<CaptchaResult> smsCaptchaProvider) {
|
this.smsCaptchaProvider = smsCaptchaProvider;
|
}
|
|
public void setCaptchaCacheProvider(CacheProvider<String> captchaCacheProvider) {
|
this.captchaCacheProvider = captchaCacheProvider;
|
}
|
|
public CaptchaProvider<CaptchaResult> getSmsCaptchaProvider() {
|
return smsCaptchaProvider;
|
}
|
|
public CacheProvider<String> getCaptchaCacheProvider() {
|
return captchaCacheProvider;
|
}
|
|
protected UserServiceImpl getUserService(){
|
return BeanContextAware.getBeanByType(UserServiceImpl.class);
|
}
|
|
private CaptchaProvider<CaptchaResult> smsCaptchaProvider;
|
private CacheProvider<String> captchaCacheProvider;
|
|
/**
|
* 返回推送管理器对象，只有在特殊情况下需要业务直接调用该对象。
|
* @return
|
* @date 2023-04-25
|
*/
|
protected PushManager getPushManager() {
|
return pushManager;
|
}
|
|
private PushManager pushManager;
|
private DeptCacheProvider deptCacheProvider;
|
private UserCacheProvider userCacheProvider;
|
private PlatformDataImportEngine platformDataImportEngine;
|
private DictCacheProvider dictCacheProvider;
|
|
@Override
|
public void afterPropertiesSet() throws Exception {}
|
}
|
