Desenvolvendo skills da Alexa com MongoDB e Golang

1
Alexa, ask Recipe Manager to INTENT

1
what ingredients do i need for {recipe}
2
what do i need to cook {recipe}
3
to cook {recipe} what ingredients do i need

1
Alexa, ask Recipe Manager what do I need to cook Chocolate Chip Cookies

1
what can i cook with {ingredientone} and {ingredienttwo}
2
what are some recipes with {ingredientone} and {ingredienttwo}
3
if i have {ingredientone} and {ingredienttwo} what can i cook

1
package main
2
3
func main() { }

1
dep init
2
dep ensure -add "go.mongodb.org/mongo-driver/mongo"

1
dep ensure -add "github.com/arienmalec/alexa-go"
2
dep ensure -add "github.com/aws/aws-lambda-go/lambda"

1
package main
2
3
import (
4
    "context"
5
    "os"
6
7
    "go.mongodb.org/mongo-driver/mongo"
8
    "go.mongodb.org/mongo-driver/mongo/options"
9
)
10
11
// Stores a handle to the collection being used by the Lambda function
12
type Connection struct {
13
    collection *mongo.Collection
14
}
15
16
func main() {
17
    ctx := context.Background()
18
    client, err := mongo.Connect(ctx, options.Client().ApplyURI(os.Getenv("ATLAS_URI")))
19
    if err != nil {
20
        panic(err)
21
    }
22
23
    defer client.Disconnect(ctx)
24
25
    connection := Connection{
26
        collection: client.Database("alexa").Collection("recipes"),
27
    }
28
}

1
package main
2
3
import (
4
    "context"
5
    "os"
6
7
    "github.com/arienmalec/alexa-go"
8
    "github.com/aws/aws-lambda-go/lambda"
9
    "go.mongodb.org/mongo-driver/mongo"
10
    "go.mongodb.org/mongo-driver/mongo/options"
11
)
12
13
// Stores a handle to the collection being used by the Lambda function
14
type Connection struct {
15
    collection *mongo.Collection
16
}
17
18
func (connection Connection) IntentDispatcher(ctx context.Context, request alexa.Request) (alexa.Response, error) {
19
    // Alexa logic here...
20
}
21
22
func main() {
23
    ctx := context.Background()
24
    client, err := mongo.Connect(ctx, options.Client().ApplyURI(os.Getenv("ATLAS_URI")))
25
    if err != nil {
26
        panic(err)
27
    }
28
29
    defer client.Disconnect(ctx)
30
31
    connection := Connection{
32
        collection: client.Database("alexa").Collection("recipes"),
33
    }
34
35
    lambda.Start(connection.IntentDispatcher)
36
}

1
{
2
    "_id": ObjectID("234232358943"),
3
    "name": "chocolate chip cookies",
4
    "ingredients": [
5
        "flour",
6
        "egg",
7
        "sugar",
8
        "chocolate"
9
    ]
10
}

1
// A data structure representation of the collection schema
2
type Recipe struct {
3
    ID          primitive.ObjectID `bson:"_id"`
4
    Name        string             `bson:"name"`
5
    Ingredients []string           `bson:"ingredients"`
6
}

1
func (connection Connection) IntentDispatcher(ctx context.Context, request alexa.Request) (alexa.Response, error) {
2
    var response alexa.Response
3
    switch request.Body.Intent.Name {
4
    case "GetIngredientsForRecipeIntent":
5
    case "GetRecipeFromIngredientsIntent":
6
    default:
7
        response = alexa.NewSimpleResponse("Unknown Request", "The intent was unrecognized")
8
    }
9
    return response, nil
10
}

1
case "GetIngredientsForRecipeIntent":
2
    var recipe Recipe
3
    recipeName := request.Body.Intent.Slots["recipe"].Value
4
    if recipeName == "" {
5
        return alexa.Response{}, errors.New("Recipe name is not present in the request")
6
    }
7
    if err := connection.collection.FindOne(ctx, bson.M{"name": recipeName}).Decode(&recipe); err != nil {
8
        return alexa.Response{}, err
9
    }
10
    response = alexa.NewSimpleResponse("Ingredients", strings.Join(recipe.Ingredients, ", "))

1
case "GetRecipeFromIngredientsIntent":
2
    var recipes []Recipe
3
    ingredient1 := request.Body.Intent.Slots["ingredientone"].Value
4
    ingredient2 := request.Body.Intent.Slots["ingredienttwo"].Value
5
    cursor, err := connection.collection.Find(ctx, bson.M{
6
        "ingredients": bson.D{
7
            {"$all", bson.A{ingredient1, ingredient2}},
8
        },
9
    })
10
    if err != nil {
11
        return alexa.Response{}, err
12
    }
13
    if err = cursor.All(ctx, &recipes); err != nil {
14
        return alexa.Response{}, err
15
    }
16
    var recipeList []string
17
    for _, recipe := range recipes {
18
        recipeList = append(recipeList, recipe.Name)
19
    }
20
    response = alexa.NewSimpleResponse("Recipes", strings.Join(recipeList, ", "))

1
GOOS=linux go build
2
zip handler.zip ./project-name

1
ask recipe manager what can i cook with flour and sugar
2
ask recipe manager what chocolate chip cookies requires