Guida introduttiva: Inviare un processo per l'accodamento e il routing

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
• Una stringa di connessione e una risorsa attiva di Servizi di comunicazione. Creare una risorsa di Servizi di comunicazione.
• La libreria client .NET più recente per il sistema operativo.

Codice di esempio

È possibile esaminare e scaricare il codice di esempio per questa guida introduttiva in GitHub.

Configurazione

Creare una nuova applicazione C#

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome JobRouterQuickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.

dotnet new console -o JobRouterQuickstart

Passare alla cartella dell'app appena creata e usare il comando dotnet build per compilare l'applicazione.

cd JobRouterQuickstart
dotnet build

Installare il pacchetto

Installare la libreria client del router processo di comunicazione di Azure per .NET con NuGet:

dotnet add package Azure.Communication.JobRouter

È necessario usare la libreria client del router del processo di comunicazione di Azure per .NET versione 1.0.0 o successiva.

Aggiungere le direttive seguenti using all'inizio di Program.cs per includere gli spazi dei nomi JobRouter.

using Azure.Communication.JobRouter;

Inizializzare il client del router di processo e il client di amministrazione

I client del router di processo possono essere autenticati usando i stringa di connessione acquisiti da una risorsa Servizi di comunicazione di Azure nella portale di Azure. Viene generato sia un client che un client di amministrazione per interagire con il servizio Router processo. Il client amministratore viene usato per effettuare il provisioning di code e criteri, mentre il client viene usato per inviare processi e registrare i ruoli di lavoro. Per altre informazioni sulle stringhe di connessione, vedere 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");

Creare un criterio di distribuzione

Job Router usa un criterio di distribuzione per decidere in che modo i lavoratori riceveranno una notifica dei processi disponibili e il tempo necessario per le notifiche, note come Offerte. Creare i criteri specificando l'ID, un nome, un'offertaExpiresAfter e una modalità di distribuzione.

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

Crea una coda

Creare la coda specificando un ID, un nome e specificare l'ID dell'oggetto Criteri di distribuzione creato in precedenza.

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

Inviare un processo

È ora possibile inviare un processo direttamente a tale coda, con un selettore di lavoro che richiede che il ruolo di lavoro abbia l'etichetta Some-Skill maggiore di 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))
        }
    });

Creare un ruolo di lavoro

A questo scopo, viene creato un ruolo di lavoro per ricevere il lavoro da tale coda, con un'etichetta uguale Some-Skill a 11 e la capacità su 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
    });

Ricevere un'offerta

Si dovrebbe ottenere un RouterWorkerOfferIssued dalla sottoscrizione di Griglia di eventi. Tuttavia, è anche possibile attendere alcuni secondi e quindi eseguire una query sul ruolo di lavoro direttamente sull'API JobRouter per verificare se è stata rilasciata un'offerta.

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}");
}

Accettare l'offerta di processo

Il ruolo di lavoro può quindi accettare l'offerta di processo usando l'SDK, che assegna il processo al ruolo di lavoro.

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}");

Completare il processo

Dopo che il lavoratore ha completato il lavoro associato al processo (ad esempio, completato la chiamata), il processo è stato completato.

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}");

Chiudere il processo

Quando il lavoratore è pronto per l'esecuzione di nuovi processi, il lavoratore deve chiudere il processo. Facoltativamente, il ruolo di lavoro può fornire un codice di eliminazione per indicare il risultato del processo.

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}");

Eliminare il processo

Dopo aver chiuso il processo, è possibile eliminare il processo in modo da poter ricreare il processo con lo stesso ID se si esegue di nuovo questo esempio

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

Eseguire il codice

Eseguire l'applicazione usando dotnet run e osservare i risultati.

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

Documentazione di riferimento

Per informazioni sul set completo di funzionalità di Servizi di comunicazione di Azure Router processo, vedere informazioni di riferimento su .NET SDK o informazioni di riferimento sull'API REST.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
• Una stringa di connessione e una risorsa attiva di Servizi di comunicazione. Creare una risorsa di Servizi di comunicazione.
• Le versioni più recenti di Node.js versioni di Active LTS e Maintenance LTS.

