validate(form, messages -> {}, this::asEditHtml);
        verifyToken(this::asEditHtml);
        createStopwordsItem(form, this::asEditHtml).ifPresent(entity -> {
            stopwordsService.store(form.dictId, entity);
            saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
        }).orElse(() -> throwValidationError(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL), this::asEditHtml));

        validate(form, messages -> {}, this::asEditHtml);
        verifyToken(this::asEditHtml);
        getWebConfig(form).ifPresent(entity -> {
            try {
                webConfigService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);

        return accessTokenList;
    }

    public OptionalEntity<AccessToken> getAccessToken(final String id) {
        return accessTokenBhv.selectByPK(id);
    }

    public void store(final AccessToken accessToken) {

        accessTokenBhv.insertOrUpdate(accessToken, op -> op.setRefreshPolicy(Constants.TRUE));

    }

    public void delete(final AccessToken accessToken) {

        }

        body.crudMode = CrudMode.CREATE;
        final FileAuthentication fileAuth = getFileAuthentication(body).map(entity -> {
            try {
                fileAuthService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);

        }

        body.crudMode = CrudMode.CREATE;
        final WebAuthentication webAuth = getWebAuthentication(body).map(entity -> {
            try {
                webAuthService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);

            if (dictFile.getId().equals(id)) {
                return OptionalEntity.of(dictFile);
            }
        }
        return OptionalEntity.empty();
    }

    public void store(final DictionaryFile<? extends DictionaryItem> dictFile, final File file) {
        getDictionaryFile(dictFile.getId()).ifPresent(currentFile -> {
            if (currentFile.getTimestamp().getTime() > dictFile.getTimestamp().getTime()) {

            throwValidationErrorApi(messages -> {
                messages.addErrorsCrudFailedToCreateInstance(GLOBAL);
            });
            return null;
        });
        try {
            groupService.store(entity);
            saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);

        return sessionId;
    }

    public synchronized void store(final String sessionId, final boolean create) {
        CrawlingInfo crawlingInfo = create ? null : getCrawlingInfoService().getLast(sessionId);
        if (crawlingInfo == null) {
            crawlingInfo = new CrawlingInfo(sessionId);
            try {
                getCrawlingInfoService().store(crawlingInfo);
            } catch (final Exception e) {

 */
package org.codelibs.fess.ds.callback;

import java.util.Map;

import org.codelibs.fess.entity.DataStoreParams;

public interface IndexUpdateCallback {

    void store(DataStoreParams paramMap, Map<String, Object> dataMap);

    long getDocumentSize();

    long getExecuteTime();

    void commit();

        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final LabelType labelType = getLabelType(body).map(entity -> {
            try {
                labelTypeService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);