Compartir a través de

Inicio rápido: Envío de trabajos para su puesta en cola y enrutamiento

  • Artículo

Empiece a trabajar con el enrutador de trabajos de Azure Communication Services mediante la configuración del cliente y, después, configure la funcionalidad básica, como colas, directivas, roles de trabajo, y trabajos. Para más información sobre los conceptos del enrutador de trabajos, consulte la documentación conceptual del enrutador de trabajos.

Requisitos previos

Código de ejemplo

Puede revisar y descargar el código de ejemplo de este inicio rápido en GitHub.

Instalación

Creación de una aplicación de C#

En una ventana de consola (por ejemplo, cmd, PowerShell o Bash), use el comando dotnet new para crear una nueva aplicación de consola con el nombre JobRouterQuickstart. Este comando crea un sencillo proyecto "Hola mundo" de C# con un solo archivo de origen: Program.cs.

dotnet new console -o JobRouterQuickstart

Cambie el directorio a la carpeta de la aplicación recién creada y use el comando dotnet build para compilar la aplicación.

cd JobRouterQuickstart
dotnet build

Instalar el paquete

Instale la biblioteca cliente del enrutador de trabajos de Azure Communication para .NET con NuGet:

dotnet add package Azure.Communication.JobRouter

Deberá usar la biblioteca cliente del enrutador de trabajos de Azure Communication para .NET versión 1.0.0 o posterior.

Agregue las directivas using siguientes al principio de Program.cs para incluir los espacios de nombres JobRouter.

using Azure.Communication.JobRouter;

Inicializar el cliente del enrutador de trabajos y el cliente de administración

Los clientes del enrutador de trabajos se pueden autenticar mediante la cadena de conexión adquirida de un recurso Azure Communication Services en Azure Portal. Generamos un cliente y un cliente de administración para interactuar con el servicio de enrutador de trabajos. El cliente administrador se usa para aprovisionar colas y directivas, mientras que el cliente se usa para enviar trabajos y registrar roles de trabajo. Para más información sobre las cadenas de conexión, consulte access-your-connection-strings-and-service-endpoints.

// Get a connection string to our Azure Communication Services resource.
var routerAdminClient = new JobRouterAdministrationClient("your_connection_string");
var routerClient = new JobRouterClient("your_connection_string");

Creación de una directiva de distribución

El enrutador de trabajos usa una directiva de distribución para decidir cómo se notificará a los roles de trabajo los trabajos disponibles y el período de vida de las notificaciones, lo que se conoce como ofertas. Para crear la directiva, especifique el id., un nombre, un valor de offerExpiresAfter y un modo de distribución.

var distributionPolicy = await routerAdminClient.CreateDistributionPolicyAsync(
    new CreateDistributionPolicyOptions(
        distributionPolicyId: "distribution-policy-1",
        offerExpiresAfter: TimeSpan.FromMinutes(1),
        mode: new LongestIdleMode())
    {
        Name = "My distribution policy"
    }
);

Creación de una cola

Para crear la cola, especifique un identificador y un nombre, y proporcione el identificador de objeto de la directiva de distribución que creó anteriormente.

var queue = await routerAdminClient.CreateQueueAsync(
    new CreateQueueOptions(queueId: "queue-1", distributionPolicyId: distributionPolicy.Value.Id)
    {
        Name = "My Queue" 
    });

Enviar un trabajo

Ahora se puede enviar un trabajo directamente a esa cola, con un selector de trabajo que exige que el trabajo tenga la etiqueta Some-Skill mayor que 10.

var job = await routerClient.CreateJobAsync(
    new CreateJobOptions(jobId: "job-1", channelId: "voice", queueId: queue.Value.Id)
    {
        Priority = 1,
        RequestedWorkerSelectors =
        {
            new RouterWorkerSelector(key: "Some-Skill", labelOperator: LabelOperator.GreaterThan, value: new RouterValue(10))
        }
    });

Creación de roles de trabajo

Ahora se crean registra un rol de trabajo para recibir trabajo de esa cola, con una etiqueta de Some-Skill igual a 11 y capacidad en my-channel.

