fj-dc/.svn/pristine/4a/4a5471525e51e2d942113901af4326c064bab3b7.svn-base

package cn.com.goldenwater.dcproj.controller.mend.bpm;

import cn.com.goldenwater.core.web.BaseController;
import cn.com.goldenwater.core.web.BaseResponse;
import cn.com.goldenwater.dcproj.dto.ResGetTaskPendDto;
import cn.com.goldenwater.dcproj.model.BisInspAllRlationPers;
import cn.com.goldenwater.dcproj.model.BisInspPblmClassify;
import cn.com.goldenwater.dcproj.model.BisInspPblmPlist;
import cn.com.goldenwater.dcproj.model.TacProvincePblmMendInfo;
import cn.com.goldenwater.dcproj.service.*;
import cn.com.goldenwater.dcproj.utils.DateUtils;
import cn.com.goldenwater.dcproj.utils.expExcel.ExportUtil;
import cn.com.goldenwater.dcproj.vo.TacTaskInstVo;
import com.github.pagehelper.PageInfo;
import com.workflow.bpm.api.bpmservices.ActionConstant;
import com.workflow.bpm.api.bpmservices.BpmTaskService;
import com.workflow.bpm.api.bpmservices.co.info.OperationCfgInfo;
import com.workflow.bpm.api.bpmservices.co.taskinst.*;
import com.workflow.bpm.api.bpmservices.dto.*;
import com.workflow.common.exception.BusinessException;
import com.workflow.common.exception.impl.CommonErrorCode;
import com.workflow.common.struct.head.Page;
import com.workflow.common.struct.req.impl.APIRequestPage;
import com.workflow.common.struct.res.Result;
import com.workflow.common.struct.res.ResultPage;
import com.workflow.common.struct.res.impl.APIResult;
import com.workflow.common.util.convert.ConvertBeanUtils;
import com.workflow.common.util.convert.type.CollectionUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.hateoas.Link;
import org.springframework.hateoas.mvc.ControllerLinkBuilder;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.util.*;
import java.util.stream.Collectors;

import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;

/**
 * @program parent
 * @Description
 * @Author admin
 * @Date 2019/7/10
 **/
@Api(tags = "流程待办任务")
@RestController
@RequestMapping("/bis/insp/pblm/plist/")
public class TaskInstController extends BaseController {

    private static final Logger logger = LoggerFactory.getLogger(TaskInstController.class);

    public static Map<String, String> actionMap = new HashMap<>();

    @Autowired
    private BpmTaskService bpmTaskService;
    @Autowired
    private OlBisInspOrgService olBisInspOrgService;
    @Autowired
    private AttAdBaseService attAdBaseService;
    @Autowired
    private BisInspPblmPlistService bisInspPblmPlistService;
    @Autowired
    private TacProvincePblmMendInfoService tacProvincePblmMendInfoService;
    @Autowired
    private BisInspAllRlationPersService bisInspAllRlationPersService;
    @Autowired
    private BisInspPblmPlistFormService formService;

    static {
        actionMap.put("922800000010", "submit");
        actionMap.put("922800000020", "back");
        actionMap.put("922800000030", "addSign");
        actionMap.put("922800000040", "circulate");
        actionMap.put("922800000050", "deny-over");
        actionMap.put("922800000060", "suspend");
        actionMap.put("922800000070", "resume");
        actionMap.put("922800000080", "abandon-over");
        actionMap.put("922800000090", "save");
    }

