pib-viewer 0.5.0

A viewer for public governmental data served over OParl
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

// SPDX-FileCopyrightText: Politik im Blick developers
// SPDX-FileCopyrightText: Wolfgang Silbermayr <wolfgang@silbermayr.at>
//
// SPDX-License-Identifier: AGPL-3.0-or-later OR EUPL-1.2

use dioxus::{
    hooks::{use_resource, use_signal},
    prelude::{Props, component, dioxus_elements, rsx},
    signals::ReadableExt as _,
};
use dioxus_core::Element;
use dioxus_router::Link;
use oparl_types::MeetingUrl;

use crate::{
    client::{get_body, get_meeting, get_organization},
    components::{AgendaItemList, OrganizationList},
    route::{Route, UrlEncoded},
};

#[derive(Debug, Clone, PartialEq, Props)]
pub struct MeetingProps {
    meeting_url: UrlEncoded<MeetingUrl>,
}

struct MeetingData {
    meeting: oparl_types::Meeting,
    body: oparl_types::Body,
    organizations: Vec<oparl_types::Organization>,
}

impl MeetingData {
    async fn get(meeting_url: &MeetingUrl) -> Result<Self, String> {
        let meeting = get_meeting(meeting_url).await?;

        let mut organizations = Vec::new();

        for organization in &meeting.organization {
            let organization = get_organization(organization).await?;
            organizations.push(organization);
        }

        let Some(organization) = organizations.first() else {
            return Err("Couldn't load body from list of organizations".to_string());
        };
        let body = get_body(organization.body.as_ref().unwrap()).await?;

        Ok(Self {
            meeting,
            organizations,
            body,
        })
    }
}

#[component]
pub fn Meeting(props: MeetingProps) -> Element {
    let meeting_url = use_signal(|| props.meeting_url.get_inner().unwrap().clone());
    let data = { use_resource(move || async move { MeetingData::get(&meeting_url()).await }) };
    rsx! {
        match &*data.read_unchecked() {
            Some(Ok(data)) => rsx! {
                if let Some(name) = &data.meeting.name {
                    dioxus::document::Title { "🗣️ {name}" }
                } else {
                    dioxus::document::Title { "🗣️ Unknown" }
                }
                h1 {
                    "🗣️ ",
                    if let Some(name) = &data.meeting.name {
                        "{name}"
                    } else {
                        i {
                            "Unknown"
                        }
                    }
                }
                Link {
                    to: Route::Body{body_url: UrlEncoded::from(data.body.id.clone())},
                    "🏛️ { data.body.name }"
                }
                AgendaItemList {
                    agenda_items: data.meeting.agenda_item.clone()
                }
                OrganizationList {
                    organizations: data.organizations.clone()
                }
            },
            Some(Err(e)) => rsx! {
                dioxus::document::Title { "Loading failed." },
                p { "Loading meeting failed, {e}" }
            },
            None =>  rsx! {
                dioxus::document::Title { "Loading…" },
                p { "Loading..." }
            }
        }

        hr {},

        "Meeting URL: {meeting_url}"
    }
}