protected void createFilterChain() {
        FilterChain chain = createDefaultFilterChain();
        for (final Filter element : filterList) {
            chain = appendFilterChain(element, chain);
        }
        filterChain = chain;
    }

    protected FilterChain appendFilterChain(final Filter filter, final FilterChain chain) {
        return query -> filter.parse(query, chain);
    }

    }

    public User load(final User user) {
        User u = user;
        for (final AuthenticationChain chain : chains) {
            u = chain.load(u);
        }
        return u;
    }

    public void addChain(final AuthenticationChain chain) {
        chains = ArrayUtils.addAll(chains, chain);
    }

    protected StreamOf<AuthenticationChain> chains() {
        return stream(chains);
    }

            @Override
            public QueryBuilder execute(QueryContext context, Query query, float boost, FilterChain chain) {
                calledFirst.set(true);
                assertFalse(called.get());
                QueryBuilder builder = chain.execute(context, query, boost);
                assertTrue(called.get());
                return builder;
            }
        });

    protected static final String OPTIONS = "OPTIONS";

    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {
        final HttpServletRequest httpRequest = (HttpServletRequest) request;
        final String origin = httpRequest.getHeader("Origin");

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.auth.chain;

import org.codelibs.fess.es.user.exentity.User;

public interface AuthenticationChain {

    void update(User user);

    void delete(User user);

        FilterChain chain = createDefaultFilterChain();
        for (final Filter element : filterList) {
            chain = appendFilterChain(element, chain);
        }
        filterChain = chain;
    }

    protected FilterChain appendFilterChain(final Filter filter, final FilterChain chain) {
        return (context, query, boost) -> filter.execute(context, query, boost, chain);
    }

            break;
        case FAVORITE:
            processFavoriteRequest(request, response, chain);
            break;
        case FAVORITES:
            processFavoritesRequest(request, response, chain);
            break;
        case PING:
            processPingRequest(request, response, chain);
            break;
        case SCROLL:

                }
            }
        }
    }

    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {
        final HttpServletRequest req = (HttpServletRequest) request;
        final String servletPath = req.getServletPath();

        return servletPath.startsWith(pathPrefix);
    }

    @Override
    public void process(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain)
            throws IOException, ServletException {
        final RequestManager requestManager = ComponentUtil.getRequestManager();

            throws IOException, ServletException {
        final WebApiManagerFactory webApiManagerFactory = ComponentUtil.getWebApiManagerFactory();
        final WebApiManager webApiManager = webApiManagerFactory.get((HttpServletRequest) request);
        if (webApiManager == null) {
            chain.doFilter(request, response);
        } else {