    /**
     * 待办任务-查询
     *
     * @param reqGetTaskPend2DTO
     * @return
     */
    //@RequiresPermissions("base.task.penging.list")
    @ApiOperation(value = "待办任务-查询")
    @GetMapping("/v1/workflow/queryPendingTask")
    public BaseResponse<PageInfo<ResGetTaskPendDto>> get_queryPendingTask(ReqGetTaskPend2DTO reqGetTaskPend2DTO) {

        if (Objects.isNull(reqGetTaskPend2DTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        logger.info("工作流当前人员getCurrentOrgId():" + getCurrentOrgId());
        //获取当前人员的所属行政区
        String province = olBisInspOrgService.getRlProvince(getCurrentOrgId());
        logger.info("工作流当前人员provice:" + province);
        //获取行政区代码对应的行政区名称
        String adName = attAdBaseService.getByAdcode(province).getAdFullName();
        logger.info("工作流当前人员provice:" + adName);
        logger.info("工作流权限前缀：" + adName);
        QueryTaskInstCO queryTaskInstCO = new QueryTaskInstCO();
        if ("jc".equals(reqGetTaskPend2DTO.getQueryType())) {
            queryTaskInstCO.setProcInstName("稽察整改-" + adName);
            reqGetTaskPend2DTO.setProcInstName("稽察整改-" + adName);
            logger.info("稽察整改-" + adName);
        } else {
            if (reqGetTaskPend2DTO.getProcInstName() == null || "".equals(reqGetTaskPend2DTO.getProcInstName())){
                queryTaskInstCO.setProcInstName("督查整改-" + adName);
                reqGetTaskPend2DTO.setProcInstName("督查整改-" + adName);
                logger.info("督查整改-" + adName);
            }else{
                queryTaskInstCO.setProcInstName(reqGetTaskPend2DTO.getProcInstName());
            }
        }
        logger.info("督查整改-" + adName);
        Page page = new Page();

        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskPend2DTO, queryTaskInstCO);
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskPend2DTO, page);
        APIRequestPage<QueryTaskInstCO> requestPage = new APIRequestPage<>();
        requestPage.setContent(queryTaskInstCO);
        if (reqGetTaskPend2DTO.getPblmClassify() != null && !"".equals(reqGetTaskPend2DTO.getPblmClassify())) {
            page.setPageNo(1);
            page.setPageSize(9999);
        } else {
            page.setPageNo(reqGetTaskPend2DTO.getPageNum());
            page.setPageSize(reqGetTaskPend2DTO.getPageSize());
        }
        requestPage.setPage(page);
        try {
            logger.info("bpm req:"+requestPage.toString()+":"+requestPage.getContent().toString());
            ResultPage<List<ResGetTaskPendDTO>> listResultPage = bpmTaskService.queryPendingTask(requestPage, getCurrentPersId(), getCurrentOrgId());

            listResultPage.setPageClass(ResGetTaskPendDto.class);
            PageInfo<ResGetTaskPendDto> newPage = new PageInfo<>();
            newPage.setPageSize(listResultPage.getPage().getPageSize());
            newPage.setTotal(listResultPage.getPage().getTotal());
            newPage.setPageNum(listResultPage.getPage().getPageNo());

            if (listResultPage.getContent() == null || listResultPage.getContent().size() == 0) {
                newPage.setList(new ArrayList<>());
                return buildSuccessResponse(newPage);
            }

            List<ResGetTaskPendDto> resultList = new ArrayList<>();
            newPage.setList(resultList);

            List<String> idList = new ArrayList<>();
            listResultPage.getContent().forEach(a -> idList.add(a.getBusinessKey()));
            Map<String, BisInspPblmClassify> pblmClassifyMap = formService.getPblmClassifyMap(idList);
            if (reqGetTaskPend2DTO.getPblmClassify() != null && !"".equals(reqGetTaskPend2DTO.getPblmClassify())) {
                List<ResGetTaskPendDTO> collect = listResultPage.getContent().stream().filter(b -> {
                    String pblmClassify = pblmClassifyMap.get(b.getBusinessKey()).getPblmClassify();
                    if (pblmClassify != null && pblmClassify.contains(reqGetTaskPend2DTO.getPblmClassify())) {
                        convertDto(b, pblmClassify, resultList);
                        return true;
                    } else {
                        return false;
                    }
                }).collect(Collectors.toList());
                listResultPage.setContent(collect);
                newPage.setPageSize(9999);
                newPage.setPageNum(1);
            } else {
                listResultPage.getContent().forEach(c -> {
                    BisInspPblmClassify bisInspPblmClassify = pblmClassifyMap.get(c.getBusinessKey());
                    if (bisInspPblmClassify != null) {
                        convertDto(c, bisInspPblmClassify.getPblmClassify(), resultList);
                    }
                });
            }

            List<ResGetTaskPendDto> resGetTaskPendDTOList = newPage.getList();
            if ("jc".equals(reqGetTaskPend2DTO.getQueryType())) {
                resGetTaskPendDTOList.forEach(resGetTaskPendDTO -> {
                    TacProvincePblmMendInfo tacProvincePblmMendInfo = tacProvincePblmMendInfoService.get(resGetTaskPendDTO.getBusinessKey());
                    Optional.ofNullable(tacProvincePblmMendInfo).ifPresent(p -> {
                        resGetTaskPendDTO.setYear(DateUtils.Date2Str(p.getIntm(), "yyyy"));
                    });
                    if (StringUtils.isBlank(resGetTaskPendDTO.getStarterName())) {
                        BisInspAllRlationPers pers = bisInspAllRlationPersService.get(resGetTaskPendDTO.getStarterId());
                        Optional.ofNullable(pers).map(BisInspAllRlationPers::getPersName).ifPresent(resGetTaskPendDTO::setStarterName);
                    }
                });
            } else {
                resGetTaskPendDTOList.forEach(resGetTaskPendDTO -> {
                    BisInspPblmPlist bisInspPblmPlist = bisInspPblmPlistService.get(resGetTaskPendDTO.getBusinessKey());
                    Optional.ofNullable(bisInspPblmPlist).ifPresent(p -> {
                        resGetTaskPendDTO.setYear(DateUtils.Date2Str(p.getIntm(), "yyyy"));
                        resGetTaskPendDTO.setImpSource(p.getImpSource());
                    });
                    if (StringUtils.isBlank(resGetTaskPendDTO.getStarterName())) {
                        BisInspAllRlationPers pers = bisInspAllRlationPersService.get(resGetTaskPendDTO.getStarterId());
                        Optional.ofNullable(pers).map(BisInspAllRlationPers::getPersName).ifPresent(resGetTaskPendDTO::setStarterName);
                    }
                });
            }
            newPage.setList(
                    resGetTaskPendDTOList.stream()
                            .filter(r -> StringUtils.isBlank(reqGetTaskPend2DTO.getYear()) || reqGetTaskPend2DTO.getYear().equals(r.getYear()))
                            .filter(r -> StringUtils.isBlank(reqGetTaskPend2DTO.getImpSource()) || reqGetTaskPend2DTO.getImpSource().equals(r.getImpSource()))
                            .collect(Collectors.toList())
            );
            return buildSuccessResponse(newPage);
        } catch (Exception e) {
            e.printStackTrace();
        }

        PageInfo<ResGetTaskPendDto> newPage = new PageInfo<>();
        newPage.setPageSize(10);
        newPage.setTotal(0);
        newPage.setPageNum(1);
        newPage.setList(new ArrayList<>());
        return buildSuccessResponse(newPage);
    }

