restapi.go 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946
  1. // Discordgo - Discord bindings for Go
  2. // Available at https://github.com/bwmarrin/discordgo
  3. // Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>. All rights reserved.
  4. // Use of this source code is governed by a BSD-style
  5. // license that can be found in the LICENSE file.
  6. // This file contains functions for interacting with the Discord REST/JSON API
  7. // at the lowest level.
  8. package discordgo
  9. import (
  10. "bytes"
  11. "encoding/json"
  12. "errors"
  13. "fmt"
  14. "image"
  15. _ "image/jpeg" // For JPEG decoding
  16. _ "image/png" // For PNG decoding
  17. "io/ioutil"
  18. "net/http"
  19. "net/url"
  20. "strconv"
  21. "time"
  22. )
  23. var ErrJSONUnmarshal = errors.New("json unmarshal")
  24. // Request makes a (GET/POST/...) Requests to Discord REST API.
  25. // All the other Discord REST Calls in this file use this function.
  26. func (s *Session) Request(method, urlStr string, data interface{}) (response []byte, err error) {
  27. if s.Debug {
  28. fmt.Printf("API REQUEST %8s :: %s\n", method, urlStr)
  29. fmt.Println("API REQUEST PAYLOAD :: [" + fmt.Sprintf("%+v", data) + "]")
  30. }
  31. var body []byte
  32. if data != nil {
  33. body, err = json.Marshal(data)
  34. if err != nil {
  35. return
  36. }
  37. }
  38. req, err := http.NewRequest(method, urlStr, bytes.NewBuffer(body))
  39. if err != nil {
  40. return
  41. }
  42. // Not used on initial login..
  43. // TODO: Verify if a login, otherwise complain about no-token
  44. if s.Token != "" {
  45. req.Header.Set("authorization", s.Token)
  46. }
  47. req.Header.Set("Content-Type", "application/json")
  48. // TODO: Make a configurable static variable.
  49. req.Header.Set("User-Agent", fmt.Sprintf("DiscordBot (https://github.com/bwmarrin/discordgo, v%s)", VERSION))
  50. if s.Debug {
  51. for k, v := range req.Header {
  52. fmt.Printf("API REQUEST HEADER :: [%s] = %+v\n", k, v)
  53. }
  54. }
  55. client := &http.Client{Timeout: (20 * time.Second)}
  56. resp, err := client.Do(req)
  57. defer resp.Body.Close()
  58. if err != nil {
  59. return
  60. }
  61. response, err = ioutil.ReadAll(resp.Body)
  62. if err != nil {
  63. return
  64. }
  65. if s.Debug {
  66. fmt.Printf("API RESPONSE STATUS :: %s\n", resp.Status)
  67. for k, v := range resp.Header {
  68. fmt.Printf("API RESPONSE HEADER :: [%s] = %+v\n", k, v)
  69. }
  70. fmt.Printf("API RESPONSE BODY :: [%s]\n", response)
  71. }
  72. // See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
  73. switch resp.StatusCode {
  74. case 200: // OK
  75. case 204: // No Content
  76. // TODO check for 401 response, invalidate token if we get one.
  77. case 429: // TOO MANY REQUESTS - Rate limiting
  78. // This will be changed to a more robust method later.
  79. // which may be hugely different as this method could cause
  80. // unending recursion
  81. rl := RateLimit{}
  82. err = json.Unmarshal(response, &rl)
  83. if err != nil {
  84. err = fmt.Errorf("Request unmarshal rate limit error : %+v", err)
  85. return
  86. }
  87. time.Sleep(rl.RetryAfter)
  88. response, err = s.Request(method, urlStr, data)
  89. default: // Error condition
  90. err = fmt.Errorf("HTTP %s, %s", resp.Status, response)
  91. }
  92. return
  93. }
  94. func unmarshal(data []byte, v interface{}) error {
  95. err := json.Unmarshal(data, v)
  96. if err != nil {
  97. return ErrJSONUnmarshal
  98. }
  99. return nil
  100. }
  101. // ------------------------------------------------------------------------------------------------
  102. // Functions specific to Discord Sessions
  103. // ------------------------------------------------------------------------------------------------
  104. // Login asks the Discord server for an authentication token.
  105. func (s *Session) Login(email, password string) (err error) {
  106. data := struct {
  107. Email string `json:"email"`
  108. Password string `json:"password"`
  109. }{email, password}
  110. response, err := s.Request("POST", LOGIN, data)
  111. if err != nil {
  112. return
  113. }
  114. temp := struct {
  115. Token string `json:"token"`
  116. }{}
  117. err = unmarshal(response, &temp)
  118. if err != nil {
  119. return
  120. }
  121. s.Token = temp.Token
  122. return
  123. }
  124. // Register sends a Register request to Discord, and returns the authentication token
  125. // Note that this account is temporary and should be verified for future use.
  126. // Another option is to save the authentication token external, but this isn't recommended.
  127. func (s *Session) Register(username string) (token string, err error) {
  128. data := struct {
  129. Username string `json:"username"`
  130. }{username}
  131. response, err := s.Request("POST", REGISTER, data)
  132. if err != nil {
  133. return
  134. }
  135. temp := struct {
  136. Token string `json:"token"`
  137. }{}
  138. err = unmarshal(response, &temp)
  139. if err != nil {
  140. return
  141. }
  142. token = temp.Token
  143. return
  144. }
  145. // Logout sends a logout request to Discord.
  146. // This does not seem to actually invalidate the token. So you can still
  147. // make API calls even after a Logout. So, it seems almost pointless to
  148. // even use.
  149. func (s *Session) Logout() (err error) {
  150. // _, err = s.Request("POST", LOGOUT, fmt.Sprintf(`{"token": "%s"}`, s.Token))
  151. if s.Token == "" {
  152. return
  153. }
  154. data := struct {
  155. Token string `json:"token"`
  156. }{s.Token}
  157. _, err = s.Request("POST", LOGOUT, data)
  158. return
  159. }
  160. // ------------------------------------------------------------------------------------------------
  161. // Functions specific to Discord Users
  162. // ------------------------------------------------------------------------------------------------
  163. // User returns the user details of the given userID
  164. // userID : A user ID or "@me" which is a shortcut of current user ID
  165. func (s *Session) User(userID string) (st *User, err error) {
  166. body, err := s.Request("GET", USER(userID), nil)
  167. if err != nil {
  168. return
  169. }
  170. err = unmarshal(body, &st)
  171. return
  172. }
  173. // UserAvatar returns an image.Image of a users Avatar.
  174. // userID : A user ID or "@me" which is a shortcut of current user ID
  175. func (s *Session) UserAvatar(userID string) (img image.Image, err error) {
  176. u, err := s.User(userID)
  177. if err != nil {
  178. return
  179. }
  180. body, err := s.Request("GET", USER_AVATAR(userID, u.Avatar), nil)
  181. if err != nil {
  182. return
  183. }
  184. img, _, err = image.Decode(bytes.NewReader(body))
  185. return
  186. }
  187. // UserUpdate updates a users settings.
  188. func (s *Session) UserUpdate(email, password, username, avatar, newPassword string) (st *User, err error) {
  189. // NOTE: Avatar must be either the hash/id of existing Avatar or
  190. // data:image/png;base64,BASE64_STRING_OF_NEW_AVATAR_PNG
  191. // to set a new avatar.
  192. // If left blank, avatar will be set to null/blank
  193. data := struct {
  194. Email string `json:"email"`
  195. Password string `json:"password"`
  196. Username string `json:"username"`
  197. Avatar string `json:"avatar,omitempty"`
  198. NewPassword string `json:"new_password,omitempty"`
  199. }{email, password, username, avatar, newPassword}
  200. body, err := s.Request("PATCH", USER("@me"), data)
  201. if err != nil {
  202. return
  203. }
  204. err = unmarshal(body, &st)
  205. return
  206. }
  207. // UserSettings returns the settings for a given user
  208. func (s *Session) UserSettings() (st *Settings, err error) {
  209. body, err := s.Request("GET", USER_SETTINGS("@me"), nil)
  210. if err != nil {
  211. return
  212. }
  213. err = unmarshal(body, &st)
  214. return
  215. }
  216. // UserChannels returns an array of Channel structures for all private
  217. // channels.
  218. func (s *Session) UserChannels() (st []*Channel, err error) {
  219. body, err := s.Request("GET", USER_CHANNELS("@me"), nil)
  220. if err != nil {
  221. return
  222. }
  223. err = unmarshal(body, &st)
  224. return
  225. }
  226. // UserChannelCreate creates a new User (Private) Channel with another User
  227. // recipientID : A user ID for the user to which this channel is opened with.
  228. func (s *Session) UserChannelCreate(recipientID string) (st *Channel, err error) {
  229. data := struct {
  230. RecipientID string `json:"recipient_id"`
  231. }{recipientID}
  232. body, err := s.Request("POST", USER_CHANNELS("@me"), data)
  233. if err != nil {
  234. return
  235. }
  236. err = unmarshal(body, &st)
  237. return
  238. }
  239. // UserGuilds returns an array of Guild structures for all guilds.
  240. func (s *Session) UserGuilds() (st []*Guild, err error) {
  241. body, err := s.Request("GET", USER_GUILDS("@me"), nil)
  242. if err != nil {
  243. return
  244. }
  245. err = unmarshal(body, &st)
  246. return
  247. }
  248. // ------------------------------------------------------------------------------------------------
  249. // Functions specific to Discord Guilds
  250. // ------------------------------------------------------------------------------------------------
  251. // Guild returns a Guild structure of a specific Guild.
  252. // guildID : The ID of a Guild
  253. func (s *Session) Guild(guildID string) (st *Guild, err error) {
  254. if s.StateEnabled {
  255. // Attempt to grab the guild from State first.
  256. st, err = s.State.Guild(guildID)
  257. if err == nil {
  258. return
  259. }
  260. }
  261. body, err := s.Request("GET", GUILD(guildID), nil)
  262. if err != nil {
  263. return
  264. }
  265. err = unmarshal(body, &st)
  266. return
  267. }
  268. // GuildCreate creates a new Guild
  269. // name : A name for the Guild (2-100 characters)
  270. func (s *Session) GuildCreate(name string) (st *Guild, err error) {
  271. data := struct {
  272. Name string `json:"name"`
  273. }{name}
  274. body, err := s.Request("POST", GUILDS, data)
  275. if err != nil {
  276. return
  277. }
  278. err = unmarshal(body, &st)
  279. return
  280. }
  281. // GuildEdit edits a new Guild
  282. // guildID : The ID of a Guild
  283. // name : A name for the Guild (2-100 characters)
  284. func (s *Session) GuildEdit(guildID, name string) (st *Guild, err error) {
  285. data := struct {
  286. Name string `json:"name"`
  287. }{name}
  288. body, err := s.Request("POST", GUILD(guildID), data)
  289. if err != nil {
  290. return
  291. }
  292. err = unmarshal(body, &st)
  293. return
  294. }
  295. // GuildDelete deletes or leaves a Guild.
  296. // guildID : The ID of a Guild
  297. func (s *Session) GuildDelete(guildID string) (st *Guild, err error) {
  298. body, err := s.Request("DELETE", GUILD(guildID), nil)
  299. if err != nil {
  300. return
  301. }
  302. err = unmarshal(body, &st)
  303. return
  304. }
  305. // GuildBans returns an array of User structures for all bans of a
  306. // given guild.
  307. // guildID : The ID of a Guild.
  308. func (s *Session) GuildBans(guildID string) (st []*User, err error) {
  309. body, err := s.Request("GET", GUILD_BANS(guildID), nil)
  310. if err != nil {
  311. return
  312. }
  313. err = unmarshal(body, &st)
  314. return
  315. }
  316. // GuildBanCreate bans the given user from the given guild.
  317. // guildID : The ID of a Guild.
  318. // userID : The ID of a User
  319. // days : The number of days of previous comments to delete.
  320. func (s *Session) GuildBanCreate(guildID, userID string, days int) (err error) {
  321. uri := GUILD_BAN(guildID, userID)
  322. if days > 0 {
  323. uri = fmt.Sprintf("%s?delete-message-days=%d", uri, days)
  324. }
  325. _, err = s.Request("PUT", uri, nil)
  326. return
  327. }
  328. // GuildBanDelete removes the given user from the guild bans
  329. // guildID : The ID of a Guild.
  330. // userID : The ID of a User
  331. func (s *Session) GuildBanDelete(guildID, userID string) (err error) {
  332. _, err = s.Request("DELETE", GUILD_BAN(guildID, userID), nil)
  333. return
  334. }
  335. // GuildMemberDelete removes the given user from the given guild.
  336. // guildID : The ID of a Guild.
  337. // userID : The ID of a User
  338. func (s *Session) GuildMemberDelete(guildID, userID string) (err error) {
  339. _, err = s.Request("DELETE", GUILD_MEMBER(guildID, userID), nil)
  340. return
  341. }
  342. // GuildMemberEdit edits the roles of a member.
  343. // guildID : The ID of a Guild.
  344. // userID : The ID of a User.
  345. // roles : A list of role ID's to set on the member.
  346. func (s *Session) GuildMemberEdit(guildID, userID string, roles []string) (err error) {
  347. data := struct {
  348. Roles []string `json:"roles"`
  349. }{roles}
  350. _, err = s.Request("PATCH", GUILD_MEMBER(guildID, userID), data)
  351. if err != nil {
  352. return
  353. }
  354. return
  355. }
  356. // GuildChannels returns an array of Channel structures for all channels of a
  357. // given guild.
  358. // guildID : The ID of a Guild.
  359. func (s *Session) GuildChannels(guildID string) (st []*Channel, err error) {
  360. body, err := s.Request("GET", GUILD_CHANNELS(guildID), nil)
  361. if err != nil {
  362. return
  363. }
  364. err = unmarshal(body, &st)
  365. return
  366. }
  367. // GuildChannelCreate creates a new channel in the given guild
  368. // guildID : The ID of a Guild.
  369. // name : Name of the channel (2-100 chars length)
  370. // ctype : Tpye of the channel (voice or text)
  371. func (s *Session) GuildChannelCreate(guildID, name, ctype string) (st *Channel, err error) {
  372. data := struct {
  373. Name string `json:"name"`
  374. Type string `json:"type"`
  375. }{name, ctype}
  376. body, err := s.Request("POST", GUILD_CHANNELS(guildID), data)
  377. if err != nil {
  378. return
  379. }
  380. err = unmarshal(body, &st)
  381. return
  382. }
  383. // GuildInvites returns an array of Invite structures for the given guild
  384. // guildID : The ID of a Guild.
  385. func (s *Session) GuildInvites(guildID string) (st []*Invite, err error) {
  386. body, err := s.Request("GET", GUILD_INVITES(guildID), nil)
  387. if err != nil {
  388. return
  389. }
  390. err = unmarshal(body, &st)
  391. return
  392. }
  393. // GuildInviteCreate creates a new invite for the given guild.
  394. // guildID : The ID of a Guild.
  395. // i : An Invite struct with the values MaxAge, MaxUses, Temporary,
  396. // and XkcdPass defined.
  397. func (s *Session) GuildInviteCreate(guildID string, i *Invite) (st *Invite, err error) {
  398. data := struct {
  399. MaxAge int `json:"max_age"`
  400. MaxUses int `json:"max_uses"`
  401. Temporary bool `json:"temporary"`
  402. XKCDPass bool `json:"xkcdpass"`
  403. }{i.MaxAge, i.MaxUses, i.Temporary, i.XkcdPass}
  404. body, err := s.Request("POST", GUILD_INVITES(guildID), data)
  405. if err != nil {
  406. return
  407. }
  408. err = unmarshal(body, &st)
  409. return
  410. }
  411. // GuildRoles returns all roles for a given guild.
  412. // guildID : The ID of a Guild.
  413. func (s *Session) GuildRoles(guildID string) (st []*Role, err error) {
  414. body, err := s.Request("GET", GUILD_ROLES(guildID), nil)
  415. if err != nil {
  416. return
  417. }
  418. err = unmarshal(body, &st)
  419. return // TODO return pointer
  420. }
  421. // GuildRoleCreate returns a new Guild Role.
  422. // guildID: The ID of a Guild.
  423. func (s *Session) GuildRoleCreate(guildID string) (st *Role, err error) {
  424. body, err := s.Request("POST", GUILD_ROLES(guildID), nil)
  425. if err != nil {
  426. return
  427. }
  428. err = unmarshal(body, &st)
  429. return
  430. }
  431. // GuildRoleEdit updates an existing Guild Role with new values
  432. // guildID : The ID of a Guild.
  433. // roleID : The ID of a Role.
  434. // name : The name of the Role.
  435. // color : The color of the role (decimal, not hex).
  436. // hoist : Whether to display the role's users separately.
  437. // perm : The permissions for the role.
  438. func (s *Session) GuildRoleEdit(guildID, roleID, name string, color int, hoist bool, perm int) (st *Role, err error) {
  439. data := struct {
  440. Name string `json:"name"` // The color the role should have (as a decimal, not hex)
  441. Color int `json:"color"` // Whether to display the role's users separately
  442. Hoist bool `json:"hoist"` // The role's name (overwrites existing)
  443. Permissions int `json:"permissions"` // The overall permissions number of the role (overwrites existing)
  444. }{name, color, hoist, perm}
  445. body, err := s.Request("PATCH", GUILD_ROLE(guildID, roleID), data)
  446. if err != nil {
  447. return
  448. }
  449. err = unmarshal(body, &st)
  450. return
  451. }
  452. // GuildRoleReorder reoders guild roles
  453. // guildID : The ID of a Guild.
  454. // roles : A list of ordered roles.
  455. func (s *Session) GuildRoleReorder(guildID string, roles []*Role) (st []*Role, err error) {
  456. body, err := s.Request("PATCH", GUILD_ROLES(guildID), roles)
  457. if err != nil {
  458. return
  459. }
  460. err = unmarshal(body, &st)
  461. return
  462. }
  463. // GuildRoleDelete deletes an existing role.
  464. // guildID : The ID of a Guild.
  465. // roleID : The ID of a Role.
  466. func (s *Session) GuildRoleDelete(guildID, roleID string) (err error) {
  467. _, err = s.Request("DELETE", GUILD_ROLE(guildID, roleID), nil)
  468. return
  469. }
  470. // GuildIcon returns an image.Image of a guild icon.
  471. // guildID : The ID of a Guild.
  472. func (s *Session) GuildIcon(guildID string) (img image.Image, err error) {
  473. g, err := s.Guild(guildID)
  474. if err != nil {
  475. return
  476. }
  477. if g.Icon == "" {
  478. err = errors.New("Guild does not have an icon set.")
  479. return
  480. }
  481. body, err := s.Request("GET", GUILD_ICON(guildID, g.Icon), nil)
  482. if err != nil {
  483. return
  484. }
  485. img, _, err = image.Decode(bytes.NewReader(body))
  486. return
  487. }
  488. // GuildSplash returns an image.Image of a guild splash image.
  489. // guildID : The ID of a Guild.
  490. func (s *Session) GuildSplash(guildID string) (img image.Image, err error) {
  491. g, err := s.Guild(guildID)
  492. if err != nil {
  493. return
  494. }
  495. if g.Splash == "" {
  496. err = errors.New("Guild does not have a splash set.")
  497. return
  498. }
  499. body, err := s.Request("GET", GUILD_SPLASH(guildID, g.Splash), nil)
  500. if err != nil {
  501. return
  502. }
  503. img, _, err = image.Decode(bytes.NewReader(body))
  504. return
  505. }
  506. // ------------------------------------------------------------------------------------------------
  507. // Functions specific to Discord Channels
  508. // ------------------------------------------------------------------------------------------------
  509. // Channel returns a Channel strucutre of a specific Channel.
  510. // channelID : The ID of the Channel you want returend.
  511. func (s *Session) Channel(channelID string) (st *Channel, err error) {
  512. body, err := s.Request("GET", CHANNEL(channelID), nil)
  513. if err != nil {
  514. return
  515. }
  516. err = unmarshal(body, &st)
  517. return
  518. }
  519. // ChannelEdit edits the given channel
  520. // channelID : The ID of a Channel
  521. // name : The new name to assign the channel.
  522. func (s *Session) ChannelEdit(channelID, name string) (st *Channel, err error) {
  523. data := struct {
  524. Name string `json:"name"`
  525. }{name}
  526. body, err := s.Request("PATCH", CHANNEL(channelID), data)
  527. if err != nil {
  528. return
  529. }
  530. err = unmarshal(body, &st)
  531. return
  532. }
  533. // ChannelDelete deletes the given channel
  534. // channelID : The ID of a Channel
  535. func (s *Session) ChannelDelete(channelID string) (st *Channel, err error) {
  536. body, err := s.Request("DELETE", CHANNEL(channelID), nil)
  537. if err != nil {
  538. return
  539. }
  540. err = unmarshal(body, &st)
  541. return
  542. }
  543. // ChannelTyping broadcasts to all members that authenticated user is typing in
  544. // the given channel.
  545. // channelID : The ID of a Channel
  546. func (s *Session) ChannelTyping(channelID string) (err error) {
  547. _, err = s.Request("POST", CHANNEL_TYPING(channelID), nil)
  548. return
  549. }
  550. // ChannelMessages returns an array of Message structures for messages within
  551. // a given channel.
  552. // channelID : The ID of a Channel.
  553. // limit : The number messages that can be returned.
  554. // beforeID : If provided all messages returned will be before given ID.
  555. // afterID : If provided all messages returned will be after given ID.
  556. func (s *Session) ChannelMessages(channelID string, limit int, beforeID int, afterID int) (st []*Message, err error) {
  557. uri := CHANNEL_MESSAGES(channelID)
  558. v := url.Values{}
  559. if limit > 0 {
  560. v.Set("limit", strconv.Itoa(limit))
  561. }
  562. if afterID > 0 {
  563. v.Set("after", strconv.Itoa(afterID))
  564. }
  565. if beforeID > 0 {
  566. v.Set("before", strconv.Itoa(beforeID))
  567. }
  568. if len(v) > 0 {
  569. uri = fmt.Sprintf("%s?%s", uri, v.Encode())
  570. }
  571. body, err := s.Request("GET", uri, nil)
  572. if err != nil {
  573. return
  574. }
  575. err = unmarshal(body, &st)
  576. return
  577. }
  578. // ChannelMessageAck acknowledges and marks the given message as read
  579. // channeld : The ID of a Channel
  580. // messageID : the ID of a Message
  581. func (s *Session) ChannelMessageAck(channelID, messageID string) (err error) {
  582. _, err = s.Request("POST", CHANNEL_MESSAGE_ACK(channelID, messageID), nil)
  583. return
  584. }
  585. // ChannelMessageSend sends a message to the given channel.
  586. // channelID : The ID of a Channel.
  587. // content : The message to send.
  588. // NOTE, mention and tts parameters may be added in 2.x branch.
  589. func (s *Session) ChannelMessageSend(channelID string, content string) (st *Message, err error) {
  590. // TODO: nonce string ?
  591. data := struct {
  592. Content string `json:"content"`
  593. TTS bool `json:"tts"`
  594. }{content, false}
  595. // Send the message to the given channel
  596. response, err := s.Request("POST", CHANNEL_MESSAGES(channelID), data)
  597. if err != nil {
  598. return
  599. }
  600. err = unmarshal(response, &st)
  601. return
  602. }
  603. // ChannelMessageEdit edits an existing message, replacing it entirely with
  604. // the given content.
  605. // channeld : The ID of a Channel
  606. // messageID : the ID of a Message
  607. func (s *Session) ChannelMessageEdit(channelID, messageID, content string) (st *Message, err error) {
  608. data := struct {
  609. Content string `json:"content"`
  610. }{content}
  611. response, err := s.Request("PATCH", CHANNEL_MESSAGE(channelID, messageID), data)
  612. if err != nil {
  613. return
  614. }
  615. err = unmarshal(response, &st)
  616. return
  617. }
  618. // ChannelMessageDelete deletes a message from the Channel.
  619. func (s *Session) ChannelMessageDelete(channelID, messageID string) (err error) {
  620. _, err = s.Request("DELETE", CHANNEL_MESSAGE(channelID, messageID), nil)
  621. return
  622. }
  623. // ChannelInvites returns an array of Invite structures for the given channel
  624. // channelID : The ID of a Channel
  625. func (s *Session) ChannelInvites(channelID string) (st []*Invite, err error) {
  626. body, err := s.Request("GET", CHANNEL_INVITES(channelID), nil)
  627. if err != nil {
  628. return
  629. }
  630. err = unmarshal(body, &st)
  631. return
  632. }
  633. // ChannelInviteCreate creates a new invite for the given channel.
  634. // channelID : The ID of a Channel
  635. // i : An Invite struct with the values MaxAge, MaxUses, Temporary,
  636. // and XkcdPass defined.
  637. func (s *Session) ChannelInviteCreate(channelID string, i Invite) (st *Invite, err error) {
  638. data := struct {
  639. MaxAge int `json:"max_age"`
  640. MaxUses int `json:"max_uses"`
  641. Temporary bool `json:"temporary"`
  642. XKCDPass bool `json:"xkcdpass"`
  643. }{i.MaxAge, i.MaxUses, i.Temporary, i.XkcdPass}
  644. body, err := s.Request("POST", CHANNEL_INVITES(channelID), data)
  645. if err != nil {
  646. return
  647. }
  648. err = unmarshal(body, &st)
  649. return
  650. }
  651. // ChannelPermissionSet creates a Permission Override for the given channel.
  652. // NOTE: This func name may changed. Using Set instead of Create because
  653. // you can both create a new override or update an override with this function.
  654. func (s *Session) ChannelPermissionSet(channelID, targetID, targetType string, allow, deny int) (err error) {
  655. data := struct {
  656. ID string `json:"id"`
  657. Type string `json:"type"`
  658. Allow int `json:"allow"`
  659. Deny int `json:"deny"`
  660. }{targetID, targetType, allow, deny}
  661. _, err = s.Request("PUT", CHANNEL_PERMISSION(channelID, targetID), data)
  662. return
  663. }
  664. // ChannelPermissionDelete deletes a specific permission override for the given channel.
  665. // NOTE: Name of this func may change.
  666. func (s *Session) ChannelPermissionDelete(channelID, targetID string) (err error) {
  667. _, err = s.Request("DELETE", CHANNEL_PERMISSION(channelID, targetID), nil)
  668. return
  669. }
  670. // ------------------------------------------------------------------------------------------------
  671. // Functions specific to Discord Invites
  672. // ------------------------------------------------------------------------------------------------
  673. // Invite returns an Invite structure of the given invite
  674. // inviteID : The invite code (or maybe xkcdpass?)
  675. func (s *Session) Invite(inviteID string) (st *Invite, err error) {
  676. body, err := s.Request("GET", INVITE(inviteID), nil)
  677. if err != nil {
  678. return
  679. }
  680. err = unmarshal(body, &st)
  681. return
  682. }
  683. // InviteDelete deletes an existing invite
  684. // inviteID : the code (or maybe xkcdpass?) of an invite
  685. func (s *Session) InviteDelete(inviteID string) (st *Invite, err error) {
  686. body, err := s.Request("DELETE", INVITE(inviteID), nil)
  687. if err != nil {
  688. return
  689. }
  690. err = unmarshal(body, &st)
  691. return
  692. }
  693. // InviteAccept accepts an Invite to a Guild or Channel
  694. // inviteID : The invite code (or maybe xkcdpass?)
  695. func (s *Session) InviteAccept(inviteID string) (st *Invite, err error) {
  696. body, err := s.Request("POST", INVITE(inviteID), nil)
  697. if err != nil {
  698. return
  699. }
  700. err = unmarshal(body, &st)
  701. return
  702. }
  703. // ------------------------------------------------------------------------------------------------
  704. // Functions specific to Discord Voice
  705. // ------------------------------------------------------------------------------------------------
  706. // VoiceRegions returns the voice server regions
  707. func (s *Session) VoiceRegions() (st []*VoiceRegion, err error) {
  708. body, err := s.Request("GET", VOICE_REGIONS, nil)
  709. if err != nil {
  710. return
  711. }
  712. err = unmarshal(body, &st)
  713. return
  714. }
  715. // VoiceICE returns the voice server ICE information
  716. func (s *Session) VoiceICE() (st *VoiceICE, err error) {
  717. body, err := s.Request("GET", VOICE_ICE, nil)
  718. if err != nil {
  719. return
  720. }
  721. err = unmarshal(body, &st)
  722. return
  723. }
  724. // ------------------------------------------------------------------------------------------------
  725. // Functions specific to Discord Websockets
  726. // ------------------------------------------------------------------------------------------------
  727. // Gateway returns the a websocket Gateway address
  728. func (s *Session) Gateway() (gateway string, err error) {
  729. response, err := s.Request("GET", GATEWAY, nil)
  730. if err != nil {
  731. return
  732. }
  733. temp := struct {
  734. URL string `json:"url"`
  735. }{}
  736. err = unmarshal(response, &temp)
  737. if err != nil {
  738. return
  739. }
  740. gateway = temp.URL
  741. return
  742. }