var worker = await routerClient.CreateWorkerAsync(
    new CreateWorkerOptions(workerId: "worker-1", capacity: 1)
    {
        Queues = { queue.Value.Id },
        Labels = { ["Some-Skill"] = new RouterValue(11) },
        Channels = { new RouterChannel(channelId: "voice", capacityCostPerJob: 1) },
        AvailableForOffers = true
    });

Recibir una oferta

Se debe obtener el valor RouterWorkerOfferIssued de Suscripción de Event Grid. Pero también se podría esperar unos segundos y consultar el trabajo directamente en la API de JobRouter para ver si se le ha emitido una oferta.

await Task.Delay(TimeSpan.FromSeconds(10));
worker = await routerClient.GetWorkerAsync(worker.Value.Id);
foreach (var offer in worker.Value.Offers)
{
    Console.WriteLine($"Worker {worker.Value.Id} has an active offer for job {offer.JobId}");
}

Aceptar la oferta de trabajo

A continuación, el rol de trabajo puede aceptar la oferta de trabajo mediante el SDK, que asigna el trabajo al rol de trabajo.

var accept = await routerClient.AcceptJobOfferAsync(workerId: worker.Value.Id, offerId: worker.Value.Offers.FirstOrDefault().OfferId);
Console.WriteLine($"Worker {worker.Value.Id} is assigned job {accept.Value.JobId}");

Completar el trabajo

Una vez que el rol de trabajo ha completado la tarea asociada al trabajo (por ejemplo, ha completado la llamada), completamos el trabajo.

await routerClient.CompleteJobAsync(new CompleteJobOptions(jobId: accept.Value.JobId, assignmentId: accept.Value.AssignmentId));
Console.WriteLine($"Worker {worker.Value.Id} has completed job {accept.Value.JobId}");

Cerrar el trabajo

Una vez que el rol de trabajo esté listo para asumir nuevos trabajos, el rol de trabajo debe cerrar el trabajo. De forma opcional, el rol de trabajo puede proporcionar un código de disposición para indicar el resultado del trabajo.

await routerClient.CloseJobAsync(new CloseJobOptions(jobId: accept.Value.JobId, assignmentId: accept.Value.AssignmentId) {
    DispositionCode = "Resolved"
});
Console.WriteLine($"Worker {worker.Value.Id} has closed job {accept.Value.JobId}");

Eliminar el trabajo

Una vez cerrado el trabajo, podemos eliminar el trabajo para que podamos volver a crear el trabajo con el mismo identificador si se vuelve a ejecutar este ejemplo

await routerClient.DeleteJobAsync(accept.Value.JobId);
Console.WriteLine($"Deleting job {accept.Value.JobId}");

Ejecución del código

Ejecute la aplicación con dotnet run y observe los resultados.

dotnet run

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Nota

La ejecución de la aplicación más de una vez hará que se coloque un nuevo trabajo en la cola cada vez. Como consecuencia, al rol de trabajo se le puede ofrecer un trabajo distinto al que se creó al ejecutar el código anterior. Dado que esto puede sesgar la solicitud, considere la posibilidad de eliminar trabajos de la cola cada vez. Consulte la documentación del SDK para administrar colas o trabajos.

Documentación de referencia

Obtenga información sobre el conjunto completo de funcionalidades del enrutador de trabajos de Azure Communication Services desde la referencia del SDK de .NET o la referencia de la API de REST.

Requisitos previos

Código de ejemplo

Puede revisar y descargar el código de ejemplo de este inicio rápido en GitHub.

Instalación

Creación de una nueva aplicación web

En una ventana de terminal o consola, cree una nueva carpeta para la aplicación y vaya a ella.

mkdir acs-router-quickstart && cd acs-router-quickstart

Ejecute npm init para crear un archivo package.json con la configuración predeterminada.

npm init -y

Cree un nuevo archivo index.js, en el que agregará el código de este inicio rápido.

Instalación de los paquetes

Tendrá que usar la biblioteca cliente del enrutador de trabajos de Azure Communication para JavaScript versión 1.0.0 o posterior.

Use el comando npm install para instalar los siguientes SDK de Communication Services para JavaScript.

npm install @azure-rest/communication-job-router --save

Instalación del marco de la aplicación

