state.go 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945
  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 code related to state tracking. If enabled, state
  7. // tracking will capture the initial READY packet and many other websocket
  8. // events and maintain an in-memory state of of guilds, channels, users, and
  9. // so forth. This information can be accessed through the Session.State struct.
  10. package discordgo
  11. import (
  12. "errors"
  13. "sort"
  14. "sync"
  15. )
  16. // ErrNilState is returned when the state is nil.
  17. var ErrNilState = errors.New("state not instantiated, please use discordgo.New() or assign Session.State")
  18. // A State contains the current known state.
  19. // As discord sends this in a READY blob, it seems reasonable to simply
  20. // use that struct as the data store.
  21. type State struct {
  22. sync.RWMutex
  23. Ready
  24. MaxMessageCount int
  25. TrackChannels bool
  26. TrackEmojis bool
  27. TrackMembers bool
  28. TrackRoles bool
  29. TrackVoice bool
  30. TrackPresences bool
  31. guildMap map[string]*Guild
  32. channelMap map[string]*Channel
  33. }
  34. // NewState creates an empty state.
  35. func NewState() *State {
  36. return &State{
  37. Ready: Ready{
  38. PrivateChannels: []*Channel{},
  39. Guilds: []*Guild{},
  40. },
  41. TrackChannels: true,
  42. TrackEmojis: true,
  43. TrackMembers: true,
  44. TrackRoles: true,
  45. TrackVoice: true,
  46. TrackPresences: true,
  47. guildMap: make(map[string]*Guild),
  48. channelMap: make(map[string]*Channel),
  49. }
  50. }
  51. // GuildAdd adds a guild to the current world state, or
  52. // updates it if it already exists.
  53. func (s *State) GuildAdd(guild *Guild) error {
  54. if s == nil {
  55. return ErrNilState
  56. }
  57. s.Lock()
  58. defer s.Unlock()
  59. // Update the channels to point to the right guild, adding them to the channelMap as we go
  60. for _, c := range guild.Channels {
  61. s.channelMap[c.ID] = c
  62. }
  63. if g, ok := s.guildMap[guild.ID]; ok {
  64. // We are about to replace `g` in the state with `guild`, but first we need to
  65. // make sure we preserve any fields that the `guild` doesn't contain from `g`.
  66. if guild.Roles == nil {
  67. guild.Roles = g.Roles
  68. }
  69. if guild.Emojis == nil {
  70. guild.Emojis = g.Emojis
  71. }
  72. if guild.Members == nil {
  73. guild.Members = g.Members
  74. }
  75. if guild.Presences == nil {
  76. guild.Presences = g.Presences
  77. }
  78. if guild.Channels == nil {
  79. guild.Channels = g.Channels
  80. }
  81. if guild.VoiceStates == nil {
  82. guild.VoiceStates = g.VoiceStates
  83. }
  84. *g = *guild
  85. return nil
  86. }
  87. s.Guilds = append(s.Guilds, guild)
  88. s.guildMap[guild.ID] = guild
  89. return nil
  90. }
  91. // GuildRemove removes a guild from current world state.
  92. func (s *State) GuildRemove(guild *Guild) error {
  93. if s == nil {
  94. return ErrNilState
  95. }
  96. _, err := s.Guild(guild.ID)
  97. if err != nil {
  98. return err
  99. }
  100. s.Lock()
  101. defer s.Unlock()
  102. delete(s.guildMap, guild.ID)
  103. for i, g := range s.Guilds {
  104. if g.ID == guild.ID {
  105. s.Guilds = append(s.Guilds[:i], s.Guilds[i+1:]...)
  106. return nil
  107. }
  108. }
  109. return nil
  110. }
  111. // Guild gets a guild by ID.
  112. // Useful for querying if @me is in a guild:
  113. // _, err := discordgo.Session.State.Guild(guildID)
  114. // isInGuild := err == nil
  115. func (s *State) Guild(guildID string) (*Guild, error) {
  116. if s == nil {
  117. return nil, ErrNilState
  118. }
  119. s.RLock()
  120. defer s.RUnlock()
  121. if g, ok := s.guildMap[guildID]; ok {
  122. return g, nil
  123. }
  124. return nil, errors.New("guild not found")
  125. }
  126. // PresenceAdd adds a presence to the current world state, or
  127. // updates it if it already exists.
  128. func (s *State) PresenceAdd(guildID string, presence *Presence) error {
  129. if s == nil {
  130. return ErrNilState
  131. }
  132. guild, err := s.Guild(guildID)
  133. if err != nil {
  134. return err
  135. }
  136. s.Lock()
  137. defer s.Unlock()
  138. for i, p := range guild.Presences {
  139. if p.User.ID == presence.User.ID {
  140. //guild.Presences[i] = presence
  141. //Update status
  142. guild.Presences[i].Game = presence.Game
  143. guild.Presences[i].Roles = presence.Roles
  144. if presence.Status != "" {
  145. guild.Presences[i].Status = presence.Status
  146. }
  147. if presence.Nick != "" {
  148. guild.Presences[i].Nick = presence.Nick
  149. }
  150. //Update the optionally sent user information
  151. //ID Is a mandatory field so you should not need to check if it is empty
  152. guild.Presences[i].User.ID = presence.User.ID
  153. if presence.User.Avatar != "" {
  154. guild.Presences[i].User.Avatar = presence.User.Avatar
  155. }
  156. if presence.User.Discriminator != "" {
  157. guild.Presences[i].User.Discriminator = presence.User.Discriminator
  158. }
  159. if presence.User.Email != "" {
  160. guild.Presences[i].User.Email = presence.User.Email
  161. }
  162. if presence.User.Token != "" {
  163. guild.Presences[i].User.Token = presence.User.Token
  164. }
  165. if presence.User.Username != "" {
  166. guild.Presences[i].User.Username = presence.User.Username
  167. }
  168. return nil
  169. }
  170. }
  171. guild.Presences = append(guild.Presences, presence)
  172. return nil
  173. }
  174. // PresenceRemove removes a presence from the current world state.
  175. func (s *State) PresenceRemove(guildID string, presence *Presence) error {
  176. if s == nil {
  177. return ErrNilState
  178. }
  179. guild, err := s.Guild(guildID)
  180. if err != nil {
  181. return err
  182. }
  183. s.Lock()
  184. defer s.Unlock()
  185. for i, p := range guild.Presences {
  186. if p.User.ID == presence.User.ID {
  187. guild.Presences = append(guild.Presences[:i], guild.Presences[i+1:]...)
  188. return nil
  189. }
  190. }
  191. return errors.New("presence not found")
  192. }
  193. // Presence gets a presence by ID from a guild.
  194. func (s *State) Presence(guildID, userID string) (*Presence, error) {
  195. if s == nil {
  196. return nil, ErrNilState
  197. }
  198. guild, err := s.Guild(guildID)
  199. if err != nil {
  200. return nil, err
  201. }
  202. for _, p := range guild.Presences {
  203. if p.User.ID == userID {
  204. return p, nil
  205. }
  206. }
  207. return nil, errors.New("presence not found")
  208. }
  209. // TODO: Consider moving Guild state update methods onto *Guild.
  210. // MemberAdd adds a member to the current world state, or
  211. // updates it if it already exists.
  212. func (s *State) MemberAdd(member *Member) error {
  213. if s == nil {
  214. return ErrNilState
  215. }
  216. guild, err := s.Guild(member.GuildID)
  217. if err != nil {
  218. return err
  219. }
  220. s.Lock()
  221. defer s.Unlock()
  222. for i, m := range guild.Members {
  223. if m.User.ID == member.User.ID {
  224. guild.Members[i] = member
  225. return nil
  226. }
  227. }
  228. guild.Members = append(guild.Members, member)
  229. return nil
  230. }
  231. // MemberRemove removes a member from current world state.
  232. func (s *State) MemberRemove(member *Member) error {
  233. if s == nil {
  234. return ErrNilState
  235. }
  236. guild, err := s.Guild(member.GuildID)
  237. if err != nil {
  238. return err
  239. }
  240. s.Lock()
  241. defer s.Unlock()
  242. for i, m := range guild.Members {
  243. if m.User.ID == member.User.ID {
  244. guild.Members = append(guild.Members[:i], guild.Members[i+1:]...)
  245. return nil
  246. }
  247. }
  248. return errors.New("member not found")
  249. }
  250. // Member gets a member by ID from a guild.
  251. func (s *State) Member(guildID, userID string) (*Member, error) {
  252. if s == nil {
  253. return nil, ErrNilState
  254. }
  255. guild, err := s.Guild(guildID)
  256. if err != nil {
  257. return nil, err
  258. }
  259. s.RLock()
  260. defer s.RUnlock()
  261. for _, m := range guild.Members {
  262. if m.User.ID == userID {
  263. return m, nil
  264. }
  265. }
  266. return nil, errors.New("member not found")
  267. }
  268. // RoleAdd adds a role to the current world state, or
  269. // updates it if it already exists.
  270. func (s *State) RoleAdd(guildID string, role *Role) error {
  271. if s == nil {
  272. return ErrNilState
  273. }
  274. guild, err := s.Guild(guildID)
  275. if err != nil {
  276. return err
  277. }
  278. s.Lock()
  279. defer s.Unlock()
  280. for i, r := range guild.Roles {
  281. if r.ID == role.ID {
  282. guild.Roles[i] = role
  283. return nil
  284. }
  285. }
  286. guild.Roles = append(guild.Roles, role)
  287. return nil
  288. }
  289. // RoleRemove removes a role from current world state by ID.
  290. func (s *State) RoleRemove(guildID, roleID string) error {
  291. if s == nil {
  292. return ErrNilState
  293. }
  294. guild, err := s.Guild(guildID)
  295. if err != nil {
  296. return err
  297. }
  298. s.Lock()
  299. defer s.Unlock()
  300. for i, r := range guild.Roles {
  301. if r.ID == roleID {
  302. guild.Roles = append(guild.Roles[:i], guild.Roles[i+1:]...)
  303. return nil
  304. }
  305. }
  306. return errors.New("role not found")
  307. }
  308. // Role gets a role by ID from a guild.
  309. func (s *State) Role(guildID, roleID string) (*Role, error) {
  310. if s == nil {
  311. return nil, ErrNilState
  312. }
  313. guild, err := s.Guild(guildID)
  314. if err != nil {
  315. return nil, err
  316. }
  317. s.RLock()
  318. defer s.RUnlock()
  319. for _, r := range guild.Roles {
  320. if r.ID == roleID {
  321. return r, nil
  322. }
  323. }
  324. return nil, errors.New("role not found")
  325. }
  326. // ChannelAdd adds a channel to the current world state, or
  327. // updates it if it already exists.
  328. // Channels may exist either as PrivateChannels or inside
  329. // a guild.
  330. func (s *State) ChannelAdd(channel *Channel) error {
  331. if s == nil {
  332. return ErrNilState
  333. }
  334. s.Lock()
  335. defer s.Unlock()
  336. // If the channel exists, replace it
  337. if c, ok := s.channelMap[channel.ID]; ok {
  338. if channel.Messages == nil {
  339. channel.Messages = c.Messages
  340. }
  341. if channel.PermissionOverwrites == nil {
  342. channel.PermissionOverwrites = c.PermissionOverwrites
  343. }
  344. *c = *channel
  345. return nil
  346. }
  347. if channel.IsPrivate {
  348. s.PrivateChannels = append(s.PrivateChannels, channel)
  349. } else {
  350. guild, ok := s.guildMap[channel.GuildID]
  351. if !ok {
  352. return errors.New("guild for channel not found")
  353. }
  354. guild.Channels = append(guild.Channels, channel)
  355. }
  356. s.channelMap[channel.ID] = channel
  357. return nil
  358. }
  359. // ChannelRemove removes a channel from current world state.
  360. func (s *State) ChannelRemove(channel *Channel) error {
  361. if s == nil {
  362. return ErrNilState
  363. }
  364. _, err := s.Channel(channel.ID)
  365. if err != nil {
  366. return err
  367. }
  368. if channel.IsPrivate {
  369. s.Lock()
  370. defer s.Unlock()
  371. for i, c := range s.PrivateChannels {
  372. if c.ID == channel.ID {
  373. s.PrivateChannels = append(s.PrivateChannels[:i], s.PrivateChannels[i+1:]...)
  374. break
  375. }
  376. }
  377. } else {
  378. guild, err := s.Guild(channel.GuildID)
  379. if err != nil {
  380. return err
  381. }
  382. s.Lock()
  383. defer s.Unlock()
  384. for i, c := range guild.Channels {
  385. if c.ID == channel.ID {
  386. guild.Channels = append(guild.Channels[:i], guild.Channels[i+1:]...)
  387. break
  388. }
  389. }
  390. }
  391. delete(s.channelMap, channel.ID)
  392. return nil
  393. }
  394. // GuildChannel gets a channel by ID from a guild.
  395. // This method is Deprecated, use Channel(channelID)
  396. func (s *State) GuildChannel(guildID, channelID string) (*Channel, error) {
  397. return s.Channel(channelID)
  398. }
  399. // PrivateChannel gets a private channel by ID.
  400. // This method is Deprecated, use Channel(channelID)
  401. func (s *State) PrivateChannel(channelID string) (*Channel, error) {
  402. return s.Channel(channelID)
  403. }
  404. // Channel gets a channel by ID, it will look in all guilds an private channels.
  405. func (s *State) Channel(channelID string) (*Channel, error) {
  406. if s == nil {
  407. return nil, ErrNilState
  408. }
  409. s.RLock()
  410. defer s.RUnlock()
  411. if c, ok := s.channelMap[channelID]; ok {
  412. return c, nil
  413. }
  414. return nil, errors.New("channel not found")
  415. }
  416. // Emoji returns an emoji for a guild and emoji id.
  417. func (s *State) Emoji(guildID, emojiID string) (*Emoji, error) {
  418. if s == nil {
  419. return nil, ErrNilState
  420. }
  421. guild, err := s.Guild(guildID)
  422. if err != nil {
  423. return nil, err
  424. }
  425. s.RLock()
  426. defer s.RUnlock()
  427. for _, e := range guild.Emojis {
  428. if e.ID == emojiID {
  429. return e, nil
  430. }
  431. }
  432. return nil, errors.New("emoji not found")
  433. }
  434. // EmojiAdd adds an emoji to the current world state.
  435. func (s *State) EmojiAdd(guildID string, emoji *Emoji) error {
  436. if s == nil {
  437. return ErrNilState
  438. }
  439. guild, err := s.Guild(guildID)
  440. if err != nil {
  441. return err
  442. }
  443. s.Lock()
  444. defer s.Unlock()
  445. for i, e := range guild.Emojis {
  446. if e.ID == emoji.ID {
  447. guild.Emojis[i] = emoji
  448. return nil
  449. }
  450. }
  451. guild.Emojis = append(guild.Emojis, emoji)
  452. return nil
  453. }
  454. // EmojisAdd adds multiple emojis to the world state.
  455. func (s *State) EmojisAdd(guildID string, emojis []*Emoji) error {
  456. for _, e := range emojis {
  457. if err := s.EmojiAdd(guildID, e); err != nil {
  458. return err
  459. }
  460. }
  461. return nil
  462. }
  463. // MessageAdd adds a message to the current world state, or updates it if it exists.
  464. // If the channel cannot be found, the message is discarded.
  465. // Messages are kept in state up to s.MaxMessageCount
  466. func (s *State) MessageAdd(message *Message) error {
  467. if s == nil {
  468. return ErrNilState
  469. }
  470. c, err := s.Channel(message.ChannelID)
  471. if err != nil {
  472. return err
  473. }
  474. s.Lock()
  475. defer s.Unlock()
  476. // If the message exists, merge in the new message contents.
  477. for _, m := range c.Messages {
  478. if m.ID == message.ID {
  479. if message.Content != "" {
  480. m.Content = message.Content
  481. }
  482. if message.EditedTimestamp != "" {
  483. m.EditedTimestamp = message.EditedTimestamp
  484. }
  485. if message.Mentions != nil {
  486. m.Mentions = message.Mentions
  487. }
  488. if message.Embeds != nil {
  489. m.Embeds = message.Embeds
  490. }
  491. if message.Attachments != nil {
  492. m.Attachments = message.Attachments
  493. }
  494. if message.Timestamp != "" {
  495. m.Timestamp = message.Timestamp
  496. }
  497. if message.Author != nil {
  498. m.Author = message.Author
  499. }
  500. return nil
  501. }
  502. }
  503. c.Messages = append(c.Messages, message)
  504. if len(c.Messages) > s.MaxMessageCount {
  505. c.Messages = c.Messages[len(c.Messages)-s.MaxMessageCount:]
  506. }
  507. return nil
  508. }
  509. // MessageRemove removes a message from the world state.
  510. func (s *State) MessageRemove(message *Message) error {
  511. if s == nil {
  512. return ErrNilState
  513. }
  514. return s.messageRemoveByID(message.ChannelID, message.ID)
  515. }
  516. // messageRemoveByID removes a message by channelID and messageID from the world state.
  517. func (s *State) messageRemoveByID(channelID, messageID string) error {
  518. c, err := s.Channel(channelID)
  519. if err != nil {
  520. return err
  521. }
  522. s.Lock()
  523. defer s.Unlock()
  524. for i, m := range c.Messages {
  525. if m.ID == messageID {
  526. c.Messages = append(c.Messages[:i], c.Messages[i+1:]...)
  527. return nil
  528. }
  529. }
  530. return errors.New("message not found")
  531. }
  532. func (s *State) voiceStateUpdate(update *VoiceStateUpdate) error {
  533. guild, err := s.Guild(update.GuildID)
  534. if err != nil {
  535. return err
  536. }
  537. s.Lock()
  538. defer s.Unlock()
  539. // Handle Leaving Channel
  540. if update.ChannelID == "" {
  541. for i, state := range guild.VoiceStates {
  542. if state.UserID == update.UserID {
  543. guild.VoiceStates = append(guild.VoiceStates[:i], guild.VoiceStates[i+1:]...)
  544. return nil
  545. }
  546. }
  547. } else {
  548. for i, state := range guild.VoiceStates {
  549. if state.UserID == update.UserID {
  550. guild.VoiceStates[i] = update.VoiceState
  551. return nil
  552. }
  553. }
  554. guild.VoiceStates = append(guild.VoiceStates, update.VoiceState)
  555. }
  556. return nil
  557. }
  558. // Message gets a message by channel and message ID.
  559. func (s *State) Message(channelID, messageID string) (*Message, error) {
  560. if s == nil {
  561. return nil, ErrNilState
  562. }
  563. c, err := s.Channel(channelID)
  564. if err != nil {
  565. return nil, err
  566. }
  567. s.RLock()
  568. defer s.RUnlock()
  569. for _, m := range c.Messages {
  570. if m.ID == messageID {
  571. return m, nil
  572. }
  573. }
  574. return nil, errors.New("message not found")
  575. }
  576. // OnReady takes a Ready event and updates all internal state.
  577. func (s *State) onReady(se *Session, r *Ready) (err error) {
  578. if s == nil {
  579. return ErrNilState
  580. }
  581. s.Lock()
  582. defer s.Unlock()
  583. // We must track at least the current user for Voice, even
  584. // if state is disabled, store the bare essentials.
  585. if !se.StateEnabled {
  586. ready := Ready{
  587. Version: r.Version,
  588. SessionID: r.SessionID,
  589. User: r.User,
  590. }
  591. s.Ready = ready
  592. return nil
  593. }
  594. s.Ready = *r
  595. for _, g := range s.Guilds {
  596. s.guildMap[g.ID] = g
  597. for _, c := range g.Channels {
  598. s.channelMap[c.ID] = c
  599. }
  600. }
  601. for _, c := range s.PrivateChannels {
  602. s.channelMap[c.ID] = c
  603. }
  604. return nil
  605. }
  606. // onInterface handles all events related to states.
  607. func (s *State) onInterface(se *Session, i interface{}) (err error) {
  608. if s == nil {
  609. return ErrNilState
  610. }
  611. r, ok := i.(*Ready)
  612. if ok {
  613. return s.onReady(se, r)
  614. }
  615. if !se.StateEnabled {
  616. return nil
  617. }
  618. switch t := i.(type) {
  619. case *GuildCreate:
  620. err = s.GuildAdd(t.Guild)
  621. case *GuildUpdate:
  622. err = s.GuildAdd(t.Guild)
  623. case *GuildDelete:
  624. err = s.GuildRemove(t.Guild)
  625. case *GuildMemberAdd:
  626. if s.TrackMembers {
  627. err = s.MemberAdd(t.Member)
  628. }
  629. case *GuildMemberUpdate:
  630. if s.TrackMembers {
  631. err = s.MemberAdd(t.Member)
  632. }
  633. case *GuildMemberRemove:
  634. if s.TrackMembers {
  635. err = s.MemberRemove(t.Member)
  636. }
  637. case *GuildRoleCreate:
  638. if s.TrackRoles {
  639. err = s.RoleAdd(t.GuildID, t.Role)
  640. }
  641. case *GuildRoleUpdate:
  642. if s.TrackRoles {
  643. err = s.RoleAdd(t.GuildID, t.Role)
  644. }
  645. case *GuildRoleDelete:
  646. if s.TrackRoles {
  647. err = s.RoleRemove(t.GuildID, t.RoleID)
  648. }
  649. case *GuildEmojisUpdate:
  650. if s.TrackEmojis {
  651. err = s.EmojisAdd(t.GuildID, t.Emojis)
  652. }
  653. case *ChannelCreate:
  654. if s.TrackChannels {
  655. err = s.ChannelAdd(t.Channel)
  656. }
  657. case *ChannelUpdate:
  658. if s.TrackChannels {
  659. err = s.ChannelAdd(t.Channel)
  660. }
  661. case *ChannelDelete:
  662. if s.TrackChannels {
  663. err = s.ChannelRemove(t.Channel)
  664. }
  665. case *MessageCreate:
  666. if s.MaxMessageCount != 0 {
  667. err = s.MessageAdd(t.Message)
  668. }
  669. case *MessageUpdate:
  670. if s.MaxMessageCount != 0 {
  671. err = s.MessageAdd(t.Message)
  672. }
  673. case *MessageDelete:
  674. if s.MaxMessageCount != 0 {
  675. err = s.MessageRemove(t.Message)
  676. }
  677. case *MessageDeleteBulk:
  678. if s.MaxMessageCount != 0 {
  679. for _, mID := range t.Messages {
  680. s.messageRemoveByID(t.ChannelID, mID)
  681. }
  682. }
  683. case *VoiceStateUpdate:
  684. if s.TrackVoice {
  685. err = s.voiceStateUpdate(t)
  686. }
  687. case *PresenceUpdate:
  688. if s.TrackPresences {
  689. s.PresenceAdd(t.GuildID, &t.Presence)
  690. }
  691. if s.TrackMembers {
  692. if t.Status == StatusOffline {
  693. return
  694. }
  695. var m *Member
  696. m, err = s.Member(t.GuildID, t.User.ID)
  697. if err != nil {
  698. // Member not found; this is a user coming online
  699. m = &Member{
  700. GuildID: t.GuildID,
  701. Nick: t.Nick,
  702. User: t.User,
  703. Roles: t.Roles,
  704. }
  705. } else {
  706. if t.Nick != "" {
  707. m.Nick = t.Nick
  708. }
  709. if t.User.Username != "" {
  710. m.User.Username = t.User.Username
  711. }
  712. // PresenceUpdates always contain a list of roles, so there's no need to check for an empty list here
  713. m.Roles = t.Roles
  714. }
  715. err = s.MemberAdd(m)
  716. }
  717. }
  718. return
  719. }
  720. // UserChannelPermissions returns the permission of a user in a channel.
  721. // userID : The ID of the user to calculate permissions for.
  722. // channelID : The ID of the channel to calculate permission for.
  723. func (s *State) UserChannelPermissions(userID, channelID string) (apermissions int, err error) {
  724. if s == nil {
  725. return 0, ErrNilState
  726. }
  727. channel, err := s.Channel(channelID)
  728. if err != nil {
  729. return
  730. }
  731. guild, err := s.Guild(channel.GuildID)
  732. if err != nil {
  733. return
  734. }
  735. if userID == guild.OwnerID {
  736. apermissions = PermissionAll
  737. return
  738. }
  739. member, err := s.Member(guild.ID, userID)
  740. if err != nil {
  741. return
  742. }
  743. return memberPermissions(guild, channel, member), nil
  744. }
  745. // UserColor returns the color of a user in a channel.
  746. // While colors are defined at a Guild level, determining for a channel is more useful in message handlers.
  747. // 0 is returned in cases of error, which is the color of @everyone.
  748. // userID : The ID of the user to calculate the color for.
  749. // channelID : The ID of the channel to calculate the color for.
  750. func (s *State) UserColor(userID, channelID string) int {
  751. if s == nil {
  752. return 0
  753. }
  754. channel, err := s.Channel(channelID)
  755. if err != nil {
  756. return 0
  757. }
  758. guild, err := s.Guild(channel.GuildID)
  759. if err != nil {
  760. return 0
  761. }
  762. member, err := s.Member(guild.ID, userID)
  763. if err != nil {
  764. return 0
  765. }
  766. roles := Roles(guild.Roles)
  767. sort.Sort(roles)
  768. for _, role := range roles {
  769. for _, roleID := range member.Roles {
  770. if role.ID == roleID {
  771. if role.Color != 0 {
  772. return role.Color
  773. }
  774. }
  775. }
  776. }
  777. return 0
  778. }