Программистам

def handler(event, context):
    """
    Entry-point for Serverless Function.
    :param event: request payload.
    :param context: information about current execution context.
    :return: response to be serialized as JSON.
    """
    text = "Hello! I\'ll repeat anything you say to me."
    if "request" in event and \
            "original_utterance" in event["request"] \
            and len(event["request"]["original_utterance"]) > 0:
        text = event["request"]["original_utterance"]
    return {
        "version": event["version"],
        "session": event["session"],
        "response": {
            "text": text,
            "end_session": "false"
        },
    }

<?php

function handler($event, $context) {
    $version = $event["version"];
    $session = $event["session"];
    $request = $event["request"];

    $text = "Hello! I'll repeat anything you say to me.";
    if (strlen($request["original_utterance"]) > 0) {
        $text = $request["original_utterance"];
    }

    return array(
        "version" => $version,
        "session" => $session,
        "response" => array(
            "text" => $text,
            "end_session" => false
        )
    );
}

handler <- function(event, context) {
    version <- event$version
    session <- event$session
    request <- event$request

    text <- "Hello! I\'ll repeat anything you say to me."

    if (nchar(request[["original_utterance"]]) > 0) {
        text <- request[["original_utterance"]]
    }

    return(list(
        version = version,
        session = session,
        response = list(
            text = text,
            end_session = FALSE
        )
    ))
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
)

type Event struct {
    Version string   `json:"version"`
    Session struct{} `json:"session"`
    Request struct {
        OriginalUtterance string `json:"original_utterance"`
    } `json:"request"`
}

type Response struct {
    Version string   `json:"version"`
    Session struct{} `json:"session"`
    Result  struct {
        Text      string `json:"text"`
        EndSession bool   `json:"end_session"`
    } `json:"response"`
}

func Handler(ctx context.Context, event []byte) (*Response, error) {
    var input Event
    err := json.Unmarshal(event, &input)
    if err != nil {
        return nil, fmt.Errorf("an error has occurred when parsing event: %v", err)
    }

    text := "Hello! I'll repeat anything you say to me."
    if input.Request.OriginalUtterance != "" {
        text = input.Request.OriginalUtterance
    }

    return &Response{
        Version: input.Version,
        Session: input.Session,
        Result: struct {
            Text      string `json:"text"`
            EndSession bool   `json:"end_session"`
        }{
            Text:      text,
            EndSession: false,
        },
    }, nil
}

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

class Request {
  Map<String, String> queryStringParameters;
  Map<String, Object> request;
  Object version;
  Object session;
}

class Response {
  private Object version;
  private Object session;
  private Map<String, Object> response;

    public Response(Object version, Object session, Map<String, Object> response) {
        this.version = version;
        this.session = session;
        this.response = response;
    }
}

public class Handler implements Function<Request, Response> {

    @Override
    public Response apply(Request request) {
        Map<String, Object> response = new HashMap<>();

        Object version = request.version;
        Object session = request.session;
        String originalUtterance = (String) request.request.get("original_utterance");
        String text = "Hello! I'll repeat anything you say to me.";

        if (originalUtterance != null && originalUtterance.length() > 0) {
            text = originalUtterance;
        }

        response.put("text", text);
        response.put("end_session", false);

        return new Response(version, session, response);
    }
}

using System;
using System.Text.Json;

public class Request
{
    public string version { get; set; }
    public JsonElement session { get; set; }
    public JsonElement request { get; set; }
}

public class Response
{
    public string version { get; set; }
    public JsonElement session { get; set; }
    public object response { get; set; }

    public Response(string version, JsonElement session, object response)
    {
        this.version = version;
        this.session = session;
        this.response = response;
    }
}

public class Handler
{
    public Response FunctionHandler(Request r)
    {
        string version = r.version;
        JsonElement session = r.session;
        JsonElement request = r.request;

        string text = "Hello! I'll repeat anything you say to me.";
        if (request.GetProperty("original_utterance").ToString().Length > 0)
            text = request.GetProperty("original_utterance").ToString();

        var responseObj = new
        {
            text = text,
            end_session = false,
        };

        return new Response(version, session, responseObj);
    }
}