~slub.team/goobi-production/1.8.0-mergebase

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Map.Entry;

import java.util.function.Function;

import java.util.stream.Collectors;

import org.apache.logging.log4j.Level;

        Collection<Metadata> entered = addLabels(new HashSet<>(metadata));

                entered.addAll(DataEditorService.getExistingMetadataRows(treeNode.getChildren()));

        List<MetadataViewWithValuesInterface> tableData = metadataView.getSortedVisibleMetadata(entered, additionallySelectedFields);

                    if (!createMetadataEntryEdit((SimpleMetadataViewInterface) metadataView, values)) {

                        /*

                         * If a conditional metadata was set automatically,

                         * start over. This is necessary to update dependent

                         * fields above or below.

                         */

                        logger.debug("Metadata was changed. Restarting.");

                        createMetadataTable();

                        break;

                    }

     * @return whether the input field could be generated. If an automatic

     *         preset has been added to the metadata, false is returned. In that

     *         case, the rule set must be invoked again to update the options

     *         for dependent fields.

    public boolean createMetadataEntryEdit(SimpleMetadataViewInterface simpleMetadataView,

                    List<Map<MetadataEntry, Boolean>> leadingFields = getListForLeadingMetadataFields();

                    Map<String, String> options = simpleMetadataView.getSelectItems(leadingFields);

                    boolean dependent = leadingFields.parallelStream().flatMap(map -> map.entrySet().parallelStream())

                            .anyMatch(entry -> Boolean.TRUE.equals(entry.getValue()));

                    if (dependent && !options.isEmpty() && addAutoPresetForConditionalMetadata(simpleMetadataView, options, values)) {

                        return false;

                    }

                    data = new ProcessSelectMetadata(this, simpleMetadataView, simpleValues(values), dependent);

            logger.catching(Level.WARN, e);

        return true;

    }

 

    /**

     * A value must be set for conditional metadata, as there is no no-selection

     * option. In this case, the first possible value is already displayed as

     * selected, even if it is not yet reflected in the metadata before saving.

     * In this case, no options are offered in selection fields that depend on

     * this field, because their options are based on the metadata. Therefore,

     * in this case, the metadata must be set explicitly. Then, a termination

     * must take place and the rule set must be invoked again in order to

     * correctly populate the dependent fields with options.

     * 

     * @param view

     *            view that gives the access the select items

     * @param metadataForInput

     *            list of metadata, to which a preset will be added if necessary

     * @return true, if the current tree building process must be restarted,

     *         because the metadata was changed

     */

    private boolean addAutoPresetForConditionalMetadata(SimpleMetadataViewInterface view, Map<String, String> options,

            Collection<Metadata> metadataForInput) {

 

        if (metadataForInput.isEmpty()) {

            MetadataEntry autoPreset = new MetadataEntry();

            autoPreset.setKey(view.getId());

            if (Objects.isNull(container)) {

                autoPreset.setDomain(DOMAIN_TO_MDSEC.get(view.getDomain().orElse(Domain.DESCRIPTION)));

            }

            autoPreset.setValue(options.entrySet().iterator().next().getKey());

            metadata.add(autoPreset);

 

            logger.debug("Added metadata {} to {}", autoPreset, metadataKey);

            return true;

        }

        return false;

    /**

     * Returns the division.

     * @return the division

     */

    public Division<?> getDivision() {

        return division;

    }

 

    List<Map<MetadataEntry, Boolean>> getListForLeadingMetadataFields() {

        List<Map<MetadataEntry, Boolean>> result = Objects.isNull(container) ? new ArrayList<>()

                : container.getListForLeadingMetadataFields();

        Map<String, MetadataEntry> metadataEntryMap = new HashMap<>();

        treeNode.getChildren().stream().map(TreeNode::getData).filter(ProcessSimpleMetadata.class::isInstance)

                .map(ProcessSimpleMetadata.class::cast).map(ProcessDetail::getMetadataID).forEachOrdered(key -> {

                    MetadataEntry metadataEntry = new MetadataEntry();

                    metadataEntry.setKey(key);

                    metadataEntryMap.put(key, metadataEntry);

                });

        metadata.stream().filter(MetadataEntry.class::isInstance).map(MetadataEntry.class::cast)

                .forEachOrdered(key -> metadataEntryMap.put(key.getKey(), key));

        result.add(metadataEntryMap.entrySet().stream()

            .collect(Collectors.toMap(Entry::getValue, all -> Boolean.FALSE)));

        return result;

    }

 

    void markLeadingMetadataFields(List<Map<MetadataEntry, Boolean>> leadingMetadataFields) {

        int lastIndex = leadingMetadataFields.size() - 1;

        if (lastIndex > 0) {

            container.markLeadingMetadataFields(leadingMetadataFields.subList(0, lastIndex));

        }

        final List<String> leadingMetadataKeys = leadingMetadataFields.get(lastIndex).entrySet().parallelStream()

                .filter(entry -> Boolean.TRUE.equals(entry.getValue())).map(entry -> entry.getKey().getKey())

                .collect(Collectors.toList());

        treeNode.getChildren().parallelStream().map(TreeNode::getData).map(ProcessDetail.class::cast)

                .filter(processDetail -> leadingMetadataKeys.contains(processDetail.getMetadataID()))

                .forEach(ProcessDetail::setLeading);

    }