if (permissions.length > 0) {
                            cb.query().setPermissions_InScope(stream(permissions).get(stream -> stream.collect(Collectors.toList())));
                        }
                    }).orElse(null);
                    final String reading = getValue(list, 1);
                    final String boost = getValue(list, 4);

        final List<String> includeVersions = versions.stream()
            .map(v -> v.hasQualifier() ? v.toString() : v.getMajor() + "." + v.getMinor())
            .distinct()
            .collect(Collectors.toList());

        final Map<String, Object> bindings = new HashMap<>();
        bindings.put("versions", versions);
        bindings.put("includeVersions", includeVersions);

        return asJson(new ApiResult.ApiConfigsResponse<ListBody>()
                .settings(Stream.of(dictFiles).map(this::createListBody).collect(Collectors.toList()))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a ListBody from a DictionaryFile for API responses.
     *

        mojos = new ArrayList<>();

        if (goals != null && !goals.isEmpty()) {
            String[] mojoGoals = goals.split(",");
            mojos = Arrays.stream(mojoGoals).map(fromGoalIntoLifecycleMojo).collect(Collectors.toList());
        }
    }

    private final Function<String, LifecycleMojo> fromGoalIntoLifecycleMojo = s -> {
        LifecycleMojo lifecycleMojo = new LifecycleMojo();
        lifecycleMojo.setGoal(s.trim());

                    .stream()
                    .filter(t -> t instanceof DependenciesGraphTask)
                    .map(Task::getPath)
                    .collect(Collectors.toList());
                if (depGraphTasks.size() > 0) {
                    if (url == null || token == null) {
                        // If there are more than one DependenciesGraphTasks to run, print the message only for one of

                        || result.getBuildSummary(project) instanceof BuildFailure)
                .map(project -> project.getGroupId() + ":" + project.getArtifactId())
                .collect(Collectors.toList());

        if (remainingProjects.isEmpty()) {
            LOGGER.info("No remaining projects found, resuming the build would not make sense.");
            return Optional.empty();
        }

        final File[] jarFiles = ResourceUtil.getPluginJarFiles(PluginHelper.ArtifactType.DATA_STORE.getId());
        if (jarFiles == null) {
            return nameSet.stream().sorted().collect(Collectors.toList());
        }
        for (final File jarFile : jarFiles) {
            try (FileSystem fs = FileSystems.newFileSystem(jarFile.toPath(), ClassLoader.getSystemClassLoader())) {

            result.addAll(Arrays.stream(pluginHelper.getAvailableArtifacts(artifactType))
                    .map(AdminPluginAction::beanToMap)
                    .collect(Collectors.toList()));
        }
        return result;
    }

    /**
     * Retrieves all installed artifacts from all plugin types.
     *
     * @return list of maps containing installed artifact information

                        if (line.contains(":")) {
                            List<String> parts = Arrays.stream(line.split(":", 2)).map(String::trim).collect(Collectors.toList());
                            String name = parts.get(0);
                            String value = parts.get(1);
                            // the ID of the CPU socket

                if (first instanceof Entity) {
                    data.register(key, coll.stream().map(BeanUtil::copyBeanToNewMap).collect(Collectors.toList()));
                    return;
                }
            }
            data.register(key, value);
        }
    }