Java ExternalTaskPojo类代码示例

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
private static DataNode<ProjectData> convert(@NotNull ProjectSystemId systemId,
                                             @NotNull ExternalProjectPojo rootProject,
                                             @NotNull Collection<ExternalProjectPojo> childProjects,
                                             @NotNull Map<String, Collection<ExternalTaskPojo>> availableTasks) {
  ProjectData projectData = new ProjectData(systemId, rootProject.getName(), rootProject.getPath(), rootProject.getPath());
  DataNode<ProjectData> projectDataNode = new DataNode<ProjectData>(PROJECT, projectData, null);

  for (ExternalProjectPojo childProject : childProjects) {
    String moduleConfigPath = childProject.getPath();
    ModuleData moduleData = new ModuleData(childProject.getName(), systemId,
                                           ModuleTypeId.JAVA_MODULE, childProject.getName(),
                                           moduleConfigPath, moduleConfigPath);
    final DataNode<ModuleData> moduleDataNode = projectDataNode.createChild(MODULE, moduleData);

    final Collection<ExternalTaskPojo> moduleTasks = availableTasks.get(moduleConfigPath);
    if (moduleTasks != null) {
      for (ExternalTaskPojo moduleTask : moduleTasks) {
        TaskData taskData = new TaskData(systemId, moduleTask.getName(), moduleConfigPath, moduleTask.getDescription());
        moduleDataNode.createChild(TASK, taskData);
      }
    }
  }

  return projectDataNode;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@Override
public boolean canExecuteTask(RunConfiguration configuration, ExternalSystemBeforeRunTask beforeRunTask) {
  final ExternalSystemTaskExecutionSettings executionSettings = beforeRunTask.getTaskExecutionSettings();

  final List<ExternalTaskPojo> tasks = ContainerUtilRt.newArrayList();
  for (String taskName : executionSettings.getTaskNames()) {
    tasks.add(new ExternalTaskPojo(taskName, executionSettings.getExternalProjectPath(), null));
  }
  if (tasks.isEmpty()) return true;

  final Pair<ProgramRunner, ExecutionEnvironment> pair =
    ExternalSystemUtil.createRunner(executionSettings, DefaultRunExecutor.EXECUTOR_ID, myProject, mySystemId);

  if (pair == null) return false;

  final ProgramRunner runner = pair.first;
  final ExecutionEnvironment environment = pair.second;

  return runner.canRun(DefaultRunExecutor.EXECUTOR_ID, environment.getRunProfile());
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@NotNull
private static String getLinkedExternalProjectPath(@NotNull Collection<ExternalTaskPojo> tasks) throws IllegalArgumentException {
  if (tasks.isEmpty()) {
    throw new IllegalArgumentException("Can't execute external tasks. Reason: given tasks list is empty");
  }
  String result = null;
  for (ExternalTaskPojo task : tasks) {
    String path = task.getLinkedExternalProjectPath();
    if (result == null) {
      result = path;
    }
    else if (!result.equals(path)) {
      throw new IllegalArgumentException(String.format(
        "Can't execute given external system tasks. Reason: expected that all of them belong to the same external project " +
        "but they are not (at least two different projects detected - '%s' and '%s'). Tasks: %s",
        result,
        task.getLinkedExternalProjectPath(),
        tasks
      ));
    }
  }
  assert result != null;
  return result;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
private static void patchAvailableTasks(@NotNull Map<String, String> adjustedPaths, @NotNull GradleLocalSettings localSettings) {
  Map<String, Collection<ExternalTaskPojo>> adjustedAvailableTasks = ContainerUtilRt.newHashMap();
  for (Map.Entry<String, Collection<ExternalTaskPojo>> entry : localSettings.getAvailableTasks().entrySet()) {
    String newPath = adjustedPaths.get(entry.getKey());
    if (newPath == null) {
      adjustedAvailableTasks.put(entry.getKey(), entry.getValue());
    }
    else {
      for (ExternalTaskPojo task : entry.getValue()) {
        String newTaskPath = adjustedPaths.get(task.getLinkedExternalProjectPath());
        if (newTaskPath != null) {
          task.setLinkedExternalProjectPath(newTaskPath);
        }
      }
      adjustedAvailableTasks.put(newPath, entry.getValue());
    }
  }
  localSettings.setAvailableTasks(adjustedAvailableTasks);
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@NotNull
private static String getLinkedExternalProjectPath(@NotNull Collection<ExternalTaskPojo> tasks) throws IllegalArgumentException {
  if (tasks.isEmpty()) {
    throw new IllegalArgumentException("Can't execute external tasks. Reason: given tasks list is empty");
  }
  String result = null;
  for (ExternalTaskPojo task : tasks) {
    String path = task.getLinkedExternalProjectPath();
    if (result == null) {
      result = path;
    }
    else if (!result.equals(path)) {
      throw new IllegalArgumentException(String.format(
        "Can't execute given external system tasks. Reason: expected that all of them belong to the same external project " +
        "but they are not (at least two different projects detected - '%s' and '%s'). Tasks: %s",
        result,
        task.getLinkedExternalProjectPath(),
        tasks));
    }
  }
  assert result != null;
  return result;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@Nonnull
private static String getLinkedExternalProjectPath(@Nonnull Collection<ExternalTaskPojo> tasks) throws IllegalArgumentException {
  if (tasks.isEmpty()) {
    throw new IllegalArgumentException("Can't execute external tasks. Reason: given tasks list is empty");
  }
  String result = null;
  for (ExternalTaskPojo task : tasks) {
    String path = task.getLinkedExternalProjectPath();
    if (result == null) {
      result = path;
    }
    else if (!result.equals(path)) {
      throw new IllegalArgumentException(String.format(
        "Can't execute given external system tasks. Reason: expected that all of them belong to the same external project " +
        "but they are not (at least two different projects detected - '%s' and '%s'). Tasks: %s",
        result,
        task.getLinkedExternalProjectPath(),
        tasks
      ));
    }
  }
  assert result != null;
  return result;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
private void mergeLocalSettings() {
  for (ExternalSystemManager<?, ?, ?, ?, ?> manager : ExternalSystemApiUtil.getAllManagers()) {
    final ProjectSystemId systemId = manager.getSystemId();

    AbstractExternalSystemLocalSettings settings = manager.getLocalSettingsProvider().fun(myProject);
    final Map<ExternalProjectPojo, Collection<ExternalProjectPojo>> availableProjects = settings.getAvailableProjects();
    final Map<String, Collection<ExternalTaskPojo>> availableTasks = settings.getAvailableTasks();

    for (Map.Entry<ExternalProjectPojo, Collection<ExternalProjectPojo>> entry : availableProjects.entrySet()) {
      final ExternalProjectPojo projectPojo = entry.getKey();
      final String externalProjectPath = projectPojo.getPath();
      final Pair<ProjectSystemId, File> key = Pair.create(systemId, new File(externalProjectPath));
      InternalExternalProjectInfo externalProjectInfo = myExternalRootProjects.get(key);
      if (externalProjectInfo == null) {
        final DataNode<ProjectData> dataNode = convert(systemId, projectPojo, entry.getValue(), availableTasks);
        externalProjectInfo = new InternalExternalProjectInfo(systemId, externalProjectPath, dataNode);
        myExternalRootProjects.put(key, externalProjectInfo);

        changed.set(true);
      }

      // restore linked project sub-modules
      ExternalProjectSettings linkedProjectSettings =
        manager.getSettingsProvider().fun(myProject).getLinkedProjectSettings(externalProjectPath);
      if (linkedProjectSettings != null && ContainerUtil.isEmpty(linkedProjectSettings.getModules())) {

        final Set<String> modulePaths = ContainerUtil.map2Set(
          ExternalSystemApiUtil.findAllRecursively(externalProjectInfo.getExternalProjectStructure(), ProjectKeys.MODULE),
          new Function<DataNode<ModuleData>, String>() {
            @Override
            public String fun(DataNode<ModuleData> node) {
              return node.getData().getLinkedExternalProjectPath();
            }
          });
        linkedProjectSettings.setModules(modulePaths);
      }
    }
  }
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
public ExternalSystemExecuteTaskTask(@NotNull ProjectSystemId externalSystemId,
                                     @NotNull Project project,
                                     @NotNull List<ExternalTaskPojo> tasksToExecute,
                                     @Nullable String vmOptions,
                                     @Nullable String scriptParameters,
                                     @Nullable String debuggerSetup) throws IllegalArgumentException {
  super(externalSystemId, ExternalSystemTaskType.EXECUTE_TASK, project, getLinkedExternalProjectPath(tasksToExecute));
  myTasksToExecute = tasksToExecute;
  myVmOptions = vmOptions;
  myScriptParameters = scriptParameters;
  myDebuggerSetup = debuggerSetup;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
public void ensureTasks(@NotNull String externalProjectConfigPath, @NotNull Collection<ExternalTaskPojo> tasks) {
    if (tasks.isEmpty()) {
      return;
    }
    ExternalSystemNode<ExternalProjectPojo> moduleNode = findProjectNode(externalProjectConfigPath);
    if (moduleNode == null) {
//      LOG.warn(String.format(
//        "Can't proceed tasks for module which external config path is '%s'. Reason: no such module node is found. Tasks: %s",
//        externalProjectConfigPath, tasks
//      ));
      return;
    }
    Set<ExternalTaskExecutionInfo> toAdd = ContainerUtilRt.newHashSet();
    for (ExternalTaskPojo task : tasks) {
      toAdd.add(buildTaskInfo(task));
    }
    for (int i = 0; i < moduleNode.getChildCount(); i++) {
      ExternalSystemNode<?> childNode = moduleNode.getChildAt(i);
      Object element = childNode.getDescriptor().getElement();
      if (element instanceof ExternalTaskExecutionInfo) {
        if (!toAdd.remove(element)) {
          removeNodeFromParent(childNode);
          //noinspection AssignmentToForLoopParameter
          i--;
        }
      }
    }

    if (!toAdd.isEmpty()) {
      for (ExternalTaskExecutionInfo taskInfo : toAdd) {
        insertNodeInto(
          new ExternalSystemNode<ExternalTaskExecutionInfo>(descriptor(taskInfo, taskInfo.getDescription(), myUiAware.getTaskIcon())),
          moduleNode);
      }
    }
  }
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@NotNull
private ExternalTaskExecutionInfo buildTaskInfo(@NotNull ExternalTaskPojo task) {
  ExternalSystemTaskExecutionSettings settings = new ExternalSystemTaskExecutionSettings();
  settings.setExternalProjectPath(task.getLinkedExternalProjectPath());
  settings.setTaskNames(Collections.singletonList(task.getName()));
  settings.setTaskDescriptions(Collections.singletonList(task.getDescription()));
  settings.setExternalSystemIdString(myExternalSystemId.toString());
  return new ExternalTaskExecutionInfo(settings, DefaultRunExecutor.EXECUTOR_ID);
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@Override
public boolean isApplicableFor(@NotNull ExternalSystemTask task) {
  if (task instanceof ExternalSystemExecuteTaskTask) {
    ExternalSystemExecuteTaskTask taskTask = (ExternalSystemExecuteTaskTask)task;
    if (!StringUtil.equals(taskTask.getExternalSystemId().getId(), GradleConstants.SYSTEM_ID.getId())) return false;

    return ContainerUtil.find(taskTask.getTasksToExecute(), new Condition<ExternalTaskPojo>() {
      @Override
      public boolean value(ExternalTaskPojo pojo) {
        return "test".equals(pojo.getName());
      }
    }) != null;
  }
  return false;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
private static void checkForAvailableTasks(int level,
                                           @Nullable String taskName,
                                           @NotNull PsiScopeProcessor processor,
                                           @NotNull ResolveState state,
                                           @NotNull PsiElement place) {
  if (taskName == null) return;
  final GroovyPsiManager psiManager = GroovyPsiManager.getInstance(place.getProject());
  PsiClass gradleApiProjectClass = psiManager.findClassWithCache(GRADLE_API_PROJECT, place.getResolveScope());
  if (canBeMethodOf(taskName, gradleApiProjectClass)) return;
  if (canBeMethodOf(GroovyPropertyUtils.getGetterNameNonBoolean(taskName), gradleApiProjectClass)) return;

  final String className = BUILT_IN_TASKS.get(taskName);
  if (className != null) {
    if (level <= 1) {
      GradleResolverUtil.addImplicitVariable(processor, state, place, className);
    }
    processTask(taskName, className, psiManager, processor, state, place);
    return;
  }

  Module module = ModuleUtilCore.findModuleForPsiElement(place);
  if (module == null) return;
  String path = module.getOptionValue(ExternalSystemConstants.ROOT_PROJECT_PATH_KEY);
  GradleLocalSettings localSettings = GradleLocalSettings.getInstance(place.getProject());
  Collection<ExternalTaskPojo> taskPojos = localSettings.getAvailableTasks().get(path);
  if (taskPojos == null) return;

  for (ExternalTaskPojo taskPojo : taskPojos) {
    if (taskName.equals(taskPojo.getName())) {
      processTask(taskName, GRADLE_API_TASK, psiManager, processor, state, place);
      return;
    }
  }
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
public ExternalSystemExecuteTaskTask(@NotNull ProjectSystemId externalSystemId,
                                     @NotNull Project project,
                                     @NotNull List<ExternalTaskPojo> tasksToExecute,
                                     @Nullable String vmOptions) throws IllegalArgumentException
{
  super(externalSystemId, ExternalSystemTaskType.EXECUTE_TASK, project, getLinkedExternalProjectPath(tasksToExecute));
  myTasksToExecute = tasksToExecute;
  myVmOptions = vmOptions;
}
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
public void ensureTasks(@NotNull String externalProjectConfigPath, @NotNull Collection<ExternalTaskPojo> tasks) {
    if (tasks.isEmpty()) {
      return;
    }
    ExternalSystemNode<ExternalProjectPojo> moduleNode = findProjectNode(externalProjectConfigPath);
    if (moduleNode == null) {
//      LOG.warn(String.format(
//        "Can't proceed tasks for module which external config path is '%s'. Reason: no such module node is found. Tasks: %s",
//        externalProjectConfigPath, tasks
//      ));
      return;
    }
    Set<ExternalTaskExecutionInfo> toAdd = ContainerUtilRt.newHashSet();
    for (ExternalTaskPojo task : tasks) {
      toAdd.add(buildTaskInfo(task));
    }
    for (int i = 0; i < moduleNode.getChildCount(); i++) {
      ExternalSystemNode<?> childNode = moduleNode.getChildAt(i);
      Object element = childNode.getDescriptor().getElement();
      if (element instanceof ExternalTaskExecutionInfo) {
        if (!toAdd.remove(element)) {
          moduleNode.remove(childNode);
          myIndexHolder[0] = i;
          myNodeHolder[0] = childNode;
          nodesWereRemoved(moduleNode, myIndexHolder, myNodeHolder);
          //noinspection AssignmentToForLoopParameter
          i--;
        }
      }
    }

    if (!toAdd.isEmpty()) {
      for (ExternalTaskExecutionInfo taskInfo : toAdd) {
        moduleNode.add(new ExternalSystemNode<ExternalTaskExecutionInfo>(descriptor(taskInfo, myUiAware.getTaskIcon())));
        myIndexHolder[0] = moduleNode.getChildCount() - 1;
        nodesWereInserted(moduleNode, myIndexHolder);
      }
    }
    ExternalSystemUiUtil.sort(moduleNode, this, NODE_COMPARATOR);
  }
 

import com.intellij.openapi.externalSystem.model.execution.ExternalTaskPojo; //导入依赖的package包/类
@NotNull
private ExternalTaskExecutionInfo buildTaskInfo(@NotNull ExternalTaskPojo task) {
  ExternalSystemTaskExecutionSettings settings = new ExternalSystemTaskExecutionSettings();
  settings.setExternalProjectPath(task.getLinkedExternalProjectPath());
  settings.setTaskNames(Collections.singletonList(task.getName()));
  settings.setExternalSystemIdString(myExternalSystemId.toString());
  return new ExternalTaskExecutionInfo(settings, DefaultRunExecutor.EXECUTOR_ID);
}