Bagikan melalui

Pustaka klien Paket JobRouter Azure Communication untuk Python - versi 1.0.0

  • Artikel

Paket ini berisi Python SDK untuk Azure Communication Services untuk JobRouter. Baca selengkapnya tentang Azure Communication Services di sini

Kode sumber | Paket (Pypi) | Dokumentasi produk

Pengelakan

Dukungan paket Azure SDK Python untuk Python 2.7 telah berakhir 01 Januari 2022. Untuk informasi dan pertanyaan lebih lanjut, silakan merujuk ke https://github.com/Azure/azure-sdk-for-python/issues/20691

Memulai

Prasyarat

Anda memerlukan langganan Azure dan Sumber Daya Communication Service untuk menggunakan paket ini.

Instal paketnya

Instal pustaka klien Azure Communication JobRouter untuk Python dengan pip:

pip install azure-communication-jobrouter

Konsep utama

Tugas

Pekerjaan mewakili unit kerja, yang perlu dirutekan ke Pekerja yang tersedia. Contoh dunia nyata dari ini mungkin panggilan masuk atau obrolan dalam konteks pusat panggilan.

Worker

Pekerja mewakili pasokan yang tersedia untuk menangani Pekerjaan. Setiap pekerja mendaftar dengan atau beberapa antrean untuk menerima pekerjaan. Contoh dunia nyata dari ini mungkin agen yang bekerja di pusat panggilan.

Antrean

Antrean mewakili daftar pekerjaan yang diurutkan yang menunggu untuk dilayani oleh pekerja. Pekerja akan mendaftar dengan antrean untuk menerima pekerjaan darinya. Contoh dunia nyata dari ini mungkin antrean panggilan di pusat panggilan.

Saluran

Saluran mewakili pengelompokan pekerjaan menurut beberapa jenis. Ketika pekerja mendaftar untuk menerima pekerjaan, mereka juga harus menentukan saluran mana yang dapat mereka tangani pekerjaan, dan berapa banyak dari masing-masing yang dapat mereka tangani secara bersamaan. Contoh dunia nyata dari ini mungkin voice calls atau chats di pusat panggilan.

Penawaran

Penawaran diperpanjang oleh JobRouter kepada pekerja untuk menangani pekerjaan tertentu ketika menentukan kecocokan, pemberitahuan ini biasanya dikirimkan melalui EventGrid. Pekerja dapat menerima atau menolak penawaran menggunakan th JobRouter API, atau akan kedaluwarsa sesuai dengan waktu hidup yang dikonfigurasi pada kebijakan distribusi. Contoh dunia nyata dari ini mungkin dering agen di pusat panggilan.

Kebijakan Distribusi

Kebijakan Distribusi mewakili set konfigurasi yang mengatur bagaimana pekerjaan dalam antrean didistribusikan kepada pekerja yang terdaftar dengan antrean tersebut. Konfigurasi ini mencakup berapa lama Penawaran valid sebelum kedaluwarsa dan mode distribusi, yang menentukan urutan di mana pekerja dipilih ketika ada beberapa yang tersedia.

Mode Distribusi

3 jenis mode adalah

  • Round Robin: Pekerja dipesan oleh Id dan pekerja berikutnya setelah yang sebelumnya yang mendapatkan penawaran dipilih.
  • Diam terpanjang: Pekerja yang belum mengerjakan pekerjaan untuk waktu yang paling lama.
  • Best Worker: Anda dapat menentukan ekspresi untuk membandingkan 2 pekerja untuk menentukan pekerja mana yang akan dipilih.

Label

Anda dapat melampirkan label ke pekerja, pekerjaan, dan antrean. Ini adalah pasangan nilai kunci yang bisa dari string, number atau boolean jenis data. Contoh dunia nyata dari ini mungkin tingkat keterampilan pekerja tertentu atau tim atau lokasi geografis.

Pemilih Label

Pemilih label dapat dilampirkan ke pekerjaan untuk menargetkan subset pekerja yang melayani antrean. Contoh dunia nyata dari ini mungkin merupakan kondisi pada panggilan masuk bahwa agen harus memiliki tingkat pengetahuan minimum tentang produk tertentu.

Kebijakan klasifikasi

Kebijakan klasifikasi dapat digunakan untuk memilih antrean secara dinamis, menentukan prioritas pekerjaan, dan melampirkan pemilih label pekerja ke pekerjaan dengan memanfaatkan mesin aturan.

Kebijakan pengecualian

