package cn.huge.module.analysis.controller;
|
|
import cn.huge.base.common.bo.ReturnBO;
|
import cn.huge.base.common.utils.ObjectUtils;
|
import cn.huge.base.common.utils.ReturnFailUtils;
|
import cn.huge.base.common.utils.ReturnSucUtils;
|
import cn.huge.base.config.CurrentUser;
|
import cn.huge.module.analysis.domain.dto.*;
|
import cn.huge.module.analysis.domain.vo.CountRepeateVo;
|
import cn.huge.module.analysis.service.AnalysisService;
|
import cn.huge.module.client.api.impl.CustClientImpl;
|
import cn.huge.module.cust.dto.CtUnitDTO;
|
import cn.huge.module.cust.dto.CtUserDTO;
|
import com.google.common.collect.Maps;
|
import dm.jdbc.util.StringUtil;
|
import org.apache.commons.lang3.StringUtils;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.domain.Page;
|
import org.springframework.data.domain.PageRequest;
|
import org.springframework.data.domain.Sort;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
/**
|
* @title: 纠纷信息主表接口api-web端
|
* @description: 纠纷信息主表接口api-web端
|
* @company: hugeinfo
|
* @author: wangwh
|
* @time: 2024-08-27 10:00:57
|
* @version: 1.0.0
|
*/
|
@Slf4j
|
@RestController
|
@RequestMapping("/api/web/analysis")
|
public class AnalysisWebController {
|
|
@Autowired(required = false)
|
private HttpServletRequest request;
|
|
@Autowired
|
private AnalysisService service;
|
@Autowired
|
private CustClientImpl custClient;
|
|
/**
|
* 获取请求URL参数
|
* @return Map<String, Object>
|
*/
|
private Map<String, Object> getParameter(){
|
Map<String, Object> terms = Maps.newHashMap();
|
// 组织地址社区
|
String queVillage = request.getParameter("queVillage");
|
if (StringUtils.isNotBlank(queVillage)){
|
terms.put("village", queVillage);
|
}
|
// 组织地址街道
|
String queRoad = request.getParameter("queRoad");
|
if (StringUtils.isNotBlank(queRoad)){
|
terms.put("road", queRoad);
|
}
|
// 组织地址区
|
String queArea = request.getParameter("queArea");
|
if (StringUtils.isNotBlank(queArea)){
|
terms.put("area", queArea);
|
}
|
// 组织地址市
|
String queCity = request.getParameter("queCity");
|
if (StringUtils.isNotBlank(queCity)){
|
terms.put("city", queCity);
|
}
|
// 组织地址省
|
String queProv = request.getParameter("queProv");
|
if (StringUtils.isNotBlank(queProv)){
|
terms.put("prov", queProv);
|
}
|
// 纠纷类型
|
String caseType = request.getParameter("caseType");
|
if (StringUtils.isNotBlank(caseType)){
|
terms.put("caseType", caseType);
|
}
|
// 纠纷类型
|
String caseTypeFirst = request.getParameter("caseTypeFirst");
|
if (StringUtils.isNotBlank(caseTypeFirst)){
|
terms.put("caseTypeFirst", caseTypeFirst);
|
}
|
// 登记开始时间
|
String createStart = request.getParameter("createStart");
|
String createEnd = request.getParameter("createEnd");
|
if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
|
terms.put("createStart", createStart);
|
terms.put("createEnd", createEnd);
|
}
|
// 办结时间
|
String closeStart = request.getParameter("closeStart");
|
String closeEnd = request.getParameter("closeEnd");
|
if(StringUtils.isNotBlank(closeStart) && StringUtils.isNotBlank(closeEnd)) {
|
terms.put("closeStart", closeStart);
|
terms.put("closeEnd", closeEnd);
|
}
|
// 事项等级
|
String caseGrade = request.getParameter("caseGrade");
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(caseGrade)){
|
terms.put("caseGrade", caseGrade);
|
}
|
// 事项来源
|
String caseSource = request.getParameter("caseSource");
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(caseSource)){
|
terms.put("caseSource", caseSource);
|
}
|
// 承办部门
|
String mediateUnitId = request.getParameter("mediateUnitId");
|
if (StringUtils.isNotBlank(mediateUnitId)){
|
terms.put("mediateUnitId", mediateUnitId);
|
}
|
// 配合部门
|
String assistUnitId = request.getParameter("assistUnitId");
|
if (StringUtils.isNotBlank(assistUnitId)){
|
terms.put("assistUnitId", assistUnitId);
|
}
|
return terms;
|
}
|
|
/**
|
* 获取请求URL参数(获取区域地址后放入map的名称不一样)
|
* @return Map<String, Object>
|
*/
|
private Map<String, Object> getParameter1(){
|
Map<String, Object> terms = Maps.newHashMap();
|
// 组织地址街道
|
String queRoad = request.getParameter("queRoad");
|
if (StringUtils.isNotBlank(queRoad)){
|
terms.put("queRoad", queRoad);
|
}else{
|
// 组织地址区
|
String queArea = request.getParameter("queArea");
|
if (StringUtils.isNotBlank(queArea)){
|
terms.put("queArea", queArea);
|
}else{
|
// 组织地址市
|
String queCity = request.getParameter("queCity");
|
if (StringUtils.isNotBlank(queCity)){
|
terms.put("queCity", queCity);
|
}else{
|
// 组织地址省
|
String queProv = request.getParameter("queProv");
|
if (StringUtils.isNotBlank(queProv)){
|
terms.put("queProv", queProv);
|
}
|
}
|
}
|
}
|
// 纠纷类型
|
String caseType = request.getParameter("caseType");
|
if (StringUtils.isNotBlank(caseType)){
|
terms.put("caseType", caseType);
|
}
|
// 纠纷类型
|
String caseTypeFirst = request.getParameter("caseTypeFirst");
|
if (StringUtils.isNotBlank(caseTypeFirst)){
|
terms.put("caseTypeFirst", caseTypeFirst);
|
}
|
// 登记开始时间
|
String createStart = request.getParameter("createStart");
|
String createEnd = request.getParameter("createEnd");
|
if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
|
terms.put("createStart", createStart);
|
terms.put("createEnd", createEnd);
|
}
|
// 办结时间
|
String closeStart = request.getParameter("closeStart");
|
String closeEnd = request.getParameter("closeEnd");
|
if(StringUtils.isNotBlank(closeStart) && StringUtils.isNotBlank(closeEnd)) {
|
terms.put("closeStart", closeStart);
|
terms.put("closeEnd", closeEnd);
|
}
|
// 事项等级
|
String caseGrade = request.getParameter("caseGrade");
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(caseGrade)){
|
terms.put("caseGrade", caseGrade);
|
}
|
// 事项来源
|
String caseSource = request.getParameter("caseSource");
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(caseSource)){
|
terms.put("caseSource", caseSource);
|
}
|
// 事项来源
|
String canal = request.getParameter("canal");
|
if (org.apache.commons.lang3.StringUtils.isNotBlank(canal)){
|
terms.put("canal", canal);
|
}
|
// 承办部门
|
String mediateUnitId = request.getParameter("mediateUnitId");
|
if (StringUtils.isNotBlank(mediateUnitId)){
|
terms.put("mediateUnitId", mediateUnitId);
|
}
|
// 配合部门
|
String assistUnitId = request.getParameter("assistUnitId");
|
if (StringUtils.isNotBlank(assistUnitId)){
|
terms.put("assistUnitId", assistUnitId);
|
}
|
//任务是否完成
|
String taskStatus = request.getParameter("taskStatus");
|
if (StringUtils.isNotBlank(taskStatus)){
|
terms.put("taskStatus", taskStatus);
|
}
|
return terms;
|
}
|
/**
|
* 统计重复来访案件数量-根据案件类型分组
|
* 此接口用于分析和统计在同一案件类型下重复来访的案件数量
|
* @url {ctx}/api/web/analysis/countRepeatedCasesByCaseType
|
* @param countRepeateVo 包含查询条件的请求体，用于指定统计范围
|
* @return ReturnBO
|
*/
|
@PostMapping("/countRepeatedCasesByCaseType")
|
public ReturnBO countRepeatedCasesByCaseType(@RequestBody CountRepeateVo countRepeateVo) {
|
try{
|
// 设置按案件类型分组的标志为true
|
countRepeateVo.setGroupByCaseType("true");
|
|
// 调用服务层方法统计重复来访案件数量
|
List<CountRepeateDto> countRepeateDtoList = service.countRepeatedCases(countRepeateVo);
|
|
// 使用ReturnSucUtils工具类返回成功信息和统计结果
|
return ReturnSucUtils.getRepInfo("请求成功",countRepeateDtoList);
|
}catch (Exception e){
|
// 捕获异常，并记录错误日志
|
log.error("统计重复来访案件数量异常",e);
|
|
// 使用ReturnFailUtils工具类返回错误信息
|
return ReturnFailUtils.getRepInfo(e.getMessage());
|
}
|
}
|
|
/**
|
* 统计重复来访案件数量-根据地区分组
|
* @url {ctx}/api/web/analysis/countRepeatedCasesByArea
|
* @param countRepeateVo 包含查询条件的请求体，用于指定统计范围
|
* @return ReturnBO 包含统计结果的返回对象
|
*/
|
@PostMapping("/countRepeatedCasesByArea")
|
public ReturnBO countRepeatedCasesByArea(@RequestBody CountRepeateVo countRepeateVo) {
|
try{
|
// 创建一个映射，用于存储不同状态下重复来访案件的统计结果
|
Map<String, List<CountRepeateDto>> collect = new HashMap<>();
|
|
// 判断是否提供了结案时间，如果没有，则查询未办结的重复来访案件
|
if(StringUtil.isEmpty(countRepeateVo.getCloseStart()) && StringUtil.isEmpty(countRepeateVo.getCloseEnd())){
|
countRepeateVo.setIsFinish("false");
|
List<CountRepeateDto> countRepeateDtoList = service.countRepeatedCasesByArea(countRepeateVo);
|
collect.put("未办结重复来访",countRepeateDtoList);
|
}else {
|
// 如果提供了关闭时间范围，则初始化未办结案件列表为空
|
collect.put("未办结重复来访",new ArrayList<>());
|
}
|
|
// 统计已办结的重复来访案件
|
countRepeateVo.setIsFinish("true");
|
List<CountRepeateDto> countRepeateDtoListIsFinish = service.countRepeatedCasesByArea(countRepeateVo);
|
collect.put("已办结重复来访",countRepeateDtoListIsFinish);
|
|
// 返回统计结果
|
return ReturnSucUtils.getRepInfo("请求成功",collect);
|
}catch (Exception e){
|
// 记录异常信息并返回错误响应
|
log.error("统计重复来访案件数量异常",e);
|
return ReturnFailUtils.getRepInfo(e.getMessage());
|
}
|
}
|
|
/**
|
* 统计重复来访案件数量-根据时间分组
|
* @url {ctx}/api/web/analysis/countRepeatedCasesByCaseType
|
* @param countRepeateVo 包含查询条件的请求体
|
* @return ReturnBO 包含统计结果的返回对象
|
*/
|
@PostMapping("/countRepeatedCasesByTime")
|
public ReturnBO countRepeatedCasesByTime(@RequestBody CountRepeateVo countRepeateVo) {
|
try{
|
// 创建一个映射，用于存储不同状态下重复来访案件的统计结果
|
Map<String, List<CountRepeateDto>> collect = new HashMap<>();
|
|
// 判断是否提供了结案时间，如果没有，则查询未办结的重复来访案件
|
if((StringUtil.isEmpty(countRepeateVo.getCloseStart())) && (StringUtil.isEmpty(countRepeateVo.getCloseEnd()))){
|
countRepeateVo.setIsFinish("false");
|
List<CountRepeateDto> countRepeateDtoList = service.countRepeatedCasesByTime(countRepeateVo);
|
collect.put("未办结重复来访",countRepeateDtoList);
|
}else {
|
// 如果提供了结案时间，则初始化未办结重复来访案件列表为空
|
collect.put("未办结重复来访",new ArrayList<>());
|
}
|
|
// 查询已办结的重复来访案件
|
countRepeateVo.setIsFinish("true");
|
List<CountRepeateDto> countRepeateDtoListIsFinish = service.countRepeatedCasesByTime(countRepeateVo);
|
collect.put("已办结重复来访",countRepeateDtoListIsFinish);
|
|
// 返回统计结果
|
return ReturnSucUtils.getRepInfo("请求成功",collect);
|
}catch (Exception e){
|
// 异常处理，记录日志并返回错误信息
|
log.error("统计重复来访案件数量异常",e);
|
return ReturnFailUtils.getRepInfo(e.getMessage());
|
}
|
}
|
|
/**
|
* 条件查询多个
|
* @url {ctx}/api/web/analysis/statistics
|
* @return Object
|
*/
|
@GetMapping("/statistics")
|
public Object statistics(@CurrentUser String userId) {
|
try {
|
// 获取当前登录用户
|
CtUserDTO loginUser = custClient.clientGetUserAll(userId);
|
CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
|
Map<String, Object> terms = getParameter1();
|
//拷贝条件，避免影响原参数
|
AvgDurationDTO avgDurationDTO = service.AvgDuration(terms, loginUser, ctUnitDTO);
|
|
return ReturnSucUtils.getRepInfo(avgDurationDTO);
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 超时任务数量查询
|
* @url {ctx}/api/web/analysis/timeoutTask
|
* @return Object
|
*/
|
@GetMapping("/timeoutTask")
|
public Object timeoutTask(@CurrentUser String userId) {
|
try {
|
// 获取当前登录用户
|
CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
|
Map<String, Object> terms = getParameter1();
|
StatisticsGroupDTO statisticsGroupDTO = new StatisticsGroupDTO();
|
|
statisticsGroupDTO = service.TimeoutTask(terms, ctUnitDTO);
|
return ReturnSucUtils.getRepInfo(statisticsGroupDTO);
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 超时任务数量查询
|
* @url {ctx}/api/web/analysis/listTimeOutTaskGroup
|
* @return Object
|
*/
|
@GetMapping("/listTimeOutTaskGroup")
|
public Object listTimeOutTaskGroup(@CurrentUser String userId, @RequestParam(value = "queryType") int queryType) {
|
try {
|
// 获取当前登录用户
|
CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
|
Map<String, Object> terms = getParameter1();
|
List<TimeOutTaskGroupDTO> timeOutTaskGroupDTOList = new ArrayList<>();
|
|
timeOutTaskGroupDTOList = service.listTimeOutTaskGroup(terms, ctUnitDTO, queryType);
|
return ReturnSucUtils.getRepInfo(timeOutTaskGroupDTOList);
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 效能分析-平均时长-分组列表
|
* @url {ctx}/api/web/analysis/AvgDurationGroup
|
* @return Object
|
*/
|
@GetMapping("/AvgDurationGroup")
|
public Object AvgDurationGroup(@CurrentUser String userId) {
|
try {
|
Map<String, Object> terms = getParameter1();
|
// 排序字段
|
String sortColmn1 = request.getParameter("sortColmn");
|
int sortColmn = 0;
|
if (StringUtils.isNotBlank(sortColmn1)){
|
sortColmn = Integer.parseInt(sortColmn1);
|
}
|
// 排序方式
|
String sortType1 = request.getParameter("sortType");
|
int sortType = 0;
|
if (StringUtils.isNotBlank(sortType1)){
|
sortType = Integer.parseInt(sortType1);
|
}
|
|
return ReturnSucUtils.getRepInfo(service.AvgDurationGroup(terms, sortType, sortColmn));
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 效能分析-平均时长-统计图
|
* @url {ctx}/api/web/analysis/AvgDurationChartsGroup
|
* @return Object
|
*/
|
@GetMapping("/AvgDurationChartsGroup")
|
public Object AvgDurationChartsGroup(@CurrentUser String userId) {
|
try {
|
Map<String, Object> terms = getParameter1();
|
return ReturnSucUtils.getRepInfo(service.AvgDurationChartsGroup(terms));
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 分页查询受理超时案件
|
* @url {ctx}/api/web/analysis/pageQuantity
|
* @param page 页码
|
* @param size 每页数量
|
* @param queryType 查询类型（1：分派；2、签收；3、受理；4、督办）
|
* @return
|
*/
|
@GetMapping("/pageQuantity")
|
public Object pageQuantity(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
|
@RequestParam(value = "queryType") int queryType, @CurrentUser String userId) {
|
try {
|
Map<String, Object> terms = getParameter1();
|
// 排序字段
|
String sortColmn1 = request.getParameter("sortColmn");
|
int sortColmn = 1;
|
if (StringUtils.isNotBlank(sortColmn1)){
|
sortColmn = Integer.parseInt(sortColmn1);
|
}
|
// 排序方式
|
String sortType1 = request.getParameter("sortType");
|
int sortType = 1;
|
if (StringUtils.isNotBlank(sortType1)){
|
sortType = Integer.parseInt(sortType1);
|
}
|
Sort sort = null;
|
String sortName = null;
|
switch (sortColmn){
|
case 1:
|
sortName = "turnaroundTime";
|
break;
|
case 2:
|
sortName = "timeLimit";
|
break;
|
case 3:
|
sortName = "caseGrade";
|
break;
|
case 4:
|
sortName = "superviseCount";
|
break;
|
default:
|
sortName = "turnaroundTime";
|
break;
|
}
|
switch (sortType){
|
case 1:
|
sort = Sort.by(Sort.Direction.ASC, sortName);
|
break;
|
case 2:
|
sort = Sort.by(Sort.Direction.DESC, sortName);
|
break;
|
default:
|
sort = Sort.by(Sort.Direction.ASC, sortName);
|
break;
|
}
|
if(ObjectUtils.isEmpty(sort)){
|
sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
|
}
|
PageRequest pageRequest = PageRequest.of(page-1, size, sort);
|
Page<TimeoutTaskInfoDTO> timeoutTaskInfoDTOPage = null;
|
|
CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
|
if(1 == queryType){
|
timeoutTaskInfoDTOPage = service.pageFPQuantity(pageRequest, terms);
|
}else if(2 == queryType){
|
timeoutTaskInfoDTOPage = service.pageSLQuantity(pageRequest, terms);
|
}else if(3 == queryType){
|
timeoutTaskInfoDTOPage = service.pageDBQuantity(pageRequest, terms);
|
}else if(4 == queryType){
|
timeoutTaskInfoDTOPage = service.pageAllQuantity(pageRequest, terms);
|
}
|
return ReturnSucUtils.getRepInfo(timeoutTaskInfoDTOPage);
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 分组任务流转统计
|
* @url {ctx}/api/web/analysis/statisticsCirculation
|
* @return
|
*/
|
@GetMapping("/statisticsCirculation")
|
public Object statisticsCirculation() {
|
try {
|
Map<String, Object> terms = getParameter1();
|
// 排序字段
|
String sortColmn1 = request.getParameter("sortColmn");
|
int sortColmn = 0;
|
if (StringUtils.isNotBlank(sortColmn1)){
|
sortColmn = Integer.parseInt(sortColmn1);
|
}
|
// 排序方式
|
String sortType1 = request.getParameter("sortType");
|
int sortType = 0;
|
if (StringUtils.isNotBlank(sortType1)){
|
sortType = Integer.parseInt(sortType1);
|
}
|
return ReturnSucUtils.getRepInfo(service.statisticsCirculation(terms, sortType, sortColmn));
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 效能分析-分组任务-统计图
|
* @url {ctx}/api/web/analysis/statisticsCirculationCharts
|
* @return
|
*/
|
@GetMapping("/statisticsCirculationCharts")
|
public Object statisticsCirculationCharts(@CurrentUser String userId) {
|
try {
|
Map<String, Object> terms = getParameter1();
|
return ReturnSucUtils.getRepInfo(service.statisticsCirculationCharts(terms));
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 解纷态势-分组查询扬言极端数量
|
* @url {ctx}/api/web/analysis/statisticsYYJDQuantity
|
* @return Object
|
*/
|
@GetMapping("/statisticsYYJDQuantity")
|
|
public Object statisticsYYJDQuantity(@CurrentUser String userId) {
|
try {
|
Map<String, Object> terms = getParameter();
|
// 组织地址社区
|
String sortType = request.getParameter("sortType");
|
if (StringUtils.isNotBlank(sortType)){
|
terms.put("sortType", sortType);
|
}
|
// 获取当前登录用户
|
CtUserDTO loginUser = custClient.clientGetUserAll(userId);
|
CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
|
return ReturnSucUtils.getRepInfo(service.statisticsYYJDQuantity(terms, ctUnitDTO));
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
|
/**
|
* 查询流转情况列表
|
* @url {ctx}/api/web/analysis/listStatisticsCirculation
|
* @return
|
*/
|
@GetMapping("/listStatisticsCirculation")
|
public Object listStatisticsCirculation(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
|
@RequestParam(value = "caseStatus") String caseStatus,
|
@RequestParam(value = "regionCode") String regionCode, @RequestParam(value = "regionName") String regionName) {
|
try {
|
Map<String, Object> terms = getParameter1();
|
if(StringUtils.isNotBlank(caseStatus)){
|
terms.put("caseStatus", caseStatus);
|
}
|
if(StringUtils.isNotBlank(regionCode) && StringUtils.isNotBlank(regionName)){
|
if(regionName.matches(".*市")){
|
terms.put("queCity", regionCode);
|
}else if(regionName.matches(".*区")){
|
terms.put("queArea", regionCode);
|
}else if(regionName.contains("街道") || regionName.matches(".*街") || regionName.matches(".*镇")){
|
terms.put("queRoad", regionCode);
|
}
|
}
|
Sort sort = Sort.by(Sort.Direction.DESC, "t3.create_time");
|
PageRequest pageRequest = PageRequest.of(page - 1, size, sort);
|
return ReturnSucUtils.getRepInfo(service.listStatisticsCirculation(terms, pageRequest));
|
} catch (Exception e) {
|
return ReturnFailUtils.getRepInfo();
|
}
|
}
|
}
|