Codice di esempio

È possibile esaminare e scaricare il codice di esempio per questa guida introduttiva in GitHub.

Configurazione

Creare una nuova applicazione Web

In una finestra del terminale o della console creare una nuova cartella per l'applicazione e passarvi.

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

Eseguire npm init per creare un file package.json con le impostazioni predefinite.

npm init -y

Creare un nuovo file index.js in cui si aggiungerà il codice per questa guida introduttiva.

Installare i pacchetti

È necessario usare la libreria client del router del processo di comunicazione di Azure per JavaScript versione 1.0.0 o successiva.

Usare il npm install comando per installare gli SDK di Servizi di comunicazione seguenti per JavaScript.

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

Configurare il framework dell'app

index.js Nel file aggiungere il codice seguente. Si aggiungerà il codice per l'avvio rapido nella main funzione .

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);
})

Inizializzare il client del router di processo

I client del router di processo possono essere autenticati usando i stringa di connessione acquisiti da una risorsa Servizi di comunicazione di Azure nella portale di Azure. Viene generato un client per interagire con il servizio Router processo. Per altre informazioni sulle stringhe di connessione, vedere access-your-connection-strings-and-service-endpoints.

Aggiungere il codice seguente all'interno index.js della main funzione .

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

Creare un criterio di distribuzione

Il router di processo usa un criterio di distribuzione per decidere in che modo i lavoratori ricevono una notifica dei processi disponibili e il tempo necessario per le notifiche, note come Offerte. Creare il criterio specificando l'ID, un nome, un'offertaExpiresAfterSeconds e una modalità di distribuzione.

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"
});

Crea una coda

Creare la coda specificando un ID, un nome e specificare l'ID dell'oggetto Criteri di distribuzione creato in precedenza.

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

Inviare un processo

È ora possibile inviare un processo direttamente a tale coda, con un selettore di lavoro che richiede che il ruolo di lavoro abbia l'etichetta Some-Skill maggiore di 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"
});

Creare un ruolo di lavoro

A questo scopo, viene creato un ruolo di lavoro per ricevere il lavoro da tale coda, con un'etichetta uguale Some-Skill a 11 e la capacità su 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"
});

Ricevere un'offerta

Si dovrebbe ottenere un RouterWorkerOfferIssued dalla sottoscrizione di Griglia di eventi. Tuttavia, è anche possibile attendere alcuni secondi e quindi eseguire una query sul ruolo di lavoro direttamente sull'API JobRouter per verificare se è stata rilasciata un'offerta.

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}`);
}

Accettare l'offerta di processo

Il ruolo di lavoro può quindi accettare l'offerta di processo usando l'SDK, che assegna il processo al ruolo di lavoro.

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}`);

Completare il processo

Dopo che il lavoratore ha completato il lavoro associato al processo (ad esempio, completato la chiamata), il processo è stato completato.

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}`);

Chiudere il processo

Quando il lavoratore è pronto per l'esecuzione di nuovi processi, il lavoratore deve chiudere il processo. Facoltativamente, il ruolo di lavoro può fornire un codice di eliminazione per indicare il risultato del processo.

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}`);

Eliminare il processo

Dopo aver chiuso il processo, è possibile eliminare il processo in modo da poter ricreare il processo con lo stesso ID se si esegue di nuovo questo esempio

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

Eseguire il codice

Per eseguire il codice, assicurarsi di essere nella directory in cui si trova il file 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

Documentazione di riferimento

Per informazioni sul set completo di funzionalità di Servizi di comunicazione di Azure Router processo, vedere le informazioni di riferimento su JavaScript SDK o informazioni di riferimento sull'API REST.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
• Una stringa di connessione e una risorsa attiva di Servizi di comunicazione. Creare una risorsa di Servizi di comunicazione.
• Python 3.7+ come sistema operativo.