    /**
     * 待办任务-导出
     *
     * @param reqGetTaskPend2DTO
     * @return
     */
    //@RequiresPermissions("base.task.penging.list")
    @ApiOperation(value = "待办任务-导出")
    @GetMapping("/v1/workflow/queryPendingTask/export")
    public void export_queryPendingTask(ReqGetTaskPend2DTO reqGetTaskPend2DTO, HttpServletResponse response) {

        if (Objects.isNull(reqGetTaskPend2DTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        if ("undefined".equalsIgnoreCase(reqGetTaskPend2DTO.getProcInstName())) {
            reqGetTaskPend2DTO.setProcInstName(null);
        }
        if ("undefined".equalsIgnoreCase(reqGetTaskPend2DTO.getNodeName())) {
            reqGetTaskPend2DTO.setNodeName(null);
        }
        if ("undefined".equalsIgnoreCase(reqGetTaskPend2DTO.getImpSource())) {
            reqGetTaskPend2DTO.setImpSource(null);
        }
        if ("undefined".equalsIgnoreCase(reqGetTaskPend2DTO.getYear())) {
            reqGetTaskPend2DTO.setYear(null);
        }
        //获取当前人员的所属行政区
        String province = olBisInspOrgService.getRlProvince(getCurrentOrgId());
        //获取行政区代码对应的行政区名称
        String adName = attAdBaseService.getByAdcode(province).getAdFullName();
        QueryTaskInstCO queryTaskInstCO = new QueryTaskInstCO();
        if ("jc".equals(reqGetTaskPend2DTO.getQueryType())) {
            queryTaskInstCO.setProcInstName("稽察整改-" + adName);
        } else {
            queryTaskInstCO.setProcInstName("督查整改-" + adName);
        }
        Page page = new Page();
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskPend2DTO, queryTaskInstCO);
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskPend2DTO, page);
        APIRequestPage<QueryTaskInstCO> requestPage = new APIRequestPage<>();
        requestPage.setContent(queryTaskInstCO);
        // 设置分页大小
        page.setPageNo(1);
        page.setPageSize(9999);

        requestPage.setPage(page);
        List<ResGetTaskPendDto> dataList = null;
        try {
            ResultPage<List<ResGetTaskPendDTO>> listResultPage = bpmTaskService.queryPendingTask(requestPage, getCurrentPersId(), getCurrentOrgId());

            listResultPage.setPageClass(ResGetTaskPendDto.class);
            PageInfo<ResGetTaskPendDto> newPage = new PageInfo<>();
            newPage.setPageSize(9999);
            newPage.setTotal(listResultPage.getPage().getTotal());
            newPage.setPageNum(1);

            if (listResultPage.getContent() != null && !listResultPage.getContent().isEmpty()) {
                List<ResGetTaskPendDto> resultList = new ArrayList<>();
                newPage.setList(resultList);

                List<String> idList = new ArrayList<>();
                listResultPage.getContent().forEach(a -> idList.add(a.getBusinessKey()));
                Map<String, BisInspPblmClassify> pblmClassifyMap = formService.getPblmClassifyMap(idList);
                if (reqGetTaskPend2DTO.getPblmClassify() != null && !"".equals(reqGetTaskPend2DTO.getPblmClassify())) {
                    List<ResGetTaskPendDTO> collect = listResultPage.getContent().stream().filter(b -> {
                        String pblmClassify = pblmClassifyMap.get(b.getBusinessKey()).getPblmClassify();
                        if (pblmClassify != null && pblmClassify.contains(reqGetTaskPend2DTO.getPblmClassify())) {
                            convertDto(b, pblmClassify, resultList);
                            return true;
                        } else {
                            return false;
                        }
                    }).collect(Collectors.toList());
                    listResultPage.setContent(collect);
                    newPage.setPageSize(9999);
                    newPage.setPageNum(1);
                } else {
                    listResultPage.getContent().forEach(c -> {
                        BisInspPblmClassify bisInspPblmClassify = pblmClassifyMap.get(c.getBusinessKey());
                        if (bisInspPblmClassify != null) {
                            convertDto(c, bisInspPblmClassify.getPblmClassify(), resultList);
                        }
                    });
                }

                List<ResGetTaskPendDto> resGetTaskPendDTOList = newPage.getList();
                if ("jc".equals(reqGetTaskPend2DTO.getQueryType())) {
                    resGetTaskPendDTOList.forEach(resGetTaskPendDTO -> {
                        TacProvincePblmMendInfo tacProvincePblmMendInfo = tacProvincePblmMendInfoService.get(resGetTaskPendDTO.getBusinessKey());
                        Optional.ofNullable(tacProvincePblmMendInfo).ifPresent(p -> {
                            resGetTaskPendDTO.setYear(DateUtils.Date2Str(p.getIntm(), "yyyy"));
                        });
                        if (StringUtils.isBlank(resGetTaskPendDTO.getStarterName())) {
                            BisInspAllRlationPers pers = bisInspAllRlationPersService.get(resGetTaskPendDTO.getStarterId());
                            Optional.ofNullable(pers).map(BisInspAllRlationPers::getPersName).ifPresent(resGetTaskPendDTO::setStarterName);
                        }
                    });
                } else {
                    resGetTaskPendDTOList.forEach(resGetTaskPendDTO -> {
                        BisInspPblmPlist bisInspPblmPlist = bisInspPblmPlistService.get(resGetTaskPendDTO.getBusinessKey());
                        Optional.ofNullable(bisInspPblmPlist).ifPresent(p -> {
                            resGetTaskPendDTO.setYear(DateUtils.Date2Str(p.getIntm(), "yyyy"));
                            resGetTaskPendDTO.setImpSource(p.getImpSource());
                        });
                        if (StringUtils.isBlank(resGetTaskPendDTO.getStarterName())) {
                            BisInspAllRlationPers pers = bisInspAllRlationPersService.get(resGetTaskPendDTO.getStarterId());
                            Optional.ofNullable(pers).map(BisInspAllRlationPers::getPersName).ifPresent(resGetTaskPendDTO::setStarterName);
                        }
                    });
                }
                newPage.setList(
                        resGetTaskPendDTOList.stream()
                                .filter(r -> StringUtils.isBlank(reqGetTaskPend2DTO.getYear()) || reqGetTaskPend2DTO.getYear().equals(r.getYear()))
                                .filter(r -> StringUtils.isBlank(reqGetTaskPend2DTO.getImpSource()) || reqGetTaskPend2DTO.getImpSource().equals(r.getImpSource()))
                                .collect(Collectors.toList())
                );
            }
            dataList = newPage.getList();
        } catch (Exception e) {
            logger.error("我的待办 导出 异常错误");
            logger.error(e.getMessage());
        }
        if (null == dataList) {
            dataList = new ArrayList<>();
        }

        List<TacTaskInstVo> exportList = new ArrayList<>();
        for (ResGetTaskPendDto pendDto : dataList) {
            TacTaskInstVo instVo = new TacTaskInstVo();
            convertExportDto(pendDto, instVo);
            exportList.add(instVo);
        }
        List<String> columns = new ArrayList<String>() {{
            add("pblmClassify");
            add("procInstName");
            add("nodeName");
            add("procTypeName");
            add("starterName");
            add("preEndUser");
            add("startTime");
            add("preEndTime");
            add("impSource");
            add("year");
        }};
        ExportUtil.exportExcelColumn(exportList, response, "整改待办列表", columns, TacTaskInstVo.class);
    }

