[Test][api] Add api module `service` layer test example (#3521)

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.apache.dolphinscheduler.api.service.impl;

import static org.apache.dolphinscheduler.common.Constants.CMDPARAM_SUB_PROCESS_DEFINE_ID;

import java.io.BufferedOutputStream;

import java.io.IOException;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import java.util.stream.Collectors;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletResponse;

import org.apache.dolphinscheduler.api.dto.ProcessMeta;

import org.apache.dolphinscheduler.api.dto.treeview.Instance;

import org.apache.dolphinscheduler.api.dto.treeview.TreeViewDto;

import org.apache.dolphinscheduler.dao.utils.DagHelper;

import org.apache.dolphinscheduler.service.permission.PermissionCheck;

import org.apache.dolphinscheduler.service.process.ProcessService;

import java.io.BufferedOutputStream;

import java.io.IOException;

import java.nio.charset.StandardCharsets;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import java.util.stream.Collectors;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.web.multipart.MultipartFile;

import com.baomidou.mybatisplus.core.metadata.IPage;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.node.ObjectNode;

/**

 * process definition service

 * process definition service impl

 */

@Service

public class ProcessDefinitionServiceImpl extends BaseService implements

                                                       String locations,

                                                       String connects) throws JsonProcessingException {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        Project project = projectMapper.queryByName(projectName);

        // check project auth

        Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);

     */

    public Map<String, Object> queryProcessDefinitionList(User loginUser, String projectName) {

        HashMap<String, Object> result = new HashMap<>(5);

        HashMap<String, Object> result = new HashMap<>();

        Project project = projectMapper.queryByName(projectName);

        Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);

     */

    public Map<String, Object> queryProcessDefinitionListPaging(User loginUser, String projectName, String searchVal, Integer pageNo, Integer pageSize, Integer userId) {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        Project project = projectMapper.queryByName(projectName);

        Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);

            return checkResult;

        }

        Page<ProcessDefinition> page = new Page(pageNo, pageSize);

        Page<ProcessDefinition> page = new Page<>(pageNo, pageSize);

        IPage<ProcessDefinition> processDefinitionIPage = processDefineMapper.queryDefineListPaging(

                page, searchVal, userId, project.getId(), isAdmin(loginUser));

        PageInfo pageInfo = new PageInfo<ProcessData>(pageNo, pageSize);

        PageInfo<ProcessDefinition> pageInfo = new PageInfo<>(pageNo, pageSize);

        pageInfo.setTotalCount((int) processDefinitionIPage.getTotal());

        pageInfo.setLists(processDefinitionIPage.getRecords());

        result.put(Constants.DATA_LIST, pageInfo);

    public Map<String, Object> queryProcessDefinitionById(User loginUser, String projectName, Integer processId) {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        Project project = projectMapper.queryByName(projectName);

        Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);

    public Map<String, Object> updateProcessDefinition(User loginUser, String projectName, int id, String name,

                                                       String processDefinitionJson, String desc,

                                                       String locations, String connects) {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        Project project = projectMapper.queryByName(projectName);

        Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);

    @Transactional(rollbackFor = RuntimeException.class)

    public Map<String, Object> deleteProcessDefinitionById(User loginUser, String projectName, Integer processDefinitionId) {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        Project project = projectMapper.queryByName(projectName);

        Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);

    /**

     * batch export process definition by ids

     *

     * @param loginUser

     * @param projectName

     * @param processDefinitionIds

     * @param response

     */

    public void batchExportProcessDefinitionByIds(User loginUser, String projectName, String processDefinitionIds, HttpServletResponse response) {

    /**

     * get process definition list by ids

     *

     * @param processDefinitionIds

     * @return

     */

    private List<ProcessMeta> getProcessDefinitionList(String processDefinitionIds) {

        List<ProcessMeta> processDefinitionList = new ArrayList<>();

    /**

     * download the process definition file

     *

     * @param response

     * @param processDefinitionList

     */

    private void downloadProcessDefinitionFile(HttpServletResponse response, List<ProcessMeta> processDefinitionList) {

        response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);

        }

    }

    /**

     * get export process metadata string

     *

     * @param processDefinitionId process definition id

     * @param processDefinition   process definition

     * @return export process metadata string

     */

    private String exportProcessMetaDataStr(Integer processDefinitionId, ProcessDefinition processDefinition) {

        //create workflow json file

        return JSONUtils.toJsonString(exportProcessMetaData(processDefinitionId, processDefinition));

    }

    /**

     * get export process metadata string

     *

     */

    @Transactional(rollbackFor = RuntimeException.class)

    public Map<String, Object> importProcessDefinition(User loginUser, MultipartFile file, String currentProjectName) {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        String processMetaJson = FileUtils.file2String(file);

        List<ProcessMeta> processMetaList = JSONUtils.toList(processMetaJson, ProcessMeta.class);

    /**

     * check and import process definition

     *

     * @param loginUser

     * @param currentProjectName

     * @param result

     * @param processMeta

     * @return

     */

    private boolean checkAndImportProcessDefinition(User loginUser, String currentProjectName, Map<String, Object> result, ProcessMeta processMeta) {

        //create process definition

        Integer processDefinitionId =

                Objects.isNull(createProcessResult.get(PROCESSDEFINITIONID)) ?

                        null : Integer.parseInt(createProcessResult.get(PROCESSDEFINITIONID).toString());

                Objects.isNull(createProcessResult.get(PROCESSDEFINITIONID))

                        ? null : Integer.parseInt(createProcessResult.get(PROCESSDEFINITIONID).toString());

        //scheduler param

        return getImportProcessScheduleResult(loginUser,

    /**

     * get create process result

     *

     * @param loginUser

     * @param currentProjectName

     * @param result

     * @param processMeta

     * @param processDefinitionName

     * @param importProcessParam

     * @return

     */

    private Map<String, Object> getCreateProcessResult(User loginUser,

                                                       String currentProjectName,

    /**

     * get import process schedule result

     *

     * @param loginUser

     * @param currentProjectName

     * @param result

     * @param processMeta

     * @param processDefinitionName

     * @param processDefinitionId

     * @return

     */

    private boolean getImportProcessScheduleResult(User loginUser,

                                                   String currentProjectName,

    /**

     * check importance params

     *

     * @param processMeta

     * @param result

     * @return

     */

    private boolean checkImportanceParams(ProcessMeta processMeta, Map<String, Object> result) {

        if (StringUtils.isEmpty(processMeta.getProjectName())) {

        return true;

    }

    /**

     * import process add special task param

     *

        }

        //recursive sub-process parameter correction map key for old process id value for new process id

        Map<Integer, Integer> subProcessIdMap = new HashMap<>(20);

        Map<Integer, Integer> subProcessIdMap = new HashMap<>();

        List<Object> subProcessList = StreamUtils.asStream(jsonArray.elements())

                .filter(elem -> checkTaskHasSubProcess(JSONUtils.parseObject(elem.toString()).path("type").asText()))

     */

    public Map<String, Object> checkProcessNodeList(ProcessData processData, String processDefinitionJson) {

        Map<String, Object> result = new HashMap<>(5);

        Map<String, Object> result = new HashMap<>();

        try {

            if (processData == null) {

                logger.error("process data is null");

        for (String definitionId : idList) {

            idIntList.add(Integer.parseInt(definitionId));

        }

        Integer[] idArray = idIntList.toArray(new Integer[idIntList.size()]);

        Integer[] idArray = idIntList.toArray(new Integer[0]);

        List<ProcessDefinition> processDefinitionList = processDefineMapper.queryDefinitionListByIdList(idArray);

        if (CollectionUtils.isEmpty(processDefinitionList)) {

            logger.info("process definition not exists");

     */

    public Map<String, Object> queryProcessDefinitionAllByProjectId(Integer projectId) {

        HashMap<String, Object> result = new HashMap<>(5);

        HashMap<String, Object> result = new HashMap<>();

        List<ProcessDefinition> resourceList = processDefineMapper.queryAllDefinitionList(projectId);

        result.put(Constants.DATA_LIST, resourceList);

    /**

     * batch copy process definition

     *

     * @param loginUser loginUser

     * @param projectName projectName

     * @param processDefinitionIds processDefinitionIds

     * @param targetProjectId targetProjectId

     * @return

     */

    @Override

    public Map<String, Object> batchCopyProcessDefinition(User loginUser,

    /**

     * batch move process definition

     *

     * @param loginUser loginUser

     * @param projectName projectName

     * @param processDefinitionIds processDefinitionIds

     * @param targetProjectId targetProjectId

     * @return

     */

    @Override

    public Map<String, Object> batchMoveProcessDefinition(User loginUser,

    /**

     * do batch move process definition

     *

     * @param targetProject targetProject

     * @param failedProcessList failedProcessList

     * @param processDefinitionIdList processDefinitionIdList

    /**

     * batch copy process definition

     *

     * @param loginUser loginUser

     * @param targetProject targetProject

     * @param failedProcessList failedProcessList

    /**

     * set failed processList

     *

     * @param failedProcessList failedProcessList

     * @param processDefinitionId processDefinitionId

     */

    /**

     * check project and auth

     *

     * @param loginUser loginUser

     * @param projectName projectName

     * @return

     */

    private Map<String, Object> checkProjectAndAuth(User loginUser, String projectName) {

        Project project = projectMapper.queryByName(projectName);

    /**

     * move process definition

     *

     * @param processId processId

     * @param targetProject targetProject

     * @return move result code

    /**

     * check batch operate result

     *

     * @param srcProjectName srcProjectName

     * @param targetProjectName targetProjectName

     * @param result result