Revision of d - Opengist

rootspring hat die Gist bearbeitet 1687625905. Zu Änderung gehen

1 file changed, 121 insertions

			@@ -1,3 +1,124 @@
	1	+	func (w *GatewayClient) HandleEvent(event []byte, typ string) {
	2	+	if w.EventHandlers.RawSinkFunc != nil {
	3	+	w.EventHandlers.RawSinkFunc(w, event, typ)
	4	+	}
	5	+
	6	+	if typ == "Bulk" {
	7	+	// Bulk is a bit unique, special handling is required
	8	+	err := w.HandleBulk(event)
	9	+
	10	+	if err != nil {
	11	+	w.Logger.Error(
	12	+	"bulk handler failed",
	13	+	zap.Error(err),
	14	+	)
	15	+	}
	16	+	}
	17	+
	18	+	if typ == "Auth" {
	19	+	// Auth is a bit unique because of event it, handle it
	20	+	err := w.HandleAuth(event)
	21	+
	22	+	if err != nil {
	23	+	w.Logger.Error(
	24	+	"auth handler failed",
	25	+	zap.Error(err),
	26	+	)
	27	+	}
	28	+	}
	29	+
	30	+	var err error
	31	+	switch typ {
	32	+	case "Error":
	33	+	err = CreateEvent[events.Error](w, event, w.EventHandlers.Error)
	34	+	case "Authenticated":
	35	+	err = CreateEvent[events.Authenticated](w, event, w.EventHandlers.Authenticated)
	36	+	case "Bulk":
	37	+	err = CreateEvent[events.Bulk](w, event, w.EventHandlers.Bulk)
	38	+	case "Pong":
	39	+	err = CreateEvent[events.Pong](w, event, w.EventHandlers.Pong)
	40	+	case "Ready":
	41	+	err = CreateEvent[events.Ready](w, event, w.EventHandlers.Ready)
	42	+	case "Message":
	43	+	err = CreateEvent[events.Message](w, event, w.EventHandlers.Message)
	44	+	case "MessageUpdate":
	45	+	err = CreateEvent[events.MessageUpdate](w, event, w.EventHandlers.MessageUpdate)
	46	+	case "MessageAppend":
	47	+	err = CreateEvent[events.MessageAppend](w, event, w.EventHandlers.MessageAppend)
	48	+	case "MessageDelete":
	49	+	err = CreateEvent[events.MessageDelete](w, event, w.EventHandlers.MessageDelete)
	50	+	case "MessageReact":
	51	+	err = CreateEvent[events.MessageReact](w, event, w.EventHandlers.MessageReact)
	52	+	case "MessageUnreact":
	53	+	err = CreateEvent[events.MessageUnreact](w, event, w.EventHandlers.MessageUnreact)
	54	+	case "MessageRemoveReaction":
	55	+	err = CreateEvent[events.MessageRemoveReaction](w, event, w.EventHandlers.MessageRemoveReaction)
	56	+	case "ChannelCreate":
	57	+	err = CreateEvent[events.ChannelCreate](w, event, w.EventHandlers.ChannelCreate)
	58	+	case "ChannelUpdate":
	59	+	err = CreateEvent[events.ChannelUpdate](w, event, w.EventHandlers.ChannelUpdate)
	60	+	case "ChannelDelete":
	61	+	err = CreateEvent[events.ChannelDelete](w, event, w.EventHandlers.ChannelDelete)
	62	+	case "ChannelGroupJoin":
	63	+	err = CreateEvent[events.ChannelGroupJoin](w, event, w.EventHandlers.ChannelGroupJoin)
	64	+	case "ChannelGroupLeave":
	65	+	err = CreateEvent[events.ChannelGroupLeave](w, event, w.EventHandlers.ChannelGroupLeave)
	66	+	case "ChannelStartTyping":
	67	+	err = CreateEvent[events.ChannelStartTyping](w, event, w.EventHandlers.ChannelStartTyping)
	68	+	case "ChannelStopTyping":
	69	+	err = CreateEvent[events.ChannelStopTyping](w, event, w.EventHandlers.ChannelStopTyping)
	70	+	case "ChannelAck":
	71	+	err = CreateEvent[events.ChannelAck](w, event, w.EventHandlers.ChannelAck)
	72	+	case "ServerCreate":
	73	+	err = CreateEvent[events.ServerCreate](w, event, w.EventHandlers.ServerCreate)
	74	+	case "ServerUpdate":
	75	+	err = CreateEvent[events.ServerUpdate](w, event, w.EventHandlers.ServerUpdate)
	76	+	case "ServerDelete":
	77	+	err = CreateEvent[events.ServerDelete](w, event, w.EventHandlers.ServerDelete)
	78	+	case "ServerMemberUpdate":
	79	+	err = CreateEvent[events.ServerMemberUpdate](w, event, w.EventHandlers.ServerMemberUpdate)
	80	+	case "ServerMemberJoin":
	81	+	err = CreateEvent[events.ServerMemberJoin](w, event, w.EventHandlers.ServerMemberJoin)
	82	+	case "ServerMemberLeave":
	83	+	err = CreateEvent[events.ServerMemberLeave](w, event, w.EventHandlers.ServerMemberLeave)
	84	+	case "ServerRoleUpdate":
	85	+	err = CreateEvent[events.ServerRoleUpdate](w, event, w.EventHandlers.ServerRoleUpdate)
	86	+	case "ServerRoleDelete":
	87	+	err = CreateEvent[events.ServerRoleDelete](w, event, w.EventHandlers.ServerRoleDelete)
	88	+	case "UserUpdate":
	89	+	err = CreateEvent[events.UserUpdate](w, event, w.EventHandlers.UserUpdate)
	90	+	case "UserRelationship":
	91	+	err = CreateEvent[events.UserRelationship](w, event, w.EventHandlers.UserRelationship)
	92	+	case "UserSettingsUpdate":
	93	+	err = CreateEvent[events.UserSettingsUpdate](w, event, w.EventHandlers.UserSettingsUpdate)
	94	+	case "UserPlatformWipe":
	95	+	err = CreateEvent[events.UserPlatformWipe](w, event, w.EventHandlers.UserPlatformWipe)
	96	+	case "EmojiCreate":
	97	+	err = CreateEvent[events.EmojiCreate](w, event, w.EventHandlers.EmojiCreate)
	98	+	case "EmojiDelete":
	99	+	err = CreateEvent[events.EmojiDelete](w, event, w.EventHandlers.EmojiDelete)
	100	+	case "WebhookCreate":
	101	+	err = CreateEvent[events.WebhookCreate](w, event, w.EventHandlers.WebhookCreate)
	102	+	case "WebhookUpdate":
	103	+	err = CreateEvent[events.WebhookUpdate](w, event, w.EventHandlers.WebhookUpdate)
	104	+	case "WebhookDelete":
	105	+	err = CreateEvent[events.WebhookDelete](w, event, w.EventHandlers.WebhookDelete)
	106	+	case "ReportCreate":
	107	+	err = CreateEvent[events.ReportCreate](w, event, w.EventHandlers.ReportCreate)
	108	+	case "Auth":
	109	+	err = CreateEvent[events.Auth](w, event, w.EventHandlers.Auth)
	110	+	default:
	111	+	w.Logger.Warn("Unknown event type: " + typ)
	112	+	}
	113	+
	114	+	if err != nil {
	115	+	w.Logger.Error(
	116	+	"Event handling failed",
	117	+	zap.Error(err),
	118	+	)
	119	+	}
	120	+	}
	121	+
