1use std::{fmt::Debug, panic::AssertUnwindSafe, sync::Arc};
2
3use async_trait::async_trait;
4use futures::FutureExt;
5use indexmap::IndexSet;
6use stoat_database::events::client::{EventV1, Ping};
7use stoat_models::v0::{
8 Channel, ChannelVoiceState, Embed, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
9 FieldsRole, FieldsServer, FieldsUser, Member, Message, PartialChannel, PartialMember,
10 PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState,
11 RelationshipStatus, RemovalIntention, Role, Server, User, UserVoiceState,
12};
13
14use crate::{Context, Error};
15
16macro_rules! set_enum_varient_values {
17 ($enum: ident, $key: ident, $value: expr, ($($varient: path),+)) => {
18 match $enum {
19 $($varient { $key, .. } )|+ => { *$key = $value },
20 _ => {}
21 }
22 };
23}
24
25macro_rules! update_enum_partial {
26 ($value: ident, $data: expr, $key: ident, ($($varient: path),+)) => {
27 if let Some(new_value) = $data.$key {
28 set_enum_varient_values!($value, $key, new_value, ($($varient),+))
29 }
30 };
31
32 (optional, $value: ident, $data: expr, $key: ident, ($($varient: path),+)) => {
33 set_enum_varient_values!($value, $key, $data.$key, ($($varient),+))
34 };
35}
36
37macro_rules! update_multi_enum_partial {
38 ($value: ident, $data: expr, ($( $( $(@$optional:tt)? optional )? ($key: ident, ($($varient: path),+))),+ $(,)?)) => {
39 $(update_enum_partial!($( $($optional)? optional,)? $value, $data, $key, ($($varient),+)));+
40 };
41}
42
43macro_rules! handle_event {
44 ($handler: expr, $context: expr, $event: ident, ($($arg: expr),*)) => {
45 {
46 let wrapper = AssertUnwindSafe(async {
47 if let Err(e) = $handler.$event($context.clone(), $($arg),*).await {
48 $handler.error($context, e).await;
49 }
50 });
51
52 if let Err(e) = wrapper.catch_unwind().await {
53 log::error!("{e:?}");
54 };
55 }
56 };
57}
58
59pub async fn update_state<H: EventHandler + Clone + Send + Sync + 'static>(
60 event: EventV1,
61 context: Context,
62 handler: Arc<H>,
63) {
64 handle_event!(handler, context.clone(), event, (event.clone()));
65
66 match event {
67 EventV1::Bulk { v } => {
68 for e in v {
69 Box::pin(update_state(e, context.clone(), handler.clone())).await;
70 }
71 }
72 EventV1::Authenticated => {
73 context.notifiers.invoke_authenticated_waiters(&()).await;
74 handle_event!(handler, context, authenticated, ())
75 }
76 EventV1::Logout => {
77 context.notifiers.invoke_logout_waiters(&()).await;
78 handle_event!(handler, context, logout, ())
79 }
80 EventV1::Pong { data } => {
81 context.notifiers.invoke_pong_waiters(&data).await;
82 handle_event!(handler, context, pong, (data))
83 }
84 EventV1::Ready {
85 users,
86 servers,
87 channels,
88 members,
89 emojis,
90 user_settings: _,
91 channel_unreads: _,
92 policy_changes: _,
93 voice_states,
94 } => {
95 for user in users.into_iter().flatten() {
96 if user.relationship == RelationshipStatus::User {
97 context.cache.set_current_user_id(user.id.clone());
98 };
99
100 context.cache.insert_user(user);
101 }
102
103 for server in servers.into_iter().flatten() {
104 context.cache.insert_server(server);
105 }
106
107 for channel in channels.into_iter().flatten() {
108 context.cache.insert_channel(channel);
109 }
110
111 for member in members.into_iter().flatten() {
112 context.cache.insert_member(member);
113 }
114
115 for voice_state in voice_states.into_iter().flatten() {
116 context.cache.insert_voice_state(voice_state);
117 }
118
119 for emoji in emojis.into_iter().flatten() {
120 context.cache.insert_emoji(emoji);
121 }
122
123 context.notifiers.invoke_ready_waiters(&()).await;
124 handle_event!(handler, context, ready, ())
125 }
126 EventV1::Message(message) => {
127 context.cache.insert_message(message.clone());
128
129 context.notifiers.invoke_message_waiters(&message).await;
130 handle_event!(handler, context, message, (message))
131 }
132 EventV1::MessageUpdate {
133 id,
134 channel: _,
135 data,
136 clear,
137 } => {
138 if let Some((before, after)) = context.cache.update_message_with(&id, |message| {
139 let before = message.clone();
140
141 message.apply_options(data.clone());
142
143 for field in &clear {
144 match field {
145 FieldsMessage::Pinned => message.pinned = None,
146 }
147 }
148
149 (before, message.clone())
150 }) {
151 context
152 .notifiers
153 .invoke_message_update_waiters(&(
154 before.clone(),
155 after.clone(),
156 data.clone(),
157 clear.clone(),
158 ))
159 .await;
160 handle_event!(
161 handler,
162 context,
163 message_update,
164 (before, after, data, clear)
165 )
166 }
167 }
168 EventV1::MessageDelete { id, channel: _ } => {
169 if let Some(message) = context.cache.remove_message(&id) {
170 context
171 .notifiers
172 .invoke_message_delete_waiters(&message)
173 .await;
174 handle_event!(handler, context, message_delete, (message))
175 }
176 }
177 EventV1::MessageReact {
178 id,
179 channel_id: _,
180 user_id,
181 emoji_id,
182 } => {
183 if let Some(message) = context.cache.update_message_with(&id, |message| {
184 message
185 .reactions
186 .entry(emoji_id.clone())
187 .or_default()
188 .insert(user_id.clone());
189
190 message.clone()
191 }) {
192 context
193 .notifiers
194 .invoke_message_react_waiters(&(
195 message.clone(),
196 user_id.clone(),
197 emoji_id.clone(),
198 ))
199 .await;
200 handle_event!(
201 handler,
202 context,
203 message_react,
204 (message, user_id, emoji_id)
205 )
206 }
207 }
208 EventV1::MessageUnreact {
209 id,
210 channel_id: _,
211 user_id,
212 emoji_id,
213 } => {
214 if let Some(message) = context.cache.update_message_with(&id, |message| {
215 if let Some(users) = message.reactions.get_mut(&emoji_id) {
216 users.remove(&user_id);
217
218 if users.is_empty() {
219 message.reactions.remove(&emoji_id);
220 };
221 }
222
223 message.clone()
224 }) {
225 context
226 .notifiers
227 .invoke_message_unreact_waiters(&(
228 message.clone(),
229 user_id.clone(),
230 emoji_id.clone(),
231 ))
232 .await;
233 handle_event!(
234 handler,
235 context,
236 message_unreact,
237 (message, user_id, emoji_id)
238 )
239 }
240 }
241 EventV1::MessageRemoveReaction {
242 id,
243 channel_id: _,
244 emoji_id,
245 } => {
246 if let Some((message, users)) = context.cache.update_message_with(&id, |message| {
247 let participants = message.reactions.remove(&emoji_id);
248
249 (message.clone(), participants.unwrap_or_default())
250 }) {
251 context
252 .notifiers
253 .invoke_message_remove_reaction_waiters(&(
254 message.clone(),
255 emoji_id.clone(),
256 users.clone(),
257 ))
258 .await;
259 handle_event!(
260 handler,
261 context,
262 message_remove_reaction,
263 (message, emoji_id, users)
264 )
265 }
266 }
267 EventV1::UserUpdate {
268 id, data, clear, ..
269 } => {
270 if let Some((before, after)) = context.cache.update_user_with(&id, |user| {
271 let before = user.clone();
272
273 user.apply_options(data.clone());
274
275 for field in &clear {
276 match field {
277 FieldsUser::Avatar => user.avatar = None,
278 FieldsUser::StatusText => {
279 if let Some(status) = user.status.as_mut() {
280 status.text = None
281 };
282 }
283 FieldsUser::StatusPresence => {
284 if let Some(status) = user.status.as_mut() {
285 status.presence = None
286 };
287 }
288 FieldsUser::DisplayName => user.display_name = None,
289 _ => {}
290 }
291 }
292
293 (before, user.clone())
294 }) {
295 context
296 .notifiers
297 .invoke_user_update_waiters(&(
298 before.clone(),
299 after.clone(),
300 data.clone(),
301 clear.clone(),
302 ))
303 .await;
304 handle_event!(handler, context, user_update, (before, after, data, clear))
305 }
306 }
307 EventV1::BulkMessageDelete { channel, ids } => {
308 let messages = context.cache.remove_messages(&ids);
309
310 context
311 .notifiers
312 .invoke_bulk_message_delete_waiters(&(
313 channel.clone(),
314 ids.clone(),
315 messages.clone(),
316 ))
317 .await;
318 handle_event!(
319 handler,
320 context,
321 bulk_message_delete,
322 (channel, ids, messages)
323 )
324 }
325 EventV1::ChannelCreate(channel) => {
326 if let Channel::TextChannel { id, server, .. } = &channel {
327 context
328 .cache
329 .update_server_with(&server, |server| server.channels.push(id.clone()));
330 };
331
332 context
333 .notifiers
334 .invoke_channel_create_waiters(&channel)
335 .await;
336 context.cache.insert_channel(channel.clone());
337
338 handle_event!(handler, context, channel_create, (channel))
339 }
340 EventV1::ChannelDelete { id } => {
341 if let Some(channel) = context.cache.remove_channel(&id) {
342 if let Channel::TextChannel { id, server, .. } = &channel {
343 context.cache.update_server_with(&server, |server| {
344 server.channels.retain(|c_id| c_id != id)
345 });
346 };
347
348 context
349 .notifiers
350 .invoke_channel_delete_waiters(&channel)
351 .await;
352 handle_event!(handler, context, channel_delete, (channel))
353 }
354 }
355 EventV1::ChannelGroupJoin { id, user } => {
356 if let Some(channel) = context.cache.update_channel_with(&id, |channel| {
357 if let Channel::Group { recipients, .. } = channel {
358 recipients.push(user.clone())
359 };
360
361 channel.clone()
362 }) {
363 context
364 .notifiers
365 .invoke_channel_group_user_join_waiters(&(channel.clone(), user.clone()))
366 .await;
367 handle_event!(handler, context, channel_group_user_join, (channel, user))
368 }
369 }
370 EventV1::ChannelGroupLeave { id, user } => {
371 if let Some(channel) = context.cache.update_channel_with(&id, |channel| {
372 if let Channel::Group { recipients, .. } = channel {
373 recipients.retain(|u_id| u_id != &user)
374 };
375
376 channel.clone()
377 }) {
378 context
379 .notifiers
380 .invoke_channel_group_user_leave_waiters(&(channel.clone(), user.clone()))
381 .await;
382 handle_event!(handler, context, channel_group_user_leave, (channel, user))
383 }
384 }
385 EventV1::ChannelUpdate { id, data, clear } => {
386 if let Some((before, after)) = context.cache.update_channel_with(&id, |channel| {
387 let before = channel.clone();
388
389 update_multi_enum_partial!(
390 channel,
391 data.clone(),
392 (
393 (name, (Channel::TextChannel)),
394 (owner, (Channel::Group)),
395 optional(description, (Channel::Group, Channel::TextChannel)),
396 optional(icon, (Channel::Group, Channel::TextChannel)),
397 (nsfw, (Channel::Group, Channel::TextChannel)),
398 (active, (Channel::DirectMessage)),
399 optional(permissions, (Channel::Group)),
400 (role_permissions, (Channel::TextChannel)),
401 optional(default_permissions, (Channel::TextChannel)),
402 optional(
403 last_message_id,
404 (Channel::DirectMessage, Channel::Group, Channel::TextChannel)
405 )
406 )
407 );
408
409 for field in &clear {
410 match field {
411 FieldsChannel::Description => set_enum_varient_values!(
412 channel,
413 description,
414 None,
415 (Channel::Group, Channel::TextChannel)
416 ),
417 FieldsChannel::Icon => set_enum_varient_values!(
418 channel,
419 icon,
420 None,
421 (Channel::Group, Channel::TextChannel)
422 ),
423 FieldsChannel::DefaultPermissions => set_enum_varient_values!(
424 channel,
425 default_permissions,
426 None,
427 (Channel::TextChannel)
428 ),
429 FieldsChannel::Voice => {
430 set_enum_varient_values!(channel, voice, None, (Channel::TextChannel))
431 }
432 }
433 }
434
435 (before, channel.clone())
436 }) {
437 context
438 .notifiers
439 .invoke_channel_update_waiters(&(
440 before.clone(),
441 after.clone(),
442 data.clone(),
443 clear.clone(),
444 ))
445 .await;
446 handle_event!(
447 handler,
448 context,
449 channel_update,
450 (before, after, data, clear)
451 )
452 }
453 }
454 EventV1::MessageAppend {
455 id,
456 channel: _,
457 append,
458 } => {
459 if let Some(message) = context.cache.update_message_with(&id, |message| {
460 if let Some(embeds) = append.embeds.clone() {
461 message.embeds.get_or_insert_default().extend(embeds);
462 }
463
464 message.clone()
465 }) {
466 let embeds = append.embeds.unwrap_or_default();
467
468 context
469 .notifiers
470 .invoke_message_append_waiters(&(message.clone(), embeds.clone()))
471 .await;
472 handle_event!(handler, context, message_append, (message, embeds))
473 }
474 }
475 EventV1::ServerCreate {
476 id: _,
477 server,
478 channels,
479 emojis,
480 voice_states,
481 } => {
482 context.cache.insert_server(server.clone());
483
484 for channel in channels.clone() {
485 context.cache.insert_channel(channel);
486 }
487
488 for emoji in emojis.clone() {
489 context.cache.insert_emoji(emoji);
490 }
491
492 context
493 .notifiers
494 .invoke_server_create_waiters(&(
495 server.clone(),
496 channels.clone(),
497 emojis.clone(),
498 voice_states.clone(),
499 ))
500 .await;
501 handle_event!(
502 handler,
503 context,
504 server_create,
505 (server, channels, emojis, voice_states)
506 )
507 }
508 EventV1::ServerDelete { id } => {
509 if let Some(server) = context.cache.remove_server(&id) {
510 let mut channels = Vec::new();
511 let mut voice_states = Vec::new();
512
513 for channel in &server.channels {
514 channels.extend(context.cache.remove_channel(channel));
515 voice_states.extend(context.cache.remove_voice_state(channel));
516 }
517
518 let emojis = context.cache.remove_server_emojis(&id);
519
520 context
521 .notifiers
522 .invoke_server_delete_waiters(&(
523 server.clone(),
524 channels.clone(),
525 emojis.clone(),
526 voice_states.clone(),
527 ))
528 .await;
529 handle_event!(
530 handler,
531 context,
532 server_delete,
533 (server, channels, voice_states, emojis)
534 )
535 }
536 }
537 EventV1::ServerUpdate { id, data, clear } => {
538 if let Some((before, after)) = context.cache.update_server_with(&id, |server| {
539 let before = server.clone();
540
541 server.apply_options(data.clone());
542
543 for field in &clear {
544 match field {
545 FieldsServer::Description => server.description = None,
546 FieldsServer::Categories => server.categories = None,
547 FieldsServer::SystemMessages => server.system_messages = None,
548 FieldsServer::Icon => server.icon = None,
549 FieldsServer::Banner => server.banner = None,
550 }
551 }
552
553 (before, server.clone())
554 }) {
555 context
556 .notifiers
557 .invoke_server_update_waiters(&(
558 before.clone(),
559 after.clone(),
560 data.clone(),
561 clear.clone(),
562 ))
563 .await;
564 handle_event!(
565 handler,
566 context,
567 server_update,
568 (before, after, data, clear)
569 )
570 }
571 }
572 EventV1::ServerMemberJoin { id: _, member, .. } => {
573 context.cache.insert_member(member.clone());
574
575 context
576 .notifiers
577 .invoke_server_member_join_waiters(&member)
578 .await;
579 handle_event!(handler, context, server_member_join, (member))
580 }
581 EventV1::ServerMemberLeave { id, user, reason } => {
582 if let Some(member) = context.cache.remove_member(&id, &user) {
583 context
584 .notifiers
585 .invoke_server_member_leave_waiters(&(member.clone(), reason.clone()))
586 .await;
587 handle_event!(handler, context, server_member_leave, (member, reason))
588 }
589 }
590 EventV1::ServerMemberUpdate { id, data, clear } => {
591 if let Some((before, after)) =
592 context
593 .cache
594 .update_member_with(&id.server, &id.user, |member| {
595 let before = member.clone();
596
597 member.apply_options(data.clone());
598
599 for field in &clear {
600 match field {
601 FieldsMember::Nickname => member.nickname = None,
602 FieldsMember::Avatar => member.avatar = None,
603 FieldsMember::Roles => member.roles.clear(),
604 FieldsMember::Timeout => member.timeout = None,
605 FieldsMember::CanReceive => member.can_publish = true,
606 FieldsMember::CanPublish => member.can_publish = true,
607 FieldsMember::JoinedAt => (),
608 }
609 }
610
611 (before, member.clone())
612 })
613 {
614 context
615 .notifiers
616 .invoke_server_member_update_waiters(&(
617 before.clone(),
618 after.clone(),
619 data.clone(),
620 clear.clone(),
621 ))
622 .await;
623 handle_event!(
624 handler,
625 context,
626 server_member_update,
627 (before, after, data, clear)
628 )
629 }
630 }
631 EventV1::ServerRoleUpdate {
632 id,
633 role_id,
634 data,
635 clear,
636 } => {
637 if let Some((before, after)) = context.cache.update_server_with(&id, |server| {
638 if let Some(role) = server.roles.get_mut(&role_id) {
639 let before = role.clone();
640
641 role.apply_options(data.clone());
642
643 for field in &clear {
644 match field {
645 FieldsRole::Colour => role.colour = None,
646 }
647 }
648
649 (Some(before), role.clone())
650 } else {
651 let role = Role {
654 id: role_id.clone(),
655 name: data.name.clone().expect("No role name"),
656 permissions: data.permissions.clone().expect("No role name"),
657 colour: data.colour.clone(),
658 hoist: data.hoist.expect("No role hoist"),
659 rank: data.rank.expect("No role rank"),
660 };
661
662 server.roles.insert(role_id.clone(), role.clone());
663
664 (None, role)
665 }
666 }) {
667 if let Some(before) = before {
668 context
669 .notifiers
670 .invoke_server_role_update_waiters(&(
671 id.clone(),
672 before.clone(),
673 after.clone(),
674 data.clone(),
675 clear.clone(),
676 ))
677 .await;
678
679 handle_event!(
680 handler,
681 context,
682 server_role_update,
683 (id, before, after, data, clear)
684 )
685 } else {
686 context
687 .notifiers
688 .invoke_server_role_create_waiters(&(id.clone(), after.clone()))
689 .await;
690
691 handle_event!(handler, context, server_role_create, (id, after))
692 }
693 }
694 }
695 EventV1::ServerRoleDelete { id, role_id } => {
696 if let Some(Some(role)) = context
697 .cache
698 .update_server_with(&id, |server| server.roles.remove(&role_id))
699 {
700 context
701 .notifiers
702 .invoke_server_role_delete_waiters(&(id.clone(), role.clone()))
703 .await;
704 handle_event!(handler, context, server_role_delete, (id, role))
705 }
706 }
707 EventV1::ServerRoleRanksUpdate { id, ranks } => {
708 if let Some((before, after)) = context.cache.update_server_with(&id, |server| {
709 let mut before = server.roles.clone().into_values().collect::<Vec<_>>();
710 before.sort_by(|a, b| a.rank.cmp(&b.rank));
711
712 for (idx, role_id) in ranks.iter().enumerate() {
713 if let Some(role) = server.roles.get_mut(role_id) {
714 role.rank = idx as i64;
715 };
716 }
717
718 let mut after = server.roles.clone().into_values().collect::<Vec<_>>();
719 after.sort_by(|a, b| a.rank.cmp(&b.rank));
720
721 (before, after)
722 }) {
723 context
724 .notifiers
725 .invoke_server_role_ranks_update_waiters(&(
726 id.clone(),
727 before.clone(),
728 after.clone(),
729 ))
730 .await;
731 handle_event!(
732 handler,
733 context,
734 server_role_ranks_update,
735 (id, before, after)
736 )
737 }
738 }
739 EventV1::UserVoiceStateUpdate {
740 id,
741 channel_id,
742 data,
743 } => {
744 if let Some((before, after)) =
745 context
746 .cache
747 .update_voice_state_partipant_with(&channel_id, &id, |state| {
748 let before = state.clone();
749
750 state.apply_options(data.clone());
751
752 (before, state.clone())
753 })
754 {
755 context
756 .notifiers
757 .invoke_user_voice_state_update_waiters(&(
758 before.clone(),
759 after.clone(),
760 data.clone(),
761 ))
762 .await;
763 handle_event!(
764 handler,
765 context,
766 user_voice_state_update,
767 (before, after, data)
768 )
769 }
770 }
771 EventV1::VoiceChannelJoin {
772 id,
773 state: user_voice_state,
774 } => {
775 context
776 .cache
777 .insert_voice_state_partipant(&id, user_voice_state.clone());
778
779 context
780 .notifiers
781 .invoke_user_voice_channel_join_waiters(&(id.clone(), user_voice_state.clone()))
782 .await;
783 handle_event!(
784 handler,
785 context,
786 user_voice_channel_join,
787 (id, user_voice_state)
788 )
789 }
790 EventV1::VoiceChannelMove {
791 user,
792 from,
793 to,
794 state: user_voice_state,
795 } => {
796 let before = context.cache.remove_voice_state_partipant(&from, &user);
797
798 context
799 .cache
800 .insert_voice_state_partipant(&to, user_voice_state.clone());
801
802 if let Some(before) = before {
803 context
804 .notifiers
805 .invoke_user_voice_channel_move_waiters(&(
806 user.clone(),
807 from.clone(),
808 to.clone(),
809 before.clone(),
810 user_voice_state.clone(),
811 ))
812 .await;
813 handle_event!(
814 handler,
815 context,
816 user_voice_channel_move,
817 (user, from, to, before, user_voice_state)
818 )
819 }
820 }
821 EventV1::VoiceChannelLeave { id, user } => {
822 if let Some(user_voice_state) = context.cache.remove_voice_state_partipant(&id, &user) {
823 context
824 .notifiers
825 .invoke_user_voice_channel_leave_waiters(&(
826 id.clone(),
827 user_voice_state.clone(),
828 ))
829 .await;
830 handle_event!(
831 handler,
832 context,
833 user_voice_channel_leave,
834 (id, user_voice_state)
835 )
836 }
837 }
838 EventV1::ChannelStartTyping { id, user } => {
839 context
840 .notifiers
841 .invoke_typing_start_waiters(&(id.clone(), user.clone()))
842 .await;
843
844 handle_event!(handler, context, typing_start, (id, user))
845 }
846 EventV1::ChannelStopTyping { id, user } => {
847 context
848 .notifiers
849 .invoke_typing_stop_waiters(&(id.clone(), user.clone()))
850 .await;
851
852 handle_event!(handler, context, typing_stop, (id, user))
853 }
854 EventV1::EmojiCreate(emoji) => {
855 context.cache.insert_emoji(emoji.clone());
856
857 context.notifiers.invoke_emoji_create_waiters(&emoji).await;
858 handle_event!(handler, context, emoji_create, (emoji));
859 }
860 EventV1::EmojiDelete { id } => {
861 if let Some(emoji) = context.cache.remove_emoji(&id) {
862 context.notifiers.invoke_emoji_delete_waiters(&emoji).await;
863 handle_event!(handler, context, emoji_delete, (emoji));
864 }
865 }
866 _ => {}
867 }
868}
869
870#[async_trait]
871#[allow(unused)]
872pub trait EventHandler: Sized {
873 type Error: From<Error> + Clone + Debug + Send + Sync + 'static;
874
875 async fn event(&self, context: Context, event: EventV1) -> Result<(), Self::Error> {
876 Ok(())
877 }
878
879 async fn authenticated(&self, context: Context) -> Result<(), Self::Error> {
880 Ok(())
881 }
882
883 async fn logout(&self, context: Context) -> Result<(), Self::Error> {
884 Ok(())
885 }
886
887 async fn pong(&self, context: Context, data: Ping) -> Result<(), Self::Error> {
888 Ok(())
889 }
890
891 async fn ready(&self, context: Context) -> Result<(), Self::Error> {
892 Ok(())
893 }
894
895 async fn message(&self, context: Context, message: Message) -> Result<(), Self::Error> {
896 Ok(())
897 }
898
899 async fn message_update(
900 &self,
901 context: Context,
902 before: Message,
903 after: Message,
904 partial: PartialMessage,
905 clear: Vec<FieldsMessage>,
906 ) -> Result<(), Self::Error> {
907 Ok(())
908 }
909
910 async fn message_delete(&self, context: Context, message: Message) -> Result<(), Self::Error> {
911 Ok(())
912 }
913
914 async fn message_react(
915 &self,
916 context: Context,
917 message: Message,
918 user_id: String,
919 emoji_id: String,
920 ) -> Result<(), Self::Error> {
921 Ok(())
922 }
923
924 async fn message_unreact(
925 &self,
926 context: Context,
927 message: Message,
928 user_id: String,
929 emoji_id: String,
930 ) -> Result<(), Self::Error> {
931 Ok(())
932 }
933
934 async fn message_remove_reaction(
935 &self,
936 context: Context,
937 message: Message,
938 emoji_id: String,
939 reactants: IndexSet<String>,
940 ) -> Result<(), Self::Error> {
941 Ok(())
942 }
943
944 async fn message_append(
945 &self,
946 context: Context,
947 message: Message,
948 embeds: Vec<Embed>,
949 ) -> Result<(), Self::Error> {
950 Ok(())
951 }
952
953 async fn user_update(
954 &self,
955 context: Context,
956 before: User,
957 after: User,
958 partial: PartialUser,
959 clear: Vec<FieldsUser>,
960 ) -> Result<(), Self::Error> {
961 Ok(())
962 }
963
964 async fn bulk_message_delete(
965 &self,
966 context: Context,
967 channel_id: String,
968 message_ids: Vec<String>,
969 found: Vec<Message>,
970 ) -> Result<(), Self::Error> {
971 Ok(())
972 }
973
974 async fn channel_create(&self, context: Context, channel: Channel) -> Result<(), Self::Error> {
975 Ok(())
976 }
977
978 async fn channel_update(
979 &self,
980 context: Context,
981 before: Channel,
982 after: Channel,
983 partial: PartialChannel,
984 clear: Vec<FieldsChannel>,
985 ) -> Result<(), Self::Error> {
986 Ok(())
987 }
988
989 async fn channel_delete(&self, context: Context, channel: Channel) -> Result<(), Self::Error> {
990 Ok(())
991 }
992
993 async fn channel_group_user_join(
994 &self,
995 context: Context,
996 channel: Channel,
997 user_id: String,
998 ) -> Result<(), Self::Error> {
999 Ok(())
1000 }
1001
1002 async fn channel_group_user_leave(
1003 &self,
1004 context: Context,
1005 channel: Channel,
1006 user_id: String,
1007 ) -> Result<(), Self::Error> {
1008 Ok(())
1009 }
1010
1011 async fn server_create(
1012 &self,
1013 context: Context,
1014 server: Server,
1015 channels: Vec<Channel>,
1016 emojis: Vec<Emoji>,
1017 voice_states: Vec<ChannelVoiceState>,
1018 ) -> Result<(), Self::Error> {
1019 Ok(())
1020 }
1021
1022 async fn server_delete(
1023 &self,
1024 context: Context,
1025 server: Server,
1026 channels: Vec<Channel>,
1027 voice_states: Vec<ChannelVoiceState>,
1028 emojis: Vec<Emoji>,
1029 ) -> Result<(), Self::Error> {
1030 Ok(())
1031 }
1032
1033 async fn server_update(
1034 &self,
1035 context: Context,
1036 before: Server,
1037 after: Server,
1038 partial: PartialServer,
1039 clear: Vec<FieldsServer>,
1040 ) -> Result<(), Self::Error> {
1041 Ok(())
1042 }
1043
1044 async fn typing_start(
1045 &self,
1046 context: Context,
1047 channel_id: String,
1048 user_id: String,
1049 ) -> Result<(), Self::Error> {
1050 Ok(())
1051 }
1052
1053 async fn typing_stop(
1054 &self,
1055 context: Context,
1056 channel_id: String,
1057 user_id: String,
1058 ) -> Result<(), Self::Error> {
1059 Ok(())
1060 }
1061
1062 async fn server_member_join(
1063 &self,
1064 context: Context,
1065 member: Member,
1066 ) -> Result<(), Self::Error> {
1067 Ok(())
1068 }
1069
1070 async fn server_member_leave(
1071 &self,
1072 context: Context,
1073 member: Member,
1074 reason: RemovalIntention,
1075 ) -> Result<(), Self::Error> {
1076 Ok(())
1077 }
1078
1079 async fn server_member_update(
1080 &self,
1081 context: Context,
1082 before: Member,
1083 after: Member,
1084 partial: PartialMember,
1085 clear: Vec<FieldsMember>,
1086 ) -> Result<(), Self::Error> {
1087 Ok(())
1088 }
1089
1090 async fn server_role_create(
1091 &self,
1092 context: Context,
1093 server_id: String,
1094 role: Role,
1095 ) -> Result<(), Self::Error> {
1096 Ok(())
1097 }
1098 async fn server_role_update(
1099 &self,
1100 context: Context,
1101 server_id: String,
1102 before: Role,
1103 after: Role,
1104 partial: PartialRole,
1105 clear: Vec<FieldsRole>,
1106 ) -> Result<(), Self::Error> {
1107 Ok(())
1108 }
1109
1110 async fn server_role_delete(
1111 &self,
1112 context: Context,
1113 server_id: String,
1114 role: Role,
1115 ) -> Result<(), Self::Error> {
1116 Ok(())
1117 }
1118
1119 async fn server_role_ranks_update(
1120 &self,
1121 context: Context,
1122 server_id: String,
1123 before: Vec<Role>,
1124 after: Vec<Role>,
1125 ) -> Result<(), Self::Error> {
1126 Ok(())
1127 }
1128
1129 async fn user_voice_state_update(
1130 &self,
1131 context: Context,
1132 before: UserVoiceState,
1133 after: UserVoiceState,
1134 partial: PartialUserVoiceState,
1135 ) -> Result<(), Self::Error> {
1136 Ok(())
1137 }
1138
1139 async fn user_voice_channel_join(
1140 &self,
1141 context: Context,
1142 channel_id: String,
1143 user_voice_state: UserVoiceState,
1144 ) -> Result<(), Self::Error> {
1145 Ok(())
1146 }
1147
1148 async fn user_voice_channel_move(
1149 &self,
1150 context: Context,
1151 user_id: String,
1152 from: String,
1153 to: String,
1154 before: UserVoiceState,
1155 after: UserVoiceState,
1156 ) -> Result<(), Self::Error> {
1157 Ok(())
1158 }
1159
1160 async fn user_voice_channel_leave(
1161 &self,
1162 context: Context,
1163 user_id: String,
1164 user_voice_state: UserVoiceState,
1165 ) -> Result<(), Self::Error> {
1166 Ok(())
1167 }
1168
1169 async fn emoji_create(&self, context: Context, emoji: Emoji) -> Result<(), Self::Error> {
1170 Ok(())
1171 }
1172
1173 async fn emoji_delete(&self, context: Context, emoji: Emoji) -> Result<(), Self::Error> {
1174 Ok(())
1175 }
1176
1177 async fn error(&self, context: Context, error: Self::Error) {
1178 log::error!("{error:?}");
1179 }
1180}