En el archivo index.js, agregue el código siguiente. Agregaremos el código para el inicio rápido en la función main.

const JobRouterClient = require('@azure-rest/communication-job-router').default;

const main = async () => {
  console.log("Azure Communication Services - Job Router Quickstart")

  // Quickstart code goes here

};

main().catch((error) => {
  console.log("Encountered an error");
  console.log(error);
})

Inicialización del cliente del enrutador de trabajos

Los clientes del enrutador de trabajos se pueden autenticar mediante la cadena de conexión adquirida de un recurso Azure Communication Services en Azure Portal. Generamos un cliente para interactuar con el servicio de enrutador de trabajos. Para más información sobre las cadenas de conexión, consulte access-your-connection-strings-and-service-endpoints.

Agregue el código siguiente en index.js dentro la función main.

const connectionString = process.env["COMMUNICATION_CONNECTION_STRING"] ||
    "endpoint=https://<resource-name>.communication.azure.com/;<access-key>";
const client = JobRouterClient(connectionString);

Creación de una directiva de distribución

El enrutador de trabajos usa una directiva de distribución para decidir cómo se notificará a los roles de trabajo acerca de los trabajos disponibles y el período de vida de las notificaciones, lo que se conoce como Ofertas. Para crear la directiva, especifique el id., un nombre, un valor de offerExpiresAfterSeconds y un modo de distribución.

const distributionPolicy = await client.path("/routing/distributionPolicies/{distributionPolicyId}", "distribution-policy-1").patch({
    body: {
        offerExpiresAfterSeconds: 60,
        mode: { kind: "longest-idle" },
        name: "My distribution policy"
    },
    contentType: "application/merge-patch+json"
});

Creación de una cola

Para crear la cola, especifique un identificador y un nombre, y proporcione el identificador de objeto de la directiva de distribución que creó anteriormente.

const queue = await client.path("/routing/queues/{queueId}", "queue-1").patch({
    body: {
        name: "My Queue",
        distributionPolicyId: distributionPolicy.body.id
    },
    contentType: "application/merge-patch+json"
});

Enviar un trabajo

Ahora se puede enviar un trabajo directamente a esa cola, con un selector de trabajo que exige que el trabajo tenga la etiqueta Some-Skill mayor que 10.

const job = await client.path("/routing/jobs/{jobId}", "job-1").patch({
    body: {
        channelId: "voice",
        queueId: queue.body.id,
        priority: 1,
        requestedWorkerSelectors: [{ key: "Some-Skill", labelOperator: "greaterThan", value: 10 }]
    },
    contentType: "application/merge-patch+json"
});

Creación de roles de trabajo

Ahora se crean registra un rol de trabajo para recibir trabajo de esa cola, con una etiqueta de Some-Skill igual a 11 y capacidad en my-channel.

let worker = await client.path("/routing/workers/{workerId}", "worker-1").patch({
    body:  {
        capacity: 1,
        queues: [queue.body.id],
        labels: { "Some-Skill": 11 },
        channels: [{ channelId: "voice", capacityCostPerJob: 1 }],
        availableForOffers: true
    },
    contentType: "application/merge-patch+json"
});

Recibir una oferta

Se debe obtener el valor RouterWorkerOfferIssued de Suscripción de Event Grid. Pero también se podría esperar unos segundos y consultar el trabajo directamente en la API de JobRouter para ver si se le ha emitido una oferta.

await new Promise(r => setTimeout(r, 10000));
worker = await client.path("/routing/workers/{workerId}", worker.body.id).get();
for (const offer of worker.body.offers) {
    console.log(`Worker ${worker.body.id} has an active offer for job ${offer.jobId}`);
}

Aceptar la oferta de trabajo

A continuación, el rol de trabajo puede aceptar la oferta de trabajo mediante el SDK, que asigna el trabajo al rol de trabajo.

const accept = await client.path("/routing/workers/{workerId}/offers/{offerId}:accept", worker.body.id, worker.body.offers[0].offerId).post();
console.log(`Worker ${worker.body.id} is assigned job ${accept.body.jobId}`);

Completar el trabajo

Una vez que el rol de trabajo ha completado la tarea asociada al trabajo (por ejemplo, ha completado la llamada), completamos el trabajo.