Kebijakan pengecualian mengontrol perilaku Pekerjaan berdasarkan pemicu dan menjalankan tindakan yang diinginkan. Kebijakan pengecualian dilampirkan ke Antrean sehingga dapat mengontrol perilaku Pekerjaan dalam Antrean.

Contoh

Inisialisasi Klien

Untuk menginisialisasi Klien SMS, string koneksi dapat digunakan untuk membuat instans. Atau, Anda juga dapat menggunakan autentikasi Direktori Aktif menggunakan DefaultAzureCredential.

from azure.communication.jobrouter import (
    JobRouterClient,
    JobRouterAdministrationClient
)

connection_string = "endpoint=ENDPOINT;accessKey=KEY"
router_client = JobRouterClient.from_connection_string(conn_str = connection_string)
router_admin_client = JobRouterAdministrationClient.from_connection_string(conn_str = connection_string)

Kebijakan Distribusi

Sebelum kita dapat membuat Antrean, kita memerlukan Kebijakan Distribusi.

from azure.communication.jobrouter.models import (
    LongestIdleMode,
    DistributionPolicy
)

distribution_policy: DistributionPolicy = DistributionPolicy(
    offer_expires_after_seconds = 24 * 60 * 60,
    mode = LongestIdleMode(
        min_concurrent_offers = 1,
        max_concurrent_offers = 1
    )
)

distribution_policy: DistributionPolicy = router_admin_client.upsert_distribution_policy(
    "distribution-policy-1",
    distribution_policy
)

Antrean

Selanjutnya, kita dapat membuat antrean.

from azure.communication.jobrouter.models import (
    RouterQueue
)

queue: RouterQueue = RouterQueue(
    distribution_policy_id = "distribution-policy-1"
)

queue: RouterQueue = router_admin_client.upsert_queue(
    "queue-1",
    queue
)

Tugas

Sekarang, kita dapat mengirimkan pekerjaan langsung ke antrean itu, dengan pemilih pekerja mengharuskan pekerja memiliki label Some-Skill yang lebih besar dari 10.

from azure.communication.jobrouter.models import (
    RouterJob,
    RouterWorkerSelector,
    LabelOperator
)

router_job: RouterJob = RouterJob(
    channel_id = "my-channel",
    queue_id = "queue-1",
    channel_reference = "12345",
    priority = 1,
    requested_worker_selectors = [
        RouterWorkerSelector(key = "Some-Skill", label_operator = LabelOperator.EQUAL, value = 10)
    ]
)

job: RouterJob = router_client.upsert_job(
    "jobId-1",
    router_job
)

Worker

Sekarang, kami mendaftarkan pekerja untuk menerima pekerjaan dari antrean itu, dengan label Some-Skill yang sama dengan 11.

from azure.communication.jobrouter.models import (
    RouterWorker,
    RouterChannel
)

router_worker: RouterWorker = RouterWorker(
    capacity = 1,
    queues = [
        "queue-1"
    ],
    labels = {
        "Some-Skill": 11
    },
    channels = [
        RouterChannel(channel_id = "my-channel", capacity_cost_per_job = 1)
    ],
    available_for_offers = True
)

worker = router_client.upsert_worker(
    "worker-1",
    router_worker
)

Penawaran

Kita harus mendapatkan RouterWorkerOfferIssued dari langganan EventGrid kita.

Ada beberapa layanan Azure berbeda yang bertindak sebagai penanganan aktivitas. Untuk skenario ini, kita akan mengasumsikan Webhook untuk pengiriman peristiwa. Pelajari selengkapnya tentang pengiriman peristiwa Webhook

Setelah peristiwa dikirimkan ke penanganan aktivitas, kita dapat mendeserialisasi payload JSON ke dalam daftar peristiwa.

# Parse the JSON payload into a list of events
from azure.eventgrid import EventGridEvent
import json

## deserialize payload into a list of typed Events
events = [EventGridEvent.from_json(json.loads(msg)) for msg in payload]

offer_id = ""
for event in events:
    if event.event_type == "Microsoft.Communication.RouterWorkerOfferIssued":
        offer_id = event.data.offer_id
    else:
        continue

Namun, kita juga dapat menunggu beberapa detik dan kemudian mengkueri pekerja secara langsung terhadap API JobRouter untuk melihat apakah penawaran dikeluarkan untuk itu.

from azure.communication.jobrouter.models import (
    RouterWorker,
)

router_worker: RouterWorker = router_client.get_worker(worker_id = "worker-1")

