tofly-hnls/common-flow/src/main/java/com/tofly/flow/controller/ProcessTemplateController.java

package com.tofly.flow.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import com.tofly.common.core.entity.ResultRespone;
import com.tofly.common.core.util.StringUtil;
import com.tofly.common.log.annotation.ToFlyAppLog;

import com.tofly.common.oauth.util.SecurityUtils;
import com.tofly.flow.dto.FormDataDto;
import com.tofly.flow.dto.ProcessInfoDto;
import com.tofly.flow.dto.ProcessInstanceDto;
import com.tofly.flow.dto.ProcessNodeInfoDto;
import com.tofly.flow.dto.ProcessTemplateNodeInfoChangeDto;
import com.tofly.flow.dto.ProcessTemplateNodeInfoDto;
import com.tofly.flow.entity.FormData;
import com.tofly.flow.entity.FormInstance;
import com.tofly.flow.entity.FormTemplate;
import com.tofly.flow.entity.FormTemplateContent;
import com.tofly.flow.entity.ProcessInstance;
import com.tofly.flow.entity.ProcessInstanceNodeInfo;
import com.tofly.flow.entity.ProcessTemplate;
import com.tofly.flow.entity.ProcessTemplateNode;
import com.tofly.flow.entity.ProcessTemplateNodeJudge;
import com.tofly.flow.service.FormDataService;
import com.tofly.flow.service.FormInstanceService;
import com.tofly.flow.service.FormTemplateContentService;
import com.tofly.flow.service.FormTemplateService;
import com.tofly.flow.service.IFileInfoService;
import com.tofly.flow.service.ProcessInstanceNodeInfoService;
import com.tofly.flow.service.ProcessInstanceService;
import com.tofly.flow.service.ProcessTemplateNodeJudgeService;
import com.tofly.flow.service.ProcessTemplateNodeService;
import com.tofly.flow.service.ProcessTemplateService;
import com.tofly.flow.vo.ApprovalNodeInfoVo;

import lombok.AllArgsConstructor;

import org.apache.commons.beanutils.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;


import java.util.*;

import javax.servlet.http.HttpServletRequest;

/**
 * 流程表单接口
 *
 * @author zhoux
 */
@RestController
@AllArgsConstructor
@RequestMapping("/processTemplate")
@Api(tags="流程模板管理接口")
public class ProcessTemplateController {
 
    private final  ProcessTemplateService processTemplateService;
        
    private final  ProcessTemplateNodeService processTemplateNodeService;
    
    private final  ProcessTemplateNodeJudgeService processTemplateNodeJudgeService;
    
    //模板流程增删改（对应实体为：ProcessTemplate）
    //----------------------------------------------------------------------------------------------------------
    
    /**
     * 流程模板分页查询
     * @param page 分页对象
     * @return
     */
     @GetMapping("/page" )
     @ApiOperation(value = "流程模板分页查询")
     public ResultRespone getProcessTemplatePage(Page page, @ModelAttribute ProcessTemplate processTemplate) {
    	 return ResultRespone.success(processTemplateService.page(page, Wrappers.query(processTemplate)));
     }
    
