grim/wasdead

I forgot to push the database code
draft
2019-03-22, Ruin
052f0fba0be0
I forgot to push the database code
package main
import (
"errors"
"flag"
"fmt"
"log"
"net/url"
"os"
"os/signal"
"strings"
"syscall"
"time"
"bitbucket.org/TheToyz/nowdead/database"
"github.com/dustin/go-humanize"
"github.com/bwmarrin/discordgo"
"github.com/nicklaw5/helix"
)
var (
DiscordToken string
TwitchToken string
DatabaseType string
TwitchClient *helix.Client
logger *log.Logger
startTime time.Time
db database.Database
)
func init() {
logger = log.New(os.Stderr, " ", log.Ldate|log.Ltime)
startTime = time.Now()
flag.StringVar(&DiscordToken, "t", "", "Discord Bot Token")
flag.StringVar(&TwitchToken, "tcid", "", "Twitch Client ID")
flag.StringVar(&DatabaseType, "db_type", "bitcask", "Database type to use (default: bitcask)")
flag.Parse()
}
func logDebug(v ...interface{}) {
logger.SetPrefix("DEBUG ")
logger.Println(v...)
}
func logInfo(v ...interface{}) {
logger.SetPrefix("INFO ")
logger.Println(v...)
}
func logError(v ...interface{}) {
logger.SetPrefix("ERROR ")
logger.Println(v...)
}
func logPanic(v ...interface{}) {
logger.SetPrefix("PANIC ")
logger.Panicln(v...)
}
func main() {
db = database.Get(DatabaseType)
if len(DiscordToken) <= 0 || len(TwitchToken) <= 0 {
logPanic("Discord Token and Twitch Client ID must be set")
}
logDebug("Discord Token:", DiscordToken)
logDebug("Twitch Token:", TwitchToken)
client, err := helix.NewClient(&helix.Options{
ClientID: TwitchToken,
})
if err != nil {
logPanic(err)
}
TwitchClient = client
dg, err := discordgo.New("Bot " + strings.TrimSpace(DiscordToken))
if err != nil {
fmt.Println("error creating Discord session,", err)
return
}
dg.AddHandler(presenceUpdate)
dg.AddHandler(messageCreate)
err = dg.Open()
if err != nil {
log.Panic(err)
return
}
fmt.Println("Bot is now running. Press CTRL-C to exit.")
sc := make(chan os.Signal, 1)
signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
<-sc
dg.Close()
}
func presenceUpdate(sess *discordgo.Session, evt *discordgo.PresenceUpdate) {
logDebug("PRESENSE UPDATE user-ID:", evt.User.ID)
if evt.Game != nil {
logDebug(fmt.Sprintf("PRESENSE UPDATE game: %#v", evt.Game))
if evt.Game.Type == discordgo.GameTypeStreaming {
pURL, _ := url.Parse(evt.Game.URL)
channel := db.GetChannel(evt.GuildID)
if channel != "" {
err := processPresenceUpdate(sess, channel, strings.TrimLeft(pURL.Path, "/"), evt.Game.URL)
if err != nil {
logError(err)
}
}
}
}
}
func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
if m.Author.ID == s.State.User.ID {
return
}
commandItems := strings.Split(m.Content, " ")
if strings.EqualFold(commandItems[0], "!uptime") {
duration := time.Now().Sub(startTime)
channel := db.GetChannel(m.GuildID)
if channel != "" {
if channel != m.ChannelID {
return
}
err := sendMessage(s, channel, fmt.Sprintf(
"Uptime is: **%02d:%02d:%02d** (since **%s**)",
int(duration.Hours()),
int(duration.Minutes())%60,
int(duration.Seconds())%60,
startTime.Format(time.Stamp)))
logError(err)
}
}
if strings.EqualFold(commandItems[0], "!isLive") {
if len(commandItems) == 1 {
return
}
channel := db.GetChannel(m.GuildID)
if channel != "" {
if channel != m.ChannelID {
return
}
err := processPresenceUpdate(s, channel, commandItems[1], "https://twitch.com/"+commandItems[1])
if err != nil {
logError(err)
sendMessage(s, channel, fmt.Sprintf("_%s_ does not seem to be live right now!", commandItems[1]))
}
}
}
if strings.EqualFold(commandItems[0], "!init") {
sendMessage(s, m.ChannelID, "All set up to talk in this channel!")
db.SetChannel(m.GuildID, m.ChannelID)
}
}
func sendMessage(sess *discordgo.Session, channelid, message string) error {
logInfo("SENDING MESSAGE:", channelid, message)
_, err := sess.ChannelMessageSend(channelid, message)
return err
}
func processPresenceUpdate(s *discordgo.Session, channelid, twitchName, url string) error {
resp, err := TwitchClient.GetUsers(&helix.UsersParams{
Logins: []string{twitchName},
})
if err != nil {
return err
}
data, _ := TwitchClient.GetStreams(&helix.StreamsParams{
UserLogins: []string{twitchName},
})
if len(resp.Data.Users) <= 0 || len(data.Data.Streams) <= 0 {
return errors.New("user was not found")
}
user := resp.Data.Users[0]
stream := data.Data.Streams[0]
f := make([]*discordgo.MessageEmbedField, 0)
f = append(f, &discordgo.MessageEmbedField{
Name: "Title",
Value: stream.Title,
})
f = append(f, &discordgo.MessageEmbedField{
Name: "Viewer",
Value: humanize.Comma(int64(stream.ViewerCount)),
Inline: true,
})
f = append(f, &discordgo.MessageEmbedField{
Name: "Lagnauge",
Value: stream.Language,
Inline: true,
})
image := strings.Replace(stream.ThumbnailURL, "{width}", "400", -1)
image = strings.Replace(image, "{height}", "225", -1)
_, err = s.ChannelMessageSendEmbed(channelid, &discordgo.MessageEmbed{
Image: &discordgo.MessageEmbedImage{
URL: image,
},
Author: &discordgo.MessageEmbedAuthor{
URL: url,
Name: user.DisplayName + " is now live",
},
Thumbnail: &discordgo.MessageEmbedThumbnail{
URL: user.ProfileImageURL,
},
Fields: f,
})
return err
}
func fileExist(name string) bool {
if _, err := os.Stat(name); err != nil {
if os.IsNotExist(err) {
return false
}
}
return true
}