Datasets:

darrel999
/

java-file-1107

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 1.11k rows

instruction stringlengths 77 90.1k
package com.chinatower.park.controller;import com.chinatower.common.entity.Result;import com.chinatower.park.common.Base64MultipartFile;import com.chinatower.park.model.FileUploadRequestVO;import com.chinatower.park.service.IFileService;import com.chinatower.system.api.request.file.ObsEncryptRequest;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.validation.annotation.Validated;import org.springframework.web.bind.annotation.;import org.springframework.web.multipart.MultipartFile;import javax.servlet.http.HttpServletResponse;import javax.validation.constraints.NotBlank;import javax.validation.constraints.NotNull;/* * @Author：zhouzhiang * @Description：文件上传下载接口 controller * @Date：2022/3/28 10:40 /@RestController@RequestMapping("/file")@Validated@Api(tags = "文件上传、下载相关接口")public class FileController { @Autowired private IFileService fileService; /* * 功能描述: 调用基础平台SDK，进行文件上传（MultipartFile） * * @param: file * @return: {@link com.chinatower.common.entity.Result} * @auther: 张莲 * @date: 2022/03/28 * @version: 上线版本 / @PostMapping(path = "/uploadOld") @ApiOperation("文件上传") public Result uploadFile(@NotNull(message = "上传文件内容不允许为空") MultipartFile file) { return fileService.uploadFile(file); } /* * 功能描述: 调用基础平台SDK，进行文件上传（Base64） * * @param: file * @return: {@link com.chinatower.common.entity.Result} * @auther: 张莲 * @date: 2022/03/28 * @version: 上线版本 / @PostMapping(path = "/upload") @ApiOperation("文件上传") public Result uploadFileForBase64(@RequestBody @Validated FileUploadRequestVO request) { String[] base64Array = request.getFile().split(","); String dataUri = base64Array[0]; String data = base64Array[1]; MultipartFile multipartFile = new Base64MultipartFile(data, request.getName(), dataUri); return fileService.uploadFile(multipartFile); } /* * 功能描述: 根据fileId，调用基础平台SDK，进行文件下载 * * @param: fileId 文件id，是调用基础平台进行上传时，基础平台返回的fileId * @auther: 张莲 * @date: 2022/03/28 * @version: 上线版本 / @GetMapping("/downloadOld/id/{fileId}") @ApiOperation("文件下载") public void downloadById(@NotBlank(message = "文件ID不允许为空") @PathVariable("fileId") String fileId, HttpServletResponse response) throws Exception { fileService.downloadFileByFileId(fileId, response); } @GetMapping("/download/id/{fileId}") @ApiOperation("文件下载") public Result downloadById(@NotBlank(message = "文件ID不允许为空") @PathVariable("fileId") String fileId) { return fileService.downloadFileByFileId(fileId); } /* * 根据参数键名下载excel模板 * @param configKey * @return */ @GetMapping("/downloadByConfigKey/id/{configKey}") @ApiOperation("文件下载") public Result downloadByConfigKey(@NotBlank(message = "参数键名不允许为空") @PathVariable("configKey") String configKey) { return fileService.downloadByConfigKey(configKey); } @PostMapping("/getObsEncryptUrl") @ApiOperation("获取obs加密串") public Result<String> getObsEncryptUrl(@RequestBody ObsEncryptRequest obsEncryptRequest) { return fileService.getObsEncryptUrl(obsEncryptRequest); }}
package com.chinatower.park.controller;import java.util.List;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 com.alibaba.fastjson.JSON;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.common.entity.Result;import com.chinatower.park.model.GridDetailVO;import com.chinatower.park.model.GridKeeperDetailVO;import com.chinatower.park.model.GridKeeperLayerRequest;import com.chinatower.park.model.GridKeeperLayerResponse;import com.chinatower.park.model.GridLayerResponse;import com.chinatower.park.model.GridParam;import com.chinatower.park.service.IGridService;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;/** * 功能描述: 网格、网格员接口controller * * @param: * @return: * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@RestController@RequestMapping("/grid")@Api(tags = "网格和网格员接口")@Slf4jpublic class GridController { @Autowired private IGridService gridService; /* * * 功能描述: 网格员数据获取（无脱敏） * * @param: gridParam 查询条件封装的实体类对象 * @return: 网格员数据 * @auther: wanglei * @date: 2022/4/25 11:07 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/findOneNoEncryptionSdk") @ApiOperation("网格员数据获取（无脱敏）") public Result findOneNoEncryptionSdk(@RequestBody GridParam gridParam) { return gridService.findOneNoEncryptionSdk(gridParam); } /* * * 功能描述: 网格员轨迹获取 * * @param: gridParam 查询条件封装的实体类对象 * @return: 网格员轨迹 * @auther: wanglei * @date: 2022/4/19 15:20 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/getKeeperTrail") @ApiOperation("网格员轨迹获取") public Result getKeeperTrail(@RequestBody GridParam gridParam) { return gridService.getKeeperTrail(gridParam); } /* * 功能描述: 查询网格树 * * @param: * @return: 网格树对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/getGridTree") @ApiOperation("查询网格树") public AjaxResult getGridTree() { GridParam gridParam = new GridParam(); AjaxResult result = gridService.getGridTree(gridParam); return result; } /* * 功能描述: 查询网格详情 * * @param: 网格查询条件封装对象类 * @return: 网格详情对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/findGridInfo") @ApiOperation("查询网格详情") public Result<GridDetailVO> findGridInfo(@RequestBody GridParam gridParam) { Long gridId = gridParam.getGridId(); if (null == gridId) { return Result.fail("必须选择网格进行查询"); } Result<GridDetailVO> result = gridService.findGridInfo(gridParam); return result; } /* * 功能描述: 查询网格员树 * * @param: * @return: 网格员树对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/getGridKeeperTree") @ApiOperation("查询网格员树") public AjaxResult getGridKeeperTree() { GridParam gridParam = new GridParam(); AjaxResult result = gridService.getGridKeeperTree(gridParam); return result; } /* * 功能描述: 查询网格员详情 * * @param: 网格查询条件封装对象类 * @return: 网格员详情对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/findGridKeeperInfo") @ApiOperation("查询网格员详情") public Result<List<GridKeeperDetailVO>> findGridKeeperInfo(@RequestBody GridParam gridParam) { Long gridId = gridParam.getGridId(); Long keeperId = gridParam.getKeeperId(); if (null == gridId && null == keeperId) { return Result.fail("必须选择网格或者网格员进行查询"); } List<GridKeeperDetailVO> list = gridService.findGridKeeperInfo(gridParam); return Result.data(list); } /* * 查询网格员图层 * @param gridKeeperLayerRequest * @return * @date 2022/3/28 * @author wanli.chen / @PostMapping("/findGridKeeperByLayer") @ApiOperation("查询网格员图层") public Result findGridKeeperByLayer(@RequestBody GridKeeperLayerRequest gridKeeperLayerRequest) { try { List<GridKeeperLayerResponse> list = gridService.findGridKeeperByLayer(gridKeeperLayerRequest); return Result.data(list); } catch (Exception ex) { log.error("查询网格员图层异常：入参=======", JSON.toJSONString(gridKeeperLayerRequest)); log.error("查询网格员图层异常信息：", ex); return Result.fail("网格员图层详情查询异常"); } } /* * 查询网格图层 * @param gridKeeperLayerRequest * @return * @date 2022/3/30 * @author wanli.chen */ @PostMapping("/findGridByLayer") @ApiOperation("查询网格图层") public Result findGridByLayer(@RequestBody GridKeeperLayerRequest gridKeeperLayerRequest) { try { List<GridLayerResponse> list = gridService.findGridByLayer(gridKeeperLayerRequest); return Result.data(list); } catch (Exception ex) { log.error("查询网格图层异常：入参=======", JSON.toJSONString(gridKeeperLayerRequest)); log.error("查询网格图层异常信息：", ex); return Result.fail("网格图层详情查询异常"); } }}
package com.chinatower.park.controller;import com.chinatower.common.entity.Result;import com.chinatower.park.model.MonitorVO;import com.chinatower.park.service.IMonitorService;import com.chinatower.outdata.api.entity.Monitor;import com.chinatower.outdata.api.entity.MonitorFake;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;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.List;@RestController@RequestMapping("/monitor")@Api(tags = "传感器设备接口")@Slf4j@RequiredArgsConstructorpublic class MonitorController { private final IMonitorService iMonitorService; @PostMapping("/queryStatusFake") @ApiOperation("查询传感器设备信息") public Result<List<MonitorFake>> queryStatusFake() { return iMonitorService.queryStatusFake(); } @PostMapping("/queryAttribute") @ApiOperation("查询传感器参数") public Result<List<Monitor>> queryAttribute(@RequestBody MonitorVO monitorVO) { return iMonitorService.queryAttribute(monitorVO); }}
package com.chinatower.park.controller;import com.chinatower.common.entity.Result;import com.chinatower.park.service.IMsgService;import com.chinatower.message.api.model.MsgBody;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;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.util.Objects;/** * @Author：zhouzhiang * @Description：内部消息转发（向目标服务器转发消息）接口 controller * @Date：2022/3/30 17:00 /@RestController@RequestMapping("/InternalForwardingMsg")@Api(tags = "内部消息转发接口")public class MsgController { @Autowired private IMsgService msgService; /* * 调用基础平台SDK，进行内部发送短信 * @return */ @PostMapping(path = "/sendMsg2TargetService") @ApiOperation("内部消息转发接口") public Result sendMsg2TargetService(MsgBody msg) { return Objects.isNull(msg) ? Result.fail("消息内容不允许为空") : msgService.sendMsg2TargetService(msg); }}
package com.chinatower.park.controller;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.park.model.ParamRequestVO;import com.chinatower.park.service.IParamService;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.validation.annotation.Validated;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;/** * 功能描述： * 参数配置接口 * @author：hued * @date：2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@RestController@RequestMapping("/param")@Api(tags = "参数配置接口")public class ParamController { @Autowired private IParamService paramService; /* * 功能描述: * 根据参数类型标识查参数 * @param: paramRequestVO 参数类型标识 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ @PostMapping("/getParamInfo") @ApiOperation("根据参数类型标识查参数") public AjaxResult getParamInfo(@RequestBody @Validated ParamRequestVO paramRequestVO) { return paramService.getParamInfo(paramRequestVO); }}
package com.chinatower.park.controller;import com.alibaba.fastjson.JSON;import com.chinatower.bdm.api.entity.ResourceConf;import com.chinatower.common.entity.Result;import com.chinatower.park.model.ResourceConfDTO;import com.chinatower.park.model.ResourceLayerResponse;import com.chinatower.park.service.IResourcesService;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;/** * * 功能描述: 资源相关接口 * * @param * @return * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@RestController@RequestMapping("/resources")@Api(tags = "资源相关接口")@Slf4jpublic class ResourcesController { @Autowired private IResourcesService resourcesService; /* * * 功能描述: 资源集合查询 * * @param resourceConfDTO * @return com.chinatower.common.entity.Result * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/selectResource") @ApiOperation("资源集合查询") public Result selectResource(@RequestBody ResourceConfDTO resourceConfDTO){ return resourcesService.selectResource(resourceConfDTO); } /* * * 功能描述: 资源单条查询 * * @param resourceConfDTO * @return com.chinatower.common.entity.Result * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @GetMapping("/getResourceInfo") @ApiOperation("资源单条查询") public Result getResourceInfo(ResourceConfDTO resourceConfDTO){ return resourcesService.getResourceInfo(resourceConfDTO); } /* * * 功能描述: 查询资源树形结构 * * @param resourceConfDTO * @return com.chinatower.common.entity.Result * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/getResourceTree") @ApiOperation("查询资源树形结构") public Result getResourceTree(@RequestBody ResourceConfDTO resourceConfDTO){ return resourcesService.getResourceTree(resourceConfDTO); } /* * 查询资源图层 * @param resourceConf * @return * @date 2022/3/28 * @author wanli.chen */ @PostMapping("/selectResourceByLayer") @ApiOperation("查询资源图层") public Result selectResourceByLayer(@RequestBody ResourceConf resourceConf) { try { List<ResourceLayerResponse> list = resourcesService.selectResourceByLayer(resourceConf); return Result.data(list); } catch (Exception ex) { log.error("查询资源图层异常：入参=======", JSON.toJSONString(resourceConf)); log.error("查询资源图层异常信息：", ex); return Result.fail("资源图层查询异常"); } }}
package com.chinatower.park.controller;import com.chinatower.common.entity.Result;import com.chinatower.park.service.ISmsService;import com.chinatower.platform.entity.request.CommonSmsRequest;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.;import java.util.Objects;/* * @Author：zhouzhiang * @Description：内部短信发送接口 controller * @Date：2022/3/30 17:00 /@RestController@RequestMapping("/sms")@Api(tags = "内部短信发送接口")public class SmsController { @Autowired private ISmsService smsService; /* * 调用基础平台SDK，进行内部发送短信 * @return */ @PostMapping(path = "/inSideSendMessage") @ApiOperation("内部发送短信接口") public Result sendMessage(@RequestBody CommonSmsRequest smsRecord) { return Objects.isNull(smsRecord) ? Result.fail("短信内容不允许为空") : smsService.sendMessage(smsRecord); }}
package com.chinatower.park.controller;import com.chinatower.analysis.api.entity.CheckpointDeviceRankingDataVO;import com.chinatower.analysis.api.entity.CheckpointTrendDataVO;import com.chinatower.common.entity.Result;import com.chinatower.park.model.StatisticsRequestVO;import com.chinatower.park.service.IStatisticsService;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;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.List;/** * 功能描述： * 卡口大屏统计相关接口 * @author：Wu.zh * @date：2022/4/28 11:40 * @version: release_v1.1 /@RestController@RequestMapping("/statistics")@Api(tags = "卡口大屏统计相关接口")public class StatisticsController { @Autowired private IStatisticsService iStatisticsService; /* * 功能描述: * 查询车流趋势统计 * @param: StatisticsRequestVO * @return: Result 结果集实体 * @auther: wu.zh * @date: 2022/4/28 11:40 * @version: release_v1.1 / @PostMapping("/getTrafficTrendStatistics") @ApiOperation("查询车流趋势统计") public Result<List<CheckpointTrendDataVO>> getTrafficTrendStatistics(@RequestBody StatisticsRequestVO statisticsRequestVO) { return iStatisticsService.getTrafficTrendStatistics(statisticsRequestVO); } /* * 功能描述: * 查询车流高频时段统计 * @param: StatisticsRequestVO * @return: Result 结果集实体 * @auther: wu.zh * @date: 2022/4/28 11:40 * @version: release_v1.1 / @PostMapping("/getHighFrequencyPeriodStatistics") @ApiOperation("查询车流趋势统计") public Result<List<CheckpointTrendDataVO>> getHighFrequencyPeriodStatistics(@RequestBody StatisticsRequestVO statisticsRequestVO) { return iStatisticsService.getHighFrequencyPeriodStatistics(statisticsRequestVO); } /* * 功能描述: * 查询卡口车流排行统计 * @param: StatisticsRequestVO * @return: Result 结果集实体 * @auther: wu.zh * @date: 2022/4/28 11:40 * @version: release_v1.1 */ @PostMapping("/getTrafficFlowRankingStatistics") @ApiOperation("查询车流趋势统计") public Result<List<CheckpointDeviceRankingDataVO>> getTrafficFlowRankingStatistics(@RequestBody StatisticsRequestVO statisticsRequestVO) { return iStatisticsService.getTrafficFlowRankingStatistics(statisticsRequestVO); }}
package com.chinatower.park.controller;import com.chinatower.common.entity.Result;import com.chinatower.park.model.ResourceTypeResultVO;import com.chinatower.park.model.SurroundRequestVO;import com.chinatower.park.model.SurroundResultVO;import com.chinatower.park.service.ISurroundService;import com.github.pagehelper.PageInfo;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.validation.annotation.Validated;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.List;/** * 功能描述： * 周边分析相关接口 * @author：hued * @date：2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@RestController@RequestMapping("/surround")@Api(tags = "周边分析相关接口")public class SurroundController { @Autowired private ISurroundService surroundService; /* * 功能描述: * 周边分析类型查询 * @param: surroundRequestVO 查询来源 1：图层下拉框 2：周边分析 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @PostMapping("/getSurroundTypeList") @ApiOperation("周边分析类型查询") public Result<List<ResourceTypeResultVO>> getSurroundTypeList(@RequestBody SurroundRequestVO surroundRequestVO) { return surroundService.getSurroundTypeList(surroundRequestVO); } /* * 功能描述: * 查询周边资源列表 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ @PostMapping("/getSurroundList") @ApiOperation("查询周边资源列表") public Result<PageInfo<SurroundResultVO>> getSurroundList(@RequestBody @Validated SurroundRequestVO SurroundRequestVO) { return surroundService.getSurroundList(SurroundRequestVO); }}
package com.chinatower.park.controller;import com.alibaba.fastjson.JSON;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.common.entity.Result;import com.chinatower.common.entity.TreeSelect;import com.chinatower.park.common.Constants;import com.chinatower.park.model.FileInfo;import com.chinatower.park.service.CommonAuthService;import com.chinatower.park.util.CommonUtils;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import com.chinatower.system.api.feign.client.SystemFeignClient;import com.chinatower.system.api.model.TreeSelectBySystem;import com.chinatower.system.api.resp.SysUserResponse;import io.swagger.annotations.Api;import lombok.extern.slf4j.Slf4j;import org.apache.commons.collections4.CollectionUtils;import org.apache.commons.lang3.StringUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.util.ObjectUtils;import org.springframework.web.bind.annotation.;import javax.annotation.Resource;import java.util.ArrayList;import java.util.List;/* * @author * @Description 用户、人员接口controller * @createTime 2022/04/02 /@RestController@Api(tags = "用户、人员接口")@Slf4jpublic class UserController { @Autowired private SystemFeignClient systemFeignClient; @Autowired private RemoteUserSecurityService remoteUserSecurityService; @Resource private CommonAuthService commonAuthService; /* * 功能描述: 获取通讯录 * * @date: 2022/04/02 * @version: release_v1.1 / @PostMapping("/base/system/user/selectUserByTenantId") public Result<List<SysUserResponse>> selectUserByTenantId(){ try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); Result<List<SysUserResponse>> result = systemFeignClient.selectUserByTenantId(sysUser.getTenantId()); if(result != null && result.getCode() == Constants.SUCCESS){ List<SysUserResponse> list = result.getData(); List<SysUserResponse> userList = new ArrayList<>(); if(CollectionUtils.isNotEmpty(list)){ List<TreeSelectBySystem> deptList = getDeptTree(); List<FileInfo> files = new ArrayList<>(); // 获取组织名称 for(SysUserResponse user : list){ if(user.getDeptId().contains(Constants.DOU_HAO)){ user.setDeptId(user.getDeptId().split(Constants.DOU_HAO)[Constants.ZERO_NUM]); } deptList.forEach(item -> { if(user.getDeptId().equals(item.getId())){ user.setDeptId(item.getLabel()); userList.add(user); if(StringUtils.isNotEmpty(user.getAvatar())){ FileInfo file = new FileInfo(); file.setId(user.getUserId()); file.setUrl(user.getAvatar()); files.add(file); } } }); } // 头像加密处理 if(CollectionUtils.isNotEmpty(files)){ List<FileInfo> newFiles = commonAuthService.getObsUrl(files); if (CollectionUtils.isNotEmpty(newFiles)){ for(FileInfo fileInfo : newFiles){ userList.forEach(item ->{ if(item.getUserId().equals(fileInfo.getId())){ item.setAvatar(fileInfo.getUrl()); } }); } } } } return Result.data(userList); }else{ return result; } } catch (Exception ex) { log.error("查询组织人员树异常信息：", ex); return Result.fail("查询组织人员树异常"); } } /* * 将组织树转成列表 * @return / private List<TreeSelectBySystem> getDeptTree(){ List<TreeSelectBySystem> data = null; try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); Result<List<TreeSelectBySystem>> result = systemFeignClient.getTenantTree(sysUser); if(result != null && result.getCode() == Constants.SUCCESS){ List<TreeSelectBySystem> list = result.getData(); if(CollectionUtils.isNotEmpty(list)){ data = new ArrayList<>(); changeData(data,list); } } return data; } catch (Exception ex) { return null; } } private void changeData(List<TreeSelectBySystem> newData,List<TreeSelectBySystem> oldData){ for(TreeSelectBySystem treeSelect : oldData){ newData.add(treeSelect); if(CollectionUtils.isNotEmpty(treeSelect.getChildren())){ changeData(newData,treeSelect.getChildren()); } } } /* * 功能描述: 查询组织人员树 * * @date: 2022/04/02 * @version: release_v1.1 / @PostMapping("/base/system/tenantDept/getTenantTree") public Result<List<TreeSelectBySystem>> getTenantTree(@RequestBody SysUser user) { try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(user, sysUser); log.info("请求查询组织人员树接口————>>>获取到当前登录人入参:{}", user); return systemFeignClient.getTenantTree(user); } catch (Exception ex) { log.error("查询组织人员树异常信息：", ex); return Result.fail("查询组织人员树异常"); } } /* * 功能描述: 根据用户编码批量查询用户信息 * * @date: 2022/11/01 / @PostMapping("/base/system/tenantDept/getListByIds") public Result<List<SysUser>> getListByUserNames(@RequestBody SysUser user) { try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(user, sysUser); log.info("请求批量查询用户信息接口————>>>获取到当前登录人入参:{}", user); AjaxResult result = systemFeignClient.getListByIds(user); if ((int) result.get(AjaxResult.CODE_TAG) == Constants.SUCCESS && !ObjectUtils.isEmpty(result.get(AjaxResult.DATA_TAG))) { return Result.data((List)result.get(AjaxResult.DATA_TAG)); }else{ return Result.fail(); } } catch (Exception ex) { log.error("根据用户编码批量查询用户信息异常：", ex); return Result.fail("查询根据用户编码批量查询用户信息异常"); } } /* * 功能描述: 查询用户列表---4/7暂定作废 * * @date: 2022/04/02 * @version: release_v1.1 / @GetMapping("/system/user/getUserList") public Result<List<SysUser>> getUserList(SysUser sysUser) { try { return systemFeignClient.getUserList(sysUser); } catch (Exception ex) { log.error("查询用户列表异常：入参======={}", JSON.toJSONString(sysUser)); log.error("查询用户列表异常信息：", ex); return Result.fail("查询用户列表异常"); } } /* * 获取组织树 * @return */ @GetMapping({"/base/system/tenantDept/getVideoTreeselect"}) public Result<List<TreeSelect>> getVideoTreeselect(){ try { return systemFeignClient.getVideoTreeselect(); } catch (Exception ex) { return Result.fail("查询组织树异常"); } }}
package com.chinatower.park.controller;import com.alibaba.fastjson.JSON;import com.chinatower.analysis.api.AnalysisAPI;import com.chinatower.analysis.api.entity.;import com.chinatower.common.entity.Result;import com.chinatower.common.page.TableDataInfo;import com.chinatower.park.model.WarningOrderInfoEntity;import com.chinatower.event.api.IFlowService;import com.chinatower.event.api.ITradeWarningOrderService;import com.chinatower.event.api.model.;import com.chinatower.event.entity.dto.;import com.chinatower.event.entity.vo.WarningOrderInfoVO;import com.chinatower.park.model.InterceptConfigVO;import com.chinatower.park.model.WarningLayerRequest;import com.chinatower.park.service.IWarningOrderService;import com.chinatower.park.util.CommonUtils;import com.chinatower.event.entity.vo.WarningOrderListVO;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.;import javax.validation.Valid;import java.util.ArrayList;import java.util.List;/** * @Auther: Wu.zh * @Date: 2022/3/28 /@RestController@Slf4jpublic class WarningOrderController { @Autowired private ITradeWarningOrderService iTradeWarningOrderService; @Autowired private IWarningOrderService warningOrderService; @Autowired private IFlowService iFlowService; @Autowired private RemoteUserSecurityService remoteUserSecurityService; @Autowired private AnalysisAPI analysisAPI; /* * 查询告警事件列表 * * @param dto * @param * @return / @PostMapping("/alarm/orderForTrade/getOrderList") public TableDataInfo getOrderList(@RequestBody TradeAlarmOrderDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); log.info("/alarm/orderForTrade/getOrderList 请求报文=={}", JSON.toJSONString(dto)); TableDataInfo tableDataInfo = iTradeWarningOrderService.getOrderList(dto); log.info("/alarm/orderForTrade/getOrderList 响应报文=={}", JSON.toJSONString(tableDataInfo)); return tableDataInfo; } /* * 查询告警事件详情 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/getOrderInfo") public Result<WarningOrderInfoEntity> getOrderInfo(@RequestBody TradeAlarmOrderDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); log.info("/alarm/orderForTrade/getOrderInfo 请求报文=={}", JSON.toJSONString(dto)); Result<WarningOrderInfoVO> result = iTradeWarningOrderService.getOrderInfo(dto); log.info("/alarm/orderForTrade/getOrderInfo 响应报文=={}", JSON.toJSONString(result)); WarningOrderInfoVO orderInfoVO = result.getData(); WarningOrderInfoEntity orderInfo = new WarningOrderInfoEntity(); BeanUtils.copyProperties(orderInfoVO, orderInfo); //是否二次研判 null-->> 0 if (orderInfo.getOrder().getIsSecondJudge() == null \|\| "".equals(orderInfo.getOrder().getIsSecondJudge())) { orderInfo.getOrder().setIsSecondJudge("0"); } // 查询是否可以编辑 TradeAlarmOrderDTO queryParam = new TradeAlarmOrderDTO(); List<String> warningOrderIds = new ArrayList<>(); warningOrderIds.add(dto.getWarningOrderId()); queryParam.setWarningOrderIds(warningOrderIds); queryParam.setPageNum(1); queryParam.setPageSize(1); TableDataInfo orderListData = this.getOrderList(queryParam); if (orderListData != null && orderListData.getRows().size() == 1) { WarningOrderListVO listDataVo = JSON.parseObject(JSON.toJSONString(orderListData.getRows().get(0)), WarningOrderListVO.class); if (listDataVo != null) { orderInfo.setIfEdit(listDataVo.getIfEdit()); } } return Result.data(orderInfo); } /* * 转领导批示 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/addLeaderAudit") public Result addLeaderAudit(@RequestBody TradeOrderLeaderAuditDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); log.info("/alarm/orderForTrade/addLeaderAudit 请求报文=={}", JSON.toJSONString(dto)); Result result = iTradeWarningOrderService.addLeaderAudit(dto); log.info("/alarm/orderForTrade/addLeaderAudit 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 事件流程流转 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/submitProcess") public Result submitProcess(@RequestBody TradeSendAlarmOrderDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); log.info("/alarm/orderForTrade/submitProcess 请求报文=={}", JSON.toJSONString(dto)); Result result = iTradeWarningOrderService.submitProcess(dto); log.info("/alarm/orderForTrade/submitProcess 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 查询告警图层 * * @param dto * @return * @date 2022/3/30 * @author wanli.chen / @PostMapping("/alarm/findWarningByLayer") @ApiOperation("查询告警图层") public Result findWarningByLayer(@RequestBody WarningLayerRequest dto) { try { return warningOrderService.findWarningByLayer(dto); } catch (Exception ex) { log.error("查询告警图层异常：入参=======", JSON.toJSONString(dto)); log.error("查询告警图层异常信息：", ex); return Result.fail("查询告警图层异常:" + ex); } } /* * 新增/取消告警收藏 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/warningOrderCollection") public Result submitProcess(@RequestBody WarningOrderCollectionDTO dto) { try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); return iTradeWarningOrderService.warningOrderCollection(dto); } catch (Exception ex) { log.error("新增/取消告警收藏异常：入参======={}", JSON.toJSONString(dto)); log.error("新增/取消告警收藏异常信息：", ex); return Result.fail("新增/取消告警收藏异常"); } } /* * 接口描述: 查询下一个流转环节 * * @param: model * @return: Result<List < ApiFlowLinkAttrModel>> * @auther: 吴宗鸿 * @date: 2022/04/06 / @PostMapping(value = "/api/flow/alarm/queryNextLink") public Result<List<ApiFlowLinkAttrModel>> queryNextLink(@RequestBody ApiFlowLinkAttrModel model) { try { return iFlowService.queryNextLink(model); } catch (Exception ex) { log.error("查询下一个流转环节异常：入参======={}", JSON.toJSONString(model)); log.error("查询下一个流转环节异常信息：", ex); return Result.fail("查询下一个流转环节异常"); } } /* * 接口描述: 查询回退环节 * * @param: model * @return: Result * @auther: 吴宗鸿 * @date: 2022/04/06 / @PostMapping({"/api/flow/alarm/queryRollbackLink"}) public Result<List<ApiFlowLinkConfigModel>> queryRollbackLink(@RequestBody ApiAlarmOrderRecordModel model) { try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(model, sysUser); return iFlowService.queryRollbackLink(model); } catch (Exception ex) { log.error("查询回退环节异常：入参======={}", JSON.toJSONString(model)); log.error("查询回退环节异常信息：", ex); return Result.fail("查询回退环节异常"); } } /* * 查询告警类型 * * @param dto * @return * @date 2022/4/7 * @author wanli.chen / @PostMapping(value = "/alarm/orderForTrade/findOrderAlarm") public Result findOrderAlarm(@RequestBody AlarmTypeDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); return iTradeWarningOrderService.findOrderAlarm(dto); } /* * 查询重复告警列表 * * @param dto * @return * @date 2022/4/7 * @author wanli.chen / @PostMapping({"/alarm/orderForTrade/getOrderListForDuplication"}) public TableDataInfo getOrderInfo(@RequestBody AlarmOrderDuplicateDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); return iTradeWarningOrderService.getOrderListForDuplication(dto); } /* * 告警核实回退 * * @param dto * @return * @date 2022/4/8 * @author wanli.chen / @PostMapping({"/alarm/orderForTrade/rollBack"}) public Result rollBack(@RequestBody TradeSendAlarmOrderDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); try { CommonUtils.setSDKCommonParam(dto, sysUser); return iTradeWarningOrderService.rollBack(dto); } catch (Exception ex) { log.error("告警核实回退异常：入参======={}", JSON.toJSONString(dto)); log.error("告警核实回退异常信息：", ex); return Result.fail("告警核实回退异常"); } } /* * 接口描述: 获取执行办理过程数据 * * @param: model * @return: Result * @auther: 吴宗鸿 * @date: 2022/04/06 / @PostMapping({"/alarm/orderForTrade/getRecordByType"}) public Result getRecordByType(@RequestBody TradeSendAlarmOrderDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); try { CommonUtils.setSDKCommonParam(dto, sysUser); return iTradeWarningOrderService.getRecordByType(dto); } catch (Exception ex) { log.error("获取执行办理过程数据异常：入参======={}", JSON.toJSONString(dto)); log.error("获取执行办理过程数据异常信息：", ex); return Result.fail("获取执行办理过程数据异常"); } } /* * 接口描述: 获取流程环节 * * @param: model * @return: Result * @auther: 吴宗鸿 * @date: 2022/05/10 / @PostMapping({"/api/flow/alarm/queryFlowLink"}) public Result<List<ApiFlowModel>> queryFlowLink(@RequestBody ApiAlarmFlowConfigModel model) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); try { CommonUtils.setSDKCommonParam(model, sysUser); return iFlowService.queryFlowLink(model); } catch (Exception ex) { log.error("获取流程环节异常：入参======={}", JSON.toJSONString(model)); log.error("获取流程环节异常信息：", ex); return Result.fail("获取流程环节异常"); } } /* * 接口描述: 查询关联告警事件信息 * * @param: dto * @return: Result * @auther: 吴宗鸿 * @date: 2022/05/10 / @PostMapping({"/alarm/orderForTrade/warningOrderInfoRel"}) public Result<List<WarningOrderInfoVO>> warningOrderInfoRel(@RequestBody WarningOrderRelDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); try { CommonUtils.setSDKCommonParam(dto, sysUser); return iTradeWarningOrderService.warningOrderInfoRel(dto); } catch (Exception ex) { log.error("查询关联告警事件信息异常：入参======={}", JSON.toJSONString(dto)); log.error("查询关联告警事件信息异常信息：", ex); return Result.fail("查询关联告警事件信息异常"); } } /* * 接口描述: 生成告警压制 * * @param: dto * @return: Result * @auther: 吴宗鸿 * @date: 2022/05/10 / @PostMapping({"/alarm/orderForTrade/createIntercept"}) public Result createIntercept(@RequestBody InterceptConfigVO vo) { try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(vo, sysUser); return warningOrderService.createIntercept(vo); } catch (Exception ex) { log.error("生成告警压制异常：入参======={}", JSON.toJSONString(vo)); log.error("生成告警压制异常信息：", ex); return Result.fail("生成告警压制异常"); } } /* * 转派调用接口 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/reassignment") public Result reassignment(@RequestBody TradeReassignmenOrdertDto dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); log.info("/alarm/orderForTrade/reassignment 请求报文=={}", JSON.toJSONString(dto)); Result result = iTradeWarningOrderService.reassignment(dto); log.info("/alarm/orderForTrade/reassignment 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 查询可转派环节接口 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/queryReassignLink") public Result queryReassignLink(@RequestBody TradeQueryReassignLinkDto dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); dto.setIndustryCode(sysUser.getIndustryCode()); dto.setAppVerCode(sysUser.getAppVerCode()); log.info("/alarm/orderForTrade/queryReassignLink 请求报文=={}", JSON.toJSONString(dto)); Result result = iTradeWarningOrderService.queryReassignLink(dto); log.info("/alarm/orderForTrade/queryReassignLink 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 查询环节处理人 * * @param model * @return / @PostMapping(value = "/alarm/orderForTrade/getFlowByIdUserTree") public Result getFlowByIdUserTree(@RequestBody FlowLinkAttrModelDTO model) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(model, sysUser); log.info("/alarm/orderForTrade/getFlowByIdUserTree 请求报文=={}", JSON.toJSONString(model)); Result result = iTradeWarningOrderService.getFlowByIdUserTree(model); log.info("/alarm/orderForTrade/getFlowByIdUserTree 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 查询环节处理人 * * @param model * @return / @PostMapping(value = "/alarm/orderForTrade/getFlowByIdUserTreeNew") public Result getFlowByIdUserTree(@RequestBody FlowLinkAttrModel model) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(model, sysUser); log.info("/alarm/orderForTrade/getFlowByIdUserTree 请求报文=={}", JSON.toJSONString(model)); Result result = iTradeWarningOrderService.getFlowByIdUserTreeNew(model); log.info("/alarm/orderForTrade/getFlowByIdUserTree 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 批量关闭事件接口 * * @param dto * @return / @PostMapping(value = "/alarm/orderForTrade/batchEndWarningOrder") public Result batchEndWarningOrder(@RequestBody BatchEndWarningOrderDTO dto) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(dto, sysUser); log.info("/alarm/orderForTrade/getFlowByIdUserTree 请求报文=={}", JSON.toJSONString(dto)); Result result = iTradeWarningOrderService.batchEndWarningOrder(dto); log.info("/alarm/orderForTrade/getFlowByIdUserTree 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 批量关闭事件接口 * * @param treeReq * @return / @PostMapping(value = "/alarm/orderForTrade/getLeaderByTenantIdShowTree") public Result getLeaderByTenantIdShowTree(@RequestBody ApiLeaderByTenantIdTreeReq treeReq) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(treeReq, sysUser); log.info("/alarm/orderForTrade/getLeaderByTenantIdShowTree 请求报文=={}", JSON.toJSONString(treeReq)); Result result = iTradeWarningOrderService.getLeaderByTenantIdShowTree(treeReq); log.info("/alarm/orderForTrade/getLeaderByTenantIdShowTree 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警受理 * * @param tradeAcceptOrderDto * @return / @PostMapping("/alarm/orderForTrade/accept") public Result accept(@RequestBody TradeAcceptOrderDto tradeAcceptOrderDto) { Result result = iTradeWarningOrderService.accept(tradeAcceptOrderDto); log.info("/alarm/order/accept 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 接口描述: 获取告警统计 * * @param: QueryParamVO * @return: Result * @auther: xieqs * @date: 2022/11/04 / @PostMapping({"/alarm/getIndustryEventStatistics"}) public Result<List<EventDataVO>> getIndustryEventStatistics(@RequestBody @Valid QueryParamVO vo) { try { log.info("/alarm/getIndustryEventStatistics 请求报文=={}", JSON.toJSONString(vo)); Result<List<EventDataVO>> industryEventStatistics = analysisAPI.getIndustryEventStatistics(vo); log.info("/alarm/getIndustryEventStatistics 响应报文=={}", JSON.toJSONString(industryEventStatistics)); return industryEventStatistics; } catch (Exception ex) { log.error("获取告警统计异常：入参======={}", JSON.toJSONString(vo)); log.error("获取告警统计异常信息：", ex); return Result.fail("获取告警统计异常"); } } /* * 接口描述: 告警数量相关统计（按租户） * * @param: AnalysisVO * @return: Result * @auther: xieqs * @date: 2022/11/08 / @PostMapping({"/alarm/getIndustryEventNum"}) public Result<EventNumVO> getIndustryEventNum(@RequestBody AnalysisVO vo) { try { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(vo, sysUser); log.info("/alarm/getIndustryEventNum 请求报文=={}", JSON.toJSONString(vo)); Result<EventNumVO> eventNumVo = analysisAPI.getIndustryEventNum(vo); log.info("/alarm/getIndustryEventNum 响应报文=={}", JSON.toJSONString(eventNumVo)); return eventNumVo; } catch (Exception ex) { log.error("告警数量相关统计（按租户）异常：入参======={}", JSON.toJSONString(vo)); log.error("告警数量相关统计（按租户）异常信息：", ex); return Result.fail("获取告警统计异常"); } } /* * 获取全部告警标签 * @return / @GetMapping("/alarm/orderForTrade/getAllAlarmTags") public Result getAllAlarmTags() { Result result = iTradeWarningOrderService.getAllAlarmTags(); log.info("/alarm/order/getAllAlarmTags 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警标签新增 * @return / @PostMapping("/alarm/orderForTrade/addTag") public Result addTag(@RequestBody AddLableDTO addLableDTO) { Result result = iTradeWarningOrderService.addTag(addLableDTO); log.info("/alarm/order/addTag 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警类型标签修改 * @return / @PostMapping("/alarm/orderForTrade/modifyTag") public Result modifyTag(@RequestBody ModifyLableDTO modifyTagDTO) { Result result = iTradeWarningOrderService.modifyTag(modifyTagDTO); log.info("/alarm/order/modifyTag 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警标签删除 * @return / @PostMapping("/alarm/orderForTrade/deleteTag") public Result deleteTag(@RequestBody DeleteLableDTO deleteLableDTO) { Result result = iTradeWarningOrderService.deleteTag(deleteLableDTO); log.info("/alarm/order/deleteTag 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 查询事件处理常用语 * @return / @PostMapping("/alarm/orderForTrade/getProcessCommonWords") public Result getProcessCommonWords() { Result result = iTradeWarningOrderService.getProcessCommonWords(); log.info("/alarm/order/getProcessCommonWords 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 编辑保存事件处理常用语 * @return / @PostMapping("/alarm/orderForTrade/updateProcessCommonWords") public Result updateProcessCommonWords(@RequestBody List<ProcessCommonWordsDTO> commonWordsDTOList) { Result result = iTradeWarningOrderService.updateProcessCommonWords(commonWordsDTOList); log.info("/alarm/order/updateProcessCommonWords 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警分享新增 * @return / @PostMapping("/alarm/orderForTrade/addShare") public Result addShare(@RequestBody AddShareDTO addShareDTO) { Result result = iTradeWarningOrderService.addShare(addShareDTO); log.info("/alarm/order/addShare 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警关联标签保存 * @return / @PostMapping("/alarm/orderForTrade/saveTagRelation") public Result saveTagRelation(@RequestBody AddLableRelationDTO addLableRelationDTO) { Result result = iTradeWarningOrderService.saveTagRelation(addLableRelationDTO); log.info("/alarm/order/saveTagRelation 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 告警对应标签查询 * @return / @GetMapping("/alarm/orderForTrade/getAlarmTagsByOrderId/{waringOrderId}") public Result getAlarmTagsByOrderId(@PathVariable("waringOrderId") String waringOrderId) { Result result = iTradeWarningOrderService.getAlarmTagsByOrderId(waringOrderId); log.info("/alarm/order/getAlarmTagsByOrderId 响应报文=={}", JSON.toJSONString(result)); return result; } /* * 根据位置及租户id行业版本获取网格信息 * @return */ @PostMapping("/alarm/orderForTrade/getGridInfoByLongitudeAndLatitude") public Result getGridInfoByLongitudeAndLatitude(@RequestBody GridInfoReq req) { Result result = iTradeWarningOrderService.getGridInfoByLongitudeAndLatitude(req); log.info("/alarm/order/getGridInfoByLongitudeAndLatitude 响应报文=={}", JSON.toJSONString(result)); return result; }}
package com.chinatower.park.controller;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.mongodb.request.QueryEntity;import com.chinatower.order.api.IWeatherApiService;import com.chinatower.platform.entity.order.QueryWeatherDTO;import com.chinatower.platform.entity.order.QueryWeatherHsitoryVO;import com.chinatower.platform.entity.order.WeatherAirDailyDTO;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.RestController;import java.util.List;/** * 功能描述： * 天气接口 * @author：xieqs * @date：2022/11/04 * @version: release_v1.1 * @requestID: /@RestController@Slf4jpublic class WeatherController { @Autowired private IWeatherApiService iWeatherApiService; /* * 功能描述: * 查询空气质量 * @param: QueryWeatherDTO 参数类型标识 * @return: Result 结果集实体 * @auther: xieqs * @date: 2022/11/04 * @version: release_v1.1 / @PostMapping("/weather/getAirNow") public Result getAirNow(@RequestBody QueryWeatherDTO queryWeatherDTO) { log.info("/weather/getAirNow 请求报文=={}", JSON.toJSONString(queryWeatherDTO)); Result<JSONObject> airNow = iWeatherApiService.getAirNow(queryWeatherDTO); log.info("/weather/getAirNow 响应报文=={}", JSON.toJSONString(airNow)); return airNow; } /* * 功能描述: * 查询实时天气 * @param: QueryWeatherDTO 参数类型标识 * @return: Result 结果集实体 * @auther: xieqs * @date: 2022/11/14 * @version: release_v1.1 / @PostMapping("/weather/getWeatherNow") public Result getWeatherNow(@RequestBody QueryWeatherDTO queryWeatherDTO) { log.info("/weather/getWeatherNow 请求报文=={}", JSON.toJSONString(queryWeatherDTO)); Result<JSONObject> weatherNow = iWeatherApiService.getWeatherNow(queryWeatherDTO); log.info("/weather/getWeatherNow 响应报文=={}", JSON.toJSONString(weatherNow)); return weatherNow; } /* * 功能描述: * 查询mongodb空气质量信息 * @param: QueryWeatherHsitoryVO 参数类型标识 * @return: Result 结果集实体 * @auther: xieqs * @date: 2022/11/14 * @version: release_v1.1 / @PostMapping("/weather/weatherAirForhistory") public Result weatherAirForhistory(@RequestBody QueryWeatherHsitoryVO queryWeatherHsitoryVO) { log.info("/weather/weatherAirForhistory 请求报文=={}", JSON.toJSONString(queryWeatherHsitoryVO)); Result<List<WeatherAirDailyDTO>> weatherList = iWeatherApiService.weatherAirForhistory(queryWeatherHsitoryVO); log.info("/weather/weatherAirForhistory 响应报文=={}", JSON.toJSONString(weatherList)); return weatherList; } /* * 功能描述: * 查询空气质量预报 * @param: QueryWeatherHsitoryVO 参数类型标识 * @return: Result 结果集实体 * @auther: xieqs * @date: 2022/11/14 * @version: release_v1.1 */ @PostMapping("/weather/getAirDay") public Result getAirDay(@RequestBody QueryWeatherDTO queryWeatherDTO) { log.info("/weather/getAirDay 请求报文=={}", JSON.toJSONString(queryWeatherDTO)); Result<JSONObject> airList = iWeatherApiService.getAirDay(queryWeatherDTO); log.info("/weather/getAirDay 响应报文=={}", JSON.toJSONString(airList)); return airList; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.park.common.Constants;import com.chinatower.park.model.AreaRequestVO;import com.chinatower.park.model.ForestryCapitalVO;import com.chinatower.park.service.IAreaService;import com.chinatower.park.util.CommonUtils;import com.chinatower.platform.entity.admin.SysArea;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import com.chinatower.system.api.feign.client.SystemFeignClient;import com.chinatower.system.api.model.AuthObjDataVO;import com.chinatower.system.api.model.DeviceTreeVO;import com.chinatower.system.api.model.SysCapitalVO;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import java.util.List;import java.util.Map;/** * 功能描述： * 行政区划接口 * @author：hued * @date：2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class AreaServiceImpl implements IAreaService { @Autowired SystemFeignClient systemFeignClient; @Autowired private RemoteUserSecurityService remoteUserSecurityService; /* * 功能描述: * 查询登录账号权限范围内的行政区划树 * @param: paramRequestVO 参数类型标识 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getAreaTree(AreaRequestVO areaRequestVO){ SysUser sysUser = new SysUser(); BeanUtils.copyProperties(areaRequestVO,sysUser); log.info(Constants._PARAM_SDK_PROVIDER + "-查询登录账号权限范围内的行政区划树-/video-system/system/user/getRegionTree" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(sysUser)); Result<List<DeviceTreeVO>> result = systemFeignClient.getRegionTree(sysUser); log.info(Constants._PARAM_SDK_PROVIDER + "-查询登录账号权限范围内的行政区划树-/video-system/system/user/getRegionTree" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); String dateStr = JSONObject.toJSONString(result); Map<String, Object> dataMap = JSON.parseObject(dateStr); List<JSONObject> list = (List<JSONObject>) dataMap.get(Constants.DATA_STRING); if (result.getCode() == Constants.SUCCESS && !CollectionUtils.isEmpty(list)) { for(JSONObject pro : list){ List<JSONObject> cityList = (List<JSONObject>)pro.get(Constants.LIST_STRING); for(JSONObject city : cityList){ List<JSONObject> conList = (List<JSONObject>)city.get(Constants.LIST_STRING); for(JSONObject con : conList){ List<JSONObject> baseList = (List<JSONObject>)con.get(Constants.LIST_STRING); if(CollectionUtils.isEmpty(baseList)){ con.remove(Constants.LIST_STRING); } } } } return Result.data(list); }else{ return result; } } @Override public Result getRegion(SysArea sysArea) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(sysArea, sysUser); log.info("/video-system/system/user/getRegion 请求报文=={}", JSONObject.toJSONString(sysArea)); Result result = systemFeignClient.getRegion(sysArea); log.info("/video-system/system/user/getRegion 响应报文=={}", JSONObject.toJSONString(result)); return result; } /* * 功能描述: * 查询登录账号数据权限 * @param: * @return: Result 结果集实体 * @auther: hued * @date: 2022年4月29日14:14:58 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getDataScopeObj() { Result<AuthObjDataVO> result = systemFeignClient.getDataScopeObj(); log.info(Constants._PARAM_SDK_PROVIDER + "-查询登录账号数据权限-/video-system/system/business/getDataScopeObj" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: * 根据省份编码查询省会信息 * @param: * @return: Result 结果集实体 * @auther: hued * @date: 2022年5月16日16:21:28 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ @Override public Result getSysCapital(ForestryCapitalVO vo) { SysCapitalVO sysCapitalVO = new SysCapitalVO(); BeanUtils.copyProperties(vo,sysCapitalVO); log.info(Constants._PARAM_SDK_PROVIDER + "-查询省会-/video-system/system/area/getSysCapital" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(sysCapitalVO)); Result<SysCapitalVO> result = systemFeignClient.getSysCapital(sysCapitalVO); log.info(Constants._PARAM_SDK_PROVIDER + "-查询省会-/video-system/system/area/getSysCapital" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.park.common.Constants;import com.chinatower.park.model.CommonlyRequestVO;import com.chinatower.park.service.ICommonlyService;import com.chinatower.system.api.feign.client.SystemFeignClient;import com.chinatower.system.api.model.VmCommonWordsVO;import com.chinatower.system.api.request.words.wordsRequest;import lombok.extern.log4j.Log4j2;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;/** * 功能描述： * 常用语接口 * @author：hued * @date：2022年4月19日14:15:03 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865983__隐患排查 /@Service@Log4j2public class CommonlyServiceImpl implements ICommonlyService { @Autowired SystemFeignClient systemFeignClient; /* * 功能描述: * 查询常用语列表 * @param: commonlyRequestVO * @return: Result * @auther: hued * @date: 2022年4月19日14:15:03 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865983__隐患排查 / public Result getCommonlyList(CommonlyRequestVO commonlyRequestVO){ wordsRequest words = new wordsRequest(); BeanUtils.copyProperties(commonlyRequestVO,words); log.info(Constants._PARAM_SDK_PROVIDER + "-查询常用语列表-/video-system/system/commonWords/getCommonWords" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(words)); Result<List<VmCommonWordsVO>> result = systemFeignClient.getCommonWords(words); log.info(Constants._PARAM_SDK_PROVIDER + "-查询常用语列表-/video-system/system/commonWords/getCommonWords" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: * 添加常用语 * @param: commonlyRequestVO 参数类型标识 * @return: Result 结果集实体 * @auther: hued * @date: 2022年4月19日14:15:03 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865983__隐患排查 / public Result addCommonly(CommonlyRequestVO commonlyRequestVO){ wordsRequest words = new wordsRequest(); BeanUtils.copyProperties(commonlyRequestVO,words); log.info(Constants._PARAM_SDK_PROVIDER + "-添加常用语-/video-system/system/commonWords/addCommonWords" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(words)); Result result = systemFeignClient.addCommonWords(words); log.info(Constants._PARAM_SDK_PROVIDER + "-添加常用语-/video-system/system/commonWords/addCommonWords" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: * 变更常用语 * @param: commonlyRequestVO 参数类型标识 * @return: Result 结果集实体 * @auther: hued * @date: 2022年4月19日14:15:03 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865983__隐患排查 / public Result updateCommonly(CommonlyRequestVO commonlyRequestVO){ wordsRequest words = new wordsRequest(); BeanUtils.copyProperties(commonlyRequestVO,words); log.info(Constants._PARAM_SDK_PROVIDER + "-变更常用语-/video-system/system/commonWords/updateCommonWords" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(words)); Result<Integer> result = systemFeignClient.updateCommonWords(words); log.info(Constants._PARAM_SDK_PROVIDER + "-变更常用语-/video-system/system/commonWords/updateCommonWords" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: * 删除常用语 * @param: commonlyRequestVO 参数类型标识 * @return: Result 结果集实体 * @auther: hued * @date: 2022年4月19日14:15:03 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865983__隐患排查 */ public Result deleteCommonly(CommonlyRequestVO commonlyRequestVO){ wordsRequest words = new wordsRequest(); BeanUtils.copyProperties(commonlyRequestVO,words); log.info(Constants._PARAM_SDK_PROVIDER + "-删除常用语-/video-system/system/commonWords/deleteCommonWordsByWordsId" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(words)); Result<Integer> result = systemFeignClient.deleteCommonWordsByWordsId(words); log.info(Constants._PARAM_SDK_PROVIDER + "-删除常用语-/video-system/system/commonWords/deleteCommonWordsByWordsId" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.analysis.api.AnalysisAPI;import com.chinatower.analysis.api.entity.AnalysisVO;import com.chinatower.analysis.api.entity.DeviceStatisticsVO;import com.chinatower.common.entity.Result;import com.chinatower.common.page.TableDataInfo;import com.chinatower.device.entity.dto.DeviceModelDTO;import com.chinatower.park.common.Constants;import com.chinatower.park.model.;import com.chinatower.park.service.IDeviceService;import com.chinatower.industry.api.IIndustryDeviceService;import com.chinatower.industry.dto.DeviceIndDTO;import com.chinatower.industry.dto.DeviceIndReqDTO;import com.chinatower.industry.dto.DeviceLayerReq;import com.chinatower.industry.vo.IndChannelInfoVO;import com.chinatower.industry.vo.IndustryDeviceTree;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.platform.entity.device.PageDeviceVO;import com.chinatower.redis.enums.RedisDBType;import com.chinatower.redis.util.RedisUtil;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import com.chinatower.system.api.feign.client.SystemFeignClient;import com.chinatower.system.api.resp.SysDictDataResponse;import com.chinatower.video.api.VideoControlAPI;import com.chinatower.video.api.VideoPlayerAPI;import com.chinatower.video.api.entity.DoPtzLocationCmdReq;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import org.springframework.util.StringUtils;import org.springframework.web.bind.annotation.RequestBody;import javax.annotation.Resource;import java.lang.reflect.Field;import java.util.ArrayList;import java.util.Collections;import java.util.List;/* * 功能描述： * 摄像机相关接口 * * @author：hued * @date：2022/3/15 16:05 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class DeviceServiceImpl implements IDeviceService { @Autowired IIndustryDeviceService industryDeviceService; @Autowired VideoPlayerAPI videoPlayerAPI; @Autowired private SystemFeignClient systemFeignClient; @Autowired private VideoControlAPI videoControlAPI; @Autowired private AnalysisAPI analysisAPI; @Resource private RemoteUserSecurityService remoteUserSecurityService; /* * 功能描述: * 根据站址编码查询摄像机列表 * @param: deviceRequestVO 查询实体 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/15 16:05 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getVideoList(DeviceRequestVO deviceRequestVO){ DeviceIndReqDTO deviceIndReqDTO = new DeviceIndReqDTO(); BeanUtils.copyProperties(deviceRequestVO,deviceIndReqDTO); log.info(Constants._PARAM_SDK_PROVIDER + "-站址信息查询设备-/video-device/industry/device/queryDevicesBySite" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(deviceIndReqDTO)); Result<List<DeviceIndDTO>> result = industryDeviceService.queryDevicesBySite(deviceIndReqDTO); log.info(Constants._PARAM_SDK_PROVIDER + "-站址信息查询设备-/video-device/industry/device/queryDevicesBySite" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); if (result.getCode() == Constants.SUCCESS && !CollectionUtils.isEmpty(result.getData())) { List<DeviceIndDTO> dataList = result.getData(); //根据挂高正序排列 Collections.sort(dataList, (o1, o2) -> { if (Double.parseDouble(StringUtils.isEmpty(o1.getHeight()) ? Constants.ZERO_FLAG : o1.getHeight()) - Double.parseDouble(StringUtils.isEmpty(o2.getHeight()) ? Constants.ZERO_FLAG : o2.getHeight()) >= 0) { return 1; }else { return -1; } }); //倒序 Collections.reverse(dataList); return Result.data(dataList); }else{ return result; } } /* * 功能描述: * 侦测-查询摄像机列表及实时流 * @param: deviceRequestVO 查询实体 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/15 16:05 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getVideoAndUrl(DeviceRequestVO deviceRequestVO){ DetectResultVO resultVO = new DetectResultVO(); List<SiteVO> siteList = new ArrayList<>(); List<UrlVO> urlList = new ArrayList<>(); String deviceCode = deviceRequestVO.getDeviceCode(); String channelCode = deviceRequestVO.getChannelCode(); //调通用平台摄像机列表查询接口（站址在地图打点） DeviceLayerReq deviceLayerReq = new DeviceLayerReq(); BeanUtils.copyProperties(deviceRequestVO,deviceLayerReq); deviceLayerReq.setLongitude(StringUtils.isEmpty(deviceRequestVO.getLongitude())?0:Double.parseDouble(deviceRequestVO.getLongitude())); deviceLayerReq.setLatitude(StringUtils.isEmpty(deviceRequestVO.getLatitude())?0:Double.parseDouble(deviceRequestVO.getLatitude())); //侦测默认搜索3公里范围内 deviceLayerReq.setDistance(String.valueOf(Integer.parseInt(Constants.THREE_FLAG)1000)); log.info(Constants._PARAM_SDK_PROVIDER + "-查询摄像机图层-/video-device/industry/device/queryDeviceLayer" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(deviceLayerReq)); Result<List<IndustryDeviceTree>> idResult = industryDeviceService.queryDeviceLayer(deviceLayerReq); log.info(Constants._PARAM_SDK_PROVIDER + "-查询摄像机图层-/video-device/industry/device/queryDeviceLayer" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(idResult)); if (idResult.getCode() == Constants.SUCCESS ) { if (!CollectionUtils.isEmpty(idResult.getData())) { List<IndustryDeviceTree> result = idResult.getData(); //循环站址 for (IndustryDeviceTree siteInfo : result) { SiteVO siteVO = new SiteVO(); //默认在线 siteVO.setStatus(Constants.ZERO_FLAG); BeanUtils.copyProperties(siteInfo, siteVO); //站址下只有一个设备，且该设备状态为离线，将站址状态置为离线 if(siteInfo.getList().size() == Constants.ONE_NUM && siteInfo.getList().get(0).getDeviceStatus().equals(Constants.ONE_FLAG)){ siteVO.setStatus(Constants.ONE_FLAG); } siteList.add(siteVO); //取距离最近的5个通道 if (urlList.size() >= Constants.FIVE_NUM) { } else { //循环站址下设备 device: for(IndustryDeviceTree deviceInfo : siteInfo.getList()) { //循环站址下设备下通道 for(IndChannelInfoVO channelInfo : deviceInfo.getChannelInfoVOList()) { if (channelInfo.getChannelStatus() == Constants.ZERO_NUM && (Constants.ZERO_FLAG.equals(deviceInfo.getDeviceStatus()))) { //告警事件-关联事件，去掉本身设备通道 if (!StringUtils.isEmpty(channelCode) && !StringUtils.isEmpty(deviceCode)) { if((deviceCode).equals(deviceInfo.getDeviceCode()) && (channelCode).equals(channelInfo.getChannelCode())){ continue ; } } UrlVO urlVO = new UrlVO(); urlVO.setDeviceCode(deviceInfo.getDeviceCode()); urlVO.setChannelCode(channelInfo.getChannelCode()); urlVO.setLatitude(siteInfo.getLatitude()); urlVO.setLongitude(siteInfo.getLongitude()); urlList.add(urlVO); } if (urlList.size() == Constants.FIVE_NUM) { break device; } } } } } if (urlList.size() == Constants.ZERO_NUM) { return Result.fail(Constants.VIDEO_AND_URL_MSG_1); } resultVO.setSiteList(siteList); resultVO.setUrlList(urlList); return Result.data(resultVO); }else{ return Result.fail(Constants.VIDEO_AND_URL_MSG_1); } }else{ return idResult; } } /** * 功能描述: * 查看摄像机信息 * @param: deviceRequestVO 查询实体 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/15 16:05 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getDeviceInfo(DeviceRequestVO deviceRequestVO){ DeviceIndReqDTO deviceIndReqDTO = new DeviceIndReqDTO(); BeanUtils.copyProperties(deviceRequestVO,deviceIndReqDTO); log.info(Constants._PARAM_SDK_PROVIDER + "-查询摄像头信息-/video-device/industry/device/getDeviceChannel" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(deviceIndReqDTO)); Result<DeviceIndDTO> result = industryDeviceService.getDeviceChannel(deviceIndReqDTO); log.info(Constants._PARAM_SDK_PROVIDER + "-查询摄像头信息-/video-device/industry/device/getDeviceChannel" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 查询摄像机图层 * @param deviceLayerReq * @return / @Override public Result queryDeviceLayer(DeviceRequestVO deviceLayerReq) { DeviceLayerReq deviceIndReq = new DeviceLayerReq(); BeanUtils.copyProperties(deviceLayerReq,deviceIndReq); log.info("/video-device/industry/device/queryDeviceLayer 请求报文=={}", JSONObject.toJSONString(deviceIndReq)); Result<List<IndustryDeviceTree>> result = industryDeviceService.queryDeviceLayer(deviceIndReq); log.info("/video-device/industry/device/queryDeviceLayer 响应报文=={}", JSONObject.toJSONString(result)); if (result.getCode() == Constants.SUCCESS) { if (!CollectionUtils.isEmpty(result.getData())) { List<DeviceLayerResponse> resultList = new ArrayList<>(result.getData().size()); result.getData().forEach(item -> { DeviceLayerResponse response = new DeviceLayerResponse(); BeanUtils.copyProperties(item, response); List<DeviceLayerResponse> deviceInfoList = new ArrayList<>(); if (!CollectionUtils.isEmpty(item.getList())) { item.getList().forEach(device -> { DeviceLayerResponse deviceInfo = new DeviceLayerResponse(); BeanUtils.copyProperties(device, deviceInfo); deviceInfoList.add(deviceInfo); }); } response.setList(deviceInfoList); resultList.add(response); }); return Result.data(resultList); } else { return result; } } else { return result; } } /* * 查询摄像机可视域 * @param deviceRequestVO * @return / @Override public Result<DeviceModelDTO> queryDeviceVisual(DeviceRequestVO deviceRequestVO) { DeviceIndReqDTO deviceIndReq = new DeviceIndReqDTO(); BeanUtils.copyProperties(deviceRequestVO, deviceIndReq); log.info("/video-device/getDeviceModelInfo 请求报文=={}", JSONObject.toJSONString(deviceIndReq)); Result<DeviceModelDTO> result = industryDeviceService.getDeviceModelInfo(deviceIndReq); log.info("/video-device/getDeviceModelInfo 返回报文=={}", JSONObject.toJSONString(result)); if (result.getCode() == Constants.SUCCESS) { DeviceModelDTO construct; if (null != result.getData()) { construct = result.getData(); } else { construct = new DeviceModelDTO(); construct.setDeviceCode(deviceRequestVO.getDeviceCode()); } splicingParam(construct); return Result.data(construct); } else { return result; } } /* * 根据站址里列表查询摄像机可视域 * @param deviceRequestVO * @return / / 0530 暂时注释确认后删除 / @Override public Result<List<DeviceModelDTO>> getDeviceVisibleBySiteV2(DeviceRequestVO deviceRequestVO) { DeviceIndReqDTO deviceIndReq = new DeviceIndReqDTO(); BeanUtils.copyProperties(deviceRequestVO, deviceIndReq); log.info("/video-device/getDeviceVisibleBySite 请求报文=={}", JSONObject.toJSONString(deviceIndReq)); Result<List<DeviceModelDTO>> result = industryDeviceService.getDeviceVisibleBySite(deviceIndReq); log.info("/video-device/getDeviceVisibleBySite 返回报文=={}", JSONObject.toJSONString(result)); return result; } /* * 05/16 返回无数据是拼接上某些参数。 / public void splicingParam(DeviceModelDTO construct) { construct.setLongitude(construct.getLongitude() != null ? construct.getLongitude() : "116.84034"); construct.setLatitude(construct.getLatitude() != null ? construct.getLatitude() : "39.890242"); construct.setHeight(construct.getHeight() != null ? construct.getHeight() : "10"); construct.setVisualRange(construct.getVisualRange() != null ? construct.getVisualRange() : "10"); construct.setHorizRange(construct.getHorizRange() != null ? construct.getHorizRange() : "30"); construct.setVertiRange(construct.getVertiRange() != null ? construct.getVertiRange() : "30"); construct.setHorizViewRange(construct.getHorizViewRange() != null ? construct.getHorizViewRange() : "180"); construct.setVertiViewRange(construct.getVertiViewRange() != null ? construct.getVertiViewRange() : "10"); } /* * 根据站址里列表查询摄像机可视域 * * @param deviceRequestVO * @return / @Override public Result<List<DeviceModelDTO>> getDeviceVisibleBySite(DeviceRequestVO deviceRequestVO) { DeviceIndReqDTO deviceIndReq = new DeviceIndReqDTO(); BeanUtils.copyProperties(deviceRequestVO, deviceIndReq); log.info("/video-device/getDeviceVisibleBySite 请求报文=={}", JSONObject.toJSONString(deviceIndReq)); Result<List<DeviceModelDTO>> result = industryDeviceService.getDeviceVisibleBySite(deviceIndReq); log.info("/video-device/getDeviceVisibleBySite 返回报文=={}", JSONObject.toJSONString(result)); List<DeviceModelDTO> modelList = result.getData(); if (CollectionUtils.isEmpty(modelList)) { modelList = new ArrayList<>(); } List<String> deviceCodes = deviceRequestVO.getDeviceCodes(); if (deviceCodes.size() > Constants.ZERO_NUM) { //获取配置增加的水平偏转角、初始化水平偏转角 String horizViewRangeInit = ""; String increaseAngle = ""; List<SysDictDataResponse> statusList = systemFeignClient.dictDataType(Constants.VISIBILITY_PARAM).getData(); log.info("/base/system/dict/data/dictDataType/{dictType} 响应报文=={}", JSONObject.toJSONString(statusList)); for (SysDictDataResponse sysDictDataResponse : statusList) { if ("初始化水平偏转角".equals(sysDictDataResponse.getDictLabel())) { horizViewRangeInit = sysDictDataResponse.getDictValue(); } if ("水平偏转角增加量".equals(sysDictDataResponse.getDictLabel())) { increaseAngle = sysDictDataResponse.getDictValue(); } } for (String deviceCode : deviceCodes) { if (modelList.stream().noneMatch(item -> deviceCode.equals(item.getDeviceCode()))) { DeviceModelDTO construct; //不存在则查询缓存 String cacheKey = Constants.REDIS_VISIBILITY + deviceCode; construct = RedisUtil.get(cacheKey, DeviceModelDTO.class, RedisDBType.PRIMARY); if (!checkObjFieldIsNotNull(construct)) { //缓存没取到，初始化 construct = new DeviceModelDTO(); construct.setDeviceCode(deviceCode); construct.setLongitude("116.84034"); construct.setLatitude("39.890242"); construct.setHeight("10"); construct.setVisualRange("3"); construct.setHorizRange("30"); construct.setVertiRange("30"); construct.setHorizViewRange(horizViewRangeInit); construct.setVertiViewRange("10"); } else { String horizViewRangeOld = construct.getHorizViewRange(); construct.setHorizViewRange(String.valueOf((Integer.parseInt(horizViewRangeOld) + Integer.parseInt(increaseAngle)) % 360)); } RedisUtil.set(cacheKey, construct, 3600, RedisDBType.PRIMARY); modelList.add(construct); } } } else { for (DeviceModelDTO construct : modelList) { splicingParam(construct); } Result<List<DeviceModelDTO>> resultFinal = Result.data(modelList); log.info("/video-device/getDeviceVisibleBySite 最终返回报文=={}", JSONObject.toJSONString(resultFinal)); return resultFinal; } Result<List<DeviceModelDTO>> resultFinal = Result.data(modelList); log.info("/video-device/getDeviceVisibleBySite 最终返回报文=={}", JSONObject.toJSONString(resultFinal)); return resultFinal; } /* * 判断实体类非空~ * true 不为空 false 为空 / public static boolean checkObjFieldIsNotNull(Object obj) { boolean flag = false; try { for (Field f : obj.getClass().getDeclaredFields()) { if (f.get(obj) != null && f.get(obj) != "") { flag = true; } } } catch (Exception e) { return false; } return flag; } /* * 功能描述: * 6.1.5. 转到指定PTZ位置 * @param: deviceRequestVO 查询实体 * @return: Result 结果集实体 * @auther: hued * @date: 2022年6月27日11:36:49 * @version: release_v1.4 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result doPtzLocationCmd(@RequestBody DeviceRequestVO deviceRequestVO) { DoPtzLocationCmdReq doPtzLocationCmdReq = new DoPtzLocationCmdReq(); BeanUtils.copyProperties(deviceRequestVO, doPtzLocationCmdReq); log.info(Constants._PARAM_SDK_PROVIDER + "-转到指定PTZ位置-/video-video/video/control/doPtzLocationCmd" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(doPtzLocationCmdReq)); Result result = videoControlAPI.doPtzLocationCmd(doPtzLocationCmdReq); log.info(Constants._PARAM_SDK_PROVIDER + "-转到指定PTZ位置-/video-video/video/control/doPtzLocationCmd" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能说明:查询行业设备传感器信息 * * @param pageDeviceVO * @param: deviceRequestVO 查询实体 * @return: TableDataInfo * @auther: zzh * @date: 2022-10-24 * @requestID: */ @Override public TableDataInfo pageIndSensorDevice(PageDeviceVO pageDeviceVO) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); pageDeviceVO.setTenantId(sysUser.getTenantId()); log.info(Constants._PARAM_SDK_PROVIDER + "-查询行业设备传感器信息-/video-device/industry/device/pageIndSensorDevice" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(pageDeviceVO)); TableDataInfo result = industryDeviceService.pageIndSensorDevice(pageDeviceVO); log.info(Constants._PARAM_SDK_PROVIDER + "-查询行业设备传感器信息-/video-device/video/control/pageIndSensorDevice" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } @Override public Result<DeviceStatisticsVO> getCameraSum() { AnalysisVO analysisVO = new AnalysisVO(); SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); analysisVO.setTenantId(sysUser.getTenantId()); log.info(Constants._PARAM_SDK_PROVIDER + "-统计摄像头数量信息-/video-device/getCameraSum" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(analysisVO)); Result<DeviceStatisticsVO> result = analysisAPI.getIndustryDeviceStatistics(analysisVO); log.info(Constants._PARAM_SDK_PROVIDER + "-统计摄像头数量信息-/video-device/getCameraSum" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.device.entity.dto.UserDeviceCollectionDTO;import com.chinatower.park.common.Constants;import com.chinatower.park.model.DeviceTreeRequestVO;import com.chinatower.park.service.IDeviceTreeService;import com.chinatower.industry.api.IIndustryDeviceService;import com.chinatower.industry.dto.MonitorTreeInfReq;import com.chinatower.industry.vo.IndustryDeviceTree;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import java.util.ArrayList;import java.util.List;/** * 功能描述： * 摄像机树相关接口 * @author：hued * @date：2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class DeviceTreeServiceImpl implements IDeviceTreeService { @Autowired IIndustryDeviceService industryDeviceService; /* * 功能描述: * 查询摄像机树 * @param: deviceTreeReqVO 查询实体 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result<List<IndustryDeviceTree>> getVideoTree(DeviceTreeRequestVO videoTreeReqVO){ MonitorTreeInfReq monitorTreeInfReq = new MonitorTreeInfReq(); BeanUtils.copyProperties(videoTreeReqVO,monitorTreeInfReq); log.info(Constants._PARAM_SDK_PROVIDER + "-查询摄像机树-/video-device/industry/device/queryMonitorIndTree" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(monitorTreeInfReq)); Result<List<IndustryDeviceTree>> result = industryDeviceService.queryMonitorIndTree(monitorTreeInfReq); log.info(Constants._PARAM_SDK_PROVIDER + "-查询摄像机树-/video-device/industry/device/queryMonitorIndTree" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); List<IndustryDeviceTree> data = new ArrayList<>(); if(result.getCode() == Constants.SUCCESS && !CollectionUtils.isEmpty(result.getData())){ //按标签展示 if(videoTreeReqVO.getDisplayMode() == Constants.THREE_NUM){ IndustryDeviceTree root = new IndustryDeviceTree(); root.setCode(Constants.LABEL_ROOT_CODE); root.setName(Constants.LABEL_ROOT_NAME); root.setLevel(Constants.ZERO_FLAG); root.setList(result.getData()); data.add(root); } //按区域展示 else if(videoTreeReqVO.getDisplayMode() == Constants.ONE_NUM){ IndustryDeviceTree root = new IndustryDeviceTree(); root.setCode(Constants.AREA_ROOT_CODE); root.setName(Constants.AREA_ROOT_NAME); root.setLevel(Constants.ZERO_FLAG); root.setList(result.getData()); data.add(root); }else{ data = result.getData(); } } return Result.data(data); } /* * 功能描述: * 添加/取消摄像机树到收藏夹 * @param: deviceTreeReqVO 查询实体 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ @Override public Result addDeviceToFavorites(DeviceTreeRequestVO videoTreeReqVO){ UserDeviceCollectionDTO userDeviceCollectionDTO = new UserDeviceCollectionDTO(); BeanUtils.copyProperties(videoTreeReqVO,userDeviceCollectionDTO); log.info(Constants._PARAM_SDK_PROVIDER + "-添加/取消摄像机树到收藏夹-/video-device/industry/device/addOrCancelCollections" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(userDeviceCollectionDTO)); Result result = industryDeviceService.addOrCancelCollections(userDeviceCollectionDTO); log.info(Constants._PARAM_SDK_PROVIDER + "-添加/取消摄像机树到收藏夹-/video-device/industry/device/addOrCancelCollections" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; }}
package com.chinatower.park.service.impl;import cn.hutool.core.map.MapUtil;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.park.common.Constants;import com.chinatower.park.service.IDictService;import com.chinatower.system.api.feign.client.SystemFeignClient;import com.chinatower.system.api.resp.SysDictDataResponse;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.HashMap;import java.util.List;import java.util.Map;/** * 功能描述： * 枚举值接口 * @author：hued * @date：2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class DictServiceImpl implements IDictService { @Autowired private SystemFeignClient systemFeignClient; /* * 功能描述: * 根据字典类型标识查字典项 --web端一次调用，接口批量处理返回 * @param: dictTypes 字典类型数组 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ @Override public Result<Map<String,List<SysDictDataResponse>>> dictDataType(String[] dictTypes) { Map<String,List<SysDictDataResponse>> result = new HashMap<>(); for (String dictType : dictTypes){ log.info(Constants._PARAM_SDK_PROVIDER + "-根据字典类型查询字典数据信息-/base/system/dict/data/dictDataType" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(dictType)); Result<List<SysDictDataResponse>> tyResult = systemFeignClient.dictDataType(dictType); log.info(Constants._PARAM_SDK_PROVIDER + "-根据字典类型查询字典数据信息-/base/system/dict/data/dictDataType" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); if(tyResult.getCode() == Constants.SUCCESS){ result.put(dictType,tyResult.getData()); } } if (MapUtil.isEmpty(result)) { return Result.fail("未查询到数据！"); }else { return Result.data(result); } }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.common.core.web.domain.ApiResult;import com.chinatower.common.entity.Result;import com.chinatower.common.entity.ResultCode;import com.chinatower.park.common.Constants;import com.chinatower.park.service.IFileService;import com.chinatower.park.util.CommonUtils;import com.chinatower.platform.common.utils.FileUtils;import com.chinatower.platform.entity.admin.SysConfig;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.system.api.feign.client.ObsEncryptFeignClient;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import com.chinatower.system.api.feign.client.SystemFeignClient;import com.chinatower.system.api.request.file.ObsEncryptRequest;import com.chinatower.system.api.resp.ObsEncryptResponse;import com.chinatower.system.api.resp.SysFileInfoResponse;import lombok.extern.slf4j.Slf4j;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import org.springframework.util.ObjectUtils;import org.springframework.web.multipart.MultipartFile;import javax.servlet.http.HttpServletResponse;import java.util.;/* * @Author：zhouzhiang * @Description：文件上传下载接口 * @Date：2022/3/28 10:40 /@Service@Slf4jpublic class FileServiceImpl implements IFileService { private static final Logger logger = LoggerFactory.getLogger(FileServiceImpl.class); @Autowired private SystemFeignClient systemFeignClient; @Autowired private ObsEncryptFeignClient obsEncryptFeignClient; @Autowired private RemoteUserSecurityService remoteUserSecurityService; /* * 调用基础平台SDK，进行文件上传 * @return / @Override public Result uploadFile(MultipartFile file) { logger.info("调用基础平台进行文件上传，文件名称：{}，大小：{}", file.getName(), file.getSize()); Result result = systemFeignClient.uploadFile2Video(file); logger.info("调用基础平台进行文件上传，基础平台返回：{}", result); if (result.getCode() == ResultCode.SUCCESS.getCode()) { Map<String, Object> dataMap = JSON.parseObject(JSON.toJSONString(result.getData()), Map.class); String fileUrl = dataMap.get("fileUrl").toString(); List<String> urls = new ArrayList<>(); urls.add(fileUrl); ObsEncryptRequest obsEncryptRequest = new ObsEncryptRequest(); obsEncryptRequest.setFileUrls(urls); log.info("/file/obsFiles/getObsEncryptUrls,{}", obsEncryptRequest); ApiResult obsEncryptUrls = obsEncryptFeignClient.getObsEncryptUrls(obsEncryptRequest); log.info("/file/obsFiles/getObsEncryptUrls1,{}", obsEncryptUrls); if (null == obsEncryptUrls.getData()) { return result; } log.info("/file/obsFiles/getObsEncryptUrls2,{}", obsEncryptUrls); List<ObsEncryptResponse> list = (List<ObsEncryptResponse>)obsEncryptUrls.getData(); for (ObsEncryptResponse obsEncryptResponse : list) { dataMap.put("fileEncryptUrl", obsEncryptResponse.getEncryptUrl()); } result.setData(dataMap); } return result; } /* * 根据fileId，调用基础平台SDK，进行文件下载 * @param fileId 文件id，是调用基础平台进行上传时，基础平台返回的fileId * @param response / @Override public void downloadFileByFileId(String fileId, HttpServletResponse response) throws Exception { logger.info("调用基础平台进行文件下载，文件ID：{}", fileId); Result<SysFileInfoResponse> result = systemFeignClient.downloadById2Video(fileId); if (result.getCode() != ResultCode.SUCCESS.getCode()) { logger.error("调用基础平台下载文件，基础平台返回报错，错误信息为：{}", result); throw new Exception("基础平台返回报错，错误信息为：" + result.getMsg()); } if (Objects.isNull(result.getData()) \|\| Objects.isNull(result.getData().getFileContent())) { throw new Exception("基础平台返回的报文或者文件内容为空"); } logger.info("调用基础平台进行文件下载，文件ID：{}，基础平台返回文件名称：{}，大小：{}", fileId, result.getData().getFileName(), result.getData().getFileSize()); FileUtils.download(response, result.getData().getFileContent(), result.getData().getFileName()); } /* * 根据fileId，调用基础平台SDK，进行文件下载 * @param fileId 文件id，是调用基础平台进行上传时，基础平台返回的fileId / @Override public Result downloadFileByFileId(String fileId) { logger.info("调用基础平台进行文件下载，文件ID：{}", fileId); Result<SysFileInfoResponse> result = systemFeignClient.downloadById2Video(fileId); if (result.getCode() != ResultCode.SUCCESS.getCode()) { logger.error("调用基础平台下载文件，基础平台返回报错，错误信息为：{}", result); return Result.fail("基础平台返回报错，错误信息为：" + result.getMsg()); } if (Objects.isNull(result.getData()) \|\| Objects.isNull(result.getData().getFileContent())) { return Result.fail("基础平台返回的报文或者文件内容为空"); } logger.info("调用基础平台进行文件下载，文件ID：{}，基础平台返回文件名称：{}，大小：{}", fileId, result.getData().getFileName(), result.getData().getFileSize()); return Result.data(result.getData().getFileContent()); } /* * 根据参数键名下载excel模板 * @param configKey * @return / @Override public Result downloadByConfigKey(String configKey){ SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); SysConfig sysConfig = new SysConfig(); sysConfig.setConfigKey(configKey); CommonUtils.setSDKCommonParam(sysConfig, sysUser); log.info("/video-system/system/config/getConfigInfo 请求报文=={}", JSONObject.toJSONString(sysConfig)); AjaxResult result = systemFeignClient.getConfigInfo(sysConfig); log.info("/video-system/system/config/getConfigInfo 响应报文=={}", JSONObject.toJSONString(result)); if ((int) result.get(AjaxResult.CODE_TAG) == Constants.SUCCESS && !ObjectUtils.isEmpty(result.get(AjaxResult.DATA_TAG))) { LinkedHashMap data = (LinkedHashMap)result.get(AjaxResult.DATA_TAG); if (!ObjectUtils.isEmpty(data.get(Constants.CONFIG_VALUE))) { String fileId = String.valueOf(data.get(Constants.CONFIG_VALUE)); log.info("/video-system/common/downloadById2Video 请求报文=={}", fileId); Result<SysFileInfoResponse> fileResult = systemFeignClient.downloadById2Video(fileId); log.info("/video-system/common/downloadById2Video 请求报文=={}", JSONObject.toJSONString(fileResult)); return fileResult; } } return Result.fail("下载模板失败！"); } /* * 获取obs加密的url串 * @param obsEncryptRequest * @return */ @Override public Result getObsEncryptUrl(ObsEncryptRequest obsEncryptRequest) { String url = obsEncryptRequest.getFileUrls().get(0); List<String> urlList = new ArrayList<>(); urlList.add(CommonUtils.dealObsUrl(url)); obsEncryptRequest.setFileUrls(urlList); log.info("/file/obsFiles/getObsEncryptUrls,request:{}", obsEncryptRequest); ApiResult<List<ObsEncryptResponse>> obsEncryptUrls = obsEncryptFeignClient.getObsEncryptUrls(obsEncryptRequest); log.info("/file/obsFiles/getObsEncryptUrls,response:{}", obsEncryptRequest); if (null != obsEncryptUrls && !CollectionUtils.isEmpty(obsEncryptUrls.getData())) { List<ObsEncryptResponse> list = obsEncryptUrls.getData(); return Result.data(list.get(0).getEncryptUrl()); } return Result.data(url); }}
package com.chinatower.park.service.impl;import java.util.ArrayList;import java.util.List;import com.chinatower.park.util.CommonUtils;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import com.alibaba.fastjson.JSONObject;import com.chinatower.bdm.api.GridAPI;import com.chinatower.bdm.api.entity.GridInfoParam;import com.chinatower.bdm.api.entity.GridKeeperInfoParam;import com.chinatower.bdm.api.entity.GridKeeperLayerParam;import com.chinatower.bdm.api.entity.GridKeeperListVO;import com.chinatower.bdm.api.entity.GridKeeperVO;import com.chinatower.bdm.api.entity.GridLayerParam;import com.chinatower.bdm.api.entity.GridListVO;import com.chinatower.bdm.api.entity.GridVO;import com.chinatower.bdm.api.entity.KeeperTreeSelectParam;import com.chinatower.bdm.api.entity.QueryTrailsParam;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.common.entity.Result;import com.chinatower.common.entity.ResultCode;import com.chinatower.park.common.Constants;import com.chinatower.park.model.GridDetailVO;import com.chinatower.park.model.GridKeeperDetailVO;import com.chinatower.park.model.GridKeeperLayerRequest;import com.chinatower.park.model.GridKeeperLayerResponse;import com.chinatower.park.model.GridLayerResponse;import com.chinatower.park.model.GridParam;import com.chinatower.park.service.IGridService;import com.chinatower.platform.model.dto.CommonFeignEntity;import lombok.extern.slf4j.Slf4j;/** * 功能描述: 网格、网格员service服务实现类 * * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class GridServiceImpl implements IGridService { @Autowired private GridAPI gridAPI; /* * * 功能描述: 网格员数据获取（无脱敏） * * @param: gridParam 查询条件封装的实体类对象 * @return: 网格员数据 * @auther: wanglei * @date: 2022/4/25 11:07 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / public Result findOneNoEncryptionSdk(GridParam gridParam) { GridKeeperInfoParam gridKeeperInfoParam = new GridKeeperInfoParam(); BeanUtils.copyProperties(gridParam, gridKeeperInfoParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员数据获取（无脱敏）-/video-forestry-baseservice/grid/findOneNoEncryptionSdk" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(gridKeeperInfoParam)); Result result = gridAPI.findOneNoEncryptionSdk(gridKeeperInfoParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员数据获取（无脱敏）-/video-forestry-baseservice/grid/findOneNoEncryptionSdk" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * * 功能描述: 网格员轨迹获取 * * @param: gridParam 查询条件封装的实体类对象 * @return: 网格员轨迹 * @auther: wanglei * @date: 2022/4/19 15:20 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / public Result getKeeperTrail(GridParam gridParam) { QueryTrailsParam queryTrailsParam = new QueryTrailsParam(); BeanUtils.copyProperties(gridParam, queryTrailsParam); queryTrailsParam.setKeeperId(gridParam.getKeeperId() == null ? null : String.valueOf(gridParam.getKeeperId())); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员轨迹获取-/video-forestry-baseservice/grid/getKeeperTrail" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(queryTrailsParam)); Result result = gridAPI.getKeeperTrail(queryTrailsParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员轨迹获取-/video-forestry-baseservice/grid/getKeeperTrail" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: 查询网格树 * * @param: * @return: 网格树对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / public AjaxResult getGridTree(GridParam gridParam) { CommonFeignEntity commonFeignEntity = new CommonFeignEntity(); // TODO: 2022/3/31 平台要求使用BeanUtils进行参数转换 BeanUtils.copyProperties(gridParam, commonFeignEntity); log.info(Constants._PARAM_SDK_PROVIDER + "-查询网格树-/video-bdm/grid/getGridTree" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(commonFeignEntity)); AjaxResult result = gridAPI.getGridTree(commonFeignEntity); log.info(Constants._PARAM_SDK_PROVIDER + "-查询网格树-/video-bdm/grid/getGridTree" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: 查询网格详情 * * @param: 网格查询条件封装对象类 * @return: 网格详情对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / public Result<GridDetailVO> findGridInfo(GridParam gridParam) { // 网格编码,查询网格详情 Long gridId = gridParam.getGridId(); GridInfoParam gridInfoParam = new GridInfoParam(); // TODO: 2022/3/31 平台要求使用BeanUtils进行参数转换 BeanUtils.copyProperties(gridParam, gridInfoParam); gridInfoParam.setGridId(gridId); log.info(Constants._PARAM_SDK_PROVIDER + "-网格单条数据查询-/video-bdm/grid/findOneSdk" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(gridInfoParam)); Result<GridVO> result = gridAPI.findGridInfo(gridInfoParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格单条数据查询-/video-bdm/grid/findOneSdk" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); if (result.getCode() != ResultCode.SUCCESS.getCode()) { return Result.fail("查询网格详情异常"); } //查询网格下级网格详情 GridLayerParam gridLayerParam = new GridLayerParam(); // TODO: 2022/3/31 平台要求使用BeanUtils进行参数转换 BeanUtils.copyProperties(gridParam, gridLayerParam); gridLayerParam.setGridId(null); gridLayerParam.setParentId(gridId.toString()); log.info(Constants._PARAM_SDK_PROVIDER + "-网格获取-/video-bdm/gridKeeper/getGridListByLayer" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(gridLayerParam)); Result<List<GridListVO>> childResult = gridAPI.getGridListByLayer(gridLayerParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格获取-/video-bdm/gridKeeper/getGridListByLayer" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(childResult)); List<GridListVO> childList = new ArrayList<>(); if (childResult.getCode() == ResultCode.SUCCESS.getCode()) { childList = childResult.getData(); } //进行对象属性转换 GridDetailVO gridDetailVO = gridProCopy(result.getData(), childList); return Result.data(gridDetailVO); } /* * 功能描述: 网格对象属性值转换 * 查询网格详情时，如果有下级网格需要查询下级网格的信息，通用能力2个接口返回的对象不一致，这里进行转换 * * @param: gridVO 网格查询条件封装对象类 childList 查询网格下级网格列表返回对象 * @return: 网格详情对象 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / private GridDetailVO gridProCopy(GridVO gridVO, List<GridListVO> childList) { GridDetailVO gridDetailVO = new GridDetailVO(); if (null != gridVO) { BeanUtils.copyProperties(gridVO,gridDetailVO); gridDetailVO.setGridId(gridVO.getGridId().toString()); gridDetailVO.setParentId(gridVO.getParentId().toString()); } if (null != childList) { List<GridDetailVO> childGridList = new ArrayList<>(); for (GridListVO vo : childList) { GridDetailVO childGridDetailVO = new GridDetailVO(); BeanUtils.copyProperties(vo,childGridDetailVO); childGridDetailVO.setKeeperPhoneNumber(null); childGridList.add(childGridDetailVO); } gridDetailVO.setChildGridList(childGridList); } return gridDetailVO; } /* * 功能描述: 查询网格员树 * * @param: * @return: 网格员树对象列表 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / public AjaxResult getGridKeeperTree(GridParam gridParam) { KeeperTreeSelectParam keeperTreeSelectParam = new KeeperTreeSelectParam(); // TODO: 2022/3/31 平台要求使用BeanUtils进行参数转换 BeanUtils.copyProperties(gridParam, keeperTreeSelectParam); keeperTreeSelectParam.setType(Constants.TWO_FLAG); log.info(Constants._PARAM_SDK_PROVIDER + "-查询网格员树-/video-bdm/gridKeeper/getGridKeeperTree" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(keeperTreeSelectParam)); AjaxResult result = gridAPI.getGridKeeperTree(keeperTreeSelectParam); log.info(Constants._PARAM_SDK_PROVIDER + "-查询网格员树-/video-bdm/gridKeeper/getGridKeeperTree" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } /* * 功能描述: 查询网格员详情 * * @param: 网格查询条件封装对象类 * @return: 网格员详情对象列表 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / public List<GridKeeperDetailVO> findGridKeeperInfo(GridParam gridParam) { List<GridKeeperDetailVO> keeperDetailList = new ArrayList<>(); Long gridId = gridParam.getGridId(); if (null != gridId) { GridKeeperLayerParam gridKeeperLayerParam = new GridKeeperLayerParam(); // TODO: 2022/3/31 平台要求使用BeanUtils进行参数转换 BeanUtils.copyProperties(gridParam, gridKeeperLayerParam); gridKeeperLayerParam.setGridId(null); gridKeeperLayerParam.setGridLevelCode(gridId.toString()); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员获取-/video-bdm/gridKeeper/getGridKeeperByLayer" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(gridKeeperLayerParam)); Result<List<GridKeeperListVO>> result = gridAPI.getGridKeeperByLayer(gridKeeperLayerParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员获取-/video-bdm/gridKeeper/getGridKeeperByLayer" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); List<GridKeeperListVO> listVOS = result.getData(); keeperDetailList = gridKeeperProCopy(listVOS, null); } else { // 网格员id Long keeperId = gridParam.getKeeperId(); GridKeeperInfoParam gridKeeperInfoParam = new GridKeeperInfoParam(); // TODO: 2022/3/31 平台要求使用BeanUtils进行参数转换 BeanUtils.copyProperties(gridParam, gridKeeperInfoParam); gridKeeperInfoParam.setKeeperId(keeperId); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员单条数据查询-/video-bdm/gridKeeper/findOneSdk" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(gridKeeperInfoParam)); Result<GridKeeperVO> result = gridAPI.findGridKeeperInfo(gridKeeperInfoParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员单条数据查询-/video-bdm/gridKeeper/findOneSdk" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); GridKeeperVO gridKeeperVOgridKeeperVO = result.getData(); keeperDetailList = gridKeeperProCopy(null, gridKeeperVOgridKeeperVO); } return keeperDetailList; } /* * 功能描述: 网格员对象属性值转换 * 与通用能力对接查询详情是2个接口，返回的数据对象不一致，这里进行转换 * * @param: list 查询网格下多个网格员列表对象 gridKeeperVO 查询网格员详情对象 * @return: 网格员详情列表 * @auther: hj * @date: 2022/3/22 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / private List<GridKeeperDetailVO> gridKeeperProCopy(List<GridKeeperListVO> list, GridKeeperVO gridKeeperVO) { List<GridKeeperDetailVO> keeperDetailVOList = new ArrayList<>(); if (null != list) { for (GridKeeperListVO vo : list) { GridKeeperDetailVO gridKeeperDetailVO = new GridKeeperDetailVO(); BeanUtils.copyProperties(vo,gridKeeperDetailVO); gridKeeperDetailVO.setOperatingDuty(null); keeperDetailVOList.add(gridKeeperDetailVO); } } if (null != gridKeeperVO) { GridKeeperDetailVO gridKeeperDetailVO = new GridKeeperDetailVO(); BeanUtils.copyProperties(gridKeeperVO,gridKeeperDetailVO); gridKeeperDetailVO.setKeeperId(gridKeeperVO.getKeeperId().toString()); gridKeeperDetailVO.setAddress(gridKeeperVO.getKeeperAddress()); keeperDetailVOList.add(gridKeeperDetailVO); } return keeperDetailVOList; } /* * 查询网格员图层 * @param gridKeeperLayerRequest * @return / @Override public List<GridKeeperLayerResponse> findGridKeeperByLayer(GridKeeperLayerRequest gridKeeperLayerRequest) { GridKeeperLayerParam gridKeeperParam = new GridKeeperLayerParam(); gridKeeperParam.setGridId(gridKeeperLayerRequest.getGridId()); CommonUtils.setSDKCommonParam(gridKeeperParam, gridKeeperLayerRequest.getTenantId(), gridKeeperLayerRequest.getUserId(), gridKeeperLayerRequest.getIndustryCode()); Result<List<GridKeeperListVO>> result = gridAPI.getGridKeeperByLayer(gridKeeperParam); List<GridKeeperLayerResponse> resultList = new ArrayList<>(result.getData().size()); if (!CollectionUtils.isEmpty(result.getData())) { result.getData().forEach(item -> { GridKeeperLayerResponse response = new GridKeeperLayerResponse(); response.setKeeperId(item.getKeeperId()); response.setKeeperCode(item.getKeeperCode()); response.setKeeperName(item.getKeeperName()); response.setLongitude(item.getLongitude()); response.setLatitude(item.getLatitude()); resultList.add(response); }); } return resultList; } /* * 查询网格图层 * @param gridKeeperLayerRequest * @return */ @Override public List<GridLayerResponse> findGridByLayer(GridKeeperLayerRequest gridKeeperLayerRequest) { GridLayerParam gridLayerParam = new GridLayerParam(); CommonUtils.setSDKCommonParam(gridLayerParam, gridKeeperLayerRequest.getTenantId(), gridKeeperLayerRequest.getUserId(), gridKeeperLayerRequest.getIndustryCode()); Result<List<GridListVO>> result = gridAPI.getGridListByLayer(gridLayerParam); List<GridLayerResponse> resultList = new ArrayList<>(result.getData().size()); if (!CollectionUtils.isEmpty(result.getData())) { result.getData().forEach(item -> { GridLayerResponse response = new GridLayerResponse(); response.setGridId(item.getGridId()); response.setGridCode(item.getGridCode()); response.setGridName(item.getGridName()); response.setGridCenter(item.getGridCenter()); response.setGridRange(item.getGridRange()); response.setColor(item.getColor()); response.setGridLevel(item.getGridLevel()); response.setPointStatus(item.getPointStatus()); resultList.add(response); }); } return resultList; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.park.common.Constants;import com.chinatower.park.model.MonitorVO;import com.chinatower.park.service.IMonitorService;import com.chinatower.outdata.api.OutdataAPI;import com.chinatower.outdata.api.entity.Monitor;import com.chinatower.outdata.api.entity.MonitorFake;import com.chinatower.outdata.api.entity.QueryStatusFakeReq;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Service;import java.util.List;@Service@Slf4j@RequiredArgsConstructorpublic class MonitorServiceImpl implements IMonitorService { private final RemoteUserSecurityService remoteUserSecurityService; private final OutdataAPI outdataAPI; @Override public Result<List<MonitorFake>> queryStatusFake() { QueryStatusFakeReq queryStatusFakeReq = new QueryStatusFakeReq(); SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); queryStatusFakeReq.setUserId(sysUser.getUserId()); log.info(Constants._PARAM_SDK_PROVIDER + "-查询传感器设备信息-/video-monitor/queryStatusFake" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(queryStatusFakeReq)); Result<List<MonitorFake>> result = outdataAPI.queryStatusFake(queryStatusFakeReq); log.info(Constants._PARAM_SDK_PROVIDER + "-查询传感器设备信息-/video-monitor/queryStatusFake" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; } @Override public Result<List<Monitor>> queryAttribute(MonitorVO monitorVO) { log.info(Constants._PARAM_SDK_PROVIDER + "-查询传感器参数-/video-monitor/queryAttribute" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(monitorVO.getDeviceCodes())); Result<List<Monitor>> result = outdataAPI.queryAttribute(monitorVO.getDeviceCodes()); log.info(Constants._PARAM_SDK_PROVIDER + "-查询传感器参数-/video-monitor/queryAttribute" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; }}
package com.chinatower.park.service.impl;import com.chinatower.common.entity.Result;import com.chinatower.park.service.IMsgService;import com.chinatower.park.util.CommonUtils;import com.chinatower.message.api.MsgStationAPI;import com.chinatower.message.api.model.MsgBody;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import lombok.extern.slf4j.Slf4j;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;/** * @Author：zhouzhiang * @Description：内部消息转发（向目标服务器转发消息）接口 controller * @Date：2022/3/30 17:00 /@Service@Slf4jpublic class MsgServiceImpl implements IMsgService { private static final Logger logger = LoggerFactory.getLogger(MsgServiceImpl.class); @Autowired private MsgStationAPI msgStationAPI; @Autowired private RemoteUserSecurityService remoteUserSecurityService; /* * 调用基础平台SDK，进行文件上传 * @return */ @Override public Result sendMsg2TargetService(MsgBody msg) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(msg, sysUser); logger.info("调用基础平台api：msgStationAPI.sendMsg2TargetService，传入参数：{}", msg); Result result = msgStationAPI.sendMsg2TargetService(msg); logger.info("调用基础平台api：msgStationAPI.sendMsg2TargetService，返回信息：{}", result); return result; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.park.common.Constants;import com.chinatower.park.model.ParamRequestVO;import com.chinatower.park.service.IParamService;import com.chinatower.platform.entity.admin.SysConfig;import com.chinatower.system.api.feign.client.SystemFeignClient;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;/** * 功能描述： * 配置参数类 * @author：hued * @date：2022/3/15 16:05 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class ParamServiceImpl implements IParamService { @Autowired SystemFeignClient systemFeignClient; /* * 功能描述: * 根据参数类型标识查参数 * @param: paramRequestVO 参数类型标识 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ @Override public AjaxResult getParamInfo(ParamRequestVO paramRequestVO){ SysConfig sysConfig = new SysConfig(); BeanUtils.copyProperties(paramRequestVO,sysConfig); log.info(Constants._PARAM_SDK_PROVIDER + "-根据参数类型标识查参数-/video-system/system/config/getConfigInfo" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(sysConfig)); AjaxResult result = systemFeignClient.getConfigInfo(sysConfig); log.info(Constants._PARAM_SDK_PROVIDER + "-根据参数类型标识查参数-/video-system/system/config/getConfigInfo" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); return result; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.bdm.api.ResourceAPI;import com.chinatower.bdm.api.entity.ResourceConf;import com.chinatower.common.core.web.domain.AjaxResult;import com.chinatower.common.entity.Result;import com.chinatower.park.common.CommonService;import com.chinatower.park.common.Constants;import com.chinatower.park.model.ResourceConfDTO;import com.chinatower.park.model.ResourceLayerResponse;import com.chinatower.park.service.IResourcesService;import com.chinatower.park.util.CommonUtils;import com.chinatower.park.util.CompletableFutureUtils;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.platform.model.dto.CommonFeignEntity;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import org.springframework.util.ObjectUtils;import org.springframework.util.StringUtils;import java.util.ArrayList;import java.util.List;import java.util.Objects;import java.util.concurrent.CompletableFuture;import java.util.concurrent.TimeUnit;import java.util.stream.Collectors;/** * 功能描述: 资源相关接口实现类 * * @param * @author wangyt * @version release_v1.1 * @return * @date 2022/3/30 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Slf4j@Service@Transactional(rollbackFor = Exception.class)public class ResourcesServiceImpl implements IResourcesService { @Autowired private ResourceAPI resourceAPI; @Autowired private RemoteUserSecurityService remoteUserSecurityService; @Autowired private ThreadPoolTaskExecutor threadPoolTaskExecutor; /* * 功能描述: 资源集合查询 * * @param resourceConfDTO * @return com.chinatower.common.entity.Result * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result selectResource(ResourceConfDTO resourceConfDTO) { //去掉租户名称，否则通用平台会模糊查询 resourceConfDTO.setTenantName(null); ResourceConf resourceConf = new ResourceConf(); BeanUtils.copyProperties(resourceConfDTO, resourceConf); log.info(Constants._PARAM_SDK_PROVIDER + "-资源集合查询-/video-bdm/resource/selectResource" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(resourceConf)); Result<List<ResourceConf>> result = resourceAPI.selectResource(resourceConf); log.info(Constants._PARAM_SDK_PROVIDER + "-资源集合查询-/video-bdm/resource/selectResource" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); //if (result.getCode() == Constants.SUCCESS && !ObjectUtils.isEmpty(result.getData())) { // List<ResourceConf> dataList = result.getData(); // for (ResourceConf map : dataList) { // if (!ObjectUtils.isEmpty(map.getIcon())) { // map.setIcon(Constants.SVG_TO_BASE64 + CommonService.getBase64ByUrl(map.getIcon())); // } // } //} return result; } /* * 功能描述: 资源单条查询 * * @param resourceConfDTO * @return com.chinatower.common.entity.Result * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getResourceInfo(ResourceConfDTO resourceConfDTO) { ResourceConf resourceConf = new ResourceConf(); BeanUtils.copyProperties(resourceConfDTO, resourceConf); log.info(Constants._PARAM_SDK_PROVIDER + "-资源单条查询-/video-bdm/resource/getResourceInfoDetail" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(resourceConf)); Result<ResourceConf> result = resourceAPI.getResourceInfoDetail(resourceConf); log.info(Constants._PARAM_SDK_PROVIDER + "-资源单条查询-/video-bdm/resource/getResourceInfoDetail" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); //转换base64,加密url会导致前台偶发不打点 if (result.getCode() == Constants.SUCCESS && !ObjectUtils.isEmpty(result.getData())) { ResourceConf r = result.getData(); if (!ObjectUtils.isEmpty(r.getIcon())) { r.setIcon(Constants.SVG_TO_BASE64 + CommonService.getBase64ByUrl(r.getIcon())); } } return result; } /* * 功能描述: 查询资源树形结构 * * @param resourceConfDTO * @return com.chinatower.common.entity.Result * @author wangyt * @date 2022/3/30 * @version release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result getResourceTree(ResourceConfDTO resourceConfDTO) { CommonFeignEntity commonFeignEntity = new CommonFeignEntity(); BeanUtils.copyProperties(resourceConfDTO, commonFeignEntity); log.info(Constants._PARAM_SDK_PROVIDER + "-查询资源树形结构-/video-bdm/resource/getResourceTree" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(commonFeignEntity)); AjaxResult result = resourceAPI.getResourceTree(commonFeignEntity); log.info(Constants._PARAM_SDK_PROVIDER + "-查询资源树形结构-/video-bdm/resource/getResourceTree" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(result)); //if ((int) result.get(AjaxResult.CODE_TAG) == Constants.SUCCESS && !ObjectUtils.isEmpty(result.get(AjaxResult.DATA_TAG))) { // List<LinkedHashMap> dataList = (List<LinkedHashMap>) result.get(AjaxResult.DATA_TAG); // for (LinkedHashMap map : dataList) { // if (!ObjectUtils.isEmpty(map.get(Constants._PARAM_ICON))) { // map.put(Constants._PARAM_ICON, Constants.SVG_TO_BASE64 + CommonService.getBase64ByUrl(String.valueOf(map.get("icon")))); // } // } //} return Result.data(result.get(AjaxResult.DATA_TAG)); } /* * 查询资源图层 * * @param resourceConf * @return / @Override public List<ResourceLayerResponse> selectResourceByLayer(ResourceConf resourceConf) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(resourceConf, sysUser); log.info("/resource/selectResource request:{}", resourceConf); Result<List<ResourceConf>> result = resourceAPI.selectResource(resourceConf); log.info("/resource/selectResource response:{}", result); List<CompletableFuture<ResourceLayerResponse>> allFutureList = new ArrayList<>(result.getData().size()); if (!CollectionUtils.isEmpty(result.getData())) { result.getData().forEach(item -> { allFutureList.add(CompletableFutureUtils.orTimeout( CompletableFuture.supplyAsync(() -> buildResourceLayerResponse(item), threadPoolTaskExecutor) .exceptionally(e -> { log.error("calDeviceVisible error", e); return null; }), 6, TimeUnit.SECONDS).exceptionally(e -> { log.error("calDeviceVisible orTimeout resourceId:{}",item.getResourceId(), e); return null; })); }); } CompletableFuture<Void> doneFuture = CompletableFuture.allOf(allFutureList.toArray(new CompletableFuture[allFutureList.size()])); return doneFuture.thenApply(v -> allFutureList.stream() .map(CompletableFuture::join).filter(Objects::nonNull) .collect(Collectors.toList())).join(); } /* * 构建返回对象 * @param item * @return / private ResourceLayerResponse buildResourceLayerResponse(ResourceConf item) { ResourceLayerResponse response = this.buildResourceLayerResponseWithoutIcon(item); if (!StringUtils.isEmpty(item.getIcon())) { response.setIcon(item.getIcon()); //response.setIcon(Constants.SVG_TO_BASE64 + CommonService.getBase64ByUrl(item.getIcon())); } return response; } /* * 构建返回对象 * @param item * @return */ private ResourceLayerResponse buildResourceLayerResponseWithoutIcon(ResourceConf item) { ResourceLayerResponse response = new ResourceLayerResponse(); response.setResourceId(item.getResourceId()); response.setResourceName(item.getResourceName()); response.setLongitude(item.getLongitude()); response.setLatitude(item.getLatitude()); response.setRadius(item.getRadius()); response.setDistance(item.getDistance()); return response; }}
package com.chinatower.park.service.impl;import com.chinatower.common.entity.Result;import com.chinatower.park.service.ISmsService;import com.chinatower.park.util.CommonUtils;import com.chinatower.platform.entity.admin.SysUser;import com.chinatower.platform.entity.request.CommonSmsRequest;import com.chinatower.platform.fegin.client.MsgFeignClient;import com.chinatower.system.api.feign.client.RemoteUserSecurityService;import lombok.extern.slf4j.Slf4j;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;/** * @Author：zhouzhiang * @Description：内部短信发送接口 controller * @Date：2022/3/30 17:00 /@Service@Slf4jpublic class SmsServiceImpl implements ISmsService { private static final Logger logger = LoggerFactory.getLogger(SmsServiceImpl.class); @Autowired private MsgFeignClient msgFeignClient; @Autowired private RemoteUserSecurityService remoteUserSecurityService; /* * 调用基础平台SDK，进行文件上传 * @return */ @Override public Result sendMessage(CommonSmsRequest smsRecord) { SysUser sysUser = remoteUserSecurityService.getLoginUser().getUser(); CommonUtils.setSDKCommonParam(smsRecord, sysUser); logger.info("调用基础平台api：msgFeignClient.sendMessage，传入参数：{}", smsRecord); Result result = msgFeignClient.sendMessage(smsRecord); logger.info("调用基础平台api：msgFeignClient.sendMessage，返回信息：{}", result); return result; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.analysis.api.CheckpointAPI;import com.chinatower.analysis.api.entity.CheckpointDeviceRankingDataVO;import com.chinatower.analysis.api.entity.CheckpointStatisticsConditionVO;import com.chinatower.analysis.api.entity.CheckpointTrendDataVO;import com.chinatower.common.entity.Result;import com.chinatower.park.common.Constants;import com.chinatower.park.model.StatisticsRequestVO;import com.chinatower.park.service.IStatisticsService;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.lang.reflect.Field;import java.util.;/* * 功能描述： * 卡口大屏统计相关接口 * @author：wu.zh * @date：2022/4/28 11:40 * @version: release_v1.1 /@Service@Slf4jpublic class StatisticsServiceImpl implements IStatisticsService { @Autowired private CheckpointAPI checkpointAPI; /* * 功能描述: * 查询车流趋势统计 * @param: StatisticsRequestVO * @return: Result 结果集实体 * @auther: wu.zh * @date: 2022/4/28 11:40 * @version: release_v1.1 / @Override public Result<List<CheckpointTrendDataVO>> getTrafficTrendStatistics(StatisticsRequestVO statisticsRequestVO) { CheckpointStatisticsConditionVO vo = new CheckpointStatisticsConditionVO(); BeanUtils.copyProperties(statisticsRequestVO,vo); log.info("/checkpoint/getTrafficTrendStatistics 请求报文=={}", JSONObject.toJSONString(vo)); try { Result<List<CheckpointTrendDataVO>> tyResult = checkpointAPI.getIndustryTrafficTrendStatistics(vo); log.info("/checkpoint/getTrafficTrendStatistics 响应报文=={}",JSONObject.toJSONString(tyResult)); List<CheckpointTrendDataVO> finalOutcome = new ArrayList<>(); if(tyResult.getCode() == Constants.SUCCESS){ //月数据 if ("2".equals(statisticsRequestVO.getDimensionFlag())){ finalOutcome = supplementaryParam(tyResult.getData(),"1",1,31); } //年数据 if ("1".equals(statisticsRequestVO.getDimensionFlag())){ finalOutcome = supplementaryParam(tyResult.getData(),"1",1,12); } } return Result.data(finalOutcome); } catch (Exception e) { log.error("请求getTrafficTrendStatistics失败", e); } return Result.data(Collections.emptyList()); } /* * 功能描述: * 查询车流高频时段统计 * @param: StatisticsRequestVO * @return: Result 结果集实体 * @auther: wu.zh * @date: 2022/4/28 11:40 * @version: release_v1.1 / @Override public Result<List<CheckpointTrendDataVO>> getHighFrequencyPeriodStatistics(StatisticsRequestVO statisticsRequestVO) { CheckpointStatisticsConditionVO vo = new CheckpointStatisticsConditionVO(); BeanUtils.copyProperties(statisticsRequestVO,vo); try { log.info("/checkpoint/getHighFrequencyPeriodStatistics 请求报文=={}", JSONObject.toJSONString(vo)); Result<List<CheckpointTrendDataVO>> tyResult = checkpointAPI.getIndustryHighFrequencyPeriodStatistics(vo); log.info("/checkpoint/getHighFrequencyPeriodStatistics 响应报文=={}",JSONObject.toJSONString(tyResult)); List<CheckpointTrendDataVO> finalOutcome = new ArrayList<>(); if(tyResult.getCode() == Constants.SUCCESS){ finalOutcome = supplementaryParam(tyResult.getData(),"2",0,23); } return Result.data(finalOutcome); } catch (Exception e) { log.error("/checkpoint/getHighFrequencyPeriodStatistics失败", e); } return Result.data(Collections.emptyList()); } /* * 功能描述: * 查询卡口车流排行统计 * @param: StatisticsRequestVO * @return: Result 结果集实体 * @auther: wu.zh * @date: 2022/4/28 11:40 * @version: release_v1.1 / @Override public Result<List<CheckpointDeviceRankingDataVO>> getTrafficFlowRankingStatistics(StatisticsRequestVO statisticsRequestVO) { CheckpointStatisticsConditionVO vo = new CheckpointStatisticsConditionVO(); BeanUtils.copyProperties(statisticsRequestVO,vo); try { log.info("/checkpoint/getTrafficFlowRankingStatistics 请求报文=={}", JSONObject.toJSONString(vo)); Result<List<CheckpointDeviceRankingDataVO>> tyResult = checkpointAPI.getIndustryTrafficFlowRankingStatistics(vo); log.info("/checkpoint/getTrafficFlowRankingStatistics 响应报文=={}",JSONObject.toJSONString(tyResult)); if(tyResult.getCode() == Constants.SUCCESS){ return tyResult; } return Result.data(new ArrayList<>()); } catch (Exception e) { log.error("/checkpoint/getTrafficFlowRankingStatistics失败", e); } return Result.data(Collections.emptyList()); } /* * 实体对象转成Map * @param obj 实体对象 * @return */ public static Map<String, Object> object2Map(Object obj) { Map<String, Object> map = new HashMap<>(); if (obj == null) { return map; } Class clazz = obj.getClass(); Field[] fields = clazz.getDeclaredFields(); try { for (Field field : fields) { field.setAccessible(true); map.put(field.getName(), field.get(obj)); } } catch (Exception e) { e.printStackTrace(); } return map; } public List<CheckpointTrendDataVO> supplementaryParam (List<CheckpointTrendDataVO> result,String type,int numMin,int numMax){ List<CheckpointTrendDataVO> ntwy = new ArrayList<>(); for (int i=numMin; i<=numMax; i++){ CheckpointTrendDataVO trend0 = new CheckpointTrendDataVO(); for (CheckpointTrendDataVO checkpointTrendDataVO:result){ Map<String,Object> map = object2Map(checkpointTrendDataVO); if ("1".equals(type)){ if (map.containsValue(String.valueOf(i))){ trend0.setNum(checkpointTrendDataVO.getNum()); break; } }else if("2".equals(type)){ if (map.containsValue(i+":00-"+(i+1)+":00")){ trend0.setNum(checkpointTrendDataVO.getNum()); break; } } } if ("0".equals(String.valueOf(trend0.getNum())) \|\| "null".equals(String.valueOf(trend0.getNum())) \|\| trend0.getNum() <= 0){ trend0.setNum(0); } if ("1".equals(type)){ trend0.setLabel(String.valueOf(i)); }else if("2".equals(type)){ trend0.setLabel(i+":00-"+(i+1)+":00"); } ntwy.add(trend0); } return ntwy; }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSONObject;import com.chinatower.bdm.api.GridAPI;import com.chinatower.bdm.api.ResourceAPI;import com.chinatower.bdm.api.ResourceTypeAPI;import com.chinatower.bdm.api.entity.GridKeeperVO;import com.chinatower.bdm.api.entity.KeeperPeripheryParam;import com.chinatower.bdm.api.entity.ResourceConf;import com.chinatower.bdm.api.entity.ResourceType;import com.chinatower.common.entity.Result;import com.chinatower.event.api.ITradeWarningOrderService;import com.chinatower.event.entity.dto.WarningOrderLayerDTO;import com.chinatower.park.common.CommonService;import com.chinatower.park.common.Constants;import com.chinatower.park.model.ResourceTypeResultVO;import com.chinatower.park.model.SurroundRequestVO;import com.chinatower.park.model.SurroundResultVO;import com.chinatower.park.service.ISurroundService;import com.chinatower.industry.api.IIndustryDeviceService;import com.chinatower.industry.dto.DeviceLayerReq;import com.chinatower.industry.vo.IndustryDeviceTree;import com.github.pagehelper.Page;import com.github.pagehelper.PageInfo;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.util.CollectionUtils;import org.springframework.util.ObjectUtils;import org.springframework.util.StringUtils;import java.util.;import java.util.stream.Collectors;/* * 功能描述： * 周边分析相关接口 * @author：hued * @date：2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 /@Service@Slf4jpublic class SurroundServiceImpl implements ISurroundService { @Autowired ResourceAPI resourceAPI; @Autowired ResourceTypeAPI resourceTypeAPI; @Autowired GridAPI gridAPI; @Autowired ITradeWarningOrderService tradeWarningOrderService; @Autowired IIndustryDeviceService iIndustryDeviceService; /* * 功能描述: * 周边分析类型查询 * @param: surroundRequestVO 查询来源 1：图层下拉框 2：周边分析 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result<List<ResourceTypeResultVO>> getSurroundTypeList(SurroundRequestVO surroundRequestVO){ List<ResourceTypeResultVO> result = new ArrayList<>(); //调通用平台资源类型查询接口 ResourceType vo = new ResourceType(); BeanUtils.copyProperties(surroundRequestVO,vo); log.info(Constants._PARAM_SDK_PROVIDER + "-周边分析类型查询-/video-bdm/resourceType/selectResourceType" + Constants._PARAM_LOG_REQUEST,JSONObject.toJSONString(vo)); Result<List<ResourceType>> tyResult = resourceTypeAPI.selectResourceType(vo); log.info(Constants._PARAM_SDK_PROVIDER + "-周边分析类型查询-/video-bdm/resourceType/selectResourceType" + Constants._PARAM_LOG_RESPONSE,JSONObject.toJSONString(tyResult)); if(tyResult.getCode() == Constants.SUCCESS && !ObjectUtils.isEmpty(tyResult.getData())){ for(ResourceType resourceType : tyResult.getData()){ ResourceTypeResultVO resourceTypeResultVO = new ResourceTypeResultVO(); BeanUtils.copyProperties(resourceType,resourceTypeResultVO); resourceTypeResultVO.setShowArea(Constants.ONE_FLAG); result.add(resourceTypeResultVO); } } if ((Constants.TWO_FLAG).equals(surroundRequestVO.getQuerySource())) { //返回集拼接非资源类型的枚举 result.add(new ResourceTypeResultVO(Constants.WGY_CODE,Constants.WGY_NAME,Constants.TWO_FLAG)); result.add(new ResourceTypeResultVO(Constants.SXJ_CODE,Constants.SXJ_NAME,Constants.TWO_FLAG)); result.add(new ResourceTypeResultVO(Constants.GJ_CODE,Constants.GJ_NAME,Constants.TWO_FLAG)); result.add(new ResourceTypeResultVO(Constants.QXZ_CODE,Constants.QXZ_NAME,Constants.TWO_FLAG)); } return Result.data(result); } /* * 功能描述: * 查询周边资源列表 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @return: Result 结果集实体 * @auther: hued * @date: 2022/3/14 11:40 * @version: release_v1.1 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / @Override public Result<PageInfo<SurroundResultVO>> getSurroundList(SurroundRequestVO surroundRequestVO){ int pageNum = surroundRequestVO.getPageNum(); int pageSize = surroundRequestVO.getPageSize(); String radius = String.valueOf(Math.round((Double.parseDouble(surroundRequestVO.getRadius())Constants.THOUSAND_NUM))); surroundRequestVO.setRadius(radius); List<SurroundResultVO> result = new ArrayList<>(); //周边分析类型 List<String> resourceTypeList = surroundRequestVO.getResourceTypeList(); //调通用平台网格员查询接口 this.getKeeperByPeriphery(resourceTypeList,surroundRequestVO,result); //调通用平台摄像机查询接口 this.queryDeviceLayer(resourceTypeList,surroundRequestVO,result); //调通用平台告警查询接口 this.getWarningOrderLayer(resourceTypeList,surroundRequestVO,result); //调通用平台气象站查询接口 this.querySensorLayer(resourceTypeList,surroundRequestVO,result); //调通用平台资源查询接口 this.selectResource(resourceTypeList,surroundRequestVO,result); //按照距离正向排序 result = result.stream().sorted(Comparator.comparing(SurroundResultVO::getDistance)).collect(Collectors.toList()); //PageHelper对List分页 Page page = CommonService.getPageForList(pageNum,pageSize,result); return Result.data(new PageInfo<>(page)); } /** * 功能描述: * 调通用平台网格员查询接口 * @param: resourceTypeList 资源类型编码集合 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @param: result 结果集 * @return: * @auther: hued * @date: 2022年8月4日09:18:08 * @version: release_v1.4 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / private void getKeeperByPeriphery(List<String> resourceTypeList,SurroundRequestVO surroundRequestVO,List<SurroundResultVO> result){ try{ if (resourceTypeList.contains(Constants.WGY_CODE)) { //移除网格员周边类型 resourceTypeList.remove(Constants.WGY_CODE); KeeperPeripheryParam keeperPeripheryParam = new KeeperPeripheryParam(); BeanUtils.copyProperties(surroundRequestVO,keeperPeripheryParam); keeperPeripheryParam.setRadius(surroundRequestVO.getRadius()); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员查询-/video-bdm/gridKeeper/getKeeperByPeriphery" + Constants._PARAM_LOG_REQUEST,JSONObject.toJSONString(keeperPeripheryParam)); Result<List<GridKeeperVO>> wgResult = gridAPI.getKeeperByPeriphery(keeperPeripheryParam); log.info(Constants._PARAM_SDK_PROVIDER + "-网格员查询-/video-bdm/gridKeeper/getKeeperByPeriphery" + Constants._PARAM_LOG_RESPONSE,JSONObject.toJSONString(wgResult)); if(wgResult.getCode() == Constants.SUCCESS && !ObjectUtils.isEmpty(wgResult.getData())){ for(GridKeeperVO gridKeeperVO : wgResult.getData()){ String distance = StringUtils.isEmpty(gridKeeperVO.getDistance()) ? Constants.ZERO_FLAG : gridKeeperVO.getDistance(); if(Double.parseDouble(distance) > 0){ String distance2f = String.format(Constants.STRING_FORMAT_2F,Double.parseDouble(distance)/Constants.THOUSAND_NUM); distance2f = (Constants.ZERO_ZERO_FLAG).equals(distance2f) ? Constants.ZERO_ONE_FLAG : distance2f; SurroundResultVO surroundResultVO = new SurroundResultVO(); BeanUtils.copyProperties(gridKeeperVO,surroundResultVO); surroundResultVO.setName(gridKeeperVO.getKeeperName()); surroundResultVO.setAddress(gridKeeperVO.getKeeperAddress()); surroundResultVO.setDistance(Double.parseDouble(distance2f)); surroundResultVO.setResourceTypeId(Constants.WGY_CODE); result.add(surroundResultVO); } } } } }catch (Exception e){ log.info("getKeeperByPeriphery异常==",e); } } /* * 功能描述: * 调通用平台摄像机查询接口 * @param: resourceTypeList 资源类型编码集合 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @param: result 结果集 * @return: * @auther: hued * @date: 2022年8月4日09:18:08 * @version: release_v1.4 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / private void queryDeviceLayer(List<String> resourceTypeList,SurroundRequestVO surroundRequestVO,List<SurroundResultVO> result){ try{ if (resourceTypeList.contains(Constants.SXJ_CODE)) { //移除摄像机周边类型 resourceTypeList.remove(Constants.SXJ_CODE); //调通用平台摄像机列表查询接口（站址在地图打点） DeviceLayerReq deviceLayerReq = new DeviceLayerReq(); BeanUtils.copyProperties(surroundRequestVO,deviceLayerReq); deviceLayerReq.setDistance(surroundRequestVO.getRadius()); deviceLayerReq.setLongitude(StringUtils.isEmpty(surroundRequestVO.getLongitude())?Constants.ZERO_NUM:Double.parseDouble(surroundRequestVO.getLongitude())); deviceLayerReq.setLatitude(StringUtils.isEmpty(surroundRequestVO.getLatitude())?Constants.ZERO_NUM:Double.parseDouble(surroundRequestVO.getLatitude())); log.info(Constants._PARAM_SDK_PROVIDER + "-摄像机查询-/video-device/industry/device/queryDeviceLayer" + Constants._PARAM_LOG_REQUEST, JSONObject.toJSONString(deviceLayerReq)); Result<List<IndustryDeviceTree>> idResult = iIndustryDeviceService.queryDeviceLayer(deviceLayerReq); log.info(Constants._PARAM_SDK_PROVIDER + "-摄像机查询-/video-device/industry/device/queryDeviceLayer" + Constants._PARAM_LOG_RESPONSE, JSONObject.toJSONString(idResult)); if(idResult.getCode() == Constants.SUCCESS && !CollectionUtils.isEmpty(idResult.getData())){ for (IndustryDeviceTree siteInfo :idResult.getData()) { String distance = StringUtils.isEmpty(siteInfo.getDistance()) ? Constants.ZERO_FLAG : siteInfo.getDistance(); if(Double.parseDouble(distance) > 0){ String distance2f = String.format(Constants.STRING_FORMAT_2F,Double.parseDouble(distance)/Constants.THOUSAND_NUM); distance2f = (Constants.ZERO_ZERO_FLAG).equals(distance2f) ? Constants.ZERO_ONE_FLAG : distance2f; for(IndustryDeviceTree devInfo : siteInfo.getList()){ SurroundResultVO surroundResultVO = new SurroundResultVO(); surroundResultVO.setLongitude(siteInfo.getLongitude()); surroundResultVO.setLatitude(siteInfo.getLatitude()); surroundResultVO.setName(devInfo.getDeviceName()); surroundResultVO.setAddress(siteInfo.getLocation()); surroundResultVO.setDistance(Double.parseDouble(distance2f)); surroundResultVO.setResourceTypeId(Constants.SXJ_CODE); result.add(surroundResultVO); } } } } } }catch (Exception e){ log.info("queryDeviceLayer异常==",e); } } /* * 功能描述: * 调通用平台告警查询接口 * @param: resourceTypeList 资源类型编码集合 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @param: result 结果集 * @return: * @auther: hued * @date: 2022年8月4日09:18:08 * @version: release_v1.4 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / private void getWarningOrderLayer(List<String> resourceTypeList,SurroundRequestVO surroundRequestVO,List<SurroundResultVO> result){ try{ if (resourceTypeList.contains(Constants.GJ_CODE)) { //移除告警周边类型 resourceTypeList.remove(Constants.GJ_CODE); WarningOrderLayerDTO dto = new WarningOrderLayerDTO(); BeanUtils.copyProperties(surroundRequestVO,dto); log.info(Constants._PARAM_SDK_PROVIDER + "-告警查询-/video-event/alarm/orderForTrade/getWarningOrderLayer" + Constants._PARAM_LOG_REQUEST,JSONObject.toJSONString(dto)); Result gjResult = tradeWarningOrderService.getWarningOrderLayer(dto); log.info(Constants._PARAM_SDK_PROVIDER + "-告警查询-/video-event/alarm/orderForTrade/getWarningOrderLayer" + Constants._PARAM_LOG_RESPONSE,JSONObject.toJSONString(gjResult)); List<LinkedHashMap> list = (List<LinkedHashMap>)gjResult.getData(); if(gjResult.getCode() == Constants.SUCCESS && !CollectionUtils.isEmpty(list)){ for (int i = 0; i < list.size(); i++) { Map jo = list.get(i); String distance = StringUtils.isEmpty(jo.get(Constants.DISTANCE)) ? Constants.ZERO_FLAG : (String)jo.get(Constants.DISTANCE); if(Double.parseDouble(distance) > 0){ String distance2f = String.format(Constants.STRING_FORMAT_2F,Double.parseDouble(distance)/Constants.THOUSAND_NUM); distance2f = (Constants.ZERO_ZERO_FLAG).equals(distance2f) ? Constants.ZERO_ONE_FLAG : distance2f; SurroundResultVO surroundResultVO = new SurroundResultVO(); surroundResultVO.setLongitude(String.valueOf(jo.get(Constants.LONGITUDE))); surroundResultVO.setLatitude(String.valueOf(jo.get(Constants.LATITUDE))); surroundResultVO.setName(String.valueOf(jo.get(Constants.ALARMBODY))); surroundResultVO.setAddress(String.valueOf(jo.get(Constants.ADDRESS))); surroundResultVO.setDistance(Double.parseDouble(distance2f)); surroundResultVO.setResourceTypeId(Constants.GJ_CODE); result.add(surroundResultVO); } } } } }catch (Exception e){ log.info("getWarningOrderLayer异常==",e); } } /* * 功能描述: * 调通用平台资源查询接口 * @param: resourceTypeList 资源类型编码集合 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @param: result 结果集 * @return: * @auther: hued * @date: 2022年8月4日09:18:08 * @version: release_v1.4 * @requestID: R-ZBZB-202203300865974_林业_监测预警 / private void selectResource(List<String> resourceTypeList,SurroundRequestVO surroundRequestVO,List<SurroundResultVO> result){ try{ if(!CollectionUtils.isEmpty(resourceTypeList)){ ResourceConf resourceConf = new ResourceConf(); BeanUtils.copyProperties(surroundRequestVO,resourceConf); log.info(Constants._PARAM_SDK_PROVIDER + "-资源查询-/video-bdm/resource/selectResource" + Constants._PARAM_LOG_REQUEST,JSONObject.toJSONString(resourceConf)); Result<List<ResourceConf>> zyResult = resourceAPI.selectResource(resourceConf); log.info(Constants._PARAM_SDK_PROVIDER + "-资源查询-/video-bdm/resource/selectResource" + Constants._PARAM_LOG_RESPONSE,JSONObject.toJSONString(zyResult)); if(zyResult.getCode() == Constants.SUCCESS && !ObjectUtils.isEmpty(zyResult.getData())){ for(ResourceConf resourceConfIn : zyResult.getData()){ String distance = StringUtils.isEmpty(resourceConfIn.getDistance()) ? Constants.ZERO_FLAG : resourceConfIn.getDistance(); if(Double.parseDouble(distance) > 0){ String distance2f = String.format(Constants.STRING_FORMAT_2F,Double.parseDouble(distance)/Constants.THOUSAND_NUM); distance2f = (Constants.ZERO_ZERO_FLAG).equals(distance2f) ? Constants.ZERO_ONE_FLAG : distance2f; SurroundResultVO surroundResultVO = new SurroundResultVO(); BeanUtils.copyProperties(resourceConfIn,surroundResultVO); surroundResultVO.setName(resourceConfIn.getResourceName()); surroundResultVO.setAddress(resourceConfIn.getAddr()); surroundResultVO.setDistance(Double.parseDouble(distance2f)); if (!ObjectUtils.isEmpty(resourceConfIn.getIcon())) { surroundResultVO.setIcon(Constants.SVG_TO_BASE64 + CommonService.getBase64ByUrl(resourceConfIn.getIcon())); } result.add(surroundResultVO); } } } } }catch (Exception e){ log.info("selectResource异常==",e); } } /* * 功能描述: * 调通用平台气象站查询接口 * @param: resourceTypeList 资源类型编码集合 * @param: surroundRequestVO 中心点经度、中心点纬度、范围半径(km)、周边分析类型、分页参数 * @param: result 结果集 * @return: * @auther: hued * @date: 2022年8月4日09:18:08 * @version: release_v1.4 * @requestID: R-ZBZB-202203300865974_林业_监测预警 */ private void querySensorLayer(List<String> resourceTypeList,SurroundRequestVO surroundRequestVO,List<SurroundResultVO> result){ try{ if (resourceTypeList.contains(Constants.QXZ_CODE)) { //移除告警周边类型 resourceTypeList.remove(Constants.QXZ_CODE); DeviceLayerReq dto = new DeviceLayerReq(); BeanUtils.copyProperties(surroundRequestVO,dto); dto.setDistance(surroundRequestVO.getRadius()); dto.setLongitude(StringUtils.isEmpty(surroundRequestVO.getLongitude())?Constants.ZERO_NUM:Double.parseDouble(surroundRequestVO.getLongitude())); dto.setLatitude(StringUtils.isEmpty(surroundRequestVO.getLatitude())?Constants.ZERO_NUM:Double.parseDouble(surroundRequestVO.getLatitude())); log.info(Constants._PARAM_SDK_PROVIDER + "-气象站查询-/video-device/industry/device/querySensorLayer" + Constants._PARAM_LOG_REQUEST,JSONObject.toJSONString(dto)); Result<List<IndustryDeviceTree>> gjResult = iIndustryDeviceService.querySensorLayer(dto); log.info(Constants._PARAM_SDK_PROVIDER + "-气象站查询-/video-device/industry/device/querySensorLayer" + Constants._PARAM_LOG_RESPONSE,JSONObject.toJSONString(gjResult)); List<IndustryDeviceTree> list = gjResult.getData(); if(gjResult.getCode() == Constants.SUCCESS && !CollectionUtils.isEmpty(list)){ for (int i = 0; i < list.size(); i++) { IndustryDeviceTree jo = list.get(i); String distance = StringUtils.isEmpty(jo.getDistance()) ? Constants.ZERO_FLAG : jo.getDistance(); if(Double.parseDouble(distance) > 0){ String distance2f = String.format(Constants.STRING_FORMAT_2F,Double.parseDouble(distance)/Constants.THOUSAND_NUM); distance2f = (Constants.ZERO_ZERO_FLAG).equals(distance2f) ? Constants.ZERO_ONE_FLAG : distance2f; SurroundResultVO surroundResultVO = new SurroundResultVO(); surroundResultVO.setLongitude(jo.getLongitude()); surroundResultVO.setLatitude(jo.getLatitude()); surroundResultVO.setName(StringUtils.isEmpty(jo.getDeviceName())?Constants.QXZ_NAME:jo.getDeviceName()); surroundResultVO.setAddress(jo.getLocation()); surroundResultVO.setDistance(Double.parseDouble(distance2f)); surroundResultVO.setResourceTypeId(Constants.QXZ_CODE); result.add(surroundResultVO); } } } } }catch (Exception e){ log.info("querySensorLayer异常==",e); } }}
package com.chinatower.park.service.impl;import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONObject;import com.chinatower.common.entity.Result;import com.chinatower.event.api.ITradeWarningOrderService;import com.chinatower.event.entity.dto.InterceptConfigDTO;import com.chinatower.event.entity.dto.WarningOrderLayerDTO;import com.chinatower.park.common.Constants;import com.chinatower.park.model.InterceptConfigVO;import com.chinatower.park.model.WarningLayerRequest;import com.chinatower.park.model.WarningLayerResponse;import com.chinatower.park.service.IWarningOrderService;import lombok.extern.log4j.Log4j2;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.time.LocalDateTime;import java.time.ZoneId;import java.time.temporal.ChronoUnit;import java.util.;/* * @description 描述 * @Author wanli.chen * @Date 2022/3/30 16:18 * @Version 1.0 * @Tips /@Service@Log4j2public class WarningOrderServiceImpl implements IWarningOrderService { @Autowired private ITradeWarningOrderService iTradeWarningOrderService; /* * 告警图层查询 * * @param dto * @return */ @Override public Result findWarningByLayer(WarningLayerRequest dto) { WarningOrderLayerDTO warningOrderLayerDTO = new WarningOrderLayerDTO(); BeanUtils.copyProperties(dto, warningOrderLayerDTO); log.info("/alarm/orderForTrade/getWarningOrderLayer 告警图层请求报文=={}", JSONObject.toJSONString(warningOrderLayerDTO)); Result result = iTradeWarningOrderService.getWarningOrderLayer(warningOrderLayerDTO); if (result.getCode() == Constants.SUCCESS) { if (result.getData() != null) { List<LinkedHashMap> list = (List<LinkedHashMap>) result.getData(); List<WarningLayerResponse> resultList = new ArrayList<>(list.size()); for (int i = 0; i < list.size(); i++) { Map map = list.get(i); WarningLayerResponse response = new WarningLayerResponse(); response.setOrderId(String.valueOf(map.get("orderId"))); response.setWarningOrderId(String.valueOf(map.get("warningOrderId"))); response.setLongitude(String.valueOf(map.get("longitude"))); response.setLatitude(String.valueOf(map.get("latitude"))); response.setDistance(String.valueOf(map.get("distance"))); response.setLocation(String.valueOf(map.get("location"))); response.setOrderStatus(String.valueOf(map.get("orderStatus"))); response.setProvinceId(String.valueOf(map.get("provinceId"))); response.setCityId(String.valueOf(map.get("cityId"))); response.setCountyId(String.valueOf(map.get("countyId"))); resultList.add(response); } return Result.data(resultList); } else { return result; } } else { return result; } } @Override public Result createIntercept(InterceptConfigVO vo) { boolean todayAlarm = vo.getNoAlarmToday(); if (todayAlarm){ int timeRemaining = getRemainSecondsOneDay(); vo.setInterceptTime(timeRemaining); } InterceptConfigDTO dto = new InterceptConfigDTO(); BeanUtils.copyProperties(vo, dto); log.info("/video-device/getDeviceVisibleBySite 请求报文=={}", JSON.toJSONString(dto)); Result result = iTradeWarningOrderService.createIntercept(dto); log.info("/video-device/getDeviceVisibleBySite 返回报文=={}", JSON.toJSONString(result)); return result; } public static Integer getRemainSecondsOneDay() { Date currentDate = new Date(); LocalDateTime midnight = LocalDateTime.ofInstant(currentDate.toInstant(), ZoneId.systemDefault()).plusDays(1).withHour(0).withMinute(0) .withSecond(0).withNano(0); LocalDateTime currentDateTime = LocalDateTime.ofInstant(currentDate.toInstant(), ZoneId.systemDefault()); long minutes = ChronoUnit.MINUTES.between(currentDateTime, midnight); return (int) minutes; }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.constant.AttachmentNameVariableEnum;import cn.surveyking.server.core.constant.ProjectModeEnum;import cn.surveyking.server.core.constant.StorageTypeEnum;import cn.surveyking.server.core.exception.InternalServerError;import cn.surveyking.server.core.uitls.;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.AnswerViewMapper;import cn.surveyking.server.domain.model.Answer;import cn.surveyking.server.domain.model.Project;import cn.surveyking.server.domain.model.ProjectPartner;import cn.surveyking.server.mapper.AnswerMapper;import cn.surveyking.server.mapper.ProjectMapper;import cn.surveyking.server.mapper.ProjectPartnerMapper;import cn.surveyking.server.service.;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import org.dhatim.fastexcel.reader.ReadableWorkbook;import org.dhatim.fastexcel.reader.Row;import org.dhatim.fastexcel.reader.Sheet;import org.springframework.beans.BeanUtils;import org.springframework.core.io.ByteArrayResource;import org.springframework.core.io.InputStreamResource;import org.springframework.http.MediaType;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import org.springframework.util.StringUtils;import java.io.;import java.text.SimpleDateFormat;import java.util.;import java.util.regex.Matcher;import java.util.regex.Pattern;import java.util.stream.Collectors;import java.util.stream.Stream;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;/* * @author javahuang * @date 2021/8/3 /@Service@Transactional@RequiredArgsConstructorpublic class AnswerServiceImpl extends ServiceImpl<AnswerMapper, Answer> implements AnswerService { private final ProjectMapper projectMapper; private final FileService fileService; private final AnswerViewMapper answerViewMapper; private final UserService userService; private final DeptService deptService; private final ProjectService projectService; private final ProjectPartnerMapper projectPartnerMapper; @Override public PaginationResponse<AnswerView> listAnswer(AnswerQuery query) { Page<Answer> page = new Page<>(query.getCurrent(), query.getPageSize()); super.page(page, Wrappers.<Answer>lambdaQuery().isNotNull(Answer::getAnswer) // 暂存题答案会为空 .eq(query.getProjectId() != null, Answer::getProjectId, query.getProjectId()) .in(query.getIds() != null && query.getIds().size() > 0, Answer::getId, query.getIds()) .lt(query.getEndTime() != null, Answer::getCreateAt, query.getEndTime()) .gt(query.getStartTime() != null, Answer::getCreateAt, query.getStartTime()) .eq(query.getId() != null, Answer::getId, query.getId()).orderByDesc(Answer::getCreateAt)); List<AnswerView> list = answerViewMapper.toView(page.getRecords()); Project project = projectMapper.selectById(query.getProjectId()); FlatSurveySchemaByType schemaByType = parseSurveySchemaByType(project.getSurvey()); list.forEach(view -> setAnswerExtraInfo(view, schemaByType)); return new PaginationResponse<>(page.getTotal(), list); } private FlatSurveySchemaByType parseSurveySchemaByType(SurveySchema schema) { FlatSurveySchemaByType schemaByType = new FlatSurveySchemaByType(); List<SurveySchema> schemaDataTypes = SchemaHelper.flatSurveySchema(schema); schemaByType.setSchemaDataTypes(schemaDataTypes); schemaByType.setUserQuestions(parseSurveySchemaByType(schemaDataTypes, SurveySchema.QuestionType.User)); schemaByType.setDeptQuestions(parseSurveySchemaByType(schemaDataTypes, SurveySchema.QuestionType.Dept)); schemaByType.setFileQuestions(parseSurveySchemaByType(schemaDataTypes, SurveySchema.QuestionType.Signature)); schemaByType.getFileQuestions() .addAll((parseSurveySchemaByType(schemaDataTypes, SurveySchema.QuestionType.Upload))); return schemaByType; } private List<SurveySchema> parseSurveySchemaByType(List<SurveySchema> flattedSurveySchema, SurveySchema.QuestionType questionType) { return flattedSurveySchema.stream().filter(x -> x.getType() == questionType).collect(Collectors.toList()); } private void setAnswerExtraInfo(AnswerView view, FlatSurveySchemaByType schemaByType) { setAnswerTypeInfo(schemaByType.getDeptQuestions(), view); setAnswerTypeInfo(schemaByType.getFileQuestions(), view); setAnswerTypeInfo(schemaByType.getUserQuestions(), view); setUserName(view); } private void setAnswerTypeInfo(List<SurveySchema> flatQuestionSchema, AnswerView view) { if (flatQuestionSchema.size() == 0) { return; } LinkedHashMap<String, Object> answers = view.getAnswer(); SurveySchema.QuestionType questionType = flatQuestionSchema.get(0).getType(); flatQuestionSchema.forEach(question -> { String questionId = question.getId(); Object option2value = answers.get(questionId); if (option2value != null && option2value instanceof Map) { // 签名题前端存的是 {qId: {oId: fileId}} 需要转换成数组 ((Map<String, Object>) option2value).values().stream().map(x -> { if (x instanceof List) { return (List<String>) x; } return Collections.singletonList(x.toString()); }).collect(Collectors.toList()).forEach(ids -> { if (questionType == SurveySchema.QuestionType.User) { view.setUsers(ids.stream().map(userId -> userService.loadUserById(userId).simpleMode()) .collect(Collectors.toList())); } else if (questionType == SurveySchema.QuestionType.Signature \|\| questionType == SurveySchema.QuestionType.Upload) { FileQuery query = new FileQuery(); query.setType(StorageTypeEnum.ANSWER_ATTACHMENT.getType()); query.setIds(ids); // 图片上传和签名需要做一个合并 view.getAttachment().addAll(fileService.listFiles(query)); } else if (questionType == SurveySchema.QuestionType.Dept) { view.setDepts(ids .stream().map(id -> deptService.listDept(null).stream() .filter(x -> x.getId().equals(id)).findFirst().orElseGet(DeptView::new)) .collect(Collectors.toList())); } }); } }); } private void setUserName(AnswerView answerView) { if (answerView.getCreateBy() != null) { UserInfo userInfo = userService.loadUserById(answerView.getCreateBy()); if (userInfo != null) { answerView.setCreateByName(userInfo.getName()); return; } ProjectPartner projectPartner = projectPartnerMapper.selectById(answerView.getCreateBy()); if (projectPartner != null) { answerView.setCreateByName(projectPartner.getUserName()); return; } } } @Override public AnswerView getAnswer(AnswerQuery query) { AnswerView answerView = null; if (query.getId() != null) { answerView = answerViewMapper.toView(getById(query.getId())); } else if (query.getProjectId() != null && Boolean.TRUE.equals(query.getLatest())) { answerView = answerViewMapper.toView(list(Wrappers.<Answer>lambdaQuery() .eq(Answer::getProjectId, query.getProjectId()) .eq(SecurityContextUtils.isAuthenticated(), Answer::getCreateBy, SecurityContextUtils.getUserId()) .eq(query.getCreateBy() != null, Answer::getCreateBy, query.getCreateBy()) .orderByDesc(Answer::getCreateAt)).stream().findFirst().orElse(null)); } if (answerView == null) { return null; } // 获取考试排名信息 if (query.isRankEnabled()) { List<Double> scores = list(Wrappers.<Answer>lambdaQuery().select(Answer::getExamScore, Answer::getId) .eq(Answer::getProjectId, answerView.getProjectId())).stream() .map(x -> Optional.ofNullable(x.getExamScore()).orElse(Double.valueOf(0))) .collect(Collectors.toList()); Collections.sort(scores, Collections.reverseOrder()); answerView.setRank(scores.indexOf(answerView.getExamScore()) + 1); } String projectId = answerView.getProjectId(); Project project = projectMapper.selectById(projectId); if (project == null \|\| project.getSurvey() == null) { // 随机问题问卷没有 schema return answerView; } FlatSurveySchemaByType schemaByType = parseSurveySchemaByType(project.getSurvey()); setAnswerExtraInfo(answerView, schemaByType); return answerView; } @Override public AnswerView saveAnswer(AnswerRequest request) { // 公开查询修改答案时不会传元数据 if (request.getMetaInfo() != null) { request.getMetaInfo().setClientInfo(parseClientInfo(request.getMetaInfo().getClientInfo())); } if (StringUtils.hasText(request.getId())) { return updateAnswer(request); } else { Answer answer = answerViewMapper.fromRequest(request); // 使用 uuid 作为外部公开查询引用，防暴力破解 answer.setId(UUID.randomUUID().toString()); answer.setCreateAt(new Date()); save(beforeSaveAnswer(answer)); return answerViewMapper.toView(answer); } } @Override public long count(AnswerQuery query) { return count(Wrappers.<Answer>lambdaQuery().eq(Answer::getProjectId, query.getProjectId()) .ge(query.getStartTime() != null, Answer::getCreateAt, query.getStartTime()) .lt(query.getEndTime() != null, Answer::getCreateAt, query.getEndTime()) .eq(query.getCreateBy() != null, Answer::getCreateBy, query.getCreateBy()) .like(query.getIp() != null, Answer::getMetaInfo, query.getIp()) .like(query.getValueQuery() != null, Answer::getAnswer, query.getValueQuery()) .like(query.getCookie() != null, Answer::getMetaInfo, query.getCookie())); } @Override public AnswerView updateAnswer(AnswerRequest request) { Answer answer = beforeSaveAnswer(answerViewMapper.fromRequest(request)); updateById(answer); return answerViewMapper.toView(answer); } @Override public void deleteAnswer(AnswerRequest request) { super.removeByIds(request.getIds()); } @Override public DownloadData downloadSurvey(DownloadQuery query) { Project project = projectMapper.selectById(query.getProjectId()); AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setProjectId(query.getProjectId()); answerQuery.setIds(query.getIds()); answerQuery.setStartTime(query.getStartTime()); answerQuery.setEndTime(query.getEndTime()); if (query.getPageSize() != 0) { answerQuery.setCurrent(query.getCurrent()); answerQuery.setPageSize(query.getPageSize()); } else { answerQuery.setPageSize(Integer.MAX_VALUE); } List<AnswerView> answerViews = listAnswer(answerQuery).getList(); DownloadData download = new DownloadData(); download.setFileName(project.getName() + ".xlsx"); try { PipedOutputStream outputStream = new PipedOutputStream(); PipedInputStream inputStream = new PipedInputStream(outputStream); new Thread(() -> { try { export(project, answerViews, outputStream); } catch (Exception e) { e.printStackTrace(); } finally { try { outputStream.close(); } catch (IOException e) { e.printStackTrace(); } } }).start(); download.setResource(new InputStreamResource(inputStream)); } catch (IOException e) { e.printStackTrace(); } download.setMediaType(MediaType.parseMediaType("application/vnd.ms-excel")); return download; } /* * 下载附件要使用 InputStreamResource，避免 Byte... 加载到内存 * @param query * @return / @Override public DownloadData downloadAttachment(DownloadQuery query) { Project project = projectMapper.selectById(query.getProjectId()); DownloadData downloadData = new DownloadData(); AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setIds(query.getIds()); answerQuery.setProjectId(query.getProjectId()); answerQuery.setStartTime(query.getStartTime()); answerQuery.setEndTime(query.getEndTime()); if (query.getCurrent() != 0 && query.getPageSize() != 0) { answerQuery.setCurrent(query.getCurrent()); answerQuery.setPageSize(query.getPageSize()); } else { answerQuery.setPageSize(Integer.MAX_VALUE); } // 下载某个问卷答案的附件 if (query.getAnswerId() != null) { answerQuery.setId(query.getAnswerId()); return generateSurveyAttachment(project, listAnswer(answerQuery).getList().get(0)); } else { // 下载所有问卷答案的附件 downloadData.setResource( new InputStreamResource(answerAttachToZip(project, listAnswer(answerQuery).getList(), query))); downloadData.setFileName(project.getName() + ".zip"); downloadData.setMediaType(MediaType.parseMediaType("application/zip")); } return downloadData; } @Override public List<AnswerView> listAnswerDeleted(AnswerQuery query) { List<AnswerView> list = answerViewMapper.toView(getBaseMapper().selectLogicDeleted(query.getProjectId())); Project project = projectMapper.selectById(query.getProjectId()); FlatSurveySchemaByType schemaByType = parseSurveySchemaByType(project.getSurvey()); list.forEach(view -> setAnswerExtraInfo(view, schemaByType)); return list; } @Override public void batchDestroyAnswer(AnswerRequest request) { this.getBaseMapper().batchDestroy(request.getIds()); } @Override public void restoreAnswer(AnswerRequest request) { this.getBaseMapper().restoreAnswer(request.getIds()); } @Override @SneakyThrows public AnswerUploadView upload(AnswerUploadRequest request) { AnswerUploadView view = new AnswerUploadView(); try (InputStream is = request.getFile().getInputStream(); ReadableWorkbook wb = new ReadableWorkbook(is)) { Sheet sheet = wb.getFirstSheet(); String name = request.getFile().getOriginalFilename().substring(0, request.getFile().getOriginalFilename().lastIndexOf(".")); List<Answer> answers = new ArrayList<>(); try (Stream<Row> rows = sheet.openStream()) { // 第一行作为行头 rows.forEach(r -> { int rowNum = r.getRowNum(); if (rowNum == 1) { if (request.getProjectId() != null) { ProjectView projectView = projectService.getProject(request.getProjectId()); view.setProjectId(projectView.getId()); view.setSchema(filterSchemaByRow(r, projectView.getSurvey())); } else if (Boolean.TRUE.equals(request.getAutoSchema())) { ProjectView projectView = parseRow2Schema(r, name, request.getParentId()); view.setProjectId(projectView.getId()); view.setSchema(projectView.getSurvey()); } } else { // 处理答案 answers.add(parseRow2Answer(view, r)); } }); } if (answers.size() > 0) { saveBatch(answers); } } return view; } private DownloadData generateSurveyAttachment(Project project, AnswerView answer) { DownloadData downloadData = new DownloadData(); List<FileView> files = answer.getAttachment(); // 如果只有一个附件，则直接返回附件的结果 if (files.size() == 1) { FileView attachment = files.get(0); downloadData.setFileName(attachment.getOriginalName()); downloadData.setResource(fileService.loadFile(new FileQuery(attachment.getId())).getBody()); } else { // 多个附件，压缩包 downloadData.setResource(new InputStreamResource( answerAttachToZip(project, Collections.singletonList(answer), new DownloadQuery()))); downloadData.setFileName(answer.getId() + ".zip"); downloadData.setMediaType(MediaType.parseMediaType("application/zip")); } return downloadData; } /* * 将单个问卷的附件转成 zip 压缩包 * @param answers * @return / private InputStream answerAttachToZip(Project project, List<AnswerView> answers, DownloadQuery query) { try { PipedOutputStream outputStream = new PipedOutputStream(); PipedInputStream inputStream = new PipedInputStream(outputStream); new Thread(() -> { try (ZipOutputStream zout = new ZipOutputStream(outputStream);) { int[] serialNum = { 0, 0 }; List<SurveySchema> uploadQuestions = SchemaHelper.flatSurveySchema(project.getSurvey()).stream() .filter(qSchema -> SurveySchema.QuestionType.Upload.equals(qSchema.getType())) .collect(Collectors.toList()); answers.forEach(answer -> { serialNum[1] = 0; answer.getAttachment().forEach(attachment -> { serialNum[0] += 1; serialNum[1] += 1; ByteArrayResource resource = (ByteArrayResource) fileService .loadFile(new FileQuery(attachment.getId())).getBody(); String parsedFileName = parseAttachmentNameByExp(answer, query.getNameExp(), attachment, serialNum, uploadQuestions); ZipEntry entry = new ZipEntry(parsedFileName); try { zout.putNextEntry(entry); zout.write(resource.getByteArray()); } catch (IOException e) { e.printStackTrace(); } }); }); // 生成表格 if (DownloadQuery.DownloadType.answerAttachment.equals(query.getType())) { ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); export(project, answers, byteArrayOutputStream); ZipEntry entry = new ZipEntry(project.getName() + ".xlsx"); zout.putNextEntry(entry); zout.write(byteArrayOutputStream.toByteArray()); } } catch (Exception e) { throw new InternalServerError("生成压缩文件失败", e); } }).start(); return inputStream; } catch (Exception e) { throw new InternalServerError("生成压缩文件失败", e); } } private void export(Project project, List<AnswerView> answerViews, OutputStream outputStream) { List<SurveySchema> schemaDataTypes = SchemaHelper.flatSurveySchema(project.getSurvey()); int[] indexArr = { 0 }; new ExcelExporter.Builder().setSheetName(project.getName()).setOutputStream(outputStream) .setRows(answerViews.stream().map(answer -> { indexArr[0] = indexArr[0] += 1; return SchemaHelper.parseRowData(answer, schemaDataTypes, indexArr[0], project.getMode()); }).collect(Collectors.toList())) .setColumns(SchemaHelper.parseColumns(schemaDataTypes, project.getMode())).build().exportToStream(); } /* * @param answerView 当前答案 * @param nameExp 附件名称表达式 * @param file 当前附件 * @param serialNum 序号 * @param uploadQuestions 问卷上传题 schema * @return 新的附件名称 / private String parseAttachmentNameByExp(AnswerView answerView, String nameExp, FileView file, int[] serialNum, List<SurveySchema> uploadQuestions) { if (StringUtils.hasText(nameExp)) { String fileName = nameExp; LinkedHashMap<String, Object> answerMap = answerView.getAnswer(); Pattern pattern = Pattern.compile("#\\{([a-zA-Z0-9]+)\\.?([a-zA-Z0-9])\\}"); Matcher matcher = pattern.matcher(nameExp); String exp, questionId, optionId = null; while (matcher.find()) { int count = matcher.groupCount(); exp = matcher.group(0); questionId = matcher.group(1); if (count > 1) { optionId = matcher.group(2); } String expValue = ""; if (AttachmentNameVariableEnum.projectId.name().equals(questionId)) { expValue = answerView.getProjectId(); } else if (AttachmentNameVariableEnum.serialNum.name().equals(questionId)) { expValue = serialNum[0] + ""; } else if (AttachmentNameVariableEnum.serialNumInAnswer.name().equals(questionId)) { expValue = serialNum[1] + ""; } else if (AttachmentNameVariableEnum.uploadDate.name().equals(questionId)) { SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd"); expValue = sdf.format(answerView.getCreateAt()); } else if (AttachmentNameVariableEnum.uploadDateTime.name().equals(questionId)) { SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss"); expValue = sdf.format(answerView.getCreateAt()); } else if (AttachmentNameVariableEnum.sourceName.name().equals(questionId)) { expValue = getFileNameWithoutSuffix(file.getOriginalName()); } else if (AttachmentNameVariableEnum.questionTitle.name().equals(questionId)) { for (SurveySchema uploadQuestion : uploadQuestions) { Object qValue = answerView.getAnswer().get(uploadQuestion.getId()); if (qValue != null) { boolean fileInCurrentSchema = ((Map<String, List<String>>) qValue) .get(uploadQuestion.getChildren().get(0).getId()).stream() .filter(x -> x.equals(file.getId())).findFirst().isPresent(); if (fileInCurrentSchema) { expValue = uploadQuestion.getTitle(); break; } } } } else { // 问题变量 Map<String, Object> questionValue = (Map<String, Object>) answerMap.get(questionId); if (questionValue != null) { // 单行文本表达式只有问题id #{xxxx} if (StringUtils.hasText(optionId)) { expValue = questionValue.get(optionId).toString(); } else { // 多行文本会有选项id #{ancd.a3dx} expValue = questionValue.values().toArray()[0].toString(); } } } fileName = StringUtils.replace(fileName, exp, expValue); } String suffix = getFileExtension(file.getOriginalName()); // 返回解析之后的文件名字 if (suffix != null) { return fileName + "." + suffix; } return fileName; } else { // 返回原始文件名字 return file.getOriginalName(); } } /** * 获取文件后缀 * @param fileName 文件名称 * @return 文件后缀 / private String getFileExtension(String fileName) { String extension = null; int i = fileName.lastIndexOf('.'); if (i > 0) { extension = fileName.substring(i + 1); } return extension; } private String getFileNameWithoutSuffix(String fileName) { String fileNameWithoutSuffix = null; int i = fileName.lastIndexOf('.'); if (i > 0) { fileNameWithoutSuffix = fileName.substring(0, i); } return fileNameWithoutSuffix; } /* * 答案保存之前计算考试分值、每题得分情况 * @param answer * @return / private Answer beforeSaveAnswer(Answer answer) { Project project = projectMapper.selectById(answer.getProjectId()); computeExamScore(answer, project); updateLinkSurveyAnswer(answer, project); return answer; } private void computeExamScore(Answer answer, Project project) { if (project != null && ProjectModeEnum.exam.equals(project.getMode()) && answer != null && answer.getAnswer() != null) { SurveySchema srcSchema = project.getSurvey(); // 随机抽题需要根据答案获取 schema if (answer.getId() != null) { Answer existAnswer = getById(answer.getId()); if (existAnswer != null && existAnswer.getSurvey() != null) { srcSchema = existAnswer.getSurvey(); } } AnswerScoreEvaluator evaluator = new AnswerScoreEvaluator(srcSchema, answer.getAnswer()); answer.setExamScore(evaluator.eval()); AnswerExamInfo examInfo = new AnswerExamInfo(); examInfo.setQuestionScore(evaluator.getQuestionScore()); answer.setExamInfo(examInfo); } } /* * 更新原始问卷答案 * @param answer * @param project */ private void updateLinkSurveyAnswer(Answer answer, Project project) { SchemaHelper.flatSurveySchema(project.getSurvey()).stream() .filter(qSchema -> !CollectionUtils.isEmpty(qSchema.getChildren().get(0).getLinkSurveys())) .forEach(qSchemaHasLinkSurvey -> { Map<String, Object> qValue = (Map<String, Object>) answer.getAnswer() .get(qSchemaHasLinkSurvey.getId()); if (qValue == null) { return; } SurveySchema optionSchemaHasLinkAttr = qSchemaHasLinkSurvey.getChildren().get(0); optionSchemaHasLinkAttr.getLinkSurveys().forEach(linkSurvey -> { if (Boolean.TRUE.equals(linkSurvey.getEnableUpdate())) { Object optionValue = qValue.get(optionSchemaHasLinkAttr.getId()); Answer linkedAnswer = this.getOne(Wrappers.<Answer>lambdaQuery() .eq(Answer::getProjectId, linkSurvey.getLinkSurveyId()) .like(Answer::getAnswer, SchemaHelper.buildLinkLikeCondition(linkSurvey, optionValue)) .orderByDesc(Answer::getCreateAt).last("limit 1")); if (linkedAnswer != null) { // 修改 for (SurveySchema.LinkField linkField : linkSurvey.getLinkFields()) { SchemaHelper.setQuestionValue(linkedAnswer.getAnswer(), linkField.getLinkQuestionId(), linkField.getLinkOptionId(), SchemaHelper.getQuestionValue(answer.getAnswer(), linkField.getFillQuestionId(), linkField.getFillOptionId())); } this.updateById(linkedAnswer); } else { // 添加 Answer addAnswer = new Answer(); BeanUtils.copyProperties(answer, addAnswer, "id", "examScore", "examInfo", "answer", "projectId"); addAnswer.setProjectId(linkSurvey.getLinkSurveyId()); LinkedHashMap addAnswerMap = new LinkedHashMap(); addAnswer.setAnswer(addAnswerMap); SchemaHelper.setQuestionValue(addAnswerMap, linkSurvey.getLinkQuestionId(), linkSurvey.getLinkOptionId(), optionValue); for (SurveySchema.LinkField linkField : linkSurvey.getLinkFields()) { SchemaHelper.setQuestionValue(addAnswerMap, linkField.getLinkQuestionId(), linkField.getLinkOptionId(), SchemaHelper.getQuestionValue(answer.getAnswer(), linkField.getFillQuestionId(), linkField.getFillOptionId())); } this.save(addAnswer); } } }); }); } private ProjectView parseRow2Schema(Row row, String name, String parentId) { // 处理行头自动生成 schema SurveySchema schema = createSurveyFromExcelRowHeader(row); schema.setTitle(name); ProjectRequest projectRequest = new ProjectRequest(); projectRequest.setSurvey(schema); projectRequest.setName(name); projectRequest.setMode(ProjectModeEnum.survey); projectRequest.setParentId(parentId); projectRequest.setSetting(ProjectSetting.builder().mode(ProjectModeEnum.survey).status(1).build()); return projectService.addProject(projectRequest); } private SurveySchema createSurveyFromExcelRowHeader(Row row) { Set<String> ids = new HashSet<>(); SurveySchema schema = SurveySchema.builder() .children(row.stream() .map(cell -> SurveySchema.builder().id(NanoIdUtils.randomNanoId(4, ids)) .type(SurveySchema.QuestionType.FillBlank).title(cell.getText()) .children(Collections.singletonList( SurveySchema.builder().id(NanoIdUtils.randomNanoId(4, ids)).build())) .build()) .collect(Collectors.toList())) .build(); return schema; } private SurveySchema filterSchemaByRow(Row row, SurveySchema schema) { List<SurveySchema> flatSurveySchema = SchemaHelper.flatSurveySchema(schema); return SurveySchema.builder().id(schema.getId()).children(row.stream().map(cell -> { String title = cell.getText(); return flatSurveySchema.stream().filter(x -> x.getTitle().equals(title)).findFirst() .orElse(SurveySchema.builder().build()); }).collect(Collectors.toList())).build(); } private Answer parseRow2Answer(AnswerUploadView view, Row r) { Answer answer = new Answer(); answer.setProjectId(view.getProjectId()); LinkedHashMap<String, Map<String, String>> answerMap = new LinkedHashMap(); int i = 0; for (SurveySchema questionSchema : view.getSchema().getChildren()) { String cellValue = r.getCellText(i); String questionId = questionSchema.getId(); if (questionSchema.getChildren() == null \|\| questionSchema.getChildren().size() == 0) { continue; } String optionId = questionSchema.getChildren().get(0).getId(); if (cellValue != null) { Map<String, String> optionValue = new LinkedHashMap<>(); optionValue.put(optionId, cellValue); answerMap.put(questionId, optionValue); } i++; } answer.setAnswer(answerMap); return answer; }}
package cn.surveyking.server.impl;import cn.surveyking.server.domain.dto.DashboardQuery;import cn.surveyking.server.domain.dto.DashboardRequest;import cn.surveyking.server.domain.dto.DashboardView;import cn.surveyking.server.domain.mapper.DashboardViewMapper;import cn.surveyking.server.domain.model.Dashboard;import cn.surveyking.server.mapper.DashboardMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.DashboardService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import lombok.RequiredArgsConstructor;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.List;/** * */@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class DashboardServiceImpl extends BaseService<DashboardMapper, Dashboard> implements DashboardService { private DashboardViewMapper dashboardViewMapper; @Override public List<DashboardView> listDashboard(DashboardQuery query) { List<Dashboard> dashboardList = list(Wrappers.<Dashboard>lambdaQuery().eq(Dashboard::getType, query.getType()) .eq(query.getProjectId() != null, Dashboard::getProjectId, query.getProjectId())); return dashboardViewMapper.toView(dashboardList); } @Override public void saveDashboard(List<DashboardRequest> request) { }}
package cn.surveyking.server.impl;import cn.surveyking.server.domain.dto.DeptRequest;import cn.surveyking.server.domain.dto.DeptView;import cn.surveyking.server.domain.dto.DeptSortRequest;import cn.surveyking.server.domain.dto.SelectDeptRequest;import cn.surveyking.server.domain.mapper.DeptDtoMapper;import cn.surveyking.server.domain.model.Dept;import cn.surveyking.server.domain.model.UserPosition;import cn.surveyking.server.mapper.DeptMapper;import cn.surveyking.server.mapper.UserPositionMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.DeptService;import cn.surveyking.server.service.UserService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import lombok.RequiredArgsConstructor;import org.apache.commons.lang3.StringUtils;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import java.util.List;import static org.apache.commons.lang3.StringUtils.isNotBlank;/** * @author javahuang * @date 2021/11/2 */@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class DeptServiceImpl extends BaseService<DeptMapper, Dept> implements DeptService { private final DeptDtoMapper deptDtoMapper; private final UserService userService; private final UserPositionMapper userPositionMapper; @Override public List<DeptView> listDept(SelectDeptRequest request) { if (request == null) { request = new SelectDeptRequest(); } List<DeptView> result = deptDtoMapper.toView(list(Wrappers.<Dept>lambdaQuery() .in(!CollectionUtils.isEmpty(request.getSelected()), Dept::getId, request.getSelected()) .orderByAsc(Dept::getSortCode))); result.forEach(orgView -> { String managerId = orgView.getManagerId(); if (isNotBlank(managerId)) { orgView.setManagerName(userService.loadUserById(managerId).getName()); } }); return result; } @Override public DeptView getDept(String id) { return deptDtoMapper.toView(getById(id)); } @Override public void addDept(DeptRequest request) { Dept dept = deptDtoMapper.fromRequest(request); if (StringUtils.isEmpty(request.getParentId())) { dept.setParentId("0"); } dept.setSortCode((int) count(Wrappers.<Dept>lambdaQuery().eq(Dept::getParentId, request.getParentId()))); save(dept); } @Override public void updateDept(DeptRequest request) { updateById(deptDtoMapper.fromRequest(request)); } @Override public void deleteDept(String id) { removeById(id); userPositionMapper.delete(Wrappers.<UserPosition>lambdaQuery().eq(UserPosition::getDeptId, id)); } @Override public void sortDept(DeptSortRequest request) { for (int i = 0; i < request.getNodes().size(); i++) { Dept dept = getById(request.getNodes().get(i)); dept.setSortCode(i); updateById(dept); } }}
package cn.surveyking.server.impl;import cn.surveyking.server.domain.model.CommDictItem;import cn.surveyking.server.mapper.CommDictItemMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.DictItemService;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;/** * @author javahuang * @date 2022/7/20 */@Service@Transactional(rollbackFor = Exception.class)public class DictItemServiceImpl extends BaseService<CommDictItemMapper, CommDictItem> implements DictItemService {}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.exception.InternalServerError;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.CommDictItemViewMapper;import cn.surveyking.server.domain.mapper.CommDictViewMapper;import cn.surveyking.server.domain.model.CommDict;import cn.surveyking.server.domain.model.CommDictItem;import cn.surveyking.server.mapper.CommDictMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.DictService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import org.dhatim.fastexcel.reader.ReadableWorkbook;import org.dhatim.fastexcel.reader.Row;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.io.IOException;import java.io.InputStream;import java.math.BigDecimal;import java.util.ArrayList;import java.util.Date;import java.util.List;import java.util.stream.Stream;import static com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank;/* * @author javahuang * @date 2022/7/19 */@Transactional(rollbackFor = Exception.class)@Service@RequiredArgsConstructorpublic class DictServiceImpl extends BaseService<CommDictMapper, CommDict> implements DictService { private final CommDictViewMapper dictViewMapper; private final CommDictItemViewMapper dictItemViewMapper; private final DictItemServiceImpl dictItemService; @Override public PaginationResponse<CommDictView> listDict(CommDictQuery query) { Page<CommDict> page = pageByQuery(query, Wrappers.<CommDict>lambdaQuery().like(isNotBlank(query.getName()), CommDict::getName, query.getName())); PaginationResponse<CommDictView> result = new PaginationResponse<>(page.getTotal(), dictViewMapper.toView(page.getRecords())); return result; } @Override public void addDict(CommDictRequest request) { save(dictViewMapper.fromRequest(request)); } @Override public void updateDict(CommDictRequest request) { updateById(dictViewMapper.fromRequest(request)); } @Override public void deleteDict(String id) { CommDict commDict = getById(id); removeById(id); dictItemService.remove(Wrappers.<CommDictItem>lambdaUpdate().eq(CommDictItem::getDictCode, commDict.getCode())); } @Override public PaginationResponse<CommDictItemView> listDictItem(CommDictItemQuery query) { Page<CommDictItem> page = dictItemService.pageByQuery(query, Wrappers.<CommDictItem>lambdaQuery() .like(isNotBlank(query.getDictCode()), CommDictItem::getDictCode, query.getDictCode())); PaginationResponse<CommDictItemView> result = new PaginationResponse<>(page.getTotal(), dictItemViewMapper.toView(page.getRecords())); return result; } @Override public void saveOrUpdateDictItem(CommDictItemRequest request) { dictItemService.saveOrUpdate(dictItemViewMapper.fromRequest(request)); } @Override public void deleteDictItem(String id) { dictItemService.removeById(id); } @Override @SneakyThrows public void importDictItem(CommDictItemRequest request) { try (InputStream is = request.getFile().getInputStream(); ReadableWorkbook wb = new ReadableWorkbook(is)) { wb.getSheets().forEach(sheet -> { try (Stream<Row> rows = sheet.openStream()) { List<CommDictItem> itemList = new ArrayList<>(); rows.forEach(r -> { if (r.getRowNum() == 1) { return; } CommDictItem item = new CommDictItem(); item.setDictCode(request.getDictCode()); item.setItemName(r.getCellText(0)); item.setItemValue(r.getCellText(1)); item.setParentItemValue(r.getCellText(2)); item.setItemLevel(r.getCellAsNumber(3).orElse(new BigDecimal(1)).intValue()); item.setItemOrder(r.getCellAsNumber(4).orElse(new BigDecimal(1)).intValue()); item.setCreateAt(new Date()); item.setCreateBy(SecurityContextUtils.getUserId()); itemList.add(item); if (itemList.size() == 10000) { dictItemService.saveBatch(itemList); itemList.clear(); } }); if (itemList.size() > 0) { dictItemService.saveBatch(itemList); } } catch (IOException e) { throw new InternalServerError("模板解析失败"); } }); } } @Override public List<CommDictView> selectDict() { return dictViewMapper.toView(list()); }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.constant.AppConsts;import cn.surveyking.server.core.constant.ErrorCode;import cn.surveyking.server.core.constant.LocalStorageNameStrategyEnum;import cn.surveyking.server.core.constant.LocalStoragePathStrategyEnum;import cn.surveyking.server.core.exception.ErrorCodeException;import cn.surveyking.server.core.uitls.BarcodeReader;import cn.surveyking.server.core.uitls.HTTPUtils;import cn.surveyking.server.core.uitls.NanoIdUtils;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.FileQuery;import cn.surveyking.server.domain.dto.FileView;import cn.surveyking.server.domain.dto.UploadFileRequest;import cn.surveyking.server.domain.mapper.FileViewMapper;import cn.surveyking.server.domain.model.File;import cn.surveyking.server.mapper.FileMapper;import cn.surveyking.server.service.FileService;import cn.surveyking.server.storage.StorageProperties;import cn.surveyking.server.storage.StorageService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.StringUtils;import org.springframework.core.io.ByteArrayResource;import org.springframework.core.io.ClassPathResource;import org.springframework.core.io.Resource;import org.springframework.http.HttpHeaders;import org.springframework.http.MediaType;import org.springframework.http.MediaTypeFactory;import org.springframework.http.ResponseEntity;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import org.springframework.web.multipart.MultipartFile;import java.io.IOException;import java.io.InputStream;import java.time.LocalDate;import java.time.format.DateTimeFormatter;import java.util.List;import java.util.Objects;import java.util.Optional;import java.util.UUID;import java.util.concurrent.atomic.AtomicLong;import static org.apache.commons.lang3.StringUtils.isEmpty;/** * @author javahuang * @date 2021/9/10 /@Service@Transactional@RequiredArgsConstructor@Slf4jpublic class FileServiceImpl extends ServiceImpl<FileMapper, File> implements FileService { private final StorageService storageService; private final FileViewMapper fileViewMapper; private final StorageProperties storageProperties; private final AtomicLong seq = new AtomicLong(System.currentTimeMillis()); @Override public void deleteFile(String id) { removeById(id); } @Override @SneakyThrows(IOException.class) public FileView upload(UploadFileRequest request) { MultipartFile uploadFile = request.getFile(); String filePath = getFileNameByStrategy(Objects.requireNonNull(uploadFile.getOriginalFilename())); File file = new File(); file.setId(NanoIdUtils.randomNanoId()); file.setStorageType(request.getFileType()); file.setOriginalName(uploadFile.getOriginalFilename()); file.setFileName(filePath); filePath = getFilePathByStrategy(request, filePath); file.setFilePath(filePath); if (isSupportImage(uploadFile.getOriginalFilename())) { String thumbImagePath = storageService.getThumbImageFilePath(filePath); try (InputStream inputStream = uploadFile.getInputStream()) { storageService.uploadFile(storageService.generateThumbImage(inputStream), thumbImagePath); file.setThumbFilePath(thumbImagePath); } } storageService.uploadFile(uploadFile.getInputStream(), filePath); save(file); FileView fileView = fileViewMapper.toView(file); if (AppConsts.FileType.BARCODE == request.getFileType()) { fileView.setContent(BarcodeReader.readBarcode(uploadFile.getInputStream())); } return fileView; } /* * 根据存储配置，按照指定规则生成相应的文件名 * @param originalName 原文件名 * @return 文件名 / private String getFileNameByStrategy(String originalName) { String strategy = storageProperties.getLocal().getNameStrategy(); int idx = originalName.lastIndexOf('.'); String fileType = originalName.substring(idx); if (LocalStorageNameStrategyEnum.SEQ_ADN_ORIGINAL_NAME.getStrategy().equals(strategy)) { return seq.incrementAndGet() + "_" + originalName; } else if (LocalStorageNameStrategyEnum.ORIGINAL_NAME_AND_SEQ.getStrategy().equals(strategy)) { return originalName.substring(0, idx) + "_" + seq.incrementAndGet() + fileType; } else if (LocalStorageNameStrategyEnum.SEQ.getStrategy().equals(strategy)) { return seq.incrementAndGet() + fileType; } else { return UUID.randomUUID().toString().replace("-", "") + fileType; } } /* * 根据本地存储配置，生成不同方式的文件保存路径 * @param request 文件上传请求 * @param fileName 文件名 * @return 文件保存路径 / private String getFilePathByStrategy(UploadFileRequest request, String fileName) { String strategy = storageProperties.getLocal().getPathStrategy(); if (LocalStoragePathStrategyEnum.BY_ID.getStrategy().equals(strategy) && request.getBasePath() != null) { return request.getBasePath() + java.io.File.separator + fileName; } else if (LocalStoragePathStrategyEnum.BY_DATE.getStrategy().equals(strategy)) { String dateFormat = storageProperties.getLocal().getDateFormat(); DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(dateFormat); LocalDate now = LocalDate.now(); dateFormat = now.format(dateTimeFormatter).replace("/", java.io.File.separator).replace("\\", java.io.File.separator); return dateFormat + java.io.File.separator + fileName; } else { return fileName; } } @Override public List<FileView> listFiles(FileQuery query) { return fileViewMapper.toView( list(Wrappers.<File>lambdaQuery().eq(query.getType() != null, File::getStorageType, query.getType()) // 默认只能查询自己的 .eq(CollectionUtils.isEmpty(query.getIds()), File::getCreateBy, SecurityContextUtils.getUserId()) // 可以根据 ids 查询已知文件 .in(!CollectionUtils.isEmpty(query.getIds()), File::getId, query.getIds()))); } @Override @SneakyThrows public ResponseEntity<Resource> loadFile(FileQuery query) { String fileId = query.getId(); if (fileId.contains("@")) { fileId = fileId.substring(0, fileId.lastIndexOf("@")); } File file = getById(fileId); if (file == null) { log.error("未找到对应的文件 {}", fileId); throw new ErrorCodeException(ErrorCode.FileNotExists); } Optional<MediaType> mediaType = MediaTypeFactory.getMediaType(file.getOriginalName()); // FIXME: 在线预览 mp4 文件会报错，但不影响使用 return ResponseEntity.ok().contentType(mediaType.orElse(MediaType.APPLICATION_OCTET_STREAM)) .headers(query.getHeaders()) .header(HttpHeaders.CONTENT_DISPOSITION, query.getDispositionType() == AppConsts.DispositionTypeEnum.inline ? AppConsts.DispositionTypeEnum.inline.name() : HTTPUtils.getContentDispositionValue(file.getOriginalName())) .body(new ByteArrayResource(storageService .download(query.getId().contains("@") ? file.getThumbFilePath() : file.getFilePath()))); } @Override public ResponseEntity<Resource> downloadTemplate(String name) { String templateName = name + ".xlsx"; return ResponseEntity.ok() .header(HttpHeaders.CONTENT_DISPOSITION, HTTPUtils.getContentDispositionValue(templateName)) .contentType(MediaType.parseMediaType("application/vnd.ms-excel")) .body(new ClassPathResource("template/" + templateName)); } /* * 生成带文件后缀的id，由于配置了 STATIC_RESOURCES ，会导致单jar部署请求 /preview/xxx.xlsx 的时候报 404 * @param originalName * @return */ private String getFileId(String originalName) { String suffix = StringUtils.substringAfterLast(originalName, "."); if (isEmpty(suffix)) { return NanoIdUtils.randomNanoId(); } return NanoIdUtils.randomNanoId() + "." + suffix; }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.domain.dto.PositionQuery;import cn.surveyking.server.domain.dto.PositionRequest;import cn.surveyking.server.domain.dto.PositionView;import cn.surveyking.server.domain.dto.SelectPositionRequest;import cn.surveyking.server.domain.mapper.PositionDtoMapper;import cn.surveyking.server.domain.model.Position;import cn.surveyking.server.mapper.PositionMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.PositionService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.List;import static com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank;/** * @author javahuang * @date 2021/11/2 */@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class PositionServiceImpl extends BaseService<PositionMapper, Position> implements PositionService { private final PositionDtoMapper positionDtoMapper; @Override public PaginationResponse<PositionView> listPosition(PositionQuery query) { Page<Position> page = pageByQuery(query, Wrappers.<Position>lambdaQuery().like(isNotBlank(query.getName()), Position::getName, query.getName())); PaginationResponse<PositionView> result = new PaginationResponse<>(page.getTotal(), positionDtoMapper.toView(page.getRecords())); return result; } @Override public void addPosition(PositionRequest request) { save(positionDtoMapper.fromRequest(request)); } @Override public void updatePosition(PositionRequest request) { updateById(positionDtoMapper.fromRequest(request)); } @Override public void deletePosition(String id) { removeById(id); } @Override public List<PositionView> selectPositions(SelectPositionRequest request) { return positionDtoMapper.toView(list()); }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.constant.AppConsts;import cn.surveyking.server.core.constant.CacheConsts;import cn.surveyking.server.core.constant.ProjectPartnerTypeEnum;import cn.surveyking.server.core.exception.InternalServerError;import cn.surveyking.server.core.uitls.ContextHelper;import cn.surveyking.server.core.uitls.ExcelExporter;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.ProjectPartnerQuery;import cn.surveyking.server.domain.dto.ProjectPartnerRequest;import cn.surveyking.server.domain.dto.ProjectPartnerView;import cn.surveyking.server.domain.dto.WhiteListRequest;import cn.surveyking.server.domain.mapper.ProjectPartnerViewMapper;import cn.surveyking.server.domain.model.ProjectPartner;import cn.surveyking.server.domain.model.User;import cn.surveyking.server.mapper.ProjectPartnerMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.ProjectPartnerService;import cn.surveyking.server.service.UserService;import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import org.dhatim.fastexcel.reader.ReadableWorkbook;import org.dhatim.fastexcel.reader.Row;import org.springframework.cache.CacheManager;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.io.InputStream;import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Optional;import java.util.stream.Collectors;import java.util.stream.Stream;import static org.apache.commons.lang3.StringUtils.isBlank;/** * @author javahuang * @date 2022/1/28 */@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class ProjectPartnerServiceImpl extends BaseService<ProjectPartnerMapper, ProjectPartner> implements ProjectPartnerService { private final UserServiceImpl userService; private final CacheManager cacheManager; private final ProjectPartnerViewMapper projectPartnerViewMapper; @Override public PaginationResponse<ProjectPartnerView> listProjectPartner(ProjectPartnerQuery query) { Page<ProjectPartner> page = pageByQuery(query, Wrappers.<ProjectPartner>lambdaQuery().eq(ProjectPartner::getProjectId, query.getProjectId()) .in(query.getTypes() != null, ProjectPartner::getType, query.getTypes()) .eq(query.getStatus() != null, ProjectPartner::getStatus, query.getStatus()).like( query.getUserName() != null && query.getTypes() != null && query.getTypes() .contains(ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType()), ProjectPartner::getUserName, query.getUserName()) .exists(query.getUserName() != null && query.getTypes() != null && query.getTypes().contains(ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()), String.format( "select 1 from t_user where t_user.name='%s' and t_user.id = t_project_partner.user_id", query.getUserName())) .orderByAsc(ProjectPartner::getCreateAt)); PaginationResponse<ProjectPartnerView> result = new PaginationResponse<>(page.getTotal(), projectPartnerViewMapper.toView(page.getRecords())); for (ProjectPartnerView view : result.getList()) { if (view.getUserId() != null) { view.setUser(userService.loadUserById(view.getUserId())); } } return result; } @Override public void addProjectPartner(ProjectPartnerRequest request) { // 添加答题人 List<ProjectPartner> existUserIds = list(Wrappers.<ProjectPartner>lambdaQuery() .in(request.getUserIds() != null, ProjectPartner::getUserId, request.getUserIds()) .in(request.getUserNames() != null && ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType() == request.getType(), ProjectPartner::getUserName, request.getUserNames()) .eq(ProjectPartner::getType, request.getType()) .eq(ProjectPartner::getProjectId, request.getProjectId())); if (ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType() == request.getType()) { saveBatch(request.getUserNames().stream().filter(username -> { if (existUserIds.stream().anyMatch(partner -> partner.getUserName().equals(username))) { return false; } return true; }).map(userName -> { ProjectPartner partner = new ProjectPartner(); partner.setProjectId(request.getProjectId()); partner.setUserName(userName); partner.setType(request.getType()); return partner; }).collect(Collectors.toList())); } else { saveBatch(request.getUserIds().stream().filter(userId -> { if (existUserIds.stream().anyMatch(partner -> partner.getUserId().equals(userId))) { return false; } if (ProjectPartnerTypeEnum.OWNER.getType() == request.getType() \|\| ProjectPartnerTypeEnum.COLLABORATOR.getType() == request.getType()) { cacheManager.getCache(CacheConsts.projectPermissionCacheName).evict(userId); } return true; }).map(userId -> { ProjectPartner partner = new ProjectPartner(); partner.setProjectId(request.getProjectId()); partner.setUserId(userId); partner.setType(request.getType()); return partner; }).collect(Collectors.toList())); } } @Override public void deleteProjectPartner(ProjectPartnerRequest request) { remove(Wrappers.<ProjectPartner>lambdaUpdate() .in(CollectionUtils.isNotEmpty(request.getIds()), ProjectPartner::getId, request.getIds()) .in(CollectionUtils.isNotEmpty(request.getProjectIds()), ProjectPartner::getProjectId, request.getProjectIds()) .eq(request.getProjectId() != null, ProjectPartner::getProjectId, request.getProjectId())); } @Override public List<String> getProjectPerms() { return getBaseMapper().getProjectPerms(SecurityContextUtils.getUserId()); } @Override @SneakyThrows public void downloadPartner(ProjectPartnerQuery query) { query.setPageSize(-1); List<ProjectPartnerView> result = listProjectPartner(query).getList(); List<List<Object>> rows = result.stream().map(r -> { List<Object> row = new ArrayList<>(); if (r.getType() == ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()) { row.add(r.getUser().getName()); } else { row.add(r.getUserName()); } row.add(AppConsts.ProjectPartnerStatus.getStatusStr(r.getStatus())); return row; }).collect(Collectors.toList()); new ExcelExporter.Builder().setOutputStream(ContextHelper.getCurrentHttpResponse().getOutputStream()) .setRows(rows).setColumns(Arrays.asList("名单", "状态")).build().exportToStream(); } @Override @SneakyThrows public void importPartner(WhiteListRequest request) { List<String> userIds = new ArrayList<>(); try (InputStream is = request.getFile().getInputStream(); ReadableWorkbook wb = new ReadableWorkbook(is)) { wb.getSheets().forEach(sheet -> { int[] rowNum = { 1 }; try (Stream<Row> rows = sheet.openStream()) { rows.forEach(r -> { if (r.getRowNum() == 1) { return; } rowNum[0] = r.getRowNum(); if (getCellValue(r, 0).isPresent() && getCellValue(r, 1).isPresent()) { User user = userService.getBaseMapper().getUser(getCellValue(r, 0).get(), getCellValue(r, 1).get()); if (user != null) { userIds.add(user.getId()); } } }); } catch (Exception e) { throw new InternalServerError(String.format("模板第%d行解析失败", rowNum[0]), e); } }); } ProjectPartnerRequest addRequest = new ProjectPartnerRequest(); addRequest.setProjectId(request.getProjectId()); addRequest.setUserIds(userIds); addRequest.setType(ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()); addProjectPartner(addRequest); } private Optional<String> getCellValue(Row row, int cellIndex) { String cellValue = row.getCellAsString(cellIndex).orElse(null); if (isBlank(cellValue)) { return Optional.empty(); } return Optional.of(cellValue); }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.constant.ProjectModeEnum;import cn.surveyking.server.core.constant.ProjectPartnerTypeEnum;import cn.surveyking.server.core.uitls.ClassUtils;import cn.surveyking.server.core.uitls.NanoIdUtils;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.ProjectViewMapper;import cn.surveyking.server.domain.model.Answer;import cn.surveyking.server.domain.model.Project;import cn.surveyking.server.mapper.AnswerMapper;import cn.surveyking.server.mapper.ProjectMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.ProjectPartnerService;import cn.surveyking.server.service.ProjectService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import org.springframework.expression.spel.standard.SpelExpressionParser;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import javax.validation.ValidationException;import java.lang.reflect.Field;import java.util.ArrayList;import java.util.Collections;import java.util.List;import static com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank;import static org.apache.commons.lang3.StringUtils.isBlank;/* * @author javahuang * @date 2021/8/3 /@Service@Transactional@RequiredArgsConstructorpublic class ProjectServiceImpl extends BaseService<ProjectMapper, Project> implements ProjectService { private final AnswerMapper answerMapper; private final ProjectViewMapper projectViewMapper; private final ProjectPartnerService projectPartnerService; private SpelExpressionParser spelParser = new SpelExpressionParser(); private List<String> projectSettingUpdateKeys; @Override public PaginationResponse<ProjectView> listProject(ProjectQuery query) { Page<Project> page = pageByQuery(query, Wrappers.<Project>lambdaQuery() .like(isNotBlank(query.getName()), Project::getName, query.getName()) .eq(isNotBlank(query.getParentId()), Project::getParentId, query.getParentId()) // 父id为空或者为 0 表示一级目录 .and(isBlank(query.getParentId()), c -> c.isNull(Project::getParentId).or().eq(Project::getParentId, "0")) .eq(query.getMode() != null, Project::getMode, query.getMode()) .exists(String.format( "SELECT 1 FROM t_project_partner t WHERE t.type in (1, 2) AND t.user_id = '%s' AND t.project_id = t_project.id", SecurityContextUtils.getUserId())) .orderByAsc(Project::getPriority, Project::getCreateAt)); PaginationResponse<ProjectView> result = new PaginationResponse<>(page.getTotal(), projectViewMapper.toView(page.getRecords())); result.getList().forEach(view -> { if (ProjectModeEnum.folder.equals(view.getMode())) { view.setTotal(count(Wrappers.<Project>lambdaQuery().eq(Project::getParentId, view.getId()))); } else { view.setTotal(answerMapper .selectCount(Wrappers.<Answer>lambdaQuery().eq(Answer::getProjectId, view.getId()))); } }); return result; } public ProjectView getProject(String id) { return projectViewMapper.toView(getById(id)); } @Override public ProjectView addProject(ProjectRequest request) { Project project = projectViewMapper.fromRequest(request); String projectId = generateProjectId(); project.setId(projectId); if (project.getSurvey() != null) { project.getSurvey().setId(projectId); } if (ProjectModeEnum.folder.equals(request.getMode())) { project.setPriority( count(Wrappers.<Project>lambdaQuery().eq(Project::getMode, ProjectModeEnum.folder)) + 1); } else { project.setPriority( count(Wrappers.<Project>lambdaQuery().ne(Project::getMode, ProjectModeEnum.folder)) + 1000); } save(project); ProjectPartnerRequest partnerRequest = new ProjectPartnerRequest(); partnerRequest.setType(ProjectPartnerTypeEnum.OWNER.getType()); partnerRequest.setProjectId(project.getId()); partnerRequest.setUserIds(Collections.singletonList(SecurityContextUtils.getUserId())); projectPartnerService.addProjectPartner(partnerRequest); return projectViewMapper.toView(project); } private String generateProjectId() { String projectId = NanoIdUtils.randomNanoId(6); // 不要以数字开头，否则工作流 xml 保存会报错 if (Character.isDigit(projectId.charAt(0))) { return generateProjectId(); } if (getById(projectId) != null) { return generateProjectId(); } return projectId; } @Override @SneakyThrows public void updateProject(ProjectRequest request) { synchronized (request.getId().intern()) { Project project = projectViewMapper.fromRequest(request); if (request.getSettingKey() != null) { validateSettingKey(request.getSettingKey()); // 实现单个设置的更新 ProjectSetting setting = getById(request.getId()).getSetting(); spelParser.parseExpression(request.getSettingKey()).setValue(setting, request.getSettingValue()); project.setSetting(setting); // 同步更新项目状态 if ("status".equals(request.getSettingKey())) { project.setStatus((Integer) request.getSettingValue()); } } updateById(project); } } /* * spel漏洞修复，只允许更新指定参数 * @param expressionString */ private void validateSettingKey(String expressionString) { if (projectSettingUpdateKeys == null) { projectSettingUpdateKeys = ClassUtils.flatClassFields(ProjectSetting.class, new ArrayList<>(), 2); } if (!projectSettingUpdateKeys.contains(expressionString)) { throw new ValidationException("非法的更新参数"); } } @Override public void deleteProject(ProjectRequest request) { removeById(request.getId()); } @Override public ProjectSetting getSetting(ProjectQuery query) { return null; } @Override public List<ProjectView> getDeleted(ProjectQuery query) { List<ProjectView> list = projectViewMapper .toView(getBaseMapper().selectLogicDeleted(SecurityContextUtils.getUserId())); list.forEach(view -> { if (!ProjectModeEnum.folder.equals(view.getMode())) { view.setTotal(answerMapper .selectCount(Wrappers.<Answer>lambdaQuery().eq(Answer::getProjectId, view.getId()))); } }); return list; } @Override public void batchDestroyProject(ProjectRequest request) { getBaseMapper().batchDestroy(request.getIds()); // 删除项目参与者 ProjectPartnerRequest deletePartnerRequest = new ProjectPartnerRequest(); deletePartnerRequest.setProjectIds(request.getIds()); projectPartnerService.deleteProjectPartner(deletePartnerRequest); } @Override public void restoreProject(ProjectRequest request) { getBaseMapper().restoreProject(request.getIds()); } private <T> T merge(T local, T remote) throws IllegalAccessException, InstantiationException { Class<?> clazz = local.getClass(); Object merged = clazz.newInstance(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object localValue = field.get(local); Object remoteValue = field.get(remote); switch (field.getType().getSimpleName()) { case "Integer": case "String": case "Boolean": case "Long": case "LinkedHashMap": field.set(merged, (remoteValue != null) ? remoteValue : localValue); break; default: field.set(merged, merge(localValue, remoteValue)); } } return (T) merged; }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.uitls.SchemaHelper;import cn.surveyking.server.domain.dto.ReportData;import cn.surveyking.server.domain.dto.SurveySchema;import cn.surveyking.server.domain.model.Answer;import cn.surveyking.server.domain.model.Project;import cn.surveyking.server.mapper.AnswerMapper;import cn.surveyking.server.mapper.ProjectMapper;import cn.surveyking.server.service.ReportService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import lombok.RequiredArgsConstructor;import org.springframework.stereotype.Service;import java.math.BigDecimal;import java.math.RoundingMode;import java.text.SimpleDateFormat;import java.util.;/* * @author javahuang * @date 2021/8/4 /@Service@RequiredArgsConstructorpublic class ReportServiceImpl implements ReportService { private final AnswerMapper answerMapper; private final ProjectMapper projectMapper; @Override public ReportData getData(String shortId) { List<Answer> answerList = answerMapper.selectList( Wrappers.<Answer>lambdaQuery().select(Answer::getAnswer, Answer::getCreateAt, Answer::getProjectId) .eq(Answer::getProjectId, shortId).orderByAsc(Answer::getCreateAt)); ReportData result = new ReportData(); result.setTotal(answerList.size()); Map<String, ReportData.Data> data = new HashMap<>(); result.setStatistics(data); Map<String, Integer> dailyCountStat = new LinkedHashMap<>(); result.setDailyCountStat(dailyCountStat); if (answerList.size() == 0) { return result; } Project project = projectMapper.selectById(answerList.get(0).getProjectId()); List<SurveySchema> questionSchemaList = SchemaHelper.flatSurveySchema(project.getSurvey()); for (Answer answer : answerList) { parseAnswer(data, answer.getAnswer()); computeDailyAnswer(dailyCountStat, answer); } return result; } /* * 选项报表统计 * @param data * @param answer */ private void parseAnswer(Map<String, ReportData.Data> data, LinkedHashMap answer) { Iterator it = answer.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = (Map.Entry) it.next(); String id = (String) pair.getKey(); Object value = pair.getValue(); ReportData.Data optionData = data.computeIfAbsent(id, s -> new ReportData.Data()); optionData.setTotal(optionData.getTotal() + 1); if (value instanceof Map) { parseAnswer(data, (LinkedHashMap) value); } else if (value instanceof Number) { Number numberValue = (Number) value; if (optionData.getMin() == null \|\| optionData.getMax() == null \|\| optionData.getAverage() == null) { optionData.setMin(numberValue); optionData.setMax(numberValue); optionData.setAverage(numberValue); } if (compareTo(optionData.getMin(), numberValue) > 0) { optionData.setMin(numberValue); } if (compareTo(numberValue, optionData.getMax()) > 0) { optionData.setMax(numberValue); } optionData.setSum(new BigDecimal(optionData.getSum().doubleValue()) .add(new BigDecimal(numberValue.doubleValue()))); optionData.setAverage(new BigDecimal(optionData.getSum().doubleValue()) .divide(new BigDecimal(optionData.getTotal()), 2, RoundingMode.HALF_UP) .setScale(2, BigDecimal.ROUND_HALF_UP)); } } } private void computeDailyAnswer(Map<String, Integer> dailyCountStat, Answer answer) { String day = new SimpleDateFormat("yyyy-MM-dd").format(answer.getCreateAt()); dailyCountStat.merge(day, 1, Integer::sum); } public int compareTo(Number n1, Number n2) { BigDecimal b1 = new BigDecimal(n1.doubleValue()); BigDecimal b2 = new BigDecimal(n2.doubleValue()); return b1.compareTo(b2); }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.constant.TagCategoryEnum;import cn.surveyking.server.core.uitls.RepoTemplateExcelParseHelper;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.RepoViewMapper;import cn.surveyking.server.domain.mapper.UserBookViewMapper;import cn.surveyking.server.domain.model.Repo;import cn.surveyking.server.domain.model.Tag;import cn.surveyking.server.domain.model.Template;import cn.surveyking.server.domain.model.UserBook;import cn.surveyking.server.mapper.RepoMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.RepoService;import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;import com.baomidou.mybatisplus.core.toolkit.IdWorker;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.multipart.MultipartFile;import java.util.;import java.util.stream.Collectors;import static com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank;/** * @author javahuang * @date 2022/4/27 /@Transactional(rollbackFor = Exception.class)@Service@RequiredArgsConstructorpublic class RepoServiceImpl extends BaseService<RepoMapper, Repo> implements RepoService { private final TemplateServiceImpl templateService; private final RepoViewMapper repoViewMapper; private final TagServiceImpl tagService; private final UserBookServiceImpl userBookService; private final UserBookViewMapper userBookViewMapper; @Override public PaginationResponse<RepoView> listRepo(RepoQuery query) { Page<Repo> page = pageByQuery(query, Wrappers.<Repo>lambdaQuery().like(isNotBlank(query.getName()), Repo::getName, query.getName()) .and(x -> x.eq(Repo::getCreateBy, SecurityContextUtils.getUserId()) .or(y -> y.eq(Repo::getShared, true))) .eq(query.getMode() != null, Repo::getMode, query.getMode()).orderByAsc(Repo::getCreateAt)); PaginationResponse<RepoView> result = new PaginationResponse<>(page.getTotal(), repoViewMapper.toView(page.getRecords())); result.getList().forEach(repoView -> { repoView.setTotal( templateService.count(Wrappers.<Template>lambdaQuery().eq(Template::getRepoId, repoView.getId()))); // 获取每个标签对应的题的数量 repoView.setTemplateTags(this.getBaseMapper().selectRepoTemplateTags(repoView.getId())); // 获取每个问题类型对应的题的数量 repoView.setRepoQuestionTypes(this.getBaseMapper().selectRepoQuestionTypes(repoView.getId())); }); return result; } @Override public RepoView getRpo(String id) { return repoViewMapper.toView(getById(id)); } @Override public void addRepo(RepoRequest request) { request.setId(IdWorker.getIdStr()); save(repoViewMapper.fromRequest(request)); tagService.batchAddTag(request.getId(), TagCategoryEnum.repo, request.getTag()); } @Override public void updateRepo(RepoRequest request) { updateById(repoViewMapper.fromRequest(request)); tagService.batchAddTag(request.getId(), TagCategoryEnum.repo, request.getTag()); } @Override public void deleteRepo(RepoRequest request) { String id = request.getId(); removeById(id); // 删除题库下面的所有题 templateService.remove(Wrappers.<Template>lambdaUpdate().eq(Template::getRepoId, id)); // 取消题库标签 tagService.remove(Wrappers.<Tag>lambdaUpdate().eq(Tag::getEntityId, id)); } @Override public void batchAddRepoTemplate(RepoTemplateRequest request) { List<Tag> tagList = new ArrayList<>(); List<TemplateRequest> templatesAdd = new ArrayList<>(); List<TemplateRequest> templatesUpdate = new ArrayList<>(); request.getTemplates().forEach(template -> { if (template.getId() == null) { template.setId(IdWorker.getIdStr()); templatesAdd.add(template); } else { templatesUpdate.add(template); } // template 里面的 tags 冗余了 if (template.getTemplate().getTags() != null) { template.setTag(template.getTemplate().getTags().toArray(new String[0])); } List<String> tags = template.getTemplate().getTags(); if (tags != null && tags.size() > 0) { tags.forEach(tagStr -> { Tag tag = new Tag(); tag.setName(tagStr); tag.setEntityId(template.getId()); tag.setCategory(TagCategoryEnum.template.name()); tagList.add(tag); }); } template.setQuestionType(template.getTemplate().getType()); }); if (templatesAdd.size() > 0) { // 添加模板的时候，需要添加题库与模板的关联关系 templatesAdd.forEach(x -> x.setRepoId(request.getRepoId())); templateService.batchAddTemplate(templatesAdd); } if (templatesUpdate.size() > 0) { templatesUpdate.forEach(x -> x.setRepoId(request.getRepoId())); templateService.batchUpdateTemplate(templatesUpdate); // 更新模板时需要删除之前的标签 tagService.remove(Wrappers.<Tag>lambdaUpdate().in(Tag::getEntityId, templatesUpdate.stream().map(x -> x.getId()).collect(Collectors.toList()))); } // 添加模板问题标签 if (tagList.size() > 0) { tagService.saveBatch(tagList); } } @Override public void batchUnBindTemplate(RepoTemplateRequest request) { if (request.getIds() != null) { templateService.removeBatchByIds(request.getIds()); } } /* * 从题库里面挑选题目 * @param repos * @return */ @Override public List<SurveySchema> pickQuestionFromRepo(List<ProjectSetting.RandomSurveyCondition> repos) { List<Template> templates = new ArrayList<>(); repos.forEach(repo -> { List<Template> repoTemplates = templateService.list(Wrappers.<Template>lambdaQuery() .eq(Template::getRepoId, repo.getRepoId()) .in(!CollectionUtils.isEmpty(repo.getTypes()), Template::getQuestionType, repo.getTypes()) .exists(!CollectionUtils.isEmpty(repo.getTags()), String.format("select 1 from t_tag t where t.entity_id = t_template.id and t.name in (%s)", Optional.ofNullable(repo.getTags()).orElse(new ArrayList<>()).stream() .map(x -> "'" + x + "'").collect(Collectors.joining(","))))); if (repo.getQuestionsNum() != null) { // 随机从问题里面挑选指定数量的题 Collections.shuffle(repoTemplates); if (repoTemplates.size() > repo.getQuestionsNum()) { repoTemplates = repoTemplates.subList(0, repo.getQuestionsNum()); } } // 给问题添加分值 repoTemplates.forEach(template -> { if (templates.stream().filter(x -> x.getId().equals(template.getId())).findFirst().isPresent()) { return; } if (repo.getExamScore() != null) { if (template.getTemplate().getAttribute() == null) { template.getTemplate().setAttribute(new SurveySchema.Attribute()); } template.getTemplate().getAttribute().setExamScore(repo.getExamScore()); } templates.add(template); }); }); // 相同类型的问题排放在一起 return templates.stream().map(x -> { SurveySchema schema = x.getTemplate(); schema.setId(x.getId()); return schema; }).sorted(Comparator.comparing(SurveySchema::getType)).collect(Collectors.toList()); } @Override @SneakyThrows public void importFromTemplate(RepoTemplateRequest request) { request.setTemplates(parseExcelToTemplate(request.getFile())); batchAddRepoTemplate(request); } @SneakyThrows private List<TemplateRequest> parseExcelToTemplate(MultipartFile file) { return new RepoTemplateExcelParseHelper(file).parse(); } @Override public PaginationResponse<UserBookView> listUserBook(UserBookQuery query) { Page<UserBook> page = userBookService.pageByQuery(query, Wrappers.<UserBook>lambdaQuery().like(query.getName() != null, UserBook::getName, query.getName()) .eq(query.getType() != null, UserBook::getType, query.getType()) .ge(query.getStartDate() != null, UserBook::getCreateAt, query.getStartDate()) .le(query.getEndDate() != null, UserBook::getCreateAt, query.getEndDate()) .eq(UserBook::getCreateBy, SecurityContextUtils.getUserId())); PaginationResponse<UserBookView> result = new PaginationResponse<>(page.getTotal(), userBookViewMapper.toView(page.getRecords())); return result; } @Override public void createUserBook(UserBookRequest request) { UserBook userBook = userBookViewMapper.fromRequest(request); userBookService.save(userBook); } @Override public void updateUserBook(UserBookRequest request) { UserBook userBook = userBookViewMapper.fromRequest(request); userBookService.updateById(userBook); } @Override public void deleteUserBook(UserBookRequest request) { if (request.getId() != null) { userBookService.removeById(request.getId()); } if (CollectionUtils.isNotEmpty(request.getIds())) { userBookService.removeByIds(request.getIds()); } if (request.getTemplateId() != null) { userBookService .remove(Wrappers.<UserBook>lambdaUpdate().eq(UserBook::getTemplateId, request.getTemplateId()) .eq(UserBook::getCreateBy, SecurityContextUtils.getUserId())); } } @Override public List<RepoView> selectRepo(SelectRepoRequest request) { List<RepoView> result = repoViewMapper .toView(list(Wrappers.<Repo>lambdaQuery().eq(Repo::getMode, request.getMode()).and(x -> x .eq(Repo::getCreateBy, SecurityContextUtils.getUserId()).or(y -> y.eq(Repo::getShared, 1))))); result.forEach(repoView -> { repoView.setTotal( templateService.count(Wrappers.<Template>lambdaQuery().eq(Template::getRepoId, repoView.getId()))); // 获取每个标签对应的题的数量 repoView.setTemplateTags(this.getBaseMapper().selectRepoTemplateTags(repoView.getId())); // 获取每个问题类型对应的题的数量 repoView.setRepoQuestionTypes(this.getBaseMapper().selectRepoQuestionTypes(repoView.getId())); }); return result; }}
package cn.surveyking.server.impl;import cn.surveyking.server.domain.model.RepoTemplate;import cn.surveyking.server.mapper.RepoTemplateMapper;import cn.surveyking.server.service.BaseService;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;/** * @author javahuang * @date 2022/4/29 */@Service@Transactional(rollbackFor = Exception.class)public class RepoTemplateServiceImpl extends BaseService<RepoTemplateMapper, RepoTemplate> {}
package cn.surveyking.server.impl;import cn.surveyking.server.domain.dto.RoleView;import cn.surveyking.server.domain.dto.SelectRoleRequest;import cn.surveyking.server.domain.mapper.RoleViewMapper;import cn.surveyking.server.domain.model.Role;import cn.surveyking.server.mapper.RoleMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.RoleService;import lombok.RequiredArgsConstructor;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.List;import java.util.stream.Collectors;/** * @author javahuang * @date 2021/10/12 */@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class RoleServiceImpl extends BaseService<RoleMapper, Role> implements RoleService { private final RoleViewMapper roleViewMapper; @Override public List<RoleView> selectRoles(SelectRoleRequest request) { return list().stream().map(role -> roleViewMapper.toView(role)).collect(Collectors.toList()); }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.Tuple2;import cn.surveyking.server.core.constant.;import cn.surveyking.server.core.exception.ErrorCodeException;import cn.surveyking.server.core.security.JwtTokenUtil;import cn.surveyking.server.core.uitls.;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.ProjectViewMapper;import cn.surveyking.server.domain.model.Answer;import cn.surveyking.server.domain.model.CommDictItem;import cn.surveyking.server.domain.model.ProjectPartner;import cn.surveyking.server.domain.model.UserBook;import cn.surveyking.server.mapper.ProjectPartnerMapper;import cn.surveyking.server.service.ProjectService;import cn.surveyking.server.service.SurveyService;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.fasterxml.jackson.databind.ObjectMapper;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.StringUtils;import org.springframework.http.HttpCookie;import org.springframework.http.HttpHeaders;import org.springframework.http.ResponseCookie;import org.springframework.security.authentication.AuthenticationManager;import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;import org.springframework.security.core.Authentication;import org.springframework.security.core.context.SecurityContextHolder;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import org.springframework.web.util.WebUtils;import javax.servlet.http.Cookie;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.validation.ValidationException;import java.text.SimpleDateFormat;import java.time.LocalDateTime;import java.time.ZoneId;import java.util.;import java.util.regex.Matcher;import java.util.regex.Pattern;import java.util.stream.Collectors;import java.util.stream.Stream;import static org.apache.commons.lang3.StringUtils.isBlank;import static org.apache.commons.lang3.StringUtils.isNotBlank;/** * @author javahuang * @date 2021/8/22 /@Service@Transactional@RequiredArgsConstructor@Slf4jpublic class SurveyServiceImpl implements SurveyService { private final ProjectService projectService; private final ProjectViewMapper projectViewMapper; private final AnswerServiceImpl answerService; private final ProjectPartnerMapper projectPartnerMapper; private final AuthenticationManager authenticationManager; private final JwtTokenUtil jwtTokenUtil; private final DictItemServiceImpl dictItemService; private final RepoServiceImpl repoService; private final UserBookServiceImpl userBookService; private final TemplateServiceImpl templateService; private final ObjectMapper objectMapper; /* * answerService 如果需要验证密码，则只有密码输入正确之后才开始加载 schema * @param query * @return / @Override public PublicProjectView loadProject(ProjectQuery query) { ProjectView project = projectService.getProject(query.getId()); PublicProjectView projectView = projectViewMapper.toPublicProjectView(project); if (project == null) { throw new ErrorCodeException(ErrorCode.ProjectNotFound); } SurveySchema loginFormSchema = null; if (query.getAnswerId() == null) { // 表单需要验证 loginFormSchema = convertAndValidateLoginFormIfNeeded(project, null); // 校验问卷 validateProject(project); } else { // 直接根据答案加载出 schema AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setId(query.getAnswerId()); AnswerView answerView = answerService.getAnswer(answerQuery); if (answerView != null) { projectView.setAnswer(answerView.getAnswer()); if (answerView.getSurvey() != null) { // 随机问题 projectView.setSurvey(answerView.getSurvey()); } } return projectView; } // 如果需要登录，将问卷 schema 替换成登录表单的 schema if (loginFormSchema != null) { projectView.setSurvey(loginFormSchema); projectView.setLoginRequired(true); } else { // 随机问题 replaceSchemaIfRandomSchema(project, projectView); // 允许修改答案 projectView.setAnswer(getLatestAnswer(projectView, null)); } projectView.setIsAuthenticated(SecurityContextUtils.isAuthenticated()); return projectView; } /* * 验证问卷 * @param query * @return / @Override public PublicProjectView validateProject(ProjectQuery query) { String projectId = query.getId(); ProjectView project = projectService.getProject(projectId); // 登录验证 convertAndValidateLoginFormIfNeeded(project, query.getAnswer()); PublicProjectView projectView = projectViewMapper.toPublicProjectView(project); // 随机问题 replaceSchemaIfRandomSchema(project, projectView); // 校验问卷 validateProject(project); projectView.setAnswer(getLatestAnswer(projectView, (String) SchemaHelper.getLoginFormAnswer(query.getAnswer(), SchemaHelper.LoginFormFieldEnum.whitelistName))); return projectView; } @Override public PublicStatisticsView statProject(ProjectQuery query) { AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setProjectId(query.getId()); answerQuery.setPageSize(-1); List<AnswerView> answers = answerService.listAnswer(answerQuery).getList(); ProjectView project = projectService.getProject(query.getId()); return new ProjectStatHelper(project.getSurvey(), answers).stat(); } @Override @Transactional(rollbackFor = Exception.class) public PublicAnswerView saveAnswer(AnswerRequest request) { String projectId = request.getProjectId(); PublicAnswerView result = new PublicAnswerView(); ProjectView project = projectService.getProject(projectId); String answerId = request.getId(); // 随机问卷更新答案 String randomSurveyCookieName = AppConsts.COOKIE_RANDOM_PROJECT_PREFIX + project.getId(); String answerIdFromCookie = ContextHelper.getCookie(randomSurveyCookieName); if (isNotBlank(answerIdFromCookie)) { answerId = answerIdFromCookie; } else if (isNotBlank(request.getQueryId())) { // 公开查询修改答案 validateAndMergeAnswer(project, request); } else if (isNotBlank(request.getId())) { // 传入答案ID 并且设置了允许修改答案，则可以修改问卷答案 boolean enableUpdate = Boolean.TRUE.equals(project.getSetting().getSubmittedSetting().getEnableUpdate()); if (!enableUpdate) { throw new ErrorCodeException(ErrorCode.AnswerChangeDisabled); } } else { // 问卷允许修改答案开关修改答案 AnswerView latestAnswer = validateAndGetLatestAnswer(project, request); if (latestAnswer != null) { answerId = latestAnswer.getId(); } } // 保存答案 request.setId(answerId); AnswerView answerView = answerService.saveAnswer(request); result.setAnswerId(answerView.getId()); // 考试模式，计算分值传给前端 if (ProjectModeEnum.exam.equals(project.getMode())) { result.setExamScore(answerView.getExamScore()); result.setQuestionScore(answerView.getExamInfo().getQuestionScore()); // 计算错题 AnswerExamInfo answerExamInfo = answerView.getExamInfo(); LinkedHashMap<String, Double> questionScore = answerExamInfo.getQuestionScore(); userBookService.saveWrongQuestion(questionScore); } // 白名单更新答题信息 request.setId(answerView.getId()); updateProjectPartnerByAnswer(request, project); // 完事儿删除 cookie 标识 if (isNotBlank(answerIdFromCookie)) { Cookie cookie = new Cookie(randomSurveyCookieName, answerIdFromCookie); cookie.setMaxAge(0); ContextHelper.getCurrentHttpResponse().addCookie(cookie); } return result; } /* * @param request * @return / @Override @SneakyThrows public PublicQueryVerifyView loadQuery(PublicQueryRequest request) { Tuple2<ProjectView, ProjectSetting.PublicQuery> projectAndQuery = getProjectAndQueryThenValidate(request); SurveySchema schema = buildQueryFormSchema(projectAndQuery.getFirst(), projectAndQuery.getSecond()); PublicQueryVerifyView view = new PublicQueryVerifyView(); view.setSchema(schema); return view; } @Override public PublicQueryView getQueryResult(PublicQueryRequest request) { Tuple2<ProjectView, ProjectSetting.PublicQuery> projectAndQuery = getProjectAndQueryThenValidate(request); SurveySchema schema = buildQueryResultSchema(projectAndQuery.getFirst(), projectAndQuery.getSecond()); PublicQueryView view = new PublicQueryView(); view.setSchema(schema); List<Answer> answers = findAnswerByQuery(request, projectAndQuery); // 根据配置的权限信息过滤答案 LinkedHashMap<String, Integer> fieldPermission = projectAndQuery.getSecond().getFieldPermission(); view.setFieldPermission(fieldPermission); view.setAnswers(answers.stream().map(answer -> { filterAnswerByFieldPermission(answer.getAnswer(), fieldPermission); PublicAnswerView answerView = new PublicAnswerView(); answerView.setAnswerId(answer.getId()); answerView.setAnswer(answer.getAnswer()); if (FieldPermissionType.visible.equals(fieldPermission.get("examScore")) \|\| FieldPermissionType.editable.equals(fieldPermission.get("examScore"))) { // 公开查询允许查询分值 answer.getAnswer().put("examScore", Collections.singletonMap("examScore", answer.getExamScore())); } answerView.setCreateAt(answer.getCreateAt()); return answerView; }).collect(Collectors.toList())); return view; } @Override public List<PublicDictView> loadDict(PublicDictRequest request) { return dictItemService .list(Wrappers.<CommDictItem>lambdaQuery().eq(CommDictItem::getDictCode, request.getDictCode()) .eq(request.getCascaderLevel() != null, CommDictItem::getItemLevel, request.getCascaderLevel()) .eq(request.getParentValue() != null, CommDictItem::getParentItemValue, request.getParentValue()) .and(isNotBlank(request.getSearch()), i -> i.like(CommDictItem::getItemName, request.getSearch()).or() .like(CommDictItem::getItemValue, request.getSearch())) .last(String.format("limit %d", request.getLimit() != null ? request.getLimit() : 50))) .stream().map(x -> { PublicDictView view = new PublicDictView(); view.setLabel(x.getItemName()); view.setValue(x.getItemValue()); return view; }).collect(Collectors.toList()); } /* * 成绩查询页面获取成绩信息 * @param request * @return / @Override public PublicExamResult loadExamResult(PublicExamRequest request) { ProjectView project = projectService.getProject(request.getId()); AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setId(request.getAnswerId()); if (Boolean.TRUE.equals(project.getSetting().getSubmittedSetting().getRankVisible())) { answerQuery.setRankEnabled(true); } AnswerView answerView = answerService.getAnswer(answerQuery); ProjectSetting.SubmittedSetting submittedSetting = project.getSetting().getSubmittedSetting(); ProjectSetting.ExamSetting examSetting = project.getSetting().getExamSetting(); PublicExamResult result = new PublicExamResult(); result.setName(project.getName()); // 可以查看正确答案和解析; // 考试结束之后才可以查看正确答案和解析 if (Boolean.TRUE.equals(submittedSetting.getAnswerAnalysis()) && examFinished(examSetting)) { result.setAnswer(answerView.getAnswer()); result.setSchema(project.getSurvey()); result.setExamInfo(answerView.getExamInfo()); } // 显示成绩单 if (Boolean.TRUE.equals(submittedSetting.getTranscriptVisible())) { result.setExamScore(answerView.getExamScore()); } // 显示排名 TODO:显示排行榜 if (Boolean.TRUE.equals(submittedSetting.getRankVisible())) { result.setRank(answerView.getRank()); } // 随机问题 if (answerView.getSurvey() != null) { result.setSchema(answerView.getSurvey()); } result.setMetaInfo(answerView.getMetaInfo()); return result; } @Override public void tempSaveAnswer(AnswerRequest request) { String projectId = request.getProjectId(); if (!Integer.valueOf(0).equals(request.getTempSave()) \|\| request.getTempAnswer() == null \|\| projectId == null) { return; } String answerId = ContextHelper.getCookie(AppConsts.COOKIE_RANDOM_PROJECT_PREFIX + projectId); if (answerId == null) { return; } if (!SecurityContextUtils.isAuthenticated()) { // 目前仅支持登录用户后端暂存 return; } AnswerRequest answerRequest = new AnswerRequest(); answerRequest.setId(answerId); answerRequest.setTempSave(0); answerRequest.setTempAnswer(request.getTempAnswer()); answerService.updateAnswer(answerRequest); } @Override public PublicLinkResult loadLinkResult(PublicLinkRequest request) { PublicLinkResult result = new PublicLinkResult(); ProjectView projectView = projectService.getProject(request.getProjectId()); if (projectView == null) { throw new ErrorCodeException(ErrorCode.ProjectNotFound); } SurveySchema currentQuestionSchema = SchemaHelper.flatSurveySchema(projectView.getSurvey()).stream() .filter(x -> x.getId().equals(request.getQuestionId())).findFirst().orElseGet(() -> { SurveySchema surveySchema = new SurveySchema(); surveySchema.setChildren(new ArrayList<>()); return surveySchema; }); List<SurveySchema.LinkSurvey> linkSurveys = currentQuestionSchema.getChildren().stream() .filter(x -> request.getOptionId().equals(x.getId())).findFirst().orElseGet(SurveySchema::new).getLinkSurveys(); if (linkSurveys == null) { throw new ErrorCodeException(ErrorCode.LinkConditionNotFound); } LinkedHashMap<String, Map<String, Object>> fillAnswer = new LinkedHashMap<>(); result.setAnswer(fillAnswer); for (SurveySchema.LinkSurvey linkSurvey : linkSurveys) { Answer answer = answerService .getOne(Wrappers.<Answer>lambdaQuery().eq(Answer::getProjectId, linkSurvey.getLinkSurveyId()) .like(Answer::getAnswer, buildLinkLikeCondition(linkSurvey, request.getValue())) .orderByDesc(Answer::getCreateAt).last("limit 1")); fillLinkFieldAndAnswer(answer != null ? answer.getAnswer() : null, linkSurvey.getLinkFields(), fillAnswer); } return result; } @SneakyThrows private String buildLinkLikeCondition(SurveySchema.LinkSurvey linkSurvey, Object value) { Map<String, Object> optionValue = new HashMap<>(); optionValue.put(linkSurvey.getLinkOptionId(), value); // Map<String, Map<String, Object>> questionValue = new HashMap<>(); // questionValue.put(linkSurvey.getLinkQuestionId(), optionValue); return StringUtils.substringBetween(objectMapper.writeValueAsString(optionValue), "{", "}"); } public void fillLinkFieldAndAnswer(LinkedHashMap answer, List<SurveySchema.LinkField> linkFields, LinkedHashMap<String, Map<String, Object>> fillAnswer) { for (SurveySchema.LinkField linkField : linkFields) { Map<String, Object> questionValueMap = fillAnswer.computeIfAbsent(linkField.getFillQuestionId(), (k) -> new HashMap<>()); if (answer == null) { continue; } Map<String, Object> linkQuestionValue = (Map<String, Object>) answer.get(linkField.getLinkQuestionId()); if (linkQuestionValue == null) { continue; } questionValueMap.put(linkField.getFillOptionId(), linkQuestionValue.get(linkField.getLinkOptionId())); } } /* * 判断考试是否结束，未设置默认为已结束 * @param examSetting * @return / private boolean examFinished(ProjectSetting.ExamSetting examSetting) { if (examSetting.getEndTime() == null \|\| examSetting.getEndTime() < System.currentTimeMillis()) { return true; } return false; } /* * 根据问卷设置校验问卷 * @param project * @return / private ProjectSetting validateProject(ProjectView project) { if (project == null) { throw new ErrorCodeException(ErrorCode.ProjectNotFound); } ProjectSetting setting = project.getSetting(); String projectId = project.getId(); if (setting.getStatus() == 0) { throw new ErrorCodeException(ErrorCode.SurveySuspend); } Long maxAnswers = setting.getAnswerSetting().getMaxAnswers(); // 校验最大答案条数限制 if (maxAnswers != null) { AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setProjectId(project.getId()); long totalAnswers = answerService.count(answerQuery); if (totalAnswers >= maxAnswers) { throw new ErrorCodeException(ErrorCode.ExceededMaxAnswers); } // 不将设置暴露给前端接口，不使用 @JsonProperty，否则设置页面回获取不到该值 setting.getAnswerSetting().setMaxAnswers(null); } // 校验问卷是否已到结束时间 Long endTime = setting.getAnswerSetting().getEndTime(); if (endTime != null) { if (new Date().getTime() > endTime) { throw new ErrorCodeException(ErrorCode.ExceededEndTime); } } // 如果需要登录，则使用账号进行限制 if (setting.getAnswerSetting().getLoginLimit() != null && Boolean.TRUE.equals(setting.getAnswerSetting().getLoginRequired())) { validateLoginLimit(projectId, setting); } // cookie 限制 if (setting.getAnswerSetting().getCookieLimit() != null) { validateCookieLimit(projectId, setting); } // ip 限制 if (setting.getAnswerSetting().getIpLimit() != null) { validateIpLimit(projectId, setting); } // 白名单限制 if (setting.getAnswerSetting().getWhitelistLimit() != null) { validateWhitelistLimit(projectId, setting); } validateExamSetting(project); return setting; } /* * 答案校验 * @param project * @param request / private void validateAnswer(ProjectView project, AnswerRequest request) { List<SurveySchema> uniqueSchemaList = SchemaHelper.findSchemaListByAttribute(project.getSurvey(), "unique", true); SchemaHelper.TreeNode treeNode = SchemaHelper.SurveySchema2TreeNode(project.getSurvey()); uniqueSchemaList.forEach(optionSchema -> { // 支持数值和字符串 String questionId = treeNode.getTreeNodeMap().get(optionSchema.getId()).getParent().getData().getId(); Object questionValue = request.getAnswer().get(questionId); if (questionValue == null) { return; } String uniqueQuery = String.format("\"%s\":", optionSchema.getId()); if (SurveySchema.DataType.number == optionSchema.getAttribute().getDataType()) { uniqueQuery += ((Map) questionValue).get(optionSchema.getId()); } else { uniqueQuery += "\"" + ((Map) questionValue).get(optionSchema.getId()) + "\""; } AnswerQuery query = new AnswerQuery(); query.setProjectId(project.getId()); query.setValueQuery(uniqueQuery); if (answerService.count(query) > 0) { String uniqueText = optionSchema.getAttribute().getUniqueText(); throw new ValidationException(isNotBlank(uniqueText) ? uniqueText : "问卷重复保存"); } }); // 选项配额校验 List<SurveySchema> hasQuotaSchemaList = SchemaHelper.findSchemaHasAttribute(project.getSurvey(), "quota"); if (hasQuotaSchemaList.size() > 0) { ProjectQuery query = new ProjectQuery(); query.setId(request.getProjectId()); PublicStatisticsView statisticsView = statProject(query); hasQuotaSchemaList.forEach(optionSchema -> { String questionId = treeNode.getTreeNodeMap().get(optionSchema.getId()).getParent().getData().getId(); Object questionValue = request.getAnswer().get(questionId); if (questionValue == null) { return; } boolean optionNotChecked = ((Map) questionValue).get(optionSchema.getId()) == null; if (optionNotChecked) { return; } PublicStatisticsView.QuestionStatistics questionStatistics = statisticsView.getQuestionStatistics() .get(questionId); int optionSelectedCount = questionStatistics.getOptionStatistics().stream() .filter(x -> x.getOptionId().equals(optionSchema.getId())).findFirst() .orElse(new PublicStatisticsView.OptionStatistics()).getCount(); Integer quota = optionSchema.getAttribute().getQuota(); if (quota != null && optionSelectedCount + 1 > quota) { throw new ValidationException("选项数量超过限制，请重新选择"); } }); } } private void validateExamSetting(ProjectView project) { ProjectSetting.ExamSetting examSetting = project.getSetting().getExamSetting(); if (examSetting == null \|\| !ProjectModeEnum.exam.equals(project.getMode())) { return; } // 校验考试开始时间 if (examSetting.getStartTime() != null && new Date(examSetting.getStartTime()).compareTo(new Date()) > 0) { throw new ErrorCodeException(ErrorCode.ExamUnStarted); } // 校验考试结束时间 if (examSetting.getEndTime() != null && new Date(examSetting.getEndTime()).compareTo(new Date()) < 0) { throw new ErrorCodeException(ErrorCode.ExamFinished); } } /* * 校验问卷并且判断是否要更新最近一次的答案 * @param project * @param request * @return 最近一次的答案 / private AnswerView validateAndGetLatestAnswer(ProjectView project, AnswerRequest request) { ProjectSetting setting = project.getSetting(); boolean needGetLatest = false; try { validateProject(project); validateAnswer(project, request); // 未设时间限制&需要登录&可以修改，永远修改的是同一份 if (SecurityContextUtils.isAuthenticated() && setting != null && Boolean.TRUE.equals(setting.getSubmittedSetting().getEnableUpdate())) { needGetLatest = true; } } catch (ErrorCodeException e) { // 如果设置了时间限制，只能修改某个时间区间内的问卷 // 登录&问卷已提交&允许修改，则可以继续修改 if (ErrorCode.SurveySubmitted.equals(e.getErrorCode()) && SecurityContextUtils.isAuthenticated() && setting != null && Boolean.TRUE.equals(setting.getSubmittedSetting().getEnableUpdate())) { needGetLatest = true; } else { throw e; } } // 获取最近一份的问卷执行答案更新操作 if (needGetLatest) { AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setProjectId(project.getId()); answerQuery.setLatest(true); AnswerView latestAnswer = answerService.getAnswer(answerQuery); if (latestAnswer != null) { return latestAnswer; } } return null; } /* * 获取最近一次的答案 * @param projectView * @return / private LinkedHashMap<String, Object> getLatestAnswer(PublicProjectView projectView, String whitelistName) { // 打开了答案允许修改开关 ProjectSetting projectSetting = projectView.getSetting(); if (projectSetting == null \|\| projectSetting.getSubmittedSetting() == null \|\| !Boolean.TRUE.equals(projectSetting.getSubmittedSetting().getEnableUpdate())) { return null; } AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setProjectId(projectView.getId()); answerQuery.setLatest(true); if (whitelistName != null) { ProjectPartner partner = projectPartnerMapper.selectOne( Wrappers.<ProjectPartner>lambdaQuery().eq(ProjectPartner::getProjectId, projectView.getId()) .eq(ProjectPartner::getUserName, whitelistName)); if (partner != null && !SecurityContextUtils.isAuthenticated()) { answerQuery.setCreateBy(partner.getId()); } } // 通过白名单或者答卷人来获取最近一次的答卷记录 if (SecurityContextUtils.isAuthenticated() \|\| answerQuery.getCreateBy() != null) { return Optional.ofNullable(answerService.getAnswer(answerQuery)).map(x -> x.getAnswer()).orElse(null); } return null; } /* * 公开查询修改答案，因为涉及到权限操作，需要将之前的答案和更新的答案做一个 merge 操作 * @param project * @param answer / private void validateAndMergeAnswer(ProjectView project, AnswerRequest answer) { if (isBlank(answer.getQueryId()) \|\| isBlank(answer.getId())) { throw new ErrorCodeException(ErrorCode.QueryResultUpdateError); } try { // 公开查询设置必须存在，并且包含可编辑字段 ProjectSetting.PublicQuery query = project.getSetting().getSubmittedSetting().getPublicQuery().stream() .filter(x -> x.getId().equals(answer.getQueryId())).findFirst().orElseGet(() -> { ProjectSetting.PublicQuery publicQuery = new ProjectSetting.PublicQuery(); publicQuery.setFieldPermission(new LinkedHashMap<>()); return publicQuery; }); if (!query.getFieldPermission().values().contains(FieldPermissionType.editable)) { throw new ErrorCodeException(ErrorCode.QueryResultUpdateError); } AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setId(answer.getId()); AnswerView latestAnswer = answerService.getAnswer(answerQuery); LinkedHashMap<String, Object> existAnswer = latestAnswer.getAnswer(); existAnswer.forEach((key, value) -> { if (!answer.getAnswer().containsKey(key)) { answer.getAnswer().put(key, value); } }); } catch (Exception e) { throw new ErrorCodeException(ErrorCode.QueryResultUpdateError); } } private void validateLoginLimit(String projectId, ProjectSetting setting) { String userId = SecurityContextUtils.getUserId(); if (userId == null) { log.info("user is empty"); return; } AnswerQuery query = new AnswerQuery(); query.setProjectId(projectId); query.setCreateBy(userId); doValidate(setting, query, setting.getAnswerSetting().getLoginLimit()); } private void validateCookieLimit(String projectId, ProjectSetting setting) { HttpServletRequest request = ContextHelper.getCurrentHttpRequest(); Cookie limitCookie = WebUtils.getCookie(request, AppConsts.COOKIE_LIMIT_NAME); if (limitCookie == null) { // 添加 cookie HttpServletResponse response = ContextHelper.getCurrentHttpResponse(); final Cookie cookie = new Cookie(AppConsts.COOKIE_LIMIT_NAME, UUID.randomUUID().toString()); cookie.setPath("/"); cookie.setMaxAge(100 360 * 24 * 60 * 60); cookie.setHttpOnly(true); response.addCookie(cookie); response.addCookie(cookie); return; } AnswerQuery query = new AnswerQuery(); query.setProjectId(projectId); query.setCookie(limitCookie.getValue()); doValidate(setting, query, setting.getAnswerSetting().getCookieLimit()); } private void validateIpLimit(String projectId, ProjectSetting setting) { HttpServletRequest request = ContextHelper.getCurrentHttpRequest(); String ip = IPUtils.getClientIpAddress(request); if (ip == null) { log.info("ip is empty"); return; } AnswerQuery query = new AnswerQuery(); query.setProjectId(projectId); query.setIp(ip); doValidate(setting, query, setting.getAnswerSetting().getIpLimit()); } private void validateWhitelistLimit(String projectId, ProjectSetting setting) { AnswerQuery query = new AnswerQuery(); query.setProjectId(projectId); // 如果白名单校验成功，导入用户获取partner表的id，系统用户是当前登录用户 id String createBy = (String) ContextHelper.getCurrentHttpRequest().getAttribute("createBy"); if (createBy != null) { query.setCreateBy(createBy); doValidate(setting, query, setting.getAnswerSetting().getWhitelistLimit()); } } private void doValidate(ProjectSetting setting, AnswerQuery query, ProjectSetting.UniqueLimitSetting limitSetting) { // 通过 cron 计算时间窗 CronHelper helper = new CronHelper(limitSetting.getLimitFreq().getCron()); Tuple2<LocalDateTime, LocalDateTime> currentWindow = helper.currentWindow(); if (currentWindow != null) { query.setStartTime(Date.from(currentWindow.getFirst().atZone(ZoneId.systemDefault()).toInstant())); query.setEndTime(Date.from(currentWindow.getSecond().atZone(ZoneId.systemDefault()).toInstant())); } long total = answerService.count(query); // 允许修改答案的话就获取最近一次的答案，不抛出异常 if (limitSetting.getLimitNum() != null && total >= limitSetting.getLimitNum() && (setting.getSubmittedSetting() == null \|\| !Boolean.TRUE.equals(setting.getSubmittedSetting().getEnableUpdate()))) { throw new ErrorCodeException(ErrorCode.SurveySubmitted); } } private Tuple2<ProjectView, ProjectSetting.PublicQuery> getProjectAndQueryThenValidate(PublicQueryRequest request) { ProjectView project = projectService.getProject(request.getId()); List<ProjectSetting.PublicQuery> queries = project.getSetting().getSubmittedSetting().getPublicQuery(); if (queries == null \|\| queries.size() == 0) { throw new ErrorCodeException(ErrorCode.QueryNotExist); } ProjectSetting.PublicQuery query = queries.stream().filter(x -> x.getId().equals(request.getResultId())) .findFirst().orElseThrow(() -> new ErrorCodeException(ErrorCode.QueryNotExist)); validatePublicQuery(query, request.getAnswer()); return new Tuple2<>(project, query); } /** * @param query 公开查询配置 * @param answer 查询答案 / @SneakyThrows private void validatePublicQuery(ProjectSetting.PublicQuery query, LinkedHashMap answer) { if (Boolean.FALSE.equals(query.getEnabled())) { throw new ErrorCodeException(ErrorCode.QueryDisabled); } SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); List<String> linkValidityPeriod = query.getLinkValidityPeriod(); if (linkValidityPeriod != null && linkValidityPeriod.size() == 2 && !DateUtils.isBetween(new Date(), sdf.parse(linkValidityPeriod.get(0)), sdf.parse(linkValidityPeriod.get(1)))) { throw new ErrorCodeException(ErrorCode.QueryDisabled); } // 校验密码 if (isNotBlank(query.getPassword()) && answer != null) { if (!answer.containsKey(AppConsts.PUBLIC_QUERY_PASSWORD_FIELD_ID)) { throw new ErrorCodeException(ErrorCode.QueryPasswordError); } String password = (String) ((Map) answer.get(AppConsts.PUBLIC_QUERY_PASSWORD_FIELD_ID)) .get(AppConsts.PUBLIC_QUERY_PASSWORD_FIELD_ID); if (isBlank(password) \|\| !query.getPassword().equals(password.trim())) { throw new ErrorCodeException(ErrorCode.QueryPasswordError); } answer.remove(AppConsts.PUBLIC_QUERY_PASSWORD_FIELD_ID); } } /* * 前端支持动态主题(问卷主题/表单主题)切换，动态构建查询表单 * @param project * @param query * @return / private SurveySchema buildQueryFormSchema(ProjectView project, ProjectSetting.PublicQuery query) { SurveySchema schema = SurveySchema.builder().id(query.getId()).title(query.getTitle()) .description(query.getDescription()) .children(findMatchChildrenInSchema(query.getConditionQuestion(), project)) .attribute(SurveySchema.Attribute.builder().submitButton("查询").build()).build(); // 目前只支持文本题 #{huaw}#{fhpd} if (isNotBlank(query.getPassword())) { // 添加一个password的schema，用于密码校验 SurveySchema passwordSchema = SurveySchema.builder().id(AppConsts.PUBLIC_QUERY_PASSWORD_FIELD_ID) .title("密码").type(SurveySchema.QuestionType.FillBlank) .attribute(SurveySchema.Attribute.builder().required(true).build()).build(); passwordSchema.setChildren(Collections .singletonList(SurveySchema.builder().id(AppConsts.PUBLIC_QUERY_PASSWORD_FIELD_ID).build())); schema.getChildren().add(passwordSchema); } return schema; } private List<SurveySchema> findMatchChildrenInSchema(String conditionQuestion, ProjectView project) { if (isBlank(conditionQuestion)) { return new ArrayList<>(); } Pattern condPattern = Pattern.compile("#\\{(.?)\\}"); Matcher m = condPattern.matcher(conditionQuestion); List<String> conditionIds = new ArrayList<>(); while (m.find()) { String qId = m.group(1); conditionIds.add(qId); } return SchemaHelper.flatSurveySchema(project.getSurvey()).stream() .filter(qSchema -> conditionIds.contains(qSchema.getId())).collect(Collectors.toList()); } /** * 根据配置的字段权限信息来过滤要查询的字段 * @param project * @param query * @return / private SurveySchema buildQueryResultSchema(ProjectView project, ProjectSetting.PublicQuery query) { SurveySchema schema = project.getSurvey().deepCopy(); SchemaHelper.updateSchemaByPermission(query.getFieldPermission(), schema); if (query.getFieldPermission().values().contains(FieldPermissionType.editable)) { schema.setAttribute(SurveySchema.Attribute.builder().submitButton("修改").suffix(null).build()); } else { schema.setAttribute(null); } if (ProjectModeEnum.exam.equals(project.getMode())) { schema.getChildren() .add(SurveySchema.builder().id("examScore").title("分数").type(SurveySchema.QuestionType.FillBlank) .attribute(SurveySchema.Attribute.builder().readOnly(true).build()) .children(Collections.singletonList(SurveySchema.builder().id("examScore").build())) .build()); } // 公开查询表单需要取消结束、显示隐藏、跳转规则 SchemaHelper.ignoreAttributes(schema, "finishRule", "visibleRule", "jumpRule"); return schema; } /* * @param request 提交的请求 * @param projectAndQuery 项目信息和当前查询信息 * @return / private List<Answer> findAnswerByQuery(PublicQueryRequest request, Tuple2<ProjectView, ProjectSetting.PublicQuery> projectAndQuery) { ProjectView projectView = projectAndQuery.getFirst(); List<SurveySchema> conditionSchemaList = findMatchChildrenInSchema( projectAndQuery.getSecond().getConditionQuestion(), projectAndQuery.getFirst()); if (conditionSchemaList.size() == 0 && request.getQuery().size() == 0) { throw new ErrorCodeException(ErrorCode.QueryResultNotExist); } SchemaHelper.TreeNode treeNode = SchemaHelper.SurveySchema2TreeNode(projectView.getSurvey()); // 通过 url 参数构建查询表单 LinkedHashMap<String, Map> queryFormValues = buildFormValuesFromQueryParameter(treeNode, request.getQuery()); // 将查询表单和url参数构建的查询表单合并 queryFormValues.putAll(request.getAnswer()); List<Answer> answer = ((AnswerServiceImpl) answerService) .list(Wrappers.<Answer>lambdaQuery().eq(Answer::getProjectId, projectView.getId()).and(i -> { queryFormValues.forEach((qId, qValueObj) -> { i.like(Answer::getAnswer, buildLikeQueryConditionOfQuestion(treeNode.getTreeNodeMap().get(qId), qValueObj)); }); })); if (answer.size() == 0) { throw new ErrorCodeException(ErrorCode.QueryResultNotExist); } // 根据配置过滤结果 return answer; } /* * 通过查询参数里面构建 form values * @param query * @return / private LinkedHashMap buildFormValuesFromQueryParameter(SchemaHelper.TreeNode surveySchemaTreeNode, Map<String, String> query) { LinkedHashMap<String, Map> formValues = new LinkedHashMap<>(); query.forEach((id, value) -> { // 默认为选项 SchemaHelper.TreeNode findNode = surveySchemaTreeNode.getTreeNodeMap().get(id); String questionId = findNode.getParent().getData().getId(); Map questionValueMap = formValues.computeIfAbsent(questionId, k -> new HashMap<>()); questionValueMap.put(id, value); }); return formValues; } /* * 通过问题答案手动构建like 查询 * @param qNode 当前问题的 schema node 节点 * @param qValueObj 当前问题的答案 * @return / private String buildLikeQueryConditionOfQuestion(SchemaHelper.TreeNode qNode, Map qValueObj) { SurveySchema optionSchema = qNode.getData().getChildren().get(0); String optionId = optionSchema.getId(); Object optionValue = qValueObj.get(optionId); String value = optionValue.toString(); // 选项非数值类型 if (optionSchema.getAttribute() == null \|\| !SurveySchema.DataType.number.equals(optionSchema.getAttribute().getDataType())) { value = "\"" + value + "\""; } return String.format("{\"%s\":%s}", optionId, value); } /* * 根据字段权限配置过滤结果集，过滤掉隐藏题的答案 * @param answer * @param fieldPermission / private void filterAnswerByFieldPermission(LinkedHashMap answer, LinkedHashMap<String, Integer> fieldPermission) { fieldPermission.entrySet().forEach(entry -> { String qId = entry.getKey(); Integer permission = entry.getValue(); if (FieldPermissionType.hidden == permission) { answer.remove(qId); } }); } /* * 如果问卷需要登录、需要密码答卷、需要白名单答卷进入问卷之前需要弹出验证表单 * @param project 当前项目 * @param answer 查询表单的答案 * @return 返回查询表单的 schema，如果未空，则会直接进入到答卷页面 / private SurveySchema convertAndValidateLoginFormIfNeeded(ProjectView project, LinkedHashMap<String, Object> answer) { boolean loginRequired = false; // 需要更新答题者为已访问的状态 boolean updatePartnerVisited = false; LambdaQueryWrapper<ProjectPartner> projectPartnerQuery = Wrappers.<ProjectPartner>lambdaQuery() .eq(ProjectPartner::getProjectId, project.getId()); Authentication authentication = null; List<SurveySchema> queryConditions = new ArrayList<>(); SurveySchema loginFormSchema = SurveySchema.builder().id(project.getId()).children(queryConditions) .title(project.getName()).build(); // 错题练习模式需要登录 if (project != null && project.getSetting() != null && project.getSetting().getExamSetting() != null) { ProjectSetting.ExamSetting examSetting = project.getSetting().getExamSetting(); if (Boolean.TRUE.equals(examSetting.getRandomSurveyWrong()) && !SecurityContextUtils.isAuthenticated()) { loginRequired = true; SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.username)); SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.password)); if (answer != null) { authentication = validateUsernameAndPassword(answer); } } } if (project != null && project.getSetting() != null && project.getSetting().getAnswerSetting() != null) { ProjectSetting.AnswerSetting answerSetting = project.getSetting().getAnswerSetting(); // 需要登录答卷 if (Boolean.TRUE.equals(answerSetting.getLoginRequired()) && !SecurityContextUtils.isAuthenticated()) { loginRequired = true; SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.username)); SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.password)); if (answer != null) { authentication = validateUsernameAndPassword(answer); } } // 需要密码答卷 if (answerSetting.getPassword() != null) { loginRequired = true; queryConditions .add(SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.extraPassword)); if (answer != null) { if (!answerSetting.getPassword().equals( SchemaHelper.getLoginFormAnswer(answer, SchemaHelper.LoginFormFieldEnum.extraPassword))) { throw new ErrorCodeException(ErrorCode.ValidationError); } } } // 白名单为系统用户 if (answerSetting.getWhitelistType() != null && ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType() == answerSetting.getWhitelistType()) { // 如果当前已登录且当前用户不在白名单内，则报错 if (SecurityContextUtils.isAuthenticated()) { boolean currentHasPerm = projectPartnerMapper.selectCount( Wrappers.<ProjectPartner>lambdaQuery().eq(ProjectPartner::getProjectId, project.getId()) .eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()) .eq(ProjectPartner::getUserId, SecurityContextUtils.getUserId())) == 1; if (!currentHasPerm) { throw new ErrorCodeException(ErrorCode.PermVerifyFailed); } updatePartnerVisited = true; projectPartnerQuery.eq(ProjectPartner::getUserId, SecurityContextUtils.getUserId()) .eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()); } else { // 需要执行登录操作 SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.username)); SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.password)); loginRequired = true; if (answer != null) { if (authentication == null) { authentication = validateUsernameAndPassword(answer); } // 执行登录操作 UserInfo user = (UserInfo) authentication.getPrincipal(); // 判断登录用户是否在白名单里面 /* * todo 这里应该加上用户类型，否则会出查询出来多条 * 多条原因： * 新创建的问卷的时候，默认的插入一条名单数据，type = 1 * 修改答题白名单设置为系统用户时，又插入一条，type = 3 * 修改答题白名单设置为外部用户时，又插入一条，type = 4，当然这条数据没有用户id，在这里不会被查出来 * 综上，这里至少会查询出2条，所以需要加入用户类型限制，或者修改答题白名单时移除旧数据 * 这里验证的是"白名单为系统用户"，所以type = 3 / boolean currentHasPerm = projectPartnerMapper.selectCount( Wrappers.<ProjectPartner>lambdaQuery().eq(ProjectPartner::getProjectId, project.getId()) .eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()) .eq(ProjectPartner::getUserId, user.getUserId())) == 1; if (!currentHasPerm) { throw new ErrorCodeException(ErrorCode.PermVerifyFailed); } updatePartnerVisited = true; projectPartnerQuery.eq(ProjectPartner::getUserId, user.getUserId()).eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()); } } } // 白名单为导入用户 if (answerSetting.getWhitelistType() != null && ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType() == answerSetting.getWhitelistType()) { SchemaHelper.appendChildIfNotExist(loginFormSchema, SchemaHelper.buildFillBlankQuerySchema(SchemaHelper.LoginFormFieldEnum.whitelistName)); loginRequired = true; if (answer != null) { // 校验登录白名单名称是否在白名单列表里面 String whitelistName = (String) SchemaHelper.getLoginFormAnswer(answer, SchemaHelper.LoginFormFieldEnum.whitelistName); if (whitelistName == null) { throw new ErrorCodeException(ErrorCode.PermVerifyFailed); } boolean currentHasPerm = projectPartnerMapper.selectCount( Wrappers.<ProjectPartner>lambdaQuery().eq(ProjectPartner::getProjectId, project.getId()) .eq(ProjectPartner::getUserName, whitelistName)) == 1; if (!currentHasPerm) { throw new ErrorCodeException(ErrorCode.PermVerifyFailed); } updatePartnerVisited = true; projectPartnerQuery.eq(ProjectPartner::getUserName, whitelistName).eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType()); } } } if (authentication != null) { // 执行登录操作，方便后续保存答案的时候获取认证信息 UserInfo user = (UserInfo) authentication.getPrincipal(); HttpCookie cookie = ResponseCookie .from(AppConsts.TOKEN_NAME, jwtTokenUtil.generateAccessToken(new UserTokenView(user.getUserId()))) .path("/").httpOnly(true).build(); ContextHelper.getCurrentHttpResponse().setHeader(HttpHeaders.SET_COOKIE, cookie.toString()); } // 更新问卷状态为已访问 if (updatePartnerVisited) { ProjectPartner projectPartner = projectPartnerMapper.selectOne(projectPartnerQuery); if (projectPartner != null && projectPartner.getStatus() == AppConsts.ProjectPartnerStatus.UNVISITED) { projectPartner.setStatus(AppConsts.ProjectPartnerStatus.VISITED); projectPartnerMapper.updateById(projectPartner); } // 如果配置的外部用户，则 createBy 为 partner 的 id，如果是内部用户则是用户 id if (projectPartner.getUserName() != null) { ContextHelper.getCurrentHttpRequest().setAttribute("createBy", projectPartner.getId()); } else if (projectPartner.getUserId() != null) { ContextHelper.getCurrentHttpRequest().setAttribute("createBy", SecurityContextUtils.getUserId()); } } if (loginRequired) { return loginFormSchema; } return null; } /* * 答卷前登录校验用户名和密码 * @param answer * @return / private Authentication validateUsernameAndPassword(LinkedHashMap<String, Object> answer) { try { Authentication authentication = authenticationManager.authenticate(new UsernamePasswordAuthenticationToken( SchemaHelper.getLoginFormAnswer(answer, SchemaHelper.LoginFormFieldEnum.username), SchemaHelper.getLoginFormAnswer(answer, SchemaHelper.LoginFormFieldEnum.password))); SecurityContextHolder.getContext().setAuthentication(authentication); return authentication; } catch (Exception e) { throw new ErrorCodeException(ErrorCode.ValidationError); } } /* * 如果存在白名单，答卷完更新白名单为已访问的状态，由于导入用户白名单没有系统用户id，需要将答案的创建人更新为答题参与表的id。 * @param request * @param project / private void updateProjectPartnerByAnswer(AnswerRequest request, ProjectView project) { if (project.getSetting() != null && project.getSetting().getAnswerSetting() != null) { Integer whitelistType = project.getSetting().getAnswerSetting().getWhitelistType(); if (whitelistType == null) { return; } LambdaQueryWrapper<ProjectPartner> queryWrapper = Wrappers.<ProjectPartner>lambdaQuery() .eq(ProjectPartner::getProjectId, project.getId()); if (ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType() == whitelistType) { queryWrapper.eq(ProjectPartner::getUserId, SecurityContextUtils.getUserId()).eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()); if (!SecurityContextUtils.isAuthenticated()) { return; } } else if (ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType() == whitelistType) { queryWrapper.eq(ProjectPartner::getUserName, request.getWhitelistName()).eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType()); } ProjectPartner projectPartner = projectPartnerMapper.selectOne(queryWrapper); projectPartner.setStatus(AppConsts.ProjectPartnerStatus.ANSWERED); projectPartnerMapper.updateById(projectPartner); // 白名单导入用户答题需要更新答案表的 createBy 为 partner 的 id if (ProjectPartnerTypeEnum.RESPONDENT_IMP_USER.getType() == whitelistType) { AnswerRequest answerUpdateRequest = new AnswerRequest(); answerUpdateRequest.setId(request.getId()); answerUpdateRequest.setCreateBy(projectPartner.getId()); answerUpdateRequest.setProjectId(request.getProjectId()); answerService.updateAnswer(answerUpdateRequest); } } } /* * 随机问题，分为随机问题和错题练习 * @param project / private void replaceSchemaIfRandomSchema(ProjectView project, PublicProjectView projectView) { if (ProjectModeEnum.exam != project.getMode()) { return; } SurveySchema source = project.getSurvey(); Boolean randomSurveyWrong = project.getSetting().getExamSetting().getRandomSurveyWrong(); if (Boolean.TRUE.equals(randomSurveyWrong)) { if (!SecurityContextUtils.isAuthenticated()) { // 需要登录 } List<UserBook> wrongUserQuestions = userBookService .list(Wrappers.<UserBook>lambdaQuery().eq(UserBook::getType, UserBookServiceImpl.BOOK_TYPE_WRONG) .eq(UserBook::getCreateBy, SecurityContextUtils.getUserId())); if (wrongUserQuestions.size() == 0) { return; } SurveySchema randomSchema = SurveySchema.builder().id(source.getId()).children(templateService .listByIds(wrongUserQuestions.stream().map(x -> x.getTemplateId()).collect(Collectors.toList())) .stream().map(x -> { SurveySchema schema = x.getTemplate(); schema.setId(x.getId()); schema.setTitle(x.getName()); return schema; }).collect(Collectors.toList())).title(source.getTitle()).attribute(source.getAttribute()) .description(source.getDescription()).build(); projectView.setSurvey(randomSchema); return; } List<ProjectSetting.RandomSurveyCondition> randomSurveyCondition = project.getSetting().getExamSetting() .getRandomSurvey(); if (randomSurveyCondition == null \|\| randomSurveyCondition.size() == 0) { return; } // 从已有答案里面加载 schema String cookieName = AppConsts.COOKIE_RANDOM_PROJECT_PREFIX + project.getId(); String answerId = ContextHelper.getCookie(cookieName); if (answerId != null) { AnswerQuery answerQuery = new AnswerQuery(); answerQuery.setId(answerId); AnswerView answerView = answerService.getAnswer(answerQuery); if (answerView != null && answerView.getSurvey() != null) { projectView.setSurvey(answerView.getSurvey()); projectView.setTempAnswer(answerView.getTempAnswer()); return; } } // 从题库里面挑题 List<SurveySchema> questionSchemaList = repoService.pickQuestionFromRepo(randomSurveyCondition); // 最终的试卷=编辑器的问题+题库挑的题 if (project.getSurvey() != null && !CollectionUtils.isEmpty(project.getSurvey().getChildren())) { questionSchemaList = Stream.concat(project.getSurvey().getChildren().stream(), questionSchemaList.stream()) .collect(Collectors.toList()); } SurveySchema randomSchema = SurveySchema.builder().id(source.getId()).children(questionSchemaList) .title(source.getTitle()).attribute(source.getAttribute()).description(source.getDescription()).build(); if (questionSchemaList.size() > 0) { projectView.setSurvey(randomSchema); AnswerRequest answerRequest = new AnswerRequest(); answerRequest.setSurvey(randomSchema); answerRequest.setProjectId(project.getId()); AnswerView answerView = answerService.saveAnswer(answerRequest); Cookie cookie = new Cookie(cookieName, answerView.getId()); cookie.setMaxAge(7 24 * 60 * 60); ContextHelper.getCurrentHttpResponse().addCookie(cookie); } }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.constant.CacheConsts;import cn.surveyking.server.core.security.PreAuthorizeAnnotationExtractor;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.RoleViewMapper;import cn.surveyking.server.domain.model.Role;import cn.surveyking.server.domain.model.SysInfo;import cn.surveyking.server.domain.model.UserRole;import cn.surveyking.server.mapper.SysInfoMapper;import cn.surveyking.server.mapper.UserRoleMapper;import cn.surveyking.server.service.SystemService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import org.springframework.beans.BeanUtils;import org.springframework.cache.CacheManager;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import java.util.List;import java.util.stream.Collectors;import static org.apache.commons.lang3.StringUtils.isNotBlank;/* * @author javahuang * @date 2021/10/12 /@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class SystemServiceImpl implements SystemService { private final RoleServiceImpl roleService; private final RoleViewMapper roleViewMapper; private final CacheManager cacheManager; private final UserRoleMapper userRoleMapper; private final SysInfoMapper sysInfoMapper; @Override public SystemInfo getSystemInfo() { SystemInfo systemInfo = new SystemInfo(); SysInfo info = sysInfoMapper.selectOne(Wrappers.<SysInfo>lambdaQuery().eq(SysInfo::getIsDefault, true)); BeanUtils.copyProperties(info, systemInfo); return systemInfo; } @Override public void updateSystemInfo(SystemInfoRequest request) { SysInfo sysInfo = new SysInfo(); BeanUtils.copyProperties(request, sysInfo); sysInfoMapper.updateById(sysInfo); } @Override public PaginationResponse<RoleView> getRoles(RoleQuery query) { Page<Role> rolePage = roleService.pageByQuery(query, Wrappers.<Role>lambdaQuery().like(isNotBlank(query.getName()), Role::getName, query.getName())); return new PaginationResponse<>(rolePage.getTotal(), rolePage.getRecords().stream().map(x -> roleViewMapper.toView(x)).collect(Collectors.toList())); } @Override public void createRole(RoleRequest request) { roleService.save(roleViewMapper.fromRequest(request)); } @Override public void updateRole(RoleRequest request) { if (!CollectionUtils.isEmpty(request.getUserIds())) { // 批量添加角色用户 for (String userId : request.getUserIds()) { UserRole userRole = new UserRole(); userRole.setUserId(userId); userRole.setRoleId(request.getId()); userRoleMapper.insert(userRole); } } else if (!CollectionUtils.isEmpty(request.getEvictUserIds())) { // 批量移除用户角色 userRoleMapper.delete(Wrappers.<UserRole>lambdaUpdate().eq(UserRole::getRoleId, request.getId()) .in(UserRole::getUserId, request.getEvictUserIds())); } else { roleService.updateById(roleViewMapper.fromRequest(request)); evictCache(request.getId()); } } @Override public void deleteRole(RoleRequest request) { roleService.removeById(request.getId()); userRoleMapper.delete(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getRoleId, request.getId())); evictCache(request.getId()); } /* * 角色信息变化时，清除对应的 cache 缓存 * @param roleId */ private void evictCache(String roleId) { userRoleMapper.selectList(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getRoleId, roleId)).forEach( userRole -> cacheManager.getCache(CacheConsts.userCacheName).evictIfPresent(userRole.getUserId())); } @Override public List<PermissionView> getPermissions() { return PreAuthorizeAnnotationExtractor.extractAllApiPermissions().stream().map(x -> new PermissionView(x)) .collect(Collectors.toList()); } @Override public void extractCodeDiffDbPermissions() { // TODO: }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.constant.TagCategoryEnum;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.SelectTagRequest;import cn.surveyking.server.domain.model.Tag;import cn.surveyking.server.mapper.TagMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.TagService;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.;/* * @author javahuang * @date 2022/4/27 */@Service@Transactional(rollbackFor = Exception.class)public class TagServiceImpl extends BaseService<TagMapper, Tag> implements TagService { @Override public void batchAddTag(String entityId, TagCategoryEnum category, String[] tagArr) { deleteTagByEntryId(entityId); if (tagArr == null \|\| tagArr.length == 0) { return; } List<Tag> tagList = new ArrayList<>(); Arrays.stream(tagArr).forEach(tagName -> { Tag tag = new Tag(); tag.setName(tagName); tag.setEntityId(entityId); tag.setCategory(category.name()); tag.setCreateAt(new Date()); tag.setCreateBy(SecurityContextUtils.getUserId()); tagList.add(tag); }); if (tagList.size() > 0) { saveBatch(tagList); } } @Override public void deleteTagByEntryId(String entityId) { remove(Wrappers.<Tag>lambdaQuery().eq(Tag::getEntityId, entityId)); } @Override public Set<String> selectTag(SelectTagRequest request) { QueryWrapper<Tag> queryWrapper = new QueryWrapper<>(); queryWrapper.select("DISTINCT name").eq("create_by", SecurityContextUtils.getUserId()) .like(request.getName() != null, "name", request.getName()).last("limit 20"); Set<String> tags = new HashSet<>(); list(queryWrapper).stream().filter(x -> x != null).forEach(x -> { tags.addAll(Arrays.asList(x.getName())); }); return tags; }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.uitls.ContextHelper;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.TemplateViewMapper;import cn.surveyking.server.domain.model.Repo;import cn.surveyking.server.domain.model.Template;import cn.surveyking.server.mapper.TemplateMapper;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.TemplateService;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.;import java.util.stream.Collectors;import static org.apache.commons.lang3.StringUtils.isNotEmpty;import static org.springframework.util.StringUtils.hasText;/** * @author javahuang * @date 2021/9/23 */@Service@Transactional@RequiredArgsConstructorpublic class TemplateServiceImpl extends BaseService<TemplateMapper, Template> implements TemplateService { private final TemplateViewMapper templateViewMapper; @Override public PaginationResponse<TemplateView> listTemplate(TemplateQuery query) { Page<Template> templatePage = pageByQuery(query, Wrappers.<Template>lambdaQuery() .like(isNotEmpty(query.getName()), Template::getName, query.getName()) .eq(query.getQuestionType() != null, Template::getQuestionType, query.getQuestionType()) // 默认查询额是普通题型 .ne(query.getQuestionType() == null, Template::getQuestionType, SurveySchema.QuestionType.Survey) .in(query.getCategories().size() > 0, Template::getCategory, query.getCategories()) .eq(query.getRepoId() != null, Template::getRepoId, query.getRepoId()) .eq(query.getMode() != null, Template::getMode, query.getMode()) .exists(query.getTag().size() > 0, String.format("select 1 from t_tag t where t.entity_id = t_template.id and t.name in (%s)", query.getTag().stream().map(x -> "'" + x + "'").collect(Collectors.joining(",")))) .eq(query.getShared() != null, Template::getShared, query.getShared()) .eq(query.getShared() != null && query.getShared() == 0, Template::getCreateBy, SecurityContextUtils.getUserId()) .eq(query.getShared() == null, Template::getCreateBy, SecurityContextUtils.getUserId()) .orderByAsc(Template::getPriority)); return new PaginationResponse<>(templatePage.getTotal(), templatePage.getRecords().stream().map(x -> templateViewMapper.toView(x)).collect(Collectors.toList())); } @Override public String addTemplate(TemplateRequest request) { Template template = templateViewMapper.fromRequest(request); save(template); return template.getId(); } @Override public void batchAddTemplate(List<TemplateRequest> templateRequests) { saveBatch(templateViewMapper.fromRequest(templateRequests)); } @Override public void batchUpdateTemplate(List<TemplateRequest> templateRequests) { updateBatchById(templateViewMapper.fromRequest(templateRequests)); } @Override public void updateTemplate(TemplateRequest request) { updateById(templateViewMapper.fromRequest(request)); } @Override public void deleteTemplate(TemplateRequest request) { removeBatchByIds(request.getIds()); } @Override public Map<String, List<TemplateView>> selectTemplate(SelectTemplateRequest request) { RepoServiceImpl repoService = ContextHelper.getBean(RepoServiceImpl.class); List<Repo> repos = repoService.list(Wrappers.<Repo>lambdaQuery().eq(Repo::getMode, request.getMode().name()) .and(x -> x.eq(Repo::getShared, 1).or(y -> y.eq(Repo::getCreateBy, SecurityContextUtils.getUserId())))); Map<String, List<TemplateView>> result = new LinkedHashMap<>(); repos.forEach(repo -> { List<TemplateView> templateViews = templateViewMapper .toView(list(Wrappers.<Template>lambdaQuery().eq(Template::getRepoId, repo.getId()))); result.put(repo.getName(), templateViews); }); return result; } public Set<String> listTemplateCategories(CategoryQuery query) { QueryWrapper<Template> queryWrapper = new QueryWrapper<>(); queryWrapper.select("DISTINCT category"); queryWrapper.like(hasText(query.getName()), "category", query.getName()); queryWrapper.eq("shared", query.getShared()); queryWrapper.eq("question_type", query.getQuestionType()); return list(queryWrapper).stream().filter(x -> x != null).map(x -> x.getCategory()).collect(Collectors.toSet()); } @Override public Set<String> getTags(TagQuery query) { Set<String> tags = new HashSet<>(); list(Wrappers.<Template>lambdaQuery().select(Template::getTag) .eq(Template::getQuestionType, SurveySchema.QuestionType.Survey) .eq(query.getShared() == 0, Template::getCreateBy, SecurityContextUtils.getUserId()) .eq(Template::getShared, query.getShared())).forEach(x -> { if (x.getTag() != null) { tags.addAll(Arrays.asList(x.getTag())); } }); return tags; }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.model.Template;import cn.surveyking.server.domain.model.UserBook;import cn.surveyking.server.mapper.UserBookMapper;import cn.surveyking.server.service.BaseService;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.service.IService;import lombok.RequiredArgsConstructor;import org.springframework.scheduling.annotation.Async;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.LinkedHashMap;import java.util.List;import java.util.stream.Collectors;/**/@Service@Transactional(rollbackFor = Exception.class)@RequiredArgsConstructorpublic class UserBookServiceImpl extends BaseService<UserBookMapper, UserBook> implements IService<UserBook> { private final TemplateServiceImpl templateService; / * 我的错题 / public static final Integer BOOK_TYPE_WRONG = 1; /* * 我的收藏 / public static final Integer BOOK_TYPE_FAVORITE = 2; /* * 保存错题 * @param questionScore */ @Async public void saveWrongQuestion(LinkedHashMap<String, Double> questionScore) { if (!SecurityContextUtils.isAuthenticated()) { return; } List<String> templateIds = questionScore.entrySet().stream() .filter(x -> x.getValue() != null && x.getValue() == 0).map(x -> x.getKey()) .collect(Collectors.toList()); List<UserBook> existUserBooks = list(Wrappers.<UserBook>lambdaQuery().in(UserBook::getTemplateId, templateIds) .eq(UserBook::getType, BOOK_TYPE_WRONG).eq(UserBook::getCreateBy, SecurityContextUtils.getUserId())); existUserBooks.stream().forEach(x -> x.setWrongTimes(x.getWrongTimes() + 1)); if (existUserBooks.size() > 0) { updateBatchById(existUserBooks); } List<String> existTemplateIds = existUserBooks.stream().map(x -> x.getTemplateId()) .collect(Collectors.toList()); List<String> notExistTemplateIds = templateIds.stream().filter(x -> !existTemplateIds.contains(x)) .collect(Collectors.toList()); if (notExistTemplateIds.size() > 0) { List<Template> templates = templateService.listByIds(notExistTemplateIds); saveBatch(templates.stream().map(x -> { UserBook userBook = new UserBook(); userBook.setWrongTimes(1); userBook.setTemplateId(x.getId()); userBook.setName(x.getName()); userBook.setType(BOOK_TYPE_WRONG); return userBook; }).collect(Collectors.toList())); } }}
package cn.surveyking.server.impl;import cn.surveyking.server.core.common.PaginationResponse;import cn.surveyking.server.core.constant.AppConsts;import cn.surveyking.server.core.constant.ErrorCode;import cn.surveyking.server.core.constant.ProjectModeEnum;import cn.surveyking.server.core.constant.ProjectPartnerTypeEnum;import cn.surveyking.server.core.exception.ErrorCodeException;import cn.surveyking.server.core.exception.InternalServerError;import cn.surveyking.server.core.security.PasswordEncoder;import cn.surveyking.server.core.uitls.ContextHelper;import cn.surveyking.server.core.uitls.PinyinUtils;import cn.surveyking.server.core.uitls.SecurityContextUtils;import cn.surveyking.server.domain.dto.;import cn.surveyking.server.domain.mapper.RoleViewMapper;import cn.surveyking.server.domain.mapper.UserPositionDtoMapper;import cn.surveyking.server.domain.mapper.UserViewMapper;import cn.surveyking.server.domain.model.;import cn.surveyking.server.mapper.;import cn.surveyking.server.service.BaseService;import cn.surveyking.server.service.ProjectPartnerService;import cn.surveyking.server.service.SystemService;import cn.surveyking.server.service.UserService;import com.anji.captcha.model.common.ResponseModel;import com.anji.captcha.model.vo.CaptchaVO;import com.anji.captcha.service.CaptchaService;import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;import com.baomidou.mybatisplus.core.toolkit.Wrappers;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import lombok.RequiredArgsConstructor;import lombok.SneakyThrows;import lombok.extern.slf4j.Slf4j;import org.dhatim.fastexcel.reader.ReadableWorkbook;import org.dhatim.fastexcel.reader.Row;import org.springframework.cache.annotation.CacheEvict;import org.springframework.cache.annotation.Cacheable;import org.springframework.dao.DuplicateKeyException;import org.springframework.security.access.AccessDeniedException;import org.springframework.security.core.GrantedAuthority;import org.springframework.security.core.userdetails.UsernameNotFoundException;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.util.CollectionUtils;import org.springframework.util.StringUtils;import javax.validation.ValidationException;import java.io.InputStream;import java.util.;import java.util.stream.Collectors;import java.util.stream.Stream;import static java.lang.String.format;import static org.apache.commons.lang3.StringUtils.isBlank;import static org.apache.commons.lang3.StringUtils.isNotBlank;/** * @author javahuang * @date 2021/8/24getCellValue /@Service@Transactional@RequiredArgsConstructor@Slf4jpublic class UserServiceImpl extends BaseService<UserMapper, User> implements UserService { private final AccountMapper accountMapper; private final PasswordEncoder passwordEncoder; private final RoleViewMapper roleViewMapper; private final UserViewMapper userViewMapper; private final UserRoleMapper userRoleMapper; private final RoleServiceImpl roleService; private final UserPositionMapper userPositionMapper; private final UserPositionDtoMapper userPositionDtoMapper; private final DeptMapper deptMapper; private final SystemService systemService; private final ProjectMapper projectMapper; private final CaptchaService captchaService; /* * @param username 账号密码登录认证使用 * @return * @throws UsernameNotFoundException */ @Override public UserInfo loadUserByUsername(String username) throws UsernameNotFoundException { LambdaQueryWrapper<Account> queryWrapper = Wrappers.<Account>lambdaQuery().eq(Account::getAuthAccount, username); Account existAccount = accountMapper.selectOne(queryWrapper); if (existAccount == null) { throw new UsernameNotFoundException(format("用户: {}, 不存在", username)); } if (existAccount.getStatus() != AppConsts.USER_STATUS.VALID) { throw new AccessDeniedException("用户: {}, 被禁用"); } return userViewMapper.toUserView(existAccount); } @Override @Cacheable(cacheNames = "userCache", key = "#p0", condition = "#p0!=null", unless = "#result == null") public UserInfo loadUserById(String userId) { User user = this.getById(userId); if (user == null) { return null; } UserInfo userInfo = userViewMapper.toUserInfo(user); List<Role> roles = userRoleMapper .selectList(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getUserId, user.getId())).stream() .map(ur -> roleService.getById(ur.getRoleId())).filter(x -> x != null).collect(Collectors.toList()); Set<String> authorities = new HashSet<>(); roles.forEach(role -> { authorities.add("ROLE_" + role.getCode()); Arrays.stream(role.getAuthority().split(",")).forEach(authority -> { authorities.add(authority); }); }); userInfo.setAuthorities( authorities.stream().map(authority -> (GrantedAuthority) () -> authority).collect(Collectors.toSet())); // 设置用户部门 if (user.getDeptId() != null) { Dept dept = deptMapper.selectById(user.getDeptId()); if (dept != null) { userInfo.setDeptName(dept.getName()); } } return userInfo; } @Override public PaginationResponse<UserView> getUsers(UserQuery query) { List<String> orgIds = getChildOrgIds(query.getDeptId()); Page<User> userPage = pageByQuery(query, Wrappers.<User>lambdaQuery().like(isNotBlank(query.getName()), User::getName, query.getName()) .exists(isNotBlank(query.getRoleId()), "select 1 from t_user_role t where t.user_id = t_user.id and t.role_id = {0}", query.getRoleId()) .notExists(isNotBlank(query.getNeRoleId()), "select 1 from t_user_role t where t.user_id = t_user.id and t.role_id = {0}", query.getNeRoleId()) .in(orgIds.size() > 0, User::getDeptId, orgIds).in(query.getIds() != null, User::getId, Arrays.asList(query.getIds() != null ? query.getIds() : new String[0]))); return new PaginationResponse<>(userPage.getTotal(), userPage.getRecords().stream().map(x -> { UserView userView = userViewMapper.toView(x); Account account = accountMapper .selectOne(Wrappers.<Account>lambdaQuery().eq(Account::getUserId, x.getId())); userView.setUsername(account.getAuthAccount()); userView.setStatus(account.getStatus()); // 设置用户部门 Dept dept = deptMapper.selectById(x.getDeptId()); if (dept != null) { userView.setDeptName(dept.getName()); } // 设置用户角色 userView.setRoles( userRoleMapper.selectList(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getUserId, x.getId())) .stream().map(userRole -> roleViewMapper.toView(roleService.getById(userRole.getRoleId()))) .collect(Collectors.toList())); // 设置用户岗位 userView.setUserPositions(userPositionDtoMapper.toView(userPositionMapper .selectList(Wrappers.<UserPosition>lambdaQuery().eq(UserPosition::getUserId, x.getId())))); return userView; }).collect(Collectors.toList())); } private List<String> getChildOrgIds(String parentOrgId) { List<String> result = new ArrayList<>(); if (parentOrgId == null) { return result; } result.add(parentOrgId); deptMapper.selectList(Wrappers.<Dept>lambdaQuery().eq(Dept::getParentId, parentOrgId)).forEach(dept -> { result.addAll(getChildOrgIds(dept.getId())); }); return result; } @Override public void createUser(UserRequest request) { User user = userViewMapper.fromRequest(request); this.save(user); // 创建登录账号 Account account = userViewMapper.toAccount(request); account.setAuthType(AppConsts.AUTH_TYPE.PWD.name()); account.setUserType(AppConsts.USER_TYPE.SysUser.toString()); account.setAuthSecret(passwordEncoder.encode(request.getPassword())); account.setUserId(user.getId()); account.setStatus(request.getStatus()); accountMapper.insert(account); // 添加用户角色 request.setId(user.getId()); addUserRoles(request); // 添加用户岗位 addUserPositions(request); } private void addUserRoles(UserRequest request) { if (!CollectionUtils.isEmpty(request.getRoles())) { request.getRoles().forEach(roleId -> { UserRole userRole = new UserRole(); userRole.setUserId(request.getId()); userRole.setRoleId(roleId); userRole.setUserType(AppConsts.USER_TYPE.SysUser.name()); userRoleMapper.insert(userRole); }); } } private void addUserPositions(UserRequest request) { if (!CollectionUtils.isEmpty(request.getUserPositions())) { request.getUserPositions().forEach(userPositionRequest -> { UserPosition userPosition = userPositionDtoMapper.fromRequest(userPositionRequest); userPosition.setUserId(request.getId()); userPositionMapper.insert(userPosition); }); } } @Override @CacheEvict(cacheNames = "userCache", key = "#request.id") public void updateUser(UserRequest request) { if (request.getId() == null) { return; } User user = userViewMapper.fromRequest(request); this.updateById(user); if (request.getStatus() != null \|\| isNotBlank(request.getPassword())) { // 更新登录账号 Account account = accountMapper .selectOne(Wrappers.<Account>lambdaQuery().eq(Account::getUserId, request.getId())); if (isNotBlank(request.getPassword()) && isNotBlank(request.getOldPassword())) { if (!passwordEncoder.matches(request.getOldPassword(), account.getAuthSecret())) { throw new InternalServerError("密码验证失败"); } } if (request.getUsername() != null) { account.setAuthAccount(request.getUsername()); } if (request.getStatus() != null) { account.setStatus(request.getStatus()); } if (isNotBlank(request.getPassword())) { account.setAuthSecret(passwordEncoder.encode(request.getPassword())); } accountMapper.updateById(account); } // 更新用户角色 if (request.getRoles() != null) { userRoleMapper.delete(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getUserId, request.getId())); addUserRoles(request); } // 更新用户岗位 if (request.getUserPositions() != null) { userPositionMapper .delete(Wrappers.<UserPosition>lambdaQuery().eq(UserPosition::getUserId, request.getId())); addUserPositions(request); } } @Override @CacheEvict(cacheNames = "userCache", key = "#id") public void deleteUser(String id) { removeById(id); accountMapper.delete(Wrappers.<Account>lambdaQuery().eq(Account::getUserId, id)); } @Override public boolean checkUsernameExist(String username) { Account account = accountMapper .selectOne(Wrappers.<Account>lambdaQuery().eq(Account::getAuthAccount, username)); if (account != null) { return true; } return false; } @Override public void updateUserPosition(UserRequest request) { userPositionMapper .delete(Wrappers.<UserPosition>lambdaQuery().eq(UserPosition::getPositionId, request.getId())); if (!CollectionUtils.isEmpty(request.getUserPositions())) { request.getUserPositions().forEach(userPositionRequest -> { UserPosition position = userPositionDtoMapper.fromRequest(userPositionRequest); position.setUserId(request.getId()); userPositionMapper.insert(position); }); } } @Override public Set<String> getUserGroups(String userId) { Set<String> groups = new LinkedHashSet<>(); // 获取用户的系统角色 userRoleMapper.selectList(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getUserId, userId)).forEach(role -> { groups.add("R:" + role.getRoleId()); }); // 获取用户的用户岗位 userPositionMapper.selectList(Wrappers.<UserPosition>lambdaQuery().eq(UserPosition::getUserId, userId)) .forEach(userPosition -> { groups.add("P:" + userPosition.getDeptId() + ":" + userPosition.getPositionId()); groups.add("P:" + "ALL:" + userPosition.getPositionId()); groups.add("P:" + userPosition.getDeptId() + ":ALL"); }); // User current = getById(userId); groups.add("U:" + userId); // groups.add("P:" + current.getOrgId() + ":"); return groups; } @Override public Set<String> getUsersByGroup(String groupId, String currentUser) { // 获取角色下面的所有用户 if (groupId.startsWith("R:")) { return userRoleMapper .selectList(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getRoleId, groupId.split(":")[1])) .stream().map(x -> x.getUserId()).collect(Collectors.toSet()); } if (groupId.startsWith("P:")) { String[] orgAndPositionId = groupId.split(":"); String orgId = orgAndPositionId[1], positionId = orgAndPositionId[2]; if (orgId.contains(AppConsts.VARIABLE_CURRENT_ORG_ID)) { orgId = loadUserById(currentUser).getDeptId(); } else if (orgId.contains(AppConsts.VARIABLE_PARENT_ORG_ID)) { orgId = loadUserById(currentUser).getDeptId(); orgId = deptMapper.selectById(orgId).getParentId(); } return userPositionMapper .selectList(Wrappers.<UserPosition>lambdaQuery() .eq(StringUtils.hasText(orgId), UserPosition::getDeptId, orgId) .eq(StringUtils.hasText(positionId), UserPosition::getPositionId, positionId)) .stream().map(up -> up.getUserId()).collect(Collectors.toSet()); } return Collections.EMPTY_SET; } @Override public List<UserInfo> selectUsers(SelectUserRequest request) { List<String> list = new ArrayList<>(); if (request.getDeptId() != null) { list.add(request.getDeptId()); this.getTreeDeptId(request.getDeptId(), list); } List<User> users = list(Wrappers.<User>lambdaQuery().select(User::getId) .in(StringUtils.hasText(request.getDeptId()), User::getDeptId, list) .like(StringUtils.hasText(request.getName()), User::getName, request.getName())); return Stream.concat(users.stream().map(user -> user.getId()), request.getSelected().stream()) .collect(Collectors.toSet()).stream() .map(userId -> ContextHelper.getBean(UserService.class).loadUserById(userId).simpleMode()) .collect(Collectors.toList()); } private void getTreeDeptId(String deptId, List<String> list) { List<Dept> deptList = deptMapper.selectList(Wrappers.<Dept>lambdaQuery().eq(Dept::getParentId, deptId)); Optional.ofNullable(deptList).map(List::stream).orElseGet(Stream::empty).forEach(info -> { list.add(info.getId()); this.getTreeDeptId(info.getId(), list); }); } @Override public void register(RegisterRequest request) { SystemInfo systemInfo = systemService.getSystemInfo(); SystemInfo.RegisterInfo registerInfo = systemInfo.getRegisterInfo(); if (registerInfo == null \|\| !Boolean.TRUE.equals(registerInfo.getRegisterEnabled())) { throw new ErrorCodeException(ErrorCode.RegisterError); } long total = accountMapper .selectCount(Wrappers.<Account>lambdaQuery().eq(Account::getAuthAccount, request.getUsername())); if (total > 0) { throw new ErrorCodeException(ErrorCode.UsernameExists); } UserRequest createUserRequest = new UserRequest(); createUserRequest.setUsername(request.getUsername()); createUserRequest.setPassword(request.getPassword()); createUserRequest.setName(request.getName()); createUserRequest.setStatus(AppConsts.USER_STATUS.VALID); String role = request.getRole(); if (role != null) { if (!registerInfo.getRoles().contains(role)) { throw new ErrorCodeException(ErrorCode.RegisterError); } createUserRequest.setRoles(Collections.singletonList(request.getRole())); } else if (registerInfo.getRoles().size() > 0) { createUserRequest.setRoles(registerInfo.getRoles()); } createUser(createUserRequest); } @Override public List<RegisterRoleView> getRegisterRoles() { List<String> defaultRegisterRoleCodes = systemService.getSystemInfo().getRegisterInfo().getRoles(); if (defaultRegisterRoleCodes.size() > 0) { return roleService.listByIds(systemService.getSystemInfo().getRegisterInfo().getRoles()).stream() .map(role -> { RegisterRoleView roleView = new RegisterRoleView(); roleView.setId(role.getId()); roleView.setName(role.getName()); return roleView; }).collect(Collectors.toList()); } return new ArrayList<>(); } @Override public UserOverview getUserOverviewData() { UserOverview userOverview = new UserOverview(); ProjectPartnerServiceImpl partnerService = (ProjectPartnerServiceImpl) ContextHelper .getBean(ProjectPartnerService.class); userOverview.setSurveyCount(partnerService.count(Wrappers.<ProjectPartner>lambdaQuery() .in(ProjectPartner::getType, Arrays.asList(ProjectPartnerTypeEnum.OWNER.getType(), ProjectPartnerTypeEnum.COLLABORATOR.getType())) .eq(ProjectPartner::getUserId, SecurityContextUtils.getUserId()) .exists(String.format( "SELECT 1 FROM t_project t WHERE t.mode = '%s' AND t.id = t_project_partner.project_id", ProjectModeEnum.survey.name())))); userOverview.setExamCount(partnerService.count(Wrappers.<ProjectPartner>lambdaQuery() .in(ProjectPartner::getType, Arrays.asList(ProjectPartnerTypeEnum.OWNER.getType(), ProjectPartnerTypeEnum.COLLABORATOR.getType())) .eq(ProjectPartner::getUserId, SecurityContextUtils.getUserId()) .exists(String.format( "SELECT 1 FROM t_project t WHERE t.mode = '%s' AND t.id = t_project_partner.project_id", ProjectModeEnum.exam.name())))); return userOverview; } @Override @SneakyThrows public void importUser(UserRequest request) { Map<String, String> roleName2Id = roleService.list().stream() .collect(Collectors.toMap(Role::getName, Role::getId)); Map<String, String> deptName2Id = deptMapper.selectList(null).stream() .collect(Collectors.toMap(Dept::getName, Dept::getId)); try (InputStream is = request.getFile().getInputStream(); ReadableWorkbook wb = new ReadableWorkbook(is)) { wb.getSheets().forEach(sheet -> { int[] rowNum = { 1 }; try (Stream<Row> rows = sheet.openStream()) { rows.forEach(r -> { if (r.getRowNum() == 1) { return; } rowNum[0] = r.getRowNum(); UserRequest userRequest = new UserRequest(); userRequest.setName( getCellValue(r, 0).orElseThrow(() -> new ErrorCodeException(ErrorCode.FileParseError))); // 自动根据用户名设置登录名 // 登录名可能有重复，通过唯一索引抛异常由用户自己控制 userRequest.setUsername( getCellValue(r, 1).orElse(PinyinUtils.chineseToPinyin(userRequest.getName()))); // 默认密码为 123456 userRequest.setPassword(getCellValue(r, 2).orElse("123456")); userRequest.setPhone(r.getCellAsString(3).orElse(null)); userRequest.setEmail(r.getCellAsString(4).orElse(null)); String deptName = r.getCellAsString(5).orElse(null); if (deptName != null && deptName2Id.containsKey(deptName)) { userRequest.setDeptId(deptName2Id.get(deptName)); } String roles = r.getCellAsString(6).orElse(null); if (roles != null) { List<String> roleIds = Arrays.stream(roles.split(",\|\\s+")).filter(roleName2Id::containsKey) .map(roleName2Id::get).collect(Collectors.toList()); userRequest.setRoles(roleIds); } createUser(userRequest); }); } catch (Exception e) { if (e instanceof DuplicateKeyException) { throw new InternalServerError(String.format("模板第%d行用户已存在", rowNum[0]), e); } throw new InternalServerError(String.format("模板第%d行解析失败", rowNum[0]), e); } }); } } @Override public PaginationResponse<MyTaskView> queryTask(MyTaskQuery query) { Page<ProjectPartner> page = ContextHelper.getBean(ProjectPartnerServiceImpl.class).pageByQuery(query, Wrappers .<ProjectPartner>lambdaQuery().eq(ProjectPartner::getUserId, SecurityContextUtils.getUserId()) .ne(ProjectPartner::getStatus, AppConsts.ProjectPartnerStatus.ANSWERED) .eq(ProjectPartner::getType, ProjectPartnerTypeEnum.RESPONDENT_SYS_USER.getType()) .exists("SELECT 1 FROM t_project t WHERE t.mode = {0} AND t.id = t_project_partner.project_id And t.is_deleted = 0", query.getType()) .orderByAsc(ProjectPartner::getStatus).orderByDesc(ProjectPartner::getCreateAt)); PaginationResponse<MyTaskView> result = new PaginationResponse<>(page.getTotal(), page.getRecords().stream().map(projectPartner -> { MyTaskView taskView = new MyTaskView(); Project project = projectMapper.selectById(projectPartner.getProjectId()); taskView.setId(projectPartner.getId()); taskView.setProjectId(projectPartner.getProjectId()); taskView.setName(project.getName()); taskView.setStatus(projectPartner.getStatus()); taskView.setExamStartTime(project.getSetting().getExamSetting().getStartTime()); taskView.setExamEndTime(project.getSetting().getExamSetting().getEndTime()); return taskView; }).collect(Collectors.toList())); return result; } @Override public PaginationResponse<MyTaskView> queryHistoryTask(MyTaskQuery query) { Page<Answer> page = new Page<>(query.getCurrent(), query.getPageSize()); ContextHelper.getBean(AnswerServiceImpl.class).page(page, Wrappers.<Answer>lambdaQuery().eq(Answer::getCreateBy, SecurityContextUtils.getUserId()).exists( "SELECT 1 FROM t_project t WHERE t.mode = {0} AND t.id = t_answer.project_id And t.is_deleted = 0", query.getType()).orderByDesc(Answer::getCreateAt)); if (page.getTotal() == 0) { return new PaginationResponse<>(0l, new ArrayList<>()); } List<Project> projectList = projectMapper.selectList(Wrappers.<Project>lambdaQuery().in(Project::getId, page.getRecords().stream().map(x -> x.getProjectId()).collect(Collectors.toSet()))); PaginationResponse<MyTaskView> result = new PaginationResponse<>(page.getTotal(), page.getRecords().stream().map(answer -> { MyTaskView taskView = new MyTaskView(); taskView.setId(answer.getId()); taskView.setAnswerId(answer.getId()); Project project = projectList.stream().filter(x -> x.getId().equals(answer.getProjectId())) .findFirst().orElse(null); if (project != null) { taskView.setProjectId(project.getId()); taskView.setName(project.getName()); if (ProjectModeEnum.exam.equals(project.getMode())) { taskView.setExamScore(answer.getExamScore()); taskView.setExamTotal(project.getSurvey().getAttribute().getExamScore()); } } try { taskView.setStartTime(answer.getMetaInfo().getAnswerInfo().getStartTime()); taskView.setEndTime(answer.getMetaInfo().getAnswerInfo().getEndTime()); } catch (Exception e) { // ignore error } return taskView; }).collect(Collectors.toList())); return result; } @Override public void validateCaptcha(AuthRequest request) { SystemInfo systemInfo = systemService.getSystemInfo(); if (systemInfo.getSetting() != null && Boolean.TRUE.equals(systemInfo.getSetting().getCaptchaEnabled())) { // 验证码已开启 CaptchaVO captchaVO = new CaptchaVO(); captchaVO.setCaptchaVerification(request.getCaptchaVerification()); ResponseModel response = captchaService.verification(captchaVO); if (response.isSuccess() == false) { // 验证码校验失败，返回信息告诉前端 // repCode 0000 无异常，代表成功 // repCode 9999 服务器内部异常 // repCode 0011 参数不能为空 // repCode 6110 验证码已失效，请重新获取 // repCode 6111 验证失败 // repCode 6112 获取验证码失败,请联系管理员 // repCode 6113 底图未初始化成功，请检查路径 // repCode 6201 get接口请求次数超限，请稍后再试! // repCode 6206 无效请求，请重新获取验证码 // repCode 6202 接口验证失败数过多，请稍后再试 // repCode 6204 check接口请求次数超限，请稍后再试! throw new ValidationException(response.getRepMsg()); } } } private Optional<String> getCellValue(Row row, int cellIndex) { String cellValue = row.getCellAsString(cellIndex).orElse(null); if (isBlank(cellValue)) { return Optional.empty(); } return Optional.of(cellValue); }}
package cn.surveyking.server.core.annotation;import cn.surveyking.server.core.constant.AppConsts;import java.lang.annotation.;/* * * @author javahuang * @date 2022/1/30 /@Target({ ElementType.METHOD })@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface EnableDataPerm { String key() default ""; /* * 权限类型，根据项目来区分权限 * @return / String permType() default AppConsts.PermType.PROJECT; /* * 默认通过 url 来获取 * @return */ String permFrom() default "";}
package cn.surveyking.server.core.aop;import cn.surveyking.server.core.annotation.EnableDataPerm;import cn.surveyking.server.core.exception.InternalServerError;import cn.surveyking.server.service.ProjectPartnerService;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;import org.aspectj.lang.reflect.MethodSignature;import org.springframework.expression.EvaluationContext;import org.springframework.expression.spel.standard.SpelExpressionParser;import org.springframework.expression.spel.support.StandardEvaluationContext;import org.springframework.stereotype.Component;import org.springframework.util.StringUtils;import java.util.Arrays;import java.util.List;/** * 校验校验权限 * * @author javahuang * @date 2022/1/30 */@Aspect@Component@Slf4j@RequiredArgsConstructorpublic class DataPermAspect { private final ProjectPartnerService projectPartnerService; private SpelExpressionParser spelParser = new SpelExpressionParser(); @Pointcut("@annotation(dataPerm)") public void checkPermissionPointCut(EnableDataPerm dataPerm) { } @Before("checkPermissionPointCut(dataPerm)") public void around(JoinPoint joinPoint, EnableDataPerm dataPerm) throws Throwable { // 获取方法参数名和值 MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature(); List<String> paramNameList = Arrays.asList(methodSignature.getParameterNames()); List<Object> paramList = Arrays.asList(joinPoint.getArgs()); EvaluationContext ctx = new StandardEvaluationContext(); for (int i = 0; i < paramNameList.size(); i++) { ctx.setVariable(paramNameList.get(i), paramList.get(i)); } String value = spelParser.parseExpression(dataPerm.key()).getValue(ctx).toString(); if (!StringUtils.hasText(value)) { throw new InternalServerError("未找到对应的问卷"); } List<String> projectPerms = projectPartnerService.getProjectPerms(); if (!projectPerms.contains(value)) { throw new InternalServerError("没有权限访问本问卷"); } }}
package cn.surveyking.server.core.base.converter;import cn.surveyking.server.core.uitls.MapBeanUtils;import cn.surveyking.server.domain.dto.ProjectSetting;import lombok.SneakyThrows;import org.springframework.core.convert.converter.Converter;import java.util.LinkedHashMap;/** * @author javahuang * @date 2022/5/15 */public class PublicQueryConverter implements Converter<LinkedHashMap<String, ?>, ProjectSetting.PublicQuery> { @Override @SneakyThrows public ProjectSetting.PublicQuery convert(LinkedHashMap<String, ?> value) { return MapBeanUtils.mapToBean(value, ProjectSetting.PublicQuery.class); }}
package cn.surveyking.server.core.base.converter;import cn.surveyking.server.core.uitls.MapBeanUtils;import cn.surveyking.server.domain.dto.ProjectSetting;import lombok.SneakyThrows;import org.springframework.core.convert.converter.Converter;import java.util.LinkedHashMap;/** * @author javahuang * @date 2022/5/15 */public class RandomSurveyConverter implements Converter<LinkedHashMap<String, Object>, ProjectSetting.RandomSurveyCondition> { @Override @SneakyThrows public ProjectSetting.RandomSurveyCondition convert(LinkedHashMap<String, Object> value) { Object examScore = value.get("examScore"); // 将 Integer/Double 统一转换为 Double if (examScore != null && examScore instanceof Integer) { value.put("examScore", ((Integer) examScore).doubleValue()); } return MapBeanUtils.mapToBean(value, ProjectSetting.RandomSurveyCondition.class); }}
package cn.surveyking.server.core.base.converter;import cn.surveyking.server.core.constant.AnswerFreqEnum;import cn.surveyking.server.domain.dto.ProjectSetting;import org.springframework.core.convert.converter.Converter;import java.util.LinkedHashMap;/** * spel converter * * @author javahuang * @date 2022/2/28 */public class UniqueLimitSettingConverter implements Converter<LinkedHashMap<?, ?>, ProjectSetting.UniqueLimitSetting> { @Override public ProjectSetting.UniqueLimitSetting convert(LinkedHashMap<?, ?> value) { Integer limitNum = (Integer) value.get("limitNum"); String limitFreq = (String) value.get("limitFreq"); return new ProjectSetting.UniqueLimitSetting(limitNum, AnswerFreqEnum.valueOf(limitFreq)); }}
package cn.surveyking.server.core.base.mapper;import cn.surveyking.server.core.uitls.ContextHelper;import com.fasterxml.jackson.databind.ObjectMapper;import org.springframework.util.CollectionUtils;import java.util.LinkedList;import java.util.List;import java.util.Map;import java.util.stream.Collectors;/** * Model对象到Domain类型对象的相互转换。实现类通常声明在Model实体类中。 * * @param <R> Request请求实体对象，通常用于新增和修改。 * @param <V> View视图对象。 * @param <M> Model数据库实体对象类型。 * @author Jerry * @date 2021-06-06 /public interface BaseModelMapper<R, V, M> { /* * 将请求转换成 Model 实体对象。 * @param request Model实体对象。 * @return Domain域对象。 / M fromRequest(R request); List<M> fromRequest(List<R> requestList); /* * 转换Model实体对象到视图对象。 * @param model model 对象。 * @return View视图对象。 / V toView(M model); List<V> toView(List<M> modelList); /* * 转换bean到map * @param bean bean对象。 * @return 转换后的map对象。 / default Map<String, Object> beanToMap(Object bean) { ObjectMapper om = ContextHelper.getBean(ObjectMapper.class); return om.convertValue(bean, Map.class); } /* * 转换bean集合到map集合 * @param dataList bean对象集合。 * @param <T> bean类型。 * @return 转换后的map对象集合。 / default <T> List<Map<String, Object>> beanToMap(List<T> dataList) { if (CollectionUtils.isEmpty(dataList)) { return new LinkedList<>(); } return dataList.stream().map(this::beanToMap).collect(Collectors.toList()); } /* * 转换map到bean。 * @param map map对象。 * @param beanClazz bean的Class对象。 * @param <T> bean类型。 * @return 转换后的bean对象。 / default <T> T mapToBean(Map<String, Object> map, Class<T> beanClazz) { ObjectMapper om = ContextHelper.getBean(ObjectMapper.class); return om.convertValue(map, beanClazz); } /* * 转换map集合到bean集合。 * @param mapList map对象集合。 * @param beanClazz bean的Class对象。 * @param <T> bean类型。 * @return 转换后的bean对象集合。 / default <T> List<T> mapToBean(List<Map<String, Object>> mapList, Class<T> beanClazz) { if (CollectionUtils.isEmpty(mapList)) { return new LinkedList<>(); } return mapList.stream().map(m -> mapToBean(m, beanClazz)).collect(Collectors.toList()); } /* * 对于Map字段到Map字段的映射场景，MapStruct会根据方法签名自动选择该函数作为对象copy的函数。由于该函数是直接返回的，因此没有对象copy，效率更高。 * 如果没有该函数，MapStruct会生成如下代码： Map<String, Object> map = * courseDto.getTeacherIdDictMap(); if ( map != null ) { course.setTeacherIdDictMap( * new HashMap<String, Object>( map ) ); } * @param map map对象。 * @return 直接返回的map。 */ default Map<String, Object> mapToMap(Map<String, Object> map) { return map; }}
package cn.surveyking.server.core.cache;import org.springframework.cache.interceptor.KeyGenerator;import org.springframework.stereotype.Component;import java.lang.reflect.Method;/** * @author javahuang * @date 2022/2/8 */@Component("deptKeyGenerator")public class DeptKeyGenerator implements KeyGenerator { @Override public Object generate(Object target, Method method, Object... params) { if (params[0] == null) { return "all"; } return "some"; }}
package cn.surveyking.server.core.common;import cn.surveyking.server.core.uitls.JSONUtil;import lombok.Data;/** * @author javahuang * @date 2021/8/6 */@Datapublic class ApiResponse<T> { private int code; private String message; private T data; public ApiResponse() { } public ApiResponse(int code, T data) { this.code = code; this.data = data; } public ApiResponse(int code, String message) { this.code = code; this.message = message; } @Override public String toString() { return JSONUtil.toJSONString(this); }}
package cn.surveyking.server.core.common;import lombok.Data;import java.util.List;/** * @author javahuang * @date 2021/10/6 */@Datapublic class PaginationResponse<T> { private Long total; private List<T> list; private Integer current; private Integer pageSize; public PaginationResponse(Long total, List<T> list) { this.total = total; this.list = list; }}
package cn.surveyking.server.core.common;/** * 二元组对象，用于返回多个值场景 * * @author javahuang * @date 2022/2/28 */public class Tuple2<T1, T2> { private final T1 first; private final T2 second; public Tuple2(T1 first, T2 second) { this.first = first; this.second = second; } public T1 getFirst() { return first; } public T2 getSecond() { return second; }}
package cn.surveyking.server.core.config;import cn.surveyking.server.core.base.converter.PublicQueryConverter;import cn.surveyking.server.core.base.converter.RandomSurveyConverter;import cn.surveyking.server.core.base.converter.UniqueLimitSettingConverter;import cn.surveyking.server.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.context.event.ApplicationReadyEvent;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.EnableAspectJAutoProxy;import org.springframework.context.event.EventListener;import org.springframework.core.convert.support.DefaultConversionService;import org.springframework.scheduling.annotation.AsyncConfigurer;import org.springframework.scheduling.annotation.EnableAsync;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import java.util.concurrent.Executor;/** * @author javahuang * @date 2021/10/19 /@Configuration@EnableAspectJAutoProxy@EnableAsyncpublic class AppConfig implements AsyncConfigurer { private UserService userService; @Autowired public void setUserService(UserService userService) { this.userService = userService; } /* * 一些初始化操作 */ @EventListener(ApplicationReadyEvent.class) public void initAfterStartup() { // userService.init(); DefaultConversionService defaultConversionService = (DefaultConversionService) DefaultConversionService .getSharedInstance(); defaultConversionService.addConverter(new UniqueLimitSettingConverter()); defaultConversionService.addConverter(new PublicQueryConverter()); defaultConversionService.addConverter(new RandomSurveyConverter()); } @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(4); executor.setMaxPoolSize(8); executor.setThreadNamePrefix("MyExecutor-"); executor.initialize(); return executor; }}
package cn.surveyking.server.core.config;import com.github.benmanes.caffeine.cache.Caffeine;import com.github.benmanes.caffeine.cache.Expiry;import org.checkerframework.checker.index.qual.NonNegative;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.cache.Cache;import org.springframework.cache.CacheManager;import org.springframework.cache.annotation.CachingConfigurerSupport;import org.springframework.cache.annotation.EnableCaching;import org.springframework.cache.concurrent.ConcurrentMapCache;import org.springframework.cache.concurrent.ConcurrentMapCacheManager;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import java.time.Duration;import java.util.Map;import java.util.stream.Collectors;/** * 使用 caffeine 自定义 cache，允许针对每个 cacheName 设置单独的 expireTime * * @author javahuang * @date 2021/9/8 */@Configuration@EnableCaching@ConfigurationProperties("custom-cache")public class CacheConfig extends CachingConfigurerSupport { private Map<String, Duration> entries; @Bean @Override public CacheManager cacheManager() { ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager() { @Override protected Cache createConcurrentMapCache(final String name) { return new ConcurrentMapCache(name, Caffeine.newBuilder().expireAfter(new Expiry<Object, Object>() { @Override public long expireAfterCreate(Object key, Object value, long currentTime) { return entries.get(name).toNanos(); } @Override public long expireAfterUpdate(Object key, Object value, long currentTime, @NonNegative long currentDuration) { return currentDuration; } @Override public long expireAfterRead(Object key, Object value, long currentTime, @NonNegative long currentDuration) { return currentDuration; } }).maximumSize(100).build().asMap(), false); } }; cacheManager.setCacheNames(entries.entrySet().stream().map(x -> x.getKey()).collect(Collectors.toList())); return cacheManager; } public Map<String, Duration> getEntries() { return entries; } public void setEntries(Map<String, Duration> entries) { this.entries = entries; }}
package cn.surveyking.server.core.config;import com.fasterxml.jackson.databind.ObjectMapper;import lombok.RequiredArgsConstructor;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Configuration;import org.springframework.core.io.Resource;import org.springframework.http.ResponseEntity;import org.springframework.http.converter.HttpMessageConverter;import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;import java.util.List;/** * @author javahuang * @date 2021/8/11 /@Configuration@RequiredArgsConstructor@RestControllerpublic class WebConfig implements WebMvcConfigurer { private final ObjectMapper objectMapper; @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { // 允许 controller 直接返回 string converters.add(0, new MappingJackson2HttpMessageConverter(objectMapper)); } @Value("classpath:/static/index.html") private Resource indexHtml; // 匹配类型的静态资源都会被 ResourceHandler 来处理 public static final String[] STATIC_RESOURCES = { "//.css", "/*/.js", "/*/.jpg", "/*/.png", "/*/.svg", // 图片 "/*/.eot", "/*/.ttf", "/*/.woff", "/*/favicon.ico" }; @Override public void addResourceHandlers(ResourceHandlerRegistry registry) { registry.setOrder(-1) // 设置静态资源映射优先级高于下面配置的 @GetMapping .addResourceHandler(STATIC_RESOURCES).addResourceLocations("classpath:/static/") .setCachePeriod(3600 24); } /** * @return */ @GetMapping public Object index() { return ResponseEntity.ok().body(indexHtml); }}
package cn.surveyking.server.core.config;import cn.surveyking.server.core.security.JwtTokenFilter;import cn.surveyking.server.core.security.RestAuthenticationEntryPoint;import cn.surveyking.server.service.UserService;import org.springframework.boot.context.properties.ConfigurationProperties;import org.springframework.context.annotation.Bean;import org.springframework.http.HttpMethod;import org.springframework.security.authentication.AuthenticationManager;import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;import org.springframework.security.config.annotation.web.builders.HttpSecurity;import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;import org.springframework.security.config.http.SessionCreationPolicy;import org.springframework.security.core.context.SecurityContextHolder;import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;import org.springframework.web.cors.CorsConfiguration;import org.springframework.web.cors.UrlBasedCorsConfigurationSource;import org.springframework.web.filter.CorsFilter;/** * @author javahuang * @date 2021/8/6 /@EnableWebSecurity@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)@ConfigurationProperties("sk.security")public class WebSecurityConfig extends WebSecurityConfigurerAdapter { /* * 开启 url token 认证 / private final UrlTokenAuthentication urlTokenAuthentication = new UrlTokenAuthentication(); private final JwtTokenFilter jwtTokenFilter; private final UserService userService; private final RestAuthenticationEntryPoint authenticationEntryPoint; public WebSecurityConfig(JwtTokenFilter jwtTokenFilter, UserService userService, RestAuthenticationEntryPoint authenticationEntryPoint) { this.jwtTokenFilter = jwtTokenFilter; this.userService = userService; this.authenticationEntryPoint = authenticationEntryPoint; // 允许在 @Async 方法里面获取 SecurityContext SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_INHERITABLETHREADLOCAL); } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(username -> userService.loadUserByUsername(username)); // 添加更多类型的认证方式 auth.authenticationProvider(); } @Override public void configure(HttpSecurity http) throws Exception { // 设置允许 iframe 引用 http.headers().frameOptions().disable(); http = http.cors().and().csrf().disable(); http = http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and(); http = http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint).and(); // 所有请求都放行，目的是单 jar 部署，输入任意路由也能跳转到对应的页面，权限拦截通过注解配置 http.authorizeRequests().antMatchers("/api/public/").permitAll().antMatchers("/api/system").permitAll() .antMatchers("/captcha/get", "/captcha/check").permitAll().antMatchers(HttpMethod.GET, "/api/file/") .permitAll().antMatchers("/api/").authenticated().antMatchers("/").permitAll(); http.addFilterBefore(jwtTokenFilter, UsernamePasswordAuthenticationFilter.class); } @Bean public CorsFilter corsFilter() { UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(); CorsConfiguration config = new CorsConfiguration(); config.setAllowCredentials(true); config.addAllowedOriginPattern(""); config.addAllowedHeader(""); config.addAllowedMethod(""); source.registerCorsConfiguration("/", config); return new CorsFilter(source); } // Expose authentication manager bean @Override @Bean public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } // Remove the default ROLE_ prefix // @Bean // public GrantedAuthorityDefaults grantedAuthorityDefaults() { // return new GrantedAuthorityDefaults(""); // } public UrlTokenAuthentication getUrlTokenAuthentication() { return urlTokenAuthentication; } public static class UrlTokenAuthentication { / * 是否开启 token 认证 */ private boolean enabled = true; public boolean isEnabled() { return this.enabled; } public void setEnabled(boolean enabled) { this.enabled = enabled; } }}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2022/2/27 /public enum AnswerFreqEnum { only(""), /* 小时 / hour("0 0 * * "), /* 天 / day("0 0 0 1-31 "), /* 星期 / week("0 0 0 1-31 1-12 1"), /* 月 / month("0 0 0 1 "), /* 季度 / quarter("0 0 0 1 /3 "), /* 年 / year("0 0 0 1 1 "); private String cron; AnswerFreqEnum(String cron) { this.cron = cron; } public String getCron() { return cron; }}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2021/8/6 /public class AppConsts { /* * token name / public static final String TOKEN_NAME = "sk-token"; /* * / public static final String COOKIE_LIMIT_NAME = "sk-limit"; /* * 随机问卷答案 ID 前缀 / public static final String COOKIE_RANDOM_PROJECT_PREFIX = "rd_answer_id_"; /* * 支持的图片类型 / public static final String[] SUPPORT_IMAGE_TYPE = { "JPG", "JPEG", "PNG", "GIF", "BMP", "WBMP" }; /* * 逻辑删除列名 / public static final String COLUMN_IS_DELETED = "is_deleted"; public static final String ROLE_ADMIN = "ROLE_admin"; /* * 匿名用户 ID / public static final String ANONYMOUS_USER_ID = "guest"; /* * 当前机构 ID 变量名 / public static final String VARIABLE_CURRENT_ORG_ID = "currentOrgId"; /* * 父机构 ID 变量名 / public static final String VARIABLE_PARENT_ORG_ID = "parentOrgId"; /* * 项目状态，运行 / public static final Integer PROJECT_STATUS_RUNNING = 1; /* * 项目状态，暂停 / public static final Integer PROJECT_STATUS_SUSPEND = 0; /* * 公开查询密码校验字段名称 / public static final String PUBLIC_QUERY_PASSWORD_FIELD_ID = "password"; /* * 存储的文件类型 TODO: 文件添加权限控制 / public interface FileType { /* 背景图片 / int BACKGROUND_IMAGE = 1; /* 顶部图片 / int HEADER_IMAGE = 2; /* 问题图片 / int QUESTION_IMAGE = 3; /* 答卷附件 / int ANSWER_ATTACHMENT = 4; /* 问题模板预览图 / int TEMPLATE_PREVIEW_IMAGE = 5; /* 条码图片 / int BARCODE = 6; } /* * 字典编码 - 权限类型 / public enum DICTCODE_PERMISSION_TYPE { MENU, OPERATION, OTHER } /* * 前端权限类型 / public enum RESOURCE_PERMISSION_DISPLAY_TYPE { MODULE, MENU, PERMISSION } public enum AUTH_TYPE { PWD } public enum USER_TYPE { /* 系统用户 / SysUser } public interface USER_STATUS { /* 正常用户 / int VALID = 1; /* 失活用户 / int INVALID = 0; } /* * 岗位对应的数据权限 / public enum DataPermissionTypeEnum { /* 本人、本人及下属、本部门、本部门及下属部门、全部 / SELF, SELF_AND_SUB, DEPT, DEPT_AND_SUB, ALL; } /* * 下载文件方式 / public enum DispositionTypeEnum { /* * 预览 / inline, /* * 附件方式下载 / attachment } /* * 仪表盘类型 / public interface DashboardType { /* 首页 / int HOMEPAGE = 1; /* 项目概要页面 / int PROJECT_OVERVIEW = 2; } public interface PermType { String PROJECT = "project"; } /* * 项目参与者状态 / public interface ProjectPartnerStatus { /* * 未访问 / int UNVISITED = 0; /* * 已访问 / int VISITED = 1; /* * 已答题 */ int ANSWERED = 2; static String getStatusStr(int status) { if (status == VISITED) { return "已访问"; } else if (status == ANSWERED) { return "已答题"; } else { return "未访问"; } } }}
package cn.surveyking.server.core.constant;/** * 附件命名变量 * @author javahuang * @date 2022/4/11 /public enum AttachmentNameVariableEnum { /* 项目id / projectId, /* 所有的附件从1开始编号 / serialNum, /* 同一个问卷内附件从1开始编号 / serialNumInAnswer, /* 上传日期 / uploadDate, /* 上传日期时间 / uploadDateTime, /* 原始文件名 / sourceName, /* 问题标题 */ questionTitle}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2021/10/15 */public final class CacheConsts { public static final String projectCache = "projectCache"; public static final String commonCacheName = "commonCache"; public static final String userCacheName = "userCache"; public static final String fileCacheName = "fileCache"; public static final String deptCacheName = "deptCache"; public static final String projectPermissionCacheName = "projectPermissionCache";}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2022/2/23 /public enum ErrorCode { /* * 账号或者密码错误 / UsernameOrPasswordError(1024, "账号或者密码错误"), /* * 注册失败 / RegisterError(1401, "注册失败"), /* * 账号已存在 / UsernameExists(1025, "账号已存在"), /* * 暂停回收 / SurveySuspend(4000, "问卷已暂停回收"), /* * 页面不存在 / ProjectNotFound(4004, "对不起，你访问的页面不存在"), /* * 验证失败 / ValidationError(4005, "验证失败"), /* * 权限校验失败 / PermVerifyFailed(4006, "没有权限访问本问卷"), /* * 停止收集 / ExceededMaxAnswers(4010, "已达到回收上限，问卷停止收集"), /* * 停止收集 / ExceededEndTime(4011, "超出截止时间，问卷停止收集"), /* * 问卷已提交 / SurveySubmitted(4012, "问卷已提交"), /* * 答案不允许修改 / AnswerChangeDisabled(4020, "答案不允许修改"), /* * 附件不存在 / FileNotExists(4040, "附件不存在"), /* * 文件上传失败 / FileUploadError(4041, "文件上传失败"), /* * 文件解析失败 / FileParseError(4042, "文件解析失败"), /* * 未配置关联条件 / LinkConditionNotFound(4050, "未配置关联条件"), /* * 关联问题不存在 / LinkQuestionNotFound(4051, "关联问题不存在"), /* * 问题不存在 / LinkOptionNotFound(4052, "关联问题不存在"), /* * 考试未开始 / ExamUnStarted(6000, "考试未开始"), /* * 考试已结束 / ExamFinished(6010, "考试已结束"), /* * 公开查询链接不存在 / QueryNotExist(7000, "该查询链接已失效，请联系项目的发布者"), /* * 公开查询链接已停止 / QueryDisabled(7001, "该查询链接已停止，请联系项目的发布者"), /* * 公开查询条件不能为空 / QueryConditionNull(7002, "查询条件不能为空"), /* * 查询密码认证失败 / QueryPasswordError(7003, "查询密码认证失败"), /* * 查询条件不存在 / QueryConditionNotExist(7004, "查询密码认证失败"), /* * 公开查询结果不存在 / QueryResultNotExist(7010, "没有查询到结果，请确认所填信息正确"), /* * 公开查询答案更新失败 / QueryResultUpdateError(7020, "答案更新失败"),; /* * 前两位区分模块，后两位区分错误消息 */ public int code; public String message; ErrorCode(int code) { this.code = code; } ErrorCode(int code, String message) { this.code = code; this.message = message; }}
package cn.surveyking.server.core.constant;/** * 字段权限类型 * * @author javahuang * @date 2022/1/6 /public final class FieldPermissionType { /* 默认隐藏 / public static final Integer hidden = 0; /* 仅可见 / public static final Integer visible = 1; /* 可编辑 */ public static final Integer editable = 2;}
package cn.surveyking.server.core.constant;/** * 本地存储文件名策略 * @author Jiutwo /public enum LocalStorageNameStrategyEnum { /* * 序列号加原文件名，例如：1653122982531_fileName.jpg / SEQ_ADN_ORIGINAL_NAME("seqAndOriginalName"), /* * 原文件名+序列号，例如：fileName_1653122982531.jpg / ORIGINAL_NAME_AND_SEQ("originalNameAndSeq"), /* * 序列号（项目启动时间戳的自增），例如：1653122982531.jpg / SEQ("seq"), /* * 去除短杠'-'的UUID，例如：8328839eae07f93443733bc7b0468f04.jpg */ UUID("uuid"); private final String strategy; LocalStorageNameStrategyEnum(String strategy) { this.strategy = strategy; } public String getStrategy() { return strategy; }}
package cn.surveyking.server.core.constant;/** * 本地存储路径策略 * @author Jiutwo /public enum LocalStoragePathStrategyEnum { /* * 所有文件存储在 rootPath 下 / BY_NO("byNo"), /* * 按照项目的short-id分文件夹存储,例如 rootPath/RyP2rR / BY_ID("byId"), /* * 按照上传日期存储，例如 rootPath/2022/06/01 */ BY_DATE("byDate"); private final String strategy; LocalStoragePathStrategyEnum(String strategy) { this.strategy = strategy; } public String getStrategy() { return strategy; }}
package cn.surveyking.server.core.constant;/** * 项目场景模式 * @author javahuang * @date 2022/4/7 /public enum ProjectModeEnum { /* 问卷模式 / survey, /* 考试模式 / exam, /* 文件夹 */ folder}
package cn.surveyking.server.core.constant;/** * 项目参与者 * @author javahuang * @date 2022/6/11 /public enum ProjectPartnerTypeEnum { /* * 所有者 / OWNER(1), /* * 协作者 / COLLABORATOR(2), /* * 答卷人(系统用户) / RESPONDENT_SYS_USER(3), /* * 答卷人(外部导入用户) */ RESPONDENT_IMP_USER(4); private int type; ProjectPartnerTypeEnum(int type) { this.type = type; } public int getType() { return type; }}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2022/5/8 /public enum ReportStatKeyEnum { /* 每日数量 */ dailyCount}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2021/8/6 */public enum ResponseCode { SUCCESS(200), FAIL(400), UNAUTHORIZED(401), FORBIDDEN(403), NOT_FOUND(404), INTERNAL_SERVER_ERROR(500); public int code; ResponseCode(int code) { this.code = code; }}
package cn.surveyking.server.core.constant;/** * 文件类型 * @author javahuang * @date 2022/5/5 /public enum StorageTypeEnum { /* 背景图片 / BACKGROUND_IMAGE(1), /* 顶部图片 / HEADER_IMAGE(2), /* 问题图片 / QUESTION_IMAGE(3), /* 答卷附件 / ANSWER_ATTACHMENT(4), /* 问题模板预览图 */ TEMPLATE_PREVIEW_IMAGE(5); private int type; StorageTypeEnum(int type) { this.type = type; } public int getType() { return type; }}
package cn.surveyking.server.core.constant;/** * @author javahuang * @date 2022/4/27 /public enum TagCategoryEnum { /* 模板标签 / template, /* 模板库标签 / repo, /* 问卷 / survey, /* 考试 */ exam;}
package cn.surveyking.server.core.exception;import cn.surveyking.server.core.constant.ErrorCode;/** * 定义异常码消息，方便后面前端进行国际化 * * @author javahuang * @date 2022/2/23 */public class ErrorCodeException extends RuntimeException { private ErrorCode errorCode; public ErrorCodeException(ErrorCode errorCode) { this.errorCode = errorCode; } public ErrorCodeException(ErrorCode errorCode, Throwable cause) { super(cause); this.errorCode = errorCode; } public ErrorCode getErrorCode() { return errorCode; }}
package cn.surveyking.server.core.exception;/** * @author javahuang * @date 2021/8/6 */public class InternalServerError extends RuntimeException { public InternalServerError() { super(); } public InternalServerError(String message) { super(message); } public InternalServerError(String message, Throwable cause) { super(message, cause); } public InternalServerError(Throwable cause) { super(cause); }}
package cn.surveyking.server.core.mvc.advice;import cn.surveyking.server.core.common.ApiResponse;import cn.surveyking.server.core.constant.ResponseCode;import org.springframework.core.MethodParameter;import org.springframework.core.io.Resource;import org.springframework.http.MediaType;import org.springframework.http.converter.ResourceRegionHttpMessageConverter;import org.springframework.http.server.ServerHttpRequest;import org.springframework.http.server.ServerHttpResponse;import org.springframework.web.bind.annotation.RestControllerAdvice;import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;/** * @author javahuang * @date 2021/08/23 */@RestControllerAdvicepublic class CustomResponseBodyAdvice implements ResponseBodyAdvice<Object> { @Override public boolean supports(MethodParameter returnType, Class converterType) { if (converterType.equals(ResourceRegionHttpMessageConverter.class)) { return false; } return true; } @Override public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) { if (body instanceof Resource) { return body; } if (body instanceof ApiResponse) { return body; } return new ApiResponse(ResponseCode.SUCCESS.code, body); }}
package cn.surveyking.server.core.mvc.advice;import cn.surveyking.server.core.common.ApiResponse;import cn.surveyking.server.core.constant.ResponseCode;import cn.surveyking.server.core.constant.ErrorCode;import cn.surveyking.server.core.exception.ErrorCodeException;import cn.surveyking.server.core.exception.InternalServerError;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Value;import org.springframework.core.io.Resource;import org.springframework.http.ResponseEntity;import org.springframework.security.access.AccessDeniedException;import org.springframework.web.bind.MethodArgumentNotValidException;import org.springframework.web.bind.MissingServletRequestParameterException;import org.springframework.web.bind.annotation.ControllerAdvice;import org.springframework.web.bind.annotation.ExceptionHandler;import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;import org.springframework.web.servlet.NoHandlerFoundException;import javax.servlet.http.HttpServletRequest;import javax.validation.ValidationException;import java.util.Map;/** * @author javahuang * @date 2021/08/13 */@ControllerAdvice@Slf4jpublic class GlobalExceptionHandler { @Value("classpath:/static/index.html") private Resource indexHtml; @ExceptionHandler(NoHandlerFoundException.class) public Object handleError404(HttpServletRequest request, Exception e) { return ResponseEntity.ok().body(indexHtml); } @ExceptionHandler(ValidationException.class) public ResponseEntity<ApiResponse<String>> handleValidationException(HttpServletRequest request, ValidationException ex) { log.error("ValidationException {}\n", request.getRequestURI(), ex); return ResponseEntity.ok().body(new ApiResponse<>(ResponseCode.FAIL.code, ex.getMessage())); } @ExceptionHandler(MissingServletRequestParameterException.class) public ResponseEntity<ApiResponse<String>> handleMissingServletRequestParameterException(HttpServletRequest request, MissingServletRequestParameterException ex) { log.error("handleMissingServletRequestParameterException {}\n", request.getRequestURI(), ex); return ResponseEntity.ok().body(new ApiResponse<>(ResponseCode.FAIL.code, "Missing request parameter")); } @ExceptionHandler(MethodArgumentTypeMismatchException.class) public ResponseEntity<ApiResponse<Map<String, String>>> handleMethodArgumentTypeMismatchException( HttpServletRequest request, MethodArgumentTypeMismatchException ex) { log.error("handleMethodArgumentTypeMismatchException {}\n", request.getRequestURI(), ex); return ResponseEntity.ok().body(new ApiResponse<>(ResponseCode.FAIL.code, "Method argument type mismatch")); } @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<ApiResponse<Map<String, String>>> handleMethodArgumentNotValidException( HttpServletRequest request, MethodArgumentNotValidException ex) { log.error("handleMethodArgumentNotValidException {}\n", request.getRequestURI(), ex); return ResponseEntity.ok().body(new ApiResponse<>(ResponseCode.FAIL.code, "Method argument validation failed")); } @ExceptionHandler(AccessDeniedException.class) public ResponseEntity<ApiResponse<String>> handleAccessDeniedException(HttpServletRequest request, AccessDeniedException ex) { log.error("handleAccessDeniedException {}\n", request.getRequestURI()); return ResponseEntity.ok().body(new ApiResponse<>(ResponseCode.FORBIDDEN.code, "Authentication failed")); } @ExceptionHandler(ErrorCodeException.class) public ResponseEntity<ApiResponse<String>> handleErrorCodeException(HttpServletRequest request, ErrorCodeException ex) { ErrorCode errorCode = ex.getErrorCode(); log.error(String.format("handleErrorCodeError %s errorCode=%d, errorMessage=%s", request.getRequestURI(), errorCode.code, errorCode.message)); return ResponseEntity.ok().body(new ApiResponse<>(errorCode.code, errorCode.message)); } @ExceptionHandler(Exception.class) public ResponseEntity<ApiResponse<String>> handleInternalServerError(HttpServletRequest request, Exception ex) { log.error("handleInternalServerError {}\n", request.getRequestURI(), ex); return ResponseEntity.ok().body(new ApiResponse<>(ResponseCode.INTERNAL_SERVER_ERROR.code, ex instanceof InternalServerError ? ex.getMessage() : "服务出了点问题")); }}
package cn.surveyking.server.core.security;import cn.surveyking.server.core.config.WebSecurityConfig;import cn.surveyking.server.core.constant.AppConsts;import cn.surveyking.server.core.uitls.ContextHelper;import cn.surveyking.server.service.UserService;import lombok.RequiredArgsConstructor;import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;import org.springframework.security.core.AuthenticationException;import org.springframework.security.core.context.SecurityContextHolder;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;import org.springframework.stereotype.Component;import org.springframework.web.filter.OncePerRequestFilter;import org.springframework.web.util.WebUtils;import javax.servlet.FilterChain;import javax.servlet.ServletException;import javax.servlet.http.Cookie;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;import java.util.ArrayList;import static java.util.Optional.ofNullable;import static org.apache.commons.lang3.StringUtils.isBlank;import static org.apache.commons.lang3.StringUtils.isNotBlank;/** * @author javahuang * @date 2021/8/23 */@Component@RequiredArgsConstructorpublic class JwtTokenFilter extends OncePerRequestFilter { private final JwtTokenUtil jwtTokenUtil; private final UserService userService; private final RestAuthenticationEntryPoint resolveException; @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException { // Get authorization cookie and validate Cookie tokenFromCookie = WebUtils.getCookie(request, AppConsts.TOKEN_NAME); WebSecurityConfig securityConfig = ContextHelper.getBean(WebSecurityConfig.class); String tokenFromParameter = securityConfig.getUrlTokenAuthentication().isEnabled() ? request.getParameter(AppConsts.TOKEN_NAME) : null; if (tokenFromCookie == null && isBlank(tokenFromParameter)) { chain.doFilter(request, response); return; } // Get jwt token and validate final String token = isNotBlank(tokenFromParameter) ? tokenFromParameter : tokenFromCookie.getValue().trim(); if (!jwtTokenUtil.validate(token)) { chain.doFilter(request, response); return; } try { // Get user identity and set it on the spring security context UserDetails userDetails = userService.loadUserById(jwtTokenUtil.getUser(token).getUserId()); UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, ofNullable(userDetails).map(UserDetails::getAuthorities).orElse(new ArrayList<>())); authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(authentication); // Execute login if (tokenFromCookie == null && tokenFromParameter != null) { Cookie cookie = new Cookie(AppConsts.TOKEN_NAME, tokenFromParameter); cookie.setPath("/"); cookie.setHttpOnly(true); response.addCookie(cookie); } chain.doFilter(request, response); } catch (AuthenticationException e) { // spring security filter 里面的异常，GlobalExceptionHandler 不能捕获 resolveException.commence(request, response, e); } }}
package cn.surveyking.server.core.security;import cn.surveyking.server.domain.dto.UserTokenView;import com.fasterxml.jackson.databind.ObjectMapper;import io.jsonwebtoken.;import io.jsonwebtoken.io.Encoders;import io.jsonwebtoken.jackson.io.JacksonDeserializer;import io.jsonwebtoken.jackson.io.JacksonSerializer;import io.jsonwebtoken.lang.Maps;import io.jsonwebtoken.security.Keys;import io.jsonwebtoken.security.SignatureException;import lombok.RequiredArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.springframework.stereotype.Component;import java.security.Key;import java.util.Date;/* * @author javahuang * @date 2021/8/23 */@Slf4j@Component@RequiredArgsConstructorpublic class JwtTokenUtil { private final ObjectMapper objectMapper; // 每次重启，所有客户端的 token 将失效 private final String jwtSecret = generateSecurityKey(); public String generateAccessToken(UserTokenView user) { return Jwts.builder().serializeToJsonWith(new JacksonSerializer(objectMapper)).claim("user", user) .setIssuedAt(new Date()).signWith(Keys.hmacShaKeyFor(jwtSecret.getBytes())).compact(); } public boolean validate(String token) { try { Jwts.parserBuilder().setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes())).build().parseClaimsJws(token); return true; } catch (SignatureException ex) { log.error("Invalid JWT signature - {}", ex.getMessage()); } catch (MalformedJwtException ex) { log.error("Invalid JWT token - {}", ex.getMessage()); } catch (ExpiredJwtException ex) { log.error("Expired JWT token - {}", ex.getMessage()); } catch (UnsupportedJwtException ex) { log.error("Unsupported JWT token - {}", ex.getMessage()); } catch (IllegalArgumentException ex) { log.error("JWT claims string is empty - {}", ex.getMessage()); } return false; } public UserTokenView getUser(String token) { return Jwts.parserBuilder() .deserializeJsonWith(new JacksonDeserializer(Maps.of("user", UserTokenView.class).build())) .setSigningKey(Keys.hmacShaKeyFor(jwtSecret.getBytes())).build().parseClaimsJws(token).getBody() .get("user", UserTokenView.class); } private static String generateSecurityKey() { Key key = Keys.secretKeyFor(SignatureAlgorithm.HS512); String secretString = Encoders.BASE64.encode(key.getEncoded()); return secretString; }}
package cn.surveyking.server.core.security;import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;import org.springframework.stereotype.Component;/** * @author javahuang * @date 2021/8/24 */@Componentpublic class PasswordEncoder extends BCryptPasswordEncoder {}
package cn.surveyking.server.core.security;import cn.surveyking.server.core.uitls.ContextHelper;import lombok.extern.slf4j.Slf4j;import org.apache.commons.lang3.StringUtils;import org.springframework.aop.framework.AopProxyUtils;import org.springframework.core.annotation.AnnotationUtils;import org.springframework.security.access.prepost.PreAuthorize;import org.springframework.web.bind.annotation.RestController;import java.lang.annotation.Annotation;import java.lang.reflect.Method;import java.util.;/* * 提取所有的 PreAuthorize 注解值 * * @author javahuang * @date 2021/10/12 /@Slf4jpublic class PreAuthorizeAnnotationExtractor { private static Set<String> permissions = null; /* * 提取所有的权限定义 * @return / public static Set<String> extractAllApiPermissions() { List<Object> controllerList = ContextHelper.getBeansByAnnotation(RestController.class); if (permissions == null) { permissions = new LinkedHashSet<>(); extractApiPermissions(controllerList); } return permissions; } private static void extractApiPermissions(List<Object> controllerList) { for (Object obj : controllerList) { Class controllerClass = AopProxyUtils.ultimateTargetClass(obj); String title = null; // 提取类信息 String codePrefix = null; // 注解 PreAuthorize bindPermission = AnnotationUtils.findAnnotation(controllerClass, PreAuthorize.class); if (bindPermission != null) { // 当前资源权限 parseAnnotationValue(bindPermission.value()); } extractAnnotationMethods(controllerClass, PreAuthorize.class).forEach(method -> { PreAuthorize methodBindPermission = AnnotationUtils.getAnnotation(method, PreAuthorize.class); parseAnnotationValue(methodBindPermission.value()); }); } } /* * 如 @PreAuthorize("hasAuthority='answer:list'") * @param value / private static void parseAnnotationValue(String value) { if (StringUtils.isBlank(value) \|\| !StringUtils.contains(value, "hasAuthority")) { return; } String authorityCode = StringUtils.substringBetween(value, "'"); if (StringUtils.isNotBlank(authorityCode)) { String[] authorityHierarchy = authorityCode.split(":"); String current = authorityHierarchy[0]; permissions.add(current.trim()); for (int i = 1; i < authorityHierarchy.length; i++) { current = current + ":" + authorityHierarchy[i]; permissions.add(current); } } else { log.warn("检测到权限码未配置 {}", value); } } /* * 获取类中所有包含注解的方法（包含父类中） * @param clazz * @return */ public static List<Method> extractAnnotationMethods(Class<?> clazz, Class<? extends Annotation> annotationClass) { List<Method> methodList = new ArrayList<>(); while (clazz != null) { Method[] methods = clazz.getDeclaredMethods(); if (methods != null) { // 被重写属性，以子类override的为准 Arrays.stream(methods).forEach((method) -> { if (AnnotationUtils.getAnnotation(method, annotationClass) != null) { methodList.add(method); } }); } clazz = clazz.getSuperclass(); } return methodList; }}
package cn.surveyking.server.core.security;import cn.surveyking.server.core.common.ApiResponse;import cn.surveyking.server.core.constant.ResponseCode;import com.fasterxml.jackson.databind.ObjectMapper;import lombok.RequiredArgsConstructor;import org.springframework.security.core.AuthenticationException;import org.springframework.security.web.AuthenticationEntryPoint;import org.springframework.stereotype.Component;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.io.IOException;/** * 捕获 spring security 认证失败异常，返回 application/json 类型的数据 * * @author javahuang * @date 2021/8/24 */@Component("restAuthenticationEntryPoint")@RequiredArgsConstructorpublic class RestAuthenticationEntryPoint implements AuthenticationEntryPoint { private final ObjectMapper objectMapper; public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authenticationException) throws IOException, ServletException { response.setContentType("application/json"); ApiResponse<String> apiResponse = new ApiResponse(ResponseCode.UNAUTHORIZED.code, authenticationException.getMessage()); response.setStatus(HttpServletResponse.SC_OK); response.getOutputStream().println(objectMapper.writeValueAsString(apiResponse)); }}
package cn.surveyking.server.core.uitls;import java.util.ArrayList;import java.util.Collections;import java.util.List;/** * Usage: * <li>String msg = Ansi.Red.and(Ansi.BgYellow).format("Hello %s", name)</li> * <li>String msg = Ansi.Blink.colorize("BOOM!")</li> * * Or, if you are adverse to that, you can use the constants directly: * <li>String msg = new Ansi(Ansi.ITALIC, Ansi.GREEN).format("Green money")</li> Or, even: * <li>String msg = Ansi.BLUE + "scientific"</li> * * NOTE: Nothing stops you from combining multiple FG colors or BG colors, but only the * last one will display. * * @author dain * */public final class Ansi { // Color code strings from: // http://www.topmudsites.com/forums/mud-coding/413-java-ansi.html public static final String SANE = "\u001B[0m"; public static final String HIGH_INTENSITY = "\u001B[1m"; public static final String LOW_INTENSITY = "\u001B[2m"; public static final String ITALIC = "\u001B[3m"; public static final String UNDERLINE = "\u001B[4m"; public static final String BLINK = "\u001B[5m"; public static final String RAPID_BLINK = "\u001B[6m"; public static final String REVERSE_VIDEO = "\u001B[7m"; public static final String INVISIBLE_TEXT = "\u001B[8m"; public static final String BLACK = "\u001B[30m"; public static final String RED = "\u001B[31m"; public static final String GREEN = "\u001B[32m"; public static final String YELLOW = "\u001B[33m"; public static final String BLUE = "\u001B[34m"; public static final String MAGENTA = "\u001B[35m"; public static final String CYAN = "\u001B[36m"; public static final String WHITE = "\u001B[37m"; public static final String BACKGROUND_BLACK = "\u001B[40m"; public static final String BACKGROUND_RED = "\u001B[41m"; public static final String BACKGROUND_GREEN = "\u001B[42m"; public static final String BACKGROUND_YELLOW = "\u001B[43m"; public static final String BACKGROUND_BLUE = "\u001B[44m"; public static final String BACKGROUND_MAGENTA = "\u001B[45m"; public static final String BACKGROUND_CYAN = "\u001B[46m"; public static final String BACKGROUND_WHITE = "\u001B[47m"; public static final Ansi HighIntensity = new Ansi(HIGH_INTENSITY); public static final Ansi Bold = HighIntensity; public static final Ansi LowIntensity = new Ansi(LOW_INTENSITY); public static final Ansi Normal = LowIntensity; public static final Ansi Italic = new Ansi(ITALIC); public static final Ansi Underline = new Ansi(UNDERLINE); public static final Ansi Blink = new Ansi(BLINK); public static final Ansi RapidBlink = new Ansi(RAPID_BLINK); public static final Ansi Black = new Ansi(BLACK); public static final Ansi Red = new Ansi(RED); public static final Ansi Green = new Ansi(GREEN); public static final Ansi Yellow = new Ansi(YELLOW); public static final Ansi Blue = new Ansi(BLUE); public static final Ansi Magenta = new Ansi(MAGENTA); public static final Ansi Cyan = new Ansi(CYAN); public static final Ansi White = new Ansi(WHITE); public static final Ansi BgBlack = new Ansi(BACKGROUND_BLACK); public static final Ansi BgRed = new Ansi(BACKGROUND_RED); public static final Ansi BgGreen = new Ansi(BACKGROUND_GREEN); public static final Ansi BgYellow = new Ansi(BACKGROUND_YELLOW); public static final Ansi BgBlue = new Ansi(BACKGROUND_BLUE); public static final Ansi BgMagenta = new Ansi(BACKGROUND_MAGENTA); public static final Ansi BgCyan = new Ansi(BACKGROUND_CYAN); public static final Ansi BgWhite = new Ansi(BACKGROUND_WHITE); final private String[] codes; final private String codes_str; public Ansi(String... codes) { this.codes = codes; String _codes_str = ""; for (String code : codes) { _codes_str += code; } codes_str = _codes_str; } public Ansi and(Ansi other) { List<String> both = new ArrayList<String>(); Collections.addAll(both, codes); Collections.addAll(both, other.codes); return new Ansi(both.toArray(new String[] {})); } public String colorize(String original) { return codes_str + original + SANE; } public String format(String template, Object... args) { return colorize(String.format(template, args)); }}
package cn.surveyking.server.core.uitls;import cn.surveyking.server.domain.dto.SurveySchema;import lombok.extern.slf4j.Slf4j;import java.util.;/* * 用于计算问卷的分值 * * @author javahuang * @date 2022/4/7 /@Slf4jpublic class AnswerScoreEvaluator { // 问卷 schema private final SurveySchema schema; // 当前答案 private final LinkedHashMap answer; List<Evaluator> evaluatorList = new ArrayList<>(); LinkedHashMap<String, Double> questionScore = new LinkedHashMap<>(); public AnswerScoreEvaluator(SurveySchema schema, LinkedHashMap answer) { this.schema = schema; this.answer = answer; evaluatorList.add(new OnlyOneEvaluator()); evaluatorList.add(new SelectAllEvaluator()); evaluatorList.add(new SelectCorrectEvaluator()); evaluatorList.add(new SelectEvaluator()); } /* * 计算总分 * @return / public Double eval() { return doEval(schema); } /* * 获取问题的分值 * @return / public LinkedHashMap<String, Double> getQuestionScore() { return this.questionScore; } private Double doEval(SurveySchema qSchema) { double score = evaluatorList.stream().filter(x -> x.support(qSchema)).findFirst().orElse(new DefaultEvaluator()) .eval(qSchema); if (SurveySchema.QuestionType.dataType().contains(qSchema.getType())) { questionScore.put(qSchema.getId(), score); } if (qSchema.getChildren() != null) { for (SurveySchema child : qSchema.getChildren()) { score += doEval(child); } } return score; } interface Evaluator { /* * @param qSchema 当前问题的 schema * @return 当前问题的分值 / Double eval(SurveySchema qSchema); /* * @param qSchema 当前问题的 schema * @return 是否能使用当前 evaluator 计算分值 / boolean support(SurveySchema qSchema); } class OnlyOneEvaluator implements Evaluator { /* * 只有一个正确答案 * @param qSchema 当前问题的 schema * @return / @Override public Double eval(SurveySchema qSchema) { String qId = qSchema.getId(); Double qScore = qSchema.getAttribute().getExamScore(); Map qValue = (Map) answer.get(qId); for (SurveySchema option : qSchema.getChildren()) { // 只有一个正确答案 if (option.getAttribute().getExamCorrectAnswer() != null && qValue.containsKey(option.getId()) && qValue.values().size() == 1) { return qScore; } } return .0; } @Override public boolean support(SurveySchema qSchema) { if (qSchema.getAttribute() == null) { return false; } return SurveySchema.ExamScoreMode.onlyOne.equals(qSchema.getAttribute().getExamAnswerMode()) && qSchema.getAttribute().getExamScore() != null && answer.get(qSchema.getId()) != null; } } class SelectAllEvaluator implements Evaluator { /* * 全部答对才得分 * @param qSchema 当前问题的 schema * @return / @Override public Double eval(SurveySchema qSchema) { String qId = qSchema.getId(); Double qScore = qSchema.getAttribute().getExamScore(); Map qValue = (Map) answer.get(qId); for (SurveySchema option : qSchema.getChildren()) { // 选了非正确答案,直接0分 if (option.getAttribute().getExamCorrectAnswer() == null && qValue.containsKey(option.getId())) { return .0; } // 正确答案没有选，直接0分 if (option.getAttribute().getExamCorrectAnswer() != null && !qValue.containsKey(option.getId())) { return .0; } // 正确答案不匹配，直接 0 分 Object optionValue = qValue.get(option.getId()); if (option.getAttribute().getExamCorrectAnswer() != null && !optionValueMatchCorrectAnswer(qSchema, option.getId(), optionValue)) { return .0; } } return qScore; } @Override public boolean support(SurveySchema qSchema) { if (qSchema.getAttribute() == null) { return false; } return SurveySchema.ExamScoreMode.selectAll.equals(qSchema.getAttribute().getExamAnswerMode()) && qSchema.getAttribute().getExamScore() != null && answer.get(qSchema.getId()) != null; } } class SelectCorrectEvaluator implements Evaluator { /* * 按正确答案计分，选择题答错不得分、填空题按正确答案算分 * @param qSchema 当前问题的 schema * @return / @Override public Double eval(SurveySchema qSchema) { String qId = qSchema.getId(); Map qValue = (Map) answer.get(qId); double sum = 0; for (SurveySchema option : qSchema.getChildren()) { // 选择题选了非正确答案,直接0分 if (!isBlank(qSchema) && option.getAttribute().getExamCorrectAnswer() == null && qValue.containsKey(option.getId())) { return .0; } // 按正确答案算分 Object optionValue = qValue.get(option.getId()); if (optionValueMatchCorrectAnswer(qSchema, option.getId(), optionValue)) { sum += option.getAttribute().getExamScore(); } } return sum; } @Override public boolean support(SurveySchema qSchema) { if (qSchema.getAttribute() == null) { return false; } return SurveySchema.ExamScoreMode.selectCorrect.equals(qSchema.getAttribute().getExamAnswerMode()) && qSchema.getAttribute().getExamScore() != null && answer.get(qSchema.getId()) != null; } } class SelectEvaluator implements Evaluator { /* * 按选中的答案算分 * @param qSchema 当前问题的 schema * @return / @Override public Double eval(SurveySchema qSchema) { String qId = qSchema.getId(); Map qValue = (Map) answer.get(qId); double sum = 0; for (SurveySchema option : qSchema.getChildren()) { // 按正确答案算分 Object optionValue = qValue.get(option.getId()); if (optionValueMatchCorrectAnswer(qSchema, option.getId(), optionValue)) { Double score = option.getAttribute().getExamScore(); if (score == null) { score = .0; log.warn("问卷{}问题{}选项{}未设置分值", schema.getId(), qSchema.getId(), option.getId()); } sum += score; } } return sum; } @Override public boolean support(SurveySchema qSchema) { if (qSchema.getAttribute() == null) { return false; } return SurveySchema.ExamScoreMode.select.equals(qSchema.getAttribute().getExamAnswerMode()) && qSchema.getAttribute().getExamScore() != null && answer.get(qSchema.getId()) != null; } } class DefaultEvaluator implements Evaluator { @Override public Double eval(SurveySchema qSchema) { return 0.0; } @Override public boolean support(SurveySchema qSchema) { return true; } } /* * @param qSchema 问题 schema * @param optionId 选项 id * @param optionValue 选项的值 * @return 该选项答案是否匹配正确答案 / private boolean optionValueMatchCorrectAnswer(SurveySchema qSchema, String optionId, Object optionValue) { if (optionValue == null) { return false; } // 选择题选项有值，则直接匹配回答正确 if (!isBlank(qSchema)) { return true; } SurveySchema.ExamMatchRule matchRule = qSchema.getAttribute().getExamMatchRule(); SurveySchema optionSchema = qSchema.getChildren().stream().filter(x -> x.getId().equals(optionId)).findFirst() .get(); String correctAnswer = optionSchema.getAttribute().getExamCorrectAnswer(); if (correctAnswer == null) { log.warn("问卷{}问题{}选项{}未设置正确答案", schema.getId(), qSchema.getId(), optionSchema.getId()); return false; } // 多个正确答案可以按照（回车键）隔开，只要有一个正确即可 for (String item : correctAnswer.split("\n")) { if (SurveySchema.ExamMatchRule.completeSame.equals(matchRule) && item.equals(optionValue.toString())) { return true; } if (SurveySchema.ExamMatchRule.contain.equals(matchRule) && item.contains(optionValue.toString())) { return true; } } return false; } /* * 选择题selectCorrect选择了错误的，整题不会得分；填空题selectCorrect只计算正确的分数 * @param qSchema 问题schema * @return 是否是填空题 */ private boolean isBlank(SurveySchema qSchema) { if (SurveySchema.QuestionType.Radio.equals(qSchema.getType()) \|\| SurveySchema.QuestionType.Checkbox.equals(qSchema.getType()) \|\| SurveySchema.QuestionType.Select.equals(qSchema.getType())) { return false; } return true; }}
package cn.surveyking.server.core.uitls;import com.google.zxing.;import com.google.zxing.client.j2se.BufferedImageLuminanceSource;import com.google.zxing.common.HybridBinarizer;import lombok.SneakyThrows;import net.coobird.thumbnailator.Thumbnails;import java.awt.image.BufferedImage;import java.io.FileNotFoundException;import java.io.IOException;import java.io.InputStream;import java.util.EnumMap;import java.util.EnumSet;import java.util.Map;/* * @author javahuang * @date 2022/5/25 /public class BarcodeReader { @SneakyThrows public static String readBarcode(InputStream inputStream) { Map<DecodeHintType, Object> hintMap = new EnumMap<DecodeHintType, Object>(DecodeHintType.class); hintMap.put(DecodeHintType.CHARACTER_SET, "utf-8"); hintMap.put(DecodeHintType.TRY_HARDER, Boolean.TRUE); hintMap.put(DecodeHintType.POSSIBLE_FORMATS, EnumSet.allOf(BarcodeFormat.class)); Map<DecodeHintType, Object> hintMap_pure = new EnumMap<DecodeHintType, Object>(DecodeHintType.class); hintMap_pure.put(DecodeHintType.CHARACTER_SET, "utf-8"); hintMap_pure.put(DecodeHintType.TRY_HARDER, Boolean.TRUE); hintMap_pure.put(DecodeHintType.PURE_BARCODE, Boolean.TRUE); return readBarcode(inputStream, hintMap, hintMap_pure); } /* * @param inputStream * @param hintMap * @return Qr Code value * @throws FileNotFoundException * @throws IOException * @throws NotFoundException */ public static String readBarcode(InputStream inputStream, Map hintMap, Map hintMap_pure) throws FileNotFoundException, IOException, NotFoundException { BufferedImage image = Thumbnails.of(inputStream).size(1280, 960).asBufferedImage(); BinaryBitmap binaryBitmap = new BinaryBitmap(new HybridBinarizer(new BufferedImageLuminanceSource(image))); Result qrCodeResult = new MultiFormatReader().decode(binaryBitmap, hintMap); if (qrCodeResult == null) { qrCodeResult = new MultiFormatReader().decode(binaryBitmap, hintMap_pure); } return qrCodeResult.getText(); }}
package cn.surveyking.server.core.uitls;import java.lang.reflect.Field;import java.util.ArrayList;import java.util.List;import java.util.stream.Collectors;/** * @author javahuang * @date 2022/11/10 /public class ClassUtils { /* * 将 class的多个层级的field 打平成 . 分割的 * @param cls * @param parentAttr * @param maxDepth * @return */ public static List<String> flatClassFields(Class cls, List<String> parentAttr, int maxDepth) { List<String> attributes = new ArrayList<>(); for (Field field : cls.getDeclaredFields()) { List<String> newArr = new ArrayList<>(parentAttr); if (field.getType().isMemberClass() && !field.getType().isEnum() && newArr.size() < maxDepth - 1) { newArr.add(field.getName()); attributes.addAll(flatClassFields(field.getType(), newArr, maxDepth)); } else { newArr.add(field.getName()); attributes.add(newArr.stream().collect(Collectors.joining("."))); } } return attributes; }}
/* * Copyright (c) 2015-2020, www.dibo.ltd (service@dibo.ltd). * <p> * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * <p> * https://www.apache.org/licenses/LICENSE-2.0 * <p> * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. /package cn.surveyking.server.core.uitls;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.BeansException;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import org.springframework.context.annotation.Lazy;import org.springframework.stereotype.Component;import org.springframework.web.context.ContextLoader;import org.springframework.web.context.request.RequestAttributes;import org.springframework.web.context.request.RequestContextHolder;import org.springframework.web.context.request.ServletRequestAttributes;import org.springframework.web.util.WebUtils;import javax.servlet.http.Cookie;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import java.lang.annotation.Annotation;import java.util.ArrayList;import java.util.List;import java.util.Map;/* * Spring上下文帮助类 * * @author mazc@dibo.ltd * @version 2.0 * @date 2019/01/01 /@Component@Lazy(false)@Slf4jpublic class ContextHelper implements ApplicationContextAware { /** * ApplicationContext上下文 / private static ApplicationContext APPLICATION_CONTEXT = null; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { APPLICATION_CONTEXT = applicationContext; } /** * 获取ApplicationContext上下文 / public static ApplicationContext getApplicationContext() { if (APPLICATION_CONTEXT == null) { APPLICATION_CONTEXT = ContextLoader.getCurrentWebApplicationContext(); } if (APPLICATION_CONTEXT == null) { log.warn("无法获取ApplicationContext，请确保ComponentScan扫描路径包含com.diboot包路径，并在Spring初始化之后调用接口!"); } return APPLICATION_CONTEXT; } /** * 根据beanId获取Bean实例 * @param beanId * @return / public static Object getBean(String beanId) { return getApplicationContext().getBean(beanId); } /** * 获取指定类型的单个Bean实例 * @param clazz * @return / public static <T> T getBean(Class<T> clazz) { try { return getApplicationContext().getBean(clazz); } catch (Exception e) { log.debug("instance not found: {}", clazz.getSimpleName()); return null; } } /** * 获取指定类型的全部实现类 * @param type * @param <T> * @return / public static <T> List<T> getBeans(Class<T> type) { Map<String, T> map = getApplicationContext().getBeansOfType(type); if (map == null \|\| map.size() == 0) { return null; } List<T> beanList = new ArrayList<>(map.size()); beanList.addAll(map.values()); return beanList; } /** * 根据注解获取beans * @param annotationType * @return */ public static List<Object> getBeansByAnnotation(Class<? extends Annotation> annotationType) { Map<String, Object> map = getApplicationContext().getBeansWithAnnotation(annotationType); if (map == null \|\| map.size() == 0) { return null; } List<Object> beanList = new ArrayList<>(); beanList.addAll(map.values()); return beanList; } public static HttpServletRequest getCurrentHttpRequest() { RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes(); if (requestAttributes instanceof ServletRequestAttributes) { HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest(); return request; } log.debug("Not called in the context of an HTTP request"); return null; } public static HttpServletResponse getCurrentHttpResponse() { RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes(); if (requestAttributes instanceof ServletRequestAttributes) { HttpServletResponse response = ((ServletRequestAttributes) requestAttributes).getResponse(); return response; } log.debug("Not called in the context of an HTTP request"); return null; } public static String getCookie(String cookieName) { Cookie cookie = WebUtils.getCookie(getCurrentHttpRequest(), cookieName); if (cookie != null) { return cookie.getValue(); } return null; }}
package cn.surveyking.server.core.uitls;import cn.surveyking.server.core.common.Tuple2;import org.springframework.scheduling.support.CronExpression;import java.time.LocalDateTime;import java.time.temporal.ChronoUnit;/** * @author javahuang * @date 2022/2/28 /public class CronHelper { private final String cron; private final CronExpression cronExpression; public CronHelper(String cron) { this.cron = cron; if (CronExpression.isValidExpression(cron)) { this.cronExpression = CronExpression.parse(cron); } else { this.cronExpression = null; } } /* * @return 当前时间窗 / public Tuple2<LocalDateTime, LocalDateTime> currentWindow() { if (this.cronExpression == null) { return defaultWindow(); } Tuple2<LocalDateTime, LocalDateTime> nextWindow = nextWindow(); long millis = ChronoUnit.MILLIS.between(nextWindow.getFirst(), nextWindow.getSecond()); LocalDateTime currentWindowStart = nextWindow.getFirst().minus(millis, ChronoUnit.MILLIS); return new Tuple2<>(currentWindowStart, nextWindow.getFirst()); } /* * 下个时间窗 * @return */ public Tuple2<LocalDateTime, LocalDateTime> nextWindow() { if (this.cronExpression == null) { return defaultWindow(); } LocalDateTime nextWindowStart = cronExpression.next(LocalDateTime.now()); LocalDateTime nextWindowEnd = cronExpression.next(nextWindowStart); return new Tuple2(nextWindowStart, nextWindowEnd); } private Tuple2<LocalDateTime, LocalDateTime> defaultWindow() { return null; }}
package cn.surveyking.server.core.uitls;import cn.surveyking.server.domain.dto.DatabaseInitProperties;import lombok.SneakyThrows;import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.net.URLDecoder;import java.nio.charset.StandardCharsets;import java.nio.file.Files;import java.nio.file.StandardOpenOption;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import java.util.Scanner;/** * @author javahuang * @date 2022/1/25 /public class DatabaseInitHelper { private static final String CONFIG_FILE = "application.properties"; private static final String IP_PATTERN = "^(([01]?\\d\\d?\|2[0-4]\\d\|25[0-5])\\.){3}([01]?\\d\\d?\|2[0-4]\\d\|25[0-5])$"; private static final String INIT_DB_SCRIPT_FILE_NAME = "init-%s.sql"; private static final String MYSQL_DRIVER_DOWNLOAD_URL = "https://repo1.maven.org/maven2/mysql/mysql-connector-java/8.0.28/mysql-connector-java-8.0.28.jar"; static Scanner sc = new Scanner(System.in); private static String db = "mysql"; public static void init(String[] args) { try { needCreateProperties(); // 初始化启动配置文件，初始化数据库脚本 if ("i".equals(args[0])) { initializeDatabase(); } else { // 通过启动命令行参数来创建配置文件 createFileFromProperties(setPropertiesFromArguments(args)); } } finally { sc.close(); } } private static void initializeDatabase() { colorOutput("请选择您的数据库类型 : "); colorOutput("1) MySql"); colorOutput("2) H2"); String selection = sc.nextLine(); switch (selection) { case "1": db = "mysql"; break; case "2": db = "h2"; break; default: return; } initDb(); } private static void initDb() { if ("mysql".equals(db)) { initMySql(); } } public static void initMySql() { // 设置连接参数 DatabaseInitProperties properties = setProperties(); // 下载数据库驱动 downloadDriverJar(properties); // 测试数据库链接 testDatabaseConnection(properties); // 创建启动文件 createFileFromProperties(properties); // 执行数据库初始化操作 initDatabaseSchema(properties); // 完成 finish(); } public static void initH2() { // TODO } @SneakyThrows private static boolean needCreateProperties() { File f = new File(CONFIG_FILE); if (!f.exists()) { f.createNewFile(); } // 总是覆盖之前的配置 return true; } private static DatabaseInitProperties setProperties() { DatabaseInitProperties properties = new DatabaseInitProperties(); properties.setApplicationName(setProperty("请输入应用名称:", "名称不能为空", ".+", "SurveyKing")); properties.setServerPort(Integer.parseInt(setProperty("请输入应用端口号(默认 1991):", "端口号不能为空", "\\d{1,5}", "1991"))); properties.setDbIp(setProperty("请输入数据库地址(默认 127.0.0.1):", "IP 地址格式不正确，请重新输入", IP_PATTERN, "127.0.0.1")); properties.setDbPort(Integer.parseInt(setProperty("请输入数据库端口(默认 3306):", "端口格式不正确，请重新输入", "\\d{1,5}", "3306"))); properties.setDbName(setProperty("请输入数据库名称:", "数据库名称不能为空", "\\w+", "")); properties.setUsername(setProperty("请输入数据库用户名:", "数据库用户名不能为空", ".+", "")); properties.setPassword(setProperty("请输入数据库密码:", "数据库密码不能为空", ".+", "")); properties.setDriverClassName("com.mysql.cj.jdbc.Driver"); return properties; } private static DatabaseInitProperties setPropertiesFromArguments(String[] args) { DatabaseInitProperties properties = new DatabaseInitProperties(); for (String arg : args) { String[] kv = arg.split("=", 2); if (kv[0].toLowerCase().contains("port")) { properties.setServerPort(Integer.parseInt(kv[1])); } else if (kv[0].toLowerCase().contains("url")) { properties.setDataSourceUrl(kv[1]); } else if (kv[0].toLowerCase().contains("username")) { properties.setUsername(kv[1]); } else if (kv[0].toLowerCase().contains("password")) { properties.setPassword(kv[1]); } } return properties; } private static String setProperty(String prompt, String errorMsg, String regex, String defaultValue) { String result; colorOutput(prompt); while (true) { result = sc.nextLine().trim(); if (result.isEmpty() && !defaultValue.isEmpty()) { result = defaultValue; break; } else if (!result.matches(regex)) { colorOutput(errorMsg, 2); continue; } else { break; } } return result; } private static void downloadDriverJar(DatabaseInitProperties properties) { try { Class.forName("com.mysql.cj.jdbc.Driver"); Class.forName(properties.getDriverClassName()); } catch (ClassNotFoundException e) { if (yesOrNo("未监测到数据库驱动，是否下载？")) { // TODO: 将数据库驱动下载到当前 lib 目录 colorOutput("开始下载驱动"); } } } private static void testDatabaseConnection(DatabaseInitProperties properties) { if (!yesOrNo("是否测试数据库连接？")) { return; } boolean reachable; try (Connection connection = DriverManager.getConnection(String.format("jdbc:mysql://%s:%d/%s", properties.getDbIp(), properties.getDbPort(), properties.getDbName()), properties.getUsername(), properties.getPassword())) { reachable = connection.isValid(10); } catch (SQLException e) { reachable = false; } if (reachable) { colorOutput("数据库连接成功", 1); } else { if (yesOrNo("数据库连接不可用，是否重新设置？")) { initMySql(); } } } /* * 数据库初始化 * @param properties / @SneakyThrows private static void initDatabaseSchema(DatabaseInitProperties properties) { if (!yesOrNo("是否执行数据库初始化操作？")) { return; } try (Connection connection = DriverManager.getConnection(String.format("jdbc:mysql://%s:%d/%s", properties.getDbIp(), properties.getDbPort(), properties.getDbName()), properties.getUsername(), properties.getPassword())) { ScriptRunner runner = new ScriptRunner(connection, false, false); String file = getJarFilePath() + File.separator + String.format(INIT_DB_SCRIPT_FILE_NAME, db); if (!new File(file).exists()) { colorOutput(String.format("初始化脚本不存在 %s", file), 2); initDatabaseSchema(properties); return; } runner.runScript(new BufferedReader(new FileReader(file))); } catch (SQLException e) { e.printStackTrace(); } colorOutput("数据库初始化完成", 1); } private static void finish() { colorOutput(String.format("初始化完成，有问题请联系作者。"), 1); } @SneakyThrows private static void createFileFromProperties(DatabaseInitProperties properties) { File f = new File(CONFIG_FILE); List<String> fileContent = new ArrayList<>(Files.readAllLines(f.toPath(), StandardCharsets.UTF_8)); writeLine(fileContent, "spring.application.name=%s", properties.getApplicationName()); writeLine(fileContent, "server.port=%d", properties.getServerPort()); writeLine(fileContent, "spring.datasource.driver-class-name=%s", properties.getDriverClassName()); if (properties.getDataSourceUrl() == null && properties.getDbName() != null) { writeLine(fileContent, "spring.datasource.url=jdbc:mysql://%s:%d/%s", properties.getDbIp(), properties.getDbPort(), properties.getDbName()); } else if (properties.getDataSourceUrl() != null) { writeLine(fileContent, "spring.datasource.url=%s", properties.getDataSourceUrl()); } writeLine(fileContent, "spring.datasource.username=%s", properties.getUsername()); writeLine(fileContent, "spring.datasource.password=%s", properties.getPassword()); Files.write(f.toPath(), fileContent, StandardCharsets.UTF_8, StandardOpenOption.TRUNCATE_EXISTING); } @SneakyThrows private static void writeLine(List<String> fileContent, String key, Object... value) { if (value.length > 0 && value[0] != null) { String newLine = String.format(key, value); String propertyKey = newLine.split("=", 2)[0]; for (int i = 0; i < fileContent.size(); i++) { if (fileContent.get(i).startsWith(propertyKey)) { fileContent.set(i, newLine); return; } } fileContent.add(newLine); } } private static boolean yesOrNo(String prompt) { colorOutput(String.format("%s Y(是) N(否)", prompt)); String yesOrNo = sc.nextLine(); if (yesOrNo.toUpperCase().contains("Y")) { return true; } return false; } /* * 获取当前 jar 运行目录 * @return */ @SneakyThrows public static String getJarFilePath() { String path = DatabaseInitHelper.class.getProtectionDomain().getCodeSource().getLocation().getPath(); String decodedPath = URLDecoder.decode(path, "UTF-8"); return new File(decodedPath.substring(0, decodedPath.indexOf("!/BOOT-INF")).split(":")[1]).getParent(); } private static void colorOutput(String output) { colorOutput(output, 0); } private static void colorOutput(String output, int level) { switch (level) { case 1: // success System.out.println(Ansi.Green.colorize(output)); break; case 2: // fail System.out.println(Ansi.Red.colorize(output)); break; default: // info System.out.println(Ansi.Blue.colorize(output)); break; } }}
package cn.surveyking.server.core.uitls;import java.time.LocalDateTime;import java.time.ZoneId;import java.util.Date;/** * @author javahuang * @date 2022/2/28 /public class DateUtils { public static Date localDateTime2date(LocalDateTime in) { return Date.from(in.atZone(ZoneId.systemDefault()).toInstant()); } public static LocalDateTime date2localDateTime(Date in) { return LocalDateTime.ofInstant(in.toInstant(), ZoneId.systemDefault()); } /* * @param current 当前日期 * @param start 起始日期 * @param end 结束日期 * @return 当前日期是否在指定日期范围内 */ public static boolean isBetween(Date current, Date start, Date end) { if (current.compareTo(start) >= 0 && current.compareTo(end) <= 0) { return true; } return false; }}
package cn.surveyking.server.core.uitls;import lombok.Data;import lombok.experimental.Accessors;import org.dhatim.fastexcel.Workbook;import org.dhatim.fastexcel.Worksheet;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.OutputStream;import java.util.List;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import static cn.surveyking.server.core.uitls.SchemaHelper.openidColumnName;/** * 轻量级 excel 导出工具，换成 poi 打的包会多出十几 M，不能接受，-_-\|\| * * @author javahuang * @date 2021/2/1 */public class ExcelExporter { private Workbook workbook; private Map<String, List<String>> columnsBySheet = new ConcurrentHashMap<>(); private Map<String, Integer> rowIndexBySheet = new ConcurrentHashMap<>(); private ByteArrayOutputStream os = new ByteArrayOutputStream(); ThreadLocal<Worksheet> localSheet = new ThreadLocal<>(); protected static ThreadLocal<Integer> localOpenid = new ThreadLocal<>(); public ExcelExporter() { this.workbook = new Workbook(os, "survey", "1.0"); } public ExcelExporter(OutputStream outputStream) { this.workbook = new Workbook(outputStream, "survey", "1.0"); } public Worksheet createSheet(String sheetName) { Worksheet worksheet = workbook.newWorksheet(sheetName); worksheet.fitToWidth((short) 10); worksheet.setFitToPage(true); localSheet.set(worksheet); rowIndexBySheet.put(sheetName, 1); return worksheet; } public void createHeader(List<String> columns) { Worksheet sheet = localSheet.get(); for (int i = 0; i < columns.size(); i++) { sheet.value(0, i, columns.get(i)); } } public void createRow(List<List<Object>> rows) { Worksheet sheet = localSheet.get(); String sheetName = sheet.getName(); int rowNum = rowIndexBySheet.get(sheetName); for (int r = 1; r <= rows.size(); r++) { List<Object> row = rows.get(r - 1); for (int c = 0; c < row.size(); c++) { Object value = row.get(c); if (value instanceof Integer) { sheet.value(r, c, (Number) value); } else if (value instanceof String) { sheet.value(r, c, (String) value); } else if (value != null) { sheet.value(r, c, value.toString()); } } rowNum++; } rowIndexBySheet.put(sheetName, rowNum); } public ByteArrayInputStream export() { try { this.workbook.finish(); return new ByteArrayInputStream(this.os.toByteArray()); } catch (IOException e) { e.printStackTrace(); } return null; } public void exportToStream() { try { this.workbook.finish(); } catch (IOException e) { e.printStackTrace(); } } @Data @Accessors(chain = true) public static class Builder { private String sheetName = "Sheet1"; private List<String> columns; private List<List<Object>> rows; private OutputStream outputStream; public ExcelExporter build() { ExcelExporter excelExporter; if (this.outputStream != null) { excelExporter = new ExcelExporter(this.outputStream); } else { excelExporter = new ExcelExporter(); } // 如果答案中不存在 openid，则删除该列 int openidColumnIndex = this.columns.indexOf(openidColumnName); if (!Boolean.TRUE.equals(SchemaHelper.localOpenId.get()) && openidColumnIndex != -1) { this.columns.remove(openidColumnIndex); this.rows.forEach(row -> { row.remove(openidColumnIndex); }); SchemaHelper.localOpenId.remove(); } excelExporter.createSheet(this.sheetName); excelExporter.createRow(this.rows); excelExporter.createHeader(this.columns); return excelExporter; } }}
package cn.surveyking.server.core.uitls;import lombok.SneakyThrows;import java.net.URLEncoder;/** * 参考 https://segmentfault.com/a/1190000023601065 * * @author javahuang * @date 2022/2/8 /public final class HTTPUtils { /* * 获取下载文件名，避免中文文件名乱码 * @param fileName * @return / @SneakyThrows public static String getContentDispositionValue(String fileName) { // 对真实文件名进行百分号编码 String percentEncodedFileName = URLEncoder.encode(fileName, "utf-8").replaceAll("\\+", "%20"); // 组装contentDisposition的值 StringBuilder contentDispositionValue = new StringBuilder(); contentDispositionValue.append("attachment; filename=").append(percentEncodedFileName); // .append("filename=").append("utf-8''").append(percentEncodedFileName); return contentDispositionValue.toString(); }}
package cn.surveyking.server.core.uitls;import javax.servlet.http.HttpServletRequest;/** * @author javahuang * @date 2021/8/6 */public class IPUtils { private static final String[] IP_HEADER_CANDIDATES = { "X-Forwarded-For", "Proxy-Client-IP", "WL-Proxy-Client-IP", "HTTP_X_FORWARDED_FOR", "HTTP_X_FORWARDED", "HTTP_X_CLUSTER_CLIENT_IP", "HTTP_CLIENT_IP", "HTTP_FORWARDED_FOR", "HTTP_FORWARDED", "HTTP_VIA", "REMOTE_ADDR" }; public static String getClientIpAddress(HttpServletRequest request) { for (String header : IP_HEADER_CANDIDATES) { String ip = request.getHeader(header); if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) { return ip; } } return request.getRemoteAddr(); }}
package cn.surveyking.server.core.uitls;import com.fasterxml.jackson.core.JsonParser;import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import lombok.extern.slf4j.Slf4j;import java.text.SimpleDateFormat;/** * @author javahuang * @date 2021/8/6 /@Slf4jpublic class JSONUtil { /* * Transfer object to JSON string * @param object * @return */ public static String toJSONString(Object object) { String result = null; ObjectMapper objectMapper = new ObjectMapper(); // set config of JSON // can use single quote objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true); objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")); try { result = objectMapper.writeValueAsString(object); } catch (JsonProcessingException e) { log.error("Generate JSON String error!" + e.getMessage()); e.printStackTrace(); } return result; }}
package cn.surveyking.server.core.uitls;import org.springframework.cglib.beans.BeanMap;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/** * @author javahuang * @date 2022/5/15 */public class MapBeanUtils { public static <T> Map<String, ?> beanToMap(T bean) { BeanMap beanMap = BeanMap.create(bean); Map<String, Object> map = new HashMap<>(); beanMap.forEach((key, value) -> { map.put(String.valueOf(key), value); }); return map; } public static <T> T mapToBean(Map<String, ?> map, Class<T> clazz) throws IllegalAccessException, InstantiationException { T bean = clazz.newInstance(); BeanMap beanMap = BeanMap.create(bean); beanMap.putAll(map); return bean; } public static <T> List<Map<String, ?>> objectsToMaps(List<T> objList) { List<Map<String, ?>> list = new ArrayList<>(); if (objList != null && objList.size() > 0) { Map<String, ?> map = null; T bean = null; for (int i = 0, size = objList.size(); i < size; i++) { bean = objList.get(i); map = beanToMap(bean); list.add(map); } } return list; } public static <T> List<T> mapsToObjects(List<Map<String, ?>> maps, Class<T> clazz) throws InstantiationException, IllegalAccessException { List<T> list = new ArrayList<>(); if (maps != null && maps.size() > 0) { Map<String, ?> map = null; for (int i = 0, size = maps.size(); i < size; i++) { map = maps.get(i); T bean = mapToBean(map, clazz); list.add(bean); } } return list; }}
/** * Copyright (c) 2017 The JNanoID Authors * Copyright (c) 2017 Aventrix LLC * Copyright (c) 2017 Andrey Sitnik * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of * the Software, and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /package cn.surveyking.server.core.uitls;import java.security.SecureRandom;import java.util.Random;import java.util.Set;/* * A class for generating unique String IDs. * * The implementations of the core logic in this class are based on NanoId, a JavaScript * library by Andrey Sitnik released under the MIT license. (https://github.com/ai/nanoid) * * @author David Klebanoff /public final class NanoIdUtils { /* * <code>NanoIdUtils</code> instances should NOT be constructed in standard * programming. Instead, the class should be used as * <code>NanoIdUtils.randomNanoId();</code>. / private NanoIdUtils() { // Do Nothing } /* * The default random number generator used by this class. Creates cryptographically * strong NanoId Strings. / public static final SecureRandom DEFAULT_NUMBER_GENERATOR = new SecureRandom(); /* * The default alphabet used by this class. Creates url-friendly NanoId Strings using * 64 unique symbols. 去掉 l 避免和 1 产生视觉混淆 / public static final char[] DEFAULT_ALPHABET = "0123456789abcdefghijkmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" .toCharArray(); /* * The default size used by this class. Creates NanoId Strings with slightly more * unique values than UUID v4. / public static final int DEFAULT_SIZE = 21; /* * Static factory to retrieve a url-friendly, pseudo randomly generated, NanoId * String. * * The generated NanoId String will have 21 symbols. * * The NanoId String is generated using a cryptographically strong pseudo random * number generator. * @return A randomly generated NanoId String. / public static String randomNanoId() { return randomNanoId(DEFAULT_NUMBER_GENERATOR, DEFAULT_ALPHABET, DEFAULT_SIZE); } /* * Static factory to retrieve a url-friendly, pseudo randomly generated, NanoId * String. * * The generated NanoId String will have 21 symbols. * * The NanoId String is generated using a cryptographically strong pseudo random * number generator. * @param size The number of symbols in the NanoId String. * @return A randomly generated NanoId String. / public static String randomNanoId(int size) { return randomNanoId(DEFAULT_NUMBER_GENERATOR, DEFAULT_ALPHABET, size); } /* * @param size The number of symbols in the NanoId String. * @param ids A group of ids generated. * @return A randomly generated NanoId String. / public static String randomNanoId(int size, Set<String> ids) { String newId = randomNanoId(size); if (ids.contains(newId)) { return randomNanoId(size, ids); } else { ids.add(newId); return newId; } } /* * Static factory to retrieve a NanoId String. * * The string is generated using the given random number generator. * @param random The random number generator. * @param alphabet The symbols used in the NanoId String. * @param size The number of symbols in the NanoId String. * @return A randomly generated NanoId String. / public static String randomNanoId(final Random random, final char[] alphabet, final int size) { if (random == null) { throw new IllegalArgumentException("random cannot be null."); } if (alphabet == null) { throw new IllegalArgumentException("alphabet cannot be null."); } if (alphabet.length == 0 \|\| alphabet.length >= 256) { throw new IllegalArgumentException("alphabet must contain between 1 and 255 symbols."); } if (size <= 0) { throw new IllegalArgumentException("size must be greater than zero."); } final int mask = (2 << (int) Math.floor(Math.log(alphabet.length - 1) / Math.log(2))) - 1; final int step = (int) Math.ceil(1.6 mask * size / alphabet.length); final StringBuilder idBuilder = new StringBuilder(); while (true) { final byte[] bytes = new byte[step]; random.nextBytes(bytes); for (int i = 0; i < step; i++) { final int alphabetIndex = bytes[i] & mask; if (alphabetIndex < alphabet.length) { idBuilder.append(alphabet[alphabetIndex]); if (idBuilder.length() == size) { return idBuilder.toString(); } } } } }}
package cn.surveyking.server.core.uitls;import net.sourceforge.pinyin4j.PinyinHelper;import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;import static org.apache.commons.lang3.StringUtils.isBlank;/** * @author javahuang * @date 2022/6/5 /public class PinyinUtils { /* * 汉字转拼音 * @param str 要转换的字符串 * @return 汉字转拼音 */ public static String chineseToPinyin(String str) { if (isBlank(str)) { return str; } StringBuilder result = new StringBuilder(); HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat(); format.setCaseType(HanyuPinyinCaseType.LOWERCASE); format.setToneType(HanyuPinyinToneType.WITHOUT_TONE); for (char c : str.toCharArray()) { // 非汉字原样输出 if (Character.toString(c).matches("[\\u4E00-\\u9FA5]+")) { String[] charPinyin = new String[0]; try { charPinyin = PinyinHelper.toHanyuPinyinStringArray(c, format); } catch (BadHanyuPinyinOutputFormatCombination e) { e.printStackTrace(); } if (charPinyin != null) { result.append(charPinyin[0]); } } else { result.append(c); } } return result.toString(); }}
package cn.surveyking.server.core.uitls;import cn.surveyking.server.domain.dto.AnswerView;import cn.surveyking.server.domain.dto.PublicStatisticsView;import cn.surveyking.server.domain.dto.SurveySchema;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.stream.Collectors;/** * @author javahuang * @date 2022/3/23 */public class ProjectStatHelper { final SurveySchema schema; final List<AnswerView> answers; public ProjectStatHelper(SurveySchema schema, List<AnswerView> answers) { this.schema = schema; this.answers = answers; } public PublicStatisticsView stat() { PublicStatisticsView result = new PublicStatisticsView(); result.setCount(answers.size()); Map<String, PublicStatisticsView.QuestionStatistics> questionStatistics = initQuestionStatistics(); answers.forEach(answerView -> { LinkedHashMap<String, Object> answer = answerView.getAnswer(); questionStatistics.entrySet().forEach(entry -> { String questionId = entry.getKey(); PublicStatisticsView.QuestionStatistics qStatistics = entry.getValue(); if (answer.containsKey(questionId)) { qStatistics.setCount(qStatistics.getCount() + 1); qStatistics.getOptionStatistics().forEach(optionStatistics -> { String optionId = optionStatistics.getOptionId(); if (((Map) answer.get(questionId)).containsKey(optionId)) { optionStatistics.setCount(optionStatistics.getCount() + 1); } }); } }); }); result.setQuestionStatistics(questionStatistics); return result; } private Map<String, PublicStatisticsView.QuestionStatistics> initQuestionStatistics() { List<SurveySchema> flatSurveySchema = SchemaHelper.flatSurveySchema(schema); // 只有问题配置了 statEnabled 和选项配置了 quota 属性的题才能进行统计 List<SurveySchema> canStatSchema = flatSurveySchema.stream() .filter(questionSchema -> Boolean.TRUE.equals(questionSchema.getAttribute().getStatEnabled()) \|\| questionSchema.getChildren().stream().filter(x -> x.getAttribute().getQuota() != null) .findFirst().isPresent()) .collect(Collectors.toList()); Map<String, PublicStatisticsView.QuestionStatistics> questionStatistics = new LinkedHashMap<>(); canStatSchema.forEach(item -> { questionStatistics.put(item.getId(), new PublicStatisticsView.QuestionStatistics(0, item.getChildren().stream().map(optionSchema -> { PublicStatisticsView.OptionStatistics optionStatistics = new PublicStatisticsView.OptionStatistics(); optionStatistics.setOptionId(optionSchema.getId()); return optionStatistics; }).collect(Collectors.toList()))); }); return questionStatistics; }}
package cn.surveyking.server.core.uitls;import cn.surveyking.server.core.constant.ErrorCode;import cn.surveyking.server.core.constant.ProjectModeEnum;import cn.surveyking.server.core.exception.ErrorCodeException;import cn.surveyking.server.domain.dto.SurveySchema;import cn.surveyking.server.domain.dto.TemplateRequest;import lombok.SneakyThrows;import org.dhatim.fastexcel.reader.ReadableWorkbook;import org.dhatim.fastexcel.reader.Row;import org.springframework.web.multipart.MultipartFile;import java.io.InputStream;import java.util.;import java.util.stream.Collectors;import java.util.stream.Stream;import static org.apache.commons.lang3.StringUtils.isBlank;import static org.apache.commons.lang3.StringUtils.isNotBlank;/* * @author javahuang * @date 2022/5/31 /public class RepoTemplateExcelParseHelper { private final MultipartFile templateFile; private List<TemplateRequest> result = new ArrayList<>(); private Set<String> ids = new HashSet<>(); /* * 标题与索引的映射关系 / private Map<String, Integer> name2index = new HashMap<>(); public RepoTemplateExcelParseHelper(MultipartFile templateFile) { this.templateFile = templateFile; } @SneakyThrows public List<TemplateRequest> parse() { try (InputStream is = templateFile.getInputStream(); ReadableWorkbook wb = new ReadableWorkbook(is)) { wb.getSheets().forEach(sheet -> { String sheetName = sheet.getName(); try (Stream<Row> rows = sheet.openStream()) { rows.forEach(r -> { int rowNum = r.getRowNum(); if (rowNum == 1) { // 第一行作为行头 parseHeader(r); } else { switch (sheetName) { case "单选题": case "判断题": parseRadio(r); break; case "多选题": parseCheckbox(r); break; case "填空题": parseFillBlank(r); break; case "简答题": parseTextarea(r); break; } } }); } catch (Exception e) { e.printStackTrace(); throw new ErrorCodeException(ErrorCode.FileParseError, e); } }); } return result; } @SneakyThrows private void parseRadio(Row r) { SurveySchema schema = row2schema(r); schema.setType(SurveySchema.QuestionType.Radio); schema.getAttribute().setExamAnswerMode(SurveySchema.ExamScoreMode.onlyOne); TemplateRequest templateRequest = TemplateRequest.builder().questionType(SurveySchema.QuestionType.Radio) .mode(ProjectModeEnum.exam).name(schema.getTitle()).template(schema).build(); result.add(templateRequest); } @SneakyThrows private void parseCheckbox(Row r) { SurveySchema schema = row2schema(r); schema.setType(SurveySchema.QuestionType.Checkbox); schema.getAttribute().setExamAnswerMode(SurveySchema.ExamScoreMode.selectAll); TemplateRequest templateRequest = TemplateRequest.builder().questionType(SurveySchema.QuestionType.Checkbox) .mode(ProjectModeEnum.exam).name(schema.getTitle()).template(schema).build(); result.add(templateRequest); } @SneakyThrows private void parseFillBlank(Row r) { SurveySchema schema = row2schema(r); SurveySchema.QuestionType questionType = schema.getChildren().size() > 1 ? SurveySchema.QuestionType.MultipleBlank : SurveySchema.QuestionType.FillBlank; schema.setType(questionType); schema.getAttribute().setExamAnswerMode(SurveySchema.ExamScoreMode.selectAll); schema.getAttribute().setExamMatchRule(SurveySchema.ExamMatchRule.completeSame); TemplateRequest templateRequest = TemplateRequest.builder().questionType(questionType) .mode(ProjectModeEnum.exam).name(schema.getTitle()).template(schema).build(); result.add(templateRequest); } @SneakyThrows private void parseTextarea(Row r) { SurveySchema schema = row2schema(r); schema.setType(SurveySchema.QuestionType.Textarea); schema.getAttribute().setExamAnswerMode(SurveySchema.ExamScoreMode.selectAll); schema.getAttribute().setExamMatchRule(SurveySchema.ExamMatchRule.completeSame); String correctAnswer = getCellAsString(r, "examCorrectAnswer"); // 简答题没有设置选项，只有答案列，所以需要手动的添加 option schema.setChildren(Collections.singletonList(SurveySchema.builder().id(generateId()) .attribute(SurveySchema.Attribute.builder().examCorrectAnswer(correctAnswer).build()).build())); ; TemplateRequest templateRequest = TemplateRequest.builder().questionType(SurveySchema.QuestionType.Textarea) .mode(ProjectModeEnum.exam).name(schema.getTitle()).template(schema).build(); result.add(templateRequest); } /* * @param currentIndex 当前选项的序号，从 0 开始 * @param rightAnswer 正确答案序号 A/B/C/D * @return / private boolean currentChecked(int currentIndex, String rightAnswer) { if (isBlank(rightAnswer)) { return false; } for (int i = 0; i < rightAnswer.length(); i++) { if (rightAnswer.toUpperCase().codePointAt(i) - 65 == currentIndex) { return true; } } return false; } private SurveySchema row2schema(Row r) { String title = getCellAsString(r, "title"); String correctAnswer = getCellAsString(r, "examCorrectAnswer"); Double examScore = getCellAsDouble(r, "examScore"); String tags = getCellAsString(r, "tags"); List<SurveySchema> optionSchemaList = r.stream() .filter(cell -> cell != null && name2index.get("minOptionIndex") != null && cell.getColumnIndex() >= name2index.get("minOptionIndex") && cell.getColumnIndex() <= name2index.get("maxOptionIndex") && isNotBlank(cell.getText())) .map(x -> { String optionTitle = x.getText(); String examCorrectAnswer = x.getText(); String optionId = generateId(); // 填空题选项存的是答案，单选多选存的是选项的文本 if (name2index.get("isChoice") != null) { // 处理选项 int columnIndex = x.getColumnIndex() - name2index.get("minOptionIndex"); boolean currentCorrect = currentChecked(columnIndex, correctAnswer); examCorrectAnswer = currentCorrect ? optionId : null; } else { optionTitle = null; } SurveySchema optionSchema = SurveySchema.builder().id(optionId).title(optionTitle) .attribute(SurveySchema.Attribute.builder().examCorrectAnswer(examCorrectAnswer).build()) .build(); return optionSchema; }).collect(Collectors.toList()); return SurveySchema.builder().title(title).attribute(SurveySchema.Attribute.builder() // 解析 .examAnalysis(getCellAsString(r, "examAnalysis")) // 分值 .examScore(examScore).build()).id(generateId()) .tags(tags != null ? Arrays.asList(tags.split("\\s\|,")) : null).children(optionSchemaList).build(); } /* * 根据标题解析出来各个选项的顺序 * @param header / private void parseHeader(Row header) { name2index = new HashMap<>(); List<Integer> optionCellIndexes = new ArrayList<>(); header.stream().forEach(cell -> { int columnIndex = cell.getColumnIndex(); String cellText = cell.getText(); switch (cellText) { case "题干": name2index.put("title", columnIndex); break; case "解析": name2index.put("examAnalysis", columnIndex); break; case "分数": case "单空分数": name2index.put("examScore", columnIndex); break; case "答案": name2index.put("examCorrectAnswer", columnIndex); break; case "标签": name2index.put("tags", columnIndex); break; default: if (isNotBlank(cellText) && (cellText.startsWith("选项") \|\| cellText.startsWith("空"))) { // 其他列都解析为答案列 optionCellIndexes.add(columnIndex); if (cellText.startsWith("选项")) { name2index.put("isChoice", -1); } else { name2index.put("isFillBlank", -1); } } break; } }); if (optionCellIndexes.size() > 0) { name2index.put("minOptionIndex", optionCellIndexes.stream().mapToInt(v -> v).min().getAsInt()); name2index.put("maxOptionIndex", optionCellIndexes.stream().mapToInt(v -> v).max().getAsInt()); } } /* * 避免列索引为空时获取值报错 * @param row * @param cellName * @return */ private String getCellAsString(Row row, String cellName) { if (name2index.get(cellName) == null) { return null; } return row.getCellAsString(name2index.get(cellName)).orElse(null); } private Double getCellAsDouble(Row row, String cellName) { if (name2index.get(cellName) == null) { return null; } String value = row.getCellText(name2index.get(cellName)); if (isBlank(value)) { return null; } return Double.parseDouble(value); } private String generateId() { return NanoIdUtils.randomNanoId(4, ids); }}

Subsets and Splits