All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.amazon.ask.mvc.MvcSdkModule Maven / Gradle / Ivy

    Go to download

    The Alexa Skills Kit MVC Framework extends the existing ASK SDK, adding features for mapping requests to methods and rendering responses via view scripts and templates such as Nashorn Javascript and Freemarker. It also integrates with the ASK SDK Interaction Model Mapper framework to create a single environment where both the interaction model and business logic of skills can be managed as code packages.

    The newest version!
    /*
    Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.

    Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file
    except in compliance with the License. A copy of the License is located at

        http://aws.amazon.com/apache2.0/

    or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS,
    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 com.amazon.ask.mvc;

import com.amazon.ask.dispatcher.request.handler.impl.DefaultHandlerAdapter;
import com.amazon.ask.interaction.definition.Model;
import com.amazon.ask.interaction.mapper.IntentMapper;
import com.amazon.ask.module.SdkModule;
import com.amazon.ask.module.SdkModuleContext;
import com.amazon.ask.mvc.annotation.plugin.*;
import com.amazon.ask.mvc.annotation.mapping.IntentMapping;
import com.amazon.ask.mvc.argument.*;
import com.amazon.ask.mvc.mapper.ControllerRequestMapper;
import com.amazon.ask.mvc.annotation.mapping.RequestMapping;
import com.amazon.ask.mvc.plugin.*;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.*;

import static com.amazon.ask.util.ValidationUtils.assertNotNull;

/**
 * {@link SdkModule} adding support for MVC mapping annotations, slot argument resolvers and view resolvers.
 *
 * @see IntentMapping
 * @see RequestMapping
 * @see com.amazon.ask.mvc.annotation.mapping.ExceptionHandler
 * @see com.amazon.ask.mvc.annotation.mapping.RequestInterceptor
 * @see com.amazon.ask.mvc.annotation.mapping.ResponseInterceptor
 * @see ArgumentResolver
 * @see ViewResolver
 * @see SkillContext
 */
public class MvcSdkModule implements SdkModule {
    /**
     * Default set of {@link ArgumentResolver}s
     */
    protected static final Collection DEFAULT_ARGUMENT_RESOLVERS =
        Collections.unmodifiableList(Arrays.asList(
            new SlotValuesArgumentResolver(),
            new SlotValueArgumentResolver(),
            new SlotArgumentResolver(),
            new RequestArgumentResolver(),
            new IntentArgumentResolver(),
            new RequestEnvelopeArgumentResolver(),
            new SessionArgumentResolver(),
            new SessionAttributesMapArgumentResolver(),
            new AttributesManagerArgumentResolver(),
            new ResponseBuilderArgumentResolver(),
            new ServiceClientFactoryArgumentResolver(),
            new LocaleArgumentResolver()));

    protected static final String MVC_USER_AGENT = "ask-mvc/1.0-beta";
    protected static final String MODELS_USER_AGENT = "ask-models/1.0-beta";

    protected final SkillContext skillContext;

    public MvcSdkModule(SkillContext skillContext) {
        this.skillContext = assertNotNull(skillContext, "context");
    }

    /**
     * Scans all controllers for methods, set up handlers and interceptors, and append user agent.
     *
     * @param moduleContext sdk module context
     */
    @Override
    public void setupModule(SdkModuleContext moduleContext) {
        moduleContext.addHandlerAdapter(new DefaultHandlerAdapter());

        moduleContext.appendCustomUserAgent(MVC_USER_AGENT);
        if (!skillContext.getModel().equals(Model.empty())) {
            moduleContext.appendCustomUserAgent(MODELS_USER_AGENT);
        }

        for (Object controller : skillContext.getControllers()) {
            moduleContext.addRequestMapper(new ControllerRequestMapper(skillContext, controller));
        }
    }

    /**
     * @return a builder with default features enabled
     */
    public static Builder builder() {
        return emptyBuilder()
            .addArgumentResolvers(DEFAULT_ARGUMENT_RESOLVERS)
            .addArgumentResolver(new AutoArgumentResolver.Scanner())
            .addRequestHandlerResolver(new AutoRequestHandler.Scanner())
            .addResponseInterceptorResolver(new AutoResponseInterceptor.Scanner())
            .addRequestInterceptorResolver(new AutoRequestInterceptor.Scanner())
            .addPredicateResolver(new AutoPredicate.Scanner())
            .addExceptionHandlerResolver(new AutoExceptionHandler.Scanner());
    }

    /**
     * @return a builder with no features enabled
     */
    public static Builder emptyBuilder() {
        return new Builder();
    }
    
    public static class Builder {
        protected Set argumentResolvers;
        protected Set exceptionHandlerResolvers;
        protected Set requestHandlerResolvers;
        protected Set requestInterceptorResolvers;
        protected Set responseInterceptorResolvers;
        protected Set predicateResolvers;
        protected Set viewResolvers;

        protected Set controllers;
        protected Model model;
        protected ObjectMapper objectMapper;

        public Builder withControllers(Set controllers) {
            this.controllers = controllers;
            return this;
        }

        public Builder addControllers(Object... controllers) {
            return addControllers(Arrays.asList(controllers));
        }

        public Builder addControllers(List controllers) {
            controllers.forEach(this::addController);
            return this;
        }

        public Builder addController(Object controller) {
            if(this.controllers == null) {
                this.controllers = new LinkedHashSet<>();
            }
            this.controllers.add(controller);
            return this;
        }

        public Builder withViewResolvers(List viewResolvers) {
            this.viewResolvers = new LinkedHashSet<>(viewResolvers);
            return this;
        }

        public Builder addViewResolvers(ViewResolver... viewResolver) {
            return addViewResolvers(Arrays.asList(viewResolver));
        }

