org.spincast.plugins.routing.RouteBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of spincast-plugins-routing Show documentation
The default Spincast Routing plugin
The newest version!
package org.spincast.plugins.routing;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.spincast.core.exchange.IRequestContext;
import org.spincast.core.filters.ISpincastFilters;
import org.spincast.core.routing.HttpMethod;
import org.spincast.core.routing.IHandler;
import org.spincast.core.routing.IRoute;
import org.spincast.core.routing.IRouteBuilder;
import org.spincast.core.routing.IRouter;
import org.spincast.core.routing.RoutingType;
import org.spincast.core.utils.ContentTypeDefaults;
import org.spincast.core.websocket.IWebsocketContext;

import com.google.common.collect.Sets;
import com.google.inject.assistedinject.Assisted;
import com.google.inject.assistedinject.AssistedInject;

public class RouteBuilder, W extends IWebsocketContext> implements IRouteBuilder {

    protected final Logger logger = LoggerFactory.getLogger(RouteBuilder.class);

    private final IRouter router;
    private final IRouteFactory routeFactory;
    private final ISpincastRouterConfig spincastRouterConfig;
    private final ISpincastFilters spincastFilters;

    private Set httpMethods;
    private String id = null;
    private String path = null;
    private Set positions;
    private Set routingTypes;
    private List> beforeFilters;
    private IHandler mainHandler;
    private List> afterFilters;
    private Set acceptedContentTypes;

    @AssistedInject
    public RouteBuilder(IRouteFactory routeFactory,
                        ISpincastRouterConfig spincastRouterConfig,
                        ISpincastFilters spincastFilters) {
        this(null, routeFactory, spincastRouterConfig, spincastFilters);
    }

    @AssistedInject
    public RouteBuilder(@Assisted IRouter router,
                        IRouteFactory routeFactory,
                        ISpincastRouterConfig spincastRouterConfig,
                        ISpincastFilters spincastFilters) {
        this.router = router;
        this.routeFactory = routeFactory;
        this.spincastRouterConfig = spincastRouterConfig;
        this.spincastFilters = spincastFilters;
    }

    protected IRouter getRouter() {
        return this.router;
    }

    protected IRouteFactory getRouteFactory() {
        return this.routeFactory;
    }

    protected ISpincastRouterConfig getSpincastRouterConfig() {
        return this.spincastRouterConfig;
    }

    protected ISpincastFilters getSpincastFilters() {
        return this.spincastFilters;
    }

    public String getId() {
        return this.id;
    }

    public String getPath() {
        return this.path;
    }

    public Set getPositions() {
        if(this.positions == null) {
            this.positions = new HashSet();
        }
        return this.positions;
    }

    public Set getRoutingTypes() {
        if(this.routingTypes == null) {
            this.routingTypes = new HashSet<>();
        }
        return this.routingTypes;
    }

    public Set getHttpMethods() {
        if(this.httpMethods == null) {
            this.httpMethods = new HashSet<>();
        }
        return this.httpMethods;
    }

    public List> getBeforeFilters() {
        if(this.beforeFilters == null) {
            this.beforeFilters = new ArrayList>();
        }
        return this.beforeFilters;
    }

    public List> getAfterFilters() {
        if(this.afterFilters == null) {
            this.afterFilters = new ArrayList>();
        }
        return this.afterFilters;
    }

    public IHandler getMainHandler() {
        return this.mainHandler;
    }

    public Set getAcceptedContentTypes() {
        if(this.acceptedContentTypes == null) {
            this.acceptedContentTypes = new HashSet<>();
        }
        return this.acceptedContentTypes;
    }

    @Override
    public IRouteBuilder id(String id) {
        this.id = id;
        return this;
    }

    @Override
    public IRouteBuilder pos(int position) {
        getPositions().add(position);
        return this;
    }

    @Override
    public IRouteBuilder allRoutingTypes() {

        getRoutingTypes().addAll(Sets.newHashSet(RoutingType.values()));
        return this;
    }

    @Override
    public IRouteBuilder found() {
        getRoutingTypes().add(RoutingType.FOUND);
        return this;
    }

    @Override
    public IRouteBuilder notFound() {
        getRoutingTypes().add(RoutingType.NOT_FOUND);
        return this;
    }

    @Override
    public IRouteBuilder exception() {
        getRoutingTypes().add(RoutingType.EXCEPTION);
        return this;
    }

    @Override
    public IRouteBuilder before(IHandler beforeFilter) {

        Objects.requireNonNull(beforeFilter, "beforeFilter can't be NULL");

        getBeforeFilters().add(beforeFilter);
        return this;
    }

