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

package com.cloud.sa.api;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.cloud.sa.flow.commom.aspect.EventProgram;
import com.cloud.sa.flow.commom.common.model.StResult;
import com.cloud.sa.flow.commom.common.system.StUserInfo;
import com.cloud.sa.flow.commom.common.utils.StConvert;
import com.cloud.sa.flow.commom.common.utils.StString;
import com.cloud.sa.flow.commom.domain.entity.*;
import com.cloud.sa.flow.commom.domain.virentity.TreeNode;
import com.cloud.sa.flow.commom.service.StMenuService;
import com.cloud.sa.flow.commom.service.StOrganizeService;
import com.cloud.sa.flow.commom.service.setting.StAdmitService;
import com.cloud.sa.flow.commom.service.setting.StSettingService;
import com.cloud.sa.flow.commom.domain.entity.setting.StEventAdditive;
import com.cloud.sa.flow.commom.domain.entity.setting.StEventMain;
import com.cloud.sa.flow.commom.domain.entity.setting.StQueryMain;
import com.cloud.sa.flow.commom.service.setting.StTaskAgentService;
import com.cloud.sa.flow.engine.service.StFlowService;
import com.wx.blink.base.common.annoation.NoNeedLogin;
import com.wx.blink.base.common.domain.ResponseDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

/**
 * @author lc
 * @date 2024/6/19 17:50
 */
@RequestMapping("/setting/engine")
@RestController
public class SettingEngineController {
    @Autowired
    StSettingService settingService;
    @Autowired
    StMenuService menuService;
    @Autowired
    StAdmitService admitService;
    @Autowired
    StFlowService flowService;
    @Autowired
    StTaskAgentService taskAgentService;
    @Autowired
    StOrganizeService organizeService;

    /**
     * 取回
     *
     * @param taskId
     * @return
     */
    @PostMapping("/retrieveFlow")
    public StResult retrieveFlow(String instanceId, String taskId) {
        return flowService.retrieveFlow(instanceId, taskId);
    }

    @PostMapping("/istQueryMain")
    public StResult istQueryMain(@RequestBody StQueryMain queryMain) {
        settingService.istQueryMain(queryMain);
        return StResult.success();
    }

    @GetMapping("/getQueryData")
    public StResult getQueryData(Integer queryMainId, String query, String queryMapField) {
        List<Map<String, String>> queryData = settingService.getQueryData(queryMainId, query, queryMapField);
        return StResult.success(queryData);
    }

    @GetMapping("/getQueryPopupData")
    public StResult getQueryPopUpData(String queryCode, String query, String queryMapField) {
        List<Map<String, String>> queryData = settingService.getQueryPopupData(queryCode, query, queryMapField);
        return StResult.success(queryData);
    }

    @PostMapping("/updateQueryMain")
    public StResult updateStQueryMain(@RequestBody StQueryMain queryMain) {
        settingService.updateStQueryMain(queryMain);
        return StResult.success();
    }

    @GetMapping("/getQueryMainList")
    public StResult getStQueryMainList(String queryName) {
        return StResult.success(settingService.getStQueryMainList(queryName));
    }

    @GetMapping("/getQueryMainListForMapping")
    public StResult getQueryMainListForMapping() {
        return StResult.success(settingService.getQueryMainListForMapping());
    }

    @GetMapping("/getServiceMapping")
    public StResult getServiceMapping(String serviceName) {
        return StResult.success(settingService.getServiceMapping(serviceName));
    }
    @GetMapping("/getQueryServiceRelated")
    public StResult getQueryServiceRelated(String queryId) {
        return StResult.success(settingService.getQueryServiceRelated(queryId));
    }

    @GetMapping("/getEventService")
    public StResult getEventService(String serviceName) {
        return StResult.success(settingService.getEventMain(serviceName));
    }

    @PostMapping("/istEventService")
    public StResult istEventService(@RequestBody StEventMain serviceEvent) {
        settingService.istEventService(serviceEvent);
        return StResult.success();
    }

    @PostMapping("/updateEventService")
    public StResult updateEventService(@RequestBody StEventMain serviceEvent) {
        settingService.updateEventService(serviceEvent);
        return StResult.success();
    }