    private void convertExportDto(ResGetTaskPendDto dto, TacTaskInstVo instVo) {
        if (dto == null) {
            return;
        }
        instVo.setPblmClassify(dto.getPblmClassify());
        instVo.setProcInstName(dto.getProcInstName());
        instVo.setNodeName(dto.getNodeName());
        instVo.setProcTypeName(dto.getProcTypeName());
        instVo.setStarterName(dto.getStarterName());
        instVo.setPreEndUser(dto.getPreEndUser());
        instVo.setStartTime(DateUtils.Date2Str(dto.getStartTime(), "yyyy-MM-dd HH:mm:ss"));
        instVo.setPreEndTime(DateUtils.Date2Str(dto.getPreEndTime(), "yyyy-MM-dd HH:mm:ss"));
        instVo.setImpSource("null".equalsIgnoreCase(dto.getImpSource()) || null == dto.getImpSource() ? "" : dto.getImpSource());
        instVo.setYear(dto.getYear());
    }

    private void convertDto(ResGetTaskPendDTO dto, String classify, List list) {
        if (dto == null) {
            return;
        }
        ResGetTaskPendDto newDto = new ResGetTaskPendDto();
        BeanUtils.copyProperties(dto, newDto);
        newDto.setPblmClassify(classify);
        list.add(newDto);
    }