    @Override
    public IRouteBuilder after(IHandler afterFilter) {

        Objects.requireNonNull(afterFilter, "afterFilter can't be NULL");

        getAfterFilters().add(afterFilter);
        return this;
    }

    @Override
    public IRouteBuilder acceptAsString(String... acceptedContentTypes) {
        getAcceptedContentTypes().addAll(Sets.newHashSet(acceptedContentTypes));
        return this;
    }

    @Override
    public IRouteBuilder acceptAsString(Set acceptedContentTypes) {

        Objects.requireNonNull(acceptedContentTypes, "acceptedContentTypes can't be NULL");

        getAcceptedContentTypes().addAll(acceptedContentTypes);
        return this;
    }

    @Override
    public IRouteBuilder accept(ContentTypeDefaults... acceptedContentTypes) {

        if(acceptedContentTypes != null) {
            for(ContentTypeDefaults contentTypeDefault : acceptedContentTypes) {
                getAcceptedContentTypes().addAll(contentTypeDefault.getVariations());
            }
        }
        return this;
    }

    @Override
    public IRouteBuilder accept(Set acceptedContentTypes) {

        Objects.requireNonNull(acceptedContentTypes, "acceptedContentTypes can't be NULL");

        for(ContentTypeDefaults contentTypeDefault : acceptedContentTypes) {
            accept(contentTypeDefault);
        }
        return this;
    }

    @Override
    public IRouteBuilder html() {
        getAcceptedContentTypes().add(ContentTypeDefaults.HTML.getMainVariation());
        return this;
    }

    @Override
    public IRouteBuilder json() {
        getAcceptedContentTypes().add(ContentTypeDefaults.JSON.getMainVariation());
        return this;
    }

    @Override
    public IRouteBuilder xml() {
        getAcceptedContentTypes().add(ContentTypeDefaults.XML.getMainVariation());
        return this;
    }

    @Override
    public IRouteBuilder path(String path) {
        this.path = path;
        return this;
    }

    @Override
    public IRouteBuilder GET() {
        getHttpMethods().add(HttpMethod.GET);
        return this;
    }

    @Override
    public IRouteBuilder POST() {
        getHttpMethods().add(HttpMethod.POST);
        return this;
    }

    @Override
    public IRouteBuilder PUT() {
        getHttpMethods().add(HttpMethod.PUT);
        return this;
    }

    @Override
    public IRouteBuilder DELETE() {
        getHttpMethods().add(HttpMethod.DELETE);
        return this;
    }

    @Override
    public IRouteBuilder OPTIONS() {
        getHttpMethods().add(HttpMethod.OPTIONS);
        return this;
    }

    @Override
    public IRouteBuilder TRACE() {
        getHttpMethods().add(HttpMethod.TRACE);
        return this;
    }

    @Override
    public IRouteBuilder HEAD() {
        getHttpMethods().add(HttpMethod.HEAD);
        return this;
    }

    @Override
    public IRouteBuilder PATCH() {
        getHttpMethods().add(HttpMethod.PATCH);
        return this;
    }

    @Override
    public IRouteBuilder ALL() {
        getHttpMethods().addAll(Sets.newHashSet(HttpMethod.values()));
        return this;
    }

    @Override
    public IRouteBuilder SOME(Set httpMethods) {
        getHttpMethods().addAll(httpMethods);
        return this;
    }

    @Override
    public IRouteBuilder SOME(HttpMethod... httpMethods) {
        getHttpMethods().addAll(Sets.newHashSet(httpMethods));
        return this;
    }

    @Override
    public void save(IHandler mainHandler) {

        if(getRouter() == null) {
            throw new RuntimeException("No router specified, can't save the route!");
        }

        IRoute route = create(mainHandler);
        getRouter().addRoute(route);
    }

    @Override
    public IRoute create(IHandler mainHandler) {

        this.mainHandler = mainHandler;

        Set routingTypes = getRoutingTypes();
        if(routingTypes.size() == 0) {
            routingTypes = new HashSet();
            routingTypes.add(RoutingType.FOUND);
        }

        //==========================================
        // If no position was specified, the route is
        // considered as a main one, "0".
        //==========================================
        if(getPositions().size() == 0) {
            getPositions().add(0);
        }

        IRoute route = getRouteFactory().createRoute(getId(),
                                                        getHttpMethods(),
                                                        getPath(),
                                                        routingTypes,
                                                        getBeforeFilters(),
                                                        mainHandler,
                                                        getAfterFilters(),
                                                        getPositions(),
                                                        getAcceptedContentTypes());
        return route;
    }

}