await client.path("/routing/jobs/{jobId}/assignments/{assignmentId}:complete", accept.body.jobId, accept.body.assignmentId).post();
console.log(`Worker ${worker.body.id} has completed job ${accept.body.jobId}`);

Cerrar el trabajo

Una vez que el rol de trabajo esté listo para asumir nuevos trabajos, el rol de trabajo debe cerrar el trabajo. De forma opcional, el rol de trabajo puede proporcionar un código de disposición para indicar el resultado del trabajo.

await client.path("/routing/jobs/{jobId}/assignments/{assignmentId}:close", accept.body.jobId, accept.body.assignmentId).post({
    body: { dispositionCode: "Resolved" }
});
console.log(`Worker ${worker.body.id} has closed job ${accept.body.jobId}`);

Eliminar el trabajo

Una vez cerrado el trabajo, podemos eliminar el trabajo para que podamos volver a crear el trabajo con el mismo identificador si se vuelve a ejecutar este ejemplo

await client.path("/routing/jobs/{jobId}", accept.body.jobId).delete();
console.log(`Deleting job ${accept.body.jobId}`);

Ejecución del código

Para ejecutar el código, asegúrese de que se encuentra en el directorio donde está el archivo index.js.

node index.js

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Nota

La ejecución de la aplicación más de una vez hará que se coloque un nuevo trabajo en la cola cada vez. Como consecuencia, al rol de trabajo se le puede ofrecer un trabajo distinto al que se creó al ejecutar el código anterior. Dado que esto puede sesgar la solicitud, considere la posibilidad de eliminar trabajos de la cola cada vez. Consulte la documentación del SDK para administrar colas o trabajos.

Documentación de referencia

Obtenga información sobre el conjunto completo de funcionalidades del enrutador de trabajos de Azure Communication Services desde la referencia del SDK de JavaScript o la referencia de la API de REST.

Requisitos previos

Código de ejemplo

Puede revisar y descargar el código de ejemplo de este inicio rápido en GitHub.

Instalación

Creación de una nueva aplicación de Python

En una ventana de terminal o consola, cree una nueva carpeta para la aplicación y vaya a ella.

mkdir jobrouter-quickstart && cd jobrouter-quickstart

Instalar el paquete

Tendrá que usar la biblioteca cliente del enrutador de trabajos de Azure Communication para Python versión 1.0.0 o posterior.

Desde el símbolo del sistema de la consola, ejecute el comando siguiente:

pip install azure-communication-jobrouter

Instalación del marco de la aplicación

Cree un archivo llamado router-quickstart.py y agregue la estructura básica del programa.

import time
from azure.communication.jobrouter import (
    JobRouterClient,
    JobRouterAdministrationClient
)
from azure.communication.jobrouter.models import (
    LongestIdleMode,
    RouterWorkerSelector,
    LabelOperator,
    RouterChannel,
    CloseJobOptions
)

class RouterQuickstart(object):
    print("Azure Communication Services - Job Router Quickstart")
    #Job Router method implementations goes here

if __name__ == '__main__':
    router = RouterQuickstart()

Inicializar el cliente del enrutador de trabajos y el cliente de administración

Los clientes del enrutador de trabajos se pueden autenticar mediante la cadena de conexión adquirida de un recurso Azure Communication Services en Azure Portal. Generamos un cliente y un cliente de administración para interactuar con el servicio de enrutador de trabajos. El cliente administrador se usa para aprovisionar colas y directivas, mientras que el cliente se usa para enviar trabajos y registrar roles de trabajo. Para más información sobre las cadenas de conexión, consulte access-your-connection-strings-and-service-endpoints.

# Get a connection string to our Azure Communication Services resource.
router_admin_client = JobRouterAdministrationClient.from_connection_string(conn_str = "your_connection_string")
router_client = JobRouterClient.from_connection_string(conn_str = "your_connection_string")

Creación de una directiva de distribución

El enrutador de trabajos usa una directiva de distribución para decidir cómo se notificará a los roles de trabajo los trabajos disponibles y el período de vida de las notificaciones, lo que se conoce como ofertas. Crear la directiva especificando el distribution_policy_id, un nombre, un valor offer_expires_after_seconds y un modo de distribución.

