Actualizar solicitud

En este fragmento de código verá cómo actualizar una Application.

Ejemplo

Tendrá que asegurarse de que los siguientes valores reemplazables se establecen en el código de ejemplo utilizando cualquier método conveniente:

Clave	Descripción
`VONAGE_API_KEY`	Your Vonage API key (see it on your dashboard).
`VONAGE_API_SECRET`	Your Vonage API secret (also available on your dashboard).
`VONAGE_APPLICATION_ID`	The Vonage Application ID.
`NAME`	The new name for the Vonage application you want to update.

Escriba el código

Añada lo siguiente a update-application.sh:

curl -X "PUT" "https://api.nexmo.com/v2/applications/$VONAGE_APPLICATION_ID" \
     -H 'Content-Type: application/json' \
     -u "$VONAGE_API_KEY:$VONAGE_API_SECRET" \
     -d $'{
  "name": "New App Name",
  "capabilities": {
    "messages": {
      "webhooks": {
        "inbound_url": {
          "address": "https://example.com/webhooks/inbound",
          "http_method": "POST"
        },
        "status_url": {
          "address": "https://example.com/webhooks/status",
          "http_method": "POST"
        }
      }
    },
    "voice": {
      "webhooks": {
        "answer_url": {
          "address": "https://example.com/webhooks/answer",
          "http_method": "POST"
        },
        "event_url": {
          "address": "https://example.com/webhooks/event",
          "http_method": "POST"
        }
      }
    },
    "rtc": {
      "webhooks": {
        "event_url": {
          "address": "https://example.com/webhooks/event",
          "http_method": "POST"
        }
      }
    },
    "vbc": {},
    "verify": {
      "webhooks": {
        "status_url": {

Ver fuente completa

Ejecute su código

Guarde este archivo en su máquina y ejecútelo:

./update-application.sh

Requisitos previos

npm install @vonage/server-sdk

Crea un archivo llamado update-application.js y añade el siguiente código:

const { Vonage } = require('@vonage/server-sdk');

const vonage = new Vonage({
  apiKey: VONAGE_API_KEY,
  apiSecret: VONAGE_API_SECRET,
});

Ver fuente completa

Escriba el código

Añada lo siguiente a update-application.js:

vonage.applications.updateApplication({
  id: VONAGE_APPLICATION_ID,
  name: 'New App Name',
  capabilities: {
    messages: {
      webhooks: {
        inboundUrl: {
          address: 'https://example.com/webhooks/inbound',
          httpMethod: 'POST',
        },
        statusUrl: {
          address: 'https://example.com/webhooks/status',
          httpMethod: 'POST',
        },
      },
    },
    voice: {
      webhooks: {
        answerUrl: {
          address: 'https://example.com/webhooks/answer',
          httpMethod: 'POST',
        },
        eventUrl: {
          address: 'https://example.com/webhooks/event',
          httpMethod: 'POST',
        },
      },
    },
    rtc: {
      webhooks: {
        eventUrl: {
          address: 'https://example.com/webhooks/event',
          httpMethod: 'POST',
        },
      },
    },
    vbc: {},
    verify: {
      webhooks: {
        statusUrl: {
          address: 'https://example.com/webhooks/status',
          httpMethod: 'POST',
        },
      },
    },
  },
})
  .then((resp) => console.log(resp))
  .catch((error) => console.error(error));

Ver fuente completa

Ejecute su código

Guarde este archivo en su máquina y ejecútelo:

node update-application.js

Requisitos previos

Añada lo siguiente a build.gradle:

implementation 'com.vonage:server-sdk-kotlin:2.1.1'

Crea un archivo llamado UpdateApplication y añade el siguiente código al método main:

val client = Vonage {
    apiKey(VONAGE_API_KEY)
    apiSecret(VONAGE_API_SECRET)
}

Ver fuente completa

Escriba el código

Añada lo siguiente al método main del archivo UpdateApplication:

val application = client.application.application(VONAGE_APPLICATION_ID).update {
    name(APPLICATION_NAME)
    messages {
        inbound {
            address("https://example.com/webhooks/inbound")
            method(HttpMethod.POST)
        }
        status {
            address("https://example.com/webhooks/status")
            method(HttpMethod.POST)
        }
    }
    voice {
        answer {
            address("https://example.com/webhooks/answer")
            method(HttpMethod.GET)
        }
        event {
            address("https://example.com/webhooks/event")
            method(HttpMethod.POST)
        }
        rtc {
            event {
                address("https://example.com/webhooks/event")
                method(HttpMethod.POST)
            }
        }
        vbc()
    }
}

Ver fuente completa

Ejecute su código

Podemos utilizar el plugin aplicación para Gradle para simplificar la ejecución de nuestra aplicación. Actualiza tu build.gradle con lo siguiente:

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

Ejecute el siguiente comando gradle para ejecutar su aplicación, sustituyendo com.vonage.quickstart.kt.application por el paquete que contiene UpdateApplication:

gradle run -Pmain=com.vonage.quickstart.kt.application.UpdateApplication

Requisitos previos

Añada lo siguiente a build.gradle:

implementation 'com.vonage:server-sdk:9.3.1'

Crea un archivo llamado UpdateApplication y añade el siguiente código al método main:

VonageClient client = VonageClient.builder()
        .apiKey(VONAGE_API_KEY)
        .apiSecret(VONAGE_API_SECRET)
        .build();

Ver fuente completa

Escriba el código

Añada lo siguiente al método main del archivo UpdateApplication:

ApplicationClient applicationClient = client.getApplicationClient();
Application existingApplication = applicationClient.getApplication(VONAGE_APPLICATION_ID);

Capability messages = Messages.builder()
        .inbound(Webhook.builder()
                .address("https://example.com/webhooks/inbound")
                .method(HttpMethod.POST)
                .build()
        )
        .status(Webhook.builder()
                .address("https://example.com/webhooks/status")
                .method(HttpMethod.POST)
                .build()
        )
        .build();

Capability voice = Voice.builder()
        .answer(Webhook.builder()
                .address("https://example.com/webhooks/answer")
                .method(HttpMethod.POST)
                .build()
        )
        .event(Webhook.builder()
                .address("https://example.com/webhooks/event")
                .method(HttpMethod.POST)
                .build()
        )
        .build();

Capability rtc = Rtc.builder()
        .event(Webhook.builder()
                .address("https://example.com/webhooks/event")
                .method(HttpMethod.POST)
                .build()
        )
        .build();

Capability vbc = Vbc.builder().build();

Application application = applicationClient.updateApplication(
        Application.builder(existingApplication)
                .name(APPLICATION_NAME)
                .addCapability(messages)
                .addCapability(voice)
                .addCapability(rtc)
                .addCapability(vbc)
                .build()
);

System.out.println("Application Updated:");
System.out.println("Old: " + existingApplication.toJson());
System.out.println("New: " + application.toJson());

Ver fuente completa

Ejecute su código

Podemos utilizar el plugin aplicación para Gradle para simplificar la ejecución de nuestra aplicación. Actualiza tu build.gradle con lo siguiente:

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

Ejecute el siguiente comando gradle para ejecutar su aplicación, sustituyendo com.vonage.quickstart.application por el paquete que contiene UpdateApplication:

gradle run -Pmain=com.vonage.quickstart.application.UpdateApplication

Requisitos previos

Install-Package Vonage

Crea un archivo llamado UpdateApplication.cs y añade el siguiente código:

using Vonage;
using Vonage.Applications;
using Vonage.Applications.Capabilities;
using Vonage.Request;

Ver fuente completa

Añada lo siguiente a UpdateApplication.cs:

var credentials = Credentials.FromApiKeyAndSecret(VONAGE_API_KEY, VONAGE_API_SECRET);
var client = new VonageClient(credentials);

Ver fuente completa

Escriba el código

Añada lo siguiente a UpdateApplication.cs:

var request = new CreateApplicationRequest
{
    Name = "New App Name",
    Capabilities = new ApplicationCapabilities
    {
        Messages = Vonage.Applications.Capabilities.Messages.Build()
            .WithInboundUrl("https://example.com/webhooks/inbound")
            .WithStatusUrl("https://example.com/webhooks/status"),
        Rtc = Rtc.Build().WithEventUrl("https://example.com/webhooks/events", WebhookHttpMethod.Post),
        Voice = Vonage.Applications.Capabilities.Voice.Build()
            .WithAnswerUrl("https://example.com/webhooks/answer", WebhookHttpMethod.Get)
            .WithEventUrl("https://example.com/webhooks/events", WebhookHttpMethod.Post),
        Vbc = Vbc.Build()
    }
};
var response = await client.ApplicationClient.UpdateApplicationAsync(VONAGE_APPLICATION_ID, request);

Ver fuente completa

Requisitos previos

composer require vonage/client

Crea un archivo llamado update-application.php y añade el siguiente código:

$basic  = new \Vonage\Client\Credentials\Basic(VONAGE_API_KEY, VONAGE_API_SECRET);
$client = new \Vonage\Client(new \Vonage\Client\Credentials\Container($basic));

Ver fuente completa

Escriba el código

Añada lo siguiente a update-application.php:

try {
    $application = $client->applications()->get(VONAGE_APPLICATION_ID);
    $application->setName('New Name2');
    $application->getVoiceConfig()->setWebhook(
        Nexmo\Application\VoiceConfig::ANSWER,
        new Nexmo\Application\Webhook('http://test.domain/webhook/voice')
    );
    $application = $client->applications()->update($application);

    echo $application->getId() . PHP_EOL;
    echo $application->getName() . PHP_EOL;
} catch (\InvalidArgumentException $e) {
    echo $e->getMessage() . PHP_EOL;
}

Ver fuente completa

Ejecute su código

Guarde este archivo en su máquina y ejecútelo:

php update-application.php

Requisitos previos

pip install vonage python-dotenv

Escriba el código

Añada lo siguiente a update-application.py:

from vonage import Auth, Vonage
from vonage_application import (ApplicationConfig, ApplicationData,
                                ApplicationUrl, Messages, MessagesWebhooks)

client = Vonage(Auth(api_key=VONAGE_API_KEY, api_secret=VONAGE_API_SECRET))

config = ApplicationConfig(
    name='My Renamed Application',
    capabilities=Messages(
        webhooks=MessagesWebhooks(
            inbound_url=ApplicationUrl(
                address='https://example.com/inbound_new_url', http_method='GET'
            ),
            status_url=ApplicationUrl(
                address='https://example.com/status_new_url', http_method='GET'
            ),
        ),
        authenticate_inbound_media=False,
    ),
)
response: ApplicationData = client.application.update_application(
    id=VONAGE_APPLICATION_ID, config=config
)

print(response)

Ver fuente completa

Ejecute su código

Guarde este archivo en su máquina y ejecútelo:

python application/update-application.py

Requisitos previos

gem install vonage

Crea un archivo llamado update-application.rb y añade el siguiente código:

Ver fuente completa

Escriba el código

Añada lo siguiente a update-application.rb:

Ver fuente completa

Ejecute su código

Guarde este archivo en su máquina y ejecútelo:

ruby update-application.rb