1	122		type EventHandlers struct {
2	123		// Not an actual revolt event, this is a sink that allows you to provide a function for raw event handling
3	124		RawSinkFunc func(w *GatewayClient, data []byte, typ string)

rootspring hat die Gist bearbeitet 1687625855. Zu Änderung gehen

1 file changed, 168 insertions

d(Datei erstellt)

		@@ -0,0 +1,168 @@
1	+	type EventHandlers struct {
2	+	// Not an actual revolt event, this is a sink that allows you to provide a function for raw event handling
3	+	RawSinkFunc func(w *GatewayClient, data []byte, typ string)
4	+
5	+	// An error occurred which meant you couldn't authenticate.
6	+	//
7	+	// <Note that grevolt handles these for you in general, but you can provide additional logic here>
8	+	Error func(w GatewayClient, ctx EventContext, e *events.Error)
9	+
10	+	// The server has authenticated your connection and you will shortly start receiving data.
11	+	Authenticated func(w GatewayClient, ctx EventContext, e *events.Authenticated)
12	+
13	+	// Several events have been sent, process each item of v as its own event.
14	+	//
15	+	// <Note that grevolt handles these for you in general, but you can provide additional logic here>
16	+	Bulk func(w GatewayClient, ctx EventContext, e *events.Bulk)
17	+
18	+	// Ping response from the server.
19	+	//
20	+	// <Note that grevolt handles these for you in general, but you can provide additional logic here>
21	+	Pong func(w GatewayClient, ctx EventContext, e *events.Pong)
22	+
23	+	// Data for use by client, data structures match the API specification
24	+	Ready func(w GatewayClient, ctx EventContext, e *events.Ready)
25	+
26	+	// Message received, the event object has the same schema as the Message object in the API with the addition of an event type.
27	+	Message func(w GatewayClient, ctx EventContext, e *events.Message)
28	+
29	+	// Message edited or otherwise updated.
30	+	MessageUpdate func(w GatewayClient, ctx EventContext, e *events.MessageUpdate)
31	+
32	+	// Message has data being appended to it.
33	+	MessageAppend func(w GatewayClient, ctx EventContext, e *events.MessageAppend)
34	+
35	+	// Message has been deleted.
36	+	MessageDelete func(w GatewayClient, ctx EventContext, e *events.MessageDelete)
37	+
38	+	// A reaction has been added to a message.
39	+	MessageReact func(w GatewayClient, ctx EventContext, e *events.MessageReact)
40	+
41	+	// A reaction has been removed from a message.
42	+	MessageUnreact func(w GatewayClient, ctx EventContext, e *events.MessageUnreact)
43	+
44	+	// A certain reaction has been removed from the message.
45	+	//
46	+	// <the difference between this and MessageUnreact is that
47	+	// this event is sent when a user with manage messages removes
48	+	// a reaction while MessageUnreact is sent when a user removes
49	+	// their own reaction>
50	+	MessageRemoveReaction func(w GatewayClient, ctx EventContext, e *events.MessageRemoveReaction)
51	+
52	+	// Channel created, the event object has the same schema as the Channel object in the API with the addition of an event type.
53	+	ChannelCreate func(w GatewayClient, ctx EventContext, e *events.ChannelCreate)
54	+
55	+	// Channel details updated.
56	+	ChannelUpdate func(w GatewayClient, ctx EventContext, e *events.ChannelUpdate)
57	+
58	+	// Channel has been deleted.
59	+	ChannelDelete func(w GatewayClient, ctx EventContext, e *events.ChannelDelete)
60	+
61	+	// A user has joined the group.
62	+	ChannelGroupJoin func(w GatewayClient, ctx EventContext, e *events.ChannelGroupJoin)
63	+
64	+	// A user has left the group.
65	+	ChannelGroupLeave func(w GatewayClient, ctx EventContext, e *events.ChannelGroupLeave)
66	+
67	+	// A user has started typing in this channel.
68	+	ChannelStartTyping func(w GatewayClient, ctx EventContext, e *events.ChannelStartTyping)
69	+
70	+	// A user has stopped typing in this channel.
71	+	ChannelStopTyping func(w GatewayClient, ctx EventContext, e *events.ChannelStopTyping)
72	+
73	+	// You have acknowledged new messages in this channel up to this message ID.
74	+	//
75	+	// <official docs say the above, but it should be 'A user' instead of 'you'?>
76	+	ChannelAck func(w GatewayClient, ctx EventContext, e *events.ChannelAck)
77	+
78	+	// Server created, the event object has the same schema as the SERVER object in the API with the addition of an event type.
79	+	ServerCreate func(w GatewayClient, ctx EventContext, e *events.ServerCreate)
80	+
81	+	// Server details updated.
82	+	ServerUpdate func(w GatewayClient, ctx EventContext, e *events.ServerUpdate)
83	+
84	+	// Server has been deleted.
85	+	ServerDelete func(w GatewayClient, ctx EventContext, e *events.ServerDelete)
86	+
87	+	// Server member details updated.
88	+	ServerMemberUpdate func(w GatewayClient, ctx EventContext, e *events.ServerMemberUpdate)
89	+
90	+	// A user has joined the group.
91	+	//
92	+	// <this should be server, not group>
93	+	ServerMemberJoin func(w GatewayClient, ctx EventContext, e *events.ServerMemberJoin)
94	+
95	+	// A user has left the group.
96	+	//
97	+	// <this should be server, not group>
98	+	ServerMemberLeave func(w GatewayClient, ctx EventContext, e *events.ServerMemberLeave)
99	+
100	+	// Server role has been updated or created.
101	+	ServerRoleUpdate func(w GatewayClient, ctx EventContext, e *events.ServerRoleUpdate)
102	+
103	+	// Server role has been deleted.
104	+	ServerRoleDelete func(w GatewayClient, ctx EventContext, e *events.ServerRoleDelete)
105	+
106	+	// User has been updated.
107	+	UserUpdate func(w GatewayClient, ctx EventContext, e *events.UserUpdate)
108	+
109	+	// Your relationship with another user has changed.
110	+	UserRelationship func(w GatewayClient, ctx EventContext, e *events.UserRelationship)
111	+
112	+	// Settings updated remotely
113	+	//
114	+	// <undocumented, will likely be available in a future release>
115	+	UserSettingsUpdate func(w GatewayClient, ctx EventContext, e *events.UserSettingsUpdate)
116	+
117	+	// User has been platform banned or deleted their account
118	+	//
119	+	// Clients should remove the following associated data:
120	+	// - Messages
121	+	// - DM Channels
122	+	// - Relationships
123	+	// - Server Memberships
124	+	//
125	+	// User flags are specified to explain why a wipe is occurring though not all reasons will necessarily ever appear.
126	+	UserPlatformWipe func(w GatewayClient, ctx EventContext, e *events.UserPlatformWipe)
127	+
128	+	// Emoji created, the event object has the same schema as the Emoji object in the API with the addition of an event type.
129	+	EmojiCreate func(w GatewayClient, ctx EventContext, e *events.EmojiCreate)
130	+
131	+	// Emoji has been deleted.
132	+	EmojiDelete func(w GatewayClient, ctx EventContext, e *events.EmojiDelete)
133	+
134	+	// New report
135	+	//
136	+	// <undocumented, will likely be available in a future release>
137	+	ReportCreate func(w GatewayClient, ctx EventContext, e *events.ReportCreate)
138	+
139	+	// Forwarded events from rAuth, currently only session deletion events are forwarded.
140	+	//
141	+	// <this event is special, you likely want AuthDeleteSession and AuthDeleteAllSessions instead>
142	+	Auth func(w GatewayClient, ctx EventContext, e *events.Auth)
143	+
144	+	// A session has been deleted.
145	+	//
146	+	// Eq: Auth->DeleteSession
147	+	AuthDeleteSession func(w GatewayClient, ctx EventContext, e *events.AuthDeleteSession)
148	+
149	+	// All sessions for this account have been deleted, optionally excluding a given ID.
150	+	//
151	+	// Eq: Auth->DeleteAllSessions
152	+	AuthDeleteAllSessions func(w GatewayClient, ctx EventContext, e *events.AuthDeleteAllSessions)
153	+
154	+	// New webhook
155	+	//
156	+	// <undocumented, will likely be available in a future release>
157	+	WebhookCreate func(w GatewayClient, ctx EventContext, e *events.WebhookCreate)
158	+
159	+	// Update existing webhook
160	+	//
161	+	// <undocumented, will likely be available in a future release>
162	+	WebhookUpdate func(w GatewayClient, ctx EventContext, e *events.WebhookUpdate)
163	+
164	+	// Delete existing webhook
165	+	//
166	+	// <undocumented, will likely be available in a future release>
167	+	WebhookDelete func(w GatewayClient, ctx EventContext, e *events.WebhookDelete)
168	+	}

Neuer Älter