PLTWEB.git - Gitblit

package com.vci.web.controller;
 
import com.vci.dto.ProcessTemplateVO;
import com.vci.pagemodel.*;
import com.vci.pagemodel.KeyValue;
import com.vci.starter.web.annotation.bus.VciNoUseBaseResult;
import com.vci.starter.web.annotation.controller.VciUnCheckRight;
import com.vci.starter.web.annotation.log.VciBusinessLog;
import com.vci.starter.web.annotation.permission.VciReferPermission;
import com.vci.starter.web.pagemodel.*;
import com.vci.starter.web.util.ControllerUtil;
import com.vci.web.service.WebProcessDefineServiceI;
import com.vci.web.util.WebUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
@VciBusinessLog(modelName="流程查询服务")
@Controller
@RequestMapping("/processDefineController")
public class WebProcessDefineController {
    
    @Autowired
    private WebProcessDefineServiceI proDefineService;
    
    @VciBusinessLog(operateName="获取待办事项")
    @RequestMapping("/getMyUndoTask")
    @ResponseBody
    public DataGrid getMyUndoTask(BaseQueryObject baseQueryObject){
        return proDefineService.getMyUndoProcessTask(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
    }
 
 
    @VciBusinessLog(operateName="查询当前用户发起的流程中正在执行中的流程")
    @RequestMapping("/getMyExecutingProcess")
    @ResponseBody
    public DataGrid getMyExecutingProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getMyExecutingProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询所有正在执行中的流程")
    @RequestMapping("/getAllExecutingProcess")
    @ResponseBody
    public DataGrid getAllExecutingProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getAllExecutingProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询当前用户发起的流程中已经完成的流程")
    @RequestMapping("/getMyFinishProcess")
    @ResponseBody
    public DataGrid getFinishProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getMyCompletedProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询所有已经完成的流程")
    @RequestMapping("/getAllFinishProcess")
    @ResponseBody
    public DataGrid getAllFinishProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getAllCompletedProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询当前用户发起的流程中已经终止的流程")
    @RequestMapping("/getMyEndProcess")
    @ResponseBody
    public DataGrid getEndProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getMyObsoledtedProcess(baseQueryObject.getConditionMap(), baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询所有已终止的流程")
    @RequestMapping("/getAllEndProcess")
    @ResponseBody
    public DataGrid getAllEndProcess(BaseQueryObject baseQueryObject){
            return proDefineService.getAllObsoledtedProcess(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询当前用户发起的流程中已经挂起的流程")
    @RequestMapping("/getMySuspendedProcess")
    @ResponseBody
    public DataGrid getMySuspendedProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getMySuspendedProcess(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询当前用户发起的流程中已经挂起的流程")
    @RequestMapping("/getAllSuspendedProcess")
    @ResponseBody
    public DataGrid getAllSuspendedProcess(BaseQueryObject baseQueryObject){
        return proDefineService.getAllSuspendedProcess(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
    }
 
    @VciBusinessLog(operateName="查询当前用户已经处理的流程任务")
    @RequestMapping("/getMyDoneProcessTask")
    @ResponseBody
    public DataGrid getMyDoneProcessTask(BaseQueryObject baseQueryObject){
        return proDefineService.getMyDoneProcessTask(baseQueryObject.getConditionMap(),baseQueryObject.getPageHelper());
    }
    
    @VciBusinessLog(operateName="获取数据展示所需表格的定义",notStore=true)
    @RequestMapping("/getDataDefine")
    @ResponseBody
    public BaseResult getDataDefine(String executionid, String taskOid, HttpServletRequest request) {
        if(StringUtils.isNotBlank(executionid)){
 
        }
        Map<String, Object> map =  proDefineService.getDataTableDefine(executionid,taskOid);
        if(!map.isEmpty()) {
            return BaseResult.success(map);
        }else {
            return BaseResult.fail("没有找到定义");
        }
    }
 
    @VciBusinessLog(operateName="根据任务主键获取任务对象",notStore=true)
    @RequestMapping("/getTaskByOid")
    @ResponseBody
    public BaseResult getTaskByOid(String taskOid){
        return BaseResult.success(proDefineService.getTaskByOid(taskOid));
    }
    
    @VciBusinessLog(operateName="获取任务关联的数据",notStore=true)
    @RequestMapping("/getDataByTask")
    @ResponseBody
    public DataGrid getDataByTask(BaseQueryObject baseQueryObject,String referColumn){
        if(baseQueryObject == null || baseQueryObject.getConditionMap() == null ||
                (!baseQueryObject.getConditionMap().containsKey("taskOid") && !baseQueryObject.getConditionMap().containsKey("processOid"))){
            return new DataGrid();
        }
        String taskOid = "";
        if(baseQueryObject.getConditionMap().containsKey("taskOid")){
            taskOid = baseQueryObject.getConditionMap().get("taskOid");
        }
        String processOid = "";
        if(baseQueryObject.getConditionMap().containsKey("processOid")){
            processOid = baseQueryObject.getConditionMap().get("processOid");
        }
        return proDefineService.getDataInProcess(taskOid,processOid,referColumn);
    }
 
    @VciBusinessLog(operateName="获取流程中业务数据关联文件",notStore=true)
    @RequestMapping("/dataGridFileInProcess")
    @ResponseBody
    public DataGrid dataGridFileInProcess(BaseQueryObject baseQueryObject,String dataOid,String executionid){
        return proDefineService.getFilesInProcess((baseQueryObject != null ? baseQueryObject.getConditionMap() : (new HashMap<String, String>())), dataOid, executionid,baseQueryObject.getPageHelper());
    }
    
    @VciBusinessLog(operateName="获取历史记录",notStore=true)
    @RequestMapping("/getHistory")
    @ResponseBody
    public DataGrid getHistory(String executionId,boolean showCurrentNode){
        return proDefineService.getHistory(executionId, showCurrentNode);
    }
    //应该使用ResonseEntity，但是不知为何前台没有获取到值，暂时使用流输出的方式
    @VciBusinessLog(operateName="获取流程图片",notStore=true)
    @GetMapping("/getProcessPic")
    public void getProcessPic(String executionId,String taskOid,HttpServletResponse response){
        try {
            byte[] picData = proDefineService.getProcessPicture(executionId, taskOid);
            if(picData!=null&& picData.length>0){
                response.setContentType(MediaType.IMAGE_PNG.toString());
                OutputStream os = response.getOutputStream();
                os.write(picData);
                os.flush();
                os.close();
                return;
            }
        } catch (Exception e) {
            try {
                ControllerUtil.writeDataToResponse(response,WebUtil.getErrorMsg(e).getBytes(),null);
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
    }
    
    @VciBusinessLog(operateName="校验流程任务是否使用相同的模板",notStore=true)
    @RequestMapping("/checkUseSameTemplate")
    @ResponseBody
    public BaseResult checkUseSameTemplate(String taskOids){
        try {
             return BaseResult.success(proDefineService.checkUseSameTemplate(taskOids));
        } catch (Exception e) {
            return BaseResult.fail(WebUtil.getErrorMsg(e));
        }
    }
    
    @VciBusinessLog(operateName="获取任务的路由",notStore=true)
    @RequestMapping("/getOutcomes")
    @ResponseBody
    public BaseResult getOutcomes(String taskOid){
         List<ProcessOutcomeVO> allOutcomes = proDefineService.getOutCome(taskOid, true);
        BaseResult result = BaseResult.success();
        result.setData(allOutcomes);
         if(allOutcomes !=null && allOutcomes.size()>0){
             result.setSuccess(true);
         }else{
             result.setSuccess(false);
             result.setMsg("获取的路由为空");
         }
         return result;
    }
 
    /**
     * 获取某个分类下的userid可以使用的流程模板
     * @param type 流程分类
     * @param filterTemplate 指定模板
     * @return 可用的流程模版
     */
    @ResponseBody
    @RequestMapping("/getTemplateByType")
    @VciBusinessLog(operateName="获取流程模板",notStore=true)
    public BaseResult getTemplateByType(String type,String filterTemplate){
        List<ProcessTemplateVO> myTemplate = proDefineService.getMyTemplates(type, filterTemplate,false);
        List<KeyValue> allCombox = new ArrayList<KeyValue>();
        if(myTemplate!=null && myTemplate.size()>0){
            for(ProcessTemplateVO pt : myTemplate){
                KeyValue kv = new KeyValue();
                kv.setKey(pt.getOid());
                kv.setValue(pt.getName() + "-" + pt.getVersion());
                kv.setAttributes(WebUtil.objectToMap(pt));
                allCombox.add(kv);
            }
            BaseResult result = BaseResult.success();
            result.setData(allCombox);
            return result;
        }else{
            return BaseResult.fail("没有可用的版本");
        }
    }
 
    /**
     * 获取流程中定义的所有任务节点
     * @param processOid 流程模版的主键
     * @param maxSecret 数据中的最大密级值
     * @return 该流程模版中所有的任务节点,其中包含所有可以选择的用户
     */
    @ResponseBody
    @RequestMapping("/getAllProcessNode")
    @VciBusinessLog(operateName="获取流程的节点",notStore=true)
    public BaseResult getAllProcessNode(String processOid,int maxSecret){
        try{
            List<ProcessNodeVO> allNode = proDefineService.getAllProcessNode(processOid, true,maxSecret);
            if(allNode!=null && allNode.size()>0){
                BaseResult baseResult = BaseResult.success();
                baseResult.setData(allNode);
                return baseResult;
            }else{
                return BaseResult.fail("数据有误，没找到流程的节点");
            }
        }catch(Exception e){
            return BaseResult.fail(WebUtil.getErrorMsg(e));
        }
    }
 
    @ResponseBody
    @RequestMapping("/getVariableByKey")
    @VciBusinessLog(operateName="获取流程中参数",notStore=true)
    @VciReferPermission(referedKey = "getVariableByKeyInProcess")
    public BaseResult getVariableByKey(String executionId,String keys){
        if(StringUtils.isBlank(executionId) || StringUtils.isBlank(keys)){
            return BaseResult.fail("没有获取到流程的信息，无法查询变量");
        }
        return BaseResult.success(proDefineService.getVariablesInProcess(executionId, keys));
    }
 
    @ResponseBody
    @RequestMapping("/listAuditSuggestFile")
    @VciBusinessLog(operateName = "获取流程中的审批意见",notStore = true)
    public DataGrid<VciFileObjectVO> listAuditSuggestFile(String taskOids){
        return proDefineService.listAuditSuggestFile(taskOids);
    }
 
 
    /**
     * 参照流程分类列表
     * @param queryObject 查询对象
     * @return 分类的信息
     */
    @ResponseBody
    @RequestMapping(value = "/referGridProcessClassify",method = RequestMethod.GET)
    @VciBusinessLog(operateName = "参照流程分类")
    public DataGrid<ProcessClassifyVO> referGridProcessClassify(BaseQueryObject queryObject){
        return proDefineService.referGridProcessClassify(queryObject.getConditionMap(),queryObject.getPageHelper());
    }
 
    /**
     * 参照流程分类树
     * @param queryObject 查询对象
     * @return 分类的信息
     */
    @ResponseBody
    @RequestMapping(value = "/referTreeProcessClassify",method = RequestMethod.GET)
    @VciBusinessLog(operateName = "参照流程分类树")
    public List<Tree> referTreeProcessClassify(TreeQueryObject queryObject){
        return proDefineService.referTreeProcessClassify(queryObject);
    }
 
    /**
     * 参照流程的模板列表
     * @param processClassifyId 流程分类的名称
     * @param name 模板名称
     * @return 模板的信息
     */
    @ResponseBody
    @RequestMapping(value = "/referGridProcessTemplate",method = RequestMethod.GET)
    @VciBusinessLog(operateName = "参照流程模板")
    public DataGrid<ProcessTemplateVO> referGridProcessTemplate(String processClassifyId,String name){
        return proDefineService.referGridProcessTemplate(processClassifyId,name);
    }
 
    @VciNoUseBaseResult
    @RequestMapping("/getUndoTaskCount")
    @VciUnCheckRight
    @VciBusinessLog(operateName = "外部系统查询待办的总数")
    public void getUndoTaskCount(String username,HttpServletResponse response){
        String count =  String.valueOf(proDefineService.getUndoTaskCount(username));
        try {
            ControllerUtil.writeDataToResponse(response,count.getBytes(StandardCharsets.UTF_8),"text/html");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
 
}