BoundLink-Plate/bound-link-api/sa-flow-api/src/main/java/com/cloud/sa/api/AppEngineController.java

package com.cloud.sa.api;

import com.alibaba.fastjson.JSONObject;
import com.cloud.sa.flow.commom.domain.UserTaskQueryForm;
import com.cloud.sa.flow.commom.common.model.StCodeMsg;
import com.cloud.sa.flow.commom.common.model.StResult;
import com.cloud.sa.flow.commom.common.utils.StString;
import com.cloud.sa.flow.commom.domain.virentity.ViewFormTop;
import com.cloud.sa.flow.commom.service.setting.StSettingService;
import com.cloud.sa.flow.engine.service.StFlowService;
import com.cloud.sa.flow.commom.service.flow.StTaskItemService;
import com.cloud.sa.flow.commom.domain.entity.StFlowMenu;
import com.cloud.sa.flow.commom.domain.entity.StFlowTemplate;
import com.cloud.sa.flow.commom.domain.entity.StTaskitem;
import com.cloud.sa.flow.commom.domain.virentity.FlowEnteredParam;
import com.cloud.sa.flow.commom.service.StMenuService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.MediaTypeFactory;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

/**
 * @author lc
 * @date 2024/6/19 17:50
 */
@Tag(name = "流程中心")
@RequestMapping("/bpm/core")
@RestController
public class AppEngineController {

    @Autowired
    StTaskItemService taskItemService;
    @Autowired
    StMenuService stMenuService;
    @Autowired
    StFlowService flowService;
    @Autowired
    StSettingService settingService;

    /**
     * 保存并提交  【前台定义一个taskid，点提交时，如果taskid没有值则调用此接口 】
     *
     * @param flowEnteredParam
     * @return
     */
    @Operation(summary = "提交流程")
    @PostMapping("/instance/savesubmit")
    public StResult SaveSubmitInstance(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        StTaskitem taskitem = null;
        if (StString.isNotEmpty(flowEnteredParam.getTableData())) {
            //如果不是批量的审批通过，则先走一下保存
            taskitem = flowService.Save(flowEnteredParam, false);
            flowEnteredParam.setTaskid(taskitem.getObjectid());
        }
        try {
            flowService.Submit(flowEnteredParam);
            return StResult.success(taskitem);
        } catch (Exception e) {
            settingService.FlowCommonExceptionRecord(e, taskitem.getObjectid(), "提交");
            return StResult.error(StCodeMsg.SERVER_EXCEPTION, e.getMessage());
        }
    }

    /**
     * 保存流程
     * 一、流程发起后首次保存，点击保存按钮。
     * 1、保存流程实例+任务+step，并返回流程实例id。
     * 2、保存业务数据到数据库
     * 二、其他时候，点击保存按钮。
     * 1、仅保存修改了的业务数据到数据库
     *
     * @param flowEnteredParam flowCode，flowVersion，bizObjectid ,tableData四个个参数
     * @return taskid
     */
    @PostMapping("/instance/save")
    public StResult SaveInstance(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        StTaskitem taskitem = flowService.Save(flowEnteredParam, true);
        return StResult.success(taskitem);
    }

    /**
     * 已阅流程
     *
     * @param flowEnteredParam taskid可能是通过保存接口获得，或者是从代办任务中的链接中获得
     * @return
     */
    @PostMapping("/instance/handleRead")
    public StResult handleRead(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        try {
            flowService.Submit(flowEnteredParam);
            return StResult.success();
        } catch (Exception e) {
            return StResult.error(StCodeMsg.SERVER_EXCEPTION, e.getMessage());
        }

    }


    /**
     * 驳回到开始
     *
     * @param flowEnteredParam
     * @return
     */
    @PostMapping("/instance/rejectstart")
    public StResult RejectToStart(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        try {
            return StResult.success(flowService.RejectToStart(flowEnteredParam));
        } catch (Exception e) {
            settingService.FlowCommonExceptionRecord(e, flowEnteredParam.getTaskid(), "驳回");
            return StResult.error(StCodeMsg.SERVER_EXCEPTION, e.getMessage());
        }

    }

    /**
     * 转发
     *
     * @param flowEnteredParam
     * @return
     */
    @PostMapping("/instance/turn/one")
    public StResult handleTurnOne(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        try {
            return StResult.success(flowService.handleTurnOne(flowEnteredParam));
        } catch (Exception e) {
            settingService.FlowCommonExceptionRecord(e, flowEnteredParam.getTaskid(), "转发");
            return StResult.error(StCodeMsg.SERVER_EXCEPTION, e.getMessage());
        }

    }

