github.com/meowstercatel/discordgo@v0.0.0-20250615204139-29b43d676735/state.go (about) 1 // Discordgo - Discord bindings for Go 2 // Available at https://github.com/bwmarrin/discordgo 3 4 // Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>. All rights reserved. 5 // Use of this source code is governed by a BSD-style 6 // license that can be found in the LICENSE file. 7 8 // This file contains code related to state tracking. If enabled, state 9 // tracking will capture the initial READY packet and many other websocket 10 // events and maintain an in-memory state of guilds, channels, users, and 11 // so forth. This information can be accessed through the Session.State struct. 12 13 package discordgo 14 15 import ( 16 "errors" 17 "sort" 18 "sync" 19 ) 20 21 // ErrNilState is returned when the state is nil. 22 var ErrNilState = errors.New("state not instantiated, please use discordgo.New() or assign Session.State") 23 24 // ErrStateNotFound is returned when the state cache 25 // requested is not found 26 var ErrStateNotFound = errors.New("state cache not found") 27 28 // ErrMessageIncompletePermissions is returned when the message 29 // requested for permissions does not contain enough data to 30 // generate the permissions. 31 var ErrMessageIncompletePermissions = errors.New("message incomplete, unable to determine permissions") 32 33 // A State contains the current known state. 34 // As discord sends this in a READY blob, it seems reasonable to simply 35 // use that struct as the data store. 36 type State struct { 37 sync.RWMutex 38 Ready 39 40 // MaxMessageCount represents how many messages per channel the state will store. 41 MaxMessageCount int 42 TrackChannels bool 43 TrackThreads bool 44 TrackEmojis bool 45 TrackStickers bool 46 TrackMembers bool 47 TrackThreadMembers bool 48 TrackRoles bool 49 TrackVoice bool 50 TrackPresences bool 51 52 guildMap map[string]*Guild 53 channelMap map[string]*Channel 54 memberMap map[string]map[string]*Member 55 } 56 57 // NewState creates an empty state. 58 func NewState() *State { 59 return &State{ 60 Ready: Ready{ 61 PrivateChannels: []*Channel{}, 62 Guilds: []*Guild{}, 63 }, 64 TrackChannels: true, 65 TrackThreads: true, 66 TrackEmojis: true, 67 TrackStickers: true, 68 TrackMembers: true, 69 TrackThreadMembers: true, 70 TrackRoles: true, 71 TrackVoice: true, 72 TrackPresences: true, 73 guildMap: make(map[string]*Guild), 74 channelMap: make(map[string]*Channel), 75 memberMap: make(map[string]map[string]*Member), 76 } 77 } 78 79 func (s *State) createMemberMap(guild *Guild) { 80 members := make(map[string]*Member) 81 for _, m := range guild.Members { 82 members[m.User.ID] = m 83 } 84 s.memberMap[guild.ID] = members 85 } 86 87 // GuildAdd adds a guild to the current world state, or 88 // updates it if it already exists. 89 func (s *State) GuildAdd(guild *Guild) error { 90 if s == nil { 91 return ErrNilState 92 } 93 94 s.Lock() 95 defer s.Unlock() 96 97 // Update the channels to point to the right guild, adding them to the channelMap as we go 98 for _, c := range guild.Channels { 99 s.channelMap[c.ID] = c 100 } 101 102 // Add all the threads to the state in case of thread sync list. 103 for _, t := range guild.Threads { 104 s.channelMap[t.ID] = t 105 } 106 107 // If this guild contains a new member slice, we must regenerate the member map so the pointers stay valid 108 if guild.Members != nil { 109 s.createMemberMap(guild) 110 } else if _, ok := s.memberMap[guild.ID]; !ok { 111 // Even if we have no new member slice, we still initialize the member map for this guild if it doesn't exist 112 s.memberMap[guild.ID] = make(map[string]*Member) 113 } 114 115 if g, ok := s.guildMap[guild.ID]; ok { 116 // We are about to replace `g` in the state with `guild`, but first we need to 117 // make sure we preserve any fields that the `guild` doesn't contain from `g`. 118 if guild.MemberCount == 0 { 119 guild.MemberCount = g.MemberCount 120 } 121 if guild.Roles == nil { 122 guild.Roles = g.Roles 123 } 124 if guild.Emojis == nil { 125 guild.Emojis = g.Emojis 126 } 127 if guild.Members == nil { 128 guild.Members = g.Members 129 } 130 if guild.Presences == nil { 131 guild.Presences = g.Presences 132 } 133 if guild.Channels == nil { 134 guild.Channels = g.Channels 135 } 136 if guild.Threads == nil { 137 guild.Threads = g.Threads 138 } 139 if guild.VoiceStates == nil { 140 guild.VoiceStates = g.VoiceStates 141 } 142 *g = *guild 143 return nil 144 } 145 146 s.Guilds = append(s.Guilds, guild) 147 s.guildMap[guild.ID] = guild 148 149 return nil 150 } 151 152 // GuildRemove removes a guild from current world state. 153 func (s *State) GuildRemove(guild *Guild) error { 154 if s == nil { 155 return ErrNilState 156 } 157 158 _, err := s.Guild(guild.ID) 159 if err != nil { 160 return err 161 } 162 163 s.Lock() 164 defer s.Unlock() 165 166 delete(s.guildMap, guild.ID) 167 168 for i, g := range s.Guilds { 169 if g.ID == guild.ID { 170 s.Guilds = append(s.Guilds[:i], s.Guilds[i+1:]...) 171 return nil 172 } 173 } 174 175 return nil 176 } 177 178 // Guild gets a guild by ID. 179 // Useful for querying if @me is in a guild: 180 // _, err := discordgo.Session.State.Guild(guildID) 181 // isInGuild := err == nil 182 func (s *State) Guild(guildID string) (*Guild, error) { 183 if s == nil { 184 return nil, ErrNilState 185 } 186 187 s.RLock() 188 defer s.RUnlock() 189 190 if g, ok := s.guildMap[guildID]; ok { 191 return g, nil 192 } 193 194 return nil, ErrStateNotFound 195 } 196 197 func (s *State) presenceAdd(guildID string, presence *Presence) error { 198 guild, ok := s.guildMap[guildID] 199 if !ok { 200 return ErrStateNotFound 201 } 202 203 for i, p := range guild.Presences { 204 if p.User.ID == presence.User.ID { 205 //guild.Presences[i] = presence 206 207 //Update status 208 guild.Presences[i].Activities = presence.Activities 209 if presence.Status != "" { 210 guild.Presences[i].Status = presence.Status 211 } 212 if presence.ClientStatus.Desktop != "" { 213 guild.Presences[i].ClientStatus.Desktop = presence.ClientStatus.Desktop 214 } 215 if presence.ClientStatus.Mobile != "" { 216 guild.Presences[i].ClientStatus.Mobile = presence.ClientStatus.Mobile 217 } 218 if presence.ClientStatus.Web != "" { 219 guild.Presences[i].ClientStatus.Web = presence.ClientStatus.Web 220 } 221 222 //Update the optionally sent user information 223 //ID Is a mandatory field so you should not need to check if it is empty 224 guild.Presences[i].User.ID = presence.User.ID 225 226 if presence.User.Avatar != "" { 227 guild.Presences[i].User.Avatar = presence.User.Avatar 228 } 229 if presence.User.Discriminator != "" { 230 guild.Presences[i].User.Discriminator = presence.User.Discriminator 231 } 232 if presence.User.Email != "" { 233 guild.Presences[i].User.Email = presence.User.Email 234 } 235 if presence.User.Token != "" { 236 guild.Presences[i].User.Token = presence.User.Token 237 } 238 if presence.User.Username != "" { 239 guild.Presences[i].User.Username = presence.User.Username 240 } 241 242 return nil 243 } 244 } 245 246 guild.Presences = append(guild.Presences, presence) 247 return nil 248 } 249 250 // PresenceAdd adds a presence to the current world state, or 251 // updates it if it already exists. 252 func (s *State) PresenceAdd(guildID string, presence *Presence) error { 253 if s == nil { 254 return ErrNilState 255 } 256 257 s.Lock() 258 defer s.Unlock() 259 260 return s.presenceAdd(guildID, presence) 261 } 262 263 // PresenceRemove removes a presence from the current world state. 264 func (s *State) PresenceRemove(guildID string, presence *Presence) error { 265 if s == nil { 266 return ErrNilState 267 } 268 269 guild, err := s.Guild(guildID) 270 if err != nil { 271 return err 272 } 273 274 s.Lock() 275 defer s.Unlock() 276 277 for i, p := range guild.Presences { 278 if p.User.ID == presence.User.ID { 279 guild.Presences = append(guild.Presences[:i], guild.Presences[i+1:]...) 280 return nil 281 } 282 } 283 284 return ErrStateNotFound 285 } 286 287 // Presence gets a presence by ID from a guild. 288 func (s *State) Presence(guildID, userID string) (*Presence, error) { 289 if s == nil { 290 return nil, ErrNilState 291 } 292 293 guild, err := s.Guild(guildID) 294 if err != nil { 295 return nil, err 296 } 297 298 for _, p := range guild.Presences { 299 if p.User.ID == userID { 300 return p, nil 301 } 302 } 303 304 return nil, ErrStateNotFound 305 } 306 307 // TODO: Consider moving Guild state update methods onto *Guild. 308 309 func (s *State) memberAdd(member *Member) error { 310 guild, ok := s.guildMap[member.GuildID] 311 if !ok { 312 return ErrStateNotFound 313 } 314 315 members, ok := s.memberMap[member.GuildID] 316 if !ok { 317 return ErrStateNotFound 318 } 319 320 m, ok := members[member.User.ID] 321 if !ok { 322 members[member.User.ID] = member 323 guild.Members = append(guild.Members, member) 324 } else { 325 // We are about to replace `m` in the state with `member`, but first we need to 326 // make sure we preserve any fields that the `member` doesn't contain from `m`. 327 if member.JoinedAt.IsZero() { 328 member.JoinedAt = m.JoinedAt 329 } 330 *m = *member 331 } 332 return nil 333 } 334 335 // MemberAdd adds a member to the current world state, or 336 // updates it if it already exists. 337 func (s *State) MemberAdd(member *Member) error { 338 if s == nil { 339 return ErrNilState 340 } 341 342 s.Lock() 343 defer s.Unlock() 344 345 return s.memberAdd(member) 346 } 347 348 // MemberRemove removes a member from current world state. 349 func (s *State) MemberRemove(member *Member) error { 350 if s == nil { 351 return ErrNilState 352 } 353 354 guild, err := s.Guild(member.GuildID) 355 if err != nil { 356 return err 357 } 358 359 s.Lock() 360 defer s.Unlock() 361 362 members, ok := s.memberMap[member.GuildID] 363 if !ok { 364 return ErrStateNotFound 365 } 366 367 _, ok = members[member.User.ID] 368 if !ok { 369 return ErrStateNotFound 370 } 371 delete(members, member.User.ID) 372 373 for i, m := range guild.Members { 374 if m.User.ID == member.User.ID { 375 guild.Members = append(guild.Members[:i], guild.Members[i+1:]...) 376 return nil 377 } 378 } 379 380 return ErrStateNotFound 381 } 382 383 // Member gets a member by ID from a guild. 384 func (s *State) Member(guildID, userID string) (*Member, error) { 385 if s == nil { 386 return nil, ErrNilState 387 } 388 389 s.RLock() 390 defer s.RUnlock() 391 392 members, ok := s.memberMap[guildID] 393 if !ok { 394 return nil, ErrStateNotFound 395 } 396 397 m, ok := members[userID] 398 if ok { 399 return m, nil 400 } 401 402 return nil, ErrStateNotFound 403 } 404 405 // RoleAdd adds a role to the current world state, or 406 // updates it if it already exists. 407 func (s *State) RoleAdd(guildID string, role *Role) error { 408 if s == nil { 409 return ErrNilState 410 } 411 412 guild, err := s.Guild(guildID) 413 if err != nil { 414 return err 415 } 416 417 s.Lock() 418 defer s.Unlock() 419 420 for i, r := range guild.Roles { 421 if r.ID == role.ID { 422 guild.Roles[i] = role 423 return nil 424 } 425 } 426 427 guild.Roles = append(guild.Roles, role) 428 return nil 429 } 430 431 // RoleRemove removes a role from current world state by ID. 432 func (s *State) RoleRemove(guildID, roleID string) error { 433 if s == nil { 434 return ErrNilState 435 } 436 437 guild, err := s.Guild(guildID) 438 if err != nil { 439 return err 440 } 441 442 s.Lock() 443 defer s.Unlock() 444 445 for i, r := range guild.Roles { 446 if r.ID == roleID { 447 guild.Roles = append(guild.Roles[:i], guild.Roles[i+1:]...) 448 return nil 449 } 450 } 451 452 return ErrStateNotFound 453 } 454 455 // Role gets a role by ID from a guild. 456 func (s *State) Role(guildID, roleID string) (*Role, error) { 457 if s == nil { 458 return nil, ErrNilState 459 } 460 461 guild, err := s.Guild(guildID) 462 if err != nil { 463 return nil, err 464 } 465 466 s.RLock() 467 defer s.RUnlock() 468 469 for _, r := range guild.Roles { 470 if r.ID == roleID { 471 return r, nil 472 } 473 } 474 475 return nil, ErrStateNotFound 476 } 477 478 // ChannelAdd adds a channel to the current world state, or 479 // updates it if it already exists. 480 // Channels may exist either as PrivateChannels or inside 481 // a guild. 482 func (s *State) ChannelAdd(channel *Channel) error { 483 if s == nil { 484 return ErrNilState 485 } 486 487 s.Lock() 488 defer s.Unlock() 489 490 // If the channel exists, replace it 491 if c, ok := s.channelMap[channel.ID]; ok { 492 if channel.Messages == nil { 493 channel.Messages = c.Messages 494 } 495 if channel.PermissionOverwrites == nil { 496 channel.PermissionOverwrites = c.PermissionOverwrites 497 } 498 if channel.ThreadMetadata == nil { 499 channel.ThreadMetadata = c.ThreadMetadata 500 } 501 502 *c = *channel 503 return nil 504 } 505 506 if channel.Type == ChannelTypeDM || channel.Type == ChannelTypeGroupDM { 507 s.PrivateChannels = append(s.PrivateChannels, channel) 508 s.channelMap[channel.ID] = channel 509 return nil 510 } 511 512 guild, ok := s.guildMap[channel.GuildID] 513 if !ok { 514 return ErrStateNotFound 515 } 516 517 if channel.IsThread() { 518 guild.Threads = append(guild.Threads, channel) 519 } else { 520 guild.Channels = append(guild.Channels, channel) 521 } 522 523 s.channelMap[channel.ID] = channel 524 525 return nil 526 } 527 528 // ChannelRemove removes a channel from current world state. 529 func (s *State) ChannelRemove(channel *Channel) error { 530 if s == nil { 531 return ErrNilState 532 } 533 534 _, err := s.Channel(channel.ID) 535 if err != nil { 536 return err 537 } 538 539 if channel.Type == ChannelTypeDM || channel.Type == ChannelTypeGroupDM { 540 s.Lock() 541 defer s.Unlock() 542 543 for i, c := range s.PrivateChannels { 544 if c.ID == channel.ID { 545 s.PrivateChannels = append(s.PrivateChannels[:i], s.PrivateChannels[i+1:]...) 546 break 547 } 548 } 549 delete(s.channelMap, channel.ID) 550 return nil 551 } 552 553 guild, err := s.Guild(channel.GuildID) 554 if err != nil { 555 return err 556 } 557 558 s.Lock() 559 defer s.Unlock() 560 561 if channel.IsThread() { 562 for i, t := range guild.Threads { 563 if t.ID == channel.ID { 564 guild.Threads = append(guild.Threads[:i], guild.Threads[i+1:]...) 565 break 566 } 567 } 568 } else { 569 for i, c := range guild.Channels { 570 if c.ID == channel.ID { 571 guild.Channels = append(guild.Channels[:i], guild.Channels[i+1:]...) 572 break 573 } 574 } 575 } 576 577 delete(s.channelMap, channel.ID) 578 579 return nil 580 } 581 582 // ThreadListSync syncs guild threads with provided ones. 583 func (s *State) ThreadListSync(tls *ThreadListSync) error { 584 guild, err := s.Guild(tls.GuildID) 585 if err != nil { 586 return err 587 } 588 589 s.Lock() 590 defer s.Unlock() 591 592 // This algorithm filters out archived or 593 // threads which are children of channels in channelIDs 594 // and then it adds all synced threads to guild threads and cache 595 index := 0 596 outer: 597 for _, t := range guild.Threads { 598 if !t.ThreadMetadata.Archived && tls.ChannelIDs != nil { 599 for _, v := range tls.ChannelIDs { 600 if t.ParentID == v { 601 delete(s.channelMap, t.ID) 602 continue outer 603 } 604 } 605 guild.Threads[index] = t 606 index++ 607 } else { 608 delete(s.channelMap, t.ID) 609 } 610 } 611 guild.Threads = guild.Threads[:index] 612 for _, t := range tls.Threads { 613 s.channelMap[t.ID] = t 614 guild.Threads = append(guild.Threads, t) 615 } 616 617 for _, m := range tls.Members { 618 if c, ok := s.channelMap[m.ID]; ok { 619 c.Member = m 620 } 621 } 622 623 return nil 624 } 625 626 // ThreadMembersUpdate updates thread members list 627 func (s *State) ThreadMembersUpdate(tmu *ThreadMembersUpdate) error { 628 thread, err := s.Channel(tmu.ID) 629 if err != nil { 630 return err 631 } 632 s.Lock() 633 defer s.Unlock() 634 635 for idx, member := range thread.Members { 636 for _, removedMember := range tmu.RemovedMembers { 637 if member.ID == removedMember { 638 thread.Members = append(thread.Members[:idx], thread.Members[idx+1:]...) 639 break 640 } 641 } 642 } 643 644 for _, addedMember := range tmu.AddedMembers { 645 thread.Members = append(thread.Members, addedMember.ThreadMember) 646 if addedMember.Member != nil { 647 err = s.memberAdd(addedMember.Member) 648 if err != nil { 649 return err 650 } 651 } 652 if addedMember.Presence != nil { 653 err = s.presenceAdd(tmu.GuildID, addedMember.Presence) 654 if err != nil { 655 return err 656 } 657 } 658 } 659 thread.MemberCount = tmu.MemberCount 660 661 return nil 662 } 663 664 // ThreadMemberUpdate sets or updates member data for the current user. 665 func (s *State) ThreadMemberUpdate(mu *ThreadMemberUpdate) error { 666 thread, err := s.Channel(mu.ID) 667 if err != nil { 668 return err 669 } 670 671 thread.Member = mu.ThreadMember 672 return nil 673 } 674 675 // Channel gets a channel by ID, it will look in all guilds and private channels. 676 func (s *State) Channel(channelID string) (*Channel, error) { 677 if s == nil { 678 return nil, ErrNilState 679 } 680 681 s.RLock() 682 defer s.RUnlock() 683 684 if c, ok := s.channelMap[channelID]; ok { 685 return c, nil 686 } 687 688 return nil, ErrStateNotFound 689 } 690 691 // Emoji returns an emoji for a guild and emoji id. 692 func (s *State) Emoji(guildID, emojiID string) (*Emoji, error) { 693 if s == nil { 694 return nil, ErrNilState 695 } 696 697 guild, err := s.Guild(guildID) 698 if err != nil { 699 return nil, err 700 } 701 702 s.RLock() 703 defer s.RUnlock() 704 705 for _, e := range guild.Emojis { 706 if e.ID == emojiID { 707 return e, nil 708 } 709 } 710 711 return nil, ErrStateNotFound 712 } 713 714 // EmojiAdd adds an emoji to the current world state. 715 func (s *State) EmojiAdd(guildID string, emoji *Emoji) error { 716 if s == nil { 717 return ErrNilState 718 } 719 720 guild, err := s.Guild(guildID) 721 if err != nil { 722 return err 723 } 724 725 s.Lock() 726 defer s.Unlock() 727 728 for i, e := range guild.Emojis { 729 if e.ID == emoji.ID { 730 guild.Emojis[i] = emoji 731 return nil 732 } 733 } 734 735 guild.Emojis = append(guild.Emojis, emoji) 736 return nil 737 } 738 739 // EmojisAdd adds multiple emojis to the world state. 740 func (s *State) EmojisAdd(guildID string, emojis []*Emoji) error { 741 for _, e := range emojis { 742 if err := s.EmojiAdd(guildID, e); err != nil { 743 return err 744 } 745 } 746 return nil 747 } 748 749 // MessageAdd adds a message to the current world state, or updates it if it exists. 750 // If the channel cannot be found, the message is discarded. 751 // Messages are kept in state up to s.MaxMessageCount per channel. 752 func (s *State) MessageAdd(message *Message) error { 753 if s == nil { 754 return ErrNilState 755 } 756 757 c, err := s.Channel(message.ChannelID) 758 if err != nil { 759 return err 760 } 761 762 s.Lock() 763 defer s.Unlock() 764 765 // If the message exists, merge in the new message contents. 766 for _, m := range c.Messages { 767 if m.ID == message.ID { 768 if message.Content != "" { 769 m.Content = message.Content 770 } 771 if message.EditedTimestamp != nil { 772 m.EditedTimestamp = message.EditedTimestamp 773 } 774 if message.Mentions != nil { 775 m.Mentions = message.Mentions 776 } 777 if message.Embeds != nil { 778 m.Embeds = message.Embeds 779 } 780 if message.Attachments != nil { 781 m.Attachments = message.Attachments 782 } 783 if !message.Timestamp.IsZero() { 784 m.Timestamp = message.Timestamp 785 } 786 if message.Author != nil { 787 m.Author = message.Author 788 } 789 if message.Components != nil { 790 m.Components = message.Components 791 } 792 793 return nil 794 } 795 } 796 797 c.Messages = append(c.Messages, message) 798 799 if len(c.Messages) > s.MaxMessageCount { 800 c.Messages = c.Messages[len(c.Messages)-s.MaxMessageCount:] 801 } 802 803 return nil 804 } 805 806 // MessageRemove removes a message from the world state. 807 func (s *State) MessageRemove(message *Message) error { 808 if s == nil { 809 return ErrNilState 810 } 811 812 return s.messageRemoveByID(message.ChannelID, message.ID) 813 } 814 815 // messageRemoveByID removes a message by channelID and messageID from the world state. 816 func (s *State) messageRemoveByID(channelID, messageID string) error { 817 c, err := s.Channel(channelID) 818 if err != nil { 819 return err 820 } 821 822 s.Lock() 823 defer s.Unlock() 824 825 for i, m := range c.Messages { 826 if m.ID == messageID { 827 c.Messages = append(c.Messages[:i], c.Messages[i+1:]...) 828 829 return nil 830 } 831 } 832 833 return ErrStateNotFound 834 } 835 836 func (s *State) voiceStateUpdate(update *VoiceStateUpdate) error { 837 guild, err := s.Guild(update.GuildID) 838 if err != nil { 839 return err 840 } 841 842 s.Lock() 843 defer s.Unlock() 844 845 // Handle Leaving Channel 846 if update.ChannelID == "" { 847 for i, state := range guild.VoiceStates { 848 if state.UserID == update.UserID { 849 guild.VoiceStates = append(guild.VoiceStates[:i], guild.VoiceStates[i+1:]...) 850 return nil 851 } 852 } 853 } else { 854 for i, state := range guild.VoiceStates { 855 if state.UserID == update.UserID { 856 guild.VoiceStates[i] = update.VoiceState 857 return nil 858 } 859 } 860 861 guild.VoiceStates = append(guild.VoiceStates, update.VoiceState) 862 } 863 864 return nil 865 } 866 867 // VoiceState gets a VoiceState by guild and user ID. 868 func (s *State) VoiceState(guildID, userID string) (*VoiceState, error) { 869 if s == nil { 870 return nil, ErrNilState 871 } 872 873 guild, err := s.Guild(guildID) 874 if err != nil { 875 return nil, err 876 } 877 878 for _, state := range guild.VoiceStates { 879 if state.UserID == userID { 880 return state, nil 881 } 882 } 883 884 return nil, ErrStateNotFound 885 } 886 887 // Message gets a message by channel and message ID. 888 func (s *State) Message(channelID, messageID string) (*Message, error) { 889 if s == nil { 890 return nil, ErrNilState 891 } 892 893 c, err := s.Channel(channelID) 894 if err != nil { 895 return nil, err 896 } 897 898 s.RLock() 899 defer s.RUnlock() 900 901 for _, m := range c.Messages { 902 if m.ID == messageID { 903 return m, nil 904 } 905 } 906 907 return nil, ErrStateNotFound 908 } 909 910 // OnReady takes a Ready event and updates all internal state. 911 func (s *State) onReady(se *Session, r *Ready) (err error) { 912 if s == nil { 913 return ErrNilState 914 } 915 916 s.Lock() 917 defer s.Unlock() 918 919 // We must track at least the current user for Voice, even 920 // if state is disabled, store the bare essentials. 921 if !se.StateEnabled { 922 ready := Ready{ 923 Version: r.Version, 924 SessionID: r.SessionID, 925 User: r.User, 926 Shard: r.Shard, 927 Application: r.Application, 928 } 929 930 s.Ready = ready 931 932 return nil 933 } 934 935 s.Ready = *r 936 937 for _, g := range s.Guilds { 938 s.guildMap[g.ID] = g 939 s.createMemberMap(g) 940 941 for _, c := range g.Channels { 942 s.channelMap[c.ID] = c 943 } 944 } 945 946 for _, c := range s.PrivateChannels { 947 s.channelMap[c.ID] = c 948 } 949 950 return nil 951 } 952 953 // OnInterface handles all events related to states. 954 func (s *State) OnInterface(se *Session, i interface{}) (err error) { 955 if s == nil { 956 return ErrNilState 957 } 958 959 r, ok := i.(*Ready) 960 if ok { 961 return s.onReady(se, r) 962 } 963 964 if !se.StateEnabled { 965 return nil 966 } 967 968 switch t := i.(type) { 969 case *GuildCreate: 970 err = s.GuildAdd(t.Guild) 971 case *GuildUpdate: 972 err = s.GuildAdd(t.Guild) 973 case *GuildDelete: 974 var old *Guild 975 old, err = s.Guild(t.ID) 976 if err == nil { 977 oldCopy := *old 978 t.BeforeDelete = &oldCopy 979 } 980 981 err = s.GuildRemove(t.Guild) 982 case *GuildMemberAdd: 983 var guild *Guild 984 // Updates the MemberCount of the guild. 985 guild, err = s.Guild(t.Member.GuildID) 986 if err != nil { 987 return err 988 } 989 guild.MemberCount++ 990 991 // Caches member if tracking is enabled. 992 if s.TrackMembers { 993 err = s.MemberAdd(t.Member) 994 } 995 case *GuildMemberUpdate: 996 if s.TrackMembers { 997 var old *Member 998 old, err = s.Member(t.GuildID, t.User.ID) 999 if err == nil { 1000 oldCopy := *old 1001 t.BeforeUpdate = &oldCopy 1002 } 1003 1004 err = s.MemberAdd(t.Member) 1005 } 1006 case *GuildMemberRemove: 1007 var guild *Guild 1008 // Updates the MemberCount of the guild. 1009 guild, err = s.Guild(t.Member.GuildID) 1010 if err != nil { 1011 return err 1012 } 1013 guild.MemberCount-- 1014 1015 // Removes member from the cache if tracking is enabled. 1016 if s.TrackMembers { 1017 err = s.MemberRemove(t.Member) 1018 } 1019 case *GuildMembersChunk: 1020 if s.TrackMembers { 1021 for i := range t.Members { 1022 t.Members[i].GuildID = t.GuildID 1023 err = s.MemberAdd(t.Members[i]) 1024 } 1025 } 1026 1027 if s.TrackPresences { 1028 for _, p := range t.Presences { 1029 err = s.PresenceAdd(t.GuildID, p) 1030 } 1031 } 1032 case *GuildRoleCreate: 1033 if s.TrackRoles { 1034 err = s.RoleAdd(t.GuildID, t.Role) 1035 } 1036 case *GuildRoleUpdate: 1037 if s.TrackRoles { 1038 err = s.RoleAdd(t.GuildID, t.Role) 1039 } 1040 case *GuildRoleDelete: 1041 if s.TrackRoles { 1042 err = s.RoleRemove(t.GuildID, t.RoleID) 1043 } 1044 case *GuildEmojisUpdate: 1045 if s.TrackEmojis { 1046 var guild *Guild 1047 guild, err = s.Guild(t.GuildID) 1048 if err != nil { 1049 return err 1050 } 1051 s.Lock() 1052 defer s.Unlock() 1053 guild.Emojis = t.Emojis 1054 } 1055 case *GuildStickersUpdate: 1056 if s.TrackStickers { 1057 var guild *Guild 1058 guild, err = s.Guild(t.GuildID) 1059 if err != nil { 1060 return err 1061 } 1062 s.Lock() 1063 defer s.Unlock() 1064 guild.Stickers = t.Stickers 1065 } 1066 case *ChannelCreate: 1067 if s.TrackChannels { 1068 err = s.ChannelAdd(t.Channel) 1069 } 1070 case *ChannelUpdate: 1071 if s.TrackChannels { 1072 old, err := s.Channel(t.ID) 1073 if err == nil { 1074 oldCopy := *old 1075 t.BeforeUpdate = &oldCopy 1076 } 1077 err = s.ChannelAdd(t.Channel) 1078 } 1079 case *ChannelDelete: 1080 if s.TrackChannels { 1081 err = s.ChannelRemove(t.Channel) 1082 } 1083 case *ThreadCreate: 1084 if s.TrackThreads { 1085 err = s.ChannelAdd(t.Channel) 1086 } 1087 case *ThreadUpdate: 1088 if s.TrackThreads { 1089 old, err := s.Channel(t.ID) 1090 if err == nil { 1091 oldCopy := *old 1092 t.BeforeUpdate = &oldCopy 1093 } 1094 err = s.ChannelAdd(t.Channel) 1095 } 1096 case *ThreadDelete: 1097 if s.TrackThreads { 1098 err = s.ChannelRemove(t.Channel) 1099 } 1100 case *ThreadMemberUpdate: 1101 if s.TrackThreads { 1102 err = s.ThreadMemberUpdate(t) 1103 } 1104 case *ThreadMembersUpdate: 1105 if s.TrackThreadMembers { 1106 err = s.ThreadMembersUpdate(t) 1107 } 1108 case *ThreadListSync: 1109 if s.TrackThreads { 1110 err = s.ThreadListSync(t) 1111 } 1112 case *MessageCreate: 1113 if s.MaxMessageCount != 0 { 1114 err = s.MessageAdd(t.Message) 1115 } 1116 case *MessageUpdate: 1117 if s.MaxMessageCount != 0 { 1118 var old *Message 1119 old, err = s.Message(t.ChannelID, t.ID) 1120 if err == nil { 1121 oldCopy := *old 1122 t.BeforeUpdate = &oldCopy 1123 } 1124 1125 err = s.MessageAdd(t.Message) 1126 } 1127 case *MessageDelete: 1128 if s.MaxMessageCount != 0 { 1129 var old *Message 1130 old, err = s.Message(t.ChannelID, t.ID) 1131 if err == nil { 1132 oldCopy := *old 1133 t.BeforeDelete = &oldCopy 1134 } 1135 1136 err = s.MessageRemove(t.Message) 1137 } 1138 case *MessageDeleteBulk: 1139 if s.MaxMessageCount != 0 { 1140 for _, mID := range t.Messages { 1141 s.messageRemoveByID(t.ChannelID, mID) 1142 } 1143 } 1144 case *VoiceStateUpdate: 1145 if s.TrackVoice { 1146 var old *VoiceState 1147 old, err = s.VoiceState(t.GuildID, t.UserID) 1148 if err == nil { 1149 oldCopy := *old 1150 t.BeforeUpdate = &oldCopy 1151 } 1152 1153 err = s.voiceStateUpdate(t) 1154 } 1155 case *PresenceUpdate: 1156 if s.TrackPresences { 1157 s.PresenceAdd(t.GuildID, &t.Presence) 1158 } 1159 if s.TrackMembers { 1160 if t.Status == StatusOffline { 1161 return 1162 } 1163 1164 var m *Member 1165 m, err = s.Member(t.GuildID, t.User.ID) 1166 1167 if err != nil { 1168 // Member not found; this is a user coming online 1169 m = &Member{ 1170 GuildID: t.GuildID, 1171 User: t.User, 1172 } 1173 } else { 1174 if t.User.Username != "" { 1175 m.User.Username = t.User.Username 1176 } 1177 } 1178 1179 err = s.MemberAdd(m) 1180 } 1181 1182 } 1183 1184 return 1185 } 1186 1187 // UserChannelPermissions returns the permission of a user in a channel. 1188 // userID : The ID of the user to calculate permissions for. 1189 // channelID : The ID of the channel to calculate permission for. 1190 func (s *State) UserChannelPermissions(userID, channelID string) (apermissions int64, err error) { 1191 if s == nil { 1192 return 0, ErrNilState 1193 } 1194 1195 channel, err := s.Channel(channelID) 1196 if err != nil { 1197 return 1198 } 1199 1200 guild, err := s.Guild(channel.GuildID) 1201 if err != nil { 1202 return 1203 } 1204 1205 member, err := s.Member(guild.ID, userID) 1206 if err != nil { 1207 return 1208 } 1209 1210 return memberPermissions(guild, channel, userID, member.Roles), nil 1211 } 1212 1213 // MessagePermissions returns the permissions of the author of the message 1214 // in the channel in which it was sent. 1215 func (s *State) MessagePermissions(message *Message) (apermissions int64, err error) { 1216 if s == nil { 1217 return 0, ErrNilState 1218 } 1219 1220 if message.Author == nil || message.Member == nil { 1221 return 0, ErrMessageIncompletePermissions 1222 } 1223 1224 channel, err := s.Channel(message.ChannelID) 1225 if err != nil { 1226 return 1227 } 1228 1229 guild, err := s.Guild(channel.GuildID) 1230 if err != nil { 1231 return 1232 } 1233 1234 return memberPermissions(guild, channel, message.Author.ID, message.Member.Roles), nil 1235 } 1236 1237 // UserColor returns the color of a user in a channel. 1238 // While colors are defined at a Guild level, determining for a channel is more useful in message handlers. 1239 // 0 is returned in cases of error, which is the color of @everyone. 1240 // userID : The ID of the user to calculate the color for. 1241 // channelID : The ID of the channel to calculate the color for. 1242 func (s *State) UserColor(userID, channelID string) int { 1243 if s == nil { 1244 return 0 1245 } 1246 1247 channel, err := s.Channel(channelID) 1248 if err != nil { 1249 return 0 1250 } 1251 1252 guild, err := s.Guild(channel.GuildID) 1253 if err != nil { 1254 return 0 1255 } 1256 1257 member, err := s.Member(guild.ID, userID) 1258 if err != nil { 1259 return 0 1260 } 1261 1262 return firstRoleColorColor(guild, member.Roles) 1263 } 1264 1265 // MessageColor returns the color of the author's name as displayed 1266 // in the client associated with this message. 1267 func (s *State) MessageColor(message *Message) int { 1268 if s == nil { 1269 return 0 1270 } 1271 1272 if message.Member == nil || message.Member.Roles == nil { 1273 return 0 1274 } 1275 1276 channel, err := s.Channel(message.ChannelID) 1277 if err != nil { 1278 return 0 1279 } 1280 1281 guild, err := s.Guild(channel.GuildID) 1282 if err != nil { 1283 return 0 1284 } 1285 1286 return firstRoleColorColor(guild, message.Member.Roles) 1287 } 1288 1289 func firstRoleColorColor(guild *Guild, memberRoles []string) int { 1290 roles := Roles(guild.Roles) 1291 sort.Sort(roles) 1292 1293 for _, role := range roles { 1294 for _, roleID := range memberRoles { 1295 if role.ID == roleID { 1296 if role.Color != 0 { 1297 return role.Color 1298 } 1299 } 1300 } 1301 } 1302 1303 for _, role := range roles { 1304 if role.ID == guild.ID { 1305 return role.Color 1306 } 1307 } 1308 1309 return 0 1310 }