/
ready.go
104 lines (91 loc) · 3.2 KB
/
ready.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package listeners
import (
"time"
"github.com/bwmarrin/discordgo"
"github.com/sarulabs/di/v2"
"github.com/zekrotja/dgrs"
"github.com/zekrotja/rogu"
"github.com/zekrotja/rogu/log"
"github.com/zekroTJA/shinpuru/internal/services/database"
"github.com/zekroTJA/shinpuru/internal/services/guildlog"
"github.com/zekroTJA/shinpuru/internal/services/scheduler"
"github.com/zekroTJA/shinpuru/internal/services/timeprovider"
"github.com/zekroTJA/shinpuru/internal/util"
"github.com/zekroTJA/shinpuru/internal/util/presence"
"github.com/zekroTJA/shinpuru/internal/util/static"
"github.com/zekroTJA/shinpuru/internal/util/vote"
)
type ListenerReady struct {
db database.Database
gl guildlog.Logger
sched scheduler.Provider
st *dgrs.State
tp timeprovider.Provider
log rogu.Logger
}
func NewListenerReady(container di.Container) *ListenerReady {
return &ListenerReady{
db: container.Get(static.DiDatabase).(database.Database),
gl: container.Get(static.DiGuildLog).(guildlog.Logger).Section("ready"),
sched: container.Get(static.DiScheduler).(scheduler.Provider),
st: container.Get(static.DiState).(*dgrs.State),
tp: container.Get(static.DiTimeProvider).(timeprovider.Provider),
log: log.Tagged("Ready"),
}
}
func (l *ListenerReady) Handler(s *discordgo.Session, e *discordgo.Ready) {
l.log.Info().Fields(
"username", e.User.String(),
"id", e.User.ID,
"nGuilds", len(e.Guilds),
).Msg("Discord Connection ready")
l.log.Info().Msgf("Invite link: %s", util.GetInviteLink(e.User.ID))
s.UpdateGameStatus(0, static.StdMotd)
l.sched.Start()
rawPresence, err := l.db.GetSetting(static.SettingPresence)
if err == nil {
pre, err := presence.Unmarshal(rawPresence)
if err == nil {
s.UpdateStatusComplex(pre.ToUpdateStatusData())
}
}
votes, err := l.db.GetVotes()
if err != nil {
l.log.Error().Err(err).Msg("Failed getting votes from DB")
} else {
vote.VotesRunning = votes
_, err = l.sched.Schedule("*/10 * * * * *", func() {
now := l.tp.Now()
for _, v := range vote.VotesRunning {
if (v.Expires != time.Time{}) && v.Expires.Before(now) {
v.Close(s, vote.VoteStateExpired)
if err = l.db.DeleteVote(v.ID); err != nil {
log.Error().Tag("LCT").Err(err).Fields("gid", v.GuildID, "vid", v.ID).Msg("Failed updating vote")
l.gl.Errorf(v.GuildID, "Failed updating vote (%s): %s", v.ID, err.Error())
}
}
}
})
if err != nil {
log.Error().Tag("LCT").Err(err).Msg("Failed scheduling votes job")
}
}
time.Sleep(1 * time.Second)
l.log.Info().Field("n", len(e.Guilds)).Msg("Start caching members of guilds ...")
for _, g := range e.Guilds {
gs, _ := l.st.Guild(g.ID)
if gs != nil && gs.MemberCount > 0 {
membs, _ := l.st.Members(g.ID)
if len(membs) >= gs.MemberCount {
l.log.Debug().Field("gid", g.ID).Msg("Skip fetching members because state is hydrated")
continue
}
}
if _, err := l.st.Members(g.ID, true); err != nil {
l.log.Error().Err(err).Field("gid", g.ID).Msg("Failed fetchting members")
} else {
l.log.Debug().Field("gid", g.ID).Msg("Fetched members")
}
}
l.log.Info().Msg("Caching members finished")
}