peace_webi_components 0.0.15

Web interface components for the peace automation framework.
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

use dot_ix::{
    model::{common::GraphvizDotTheme, info_graph::InfoGraph},
    rt::IntoGraphvizDotSrc,
    web_components::DotSvg,
};
use leptos::{
    component,
    prelude::{ClassAttribute, ElementChild, ServerFnError, Set, Transition},
    server, view, IntoView,
};

/// Renders the flow graph.
///
/// # Future
///
/// * Take in whether any execution is running. Use that info to style
///   nodes/edges.
/// * Take in values so they can be rendered, or `WriteSignal`s, to notify the
///   component that will render values about which node is selected.
#[component]
pub fn FlowGraph() -> impl IntoView {
    view! {
        <div class="flex items-center justify-center">
            <ProgressGraph />
            <OutcomeGraph />
        </div>
    }
}

#[server]
async fn progress_info_graph_fetch() -> Result<InfoGraph, ServerFnError> {
    use leptos::prelude::{Get, ReadSignal};
    use peace_flow_model::FlowId;
    use peace_webi_model::FlowProgressInfoGraphs;

    let flow_id = leptos::prelude::use_context::<ReadSignal<FlowId>>();
    let flow_progress_info_graphs =
        leptos::prelude::use_context::<FlowProgressInfoGraphs<FlowId>>();
    let progress_info_graph = if let Some(flow_progress_info_graphs) = flow_progress_info_graphs {
        let flow_progress_info_graphs = flow_progress_info_graphs.lock().ok();

        flow_id
            .as_ref()
            .map(Get::get)
            .zip(flow_progress_info_graphs)
            .and_then(|(flow_id, flow_progress_info_graphs)| {
                flow_progress_info_graphs.get(&flow_id).cloned()
            })
            .unwrap_or_default()
    } else {
        InfoGraph::default()
    };

    Ok(progress_info_graph)
}

#[component]
fn ProgressGraph() -> impl IntoView {
    let (progress_info_graph, progress_info_graph_set) =
        leptos::prelude::signal(InfoGraph::default());
    let (dot_src_and_styles, dot_src_and_styles_set) = leptos::prelude::signal(None);

    leptos::prelude::LocalResource::new(move || async move {
        let progress_info_graph = progress_info_graph_fetch().await.unwrap_or_default();
        let dot_src_and_styles =
            IntoGraphvizDotSrc::into(&progress_info_graph, &GraphvizDotTheme::default());

        if let Ok(progress_info_graph_serialized) = serde_yaml::to_string(&progress_info_graph) {
            leptos::logging::log!("{progress_info_graph_serialized}");
        }

        progress_info_graph_set.set(progress_info_graph);
        dot_src_and_styles_set.set(Some(dot_src_and_styles));
    });

    view! {
        <Transition fallback=move || view! { <p>"Loading graph..."</p> }>
            <DotSvg
                info_graph=progress_info_graph.into()
                dot_src_and_styles=dot_src_and_styles.into()
            />
        </Transition>
    }
}

#[server]
async fn outcome_info_graph_fetch() -> Result<InfoGraph, ServerFnError> {
    use leptos::prelude::{Get, ReadSignal};
    use peace_flow_model::FlowId;
    use peace_webi_model::FlowOutcomeInfoGraphs;

    let flow_id = leptos::prelude::use_context::<ReadSignal<FlowId>>();
    let flow_outcome_info_graphs = leptos::prelude::use_context::<FlowOutcomeInfoGraphs<FlowId>>();
    let outcome_info_graph = if let Some(flow_outcome_info_graphs) = flow_outcome_info_graphs {
        let flow_outcome_info_graphs = flow_outcome_info_graphs.lock().ok();

        flow_id
            .as_ref()
            .map(Get::get)
            .zip(flow_outcome_info_graphs)
            .and_then(|(flow_id, flow_outcome_info_graphs)| {
                flow_outcome_info_graphs.get(&flow_id).cloned()
            })
            .unwrap_or_default()
    } else {
        InfoGraph::default()
    };

    Ok(outcome_info_graph)
}

#[component]
fn OutcomeGraph() -> impl IntoView {
    let (outcome_info_graph, outcome_info_graph_set) =
        leptos::prelude::signal(InfoGraph::default());
    let (dot_src_and_styles, dot_src_and_styles_set) = leptos::prelude::signal(None);

    leptos::prelude::LocalResource::new(move || async move {
        let outcome_info_graph = outcome_info_graph_fetch().await.unwrap_or_default();
        let dot_src_and_styles =
            IntoGraphvizDotSrc::into(&outcome_info_graph, &GraphvizDotTheme::default());

        if let Ok(outcome_info_graph_serialized) = serde_yaml::to_string(&outcome_info_graph) {
            leptos::logging::log!("{outcome_info_graph_serialized}");
        }

        outcome_info_graph_set.set(outcome_info_graph);
        dot_src_and_styles_set.set(Some(dot_src_and_styles));
    });

    view! {
        <Transition fallback=move || view! { <p>"Loading graph..."</p> }>
            <DotSvg
                info_graph=outcome_info_graph.into()
                dot_src_and_styles=dot_src_and_styles.into()
            />
        </Transition>
    }
}