shield-dioxus 0.3.0

Dioxus integration for Shield.
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

use dioxus::prelude::*;
use serde_json::Value;
use shield::{ActionForms, ResponseType};

use crate::{query::Query, style::ErasedDioxusStyle};

#[derive(Clone, PartialEq, Props)]
pub struct ActionProps {
    #[props(default = "index".to_owned())]
    action_id: String,
    query: String,
}

#[component]
pub fn Action(props: ActionProps) -> Element {
    let response = use_server_future({
        let action_id = props.action_id.clone();

        move || forms(action_id.clone())
    })?;
    let style = use_context::<ErasedDioxusStyle>();

    let response_read = response.read();
    let response = response_read.as_ref().unwrap();

    use_context_provider(|| Query::parse(&props.query));

    match response {
        Ok(forms) => style.render(forms),
        Err(err) => rsx! { "{err}" },
    }
}

#[get("/api/auth/forms", parts: dioxus::fullstack::http::request::Parts)]
async fn forms(action_id: String) -> Result<ActionForms> {
    use anyhow::anyhow;

    use crate::integration::DioxusIntegrationDyn;

    let integration = parts
        .extensions
        .get::<DioxusIntegrationDyn>()
        .ok_or_else(|| anyhow!("Dioxus Shield integration should be extracted."))?;
    let shield = integration.extract_shield(&parts.extensions)?;
    let session = integration.extract_session(&parts.extensions)?;

    let forms = shield
        .action_forms(&action_id, session)
        .await
        .context("Failed to get Shield action forms.")?;

    Ok(forms)
}

#[post("/api/auth/call", parts: dioxus::fullstack::http::request::Parts)]
pub async fn call(
    action_id: String,
    // TODO: Would be nice if this argument could fill up with all unknown keys instead of setting name to `data[...]`.
    data: Value,
) -> Result<ResponseType> {
    use anyhow::anyhow;
    use serde_json::Value;
    use shield::Request;

    use crate::integration::DioxusIntegrationDyn;

    tracing::info!("call data {data:#?}");

    let integration = parts
        .extensions
        .get::<DioxusIntegrationDyn>()
        .ok_or_else(|| anyhow!("Dioxus Shield integration should be extracted."))?;
    let shield = integration.extract_shield(&parts.extensions)?;
    let session = integration.extract_session(&parts.extensions)?;

    let response = shield
        .call(
            &action_id,
            session,
            Request {
                query: Value::Null,
                form_data: data,
            },
        )
        .await
        .context("Failed to call Shield action.")?;

    Ok(response)
}

#[post("/api/auth/call-method", parts: dioxus::fullstack::http::request::Parts)]
pub async fn call_method(
    action_id: String,
    method_id: String,
    provider_id: Option<String>,
    // TODO: Would be nice if this argument could fill up with all unknown keys instead of setting name to `data[...]`.
    data: Value,
) -> Result<ResponseType> {
    use anyhow::anyhow;
    use serde_json::Value;
    use shield::Request;

    use crate::integration::DioxusIntegrationDyn;

    tracing::info!("call method data {data:#?}");

    let integration = parts
        .extensions
        .get::<DioxusIntegrationDyn>()
        .ok_or_else(|| anyhow!("Dioxus Shield integration should be extracted."))?;
    let shield = integration.extract_shield(&parts.extensions)?;
    let session = integration.extract_session(&parts.extensions)?;

    let response = shield
        .call_method(
            &action_id,
            &method_id,
            provider_id.as_deref(),
            session,
            Request {
                query: Value::Null,
                form_data: data,
            },
        )
        .await
        .context("Failed to call Shield method action.")?;

    Ok(response)
}