        public Builder addViewResolvers(List viewResolvers) {
            viewResolvers.forEach(this::addViewResolver);
            return this;
        }

        public Builder addViewResolver(ViewResolver viewResolver) {
            if (this.viewResolvers == null) {
                this.viewResolvers = new LinkedHashSet<>();
            }
            this.viewResolvers.add(viewResolver);
            return this;
        }

        public Builder withArgumentResolvers(Set argumentResolvers) {
            this.argumentResolvers = new LinkedHashSet<>(argumentResolvers);
            return this;
        }

        public Builder addArgumentResolvers(ArgumentResolver... argumentResolver) {
            return addArgumentResolvers(Arrays.asList(argumentResolver));
        }

        public Builder addArgumentResolvers(Collection argumentResolvers) {
            argumentResolvers.forEach(this::addArgumentResolver);
            return this;
        }

        public Builder addArgumentResolver(ArgumentResolver argumentResolver) {
            if (this.argumentResolvers == null) {
                this.argumentResolvers = new LinkedHashSet<>();
            }
            this.argumentResolvers.add(argumentResolver);
            return this;
        }

        public Builder withRequestHandlerResolvers(Collection resolvers) {
            this.requestHandlerResolvers = new LinkedHashSet<>(resolvers);
            return this;
        }
        public Builder addRequestHandlerResolvers(Collection resolvers) {
            resolvers.forEach(this::addRequestHandlerResolver);
            return this;
        }
        public Builder addRequestHandlerResolver(RequestHandlerResolver resolver) {
            if (this.requestHandlerResolvers == null) {
                this.requestHandlerResolvers = new LinkedHashSet<>();
            }
            this.requestHandlerResolvers.add(resolver);
            return this;
        }

        public Builder withPredicateResolvers(Collection resolvers) {
            this.predicateResolvers = new LinkedHashSet<>(resolvers);
            return this;
        }
        
        public Builder addPredicateResolvers(Collection resolvers) {
            resolvers.forEach(this::addPredicateResolver);
            return this;
        }

        public Builder addPredicateResolver(PredicateResolver resolver) {
            if (this.predicateResolvers == null) {
                this.predicateResolvers = new LinkedHashSet<>();
            }
            this.predicateResolvers.add(resolver);
            return this;
        }

        public Builder withRequestInterceptorResolvers(Collection resolvers) {
            this.requestInterceptorResolvers = new LinkedHashSet<>(resolvers);
            return this;
        }
        
        public Builder addRequestInterceptorResolvers(Collection resolvers) {
            resolvers.forEach(this::addRequestInterceptorResolver);
            return this;
        }

        public Builder addRequestInterceptorResolver(RequestInterceptorResolver resolver) {
            if (this.requestInterceptorResolvers == null) {
                this.requestInterceptorResolvers = new LinkedHashSet<>();
            }
            this.requestInterceptorResolvers.add(resolver);
            return this;
        }
        
        public Builder withResponseInterceptorResolvers(Collection resolvers) {
            this.responseInterceptorResolvers = new LinkedHashSet<>(resolvers);
            return this;
        }
        
        public Builder addResponseInterceptorResolvers(Collection resolvers) {
            resolvers.forEach(this::addResponseInterceptorResolver);
            return this;
        }

        public Builder addResponseInterceptorResolver(ResponseInterceptorResolver resolver) {
            if (this.responseInterceptorResolvers == null) {
                this.responseInterceptorResolvers = new LinkedHashSet<>();
            }
            this.responseInterceptorResolvers.add(resolver);
            return this;
        }
        
        public Builder withExceptionHandlerResolvers(Collection resolvers) {
            this.exceptionHandlerResolvers = new LinkedHashSet<>(resolvers);
            return this;
        }
        
        public Builder addExceptionHandlerResolvers(Collection resolvers) {
            resolvers.forEach(this::addExceptionHandlerResolver);
            return this;
        }

        public Builder addExceptionHandlerResolver(ExceptionHandlerResolver resolver) {
            if (this.exceptionHandlerResolvers == null) {
                this.exceptionHandlerResolvers = new LinkedHashSet<>();
            }
            this.exceptionHandlerResolvers.add(resolver);
            return this;
        }

        public Builder withObjectMapper(ObjectMapper objectMapper) {
            this.objectMapper = objectMapper;
            return this;
        }

        public Builder withModel(Model model) {
            this.model = model;
            return this;
        }

        public MvcSdkModule build() {
            Set argumentResolvers = this.argumentResolvers != null
                ? this.argumentResolvers : new LinkedHashSet<>(DEFAULT_ARGUMENT_RESOLVERS);

            if (model != null && !model.equals(Model.empty())) {
                IntentMapper intentMapper = IntentMapper.fromModel(model);
                argumentResolvers.add(new IntentModelArgumentResolver(intentMapper));
                argumentResolvers.add(new SlotModelArgumentResolver(intentMapper));
            }
            if (this.argumentResolvers != null) {
                argumentResolvers.addAll(this.argumentResolvers);
            }

            return new MvcSdkModule(SkillContext.builder()
                .withControllers(controllers)
                .withModel(model)
                .withObjectMapper(objectMapper)
                .withArgumentResolvers(argumentResolvers)
                .withExceptionHandlerResolvers(exceptionHandlerResolvers)
                .withPredicateResolvers(predicateResolvers)
                .withRequestHandlerResolvers(requestHandlerResolvers)
                .withRequestInterceptorResolvers(requestInterceptorResolvers)
                .withResponseInterceptorResolvers(responseInterceptorResolvers)
                .withViewResolvers(viewResolvers)
                .build());
        }
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy