synpad 0.1.0

A full-featured Matrix chat client built with Dioxus
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

use dioxus::prelude::*;
use matrix_sdk::ruma::OwnedRoomId;

use crate::components::avatar::Avatar;
use crate::state::app_state::AppState;

/// Preview bar shown when an invited room is selected - shows Accept/Decline.
#[component]
pub fn InvitePreviewBar(
    room_id: String,
    room_name: String,
    avatar_url: Option<String>,
    inviter: Option<String>,
) -> Element {
    let mut state = use_context::<Signal<AppState>>();
    let mut is_accepting = use_signal(|| false);
    let mut is_declining = use_signal(|| false);
    let mut error_msg = use_signal(|| Option::<String>::None);

    let accept_room_id = room_id.clone();
    let on_accept = move |_| {
        let rid = accept_room_id.clone();
        is_accepting.set(true);
        error_msg.set(None);
        spawn(async move {
            let client = { state.read().client.clone() };
            if let Some(client) = client {
                if let Ok(room_id) = OwnedRoomId::try_from(rid.as_str()) {
                    if let Some(room) = client.get_room(&room_id) {
                        match room.join().await {
                            Ok(_) => {
                                tracing::info!("Accepted invite for {room_id}");
                                state.write().active_room_id = Some(room_id);
                            }
                            Err(e) => {
                                tracing::error!("Failed to accept invite: {e}");
                                error_msg.set(Some(format!("Failed to join: {e}")));
                            }
                        }
                    }
                }
            }
            is_accepting.set(false);
        });
    };

    let decline_room_id = room_id.clone();
    let on_decline = move |_| {
        let rid = decline_room_id.clone();
        is_declining.set(true);
        error_msg.set(None);
        spawn(async move {
            let client = { state.read().client.clone() };
            if let Some(client) = client {
                if let Ok(room_id) = OwnedRoomId::try_from(rid.as_str()) {
                    if let Some(room) = client.get_room(&room_id) {
                        match room.leave().await {
                            Ok(_) => {
                                tracing::info!("Declined invite for {room_id}");
                                state.write().active_room_id = None;
                            }
                            Err(e) => {
                                tracing::error!("Failed to decline invite: {e}");
                                error_msg.set(Some(format!("Failed to decline: {e}")));
                            }
                        }
                    }
                }
            }
            is_declining.set(false);
        });
    };

    let inviter_text = inviter
        .map(|i| format!("{i} invited you"))
        .unwrap_or_else(|| "You've been invited".to_string());

    let has_error = error_msg.read().is_some();
    let err_text = error_msg.read().clone().unwrap_or_default();

    rsx! {
        div {
            class: "invite-preview",

            div {
                class: "invite-preview__info",
                Avatar {
                    name: room_name.clone(),
                    url: avatar_url,
                    size: 48,
                }
                div {
                    class: "invite-preview__text",
                    h3 { class: "invite-preview__room-name", "{room_name}" }
                    p { class: "invite-preview__inviter", "{inviter_text}" }
                }
            }

            if has_error {
                div {
                    class: "invite-preview__error",
                    "{err_text}"
                }
            }

            div {
                class: "invite-preview__actions",
                button {
                    class: "btn btn--secondary",
                    disabled: *is_declining.read() || *is_accepting.read(),
                    onclick: on_decline,
                    if *is_declining.read() { "Declining..." } else { "Decline" }
                }
                button {
                    class: "btn btn--primary",
                    disabled: *is_accepting.read() || *is_declining.read(),
                    onclick: on_accept,
                    if *is_accepting.read() { "Accepting..." } else { "Accept" }
                }
            }
        }
    }
}