    @PostMapping("/deleteEventService")
    public StResult deleteEventService(@RequestBody StEventMain serviceEvent) {
        settingService.deleteEventService(serviceEvent);
        return StResult.success();
    }

    @GetMapping("/getEventAdditiveService")
    public StResult getEventAdditiveService(String flowCode) {
        return StResult.success(settingService.getEventAdditiveMain(flowCode));
    }

    @PostMapping("/istEventAdditiveService")
    public StResult istEventAdditiveService(@RequestBody StEventAdditive serviceEvent) {
        settingService.istEventAdditiveService(serviceEvent);
        return StResult.success();
    }

    @PostMapping("/updateEventAdditiveService")
    public StResult updateEventAdditiveService(@RequestBody StEventAdditive serviceEvent) {
        settingService.updateEventAdditiveService(serviceEvent);
        return StResult.success();
    }

    @PostMapping("/deleteEventAdditiveService")
    public StResult deleteEventAdditiveService(@RequestBody StEventAdditive serviceEvent) {
        settingService.deleteEventAdditiveService(serviceEvent);
        return StResult.success();
    }

    @GetMapping("/getSingleFlowSetting")
    public StResult getSingleFlowSetting(String flowCode) {
        return StResult.success(menuService.getStFlowMenuByFlowCode(flowCode));
    }

    @PostMapping("/SetSingleFlowSetting")
    public StResult SetSingleFlowSetting(@RequestBody StFlowMenu flowMenu) {
        StFlowMenu stFlowMenuByFlowCode = menuService.getStFlowMenuByFlowCode(flowMenu.getFlowCode());
        if (StString.isEmpty(flowMenu.getFlowNamePrefix()) == false) {
            stFlowMenuByFlowCode.setFlowNamePrefix(flowMenu.getFlowNamePrefix());
        }
        if (StString.isEmpty(flowMenu.getFlowNameSetting()) == false) {
            stFlowMenuByFlowCode.setFlowNameSetting(flowMenu.getFlowNameSetting());
        }
        if (StString.isEmpty(flowMenu.getFlowDescribe()) == false) {
            stFlowMenuByFlowCode.setFlowDescribe(flowMenu.getFlowDescribe());
        }
        stFlowMenuByFlowCode.setUpdateBy(StUserInfo.getUserCode());
        stFlowMenuByFlowCode.setUpdateTime(LocalDateTime.now());
        menuService.updateStFlowMenuByFlowCode(stFlowMenuByFlowCode);
        return StResult.success();
    }

    //发起权限管理
    @PostMapping("/istInitAdmit")
    public StResult istInitAdmit(@RequestBody List<StAdmitInit> admitInits) {
        admitService.istInitAdmit(admitInits);
        return StResult.success();
    }

    @PostMapping("/delInitAdmit")
    public StResult delInitAdmit(@RequestBody StAdmitInit admitInit) {
        admitService.delInitAdmit(admitInit);
        return StResult.success();
    }

    @PostMapping("/updateInitAdmit")
    public StResult updateInitAdmit(@RequestBody StAdmitInit admitInit) {
        admitService.updateInitAdmit(admitInit);
        return StResult.success();
    }

    @GetMapping("/getInitAdmit")
    public StResult getInitAdmit(String flowCode) {
        return StResult.success(admitService.getInitAdmit(flowCode));
    }


    //发起权限管理
    @PostMapping("/istManageAdmit")
    public StResult istManageAdmit(@RequestBody List<StAdmitFlow> admitInits) {
        admitService.istManageAdmit(admitInits);
        return StResult.success();
    }

    @PostMapping("/delManageAdmit")
    public StResult delManageAdmit(@RequestBody StAdmitFlow admitInit) {
        admitService.delManageAdmit(admitInit);
        return StResult.success();
    }

    @PostMapping("/updateManageAdmit")
    public StResult updateManageAdmit(@RequestBody StAdmitFlow admitInit) {
        admitService.updateManageAdmit(admitInit);
        return StResult.success();
    }

    @GetMapping("/getManageAdmit")
    public StResult getManageAdmit(String flowCode) {
        return StResult.success(admitService.getManageAdmit(flowCode));
    }

