niloecl 0.2.0

An implementation of the axum handler pattern for twilight interactions
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

use serde_json::Value;
use twilight_model::application::interaction::{
    modal::ModalInteractionComponent, Interaction, InteractionData,
};

use crate::{handler::FromRequest, into_response_impls::BasicErrorReport, IntoResponse};

#[derive(Debug, PartialEq, Eq, Hash, serde::Deserialize)]
pub struct ModalSubmit<T> {
    pub custom_id: String,
    pub data: T,
}

impl<S: Sync, T: for<'a> serde::Deserialize<'a>> FromRequest<S> for ModalSubmit<T> {
    type Rejection = ModalSubmitError;

    async fn from_request(req: &mut Interaction, _: &S) -> Result<Self, Self::Rejection> {
        let Some(InteractionData::ModalSubmit(ms)) = &req.data else {
            return if req.data.is_some() {
                Err(ModalSubmitError::WrongInteractionData)
            } else {
                Err(ModalSubmitError::NoInteractionData)
            };
        };

        let mut json_map = serde_json::Map::with_capacity(ms.components.len());

        for component in &ms.components {
            map_component_extend(component, &mut json_map);
        }

        Ok(Self {
            custom_id: ms.custom_id.clone(),
            data: serde_json::from_value(Value::Object(json_map))?,
        })
    }
}

macro_rules! jsonify_array {
    ($map:expr, $val:expr) => {{
        $map.insert(
            $val.custom_id.clone(),
            Value::Array(
                $val.values
                    .iter()
                    .map(|v| Value::String(v.to_string()))
                    .collect(),
            ),
        );
    }};
}

fn map_component_extend(
    component: &ModalInteractionComponent,
    map: &mut serde_json::Map<String, Value>,
) {
    match component {
        ModalInteractionComponent::Label(mil) => map_component_extend(&mil.component, map),
        ModalInteractionComponent::ActionRow(ar) => {
            for subcomponent in &ar.components {
                map_component_extend(subcomponent, map);
            }
        }
        ModalInteractionComponent::StringSelect(ss) => jsonify_array!(map, ss),
        ModalInteractionComponent::UserSelect(us) => jsonify_array!(map, us),
        ModalInteractionComponent::RoleSelect(rs) => jsonify_array!(map, rs),
        ModalInteractionComponent::MentionableSelect(ms) => jsonify_array!(map, ms),
        ModalInteractionComponent::TextInput(ti) => {
            map.insert(ti.custom_id.clone(), Value::String(ti.value.clone()));
        }
        ModalInteractionComponent::ChannelSelect(cs) => jsonify_array!(map, cs),
        ModalInteractionComponent::FileUpload(fu) => jsonify_array!(map, fu),
        ModalInteractionComponent::TextDisplay(_) | ModalInteractionComponent::Unknown(_) => {}
    }
}

#[derive(Debug)]
pub enum ModalSubmitError {
    SerdeJson(serde_json::Error),
    WrongInteractionData,
    NoInteractionData,
}

impl From<serde_json::Error> for ModalSubmitError {
    fn from(value: serde_json::Error) -> Self {
        Self::SerdeJson(value)
    }
}

impl std::fmt::Display for ModalSubmitError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let message = match self {
            Self::SerdeJson(_) => "Could not deserialize custom modal struct",
            Self::WrongInteractionData => "Invalid interaction data",
            Self::NoInteractionData => "No interaction data",
        };
        f.write_str(message)
    }
}

impl IntoResponse for ModalSubmitError {
    fn into_response(self) -> twilight_model::http::interaction::InteractionResponse {
        BasicErrorReport(self).into_response()
    }
}