dpm-interchange 0.1.0

Bounded project-file interchange for reviewed DPM plan proposals
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

//! The local fields a candidate changes on existing work, stated as before/after values so the
//! report describes the mutation itself rather than what the source contained.

use crate::mspdi::report::FieldChange;
use dpm_model::{Key, ThreePointEstimate, WorkItem, WorkItemId};
use std::collections::BTreeMap;

/// Fields an import maps; every other work field is local and never changes.
pub(super) fn between(
    before: &WorkItem,
    after: &WorkItem,
    keys: &BTreeMap<WorkItemId, &Key>,
) -> Vec<FieldChange> {
    let parent = |parent: Option<WorkItemId>| {
        parent.map_or_else(
            || "(top level)".to_owned(),
            |id| {
                keys.get(&id)
                    .map_or_else(|| id.to_string(), |k| k.0.clone())
            },
        )
    };
    let fields = [
        ("title", before.title.clone(), after.title.clone()),
        (
            "order",
            format!("{:?}", before.order.0),
            format!("{:?}", after.order.0),
        ),
        (
            "objective",
            before.contract.objective.clone(),
            after.contract.objective.clone(),
        ),
        (
            "kind",
            format!("{:?}", before.kind),
            format!("{:?}", after.kind),
        ),
        ("parent", parent(before.parent), parent(after.parent)),
        (
            "priority",
            format!("{:?}", before.schedule.priority),
            format!("{:?}", after.schedule.priority),
        ),
        (
            "estimate",
            estimate(before.schedule.estimate),
            estimate(after.schedule.estimate),
        ),
        (
            "calendar",
            calendar(before.schedule.calendar.as_deref()),
            calendar(after.schedule.calendar.as_deref()),
        ),
    ];
    fields
        .into_iter()
        .filter(|(_, from, to)| from != to)
        .map(|(field, before, after)| FieldChange {
            field: field.into(),
            before,
            after,
        })
        .collect()
}

fn calendar(name: Option<&str>) -> String {
    name.map_or_else(|| "(resolved by executor)".to_owned(), str::to_owned)
}

fn estimate(estimate: Option<ThreePointEstimate>) -> String {
    estimate.map_or_else(
        || "unestimated".to_owned(),
        |e| {
            format!(
                "O={} M={} P={} h",
                e.optimistic_hours, e.likely_hours, e.pessimistic_hours
            )
        },
    )
}