rate-app 0.39.0

RillRate App
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

use super::state::{DashboardState, DashboardStructure, PATHS};
use rate_ui::shared_object::SharedObject;
use rate_ui::widget::wired_widget::{SingleFlowMeta, WiredWidget};
use rate_ui::widget::{Context, Widget, WidgetRuntime};
use rill_protocol::io::provider::Path;
use rrpack_prime::manifest::paths::{PathsSpec, PathsState};
use yew::Html;

pub type Loader = WidgetRuntime<LoaderWidget>;

pub struct LoaderWidget {
    paths: SharedObject<DashboardState>,
}

impl Default for LoaderWidget {
    fn default() -> Self {
        Self {
            paths: PATHS.with(SharedObject::clone),
        }
    }
}

impl Widget for LoaderWidget {
    type Event = ();
    type Tag = Option<Path>;
    type Properties = ();
    type Meta = SingleFlowMeta<Self>;

    fn init(&mut self, ctx: &mut Context<Self>) {
        let path = PathsSpec::path().of_server();
        ctx.rewire(path);
    }

    fn view(&self, _ctx: &Context<Self>) -> Html {
        Html::default()
    }
}

impl WiredWidget<SingleFlowMeta<Self>> for LoaderWidget {
    type Flow = PathsState;

    fn state_changed(&mut self, _reloaded: bool, ctx: &mut Context<Self>) {
        // TODO: Consider to process deltas instead!
        let mut new_structure = DashboardStructure::default();
        if let Some(state) = ctx.meta().state() {
            //log::error!("DASHBOARD: {:?}", state);
            for path in state.records.keys().cloned() {
                let mut items = path.into_iter();

                let packages = &mut new_structure.packages;
                if let Some(package) = items.next() {
                    let dashboards = packages.entry(package).or_default();
                    if let Some(dashboard) = items.next() {
                        let groups = dashboards.entry(dashboard).or_default();
                        if let Some(group) = items.next() {
                            let streams = groups.entry(group).or_default();
                            if let Some(stream) = items.next() {
                                streams.insert(stream);
                            }
                        }
                    }
                }
            }
            let mut paths = self.paths.write();
            paths.structure = new_structure;
            // TODO: Avoid cloning here!!!
            paths.descs = state.records.clone();
        }
    }
}