package state import ( "sort" "sync" "github.com/diamondburned/arikawa/discord" ) // TODO: make an ExpiryStore type DefaultStore struct { *DefaultStoreOptions self discord.User // includes normal and private privates map[discord.Snowflake]*discord.Channel // channelID:channel guilds map[discord.Snowflake]*discord.Guild // guildID:guild channels map[discord.Snowflake][]discord.Channel // guildID:channels members map[discord.Snowflake][]discord.Member // guildID:members presences map[discord.Snowflake][]discord.Presence // guildID:presences messages map[discord.Snowflake][]discord.Message // channelID:messages mut sync.Mutex } type DefaultStoreOptions struct { MaxMessages uint // default 50 } var _ Store = (*DefaultStore)(nil) func NewDefaultStore(opts *DefaultStoreOptions) *DefaultStore { if opts == nil { opts = &DefaultStoreOptions{ MaxMessages: 50, } } ds := &DefaultStore{ DefaultStoreOptions: opts, } ds.Reset() return ds } func (s *DefaultStore) Reset() error { s.mut.Lock() defer s.mut.Unlock() s.self = discord.User{} s.privates = map[discord.Snowflake]*discord.Channel{} s.guilds = map[discord.Snowflake]*discord.Guild{} s.channels = map[discord.Snowflake][]discord.Channel{} s.members = map[discord.Snowflake][]discord.Member{} s.presences = map[discord.Snowflake][]discord.Presence{} s.messages = map[discord.Snowflake][]discord.Message{} return nil } //// func (s *DefaultStore) Me() (*discord.User, error) { s.mut.Lock() defer s.mut.Unlock() if !s.self.ID.Valid() { return nil, ErrStoreNotFound } return &s.self, nil } func (s *DefaultStore) MyselfSet(me *discord.User) error { s.mut.Lock() s.self = *me s.mut.Unlock() return nil } //// func (s *DefaultStore) Channel(id discord.Snowflake) (*discord.Channel, error) { s.mut.Lock() defer s.mut.Unlock() for _, chs := range s.channels { for _, ch := range chs { if ch.ID == id { return &ch, nil } } } if ch, ok := s.privates[id]; ok { return ch, nil } return nil, ErrStoreNotFound } func (s *DefaultStore) Channels(guildID discord.Snowflake) ([]discord.Channel, error) { s.mut.Lock() defer s.mut.Unlock() chs, ok := s.channels[guildID] if !ok { return nil, ErrStoreNotFound } return append([]discord.Channel{}, chs...), nil } func (s *DefaultStore) PrivateChannels() ([]discord.Channel, error) { s.mut.Lock() var chs = make([]discord.Channel, 0, len(s.privates)) for _, ch := range s.privates { chs = append(chs, *ch) } s.mut.Unlock() sort.Slice(chs, func(i, j int) bool { // Latest first return chs[i].LastMessageID > chs[j].LastMessageID }) return chs, nil } func (s *DefaultStore) ChannelSet(channel *discord.Channel) error { s.mut.Lock() defer s.mut.Unlock() switch channel.Type { case discord.DirectMessage, discord.GroupDM: s.privates[channel.ID] = channel default: chs := s.channels[channel.GuildID] for i, ch := range chs { if ch.ID == channel.ID { // Also from discordgo. if channel.Permissions == nil { channel.Permissions = ch.Permissions } // Found, just edit chs[i] = *channel return nil } } chs = append(chs, *channel) s.channels[channel.GuildID] = chs } return nil } func (s *DefaultStore) ChannelRemove(channel *discord.Channel) error { s.mut.Lock() defer s.mut.Unlock() chs, ok := s.channels[channel.GuildID] if !ok { return ErrStoreNotFound } for i, ch := range chs { if ch.ID == channel.ID { chs = append(chs[:i], chs[i+1:]...) s.channels[channel.GuildID] = chs return nil } } return ErrStoreNotFound } //// func (s *DefaultStore) Emoji(guildID, emojiID discord.Snowflake) (*discord.Emoji, error) { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return nil, ErrStoreNotFound } for _, emoji := range gd.Emojis { if emoji.ID == emojiID { return &emoji, nil } } return nil, ErrStoreNotFound } func (s *DefaultStore) Emojis(guildID discord.Snowflake) ([]discord.Emoji, error) { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return nil, ErrStoreNotFound } return append([]discord.Emoji{}, gd.Emojis...), nil } func (s *DefaultStore) EmojiSet(guildID discord.Snowflake, emojis []discord.Emoji) error { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return ErrStoreNotFound } filtered := emojis[:0] Main: for _, enew := range emojis { // Try and see if this emoji is already in the slice for i, emoji := range gd.Emojis { if emoji.ID == enew.ID { // If it is, we simply replace it gd.Emojis[i] = enew continue Main } } // If not, we add it to the slice that's to be appended. filtered = append(filtered, enew) } // Append the new emojis gd.Emojis = append(gd.Emojis, filtered...) return nil } //// func (s *DefaultStore) Guild(id discord.Snowflake) (*discord.Guild, error) { s.mut.Lock() defer s.mut.Unlock() ch, ok := s.guilds[id] if !ok { return nil, ErrStoreNotFound } return ch, nil } func (s *DefaultStore) Guilds() ([]discord.Guild, error) { s.mut.Lock() if len(s.guilds) == 0 { s.mut.Unlock() return nil, ErrStoreNotFound } var gs = make([]discord.Guild, 0, len(s.guilds)) for _, g := range s.guilds { gs = append(gs, *g) } s.mut.Unlock() sort.Slice(gs, func(i, j int) bool { return gs[i].ID > gs[j].ID }) return gs, nil } func (s *DefaultStore) GuildSet(guild *discord.Guild) error { s.mut.Lock() defer s.mut.Unlock() if g, ok := s.guilds[guild.ID]; ok { // preserve state stuff if guild.Roles == nil { guild.Roles = g.Roles } if guild.Emojis == nil { guild.Emojis = g.Emojis } } s.guilds[guild.ID] = guild return nil } func (s *DefaultStore) GuildRemove(id discord.Snowflake) error { s.mut.Lock() delete(s.guilds, id) s.mut.Unlock() return nil } //// func (s *DefaultStore) Member(guildID, userID discord.Snowflake) (*discord.Member, error) { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.members[guildID] if !ok { return nil, ErrStoreNotFound } for _, m := range ms { if m.User.ID == userID { return &m, nil } } return nil, ErrStoreNotFound } func (s *DefaultStore) Members(guildID discord.Snowflake) ([]discord.Member, error) { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.members[guildID] if !ok { return nil, ErrStoreNotFound } return append([]discord.Member{}, ms...), nil } func (s *DefaultStore) MemberSet(guildID discord.Snowflake, member *discord.Member) error { s.mut.Lock() defer s.mut.Unlock() ms := s.members[guildID] // Try and see if this member is already in the slice for i, m := range ms { if m.User.ID == member.User.ID { // If it is, we simply replace it ms[i] = *member s.members[guildID] = ms return nil } } // Append the new member ms = append(ms, *member) s.members[guildID] = ms return nil } func (s *DefaultStore) MemberRemove(guildID, userID discord.Snowflake) error { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.members[guildID] if !ok { return ErrStoreNotFound } // Try and see if this member is already in the slice for i, m := range ms { if m.User.ID == userID { ms = append(ms, ms[i+1:]...) s.members[guildID] = ms return nil } } return ErrStoreNotFound } //// func (s *DefaultStore) Message(channelID, messageID discord.Snowflake) (*discord.Message, error) { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.messages[channelID] if !ok { return nil, ErrStoreNotFound } for _, m := range ms { if m.ID == messageID { return &m, nil } } return nil, ErrStoreNotFound } func (s *DefaultStore) Messages(channelID discord.Snowflake) ([]discord.Message, error) { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.messages[channelID] if !ok { return nil, ErrStoreNotFound } return append([]discord.Message{}, ms...), nil } func (s *DefaultStore) MaxMessages() int { return int(s.DefaultStoreOptions.MaxMessages) } func (s *DefaultStore) MessageSet(message *discord.Message) error { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.messages[message.ChannelID] if !ok { ms = make([]discord.Message, 0, s.MaxMessages()+1) } // Check if we already have the message. for i, m := range ms { if m.ID == message.ID { // Thanks, Discord. if message.Content != "" { m.Content = message.Content } if message.EditedTimestamp.Valid() { m.EditedTimestamp = message.EditedTimestamp } if message.Mentions != nil { m.Mentions = message.Mentions } if message.Embeds != nil { m.Embeds = message.Embeds } if message.Attachments != nil { m.Attachments = message.Attachments } if message.Timestamp.Valid() { m.Timestamp = message.Timestamp } if message.Author.ID.Valid() { m.Author = message.Author } ms[i] = m return nil } } // Prepend the latest message at the end if end := s.MaxMessages(); len(ms) >= end { // Copy hack to prepend. This copies the 0th-(end-1)th entries to // 1st-endth. copy(ms[1:end], ms[0:end-1]) // Then, set the 0th entry. ms[0] = *message } else { ms = append(ms, *message) } s.messages[message.ChannelID] = ms return nil } func (s *DefaultStore) MessageRemove(channelID, messageID discord.Snowflake) error { s.mut.Lock() defer s.mut.Unlock() ms, ok := s.messages[channelID] if !ok { return ErrStoreNotFound } for i, m := range ms { if m.ID == messageID { ms = append(ms[:i], ms[i+1:]...) s.messages[channelID] = ms return nil } } return ErrStoreNotFound } //// func (s *DefaultStore) Presence(guildID, userID discord.Snowflake) (*discord.Presence, error) { s.mut.Lock() defer s.mut.Unlock() ps, ok := s.presences[guildID] if !ok { return nil, ErrStoreNotFound } for _, p := range ps { if p.User.ID == userID { return &p, nil } } return nil, ErrStoreNotFound } func (s *DefaultStore) Presences(guildID discord.Snowflake) ([]discord.Presence, error) { s.mut.Lock() defer s.mut.Unlock() ps, ok := s.presences[guildID] if !ok { return nil, ErrStoreNotFound } return append([]discord.Presence{}, ps...), nil } func (s *DefaultStore) PresenceSet(guildID discord.Snowflake, presence *discord.Presence) error { s.mut.Lock() defer s.mut.Unlock() ps := s.presences[guildID] for i, p := range ps { if p.User.ID == presence.User.ID { ps[i] = *presence s.presences[guildID] = ps return nil } } ps = append(ps, *presence) s.presences[guildID] = ps return nil } func (s *DefaultStore) PresenceRemove(guildID, userID discord.Snowflake) error { s.mut.Lock() defer s.mut.Unlock() ps, ok := s.presences[guildID] if !ok { return ErrStoreNotFound } for i, p := range ps { if p.User.ID == userID { ps = append(ps[:i], ps[i+1:]...) s.presences[guildID] = ps return nil } } return ErrStoreNotFound } //// func (s *DefaultStore) Role(guildID, roleID discord.Snowflake) (*discord.Role, error) { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return nil, ErrStoreNotFound } for _, r := range gd.Roles { if r.ID == roleID { return &r, nil } } return nil, ErrStoreNotFound } func (s *DefaultStore) Roles(guildID discord.Snowflake) ([]discord.Role, error) { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return nil, ErrStoreNotFound } return append([]discord.Role{}, gd.Roles...), nil } func (s *DefaultStore) RoleSet(guildID discord.Snowflake, role *discord.Role) error { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return ErrStoreNotFound } for i, r := range gd.Roles { if r.ID == role.ID { gd.Roles[i] = *role return nil } } gd.Roles = append(gd.Roles, *role) return nil } func (s *DefaultStore) RoleRemove(guildID, roleID discord.Snowflake) error { s.mut.Lock() defer s.mut.Unlock() gd, ok := s.guilds[guildID] if !ok { return ErrStoreNotFound } for i, r := range gd.Roles { if r.ID == roleID { gd.Roles = append(gd.Roles[:i], gd.Roles[i+1:]...) return nil } } return ErrStoreNotFound }