    /**
     * 查询待办任务数量
     *
     * @param userId
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "查询待办任务数量")
    @GetMapping("/v1/workflow/queryPendingTaskCount/{userId}")
    public Result<Integer> queryPendingTaskCount(@PathVariable String userId) {
        return bpmTaskService.queryPendingTaskCount(userId);
    }

    /**
     * 查询下一节点详情
     *
     * @param reqQueryTasknextnodeDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "查询下一节点详情")
    @PostMapping("/v1/workflow/findNextActivityParticipants")
    public Result<ResQueryNextActivityDTO> findNextActivityParticipants(@RequestBody ReqQueryTasknextnodeDTO reqQueryTasknextnodeDTO) {
        if (Objects.isNull(reqQueryTasknextnodeDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        QueryTasknextnodeCO queryTasknextnodeCO = new QueryTasknextnodeCO();
        ConvertBeanUtils.copyPropertiesBySource(reqQueryTasknextnodeDTO, queryTasknextnodeCO);
        return bpmTaskService.findNextActivityParticipants(queryTasknextnodeCO);
    }

    /**
     * 查询待办任务详情
     *
     * @param taskInstId
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "查询待办任务详情")
    @GetMapping("/v1/workflow/qryTaskDetail/{taskInstId}")
    public BaseResponse<ResGetTaskDetailDTO> qryTaskDetail(@PathVariable String taskInstId) {
        if (StringUtils.isEmpty(taskInstId)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        QueryTaskDetailCO queryTaskDetailCO = new QueryTaskDetailCO();
        queryTaskDetailCO.setTaskInstId(taskInstId);
        return buildSuccessResponse(getLink(bpmTaskService.qryTaskDetail(queryTaskDetailCO)).getContent());
    }

    /**
     * 查询待办任务详情
     *
     * @param procInstId
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "依据流程实例查询任务详细")
    @GetMapping("/v1/workflow/task/{procInstId}")
    public Result<ResProcTaskDetailDTO> qryProcTaskDetail(@PathVariable String procInstId) {
        if (StringUtils.isEmpty(procInstId)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        APIResult<ResProcTaskDetailDTO> resProcTaskDetailDTOResult = bpmTaskService.qryProcTaskDetail(procInstId);
        ResProcTaskDetailDTO resProcTaskDetailDTO = resProcTaskDetailDTOResult.getContent();
        if (resProcTaskDetailDTO != null) {
            Link queryFlowChartLink = ControllerLinkBuilder.linkTo(ControllerLinkBuilder.methodOn(ProcessInstController.class).post_qryProcessDiagram(procInstId)).withRel("bpmn").withTitle("查询流程图");
            resProcTaskDetailDTO.setFormDataUrl(appendUrlWithLink(resProcTaskDetailDTO.getFormDataUrl(),
                    queryFlowChartLink.getHref()));
        }
        return resProcTaskDetailDTOResult;
    }

    private Result<ResGetTaskDetailDTO> getLink(APIResult<ResGetTaskDetailDTO> qryTaskDetail) {

        ResGetTaskDetailDTO resGetTaskDetailDTO = qryTaskDetail.getContent();
        String procInstId = resGetTaskDetailDTO != null ? resGetTaskDetailDTO.getProcInstId() : "";
        String taskInstId = resGetTaskDetailDTO != null ? resGetTaskDetailDTO.getTaskInstId() : "";
        Link queryTaskFlowLink = linkTo(ControllerLinkBuilder.methodOn(TaskInstController.class).queryTaskFlowList(procInstId)).withRel("queryTaskFlowList").withTitle("查询流转历史");
        Link queryFlowChartLink = linkTo(ControllerLinkBuilder.methodOn(ProcessInstController.class).post_qryProcessDiagram(procInstId)).withRel("bpmn").withTitle("查询流程图");

        Link denyOverLink = ControllerLinkBuilder.linkTo(ControllerLinkBuilder.methodOn(TaskActionController.class).denyOver(taskInstId)).withRel("taskAction/" + taskInstId + "/denyOverLink").withTitle("任务-流程-否决结束");
        Link abandonOverLink = linkTo(ControllerLinkBuilder.methodOn(TaskActionController.class).abandonOver(taskInstId)).withRel("taskAction/" + taskInstId + "/abandonOverLink").withTitle("任务-流程-作废结束");
        Link submitLink =
                linkTo(ControllerLinkBuilder.methodOn(TaskActionController.class).actionSubmit(taskInstId, new ReqTaskActionSubmitDTO())).withRel("taskAction/" + taskInstId + "/submit").withTitle("任务-提交");
        Link backLink =
                linkTo(ControllerLinkBuilder.methodOn(TaskActionController.class).actionBack(taskInstId, new ReqTaskActionBackDTO())).withRel("taskAction/" + taskInstId + "/back").withTitle("任务-退回");
        Link suspendLink =
                linkTo(ControllerLinkBuilder.methodOn(ProcessInstController.class).post_suspendProcInst(procInstId)).withRel("suspendProcInst").withTitle("挂起流程");
        Link resumeLink =
                linkTo(ControllerLinkBuilder.methodOn(ProcessInstController.class).post_resumeProcInst(procInstId)).withRel("resumeProcInst").withTitle("重启挂起流程");
        Link saveLink =
                linkTo(ControllerLinkBuilder.methodOn(TaskInstController.class).saveTempComment(new ReqPostTempCommentSaveDTO())).withRel("saveTempComment").withTitle("保存");

        Map<String, String> linkMap = new HashMap<>();
        linkMap.put("submit", submitLink.getHref());
        linkMap.put("back", backLink.getHref());
        linkMap.put("deny-over", denyOverLink.getHref());
        linkMap.put("abandon-over", abandonOverLink.getHref());
        linkMap.put("taskActionLink", queryFlowChartLink.getHref());
        linkMap.put("suspend", suspendLink.getHref());
        linkMap.put("resume", resumeLink.getHref());
        linkMap.put("save", saveLink.getHref());

        if (qryTaskDetail.getContent() != null) {
            Map<String, String> targetMap = qryTaskDetail.getContent().get_links();
            targetMap.put("graph", queryFlowChartLink.getHref());
            targetMap.put("opinion", queryTaskFlowLink.getHref());

            //处理操作类型的链接（加签，退回，提交和结束）
            dealWithActionLink(targetMap, qryTaskDetail.getContent().getNodeOperList(), linkMap);

            resGetTaskDetailDTO.setFormDataUrl(appendUrlWithLink(resGetTaskDetailDTO.getFormDataUrl(),
                    queryFlowChartLink.getHref()));
        }
        return qryTaskDetail;
    }

    private void dealWithActionLink(Map<String, String> targetMap, List<OperationCfgInfo> nodeOperList,
                                    Map<String, String> linkMap) {
        if (CollectionUtil.isNotEmpty(nodeOperList)) {
            nodeOperList.stream().forEach(operationConfigInfo -> {
                String targetLink = "";
                if (ActionConstant.PROCESS_ACTION_TYPE.equals(operationConfigInfo.getActionType())) {
                    //流程动作
                    targetLink = getSpecifyHrefWithEnumKey(linkMap, operationConfigInfo.getOperationType());
                    setMapValue(targetMap, operationConfigInfo, targetLink);
                }
            });
        }

    }

    private String getSpecifyHrefWithEnumKey(Map<String, String> linkMap, String operationTypeCode) {
        for (Map.Entry<String, String> entry : actionMap.entrySet()) {
            if (entry.getKey().equals(operationTypeCode)) {
                return getSpecifyHrefWithKey(linkMap, entry.getValue());
            }
        }
        return null;
    }

    private String getSpecifyHrefWithKey(Map<String, String> linkMap, String linkName) {
        for (Map.Entry<String, String> entry : linkMap.entrySet()) {
            if (entry.getKey().equals(linkName)) {
                return entry.getValue();
            }
        }
        return null;
    }

    private void setMapValue(Map<String, String> targetMap, OperationCfgInfo operationCfgInfo,
                             String targetLink) {
        for (Map.Entry<String, String> entry : actionMap.entrySet()) {
            if (entry.getKey().equals(operationCfgInfo.getOperationType())) {
                targetMap.put(entry.getValue(), targetLink);
            }
        }
    }

    private static String appendUrlWithLink(String formDataUrl, String tempLinkHref) {
        StringBuffer newFormDataUrl = new StringBuffer(tempLinkHref.substring(0, tempLinkHref.indexOf("bis/")));
        return newFormDataUrl.append(formDataUrl).toString();
    }

    /**
     * 查询流转历史
     *
     * @param procInstId
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "查询流转历史")
    @GetMapping("/v1/workflow/queryTaskFlowList/{procInstId}")
    public BaseResponse<List<ResQueryTaskFlowDTO>> queryTaskFlowList(@PathVariable String procInstId) {
        if (StringUtils.isEmpty(procInstId)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        QueryTaskFlowCO taskFlowCO = new QueryTaskFlowCO();
        taskFlowCO.setProcInstId(procInstId);
        return buildSuccessResponse(bpmTaskService.queryTaskFlowList(taskFlowCO).getContent());
    }

    /**
     * 领取任务
     *
     * @param reqTaskClaimDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "领取任务")
    @PostMapping("/v1/workflow/claimTask")
    public Result<?> claimTask(@RequestBody ReqTaskClaimDTO reqTaskClaimDTO) {
        if (Objects.isNull(reqTaskClaimDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskClaimCO taskClaimCO = new TaskClaimCO();
        ConvertBeanUtils.copyPropertiesBySource(reqTaskClaimDTO, taskClaimCO);
        return bpmTaskService.claimTask(taskClaimCO);
    }


    /**
     * 领取任务状态重置
     *
     * @param reqTaskUnClaimDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "领取任务状态重置")
    @PostMapping("/v1/workflow/unClaimTask")
    public Result<?> unClaimTask(@RequestBody ReqTaskUnClaimDTO reqTaskUnClaimDTO) {
        if (Objects.isNull(reqTaskUnClaimDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskUnClaimCO taskUnClaimCO = new TaskUnClaimCO();
        ConvertBeanUtils.copyPropertiesBySource(reqTaskUnClaimDTO, taskUnClaimCO);
        return bpmTaskService.unClaimTask(taskUnClaimCO);
    }


    /**
     * 查询当前任务竞签分配人
     *
     * @param reqGetTaskInstIdDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "查询当前任务竞签分配人")
    @PostMapping("/v1/workflow/qryClaimUsers")
    public Result<List<ResGetSysUserDTO>> qryClaimUsers(@RequestBody ReqGetTaskInstIdDTO reqGetTaskInstIdDTO) {
        if (Objects.isNull(reqGetTaskInstIdDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskInstIdCO taskInstIdCO = new TaskInstIdCO();
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskInstIdDTO, taskInstIdCO);
        return bpmTaskService.qryClaimUsers(taskInstIdCO);
    }

    /**
     * 挂起任务实例
     *
     * @param reqGetTaskInstIdDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "挂起任务实例")
    @PostMapping("/v1/workflow/suspendTask")
    public Result<?> suspendTask(@RequestBody ReqGetTaskInstIdDTO reqGetTaskInstIdDTO) {
        if (Objects.isNull(reqGetTaskInstIdDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskInstIdCO taskInstIdCO = new TaskInstIdCO();
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskInstIdDTO, taskInstIdCO);
        return bpmTaskService.suspendTask(taskInstIdCO);
    }

    /**
     * 启动挂起的任务实例
     *
     * @param reqGetTaskInstIdDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "启动挂起的任务实例")
    @PostMapping("/v1/workflow/resumeTask")
    public Result<?> resumeTask(@RequestBody ReqGetTaskInstIdDTO reqGetTaskInstIdDTO) {
        if (Objects.isNull(reqGetTaskInstIdDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskInstIdCO taskInstIdCO = new TaskInstIdCO();
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskInstIdDTO, taskInstIdCO);
        return bpmTaskService.resumeTask(taskInstIdCO);
    }

    /**
     * 获取当前任务可转发候选用户列表
     *
     * @param reqSysUserDTO
     * @return
     */
    @ApiOperation(value = "获取当前任务可转发候选用户列表")
    @PostMapping("/v1/workflow/qryTransferTaskUsers")
    public Result<List<ResSysUserDTO>> qryTransferTaskUsers(@RequestBody @Valid ReqSysUserDTO reqSysUserDTO) {
        if (reqSysUserDTO == null) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        return bpmTaskService.qryTransferTaskUsers(reqSysUserDTO);
    }

