├── skillserver
    ├── examples
    │   ├── jeopardy
    │   │   ├── .gitignore
    │   │   ├── intent_schema.json
    │   │   ├── README.md
    │   │   ├── utterances.txt
    │   │   └── jeopardy.go
    │   └── helloworld.go
    ├── .gitignore
    ├── dialog
    │   └── default.go
    ├── README.md
    ├── ssml-builder.go
    ├── skillserver.go
    └── echo.go
├── .travis.yml
├── LICENSE
└── README.md


/skillserver/examples/jeopardy/.gitignore:
--------------------------------------------------------------------------------
1 | *.sh
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: go
 2 | 
 3 | matrix:
 4 |   include:
 5 |     - go: "tip"
 6 |     - go: "1.x"
 7 |     - go: "1.10"
 8 |     - go: "1.9"
 9 |     - go: "1.8"
10 |   allow_failures:
11 |     - go: tip
12 | 


--------------------------------------------------------------------------------
/skillserver/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | *.test
24 | *.prof
25 | 
26 | 


--------------------------------------------------------------------------------
/skillserver/examples/helloworld.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	alexa "github.com/mikeflynn/go-alexa/skillserver"
 5 | )
 6 | 
 7 | var applications = map[string]interface{}{
 8 | 	"/echo/helloworld": alexa.EchoApplication{ // Route
 9 | 		AppID:    "xxxxxxxx", // Echo App ID from Amazon Dashboard
10 | 		OnIntent: echoIntentHandler,
11 | 		OnLaunch: echoIntentHandler,
12 | 	},
13 | }
14 | 
15 | func main() {
16 | 	alexa.Run(applications, "3000")
17 | }
18 | 
19 | func echoIntentHandler(echoReq *alexa.EchoRequest, echoResp *alexa.EchoResponse) {
20 | 	echoResp.OutputSpeech("Hello world from my new Echo test app!").Card("Hello World", "This is a test card.")
21 | }
22 | 


--------------------------------------------------------------------------------
/skillserver/examples/jeopardy/intent_schema.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "intents": [
 3 |     {
 4 |       "intent": "StartJeopardy",
 5 |       "slots": []
 6 |     },
 7 |     {
 8 |       "intent": "PickCategory",
 9 |       "slots": [
10 |         {
11 |           "name": "Category",
12 |           "type": "LITERAL"
13 |         }
14 |       ]
15 |     },
16 |     {
17 |       "intent": "AnswerQuestion",
18 |       "slots": [
19 |         {
20 |           "name": "Answer",
21 |           "type": "LITERAL"
22 |         }
23 |       ]
24 |     },
25 |     {
26 |       "intent": "QuitGame",
27 |       "slots": []
28 |     },
29 |     {
30 |       "intent": "ListCategories",
31 |       "slots": []
32 |     },
33 |     {
34 |       "intent": "RepeatQuestion",
35 |       "slots": []
36 |     }
37 |   ]
38 | }


