mirror of
https://github.com/Luzifer/discord-community.git
synced 2024-09-19 16:22:59 +00:00
263 lines
7.8 KiB
Go
263 lines
7.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/Luzifer/go_helpers/v2/backoff"
|
|
"github.com/bwmarrin/discordgo"
|
|
"github.com/pkg/errors"
|
|
"github.com/robfig/cron/v3"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
/*
|
|
* @module schedule
|
|
* @module_desc Posts stream schedule derived from Twitch schedule as embed in Discord channel
|
|
*/
|
|
|
|
const (
|
|
twitchAPIRequestLimit = 5
|
|
twitchAPIRequestTimeout = 2 * time.Second
|
|
)
|
|
|
|
var (
|
|
defaultStreamScheduleEntries = ptrInt64(5)
|
|
defaultStreamSchedulePastTime = ptrDuration(15 * time.Minute)
|
|
)
|
|
|
|
func init() {
|
|
RegisterModule("schedule", func() module { return &modStreamSchedule{} })
|
|
}
|
|
|
|
type (
|
|
modStreamSchedule struct {
|
|
attrs moduleAttributeStore
|
|
discord *discordgo.Session
|
|
}
|
|
|
|
twitchStreamScheduleResponse struct {
|
|
Data struct {
|
|
Segments []struct {
|
|
ID string `json:"id"`
|
|
StartTime *time.Time `json:"start_time"`
|
|
EndTime *time.Time `json:"end_time"`
|
|
Title string `json:"title"`
|
|
CanceledUntil *time.Time `json:"canceled_until"`
|
|
Category *struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
} `json:"category"`
|
|
IsRecurring bool `json:"is_recurring"`
|
|
} `json:"segments"`
|
|
BroadcasterID string `json:"broadcaster_id"`
|
|
BroadcasterName string `json:"broadcaster_name"`
|
|
BroadcasterLogin string `json:"broadcaster_login"`
|
|
Vacation *struct {
|
|
StartTime *time.Time `json:"start_time"`
|
|
EndTime *time.Time `json:"end_time"`
|
|
} `json:"vacation"`
|
|
} `json:"data"`
|
|
Pagination struct {
|
|
Cursor string `json:"cursor"`
|
|
} `json:"pagination"`
|
|
}
|
|
)
|
|
|
|
func (m *modStreamSchedule) Initialize(crontab *cron.Cron, discord *discordgo.Session, attrs moduleAttributeStore) error {
|
|
m.attrs = attrs
|
|
m.discord = discord
|
|
|
|
if err := attrs.Expect(
|
|
"discord_channel_id",
|
|
"embed_title",
|
|
"twitch_channel_id",
|
|
"twitch_client_id",
|
|
"twitch_token",
|
|
); err != nil {
|
|
return errors.Wrap(err, "validating attributes")
|
|
}
|
|
|
|
// @attr cron optional string "*/10 * * * *" When to execute the schedule transfer
|
|
if _, err := crontab.AddFunc(attrs.MustString("cron", ptrString("*/10 * * * *")), m.cronUpdateSchedule); err != nil {
|
|
return errors.Wrap(err, "adding cron function")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m modStreamSchedule) cronUpdateSchedule() {
|
|
var data twitchStreamScheduleResponse
|
|
if err := backoff.NewBackoff().WithMaxIterations(twitchAPIRequestLimit).Retry(func() error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), twitchAPIRequestTimeout)
|
|
defer cancel()
|
|
|
|
u, _ := url.Parse("https://api.twitch.tv/helix/schedule")
|
|
params := make(url.Values)
|
|
// @attr twitch_channel_id required string "" ID (not name) of the channel to fetch the schedule from
|
|
params.Set("broadcaster_id", m.attrs.MustString("twitch_channel_id", nil))
|
|
// @attr schedule_past_time optional duration "15m" How long in the past should the schedule contain an entry
|
|
params.Set("start_time", time.Now().Add(-m.attrs.MustDuration("schedule_past_time", defaultStreamSchedulePastTime)).Format(time.RFC3339))
|
|
u.RawQuery = params.Encode()
|
|
|
|
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
|
|
// @attr twitch_token required string "" Token for the user the `twitch_channel_id` belongs to
|
|
req.Header.Set("Authorization", "Bearer "+m.attrs.MustString("twitch_token", nil))
|
|
// @attr twitch_client_id required string "" Twitch client ID the token was issued for
|
|
req.Header.Set("Client-Id", m.attrs.MustString("twitch_client_id", nil))
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return errors.Wrap(err, "fetching schedule")
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
return errors.Wrap(
|
|
json.NewDecoder(resp.Body).Decode(&data),
|
|
"decoding schedule response",
|
|
)
|
|
}); err != nil {
|
|
log.WithError(err).Error("Unable to fetch stream schedule")
|
|
return
|
|
}
|
|
|
|
msgEmbed := &discordgo.MessageEmbed{
|
|
// @attr embed_color optional int64 "3066993" Integer representation of the hex color for the embed (default is #2ECC71)
|
|
Color: int(m.attrs.MustInt64("embed_color", ptrInt64(3066993))),
|
|
// @attr embed_description optional string "" Description for the embed block
|
|
Description: m.attrs.MustString("embed_description", ptrStringEmpty),
|
|
Fields: []*discordgo.MessageEmbedField{},
|
|
Thumbnail: &discordgo.MessageEmbedThumbnail{
|
|
// @attr embed_thumbnail_url optional string "" Publically hosted image URL to use as thumbnail
|
|
URL: m.attrs.MustString("embed_thumbnail_url", ptrStringEmpty),
|
|
// @attr embed_thumbnail_width optional int64 "" Width of the thumbnail
|
|
Width: int(m.attrs.MustInt64("embed_thumbnail_width", ptrInt64Zero)),
|
|
// @attr embed_thumbnail_height optional int64 "" Height of the thumbnail
|
|
Height: int(m.attrs.MustInt64("embed_thumbnail_height", ptrInt64Zero)),
|
|
},
|
|
Timestamp: time.Now().Format(time.RFC3339),
|
|
// @attr embed_title required string "" Title of the embed (used to find the managed post, must be unique for that channel)
|
|
Title: m.attrs.MustString("embed_title", nil),
|
|
Type: discordgo.EmbedTypeRich,
|
|
}
|
|
|
|
for _, seg := range data.Data.Segments {
|
|
title := seg.Title
|
|
if seg.Category != nil && seg.Category.Name != seg.Title {
|
|
title = fmt.Sprintf("%s (%s)", seg.Title, seg.Category.Name)
|
|
}
|
|
|
|
if seg.StartTime == nil || seg.CanceledUntil != nil {
|
|
continue
|
|
}
|
|
|
|
msgEmbed.Fields = append(msgEmbed.Fields, &discordgo.MessageEmbedField{
|
|
Name: m.formatGermanShort(*seg.StartTime),
|
|
Value: title,
|
|
Inline: false,
|
|
})
|
|
|
|
// @attr schedule_entries optional int64 "5" How many schedule entries to add to the embed as fields
|
|
if len(msgEmbed.Fields) == int(m.attrs.MustInt64("schedule_entries", defaultStreamScheduleEntries)) {
|
|
break
|
|
}
|
|
}
|
|
|
|
// @attr discord_channel_id required string "" ID of the Discord channel to post the message to
|
|
msgs, err := m.discord.ChannelMessages(m.attrs.MustString("discord_channel_id", nil), 100, "", "", "")
|
|
if err != nil {
|
|
log.WithError(err).Error("Unable to fetch announcement channel messages")
|
|
return
|
|
}
|
|
|
|
var managedMsg *discordgo.Message
|
|
for _, msg := range msgs {
|
|
if len(msg.Embeds) == 0 || msg.Embeds[0].Title != msgEmbed.Title {
|
|
continue
|
|
}
|
|
|
|
managedMsg = msg
|
|
}
|
|
|
|
if managedMsg != nil {
|
|
oldEmbed := managedMsg.Embeds[0]
|
|
|
|
if !m.embedNeedsUpdate(oldEmbed, msgEmbed) {
|
|
log.Debug("Stream Schedule is up-to-date")
|
|
return
|
|
}
|
|
|
|
_, err = m.discord.ChannelMessageEditEmbed(m.attrs.MustString("discord_channel_id", nil), managedMsg.ID, msgEmbed)
|
|
} else {
|
|
_, err = m.discord.ChannelMessageSendEmbed(m.attrs.MustString("discord_channel_id", nil), msgEmbed)
|
|
}
|
|
if err != nil {
|
|
log.WithError(err).Error("Unable to announce streamplan")
|
|
return
|
|
}
|
|
|
|
log.Info("Updated Stream Schedule")
|
|
}
|
|
|
|
func (m modStreamSchedule) formatGermanShort(t time.Time) string {
|
|
wd := map[time.Weekday]string{
|
|
time.Monday: "Mo.",
|
|
time.Tuesday: "Di.",
|
|
time.Wednesday: "Mi.",
|
|
time.Thursday: "Do.",
|
|
time.Friday: "Fr.",
|
|
time.Saturday: "Sa.",
|
|
time.Sunday: "So.",
|
|
}[t.Weekday()]
|
|
|
|
tz, err := time.LoadLocation("Europe/Berlin")
|
|
if err != nil {
|
|
log.WithError(err).Fatal("Unable to load timezone Europe/Berlin")
|
|
}
|
|
|
|
return strings.Join([]string{wd, t.In(tz).Format("02.01. 15:04"), "Uhr"}, " ")
|
|
}
|
|
|
|
func (m modStreamSchedule) embedNeedsUpdate(o, n *discordgo.MessageEmbed) bool {
|
|
if o.Title != n.Title {
|
|
return true
|
|
}
|
|
|
|
if o.Description != n.Description {
|
|
return true
|
|
}
|
|
|
|
if o.Thumbnail != nil && n.Thumbnail == nil || o.Thumbnail == nil && n.Thumbnail != nil {
|
|
return true
|
|
}
|
|
|
|
if o.Thumbnail != nil && o.Thumbnail.URL != n.Thumbnail.URL {
|
|
return true
|
|
}
|
|
|
|
if len(o.Fields) != len(n.Fields) {
|
|
return true
|
|
}
|
|
|
|
for i := range o.Fields {
|
|
if o.Fields[i].Name != n.Fields[i].Name {
|
|
return true
|
|
}
|
|
|
|
if o.Fields[i].Value != n.Fields[i].Value {
|
|
return true
|
|
}
|
|
|
|
if o.Fields[i].Inline != n.Fields[i].Inline {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|