    /**
     * 任务转发
     *
     * @param reqPostTaskForwardDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "任务转发")
    @PostMapping("/v1/workflow/forwardTask")
    public Result<?> forwardTask(@RequestBody ReqPostTaskForwardDTO reqPostTaskForwardDTO) {
        if (Objects.isNull(reqPostTaskForwardDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskForwardCO taskForwardCO = new TaskForwardCO();
        ConvertBeanUtils.copyPropertiesBySource(reqPostTaskForwardDTO, taskForwardCO);
        return bpmTaskService.forwardTask(taskForwardCO);
    }

    /**
     * 任务撤回
     *
     * @param reqPostTaskRecallDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "任务撤回")
    @PostMapping("/v1/workflow/recallTask")
    public Result<?> recallTask(@RequestBody ReqPostTaskRecallDTO reqPostTaskRecallDTO) {
        if (Objects.isNull(reqPostTaskRecallDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskRecallCO taskRecallCO = new TaskRecallCO();
        ConvertBeanUtils.copyPropertiesBySource(reqPostTaskRecallDTO, taskRecallCO);
        return bpmTaskService.recallTask(taskRecallCO);
    }

    /**
     * 任务意见暂存
     *
     * @param reqPostTempCommentSaveDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "任务意见暂存")
    @PostMapping("/v1/workflow/saveTempComment")
    public Result<?> saveTempComment(@RequestBody ReqPostTempCommentSaveDTO reqPostTempCommentSaveDTO) {
        if (Objects.isNull(reqPostTempCommentSaveDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TempCommentSaveCO tempCommentSaveCO = new TempCommentSaveCO();
        ConvertBeanUtils.copyPropertiesBySource(reqPostTempCommentSaveDTO, tempCommentSaveCO);
        return bpmTaskService.saveTempComment(tempCommentSaveCO);
    }

    /**
     * 查看任务标识
     *
     * @param reqGetTaskInstIdDTO
     * @return
     */
    //@RequiresPermissions("base.bpm.operation")
    @ApiOperation(value = "更新查看任务标识")
    @PostMapping("/v1/workflow/updateLookInd")
    public Result<?> updateLookInd(@RequestBody ReqGetTaskInstIdDTO reqGetTaskInstIdDTO) {
        if (Objects.isNull(reqGetTaskInstIdDTO)) {
            throw new BusinessException(CommonErrorCode.ParamIsNull);
        }
        TaskInstIdCO taskInstIdCO = new TaskInstIdCO();
        ConvertBeanUtils.copyPropertiesBySource(reqGetTaskInstIdDTO, taskInstIdCO);
        return bpmTaskService.updateLookInd(taskInstIdCO);
    }

}