Handle user input with ASR

const Express = require('express');
const bodyParser = require('body-parser');

const app = new Express();
app.use(bodyParser.json());

const onInboundCall = (request, response) => {
  const ncco = [
    {
      action: 'talk',
      text: 'Please say something',
    },
    {
      action: 'input',
      type: ['speech'],
      eventUrl: [`${request.protocol}://${request.get('host')}/webhooks/asr`],
      speech: {
        endOnSilence: 1,
        language: 'en-US',
        uuid: [request.query.uuid],
      },
    },
  ];

  response.json(ncco);
};

const onInput = (request, response) => {
  const speech = request.body?.speech?.results[0]?.text;

  const ncco = [
    {
      action: 'talk',
      text: `You said ${speech}`,
    },
  ];

  response.json(ncco);
};

app
  .get('/webhooks/answer', onInboundCall)
  .post('/webhooks/asr', onInput);

app.listen(3000);

embeddedServer(Netty, port = 8000) {
    routing {
        get("/webhooks/answer") {
            call.response.header("Content-Type", "application/json")
            call.respond(
                Ncco(
                    talkAction("Please say something."),
                    inputAction {
                        eventUrl(call.request.path().replace("answer", "asr"))
                        speech {
                            language(SpeechSettings.Language.ENGLISH_UNITED_STATES)
                        }
                    }
                ).toJson()
            )
        }
        post("/webhooks/asr") {
            val event = EventWebhook.fromJson(call.receive())
            call.response.header("Content-Type", "application/json")
            call.respond(
                Ncco(
                    talkAction("You said: "+event.speech.results.first().text),
                ).toJson()
            )
        }
    }
}.start(wait = true)

apply plugin: 'application'
mainClassName = project.hasProperty('main') ? project.getProperty('main') : ''

/*
 * Route to answer incoming calls.
 */
Route answerCallRoute = (req, res) -> {
    TalkAction intro = TalkAction
            .builder("Please say something")
            .build();

    SpeechSettings speechSettings = SpeechSettings.builder()
            .language(SpeechSettings.Language.ENGLISH_UNITED_STATES).build();

    InputAction input = InputAction.builder()
            .type(Collections.singletonList("speech"))
            .eventUrl(String.format("%s://%s/webhooks/asr", req.scheme(), req.host()))
            .speech(speechSettings)
            .build();


    res.type("application/json");

    return new Ncco(intro, input).toJson();
};

/*
 * Route which returns NCCO saying which word was recognized.
 */
Route speechInputRoute = (req, res) -> {
    EventWebhook event = EventWebhook.fromJson(req.body());

    TalkAction response = TalkAction.builder(String.format("You said %s, Goodbye.",
            event.getSpeech().getResults().get(0).getText()
    )).build();
    res.type("application/json");

    return new Ncco(response).toJson();
};

Spark.port(3000);
Spark.get("/webhooks/answer", answerCallRoute);
Spark.post("/webhooks/asr", speechInputRoute);

apply plugin: 'application'
mainClassName = project.hasProperty('main') ? project.getProperty('main') : ''

[HttpGet("[controller]/webhooks/answer")]
public IActionResult Answer()
{
    var host = Request.Host.ToString();
    //Uncomment the next line if using ngrok with --host-header option
    //host = Request.Headers["X-Original-Host"];

    var request = WebhookParser.ParseQuery<Answer>(Request.Query);
    var eventUrl = $"{Request.Scheme}://{host}/webhooks/asr";
    var speechSettings = new SpeechSettings { Language = "en-US", EndOnSilence = 1, Uuid = new[] { request.Uuid } };
    var inputAction = new MultiInputAction { Speech = speechSettings, EventUrl = new[] { eventUrl } };

    var talkAction = new TalkAction { Text = "Please speak now" };

    var ncco = new Ncco(talkAction, inputAction);
    return Ok(ncco.ToString());
}

[HttpPost("/webhooks/asr")]
public async Task<IActionResult> OnInput()
{            
    var input = await WebhookParser.ParseWebhookAsync<MultiInput>(Request.Body, Request.ContentType);
    var talkAction = new TalkAction();
    talkAction.Text = input.Speech.SpeechResults[0].Text;
    var ncco = new Ncco(talkAction);
    return Ok(ncco.ToString());
}

use Vonage\Voice\NCCO\Action\Talk;
use Vonage\Voice\NCCO\Action\Input;
use \Psr\Http\Message\ResponseInterface as Response;
use \Psr\Http\Message\ServerRequestInterface as Request;

require 'vendor/autoload.php';

$app = new \Slim\App;

$app->get('/webhooks/answer', function (Request $request, Response $response) {
    $uri = $request->getUri();
    $url = $uri->getScheme().'://'.$uri->getHost().':'.$uri->getPort().'/webhooks/asr';

    $inputAction = new Input();
    $inputAction
        ->setSpeechEndOnSilence(true)
        ->setSpeechLanguage('en-US')
        ->setEventWebhook(new Webhook($url))
    ;
    $ncco = new NCCO();
    $ncco
        ->addAction(new Talk('Please say something'))
        ->addAction($inputAction)
    ;

    return $response->withJson($ncco->toArray());
});

$app->map(['GET', 'POST'], '/webhooks/asr', function (Request $request, Response $response) {
    /** @var InputWebhook $input */
    $input = Factory::createFromRequest($request);

    $ncco = new NCCO();
    $ncco->addAction(new Talk('You said ' . $input->getSpeech()['results'][0]['text']));

    return $response->withJson($ncco->toArray());
});

$app->run();

#!/usr/bin/env python3
from flask import Flask, request, jsonify

app = Flask(__name__)


@app.route("/webhooks/answer", methods=["POST", "GET"])
def answer_call():
    ncco = [
        {"action": "talk", "text": "Please, tell me something",},
        {
            "action": "input",
            "type": ["speech"],
            "eventUrl": [
                "{host}{endpoint}".format(
                    host=request.host_url, endpoint="webhooks/asr"
                )
            ],
            "speech": {
                "endOnSilence": 1,
                "language": "en-US",
                "uuid": [request.args.get("uuid")], # Change to request.json.get("uuid") if using POST-JSON webhook format
            },
        },
    ]
    return jsonify(ncco)


@app.route("/webhooks/asr", methods=["POST", "GET"])
def answer_asr():
    body = request.get_json()
    if body is not None and "speech" in body:
        speech = body["speech"]["results"][0]["text"]
        ncco = [
            {"action": "talk", "text": "Hello ,you said {speech}".format(speech=speech)}
        ]
    else:
        ncco = [{"action": "talk", "text": "Sorry, i don't undertand. Bye"}]

    return jsonify(ncco)


if __name__ == "__main__":
    app.run(port=3000)

require 'sinatra'
require 'sinatra/multi_route'
require 'rack/contrib'

use Rack::JSONBodyParser

before do
  content_type :json
end

route :get, :post, '/webhooks/answer' do
  [
    {
      action: 'talk',
      text: 'Please say something'
    },
    {
      action: 'input',
      type: [ 'speech' ],
      eventUrl: ["#{request.base_url}/webhooks/asr"],
      speech: {
        endOnSilence: 1,
        uuid: [params[:uuid]],
        language: 'en-US'
      }
    }
  ].to_json
end

route :post, '/webhooks/asr' do
  [{
    action: 'talk',
    text: "You said #{params["speech"]["results"][0]["text"]}"
  }].to_json
end

route :post, '/webhooks/event' do
  puts params
end

set :port, 3000