wsapi.go 9.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. /******************************************************************************
  2. * A Discord API for Golang.
  3. * See discord.go for more information.
  4. *
  5. * This file contains low level functions for interacting
  6. * with the Discord Websocket interface.
  7. */
  8. package discordgo
  9. import (
  10. "encoding/json"
  11. "fmt"
  12. "runtime"
  13. "time"
  14. "github.com/gorilla/websocket"
  15. )
  16. // Basic struct for all Websocket Event messages
  17. type Event struct {
  18. Type string `json:"t"`
  19. State int `json:"s"`
  20. Operation int `json:"o"`
  21. Direction int `json:"dir"`
  22. //Direction of command, 0-received, 1-sent -- thanks Xackery/discord
  23. RawData json.RawMessage `json:"d"`
  24. Session Session
  25. }
  26. // The Ready Event given after initial connection
  27. type Ready struct {
  28. Version int `json:"v"`
  29. SessionID string `json:"session_id"`
  30. HeartbeatInterval time.Duration `json:"heartbeat_interval"`
  31. User User `json:"user"`
  32. ReadState []ReadState
  33. PrivateChannels []PrivateChannel
  34. Guilds []Guild
  35. }
  36. // ReadState might need to move? Gives me the read status
  37. // of all my channels when first connecting. I think :)
  38. type ReadState struct {
  39. MentionCount int
  40. LastMessageID int `json:"last_message_id,string"`
  41. ID int `json:"id,string"`
  42. }
  43. type TypingStart struct {
  44. UserId int `json:"user_id,string"`
  45. ChannelId int `json:"channel_id,string"`
  46. Timestamp int `json:"timestamp"`
  47. }
  48. type PresenceUpdate struct {
  49. User User `json:"user"`
  50. Status string `json:"status"`
  51. Roles []string `json:"roles"` // TODO: Should be ints, see below
  52. GuildId int `json:"guild_id,string"`
  53. GameId int `json:"game_id"`
  54. }
  55. //Roles []string `json:"roles"` // TODO: Should be ints, see below
  56. // Above "Roles" should be an array of ints
  57. // TODO: Figure out how to make it be one.
  58. /*
  59. {
  60. "roles": [
  61. "89544728336416768",
  62. "110429733396676608"
  63. ],
  64. }
  65. */
  66. type MessageAck struct {
  67. MessageId int `json:"message_id,string"`
  68. ChannelId int `json:"channel_id,string"`
  69. }
  70. type MessageDelete struct {
  71. Id int `json:"id,string"`
  72. ChannelId int `json:"channel_id,string"`
  73. } // so much like MessageAck..
  74. type GuildIntegrationsUpdate struct {
  75. GuildId int `json:"guild_id,string"`
  76. }
  77. // Open a websocket connection to Discord
  78. func Open(s *Session) (err error) {
  79. // TODO: See if there's a use for the http response.
  80. // conn, response, err := websocket.DefaultDialer.Dial(session.Gateway, nil)
  81. s.wsConn, _, err = websocket.DefaultDialer.Dial(s.Gateway, nil)
  82. return
  83. }
  84. // maybe this is SendOrigin? not sure the right name here
  85. // also bson.M vs string interface map? Read about
  86. // how to send JSON the right way.
  87. func Handshake(s *Session) (err error) {
  88. err = s.wsConn.WriteJSON(map[string]interface{}{
  89. "op": 2,
  90. "d": map[string]interface{}{
  91. "v": 3,
  92. "token": s.Token,
  93. "properties": map[string]string{
  94. "$os": runtime.GOOS,
  95. "$browser": "Discordgo",
  96. "$device": "Discordgo",
  97. "$referer": "",
  98. "$referring_domain": "",
  99. },
  100. },
  101. })
  102. return
  103. }
  104. func UpdateStatus(s *Session, idleSince, gameId string) (err error) {
  105. err = s.wsConn.WriteJSON(map[string]interface{}{
  106. "op": 2,
  107. "d": map[string]interface{}{
  108. "idle_since": idleSince,
  109. "game_id": gameId,
  110. },
  111. })
  112. return
  113. }
  114. // TODO: need a channel or something to communicate
  115. // to this so I can tell it to stop listening
  116. func Listen(s *Session) (err error) {
  117. if s.wsConn == nil {
  118. fmt.Println("No websocket connection exists.")
  119. return // need to return an error.
  120. }
  121. for { // s.wsConn != nil { // need a cleaner way to exit? this doesn't acheive anything.
  122. messageType, message, err := s.wsConn.ReadMessage()
  123. if err != nil {
  124. fmt.Println(err)
  125. break
  126. }
  127. go event(s, messageType, message)
  128. }
  129. return
  130. }
  131. // Not sure how needed this is and where it would be best to call it.
  132. // somewhere.
  133. func Close(s *Session) {
  134. s.wsConn.Close()
  135. }
  136. // Front line handler for all Websocket Events. Determines the
  137. // event type and passes the message along to the next handler.
  138. func event(s *Session, messageType int, message []byte) (err error) {
  139. if s.Debug {
  140. printJSON(message)
  141. }
  142. var e Event
  143. if err := json.Unmarshal(message, &e); err != nil {
  144. return err
  145. }
  146. switch e.Type {
  147. case "READY":
  148. if s.OnReady != nil {
  149. var st Ready
  150. if err := json.Unmarshal(e.RawData, &st); err != nil {
  151. fmt.Println(err)
  152. printJSON(e.RawData) // TODO: Better error logging
  153. return
  154. }
  155. s.OnReady(s, st)
  156. return
  157. }
  158. case "VOICE_STATE_UPDATE":
  159. if s.OnVoiceStateUpdate != nil {
  160. var st VoiceState
  161. if err := json.Unmarshal(e.RawData, &st); err != nil {
  162. fmt.Println(err)
  163. printJSON(e.RawData) // TODO: Better error logging
  164. return
  165. }
  166. s.OnVoiceStateUpdate(s, st)
  167. return
  168. }
  169. case "PRESENCE_UPDATE":
  170. if s.OnPresenceUpdate != nil {
  171. var st PresenceUpdate
  172. if err := json.Unmarshal(e.RawData, &st); err != nil {
  173. fmt.Println(err)
  174. printJSON(e.RawData) // TODO: Better error logging
  175. return err
  176. }
  177. s.OnPresenceUpdate(s, st)
  178. return
  179. }
  180. case "TYPING_START":
  181. if s.OnTypingStart != nil {
  182. var st TypingStart
  183. if err := json.Unmarshal(e.RawData, &st); err != nil {
  184. printJSON(e.RawData) // TODO: Better error logging
  185. return err
  186. }
  187. s.OnTypingStart(s, st)
  188. return
  189. }
  190. case "MESSAGE_CREATE":
  191. if s.OnMessageCreate != nil {
  192. var st Message
  193. if err := json.Unmarshal(e.RawData, &st); err != nil {
  194. printJSON(e.RawData) // TODO: Better error logging
  195. return err
  196. }
  197. s.OnMessageCreate(s, st)
  198. return
  199. }
  200. case "MESSAGE_UPDATE":
  201. if s.OnMessageUpdate != nil {
  202. var st Message
  203. if err := json.Unmarshal(e.RawData, &st); err != nil {
  204. printJSON(e.RawData) // TODO: Better error logging
  205. return err
  206. }
  207. s.OnMessageUpdate(s, st)
  208. return
  209. }
  210. case "MESSAGE_DELETE":
  211. if s.OnMessageDelete != nil {
  212. var st MessageDelete
  213. if err := json.Unmarshal(e.RawData, &st); err != nil {
  214. printJSON(e.RawData) // TODO: Better error logging
  215. return err
  216. }
  217. s.OnMessageDelete(s, st)
  218. return
  219. }
  220. case "MESSAGE_ACK":
  221. if s.OnMessageAck != nil {
  222. var st MessageAck
  223. if err := json.Unmarshal(e.RawData, &st); err != nil {
  224. printJSON(e.RawData) // TODO: Better error logging
  225. return err
  226. }
  227. s.OnMessageAck(s, st)
  228. return
  229. }
  230. case "CHANNEL_CREATE":
  231. if s.OnChannelCreate != nil {
  232. var st Channel
  233. if err := json.Unmarshal(e.RawData, &st); err != nil {
  234. printJSON(e.RawData) // TODO: Better error logginEventg
  235. return err
  236. }
  237. s.OnChannelCreate(s, st)
  238. return
  239. }
  240. case "CHANNEL_UPDATE":
  241. if s.OnChannelUpdate != nil {
  242. var st Channel
  243. if err := json.Unmarshal(e.RawData, &st); err != nil {
  244. printJSON(e.RawData) // TODO: Better error logginEventg
  245. return err
  246. }
  247. s.OnChannelUpdate(s, st)
  248. return
  249. }
  250. case "CHANNEL_DELETE":
  251. if s.OnChannelDelete != nil {
  252. var st Channel
  253. if err := json.Unmarshal(e.RawData, &st); err != nil {
  254. printJSON(e.RawData) // TODO: Better error logginEventg
  255. return err
  256. }
  257. s.OnChannelDelete(s, st)
  258. return
  259. }
  260. case "GUILD_CREATE":
  261. if s.OnGuildCreate != nil {
  262. var st Guild
  263. if err := json.Unmarshal(e.RawData, &st); err != nil {
  264. printJSON(e.RawData) // TODO: Better error logginEventg
  265. return err
  266. }
  267. s.OnGuildCreate(s, st)
  268. return
  269. }
  270. case "GUILD_DELETE":
  271. if s.OnGuildDelete != nil {
  272. var st Guild
  273. if err := json.Unmarshal(e.RawData, &st); err != nil {
  274. printJSON(e.RawData) // TODO: Better error logginEventg
  275. return err
  276. }
  277. s.OnGuildDelete(s, st)
  278. return
  279. }
  280. case "GUILD_MEMBER_ADD":
  281. if s.OnGuildMemberAdd != nil {
  282. var st Member
  283. if err := json.Unmarshal(e.RawData, &st); err != nil {
  284. printJSON(e.RawData) // TODO: Better error logginEventg
  285. return err
  286. }
  287. s.OnGuildMemberAdd(s, st)
  288. return
  289. }
  290. case "GUILD_MEMBER_REMOVE":
  291. if s.OnGuildMemberRemove != nil {
  292. var st Member
  293. if err := json.Unmarshal(e.RawData, &st); err != nil {
  294. printJSON(e.RawData) // TODO: Better error logginEventg
  295. return err
  296. }
  297. s.OnGuildMemberRemove(s, st)
  298. return
  299. }
  300. case "GUILD_MEMBER_UPDATE":
  301. if s.OnGuildMemberUpdate != nil {
  302. var st Member
  303. if err := json.Unmarshal(e.RawData, &st); err != nil {
  304. printJSON(e.RawData) // TODO: Better error logginEventg
  305. return err
  306. }
  307. s.OnGuildMemberUpdate(s, st)
  308. return
  309. }
  310. /*
  311. case "GUILD_ROLE_CREATE":
  312. if s.OnGuildRoleCreate != nil {
  313. }
  314. case "GUILD_ROLE_DELETE":
  315. if s.OnGuildRoleDelete != nil {
  316. }
  317. */
  318. case "GUILD_INTEGRATIONS_UPDATE":
  319. if s.OnGuildIntegrationsUpdate != nil {
  320. var st GuildIntegrationsUpdate
  321. if err := json.Unmarshal(e.RawData, &st); err != nil {
  322. printJSON(e.RawData) // TODO: Better error logginEventg
  323. return err
  324. }
  325. s.OnGuildIntegrationsUpdate(s, st)
  326. return
  327. }
  328. default:
  329. fmt.Println("UNKNOWN EVENT: ", e.Type)
  330. // learn the log package
  331. // log.print type and JSON data
  332. }
  333. // if still here, send to generic OnEvent
  334. if s.OnEvent != nil {
  335. s.OnEvent(s, e)
  336. }
  337. return
  338. }
  339. // This heartbeat is sent to keep the Websocket conenction
  340. // to Discord alive. If not sent, Discord will close the
  341. // connection.
  342. func Heartbeat(s *Session, i time.Duration) {
  343. if s.wsConn == nil {
  344. fmt.Println("No websocket connection exists.")
  345. return // need to return an error.
  346. }
  347. ticker := time.NewTicker(i * time.Millisecond)
  348. for range ticker.C {
  349. timestamp := int(time.Now().Unix())
  350. err := s.wsConn.WriteJSON(map[string]int{
  351. "op": 1,
  352. "d": timestamp,
  353. })
  354. if err != nil {
  355. return // log error?
  356. }
  357. }
  358. }