Track NCCO progress

const Express = require('express');
const app = new Express();

const onInboundCall = (request, response) => {
  const ncco = [
    {
      'action': 'talk',
      'text': 'Thanks for calling the notification line',
    },
    {
      'action': 'notify',
      'payload': {
        'foo': 'bar',
      },
      'eventUrl': [`${request.protocol}://${request.get('host')}/webhooks/notification`],
    },
    {
      'action': 'talk',
      'text': 'You will never hear me as the notification URL will return an NCCO ',
    },
  ];

  response.json(ncco);
};

const onNotification = (request, response) => {
  const ncco = [
    {
      'action': 'talk',
      'text': 'Your notification has been received, loud and clear',
    },
  ];

  response.json(ncco);
};

app
  .get('/webhooks/answer', onInboundCall)
  .post('/webhooks/notification', onNotification);

app.listen(3000);

embeddedServer(Netty, port = 8000) {
    routing {
        get("/webhooks/answer") {
            call.response.header("Content-Type", "application/json")
            call.respond(
                Ncco(
                    talkAction("Thanks for calling the notification line."),
                    notifyAction(
                        call.request.path().replace("answer", "notification"),
                        mapOf("foo" to "bar")
                    ),
                    talkAction("You will never hear me as the notification URL will return an NCCO")
                ).toJson()
            )
        }
        post("/webhooks/notification") {
            val event = EventWebhook.fromJson(call.receive())
            call.response.header("Content-Type", "application/json")
            call.respond(
                Ncco(
                    talkAction("Your notification has been received, loud and clear."),
                ).toJson()
            )
        }
    }
}.start(wait = true)

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

/*
 * Answer Route
 */
get("/webhooks/answer", (req, res) -> {
    String notifyUrl = String.format("%s://%s/webhooks/notification", req.scheme(), req.host());

    TalkAction intro = TalkAction.builder("Thanks for calling the notification line.")
            .build();

    Map<String, String> payload = new HashMap<>();
    payload.put("foo", "bar");

    NotifyAction notify = NotifyAction.builder(payload)
            .eventUrl(notifyUrl)
            .build();

    TalkAction unheard = TalkAction.builder("You will never hear me as the notification URL will return an NCCO")
            .build();

    res.type("application/json");
    return new Ncco(intro, notify, unheard).toJson();
});

/*
 * Notification Route
 */
post("/webhooks/notification", (req, res) -> {
    res.type("application/json");
    return new Ncco(
            TalkAction.builder("Your notification has been received, loud and clear.")
                    .build()
    ).toJson();
});

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 eventUrl = $"{Request.Scheme}://{host}/webhooks/notification";

    var talkAction = new TalkAction() { Text = "Thanks for calling the notification line" };
    var notifyAction = new NotifyAction()
    {
        EventUrl = new[] { eventUrl },
        Payload = new FooBar() { Foo = "bar" }
    };
    var talkAction2 = new TalkAction() { Text = "You will never hear me as the notification URL will return an NCCO" };
    var ncco = new Ncco(talkAction, notifyAction, talkAction2);
    return Ok(ncco.ToString());
}

[HttpPost("webhooks/notification")]
public async Task<IActionResult> Notify()
{
    var notification = await WebhookParser.ParseWebhookAsync<Notification<FooBar>>(Request.Body, Request.ContentType);
    Console.WriteLine($"Notification received payload's foo = {notification.Payload.Foo}");
    var talkAction = new TalkAction() { Text = "Your notification has been received, loud and clear" };
    var ncco = new Ncco(talkAction);
    return Ok(ncco.ToString());
}

require 'vendor/autoload.php';

$app = new \Slim\App();

$app->get('/webhooks/answer', function (Request $request, Response $response) {
    //Get our public URL for this route
    $uri = $request->getUri();
    $url = $uri->getScheme() . '://'.$uri->getHost() . ($uri->getPort() ? ':'.$uri->getPort() : '') . '/webhooks/notification';

    $notify = new \Vonage\Voice\NCCO\Action\Notify(
        ['foo' => 'bar'],
        new \Vonage\Voice\Webhook($url, 'GET')
    );

    $ncco = new \Vonage\Voice\NCCO\NCCO();
    $ncco
        ->addAction(
            new \Vonage\Voice\NCCO\Action\Talk('Thanks for calling the notification line')
        )
        ->addAction($notify)
        ->addAction(
            new \Vonage\Voice\NCCO\Action\Talk('You will never hear me as the notification URL will return an NCCO')
        )
    ;

    return new JsonResponse($ncco);
});

$app->map(['GET', 'POST'], '/webhooks/notification', function (Request $request, Response $response) {
    /** @var \Vonage\Voice\Webhook\Event */
    $event = \Vonage\Voice\Webhook\Factory::createFromRequest($request);
    error_log(print_r($event, true));

    $ncco = new \Vonage\Voice\NCCO\NCCO();
    $ncco->addAction(
        new \Vonage\Voice\NCCO\Action\Talk('Your notification has been received, loud and clear')
    );

    return new JsonResponse($ncco);
});

$app->map(['GET', 'POST'], '/webhooks/event', function (Request $request, Response $response) {
    /** @var \Vonage\Voice\Webhook\Event */
    $event = \Vonage\Voice\Webhook\Factory::createFromRequest($request);
    error_log(print_r($event, true));

    return $response->withStatus(204);
});

$app->run();

from flask import Flask, request, jsonify

app = Flask(__name__)


@app.route("/webhooks/answer")
def answer_call():
    ncco = [{
        "action": "talk",
        "text": "Thanks for calling the notification line"
    },
        {
            "action": "notify",
            "payload": {
                "foo": "bar"
            },
            "eventUrl": [
                "{url_root}webhooks/notification".format(url_root=request.url_root)
            ]
        },
        {
            "action": "talk",
            "text": "You will never hear me as the notification URL will return an NCCO "
        }]
    return jsonify(ncco)


@app.route("/webhooks/notification", methods=['POST'])
def notification():
    ncco = [{
        "action": "talk",
        "text": "Your notification has been received, loud and clear"
    }]
    return jsonify(ncco)


@app.route("/webhooks/event", methods=['POST'])
def event():
    return "OK"

use Rack::PostBodyContentTypeParser

before do
  content_type :json
end

route :get, :post, '/webhooks/answer' do
  [
    {
      'action' => 'talk',
      'text' => 'Thanks for calling the notification line'
    },
    {
      'action' => 'notify',
      'payload' => {'foo' => 'bar'},
      'eventUrl' => ["#{request.base_url}/webhooks/notification"]
    },
    {
      'action' => 'talk',
      'text' => 'You will never hear me as the notification URL will return an NCCO'
    }
  ].to_json
end

route :get, :post, '/webhooks/notification' do
  puts params
  [
    {
      'action' => 'talk',
      'text' => 'Your notification has been received, loud and clear'
    }
  ].to_json
end

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

set :port, 3000