    /**
     * 加签
     *
     * @param flowEnteredParam
     * @return
     */
    @PostMapping("/instance/add/one")
    public StResult handleAddOne(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        try {
            return StResult.success(flowService.handleAddOne(flowEnteredParam));
        } catch (Exception e) {
            settingService.FlowCommonExceptionRecord(e, flowEnteredParam.getTaskid(), "加签");
            return StResult.error(StCodeMsg.SERVER_EXCEPTION, e.getMessage());
        }

    }

    /**
     * 传阅
     *
     * @param flowEnteredParam
     * @return
     */
    @PostMapping("/instance/circulate/one")
    public StResult handleCirculated(@Validated @RequestBody FlowEnteredParam flowEnteredParam) {
        try {
            return StResult.success(flowService.handleCirculated(flowEnteredParam));
        } catch (Exception e) {
            settingService.FlowCommonExceptionRecord(e, flowEnteredParam.getTaskid(), "传阅");
            return StResult.error(StCodeMsg.SERVER_EXCEPTION, e.getMessage());
        }

    }

    /**
     * 插入模版
     *
     * @param saveOrPublish  0表示保存，1表示发布
     * @param stFlowTemplate
     * @return
     */
    @PostMapping("/istStFlowTemplate")
    public StResult istStFlowTemplate(String saveOrPublish, @Valid @RequestBody StFlowTemplate stFlowTemplate) {
        if (StString.isEmpty(saveOrPublish)) {
            return StResult.error(StCodeMsg.PARAMETER_ISNULL, "saveOrPublish为空");
        }
        flowService.istStFlowTemplate(saveOrPublish, stFlowTemplate);
        return StResult.success();
    }


    /**
     * 插入功能菜单
     *
     * @param stFlowMenu
     * @return
     */
    @PostMapping("/istStFlowMenu")
    public StResult istStFlowMenu(@Valid @RequestBody StFlowMenu stFlowMenu) {
        stMenuService.istStFlowMenu(stFlowMenu);
        return StResult.success();
    }


    /**
     * 获取功能菜单
     *
     * @param id
     * @return
     */
    @GetMapping("/getStFlowMenu")
    public String getStFlowMenu(int id) {
        StFlowMenu stFlowMenu = stMenuService.getStFlowMenu(id);
        return stFlowMenu.toString();
    }

    @GetMapping("/getAllStFlowMenu")
    public StResult getAllStFlowMenu(String queryMenuName) {
        return StResult.success(stMenuService.getAllStFlowMenu(queryMenuName));
    }

    @PostMapping("/delProcess")
    public StResult delProcess(@RequestBody JSONObject params) {
        stMenuService.delProcess(params.getString("flowCode"));
        return StResult.success();
    }

    @GetMapping("/getStartStFlowMenu")
    public StResult getStartStFlowMenu(String queryMenuName) {
        return StResult.success(stMenuService.getStartStFlowMenu(queryMenuName));
    }

    @GetMapping("/getQueryStFlowMenu")
    public StResult getQueryStFlowMenu(String queryMenuName) {
        return StResult.success(stMenuService.getQueryStFlowMenu(queryMenuName));
    }

    /**
     * 子流程选择流程模版
     *
     * @return
     */
    @GetMapping("/getChildFlowStFlowMenu")
    public StResult getChildFlowStFlowMenu() {
        return StResult.success(stMenuService.getChildFlowStFlowMenu());
    }

    /**
     * 根据流程编号获取流程实例
     *
     * @param enteredParam flowCode:流程编号， flowVersion：流程版本（不带此参数表示获取最新版本）
     * @return
     */
    @PostMapping("/getStFlowTemplate")
    public StResult getStFlowTemplate(@Validated @RequestBody FlowEnteredParam enteredParam) {
        StFlowTemplate stFlowTemplate = flowService.getStFlowTemplate(enteredParam.getFlowCode(), enteredParam.getFlowVersion());
        return StResult.success(stFlowTemplate);
    }

    /**
     * 获取当前用户的任务列表
     * 当前代办任务
     *
     * @return
     */
    @GetMapping("/getUserTaskList/todo")
    public StResult getUserTaskListTodo(UserTaskQueryForm form) {
        return StResult.success(taskItemService.getUserTaskListTodo(form));
    }

