1use chrono::{DateTime, Utc};
31use rustango::sql::Auto;
32use rustango::Model;
33use serde::{Deserialize, Serialize};
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
41#[serde(rename_all = "snake_case")]
42pub enum WorkflowStatus {
43 InProgress,
44 Approved,
45 NeedsChanges,
46 Cancelled,
47}
48
49impl WorkflowStatus {
50 #[must_use]
51 pub fn as_str(self) -> &'static str {
52 match self {
53 Self::InProgress => "in_progress",
54 Self::Approved => "approved",
55 Self::NeedsChanges => "needs_changes",
56 Self::Cancelled => "cancelled",
57 }
58 }
59
60 #[must_use]
61 pub fn parse(s: &str) -> Option<Self> {
62 Some(match s {
63 "in_progress" => Self::InProgress,
64 "approved" => Self::Approved,
65 "needs_changes" => Self::NeedsChanges,
66 "cancelled" => Self::Cancelled,
67 _ => return None,
68 })
69 }
70}
71
72#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
73#[serde(rename_all = "snake_case")]
74pub enum TaskStatus {
75 InProgress,
76 Approved,
77 Rejected,
78 Skipped,
79}
80
81impl TaskStatus {
82 #[must_use]
83 pub fn as_str(self) -> &'static str {
84 match self {
85 Self::InProgress => "in_progress",
86 Self::Approved => "approved",
87 Self::Rejected => "rejected",
88 Self::Skipped => "skipped",
89 }
90 }
91
92 #[must_use]
93 pub fn parse(s: &str) -> Option<Self> {
94 Some(match s {
95 "in_progress" => Self::InProgress,
96 "approved" => Self::Approved,
97 "rejected" => Self::Rejected,
98 "skipped" => Self::Skipped,
99 _ => return None,
100 })
101 }
102}
103
104#[derive(Model, Debug, Clone, Serialize, Deserialize)]
109#[rustango(
110 table = "cms_workflow",
111 app = "cms",
112 display = "name",
113 admin(
114 list_display = "name, active, created_at",
115 ordering = "name",
116 list_filter = "active",
117 )
118)]
119pub struct Workflow {
120 #[rustango(primary_key)]
121 pub id: Auto<i64>,
122
123 #[rustango(max_length = 100, index)]
126 pub name: String,
127
128 #[rustango(max_length = 255)]
130 pub description: String,
131
132 pub active: bool,
136
137 pub require_reapproval_on_edit: bool,
141
142 #[rustango(auto_now_add)]
143 pub created_at: Auto<DateTime<Utc>>,
144
145 #[rustango(auto_now)]
146 pub updated_at: Auto<DateTime<Utc>>,
147}
148
149#[derive(Model, Debug, Clone, Serialize, Deserialize)]
157#[rustango(
158 table = "cms_workflow_task",
159 app = "cms",
160 display = "name",
161 admin(
162 list_display = "workflow_id, sort_order, name, role_id",
163 ordering = "workflow_id, sort_order",
164 list_filter = "workflow_id",
165 )
166)]
167pub struct WorkflowTask {
168 #[rustango(primary_key)]
169 pub id: Auto<i64>,
170
171 #[rustango(fk = "cms_workflow", on = "id", index)]
172 pub workflow_id: i64,
173
174 #[rustango(max_length = 100)]
177 pub name: String,
178
179 #[rustango(fk = "rustango_roles", on = "id", index)]
183 pub role_id: i64,
184
185 pub sort_order: i32,
188
189 #[rustango(max_length = 64, default = "'group_approval'")]
201 pub kind: String,
202
203 #[rustango(max_length = 500, default = "''")]
206 pub webhook_url: String,
207}
208
209#[derive(Model, Debug, Clone, Serialize, Deserialize)]
216#[rustango(
217 table = "cms_workflow_state",
218 app = "cms",
219 display = "page_id",
220 admin(
221 list_display = "page_id, workflow_id, status, current_task_id, requested_by, requested_at",
222 ordering = "-requested_at",
223 list_filter = "status, workflow_id",
224 )
225)]
226pub struct WorkflowState {
227 #[rustango(primary_key)]
228 pub id: Auto<i64>,
229
230 #[rustango(fk = "cms_page", on = "id", index)]
231 pub page_id: i64,
232
233 #[rustango(fk = "cms_workflow", on = "id", index)]
234 pub workflow_id: i64,
235
236 #[rustango(max_length = 16, index)]
238 pub status: String,
239
240 pub current_task_id: Option<i64>,
243
244 #[rustango(fk = "rustango_users", on = "id", index)]
246 pub requested_by: i64,
247
248 #[rustango(auto_now_add)]
249 pub requested_at: Auto<DateTime<Utc>>,
250
251 pub finished_at: Option<DateTime<Utc>>,
254}
255
256#[derive(Model, Debug, Clone, Serialize, Deserialize)]
262#[rustango(
263 table = "cms_task_state",
264 app = "cms",
265 display = "id",
266 admin(
267 list_display = "workflow_state_id, task_id, status, decided_by, decided_at",
268 ordering = "-decided_at",
269 list_filter = "status",
270 )
271)]
272pub struct TaskState {
273 #[rustango(primary_key)]
274 pub id: Auto<i64>,
275
276 #[rustango(fk = "cms_workflow_state", on = "id", index)]
277 pub workflow_state_id: i64,
278
279 #[rustango(fk = "cms_workflow_task", on = "id", index)]
280 pub task_id: i64,
281
282 #[rustango(max_length = 16, index)]
284 pub status: String,
285
286 pub comment: String,
289
290 pub decided_by: Option<i64>,
293
294 pub decided_at: Option<DateTime<Utc>>,
295}
296
297pub async fn active_state_for_page(
309 pool: &rustango::sql::Pool,
310 page_id: i64,
311) -> Result<Option<WorkflowState>, rustango::sql::ExecError> {
312 Ok(latest_state_for_page(pool, page_id).await?.filter(|st| {
316 st.status == WorkflowStatus::InProgress.as_str() || st.status == WorkflowStatus::NeedsChanges.as_str()
317 }))
318}
319
320pub async fn latest_state_for_page(
325 pool: &rustango::sql::Pool,
326 page_id: i64,
327) -> Result<Option<WorkflowState>, rustango::sql::ExecError> {
328 use rustango::core::Column as _;
329 use rustango::sql::FetcherPool as _;
330
331 let rows: Vec<WorkflowState> = WorkflowState::objects()
332 .where_(WorkflowState::page_id.eq(page_id))
333 .order_by(&[("requested_at", true), ("id", true)]) .fetch(pool)
335 .await?;
336 Ok(rows.into_iter().next())
337}
338
339pub async fn history_for_page(
345 pool: &rustango::sql::Pool,
346 page_id: i64,
347) -> Result<Vec<TaskState>, rustango::sql::ExecError> {
348 use rustango::core::Column as _;
349 use rustango::sql::FetcherPool as _;
350
351 let ids: Vec<i64> = WorkflowState::objects()
352 .where_(WorkflowState::page_id.eq(page_id))
353 .fetch(pool)
354 .await?
355 .into_iter()
356 .filter_map(|st| st.id.get().copied())
357 .collect();
358 if ids.is_empty() {
359 return Ok(Vec::new());
360 }
361 TaskState::objects()
362 .where_(TaskState::workflow_state_id.is_in(ids))
363 .order_by(&[("id", false)])
364 .fetch(pool)
365 .await
366}
367
368pub async fn find_by_name(
377 pool: &rustango::sql::Pool,
378 name: &str,
379) -> Result<Option<Workflow>, rustango::sql::ExecError> {
380 use rustango::core::Column as _;
381 use rustango::sql::FetcherPool as _;
382
383 let rows: Vec<Workflow> = Workflow::objects()
384 .where_(Workflow::name.eq(name.to_owned()))
385 .where_(Workflow::active.eq(true))
386 .fetch(pool)
387 .await?;
388 Ok(rows.into_iter().next())
389}
390
391pub async fn review_workflow_for_type(
400 pool: &rustango::sql::Pool,
401 page_type_id: i64,
402) -> Result<Option<Workflow>, rustango::sql::ExecError> {
403 use rustango::core::Column as _;
404
405 let Some(pt) = crate::page_type_model::PageType::objects()
406 .where_(crate::page_type_model::PageType::id.eq(page_type_id))
407 .first(pool)
408 .await?
409 else {
410 return Ok(None);
411 };
412 let Some(name) = pt.workflow_name() else {
413 return Ok(None);
414 };
415 let Some(wf) = find_by_name(pool, &name).await? else {
416 return Ok(None);
417 };
418 let has_steps = !tasks_for(pool, wf.id.get().copied().unwrap_or_default()).await?.is_empty();
419 Ok(has_steps.then_some(wf))
420}
421
422pub async fn page_types_using(
427 pool: &rustango::sql::Pool,
428 name: &str,
429) -> Result<Vec<crate::page_type_model::PageType>, rustango::sql::ExecError> {
430 use rustango::core::Column as _;
431 use rustango::sql::FetcherPool as _;
432 crate::page_type_model::PageType::objects()
433 .where_(crate::page_type_model::PageType::workflow.eq(name.to_owned()))
434 .fetch(pool)
435 .await
436}
437
438pub async fn rebind_page_types(
444 pool: &rustango::sql::Pool,
445 old: &str,
446 new: &str,
447) -> Result<usize, rustango::sql::ExecError> {
448 let types = page_types_using(pool, old).await?;
449 let n = types.len();
450 for mut pt in types {
451 new.clone_into(&mut pt.workflow);
452 pt.save_pool(pool).await?;
453 }
454 Ok(n)
455}
456
457pub async fn tasks_for(
462 pool: &rustango::sql::Pool,
463 workflow_id: i64,
464) -> Result<Vec<WorkflowTask>, rustango::sql::ExecError> {
465 use rustango::core::Column as _;
466 use rustango::sql::FetcherPool as _;
467
468 WorkflowTask::objects()
469 .where_(WorkflowTask::workflow_id.eq(workflow_id))
470 .order_by(&[("sort_order", false), ("id", false)])
471 .fetch(pool)
472 .await
473}
474
475pub async fn submit_for_review(
483 pool: &rustango::sql::Pool,
484 page_id: i64,
485 workflow: &Workflow,
486 tasks: &[WorkflowTask],
487 requested_by: i64,
488) -> Result<WorkflowState, rustango::sql::ExecError> {
489 use rustango::sql::Auto;
490
491 let workflow_id = workflow.id.get().copied().unwrap_or_default();
492 let first_task_id = tasks.first().and_then(|t| t.id.get().copied());
493
494 let mut state = WorkflowState {
495 id: Auto::Unset,
496 page_id,
497 workflow_id,
498 status: WorkflowStatus::InProgress.as_str().to_owned(),
499 current_task_id: first_task_id,
500 requested_by,
501 requested_at: Auto::Unset,
502 finished_at: None,
503 };
504 state.insert_pool(pool).await?;
505
506 if let Some(task_id) = first_task_id {
507 let state_id = state.id.get().copied().unwrap_or_default();
508 let mut ts = TaskState {
509 id: Auto::Unset,
510 workflow_state_id: state_id,
511 task_id,
512 status: TaskStatus::InProgress.as_str().to_owned(),
513 comment: String::new(),
514 decided_by: None,
515 decided_at: None,
516 };
517 ts.insert_pool(pool).await?;
518 }
519
520 advance_through_auto_approve_chain(pool, &mut state, tasks, page_id, requested_by).await?;
524 Ok(state)
525}
526
527async fn advance_through_auto_approve_chain(
534 pool: &rustango::sql::Pool,
535 state: &mut WorkflowState,
536 tasks: &[WorkflowTask],
537 page_id: i64,
538 requested_by: i64,
539) -> Result<(), rustango::sql::ExecError> {
540 use crate::page::Page;
541 use rustango::core::Column as _;
542 use rustango::sql::Auto;
543
544 let page: Page = match Page::objects()
547 .where_(Page::id.eq(page_id))
548 .first(pool)
549 .await?
550 {
551 Some(p) => p,
552 None => return Ok(()),
553 };
554
555 loop {
556 let Some(current_task_id) = state.current_task_id else {
557 return Ok(());
558 };
559 let Some(current_task) = tasks
560 .iter()
561 .find(|t| t.id.get().copied() == Some(current_task_id))
562 else {
563 return Ok(());
564 };
565 let kind = crate::task_kind::find(¤t_task.kind)
566 .unwrap_or_else(|| Box::new(crate::task_kind::GroupApprovalKind));
567 let ctx = crate::task_kind::AssignedTask {
568 task: current_task,
569 page: &page,
570 requested_by,
571 };
572 match kind.on_assign(&ctx) {
573 crate::task_kind::AssignOutcome::WaitForHuman => return Ok(()),
574 crate::task_kind::AssignOutcome::AutoApprove => {
575 let state_id = state.id.get().copied().unwrap_or_default();
578 let now = Utc::now();
579 if let Some(mut ts) = TaskState::objects()
580 .where_(TaskState::workflow_state_id.eq(state_id))
581 .where_(TaskState::task_id.eq(current_task_id))
582 .where_(TaskState::status.eq(TaskStatus::InProgress.as_str().to_owned()))
583 .first(pool)
584 .await?
585 {
586 ts.status = TaskStatus::Approved.as_str().to_owned();
587 ts.decided_by = None;
588 ts.decided_at = Some(now);
589 ts.comment = format!("auto-approved by `{}` task kind", current_task.kind);
590 ts.save_pool(pool).await?;
591 }
592
593 let current_sort = current_task.sort_order;
594 let next = tasks
595 .iter()
596 .filter(|t| t.sort_order > current_sort)
597 .min_by_key(|t| t.sort_order);
598 if let Some(next_task) = next {
599 let next_id = next_task.id.get().copied().unwrap_or_default();
600 state.current_task_id = Some(next_id);
601 state
606 .save_partial(&["status", "current_task_id", "finished_at"], pool)
607 .await?;
608 let mut ts = TaskState {
609 id: Auto::Unset,
610 workflow_state_id: state_id,
611 task_id: next_id,
612 status: TaskStatus::InProgress.as_str().to_owned(),
613 comment: String::new(),
614 decided_by: None,
615 decided_at: None,
616 };
617 ts.insert_pool(pool).await?;
618 } else {
622 state.current_task_id = None;
623 state.status = WorkflowStatus::Approved.as_str().to_owned();
624 state.finished_at = Some(now);
625 state
630 .save_partial(&["status", "current_task_id", "finished_at"], pool)
631 .await?;
632 return Ok(());
633 }
634 }
635 }
636 }
637}
638
639#[derive(Debug, Clone)]
644pub enum ApproveOutcome {
645 Advanced { next_task_id: i64 },
646 Finished,
647 AlreadyDecided,
652}
653
654async fn claim_task(
658 pool: &rustango::sql::Pool,
659 state_id: i64,
660 task_id: i64,
661 to: TaskStatus,
662 decided_by: i64,
663 comment: &str,
664) -> Result<bool, rustango::sql::ExecError> {
665 use rustango::core::{Column as _, SqlValue};
666 use rustango::sql::UpdaterPool as _;
667 let changed = TaskState::objects()
668 .where_(TaskState::workflow_state_id.eq(state_id))
669 .where_(TaskState::task_id.eq(task_id))
670 .where_(TaskState::status.eq(TaskStatus::InProgress.as_str().to_owned()))
671 .update()
672 .set("status", SqlValue::from(to.as_str()))
673 .set("decided_by", SqlValue::from(decided_by))
674 .set("decided_at", SqlValue::from(Utc::now()))
675 .set("comment", SqlValue::from(comment.to_owned()))
676 .execute_pool(pool)
677 .await?;
678 Ok(changed > 0)
679}
680
681pub async fn approve_current(
688 pool: &rustango::sql::Pool,
689 state: &mut WorkflowState,
690 tasks: &[WorkflowTask],
691 decided_by: i64,
692 comment: &str,
693) -> Result<ApproveOutcome, rustango::sql::ExecError> {
694 use rustango::sql::Auto;
695
696 let state_id = state.id.get().copied().unwrap_or_default();
697 let current_task_id = state.current_task_id.unwrap_or_default();
698 let now = Utc::now();
699
700 let Some(current_sort) = tasks
704 .iter()
705 .find(|t| t.id.get().copied() == Some(current_task_id))
706 .map(|t| t.sort_order)
707 else {
708 return Ok(ApproveOutcome::AlreadyDecided);
709 };
710
711 if !claim_task(pool, state_id, current_task_id, TaskStatus::Approved, decided_by, comment).await? {
715 return Ok(ApproveOutcome::AlreadyDecided);
716 }
717
718 let next = tasks
720 .iter()
721 .filter(|t| t.sort_order > current_sort)
722 .min_by_key(|t| t.sort_order);
723
724 if let Some(next_task) = next {
725 let next_id = next_task.id.get().copied().unwrap_or_default();
726 state.current_task_id = Some(next_id);
727 state.status = WorkflowStatus::InProgress.as_str().to_owned();
728 state
733 .save_partial(&["status", "current_task_id", "finished_at"], pool)
734 .await?;
735
736 let mut ts = TaskState {
737 id: Auto::Unset,
738 workflow_state_id: state_id,
739 task_id: next_id,
740 status: TaskStatus::InProgress.as_str().to_owned(),
741 comment: String::new(),
742 decided_by: None,
743 decided_at: None,
744 };
745 ts.insert_pool(pool).await?;
746
747 advance_through_auto_approve_chain(pool, state, tasks, state.page_id, decided_by).await?;
751 if state.status == WorkflowStatus::Approved.as_str() {
752 Ok(ApproveOutcome::Finished)
753 } else if let Some(advanced_id) = state.current_task_id {
754 Ok(ApproveOutcome::Advanced {
755 next_task_id: advanced_id,
756 })
757 } else {
758 Ok(ApproveOutcome::Finished)
759 }
760 } else {
761 state.current_task_id = None;
762 state.status = WorkflowStatus::Approved.as_str().to_owned();
763 state.finished_at = Some(now);
764 state
769 .save_partial(&["status", "current_task_id", "finished_at"], pool)
770 .await?;
771 Ok(ApproveOutcome::Finished)
772 }
773}
774
775pub async fn reject_current(
784 pool: &rustango::sql::Pool,
785 state: &mut WorkflowState,
786 decided_by: i64,
787 comment: &str,
788) -> Result<bool, rustango::sql::ExecError> {
789 let state_id = state.id.get().copied().unwrap_or_default();
790 let current_task_id = state.current_task_id.unwrap_or_default();
791 let now = Utc::now();
792
793 if !claim_task(pool, state_id, current_task_id, TaskStatus::Rejected, decided_by, comment).await? {
796 return Ok(false);
797 }
798
799 state.status = WorkflowStatus::NeedsChanges.as_str().to_owned();
800 state.finished_at = Some(now);
801 state
804 .save_partial(&["status", "current_task_id", "finished_at"], pool)
805 .await?;
806 Ok(true)
807}
808
809pub async fn cancel(
818 pool: &rustango::sql::Pool,
819 state: &mut WorkflowState,
820 decided_by: i64,
821) -> Result<(), rustango::sql::ExecError> {
822 use rustango::core::Column as _;
823 use rustango::sql::FetcherPool as _;
824
825 let state_id = state.id.get().copied().unwrap_or_default();
826 let now = Utc::now();
827
828 let inflight: Vec<TaskState> = TaskState::objects()
829 .where_(TaskState::workflow_state_id.eq(state_id))
830 .where_(TaskState::status.eq(TaskStatus::InProgress.as_str().to_owned()))
831 .fetch(pool)
832 .await?;
833 for mut ts in inflight {
834 ts.status = TaskStatus::Skipped.as_str().to_owned();
835 ts.decided_by = Some(decided_by);
836 ts.decided_at = Some(now);
837 ts.save_pool(pool).await?;
838 }
839
840 state.status = WorkflowStatus::Cancelled.as_str().to_owned();
841 state.finished_at = Some(now);
842 state.current_task_id = None;
843 state
846 .save_partial(&["status", "current_task_id", "finished_at"], pool)
847 .await?;
848 crate::pending_change::discard(pool, state.page_id).await?;
850 Ok(())
851}
852
853pub async fn has_prior_approval(
861 pool: &rustango::sql::Pool,
862 page_id: i64,
863) -> Result<bool, rustango::sql::ExecError> {
864 use rustango::core::Column as _;
865 use rustango::sql::FetcherPool as _;
866
867 let rows: Vec<WorkflowState> = WorkflowState::objects()
868 .where_(WorkflowState::page_id.eq(page_id))
869 .where_(WorkflowState::status.eq(WorkflowStatus::Approved.as_str().to_owned()))
870 .fetch(pool)
871 .await?;
872 Ok(!rows.is_empty())
873}
874