distribution_policy = router_admin_client.upsert_distribution_policy(
    distribution_policy_id ="distribution-policy-1",
    offer_expires_after_seconds = 60,
    mode = LongestIdleMode(),
    name = "My distribution policy")

Creación de una cola

Para crear la cola, especifique un identificador y un nombre, y proporcione el identificador de objeto de la directiva de distribución que creó anteriormente.

queue = router_admin_client.upsert_queue(
    queue_id = "queue-1",
    name = "My Queue",
    distribution_policy_id = distribution_policy.id)

Enviar un trabajo

Ahora se puede enviar un trabajo directamente a esa cola, con un selector de trabajo que exige que el trabajo tenga la etiqueta Some-Skill mayor que 10.

job = router_client.upsert_job(
    job_id = "job-1",
    channel_id = "voice",
    queue_id = queue.id,
    priority = 1,
    requested_worker_selectors = [
        RouterWorkerSelector(
            key = "Some-Skill",
            label_operator = LabelOperator.GREATER_THAN,
            value = 10
        )
    ])

Creación de roles de trabajo

Ahora se crean registra un rol de trabajo para recibir trabajo de esa cola, con una etiqueta de Some-Skill igual a 11 y capacidad en my-channel.

worker = router_client.upsert_worker(
    worker_id = "worker-1",
    capacity = 1,
    queues = ["queue-1"],
    labels = {
        "Some-Skill": 11
    },
    channels = [RouterChannel(channel_id = "voice", capacity_cost_per_job = 1)],
    available_for_offers = True
)

Recibir una oferta

Se debe obtener el valor RouterWorkerOfferIssued de Suscripción de Event Grid. Pero también se podría esperar unos segundos y consultar el trabajo directamente en la API de JobRouter para ver si se le ha emitido una oferta.

time.sleep(10)
worker = router_client.get_worker(worker_id = worker.id)
for offer in worker.offers:
    print(f"Worker {worker.id} has an active offer for job {offer.job_id}")

Aceptar la oferta de trabajo

A continuación, el rol de trabajo puede aceptar la oferta de trabajo mediante el SDK, que asigna el trabajo al rol de trabajo.

accept = router_client.accept_job_offer(worker_id = worker.id, offer_id = worker.offers[0].offer_id)
print(f"Worker {worker.id} is assigned job {accept.job_id}")

Completar el trabajo

Una vez que el rol de trabajo ha completado la tarea asociada al trabajo (por ejemplo, ha completado la llamada), completamos el trabajo.

router_client.complete_job(job_id = job.id, assignment_id = accept.assignment_id)
print(f"Worker {worker.id} has completed job {accept.job_id}")

Cerrar el trabajo

Una vez que el rol de trabajo esté listo para asumir nuevos trabajos, el rol de trabajo debe cerrar el trabajo. De forma opcional, el rol de trabajo puede proporcionar un código de disposición para indicar el resultado del trabajo.

router_client.close_job(job_id = job.id, assignment_id = accept.assignment_id, options = CloseJobOptions(disposition_code = "Resolved"))
print(f"Worker {worker.id} has closed job {accept.job_id}")

Eliminar el trabajo

Una vez cerrado el trabajo, podemos eliminar el trabajo para que podamos volver a crear el trabajo con el mismo identificador si se vuelve a ejecutar este ejemplo

router_client.delete_job(accept.job_id)
print(f"Deleting {accept.job_id}")

Ejecución del código

Para ejecutar el código, asegúrese de que se encuentra en el directorio donde está el archivo router-quickstart.py.

python router-quickstart.py

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Nota

La ejecución de la aplicación más de una vez hará que se coloque un nuevo trabajo en la cola cada vez. Como consecuencia, al rol de trabajo se le puede ofrecer un trabajo distinto al que se creó al ejecutar el código anterior. Dado que esto puede sesgar la solicitud, considere la posibilidad de eliminar trabajos de la cola cada vez. Consulte la documentación del SDK para administrar colas o trabajos.

Documentación de referencia

Obtenga información sobre el conjunto completo de funcionalidades del enrutador de trabajos de Azure Communication Services desde la referencia del SDK de Python o la referencia de la API de REST.

