综合查询-排序

zhouxiantao

2024-09-25 dfa813134c05b718c039c432f0fa7be3cc118fd3

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/controller/web/CaseTaskWebController.java

@@ -4,18 +4,14 @@
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.AcceptTaskDTO;
import cn.huge.module.cases.domain.dto.AssignTaskDTO;
import cn.huge.module.cases.domain.dto.SignTaskDTO;
import cn.huge.module.cases.domain.po.CaseAppear;
import cn.huge.module.cases.domain.po.CaseReturn;
import cn.huge.module.cases.domain.po.CaseTask;
import cn.huge.module.cases.domain.po.CaseWindupApply;
import cn.huge.module.cases.domain.dto.*;
import cn.huge.module.cases.domain.po.*;
import cn.huge.module.cases.service.*;
import cn.huge.module.client.api.SysClient;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.SysClientImpl;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.mediate.constant.AuditBaseConstsEnum;
import cn.huge.module.sys.dto.FileIdTypeInfoBaseDTO;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
@@ -23,6 +19,7 @@
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;
@@ -64,6 +61,8 @@
    private CustClientImpl custClient;
    @Autowired
    private CaseSuperviseService superviseService;
    @Autowired
    private CaseDismissService caseDismissService;

    /**
    * web端-任务处理页面-初始化tab和按钮
@@ -75,6 +74,22 @@
    public Object getTabButton(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            return ReturnSucUtils.getRepInfo(service.webGetTabButton(caseTaskId, userId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-不予受理
     * @url {ctx}/api/web/caseTask/dismiss
     * @param caseDismiss 不予受理表单
     * @return Object
     */
    @PostMapping("/dismiss")
    public Object dismiss(@RequestBody CaseDismiss caseDismiss, @CurrentUser String userId) {
        try {
            service.webDismiss(caseDismiss, userId);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
@@ -105,6 +120,41 @@
    @PostMapping("/sign")
    public Object sign(@RequestBody List<SignTaskDTO> signTaskDTOList, @CurrentUser String userId) {
        try {
            service.webSign(signTaskDTOList, userId);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-全部签收
     * @url {ctx}/api/web/caseTask/allSign
     * @param
     * @return Object
     */
    @PostMapping("/allSign")
    public Object allSign(@CurrentUser String userId, @RequestBody AllSignDTO allSignDTO) {
        try {
            // 条件
            Map<String, Object> terms = Maps.newHashMap();
            if(ObjectUtils.isNotEmpty(allSignDTO)){
                // 流程/签收时间区间
                if(StringUtils.isNotBlank(allSignDTO.getTimeStart()) && StringUtils.isNotBlank(allSignDTO.getTimeEnd())) {
                    // 待签收，查询流转时间
                    terms.put("createTimeStart", allSignDTO.getTimeStart());
                    terms.put("createTimeEnd", allSignDTO.getTimeEnd());
                }
                // 查询申请方/被申请方关键词
                if (StringUtils.isNotBlank(allSignDTO.getPartyName())){
                    terms.put("partyName", allSignDTO.getPartyName());
                }
            }
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("candeUnitId",loginUser.getUnitId());
            terms.put("signStatus", 1);

            List<SignTaskDTO>signTaskDTOList = service.listIdByTerms(terms);
            service.webSign(signTaskDTOList, userId);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
@@ -201,12 +251,14 @@
    public Object getReturnApplyInfo(@RequestParam(value = "caseTaskId") String caseTaskId, @CurrentUser String userId) {
        try {
            CaseReturn caseReturn = caseReturnService.getByCaseTaskId(caseTaskId);
            Map<String, Object> term = new HashMap<>();
            term.put("mainId", caseReturn.getCaseId());
            term.put("ownerIds", caseReturn.getId());
            List<FileIdTypeInfoBaseDTO> fileInfoList = sysClient.listIdTypeInfoByOwnerIdList(term);
            if(CollectionUtils.isNotEmpty(fileInfoList)){
                caseReturn.setFileInfoList(fileInfoList.get(0).getFileList().get(0).getFileList());
            if (ObjectUtils.isNotEmpty(caseReturn)) {
                Map<String, Object> term = new HashMap<>();
                term.put("mainId", caseReturn.getCaseId());
                term.put("ownerIds", "'" + caseReturn.getId() + "'");
                List<FileIdTypeInfoBaseDTO> fileInfoList = sysClient.listIdTypeInfoByOwnerIdList(term);
                if (CollectionUtils.isNotEmpty(fileInfoList)) {
                    caseReturn.setFileInfoList(fileInfoList.get(0).getFileList().get(0).getFileList());
                }
            }
            return ReturnSucUtils.getRepInfo(caseReturn);
        } catch (Exception e) {
@@ -313,7 +365,7 @@
     * @param size 每页数量
     * @param status 状态，1：待分派，2：已分派
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：流转时间；2：分派时限；3：事项等级）
     * @param sortColmn 排序字段（1：流转时间；2：分派时限/分派时间；3：事项等级；4：督办次数）
     * @return
     */
    @GetMapping("/pageMyTaskFp")
@@ -321,19 +373,35 @@
                               @RequestParam(value = "status") int status, @CurrentUser String userId,
                               @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn) {
        try {
            // 条件
            Map<String, Object> terms = Maps.newHashMap();
            // 流程/分派时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                terms.put("timeStart", timeStart);
                terms.put("timeEnd", timeEnd);
                // 待分派，查询流转时间
                if (status == 1){
                    terms.put("createTimeStart", timeStart);
                    terms.put("createTimeEnd", timeEnd);
                }else {
                    // 已分派，查询分派时间
                    terms.put("handleTimeStart", timeStart);
                    terms.put("handleTimeEnd", timeEnd);
                }
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            if (status == 1) {
                terms.put("candeUnitId", loginUser.getUnitId());
            }else {
                terms.put("handleUnitId", loginUser.getUnitId());
            }
            terms.put("status", status);
            // 排序
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
@@ -341,10 +409,20 @@
                    sortName = "t1.create_time";
                    break;
                case 2:
                    sortName = "t1.expire_time";
                    if (status == 1){
                        sortName = "t1.expire_time";
                    }else {
                        sortName = "t1.handle_time";
                    }
                    break;
                case 3:
                    sortName = "t2.case_level";
                    break;
                case 4:
                    sortName = "superviseCount";
                    break;
                default:
                    sortName = "t1.create_time";
                    break;
            }
            switch (sortType){
@@ -354,14 +432,14 @@
                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);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("candeUnitId",loginUser.getUnitId());
            terms.put("status", status);
            return ReturnSucUtils.getRepInfo(service.pageMyTaskFp(pageRequest, terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
@@ -375,7 +453,7 @@
     * @param size 每页数量
     * @param status 状态，1：待签收，2：已签收
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：流转时间；2：分派时限；3：事项等级）
     * @param sortColmn 排序字段（1：流转时间；2：签收时限/签收时间；3：事项等级；4：督办次数）
     * @return
     */
    @GetMapping("/pageMyTaskQs")
@@ -383,19 +461,35 @@
                               @RequestParam(value = "status") int status, @CurrentUser String userId,
                               @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn) {
        try {
            // 条件
            Map<String, Object> terms = Maps.newHashMap();
            // 流程/签收时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                terms.put("timeStart", timeStart);
                terms.put("timeEnd", timeEnd);
                // 待签收，查询流转时间
                if (status == 1){
                    terms.put("createTimeStart", timeStart);
                    terms.put("createTimeEnd", timeEnd);
                }else {
                    // 已签收，查询签收时间
                    terms.put("signTimeStart", timeStart);
                    terms.put("signTimeEnd", timeEnd);
                }
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            if (status == 1) {
                terms.put("candeUnitId", loginUser.getUnitId());
            }else {
                terms.put("handleUnitId", loginUser.getUnitId());
            }
            terms.put("signStatus", status);
            // 排序
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
@@ -403,10 +497,20 @@
                    sortName = "t1.create_time";
                    break;
                case 2:
                    sortName = "t1.expire_time";
                    if (status == 1){
                        sortName = "t1.sign_expire_time";
                    }else {
                        sortName = "t1.sign_time";
                    }
                    break;
                case 3:
                    sortName = "t2.case_level";
                    break;
                case 4:
                    sortName = "superviseCount";
                    break;
                default:
                    sortName = "t1.create_time";
                    break;
            }
            switch (sortType){
@@ -416,14 +520,14 @@
                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);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("candeUnitId",loginUser.getUnitId());
            terms.put("signStatus", status);
            return ReturnSucUtils.getRepInfo(service.pageMyTaskQs(pageRequest, terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
@@ -435,9 +539,9 @@
     * @url {ctx}/api/web/caseTask/pageMyTaskSl
     * @param page 页码
     * @param size 每页数量
     * @param status 状态，1：待受理，2：已受理
     * @param status 状态，1：待受理，2：已受理，3：不予受理
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：流转时间；2：分派时限；3：事项等级）
     * @param sortColmn 排序字段（1：流转时间；2：受理时限/受理时间/不予受理时间；3：事项等级；4：督办次数）
     * @return
     */
    @GetMapping("/pageMyTaskSl")
@@ -445,30 +549,43 @@
                               @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn,
                               @RequestParam(value = "status") int status, @CurrentUser String userId) {
        try {
            Map<String, Object> terms = Maps.newHashMap();
            // 流程/受理时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                terms.put("timeStart", timeStart);
                terms.put("timeEnd", timeEnd);
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            // 排序
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
                case 1:
                    sortName = "t1.create_time";
                    // 不予受理
                    if (status == 3){
                        sortName = "t1.case_task_time";
                    }else {
                        sortName = "t1.create_time";
                    }
                    break;
                case 2:
                    sortName = "t1.expire_time";
                    // 待受理
                    if (status == 1){
                        sortName = "t1.expire_time";
                    }else if (status == 2){
                        // 已受理
                        sortName = "t1.handle_time";
                    }else {
                        // 不予受理
                        sortName = "t1.dis_time";
                    }
                    break;
                case 3:
                    sortName = "t2.case_level";
                    break;
                case 4:
                    sortName = "superviseCount";
                    break;
                default:
                    // 不予受理
                    if (status == 3){
                        sortName = "t1.case_task_time";
                    }else {
                        sortName = "t1.create_time";
                    }
                    break;
            }
            switch (sortType){
@@ -478,15 +595,53 @@
                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);
            // 条件
            Map<String, Object> terms = Maps.newHashMap();
            // 流程/受理时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                // 待受理，查询流转时间
                if (status == 1){
                    terms.put("createTimeStart", timeStart);
                    terms.put("createTimeEnd", timeEnd);
                }else if (status == 2){
                    // 已受理，查询受理时间
                    terms.put("handleTimeStart", timeStart);
                    terms.put("handleTimeEnd", timeEnd);
                }else {
                    // 不予受理，查询不予受理时间
                    terms.put("disTimeStart", timeStart);
                    terms.put("disTimeEnd", timeEnd);
                }
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("candeUnitId",loginUser.getUnitId());
            terms.put("status", status);
            return ReturnSucUtils.getRepInfo(service.pageMyTaskSl(pageRequest, terms));
            // 不予受理，查询case_dismiss表
            if (status == 3){
                terms.put("disUnitId", loginUser.getUnitId());
                return ReturnSucUtils.getRepInfo(caseDismissService.pageMyTaskBysl(pageRequest, terms));
            }else {
                terms.put("status", status);
                if (status == 1){
                    terms.put("candeUnitId", loginUser.getUnitId());
                }else {
                    terms.put("handleUnitId", loginUser.getUnitId());
                }
                return ReturnSucUtils.getRepInfo(service.pageMyTaskSl(pageRequest, terms));
            }
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
@@ -497,28 +652,34 @@
     * @url {ctx}/api/web/caseTask/pageMyTaskBlz
     * @param page 页码
     * @param size 每页数量
     * @param caseTaskType 纠纷任务类型（1：我承办的；2：我配合的）
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：流转时间/已办天数；2：分派时限；3：事项等级）
     * @param sortColmn 排序字段（1：流转时间/已办天数；2：分派时限；3：事项等级；4：督办次数）
     * @return
     */
    @GetMapping("/pageMyTaskBlz")
    public Object pageMyTaskBlz(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                                @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn,
                                @CurrentUser String userId) {
                                @RequestParam(value = "caseTaskType") int caseTaskType, @RequestParam(value = "sortType") int sortType,
                                @RequestParam(value = "sortColmn") int sortColmn, @CurrentUser String userId) {
        try {
            // 条件
            Map<String, Object> terms = Maps.newHashMap();
            // 流程/结案申请/结案时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                terms.put("timeStart", timeStart);
                terms.put("timeEnd", timeEnd);
                terms.put("createTimeStart", timeStart);
                terms.put("createTimeEnd", timeEnd);
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            terms.put("caseTaskType", caseTaskType);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("candeUnitId", loginUser.getUnitId());
            // 排序
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
@@ -531,6 +692,12 @@
                case 3:
                    sortName = "t2.case_level";
                    break;
                case 4:
                    sortName = "superviseCount";
                    break;
                default:
                    sortName = "t1.create_time";
                    break;
            }
            switch (sortType){
                case 1:
@@ -539,14 +706,14 @@
                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);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("candeUnitId",loginUser.getUnitId());
            return ReturnSucUtils.getRepInfo(service.pageMyTaskBlz(pageRequest, terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
@@ -554,41 +721,68 @@
    }

    /**
     * web端-工作台-查询待办任务-办理任务
     * web端-工作台-查询待办任务-已办理任务
     * @url {ctx}/api/web/caseTask/pageMyTaskBl
     * @param page 页码
     * @param size 每页数量
     * @param status 状态，0：结案申请，1：已结案
     * @param caseTaskType 纠纷任务类型（1：我承办的；2：我配合的）
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：结案申请时间；2：事项等级）
     * @param sortColmn 排序字段（1：结案申请时间；2：事项等级；3：督办次数）
     * @return
     */
    @GetMapping("/pageMyTaskBl")
    public Object pageMyTaskBl(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                               @RequestParam(value = "status") int status, @CurrentUser String userId,
                               @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn) {
                               @RequestParam(value = "status") int status, @RequestParam(value = "caseTaskType") int caseTaskType,
                               @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn,
                               @CurrentUser String userId) {
        try {
            Map<String, Object> terms = Maps.newHashMap();
            // 流程/结案申请/结案时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                terms.put("timeStart", timeStart);
                terms.put("timeEnd", timeEnd);
                terms.put("applyTimeStart", timeStart);
                terms.put("applyTimeStart", timeEnd);
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            terms.put("applyStatus", status);
            if (status == 1){
                terms.put("auditResult", AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex());
            }
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            if (caseTaskType == 1){
                terms.put("applyUnitId", loginUser.getUnitId());
            }else {
                terms.put("assistUnitId", loginUser.getUnitId());
            }
            // 排序
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
                case 1:
                    sortName = "t1.apply_time";
                    if (status == 0) {
                        sortName = "t1.apply_time";
                    }else {
                        sortName = "t1.audit_time";
                    }
                    break;
                case 2:
                    sortName = "t1.case_level";
                    sortName = "t2.case_level";
                    break;
                case 3:
                    sortName = "superviseCount";
                    break;
                default:
                    if (status == 0) {
                        sortName = "t1.apply_time";
                    }else {
                        sortName = "t1.audit_time";
                    }
                    break;
            }
            switch (sortType){
@@ -598,15 +792,15 @@
                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);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("applyUnitId",loginUser.getUnitId());
            terms.put("applyStatus", status);
            return ReturnSucUtils.getRepInfo(service.pageMyTaskBl(pageRequest, terms));
            return ReturnSucUtils.getRepInfo(service.pageMyTaskJa(pageRequest, terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
@@ -625,7 +819,8 @@
    @GetMapping("/pageMyTaskSh")
    public Object pageMyTaskSh(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                               @RequestParam(value = "status") int status, @RequestParam(value = "type") int type,
                               @CurrentUser String userId, @RequestParam(value = "sortType") int sortType) {
                               @CurrentUser String userId, @RequestParam(value = "sortType") int sortType,
                               @RequestParam(value = "sortColmn") int sortColmn) {
        try {
            Map<String, Object> terms = Maps.newHashMap();
            // 回退/上报/结案申请/联合处置申请/审核时间区间
@@ -644,16 +839,43 @@
            String sortName = null;
            switch (type){
                case 1:
                    sortName = "t1.return_time";
                    if(1 == sortColmn){
                        sortName = "t1.return_time";
                    }else if(2 == sortColmn){
                        sortName = "t2.case_level";
                    }else if(3 == sortColmn){
                        sortName = "t1.audit_time";
                    }
                    break;
                case 2:
                    sortName = "t1.appear_time";
                    if(1 == sortColmn) {
                        sortName = "t1.appear_time";
                    }else if(2 == sortColmn){
                        sortName = "t2.case_level";
                    }else if(3 == sortColmn){
                        sortName = "t1.audit_time";
                    }
                    break;
                case 3:
                    sortName = "t1.apply_time";
                    if(1 == sortColmn) {
                        sortName = "t1.apply_time";
                    }else if(2 == sortColmn){
                        sortName = "t2.case_level";
                    }else if(3 == sortColmn){
                        sortName = "t1.audit_time";
                    }
                    break;
                case 4:
                    sortName = "t1.apply_time";
                    if(1 == sortColmn) {
                        sortName = "t1.apply_time";
                    }else if(2 == sortColmn){
                        sortName = "t2.case_level";
                    }else if(3 == sortColmn){
                        sortName = "t1.audit_time";
                    }
                    break;
                default:
                    sortName = "t1.create_time";
                    break;
            }
            switch (sortType){
@@ -662,6 +884,9 @@
                    break;
                case 2:
                    sort = Sort.by(Sort.Direction.DESC, sortName);
                    break;
                default:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
            }
            if(ObjectUtils.isEmpty(sort)){
@@ -677,53 +902,88 @@
        }
    }

//    /**
//     * web端-工作台-查询待办任务-审核任务
//     * @url {ctx}/api/web/caseTask/pageMyTaskShWSQD
//     * @param page 页码
//     * @param size 每页数量
//     * @param status 状态，0：待审核，1：已审核
//     * @param sortType 排序方式（1：正序；2：倒序）
//     * @param sortColmn 排序字段（1：结案申请时间；2：事项等级）
//     * @return
//     */
//    @GetMapping("/pageMyTaskShWSQD")
//    public Object pageMyTaskShWSQD(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
//                               @RequestParam(value = "status") int status, @CurrentUser String userId,
//                                   @RequestParam(value = "sortType") int sortType, @RequestParam(value = "sortColmn") int sortColmn) {
//        try {
//            Map<String, Object> terms = Maps.newHashMap();
//            // 回退/上报/结案申请/联合处置申请/审核时间区间
//            String timeStart = request.getParameter("timeStart");
//            String timeEnd = request.getParameter("timeEnd");
//            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
//                terms.put("timeStart", timeStart);
//                terms.put("timeEnd", timeEnd);
//            }
//            // 查询申请方/被申请方关键词
//            String partyName = request.getParameter("partyName");
//            if (StringUtils.isNotBlank(partyName)){
//                terms.put("partyName", partyName);
//            }
//            if(ObjectUtils.isEmpty(sort)){
//                sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
//            }
//            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
//            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
//            terms.put("auditUnitId",loginUser.getUnitId());
//            terms.put("applyStatus", status);
//            return ReturnSucUtils.getRepInfo(service.pageMyTaskShWSQD(pageRequest, type, terms));
//        } catch (Exception e) {
//            return ReturnFailUtils.getRepInfo();
//        }
//    }
    /**
     * web端-工作台-查询待办任务-审核任务-我申请的
     * @url {ctx}/api/web/caseTask/pageMyTaskShWSQD
     * @param page 页码
     * @param size 每页数量
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：申请时间；2：审核时间；3：事项等级）
     * @return
     */
    @GetMapping("/pageMyTaskShWSQD")
    public Object pageMyTaskShWSQD(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                               @CurrentUser String userId,@RequestParam(value = "sortType") int sortType,
                               @RequestParam(value = "sortColmn") int sortColmn) {
        try {
            Map<String, Object> terms = Maps.newHashMap();
            // 时间区间
            String timeStart = request.getParameter("timeStart");
            String timeEnd = request.getParameter("timeEnd");
            if(StringUtils.isNotBlank(timeStart) && StringUtils.isNotBlank(timeEnd)) {
                terms.put("timeStart", timeStart);
                terms.put("timeEnd", timeEnd);
            }
            // 查询申请方/被申请方关键词
            String partyName = request.getParameter("partyName");
            if (StringUtils.isNotBlank(partyName)){
                terms.put("partyName", partyName);
            }
            // 申请类型
            String applyType = request.getParameter("applyType");
            if (StringUtils.isNotBlank(applyType)){
                terms.put("applyType", applyType);
            }
            // 审核结果
            String auditResult = request.getParameter("auditResult");
            if (StringUtils.isNotBlank(auditResult)){
                terms.put("auditResult", auditResult);
            }
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
                case 1:
                    sortName = "t1.turnaroundTime";
                    break;
                case 2:
                    sortName = "t1.auditTime";
                    break;
                case 3:
                    sortName = "caseGrade";
                    break;
                default:
                    sortName = "t1.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);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("applyUnitId",loginUser.getUnitId());
            return ReturnSucUtils.getRepInfo(service.pageMyTaskShWSQD(pageRequest, terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-工作台-查询待办任务-督办
     * @url {ctx}/api/web/caseTask/pageMyTaskDb
     * @param page 页码
     * @param size 每页数量
     * @param status 状态，0：未回复，1：已回复
     * @param status 状态，0：未回复，1：已回复, 3:我发起的
     * @param sortType 排序方式（1：正序；2：倒序）
     * @param sortColmn 排序字段（1：督办时间/回复时限；2：事项等级）
     * @return
@@ -753,7 +1013,19 @@
                    sortName = "t1.sup_time";
                    break;
                case 2:
                    sortName = "t1.case_level";
                    sortName = "timeLimit";
                    break;
                case 3:
                    sortName = "t2.case_level";
                    break;
                case 4:
                    sortName = "t1.sup_status";
                    break;
                case 5:
                    sortName = "t1.reply_time";
                    break;
                default:
                    sortName = "t1.sup_time";
                    break;
            }
            switch (sortType){
@@ -763,16 +1035,27 @@
                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);
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("quiltUnitId",loginUser.getUnitId());
            terms.put("supStatus", status);

            return ReturnSucUtils.getRepInfo(superviseService.pageMyTaskDb(pageRequest, terms));
            Page<FrontPageListDTO> frontPageListDTOPage = null;
            if(StringUtils.isNotBlank(loginUser.getUnitId())){
                terms.put("type", status);
                if(3 != status){
                    terms.put("quiltUnitId",loginUser.getUnitId());
                    terms.put("supStatus", status);
                }else{
                    terms.put("supUnitId",loginUser.getUnitId());
                }
                frontPageListDTOPage = superviseService.pageMyTaskDb(pageRequest, terms);
            }
            return ReturnSucUtils.getRepInfo(frontPageListDTOPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
@@ -791,4 +1074,113 @@
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-工作台-已办事项
     * @url {ctx}/api/web/caseTask/pageMyTaskYb
     * @param page 页码
     * @param size 每页数量
     * sortColmn 排序字段（1：办理时间；2：事项等级；3：督办次数）
     * sortType 排序方式（1：正序；2：倒序）
     * @return
     */
    @GetMapping("/pageMyTaskYb")
    public Object pageMyTaskYb(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                               @CurrentUser String userId) {
        try {
            // 条件
            Map<String, Object> terms = Maps.newHashMap();
            // 受理时间
            String createTimeStart = request.getParameter("createTimeStart");
            String createTimeEnd = request.getParameter("createTimeEnd");
            if(StringUtils.isNotBlank(createTimeStart) && StringUtils.isNotBlank(createTimeEnd)) {
                terms.put("createTimeStart", createTimeStart);
                terms.put("createTimeEnd", createTimeEnd);
            }
            // 办结时间
            String handleTimeStart = request.getParameter("handleTimeStart");
            String handleTimeEnd = request.getParameter("handleTimeEnd");
            if(StringUtils.isNotBlank(handleTimeStart) && StringUtils.isNotBlank(handleTimeEnd)) {
                terms.put("handleTimeStart", handleTimeStart);
                terms.put("handleTimeEnd", handleTimeEnd);
            }
            // 经办人
            String mediator = request.getParameter("mediator");
            if (StringUtils.isNotBlank(mediator)){
                terms.put("mediator", mediator);
            }
            // 事项来源
            String canal = request.getParameter("canal");
            if (StringUtils.isNotBlank(canal)){
                terms.put("canal", canal);
            }
            // 化解结果
            String mediResult = request.getParameter("mediResult");
            if (StringUtils.isNotBlank(mediResult)){
                terms.put("mediResult", mediResult);
            }
            // 事项等级
            String caseLevel = request.getParameter("caseLevel");
            if (StringUtils.isNotBlank(caseLevel)){
                terms.put("caseLevel", caseLevel);
            }
            // 纠纷类型
            String caseType = request.getParameter("caseType");
            if (StringUtils.isNotBlank(caseType)){
                terms.put("caseType", caseType);
            }
            // 事项状态
            String status = request.getParameter("status");
            if (StringUtils.isNotBlank(status)){
                terms.put("status", status);
            }
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            terms.put("handleUnitId", loginUser.getUnitId());
            // 排序
            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 = "t1.handle_time";
                    break;
                case 2:
                    sortName = "t2.case_level";
                    break;
                case 3:
                    sortName = "superviseCount";
                    break;
                default:
                    sortName = "t1.handle_time";
                    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);
            return ReturnSucUtils.getRepInfo(service.pageMyTaskYb(pageRequest, terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }
}