     /**
      * 通过id查询
      * @param id id
      * @return ResultRespone
      */
     @GetMapping("/{id}" )
     @ApiOperation(value = "通过ID查询流程模板信息")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "BigDecimal")
     })
     public ResultRespone getProcessTemplateById(@PathVariable("id" ) Long id) { 
    	ProcessTemplate processTemplate = processTemplateService.getById(id);    	 
     	List<ProcessTemplateNodeJudge>  judges = processTemplateNodeJudgeService.list(Wrappers.<ProcessTemplateNodeJudge>lambdaQuery()
 				.eq(ProcessTemplateNodeJudge::getProcessTemplateId,id)); 	
     	processTemplate.setProcessTemplateNodeJudges(judges);     	
     	return ResultRespone.success(processTemplate);
     }

     /**
      * 新增流程模板信息
      * @return ResultRespone
      */
     @ToFlyAppLog(title="新增流程模板信息" )
     @ApiOperation(value = "新增流程模板信息")
     @PostMapping
     public ResultRespone saveProcessTemplate(@RequestBody ProcessTemplate processTemplate,HttpServletRequest request) {		
    	 processTemplate.setCreateUser(SecurityUtils.getUserId());
    	 processTemplate.setCreateTime(new Date());
    	 processTemplateService.save(processTemplate);
         return ResultRespone.success(processTemplate.getId());
     }
     
     /**
      * 修改
      * @return ResultRespone
      */
     @ToFlyAppLog(title="修改流程模板信息" )
     @ApiOperation(value = "修改流程模板信息")
     @PutMapping
     public ResultRespone updateProcessTemplateById(@RequestBody ProcessTemplate processTemplate,HttpServletRequest request) {
     	return ResultRespone.success(processTemplateService.updateById(processTemplate));
     }
     
            
     /**
      * 通过id批量删除
      * @param ids id
      * @return ResultRespone
      */
     @ToFlyAppLog(title="通过id批量删除流程模板" )
     @ApiOperation(value = "通过ID批量删除流程模板")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "ids", value = "批量删除，多个id以逗号隔开", required = true, dataType = "String")
     })
     @DeleteMapping("/deleteByIds" )
     public ResultRespone removeProcessTemplateByIds(String ids) {
    	 
    	 List<String> idList = Arrays.asList(ids.split(","));
    	 
    	 for(String id : idList) {		 
    		 processTemplateNodeService.remove((Wrappers.<ProcessTemplateNode>lambdaQuery()
     				.eq(ProcessTemplateNode::getProcessTemplateId,id))); 
    		 processTemplateNodeJudgeService.remove((Wrappers.<ProcessTemplateNodeJudge>lambdaQuery()
      				.eq(ProcessTemplateNodeJudge::getProcessTemplateId,id)));
    	 }
    	 
         return ResultRespone.success(processTemplateService.removeByIds(idList));
     }
     
     
     /**
      * 获取所有流程模板列表信息
      * @return ResultRespone
      */
     @ApiOperation(value = "获取所有流程模板列表信息")
     @GetMapping("/queryProcessTemplateList")
     public ResultRespone queryProcessTemplateList() {
     	try {
         	List<ProcessTemplate> tempList= processTemplateService.list();
         	return ResultRespone.success(tempList);
     	}catch (Exception e) {
     		return ResultRespone.failed(e.getMessage());
 		}
     }
     
     //模板流程节点增删改（对应实体为：ProcessTemplateNode）
     //----------------------------------------------------------------------------------------------------------
     
     /**
      * 根据流程模板ID获取该流程下所有的流程模板节点信息(去重查询)
      * @return ResultRespone
      */
     @ApiOperation(value = "根据流程模板ID获取该流程下流程模板节点（去重查询） id:流程模板ID ")
     @GetMapping("/processTemplateApprovalNodes/{id}")
     public ResultRespone processTemplateApprovalNodes(@PathVariable("id") Long processTemplateId) {    	
     	try {
         	return ResultRespone.success(processTemplateService.getNodeInfoApprovalByTemplateId(processTemplateId));
     	}catch (Exception e) {
     		e.printStackTrace();
     		return ResultRespone.failed(e.getMessage());
 		}
     }
     
     /**
      * 通过id查询
      * @param id id
      * @return ResultRespone
      */
     @GetMapping("/processTemplateNode/{id}" )
     @ApiOperation(value = "通过ID查询流程模板信息")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "id", value = "ID", required = true, dataType = "BigDecimal")
     })
     public ResultRespone getProcessTemplateNodeById(@PathVariable("id" ) Long id) {
     	return ResultRespone.success(processTemplateNodeService.getById(id));
     }
     
     /**
      * 新增流程模板节点信息
      * @return ResultRespone
      */
     @ToFlyAppLog(title="新增流程模板节点信息" )
     @ApiOperation(value = "新增流程模板节点信息")
     @PostMapping("/processTemplateNode")
     public ResultRespone saveProcessTemplateNode(@RequestBody ProcessTemplateNode processTemplateNode) {		
    	 processTemplateNodeService.save(processTemplateNode);
         return ResultRespone.success(processTemplateNode.getId());
     }
     
     
     /**
      * 修改
      * @return ResultRespone
      */
     @ToFlyAppLog(title="修改流程模板节点信息" )
     @ApiOperation(value = "修改流程模板节点信息（不修改审批人信息）")
     @PutMapping("/processTemplateNode")
     public ResultRespone updateProcessTemplateNodeById(@RequestBody ProcessTemplateNode processTemplateNode) {
    	 
    	 
    	ProcessTemplateNode existNode = processTemplateNodeService.getById(processTemplateNode.getId());    	 
    	 
  		List<ProcessTemplateNode> nodes = processTemplateNodeService.list(Wrappers.<ProcessTemplateNode>lambdaQuery()
 				.eq(ProcessTemplateNode::getProcessTemplateId,existNode.getProcessTemplateId())
 				.eq(ProcessTemplateNode::getProcessNodeAlias,existNode.getProcessNodeAlias()));
  		
  		for(ProcessTemplateNode node:nodes) {
  			node.setSortNum(processTemplateNode.getSortNum());
  			node.setProcessNodeAlias(processTemplateNode.getProcessNodeAlias());
  			node.setProcessNodeName(processTemplateNode.getProcessNodeName());
  			node.setFormTemplateId(processTemplateNode.getFormTemplateId());
  			processTemplateNodeService.updateById(node);
  		}
  		
    	return ResultRespone.success(true);
     }
     
          
     /**
      * 通过id批量删除
      * @param ids id
      * @return ResultRespone
      */
     @ToFlyAppLog(title="通过id批量删除流程节点信息" )
     @ApiOperation(value = "通过id批量删除流程节点信息")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "ids", value = "批量删除，多个id以逗号隔开", required = true, dataType = "String")
     })
     @DeleteMapping("/processTemplateNode/deleteByIds" )
     public ResultRespone removeFormTemplateNodeByIds(String ids) {
    	 
    	 List<String> idList = Arrays.asList(ids.split(","));
    	 
    	 for(String id : idList) {	
    		 ProcessTemplateNode  node=  processTemplateNodeService.getById(id);
    		 processTemplateNodeService.remove(Wrappers.<ProcessTemplateNode>lambdaQuery()
    	 				.eq(ProcessTemplateNode::getProcessTemplateId,node.getProcessTemplateId())
    	 				.eq(ProcessTemplateNode::getProcessNodeAlias,node.getProcessNodeAlias()));
    	 }
    	 
         return ResultRespone.success(true);
     }
     
     
     //流程模板节点审批人（多人查询、修改）
     //----------------------------------------------------------------------------------------------------------
     
     
     /**
      * 根据流程模板ID获取该流程下所有的流程模板节点信息
      * @return ResultRespone
      */
     @ApiOperation(value = "根据流程模板ID获取该流程下所有的流程模板节点信息 id:流程模板ID ")
     @GetMapping("/processTemplateNodes/{id}")
     public ResultRespone processTemplateNodes(@PathVariable("id") Long processTemplateId) {    	
     	try {
     		List<ProcessTemplateNode> nodes = processTemplateNodeService.list(Wrappers.<ProcessTemplateNode>lambdaQuery()
     				.eq(ProcessTemplateNode::getProcessTemplateId,processTemplateId)
     				.orderByAsc(ProcessTemplateNode::getSortNum));
         	return ResultRespone.success(nodes);
     	}catch (Exception e) {
     		e.printStackTrace();
     		return ResultRespone.failed(e.getMessage());
 		}
     }

     
     /**
      * 修改流程节点审批信息
      * @return ResultRespone
      */
     @ApiOperation(value = "修改流程节点审批人信息")
     @PostMapping("/processTemplateNode/updateProcessTemplateApprovalNode")
     public ResultRespone updateProcessTemplateApprovalNode(@RequestBody ProcessTemplateNodeInfoChangeDto processTemplateNodeInfoChangeDto) {    	
     	try {
     		
     		 processTemplateNodeService.remove((Wrappers.<ProcessTemplateNode>lambdaQuery()
      				.eq(ProcessTemplateNode::getProcessTemplateId, processTemplateNodeInfoChangeDto.getProcessTemplateId())
      				.eq(ProcessTemplateNode::getProcessNodeAlias,  processTemplateNodeInfoChangeDto.getProcessTemplateNodeAlias()))); 
     		 	 
      		 
     		 System.out.println("审批人修改>>>>>>>>>>>>>>>>>>>"+processTemplateNodeInfoChangeDto.getApprovalPerson().size());
     		 
     		 for(Map<String,String> person: processTemplateNodeInfoChangeDto.getApprovalPerson()) {
      			 
      			ProcessTemplateNode templateNode =new ProcessTemplateNode();
      			
      			templateNode.setApprovalPersonId(Long.valueOf(person.get("approvalPersonId")));
      			templateNode.setApprovalPersonName(person.get("approvalPersonName"));
      			templateNode.setApprovalType(processTemplateNodeInfoChangeDto.getApprovalType());
      			templateNode.setProcessTemplateId(processTemplateNodeInfoChangeDto.getProcessTemplateId());
      			templateNode.setProcessNodeAlias(processTemplateNodeInfoChangeDto.getProcessTemplateNodeAlias());
      			
      			templateNode.setFormTemplateId(processTemplateNodeInfoChangeDto.getFormTemplateId());
      			templateNode.setSortNum(processTemplateNodeInfoChangeDto.getSortNum());
      			templateNode.setProcessNodeName(processTemplateNodeInfoChangeDto.getProcessTemplateNodeName());
      			
      			processTemplateNodeService.save(templateNode);
      			 
      		 }
     		     		     		     		
         	return ResultRespone.success(true);
     	}catch (Exception e) {
     		e.printStackTrace();
     		return ResultRespone.failed(e.getMessage());
 		}
     }
     
     
     
     
     //模板流程规则增删改（对应实体为：ProcessTemplateNodeJudge）
     //----------------------------------------------------------------------------------------------------------
     
     /**
      * 新增流程规则信息
      * @return ResultRespone
      */
     @ToFlyAppLog(title="新增流程规则信息" )
     @ApiOperation(value = "新增流程规则信息")
     @PostMapping("/processTemplateNodeJudge")
     public ResultRespone saveProcessTemplateNodeJudge(@RequestBody ProcessTemplateNodeJudge processTemplateNodeJudge) {		
    	 processTemplateNodeJudgeService.save(processTemplateNodeJudge);
         return ResultRespone.success(processTemplateNodeJudge.getId());
     }
     
     /**
      * 修改
      * @return ResultRespone
      */
     @ToFlyAppLog(title="修改流程规则信息" )
     @ApiOperation(value = "修改流程规则信息")
     @PutMapping("/processTemplateNodeJudge")
     public ResultRespone updateProcessTemplateNodeJudge(@RequestBody ProcessTemplateNodeJudge processTemplateNodeJudge) {
     	return ResultRespone.success(processTemplateNodeJudgeService.updateById(processTemplateNodeJudge));
     }
     
            
     /**
      * 通过id批量删除
      * @param ids id
      * @return ResultRespone
      */
     @ToFlyAppLog(title="通过id批量删除流程规则信息" )
     @ApiOperation(value = "通过ID批量删除流程规则信息")
     @ApiImplicitParams({
             @ApiImplicitParam(name = "ids", value = "批量删除，多个id以逗号隔开", required = true, dataType = "String")
     })
     @DeleteMapping("/processTemplateNodeJudge/deleteByIds" )
     public ResultRespone removeProcessTemplateNodeJudge(String ids) {
    	 List<String> idList = Arrays.asList(ids.split(","));
         return ResultRespone.success(processTemplateNodeJudgeService.removeByIds(idList));
     }
}