// last_modified
        // id
        // virtual_host
        defaultDataMap.put(fessConfig.getIndexFieldVirtualHost(),
                stream(config.getVirtualHosts()).get(stream -> stream.filter(StringUtil::isNotBlank).collect(Collectors.toList())));

        storeData(config, callback, paramMap.newInstance(), configScriptMap, defaultDataMap);

    }

    /**
     * Get the script type.

import org.codelibs.fess.opensearch.log.cbean.cq.FavoriteLogCQ;
import org.codelibs.fess.opensearch.log.cbean.cq.bs.BsFavoriteLogCQ;
import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.opensearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;

rn e===n!==r}):"string"!=typeof n?ce.grep(e,function(e){return-1<se.call(n,e)!==r}):ce.filter(n,e,r)}ce.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?ce.find.matchesSelector(r,e)?[r]:[]:ce.find.matches(e,ce.grep(t,function(e){return 1===e.nodeType}))},ce.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(ce(e).filter(function(){for(t=0;t<r;t++)if(ce.contains(i[t],this))return!0}));for(n=this.pushStack(...

            // Pass jcifs.* properties via formParameters for NTLM configuration
            final Map<String, String> jcifsParams = paramMap.entrySet()
                    .stream()
                    .filter(e -> e.getKey().startsWith("jcifs."))
                    .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
            if (!jcifsParams.isEmpty()) {
                config.setNtlmParameters(jcifsParams);

        if (StringUtil.isBlank(virtualHostKey)) {
            labelList =
                    labelTypeItemList.stream().filter(item -> matchLocale(requestLocale, item.getLocale())).collect(Collectors.toList());
        } else {
            labelList = labelTypeItemList.stream()
                    .filter(item -> matchLocale(requestLocale, item.getLocale()) && virtualHostKey.equals(item.getVirtualHost()))

        }
        saveInfo(messages -> messages.addSuccessStartedDataUpdate(GLOBAL));
        return redirect(getClass());
    }

    /**
     * Clears all crawler indices including queue, data, and filter indices.
     *
     * @param form the action form (validated but not used for configuration)
     * @return HTML response redirecting to the maintenance page
     */
    @Execute
    @Secured({ ROLE })

            return;
        }

        // X-Robots-Tag
        responseData.getMetaDataMap()
                .entrySet()
                .stream()
                .filter(e -> X_ROBOTS_TAG.equalsIgnoreCase(e.getKey()) && e.getValue() != null)
                .forEach(e -> {
                    boolean noindex = false;
                    boolean nofollow = false;

    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>
    <function-signature>java.lang.String getMessage(java.lang.String, java.lang.String)</function-signature>
    <example>${fe:message("labels.foobar", "default value")}</example>
  </function>

  <function>
    <description>Check if user has a permission.</description>
    <name>permission</name>

        }
    }

    private
    fun assertLeftoverFilesCleanedUpEventually(vararg leftoverFiles: String) {
        leftoverFiles.forEach {
            assertTrue(projectDir.resolve(it).walk().filter { it.isFile }.toList().isEmpty())
        }
    }

    @Test
    fun `fail build if leftover file found and test passes`() {
        val result = run(":successful-test-with-leftover:test").buildAndFail()

     * @return the protected words file if found
     */
    public OptionalEntity<ProtwordsFile> getProtwordsFile(final String dictId) {
        return dictionaryManager.getDictionaryFile(dictId)
                .filter(ProtwordsFile.class::isInstance)
                .map(file -> OptionalEntity.of((ProtwordsFile) file))
                .orElse(OptionalEntity.empty());
    }

    /**
     * Gets a specific protected words item by ID.