    @GetMapping("/getUserTaskNum")
    public StResult getUserTaskNum() throws ExecutionException, InterruptedException {
        return StResult.success(taskItemService.getUserTaskNum());
    }

    @GetMapping("/getNotices")
    public StResult getNotices() {
        return StResult.success(taskItemService.getNotices());
    }

    /**
     * 查询已办任务接口
     *
     * @param form
     * @return
     */
    @GetMapping("/getUserTaskList/done")
    public StResult getUserTaskListDone(UserTaskQueryForm form) {
        return StResult.success(taskItemService.getUserTaskListDone(form));
    }

    /**
     * 查询传阅流程
     *
     * @param form
     * @return
     */
    @GetMapping("/getUserTaskList/circulation")
    public StResult getUserTaskListCirculation(UserTaskQueryForm form) {
        return StResult.success(taskItemService.getUserTaskListCirculation(form));
    }

    /**
     * 查询我的流程
     *
     * @param form
     * @return
     */
    @GetMapping("/getUserTaskList/myTask")
    public StResult getUserTaskListMyTask(UserTaskQueryForm form) {
        return StResult.success(taskItemService.getUserTaskListMyTask(form));
    }

    @GetMapping("/getUserTaskList/queryTask")
    public StResult getUserTaskListQueryTask(UserTaskQueryForm form) {
        return StResult.success(taskItemService.getUserTaskListQueryTask(form));
    }


    /**
     * 流程图查看
     *
     * @param instanceid
     * @return
     */
    @GetMapping("/instance/view")
    public StResult View(String instanceid) {
        return StResult.success(flowService.ViewProcess(instanceid));
    }

    /**
     * 查看横向审批人
     *
     * @param instanceid
     * @return
     */
    @GetMapping("/instance/viewList")
    public StResult ViewList(String instanceid) {
        return StResult.success(flowService.ViewProcessList(instanceid));
    }

    @PostMapping("/addStFlowMenu")
    public StResult addStFlowMenu(@RequestBody JSONObject params) throws Exception {
        flowService.addStFlowMenu(params);
        return StResult.success();
    }

    /**
     * 查看流程下放的审批信息
     *
     * @param instanceid
     * @return
     */
    @GetMapping("/instance/task")
    public StResult getStTaskitemListByInstanceid(String instanceid) {
        JSONObject stTaskItemList = flowService.getStTaskItemList(instanceid);
        return StResult.success(stTaskItemList);
    }

    /**
     * 获取审批流查看页面的顶部信息
     *
     * @return
     */
    @GetMapping("/instance/view/top")
    public StResult getStViewFormTop(String instanceid) {
        ViewFormTop stViewFormTop = flowService.getStViewFormTop(instanceid);
        return StResult.success(stViewFormTop);
    }

    @GetMapping("/instance/getFlowTemplateHistory")
    public StResult getFlowTemplateHistory(String flowCode) {
        List<Map> flowTemplateHistory = flowService.getFlowTemplateHistory(flowCode);
        return StResult.success(flowTemplateHistory);
    }

    @GetMapping("/instance/getFlowTemplateForVersion")
    public StResult getFlowTemplateForVersion(String flowCode, Integer version) {
        StFlowTemplate stFlowTemplate = flowService.getStFlowTemplate(flowCode, version);
        return StResult.success(stFlowTemplate);
    }

    @GetMapping("/exportData")
    public void exportData(@RequestParam String flowCode, HttpServletRequest request, HttpServletResponse response) {
        // 设置文件名
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = now.format(formatter);
        String fileName = flowCode + formattedDateTime + ".txt";
        try {
            response.setHeader(HttpHeaders.CONTENT_TYPE, MediaTypeFactory.getMediaType(fileName).orElse(MediaType.APPLICATION_OCTET_STREAM) + ";charset=utf-8");
            response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8").replaceAll("\\+", "%20"));
            response.setHeader(HttpHeaders.ACCESS_CONTROL_EXPOSE_HEADERS, HttpHeaders.CONTENT_DISPOSITION);
            String exportData = flowService.getExportData(flowCode);
            // 写入数据到响应流
            OutputStream outputStream = response.getOutputStream();
            outputStream.write(exportData.getBytes("UTF-8"));
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
            // 处理异常
        }
    }

    @PostMapping("/importData")
    public StResult importData(@RequestParam MultipartFile file) {
        return flowService.importData(file);
    }

}