Eskalieren eines Auftrags
In diesem Leitfaden erfahren Sie, wie Sie einen Auftrag in einer Warteschlange mithilfe einer Ausnahmerichtlinie eskalieren.
Voraussetzungen
- Ein Azure-Konto mit einem aktiven Abonnement. Sie können kostenlos ein Konto erstellen.
- Eine bereitgestellte Communication Services-Ressource. Erstellen Sie eine Communication Services-Ressource.
- Optional: Absolvieren Sie die Schnellstartanleitung für die ersten Schritte mit dem Auftragsrouter.
- Optional: Lesen Sie die the Schrittanleitung zur Auftragsklassifizierung
Eskalationsübersicht
Die Eskalation kann als verschiedene Verhaltensweisen auftreten, z. B. als das Verschieben eines Auftrags in eine andere Warteschlange und/oder das Angeben einer höheren Priorität. Aufträge mit einer höheren Priorität werden an Arbeitnehmer verteilt, bevor Arbeitsplätze mit einer niedrigeren Priorität arbeiten. Für diese Anleitung verwenden wir eine Klassifizierungsrichtlinie und eine Ausnahmerichtlinie und um dieses Ziel zu erreichen.
Konfiguration der Klassifizierungsrichtlinie
Erstellen Sie eine Klassifizierungsrichtlinie, die die neue Bezeichnung, die dem Auftrag hinzugefügt wurde, verarbeiten kann. Diese Richtlinie wertet die Escalated Bezeichnung aus und weist den Auftrag einer der beiden Warteschlangen zu. Die Richtlinie verwendet auch das Regelmodul , um die Priorität des Auftrags von 1 zu erhöhen 10.
var classificationPolicy = await administrationClient.CreateClassificationPolicyAsync(
new CreateClassificationPolicyOptions(classificationPolicyId: "Classify_XBOX_Voice_Jobs")
{
Name = "Classify XBOX Voice Jobs",
QueueSelectorAttachments =
{
new ConditionalQueueSelectorAttachment(
condition: new ExpressionRouterRule("job.Escalated = true"),
queueSelectors: new List<RouterQueueSelector>
{
new (key: "Id", labelOperator: LabelOperator.Equal, value: new RouterValue("XBOX_Escalation_Queue"))
})
},
PrioritizationRule = new ExpressionRouterRule("If(job.Escalated = true, 10, 1)"),
});
var classificationPolicy = await client.path("/routing/classificationPolicies/{classificationPolicyId}", "Classify_XBOX_Voice_Jobs").patch({
body: {
name: "Classify XBOX Voice Jobs",
queueSelectorAttachments: [{
kind: "conditional",
condition: {
kind: "expression",
expression: 'job.Escalated = true'
},
queueSelectors: [{
key: "Id",
labelOperator: "equal",
value: "XBOX_Escalation_Queue"
}]
}],
prioritizationRule: {
kind: "expression",
expression: "If(job.Escalated = true, 10, 1)"
}
},
contentType: "application/merge-patch+json"
});
classification_policy: ClassificationPolicy = administration_client.upsert_classification_policy(
classification_policy_id = "Classify_XBOX_Voice_Jobs",
name = "Classify XBOX Voice Jobs",
queue_selector_attachments = [
ConditionalQueueSelectorAttachment(
condition = ExpressionRouterRule(expression = 'job.Escalated = true'),
queue_selectors = [
RouterQueueSelector(key = "Id", label_operator = LabelOperator.EQUAL, value = "XBOX_Escalation_Queue")
]
)
],
prioritization_rule = ExpressionRouterRule(expression = "If(job.Escalated = true, 10, 1)")))
ClassificationPolicy classificationPolicy = administrationClient.createClassificationPolicy(
new CreateClassificationPolicyOptions("Classify_XBOX_Voice_Jobs")
.setName("Classify XBOX Voice Jobs")
.setQueueSelectorAttachments(List.of(new ConditionalQueueSelectorAttachment(
new ExpressionRouterRule("job.Escalated = true"),
List.of(new RouterQueueSelector("Id", LabelOperator.EQUAL, new RouterValue("XBOX_Escalation_Queue"))))))
.setPrioritizationRule(new ExpressionRouterRule("If(job.Escalated = true, 10, 1)")));
Konfiguration der Ausnahmerichtlinie
Erstellen Sie eine an die Warteschlange angefügte Ausnahmerichtlinie, die zeitauslöst ist, und führt die Aktion des Neuklassifizierungsauftrags aus.
var exceptionPolicy = await administrationClient.CreateExceptionPolicyAsync(new CreateExceptionPolicyOptions(
exceptionPolicyId: "Escalate_XBOX_Policy",
exceptionRules: new List<ExceptionRule>
{
new(
id: "Escalated_Rule",
trigger: new WaitTimeExceptionTrigger(TimeSpan.FromMinutes(5)),
actions: new List<ExceptionAction>
{
new ReclassifyExceptionAction(classificationPolicyId: classificationPolicy.Value.Id)
{
LabelsToUpsert = { ["Escalated"] = new RouterValue(true) }
}
}
)
}) { Name = "Add escalated label and reclassify XBOX Job requests after 5 minutes" });
await client.path("/routing/exceptionPolicies/{exceptionPolicyId}", "Escalate_XBOX_Policy").patch({
body: {
name: "Add escalated label and reclassify XBOX Job requests after 5 minutes",
exceptionRules: [
{
id: "Escalated_Rule",
trigger: { kind: "waitTime", thresholdSeconds: 5 * 60 },
actions: [{ kind: "reclassify", classificationPolicyId: classificationPolicy.body.id, labelsToUpsert: { Escalated: true }}]
}]
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_exception_policy(
exception_policy_id = "Escalate_XBOX_Policy",
name = "Add escalated label and reclassify XBOX Job requests after 5 minutes",
exception_rules = [
ExceptionRule(
id = "Escalated_Rule",
trigger = WaitTimeExceptionTrigger(threshold_seconds = 5 * 60),
actions = [ReclassifyExceptionAction(
classification_policy_id = classification_policy.id,
labels_to_upsert = { "Escalated": True }
)]
)
]
)
administrationClient.createExceptionPolicy(new CreateExceptionPolicyOptions("Escalate_XBOX_Policy",
List.of(new ExceptionAction("Escalated_Rule", new WaitTimeExceptionTrigger(5 * 60),
List.of(new ReclassifyExceptionAction()
.setClassificationPolicyId(classificationPolicy.getId())
.setLabelsToUpsert(Map.of("Escalated", new RouterValue(true))))))
).setName("Add escalated label and reclassify XBOX Job requests after 5 minutes"));
Warteschlangenkonfiguration
Erstellen Sie die erforderlichen Warteschlangen für reguläre und eskalierte Aufträge, und weisen Sie der regulären Warteschlange die Ausnahmerichtlinie zu.
Hinweis
In diesem Schritt wird davon ausgegangen, dass Sie bereits eine Verteilungsrichtlinie mit dem Namen Round_Robin_Policy erstellt haben.
var defaultQueue = await administrationClient.CreateQueueAsync(
new CreateQueueOptions(queueId: "XBOX_Queue", distributionPolicyId: "Round_Robin_Policy")
{
Name = "XBOX Queue",
ExceptionPolicyId = exceptionPolicy.Value.Id
});
var escalationQueue = await administrationClient.CreateQueueAsync(
new CreateQueueOptions(queueId: "XBOX_Escalation_Queue", distributionPolicyId: "Round_Robin_Policy")
{
Name = "XBOX Escalation Queue"
});
await administrationClient.path("/routing/queues/{queueId}", "XBOX_Queue").patch({
body: {
distributionPolicyId: "Round_Robin_Policy",
exceptionPolicyId: exceptionPolicy.body.id,
name: "XBOX Queue"
},
contentType: "application/merge-patch+json"
});
await administrationClient.path("/routing/queues/{queueId}", "XBOX_Escalation_Queue").patch({
body: {
distributionPolicyId: "Round_Robin_Policy",
name: "XBOX Escalation Queue"
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_queue(
queue_id = "XBOX_Queue",
distribution_policy_id = "Round_Robin_Policy",
exception_policy_id = exception_policy.id,
name = "XBOX Queue")
administration_client.upsert_queue(
queue_id = "XBOX_Escalation_Queue",
distribution_policy_id = "Round_Robin_Policy",
name = "XBOX Escalation Queue")
administrationClient.createQueue(new CreateQueueOptions("XBOX_Queue", "Round_Robin_Policy")
.setExceptionPolicyId(exceptionPolicy.getId())
.setName("XBOX Queue"));
administrationClient.createQueue(new CreateQueueOptions("XBOX_Escalation_Queue", "Round_Robin_Policy")
.setName("XBOX Escalation Queue"));
Auftragslebenszyklus
Wenn Sie den Auftrag übermitteln, wird er der Warteschlange XBOX_Queue mit dem voice Kanal hinzugefügt. Für dieses beispiel besteht die Anforderung darin, einen Worker mit einer Bezeichnung namens XBOX_Hardwarezu finden, die einen Wert größer oder gleich der Zahl 7hat.
await client.CreateJobAsync(new CreateJobOptions(jobId: "job1", channelId: "voice", queueId: defaultQueue.Value.Id)
{
RequestedWorkerSelectors =
{
new RouterWorkerSelector(key: "XBOX_Hardware", labelOperator: LabelOperator.GreaterThanOrEqual, value: new RouterValue(7))
}
});
var job = await client.path("/routing/jobs/{jobId}", "job1").patch({
body: {
channelId: "voice",
queueId: defaultQueue.body.id,
requestedWorkerSelectors: [{ key: "XBOX_Hardware", labelOperator: "GreaterThanOrEqual", value: 7 }]
},
contentType: "application/merge-patch+json"
});
administration_client.upsert_job(
job_id = "job1",
channel_id = "voice",
queue_id = default_queue.id,
requested_worker_selectors = [
RouterWorkerSelector(key = "XBOX_Hardware", label_operator = LabelOperator.GreaterThanOrEqual, value = 7)
])
administrationClient.createJob(new CreateJobOptions("job1", "voice", defaultQueue.getId())
.setRequestedWorkerSelectors(List.of(
new RouterWorkerSelector("XBOX_Hardware", LabelOperator.GREATER_THAN_OR_EQUAL, new RouterValue(7)))));
Die folgenden Lebenszyklusschritte treten auf, sobald die Konfiguration abgeschlossen ist und der Auftrag übermittelt wird:
- Der Auftrag wird an den Auftragsrouter gesendet und produziert die
RouterJobReceivedereignisseRouterJobQueued. - Als Nächstes beginnt der 5-Minuten-Timer und löst aus, wenn keine übereinstimmenden Mitarbeiter zugewiesen sind. Nach 5 Minuten gibt der Auftragsrouter ein
RouterJobExceptionTriggeredund ein anderesRouterJobQueuedEreignis aus. - An diesem Punkt wechselt der Auftrag auf die
XBOX_Escalation_QueueUnd die Priorität wird auf festgelegt10.