Requisitos previos

Código de ejemplo

Puede revisar y descargar el código de ejemplo de este inicio rápido en GitHub.

Instalación

Creación de una aplicación Java

En una ventana de la consola, como cmd, PowerShell o Bash, use el comando mvn siguiente para crear una aplicación de consola con el nombre router-quickstart. Este comando crea un sencillo proyecto de Java "Hola mundo", con un solo archivo de código fuente: App.java.

mvn archetype:generate -DgroupId=com.communication.jobrouter.quickstart -DartifactId=jobrouter-quickstart-java -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Inclusión del paquete

Tendrá que usar la biblioteca cliente del enrutador de trabajos de Azure Communication para Java versión 1.0.0 o posterior.

Inclusión del archivo BOM

Incluya azure-sdk-bom en el proyecto para que tenga dependencia de la versión de disponibilidad general (GA) de la biblioteca. En el fragmento de código siguiente, reemplace el marcador de posición {bom_version_to_target} por el número de versión. Para más información sobre el BOM, consulte el archivo Léame de BOM del SDK de Azure.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

y, luego, incluya la dependencia directa en la sección de dependencias sin la etiqueta de versión.

<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-jobrouter</artifactId>
  </dependency>
</dependencies>

Inclusión de dependencias directas

Si quiere tomar dependencia de una versión determinada de la biblioteca que no está presente en el BOM, agregue la dependencia directa al proyecto como se muestra a continuación.

<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-communication-jobrouter</artifactId>
  <version>1.0.0</version>
</dependency>

Instalación del marco de la aplicación

Vaya al directorio /src/main/java/com/communication/quickstart y abra el archivo App.java. Agregue el siguiente código:

package com.communication.quickstart;

import com.azure.communication.jobrouter.JobRouterAdministrationClient;
import com.azure.communication.jobrouter.JobRouterAdministrationClientBuilder;
import com.azure.communication.jobrouter.JobRouterClient;
import com.azure.communication.jobrouter.JobRouterClientBuilder;
import com.azure.communication.jobrouter.*;
import com.azure.communication.jobrouter.models.*;

import java.time.Duration;
import java.util.List;
import java.util.Map;

public class App
{
    public static void main(String[] args) throws IOException
    {
        System.out.println("Azure Communication Services - Job Router Quickstart");
        // Quickstart code goes here
    }
}

Inicializar el cliente del enrutador de trabajos y el cliente de administración

Los clientes del enrutador de trabajos se pueden autenticar mediante la cadena de conexión adquirida de un recurso Azure Communication Services en Azure Portal. Generamos un cliente y un cliente de administración para interactuar con el servicio de enrutador de trabajos. El cliente administrador se usa para aprovisionar colas y directivas, mientras que el cliente se usa para enviar trabajos y registrar roles de trabajo. Para más información sobre las cadenas de conexión, consulte access-your-connection-strings-and-service-endpoints.

// Get a connection string to our Azure Communication Services resource.
JobRouterAdministrationClient routerAdminClient = new JobRouterAdministrationClientBuilder().connectionString("your_connection_string").buildClient();
JobRouterClient routerClient = new JobRouterClientBuilder().connectionString("your_connection_string").buildClient();

Creación de una directiva de distribución

El enrutador de trabajos usa una directiva de distribución para decidir cómo se notificará a los roles de trabajo los trabajos disponibles y el período de vida de las notificaciones, lo que se conoce como ofertas. Para crear la directiva, especifique el id., un nombre, un valor de offerExpiresAfter y un modo de distribución.

DistributionPolicy distributionPolicy = routerAdminClient.createDistributionPolicy(
    new CreateDistributionPolicyOptions("distribution-policy-1", Duration.ofMinutes(1), new LongestIdleMode())
        .setName("My distribution policy"));

Creación de una cola

Para crear la cola, especifique un identificador y un nombre, y proporcione el identificador de objeto de la directiva de distribución que creó anteriormente.

RouterQueue queue = routerAdminClient.createQueue(
    new CreateQueueOptions("queue-1", distributionPolicy.getId()).setName("My queue")
);

Enviar un trabajo