    //流程管理员
    @PostMapping("/istAdminAdmit")
    public StResult istAdminAdmit(@RequestBody List<StAdmitAdmin> admins) {
        admitService.istAdminAdmit(admins);
        return StResult.success();
    }

    @PostMapping("/delAdminAdmit")
    public StResult delAdminAdmit(@RequestBody StAdmitAdmin admin) {
        admitService.delAdminAdmit(admin);
        return StResult.success();
    }

    @PostMapping("/updateAdminAdmit")
    public StResult updateAdminAdmit(@RequestBody StAdmitAdmin admin) {
        admitService.updateAdminAdmit(admin);
        return StResult.success();
    }

    @GetMapping("/getAdminAdmit")
    public StResult getAdminAdmit() {
        return StResult.success(admitService.getAdminAdmit());
    }

    @GetMapping("/getUserManageAdmit")
    public StResult getUserManageAdmit(String flowCode) {
        return StResult.success(admitService.getUserManageAdmit(flowCode, StUserInfo.getUserCode()));
    }

    @GetMapping("/getFlowException")
    public StResult getFlowException(String instanceId) {
        StFlowExceptional flowException = settingService.getFlowException(instanceId);
        return StResult.success(flowException);
    }

    @PostMapping("/updateFlowException")
    public StResult updateFlowException(@RequestBody StFlowExceptional flowExceptional) {
        flowService.updateFlowException(flowExceptional.getId(), flowExceptional.getInstanceId());
        return StResult.success();
    }

    @GetMapping("/getTaskAgent")
    public StResult getTaskAgent(StTaskAgent taskAgent) {
        return taskAgentService.getTaskAgent(taskAgent);
    }

    @PostMapping("/insertTaskAgent")
    public StResult insertTaskAgent(@RequestBody StTaskAgent taskAgent) {
        return taskAgentService.insertTaskAgent(taskAgent);
    }

    @PostMapping("/delTaskAgent")
    public StResult delTaskAgent(@RequestBody List<Integer> ids) {
        return taskAgentService.delTaskAgent(ids);
    }

    @GetMapping("/getCommonComment")
    public StResult getCommonComment() {
        List<StCommonComment> commonComment = settingService.getCommonComment();
        return StResult.success(commonComment);
    }

    @PostMapping("/insertCommonComment")
    public StResult insertCommonComment(@RequestBody StCommonComment commonComment) {
        return StResult.success(settingService.insertCommonComment(commonComment));
    }

    @PostMapping("/deleteCommonComment")
    public StResult deleteCommonComment(@RequestBody List<Long> ids) {
        return StResult.success(settingService.deleteCommonComment(ids));
    }

    @GetMapping("/flowUpgradeVersion")
    public StResult flowUpgradeVersion(String instanceId) {
        return StResult.success(settingService.flowUpgradeVersion(instanceId));
    }

    @GetMapping("/userSelectList")
    public ResponseDTO<List<TreeNode>> buildDeptSelectUserTree(Integer level, String id, String dicStoredFlag) {
        List<TreeNode> treeNodes = organizeService.buildDeptSelectUserTree(level, id, dicStoredFlag);
        return ResponseDTO.ok(treeNodes);
    }

    @GetMapping("/userSelectList/search")
    public ResponseDTO<List<TreeNode>> buildDeptSelectUserTreeSearch(String searchText) {
        List<TreeNode> treeNodes = organizeService.buildDeptSelectUserTreeSearch(searchText);
        return ResponseDTO.ok(treeNodes);
    }
    @GetMapping("/getQueryMainSingleForMapping")
    public StResult getQueryMainSingleForMapping(Integer queryId) {
        return StResult.success(settingService.getQueryMainSingleForMapping(queryId));
    }
    @GetMapping("/getPrint")
    public StResult getPrint(String flowCode) {
        return settingService.getPrint(flowCode);
    }

    @PostMapping("/updatePrint")
    public StResult updatePrint(@RequestBody StPrint print) {
        return settingService.updatePrint(print.getFlowCode(), print.getContent());
    }
    @GetMapping("/getScriptByFlowCode")
    public StResult getScriptByFlowCode(String flowCode) {
        return settingService.getScriptByFlowCode(flowCode);
    }
}