kanban-persistence 0.7.0

Persistence traits and shared types for the kanban project management tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use chrono::Utc;
use kanban_domain::card::{Card, CardPriority, CardStatus};
use kanban_domain::sprint::{Sprint, SprintStatus};
use kanban_domain::Snapshot;
use kanban_domain::{ArchivedCard, Board, Column, DependencyGraph, SprintLog};
use uuid::Uuid;

pub fn fully_populated_snapshot() -> Snapshot {
    let board_id = Uuid::new_v4();
    let col_id = Uuid::new_v4();
    let sprint_id = Uuid::new_v4();
    let card_id = Uuid::new_v4();
    let archived_card_inner_id = Uuid::new_v4();
    let now = Utc::now();

    let board = Board {
        id: board_id,
        name: "Full Board".into(),
        description: Some("Board desc".into()),
        sprint_prefix: Some("sprint".into()),
        card_prefix: Some("FB".into()),
        task_sort_field: kanban_domain::board::SortField::Priority,
        task_sort_order: kanban_domain::board::SortOrder::Descending,
        sprint_duration_days: Some(14),
        sprint_names: vec!["Alpha".into(), "Beta".into()],
        sprint_name_used_count: 1,
        next_sprint_number: 3,
        active_sprint_id: Some(sprint_id),
        task_list_view: kanban_domain::task_list_view::TaskListView::GroupedByColumn,
        card_counter: 4,
        sprint_counters: {
            let mut m = std::collections::HashMap::new();
            m.insert("sprint".into(), 3u32);
            m
        },
        completion_column_id: Some(col_id),
        position: 0,
        created_at: now,
        updated_at: now,
    };

    let column = Column {
        id: col_id,
        board_id,
        name: "Full Col".into(),
        position: 0,
        wip_limit: Some(5),
        created_at: now,
        updated_at: now,
    };

    let sprint = Sprint {
        id: sprint_id,
        board_id,
        sprint_number: 2,
        name_index: Some(0),
        prefix: Some("sprint".into()),
        card_prefix: Some("TASK".into()),
        status: SprintStatus::Active,
        start_date: Some(now),
        end_date: Some(now),
        created_at: now,
        updated_at: now,
    };

    let card = Card {
        id: card_id,
        column_id: col_id,
        title: "Full Card".into(),
        description: Some("desc".into()),
        priority: CardPriority::High,
        status: CardStatus::InProgress,
        position: 0,
        due_date: Some(now),
        points: Some(3),
        card_number: 1,
        sprint_id: Some(sprint_id),
        created_at: now,
        updated_at: now,
        completed_at: None,
        sprint_logs: vec![SprintLog {
            sprint_id,
            sprint_number: 2,
            sprint_name: Some("Alpha".into()),
            started_at: now,
            ended_at: None,
            status: "Active".into(),
        }],
    };

    let archived_card = ArchivedCard {
        card: Card {
            id: archived_card_inner_id,
            column_id: col_id,
            title: "Archived Card".into(),
            description: Some("archived desc".into()),
            priority: CardPriority::Critical,
            status: CardStatus::Done,
            position: 1,
            due_date: Some(now),
            points: Some(5),
            card_number: 2,
            sprint_id: Some(sprint_id),
            created_at: now,
            updated_at: now,
            completed_at: Some(now),
            sprint_logs: vec![],
        },
        archived_at: now,
        original_column_id: col_id,
        original_position: 1,
    };

    use kanban_core::EdgeBase;
    use kanban_domain::{BlocksEdge, RelatesEdge, RelatesKind, Severity};
    let graph = DependencyGraph::from_validated_per_kind_edges(
        vec![],
        vec![BlocksEdge {
            base: EdgeBase {
                source: card_id,
                target: archived_card_inner_id,
                created_at: now,
                archived_at: None,
            },
            severity: Severity::default(),
        }],
        vec![RelatesEdge {
            base: EdgeBase {
                source: card_id,
                target: archived_card_inner_id,
                created_at: now,
                archived_at: Some(now),
            },
            kind: RelatesKind::default(),
        }],
    )
    .expect("test fixture edges must validate");

    Snapshot {
        boards: vec![board],
        columns: vec![column],
        cards: vec![card],
        archived_cards: vec![archived_card],
        sprints: vec![sprint],
        graph,
    }
}