Ahora se puede enviar un trabajo directamente a esa cola, con un selector de trabajo que exige que el trabajo tenga la etiqueta Some-Skill mayor que 10.

RouterJob job = routerClient.createJob(new CreateJobOptions("job-1", "voice", queue.getId())
    .setPriority(1)
    .setRequestedWorkerSelectors(List.of(
        new RouterWorkerSelector("Some-Skill", LabelOperator.GREATER_THAN, new RouterValue(10)))));

Creación de roles de trabajo

Ahora se crean registra un rol de trabajo para recibir trabajo de esa cola, con una etiqueta de Some-Skill igual a 11 y capacidad en my-channel.

RouterWorker worker = routerClient.createWorker(
    new CreateWorkerOptions("worker-1", 1)
        .setQueues(List.of(queue.getId()))
        .setLabels(Map.of("Some-Skill", new RouterValue(11)))
        .setChannels(List.of(new RouterChannel("voice", 1))));

Recibir una oferta

Se debe obtener el valor RouterWorkerOfferIssued de Suscripción de Event Grid. Pero también se podría esperar unos segundos y consultar el trabajo directamente en la API de JobRouter para ver si se le ha emitido una oferta.

Thread.sleep(10000);
worker = routerClient.getWorker(worker.getId());
for (RouterJobOffer offer : worker.getOffers()) {
    System.out.printf("Worker %s has an active offer for job %s\n", worker.getId(), offer.getJobId());
}

Aceptar la oferta de trabajo

A continuación, el rol de trabajo puede aceptar la oferta de trabajo mediante el SDK, que asigna el trabajo al rol de trabajo.

AcceptJobOfferResult accept = routerClient.acceptJobOffer(worker.getId(), worker.getOffers().get(0).getOfferId());
System.out.printf("Worker %s is assigned job %s\n", worker.getId(), accept.getJobId());

Completar el trabajo

Una vez que el rol de trabajo ha completado la tarea asociada al trabajo (por ejemplo, ha completado la llamada), completamos el trabajo.

routerClient.completeJobWithResponse(accept.getJobId(), accept.getAssignmentId(), null);
System.out.printf("Worker %s has completed job %s\n", worker.getId(), accept.getJobId());

Cerrar el trabajo

Una vez que el rol de trabajo esté listo para asumir nuevos trabajos, el rol de trabajo debe cerrar el trabajo.

routerClient.closeJobWithResponse(accept.getJobId(), accept.getAssignmentId(), null);
System.out.printf("Worker %s has closed job %s\n", worker.getId(), accept.getJobId());

Eliminar el trabajo

Una vez cerrado el trabajo, podemos eliminar el trabajo para que podamos volver a crear el trabajo con el mismo identificador si se vuelve a ejecutar este ejemplo

routerClient.deleteJob(accept.getJobId());
System.out.printf("Deleting job %s\n", accept.getJobId());

Ejecución del código

Para ejecutar el código, vaya al directorio que contiene el archivo pom.xml y compile el programa.

mvn compile

A continuación, compile el paquete:

mvn package

Ejecución de la aplicación

mvn exec:java -Dexec.mainClass="com.communication.jobrouter.quickstart.App" -Dexec.cleanupDaemonThreads=false

La salida prevista describe cada acción completada:

Azure Communication Services - Job Router Quickstart
Worker worker-1 has an active offer for job job-1
Worker worker-1 is assigned job job-1
Worker worker-1 has completed job job-1
Worker worker-1 has closed job job-1
Deleting job job-1

Nota

La ejecución de la aplicación más de una vez hará que se coloque un nuevo trabajo en la cola cada vez. Como consecuencia, al rol de trabajo se le puede ofrecer un trabajo distinto al que se creó al ejecutar el código anterior. Dado que esto puede sesgar la solicitud, considere la posibilidad de eliminar trabajos de la cola cada vez. Consulte la documentación del SDK para administrar colas o trabajos.

Documentación de referencia

Obtenga información sobre el conjunto completo de funcionalidades del enrutador de trabajos de Azure Communication Services desde la referencia del SDK de Java o la referencia de la API de REST.

Pasos siguientes

Explore los tutoriales del Enrutador de trabajos