Quy trình (*.bpmn, DMN)
Việc nghiệp vụ trải qua nhiều bước: hẹn giờ, chờ sự kiện, chờ người duyệt. Vẽ quy trình bằng BPMN (chuẩn Camunda 8 / Zeebe), quyết định theo số bằng bảng DMN; manh.run lưu trạng thái và chạy tiếp đúng lúc.
app/orders/
├── checkout.bpmn # mô hình BPMN (vẽ bằng công cụ BPMN bất kỳ, chuẩn Camunda 8 / Zeebe)
├── reserve.task.ts # service task type="orders/reserve"
├── approval.dmn # bảng quyết định DMN (số tiền → ai duyệt); businessRuleTask gọi tới
├── post.ts # start("app/orders/checkout.bpmn", …)
└── [no]/pay/post.ts # send("order:" + no, "paid", …)Vai trò
Dùng khi một việc nghiệp vụ trải qua thời gian: đơn hàng tự huỷ nếu 24 giờ chưa thanh toán, đơn lớn cần quản lý duyệt và tự leo thang sau 2 ngày, chuỗi mail chăm sóc khách. Trong lúc quy trình đang chờ thì không có gì chạy, không tốn tài nguyên. Trạng thái nằm trong cơ sở dữ liệu của app. Một việc chậm chạy một lần sau request thì dùng *.job.ts; một chuỗi bước kỹ thuật viết bằng code thì xem *.workflow.ts.
Export
*.bpmn: một<process>chạy được. Service task trỏ tới handler bằngzeebe:taskDefinition type, điều kiện viết bằng FEEL (=total >= 1000). Business rule task trỏ tới một bảng quyết định DMN bằngzeebe:calledDecision decisionId+resultVariable.*.task.ts:defaultlà hàmasync (input, ctx)trả về object; giá trị trả về thành biến của quy trình. Type mặc định là đường dẫn bỏapp/và.task.ts.*.dmn: một hay nhiều<decision id>dạng bảng quyết định (DMN 1.3, vẽ bằng công cụ DMN bất kỳ). Mỗi ô là FEEL (không có dấu=đứng đầu): cột input là biểu thức trên biến, ô input của một dòng là “unary test” (< 20000000,[20..100),"VN",-là bất kỳ), ô output là biểu thức. Hit policy: UNIQUE (mặc định), FIRST, COLLECT.
Ví dụ
import { BpmnError } from "manh/workflow";
import { reserveStock } from "./repository";
export default async function (input: { orderId: number }) {
const ok = await reserveStock(input.orderId);
if (!ok) throw new BpmnError("OUT_OF_STOCK", "Hết hàng"); // đi theo boundary error có mã này
return { reserved: true };
}import { start } from "manh/workflow";
export default async (c, { body }) => {
const order = await createOrder(body);
start("app/orders/checkout.bpmn", { orderId: order.id, total: order.total }, { key: "order:" + order.id });
return order;
};import { tasks } from "manh/workflow";
export const access = ["manager"];
export default () => tasks({ group: "manager" }); // hộp việc cần duyệt; completeTask(id, data) để duyệtQuy tắc “theo số tiền” (đơn mua > 20 triệu thì cần trưởng phòng, > 100 triệu thì cần giám đốc) nên viết thành bảng quyết định DMN rồi cho một businessRuleTask gọi tới, thay vì chuỗi điều kiện FEEL dài trên gateway:
<decision id="approval" name="Ai duyệt đơn mua"><decisionTable hitPolicy="FIRST">
<input id="i1" label="Số tiền"><inputExpression typeRef="number"><text>amount</text></inputExpression></input>
<output id="o1" name="approver" typeRef="string"/>
<rule><inputEntry><text>< 20000000</text></inputEntry><outputEntry><text>"truong_nhom"</text></outputEntry></rule>
<rule><inputEntry><text>[20000000..100000000)</text></inputEntry><outputEntry><text>"truong_phong"</text></outputEntry></rule>
<rule><inputEntry><text>>= 100000000</text></inputEntry><outputEntry><text>"giam_doc"</text></outputEntry></rule>
</decisionTable></decision><bpmn:businessRuleTask id="who"><bpmn:extensionElements>
<zeebe:calledDecision decisionId="approval" resultVariable="approver" />
</bpmn:extensionElements></bpmn:businessRuleTask>
<!-- sau đó user task để assignee="=approver", hoặc gateway rẽ theo =approver = "giam_doc" -->Một quy trình duyệt mua hàng đầy đủ: duyệt nhiều cấp (bảng DMN chọn cấp theo số tiền), duyệt song song nhiều người (multi-instance), và nhắc quá hạn (boundary timer không ngắt, bỏ cuối tuần + ngày lễ):
<!-- 1) Duyệt nhiều cấp: bảng DMN chọn những người phải ký theo số tiền -->
<bpmn:businessRuleTask id="chon"><bpmn:extensionElements>
<zeebe:calledDecision decisionId="approval" resultVariable="nguoiKy" />
</bpmn:extensionElements></bpmn:businessRuleTask>
<!-- 2) Duyệt song song nhiều người: mỗi người một việc, ra một token khi xong hết (hoặc đủ 2 phiếu) -->
<bpmn:userTask id="duyet" name="Duyệt đơn"><bpmn:extensionElements>
<zeebe:assignmentDefinition assignee="=nguoi" />
<zeebe:loopCharacteristics inputCollection="=nguoiKy" inputElement="nguoi"
outputCollection="phieu" outputElement="=dongY" />
</bpmn:extensionElements>
<bpmn:multiInstanceLoopCharacteristics isSequential="false">
<bpmn:completionCondition>=count(phieu) >= 2</bpmn:completionCondition>
</bpmn:multiInstanceLoopCharacteristics></bpmn:userTask>
<!-- 3) Nhắc quá hạn: hẹn giờ KHÔNG NGẮT sau 1 ngày làm việc (bỏ cuối tuần + lễ VN); việc duyệt vẫn mở -->
<bpmn:boundaryEvent id="nhac" cancelActivity="false" attachedToRef="duyet">
<bpmn:extensionElements><zeebe:properties><zeebe:property name="calendar" value="vn" /></zeebe:properties></bpmn:extensionElements>
<bpmn:timerEventDefinition><bpmn:timeDuration>P1D</bpmn:timeDuration></bpmn:timerEventDefinition>
</bpmn:boundaryEvent>
<bpmn:sequenceFlow id="r1" sourceRef="nhac" targetRef="guiNhac" /> <!-- nhánh phụ: gửi email nhắc -->Tách một quy trình dùng lại thành file riêng rồi gọi nó: “duyệt hợp đồng” gọi “duyệt ngân sách”.
<!-- call activity: chạy app/ngansach/duyet-ngan-sach.bpmn thành một lượt con, chờ xong rồi đi tiếp -->
<bpmn:callActivity id="duyetNganSach" name="Duyệt ngân sách">
<bpmn:extensionElements><zeebe:calledElement processId="duyet-ngan-sach" />
<zeebe:ioMapping>
<zeebe:input source="=giaTriHopDong" target="soTien" /> <!-- biến vào lượt con -->
<zeebe:output source="=ketQua" target="nganSachOk" /> <!-- biến lấy ra -->
</zeebe:ioMapping></bpmn:extensionElements></bpmn:callActivity><bpmn:process id="duyet-ngan-sach" isExecutable="true">
<bpmn:startEvent id="s" /> <!-- … các bước duyệt ngân sách, đặt biến ketQua … --> <bpmn:endEvent id="e" />
</bpmn:process>Cần biết
- Hỗ trợ: start, end, terminate, service / send, user, script (FEEL), business rule (bảng quyết định DMN), receive, exclusive, parallel, inclusive (rẽ mọi nhánh điều kiện đúng; nhập chờ mọi token còn có thể tới), event-based gateway, timer và message, boundary timer / error / message, sub-process lồng và call activity, cùng vòng lặp chuẩn, sự kiện điều kiện và sub-process ad-hoc (bên dưới). Phần tử chưa hỗ trợ (ad-hoc tuần tự, sub-process theo sự kiện kích bằng timer…) bị
checkbáo lỗi kèm id phần tử. - Sub-process lồng (
<bpmn:subProcess>): một khối có start / luồng / end riêng (cần đúng một start và ít nhất một end). Một token vào start trong, chạy luồng trong, rồi một token ra tiếp trên nhánh của sub-process khi luồng trong kết thúc. Dùng để gắn một boundary cho cả khối: boundary timer huỷ cả khối rồi đi nhánh quá hạn, hoặc boundary error bắtBpmnErrordo bất kỳ task nào bên trong ném. Lỗi trong khối (kể cảBpmnErrorkhông ai bắt ở trong) leo tới boundary error của sub-process; không có boundary nào khớp → lượt dừng ở sự cố. Sub-process dùng chung biến của lượt (ghi bên trong thì phần còn lại của lượt thấy). Multi-instance trên sub-process chưa mở (đặt multi-instance lên task bên trong). - Call activity (
<bpmn:callActivity>+<zeebe:calledElement processId="..." />): chạy một.bpmnkhác (theo<process id>) thành một lượt con riêng — có dòng lượt riêng, việc / hẹn giờ / sự cố riêng, hiện trong danh sách lượt. Lượt cha chờ ở call cho tới khi lượt con xong rồi mới đi tiếp. Mặc định truyền hết biến của cha vào con và lấy hết biến của con ra; thêmzeebe:ioMappingđể ánh xạ chọn lọc. Lượt con gặp sự cố thì cha đứng chờ ở call (sửa rồi thử lại lượt con là cha chạy tiếp); con thất bại / bị huỷ thì cha vào sự cố. Huỷ cha thì huỷ luôn con.checkbáo lỗi nếucalledElementtrỏ tới process id không.bpmnnào định nghĩa, và một process không được tự gọi chính nó. - Boundary không ngắt (
cancelActivity="false", timer hoặc message): mở một nhánh phụ (nhắc hạn, điều phối) mà không huỷ việc chính — việc chính vẫn chạy. Boundary ngắt (mặc định) thì huỷ việc chính rồi đi theo nhánh. SLA/hạn chót = userTask + boundary timer không ngắt. - Hạn xử lý (SLA): đặt
<zeebe:taskSchedule dueDate="P1D"/>cho user task (thời lượng ISO tính từ lúc mở việc, một mốc ngày giờ, hoặc=FEEL). Hộp việc hiện badge “sắp đến hạn” / “quá hạn” và sắp theo hạn; cờoverduetính lúc đọc, không ghi thêm. Nhắc khi quá hạn là boundary timer không ngắt ở trên. - Multi-instance (
multiInstanceLoopCharacteristicstrên một task): chạy một bản cho mỗi phần tử củainputCollection(danh sách FEEL),inputElementlà biến cục bộ cho phần tử.isSequential="false"= song song (“duyệt song song nhiều người”, mở hết các việc cùng lúc);true= tuần tự, xong cái này mới mở cái sau. Ra đúng một token khi mọi bản xong hoặccompletionConditionđúng;outputCollectiongom kết quả theo thứ tự (service task gom vào đây, không trộn vào biến chung để tránh tranh chấp). - Lịch làm việc VN: thêm
zeebe:property name="calendar" value="vn"vào event có hẹn giờ → thời lượng tính theo ngày làm việc, bỏ Thứ Bảy / Chủ Nhật và ngày lễ (Tết, Giỗ Tổ, 30/4, 1/5, 2/9); một hạn rơi vào cuối tuần / lễ sẽ dời sang ngày làm việc kế. Chỉ dùng cho đơn vị ngày/tuần (không dùng tháng/năm). Danh sách lễ âm lịch cập nhật theo năm. - Bảng DMN: một ô là FEEL (không có
=đầu). Hit policy UNIQUE (mặc định, khớp quá một dòng thì lượt dừng ở sự cố), FIRST (dòng khớp đầu tiên thắng), COLLECT (danh sách mọi dòng khớp). Không khớp dòng nào →null(UNIQUE/FIRST) hoặc[](COLLECT). Một cột output → chính giá trị; nhiều cột → object.businessRuleTasktrỏ tới decision không có →checkbáo lỗi. - Cùng
keykhi quy trình còn chạy thìstarttrả lại lượt cũ, không tạo trùng. - Deploy bản mô hình mới không làm lượt đang chạy đổi hướng: lượt đó chạy hết theo bản cũ.
- Gọi
start,send,completeTasktrong post / put / patch / delete, không gọi trongget.ts. checkđọc thử mọi biểu thức FEEL (điều kiện, ioMapping, script, hẹn giờ) và báo lỗi cú pháp kèm id phần tử.- Điều kiện phải ra
truehoặcfalse. Thiếu biến (=amount > 1000khi chưa cóamount), service task hết lượt thử, hay thiếu handler thì lượt dừng ở trạng thái sự cố (INCIDENT) chứ không tự rẽ nhánh mặc định. Sửa dữ liệu hoặc deploy bản sửa rồi bấm Thử lại, lượt chạy tiếp từ đúng bước đó. - Xem từng bước, thử lại bước lỗi, huỷ lượt ở Vận hành › Quy trình.
Hộp việc “Việc cần làm”
Người dùng làm các bước user task ngay trong app. tasks({ user }) là hộp việc của người đang đăng nhập (việc giao cho họ, họ nhận, hay nhóm của họ); tasks({ requested: user }) là những việc họ khởi tạo và đang chờ người khác — họ thấy nhưng không hoàn tất thay được; tasks({ group }) là việc còn trống của một nhóm. Mỗi việc có assignee, requestedBy (ai kích hoạt lượt — truyền start(path, input, { by: user.id })), dueAt và cờ overdue.
import { reassignTask, notifications, markRead } from "manh/process";
export default async (c, { user, body }) => {
// chỉ người đang xử lý được việc (assignee / nhận / nhóm), hoặc admin app ({ admin: true }), mới chuyển được
await reassignTask(body.taskId, { to: body.to, reason: body.reason }, user);
return { bell: await notifications({ user, unread: true }) }; // thông báo trong app (không gửi email)
};reassignTask / delegateTask chuyển việc cho người khác: người mới làm được, người cũ không; taskHistory(id) giữ lịch sử. Thông báo chạy trong app (notifications, markRead) — mỗi sự kiện một dòng (được giao / chuyển / quá hạn / xong). Khối tasklist dựng sẵn trang /tasks với đủ các tab, badge hạn, nút chuyển người và chuông thông báo.
Phân tích
Ở Vận hành › Phân tích có sẵn mấy cách đọc số liệu của một quy trình theo khoảng thời gian, tính thẳng từ lịch sử lượt chạy (không cần cấu hình gì):
- Heatmap — tô lên sơ đồ: mỗi bước chạy bao nhiêu lần, lâu bao nhiêu (trung bình / p50 / p90), người chờ nhận việc bao lâu; đường đi đậm theo lưu lượng.
- Biến thể — các đường đi mà những lượt chạy thật sự đã theo. Một biến thể là dãy các bước một lượt đã chạy, theo thứ tự, tới tận bước kết thúc (nên hai lượt khác kết cục — duyệt xong, bị từ chối, quá hạn leo thang — là hai biến thể khác nhau). Bảng xếp hạng cho biết đường nào phổ biến nhất: số case, tỉ lệ, thời gian trung vị; phần còn lại gom vào dòng “Khác”. Bấm một biến thể để tô đường của nó lên sơ đồ và xem danh sách các case đã đi đường đó.
- So sánh — đặt hai nhóm case cạnh nhau (mặc định: khoảng trước và khoảng hiện tại, ví dụ trước và sau một lần đổi mô hình) rồi xem cái gì đổi. Mỗi nhóm là một khoảng thời gian; bảng cho biết với từng chỉ số, nhóm A so với nhóm B và mức chênh: phân bố biến thể (biến thể nào tăng, giảm, mới xuất hiện hay không còn), thời gian từng bước (trung vị / p90), tỉ lệ rẽ mỗi nhánh của mỗi gateway, và thông lượng (số case, tỉ lệ hoàn tất, thời gian chạy trung bình). Luôn ghi rõ số case mỗi nhóm; chênh lệch đọc là “đi kèm”, không phải nhân quả. Phân bố biến thể cần chi tiết từng lượt (giữ 30 ngày) nên một nhóm cũ hơn 30 ngày sẽ không có phần đó.
- Hành trình — chọn một case (bấm một dòng trong danh sách case của Biến thể hay của Bước chậm) để xem trọn đường đi của lượt đó theo thứ tự: mỗi bước đã chạy kèm loại, giờ bắt đầu / kết thúc, thời gian và kết cục; cổng rẽ nhánh đi nhánh nào (và bỏ nhánh nào); việc của người thì ai nhận, ai làm, chờ bao lâu và làm bao lâu, hạn và các lần chuyển việc; sự cố kèm lỗi; dữ liệu mỗi bước trả về và các biến của lượt (có giới hạn). Đường đi được tô lên sơ đồ. Chỉ một lượt chạy của một process; chi tiết lượt giữ 30 ngày. Vị trí cổng rẽ nhánh trên dòng thời gian được suy ra từ các luồng đã đi (cổng không ghi dòng riêng).
- Tuân thủ — đo các lượt chạy thật lệch bao xa khỏi một đường chuẩn. Đường chuẩn mặc định là biến thể chạy nhiều nhất trong khoảng; bạn có thể ghim một biến thể khác (chọn từ danh sách) làm “đường lý tưởng”. Một case tuân thủ khi dãy bước của nó đúng bằng đường chuẩn. Trang cho biết tỉ lệ tuân thủ, rồi với các case lệch: bước nào bị bỏ qua (có trong đường chuẩn nhưng case không chạy), bước nào ngoài đường chuẩn (case chạy mà đường chuẩn không có), và chỗ đi lệch đầu tiên (sau bước nào của đường chuẩn thì đường của case bắt đầu khác) — cho thấy các lượt hay “đi sai kịch bản” ở đâu — cùng các biến thể lệch phổ biến nhất (bấm một biến thể để tô bước ngoài đường chuẩn lên sơ đồ). Cần chi tiết từng lượt nên chỉ đọc 30 ngày gần nhất. Đây là mục cuối của bộ phân tích biến thể (Biến thể, So sánh, Hành trình, Tuân thủ).
- Bước chậm — bước nào mất nhiều thời gian nhất trên ngưỡng p90, các lượt chậm nhất, và những biến dữ liệu hay đi cùng lượt chậm.
- Nhánh — với một gateway và một bước kết thúc: bao nhiêu phần trăm lượt rẽ mỗi nhánh thì tới được kết thúc đó.
- Việc người — thời gian chờ nhận / thời gian làm theo nhóm, theo người, theo bước.
Số liệu tính từ lịch sử từng lượt trong 30 ngày gần nhất; khoảng dài hơn dùng bảng gộp theo ngày (giữ 13 tháng). Riêng Biến thể, Bước chậm và Nhánh cần chi tiết từng lượt nên luôn gói về 30 ngày.
Tín hiệu, giao dịch và bù trừ
Hai mảnh cuối cho quy trình nghiệp vụ thật: một sự kiện báo cho nhiều lượt cùng lúc, và cách hoàn tác sạch khi một chuỗi bước hỏng giữa chừng.
- Tín hiệu (signal) là phát một lần, nhiều nơi cùng nghe. Message qua
sendtới đúng một lượt; tín hiệu thì một lần ném tới mọi chỗ đang chờ cùng tên tín hiệu trong các lượt đang chạy của app (phạm vi là trong một app, không vượt sang app khác). Khai báo<bpmn:signal name="paid"/>rồi trỏ bằngsignalRef. Ném ở intermediate throw event hoặc end event (signalEventDefinition); bắt ở intermediate catch event hoặc boundary event gắn trên một việc (ngắt, hoặccancelActivity="false"thì không ngắt — mở một nhánh phụ mà việc vẫn chạy); hoặc đặtsignalEventDefinitionlên start event của một quy trình để một lần phát khởi một lượt mới của quy trình đó. Chỗ bắt nào không đang chờ lúc ném thì không nhận được (tín hiệu không giữ lại) — cần đúng một lượt nhận và có thể tới sớm thì dùng message. Một lần ném mà không có chỗ nào đang chờ thì không ghi gì. - Giao dịch (transaction) và bù trừ (compensation) — hoàn tác kiểu saga. Gói những bước cần hoàn tác gọn gàng (giữ hàng, trừ tiền thẻ, đặt chỗ) vào một
<bpmn:transaction>(chạy như một sub-process lồng). Mỗi việc đảo được gắn một boundary bù trừ (<bpmn:boundaryEvent><bpmn:compensateEventDefinition/>) nối bằng<bpmn:association sourceRef="<boundary>" targetRef="<handler>"/>tới một việc xử lý bù trừ đánh dấuisForCompensation="true"(một service hoặc script task —undoBook,refund); việc này nằm ngoài luồng chính, chỉ chạy khi bù trừ. Mỗi việc chạy xong được ghi nhớ. Kích hoạt bù trừ bằng một cancel end event (<bpmn:endEvent><bpmn:cancelEventDefinition/>trong giao dịch) hoặc một compensation throw (<bpmn:intermediateThrowEvent><bpmn:compensateEventDefinition/>): các việc đã xong được hoàn tác theo thứ tự ngược (cái làm sau cùng được đảo trước), việc chưa chạy thì bỏ qua. Cancel end còn huỷ giao dịch và đi theo nhánh của cancel boundary (<bpmn:boundaryEvent><bpmn:cancelEventDefinition/>gắn trên giao dịch); compensation throw thì bù trừ xong rồi chạy tiếp. Một handler ném lỗi thì lượt dừng ở sự cố; thử lại chạy tiếp từ đúng handler đó (nên viết handler đảo được lặp lại nhiều lần vẫn đúng). Giới hạn đã biết: bù trừ kích hoạt từ bên trong giao dịch (giao dịch đã xong thì không bù trừ từ ngoài), handler bù trừ là một service hoặc script task (không phải user task hay cả một luồng con), và handler đọc biến hiện tại của lượt.
Sub-process theo sự kiện và escalation
Phản ứng với chuyện xảy ra bên trong một phạm vi (cả quy trình hoặc một sub-process) mà không phải vẽ boundary lên từng bước.
- Sub-process theo sự kiện (
<bpmn:subProcess triggeredByEvent="true">) nằm trong phạm vi, không có đường nối vào hay ra. Sự kiện bắt đầu của chính nó quyết định khi nào chạy: lỗiBpmnErrortrong phạm vi, một signal, một escalation hoặc một message gửi bằngsend. Nó chỉ “mở tai” khi phạm vi đang chạy, và dùng chung biến với phạm vi đó. - Ngắt (mặc định, luôn thế với lỗi): các token còn lại trong phạm vi bị huỷ (việc người đang mở được đóng), phần xử lý chạy, rồi phạm vi hoàn tất và luồng đi tiếp sau nó. Không ngắt (
isInterrupting="false"): phần xử lý chạy ở nhánh phụ, phạm vi vẫn chạy, và mỗi signal / message / escalation tới là một lần chạy mới. Phạm vi chưa hoàn tất khi còn một phần xử lý đang chạy. - Escalation là thông báo đi lên, không phải lỗi. Khai báo
<bpmn:escalation id="late" escalationCode="LATE"/>, ném bằng intermediate throw hoặc end event (escalationEventDefinition), bắt bằng boundary escalation trên một sub-process (ngắt, hoặccancelActivity="false") hay bằng sub-process theo sự kiện. Đi từ trong ra ngoài: ở mỗi phạm vi xét sub-process theo sự kiện trước, rồi boundary trên sub-process, rồi phạm vi bên ngoài. Không ai bắt thì bỏ qua, bên ném cứ đi tiếp; bắt kiểu không ngắt thì bên ném vẫn đi tiếp; bắt kiểu ngắt thì huỷ phạm vi nơi bắt. - Giới hạn: sub-process theo sự kiện kích bằng timer bị
checktừ chối (cần đồng hồ ngoài), hãy dùng boundary timer trên sub-process; escalation không đi xuyên qua call activity sang lượt cha; boundary escalation chỉ gắn lên sub-process; signal / message chỉ bắt được khi lượt đang chờ đúng lúc đó.
Vòng lặp, điều kiện và bước ad-hoc
Ba dạng nữa cho quy trình phải lặp lại, chờ dữ liệu, hoặc để người làm tự chọn thứ tự.
- Vòng lặp chuẩn. Thêm
<bpmn:standardLoopCharacteristics testBefore="true" loopMaximum="5"><bpmn:loopCondition>=lan_thu < 3</bpmn:loopCondition></bpmn:standardLoopCharacteristics>vào service, user hoặc script task, business rule task hay sub-process lồng, bước đó sẽ chạy lặp từng vòng một chừng nào điều kiện còn đúng.testBefore="true"(mặc định) kiểm tra trước, nên điều kiện sai ngay từ đầu thì bước không chạy lần nào;testBefore="false"chạy một lần rồi mới kiểm tra.loopMaximum(1 đến 1000) dừng vòng lặp êm khi chạm mức đó. Không đặt thì có trần cứng 1000 vòng: quá mức đó mà điều kiện vẫn đúng, lượt chạy dừng ở sự cố thay vì quay mãi. Điều kiện phải trả về đúng hoặc sai, nên biến chưa có hay gõ sai đều thành sự cố, giống như ở gateway. Muốn “mỗi phần tử của một danh sách một lần” thì dùng multi-instance; hai kiểu này không đi chung một task. - Sự kiện điều kiện.
<bpmn:conditionalEventDefinition><bpmn:condition>=dung = true</bpmn:condition></bpmn:conditionalEventDefinition>dùng được làm boundary (ngắt hoặccancelActivity="false"), làm intermediate catch chờ tới khi điều kiện đúng (đúng sẵn lúc tới nơi thì đi tiếp ngay), hoặc làm điểm bắt đầu của sub-process theo sự kiện. Điều kiện đọc biến của quy trình và được kiểm tra khi phần tử bắt đầu hoạt động, rồi sau mỗi bước đã chạy trong lần đánh thức (xong một việc, chạy một script, nhận một message). Đây không phải theo dõi trực tiếp: biến chỉ đổi khi lượt đang chạy, nên không có gì quét định kỳ và không đặt timer. Điều kiện về giờ giấc hay về một bảng sẽ không bao giờ được nhận ra; hãy dùng timer, hoặc đọc giá trị đó vào biến bằng một script task trước. Biến chưa có tính là sai. Boundary hay sub-process theo sự kiện không ngắt chỉ kích một lần mỗi khi điều kiện chuyển từ sai sang đúng, không kích ở mọi lần kiểm tra. - Sub-process ad-hoc.
<bpmn:adHocSubProcess>cho mọi hoạt động bên trong mà không có đường nối vào chạy cùng lúc, mỗi cái chạy độc lập. Không cần start hay end event.<bpmn:completionCondition>=da_duyet = true</bpmn:completionCondition>(tuỳ chọn) được kiểm tra mỗi khi một hoạt động bên trong xong; khi đúng, những hoạt động còn đang chạy bị huỷ (việc người đang mở được đóng) và quy trình đi tiếp sau sub-process. Không có điều kiện hoàn tất thì sub-process kết thúc khi mọi hoạt động đã xong. Mỗi hoạt động chạy một lần, muốn lặp thì gắn vòng lặp chuẩn lên nó.ordering="Sequential"bị từ chối vì không có gì chọn hoạt động kế tiếp: hãy nối các bước bằng đường nối tuần tự.
Sự kiện liên kết: nhảy tới bước khác trong cùng quy trình
Sơ đồ dài hay có đường nối chạy ngang cả trang. Sự kiện liên kết (link) thay những đường đó bằng một cặp nhãn: chỗ nhảy đi và chỗ nhảy tới.
- Cách viết. Chỗ nhảy đi là
<bpmn:intermediateThrowEvent><bpmn:linkEventDefinition name="duyet-lai"/></bpmn:intermediateThrowEvent>. Chỗ nhảy tới là<bpmn:intermediateCatchEvent><bpmn:linkEventDefinition name="duyet-lai"/></bpmn:intermediateCatchEvent>. Lượt chạy đi tới sự kiện nhảy đi thì chuyển ngay sang sự kiện nhận cùng tên và tiếp tục theo đường nối ra của nó. Nhảy ngược lên trên cũng được, nên dùng làm vòng “làm lại”. - Ghép theo tên, trong một cấp. Mỗi tên có đúng một sự kiện nhận và một hay nhiều sự kiện nhảy đi (cùng nhảy về chỗ đó). Cả hai nằm chung một cấp: cùng ở quy trình chính, hoặc cùng nằm trong một sub-process lồng. Nhảy qua ranh giới sub-process bị từ chối, trong sub-process ad-hoc cũng không dùng được. Sự kiện nhảy đi không có đường nối ra, sự kiện nhận không có đường nối vào.
- Không chờ gì cả. Đây không phải message: bước nhảy xảy ra ngay trong lần đánh thức đang chạy, không đổi biến, không ghi dòng sự kiện nào.
checktừ chối tên thiếu nơi nhận, nơi nhận không ai nhảy tới, hai nơi nhận cùng tên, hoặc cặp nằm ở hai cấp khác nhau, kèm id phần tử.
Tự khởi động quy trình: hẹn giờ và message
Hai cách bắt đầu một quy trình ngoài việc gọi start().
- Start bằng hẹn giờ. Gắn cron vào start event của quy trình:
<bpmn:startEvent id="daily"><bpmn:timerEventDefinition><bpmn:timeCycle>0 9 * * 1-5</bpmn:timeCycle></bpmn:timerEventDefinition></bpmn:startEvent>. Đó là cron 5 trường theo giờ UTC, giống file.cron.ts, và start event không nhận gì khác: không cótimeDate,timeDuration, hay khoảng lặpR/PT1H. Mỗi lần đến giờ, một lượt chạy mới bắt đầu với biến rỗng. Lần bị lỡ không được xếp hàng bù, và lượt đang chạy không ngăn lần sau khởi động. Lịch này tính vào giới hạn cron của app như mọi cron khác. - Start bằng message. Gắn
<bpmn:messageEventDefinition messageRef="M1"/>vào start event, khai báo<bpmn:message id="M1" name="order.placed"/>trong file. Khi đósend("app/orders/checkout.bpmn", "order.placed", { orderId: 12 })(đường dẫn quy trình đứng ở chỗ id lượt chạy) khởi động một lượt mới và trả về id của nó; object bạn gửi trở thành biến của quy trình. Mỗi lầnsendkhớp là một lượt riêng: chưa có kiểu “khớp thì chuyển tới lượt đang chạy, không thì mới khởi động” theo khoá. Tên mà start event không nghe thìsendchạy như cũ tới một lượt.
Một quy trình chỉ có một start event, nên nó bắt đầu theo một trong các cách: thường, bằng signal, bằng hẹn giờ hoặc bằng message. Trong Playground trên trình duyệt, message start chạy qua send; hẹn giờ chỉ kích khi bạn tua nhanh đồng hồ của bản demo.
Bước tiếp theo
- *.workflow.ts — chuỗi bước kỹ thuật viết bằng code, chạy trên cùng engine.
- *.job.ts — một việc chậm chạy nền sau request.
- *.cron.ts — chạy theo lịch, có thể gọi
startđể mở quy trình mỗi sáng.