for offer in router_worker.offers:
    print(f"Worker {router_worker.id} has an active offer for job {offer.job_id}")

Menerima penawaran

Setelah pekerja menerima penawaran, dibutuhkan dua tindakan yang mungkin: terima atau tolak. Kami akan menerima tawaran.

from azure.communication.jobrouter.models import (
    RouterJobOffer,
    AcceptJobOfferResult,
    RouterJobStatus
)

# fetching the offer id
job_offer: RouterJobOffer = [offer for offer in router_worker.offers if offer.job_id == "jobId-1"][0]
offer_id = job_offer.offer_id

# accepting the offer sent to `worker-1`
accept_job_offer_result: AcceptJobOfferResult = router_client.accept_job_offer(
    worker_id = "worker-1",
    offer_id = offer_id
)

print(f"Offer: {job_offer.offer_id} sent to worker: {router_worker.id} has been accepted")
print(f"Job has been assigned to worker: {router_worker.id} with assignment: {accept_job_offer_result.assignment_id}")

# verify job assignment is populated when querying job
updated_job = router_client.get_job(job_id = "jobId-1")
print(f"Job assignment has been successful: {updated_job.job_status == RouterJobStatus.Assigned and accept_job_offer_result.assignment_id in updated_job.assignments}")

Menyelesaikan pekerjaan

Setelah pekerja selesai dengan pekerjaan, pekerja harus menandai pekerjaan sebagai completed.

import datetime
from azure.communication.jobrouter.models import (
    CompleteJobOptions
)
complete_job_result = router_client.complete_job(
    "jobId-1",
    accept_job_offer_result.assignment_id,
    CompleteJobOptions(
        note = f"Job has been completed by {router_worker.id} at {datetime.datetime.utcnow()}"
    )
)

print(f"Job has been successfully completed.")

Menutup pekerjaan

Setelah pekerjaan selesai, pekerja dapat melakukan tindakan pembungkusan pekerjaan sebelum menutup pekerjaan dan akhirnya merilis kapasitasnya untuk menerima lebih banyak pekerjaan yang masuk

from azure.communication.jobrouter.models import (
    RouterJob,
    RouterJobStatus,
    CloseJobOptions,
)

close_job_result = router_client.close_job(
    "jobId-1",
    accept_job_offer_result.assignment_id,
    CloseJobOptions(
        note = f"Job has been closed by {router_worker.id} at {datetime.datetime.utcnow()}"
    )
)

print(f"Job has been successfully closed.")

update_job: RouterJob = router_client.get_job(job_id = "jobId-1")
print(f"Updated job status: {update_job.job_status == RouterJobStatus.CLOSED}")

import time
from datetime import datetime, timedelta
from azure.communication.jobrouter.models import (
    RouterJob,
    RouterJobStatus,
    CloseJobOptions,
)

close_job_in_future_result = router_client.close_job(
    "jobId-1",
    accept_job_offer_result.assignment_id,
    CloseJobOptions(
        note = f"Job has been closed by {router_worker.id} at {datetime.utcnow()}",
        close_at = datetime.utcnow() + timedelta(seconds = 2)
    )
)

print(f"Job has been marked to close")
time.sleep(secs = 2)
update_job: RouterJob = router_client.get_job(job_id = "jobId-1")
print(f"Updated job status: {update_job.job_status == RouterJobStatus.CLOSED}")

Pemecahan Masalah

Mengalami masalah? Bagian ini harus berisi detail tentang apa yang harus dilakukan di sana.

Langkah berikutnya

Lebih banyak kode sampel

Silakan lihat direktori sampel untuk contoh terperinci tentang cara menggunakan pustaka ini.

Berikan Umpan Balik

Jika Anda menemukan bug atau memiliki saran, silakan ajukan masalah di bagian Masalah proyek

Berkontribusi

Proyek ini menyambut baik kontribusi dan saran. Sebagian besar kontribusi mengharuskan Anda menyetujui Perjanjian Lisensi Kontributor (CLA) yang menyatakan bahwa Anda memiliki hak untuk, dan benar-benar melakukannya, memberi kami hak untuk menggunakan kontribusi Anda. Untuk detailnya, kunjungi cla.microsoft.com.

Proyek ini telah mengadopsi Kode Etik Sumber Terbuka Microsoft. Untuk informasi selengkapnya, lihat Tanya Jawab Umum Tata Tertib atau hubungi opencode@microsoft.com untuk pertanyaan atau komentar lainnya.