Merge remote-tracking branch 'origin/develop_1' into develop_1

This commit is contained in:
Mr.Z
2021-11-09 14:53:28 +08:00
108 changed files with 2515 additions and 1335 deletions
@@ -0,0 +1,32 @@
package com.adc.da.FeignClient;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
/**
* @Description: TODO
* @author: super_liu
* @date: 2021年10月11日 13:33
*/
/**
* Feign配置
* 使用FeignClient进行服务间调用,传递headers信息
*/
@Configuration
public class FeignConfig implements RequestInterceptor {
@Override
public void apply(RequestTemplate requestTemplate) {
ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
if(attributes != null){
HttpServletRequest request = attributes.getRequest();
//添加token
requestTemplate.header("token", request.getHeader("token"));
}
}
}
@@ -17,6 +17,12 @@ import java.util.Set;
//@FeignClient(value = "shan6")
public interface workFlowFeignClient {
@RequestMapping(value = "/bat-wkflow/oaTaskExec/execTask",method = RequestMethod.GET)
Map<String,Object> execTask(@RequestParam("todoId") String todoId);
@RequestMapping(value = "/bat-wkflow/task/get_verify_by_instance",method = RequestMethod.GET)
Map<String,Object> get_verify_by_instance(@RequestParam("taskId") String taskId, @RequestParam("pId") String pId);
@RequestMapping(value = "/bat-wkflow/activiti_define_start_user",method = RequestMethod.GET)
Wrapper<String> activiti_define_start(@RequestParam("id") String id, @RequestParam("userId") String userId, @RequestParam("bpnId") String bpnId);
@@ -25,6 +25,16 @@ public class workFlowFeignClientImpl {
@Autowired
private IUserEOService userEOService;
public Map<String,Object> execTask(@RequestParam("todoId") String todoId){
Map<String,Object> stringWrapper = workFlowFeignClient.execTask(todoId);
return stringWrapper;
}
public Map<String,Object> get_verify_by_instance(@RequestParam("taskId") String taskId, @RequestParam("pId") String pId){
Map<String,Object> stringWrapper = workFlowFeignClient.get_verify_by_instance(taskId,pId);
return stringWrapper;
}
public ResponseMessage activiti_define_start(@RequestParam("Id") String Id, @RequestParam("userId") String userId, @RequestParam("bpnId") String bpnId){
Wrapper<String> stringWrapper = workFlowFeignClient.activiti_define_start(Id,userId,bpnId);
return Result.success(stringWrapper.getResult());
@@ -44,5 +44,7 @@ public class BusProcessNew {
private String finishFlag;
private long commitStatus;
}
@@ -35,10 +35,8 @@ import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
@RestController
@RequestMapping("/${restPath}/lawss/activiti")
@@ -51,6 +49,18 @@ public class WorkFlowController {
// @Autowired
// private ExportExcelMapper exportExcelMapper;
@ApiOperation(value = "干活流程接收待办")
@GetMapping("/execTask")
public Map<String,Object> execTask(@RequestParam("todoId") String todoId){
return workFlowFeignClient.execTask(todoId);
}
@ApiOperation(value = "流程实例明细验证是否完成")
@GetMapping("/get_verify_by_instance")
public Map<String,Object> activiti_define_start1(@RequestParam("taskId") String taskId, @RequestParam("pId") String pId){
return workFlowFeignClient.get_verify_by_instance(taskId,pId);
}
@ApiOperation(value = "导出excel")
@PostMapping("/export_excel")
public void exportExcel(@RequestBody ExportExcelEO exportExcelEO, HttpServletResponse response, HttpServletRequest request) throws IOException {
@@ -62,8 +72,11 @@ public class WorkFlowController {
if(exportExcelEO.getFileName()==null||exportExcelEO.getFileName().trim().length()==0){
exportExcelEO.setFileName(UUID.fastUUID().toString(true));
}
List<Map<String, Object>> dataList = exportExcelEO.getDataList().stream()
.sorted(Comparator.comparing(a -> String.valueOf(a.get("chapterNumber").toString())))
.collect(Collectors.toList());
Workbook excel = TableToExcel.createExcel(exportExcelEO.getColumnName(), exportExcelEO.getDataList(), null, exportExcelEO.getFileName());
Workbook excel = TableToExcel.createExcel(exportExcelEO.getColumnName(), dataList, null, exportExcelEO.getFileName());
response.reset();
@@ -3,6 +3,7 @@ package com.adc.da.http;
public enum ResponseMessageCodeEnum {
SUCCESS("0"),
ERROR("-1"),
ERROR_TOKEN("LE505"),
VALID_ERROR("1000"),
SAVE_SUCCESS("r0001"),
UPDATE_SUCCESS("r0002"),
+3 -1
View File
@@ -27,7 +27,9 @@
<dependency>
<groupId>com.artofsolving</groupId>
<artifactId>jodconverter</artifactId>
<version>2.2.1</version>
<scope>system</scope>
<version>2.2.2</version>
<systemPath>${basedir}/src/main/lib/jodconverter-2.2.2.jar</systemPath>
</dependency>
<dependency>
<groupId>org.jodconverter</groupId>
@@ -0,0 +1,31 @@
package com.adc.da.login.exception;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.Result;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
* 全局异常处理
*
* @author ch
* @version 1.0.0
* @since 1.0.0
* <p>
* Created at 2020/8/6 5:03 下午
*/
@RestControllerAdvice
public class SysRuntimeExceptionHandler {
@ExceptionHandler(TokenRuntimeException.class)
public ResponseMessage tokenRuntimeException(TokenRuntimeException e) {
e.printStackTrace();
return Result.error(e.getCode(), e.getMsg());
}
@ExceptionHandler(Exception.class)
public ResponseMessage handlerException(Exception e){
e.printStackTrace();
return Result.error();
}
}
@@ -0,0 +1,24 @@
package com.adc.da.login.exception;
import lombok.Data;
/**
* 自定义 token 异常
*
* @author ch
* @version 1.0.0
* @since 1.0.0
* <p>
* Created at 2020/8/6 4:58 下午
*/
@Data
public class TokenRuntimeException extends RuntimeException{
private String code = "401";
private String msg;
public TokenRuntimeException(String msg) {
super(msg);
}
}
@@ -3,14 +3,11 @@ package com.adc.da.login.rest;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.Result;
import com.adc.da.login.util.JWTUtil;
import com.adc.da.login.util.UserUtils;
import com.adc.da.login.vo.LoginVO;
import com.adc.da.sys.entity.MenuEO;
import com.adc.da.login.exception.TokenRuntimeException;
import com.adc.da.login.util.IDMUtil;
import com.adc.da.login.util.JwtUtils;
import com.adc.da.sys.entity.UserEO;
import com.adc.da.sys.service.IUserEOService;
import com.adc.da.sys.vo.UserVO;
import com.adc.da.util.Encodes;
import com.adc.da.util.PasswordUtils;
import com.alibaba.fastjson.JSON;
import io.swagger.annotations.Api;
@@ -18,20 +15,20 @@ import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import sun.misc.BASE64Encoder;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.NotNull;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
@Validated
@@ -43,84 +40,10 @@ public class LoginRestController {
@Autowired
private IUserEOService userService;
/**
* 读取配置文件判断是否需要开启Base64加密,默认值为false
*/
@Value("${isPassEncrypted:false}")
private boolean isPassEncrypted;
/**
* 无缓存,用于校验
*/
private static final String NO_CACHE = "no-cache";
/**
* 登录失败Map字段
*/
private static final String LOGIN_FAIL_MAP = "loginFailMap";
/**
* 验证码
*/
private static final Object VERIFY_CODE = "VerifyCode";
/**
* 10分钟内最大错误次数
*/
@Value("${maxLoginErrorCount:3}")
private int maxLoginErrorCount;
/**
* 读取验证码模式配置,
* 1为不开启,2为开启,3为三次输错用户名或密码才开启,
* 默认为1
* <p>
* 若配置文件缺少该参数,将设置为1
*/
@Value("${verifyCodeMode:1}")
private int verifyCodeMode;
// @ApiOperation(value = "登录")
// @PostMapping(value = "/login")
// @ResponseBody
// public ResponseMessage<String> loginWithVerifyCode(HttpServletResponse response, @RequestBody LoginVO loginVO) {
// String username = loginVO.getUsername();
// String password = loginVO.getPassword();
// String key = loginVO.getKey();
//
// if (StringUtils.isBlank(username)) {
// return Result.error("r0014", "登录名不能为空");
// }
// if (StringUtils.isBlank(password)) {
// return Result.error("r0016", "密码不能为空");
// }
// if (StringUtils.isBlank(key)) {
// return Result.error("key不能为空");
// }
//
//
//
// UserEO userEO = userService.getUserByLoginNameNotDeleted(username);
// if (null == userEO) {
// log.info("用户[{}]身份验证失败", username);
// return Result.error("r0011", "您输入的帐号或密码有误");
// }
// if (PasswordUtils.validatePassword(password, userEO.getPassword())) {
// String token = JWTUtil.sign(username, userEO.getPassword(), userEO.getUsid());
// response.setHeader("Authorization", token);
// response.addHeader("Access-Control-Allow-Headers", "Authorization");
// return Result.success(token);
// } else {
// log.info("用户[{}]密码验证失败", username);
// return Result.error("r0011", "您输入的帐号或密码有误");
// }
// }
@Autowired
private IDMUtil idmUtil;
@Autowired
private JwtUtils jwtUtils;
@ApiOperation(value = "登录")
// @GetMapping(value = "/login")
@@ -140,11 +63,10 @@ public class LoginRestController {
return Result.error("r0011", "您输入的帐号已禁用");
}
if (PasswordUtils.validatePassword(password, userEO.getPassword())) {
String token = JWTUtil.sign(username, userEO.getUsid(),userEO.getPassword());
response.setHeader("Authorization", token);
response.addHeader("Access-Control-Allow-Headers", "Authorization");
String token = jwtUtils.generateToken(userEO.getUsid());
// 加密重要信息
BASE64Encoder encoder = new BASE64Encoder();
userEO.setToken(token);
String userStr = JSON.toJSONString(userEO);
String userStr2 = URLEncoder.encode(userStr,"UTF-8");
userStr = encoder.encode(userStr2.getBytes());
@@ -156,69 +78,50 @@ public class LoginRestController {
}
/**
* 退出登录,客户端把Token丢弃就可以
*/
@ApiOperation(value = "退出登录")
@GetMapping("/logout")
@ApiOperation(value = "登录")
@PostMapping(value = "/loginIdm")
@ResponseBody
public ResponseMessage logout(HttpServletResponse response,String ticket) {
UserUtils.logout();
return Result.success();
}
@ApiOperation(value = "未授权访问")
@RequestMapping(path = "/401")
@ResponseBody
public ResponseMessage unauthorized() {
return Result.error("401", "Unauthorized");
}
/**
* 登录成功之后获取当前登录用户信息的接口
*/
@ApiOperation(value = "获取登录用户信息")
@GetMapping("/userInfo")
@ResponseBody
public ResponseMessage<UserEO> userInfo(HttpServletResponse response) throws NumberFormatException {
UserEO user = UserUtils.getUser();
if (user != null) {
return Result.success(user);
public ResponseMessage<String> loginRest(String code) throws UnsupportedEncodingException {
String account = idmUtil.idmLogin(code);
if(StringUtils.isBlank(account)){
return Result.error("r0011", "用户不存在");
}
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
return Result.error();
/**
* TODO OA 用户不全 待同步
*/
UserEO userEO = userService.getUserByLoginNameNotDeleted(account);
if (null == userEO) {
return Result.error("r0011", "用户不存在");
}
if(userEO.getDisableFlag()==1){
return Result.error("r0011", "帐号已禁用");
}
String token = jwtUtils.generateToken(account);
userEO.setToken(token);
// 加密重要信息
BASE64Encoder encoder = new BASE64Encoder();
String userStr = JSON.toJSONString(userEO);
String userStr2 = URLEncoder.encode(userStr,"UTF-8");
userStr = encoder.encode(userStr2.getBytes());
return Result.success(userStr);
}
/**
* 获取用户菜单,已用菜单管理实现
*/
@ApiOperation(value = "获取登录用户菜单权限")
@GetMapping("/userMenu")
@ResponseBody
public ResponseMessage<List<MenuEO>> userMenu(){
return Result.success(UserUtils.getMenuList());
@ApiOperation(value = "登出")
@PostMapping(value = "/logout")
public void logout(HttpServletRequest request, HttpServletResponse response){
Cookie[] cookies = request.getCookies();
try {
for(int i=0;i < cookies.length;i++) {
Cookie cookie = new Cookie(cookies[i].getName(), null);
cookie.setMaxAge(0);
cookie.setPath("testsso1.foton.com.cn");//根据你创建cookie的路径进行填写
response.addCookie(cookie);
}
}catch(Exception ex) {
System.out.println("清空Cookies发生异常!");
}
}
/**
* 修改当前登录用户密码
*/
@ApiOperation(value = "修改密码")
@PutMapping("/updatePassword")
@ResponseBody
public ResponseMessage updatePassword(@NotNull(message = "请输入旧密码") @RequestParam String oldPassword,
@NotNull(message = "请输入新密码") @RequestParam String newPassword) {
// 前台如果base64传输密文,则需要解码
if (isPassEncrypted) {
oldPassword = new String(Encodes.decodeBase64(oldPassword), StandardCharsets.UTF_8);
newPassword = new String(Encodes.decodeBase64(newPassword), StandardCharsets.UTF_8);
}
if (!newPassword.matches("^(?![0-9]*$)[a-zA-Z0-9]{6,10}$")) {
return Result.error("r0018", "新密码必须6-10位且不能纯数字");
}
userService.updatePassword(UserUtils.getUserId(), oldPassword, newPassword);
return Result.success();
}
}
@@ -1,158 +0,0 @@
package com.adc.da.login.security;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
/**
* JWT过滤器,针对请求进行拦截过滤
*/
@Slf4j
public class JWTFilter extends BasicHttpAuthenticationFilter {
//10分钟后刷新token
private static final int tokenRefreshInterval = 60 * 10;
/**
* 这里我们详细说明下为什么最终返回的都是true,即允许访问
*例如我们提供一个地址 GET /article
*登入用户和游客看到的内容是不同的
*如果在这里返回了false,请求会被直接拦截,用户看不到任何东西
*所以我们在这里返回trueController中可以通过 subject.isAuthenticated() 来判断用户是否登入
*如果有些资源只有登入用户才能访问,我们只需要在方法上面加上 @RequiresAuthentication 注解即可
*但是这样做有一个缺点,就是不能够对GET,POST等请求进行分别过滤鉴权(因为我们重写了官方的方法),但实际上对应用影响不大
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
if (isLoginAttempt(request, response)) {
try {
return executeLogin(request, response);
} catch (Exception e) {
responseError(request, response);
return false;
}
}else{
return false;
}
}
/**
* 检测header里面是否包含Authorization字段
* @param request
* @param response
* @return
*/
@Override
protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
HttpServletRequest req = (HttpServletRequest) request;
String authorization = req.getHeader("Authorization");
log.debug("判断用户是否想要登录:{}",authorization);
return authorization != null;
}
/**
* 认证失败后调用的方法
* @param request
* @param response
* @return
* @throws Exception
*/
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
this.responseError(request,response);
return false;
}
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception{
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String authorization = httpServletRequest.getHeader("Authorization");
log.debug("用户开始认证x{}",authorization);
JWTToken token = new JWTToken(authorization);
// 提交给realm进行登入,如果错误他会抛出异常并被捕获
getSubject(request, response).login(token);
// 如果没有抛出异常则代表登入成功,返回true
return true;
}
@Override
protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
if(token instanceof JWTToken){
JWTToken jwtToken= (JWTToken) token;
//TODO 此处需要设置token自动续期功能
}
return true;
}
@Override
protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
HttpServletResponse httpServletResponse = (HttpServletResponse) response;
httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
httpServletResponse.addHeader("Access-Control-Allow-Headers", "Authorization");
// 跨域时会首先发送一个option请求,这里我们给option请求直接返回正常状态
if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
httpServletResponse.setStatus(HttpStatus.OK.value());
return false;
}
return super.preHandle(request, response);
}
/**
* 将非法请求跳转到 /401
*/
private void responseError(ServletRequest req, ServletResponse resp) {
try {
HttpServletResponse httpServletResponse = (HttpServletResponse) resp;
if(httpServletResponse.isCommitted()){
return;
}
//此处需要返回统一的错误对象 以便应对统一的异常处理
JSONObject result=new JSONObject();
result.put("respCode","A404");
result.put("ok",false);
result.put("message","认证失败");
result.put("data",null);
httpServletResponse.setHeader("Content-Type", "application/json");
httpServletResponse.setHeader("Access-Control-Allow-Credentials", "true");
httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET, POST");
httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");
httpServletResponse.setHeader("Access-Control-Max-Age", "3600");
// response.setHeader("Content-type", "application/json;charset=UTF-8");
httpServletResponse.setStatus(HttpServletResponse.SC_OK);
httpServletResponse.setContentType("application/json;charset=UTF-8");
httpServletResponse.setCharacterEncoding("UTF-8");
PrintWriter printWriter = httpServletResponse.getWriter();
printWriter.append(result.toString(SerializerFeature.WriteMapNullValue));
printWriter.flush();
// httpServletResponse.sendRedirect("/401");
} catch (IOException e) {
log.error(e.getMessage());
}
}
private boolean shouldTokenRefresh(JWTToken jwtToken) {
// LocalDateTime issueTime = LocalDateTime.ofInstant(issueAt.toInstant(), ZoneId.systemDefault());
// return LocalDateTime.now().minusSeconds(tokenRefreshInterval).isAfter(issueTime);
return true;
}
}
@@ -1,145 +0,0 @@
package com.adc.da.login.security;
import com.adc.da.login.util.JWTUtil;
import com.adc.da.login.util.UserUtils;
import com.adc.da.sys.entity.UserEO;
import com.adc.da.sys.service.IUserEOService;
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.Service;
import java.io.Serializable;
import java.util.*;
@Service
public class JWTRealm extends AuthorizingRealm {
private static final Logger logger = LoggerFactory.getLogger(JWTRealm.class);
private IUserEOService userEOService;
/**
* JWT签名密钥
*/
public static final String SECRET = "AyX3TWpHIkPfE9rqaDiYV416d0nguURLQ8vhNzBlK7MGcOJjmoZ2w5stSeCFxb16";
@Autowired
public void setUserEOService(IUserEOService userEOService) {
this.userEOService = userEOService;
}
/**
* 必须重写此方法,不然Shiro会报错
*/
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof JWTToken;
}
/**
* 此方法调用hasRole,hasPermission的时候才会进行回调.
* <p>
* 权限信息.(授权):
* 1、如果用户正常退出,缓存自动清空;
* 2、如果用户非正常退出,缓存自动清空;
* 3、如果我们修改了用户的权限,而用户不退出系统,修改的权限无法立即生效。
* (需要手动编程进行实现;放在service进行调用)
* 在权限修改后调用realm中的方法,realm已经由spring管理,所以从spring中获取realm实例,调用clearCached方法;
* :Authorization 是授权访问控制,用于对用户进行的操作授权,证明该用户是否允许进行当前操作,如访问某个链接,某个资源文件等。
*
* @param principalCollection
* @return
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
String username = JWTUtil.getUsername(principalCollection.toString());
if (username == null) {
return null;
}
UserEO user = userEOService.getUserByLoginNameNotDeleted(username);
if (user != null) {
try {
return UserUtils.getAuthInfo();
} catch (NumberFormatException e) {
logger.error("AuthorizationInfo NumberFormatException", e);
} catch (Exception e) {
logger.error("AuthorizationInfo Exception", e);
}
}
return null;
}
/**
* 认证信息(身份验证)
* Authentication 是用来验证用户身份
*
* @param authenticationToken
* @return
* @throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
String token = (String) authenticationToken.getCredentials();
// 解密获得username,用于和数据库进行对比
String username = JWTUtil.getUsername(token);
if (username == null) {
throw new AuthenticationException("token 无效!");
}
UserEO user = userEOService.getUserByLoginNameNotDeleted(username);
if (user == null) {
throw new AuthenticationException("用户"+username+"不存在") ;
}
if (!JWTUtil.verify(token, username,user.getUsid(),user.getPassword())) {
throw new AuthenticationException("账户密码错误!");
}
return new SimpleAuthenticationInfo(token, token, "jwtRealm");
}
/**
* 授权用户信息
*/
public static class Principal implements Serializable {
private static final long serialVersionUID = 1L;
private String id;
private String loginName;
private transient Map<String, Object> cacheMap;
public Principal(UserEO user) {
this.id = user.getUsid() == null ? "" : String.valueOf(user.getUsid());
this.loginName = user.getAccount();
}
public String getId() {
return id;
}
public String getLoginName() {
return loginName;
}
public Map<String, Object> getCacheMap() {
if (cacheMap == null) {
cacheMap = new HashMap<>();
}
return cacheMap;
}
}
}
@@ -1,32 +0,0 @@
package com.adc.da.login.security;
import org.apache.shiro.authc.AuthenticationToken;
/**
* JWT认证token实体对象
*/
public class JWTToken implements AuthenticationToken {
private static final long serialVersionUID = 613047528940906064L;
// 秘钥
private String token;
public JWTToken(String token) {
this.token = token;
}
@Override
public Object getPrincipal() {
return getToken();
}
@Override
public Object getCredentials() {
return getToken();
}
public String getToken() {
return token;
}
}
@@ -0,0 +1,80 @@
package com.adc.da.login.security;
import com.adc.da.login.exception.TokenRuntimeException;
import com.adc.da.login.util.JwtUtils;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
/**
* 创建一个 token 拦截器.
* 需要继承 HandlerInterceptorAdapter,并且声明为spring的组件
* @author ch
* @version 1.0.0
* @since 1.0.0
* <p>
* Created at 2020/7/30 2:19 下午
*/
@Component
@Slf4j
public class TokenInterceptor extends HandlerInterceptorAdapter {
// 注入jwt工具类
@Autowired
private JwtUtils jwtUtils;
// 重写 前置拦截方法
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 1、从请求头中获取token
String token = request.getHeader("token");
// 2、判断 token 是否存在
if (token == null ||"".equals(token)) {
log.error("未登录");
// 这里可以自定义 抛出 token 异常
throw new TokenRuntimeException("未登录");
}
// 3、解析token
Claims claim = jwtUtils.getClaimsByToken(token);
if (null == claim) {
System.out.println("token 解析错误");
// 这里可以自定义 抛出 token 异常
throw new TokenRuntimeException("token解析错误");
}
// 4、判断 token 是否过期
Date expiration = claim.getExpiration();
boolean tokenExpired = jwtUtils.isTokenExpired(expiration);
if (tokenExpired) {
System.out.println("token已过期,请重新登录");
// 这里可以自定义 抛出 token 异常
throw new TokenRuntimeException("token已过期");
}
// 5、 从 token 中获取员工信息
String subject = claim.getSubject();
// 6、去数据库中匹配 id 是否存在 (这里直接写死了)
if (null == subject ) {
System.out.println("员工不存在");
// 这里可以自定义 抛出 token 异常
throw new TokenRuntimeException("员工不存在");
}
// 7、成功后 设置想设置的属性,比如员工姓名
request.setAttribute("userId", subject);
request.setAttribute("userName", "张三");
return true;
}
}
@@ -0,0 +1,79 @@
package com.adc.da.login.security;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Autowired
private TokenInterceptor interceptor;
@Bean
public TokenInterceptor getSecurityInterceptor() {
return new TokenInterceptor();
}
/**
* 重写添加拦截器
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
InterceptorRegistration addInterceptor = registry.addInterceptor(getSecurityInterceptor());
addInterceptor.excludePathPatterns("/api/loginIdm");
/**
* TODO 测试流程 开放 login 接口 正式环境 关闭
*/
addInterceptor.excludePathPatterns("/api/login");
addInterceptor.excludePathPatterns("/v2/api-docs");
addInterceptor.excludePathPatterns("/webjars/**");
addInterceptor.excludePathPatterns("/swagger-resources/**");
addInterceptor.excludePathPatterns("/swagger-ui.html");
addInterceptor.excludePathPatterns("/doc.html");
addInterceptor.excludePathPatterns("/api/lawss/activiti/get_verify_by_instance");
addInterceptor.excludePathPatterns("/api/sys/user/getById");
addInterceptor.excludePathPatterns("/api/person/userInfo/getByUserInfoCode");
addInterceptor.excludePathPatterns("/api/att/attFile/upload");
addInterceptor.excludePathPatterns("/api/sarStandardsInfo/sar-standards-info/exportStandardsInfoExcel");
//pcms项目数据下发开放接口
addInterceptor.excludePathPatterns("/api/sarStandProjectLibrary/save");
addInterceptor.excludePathPatterns("/api/sar-stand-project-team/save");
//tc模块结构单元数据
addInterceptor.excludePathPatterns("/api/sarModelTree/save");
//同步用户数据
addInterceptor.excludePathPatterns("/api/DataSync/importUserData");
//同步组织机构数据
addInterceptor.excludePathPatterns("/api/DataSync/importOrgData");
//从excl中导入标准
addInterceptor.excludePathPatterns("/api/ImportExcel/import");
//标准征求意见导出
addInterceptor.excludePathPatterns("/api/slrs/sar-public-idea-all/tuallStand");
//标准法规清单导出
addInterceptor.excludePathPatterns("/api/sarLawsAttrDetailedList/sar-laws-attr-detailed-list/ExportLawsById");
//标准法规清单车型导出
addInterceptor.excludePathPatterns("/api/sarStandProjectLibrary/exportStandAttrInfoExcel");
//为符合项整改导出
addInterceptor.excludePathPatterns("/api/sarStandUnqualified/sar-stand-unqualified/exportStandUnqulifiedExcel");
//文件预览
addInterceptor.excludePathPatterns("/api/att/attFile/getFileInfo");
//附件下载
addInterceptor.excludePathPatterns("/api/att/attFile/downloadFileForSar");
//水印下载
addInterceptor.excludePathPatterns("/api/att/attFile/downloadFileForSarWaterMark");
// //测试接口使用
// addInterceptor.excludePathPatterns("/api/**");
// 添加自定义拦截器,并拦截对应 url
addInterceptor.addPathPatterns("/**");
}
}
@@ -1,84 +0,0 @@
package com.adc.da.login.util;
import com.adc.da.util.SpringContextHolder1;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
/**
* Cache工具类
*/
public class CacheUtils {
private CacheUtils() {
super();
}
private static CacheManager cacheManager = (CacheManager) SpringContextHolder1.getBean("ehCacheManagerFactoryBean");
private static final String SYS_CACHE = "sysCache";
private static final String ERROR_CACHE = "errorCache";
public static Object get(String key) {
return get(SYS_CACHE, key);
}
public static void put(String key, Object value) {
put(SYS_CACHE, key, value);
}
public static void remove(String key) {
remove(SYS_CACHE, key);
}
//配合main模块下resource/cache/ehcache-local.xml
//<cache name="errorCache" maxElementsInMemory="100" timeToIdleSeconds="180" timeToLiveSeconds="300" eternal="false" overflowToDisk="true"/>
public static Object getErrorCache(String key) {
return get(ERROR_CACHE, key);
}
public static void putErrorCache(String key, Object value) {
put(ERROR_CACHE, key, value);
}
public static void removeErrorCache(String key) {
remove(ERROR_CACHE, key);
}
public static Object get(String cacheName, String key) {
Element element = getCache(cacheName).get(key);
return element == null ? null : element.getObjectValue();
}
public static void put(String cacheName, String key, Object value) {
Element element = new Element(key, value);
getCache(cacheName).put(element);
}
public static void remove(String cacheName, String key) {
getCache(cacheName).remove(key);
}
/**
* 获得一个Cache,没有则创建一个。
* @param cacheName
* @return
*/
private static Cache getCache(String cacheName) {
Cache cache = cacheManager.getCache(cacheName);
if (cache == null) {
cacheManager.addCache(cacheName);
cache = cacheManager.getCache(cacheName);
cache.getCacheConfiguration().setEternal(true);
}
return cache;
}
public static CacheManager getCacheManager() {
return cacheManager;
}
}
@@ -0,0 +1,73 @@
package com.adc.da.login.util;
import com.adc.da.ocr.util.OkHttpUtil;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
@Slf4j
public class IDMUtil {
@Autowired
private OkHttpUtil okHttpUtil;
private final String app_key = "app_slrs";
private final String app_secret = "Fxi5LHbI5yGbQQDpVp86GcCdXeC5Bjfe";
private final String access_url = "http://sso.foton.com.cn/oauth2.0/accessTokenByJson";
private final String profile_ur = "http://sso.foton.com.cn/oauth2.0/profileByJson";
private final String redirect_url = "https://slrs.foton.com.cn";
public String idmLogin(String code){
try{
String access_token = "";
Map<String,String> param = new HashMap<>();
param.put("client_id",app_key);
param.put("client_secret",app_secret);
param.put("grant_type","authorization_code");
param.put("redirect_uri",redirect_url);
param.put("code",code);
String access_token_str = okHttpUtil.post(access_url,param,new HashMap<>());
JSONObject atJsonObj = JSONObject.fromObject(access_token_str);
System.out.println("AccessTokenJSON:" + atJsonObj);
if (atJsonObj.has("status")) {
System.out.println("AccessTokenStatus:" + atJsonObj.get("status"));
if ("true".equals(atJsonObj.get("status").toString())) {
if (atJsonObj.has("access_token")) {
access_token = atJsonObj.get("access_token").toString();
}
}
}
if(StringUtils.isBlank(access_token)){
return "";
}
Map<String,String> param_p = new HashMap<>();
param_p.put("access_token",access_token.substring(13));
String principal_json = okHttpUtil.post(profile_ur,param_p,new HashMap<>());
JSONObject pfjsonObj = JSONObject.fromObject(principal_json);
if (pfjsonObj.has("status")) {
System.out.println("ProfileStatus:" + pfjsonObj.get("status"));
if ("true".equals(pfjsonObj.get("status").toString())) {
if (pfjsonObj.has("id")) {
System.out.println("ID:" + pfjsonObj.get("id"));
}
if (pfjsonObj.has("attributes")) {
JSONObject attrObj = JSONObject.fromObject(pfjsonObj.get("attributes"));
if (attrObj.has("userid")) {
return attrObj.get("userid").toString();
}
}
}
}
}catch(Exception e){
log.error("单点登录获取用户信息失败");
e.printStackTrace();
}
return "";
}
}
@@ -1,79 +0,0 @@
package com.adc.da.login.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.beans.factory.annotation.Value;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
public class JWTUtil {
// 设置过期时间,默认为2小时
private static long EXPIRE_TIME = 120;
@Value("${EXPIRE_TIME}")
public void setEnv(long expireTime) {
setExpireTime(expireTime);
}
public static synchronized void setExpireTime(long expireTime) {
EXPIRE_TIME = expireTime;
}
public static boolean verify(String token, String username,String userId, String secret) {
try {
Algorithm algorithm = Algorithm.HMAC512(secret);
JWTVerifier verifier = JWT.require(algorithm)
.withClaim("username", username).withClaim("userid", userId)
.build();
verifier.verify(token);
return true;
} catch (Exception e) {
return false;
}
}
/**
* @Title: getUsername
* @Description: 获取token中的信息无需secret解密也能获得
* @Author 刘仁
* @DateTime 2019年4月1日 下午4:42:39
* @param token
* @return
*/
public static String getUsername(String token) {
try {
DecodedJWT jwt = JWT.decode(token);
return jwt.getClaim("username").asString();
} catch (JWTDecodeException e) {
return null;
}
}
public static String getUserId(String token){
try {
DecodedJWT jwt = JWT.decode(token);
return jwt.getClaim("userid").asString();
} catch (JWTDecodeException e) {
return null;
}
}
public static String sign(String username,String userId, String secret) {
Date date = Date
.from(LocalDateTime.now().plusMinutes(EXPIRE_TIME).atZone(ZoneId.systemDefault()).toInstant());
Algorithm algorithm = Algorithm.HMAC512(secret);
String sign = JWT.create()
.withClaim("username", username).withClaim("userid", userId)
.withExpiresAt(date)
.sign(algorithm);
// 附带username信息
return sign;
}
}
@@ -0,0 +1,102 @@
package com.adc.da.login.util;
import com.adc.da.att.entity.TsUser;
import com.adc.da.sys.entity.UserEO;
import com.adc.da.sys.service.IUserEOService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Date;
import java.util.List;
/**
* token 工具类
*
* @author ch
* @version 1.0.0
* @since 1.0.0
* <p>
* Created at 2020/7/30 2:23 下午
*/
@Component
public class JwtUtils {
// 过期时间
private static long expire = 6048000;
// 秘钥
private static String secret = "HSyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9";
@Autowired
private IUserEOService userService;
/**
* 创建一个token
*
* @param userId
* @return
*/
public String generateToken(String userId) {
Date now = new Date();
Date expireDate = new Date(now.getTime() + expire);
return Jwts.builder().setHeaderParam("type", "JWT").setSubject(userId).setIssuedAt(now)
.setExpiration(expireDate).signWith(
SignatureAlgorithm.HS512, secret).compact();
}
/**
* 解析token
*/
public Claims getClaimsByToken(String token) {
Claims claims;
try {
claims = Jwts.parser()
.setSigningKey(secret) // 设置标识名
.parseClaimsJws(token) //解析token
.getBody();
} catch (ExpiredJwtException e) {
claims = e.getClaims();
}
return claims;
}
public String getUserIdByToken(){
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
String user = "";
if(attributes != null){
HttpServletRequest request = attributes.getRequest();
Claims claim = getClaimsByToken(request.getHeader("token"));
user = claim.getSubject();
}
return user;
}
public UserEO getUserByToken(){
UserEO userEO = new UserEO();
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
if(attributes != null){
HttpServletRequest request = attributes.getRequest();
//添加token
Claims claim = getClaimsByToken(request.getHeader("token"));
String subject = claim.getSubject();
List<UserEO> userEOS = userService.getUser(subject);
userEO = userEOS.get(0);
}
return userEO;
}
/**
* 判断 token 是否过期
*/
public boolean isTokenExpired(Date expiration){
return expiration.before(new Date());
}
}
@@ -1,8 +1,6 @@
package com.adc.da.login.util;
import cn.hutool.core.util.ObjectUtil;
import com.adc.da.login.security.JWTRealm;
import com.adc.da.login.security.JWTRealm.Principal;
import com.adc.da.sys.entity.MenuEO;
import com.adc.da.sys.entity.RoleEO;
import com.adc.da.sys.entity.UserEO;
@@ -12,15 +10,14 @@ import com.adc.da.sys.service.IUserEOService;
import com.adc.da.util.SpringContextHolder1;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.UnavailableSecurityManagerException;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.session.InvalidSessionException;
import org.apache.shiro.subject.Subject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
import java.util.Map;
@@ -50,6 +47,11 @@ public class UserUtils {
public static final String CACHE_AREA_LIST = "areaList";
public static final String CACHE_OFFICE_LIST = "officeList";
/**
* @see JwtUtils
*/
private static JwtUtils jwtUtils = SpringContextHolder1.getBean(JwtUtils.class);
/**
* @see IUserEOService
*/
@@ -82,11 +84,11 @@ public class UserUtils {
* 获取当前登录用户名
*/
public static String getUserName() {
// JWTRealm.Principal principal = (Principal) SecurityUtils.getSubject().getPrincipal();
// if (principal != null) {
// return principal.getLoginName();
// }
return "admin";
UserEO userEO = getUser();
if (userEO != null) {
return userEO.getAccount();
}
return null;
}
/**
@@ -94,27 +96,25 @@ public class UserUtils {
* @throws Exception
*/
public static String getUserId() {
UserEO userEO = getUser();
if (userEO != null) {
return userEO.getUsid();
}
return null;
return jwtUtils.getUserIdByToken();
}
/**
* 获取当前登录用户信息
*/
public static UserEO getUser() {
UserEO user = (UserEO) CacheUtils.getCache(CURRENT_USER);
UserEO user = jwtUtils.getUserByToken();
if (user == null) {
user = new UserEO();
String userName = getUserName();
String userId = getUserId();
if (StringUtils.isNotEmpty(userName)) {
UserEO userInDb = userService.getUserByLoginNameNotDeleted(userName);
user = ObjectUtil.clone(userInDb);
user.setPassword("");
CacheUtils.putCache(CURRENT_USER, user);
if (StringUtils.isNotEmpty(userId)) {
List<UserEO> userEOS = userService.getUser(userId);
if(!userEOS.isEmpty()){
user = ObjectUtil.clone(userEOS.get(0));
user.setPassword("");
CacheUtils.putCache(CURRENT_USER, user);
}
}
}
return user;
@@ -218,15 +218,6 @@ public class UserUtils {
public static Map<String, Object> getCacheMap() {
Map<String, Object> map = Maps.newHashMap();
try {
Subject subject = SecurityUtils.getSubject();
JWTRealm.Principal principal = (JWTRealm.Principal) subject.getPrincipal();
return principal != null ? principal.getCacheMap() : map;
} catch (UnavailableSecurityManagerException e) {
logger.error(e.getMessage(),e);
} catch (InvalidSessionException e) {
logger.error(e.getMessage(),e);
}
return map;
}
}
@@ -4,6 +4,7 @@ import com.adc.da.exception.AdcDaBaseException;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.ResponseMessageCodeEnum;
import com.adc.da.http.Result;
import com.adc.da.login.exception.TokenRuntimeException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
@@ -32,6 +33,11 @@ public class AdcDaBaseExceptionAdvice {
public ResponseMessage handlerAdcDaBaseException(Exception exception) {
log.error(exception.getMessage(), exception);
// TODO 在数据库中记录程序异常,这个地方的异常是未处理的异常,需要管理员查看并进行处理以防重复出现
if(exception.getStackTrace() != null){
if(exception.getMessage().equals("token已过期")){
return Result.error(ResponseMessageCodeEnum.ERROR_TOKEN.getCode(), "token已过期,请重新登录");
}
}
return Result.error(ResponseMessageCodeEnum.ERROR.getCode(), "程序异常,请重试。如果重复出现请联系管理员处理!");
}
@@ -1,41 +0,0 @@
package com.adc.da.main.advice;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.Result;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authz.UnauthenticatedException;
import org.apache.shiro.authz.UnauthorizedException;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
@Slf4j
@ControllerAdvice
@Order(value=2)
public class ShiroExceptionAdvice {
@ResponseStatus(HttpStatus.UNAUTHORIZED)
@ExceptionHandler({AuthenticationException.class, UnknownAccountException.class,
UnauthenticatedException.class, IncorrectCredentialsException.class})
@ResponseBody
public ResponseMessage unauthorized(Exception exception) {
log.warn(exception.getMessage(), exception);
log.info("catch UnknownAccountException");
return Result.error("A404", "无权访问");
}
@ResponseStatus(HttpStatus.UNAUTHORIZED)
@ExceptionHandler(UnauthorizedException.class)
@ResponseBody
public ResponseMessage unauthorized1(UnauthorizedException exception) {
log.warn(exception.getMessage(), exception);
return Result.error("A404","无权访问");
}
}
@@ -1,44 +0,0 @@
package com.adc.da.main.config;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* shiro 自定义URL规则设置
*/
public class DefinitionUrlConfig {
/**
* 匿名用户,无需登录
*/
private static final String ANON = "anon";
// 拦截器
//rest:比如/admins/user/**=rest[user],根据请求的方法,相当于/admins/user/**=perms[usermethod] ,其中method为postgetdelete等。
//port:比如/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal//serverName8081?queryString,其中schmal是协议http或https等,serverName是你访问的host,8081是url配置里port的端口,queryString是你访问的url里的?后面的参数。
//perms:比如/admins/user/**=perms[useradd*],perms参数可以写多个,多个时必须加上引号,并且参数之间用逗号分割,比如/admins/user/**=perms["useradd*,usermodify*"],当有多个参数时必须每个参数都通过才通过,想当于isPermitedAll()方法。
//roles:比如/admins/user/**=roles[admin],参数可以写多个,多个时必须加上引号,并且参数之间用逗号分割,当有多个参数时,比如/admins/user/**=roles["admin,guest"],每个参数通过才算通过,相当于hasAllRoles()方法。//要实现or的效果看http://zgzty.blog.163.com/blog/static/83831226201302983358670/
//anon:比如/admins/**=anon 没有参数,表示可以匿名使用。
//authc:比如/admins/user/**=authc表示需要认证才能使用,没有参数
//authcBasic:比如/admins/user/**=authcBasic没有参数表示httpBasic认证
//ssl:比如/admins/user/**=ssl没有参数,表示安全的url请求,协议为https
//user:比如/admins/user/**=user没有参数表示必须存在用户,当登入操作时不做检查
public static Map<String,String> definitionUrlOptions(){
Map<String, String> filterRuleMap = new LinkedHashMap<>();
//TODO 此处设置URL过滤规则 默认是全部请求进行拦截,此处设置为不拦截的URL地址
filterRuleMap.put("/api/login",ANON);//登录接口
// swagger接口文档
filterRuleMap.put("/v2/api-docs", "anon");
filterRuleMap.put("/webjars/**", "anon");
filterRuleMap.put("/swagger-resources/**", "anon");
filterRuleMap.put("/swagger-ui.html", "anon");
filterRuleMap.put("/doc.html", "anon");
return filterRuleMap;
}
}
@@ -1,151 +0,0 @@
package com.adc.da.main.config;
import com.adc.da.login.security.JWTFilter;
import com.adc.da.login.security.JWTRealm;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.ClassPathResource;
import javax.servlet.Filter;
import java.util.HashMap;
import java.util.Map;
@Configuration
@Order(value=1)
public class ShiroConfig {
private static final String JWT_FILTER_NAME = "jwt";
private static final String URL_SUFFIX="/api";
/**
* 自定义realm,实现登录授权流程
* @return
*/
@Bean(name="jwtRealm")
public JWTRealm jwtRealm() {
return new JWTRealm();
}
/**
* 配置securityManager 管理subject(默认),并把自定义realm交由manager
*/
@Bean
public DefaultSecurityManager securityManager() {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
// 设置realm.
securityManager.setRealm(jwtRealm());
//注入缓存管理器
securityManager.setCacheManager(ehCacheManager());
/*
* 关闭shiro自带的session,详情见文档
* http://shiro.apache.org/session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
*/
DefaultSubjectDAO defaultSubjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator storageEvaluator = new DefaultSessionStorageEvaluator();
storageEvaluator.setSessionStorageEnabled(false);
defaultSubjectDAO.setSessionStorageEvaluator(storageEvaluator);
securityManager.setSubjectDAO(defaultSubjectDAO);
return securityManager;
}
/**
* 拦截链
*/
@Bean
public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultSecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
shiroFilterFactoryBean.setSecurityManager(securityManager);
shiroFilterFactoryBean.setFilters(filterMap());
shiroFilterFactoryBean.setFilterChainDefinitionMap(definitionMap());
return shiroFilterFactoryBean;
}
/**
* 自定义拦截器,处理所有请求
*/
private Map<String, Filter> filterMap() {
Map<String, Filter> filterMap = new HashMap<>();
filterMap.put(JWT_FILTER_NAME, new JWTFilter());
return filterMap;
}
/**
* url拦截规则
*/
private Map<String, String> definitionMap() {
// 拦截器
//rest:比如/admins/user/**=rest[user],根据请求的方法,相当于/admins/user/**=perms[usermethod] ,其中method为postgetdelete等。
//port:比如/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal//serverName8081?queryString,其中schmal是协议http或https等,serverName是你访问的host,8081是url配置里port的端口,queryString是你访问的url里的?后面的参数。
//perms:比如/admins/user/**=perms[useradd*],perms参数可以写多个,多个时必须加上引号,并且参数之间用逗号分割,比如/admins/user/**=perms["useradd*,usermodify*"],当有多个参数时必须每个参数都通过才通过,想当于isPermitedAll()方法。
//roles:比如/admins/user/**=roles[admin],参数可以写多个,多个时必须加上引号,并且参数之间用逗号分割,当有多个参数时,比如/admins/user/**=roles["admin,guest"],每个参数通过才算通过,相当于hasAllRoles()方法。//要实现or的效果看http://zgzty.blog.163.com/blog/static/83831226201302983358670/
//anon:比如/admins/**=anon 没有参数,表示可以匿名使用。
//authc:比如/admins/user/**=authc表示需要认证才能使用,没有参数
//authcBasic:比如/admins/user/**=authcBasic没有参数表示httpBasic认证
//ssl:比如/admins/user/**=ssl没有参数,表示安全的url请求,协议为https
//user:比如/admins/user/**=user没有参数表示必须存在用户,当登入操作时不做检查
Map<String, String> definitionMap = DefinitionUrlConfig.definitionUrlOptions();
// definitionMap.put(URL_SUFFIX+"/**", JWT_FILTER_NAME);
return definitionMap;
}
/* *//**
* 开启注解
*//*
@Bean
@DependsOn("lifecycleBeanPostProcessor")
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
// 强制使用cglib代理,防止和aop冲突
defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
return defaultAdvisorAutoProxyCreator;
}
@Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
}*/
/**
* 开启shiro aop注解支持. 使用代理方式; 所以需要开启代码支持;
*
* @param securityManager 安全管理器
* @return 授权Advisor
*/
@Bean("authorizationAttributeSourceAdvisor")
public AuthorizationAttributeSourceAdvisor advisor(DefaultSecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
/**
* shiro缓存管理器;
* 需要注入对应的其它的实体类中:
* 1、安全管理器:securityManager
* 可见securityManager是整个shiro的核心;
*
* @return
*/
@Bean
public EhCacheManager ehCacheManager() {
EhCacheManager cacheManager = new EhCacheManager();
cacheManager.setCacheManagerConfigFile("classpath:cache/ehcache.xml");
return cacheManager;
}
}
@@ -1,92 +0,0 @@
package com.adc.da.main.config;
import com.adc.da.login.security.JWTRealm;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.core.io.ClassPathResource;
//@Configuration
public class ShiroConfiguration {
@Bean(name = "ehCacheManagerFactoryBean")
public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() {
EhCacheManagerFactoryBean ehCacheManagerFactoryBean = new EhCacheManagerFactoryBean();
ClassPathResource classPathResource = new ClassPathResource("cache/ehcache-local.xml");
ehCacheManagerFactoryBean.setConfigLocation(classPathResource);
return ehCacheManagerFactoryBean;
}
@Bean(name = "shiroCacheManager")
@DependsOn({ "ehCacheManagerFactoryBean" })
public EhCacheManager shiroCacheManager() {
EhCacheManager ehCacheManager = new EhCacheManager();
ehCacheManager.setCacheManager(ehCacheManagerFactoryBean().getObject());
return ehCacheManager;
}
@Bean
@DependsOn({ "lifecycleBeanPostProcessor" })
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator proxyCreator = new DefaultAdvisorAutoProxyCreator();
proxyCreator.setProxyTargetClass(true);
return proxyCreator;
}
@Bean(name = "lifecycleBeanPostProcessor")
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
}
@Bean(name = "securityManager")
public SecurityManager securityManager() {
DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
defaultWebSecurityManager.setRealm(jwtRealm());
// 关闭shiro自带的session
DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
defaultWebSecurityManager.setSubjectDAO(subjectDAO);
// 自定义缓存管理器
defaultWebSecurityManager.setCacheManager(shiroCacheManager());
SecurityUtils.setSecurityManager(defaultWebSecurityManager);
return defaultWebSecurityManager;
}
@Bean
public HashedCredentialsMatcher hashedCredentialsMatcher() {
HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
hashedCredentialsMatcher.setHashAlgorithmName("md5");// 散列算法:这里使用MD5算法;
hashedCredentialsMatcher.setHashIterations(2);// 散列的次数,比如散列两次,相当于
// md5(md5(""));
return hashedCredentialsMatcher;
}
@Bean
public JWTRealm jwtRealm() {
JWTRealm jwtRealm = new JWTRealm();
return jwtRealm;
}
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager());
return advisor;
}
}
@@ -4,7 +4,7 @@
#=============================================
spring.datasource.driverClassName = com.mysql.cj.jdbc.Driver
spring.datasource.url = jdbc:mysql://39.100.23.127:3306/foton_slrs_test2?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
#spring.datasource.url = jdbc:mysql://10.96.10.171/foton_slrs_test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
#spring.datasource.url = jdbc:mysql://10.96.10.54/foton_slrs_test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
spring.datasource.username = root
spring.datasource.password = root
@@ -49,6 +49,10 @@ spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.listener.simple.acknowledge-mode= manual
# 生产者 默认关闭 发版 需改为 true
spring.rabbitmq.listener.direct.auto-startup=false
# 消费者 默认关闭 发版 需改为 true
spring.rabbitmq.listener.simple.auto-startup=false
#消费失败消息干掉
spring.rabbitmq.listener.simple.default-requeue-rejected= true
#5秒
@@ -84,13 +84,9 @@ public class SearchCenterController extends BaseController<Map<String, Object>>
if (StringUtils.isAlphanumericSpace(searchInfoEO.getSelectIndex())) {
if(elasticsearchService.isIndexExist(searchInfoEO.getSelectIndex())){
if("fulltextserch".equals(searchInfoEO.getSelectIndex()) || "fulltextserch"== searchInfoEO.getSelectIndex()){
Pattern pattern = Pattern.compile("^[a-zA-Z]+\\s[0-9a-zA-Z\\.\\(\\\\\\)\\-\\s]+$");
Pattern pattern = Pattern.compile("^[0-9a-zA-Z\\.\\(\\\\\\)\\s\\/\\-]+$");
if (null != searchInfoEO.getSelectValue() && StringUtils.isNotBlank(searchInfoEO.getSelectValue())) {
if (pattern.matcher(searchInfoEO.getSelectValue()).matches()) {
result = searchCenterService.searchSarBykeyAndHighLightNumber(searchInfoEO);
}else {
result = searchCenterService.searchSarBykeyAndHighLight(searchInfoEO);
}
result = searchCenterService.searchSarBykeyAndHighLight(searchInfoEO);
} else {
result = searchCenterService.searchSarBykeyAndHighLight(searchInfoEO);
}
@@ -156,7 +156,7 @@ public class SearchCenterServiceImpl implements SearchCenterService {
boolQueryShould.should(QueryBuilders.wildcardQuery("standSort.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(QueryBuilders.wildcardQuery("stand_code.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(QueryBuilders.wildcardQuery("standYear.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(QueryBuilders.wildcardQuery("standName.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(QueryBuilders.wildcardQuery("stand_name.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(QueryBuilders.wildcardQuery("standEnName.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(QueryBuilders.wildcardQuery("textStatusBuss.keyword", "*"+searchInfoEO.getSelectValue()+"*"));
if (isRqFormat(searchInfoEO.getSelectValue())) {
@@ -178,6 +178,12 @@ public class SearchCenterServiceImpl implements SearchCenterService {
if (StringUtils.isNotBlank(searchInfoEO.getStandType())) {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("standType.keyword", "*"+searchInfoEO.getStandType()+"*"));
}
if (StringUtils.isNotBlank(searchInfoEO.getStandSort())) {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("numbershow.keyword", "*"+searchInfoEO.getStandSort()+" "+"*"));
}
if (StringUtils.isNotBlank(searchInfoEO.getTextStatus())) {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("textStatus.keyword", "*"+searchInfoEO.getTextStatus()+"*"));
}
boolQueryBuilder.must(boolQueryShould);
}else {
boolQueryBuilder.must(boolQueryShould);
@@ -245,7 +251,7 @@ public class SearchCenterServiceImpl implements SearchCenterService {
}
if(searchInfoEO.getCYSD() != null && StringUtils.isNotBlank(searchInfoEO.getCYSD())){
List<String> fieldList = Arrays.asList(searchInfoEO.getCYSD() .split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
List<String> fieldList = Arrays.asList(searchInfoEO.getCYSD().split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
JSONArray array= JSONArray.parseArray(JSON.toJSONString(fieldList));
collectAttrMap.put("CYSD",array);
}
@@ -287,15 +293,60 @@ public class SearchCenterServiceImpl implements SearchCenterService {
}
}
if(!fields.isEmpty()){
for (String str : fields) {
boolQueryBuilderMust.must(QueryBuilders.wildcardQuery(keyWordField, "*"+str+"*"));
if(fields.size() > 1){
BoolQueryBuilder boolQueryBuilderShould = new BoolQueryBuilder();
fields.forEach(s -> {
boolQueryBuilderShould.should(QueryBuilders.wildcardQuery(keyWordField, "*"+s+"*"));
});
boolQueryBuilder.must(boolQueryBuilderShould);
}else {
boolQueryBuilderMust.must(QueryBuilders.wildcardQuery(keyWordField, "*"+fields.get(0)+"*"));
}
}
}
}
}
if(StringUtils.isNotEmpty(searchInfoEO.getSelectValue())) {
boolQueryBuilder.should(boolQueryBuilderMust);
if(searchInfoEO.getQCDW() != null && StringUtils.isNotBlank(searchInfoEO.getQCDW())){
List<String> list = Arrays.asList(searchInfoEO.getQCDW().split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
if(list.size() > 1){
BoolQueryBuilder boolQueryBuilderShould = new BoolQueryBuilder();
list.forEach(s -> {
boolQueryBuilderShould.should(QueryBuilders.wildcardQuery("QCDW.keyword", "*"+s+"*"));
});
boolQueryBuilder.must(boolQueryBuilderShould);
}else {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("QCDW.keyword", "*"+searchInfoEO.getQCDW()+"*"));
}
}
if(searchInfoEO.getCYSD() != null && StringUtils.isNotBlank(searchInfoEO.getCYSD())){
List<String> list = Arrays.asList(searchInfoEO.getCYSD().split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
if(list.size() > 1){
BoolQueryBuilder boolQueryBuilderShould = new BoolQueryBuilder();
list.forEach(s -> {
boolQueryBuilderShould.should(QueryBuilders.wildcardQuery("CYSD.keyword", "*"+s+"*"));
});
boolQueryBuilder.must(boolQueryBuilderShould);
}else {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("CYSD.keyword", "*"+searchInfoEO.getCYSD()+"*"));
}
}
if(searchInfoEO.getCLLX() != null && StringUtils.isNotBlank(searchInfoEO.getCLLX())){
List<String> list = Arrays.asList(searchInfoEO.getCLLX().split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
if(list.size() > 1){
BoolQueryBuilder boolQueryBuilderShould = new BoolQueryBuilder();
list.forEach(s -> {
boolQueryBuilderShould.should(QueryBuilders.wildcardQuery("CLLX.keyword", "*"+s+"*"));
});
boolQueryBuilder.must(boolQueryBuilderShould);
}else {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("CLLX.keyword", "*"+searchInfoEO.getCLLX()+"*"));
}
}
}else {
boolQueryBuilder.must(boolQueryBuilderMust);
}
@@ -312,7 +363,16 @@ public class SearchCenterServiceImpl implements SearchCenterService {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("standType.keyword", "*"+searchInfoEO.getStandType()+"*"));
}
if (StringUtils.isNotBlank(searchInfoEO.getStandSort())) {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("standSort.keyword", "*"+searchInfoEO.getStandSort()+"*"));
List<String> list = Arrays.asList(searchInfoEO.getStandSort().split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
if(list.size() > 1){
BoolQueryBuilder boolQueryBuilderShould = new BoolQueryBuilder();
list.forEach(s -> {
boolQueryBuilderShould.should(QueryBuilders.wildcardQuery("numbershow.keyword", "*"+s+" "+"*"));
});
boolQueryBuilder.must(boolQueryBuilderShould);
}else {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("numbershow.keyword", "*"+searchInfoEO.getStandSort()+" "+"*"));
}
}
if (StringUtils.isNotBlank(searchInfoEO.getStandNumber())) {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("standNumber.keyword", "*"+searchInfoEO.getStandNumber()+"*"));
@@ -584,7 +644,16 @@ public class SearchCenterServiceImpl implements SearchCenterService {
}
if (StringUtils.isNotBlank(searchInfoEO.getTextStatusBuss())) {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("textStatusBuss.keyword", "*"+searchInfoEO.getTextStatusBuss()+"*"));
List<String> list = Arrays.asList(searchInfoEO.getTextStatusBuss().split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
if(list.size() > 1){
BoolQueryBuilder boolQueryBuilderShould = new BoolQueryBuilder();
list.forEach(s -> {
boolQueryBuilderShould.should(QueryBuilders.wildcardQuery("textStatusBuss.keyword", "*"+s+"*"));
});
boolQueryBuilder.must(boolQueryBuilderShould);
}else {
boolQueryBuilder.must(QueryBuilders.wildcardQuery("textStatusBuss.keyword", "*"+searchInfoEO.getTextStatusBuss()+"*"));
}
}
if (searchInfoEO.getIssueTime() != null) {
@@ -644,7 +713,7 @@ public class SearchCenterServiceImpl implements SearchCenterService {
// 循环统计各种类型数据
String[] seniortype;
if("stand".equals(searchInfoEO.getSelectIndex())) {
String[] seniortypeStand = {"standSort", "statecode","CYSD","ZRLX","CLLX","CBCD"};
String[] seniortypeStand = {"standSort", "statecode","CYSD","ZRLX","CLLX","CBCD","textStatus","textStatusName"};
seniortype = seniortypeStand.clone();
} else if("laws".equals(searchInfoEO.getSelectIndex())){
String[] seniortypeLaws = {"country","statecode","SYCLLX","ZRLX","WSSFCY"};
@@ -943,12 +1012,16 @@ public class SearchCenterServiceImpl implements SearchCenterService {
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
// 记录搜索记录到数据库中
if(StringUtils.isNotEmpty(searchInfoEO.getSelectValue())){
QueryBuilder multiQueryBuilder = QueryBuilders.multiMatchQuery("");
multiQueryBuilder = QueryBuilders.multiMatchQuery(searchInfoEO.getSelectValue(),
"title","textContent","textItems"
).minimumShouldMatch("100%").field("title",10f);
boolQueryBuilder.must(multiQueryBuilder);
// boolQueryBuilder.should()
boolQueryBuilder.should(QueryBuilders.multiMatchQuery(searchInfoEO.getSelectValue(),
"title"
).minimumShouldMatch("100%").field("title",10f));
boolQueryBuilder.should(QueryBuilders.multiMatchQuery(searchInfoEO.getSelectValue(),
"textContent"
).minimumShouldMatch("100%").field("title",10f));
boolQueryBuilder.should(QueryBuilders.multiMatchQuery(searchInfoEO.getSelectValue(),
"textItems"
).minimumShouldMatch("100%").field("title",10f));
boolQueryBuilder.should(QueryBuilders.wildcardQuery("title.keyword","*"+searchInfoEO.getSelectValue()+"*"));
}
//在结果中检索
if (StringUtils.isNotEmpty(searchInfoEO.getResultKeyword())) {
@@ -1060,16 +1133,16 @@ public class SearchCenterServiceImpl implements SearchCenterService {
BoolQueryBuilder boolQueryMust = QueryBuilders.boolQuery();
QueryBuilder multiQueryBuilder;
multiQueryBuilder = QueryBuilders.multiMatchQuery(value,
"title","textContent").minimumShouldMatch("100%").field("title",1f);
"title.keyword","textContent.keyword").minimumShouldMatch("100%").field("title.keyword",1f);
boolQueryMust.must(multiQueryBuilder);
boolQueryShould.should(QueryBuilders.wildcardQuery("title", "*"+searchInfoEO.getSelectValue()+"*").boost(10f))
.should(QueryBuilders.wildcardQuery("textContent", "*"+searchInfoEO.getSelectValue()+"*"))
boolQueryShould.should(QueryBuilders.wildcardQuery("title.keyword", "*"+searchInfoEO.getSelectValue()+"*").boost(10f))
.should(QueryBuilders.wildcardQuery("textContent.keyword", "*"+searchInfoEO.getSelectValue()+"*"))
.should(multiQueryBuilder);
boolQueryBuilder.should(boolQueryShould);
//在结果中检索
// boolQueryBuilder.must(multiQueryBuilder);
HighlightBuilder hiBuilder=new HighlightBuilder();
HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("title");
HighlightBuilder.Field highlightTitle = new HighlightBuilder.Field("title.keyword");
hiBuilder.field(highlightTitle);
HighlightBuilder.Field highlightUser = new HighlightBuilder.Field("textContent");
hiBuilder.field(highlightUser);
@@ -1091,7 +1164,7 @@ public class SearchCenterServiceImpl implements SearchCenterService {
Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
//解析高亮字段
Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();
HighlightField field= highlightFields.get("title");
HighlightField field= highlightFields.get("title.keyword");
if(field!= null){
Text[] fragments = field.fragments();
String n_field = "";
@@ -1099,11 +1172,11 @@ public class SearchCenterServiceImpl implements SearchCenterService {
n_field += fragment;
}
//高亮标题覆盖原标题
sourceAsMap.put("title",n_field);
sourceAsMap.put("title.keyword",n_field);
}
Map<String, HighlightField> highlightFieldsnameshowStr = searchHit.getHighlightFields();
HighlightField fieldnameshowStr= highlightFieldsnameshowStr.get("textContent");
HighlightField fieldnameshowStr= highlightFieldsnameshowStr.get("textContent.keyword");
if(fieldnameshowStr!= null){
Text[] fragments = fieldnameshowStr.fragments();
String n_field = "";
@@ -1111,7 +1184,7 @@ public class SearchCenterServiceImpl implements SearchCenterService {
n_field += fragment;
}
//高亮标题覆盖原标题
sourceAsMap.put("textContent",n_field);
sourceAsMap.put("textContent.keyword",n_field);
}
result.add(sourceAsMap);
}
@@ -302,9 +302,10 @@ public class StandLawsSearchServiceImpl implements StandLawsSearchService {
contentBuilder.append("企标类别:").append(attrInfoMap.get("standSort")).append(" ");
contentBuilder.append("标准年份:").append(attrInfoMap.get("standYear")).append(" ");
contentBuilder.append("企标名称:").append(attrInfoMap.get("standName")).append(" ");
contentBuilder.append("企标英文名称:").append(attrInfoMap.get("standName")).append(" ");
contentBuilder.append("企标英文名称:").append(attrInfoMap.get("stand_en_name")).append(" ");
contentBuilder.append("文本状态:").append(attrInfoMap.get("textStatusBussName")).append(" ");
contentBuilder.append("企标实施日期:").append(attrInfoMap.get("putTime")).append(" ");
contentBuilder.append("企标发布日期:").append(attrInfoMap.get("issueTime")).append(" ");
contentBuilder.append("废止日期:").append(attrInfoMap.get("FZRQBUSSName")).append(" ");
contentBuilder.append("复审日期:").append(attrInfoMap.get("FSRQBUSSName")).append(" ");
contentBuilder.append("起草部门:").append(attrInfoMap.get("QCDWName")).append(" ");
@@ -171,17 +171,18 @@ public class SendBussMQService {
saveMap.put("validFlag","0");
saveMap.put("content",infoEO.getFileIds());
String fieldInfo = InitStandAttrUtil.queryField;
String fieldInfo = InitStandAttrUtil.queryFieldBuss;
List<String> fieldInfoList = Arrays.asList(fieldInfo .split(",")).stream().map(s -> (s.trim())).collect(Collectors.toList());
// 动态存储属性字段
for (String field : fieldInfoList) {
saveMap.put(field,attrInfoMap.getOrDefault(field,""));
String fieldValue = "";
if(infoMap.get(field) != null && StringUtils.isNotBlank(infoMap.get(field).toString())){
Object json= new JSONTokener(infoMap.get(field).toString()).nextValue();
String fieldFilter = field.toLowerCase();
if(infoMap.get(fieldFilter) != null && StringUtils.isNotBlank(infoMap.get(fieldFilter).toString())){
Object json= new JSONTokener(infoMap.get(fieldFilter).toString()).nextValue();
if(!json.toString().equals("null")){
fieldValue = infoMap.get(field).toString();
fieldValue = infoMap.get(fieldFilter).toString();
}
}
saveMap.put(field+"Name",fieldValue);
@@ -24,8 +24,8 @@ import org.springframework.stereotype.Component;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.regex.Pattern;
@EnableScheduling
@Component
@@ -129,10 +129,15 @@ public class ScheduledJob {
.setMark("3")
.setStandCode(warningEO.getStandSort()+" "+ warningEO.getStandNum()+"-"+ warningEO.getStandYear());
//实施日期达到预警时间,但新车型实施日期不在时间内
if (term.isTerm(warningEO.getXCXSSRQ())){
warningEO.setPutTime(warningEO.getXCXSSRQ());
}
//实施日期达到预警时间,但在产车实施日期不在时间内
/**
* 2021/9/9取消限制
*/
// if (term.isTerm(warningEO.getXCXSSRQ())){
// warningEO.setPutTime(warningEO.getXCXSSRQ());
// }
warningEO.setPutTime(warningEO.getXCXSSRQ());
}
warningList.addAll(standInfoXCXSSRQ);
@@ -150,9 +155,13 @@ public class ScheduledJob {
.setMark("4")
.setStandCode(warningEO.getStandSort()+" "+ warningEO.getStandNum()+"-"+ warningEO.getStandYear());
//实施日期达到预警时间,但在产车实施日期不在时间内
if (term.isTerm(warningEO.getZCCSSRQ())){
warningEO.setPutTime(warningEO.getZCCSSRQ());
}
/**
* 2021/9/9取消限制
*/
// if (term.isTerm(warningEO.getZCCSSRQ())){
// warningEO.setPutTime(warningEO.getZCCSSRQ());
// }
warningEO.setPutTime(warningEO.getZCCSSRQ());
}
warningList.addAll(standInfoZCCSSRQ);
@@ -215,47 +224,50 @@ public class ScheduledJob {
//查询代替标准字段得到一个 被代替了的标准的id的键值对列表
List<Map<String, Object>> replaceStandIdMaps = sarStandAttrInfoDao.selectMaps(columnForDTBJH);
HashMap<String, Integer> replaceIdCountMap = new HashMap<>();
// 格式为 T/CSAE 175-2021
Pattern pattern = Pattern.compile("^\\S*\\s\\S*[\\u2014\\u002d\\s]\\d{4}$");
replaceStandIdMaps.forEach(item->{
if (item!=null){
//此标准代替的标准的标准号的数组
String DTBJHStr = item.get("DTBJH").toString();
//数据格式: (GB 123-2000,GB 4233434-2021,GB 423423423-2021)
if (!DTBJHStr.equals("")){
if (!DTBJHStr.equals("")) {
String[] DTBJHArray = DTBJHStr.split(",");
for (String DTBJH : DTBJHArray) {
String[] sortAndNumberAndYear = DTBJH.split("\\s+");
String sort = sortAndNumberAndYear[0];
String[] numberAndYear = sortAndNumberAndYear[1].split("\\-");
String number=numberAndYear[0];
String year=numberAndYear[1];
if (!pattern.matcher(DTBJH).matches()){
continue;
}
String[] split = DTBJH.split("[\\u2014\\u002d\\s]");//以空格或'-'或'—'分割
String sort = split[0];
String number = split[1];
String year = split[2];
QueryWrapper<SarStandardsInfo> infoWrapper = new QueryWrapper<>();
infoWrapper.select("ID")
.eq("STAND_SORT",sort)
.eq("STAND_NUMBER",number)
.eq("STAND_YEAR",year);
.eq("STAND_SORT", sort)
.eq("STAND_NUMBER", number)
.eq("STAND_YEAR", year);
List<Map<String, Object>> idMaps = sarStandardsInfoDao.selectMaps(infoWrapper);
String standId = idMaps.get(0).get("ID").toString();
//如果代替标准id已存在则映射为2不存在则添加并映射为1
if (replaceIdCountMap.containsKey(standId)) {
replaceIdCountMap.replace(standId,2);
}else {
replaceIdCountMap.put(standId, 1);
if (idMaps.size() > 0) {
String standId = idMaps.get(0).get("ID").toString();
//如果代替标准id已存在则映射为2不存在则添加并映射为1
if (replaceIdCountMap.containsKey(standId)) {
replaceIdCountMap.replace(standId, 2);
} else {
replaceIdCountMap.put(standId, 1);
}
}
}
}
}
});
@@ -0,0 +1,34 @@
package com.adc.da.scheduled;
import com.adc.da.slrs.DataSync.DataSyncController;
import com.adc.da.slrs.DataSync.service.IDataSyncService;
import com.sun.org.apache.bcel.internal.generic.NEW;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
* 定时同步用户和组织机构信息
*/
@EnableScheduling
@Component
@Slf4j
public class ScheduledSync {
@Autowired
private IDataSyncService iDataSyncService;
// @Scheduled(cron = "0 */40 * * * ?") //40分钟执行同步一次
// @Scheduled(cron="*/5 * * * * ?")
@Async
public void syncSchedulingTasks() throws Exception {
iDataSyncService.orgDataSync(); //时间短
iDataSyncService.dataSync(); //时间长
}
}
@@ -0,0 +1,58 @@
package com.adc.da.slrs.DataSync;
import com.adc.da.slrs.DataSync.service.IDataSyncService;
import com.adc.da.slrs.sarInstitution.entity.TsInstitution;
import com.adc.da.slrs.sarInstitution.service.ITsInstitutionService;
import com.adc.da.slrs.sarInstitution.service.impl.TsInstitutionServiceImpl;
import com.adc.da.slrs.sarPosition.entity.TsPosition;
import com.adc.da.slrs.sarPosition.service.ITsPositionService;
import com.adc.da.slrs.sarPosition.service.impl.TsPositionServiceImpl;
import com.adc.da.slrs.sarUser.entity.TsUser;
import com.adc.da.slrs.sarUser.service.ITsUserService;
import com.adc.da.slrs.sarUser.service.impl.TsUserServiceImpl;
import com.adc.da.sync.service.SyncUserService;
import com.adc.da.sys.dao.OrgEODao;
import com.adc.da.sys.entity.OrgEO;
import com.adc.da.sys.entity.UserOrgEO;
import com.adc.da.sys.service.IOrgEOService;
import com.adc.da.sys.service.impl.OrgEOServiceImpl;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.sql.Timestamp;
import java.util.*;
@RestController
@Api(description = "|SarStandPutTime|")
@RequestMapping("/${restPath}/DataSync")
public class DataSyncController {
@Autowired
private IDataSyncService iDataSyncService;
@ApiOperation("同步用户数据")
@PostMapping("/importUserData")
public String importUserData() throws Exception {
return iDataSyncService.dataSync();
}
@ApiOperation("同步组织机构")
@PostMapping("/importOrgData")
public String importOrgData() throws Exception {
return iDataSyncService.orgDataSync();
}
}
@@ -0,0 +1,8 @@
package com.adc.da.slrs.DataSync.service;
public interface IDataSyncService {
public String dataSync() throws Exception;
public String orgDataSync() throws Exception;
}
@@ -0,0 +1,173 @@
package com.adc.da.slrs.DataSync.service.impl;
import com.adc.da.slrs.DataSync.service.IDataSyncService;
import com.adc.da.slrs.sarInstitution.entity.TsInstitution;
import com.adc.da.slrs.sarInstitution.service.ITsInstitutionService;
import com.adc.da.slrs.sarPosition.entity.TsPosition;
import com.adc.da.slrs.sarPosition.service.ITsPositionService;
import com.adc.da.slrs.sarUser.entity.TsUser;
import com.adc.da.slrs.sarUser.service.ITsUserService;
import com.adc.da.sync.service.SyncUserService;
import com.adc.da.sys.entity.UserOrgEO;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.sql.Timestamp;
import java.util.*;
@Service
public class DataSyncServiceImpl implements IDataSyncService {
@Autowired
ITsPositionService tsPositionService;
@Autowired
ITsUserService tsUserService;
@Autowired
ITsInstitutionService tsInstitutionService;
@Override
public String dataSync() throws Exception {
SyncUserService syncUserService = new SyncUserService();
List<String> res = syncUserService.syncFotonUser();
//存放岗位信息
Map<String, String> positionMap = new HashMap<>();
Map<String, String> useDistinct = new HashMap<>();
TsPosition position = new TsPosition();
position.setCurrent(1);
position.setPageSize(100000);
IPage<TsPosition> iPage = tsPositionService.getPosition(position);
List<TsPosition> positions=iPage.getRecords();
if (!positions.isEmpty()) {
positions.forEach(tsPosition -> {
positionMap.put(tsPosition.getName(), tsPosition.getId());
});
}
/**
* 得到数据时,删除系统表中所有用户信息
*/
if (res.size()>0){
tsUserService.deleteUser();
}
for (String s : res) {
//获取到所有用户数据
List<TsUser> tsUsers = new ArrayList<>();
JSONArray jsonArray = JSONArray.parseArray(JSONObject.parseObject(s.toString()).getString("results"));
jsonArray.forEach(object -> {
JSONObject jsonObject = JSONObject.parseObject(object.toString());
//先获取岗位以及岗位id
TsUser tsUser = new TsUser();
UserOrgEO userOrgEO = new UserOrgEO();
//设置岗位
if (null != jsonObject.getString("title")) {
//通过岗位名称查询系统表中是否有岗位,有则设定用户的岗位为系统中的岗位,否则新增
if (null == positionMap.get(jsonObject.getString("title"))) {
TsPosition tsPosition = new TsPosition();
tsPosition.setId(String.valueOf(UUID.randomUUID()));
tsPosition.setName(jsonObject.getString("title"));
tsPositionService.addPosition(tsPosition);
//放入岗位的map集合中
positionMap.put(tsPosition.getName(), tsPosition.getId());
//放入类中
tsUser.setPositionName(tsPosition.getName());
tsUser.setPositionId(tsPosition.getId());
} else {
tsUser.setPositionName(jsonObject.getString("title").trim());
tsUser.setPositionId(positionMap.get(jsonObject.getString("title").trim()));
}
}
//设置其他数据
Timestamp createTime = new Timestamp(new Date().getTime());
tsUser.setState(jsonObject.getString("userStatus"));
tsUser.setUname(null!=jsonObject.getString("name")?jsonObject.getString("name"):"");
tsUser.setValidFlag("0");
tsUser.setDisableFlag("0");
tsUser.setCreationTime(createTime);
tsUser.setUserId(jsonObject.getString("userid"));
tsUser.setAccount(jsonObject.getString("userid"));
tsUser.setInstitutionId(null!=jsonObject.getString("orgNumber")?jsonObject.getString("orgNumber"):"" );
tsUser.setInstitutionName(null!=jsonObject.getString("orgName")?jsonObject.getString("orgName"):"" );
if (null == useDistinct.get(jsonObject.getString("userid"))) {
tsUsers.add(tsUser);
}
// //测试数据删除
// if (! "anbin".equals(jsonObject.getString("userid"))){
//
// //测试数据修改
// if ("anbing".equals(jsonObject.getString("userid"))){
// tsUser.setUname("DDDDDD");
// tsUsers.add(tsUser);
// } else if (null == useDistinct.get(jsonObject.getString("userid"))) {
// tsUsers.add(tsUser);
//
// }
// }
useDistinct.put(tsUser.getUserId(),tsUser.getUserId());
});
tsUserService.saveBatch(tsUsers);
}
//测试数据添加
// TsUser addUser = new TsUser();
// addUser.setState("FFFFFFF");
// addUser.setUname("zhaokaiyao");
// addUser.setValidFlag("0");
// addUser.setDisableFlag("0");
// addUser.setCreationTime(new Timestamp(new Date().getTime()));
// addUser.setUserId("FFFFFFF");
// addUser.setAccount("zhaokaiyao");
// addUser.setInstitutionId("10022745");
// addUser.setInstitutionName("福田营销其他");
//
// List<TsUser> addUserList = Arrays.asList(addUser);
// tsUserService.saveBatch(addUserList);
return "1";
}
public String orgDataSync() throws Exception {
SyncUserService syncUserService = new SyncUserService();
List<String> res = syncUserService.syncFotonOrg();
//获取到所有用户数据
List<String> strings=new ArrayList<>();
tsInstitutionService.clearData();
for (String s : res) {
JSONArray jsonArray = JSONArray.parseArray(JSONObject.parseObject(s.toString()).getString("results"));
jsonArray.forEach(object -> {
JSONObject jsonObject = JSONObject.parseObject(object.toString());
strings.add(jsonObject.getString("parentOrgNumber"));
});
}
for (String s : res) {
List<TsInstitution> tsInstitutions = new ArrayList<>();
JSONArray jsonArray = JSONArray.parseArray(JSONObject.parseObject(s.toString()).getString("results"));
jsonArray.forEach(object -> {
JSONObject jsonObject = JSONObject.parseObject(object.toString());
TsInstitution tsInstitution=new TsInstitution();
tsInstitution.setId(jsonObject.getString("orgNumber"));
tsInstitution.setName(jsonObject.getString("orgName"));
tsInstitution.setHasChild(strings.contains(jsonObject.getString("orgNumber"))?"1":"0");
tsInstitution.setParentId(jsonObject.getString("parentOrgNumber"));
//部门为"null"的数据不保存
if (!"null".equals(jsonObject.getString("orgName"))){
tsInstitutions.add(tsInstitution);
}
});
tsInstitutionService.saveBatch(tsInstitutions);
}
return "1";
}
}
@@ -0,0 +1,80 @@
package com.adc.da.slrs.ImportExcelDatas.comment;
import com.adc.da.slrs.ImportExcelDatas.entity.ImportDto;
import com.adc.da.utils.util.BussStandExportUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.util.List;
@Component
public class ExclErrorOut {
private static final Logger logger = LoggerFactory.getLogger(BussStandExportUtil.class);
public static Workbook exportDatas (List<ImportDto> datas,String header) {
Workbook workbook = new XSSFWorkbook();
try {
//创建工作表对象
Sheet sheet = workbook.createSheet();
// 创建头部
createHeader(workbook,sheet,header);
// 创建数据
createDatas(workbook,sheet,datas);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return workbook;
}
public static void createHeader(Workbook workbook, Sheet sheet, String header){
CellStyle cellStyle = workbook.createCellStyle();//初始化单元格格式对象
cellStyle.setAlignment(HorizontalAlignment.CENTER);
Row rowHeader = sheet.createRow(0);//开始创建标题行
if (StringUtils.isNotBlank(header)) {
String[] headerArr = header.split(",");
for (int i=0;i < headerArr.length; i++) {
rowHeader.createCell(i).setCellValue(headerArr[i]);
// rowHeader.createCell(i).setCellStyle(cellStyle);
}
}
}
public static void createDatas(Workbook workbook,Sheet sheet,List<ImportDto> datas) throws Exception{
CellStyle cellStyle = workbook.createCellStyle();//初始化单元格格式对象
cellStyle.setAlignment(HorizontalAlignment.CENTER);
if (datas != null && !datas.isEmpty()) {
for (int i=0;i < datas.size(); i++) {
ImportDto importDto = datas.get(i);
Row row = sheet.createRow(i+1);
int sheetNum = 0;
Class cls = importDto.getClass();
Field[] fields = cls.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
if (field.get(importDto)!=null){
String value = field.get(importDto).toString();
row.createCell(sheetNum).setCellValue(value);
}else {
row.createCell(sheetNum).setCellValue("");
}
sheetNum++;
}
}
}
}
}
@@ -0,0 +1,36 @@
package com.adc.da.slrs.ImportExcelDatas.comment;
import com.adc.da.slrs.ImportExcelDatas.entity.ImportDto;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@Component
public class ExclExport extends ExclErrorOut {
/**
* 导出多个sheet页的excl
*/
public Workbook exportData(Map<String, List<ImportDto>> dataMap, String header) {
Workbook workbook=new XSSFWorkbook();
try {
for (Map.Entry<String, List<ImportDto>> entry : dataMap.entrySet()) {
List<ImportDto> datas = entry.getValue();
Sheet sheet = workbook.createSheet(entry.getKey());
super.createHeader(workbook,sheet,header);
super.createDatas(workbook,sheet,datas);
}
} catch (Exception e) {
e.printStackTrace();
}
return workbook;
}
}
@@ -1,15 +1,23 @@
package com.adc.da.slrs.ImportExcelDatas.controller;
import com.adc.da.base.web.BaseController;
import com.adc.da.common.ReadExcel;
import com.adc.da.http.ResponseMessage;
import com.adc.da.slrs.ImportExcelDatas.comment.ExclErrorOut;
import com.adc.da.slrs.ImportExcelDatas.entity.ImportDto;
import com.adc.da.slrs.ImportExcelDatas.service.ImportExcelService;
import com.adc.da.slrs.ImportExcelDatas.service.impl.ImportExcelServiceImpl;
import com.adc.da.slrs.sarBussionessStand.entity.SarBussionessStand;
import com.adc.da.slrs.sarPersonalCenter.entity.SarUserStar;
import com.adc.da.slrs.sarPersonalCenter.entity.SarUserStarEO;
import com.adc.da.util.exception.AdcDaBaseException;
import com.adc.da.util.utils.IOUtils;
import com.adc.da.util.utils.StringUtils;
import com.adc.da.utils.util.BussStandExportUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@@ -17,6 +25,10 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;
import java.util.Map;
@@ -28,14 +40,43 @@ public class ImportExcelController extends BaseController<ImportDto> {
@Autowired
private ImportExcelService importExcelService;
@Autowired
private ExclErrorOut exclErrorOut;
@ApiOperation("批量删除用户收藏")
@PostMapping("/import")
public ResponseMessage<Boolean> deleteList(MultipartFile file,MultipartFile file2) {
public void deleteList(MultipartFile file, MultipartFile file2, HttpServletResponse response, HttpServletRequest request) throws IOException {
Map<String, List<ImportDto>> mapMap=importExcelService.getExcelData(file,file2);
ResponseMessage responseMessage=new ResponseMessage();
responseMessage.setMessage(mapMap.toString());
responseMessage.isOk();
return responseMessage;
List<ImportDto> errorList = importExcelService.storageExclData(mapMap);
// List<ImportDto> guonei= mapMap.get("GNBZ");
// List<ImportDto> haiwai = mapMap.get("HWBZ");
// List<ImportDto> qibiao = mapMap.get("QYBZ");
OutputStream os = null;
Workbook workbook = null;
try {
String exportName="错误表格";
response.setHeader("Content-Disposition",
"attachment; filename=" + ReadExcel.encodeFileName(exportName+".xlsx",request));
response.setContentType("application/force-download");
//导出数据
String headStr="标准号,标准名称,英文名称,发布时间,实施时间,标准状态,代替标准号,附件路径,错误原因";
workbook = exclErrorOut.exportDatas(errorList,headStr);
os = response.getOutputStream();
workbook.write(os);
os.flush();
} catch (IOException e) {
throw new AdcDaBaseException("下载文件失败,请重试");
} finally {
IOUtils.closeQuietly(os);
if (workbook != null) {
workbook.close();
}
}
// return responseMessage;
}
}
@@ -22,4 +22,7 @@ public class ImportDto extends BaseEntity {
private String replaceId;
// 附件路径
private String path;
// 错误原因
private String errorStr;
}
@@ -11,4 +11,7 @@ public interface ImportExcelService extends IService<ImportDto> {
Map<String, List<ImportDto>> getExcelData(MultipartFile file,MultipartFile file2);
public List<ImportDto> storageExclData(Map<String, List<ImportDto>> importListMap);
}
@@ -1,39 +1,77 @@
package com.adc.da.slrs.ImportExcelDatas.service.impl;
import com.adc.da.att.service.IAttFileEOService;
import com.adc.da.att.vo.AttFileVo;
import com.adc.da.http.Result;
import com.adc.da.slrs.ImportExcelDatas.dao.ImportExcelDao;
import com.adc.da.slrs.ImportExcelDatas.entity.ImportDto;
import com.adc.da.slrs.ImportExcelDatas.service.ImportExcelService;
import com.adc.da.slrs.sarBussionessStand.entity.SarBussionessStand;
import com.adc.da.slrs.sarBussionessStand.service.ISarBussionessStandService;
import com.adc.da.slrs.sarStandardsInfo.entity.SarStandardsInfo;
import com.adc.da.slrs.sarStandardsInfo.service.ISarStandardsInfoService;
import com.adc.da.sys.dao.DicTypeEODao;
import com.adc.da.sys.entity.DicTypeEO;
import com.adc.da.sys.entity.DictionaryEO;
import com.adc.da.sys.service.impl.DicTypeEOServiceImpl;
import com.adc.da.util.UUIDUtils;
import com.adc.da.utils.util.InitStandAttrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.gson.Gson;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.InputStream;
import java.util.*;
import java.util.regex.Pattern;
@Service
public class ImportExcelServiceImpl extends ServiceImpl<ImportExcelDao, ImportDto> implements ImportExcelService {
@Autowired
private IAttFileEOService attFileEOService;
// @Autowired
// private CreateStandMQService createStandMQService;
//
// @Autowired
// private SarStandardsInfoServiceImpl sarStandardsInfoService;
//
//
//
// @Autowired
// private SarBussionessStandServiceImpl sarBussionessStandService;
private final static String GN = "GB,GB/T,QC/T,GJB,JB,JT,HG,YV,SY,SH,GA,HJ,QB,JG,NB,JC,YS/T,FZ/T,TB/T,JJG,SJ/T,T/TBPS" +
",NB/T,CJ/T,YS/T,SJ/T,BB/T,SN/T,SB/T,MH/T,DB11,SZDB/Z,HKG,T/ZSA,CSAE,T/CAS,T/CADA,T/CHTS,T/ITS,T/BJQC";
private final static String QB = "Q/QCBFC,Q/FT,Q/FL,Q/QCFLC,Q/BQB,Q/SGT," +
"Q-AMSN,QB-NE,Q-IOUM,Q房/AYJ,KNT";
private final static String DATE = "-2008,—2008,-2009,—2009,-2010,—2010,-2011,—2011,-2012,—2012,-2013,—2013," +
"- 2008,— 2008,- 2009,— 2009,- 2010,— 2010,- 2011,— 2011,- 2012,— 2012,- 2013,— 2013" +
",-2014,—2014,-2015,—2015,-2016,—2016,-2017,—2017,-2018,—2018,-2019,—2019,-2020,—2020,-2021,—2021" +
",- 2014,— 2014,- 2015,— 2015,- 2016,— 2016,- 2017,— 2017,- 2018,— 2018,- 2019,— 2019,- 2020,— 2020,- 2021,— 2021";
// file 为主 file2 为附件
@Override
public Map<String, List<ImportDto>> getExcelData(MultipartFile file, MultipartFile file2) {
List<String> dates = new ArrayList<>();
for (int i = 1669; i < 2023; i++) {
dates.add("-" + i);
dates.add("" + i);
dates.add("- " + i);
dates.add("" + i);
}
if (file == null || file.getSize() == 0) {
log.error("文件上传错误,重新上传");
}
@@ -82,10 +120,10 @@ public class ImportExcelServiceImpl extends ServiceImpl<ImportExcelDao, ImportDt
datas.forEach(items -> {
//判断是否是正确的数据
String[] as = items.split(",");
if (!inDate(as[0])) {
if (!inDate(as[0], dates)) {
ImportDto importDto = getImportDto(as);
error.add(importDto);
middle.put(as[0].trim(), "error-"+error.size());
middle.put(as[0].trim(), "error-" + error.size());
} else {
//数据二次拆解 针对标准进行拆解
String[] step2 = as[0].trim().split(" ");
@@ -93,15 +131,15 @@ public class ImportExcelServiceImpl extends ServiceImpl<ImportExcelDao, ImportDt
if (isCheck(GNS, step2[0].trim())) {
ImportDto importDto = getImportDto(as);
InCountry.add(importDto);
middle.put(as[0].trim(), "GNBZ-"+InCountry.size());
middle.put(as[0].trim(), "GNBZ-" + InCountry.size());
} else if (isCheck(QBS, step2[0].trim())) {
ImportDto importDto = getImportDto(as);
QiBiao.add(importDto);
middle.put(as[0].trim(), "QYBZ-"+QiBiao.size());
middle.put(as[0].trim(), "QYBZ-" + QiBiao.size());
} else {
ImportDto importDto = getImportDto(as);
OutCountry.add(importDto);
middle.put(as[0].trim(), "HWBZ-"+OutCountry.size());
middle.put(as[0].trim(), "HWBZ-" + OutCountry.size());
}
}
});
@@ -110,23 +148,22 @@ public class ImportExcelServiceImpl extends ServiceImpl<ImportExcelDao, ImportDt
res.put("QYBZ", QiBiao);
res.put("HWBZ", OutCountry);
fujian.forEach(items2 ->{
String[] fj=items2.split(",");
if (fj.length>2) {
fujian.forEach(items2 -> {
String[] fj = items2.split(",");
if (fj.length > 2) {
if (null != middle.get(null != fj[2] ? fj[2].trim() : "")) {
//对应数据位置
String[] location = middle.get(fj[2].trim()).split("-");
res.get(location[0]).get(Integer.parseInt(location[1])-1).setPath(fj[3]);
res.get(location[0]).get(Integer.parseInt(location[1]) - 1).setPath(fj[3]);
}
}
} );
});
return res;
}
private boolean inDate(String as) {
List<String> dates = new ArrayList<>(Arrays.asList(DATE.split(",")));
private boolean inDate(String as, List<String> dates) {
if (null != as && !"".equals(as)) {
for (String s : dates) {
if (s.equals(as.trim())) {
@@ -227,4 +264,442 @@ public class ImportExcelServiceImpl extends ServiceImpl<ImportExcelDao, ImportDt
}
private List<ImportDto> error = new ArrayList<>();
private List<ImportDto> fileError = new ArrayList<>();
@Autowired
private ISarStandardsInfoService sarStandardsInfoService;
@Autowired
private DicTypeEOServiceImpl dicTypeEOService;
@Autowired
private ISarBussionessStandService sarBussionessStandService;
@Override
public List<ImportDto> storageExclData(Map<String, List<ImportDto>> importListMap) {
error = importListMap.get("error");
/**
* 初始化国内外标准属性字段
*/
List<String> listStandField = InitStandAttrUtil.queryFieldList;
Map<String,String> standAttrMap = new TreeMap<>();
listStandField.forEach(item ->{
standAttrMap.put(item,"");
});
/**
* 海外标准
*/
importListMap.get("HWBZ").forEach(item -> {
String standID = UUIDUtils.randomUUID20();
//使用初始化的属性字段映射 获得key值,value为""
Map<String, String> mapField = standAttrMap;
SarStandardsInfo ForeignEO = parseImportDtoToStandardsInfo(item,mapField, standID);
if (ForeignEO != null) {
ForeignEO.setValidFlag("0");
ForeignEO.setStandType("FOREIGN");
QueryWrapper<SarStandardsInfo> standSaveWrapper = new QueryWrapper<>();
standSaveWrapper
.eq("STAND_SORT", ForeignEO.getStandSort())
.eq("STAND_NUMBER", ForeignEO.getStandNumber())
.eq("STAND_YEAR", ForeignEO.getStandYear());
SarStandardsInfo one = sarStandardsInfoService.getOne(standSaveWrapper);
if (one != null) {
ForeignEO.setId(one.getId());
try {
sarStandardsInfoService.updateSarStandardsInfo(ForeignEO);
} catch (Exception e) {
item.setErrorStr("标准更新失败");
error.add(item);
e.printStackTrace();
}
} else {
try {
sarStandardsInfoService.createSarStandardsInfo(ForeignEO);
} catch (Exception e) {
item.setErrorStr("标准新增失败");
error.add(item);
e.printStackTrace();
}
}
} else {
item.setErrorStr("标准号无法解析");
error.add(item);
}
});
/**
* 国内标准
*/
importListMap.get("GNBZ").forEach(item -> {
String standID = UUIDUtils.randomUUID20();
//使用初始化的属性字段映射 获得key值,value为""
Map<String, String> mapStandField = standAttrMap;
SarStandardsInfo InlandEO = parseImportDtoToStandardsInfo(item, mapStandField,standID);
if (InlandEO != null) {
InlandEO.setValidFlag("0");
InlandEO.setStandType("INLAND");
QueryWrapper<SarStandardsInfo> standSaveWrapper = new QueryWrapper<>();
standSaveWrapper
.eq("STAND_SORT", InlandEO.getStandSort())
.eq("STAND_NUMBER", InlandEO.getStandNumber())
.eq("STAND_YEAR", InlandEO.getStandYear());
SarStandardsInfo one = sarStandardsInfoService.getOne(standSaveWrapper);
if (one != null) {
InlandEO.setId(one.getId());
try {
sarStandardsInfoService.updateSarStandardsInfo(InlandEO);
} catch (Exception e) {
item.setErrorStr("国内标准更新失败");
error.add(item);
e.printStackTrace();
}
} else {
try {
sarStandardsInfoService.createSarStandardsInfo(InlandEO);
} catch (Exception e) {
item.setErrorStr("国内标准新增失败");
error.add(item);
e.printStackTrace();
}
}
} else {
item.setErrorStr("标准号无法解析");
error.add(item);
importListMap.replace("error", error);
}
});
/**
* 企业标准
*/
/**
* 初始化企业标准属性字段
*/
List<String> listStandBussField = InitStandAttrUtil.queryFieldListBuss;
Map<String,String> bussAttrMap = new TreeMap<>();
listStandBussField.forEach(item->{
bussAttrMap.put(item,"");
});
importListMap.get("QYBZ").forEach(item -> {
String standId = UUIDUtils.randomUUID20();
SarBussionessStand BussEO = parseImportDtoToSarBussionessStand(item, bussAttrMap,standId);
if (BussEO != null) {
try {
QueryWrapper<SarBussionessStand> saveWrapper = new QueryWrapper<>();
saveWrapper.eq("STAND_CODE", item.getStandId());
SarBussionessStand one = sarBussionessStandService.getOne(saveWrapper);
if (one != null) {
BussEO.setId(one.getId());
sarBussionessStandService.updateSarBussionessStand(BussEO);
} else {
sarBussionessStandService.createSarBussionessStand(BussEO);
}
} catch (Exception e) {
item.setErrorStr("数据格式错误");
error.add(item);
e.printStackTrace();
}
}
});
error.addAll(fileError);
return error;
}
/**
* 整理为标准信息实体
* @param importDto
* @param fieldMap 属性字段
* @param standId
* @return
*/
public SarStandardsInfo parseImportDtoToStandardsInfo(ImportDto importDto,Map<String,String> fieldMap, String standId) {
HashMap<String, String> analysis = analysisStandId(importDto);
if (analysis == null) {
return null;
}
SarStandardsInfo sarStandardsInfoEO = new SarStandardsInfo();
sarStandardsInfoEO.setId(standId);
sarStandardsInfoEO.setStandSort(analysis.get("sort"));
sarStandardsInfoEO.setStandNumber(analysis.get("number"));
sarStandardsInfoEO.setStandYear(analysis.get("year"));
sarStandardsInfoEO.setStandName(importDto.getStandName());
sarStandardsInfoEO.setStandEnName(importDto.getStandNameEN());
/**
* 截取发布日期 年月日
*/
String issueDate = importDto.getPublishTime().substring(0, 19);
sarStandardsInfoEO.setIssueTime(issueDate);//标准发布日期
String standStatus = importDto.getStandStatus();
if ("有效".equals(standStatus)) {
sarStandardsInfoEO.setTextStatus("vsaga7nwub");//现行有效
}
/**
* 标准属性字段
*/
fieldMap.put("DTBJH", importDto.getReplaceId());
fieldMap.put("SSRQ", importDto.getImplementedTime().substring(0, 19));
/**
* 文件
*/
if (importDto.getPath() != null) {
String path[] = importDto.getPath().split("/");
String realPath = "";
for (int i = 4; i < path.length; i++) {
realPath = realPath + "/" + path[i];
}
try {
// File file = new File("C:\\Users\\22501\\Desktop\\foton\\2021\\" + realPath);
// File file = new File(importPath + realPath);
File file = new File("/home/file/2021/" + realPath);
if (file.exists()) {
AttFileVo fileInfo = attFileEOService.saveFileInfo(file);
if (importDto.getImplementedTime() != null) {
fieldMap.put("FBGJBD", fileInfo.getAttId());
} else {
fieldMap.put("GLWJ", fileInfo.getAttId());
}
} else {
importDto.setErrorStr("文件不存在");
fileError.add(importDto);
}
} catch (Exception e) {
importDto.setErrorStr("文件打开失败");
fileError.add(importDto);
e.printStackTrace();
}
}
// attrInfoMap.put("")
Gson gson = new Gson();
String attrInfoJson = gson.toJson(fieldMap);
sarStandardsInfoEO.setSarStandAttrEOStr(attrInfoJson);//新增修改时属性表信息
return sarStandardsInfoEO;
}
/**
* 整理为企业标准实体
* @param importDto
* @param standId
* @return
*/
public SarBussionessStand parseImportDtoToSarBussionessStand(ImportDto importDto,Map<String,String> fieldMap, String standId) {
HashMap<String, String> analysis = analysisStandId(importDto);
if (analysis == null) {
return null;
} else {
SarBussionessStand sarBussionessStand = new SarBussionessStand();
sarBussionessStand.setId(standId);
sarBussionessStand.setStandSort(analysis.get("sort"));
sarBussionessStand.setStandYear(analysis.get("year"));
sarBussionessStand.setStandCode(importDto.getStandId());
sarBussionessStand.setStandName(importDto.getStandName());
sarBussionessStand.setStandEnName(importDto.getStandNameEN());
sarBussionessStand.setIssueTime(importDto.getPublishTime());
sarBussionessStand.setPutTime(importDto.getImplementedTime());
sarBussionessStand.setReplacedStandNum(importDto.getReplaceId());
sarBussionessStand.setValidFlag(0);
if ("有效".equals(importDto.getStandStatus())) {
sarBussionessStand.setTextStatusBuss("vsaga7nwub");
}
/**
* 企业标准属性字段
*/
if (importDto.getPath() != null) {
String path[] = importDto.getPath().split("/");
String realPath = "";
for (int i = 4; i < path.length; i++) {
realPath = realPath + "/" + path[i];
}
try {
// File file = new File("C:\\Users\\22501\\Desktop\\foton\\2021\\" + realPath);
// File file = new File(importPath + realPath);
File file = new File("/home/file/2021/" + realPath);
if (file.exists()) {
AttFileVo fileInfo = attFileEOService.saveFileInfo(file);
if (importDto.getImplementedTime()!=null && importDto.getImplementedTime()!=""){
fieldMap.put("FBGBUSS",fileInfo.getAttId());
}else {
fieldMap.put("GLWJBUSS",fileInfo.getAttId());
}
} else {
importDto.setErrorStr("文件不存在");
fileError.add(importDto);
}
} catch (Exception e) {
importDto.setErrorStr("路径错误!");
fileError.add(importDto);
e.printStackTrace();
}
}
String attrInfoJson = new Gson().toJson(fieldMap);
sarBussionessStand.setSarStandAttrEOStr(attrInfoJson);//新增修改时属性表信息
return sarBussionessStand;
}
}
/**
* 解析标准号,标准类别不存在则新增
* @param importDto
* @return
*/
public HashMap<String, String> analysisStandId(ImportDto importDto) {
HashMap<String, String> result = new HashMap<>();
if (importDto.getStandId() == null) {
importDto.setErrorStr("标准号为空");
error.add(importDto);
return null;
} else {
String standId = importDto.getStandId();
//格式 非空格字符+空格+非空格字符+‘-’或‘—’或空格+年份 如Q/FT F003—2001
Pattern pattern = Pattern.compile("^\\S*\\s\\S*[\\u2014\\u002d\\s]\\d{4}$");
if (!pattern.matcher(standId).matches()) {
importDto.setErrorStr("标准号无法解析");
error.add(importDto);
return null;
}
String sort = "";
String number = "";
String year = "";
String[] split = importDto.getStandId().split("[\\u2014\\u002d\\s]");//以空格或'-'或'—'分割
// 多种格式(╯‵□′)╯︵┻━┻ Q-FL T015-2021 Q/ FL T015-2021 Q/FL T015-2021
int length = split.length;
number = split[length - 2];
year = split[length - 1];
for (int i = 0; i < length - 2; i++) {
sort += split[i];
}
result.put("sort", sort);
result.put("number", number);
result.put("year", year);
//标准类别不存在,新增标准类别
List<DicTypeEO> isExist = dicTypeEOService.getTypeIdByDicIdAndTypeName("JKSADFH564S", null, sort, null);
if (isExist == null || isExist.isEmpty() || isExist.size()==0){
DicTypeEO dicTypeVO = new DicTypeEO();
dicTypeVO.setId(null);
dicTypeVO.setDicId("JKSADFH564S");
dicTypeVO.setDicTypeCode(sort);
dicTypeVO.setDicTypeName(sort);
dicTypeVO.setShowIndex(1);
Integer dicTypeEO = dicTypeEOService.saveDictype(dicTypeVO);
if (dicTypeEO>0){
importDto.setErrorStr("标准类别不存在,已新增");
}else {
importDto.setErrorStr("标准类别不存在,新增失败");
}
error.add(importDto);
}
return result;
}
}
}
@@ -14,7 +14,7 @@ import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
*
*
* </p>
*
* @author super_liu
@@ -52,6 +52,9 @@ public class SarBussStandAttrInfo extends BaseEntity {
@TableField("MODIFY_TIME")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
private Date modifyTime;
@TableField(exist = false)
private String glwj;
//
// @TableField("SVPPS")
// private String svpps;
@@ -24,6 +24,8 @@ public interface ISarBussionessStandService extends IService<SarBussionessStand>
SarBussionessStand updateSarBussionessStand(SarBussionessStand sarBussionessStandEO) throws Exception;
ResponseMessage<SarBussionessStand> createSarBussionessStand(SarBussionessStand sarBussionessStandEO) throws Exception;
List<SarBussionessStand> selectStandardsByStandNumber(String replaceStandNum);
SarBussionessStand selectStandardsInfoByKey(String id) throws Exception;
@@ -54,9 +54,12 @@ public interface TsInstitutionDao extends BaseMapper<TsInstitution> {
* 查询根机构
* @return List<TsInstitution>
*/
@Select("select * from ts_institution where parent_id not in (select id from ts_institution)")
@Select("select * from ts_institution where parent_id not in (select id from ts_institution) order by name")
List<TsInstitution> selectRoot();
@Select("select * from ts_institution order by rand() limit 1")
TsInstitution selectRand();
int clearData();
}
@@ -42,4 +42,6 @@ public interface ITsInstitutionService extends IService<TsInstitution> {
* @return
*/
public List<TsInstitution> getFirst();
int clearData();
}
@@ -213,4 +213,9 @@ public class TsInstitutionServiceImpl extends ServiceImpl<TsInstitutionDao, TsIn
return tsInstitutions;
}
@Override
public int clearData() {
return tsInstitutionDao.clearData();
}
}
@@ -208,8 +208,12 @@ public class SarLawsAttrDetailedListController extends BaseController<SarLawsAtt
}
}
}
String completedString = builder.delete(builder.length()-1,builder.length()).toString();
list1.setZRBM(completedString);
try {
String completedString = builder.delete(builder.length()-1,builder.length()).toString();
list1.setZRBM(completedString);
}catch (Exception e){
System.out.println(e);
}
}else {
for (Map<String, String> map1 : zrbn) {
if (map1.get("value").equals(list1.getZRBM())) {
@@ -48,66 +48,66 @@ public class LawsDto {
private String NYLX;
@ApiModelProperty(value = "标准年份")
@ExcelProperty(value = "标准年份", index = 5)
// @ExcelProperty(value = "标准年份", index = 5)
private String standYear;
@ApiModelProperty(value = "标准类别")
@ExcelProperty(value = "标准类别", index = 6)
// @ExcelProperty(value = "标准类别", index = 6)
private String standSortShow;
@ApiModelProperty(value = "标准发表日期")
@ExcelProperty(value = "标准发表日期", index = 7)
// @ExcelProperty(value = "标准发表日期", index = 7)
private String issueTime;
@ColumnWidth(16)
@ExcelProperty(value = "标准实施日期", index = 8)
@ExcelProperty(value = "标准实施日期", index = 5)
@ApiModelProperty(value = "标准实施日期")
@DateTimeFormat("yyyy年MM月dd日")
private String SSRQ;
@ColumnWidth(16)
@ExcelProperty(value = "新车型实施日期", index = 9)
@ExcelProperty(value = "新车型实施日期", index = 6)
@ApiModelProperty(value = "新车型实施日期")
@DateTimeFormat("yyyy年MM月dd日")
private String XCXSSRQGJ;
@ColumnWidth(16)
@ExcelProperty(value = "在产车实施日期", index = 10)
@ExcelProperty(value = "在产车实施日期", index = 7)
@ApiModelProperty(value = "在产车实施日期")
@DateTimeFormat("yyyy年MM月dd日")
private String ZCCSSRQGJ;
@ExcelProperty(value = "责任部门", index = 11)
@ExcelProperty(value = "责任部门", index = 8)
@ApiModelProperty(value = "责任部门")
private String ZRBM;
@ColumnWidth(14)
@ExcelProperty(value = "适用产品线", index = 12)
@ExcelProperty(value = "适用产品线", index = 9)
@ApiModelProperty(value = "适用产品线")
private String SYCPX;
@ColumnWidth(20)
@ExcelProperty(value = "乘用车VPPS编码", index = 13)
@ExcelProperty(value = "乘用车VPPS编码", index = 10)
@ApiModelProperty(value = "乘用车VPPS编码")
private String CYCVPPSBM;
@ColumnWidth(20)
@ExcelProperty(value = "乘用车vpps中文名称", index = 14)
@ExcelProperty(value = "乘用车vpps中文名称", index = 11)
@ApiModelProperty(value = "乘用车vpps中文名称")
private String CYCVPPSCN;
@ColumnWidth(20)
@ExcelProperty(value = "卡车VPPS编码", index = 15)
@ExcelProperty(value = "卡车VPPS编码", index = 12)
@ApiModelProperty(value = "卡车VPPS编码")
private String KCCVPPSBM;
@ColumnWidth(20)
@ExcelProperty(value = "卡车vpps中文名称", index = 16)
@ExcelProperty(value = "卡车vpps中文名称", index = 13)
@ApiModelProperty(value = "卡车vpps中文名称")
private String KCCVPPSCN;
@ApiModelProperty(value = "责任工程师")
@ExcelProperty(value = "责任工程师", index = 17)
// @ExcelProperty(value = "责任工程师", index = 17)
private String responsibleEngineer;
@ApiModelProperty(value = "1")
@@ -57,16 +57,19 @@ public class SarLawsAttrDetailedListServiceImpl extends ServiceImpl<SarLawsAttrD
QueryWrapper<SarLawsAttrDetailedList> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("stand_id",lawsDto.getId())
.eq("detailed_list_id",sarFindDto.getId());
List<SarLawsAttrDetailedList> sarLawsAttrDetailedLists = sarLawsAttrDetailedListDao.selectList(queryWrapper);
if (StringUtils.isNoneEmpty(sarLawsAttrDetailedLists.get(0).getSsrq())){
lawsDto.setSSRQ(sarLawsAttrDetailedLists.get(0).getSsrq());
}
if (StringUtils.isNoneEmpty(sarLawsAttrDetailedLists.get(0).getXcxssrq())){
lawsDto.setXCXSSRQGJ(sarLawsAttrDetailedLists.get(0).getXcxssrq());
}
if (StringUtils.isNoneEmpty(sarLawsAttrDetailedLists.get(0).getZccssrq())){
lawsDto.setZCCSSRQGJ(sarLawsAttrDetailedLists.get(0).getZccssrq());
}
/**
*2021/9/13 摒弃使用清单实施日期,改用标准实施日期
*/
// List<SarLawsAttrDetailedList> sarLawsAttrDetailedLists = sarLawsAttrDetailedListDao.selectList(queryWrapper);/
// if (StringUtils.isNoneEmpty(sarLawsAttrDetailedLists.get(0).getSsrq())){
// lawsDto.setSSRQ(sarLawsAttrDetailedLists.get(0).getSsrq());
// }
// if (StringUtils.isNoneEmpty(sarLawsAttrDetailedLists.get(0).getXcxssrq())){
// lawsDto.setXCXSSRQGJ(sarLawsAttrDetailedLists.get(0).getXcxssrq());
// }
// if (StringUtils.isNoneEmpty(sarLawsAttrDetailedLists.get(0).getZccssrq())){
// lawsDto.setZCCSSRQGJ(sarLawsAttrDetailedLists.get(0).getZccssrq());
// }
if ("INLAND".equals(lawsDto.getStandType()))lawsDto.setStandType("INLAND_STAND");
if ("FOREIGN".equals(lawsDto.getStandType()))lawsDto.setStandType("FOREIGN_STAND");
}
@@ -281,18 +284,25 @@ public class SarLawsAttrDetailedListServiceImpl extends ServiceImpl<SarLawsAttrD
xcx = mapList.get("新车型实施日期("+s.getCountry()+")");
zcc = mapList.get("在产车实施日期("+s.getCountry()+")");
}else {
dateTime(mapList,s);
}
dateTime(mapList, putTime, xcx, zcc, s);
}
return mapList;
}
private void dateTime(LinkedHashMap<String, List<String>> mapList, List<String> putTime, List<String> xcx, List<String> zcc, StandRegionalTimeDto s) {
putTime.add(new SimpleDateFormat("yyyy-MM-dd").format(s.getPutTime()));
xcx.add(new SimpleDateFormat("yyyy-MM-dd").format(s.getXcxssrq()));
zcc.add(new SimpleDateFormat("yyyy-MM-dd").format(s.getZccssrq()));
mapList.put("实施日期("+s.getCountry()+")",putTime);
mapList.put("新车型实施日期("+s.getCountry()+")",xcx);
mapList.put("在产车实施日期("+s.getCountry()+")",zcc);
private void dateTime(LinkedHashMap<String, List<String>> mapList, StandRegionalTimeDto s) {
String putTime = new SimpleDateFormat("yyyy-MM-dd").format(s.getPutTime());
String xcx = new SimpleDateFormat("yyyy-MM-dd").format(s.getXcxssrq());
String zcc = new SimpleDateFormat("yyyy-MM-dd").format(s.getZccssrq());
// putTime.add(new SimpleDateFormat("yyyy-MM-dd").format(s.getPutTime());
// xcx.add(new SimpleDateFormat("yyyy-MM-dd").format(s.getXcxssrq()));
// zcc.add(new SimpleDateFormat("yyyy-MM-dd").format(s.getZccssrq()));
mapList.put("实施日期("+s.getCountry()+")", Collections.singletonList(putTime));
mapList.put("新车型实施日期("+s.getCountry()+")", Collections.singletonList(xcx));
mapList.put("在产车实施日期("+s.getCountry()+")", Collections.singletonList(zcc));
}
}
@@ -599,6 +599,11 @@ public class SarLawsDetailedListServiceImpl extends ServiceImpl<SarLawsDetailedL
@Override
public void standardToLaws(String countryArea,TimeDto timeDto) {
if (countryArea==null){
countryArea="";
}
/**
* 加入对应"国家/地区"的清单列表
*/
@@ -3,14 +3,18 @@ package com.adc.da.slrs.sarModelTree.controller;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.Result;
import com.adc.da.slrs.sarModelTree.entity.ResponseResult;
import com.adc.da.slrs.sarModelTree.service.ISarModelTreeService;
import com.adc.da.slrs.sarModelTree.service.ISarModuleTreeService;
import com.adc.da.slrs.sarModelTree.service.impl.SarModuleTreeServiceImpl;
import com.adc.da.slrs.sarStandProjectLibrary.entity.Company;
import com.adc.da.slrs.sarStandProjectLibrary.entity.Head;
import com.adc.da.slrs.sarStandProjectLibrary.entity.ResponseDto;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.*;
import com.adc.da.slrs.sarModelTree.entity.SarModelTree;
import io.swagger.annotations.Api;
import org.springframework.web.bind.annotation.RestController;
import com.adc.da.base.web.BaseController;
import java.util.List;
@@ -31,10 +35,14 @@ public class SarModelTreeController extends BaseController<SarModelTree> {
@Autowired
private ISarModelTreeService iSarModelTreeService;
@Autowired
private ISarModuleTreeService iSarModuleTreeService;
@ApiOperation("查询父所有资源")
@GetMapping("/list")
public ResponseMessage<List<SarModelTree>> getAll(SarModelTree sarVppsTree){
List<SarModelTree> tsResources = iSarModelTreeService.getAll(sarVppsTree);
public ResponseMessage<List<SarModelTree>> getAll(){
List<SarModelTree> tsResources = iSarModelTreeService.getAll(null);
// List<SarModelTree> tsResources = iSarModuleTreeService.getAll(null);
return Result.success(tsResources);
}
@@ -46,4 +54,16 @@ public class SarModelTreeController extends BaseController<SarModelTree> {
List<SarModelTree> tsResources = iSarModelTreeService.recursionGetChildren(tree);
return Result.success(tsResources);
}
@ApiOperation("同步模块单元信息")
@PostMapping("/save")
public ResponseDto save(@RequestBody String json){
//todo 实现解析并存储的到数据库
Head head = iSarModuleTreeService.analysisJsonAndStorage(json);
ResponseDto responseDto = new ResponseDto(head);
return responseDto;
}
}
@@ -0,0 +1,8 @@
package com.adc.da.slrs.sarModelTree.dao;
import com.adc.da.slrs.sarModelTree.entity.SarModuleTree;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface SarModuleTreeDao extends BaseMapper<SarModuleTree> {
}
@@ -0,0 +1,12 @@
package com.adc.da.slrs.sarModelTree.entity;
/**
* 同步数据时使用的返回给其他系统的结果
*/
public class ResponseResult {
private String GUID; //序列号 业务主键
private String MESSAGE; //接口信息 失败时,详细的失败原因
private String STATUS; //接口状态 B(失败),S(成功)
}
@@ -0,0 +1,76 @@
package com.adc.da.slrs.sarModelTree.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.google.gson.annotations.SerializedName;
import lombok.Data;
@Data
@TableName("sar_module_tree")
public class SarModuleTree {
@SerializedName("GUID")
@TableId
private String guid;
@SerializedName("FTVSTYPE1")
@TableField("FTVSTYPE1")
private String ftvstype1;
@SerializedName("FTVSTYPE2")
@TableField("FTVSTYPE2")
private String ftvstype2;
@SerializedName("FTVSTYPE3")
@TableField("FTVSTYPE3")
private String ftvstype3;
@SerializedName("FTVSTYPE4")
@TableField("FTVSTYPE4")
private String ftvstype4;
@SerializedName("FTVSTYPE5")
@TableField("FTVSTYPE5")
private String ftvstype5;
@SerializedName("FTVSTYPE6")
@TableField("FTVSTYPE6")
private String ftvstype6;
@SerializedName("FTVSTYPE7")
@TableField("FTVSTYPE7")
private String ftvstype7;
@SerializedName("FTVSTYPE9")
@TableField("FTVSTYPE9")
private String ftvstype9;
@SerializedName("ACLUSERNAMES")
@TableField("ACLUSERNAMES")
private String aclusernames;
@SerializedName("CREATOR")
@TableField("CREATOR")
private String creator;
@SerializedName("SERIESID")
@TableField("SERIESID")
private String seriesid; //SF_ID
@SerializedName("RESERVED")
@TableField("RESERVED")
private String reserved; //SE_ID
@SerializedName("STARTED")
@TableField("STARTED")
private String started; //SU_ID
@SerializedName("CREATIONDATE")
@TableField("CREATIONDATE")
private String creationdate;
}
@@ -0,0 +1,16 @@
package com.adc.da.slrs.sarModelTree.service;
import com.adc.da.slrs.sarModelTree.entity.SarModelTree;
import com.adc.da.slrs.sarStandProjectLibrary.entity.Head;
import java.util.List;
public interface ISarModuleTreeService {
List<SarModelTree> getAll(SarModelTree sarModelTree);
List<SarModelTree> recursionGetChildren(SarModelTree parent);
public Head analysisJsonAndStorage(String json);
}
@@ -0,0 +1,97 @@
package com.adc.da.slrs.sarModelTree.service.impl;
import com.adc.da.slrs.sarModelTree.dao.SarModuleTreeDao;
import com.adc.da.slrs.sarModelTree.entity.SarModelTree;
import com.adc.da.slrs.sarModelTree.entity.SarModuleTree;
import com.adc.da.slrs.sarModelTree.service.ISarModuleTreeService;
import com.adc.da.slrs.sarStandProjectLibrary.entity.Head;
import com.adc.da.util.UUIDUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class SarModuleTreeServiceImpl extends ServiceImpl<SarModuleTreeDao, SarModuleTree> implements ISarModuleTreeService {
@Autowired()
private SarModuleTreeServiceImpl sarModuleTreeService;
@Override
public List<SarModelTree> getAll(SarModelTree sarModelTree) {
QueryWrapper<SarModuleTree> treeQueryWrapper = new QueryWrapper<>();
treeQueryWrapper.groupBy("FTVSTYPE1");
List<SarModuleTree> moduleTreeList = this.baseMapper.selectList(treeQueryWrapper);
//把SarModuleTree类型的list集合转换为SarModelTree类型的list集合
List<SarModelTree> sarModelTreeList = moduleTreeList.stream().map(SarModuleTree -> {
SarModelTree modelTree = new SarModelTree();
modelTree.setId(SarModuleTree.getGuid());
modelTree.setName(SarModuleTree.getFtvstype1());
// modelTree.setModel("TS"+SarModuleTree.get);
return modelTree;
}).collect(Collectors.toList());
return sarModelTreeList;
}
@Override
public List<SarModelTree> recursionGetChildren(SarModelTree parent) {
return null;
}
@Override
public Head analysisJsonAndStorage(String json) {
//获取头部 返回结果需要
Head head = new Head();
try{
//把字符串转换成对象
JsonObject parse = JsonParser.parseString(json).getAsJsonObject();
//要把jsonObject里的HEAD强转成JsonObject类型
JsonObject HEAD = (JsonObject) parse.get("HEAD");
//因为是最后要取的值了,所以就拿到之后把它转换成String类型
HEAD.get("CONSUMER").getAsString();
head.setBIZTRANSACTIONID(HEAD.get("BIZTRANSACTIONID").getAsString());
//获取json中的list
JsonArray list = (JsonArray)parse.get("LIST");
Gson gson = new Gson();
List<SarModuleTree> moduleTreeList = new LinkedList<>();
list.forEach(item->{
JsonObject objectJson=(JsonObject) item;
SarModuleTree sarModuleTree = gson.fromJson(objectJson, SarModuleTree.class);
sarModuleTree.setGuid(UUIDUtils.randomUUID20());
moduleTreeList.add(sarModuleTree);
});
//进行全量覆盖即删除表中所有数据,之后插入新的数据
sarModuleTreeService.remove(null);
sarModuleTreeService.saveBatch(moduleTreeList);
head.setSUCCESSCOUNT(String.valueOf(moduleTreeList.size()));
}catch (Exception e){
head.setERRORCODE("2");
head.setRESULT("业务失败需要重做,失败原因: "+e.getMessage());
return head;
}
head.setERRORCODE("0");
head.setRESULT("成功");
return head;
}
}
@@ -291,6 +291,7 @@ public class TsResourceServiceImpl extends ServiceImpl<TsResourceDao, TsResource
QueryWrapper<TsResource> TsResourceQueryWrapper=new QueryWrapper<>();
TsResourceQueryWrapper.eq("PARENT_ID",parent.getId());
TsResourceQueryWrapper.in("ID",getMenuIdList);
TsResourceQueryWrapper.orderByAsc("DISPLAY_SEQ");
List<TsResource> children=dao.selectList(TsResourceQueryWrapper);
for(TsResource TsResource:children){
TsResource.setChildren(recursionGetListChildren((TsResource),(getMenuIdList)));
@@ -104,6 +104,7 @@ public class SarPublicIdeaAllController extends BaseController<SarPublicIdeaAll>
if (!StringUtils.isEmpty(cid)){
QueryWrapper<SarPublicIdeaAll> wrapper = new QueryWrapper<>();
wrapper.eq(SarPublicIdeaAll.CID,cid);
wrapper.orderByAsc("part_code");
data=sarPublicIdeaAllDao.selectList(wrapper);
}
List<GetExcelDto> standExcel=new ArrayList<>();
@@ -39,7 +39,7 @@ public class SarPublicIdeaController extends BaseController<SarPublicIdea> {
@ApiOperation(value = "分页查询")
@GetMapping("/SelectAllPage")
public ResponseMessage selectAllPage(@RequestParam(defaultValue="1")Integer page,@RequestParam(defaultValue="10")Integer size,String categorg, String cname,
String start, String end){
String start, String end,String type){
Date startdate = null;
Date enddate = null;
SimpleDateFormat formater = new SimpleDateFormat();
@@ -54,7 +54,7 @@ public class SarPublicIdeaController extends BaseController<SarPublicIdea> {
} catch (ParseException e) {
e.printStackTrace();
}
IPage<SarPublicIdea> Publiclist =sarPublicIdeaService.selectAllP(page,size,categorg,cname,startdate,enddate);
IPage<SarPublicIdea> Publiclist =sarPublicIdeaService.selectAllP(page,size,categorg,cname,startdate,enddate,type);
return Result.success(Publiclist);
}
@@ -66,5 +66,11 @@ public class SarPublicIdea extends BaseEntity {
@TableField("uniques")
private String uniques;
@TableField("files")
private String files;
@TableField("files_name")
private String filesName;
}
@@ -20,6 +20,6 @@ import java.util.Date;
public interface ISarPublicIdeaService extends IService<SarPublicIdea> {
String add(SarPublicIdea sarPublicIdea);
IPage<SarPublicIdea> selectAllP(Integer page, Integer size, String categorg, String cname, Date startdate, Date enddate);
IPage<SarPublicIdea> selectAllP(Integer page, Integer size, String categorg, String cname, Date startdate, Date enddate, String type);
IPage<SarPublicIdea> selectAllDynamic(SeByoDto seByoDto);
}
@@ -1,7 +1,6 @@
package com.adc.da.slrs.sarStandIdea.service.Impl;
import com.adc.da.slrs.sarStandIdea.dao.SarPublicIdeaDao;
import com.adc.da.slrs.sarStandIdea.entity.SarPublicIdea;
@@ -22,7 +21,7 @@ import java.util.Date;
/**
* <p>
* 服务实现类
* 服务实现类
* </p>
*
* @author super_liu
@@ -36,7 +35,7 @@ public class SarPublicIdeaServiceImpl extends ServiceImpl<SarPublicIdeaDao, SarP
@Override
public String add(SarPublicIdea sarPublicIdea) {
if (!sarPublicIdea.getId().isEmpty()){
if (!sarPublicIdea.getId().isEmpty()) {
sarPublicIdea.setId(UUIDUtils.randomUUID10());
sarPublicIdeaDao.insert(sarPublicIdea);
return "增加成功";
@@ -45,22 +44,28 @@ public class SarPublicIdeaServiceImpl extends ServiceImpl<SarPublicIdeaDao, SarP
}
@Override
public IPage<SarPublicIdea> selectAllP(Integer p, Integer size, String category, String cname, Date start, Date end) {
public IPage<SarPublicIdea> selectAllP(Integer p, Integer size, String category, String cname, Date start, Date end, String type) {
QueryWrapper<SarPublicIdea> list = new QueryWrapper<>();
list.like(StringUtils.isNotEmpty(category),"category",category)
.like(StringUtils.isNotEmpty(cname),"cname",cname)
.ge(start!=null,"start_time",start)
.le(end!=null,"end_time",end)
.orderByAsc("end_time");
Page<SarPublicIdea> page = new Page<>(p,size);
if ("1".equals(type)) {
list.like(StringUtils.isNotEmpty(category), "category", category)
.like(StringUtils.isNotEmpty(cname), "cname", cname)
.ge(start != null, "start_time", start)
.le(end != null, "end_time", end)
.orderByDesc("start_time");
} else {
list.like(StringUtils.isNotEmpty(category), "category", category)
.like(StringUtils.isNotEmpty(cname), "cname", cname)
.ge("end_time", new Date())
.orderByAsc("end_time");
}
Page<SarPublicIdea> page = new Page<>(p, size);
IPage<SarPublicIdea> userIPage = sarPublicIdeaDao.selectPage(page, list);
System.out.println("总条数"+userIPage.getTotal());
System.out.println("总页数"+userIPage.getPages());
System.out.println("总条数" + userIPage.getTotal());
System.out.println("总页数" + userIPage.getPages());
return userIPage;
}
/**
*
* @param seByoDto
* @return
*/
@@ -72,33 +77,33 @@ public class SarPublicIdeaServiceImpl extends ServiceImpl<SarPublicIdeaDao, SarP
SimpleDateFormat formater = new SimpleDateFormat();
formater.applyPattern("yyyy-MM-dd");
try {
if (seByoDto.getStartTime()!=null){
if (seByoDto.getStartTime() != null) {
sar.setStartTime(formater.parse(seByoDto.getStartTime()));
}
if (seByoDto.getEndTime()!=null){
if (seByoDto.getEndTime() != null) {
sar.setEndTime(formater.parse(seByoDto.getEndTime()));
}
} catch (ParseException e) {
e.printStackTrace();
}
QueryWrapper<SarPublicIdea> wrapper = new QueryWrapper<>();
if (sar.getCategory()!=null&&sar.getCategory().length()!=0){
wrapper.like("category",sar.getCategory());
if (sar.getCategory() != null && sar.getCategory().length() != 0) {
wrapper.like("category", sar.getCategory());
}
if (sar.getCname()!=null&&sar.getCname().length()!=0){
wrapper.like("cname",sar.getCname());
if (sar.getCname() != null && sar.getCname().length() != 0) {
wrapper.like("cname", sar.getCname());
}
if (sar.getStartTime()!=null){
wrapper.le("start_time",sar.getStartTime());
if (sar.getStartTime() != null) {
wrapper.le("start_time", sar.getStartTime());
}
if (sar.getEndTime()!=null){
wrapper.gt("end_time",sar.getEndTime());
if (sar.getEndTime() != null) {
wrapper.gt("end_time", sar.getEndTime());
}
Page<SarPublicIdea> page = new Page<>(seByoDto.getPage(), seByoDto.getSize());
IPage<SarPublicIdea> userIPage = sarPublicIdeaDao.selectPage(page, wrapper);
System.out.println("总条数"+userIPage.getTotal());
System.out.println("总页数"+userIPage.getPages());
System.out.println("总条数" + userIPage.getTotal());
System.out.println("总页数" + userIPage.getPages());
return userIPage;
@@ -1,5 +1,6 @@
package com.adc.da.slrs.sarStandItems.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
@@ -22,9 +23,13 @@ public class SarStandItemsDto {
@ApiModelProperty(value = "条目编号")
private String itemsNum;
@ApiModelProperty(value = "内容")
@ApiModelProperty(value = "名称")
private String itemsName;
@ApiModelProperty(value = "内容")
@TableField("TERMS_CONDITIONS")
private String termsConditions;
@ApiModelProperty(value = "责任部门")
private String responsibleUnit;
@@ -48,4 +53,8 @@ public class SarStandItemsDto {
private String zccssrq;
private String technicalRequir;
private String changePoint;
}
@@ -19,8 +19,7 @@ import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.*;
/**
* <p>
@@ -193,11 +192,56 @@ public class SarStandItemsServiceImpl extends ServiceImpl<SarStandItemsDao, SarS
}
public List<SarStandItemsDto> findAllItems(String type,String[] ids){
return dao.selectAllItemsByIds(type,ids);
List<SarStandItemsDto> list=dao.selectAllItemsByIds(type,ids);
List<SarStandItemsDto> res=new ArrayList<>();
if (null == list || list.isEmpty()){
return list;
}else {
List<Integer> integerList=new ArrayList<>();
Map<Integer,List<SarStandItemsDto>> map=new HashMap<>();
list.forEach(sarStandItemsDto -> {
int a= sarStandItemsDto.getItemsNum().indexOf(".");
String mark=sarStandItemsDto.getItemsNum();
if (a>0){
mark=mark.substring(0,a);
}
if (null != map.get(Integer.valueOf(mark))){
map.get(Integer.valueOf(mark)).add(sarStandItemsDto);
}else {
integerList.add(Integer.valueOf(mark));
List<SarStandItemsDto> middle=new ArrayList<>();
middle.add(sarStandItemsDto);
map.put(Integer.valueOf(mark),middle);
}
});
Collections.sort(integerList);
integerList.forEach(integer -> {
res.addAll(map.get(integer));
});
return res;
}
}
public List<SarStandItems> querySarItemAndInterpretation(FindSarItemsPageReqDTO page){
//排序
if (page.getOrderBy()!=null && page.getOrder()!=null){
switch (page.getOrderBy()){
case "itemsNum" : page.setOrderBy("ITEMS_NUM"); break;
default:page.setOrderBy("ITEMS_NUM"); page.setOrder("DESC");
}
switch (page.getOrder()){
case "descending":page.setOrder("DESC");break;
default:page.setOrder("ASC");
}
}else {
page.setOrderBy("ITEMS_NUM");
page.setOrder("DESC");
}
//分页查询的总数
Integer count=dao.sarItemCount(page);
page.getPager().setRowCount(count);
@@ -14,6 +14,7 @@ import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import com.adc.da.base.web.BaseController;
@@ -33,7 +34,8 @@ import java.util.*;
*/
@RestController
@Api(description = "|SarStandProjectLibrary|")
@RequestMapping("/api/sarStandProjectLibrary")
@RequestMapping("/${restPath}/sarStandProjectLibrary")
@Slf4j
public class SarStandProjectLibraryController extends BaseController<SarStandProjectLibrary> {
@Resource
private SarStandProjectLibraryServiceImpl sarStandProjectLibraryService;
@@ -227,9 +229,11 @@ public class SarStandProjectLibraryController extends BaseController<SarStandPro
@PostMapping("/save")
@ApiOperation("同步车型项目数据")
public ResponseDto save(@RequestBody String jsonStr){
log.info(jsonStr);
Head head = sarStandProjectLibraryService.AnalysisJsonAndStorage(jsonStr);
ArrayList<Company> companies = new ArrayList<>();
ResponseDto responseDto = new ResponseDto(head,companies);
//todo 未确定返回内容
Company company = new Company();
company.setCOMPANY_CODE("");
company.setFISCAL_YEAR("");
@@ -3,6 +3,7 @@ package com.adc.da.slrs.sarStandProjectLibrary.entity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
@Data
public class ResponseDto {
@@ -17,14 +18,20 @@ public class ResponseDto {
// }
List<Company> LIST;
List<?> LIST;
public ResponseDto(Head HEAD, List<Company> LIST) {
public ResponseDto(Head HEAD, List<?> LIST) {
this.HEAD = HEAD;
this.LIST = LIST;
}
public ResponseDto() {
public ResponseDto(Head HEAD) {
ArrayList<Company> companies = new ArrayList<>();
Company company = new Company();
company.setCOMPANY_CODE("");
company.setFISCAL_YEAR("");
companies.add(company);
this.LIST=companies;
this.HEAD=HEAD;
}
}
@@ -75,25 +75,25 @@ public class SarStandProjectLibraryServiceImpl extends ServiceImpl<SarStandProje
//把刚刚拿到的值存到实体类里
SarStandProjectLibrary projectInfo = new SarStandProjectLibrary();
projectInfo
.setProjectPlatfor(projectObject.get("eng_platform").getAsString())
.setProjectNumber(projectObject.get("code").getAsString())
.setProjectName(projectObject.get("name").getAsString())
.setProjectClassification(projectObject.get("catalog_name").getAsString())
.setProjectStatus(projectObject.get("project_status").getAsString())
.setProjectGroup(projectObject.get("project_group_name").getAsString())
.setCurrentNode(projectObject.get("project_current_milestone").getAsString())
.setProjectLevel(projectObject.get("project_level").getAsString())
.setProductLine(projectObject.get("eng_product_line").getAsString());
.setProjectPlatfor(projectObject.get("projectPlatfor").getAsString())
.setProjectNumber(projectObject.get("projectNumber").getAsString())
.setProjectName(projectObject.get("projectName").getAsString())
.setProjectClassification(projectObject.get("projectClassification").getAsString())
.setProjectStatus(projectObject.get("projectStatus").getAsString())
.setProjectGroup(projectObject.get("projectGroup").getAsString())
.setCurrentNode(projectObject.get("currentNode").getAsString())
.setProjectLevel(projectObject.get("projectLevel").getAsString())
.setProductLine(projectObject.get("productLine").getAsString());
projectObject.get("target_end_on").getAsString();
projectObject.get("projectEndDate").getAsString();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date targetBeginOn = null;
try {
targetBeginOn = simpleDateFormat.parse(projectObject.get("target_begin_on").getAsString());
targetBeginOn = simpleDateFormat.parse(projectObject.get("projectStartDate").getAsString());
Date targetEndOn = simpleDateFormat.parse(projectObject.get("target_end_on").getAsString());
Date targetEndOn = simpleDateFormat.parse(projectObject.get("projectEndDate").getAsString());
projectInfo
.setProjectStartDate(targetBeginOn)
.setProjectEndDate(targetEndOn);
@@ -113,6 +113,7 @@ public class SarStandProjectLibraryServiceImpl extends ServiceImpl<SarStandProje
}
}catch (Exception e){
e.printStackTrace();
head.setERRORCODE("2");
head.setRESULT("业务失败需要重做");
return head;
@@ -1,21 +1,20 @@
package com.adc.da.slrs.sarStandProjectTeam.controller;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.Result;
import com.adc.da.base.web.BaseController;
import com.adc.da.slrs.sarStandProjectLibrary.entity.Company;
import com.adc.da.slrs.sarStandProjectLibrary.entity.Head;
import com.adc.da.slrs.sarStandProjectLibrary.entity.ResponseDto;
import com.adc.da.slrs.sarStandProjectLibrary.entity.SarStandProjectLibrary;
import com.adc.da.slrs.sarStandProjectTeam.service.ISarStandProjectTeamService;
import com.google.gson.*;
import io.swagger.annotations.ApiOperation;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.adc.da.slrs.sarStandProjectTeam.entity.SarStandProjectTeam;
import com.adc.da.slrs.sarStandProjectTeam.service.ISarStandProjectTeamService;
import io.swagger.annotations.Api;
import com.adc.da.base.web.BaseController;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
@@ -30,7 +29,8 @@ import java.util.ArrayList;
*/
@RestController
@Api(description = "|SarStandProjectTeam|")
@RequestMapping("/slrs/sar-stand-project-team")
@RequestMapping("/${restPath}/sar-stand-project-team")
@Slf4j
public class SarStandProjectTeamController extends BaseController<SarStandProjectTeam> {
@Autowired
@@ -39,8 +39,10 @@ public class SarStandProjectTeamController extends BaseController<SarStandProjec
@PostMapping("/save")
@ApiOperation("同步PCMS组织信息")
public ResponseDto save(@RequestBody String jsonStr){
log.info(jsonStr);
Head head = sarStandProjectTeamService.AnalysisJsonAndStorage(jsonStr);
ArrayList<Company> companies = new ArrayList<>();
//todo 未确定返回内容
Company company = new Company();
company.setCOMPANY_CODE("");
company.setFISCAL_YEAR("");
@@ -75,6 +75,7 @@ public class SarStandProjectTeamServiceImpl extends ServiceImpl<SarStandProjectT
}catch (Exception e){
responseHead.setERRORCODE("2");
responseHead.setRESULT("业务失败需要重做");
e.printStackTrace();
return responseHead;
}
responseHead.setERRORCODE("0")
@@ -36,7 +36,12 @@ public class SarStandUnqualified extends BaseEntity {
private static final long serialVersionUID = 1L;
@ExcelProperty("标准ID")
@ExcelProperty("标准")
@ApiModelProperty(value = "标准编号")
@TableField("STAND_SERIAL_NUMBER")
private String standSerialNumber;
@ExcelIgnore
@ApiModelProperty(value = "标准ID")
@TableField("STAND_ID")
private String standId;
@@ -69,27 +74,27 @@ public class SarStandUnqualified extends BaseEntity {
@TableField("ITEMS_NAME")
private String itemsName;
@ExcelProperty(value = "产品类型",converter = ProductTypeConverter.class)
@ApiModelProperty(value = "产品类型(research为在研产品,product为在产产品)")
@TableField("PRODUCT_TYPE")
private String productType;
@ExcelProperty("产品线")
@ApiModelProperty(value = "产品线")
@TableField("PRODUCT_LINE")
private String productLine;
@ExcelProperty("责任部门")
@ApiModelProperty(value = "责任部门")
@TableField("RESPONSIBLE_UNIT")
private String responsibleUnit;
@ExcelProperty("项目名称")
@ApiModelProperty(value = "项目名称")
@TableField("PRODUCT_NAME")
private String productName;
@ExcelProperty("创建部门")
@ExcelIgnore
@ApiModelProperty(value = "创建部门")
@TableField("CREATE_DEPT_ID")
private String createDeptId;
@ExcelProperty("创建人")
@ExcelIgnore
@ApiModelProperty(value = "创建人")
@TableField("CREATE_BY_ID")
private String createById;
@@ -113,17 +118,16 @@ public class SarStandUnqualified extends BaseEntity {
@TableField("ACTUAL_CLOSE_TIME")
private Date actualCloseTime;
@ExcelIgnore
@ApiModelProperty(value = "计划关闭时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField("PLAN_CLOSE_TIME")
private Date planCloseTime;
@ExcelProperty("不合规项目")
@ApiModelProperty(value = "未符合原因")
@TableField("REASON")
private String reason;
@ExcelProperty("责任部门")
@ApiModelProperty(value = "责任部门")
@TableField("RESPONSIBLE_UNIT")
private String responsibleUnit;
@ExcelProperty("质量工程师")
@ApiModelProperty(value = "质量工程师")
@TableField("QA_ENGINEER")
@@ -139,33 +143,34 @@ public class SarStandUnqualified extends BaseEntity {
@TableField("DUTY_ENGINEER")
private String dutyEngineer;
@ExcelProperty("标准编号")
@ApiModelProperty(value = "标准编号")
@TableField("STAND_SERIAL_NUMBER")
private String standSerialNumber;
@ExcelProperty(value = "产品类型",converter = ProductTypeConverter.class)
@ApiModelProperty(value = "产品类型(research为在研产品,product为在产产品)")
@TableField("PRODUCT_TYPE")
private String productType;
@ExcelProperty("计划关闭时间")
@ApiModelProperty(value = "计划关闭时间")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField("PLAN_CLOSE_TIME")
private Date planCloseTime;
@ExcelIgnore
@ApiModelProperty(value = "主键")
@TableId(type = IdType.UUID)
private String id;
@ExcelIgnore
@ApiModelProperty(value = "质量工程师")
@TableField(exist=false)
private String qaEngineerName;
@ExcelIgnore
@ApiModelProperty(value = "认证工程师")
@TableField(exist=false)
private String authEngineerName;
@ExcelIgnore
@ApiModelProperty(value = "责任工程师")
@TableField(exist=false)
private String dutyEngineerName;
@ExcelIgnore
@ApiModelProperty(value = "国内OR海外")
@TableField(exist=false)
private String standType;
@@ -6,6 +6,7 @@ import com.adc.da.base.web.BaseController;
import com.adc.da.http.ResponseMessage;
import com.adc.da.http.Result;
import com.adc.da.slrs.sarSarAccessInfo.entity.SarSarAccessInfo;
import com.adc.da.slrs.sarStandItems.entity.SarStandItemsDto;
import com.adc.da.slrs.sarStandardComplianceAssessResult.entity.*;
import com.adc.da.slrs.sarStandardComplianceAssessResult.service.ISarInterpretationForeignStandardService;
import com.adc.da.slrs.sarStandardComplianceAssessResult.service.ISarInterpretationNationalStandardService;
@@ -165,6 +166,9 @@ public class SarStandardComplianceAssessResultController {
if (eo.getType() != null) queryWrapper.eq("type", eo.getType());
if (eo.getProductName() != null) queryWrapper.like("product_name", eo.getProductName());
if (eo.getProductId() != null) queryWrapper.like("product_id", eo.getProductId());
queryWrapper.orderByAsc("product_name");
queryWrapper.orderByAsc("standard_item");
// if (eo.getInterpretationTime() != null) queryWrapper.eq("INTERPRETATION_TIME", eo.getInterpretationTime());
IPage<SarStandardComplianceProductAssess> page = iSarStandardComplianceProductAssessService.page(iPage, queryWrapper);
@@ -218,7 +218,10 @@ public class SarStandardsInfoController extends BaseController<SarStandardsInfo>
int result = sarStandardsInfoEOService.deleteSarStandards(ids);
if (result > 0) {
return Result.success("0", "删除成功", result);
} else {
}else if(result == -1) {
return Result.success("-1","所选的标准下挂有标准,无法删除");
}
else {
return Result.error("删除失败");
}
}
@@ -31,7 +31,7 @@ public interface SarStandardsInfoDao extends BaseMapper<SarStandardsInfo> {
List<SarStandardsInfo> selectStandardsByStandnumber(SarStandardsInfo sarStandardsInfoEO);
List<SarStandardsInfo> queryStandInfoByList(@Param("limit") Integer limit);
List<SarStandardsInfo> queryStandInfoByList(@Param("limit") Integer limit,@Param("typeCode") String typeCode);
Integer selectStandColumn(@Param("columnName") String columnName);
@@ -155,6 +155,8 @@ public class SarStandardsInfo extends BaseEntity {
@TableField(exist = false)
private String standNatureShow; // 标准性质显示名称
@TableField(exist = false)
private String standTextStatusShow; // 标准文本状态显示名称
@TableField(exist = false)
private String sychronId; // 同步数据ID
@TableField(exist = false)
private List<DicTypeEO> dicTypeList = new ArrayList(); // 记录标准涉及到的所有数据字典数据
@@ -607,5 +609,13 @@ public class SarStandardsInfo extends BaseEntity {
public void setStandSystemName(String standSystemName) {
this.standSystemName = standSystemName;
}
public String getStandTextStatusShow() {
return standTextStatusShow;
}
public void setStandTextStatusShow(String standTextStatusShow) {
this.standTextStatusShow = standTextStatusShow;
}
}
@@ -15,6 +15,8 @@ import com.adc.da.search.entity.StandLawsEO;
import com.adc.da.search.service.StandLawsSearchService;
import com.adc.da.slrs.otConvertMq.dao.OtConvertMqDao;
import com.adc.da.slrs.otConvertMq.entity.OtConvertMq;
import com.adc.da.slrs.sarLawsAttrDetailedList.entity.SarLawsAttrDetailedList;
import com.adc.da.slrs.sarLawsAttrDetailedList.service.impl.SarLawsAttrDetailedListServiceImpl;
import com.adc.da.slrs.sarLawsInfo.entity.SarLawsInfo;
import com.adc.da.slrs.sarLawsInfo.page.SarLawsInfoEOPage;
import com.adc.da.slrs.sarLawsInfo.page.SarLawsItemsEOPage;
@@ -49,6 +51,10 @@ import com.adc.da.slrs.sarStandardsInfo.service.ISarStandardsInfoService;
import com.adc.da.slrs.sarUpdLog.service.ISarUpdLogService;
import com.adc.da.slrs.sarUser.service.ITsUserService;
import com.adc.da.slrs.sysInfo.service.SysInfoEOService;
import com.adc.da.slrs.tsDictionaryType.dao.TsDicTypeDao;
import com.adc.da.slrs.tsDictionaryType.dao.TsDictionaryDao;
import com.adc.da.slrs.tsDictionaryType.entity.TsDicType;
import com.adc.da.slrs.tsDictionaryType.entity.TsDictionary;
import com.adc.da.sys.common.SelectionResult;
import com.adc.da.sys.constant.ValueStateEnum;
import com.adc.da.sys.dao.DicTypeEODao;
@@ -203,6 +209,12 @@ public class SarStandardsInfoServiceImpl extends ServiceImpl<SarStandardsInfoDao
@Autowired
private StandLawsSearchService standLawsSearchService;
@Autowired
private TsDictionaryDao tsDictionaryDao;
@Autowired
private TsDicTypeDao tsDicTypeDao;
// /**
// * 反向操作标准
// */
@@ -439,11 +451,16 @@ public class SarStandardsInfoServiceImpl extends ServiceImpl<SarStandardsInfoDao
return resultMap;
}
public void attrInfoShowDetails(List<SarStandardsInfo> sarlist) throws Exception {
for (SarStandardsInfo row : sarlist) {
attrInfoDetails(row);
Map<String, Object> getAttrMap = row.getAttrInfoMap();
if (getAttrMap != null && getAttrMap.size() > 0) {
//存在的分解单文本名称列表
LinkedList<String> itemExistList = new LinkedList<>();
getAttrMap.put("itemExistList",itemExistList);
for (Map.Entry<String, Object> entry : getAttrMap.entrySet()) {
String name = entry.getKey();
String value = "";
@@ -452,6 +469,15 @@ public class SarStandardsInfoServiceImpl extends ServiceImpl<SarStandardsInfoDao
if (StringUtils.isNotBlank(value)) {
List<AttFileEO> fileObj = attFileEOService.getMultiFileInfos(value);
entry.setValue(fileObj);
//以标准id和文本类型查询分解单表 有数据设标记为为 1
FindSarItemsPageReqDTO sarItemCount = new FindSarItemsPageReqDTO();
sarItemCount.setStandId(row.getId());
sarItemCount.setFileType(name);
Integer sarItemsCount = standItemsDao.sarItemCount(sarItemCount);
if (sarItemsCount>0){
//存在分解单的文本名称存入列表
itemExistList.add(name);
}
}
}else if (entry.getValue() != null && InitStandAttrUtil.selectionFieldList != null && InitStandAttrUtil.selectionFieldList.size() > 0 && InitStandAttrUtil.selectionFieldList.contains(name)) {
value = entry.getValue().toString();
@@ -1261,13 +1287,32 @@ public class SarStandardsInfoServiceImpl extends ServiceImpl<SarStandardsInfoDao
}
@Autowired
SarLawsAttrDetailedListServiceImpl detailedListService;
public int deleteSarStandards(String ids) {
QueryWrapper<SarLawsAttrDetailedList> detailedListQueryWrapper = new QueryWrapper<>();
String[] idArr = ids.split(",");
SarStandardsInfo sarStandardsInfoEO = new SarStandardsInfo();
sarStandardsInfoEO.setValidFlag("1");
sarStandardsInfoEO.setModifyTime(new Date());
int countResult = 0;
//如果清单下挂着标准A在标准库里删除标准A的话加个验证 不让删这个标准
for (String id : idArr){
detailedListQueryWrapper.eq("stand_id",id);
int count = detailedListService.count(detailedListQueryWrapper);
if (count>0){
countResult = -1;
return countResult;
}
}
for (String id : idArr) {
countResult++;
//查询删除的标准信息为删除代替关系
SarStandardsInfo getDelStandInfoList = dao.selectById(id);
@@ -2018,9 +2063,28 @@ public class SarStandardsInfoServiceImpl extends ServiceImpl<SarStandardsInfoDao
return strhours;
}
@Override
public List<SarStandardsInfo> getStandInfoByList(String limit){
return dao.queryStandInfoByList(Integer.valueOf(limit));
//查询文本状态为即将实施的
QueryWrapper<TsDictionary> dictionaryWrapper = new QueryWrapper<>();
dictionaryWrapper.select("ID")
.eq("DICTIONARY_NAME","文本状态");
List<Map<String, Object>> dicMaps = tsDictionaryDao.selectMaps(dictionaryWrapper);
QueryWrapper<TsDicType> dicTypeWrapper = new QueryWrapper<>();
dicTypeWrapper.select("DIC_TYPE_CODE")
.eq("DIC_ID",dicMaps.get(0).get("ID").toString())
.eq("DIC_TYPE_NAME","即将实施");
List<Map<String, Object>> typeMaps = tsDicTypeDao.selectMaps(dicTypeWrapper);
List<SarStandardsInfo> standInfoList = dao.queryStandInfoByList(Integer.valueOf(limit), typeMaps.get(0).get("DIC_TYPE_CODE").toString());
return standInfoList;
}
/**
@@ -2162,8 +2226,8 @@ public class SarStandardsInfoServiceImpl extends ServiceImpl<SarStandardsInfoDao
// String readFilePath = "E:\\上汽企标流程总览.pdf";
try {
// 判断文件是docx还是PDF
if (null != attFileEO.getFileSuffix() && (attFileEO.getFileSuffix().equals("docx") || attFileEO.getFileSuffix().equals("doc") || attFileEO.getFileSuffix().equals("ppt") || attFileEO.getFileSuffix().equals("pptx"))) {
if(attFileEO.getFileSuffix().equals("doc")){
if (null != attFileEO.getFileSuffix() && (attFileEO.getFileSuffix().equals("docx") || attFileEO.getFileSuffix().equals("doc")|| attFileEO.getFileSuffix().equals("DOC")|| attFileEO.getFileSuffix().equals("DOCX") || attFileEO.getFileSuffix().equals("ppt") || attFileEO.getFileSuffix().equals("pptx"))) {
if(attFileEO.getFileSuffix().equals("doc")||attFileEO.getFileSuffix().equals("docx") || attFileEO.getFileSuffix().equals("DOC")|| attFileEO.getFileSuffix().equals("DOCX")){
FileInputStream fis = new FileInputStream(readFilePath);
WordExtractor wordExtractor = new WordExtractor(fis);
String txt = wordExtractor.getText();
@@ -9,10 +9,12 @@ import com.adc.da.slrs.sarMenu.entity.SarMenu;
import com.adc.da.slrs.sarResource.entity.TsResource;
import com.adc.da.slrs.sarUrl.dao.TsUrlDao;
import com.adc.da.slrs.sarUser.dao.TsUserDao;
import com.adc.da.slrs.sarUser.entity.UpDTO;
import com.adc.da.slrs.sarUser.entity.UserPositionVO;
import com.adc.da.slrs.sarUser.service.ITsUserService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.ApiOperation;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@@ -80,5 +82,12 @@ public class TsUserController extends BaseController<TsUser> {
}
@ApiOperation("查询人接口悬浮窗")
@GetMapping("/selectUp")
public ResponseMessage<List<UpDTO>> selectUp(@Param("uname") String uname) throws Exception {
return Result.success(tsUserService.selectByName(uname));
}
}
@@ -3,10 +3,7 @@ package com.adc.da.slrs.sarUser.dao;
import com.adc.da.http.ResponseMessage;
import com.adc.da.slrs.sarUser.entity.TsUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.*;
import java.util.List;
@@ -20,6 +17,9 @@ import java.util.List;
*/
public interface TsUserDao extends BaseMapper<TsUser> {
@Update("truncate table ts_user")
void deleteUser();
/**
* 查询用户已经绑定的岗位ID
*/
@@ -143,9 +143,11 @@ public class TsUser extends BaseEntity {
private List<TsPosition> positions;
@ApiModelProperty("当前页")
@TableField(exist = false)
private Integer current;
@ApiModelProperty("每页条数")
@TableField(exist = false)
private Integer size;
public TsUser() {
@@ -0,0 +1,13 @@
package com.adc.da.slrs.sarUser.entity;
import lombok.Data;
@Data
public class UpDTO {
private String value;
private String id;
}
@@ -4,6 +4,7 @@ import com.adc.da.http.ResponseMessage;
import com.adc.da.slrs.sarMenu.entity.SarMenu;
import com.adc.da.slrs.sarResource.entity.TsResource;
import com.adc.da.slrs.sarUser.entity.TsUser;
import com.adc.da.slrs.sarUser.entity.UpDTO;
import com.adc.da.slrs.sarUser.entity.UserPositionVO;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
@@ -20,6 +21,7 @@ import java.util.List;
*/
public interface ITsUserService extends IService<TsUser> {
void deleteUser();
/**
* 通过机构ID查询人员
@@ -74,4 +76,6 @@ public interface ITsUserService extends IService<TsUser> {
void parseUser() throws Exception;
List<SarMenu> getSecondMenusByUserId(String userId);
List<UpDTO> selectByName(String name);
}
@@ -14,6 +14,7 @@ import com.adc.da.slrs.sarRole.service.ITsRoleService;
import com.adc.da.slrs.sarUser.entity.SyncUser;
import com.adc.da.slrs.sarUser.entity.TsUser;
import com.adc.da.slrs.sarUser.dao.TsUserDao;
import com.adc.da.slrs.sarUser.entity.UpDTO;
import com.adc.da.slrs.sarUser.entity.UserPositionVO;
import com.adc.da.slrs.sarUser.service.ITsUserService;
import com.adc.da.sync.service.SyncUserService;
@@ -31,6 +32,8 @@ import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@@ -60,6 +63,11 @@ public class TsUserServiceImpl extends ServiceImpl<TsUserDao, TsUser> implements
@Autowired
private TsPositionDao tsPositionDao;
public void deleteUser(){
tsUserDao.deleteUser();
};
/**
* 通过机构ID查询人员
* @return List<TsUser>
@@ -70,7 +78,7 @@ public class TsUserServiceImpl extends ServiceImpl<TsUserDao, TsUser> implements
Page<TsUser> tsUserPage = new Page<>();
System.out.println(tsUser.getCurrent());
System.out.println(tsUser.getSize());
List<TsUser> tsUserList = tsUserDao.getUserAndPositionPage((tsUser.getCurrent()-1)*tsUser.getSize(),1*tsUser.getSize(),tsUser);
List<TsUser> tsUserList = tsUserDao.getUserAndPositionPage((tsUser.getCurrent()-1)*tsUser.getSize(),tsUser.getSize(),tsUser);
Integer total = tsUserDao.getUserAndPositionCount(tsUser);
tsUserPage.setRecords(tsUserList);
tsUserPage.setCurrent(tsUser.getCurrent());
@@ -145,6 +153,14 @@ public class TsUserServiceImpl extends ServiceImpl<TsUserDao, TsUser> implements
UserEO userEO=UserUtils.getUser();
String userId= userEO.getUsid();
List<String> positionIds=tsUserDao.selectPositionIds(userId);
/**
* 当用户没有所属岗位默认给一个other岗位适用于特定权限外的其他用户
* 用户同步时需要将用户配置的系统内的岗位保留
*/
if(positionIds == null || positionIds.isEmpty()){
positionIds = Arrays.asList(new String[]{"other"});
}
List<String> roleIds=tsPositionService.getRoleIdsByPositionIds(positionIds);
List<String> menuIds=tsRoleService.getMenuIdsByRoleIds(roleIds);
return sarMenuService.getMenuByIds(menuIds);
@@ -273,4 +289,20 @@ public class TsUserServiceImpl extends ServiceImpl<TsUserDao, TsUser> implements
List<String> menuIds=tsRoleService.getMenuIdsByRoleIds(roleIds);
return sarMenuService.getSecondMenuByIds(menuIds);
}
@Override
public List<UpDTO> selectByName(String name) {
QueryWrapper<TsUser> tsUserQueryWrapper=new QueryWrapper<>();
tsUserQueryWrapper.like("ACCOUNT",name);
tsUserQueryWrapper.or().like("UNAME",name);
List<TsUser> res= tsUserDao.selectList(tsUserQueryWrapper);
List<UpDTO> result=new ArrayList<>();
res.forEach(tsUser -> {
UpDTO upDTO=new UpDTO();
upDTO.setValue(tsUser.getUname()+"("+tsUser.getAccount()+")");
upDTO.setId(tsUser.getUserId());
result.add(upDTO);
});
return result;
}
}
@@ -7,12 +7,18 @@ import java.util.List;
import com.adc.da.base.web.BaseController;
import com.adc.da.http.PageInfo;
import com.adc.da.person.entity.PersonMsgEO;
import com.adc.da.slrs.sarStandItems.entity.SarStandItems;
import com.adc.da.slrs.sarStandItems.service.impl.SarStandItemsServiceImpl;
import com.adc.da.slrs.sarStandardComplianceAssessResult.entity.SarStandardsInfoEO;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitInfoEO;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitInfoEOPage;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitItemsEO;
import com.adc.da.slrs.standardSplit.entity.SarLawsInfoEO;
import com.adc.da.slrs.standardSplit.service.*;
import com.adc.da.sys.util.LoginUserUtil;
import com.adc.da.util.UUIDUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -162,21 +168,56 @@ public class SarFileSplitInfoEOController extends BaseController<SarFileSplitInf
}
}
@Autowired
private SarStandItemsServiceImpl ServiceImpl;
@ApiOperation(value = "|SarFileSplitInfoEO|关联")
@PostMapping("/connectToStandItems")
public ResponseMessage connectToStandItems(@RequestBody List<SarFileSplitInfoEO> sarFileSplitInfoEOList) throws Exception {
for (SarFileSplitInfoEO sarFileSplitInfoEO:sarFileSplitInfoEOList) {
List<SarStandardsInfoEO> getList = new ArrayList<>();
List<SarLawsInfoEO> sarLawsInfoEOList = new ArrayList<>();
List<SarFileSplitItemsEO> querySame = null;
/**
* 删除原来的分解单
*/
QueryWrapper<SarStandItems> removeWrapper = new QueryWrapper<>();
removeWrapper.eq("STAND_ID",sarFileSplitInfoEOList.get(0).getStandId())
.eq("FILE_TYPE",sarFileSplitInfoEOList.get(0).getFileType());
ServiceImpl.remove(removeWrapper);
for (SarFileSplitInfoEO sarFileSplitInfoEO : sarFileSplitInfoEOList) {
// List<SarStandardsInfoEO> getList = new ArrayList<>();
// List<SarLawsInfoEO> sarLawsInfoEOList = new ArrayList<>();
querySame = sarFileSplitInfoEOService.querySame(sarFileSplitInfoEO);
/**
* 使选定的拆分条款 插入分解单
*/
querySame.forEach(item->{
QueryWrapper<SarStandItems> sarStandItemsQueryWrapper = new QueryWrapper<>();
sarStandItemsQueryWrapper.eq("edit_flag",item.getEditFlag());
SarStandItems sarStandItems = new SarStandItems();
sarStandItems.setStandId(sarFileSplitInfoEO.getStandId());
sarStandItems.setEditFlag(item.getEditFlag());
sarStandItems.setItemsName(item.getItemsName());
sarStandItems.setTermsConditions(item.getItermsConditions());
sarStandItems.setItemsNum(item.getItemsNum());
sarStandItems.setId(UUIDUtils.randomUUID20());
sarStandItems.setFileType(sarFileSplitInfoEO.getFileType());
ServiceImpl.saveOrUpdate(sarStandItems,sarStandItemsQueryWrapper);
});
//根据标准号查询标准是否存在
String standNum="";
if (StringUtils.isNotEmpty(sarFileSplitInfoEO.getStandId())) {
standNum=sarFileSplitInfoEO.getShowNumber();
} else if(StringUtils.isNotEmpty(sarFileSplitInfoEO.getStandNumSplit())){
standNum=sarFileSplitInfoEO.getStandNumSplit();
}else{
return Result.error("标准号不能为空");
}
// String standNum="";
// if (StringUtils.isNotEmpty(sarFileSplitInfoEO.getStandId())) {
// standNum=sarFileSplitInfoEO.getShowNumber();
// } else if(StringUtils.isNotEmpty(sarFileSplitInfoEO.getStandNumSplit())){
// standNum=sarFileSplitInfoEO.getStandNumSplit();
// }else{
// return Result.error("标准号不能为空");
// }
// if (sarFileSplitInfoEO.getFileType().equals("ZCWB") || sarFileSplitInfoEO.getFileType().equals("GCGJ")) {
// SarLawsInfoEOPage page = new SarLawsInfoEOPage();
// page.setLawsType("FOREIGN");
@@ -201,7 +242,8 @@ public class SarFileSplitInfoEOController extends BaseController<SarFileSplitInf
// return Result.error("0", "该条数据标准号在标准库中不存在");
// }
}
return Result.error("0","关联失败");
// return Result.error("0","关联失败");
return Result.success(querySame);
}
@ApiOperation(value = "|SarFileSplitInfoEO|标准拆分编辑")
@@ -211,7 +253,7 @@ public class SarFileSplitInfoEOController extends BaseController<SarFileSplitInf
if(null!=sarFileSplitInfoEO){
sarFileSplitInfoEO.setModifyTime(new Date());
if (null==sarFileSplitInfoEO.getSplitStatus())
sarFileSplitInfoEO.setSplitStatus("0");
sarFileSplitInfoEO.setSplitStatus("1");
sarFileSplitInfoEOService.updateByPrimaryKeySelective(sarFileSplitInfoEO);
return Result.success("0","编辑成功",null);
}else{
@@ -2,6 +2,7 @@ package com.adc.da.slrs.standardSplit.dao;
import com.adc.da.base.page.BasePage;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitInfoEO;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitItemsEO;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@@ -36,4 +37,6 @@ public interface SarFileSplitInfoEODao extends BaseMapper<SarFileSplitInfoEO> {
int deleteByIds(SarFileSplitInfoEO sarFileSplitInfoEO);
List<SarFileSplitItemsEO> querySame (SarFileSplitInfoEO sarFileSplitInfoEO);
}
@@ -4,6 +4,7 @@ import com.adc.da.base.page.BasePage;
import com.adc.da.person.entity.PersonMsgEO;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitInfoEO;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitInfoEOPage;
import com.adc.da.slrs.standardSplit.entity.SarFileSplitItemsEO;
import java.util.List;
@@ -30,4 +31,6 @@ public interface SarFileSplitInfoEOService {
PersonMsgEO updateNew(PersonMsgEO val) throws Exception;
String getClauseBySplitId(String standNum, String fileType);
List<SarFileSplitItemsEO> querySame (SarFileSplitInfoEO sarFileSplitInfoEO);
}
@@ -2,6 +2,7 @@ package com.adc.da.slrs.standardSplit.service.impl;
import com.adc.da.att.service.IAttFileEOService;
import com.adc.da.person.entity.PersonMsgEO;
import com.adc.da.slrs.sarStandAttrDetails.service.ISarStandAttrDetailsService;
import com.adc.da.slrs.sarStandItems.entity.SarStandItems;
import com.adc.da.slrs.standardSplit.dao.*;
import com.adc.da.slrs.standardSplit.service.SarLawsInfoEOService;
@@ -10,8 +11,11 @@ import com.adc.da.base.page.BasePage;
import com.adc.da.common.ReadWordTable;
import com.adc.da.slrs.standardSplit.entity.*;
import com.adc.da.slrs.standardSplit.service.SarFileSplitInfoEOService;
import com.adc.da.sys.common.SelectionResult;
import com.adc.da.sys.util.LoginUserUtil;
import com.adc.da.sys.util.UUIDUtils;
import com.adc.da.utils.util.InitStandAttrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.xwpf.usermodel.*;
@@ -46,6 +50,9 @@ import org.springframework.transaction.interceptor.TransactionAspectSupport;
public class SarFileSplitInfoEOServiceImpl implements SarFileSplitInfoEOService {
private static final Logger logger = LoggerFactory.getLogger(SarFileSplitInfoEOServiceImpl.class);
@Autowired
private ISarStandAttrDetailsService sarStandAttrDetailsEOService;
@Autowired
private IAttFileEOService attFileEOService;
@Value("${file.path}")
@@ -335,7 +342,7 @@ public class SarFileSplitInfoEOServiceImpl implements SarFileSplitInfoEOService
middle=messageList;
for (SarFileSplitItemsEO mis:messageList) {
mis.setWorkFlowShow("1");
if (mis.getItemsNum().equals("1") || mis.getItemsNum().startsWith("1.") || mis.getItemsNum().equals("2") || mis.getItemsNum().startsWith("2.") || mis.getItemsNum().equals("3") || mis.getItemsNum().startsWith("3.")){
if (mis.getItemsNum().equals("2") || mis.getItemsNum().startsWith("2.") || mis.getItemsNum().equals("3") || mis.getItemsNum().startsWith("3.")){
mis.setWorkFlowShow("0");
}
else {
@@ -349,6 +356,11 @@ public class SarFileSplitInfoEOServiceImpl implements SarFileSplitInfoEOService
}
}
}
messageList.forEach(sarFileSplitItemsEO -> {
if (sarFileSplitItemsEO.getItemsNum().equals("1")){
sarFileSplitItemsEO.setWorkFlowShow("1");
}
});
sarFileSplitMenuEODao.insertForeach(treeList);
sarFileSplitItemsEODao.insertForeach(messageList);
sarFileSplitItemsValEODao.insertForeach(itemValList);
@@ -583,11 +595,11 @@ public class SarFileSplitInfoEOServiceImpl implements SarFileSplitInfoEOService
page.getPager().setRowCount(rowCount);
List<SarFileSplitInfoEO> rows = sarFileSplitInfoEODao.queryByPageOwn(page);
Map<String, String> map = new HashMap<>();
map.put("CA", "草稿");
map.put("ZQYJG", "征求意见稿");
map.put("BPG", "报批稿");
map.put("SSG", "送审稿");
map.put("FBGBJBD", "发布稿(必读)");
List<SelectionResult> selectionResults = sarStandAttrDetailsEOService.selectFileFieldForSel(null);
selectionResults.forEach(detailsEO->{
map.put(detailsEO.getValue(),detailsEO.getLabel());
});
if (rows != null && !rows.isEmpty()) {
for (SarFileSplitInfoEO infoEO : rows) {
@@ -730,4 +742,9 @@ public class SarFileSplitInfoEOServiceImpl implements SarFileSplitInfoEOService
return rows.get(0).getId();
}
@Override
public List<SarFileSplitItemsEO> querySame (SarFileSplitInfoEO sarFileSplitInfoEO){
return dao.querySame(sarFileSplitInfoEO);
};
}
@@ -31,7 +31,7 @@ public class FieldConvertUtil {
"文本状态,发布日期"; // 导出基础表字段 //删除 实施日期 2021-05-28
public static String exportBaseFieldNamesForeign = "标准类别,标准编号,标准年份,中文名称,英文名称," +
"文本状态,发布日期,文本说明,是否纳入认证清单,体系类别,标签,适用产品线,适用认证,能源类型,责任工程师," +
"文本状态,发布日期,是否纳入认证清单,体系类别,标签,适用认证,能源类型," +
"关联文件,发布稿,增补件,勘误件,草案"; // 导出基础表字段
public static String exportAttrFieldNamesInland = "归口管理部门,发布机构,工作组信息,我司参与深度,适用车辆类型,要求类型," +
@@ -101,10 +101,14 @@ public class StandExportUtil {
Map<String,Object> attrValueMap = sarStandardsInfoEO.getAttrInfoMap();
switch (name) {
case "标准性质":
value = sarStandardsInfoEO.getStandNature();
value = sarStandardsInfoEO.getStandNatureShow();
break;
case "是否纳入认证清单":
value = sarStandardsInfoEO.getIsRelateAccess();
switch (sarStandardsInfoEO.getIsRelateAccess()){
case "0": value=""; break;
case "1": value=""; break;
default:value="";
}
break;
case "标准体系":
value = sarStandardsInfoEO.getStandSystem();
@@ -137,8 +141,8 @@ public class StandExportUtil {
case "英文名称":
value = sarStandardsInfoEO.getStandEnName();
break;
case "标准状态":
value = sarStandardsInfoEO.getStandStateShow();
case "文本状态":
value = sarStandardsInfoEO.getStandTextStatusShow();
break;
case "发布日期":
if (sarStandardsInfoEO.getIssueTime() != null) {
@@ -408,12 +408,14 @@
<select id="querySarItemAndInterpretation" resultMap="sarItemVOResultMap"
parameterType="com.adc.da.slrs.sarStandItems.entity.FindSarItemsPageReqDTO">
SELECT
*
sar_stand_items.*,split_pid(sar_stand_items.ITEMS_NUM,'.') as tt
FROM
sar_stand_items
<include refid="sarItemWhere"/>
LIMIT #{page},#{pageSize}
<if test="orderBy !=null and orderBy!=''">
order by tt ${order}
</if>
LIMIT ${pager.startIndex-1},${pageSize}
</select>
<!-- 查询SAR_STAND_ITEMS列表 -->
@@ -729,7 +731,8 @@
<select id="selectAllItemsByIds" resultType="com.adc.da.slrs.sarStandItems.entity.SarStandItemsDto">
select ID,STAND_ID,ITEMS_NUM,ITEMS_NAME,RESPONSIBLE_UNIT,SVPPS,APPLY_ARCTIC,CLAIM_TYPE,BUS_STAND_COVER,DUTY_ENGINEER as responsibleEngineer,XCXSSRQ as xcxssrq,ZCCSSRQ as zccssrq
select ID,STAND_ID,ITEMS_NUM,ITEMS_NAME,RESPONSIBLE_UNIT,SVPPS,APPLY_ARCTIC,CLAIM_TYPE,BUS_STAND_COVER,DUTY_ENGINEER as responsibleEngineer,XCXSSRQ as xcxssrq,ZCCSSRQ as zccssrq ,read_content as technicalRequir ,compared_with_previous as changePoint
,TERMS_CONDITIONS as termsConditions
from SAR_STAND_ITEMS
where FILE_TYPE=#{type}
<if test="ids != null">
@@ -738,6 +741,7 @@
#{item}
</foreach>
</if>
order by ITEMS_NUM
</select>
<select id="selectStandTime" resultType="com.adc.da.slrs.sarStandItems.entity.StandsTimeDto">
select STAND_ID,XCXSSRQ,ZCCSSRQ
@@ -136,7 +136,7 @@
<!-- 查询字段及对应数据-->
<select id="selectStandFieldAndData" resultType="Map">
SELECT ${fieldInfo}
SELECT STAND_ID,${fieldInfo}
FROM SAR_BUSS_STAND_ATTR_INFO
WHERE valid_flag=0 and stand_id = #{standId}
</select>
@@ -161,4 +161,4 @@
FROM SAR_BUSS_STAND_ATTR_INFO
WHERE stand_id = #{standId} and valid_flag=0
</select>
</mapper>
</mapper>
@@ -45,22 +45,17 @@
put_time, issue_time,stand_en_name,stand_name, stand_code, id,apply_country, stand_nature, stand_sort,text_status_buss
</sql>
<sql id="Base_Column_List_show" >
stand_year,dicapplyCountry.DIC_TYPE_NAME as applyCountryShow,dicstandSort.DIC_TYPE_NAME as standSortShow,
dicstandNature.DIC_TYPE_NAME as standNatrueShow,SAR_BUSSIONESS_STAND.modify_time,
SAR_BUSSIONESS_STAND.modify_time,
SAR_BUSSIONESS_STAND.creation_time, SAR_BUSSIONESS_STAND.valid_flag,
SAR_BUSSIONESS_STAND.apply_country, SAR_BUSSIONESS_STAND.stand_nature,SAR_BUSSIONESS_STAND.stand_sort,
stand_status, replaced_stand_num,replace_stand_num,put_time,issue_time,stand_en_name,
stand_name, stand_code,SAR_BUSSIONESS_STAND.id,dicstandStatus.DIC_TYPE_NAME as standStatusShow,SAR_BUSSIONESS_STAND.text_status_buss
stand_name, stand_code,SAR_BUSSIONESS_STAND.id,SAR_BUSSIONESS_STAND.text_status_buss
</sql>
<sql id="Group_Column_List_show" >
stand_year,dicapplyCountry.DIC_TYPE_NAME,dicstandSort.DIC_TYPE_NAME,dicstandNature.DIC_TYPE_NAME,SAR_BUSSIONESS_STAND.modify_time,
SAR_BUSSIONESS_STAND.creation_time, SAR_BUSSIONESS_STAND.valid_flag,
SAR_BUSSIONESS_STAND.apply_country, SAR_BUSSIONESS_STAND.stand_nature,
SAR_BUSSIONESS_STAND.stand_sort,
stand_status, replaced_stand_num, replace_stand_num,put_time,
issue_time, stand_en_name, stand_name, stand_code,
SAR_BUSSIONESS_STAND.id,dicstandStatus.DIC_TYPE_NAME
SAR_BUSSIONESS_STAND.id
</sql>
@@ -354,10 +349,6 @@
<!-- 分页查询条件 -->
<sql id="SarBussionInfo_Where_Clause">
left join TS_DICTYPE dicstandStatus ON ( dicstandStatus.dic_type_code = SAR_BUSSIONESS_STAND.TEXT_STATUS_BUSS AND dicstandStatus.dic_id IS NOT NULL and dicstandStatus.valid_flag = 0)
left join TS_DICTYPE dicstandNature ON ( dicstandNature.dic_type_code = SAR_BUSSIONESS_STAND.STAND_NATURE AND dicstandNature.dic_id IS NOT NULL and dicstandNature.valid_flag = 0)
left join TS_DICTYPE dicstandSort ON ( dicstandSort.dic_type_code = SAR_BUSSIONESS_STAND.STAND_SORT AND dicstandSort.dic_id IS NOT NULL and dicstandSort.valid_flag = 0)
left join TS_DICTYPE dicapplyCountry ON ( dicapplyCountry.dic_type_code = SAR_BUSSIONESS_STAND.APPLY_COUNTRY AND dicapplyCountry.dic_id IS NOT NULL and dicapplyCountry.valid_flag = 0)
left join SAR_BUSS_STAND_MENU ON SAR_BUSSIONESS_STAND.id = SAR_BUSS_STAND_MENU.buss_stand_id
left join TS_RESOURCE on SAR_BUSS_STAND_MENU.menu_id = TS_RESOURCE.id
left join SAR_BUSS_STAND_ATTR_INFO on (SAR_BUSS_STAND_ATTR_INFO.STAND_ID = SAR_BUSSIONESS_STAND.id and SAR_BUSS_STAND_ATTR_INFO.valid_flag=0)
@@ -460,6 +451,9 @@
<if test="standStatus != null" >
and SAR_BUSSIONESS_STAND.STAND_STATUS = #{standStatus}
</if>
<if test="standEnName != null">
and SAR_BUSSIONESS_STAND.STAND_EN_NAME like concat('%', #{standEnName},'%')
</if>
<if test="advanceSearchStr != null">
and (${advanceSearchStr})
</if>
@@ -581,14 +575,7 @@
<select id="getBussionessStandInfoPage" resultMap="BaseResultMap" parameterType="com.adc.da.slrs.sarStandardsInfo.entity.SarBussionessStandEOPage">
select * from
(select tmp_tb.* from
(select <include refid="Base_Column_List_show" />,
(case WHEN dicstandStatus.DIC_TYPE_NAME = '已发布' THEN 1
WHEN dicstandStatus.DIC_TYPE_NAME = '计划修订' THEN 2
WHEN dicstandStatus.DIC_TYPE_NAME = '修订中' THEN 3
WHEN dicstandStatus.DIC_TYPE_NAME = '已修订' THEN 4
WHEN dicstandStatus.DIC_TYPE_NAME = '被替代' THEN 5
WHEN dicstandStatus.DIC_TYPE_NAME = '废止' THEN 6
WHEN dicstandStatus.DIC_TYPE_NAME IS NULL THEN 7 END) AS paixu
(select <include refid="Base_Column_List_show" />
from SAR_BUSSIONESS_STAND
<include refid="SarBussionInfo_Where_Clause"/>
GROUP BY <include refid="Group_Column_List_show"/>
@@ -45,12 +45,12 @@
left join ts_user u
on i.id=u.institution_id
<if test="userName == null">
where i.parent_id not in (select id from ts_institution)
where i.parent_id not in (select id from ts_institution) order by i.name
</if>
<if test="userName != null">
where u.uname like concat('%','${userName}','%')
where u.uname like concat('%','${userName}','%') or u.account like concat('%','${userName}','%')
</if>
</select>
@@ -68,4 +68,8 @@
</foreach>
</insert>
<delete id="clearData">
delete from ts_institution
</delete>
</mapper>
@@ -122,7 +122,31 @@
#{item}
</foreach>
</where>
group by a.ID
UNION
SELECT a.ID,a.STAND_NUMBER as standNumber,a.STAND_NAME as standName,a.STAND_EN_NAME,b.NYLX,b.SSRQ as SSRQ,b.XCXSSRQ as XCXSSRQGJ,b.ZCCSSRQ as ZCCSSRQGJ,
b.ZRBM,b.SYCPX,b.CYCVPPSBM,b.CYCVPPSCN,b.KCCVPPSBM,b.KCCVPPSCN,b.CLLX as typeApplicable,a.STAND_SORT as standSortShow,
a.STAND_YEAR as standYear,ISSUE_TIME as issueTime,a.STAND_TYPE as standType,a.TEXT_STATUS as textStatus
FROM sar_standards_info a LEFT JOIN sar_stand_attr_info b on
a.ID = b.STAND_ID
left join sar_stand_items ssi on ssi.stand_id = a.id
<where>
<if test="standName != null">
(a.STAND_NUMBER LIKE concat ('%',#{standName,jdbcType=VARCHAR},'%')
or a.STAND_NAME LIKE concat ('%',#{standName,jdbcType=VARCHAR},'%'))
and
</if>
<if test="fileType !=null">
ssi.FILE_TYPE = #{fileType} and
</if>
<if test="standType !=null">
a.STAND_TYPE = #{standType} and
</if>
a.ID IN
<foreach collection="param1" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</where>
limit #{start},#{end}
</select>
@@ -150,13 +174,36 @@
#{item}
</foreach>
</where>
group by a.ID
UNION
SELECT a.ID,a.STAND_NUMBER as standNumber,a.STAND_NAME as standName,a.STAND_EN_NAME,b.NYLX,b.SSRQ as SSRQ,b.XCXSSRQ as XCXSSRQGJ,b.ZCCSSRQ as ZCCSSRQGJ,
b.ZRBM,b.SYCPX,b.CYCVPPSBM,b.CYCVPPSCN,b.KCCVPPSBM,b.KCCVPPSCN,b.CLLX as typeApplicable,a.STAND_SORT as standSortShow,
a.STAND_YEAR as standYear,ISSUE_TIME as issueTime,a.STAND_TYPE as standType,a.TEXT_STATUS as textStatus
FROM sar_standards_info a LEFT JOIN sar_stand_attr_info b on
a.ID = b.STAND_ID
left join sar_stand_items ssi on ssi.stand_id = a.id
<where>
<if test="standName != null">
(a.STAND_NUMBER LIKE concat ('%',#{standName,jdbcType=VARCHAR},'%')
or a.STAND_NAME LIKE concat ('%',#{standName,jdbcType=VARCHAR},'%'))
and
</if>
<if test="fileType !=null">
ssi.FILE_TYPE = #{fileType} and
</if>
<if test="standType !=null">
a.STAND_TYPE = #{standType} and
</if>
a.ID IN
<foreach collection="param1" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</where>
</select>
<select id="selectTimes" resultType="com.adc.da.slrs.sarLawsAttrDetailedList.entity.StandRegionalTimeDto">
SELECT
b.country_area AS country,
a.ssrq AS ssrq,
a.ssrq AS putTime,
a.xcxssrq AS xcxssrq,
a.zccssrq AS zccssrq
FROM
@@ -32,7 +32,9 @@
p.name like concat(concat('%',#{name}),'%')
</if>
</where>
<if test=" null!= pageSize ">
limit ${(current-1) * pageSize},${pageSize}
</if>
</select>
<select id="pageTotal" resultType="Long">
@@ -50,6 +50,7 @@
</if>
<if test="sar.standSerialNumber != null and sar.standSerialNumber != '' ">
and STAND_SERIAL_NUMBER like concat(concat('%',#{sar.standSerialNumber}),'%')
or sar_stand_unqualified.STAND_NAME like concat(concat('%',#{sar.standSerialNumber}),'%')
</if>
limit #{start},#{end}
</select>
@@ -73,6 +74,7 @@
</if>
<if test="sar.standSerialNumber != null and sar.standSerialNumber != '' ">
and STAND_SERIAL_NUMBER like concat(concat('%',#{sar.standSerialNumber}),'%')
or sar_stand_unqualified.STAND_NAME like concat(concat('%',#{sar.standSerialNumber}),'%')
</if>
</select>
</mapper>
@@ -8,13 +8,15 @@
<result column="STAND_ID" property="standId"/>
<result column="ITEMS_NAME" property="itemsName"/>
<result column="ITEMS_NUM" property="itemsNum"/>
<result column="STAND_NUMBER" property="standCode"/>
<result column="STAND_NUMBER" property="standNum"/>
<result column="STAND_NAME" property="standName"/>
<result column="XCXSSRQ" property="XCXSSRQ"/>
<result column="ZCCSSRQ" property="ZCCSSRQ"/>
<result column="CLLX" property="applyType"/>
<result column="STAND_TYPE" property="standType"/>
<result column="DUTY_ENGINEER" property="dutyEngineer"/>
<result column="STAND_SORT" property="standSort"/>
<result column="STAND_YEAR" property="standYear"/>
</resultMap>
<!-- 查询条件 -->
<select id="selectWithinTerm" resultMap="resultMap" parameterType="com.adc.da.scheduled.entity.DataDTO">
@@ -25,6 +27,8 @@
items.TERMS_CONDITIONS,
items.DUTY_ENGINEER,
items.STAND_ID,
info.STAND_SORT,
info.STAND_YEAR,
info.STAND_NAME,
info.STAND_TYPE,
info.STAND_NUMBER,
@@ -60,8 +60,8 @@
SAR_STANDARDS_INFO.stand_number, SAR_STANDARDS_INFO.stand_year, SAR_STANDARDS_INFO.stand_name, SAR_STANDARDS_INFO.stand_en_name,
SAR_STANDARDS_INFO.stand_state, SAR_STANDARDS_INFO.stand_nature, SAR_STANDARDS_INFO.issue_time, SAR_STANDARDS_INFO.put_time,
concat(SAR_STANDARDS_INFO.synopsis, '') as synopsis, concat(replace_stand_num, '') as replace_stand_num, replaced_stand_num, SAR_STANDARDS_INFO.creation_user, SAR_STANDARDS_INFO.valid_flag,
SAR_STANDARDS_INFO.creation_time, SAR_STANDARDS_INFO.modify_time,dicountry.DIC_TYPE_NAME as countryShow, dicstandSort.DIC_TYPE_NAME as standSortShow,
dicstandState.DIC_TYPE_NAME as standStateShow,dicstandNature.DIC_TYPE_NAME as standNatureShow,is_relate_access,cite_stand,cited_stand,SAR_STANDARDS_INFO.text_status,SAR_STANDARDS_INFO.STAND_SYSTEM
SAR_STANDARDS_INFO.creation_time, SAR_STANDARDS_INFO.modify_time, dicstandSort.DIC_TYPE_NAME as standSortShow,
dicstandTextStatus.DIC_TYPE_NAME as standTextStatusShow,is_relate_access,cite_stand,cited_stand,SAR_STANDARDS_INFO.text_status,SAR_STANDARDS_INFO.STAND_SYSTEM
</sql>
<sql id="Group_Column_List_Show">
@@ -69,8 +69,8 @@
SAR_STANDARDS_INFO.stand_number, SAR_STANDARDS_INFO.stand_year, SAR_STANDARDS_INFO.stand_name, SAR_STANDARDS_INFO.stand_en_name,
SAR_STANDARDS_INFO.stand_state, SAR_STANDARDS_INFO.stand_nature, SAR_STANDARDS_INFO.issue_time, SAR_STANDARDS_INFO.put_time,
concat(SAR_STANDARDS_INFO.synopsis, ''), concat(replace_stand_num, ''), replaced_stand_num, SAR_STANDARDS_INFO.creation_user, SAR_STANDARDS_INFO.valid_flag,
SAR_STANDARDS_INFO.creation_time, SAR_STANDARDS_INFO.modify_time,dicountry.DIC_TYPE_NAME, dicstandSort.DIC_TYPE_NAME,
dicstandState.DIC_TYPE_NAME,dicstandNature.DIC_TYPE_NAME,is_relate_access,cite_stand,cited_stand,SAR_STANDARDS_INFO.text_status,SAR_STANDARDS_INFO.STAND_SYSTEM
SAR_STANDARDS_INFO.creation_time, SAR_STANDARDS_INFO.modify_time, dicstandSort.DIC_TYPE_NAME,
dicstandTextStatus.DIC_TYPE_NAME,is_relate_access,cite_stand,cited_stand,SAR_STANDARDS_INFO.text_status,SAR_STANDARDS_INFO.STAND_SYSTEM
</sql>
<!-- 查询条件 -->
@@ -323,8 +323,8 @@
<if test="textStatus != null" >
text_status = #{textStatus},
</if>
<if test="standSystem != null" >
stand_system = #{standSystem},
<if test="standSystem != null" >
stand_system = #{standSystem},
</if>
</set>
where id = #{id}
@@ -372,14 +372,15 @@
</select>
<sql id="SarStandardsInfo_Where_Clause">
left join TS_DICTYPE dicountry on (dicountry.dic_type_code = SAR_STANDARDS_INFO.country and dicountry.dic_id is
not null and dicountry.valid_flag = 0)
left join TS_DICTYPE dicstandSort on (dicstandSort.dic_type_code = SAR_STANDARDS_INFO.stand_sort and
dicstandSort.dic_id is not null and dicstandSort.valid_flag = 0 and dicstandSort.PARENT_ID is null)
left join TS_DICTYPE dicstandState on (dicstandState.dic_type_code = SAR_STANDARDS_INFO.stand_state and
dicstandState.dic_id is not null and dicstandState.valid_flag = 0 )
left join TS_DICTYPE dicstandNature on (dicstandNature.dic_type_code = SAR_STANDARDS_INFO.stand_nature and
dicstandNature.dic_id is not null and dicstandNature.valid_flag = 0 )
LEFT JOIN TS_DICTYPE dicstandTextStatus ON (
dicstandTextStatus.dic_type_code = SAR_STANDARDS_INFO.text_status
AND dicstandTextStatus.dic_id IS NOT NULL
AND dicstandTextStatus.valid_flag = 0
)
left join SAR_STAND_MENU ON SAR_STANDARDS_INFO.id = SAR_STAND_MENU.stand_id
left join TS_RESOURCE on SAR_STAND_MENU.menu_id = TS_RESOURCE.id
left join SAR_STAND_ATTR_INFO on (SAR_STAND_ATTR_INFO.stand_id = SAR_STANDARDS_INFO.id and SAR_STAND_ATTR_INFO.valid_flag=0)
@@ -408,6 +409,9 @@
<!-- 标准名称 -->
<if test="standName != null and standName != ''">
and stand_name like concat(concat('%',#{standName}),'%')
or STAND_NUMBER like concat(concat('%',#{standName}),'%')
or STAND_YEAR like concat(concat('%',#{standName}),'%')
or STAND_SORT like concat(concat('%',#{standName}),'%')
</if>
<if test="standEnName != null and standEnName != ''">
and stand_en_name like concat(concat('%',#{standEnName}),'%')
@@ -494,7 +498,7 @@
<if test="standSort != null and standSort != ''" >
and SAR_STANDARDS_INFO.stand_sort = #{standSort}
</if>
<!--标准年份-->
<!--标准年份-->
<if test="standYear != null and standYear != ''">
and SAR_STANDARDS_INFO.STAND_YEAR = #{standYear}
</if>
@@ -547,19 +551,7 @@
(select tmp_tb.* from
(select
<include refid="Base_Column_List_Show"/>,SAR_STAND_ATTR_INFO.CHJL AS CHJL,
(case WHEN dicstandState.DIC_TYPE_NAME = '草稿' THEN 1
WHEN dicstandState.DIC_TYPE_NAME = '征求意见稿' THEN 2
WHEN dicstandState.DIC_TYPE_NAME = '送审稿' THEN 3
WHEN dicstandState.DIC_TYPE_NAME = '报批稿' THEN 4
WHEN dicstandState.DIC_TYPE_NAME = '发布稿' THEN 5
WHEN dicstandState.DIC_TYPE_NAME = '已实施' THEN 6
WHEN dicstandState.DIC_TYPE_NAME = '计划修订' THEN 7
WHEN dicstandState.DIC_TYPE_NAME = '修订中' THEN 8
WHEN dicstandState.DIC_TYPE_NAME = '已修订' THEN 9
WHEN dicstandState.DIC_TYPE_NAME = '已作废' THEN 10
WHEN dicstandState.DIC_TYPE_NAME IS NULL THEN 11
WHEN dicstandState.DIC_TYPE_NAME ='' THEN 11
END) AS paixu,
(
CASE
WHEN ZCCSSRQ = 'TBD' THEN '6999-01-01'
@@ -595,7 +587,7 @@
) AS issueTime
from SAR_STANDARDS_INFO
<include refid="SarStandardsInfo_Where_Clause"/>
GROUP BY <include refid="Group_Column_List_Show"/>,CHJL,SAR_STAND_ATTR_INFO.XCXSSRQ,SAR_STAND_ATTR_INFO.ZCCSSRQ
GROUP BY <include refid="Group_Column_List_Show"/>,CHJL,SAR_STAND_ATTR_INFO.XCXSSRQ,SAR_STAND_ATTR_INFO.ZCCSSRQ,SAR_STAND_ATTR_INFO.SSRQ
order by
${orderBy1} ${order1},SAR_STANDARDS_INFO.id
) tmp_tb limit ${pager.startIndex-1},${pageSize}) a
@@ -646,12 +638,19 @@
</if>
</select>
<select id="queryStandInfoByList" resultMap="BaseResultMap" parameterType="java.lang.Integer">
<select id="queryStandInfoByList" resultMap="BaseResultMap">
select
<include refid="Base_Column_List"/>
FROM sar_standards_info
LEFT JOIN sar_stand_attr_info ssai ON ssai.STAND_ID = SAR_STANDARDS_INFO.ID
WHERE DATE_FORMAT(ssai.SSRQ,'%Y-%m-%D') &gt;= DATE_FORMAT(SAR_STANDARDS_INFO.ISSUE_TIME,'%Y-%m-%D')
WHERE
DATE_FORMAT(ssai.SSRQ, '%Y-%m-%d') >= DATE_FORMAT(
SAR_STANDARDS_INFO.ISSUE_TIME,
'%Y-%m-%d'
)
AND
sar_standards_info.VALID_FLAG='0'
AND TEXT_STATUS=#{typeCode}
ORDER BY SAR_STANDARDS_INFO.ISSUE_TIME DESC
LIMIT #{limit}
</select>
@@ -731,14 +730,15 @@
select
<include refid="Base_Column_List_Show"/>
from SAR_STANDARDS_INFO
left join TS_DICTYPE dicountry on (dicountry.dic_type_code = SAR_STANDARDS_INFO.country and dicountry.dic_id is
not null and dicountry.valid_flag = 0)
left join TS_DICTYPE dicstandSort on (dicstandSort.dic_type_code = SAR_STANDARDS_INFO.stand_sort and
dicstandSort.dic_id is not null and dicstandSort.valid_flag = 0 and dicstandSort.PARENT_ID is null)
left join TS_DICTYPE dicstandState on (dicstandState.dic_type_code = SAR_STANDARDS_INFO.stand_state and
dicstandState.dic_id is not null and dicstandState.valid_flag = 0 )
left join TS_DICTYPE dicstandNature on (dicstandNature.dic_type_code = SAR_STANDARDS_INFO.stand_nature and
dicstandNature.dic_id is not null and dicstandNature.valid_flag = 0 )
LEFT JOIN TS_DICTYPE dicstandTextStatus ON (
dicstandTextStatus.dic_type_code = SAR_STANDARDS_INFO.text_status
AND dicstandTextStatus.dic_id IS NOT NULL
AND dicstandTextStatus.valid_flag = 0
)
left join SAR_STAND_MENU ON SAR_STANDARDS_INFO.id = SAR_STAND_MENU.stand_id
left join TS_RESOURCE on SAR_STAND_MENU.menu_id = TS_RESOURCE.id
where SAR_STANDARDS_INFO.id = #{id}
@@ -849,14 +849,11 @@
(select
<include refid="Base_Column_List_Show"/>,SAR_STAND_ATTR_INFO.CHJL AS CHJL
from SAR_STANDARDS_INFO
left join TS_DICTYPE dicountry on (dicountry.dic_type_code = SAR_STANDARDS_INFO.country and dicountry.dic_id is
not null and dicountry.valid_flag = 0)
left join TS_DICTYPE dicstandSort on (dicstandSort.dic_type_code = SAR_STANDARDS_INFO.stand_sort and
dicstandSort.dic_id is not null and dicstandSort.valid_flag = 0 and dicstandSort.PARENT_ID is null)
left join TS_DICTYPE dicstandState on (dicstandState.dic_type_code = SAR_STANDARDS_INFO.stand_state and
dicstandState.dic_id is not null and dicstandState.valid_flag = 0 )
left join TS_DICTYPE dicstandNature on (dicstandNature.dic_type_code = SAR_STANDARDS_INFO.stand_nature and
dicstandNature.dic_id is not null and dicstandNature.valid_flag = 0 )
left join SAR_STAND_MENU ON SAR_STANDARDS_INFO.id = SAR_STAND_MENU.stand_id
left join TS_RESOURCE on SAR_STAND_MENU.menu_id = TS_RESOURCE.id
left join SAR_STAND_ATTR_INFO on (SAR_STAND_ATTR_INFO.stand_id = SAR_STANDARDS_INFO.id and SAR_STAND_ATTR_INFO.valid_flag=0)
@@ -50,7 +50,16 @@
on u.usid=up.user_id
left join ts_position p
on up.position_id=p.id
where u.institution_id=#{TsUser.institutionId}
where 1=1
<if test="TsUser.institutionId != null and TsUser.institutionId != '' ">
and u.institution_id=#{TsUser.institutionId}
</if>
<if test="TsUser.uname != null and TsUser.uname != '' ">
and u.uname like concat('%',#{TsUser.uname},'%')
</if>
<if test="TsUser.email != null and TsUser.email != '' ">
and u.email like concat('%',#{TsUser.email},'%')
</if>
</select>
<select id="getUserIdsByPositionIds" resultType="String">
@@ -195,7 +195,7 @@
<!-- 根据id查询 SAR_FILE_SPLIT_INFO -->
<select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String">
select <include refid="Base_Column_List" />
select <include refid="Base_Column_List" />
from SAR_FILE_SPLIT_INFO
where id = #{value}
@@ -290,7 +290,7 @@
<select id="queryByCountOwn" resultType="java.lang.Integer" parameterType="com.adc.da.slrs.standardSplit.entity.SarFileSplitInfoEOPage">
SELECT
count(0)
count(1)
FROM
SAR_FILE_SPLIT_INFO
LEFT JOIN SAR_STANDARDS_INFO ON SAR_FILE_SPLIT_INFO.STAND_ID = SAR_STANDARDS_INFO.id
@@ -334,4 +334,10 @@
</foreach>
</delete>
<select id="querySame" resultType="com.adc.da.slrs.standardSplit.entity.SarFileSplitItemsEO" parameterType="com.adc.da.slrs.standardSplit.entity.SarFileSplitItemsEO">
select * from SAR_FILE_SPLIT_ITEMS
LEFT JOIN SAR_FILE_SPLIT_INFO ON SAR_FILE_SPLIT_ITEMS.INFO_ID = SAR_FILE_SPLIT_INFO.ID
where SAR_FILE_SPLIT_INFO.ID = #{id}
</select>
</mapper>
@@ -294,7 +294,7 @@ public class AttFileEOController {
String suffix=fileName.substring(fileName.lastIndexOf(".")+1);
//只能在pdf中添加水印,
//非pdf文件直接下载原文件
if (suffix.equals("pdf")){
if (suffix.equals("pdf")||suffix.equals("PDF")){
downloadFilePath=waterFilePath;
}else {
downloadFilePath=oldFilePath;
@@ -21,7 +21,7 @@ public class SyncUserService {
public static void main(String[] args) throws Exception {
SyncUserService syncUserService=new SyncUserService();
syncUserService.syncFotonOrg();
syncUserService.syncFotonUser();
}
/**
@@ -50,7 +50,7 @@ public class SyncUserService {
json.add(rs);
JSONObject responseStr = JSON.parseObject(rs);
System.out.println(rs);
if (responseStr.containsKey("cookie")) {
try {
JSONArray entries = responseStr.getJSONArray("cookie");

Some files were not shown because too many files have changed in this diff Show More