Codice di esempio

È possibile esaminare e scaricare il codice di esempio per questa guida introduttiva in GitHub.

Configurazione

Creare una nuova applicazione Python

In una finestra del terminale o della console creare una nuova cartella per l'applicazione e passarvi.

mkdir jobrouter-quickstart && cd jobrouter-quickstart

Installare il pacchetto

Sarà necessario usare la libreria client del router del processo di comunicazione di Azure per Python versione 1.0.0 o successiva.

Dal prompt della console, eseguire il seguente comando:

pip install azure-communication-jobrouter

Configurare il framework dell'app

Creare un nuovo file denominato router-quickstart.py e aggiungere la struttura del programma di base.

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()

Inizializzare il client del router di processo e il client di amministrazione

I client del router di processo possono essere autenticati usando i stringa di connessione acquisiti da una risorsa Servizi di comunicazione di Azure nella portale di Azure. Viene generato sia un client che un client di amministrazione per interagire con il servizio Router processo. Il client amministratore viene usato per effettuare il provisioning di code e criteri, mentre il client viene usato per inviare processi e registrare i ruoli di lavoro. Per altre informazioni sulle stringhe di connessione, vedere 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")

Creare un criterio di distribuzione

Job Router usa un criterio di distribuzione per decidere in che modo i lavoratori riceveranno una notifica dei processi disponibili e il tempo necessario per le notifiche, note come Offerte. Creare i criteri specificando il distribution_policy_id, un nome, un valore offer_expires_after_seconds e una modalità di distribuzione.

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")

Crea una coda

Creare la coda specificando un ID, un nome e specificare l'ID dell'oggetto Criteri di distribuzione creato in precedenza.

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

Inviare un processo

È ora possibile inviare un processo direttamente a tale coda, con un selettore di lavoro che richiede che il ruolo di lavoro abbia l'etichetta Some-Skill maggiore di 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
        )
    ])

Creare un ruolo di lavoro

A questo scopo, viene creato un ruolo di lavoro per ricevere il lavoro da tale coda, con un'etichetta uguale Some-Skill a 11 e la capacità su 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
)

Ricevere un'offerta

Si dovrebbe ottenere un RouterWorkerOfferIssued dalla sottoscrizione di Griglia di eventi. Tuttavia, è anche possibile attendere alcuni secondi e quindi eseguire una query sul ruolo di lavoro direttamente sull'API JobRouter per verificare se è stata rilasciata un'offerta.

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}")

Accettare l'offerta di processo

Il ruolo di lavoro può quindi accettare l'offerta di processo usando l'SDK, che assegna il processo al ruolo di lavoro.

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}")

Completare il processo

Dopo che il lavoratore ha completato il lavoro associato al processo (ad esempio, completato la chiamata), il processo è stato completato.

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

Chiudere il processo

Quando il lavoratore è pronto per l'esecuzione di nuovi processi, il lavoratore deve chiudere il processo. Facoltativamente, il ruolo di lavoro può fornire un codice di eliminazione per indicare il risultato del processo.

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}")

Eliminare il processo

Dopo aver chiuso il processo, è possibile eliminare il processo in modo da poter ricreare il processo con lo stesso ID se si esegue di nuovo questo esempio

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

Eseguire il codice

Per eseguire il codice, assicurarsi di essere nella directory in cui si trova il file 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

Documentazione di riferimento

Per informazioni sul set completo di funzionalità di Servizi di comunicazione di Azure Router processo, vedere le informazioni di riferimento su Python SDK o informazioni di riferimento sull'API REST.

Prerequisiti

• Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente.
• Una stringa di connessione e una risorsa attiva di Servizi di comunicazione. Creare una risorsa di Servizi di comunicazione.
• Java Development Kit (JDK) versione 8 o successiva.
• Apache Maven

Codice di esempio

È possibile esaminare e scaricare il codice di esempio per questa guida introduttiva in GitHub.

Configurazione

Creare una nuova applicazione Java