--------------------------------------------------------------------------------
/skillserver/examples/jeopardy/README.md:
--------------------------------------------------------------------------------
 1 | ## Alexa Skill: Jeopardy
 2 | 
 3 | [![Alexa Jeopardy Demo](http://i.imgur.com/1lNgQjB.png)](https://www.youtube.com/watch?v=mDIEGUtoSjw)
 4 | 
 5 | ### Requirements
 6 | * Compiled Go code
 7 | * MongoDB running on localhost
 8 | 
 9 | ### Functionality
10 | * "Alexa, ask Jeopardy to start a game."
11 | 
12 | Jeopardy uses the amazing [jservice.io](http://jservice.io) API to pull actual Jeopardy questions and categories.
13 | 
14 | ### Potential Future Enhancements:
15 | * Allow selection of point value when selecting the category.
16 | * Allow for category selection when you star the game.
17 | * Use Amazon User ID to continue previous game, or keep track of all-time score.
18 | * Pull random categories.
19 | * Double Jeopardy!
20 | * Final Jeopardy!
21 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Mike Flynn
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/skillserver/dialog/default.go:
--------------------------------------------------------------------------------
 1 | package dialog
 2 | 
 3 | // Type will indicate type of dialog interaction to be sent to the user.
 4 | type Type string
 5 | 
 6 | const (
 7 | 	// Delegate will indicate that the Alexa service should continue the dialog ineraction.
 8 | 	Delegate Type = "Dialog.Delegate"
 9 | 
10 | 	// ElicitSlot will indicate to the Alexa service that the specific slot should be elicited from the user.
11 | 	ElicitSlot Type = "Dialog.ElicitSlot"
12 | 
13 | 	// ConfirmSlot indicates to the Alexa service that the slot value should be confirmed by the user.
14 | 	ConfirmSlot Type = "Dialog.ConfirmSlot"
15 | 
16 | 	// ConfirmIntent indicates to the Alexa service that the complete intent should be confimed by the user.
17 | 	ConfirmIntent Type = "Dialog.ConfirmIntent"
18 | )
19 | 
20 | const (
21 | 	// Started indicates that the dialog interaction has just begun.
22 | 	Started string = "STARTED"
23 | 
24 | 	// InProgress indicates that the dialog interation is continuing.
25 | 	InProgress string = "IN_PROGRESS"
26 | 
27 | 	// Completed indicates that the dialog interaction has finished.
28 | 	// The intent and slot confirmation status should be checked.
29 | 	Completed string = "COMPLETED"
30 | )
31 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## `go-alexa`: A Go toolset for creating Amazon Alexa Skills
 2 | 
 3 | 
 4 | [![build status badge][travis-badge]][travis-job]
 5 | 
 6 | [![GoDoc][1]][2]
 7 | [![GoCard][3]][4]
 8 | 
 9 | [1]: https://godoc.org/github.com/mikeflynn/go-alexa?status.svg
10 | [2]: https://godoc.org/github.com/mikeflynn/go-alexa
11 | [3]: https://goreportcard.com/badge/github.com/mikeflynn/go-alexa
12 | [4]: https://goreportcard.com/report/github.com/mikeflynn/go-alexa
13 | [travis-badge]: https://travis-ci.org/mikeflynn/go-alexa.svg?branch=master
14 | [travis-job]: https://travis-ci.org/mikeflynn/go-alexa
15 | 
16 | The Amazon Echo, with it's voice assitant Alexa, is a surprisingly amazing tool. Having the power of voice recognition tied to the web ready at any time is quite powerful and now that Amazon has opened up a developer platform it's even more exciting!
17 | 
18 | Amazon has supplied packages for Java and Node.js (tied to the AWS Lamda platform) but I wanted to develop my skills in Go. As I moved through the process making my app work with Amazon's spec, a simple web framework that took care all the heavy lifting on security and crafting the response object formed. I'm looking forward to more Go-based tools getting created and living in this `go-alexa` bucket but for now the `skillserver` is the first tool.
19 | 
20 | Mike Flynn gave a talk about this library an conversational applications in general at the 2016 Strange Loop Conference: ["Exploring Conversational Interfaces with Amazon Alexa and Go"](https://www.youtube.com/watch?v=pDdE3PKy6mo)
21 | 
22 | ### Tools
23 | 
24 | * [`skillserver`](skillserver/) - A framework to quickly create a skill web service that handles all of the Amazon requirements.
25 |   * Example: [Jeopardy](skillserver/examples/jeopardy)
26 | 
27 | ### Future Proposed Tools
28 | 
29 | * An Amazon Echo request simulator
30 | * A library for Alexa responses
31 | 
32 | ### Original Author
33 | 
34 | Mike Flynn ([@thatmikeflynn](http://twitter.com/thatmikeflynn))
35 | 


--------------------------------------------------------------------------------
/skillserver/examples/jeopardy/utterances.txt:
--------------------------------------------------------------------------------
 1 | QuitGame goodbye
 2 | QuitGame i'm done
 3 | QuitGame i am done
 4 | QuitGame game over
 5 | QuitGame quit
 6 | StartJeopardy lets play a game
 7 | StartJeopardy wanna play
 8 | StartJeopardy start a game
 9 | StartJeopardy to start a game
10 | StartJeopardy play a game
11 | ListCategories list the categories
12 | ListCategories give me the categories
13 | ListCategories what are the categories again
14 | ListCategories what are the categories
15 | ListCategories to list the categories
16 | PickCategory give me a {food|Category} question
17 | PickCategory lets start with {hodgepodge|Category}
18 | PickCategory ask a {history|Category} question
19 | PickCategory any category
20 | PickCategory i will take {sports|Category}
21 | PickCategory i'll take {science|Category}
22 | PickCategory {food|Category}
23 | PickCategory {hodgepodge|Category}
24 | PickCategory {history|Category}
25 | PickCategory {sports|Category}
26 | PickCategory {science|Category}
27 | PickCategory {television|Category}
28 | PickCategory {people|Category}
29 | PickCategory {rhyme time|Category}
30 | PickCategory {pop music|Category}
31 | PickCategory {quotations|Category}
32 | PickCategory lets go with a {food|Category} question
33 | PickCategory how about {television|Category}
34 | PickCategory i'll start with {people|Category}
35 | PickCategory give me a {sports|Category} question
36 | PickCategory i'll take {sports|Category}
37 | RepeatQuestion can you repeat the question
38 | RepeatQuestion repeat the question
39 | RepeatQuestion say question again
40 | RepeatQuestion can you say the question again
41 | AnswerQuestion who is {abraham lincoln|Answer}
42 | AnswerQuestion what is a {robot|Answer}
43 | AnswerQuestion what is {sweet tea|Answer}
44 | AnswerQuestion where is {the washington monument|Answer}
45 | AnswerQuestion who are {the doobie brothers|Answer}
46 | AnswerQuestion what are {pancakes|Answer}
47 | AnswerQuestion where are {the rocky mountains|Answer}
48 | AnswerQuestion i don't know
49 | AnswerQuestion not sure
50 | AnswerQuestion no idea
51 | AnswerQuestion i give up
52 | 


--------------------------------------------------------------------------------
/skillserver/README.md:
--------------------------------------------------------------------------------
 1 | ## `go-alexa/skillserver`
 2 | 
 3 | A simple Go framework to quickly create an Amazon Alexa Skills web service.
 4 | 
 5 | ### Updates
 6 | 10/3/16: Go 1.7 is required now as `go-alexa` uses the new core context library. It's not ideal to require 1.7, but with Go's no breaking changes promise it should be an easy upgrade for the vast majority of projects out there and it's better to keep up with the current release. If this change causes any issues, please reach out with an issue.
 7 | 
 8 | 4/5/16: After taking a few good addtions from the community recently, I also just added new hooks that make it even easier to get going since you don't have to write a full `net/http` handler (see the new Hello World below)!
 9 | 
10 | ### What?
11 | 
12 | After beta testing the Amazon Echo (and it's voice assistant Alexa) for several months, Amazon has released the product to the public and created an SDK for developers to add new "Alexa Skills" to the product.
13 | 
14 | You can see the SDK documentation here: [developer.amazon.com/public/solutions/alexa/alexa-skills-kit](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit) but in short, a developer can make a web service that allows a user to say: _Alexa, ask [your service] to [some action your service provides]_
15 | 
16 | ### Requirements
17 | 
18 | Amazon has a list of requirements to get a new Skill up and running
19 | 
20 | 1. Creating your new Skill on their Development Dashboard populating it with details and example phrases. That process is documented here: [developer.amazon.com/appsandservices/solutions/alexa/alexa-skills-kit/docs/defining-the-voice-interface](https://developer.amazon.com/appsandservices/solutions/alexa/alexa-skills-kit/docs/defining-the-voice-interface)
21 | 2. A lengthy request validation proces. Documented here: [developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/developing-an-alexa-skill-as-a-web-service](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/developing-an-alexa-skill-as-a-web-service)
22 | 3. A formatted JSON response.
23 | 4. SSL connection required, even for development.
24 | 5. If you don't wish to validate the certificate, you can use --insecure-skip-verify which disables all certificate validations. ***NOT RECOMMENDED FOR PRODUCTION USE***
25 | 
26 | ### How `skillserver` Helps
27 | 
28 | The `go-alexa/skillserver` takes care of #2 and #3 for you so you can concentrate on #1 and coding your app. (#4 is what it is. See the section on SSL below.)
29 | 
30 | ### An Example App
31 | 
32 | Creating an Alexa Skill web service is easy with `go-alexa/skillserver`. Simply import the project as any other Go project, define your app, and write your endpoint. All the web service, security checks, and assistance in creating the response objects are done for you.
33 | 
34 | Here's a simple, but complete web service example:
35 | 
36 | ```go
37 | package main
38 | 
39 | import (
40 | 	alexa "github.com/mikeflynn/go-alexa/skillserver"
41 | )
42 | 
43 | var Applications = map[string]interface{}{
44 | 	"/echo/helloworld": alexa.EchoApplication{ // Route
45 | 		AppID:    "xxxxxxxx", // Echo App ID from Amazon Dashboard
46 | 		OnIntent: EchoIntentHandler,
47 | 		OnLaunch: EchoIntentHandler,
48 | 	},
49 | }
50 | 
51 | func main() {
52 | 	alexa.Run(Applications, "3000")
53 | }
54 | 
55 | func EchoIntentHandler(echoReq *alexa.EchoRequest, echoResp *alexa.EchoResponse) {
56 | 	echoResp.OutputSpeech("Hello world from my new Echo test app!").Card("Hello World", "This is a test card.")
57 | }
58 | ```
59 | 
60 | Details:
61 | * You define your endpoints by creating a `map[string]interface{}` and loading it with `EchoApplication` types that specify the Application ID and handler function.
62 | * All Skill endpoints must start with `/echo/` as that's the route grouping that has the security middleware.
63 | * The easiest way to get started is define handler functions by using `OnIntent`, `OnLaunch`, or `OnSessionEnded` that take an EchoRequest and an EchoResponse.
64 | * ...but if you want full control you can still use the `EchoApplication.Handler` hook to write a regular `net/http` handler so you have full access to the request and ResponseWriter.
65 | * The JSON from the Echo request is already parsed for you. Grab it by calling `skillserver.GetEchoRequest(r *http.Request)`.
66 | * You generate the Echo Response by using the EchoResponse struct that has methods to generate each part and that's it! ...unless you use the `EchoApplication.Handler` hook. In that case you need to write your JSON to the string with the `EchoResponse.toString()` method.
67 | 
68 | ### The SSL Requirement
69 | 
70 | Amazon requires an SSL connection for all steps in the Skill process, even local development (which still gets requests from the Echo web service). Amazon is pushing their AWS Lambda service that takes care of SSL for you ~~but Go isn't an option on Lambda~~. What I've done personally is put Nginx in front of my Go app and let Nginx handle the SSL (a self-signed cert for development and a real cert when pushing to production). More information here on  [nginx.com](https://www.nginx.com/blog/nginx-ssl/).
71 | 
72 | ### Contributors
73 | 
74 | Mike Flynn ([@thatmikeflynn](https://twitter.com/thatmikeflynn))
75 | 


--------------------------------------------------------------------------------
/skillserver/ssml-builder.go:
--------------------------------------------------------------------------------
  1 | package skillserver
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | )
  7 | 
  8 | /**
  9 |  * Details about the Speech Synthesis Markup Language (SSML) can be found on this page:
 10 |  * https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/speech-synthesis-markup-language-ssml-reference
 11 |  */
 12 | 
 13 | // Helper Types
 14 | 
 15 | // SSMLTextBuilder implements the builder pattern for constructing a speech string
 16 | // which may or may not contain SSML tags.
 17 | type SSMLTextBuilder struct {
 18 | 	buffer *bytes.Buffer
 19 | }
 20 | 
 21 | // WordRole is used as the role argument in the AppendPartOfSpeech method. This should
 22 | // be one of the constants defined in the Amazon SSML Reference docs.
 23 | type WordRole string
 24 | 
 25 | const (
 26 | 	// PresentSimple is used to pronounce the word as a verb
 27 | 	PresentSimple WordRole = "amazon:VB"
 28 | 	// PastParticle is used to pronounce the word as a past particle
 29 | 	PastParticle WordRole = "amazon:VBD"
 30 | 	// Noun is used to pronounce the word as a noun
 31 | 	Noun WordRole = "amazon:NN"
 32 | 	// AlternateSense is used to select the alternate sense for a specific word. According
 33 | 	// to the Amazon SSML Reference:
 34 | 	// 		" Use the non-default sense of the word. For example, the noun "bass" is pronounced
 35 | 	//		differently depending on meaning. The "default" meaning is the lowest part of the
 36 | 	// 		musical range. The alternate sense (which is still a noun) is a freshwater fish.
 37 | 	// 		Specifying <speak><w role="amazon:SENSE_1">bass</w>"</speak> renders the non-default
 38 | 	// 		pronunciation (freshwater fish)."
 39 | 	AlternateSense WordRole = "amazon:SENSE_1"
 40 | )
 41 | 
 42 | // PhoneticAlphabet represents the alphabet to be used when appending phonemes
 43 | type PhoneticAlphabet string
 44 | 
 45 | const (
 46 | 	// Ipa is the International Phonetic Alphabet
 47 | 	Ipa PhoneticAlphabet = "ipa"
 48 | 	// XSampa is the Extended Speech Assesment Methods Phonetic Alphabet
 49 | 	XSampa PhoneticAlphabet = "x-sampa"
 50 | )
 51 | 
 52 | // NewSSMLTextBuilder is a convenienve method for constructing a new SSMLTextBuilder
 53 | // instance that starts with no speech text added.
 54 | func NewSSMLTextBuilder() *SSMLTextBuilder {
 55 | 	return &SSMLTextBuilder{bytes.NewBufferString("")}
 56 | }
 57 | 
 58 | // AppendPlainSpeech will append the supplied text as regular speech to be spoken by the Alexa device.
 59 | func (builder *SSMLTextBuilder) AppendPlainSpeech(text string) *SSMLTextBuilder {
 60 | 
 61 | 	builder.buffer.WriteString(text)
 62 | 
 63 | 	return builder
 64 | }
 65 | 
 66 | // AppendAmazonEffect will add a new speech string with the provided effect name.
 67 | // Check the SSML reference page for a list of available effects.
 68 | func (builder *SSMLTextBuilder) AppendAmazonEffect(text, name string) *SSMLTextBuilder {
 69 | 
 70 | 	builder.buffer.WriteString(fmt.Sprintf("<amazon:effect name=\"%s\">%s</amazon:effect>", name, text))
 71 | 
 72 | 	return builder
 73 | }
 74 | 
 75 | // AppendAudio will append the playback of an MP3 file to the response. The audio playback
 76 | // will take place at the specific point in the text to speech response.
 77 | func (builder *SSMLTextBuilder) AppendAudio(src string) *SSMLTextBuilder {
 78 | 
 79 | 	builder.buffer.WriteString(fmt.Sprintf("<audio src=\"%s\"/>", src))
 80 | 
 81 | 	return builder
 82 | }
 83 | 
 84 | // AppendBreak will add a pause to the text to speech output. The default is a medium pause.
 85 | // Refer to the SSML reference for the available strength values.
 86 | func (builder *SSMLTextBuilder) AppendBreak(strength, time string) *SSMLTextBuilder {
 87 | 
 88 | 	if strength == "" {
 89 | 		// The default strength is medium
 90 | 		strength = "medium"
 91 | 	}
 92 | 
 93 | 	builder.buffer.WriteString(fmt.Sprintf("<break strength=\"%s\" time=\"%s\"/>", strength, time))
 94 | 
 95 | 	return builder
 96 | }
 97 | 
 98 | // AppendEmphasis will include a set of text to be spoken with the specific level of emphasis.
 99 | // Refer to the SSML reference for available emphasis level values.
100 | func (builder *SSMLTextBuilder) AppendEmphasis(text, level string) *SSMLTextBuilder {
101 | 
102 | 	builder.buffer.WriteString(fmt.Sprintf("<emphasis level=\"%s\">%s</emphasis>", level, text))
103 | 
104 | 	return builder
105 | }
106 | 
107 | // AppendParagraph will append the specific text as a new paragraph. Extra strong breaks will
108 | // be used before and after this text.
109 | func (builder *SSMLTextBuilder) AppendParagraph(text string) *SSMLTextBuilder {
110 | 
111 | 	builder.buffer.WriteString(fmt.Sprintf("<p>%s</p>", text))
112 | 
113 | 	return builder
114 | }
115 | 
116 | // AppendProsody provides a way to modify the rate, pitch, and volume of a piece of spoken text.
117 | func (builder *SSMLTextBuilder) AppendProsody(text, rate, pitch, volume string) *SSMLTextBuilder {
118 | 
119 | 	builder.buffer.WriteString(fmt.Sprintf("<prosody rate=\"%s\" pitch=\"%s\" volume=\"%s\">%s</prosody>", rate, pitch, volume, text))
120 | 
121 | 	return builder
122 | }
123 | 
124 | // AppendSentence will indicate the provided text should be spoken as a new sentence. This text will
125 | // include strong breaks before and after.
126 | func (builder *SSMLTextBuilder) AppendSentence(text string) *SSMLTextBuilder {
127 | 
128 | 	builder.buffer.WriteString(fmt.Sprintf("<s>%s</s>", text))
129 | 
130 | 	return builder
131 | }
132 | 
133 | // AppendPartOfSpeech is used to explictily define the part of speech for a word that is being
134 | // appended to the text to speech output sent in a skill server response.
135 | func (builder *SSMLTextBuilder) AppendPartOfSpeech(role WordRole, text string) *SSMLTextBuilder {
136 | 
137 | 	if role != "" {
138 | 		builder.buffer.WriteString(fmt.Sprintf("<w role=\"%s\">%s</w>", role, text))
139 | 	}
140 | 
141 | 	return builder
142 | }
143 | 
144 | // AppendSubstitution provides a way to indicate an alternate pronunciation for a piece of text.
145 | func (builder *SSMLTextBuilder) AppendSubstitution(text, alias string) *SSMLTextBuilder {
146 | 
147 | 	builder.buffer.WriteString(fmt.Sprintf("<sub alias=\"%s\">%s</sub>", alias, text))
148 | 
149 | 	return builder
150 | }
151 | 
152 | // AppendSayAs is used to provide additional information about how the text string being appended
153 | // should be interpreted. For example this can be used to interpret the string as a list
154 | // of individual characters or to read out digits one at a time. The format string is
155 | // ignored unless the interpret-as argument is `date`. Refer to the SSML referene for valid
156 | // values for the interpretAs parameter.
157 | func (builder *SSMLTextBuilder) AppendSayAs(interpretAs, format, text string) *SSMLTextBuilder {
158 | 
159 | 	if interpretAs == "date" {
160 | 		builder.buffer.WriteString(fmt.Sprintf("<say-as interpret-as=\"%s\" format=\"%s\">%s</say-as>",
161 | 			interpretAs, format, text))
162 | 	} else if interpretAs != "" {
163 | 		builder.buffer.WriteString(fmt.Sprintf("<say-as interpret-as=\"%s\">%s</say-as>", interpretAs, text))
164 | 	}
165 | 
166 | 	return builder
167 | }
168 | 
169 | // AppendPhoneme is used to specify a phonetic pronunciation for a piece of text to be appended
170 | // to the response.
171 | func (builder *SSMLTextBuilder) AppendPhoneme(alphabet PhoneticAlphabet, phoneme, text string) *SSMLTextBuilder {
172 | 
173 | 	if phoneme != "" && text != "" && alphabet != PhoneticAlphabet("") {
174 | 		builder.buffer.WriteString(fmt.Sprintf("<phoneme alphabet=\"%s\" ph=\"%s\">%s</phoneme>", alphabet, phoneme, text))
175 | 	}
176 | 
177 | 	return builder
178 | }
179 | 
180 | // Build will construct the appropriate speech string including any SSML
181 | // tags that were added to the Builder.
182 | func (builder *SSMLTextBuilder) Build() string {
183 | 	return fmt.Sprintf("<speak>%s</speak>", builder.buffer.String())
184 | }
185 | 


--------------------------------------------------------------------------------
/skillserver/examples/jeopardy/jeopardy.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"log"
  7 | 	"math/rand"
  8 | 	"net/http"
  9 | 	"os"
 10 | 	"strconv"
 11 | 	"strings"
 12 | 	"time"
 13 | 
 14 | 	"github.com/kennygrant/sanitize"
 15 | 	alexa "github.com/mikeflynn/go-alexa/skillserver"
 16 | 	"gopkg.in/mgo.v2"
 17 | 	"gopkg.in/mgo.v2/bson"
 18 | )
 19 | 
 20 | var applications = map[string]interface{}{
 21 | 	"/echo/jeopardy": alexa.EchoApplication{
 22 | 		AppID:   os.Getenv("JEOPARDY_APP_ID"),
 23 | 		Handler: EchoJeopardy,
 24 | 	},
 25 | }
 26 | 
 27 | func main() {
 28 | 	rand.Seed(time.Now().UTC().UnixNano())
 29 | 	alexa.Run(applications, "3000")
 30 | }
 31 | 
 32 | // JeopardySession will contain all data needed for a single Jeopardy game session.
 33 | type JeopardySession struct {
 34 | 	AWSID           string
 35 | 	Dollars         int
 36 | 	NumQuestions    int
 37 | 	CurrentQuestion JeopardyQuestion
 38 | 	UpdatedAt       int64
 39 | }
 40 | 
 41 | // JeopardyQuestion wraps the data representing a single question to be asked of the user.
 42 | type JeopardyQuestion struct {
 43 | 	Category string
 44 | 	Question string
 45 | 	Answer   string
 46 | 	Value    int
 47 | }
 48 | 
 49 | var jeopardyCategories = map[string]int{
 50 | 	"food":       49,
 51 | 	"hodgepodge": 227,
 52 | 	"history":    114,
 53 | 	"sports":     42,
 54 | 	"science":    25,
 55 | 	"television": 67,
 56 | 	"people":     442,
 57 | 	"rhyme time": 561,
 58 | 	"pop music":  770,
 59 | 	"quotations": 1420,
 60 | }
 61 | 
 62 | var jeopardyGreetings = []string{
 63 | 	"Sure.",
 64 | 	"Lets do it!",
 65 | 	"Whatever. I'm just sitting here I guess.",
 66 | 	"No. I'm busy. Just kidding.",
 67 | 	"Coolio.",
 68 | 	"Lets play Jeopardy!",
 69 | }
 70 | 
 71 | var jeopardyCatSelect = []string{
 72 | 	"Don't worry your pretty little head about it. Lets go with ",
 73 | 	"I'll pick ",
 74 | 	"Lets go with ",
 75 | 	"You should have picked. I'm going with ",
 76 | 	"You've already failed, but lets keep going with ",
 77 | }
 78 | 
 79 | var jeopardyRightAnswer = []string{
 80 | 	"You got it! ",
 81 | 	"Nice. ",
 82 | 	"Bingo. ",
 83 | 	"Nailed it! ",
 84 | 	"Correct. ",
 85 | 	"That is right. ",
 86 | 	"Holy crap you got it! ",
 87 | }
 88 | 
 89 | var jeopardyWrongAnswer = []string{
 90 | 	"Nope.",
 91 | 	"Sorry, that's incorrect.",
 92 | 	"Wow, no, not even close.",
 93 | 	"Yikes. No.",
 94 | 	"Awww, too bad.",
 95 | }
 96 | 
 97 | // #1: Greeting and ask for category.
 98 | // #2: Deliver question with dollar amount.
 99 | // #3: Verify answer (update session total)
100 | // #4: Give current score and list categories.
101 | 
102 | // EchoJeopardy is an HTTP handler that will accept the incoming requests to the skill
103 | // and return the contents of an Alexa app response to the server.
104 | func EchoJeopardy(w http.ResponseWriter, r *http.Request) {
105 | 	echoReq := alexa.GetEchoRequest(r)
106 | 
107 | 	// Start up Mongo!
108 | 	mongodb, err := mgo.Dial("localhost")
109 | 	if err != nil {
110 | 		panic(err)
111 | 	}
112 | 
113 | 	col := mongodb.DB("echo").C("jeopardy")
114 | 	defer mongodb.Close()
115 | 
116 | 	log.Println(echoReq.GetRequestType())
117 | 	log.Println(echoReq.GetSessionID())
118 | 
119 | 	if echoReq.GetRequestType() == "LaunchRequest" {
120 | 		session := getJeopardySession(col, echoReq.GetSessionID())
121 | 
122 | 		echoResp, _ := jeopardyStart(echoReq, session)
123 | 
124 | 		json, _ := echoResp.String()
125 | 		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
126 | 		w.Write(json)
127 | 	} else if echoReq.GetRequestType() == "IntentRequest" {
128 | 		log.Println(echoReq.GetIntentName())
129 | 
130 | 		session := getJeopardySession(col, echoReq.GetSessionID())
131 | 
132 | 		var echoResp *alexa.EchoResponse
133 | 
134 | 		switch echoReq.GetIntentName() {
135 | 		case "StartJeopardy":
136 | 			echoResp, session = jeopardyStart(echoReq, session)
137 | 		case "ListCategories":
138 | 			echoResp, session = jeopardyStart(echoReq, session)
139 | 		case "PickCategory":
140 | 			if session.CurrentQuestion.Category == "" {
141 | 				echoResp, session = jeopardyCategory(echoReq, session)
142 | 			} else {
143 | 				echoResp, session = jeopardyAnswer(echoReq, session)
144 | 			}
145 | 
146 | 			session.update(col)
147 | 		case "AnswerQuestion":
148 | 			echoResp, session = jeopardyAnswer(echoReq, session)
149 | 			session.update(col)
150 | 		case "RepeatQuestion":
151 | 			if session.CurrentQuestion.Question != "" {
152 | 				echoResp = alexa.NewEchoResponse().OutputSpeech(session.CurrentQuestion.Question).EndSession(false)
153 | 			} else {
154 | 				echoResp = alexa.NewEchoResponse().OutputSpeech("I didn't ask a question. Please pick a category first.").EndSession(false)
155 | 			}
156 | 		case "QuitGame":
157 | 			noun := "questions"
158 | 			if session.NumQuestions == 1 {
159 | 				noun = "question"
160 | 			}
161 | 			echoResp = alexa.NewEchoResponse().OutputSpeech("You ended with " + strconv.Itoa(session.Dollars) + " after " + strconv.Itoa(session.NumQuestions) + " " + noun + " .").EndSession(true)
162 | 		default:
163 | 			echoResp = alexa.NewEchoResponse().OutputSpeech("I'm sorry, I didn't get that. Can you say that again?").EndSession(false)
164 | 		}
165 | 
166 | 		json, _ := echoResp.String()
167 | 		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
168 | 		w.Write(json)
169 | 	} else if echoReq.GetRequestType() == "SessionEndedRequest" {
170 | 		//session.Delete(col)
171 | 	}
172 | }
173 | 
174 | func jeopardyStart(echoReq *alexa.EchoRequest, session *JeopardySession) (*alexa.EchoResponse, *JeopardySession) {
175 | 	catNames := []string{}
176 | 	for k := range jeopardyCategories {
177 | 		catNames = append(catNames, k)
178 | 	}
179 | 
180 | 	msg := ""
181 | 	if echoReq.GetIntentName() == "StartJeopardy" {
182 | 		msg = jeopardyGreetings[rand.Intn(len(jeopardyGreetings))] + " Please pick one of the following categories: "
183 | 	} else {
184 | 		msg = "The categories are "
185 | 	}
186 | 	msg += strings.Join(catNames, ", ")
187 | 	echoResp := alexa.NewEchoResponse().OutputSpeech(msg).EndSession(false)
188 | 
189 | 	return echoResp, session
190 | }
191 | 
192 | func jeopardyCategory(echoReq *alexa.EchoRequest, session *JeopardySession) (*alexa.EchoResponse, *JeopardySession) {
193 | 	msg := ""
194 | 	echoResp := alexa.NewEchoResponse()
195 | 
196 | 	// Declare the category
197 | 	category, err := echoReq.GetSlotValue("Category")
198 | 	_, catExists := jeopardyCategories[category]
199 | 	if err != nil || !catExists {
200 | 		catNames := []string{}
201 | 		for k := range jeopardyCategories {
202 | 			catNames = append(catNames, k)
203 | 		}
204 | 
205 | 		category = getRandom(catNames)
206 | 
207 | 		msg = msg + getRandom(jeopardyCatSelect) + category + ". "
208 | 	} else {
209 | 		category = strings.ToLower(category)
210 | 	}
211 | 
212 | 	clue, err := getJServiceClue(jeopardyCategories[category])
213 | 	if err != nil {
214 | 		clue, err = getJServiceClue(jeopardyCategories[category])
215 | 		if err != nil {
216 | 			echoResp := alexa.NewEchoResponse().OutputSpeech("I'm sorry, but I can't seem to get a question right now.").EndSession(true)
217 | 			return echoResp, session
218 | 		}
219 | 	}
220 | 
221 | 	msg += "From " + category + " for " + strconv.Itoa(clue.Value) + ". " + clue.Question + ". I need your answer in the form of a question."
222 | 
223 | 	session.CurrentQuestion.Category = category
224 | 	session.CurrentQuestion.Answer = sanitize.HTML(clue.Answer)
225 | 	session.CurrentQuestion.Question = clue.Question
226 | 	session.CurrentQuestion.Value = clue.Value
227 | 
228 | 	log.Println(session.CurrentQuestion.Question)
229 | 	log.Println(session.CurrentQuestion.Answer)
230 | 
231 | 	echoResp.OutputSpeech(msg).Card("Question", msg).Reprompt("Times up. I need your answer in the form of a question.").EndSession(false)
232 | 
233 | 	return echoResp, session
234 | }
235 | 
236 | func jeopardyAnswer(echoReq *alexa.EchoRequest, session *JeopardySession) (*alexa.EchoResponse, *JeopardySession) {
237 | 	msg := ""
238 | 	echoResp := alexa.NewEchoResponse()
239 | 
240 | 	if session.CurrentQuestion.Answer == "" {
241 | 		echoResp.OutputSpeech("You need to get a question before answering!").EndSession(false)
242 | 		return echoResp, session
243 | 	}
244 | 
245 | 	answer, err := echoReq.GetSlotValue("Answer")
246 | 	log.Println(answer)
247 | 	if err != nil {
248 | 		echoResp.OutputSpeech("We need an answer!").EndSession(false)
249 | 		return echoResp, session
250 | 	}
251 | 
252 | 	if strings.ToLower(answer) == strings.ToLower(session.CurrentQuestion.Answer) {
253 | 		msg += getRandom(jeopardyRightAnswer)
254 | 		session.Dollars = session.Dollars + session.CurrentQuestion.Value
255 | 	} else {
256 | 		msg += getRandom(jeopardyWrongAnswer) + " The correct answer was " + session.CurrentQuestion.Answer + ". "
257 | 	}
258 | 
259 | 	session.NumQuestions++
260 | 	session.CurrentQuestion = JeopardyQuestion{}
261 | 
262 | 	msg += "You're at " + strconv.Itoa(session.Dollars) + " after " + strconv.Itoa(session.NumQuestions) + " questions. Please pick another category."
263 | 
264 | 	echoResp.OutputSpeech(msg).Card("Answer", session.CurrentQuestion.Answer).EndSession(false)
265 | 
266 | 	return echoResp, session
267 | }
268 | 
269 | func getRandom(list []string) string {
270 | 	return list[rand.Intn(len(list))]
271 | }
272 | 
273 | func getJeopardySession(col *mgo.Collection, sessid string) *JeopardySession {
274 | 	user := &JeopardySession{}
275 | 	err := col.Find(bson.M{"awsid": sessid}).One(&user)
276 | 	if err != nil || user.AWSID == "" {
277 | 		log.Println("Creating new session.")
278 | 		user.AWSID = sessid
279 | 		user.NumQuestions = 0
280 | 		user.Dollars = 0
281 | 		user.UpdatedAt = time.Now().Unix()
282 | 		err = col.Insert(&user)
283 | 		if err != nil {
284 | 			panic(err)
285 | 		}
286 | 	}
287 | 
288 | 	return user
289 | }
290 | 
291 | func (s *JeopardySession) update(col *mgo.Collection) error {
292 | 	s.UpdatedAt = time.Now().Unix()
293 | 	err := col.Update(bson.M{"awsid": s.AWSID}, s)
294 | 	if err != nil {
295 | 		return err
296 | 	}
297 | 
298 | 	return nil
299 | }
300 | 
301 | func (s *JeopardySession) delete(col *mgo.Collection) error {
302 | 	err := col.Remove(bson.M{"awsid": s.AWSID})
303 | 	if err != nil {
304 | 		return err
305 | 	}
306 | 
307 | 	return nil
308 | }
309 | 
310 | // jservice
311 | 
312 | // JServiceClue contains data about a question and ansewr from the jservice.
313 | type JServiceClue struct {
314 | 	ID           int    `json:"id"`
315 | 	Answer       string `json:"answer"`
316 | 	Question     string `json:"question"`
317 | 	Value        int    `json:"value"`
318 | 	AirDate      string `json:"airdate"`
319 | 	CreatedAt    string `json:"created_at"`
320 | 	UpdatedAt    string `json:"updated_at"`
321 | 	CategoryID   int    `json:"category_id"`
322 | 	GameID       int    `json:"game_id"`
323 | 	InvalidCount int    `json:"invalid_count,omitempty"`
324 | 	Category     struct {
325 | 		ID         int    `json:"id"`
326 | 		Title      string `json:"title"`
327 | 		CreatedAt  string `json:"created_at"`
328 | 		UpdatedAt  string `json:"updated_at"`
329 | 		CluesCount int    `json:"clues_count"`
330 | 	} `json:"category"`
331 | }
332 | 
333 | func getJServiceClue(catID int) (JServiceClue, error) {
334 | 	offset := rand.Intn(100)
335 | 	log.Println("http://jservice.io/api/clues?category=" + strconv.Itoa(catID) + "&offset=" + strconv.Itoa(offset))
336 | 	response, err := http.Get("http://jservice.io/api/clues?category=" + strconv.Itoa(catID) + "&offset=" + strconv.Itoa(offset))
337 | 	if err != nil {
338 | 		log.Println(err.Error())
339 | 		return JServiceClue{}, err
340 | 	}
341 | 
342 | 	var clues []JServiceClue
343 | 	err = json.NewDecoder(response.Body).Decode(&clues)
344 | 	if err != nil {
345 | 		log.Println(err.Error())
346 | 		return JServiceClue{}, err
347 | 	}
348 | 
349 | 	if len(clues) > 0 {
350 | 		return clues[0], nil
351 | 	}
352 | 
353 | 	return JServiceClue{}, errors.New("no clues returned")
354 | }
355 | 


--------------------------------------------------------------------------------
/skillserver/skillserver.go:
--------------------------------------------------------------------------------
  1 | package skillserver
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"context"
  6 | 	"crypto"
  7 | 	"crypto/rsa"
  8 | 	"crypto/sha1"
  9 | 	"crypto/tls"
 10 | 	"crypto/x509"
 11 | 	"encoding/base64"
 12 | 	"encoding/json"
 13 | 	"encoding/pem"
 14 | 	"errors"
 15 | 	"io"
 16 | 	"io/ioutil"
 17 | 	"log"
 18 | 	"net/http"
 19 | 	"net/url"
 20 | 	"strings"
 21 | 	"time"
 22 | 
 23 | 	"github.com/gorilla/mux"
 24 | 	"github.com/urfave/negroni"
 25 | )
 26 | 
 27 | // EchoApplication represents a single Alexa application server. This application type needs to include
 28 | // the application ID from the Alexa developer portal that will be making requests to the server. This AppId needs
 29 | // to be verified to ensure the requests are coming from the correct app. Handlers can also be provied for
 30 | // different types of requests sent by the Alexa Skills Kit such as OnLaunch or OnIntent.
 31 | type EchoApplication struct {
 32 | 	AppID              string
 33 | 	Handler            func(http.ResponseWriter, *http.Request)
 34 | 	OnLaunch           func(*EchoRequest, *EchoResponse)
 35 | 	OnIntent           func(*EchoRequest, *EchoResponse)
 36 | 	OnSessionEnded     func(*EchoRequest, *EchoResponse)
 37 | 	OnAudioPlayerState func(*EchoRequest, *EchoResponse)
 38 | }
 39 | 
 40 | // StdApplication is a type of application that allows the user to accept and manually process
 41 | // requests from an Alexa application on an existing HTTP server. Request validation and parsing
 42 | // will need to be done manually to ensure compliance with the requirements of the Alexa Skills Kit.
 43 | type StdApplication struct {
 44 | 	Methods string
 45 | 	Handler func(http.ResponseWriter, *http.Request)
 46 | }
 47 | 
 48 | type requestContextKey string
 49 | 
 50 | var (
 51 | 	applications       = map[string]interface{}{}
 52 | 	rootPrefix         = "/"
 53 | 	echoPrefix         = "/echo/"
 54 | 	insecureSkipVerify = false
 55 | )
 56 | 
 57 | // SetEchoPrefix provides a way to specify a single path prefix that all EchoApplications will share.SetEchoPrefix
 58 | // All incoming requests to an initialized EchoApplication will need to have a path that starts with this prefix.
 59 | func SetEchoPrefix(prefix string) {
 60 | 	echoPrefix = prefix
 61 | }
 62 | 
 63 | // SetRootPrefix allows a single path prefix to be applied to the request path of all
 64 | // StdApplications. All requests to the StdApplications provided will need to begin with
 65 | // this prefix.
 66 | func SetRootPrefix(prefix string) {
 67 | 	rootPrefix = prefix
 68 | }
 69 | 
 70 | // SetVerifyAWSCerts allows to specify whether AWS provided certs should be verified or not
 71 | func SetVerifyAWSCerts(doVerify bool) {
 72 | 	insecureSkipVerify = !doVerify
 73 | 	if insecureSkipVerify {
 74 | 		log.Println("insecure skip verify selected, certs will not be checked")
 75 | 	}
 76 | }
 77 | 
 78 | // Run will initialize the apps provided and start an HTTP server listening on the specified port.
 79 | func Run(apps map[string]interface{}, port string) {
 80 | 	router := mux.NewRouter()
 81 | 	initialize(apps, router)
 82 | 	n := negroni.Classic()
 83 | 	n.UseHandler(router)
 84 | 	n.Run(":" + port)
 85 | }
 86 | 
 87 | // RunSSL takes in a map of application, server port, certificate and key files, and
 88 | // tries to start a TLS server which alexa can directly pass commands to.
 89 | // It panics out with the error if the server couldn't be started. Or else the method blocks
 90 | // at ListenAndServeTLS line.
 91 | // If the server starts succcessfully and there are connection errors afterwards, they are
 92 | // logged to the stdout and no error is returned.
 93 | // For generating a testing cert and key, read the following:
 94 | // https://developer.amazon.com/docs/custom-skills/configure-web-service-self-signed-certificate.html
 95 | func RunSSL(apps map[string]interface{}, port, cert, key string) {
 96 | 	router := mux.NewRouter()
 97 | 
 98 | 	initialize(apps, router)
 99 | 
100 | 	// This is very limited TLS configuration which is required to connect alexa to our webservice.
101 | 	// The curve preferences are used by ECDSA/ECDHE algorithms for figuring out the matching algorithm
102 | 	// from alexa side starting from the strongest to the weakest.
103 | 	cfg := &tls.Config{
104 | 		MinVersion:               tls.VersionTLS12,
105 | 		CurvePreferences:         []tls.CurveID{tls.CurveP521, tls.CurveP384, tls.CurveP256},
106 | 		PreferServerCipherSuites: true,
107 | 		CipherSuites: []uint16{
108 | 			// If the connection throws errors related to crypt algorithm mismatch between server and client,
109 | 			// this line must be replaced by constants present in crypt/tls package for the value that works.
110 | 			tls.TLS_AES_128_GCM_SHA256,
111 | 			tls.TLS_AES_256_GCM_SHA384,
112 | 			tls.TLS_CHACHA20_POLY1305_SHA256,
113 | 			tls.TLS_RSA_WITH_RC4_128_SHA,
114 | 			tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
115 | 			tls.TLS_RSA_WITH_AES_128_CBC_SHA,
116 | 			tls.TLS_RSA_WITH_AES_256_CBC_SHA,
117 | 			tls.TLS_RSA_WITH_AES_128_CBC_SHA256,
118 | 			tls.TLS_RSA_WITH_AES_128_GCM_SHA256,
119 | 			tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
120 | 			tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
121 | 			tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
122 | 			tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
123 | 			tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA,
124 | 			tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
125 | 			tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
126 | 			tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
127 | 			tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
128 | 			tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
129 | 			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
130 | 			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
131 | 			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
132 | 			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
133 | 			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
134 | 			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
135 | 		},
136 | 	}
137 | 	srv := &http.Server{
138 | 		Addr:         ":" + port,
139 | 		Handler:      router,
140 | 		TLSConfig:    cfg,
141 | 		TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler), 0),
142 | 	}
143 | 	log.Fatal(srv.ListenAndServeTLS(cert, key))
144 | }
145 | 
146 | func initialize(apps map[string]interface{}, router *mux.Router) {
147 | 	applications = apps
148 | 
149 | 	// /echo/* Endpoints
150 | 	echoRouter := mux.NewRouter()
151 | 	// /* Endpoints
152 | 	pageRouter := mux.NewRouter()
153 | 
154 | 	hasPageRouter := false
155 | 
156 | 	for uri, meta := range applications {
157 | 		switch app := meta.(type) {
158 | 		case EchoApplication:
159 | 			handlerFunc := func(w http.ResponseWriter, r *http.Request) {
160 | 				echoReq := GetEchoRequest(r)
161 | 				echoResp := NewEchoResponse()
162 | 
163 | 				if echoReq.GetRequestType() == "LaunchRequest" {
164 | 					if app.OnLaunch != nil {
165 | 						app.OnLaunch(echoReq, echoResp)
166 | 					}
167 | 				} else if echoReq.GetRequestType() == "IntentRequest" {
168 | 					if app.OnIntent != nil {
169 | 						app.OnIntent(echoReq, echoResp)
170 | 					}
171 | 				} else if echoReq.GetRequestType() == "SessionEndedRequest" {
172 | 					if app.OnSessionEnded != nil {
173 | 						app.OnSessionEnded(echoReq, echoResp)
174 | 					}
175 | 				} else if strings.HasPrefix(echoReq.GetRequestType(), "AudioPlayer.") {
176 | 					if app.OnAudioPlayerState != nil {
177 | 						app.OnAudioPlayerState(echoReq, echoResp)
178 | 					}
179 | 				} else {
180 | 					http.Error(w, "Invalid request.", http.StatusBadRequest)
181 | 				}
182 | 
183 | 				json, _ := echoResp.String()
184 | 				w.Header().Set("Content-Type", "application/json;charset=UTF-8")
185 | 				w.Write(json)
186 | 			}
187 | 
188 | 			if app.Handler != nil {
189 | 				handlerFunc = app.Handler
190 | 			}
191 | 
192 | 			echoRouter.HandleFunc(uri, handlerFunc).Methods("POST")
193 | 		case StdApplication:
194 | 			hasPageRouter = true
195 | 			pageRouter.HandleFunc(uri, app.Handler).Methods(app.Methods)
196 | 		}
197 | 	}
198 | 
199 | 	router.PathPrefix(echoPrefix).Handler(negroni.New(
200 | 		negroni.HandlerFunc(validateRequest),
201 | 		negroni.HandlerFunc(verifyJSON),
202 | 		negroni.Wrap(echoRouter),
203 | 	))
204 | 
205 | 	if hasPageRouter {
206 | 		router.PathPrefix(rootPrefix).Handler(negroni.New(
207 | 			negroni.Wrap(pageRouter),
208 | 		))
209 | 	}
210 | }
211 | 
212 | // GetEchoRequest is a convenience method for retrieving and casting an `EchoRequest` out of a
213 | // standard `http.Request`.
214 | func GetEchoRequest(r *http.Request) *EchoRequest {
215 | 	return r.Context().Value(requestContextKey("echoRequest")).(*EchoRequest)
216 | }
217 | 
218 | // HTTPError is a convenience method for logging a message and writing the provided error message
219 | // and error code to the HTTP response.
220 | func HTTPError(w http.ResponseWriter, logMsg string, err string, errCode int) {
221 | 	if logMsg != "" {
222 | 		log.Println(logMsg)
223 | 	}
224 | 
225 | 	http.Error(w, err, errCode)
226 | }
227 | 
228 | // Decode the JSON request and verify it.
229 | func verifyJSON(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
230 | 	var echoReq *EchoRequest
231 | 	err := json.NewDecoder(r.Body).Decode(&echoReq)
232 | 	if err != nil {
233 | 		HTTPError(w, err.Error(), "Bad Request", 400)
234 | 		return
235 | 	}
236 | 
237 | 	// Check the timestamp
238 | 	if !echoReq.VerifyTimestamp() && r.URL.Query().Get("_dev") == "" {
239 | 		HTTPError(w, "Request too old to continue (>150s).", "Bad Request", 400)
240 | 		return
241 | 	}
242 | 
243 | 	// Check the app id
244 | 	if !echoReq.VerifyAppID(applications[r.URL.Path].(EchoApplication).AppID) {
245 | 		HTTPError(w, "Echo AppID mismatch!", "Bad Request", 400)
246 | 		return
247 | 	}
248 | 
249 | 	r = r.WithContext(context.WithValue(r.Context(), requestContextKey("echoRequest"), echoReq))
250 | 
251 | 	next(w, r)
252 | }
253 | 
254 | // Run all mandatory Amazon security checks on the request.
255 | func validateRequest(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
256 | 	devFlag := r.URL.Query().Get("_dev")
257 | 	isDev := devFlag != ""
258 | 	if !isDev && !IsValidAlexaRequest(w, r) {
259 | 		log.Println("Request invalid")
260 | 		return
261 | 	}
262 | 	next(w, r)
263 | }
264 | 
265 | // IsValidAlexaRequest handles all the necessary steps to validate that an incoming http.Request has actually come from
266 | // the Alexa service. If an error occurs during the validation process, an http.Error will be written to the provided http.ResponseWriter.
267 | // The required steps for request validation can be found on this page:
268 | // --insecure-skip-verify flag will disable all validations
269 | // https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/developing-an-alexa-skill-as-a-web-service#hosting-a-custom-skill-as-a-web-service
270 | func IsValidAlexaRequest(w http.ResponseWriter, r *http.Request) bool {
271 | 	if insecureSkipVerify {
272 | 		return true
273 | 	}
274 | 	certURL := r.Header.Get("SignatureCertChainUrl")
275 | 
276 | 	// Verify certificate URL
277 | 	if !verifyCertURL(certURL) {
278 | 		HTTPError(w, "Invalid cert URL: "+certURL, "Not Authorized", 401)
279 | 		return false
280 | 	}
281 | 
282 | 	// Fetch certificate data
283 | 	certContents, err := readCert(certURL)
284 | 	if err != nil {
285 | 		HTTPError(w, err.Error(), "Not Authorized", 401)
286 | 		return false
287 | 	}
288 | 
289 | 	// Decode certificate data
290 | 	block, _ := pem.Decode(certContents)
291 | 	if block == nil {
292 | 		HTTPError(w, "Failed to parse certificate PEM.", "Not Authorized", 401)
293 | 		return false
294 | 	}
295 | 
296 | 	cert, err := x509.ParseCertificate(block.Bytes)
297 | 	if err != nil {
298 | 		HTTPError(w, err.Error(), "Not Authorized", 401)
299 | 		return false
300 | 	}
301 | 
302 | 	// Check the certificate date
303 | 	if time.Now().Unix() < cert.NotBefore.Unix() || time.Now().Unix() > cert.NotAfter.Unix() {
304 | 		HTTPError(w, "Amazon certificate expired.", "Not Authorized", 401)
305 | 		return false
306 | 	}
307 | 
308 | 	// Check the certificate alternate names
309 | 	foundName := false
310 | 	for _, altName := range cert.Subject.Names {
311 | 		if altName.Value == "echo-api.amazon.com" {
312 | 			foundName = true
313 | 		}
314 | 	}
315 | 
316 | 	if !foundName {
317 | 		HTTPError(w, "Amazon certificate invalid.", "Not Authorized", 401)
318 | 		return false
319 | 	}
320 | 
321 | 	// Verify the key
322 | 	publicKey := cert.PublicKey
323 | 	encryptedSig, _ := base64.StdEncoding.DecodeString(r.Header.Get("Signature"))
324 | 
325 | 	// Make the request body SHA1 and verify the request with the public key
326 | 	var bodyBuf bytes.Buffer
327 | 	hash := sha1.New()
328 | 	_, err = io.Copy(hash, io.TeeReader(r.Body, &bodyBuf))
329 | 	if err != nil {
330 | 		HTTPError(w, err.Error(), "Internal Error", 500)
331 | 		return false
332 | 	}
333 | 	//log.Println(bodyBuf.String())
334 | 	r.Body = ioutil.NopCloser(&bodyBuf)
335 | 
336 | 	err = rsa.VerifyPKCS1v15(publicKey.(*rsa.PublicKey), crypto.SHA1, hash.Sum(nil), encryptedSig)
337 | 	if err != nil {
338 | 		HTTPError(w, "Signature match failed.", "Not Authorized", 401)
339 | 		return false
340 | 	}
341 | 
342 | 	return true
343 | }
344 | 
345 | func readCert(certURL string) ([]byte, error) {
346 | 	certPool, err := x509.SystemCertPool()
347 | 	if err != nil || certPool == nil {
348 | 		log.Println("Can't open system cert pools")
349 | 	}
350 | 
351 | 	tr := &http.Transport{
352 | 		TLSClientConfig: &tls.Config{RootCAs: certPool, InsecureSkipVerify: insecureSkipVerify},
353 | 	}
354 | 	hc := &http.Client{Timeout: 2 * time.Second, Transport: tr}
355 | 
356 | 	cert, err := hc.Get(certURL)
357 | 	if err != nil {
358 | 		return nil, errors.New("could not download Amazon cert file: " + err.Error())
359 | 	}
360 | 	defer cert.Body.Close()
361 | 	certContents, err := ioutil.ReadAll(cert.Body)
362 | 	if err != nil {
363 | 		return nil, errors.New("could not read Amazon cert file: " + err.Error())
364 | 	}
365 | 
366 | 	return certContents, nil
367 | }
368 | 
369 | func verifyCertURL(path string) bool {
370 | 	link, _ := url.Parse(path)
371 | 
372 | 	if link.Scheme != "https" {
373 | 		return false
374 | 	}
375 | 
376 | 	if link.Host != "s3.amazonaws.com" && link.Host != "s3.amazonaws.com:443" {
377 | 		return false
378 | 	}
379 | 
380 | 	if !strings.HasPrefix(link.Path, "/echo.api/") {
381 | 		return false
382 | 	}
383 | 
384 | 	return true
385 | }
386 | 


--------------------------------------------------------------------------------
/skillserver/echo.go:
--------------------------------------------------------------------------------
  1 | package skillserver
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"time"
  7 | 
  8 | 	"github.com/mikeflynn/go-alexa/skillserver/dialog"
  9 | )
 10 | 
 11 | // ConfirmationStatus represents the status of either a dialog or slot confirmation.
 12 | type ConfirmationStatus string
 13 | 
 14 | const (
 15 | 	// ConfConfirmed indicates the intent or slot has been confirmed by the end user.
 16 | 	ConfConfirmed ConfirmationStatus = "CONFIRMED"
 17 | 
 18 | 	// ConfDenied means the end user indicated the intent or slot should NOT proceed.
 19 | 	ConfDenied ConfirmationStatus = "DENIED"
 20 | 
 21 | 	// ConfNone means there has been not acceptance or denial of the intent or slot.
 22 | 	ConfNone ConfirmationStatus = "NONE"
 23 | )
 24 | 
 25 | // Request Functions
 26 | 
 27 | // VerifyTimestamp will parse the timestamp in the EchoRequest and verify that it is in the correct
 28 | // format and is not too old. True will be returned if the timestamp is valid; false otherwise.
 29 | func (r *EchoRequest) VerifyTimestamp() bool {
 30 | 	reqTimestamp, _ := time.Parse("2006-01-02T15:04:05Z", r.Request.Timestamp)
 31 | 	if time.Since(reqTimestamp) < time.Duration(150)*time.Second {
 32 | 		return true
 33 | 	}
 34 | 
 35 | 	return false
 36 | }
 37 | 
 38 | // VerifyAppID check that the incoming application ID matches the application ID provided
 39 | // when running the server. This is a step required for skill certification.
 40 | func (r *EchoRequest) VerifyAppID(myAppID string) bool {
 41 | 	if r.Session.Application.ApplicationID == myAppID ||
 42 | 		r.Context.System.Application.ApplicationID == myAppID {
 43 | 		return true
 44 | 	}
 45 | 
 46 | 	return false
 47 | }
 48 | 
 49 | // GetSessionID is a convenience method for getting the session ID out of an EchoRequest.
 50 | func (r *EchoRequest) GetSessionID() string {
 51 | 	return r.Session.SessionID
 52 | }
 53 | 
 54 | // GetUserID is a convenience method for getting the user identifier out of an EchoRequest.
 55 | func (r *EchoRequest) GetUserID() string {
 56 | 	return r.Session.User.UserID
 57 | }
 58 | 
 59 | // GetRequestType is a convenience method for getting the request type out of an EchoRequest.
 60 | func (r *EchoRequest) GetRequestType() string {
 61 | 	return r.Request.Type
 62 | }
 63 | 
 64 | // GetIntentName is a convenience method for getting the intent name out of an EchoRequest.
 65 | func (r *EchoRequest) GetIntentName() string {
 66 | 	if r.GetRequestType() == "IntentRequest" {
 67 | 		return r.Request.Intent.Name
 68 | 	}
 69 | 
 70 | 	return r.GetRequestType()
 71 | }
 72 | 
 73 | // GetSlotValue is a convenience method for getting the value of the specified slot out of an EchoRequest
 74 | // as a string. An error is returned if a slot with that value is not found in the request.
 75 | func (r *EchoRequest) GetSlotValue(slotName string) (string, error) {
 76 | 	slot, err := r.GetSlot(slotName)
 77 | 
 78 | 	if err != nil {
 79 | 		return "", err
 80 | 	}
 81 | 
 82 | 	return slot.Value, nil
 83 | }
 84 | 
 85 | // GetSlot will return an EchoSlot from the EchoRequest with the given name.
 86 | func (r *EchoRequest) GetSlot(slotName string) (EchoSlot, error) {
 87 | 	if _, ok := r.Request.Intent.Slots[slotName]; ok {
 88 | 		return r.Request.Intent.Slots[slotName], nil
 89 | 	}
 90 | 
 91 | 	return EchoSlot{}, errors.New("slot name not found")
 92 | }
 93 | 
 94 | // AllSlots will return a map of all the slots in the EchoRequest mapped by their name.
 95 | func (r *EchoRequest) AllSlots() map[string]EchoSlot {
 96 | 	return r.Request.Intent.Slots
 97 | }
 98 | 
 99 | // Locale returns the locale specified in the request.
100 | func (r *EchoRequest) Locale() string {
101 | 	return r.Request.Locale
102 | }
103 | 
104 | // Response Functions
105 | 
106 | // NewEchoResponse will construct a new response instance with the required metadata and an empty speech string.
107 | // By default the response will indicate that the session should be ended. Use the `EndSession(bool)` method if the
108 | // session should be left open.
109 | func NewEchoResponse() *EchoResponse {
110 | 	er := &EchoResponse{
111 | 		Version: "1.0",
112 | 		Response: EchoRespBody{
113 | 			ShouldEndSession: true,
114 | 		},
115 | 		SessionAttributes: make(map[string]interface{}),
116 | 	}
117 | 
118 | 	return er
119 | }
120 | 
121 | // OutputSpeech will replace any existing text that should be spoken with this new value. If the output
122 | // needs to be constructed in steps or special speech tags need to be used, see the `SSMLTextBuilder`.
123 | func (r *EchoResponse) OutputSpeech(text string) *EchoResponse {
124 | 	r.Response.OutputSpeech = &EchoRespPayload{
125 | 		Type: "PlainText",
126 | 		Text: text,
127 | 	}
128 | 
129 | 	return r
130 | }
131 | 
132 | // Card will add a card to the Alexa app's response with the provided title and content strings.
133 | func (r *EchoResponse) Card(title string, content string) *EchoResponse {
134 | 	return r.SimpleCard(title, content)
135 | }
136 | 
137 | // OutputSpeechSSML will add the text string provided and indicate the speech type is SSML in the response.
138 | // This should only be used if the text to speech string includes special SSML tags.
139 | func (r *EchoResponse) OutputSpeechSSML(text string) *EchoResponse {
140 | 	r.Response.OutputSpeech = &EchoRespPayload{
141 | 		Type: "SSML",
142 | 		SSML: text,
143 | 	}
144 | 
145 | 	return r
146 | }
147 | 
148 | // SimpleCard will indicate that a card should be included in the Alexa companion app as part of the response.
149 | // The card will be shown with the provided title and content.
150 | func (r *EchoResponse) SimpleCard(title string, content string) *EchoResponse {
151 | 	r.Response.Card = &EchoRespPayload{
152 | 		Type:    "Simple",
153 | 		Title:   title,
154 | 		Content: content,
155 | 	}
156 | 
157 | 	return r
158 | }
159 | 
160 | // StandardCard will indicate that a card should be shown in the Alexa companion app as part of the response.
161 | // The card shown will include the provided title and content as well as images loaded from the locations provided
162 | // as remote locations.
163 | func (r *EchoResponse) StandardCard(title string, content string, smallImg string, largeImg string) *EchoResponse {
164 | 	r.Response.Card = &EchoRespPayload{
165 | 		Type:    "Standard",
166 | 		Title:   title,
167 | 		Content: content,
168 | 	}
169 | 
170 | 	if smallImg != "" {
171 | 		r.Response.Card.Image.SmallImageURL = smallImg
172 | 	}
173 | 
174 | 	if largeImg != "" {
175 | 		r.Response.Card.Image.LargeImageURL = largeImg
176 | 	}
177 | 
178 | 	return r
179 | }
180 | 
181 | // LinkAccountCard is used to indicate that account linking still needs to be completed to continue
182 | // using the Alexa skill. This will force an account linking card to be shown in the user's companion app.
183 | func (r *EchoResponse) LinkAccountCard() *EchoResponse {
184 | 	r.Response.Card = &EchoRespPayload{
185 | 		Type: "LinkAccount",
186 | 	}
187 | 
188 | 	return r
189 | }
190 | 
191 | // Reprompt will send a prompt back to the user, this could be used to request additional information from the user.
192 | func (r *EchoResponse) Reprompt(text string) *EchoResponse {
193 | 	r.Response.Reprompt = &EchoReprompt{
194 | 		OutputSpeech: EchoRespPayload{
195 | 			Type: "PlainText",
196 | 			Text: text,
197 | 		},
198 | 	}
199 | 
200 | 	return r
201 | }
202 | 
203 | // RepromptSSML is similar to the `Reprompt` method but should be used when the prompt
204 | // to the user should include special speech tags.
205 | func (r *EchoResponse) RepromptSSML(text string) *EchoResponse {
206 | 	r.Response.Reprompt = &EchoReprompt{
207 | 		OutputSpeech: EchoRespPayload{
208 | 			Type: "SSML",
209 | 			Text: text,
210 | 		},
211 | 	}
212 | 
213 | 	return r
214 | }
215 | 
216 | // EndSession is a convenience method for setting the flag in the response that will
217 | // indicate if the session between the end user's device and the skillserver should be closed.
218 | func (r *EchoResponse) EndSession(flag bool) *EchoResponse {
219 | 	r.Response.ShouldEndSession = flag
220 | 
221 | 	return r
222 | }
223 | 
224 | // RespondToIntent is used to Delegate/Elicit/Confirm a dialog or an entire intent with
225 | // user of alexa. The func takes in name of the dialog, updated intent/intent to confirm
226 | // if any and optional slot value. It prepares a Echo Response to be returned.
227 | // Multiple directives can be returned by calling the method in chain
228 | // (eg. RespondToIntent(...).RespondToIntent(...), each RespondToIntent call appends the
229 | // data to Directives array and will return the same at the end.
230 | func (r *EchoResponse) RespondToIntent(name dialog.Type, intent *EchoIntent, slot *EchoSlot) *EchoResponse {
231 | 	directive := EchoDirective{Type: name}
232 | 	if intent != nil && name == dialog.ConfirmIntent {
233 | 		directive.IntentToConfirm = intent.Name
234 | 	} else {
235 | 		directive.UpdatedIntent = intent
236 | 	}
237 | 
238 | 	if slot != nil {
239 | 		if name == dialog.ElicitSlot {
240 | 			directive.SlotToElicit = slot.Name
241 | 		} else if name == dialog.ConfirmSlot {
242 | 			directive.SlotToConfirm = slot.Name
243 | 		}
244 | 	}
245 | 	r.Response.Directives = append(r.Response.Directives, &directive)
246 | 	return r
247 | }
248 | 
249 | func (r *EchoResponse) String() ([]byte, error) {
250 | 	jsonStr, err := json.Marshal(r)
251 | 	if err != nil {
252 | 		return nil, err
253 | 	}
254 | 
255 | 	return jsonStr, nil
256 | }
257 | 
258 | // Request Types
259 | 
260 | // EchoRequest represents all fields sent from the Alexa service to the skillserver.
261 | // Convenience methods are provided to pull commonly used properties out of the request.
262 | type EchoRequest struct {
263 | 	Version string      `json:"version"`
264 | 	Session EchoSession `json:"session"`
265 | 	Request EchoReqBody `json:"request"`
266 | 	Context EchoContext `json:"context"`
267 | }
268 | 
269 | // EchoSession contains information about the ongoing session between the Alexa server and
270 | // the skillserver. This session is stored as part of each request.
271 | type EchoSession struct {
272 | 	New         bool   `json:"new"`
273 | 	SessionID   string `json:"sessionId"`
274 | 	Application struct {
275 | 		ApplicationID string `json:"applicationId"`
276 | 	} `json:"application"`
277 | 	Attributes map[string]interface{} `json:"attributes"`
278 | 	User       struct {
279 | 		UserID      string `json:"userId"`
280 | 		AccessToken string `json:"accessToken,omitempty"`
281 | 	} `json:"user"`
282 | }
283 | 
284 | // EchoContext contains information about the context in which the request was sent.
285 | // This could be information about the device from which the request was sent or about the invoked Alexa application.
286 | type EchoContext struct {
287 | 	System struct {
288 | 		Device struct {
289 | 			DeviceID string `json:"deviceId,omitempty"`
290 | 		} `json:"device,omitempty"`
291 | 		Application struct {
292 | 			ApplicationID string `json:"applicationId,omitempty"`
293 | 		} `json:"application,omitempty"`
294 | 	} `json:"System,omitempty"`
295 | }
296 | 
297 | // EchoReqBody contains all data related to the type of request sent.
298 | type EchoReqBody struct {
299 | 	Type        string     `json:"type"`
300 | 	RequestID   string     `json:"requestId"`
301 | 	Timestamp   string     `json:"timestamp"`
302 | 	Intent      EchoIntent `json:"intent,omitempty"`
303 | 	Reason      string     `json:"reason,omitempty"`
304 | 	Locale      string     `json:"locale,omitempty"`
305 | 	DialogState string     `json:"dialogState,omitempty"`
306 | }
307 | 
308 | // EchoIntent represents the intent that is sent as part of an EchoRequest. This includes
309 | // the name of the intent configured in the Alexa developers dashboard as well as any slots
310 | // and the optional confirmation status if one is needed to complete an intent.
311 | type EchoIntent struct {
312 | 	Name               string              `json:"name"`
313 | 	Slots              map[string]EchoSlot `json:"slots"`
314 | 	ConfirmationStatus ConfirmationStatus  `json:"confirmationStatus"`
315 | }
316 | 
317 | // EchoSlot represents variable values that can be sent that were specified by the end user
318 | // when invoking the Alexa application.
319 | type EchoSlot struct {
320 | 	Name               string             `json:"name"`
321 | 	Value              string             `json:"value"`
322 | 	Resolutions        EchoResolution     `json:"resolutions"`
323 | 	ConfirmationStatus ConfirmationStatus `json:"confirmationStatus"`
324 | }
325 | 
326 | // EchoResolution contains the results of entity resolutions when it relates to slots and how
327 | // the values are resolved. The resolutions will be organized by authority, for custom slots
328 | // the authority will be the custom slot type that was defined.
329 | // Find more information here: https://developer.amazon.com/docs/custom-skills/define-synonyms-and-ids-for-slot-type-values-entity-resolution.html#intentrequest-changes
330 | type EchoResolution struct {
331 | 	ResolutionsPerAuthority []EchoResolutionPerAuthority `json:"resolutionsPerAuthority"`
332 | }
333 | 
334 | // EchoResolutionPerAuthority contains information about a single slot resolution from a single
335 | // authority. The values silce will contain all possible matches for different slots.
336 | // These resolutions are most interesting when working with synonyms.
337 | type EchoResolutionPerAuthority struct {
338 | 	Authority string `json:"authority"`
339 | 	Status    struct {
340 | 		Code string `json:"code"`
341 | 	} `json:"status"`
342 | 	Values []map[string]struct {
343 | 		Name string `json:"name"`
344 | 		ID   string `json:"id"`
345 | 	} `json:"values"`
346 | }
347 | 
348 | // Response Types
349 | 
350 | // EchoResponse represents the information that should be sent back to the Alexa service
351 | // from the skillserver.
352 | type EchoResponse struct {
353 | 	Version           string                 `json:"version"`
354 | 	SessionAttributes map[string]interface{} `json:"sessionAttributes,omitempty"`
355 | 	Response          EchoRespBody           `json:"response"`
356 | }
357 | 
358 | // EchoRespBody contains the body of the response to be sent back to the Alexa service.
359 | // This includes things like the text that should be spoken or any cards that should
360 | // be shown in the Alexa companion app.
361 | type EchoRespBody struct {
362 | 	OutputSpeech     *EchoRespPayload `json:"outputSpeech,omitempty"`
363 | 	Card             *EchoRespPayload `json:"card,omitempty"`
364 | 	Reprompt         *EchoReprompt    `json:"reprompt,omitempty"` // Pointer so it's dropped if empty in JSON response.
365 | 	ShouldEndSession bool             `json:"shouldEndSession"`
366 | 	Directives       []*EchoDirective `json:"directives,omitempty"`
367 | }
368 | 
369 | // EchoReprompt contains speech that should be spoken back to the end user to retrieve
370 | // additional information or to confirm an action.
371 | type EchoReprompt struct {
372 | 	OutputSpeech EchoRespPayload `json:"outputSpeech,omitempty"`
373 | }
374 | 
375 | // EchoRespImage represents a single image with two variants that should be returned as part
376 | // of a response. Small and Large image sizes can be provided.
377 | type EchoRespImage struct {
378 | 	SmallImageURL string `json:"smallImageUrl,omitempty"`
379 | 	LargeImageURL string `json:"largeImageUrl,omitempty"`
380 | }
381 | 
382 | // EchoRespPayload contains the interesting parts of the Echo response including text to be spoken,
383 | // card attributes, and images.
384 | type EchoRespPayload struct {
385 | 	Type    string        `json:"type,omitempty"`
386 | 	Title   string        `json:"title,omitempty"`
387 | 	Text    string        `json:"text,omitempty"`
388 | 	SSML    string        `json:"ssml,omitempty"`
389 | 	Content string        `json:"content,omitempty"`
390 | 	Image   EchoRespImage `json:"image,omitempty"`
391 | }
392 | 
393 | // EchoDirective includes information about intents and slots that should be confirmed or elicted from the user.
394 | // The type value can be used to delegate the action to the Alexa service. In this case, a pre-configured prompt
395 | // will be used from the developer console.
396 | type EchoDirective struct {
397 | 	Type            dialog.Type `json:"type"`
398 | 	UpdatedIntent   *EchoIntent `json:"updatedIntent,omitempty"`
399 | 	SlotToConfirm   string      `json:"slotToConfirm,omitempty"`
400 | 	SlotToElicit    string      `json:"slotToElicit,omitempty"`
401 | 	IntentToConfirm string      `json:"intentToConfirm,omitempty"`
402 | }
403 | 


--------------------------------------------------------------------------------