Struct slack_morphism::errors::SlackClientProtocolError

source · 
pub struct SlackClientProtocolError {
    pub json_error: Error,
    pub json_body: Option<String>,
}

Fields§

§json_error: Error§json_body: Option<String>

Implementations§

Examples found in repository?
src/errors.rs (line 211)
209
210
211
212
213

pub fn map_serde_error(err: serde_json::Error, tried_to_parse: Option<&str>) -> SlackClientError {
    SlackClientError::ProtocolError(
        SlackClientProtocolError::new(err).opt_json_body(tried_to_parse.map(|s| s.to_string())),
    )
}
More examples
Hide additional examples
src/socket_mode/clients_manager_listener.rs (line 67)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

    async fn on_message(
        &self,
        client_id: &SlackSocketModeWssClientId,
        message_body: String,
    ) -> Option<String> {
        if let Some(clients_manager) = self.clients_manager.upgrade() {
            match serde_json::from_str::<SlackSocketModeEvent>(message_body.as_str()).map_err(|e| {
                SlackClientProtocolError::new(e)
                    .with_json_body(message_body.to_string())
                    .into()
            }) {
                Ok(sm_event) => match sm_event {
                    SlackSocketModeEvent::Hello(event) => {
                        self.callbacks
                            .hello_callback
                            .call(
                                event,
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await;
                        None
                    }
                    SlackSocketModeEvent::Disconnect(event) => {
                        trace!(
                            "[{}] Received socket mode disconnected event: {:?}",
                            client_id.to_string(),
                            event
                        );
                        clients_manager.restart_client(client_id).await;
                        None
                    }
                    SlackSocketModeEvent::Interactive(event) => {
                        let reply =
                            serde_json::to_string(&SlackSocketModeEventCommonAcknowledge::new(
                                event.envelope_params.envelope_id,
                            ))
                            .unwrap();

                        match self
                            .callbacks
                            .interaction_callback
                            .call(
                                event.payload.clone(),
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await
                        {
                            Ok(_) => Some(reply),
                            Err(err) => {
                                if self.listener_environment.error_handler.clone()(
                                    err,
                                    self.listener_environment.client.clone(),
                                    self.listener_environment.user_state.clone(),
                                )
                                .is_success()
                                {
                                    Some(reply)
                                } else {
                                    None
                                }
                            }
                        }
                    }
                    SlackSocketModeEvent::EventsApi(event) => {
                        let reply =
                            serde_json::to_string(&SlackSocketModeEventCommonAcknowledge::new(
                                event.envelope_params.envelope_id,
                            ))
                            .unwrap();

                        match self
                            .callbacks
                            .push_events_callback
                            .call(
                                event.payload.clone(),
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await
                        {
                            Ok(_) => Some(reply),
                            Err(err) => {
                                if self.listener_environment.error_handler.clone()(
                                    err,
                                    self.listener_environment.client.clone(),
                                    self.listener_environment.user_state.clone(),
                                )
                                .is_success()
                                {
                                    Some(reply)
                                } else {
                                    None
                                }
                            }
                        }
                    }

                    SlackSocketModeEvent::SlashCommands(event) => {
                        match self
                            .callbacks
                            .command_callback
                            .call(
                                event.payload.clone(),
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await
                        {
                            Ok(reply) => Some(
                                serde_json::to_string(
                                    &SlackSocketModeCommandEventAck::new(
                                        SlackSocketModeEventCommonAcknowledge::new(
                                            event.envelope_params.envelope_id,
                                        ),
                                    )
                                    .with_payload(reply),
                                )
                                .unwrap(),
                            ),
                            Err(err) => {
                                if self.listener_environment.error_handler.clone()(
                                    err,
                                    self.listener_environment.client.clone(),
                                    self.listener_environment.user_state.clone(),
                                )
                                .is_success()
                                {
                                    Some(
                                        serde_json::to_string(
                                            &SlackSocketModeCommandEventAck::new(
                                                SlackSocketModeEventCommonAcknowledge::new(
                                                    event.envelope_params.envelope_id,
                                                ),
                                            ),
                                        )
                                        .unwrap(),
                                    )
                                } else {
                                    None
                                }
                            }
                        }
                    }
                },
                Err(err) => {
                    self.listener_environment.error_handler.clone()(
                        err,
                        self.listener_environment.client.clone(),
                        self.listener_environment.user_state.clone(),
                    );
                    None
                }
            }
        } else {
            None
        }
    }
source

pub fn json_body(&mut self, value: String) -> &mut Self

source

pub fn reset_json_body(&mut self) -> &mut Self

source

pub fn mopt_json_body(&mut self, value: Option<String>) -> &mut Self

source

pub fn with_json_body(self, value: String) -> Self

Examples found in repository?
src/socket_mode/clients_manager_listener.rs (line 68)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

    async fn on_message(
        &self,
        client_id: &SlackSocketModeWssClientId,
        message_body: String,
    ) -> Option<String> {
        if let Some(clients_manager) = self.clients_manager.upgrade() {
            match serde_json::from_str::<SlackSocketModeEvent>(message_body.as_str()).map_err(|e| {
                SlackClientProtocolError::new(e)
                    .with_json_body(message_body.to_string())
                    .into()
            }) {
                Ok(sm_event) => match sm_event {
                    SlackSocketModeEvent::Hello(event) => {
                        self.callbacks
                            .hello_callback
                            .call(
                                event,
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await;
                        None
                    }
                    SlackSocketModeEvent::Disconnect(event) => {
                        trace!(
                            "[{}] Received socket mode disconnected event: {:?}",
                            client_id.to_string(),
                            event
                        );
                        clients_manager.restart_client(client_id).await;
                        None
                    }
                    SlackSocketModeEvent::Interactive(event) => {
                        let reply =
                            serde_json::to_string(&SlackSocketModeEventCommonAcknowledge::new(
                                event.envelope_params.envelope_id,
                            ))
                            .unwrap();

                        match self
                            .callbacks
                            .interaction_callback
                            .call(
                                event.payload.clone(),
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await
                        {
                            Ok(_) => Some(reply),
                            Err(err) => {
                                if self.listener_environment.error_handler.clone()(
                                    err,
                                    self.listener_environment.client.clone(),
                                    self.listener_environment.user_state.clone(),
                                )
                                .is_success()
                                {
                                    Some(reply)
                                } else {
                                    None
                                }
                            }
                        }
                    }
                    SlackSocketModeEvent::EventsApi(event) => {
                        let reply =
                            serde_json::to_string(&SlackSocketModeEventCommonAcknowledge::new(
                                event.envelope_params.envelope_id,
                            ))
                            .unwrap();

                        match self
                            .callbacks
                            .push_events_callback
                            .call(
                                event.payload.clone(),
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await
                        {
                            Ok(_) => Some(reply),
                            Err(err) => {
                                if self.listener_environment.error_handler.clone()(
                                    err,
                                    self.listener_environment.client.clone(),
                                    self.listener_environment.user_state.clone(),
                                )
                                .is_success()
                                {
                                    Some(reply)
                                } else {
                                    None
                                }
                            }
                        }
                    }

                    SlackSocketModeEvent::SlashCommands(event) => {
                        match self
                            .callbacks
                            .command_callback
                            .call(
                                event.payload.clone(),
                                self.listener_environment.client.clone(),
                                self.listener_environment.user_state.clone(),
                            )
                            .await
                        {
                            Ok(reply) => Some(
                                serde_json::to_string(
                                    &SlackSocketModeCommandEventAck::new(
                                        SlackSocketModeEventCommonAcknowledge::new(
                                            event.envelope_params.envelope_id,
                                        ),
                                    )
                                    .with_payload(reply),
                                )
                                .unwrap(),
                            ),
                            Err(err) => {
                                if self.listener_environment.error_handler.clone()(
                                    err,
                                    self.listener_environment.client.clone(),
                                    self.listener_environment.user_state.clone(),
                                )
                                .is_success()
                                {
                                    Some(
                                        serde_json::to_string(
                                            &SlackSocketModeCommandEventAck::new(
                                                SlackSocketModeEventCommonAcknowledge::new(
                                                    event.envelope_params.envelope_id,
                                                ),
                                            ),
                                        )
                                        .unwrap(),
                                    )
                                } else {
                                    None
                                }
                            }
                        }
                    }
                },
                Err(err) => {
                    self.listener_environment.error_handler.clone()(
                        err,
                        self.listener_environment.client.clone(),
                        self.listener_environment.user_state.clone(),
                    );
                    None
                }
            }
        } else {
            None
        }
    }
source

pub fn without_json_body(self) -> Self

source

pub fn opt_json_body(self, value: Option<String>) -> Self

Examples found in repository?
src/errors.rs (line 211)
209
210
211
212
213

pub fn map_serde_error(err: serde_json::Error, tried_to_parse: Option<&str>) -> SlackClientError {
    SlackClientError::ProtocolError(
        SlackClientProtocolError::new(err).opt_json_body(tried_to_parse.map(|s| s.to_string())),
    )
}

Trait Implementations§

Formats the value using the given formatter. Read more
Formats the value using the given formatter. Read more
The lower-level source of this error, if any. Read more
👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
Converts to this type from the input type.

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Instruments this type with the current Span, returning an Instrumented wrapper. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

🔬This is a nightly-only experimental API. (provide_any)
Data providers should implement this method to provide all values they are able to provide by using demand. Read more
Converts the given value to a String. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more