In una finestra della console ,ad esempio cmd, PowerShell o Bash, usare il mvn comando seguente per creare una nuova app console con il nome router-quickstart. Questo comando crea un semplice progetto Java "Hello World" con un singolo file di origine: App.java.

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

Includere il pacchetto

Sarà necessario usare la libreria client del router del processo di comunicazione di Azure per Java versione 1.0.0 o successiva.

Includere il file BOM

Includere per azure-sdk-bom il progetto la dipendenza dalla versione disponibile a livello generale della libreria. Nel frammento di codice seguente sostituire il segnaposto {bom_version_to_target} con il numero di versione. Per altre informazioni sulla distinta base, vedere il file leggimi bom di Azure SDK.

<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>

e quindi includere la dipendenza diretta nella sezione dipendenze senza il tag di versione.

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

Includi dipendenza diretta

Se si vuole dipendere da una determinata versione della libreria che non è presente nella distinta base, aggiungere la dipendenza diretta al progetto come indicato di seguito.

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

Configurare il framework app

Passare alla directory /src/main/java/com/communication/quickstart e aprire il App.java file. Aggiungere il codice seguente:

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
    }
}

Inizializzare il client del router di processo e il client di amministrazione

I client del router di processo possono essere autenticati usando i stringa di connessione acquisiti da una risorsa Servizi di comunicazione di Azure nella portale di Azure. Viene generato sia un client che un client di amministrazione per interagire con il servizio Router processo. Il client amministratore viene usato per effettuare il provisioning di code e criteri, mentre il client viene usato per inviare processi e registrare i ruoli di lavoro. Per altre informazioni sulle stringhe di connessione, vedere 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();

Creare un criterio di distribuzione

Job Router usa un criterio di distribuzione per decidere in che modo i lavoratori riceveranno una notifica dei processi disponibili e il tempo necessario per le notifiche, note come Offerte. Creare i criteri specificando l'ID, un nome, un'offertaExpiresAfter e una modalità di distribuzione.

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

Crea una coda

Creare la coda specificando un ID, un nome e specificare l'ID dell'oggetto Criteri di distribuzione creato in precedenza.

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

Inviare un processo

È ora possibile inviare un processo direttamente a tale coda, con un selettore di lavoro che richiede che il ruolo di lavoro abbia l'etichetta Some-Skill maggiore di 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)))));

Creare un ruolo di lavoro

A questo scopo, viene creato un ruolo di lavoro per ricevere il lavoro da tale coda, con un'etichetta uguale Some-Skill a 11 e la capacità su 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))));

Ricevere un'offerta

Si dovrebbe ottenere un RouterWorkerOfferIssued dalla sottoscrizione di Griglia di eventi. Tuttavia, è anche possibile attendere alcuni secondi e quindi eseguire una query sul ruolo di lavoro direttamente sull'API JobRouter per verificare se è stata rilasciata un'offerta.

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());
}

Accettare l'offerta di processo

Il ruolo di lavoro può quindi accettare l'offerta di processo usando l'SDK, che assegna il processo al ruolo di lavoro.

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());

Completare il processo

Dopo che il lavoratore ha completato il lavoro associato al processo (ad esempio, completato la chiamata), il processo è stato completato.

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

Chiudere il processo

Quando il lavoratore è pronto per l'esecuzione di nuovi processi, il lavoratore deve chiudere il processo.

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

Eliminare il processo

Dopo aver chiuso il processo, è possibile eliminare il processo in modo da poter ricreare il processo con lo stesso ID se si esegue di nuovo questo esempio

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

Eseguire il codice

Per eseguire il codice, passare alla directory contenente il pom.xml file e compilare il programma.

mvn compile

Compilare quindi il pacchetto:

mvn package

Eseguire l'app

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

L'output previsto descrive ogni azione completata:

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

Documentazione di riferimento

Per informazioni sul set completo di funzionalità di Servizi di comunicazione di Azure Router processo, vedere le informazioni di riferimento su Java SDK o informazioni di riferimento sull'API REST.