Remove support for group calls and guild sync

Calls and guild sync are essentially leftovers from selfbot support
removal, the former moreso.

Removes the following `model::event` structs:

- CallCreateEvent
- CallDeleteEvent
- CallUpdateEvent
- GuildSyncEvent

which also removes the following `model::event::Event` variants:

`client::gateway::Shard::sync_calls` has been removed.

The following `client::Client` methods have been removed:

- `on_call_create`
- `on_call_delete`
- `on_call_update`
- `on_guild_sync`

Removes the following items on `ext::cache::Cache`:

```
ext::cache::Cache::{
    // fields
    calls,
    // methods
    get_call,
    update_with_call_create,
    update_with_call_delete,
    update_with_call_update,
    update_with_guild_sync,
}
```

Voice structs and methods now take solely a `guild_id` instead of a
`target`, due to the handling of 1-on-1 and group calls being removed.

This continues off commit d9118c0.<Paste>

1 files changed, 0 insertions, 57 deletions

diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 49dbdb0..fd46394 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -121,56 +121,6 @@ fn handle_event(event: Event,
                 data: &Arc<Mutex<ShareMap>>,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
-        Event::CallCreate(event) => {
-            if let Some(handler) = handler!(on_call_create, event_store) {
-                update!(update_with_call_create, event);
-
-                let context = context(None, conn, data);
-
-                thread::spawn(move || (handler)(context, event.call));
-            } else {
-                update!(update_with_call_create, event);
-            }
-        },
-        Event::CallDelete(event) => {
-            if let Some(handler) = handler!(on_call_delete, event_store) {
-                let context = context(None, conn, data);
-
-                feature_cache! {{
-                    let call = update!(update_with_call_delete, event);
-
-                    thread::spawn(move || (handler)(context, event.channel_id, call));
-                } else {
-                    thread::spawn(move || (handler)(context, event.channel_id));
-                }}
-            } else {
-                update!(update_with_call_delete, event);
-            }
-        },
-        Event::CallUpdate(event) => {
-            if let Some(handler) = handler!(on_call_update, event_store) {
-                let context = context(None, conn, data);
-
-                feature_cache! {{
-                    let before = update!(update_with_call_update, event, true);
-                    let after = CACHE
-                        .read()
-                        .unwrap()
-                        .calls
-                        .get(&event.channel_id)
-                        .cloned();
-
-                    thread::spawn(move || (handler)(context, before, after));
-                } else {
-                    thread::spawn(move || (handler)(context, event));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    update!(update_with_call_update, event, false);
-                }
-            }
-        },
         Event::ChannelCreate(event) => {
             if let Some(handler) = handler!(on_channel_create, event_store) {
                 update!(update_with_channel_create, event);
@@ -403,13 +353,6 @@ fn handle_event(event: Event,
                 }
             }
         },
-        Event::GuildSync(event) => {
-            if let Some(handler) = handler!(on_guild_sync, event_store) {
-                let context = context(None, conn, data);
-
-                thread::spawn(move || (handler)(context, event));
-            }
-        },
         Event::GuildUnavailable(event) => {
             update!(update_with_guild_unavailable, event);