package cn.huge.module.cases.controller.web;

import cn.huge.base.common.utils.DateUtils;
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.cases.domain.dto.*;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.service.CaseInfoService;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.cust.dto.CtUserDTO;
import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
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.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @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/caseInfo")
public class CaseInfoWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private CaseInfoService service;

    private Map<String,Object> getParameterAll() {
        Map<String, Object> terms = getParameter();
//            // 来访时间
        String visitTimeStart = request.getParameter("visitTimeStart");
        String visitTimeEnd = request.getParameter("visitTimeEnd");
        if(StringUtils.isNotBlank(visitTimeStart) && StringUtils.isNotBlank(visitTimeEnd)) {
            terms.put("visitTimeStart", visitTimeStart + " 00:00:00");
            terms.put("visitTimeEnd", visitTimeEnd + " 23:59:59");
        }
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart+ " 00:00:00");
            terms.put("createEnd", createEnd+ " 23:59:59");
        }
        String closeStart = request.getParameter("closeStart");
        String closeEnd = request.getParameter("closeEnd");
        if(StringUtils.isNotBlank(closeStart) && StringUtils.isNotBlank(closeEnd)) {
            terms.put("createStart", closeStart+ " 00:00:00");
            terms.put("createEnd", closeEnd+ " 23:59:59");
        }
        String fileStart = request.getParameter("fileStart");
        String fileEnd = request.getParameter("fileEnd");
        if(StringUtils.isNotBlank(fileStart) && StringUtils.isNotBlank(fileEnd)) {
            terms.put("createStart", fileStart+ " 00:00:00");
            terms.put("createEnd", fileEnd+ " 23:59:59");
        }
        String areaType = request.getParameter("areaType");
        if (StringUtils.isNotBlank(areaType)){
            terms.put("areaType", areaType);
        }
        // 实际调解组织编号
        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 mediateUnitName = request.getParameter("mediateUnitName");
        if (StringUtils.isNotBlank(mediateUnitName)){
            terms.put("mediateUnitName", mediateUnitName);
        }
        // 配合组织，多个用,隔开
        String assistUnitName = request.getParameter("assistUnitName");
        if (StringUtils.isNotBlank(assistUnitName)){
            terms.put("assistUnitName", assistUnitName);
        }
        // 配合组织，多个用,隔开
        String evaluateGrade = request.getParameter("evaluateGrade");
        if (StringUtils.isNotBlank(evaluateGrade)){
            terms.put("evaluateGrade", evaluateGrade);
        }
        // 配合组织，多个用,隔开
        String mediResult = request.getParameter("mediResult");
        if (StringUtils.isNotBlank(mediResult)){
            terms.put("mediResult", mediResult);
        }
        String peopleNum = request.getParameter("peopleNum");
        if (StringUtils.isNotBlank(peopleNum)){
            String[] split = peopleNum.split("-");
            String number = split[0];
            if(number.equals("0") && split.length==1){
                terms.put("peopleNumEnd", split[0]);
            }else{
                terms.put("peopleNumStart", split[0]);
                if(split.length>1){
                    terms.put("peopleNumEnd", split[1]);
                }
            }
        }
        String amount = request.getParameter("amount");
        if (StringUtils.isNotBlank(amount)){
            String[] split = amount.split("-");
            String number = split[0];
            if(number.equals("0") && split.length==1){
                terms.put("amountEnd", split[0]);
            }else{
                terms.put("amountStart", split[0]);
                if(split.length>1){
                    terms.put("amountEnd", split[1]);
                }
            }
        }
        return terms;
    }

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 主键编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 事项标题
        String caseTitle = request.getParameter("caseTitle");
        if (StringUtils.isNotBlank(caseTitle)){
            terms.put("caseTitle", caseTitle);
        }
        // 事项编号
        String caseRef = request.getParameter("caseRef");
        if (StringUtils.isNotBlank(caseRef)){
            terms.put("caseRef", caseRef);
        }
        // 事项等级
        String caseLevel = request.getParameter("caseLevel");
        if (StringUtils.isNotBlank(caseLevel)){
            terms.put("caseLevel", caseLevel);
        }
        // 来访时间
        String visitTime = request.getParameter("visitTime");
        if (StringUtils.isNotBlank(visitTime)){
            terms.put("visitTime", visitTime);
        }
        // 来访人数
        String visitPeopleNum = request.getParameter("visitPeopleNum");
        if (StringUtils.isNotBlank(visitPeopleNum)){
            terms.put("visitPeopleNum", visitPeopleNum);
        }
        // 调解类型
        String mediType = request.getParameter("mediType");
        if (StringUtils.isNotBlank(mediType)){
            terms.put("mediType", mediType);
        }
        // 调解类型名称
        String mediTypeName = request.getParameter("mediTypeName");
        if (StringUtils.isNotBlank(mediTypeName)){
            terms.put("mediTypeName", mediTypeName);
        }
        // 纠纷一级类型
        String caseTypeFirst = request.getParameter("caseTypeFirst");
        if (StringUtils.isNotBlank(caseTypeFirst)){
            terms.put("caseTypeFirst", caseTypeFirst);
        }
        // 纠纷一级类型名称
        String caseTypeFirstName = request.getParameter("caseTypeFirstName");
        if (StringUtils.isNotBlank(caseTypeFirstName)){
            terms.put("caseTypeFirstName", caseTypeFirstName);
        }
        // 纠纷类型
        String caseType = request.getParameter("caseType");
        if (StringUtils.isNotBlank(caseType)){
            terms.put("caseType", caseType);
        }
        // 纠纷类型名称
        String caseTypeName = request.getParameter("caseTypeName");
        if (StringUtils.isNotBlank(caseTypeName)){
            terms.put("caseTypeName", caseTypeName);
        }
        // 纠纷发生时间
        String occurTime = request.getParameter("occurTime");
        if (StringUtils.isNotBlank(occurTime)){
            terms.put("occurTime", occurTime);
        }
        // 纠纷发生地详细地址
        String addr = request.getParameter("addr");
        if (StringUtils.isNotBlank(addr)){
            terms.put("addr", addr);
        }
        // 纠纷发生地经度
        String lng = request.getParameter("lng");
        if (StringUtils.isNotBlank(lng)){
            terms.put("lng", lng);
        }
        // 纠纷发生地纬度
        String lat = request.getParameter("lat");
        if (StringUtils.isNotBlank(lat)){
            terms.put("lat", lat);
        }
        // 纠纷发生地网格地址
        String wgAddr = request.getParameter("wgAddr");
        if (StringUtils.isNotBlank(wgAddr)){
            terms.put("wgAddr", wgAddr);
        }
        // 纠纷发生地网格地址经度
        String wgLng = request.getParameter("wgLng");
        if (StringUtils.isNotBlank(wgLng)){
            terms.put("wgLng", wgLng);
        }
        // 纠纷发生地网格地址纬度
        String wgLat = request.getParameter("wgLat");
        if (StringUtils.isNotBlank(wgLat)){
            terms.put("wgLat", wgLat);
        }
        // 问题属地省
        String queProv = request.getParameter("queProv");
        if (StringUtils.isNotBlank(queProv)){
            terms.put("queProv", queProv);
        }
        // 问题属地省名称
        String queProvName = request.getParameter("queProvName");
        if (StringUtils.isNotBlank(queProvName)){
            terms.put("queProvName", queProvName);
        }
        // 问题属地市
        String queCity = request.getParameter("queCity");
        if (StringUtils.isNotBlank(queCity)){
            terms.put("queCity", queCity);
        }
        // 问题属地市名称
        String queCityName = request.getParameter("queCityName");
        if (StringUtils.isNotBlank(queCityName)){
            terms.put("queCityName", queCityName);
        }
        // 问题属地区
        String queArea = request.getParameter("queArea");
        if (StringUtils.isNotBlank(queArea)){
            terms.put("queArea", queArea);
        }
        // 问题属地区名称
        String queAreaName = request.getParameter("queAreaName");
        if (StringUtils.isNotBlank(queAreaName)){
            terms.put("queAreaName", queAreaName);
        }
        // 问题属地街道
        String queRoad = request.getParameter("queRoad");
        if (StringUtils.isNotBlank(queRoad)){
            terms.put("queRoad", queRoad);
        }
        // 问题属地街道名称
        String queRoadName = request.getParameter("queRoadName");
        if (StringUtils.isNotBlank(queRoadName)){
            terms.put("queRoadName", queRoadName);
        }
        // 问题属地社区
        String queVillage = request.getParameter("queVillage");
        if (StringUtils.isNotBlank(queVillage)){
            terms.put("queVillage", queVillage);
        }
        // 问题属地社区名称
        String queVillageName = request.getParameter("queVillageName");
        if (StringUtils.isNotBlank(queVillageName)){
            terms.put("queVillageName", queVillageName);
        }
        // 涉及人数
        String peopleNum = request.getParameter("peopleNum");
        if (StringUtils.isNotBlank(peopleNum)){
            terms.put("peopleNum", peopleNum);
        }
        // 涉及金额
        String amount = request.getParameter("amount");
        if (StringUtils.isNotBlank(amount)){
            terms.put("amount", amount);
        }
        // 涉及人群
        String crowd = request.getParameter("crowd");
        if (StringUtils.isNotBlank(crowd)){
            terms.put("crowd", crowd);
        }
        // 涉及人群名称
        String crowdName = request.getParameter("crowdName");
        if (StringUtils.isNotBlank(crowdName)){
            terms.put("crowdName", crowdName);
        }
        // 事项来源
        String canal = request.getParameter("canal");
        if (StringUtils.isNotBlank(canal)){
            terms.put("canal", canal);
        }
        // 事项来源名称
        String canalName = request.getParameter("canalName");
        if (StringUtils.isNotBlank(canalName)){
            terms.put("canalName", canalName);
        }
        // 来访形式
        String visitWay = request.getParameter("visitWay");
        if (StringUtils.isNotBlank(visitWay)){
            terms.put("visitWay", visitWay);
        }
        // 来访形式名称
        String visitWayName = request.getParameter("visitWayName");
        if (StringUtils.isNotBlank(visitWayName)){
            terms.put("visitWayName", visitWayName);
        }
        // 事项概况
        String caseDes = request.getParameter("caseDes");
        if (StringUtils.isNotBlank(caseDes)){
            terms.put("caseDes", caseDes);
        }
        // 事项申请
        String caseClaim = request.getParameter("caseClaim");
        if (StringUtils.isNotBlank(caseClaim)){
            terms.put("caseClaim", caseClaim);
        }
        // 是否重大矛盾纠纷，0：否，1：是
        String majorStatus = request.getParameter("majorStatus");
        if (StringUtils.isNotBlank(majorStatus)){
            terms.put("majorStatus", majorStatus);
        }
        // 纠纷来源
        String source = request.getParameter("source");
        if (StringUtils.isNotBlank(source)){
            terms.put("source", source);
        }
        // 纠纷来源名称
        String sourceName = request.getParameter("sourceName");
        if (StringUtils.isNotBlank(sourceName)){
            terms.put("sourceName", sourceName);
        }
        // 矛调号
        String caseNo = request.getParameter("caseNo");
        if (StringUtils.isNotBlank(caseNo)){
            terms.put("caseNo", caseNo);
        }
        // 民诉前调号
        String mediateNo = request.getParameter("mediateNo");
        if (StringUtils.isNotBlank(mediateNo)){
            terms.put("mediateNo", mediateNo);
        }
        // 民诉前调书号
        String mediateBookNo = request.getParameter("mediateBookNo");
        if (StringUtils.isNotBlank(mediateBookNo)){
            terms.put("mediateBookNo", mediateBookNo);
        }
        // 诉讼案号
        String civilNo = request.getParameter("civilNo");
        if (StringUtils.isNotBlank(civilNo)){
            terms.put("civilNo", civilNo);
        }
        // 申请方当事人名称
        String plaintiffs = request.getParameter("plaintiffs");
        if (StringUtils.isNotBlank(plaintiffs)){
            terms.put("plaintiffs", plaintiffs);
        }
        // 申请方代理人名称
        String pagents = request.getParameter("pagents");
        if (StringUtils.isNotBlank(pagents)){
            terms.put("pagents", pagents);
        }
        // 被申请方当事人名称
        String defendants = request.getParameter("defendants");
        if (StringUtils.isNotBlank(defendants)){
            terms.put("defendants", defendants);
        }
        // 被申请方代理人名称
        String dagents = request.getParameter("dagents");
        if (StringUtils.isNotBlank(dagents)){
            terms.put("dagents", dagents);
        }
        // 登记组织编号
        String inputUnitId = request.getParameter("inputUnitId");
        if (StringUtils.isNotBlank(inputUnitId)){
            terms.put("inputUnitId", inputUnitId);
        }
        // 登记组织名称
        String inputUnitName = request.getParameter("inputUnitName");
        if (StringUtils.isNotBlank(inputUnitName)){
            terms.put("inputUnitName", inputUnitName);
        }
        // 登记人编号
        String inputUserId = request.getParameter("inputUserId");
        if (StringUtils.isNotBlank(inputUserId)){
            terms.put("inputUserId", inputUserId);
        }
        // 登记人名称
        String inputUserName = request.getParameter("inputUserName");
        if (StringUtils.isNotBlank(inputUserName)){
            terms.put("inputUserName", inputUserName);
        }
        // 登记方式，1：正常登记，2：案件导入
        String inputWay = request.getParameter("inputWay");
        if (StringUtils.isNotBlank(inputWay)){
            terms.put("inputWay", inputWay);
        }
        // 事项状态，1：待分派，2：待签收，3：待受理，4：化解中，5：结案审核，6：待评价，7：已归档，8：不予受理
        String status = request.getParameter("status");
        if (StringUtils.isNotBlank(status)){
            terms.put("status", status);
        }
        // 事项状态名称
        String statusName = request.getParameter("statusName");
        if (StringUtils.isNotBlank(statusName)){
            terms.put("statusName", statusName);
        }
        // 事项进度，1：来访登记，2：事件流转，3：办理反馈，4：结案申请，5：当事人评价，6：结案归档
        String process = request.getParameter("process");
        if (StringUtils.isNotBlank(process)){
            terms.put("process", process);
        }
        // 事项进度名称
        String processName = request.getParameter("processName");
        if (StringUtils.isNotBlank(processName)){
            terms.put("processName", processName);
        }
        // 对外展示事项进度，1：待受理，2：化解中，3：已结案，4：不予受理
        String infoProcess = request.getParameter("process");
        if (StringUtils.isNotBlank(infoProcess)){
            terms.put("infoProcess", infoProcess);
        }
        // 对外展示事项进度
        String infoProcessName = request.getParameter("infoProcessName");
        if (StringUtils.isNotBlank(infoProcessName)){
            terms.put("infoProcessName", infoProcessName);
        }
        // 小程序是否可见，0：不可见，1：可见
        String partyShow = request.getParameter("partyShow");
        if (StringUtils.isNotBlank(partyShow)){
            terms.put("partyShow", partyShow);
        }
        // 意向调解组织编号
        String wantUnitId = request.getParameter("wantUnitId");
        if (StringUtils.isNotBlank(wantUnitId)){
            terms.put("wantUnitId", wantUnitId);
        }
        // 意向调解组织名称
        String wantUnitName = request.getParameter("wantUnitName");
        if (StringUtils.isNotBlank(wantUnitName)){
            terms.put("wantUnitName", wantUnitName);
        }
        // 意向调解员编号
        String wantUserId = request.getParameter("wantUserId");
        if (StringUtils.isNotBlank(wantUserId)){
            terms.put("wantUserId", wantUserId);
        }
        // 意向调解员名称
        String wantUserName = request.getParameter("wantUserName");
        if (StringUtils.isNotBlank(wantUserName)){
            terms.put("wantUserName", wantUserName);
        }
        // 删除状态，0：未删除，1：已删除
        String deleteStatus = request.getParameter("deleteStatus");
        if (StringUtils.isNotBlank(deleteStatus)){
            terms.put("deleteStatus", deleteStatus);
        }
        // 顾客编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        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 updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/caseInfo/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/caseInfo/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<CaseInfo> caseInfoPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseInfoPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/caseInfo/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/caseInfo/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/caseInfo/saveCaseInfo
    * @param caseInfo 实体对象
    * @return Object
    */
    @PostMapping("/saveCaseInfo")
    public Object saveCaseInfo(@RequestBody CaseInfo caseInfo) {
        try {
            service.saveCaseInfo(caseInfo);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * PC端-纠纷登记-保存纠纷信息-正常案件
     * @url {ctx}/api/web/caseInfo/caseRegister
     * @param registerSaveDTO 实体对象
     */
    @PostMapping("/caseRegister")
    public Object caseRegister(@CurrentUser String userId, @RequestBody RegisterSaveDTO registerSaveDTO) {
        try {
            String caseId = service.caseRegister(registerSaveDTO, userId);
            return ReturnSucUtils.getRepInfo(caseId);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * PC端-正式案件-查询纠纷信息
     * @url {ctx}/api/web/caseInfo/getCaseInfo?id=
     * @param id 纠纷编号
     * @return Object
     */
    @GetMapping("/getCaseInfo")
    public Object getCaseInfo(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getCaseInfo(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * PC端-查询档案信息
     * @url {ctx}/api/web/caseInfo/getCaseArchivesInfo?id=
     * @param id 纠纷编号
     * @return Object
     */
    @GetMapping("/getCaseArchivesInfo")
    public Object getCaseArchivesInfo(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getCaseArchivesInfo(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }


    /**
     * 综合查询
     * @url {ctx}/api/web/caseInfo/pageQueryAll
     * @param page 页码
     * @param size 每页数量
     * @return Object
     */
    @GetMapping("/pageQueryAll")
    public Object pageQueryAll(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameterAll();
            Sort sort = null;
            String sortName = null;
            String sortColmnStr = request.getParameter("sortColmn");
            String sortTypeStr = request.getParameter("sortType");
            int sortColmn = 1;
            int sortType = 1;
            if (StringUtils.isNotBlank(sortColmnStr)) {
                sortColmn = Integer.valueOf(sortColmnStr);
            }
            if (StringUtils.isNotBlank(sortTypeStr)) {
                sortType = Integer.valueOf(sortTypeStr);
            }
            switch (sortColmn) {
                case 1:
                    sortName = "a.create_time";
                    break;
                case 2:
                    sortName = "b.close_time";
                    break;
            }
            switch (sortType) {
                case 1:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
                case 2:
                    sort = Sort.by(Sort.Direction.DESC, sortName);
                    break;
            }
            if (ObjectUtils.isEmpty(sort)) {
                sort = Sort.by(Sort.Direction.DESC, "a.create_time");
            }
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<CasePageDTO> caseInfoPage = service.pageQueryAll(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseInfoPage);
        } catch (Exception e) {
            log.error("Controller接口[CaseInfoWebController.pageQueryAll]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 综合查询-导出
     *
     * @return Object
     * @url {ctx}/api/web/caseInfo/exportQueryAll
     */
    @RequestMapping("/exportQueryAll")
    public void exportQueryAll(HttpServletResponse response) {
        try {
            Map<String, Object> terms = getParameterAll();
            Sort sort = Sort.by(Sort.Direction.DESC, "a.create_time");
            PageRequest pageRequest = PageRequest.of(0, 1000000, sort);
            Page<CasePageDTO> caseInfoPage = service.pageQueryAll(pageRequest, terms);
            List<CaseInfoWeExcelDTO> excelList = new ArrayList<>();
            if(ObjectUtils.isNotEmpty(caseInfoPage.getContent())){
                for (CasePageDTO casePageDTO : caseInfoPage.getContent()) {
                    CaseInfoWeExcelDTO caseInfoWeExcelDTO = new CaseInfoWeExcelDTO();
                    BeanUtils.copyProperties(casePageDTO,caseInfoWeExcelDTO);
                    caseInfoWeExcelDTO.setCloseTime(DateUtils.DateToString(casePageDTO.getCloseTime(), DateUtils.YYYY_MM_DD));
                    caseInfoWeExcelDTO.setCreateTime(DateUtils.DateToString(casePageDTO.getCreateTime(), DateUtils.YYYY_MM_DD));
                    caseInfoWeExcelDTO.setCaseTypeName(casePageDTO.getCaseTypeFirstName()+"/"+casePageDTO.getCaseTypeName());
                    excelList.add(caseInfoWeExcelDTO);
                }
            }
            String fileName = "综合查询.xlsx";
            response.setCharacterEncoding("UTF-8");
            response.setHeader("content-Type", "application/vnd.ms-excel;charset=UTF-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
            ServletOutputStream outputStream = response.getOutputStream();
            EasyExcel.write(outputStream, CaseInfoWeExcelDTO.class).sheet("综合查询").doWrite(excelList);
        } catch (Exception e) {
            log.error("Controller接口[CaseInfoWebController.exportQueryAll]请求异常："+e, e);
        }

    }

    /**
     * 综合查询
     * @url {ctx}/api/web/caseInfo/statistics
     * @return Object
     * @CurrentUser String userId
     */
    @GetMapping("/statistics")
    public Object statistics() {
        try {
            Map<String, Object> terms = getParameterAll();
            return ReturnSucUtils.getRepInfo( "处理成功", service.statistics(terms));
        } catch (Exception e) {
            log.error("Controller接口[CaseInfoWebController.statistics]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 小程序是否可见修改修改
     * @url {ctx}/api/web/caseInfo/updateVisibleStatus
     * @return Object
     * @CurrentUser String userId
     */
    @PostMapping("/updateVisibleStatus")
    public Object updateVisibleStatus(@RequestBody CaseInfo caseInfo) {
        try {
            service.updateCaseInfo(caseInfo);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[CaseInfoWebController.statistics]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }
}