├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── bot.go
├── carbonitexplugin
    └── carbonitexplugin.go
├── chartplugin
    └── chartplugin.go
├── cmd
    └── bruxism
    │   └── main.go
├── comicplugin
    ├── comicplugin.go
    └── comicplugin_test.go
├── commandplugin.go
├── discord.go
├── discord_test.go
├── discordavatarplugin
    └── discordavatarplugin.go
├── emojiplugin
    ├── README.md
    └── emojiplugin.go
├── go.mod
├── go.sum
├── helpplugin.go
├── interfaces.go
├── inviteplugin
    └── inviteplugin.go
├── irc.go
├── liveplugin
    └── liveplugin.go
├── mockmessage.go
├── mockservice.go
├── mtgplugin
    └── mtgplugin.go
├── musicplugin
    ├── README.md
    └── musicplugin.go
├── mysonplugin
    └── mysonplugin.go
├── numbertriviaplugin
    └── numbertriviaplugin.go
├── playedplugin
    └── playedplugin.go
├── playingplugin
    └── playingplugin.go
├── reminderplugin
    └── reminderplugin.go
├── simpleplugin.go
├── slack.go
├── statsplugin
    └── statsplugin.go
├── streamerplugin
    └── streamerplugin.go
├── topstreamersplugin
    └── topstreamersplugin.go
├── triviaplugin
    ├── questions.go
    └── triviaplugin.go
├── youtube.go
├── youtubejoinplugin
    └── youtubejoinplugin.go
└── ytlivechannel.go


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
 2 | *.o
 3 | *.a
 4 | *.so
 5 | 
 6 | # Folders
 7 | _obj
 8 | _test
 9 | 
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 | 
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 | 
20 | _testmain.go
21 | 
22 | *.exe
23 | *.test
24 | *.prof
25 | 
26 | # ignore dep/vendor for now
27 | 
28 | /Gopkg.*
29 | /vendor


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: go
 2 | go:
 3 |     - 1.8
 4 |     - 1.9
 5 |     - "1.10"
 6 | install:
 7 |     - go get github.com/iopred/bruxism/carbonitexplugin
 8 |     - go get github.com/iopred/bruxism/chartplugin
 9 |     - go get github.com/iopred/bruxism/comicplugin
10 |     - go get github.com/iopred/bruxism/discordavatarplugin
11 |     - go get github.com/iopred/bruxism/emojiplugin
12 |     - go get github.com/iopred/bruxism/inviteplugin
13 |     - go get github.com/iopred/bruxism/liveplugin
14 |     - go get github.com/iopred/bruxism/mtgplugin
15 |     - go get github.com/iopred/bruxism/musicplugin
16 |     - go get github.com/iopred/bruxism/mysonplugin
17 |     - go get github.com/iopred/bruxism/numbertriviaplugin
18 |     - go get github.com/iopred/bruxism/playedplugin
19 |     - go get github.com/iopred/bruxism/playingplugin
20 |     - go get github.com/iopred/bruxism/reminderplugin
21 |     - go get github.com/iopred/bruxism/statsplugin
22 |     - go get github.com/iopred/bruxism/streamerplugin
23 |     - go get github.com/iopred/bruxism/topstreamersplugin
24 |     - go get github.com/iopred/bruxism/triviaplugin
25 |     - go get github.com/iopred/bruxism/youtubejoinplugin
26 |     - go get -v github.com/iopred/bruxism
27 |     - go get -v .
28 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Christopher Rhodes
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Bruxism
  2 | A chat bot for YouTube, Discord and IRC.
  3 | 
  4 | [![GoDoc](https://godoc.org/github.com/iopred/bruxism?status.svg)](https://godoc.org/github.com/iopred/bruxism)
  5 | [![Go report](http://goreportcard.com/badge/iopred/bruxism)](http://goreportcard.com/report/iopred/bruxism)
  6 | [![Build Status](https://travis-ci.org/iopred/bruxism.svg?branch=master)](https://travis-ci.org/iopred/bruxism)
  7 | 
  8 | ## Current plugin support:
  9 | 
 10 | Commands are prefixed with `@BotName `.
 11 | 
 12 | * `emoji <emoji>` - Returns a big version of an emoji. Please read the README in emojiplugin for installation notes.
 13 | * `help [<topic>]` - Returns generic help or help for a specific topic. Available topics: `comic,remind`
 14 | * `invite <id>` - Provides invite URL for the bot.
 15 | * `numbertrivia [<number>]` - Returns trivia for a random number or a specified number if provided.
 16 | * `playing` - Set which game the bot is playing on Discord. Only enabled for bot owner.
 17 | * `reminder <time> | <reminder>` - Sets a reminder.
 18 | * `stats` - Lists bot statistics.
 19 | * `streamer <streamername|streamerid>` - Grabs details about a YouTube streamer.
 20 | * `topstreamers` - List the current top streamers on YouTube Gaming.
 21 | 
 22 | eg: `@BotName help`
 23 | 
 24 | Also supports direct invites on Discord and support for announcing streamers going live on YouTube Gaming.
 25 | 
 26 | ## Usage:
 27 | 
 28 | ### Installation:
 29 | 
 30 | `go get github.com/iopred/bruxism/cmd/bruxism`
 31 | 
 32 | `go install github.com/iopred/bruxism/cmd/bruxism`
 33 | 
 34 | `cd $GOPATH/bin`
 35 | 
 36 | ### Setup
 37 | 
 38 | You must first generate a YouTube Oauth token in the [Google Developer Console](https://console.developers.google.com/).
 39 | 
 40 | Go to Credentials and download the JSON config file and save it in `$GOPATH/bin` as `youtubeoauth2config.json`
 41 | 
 42 | `./bruxism -youtubeurl`
 43 | 
 44 | You will then be given a URL (and copied to clipboard), visit that URL and copy the code, then run:
 45 | 
 46 | `./bruxism -youtubeauth <AUTH CODE>`
 47 | 
 48 | Now the bot can be run:
 49 | 
 50 | `./bruxism -youtubechannelids <youtube channel id1,youtube channel id2>`
 51 | 
 52 | #### Important!
 53 | The account you choose during the oauth flow is the account that the bot will use to send messages.
 54 | 
 55 | If you are trying to test the bot, make sure the account you are sending messages with is **different** from the bot account.
 56 | 
 57 | Bruxism ignores messages from the bot account, so if you are sharing accounts all commands will be ignored.
 58 | 
 59 | 
 60 | ### Run as a Discord bot
 61 | 
 62 | `./bruxism -discordtoken "Bot <discord bot token>"`
 63 | 
 64 | It is suggested that you set `-discordapplicationclientid` if you are running a bot account, this will make `inviteplugin` function correctly.
 65 | 
 66 | It is suggested that you set `-discordowneruserid` as this prevents anyone from calling `playingplugin`.
 67 | 
 68 | To invite your bot to a server, visit: `https://discordapp.com/oauth2/authorize?client_id=<discord client id>&scope=bot`
 69 | 
 70 | ### Run as an IRC bot
 71 | 
 72 | `./bruxism -ircserver <irc server> -ircusername <irc username> -ircchannels <#channel1,#channel2>`
 73 | 
 74 | ### Run as a Slack bot
 75 | 
 76 | `./bruxism -slacktoken <slack token>`
 77 | 
 78 | It is suggested that you set `-slackowneruserid`.
 79 | 
 80 | #### Image uploads
 81 | 
 82 | Some plugins upload images to imgur (such as chartplugin), it's suggested that you run your bot with `-imgurid <imgurid>` to enable this.
 83 | 
 84 | ## Arguments:
 85 | 
 86 | * `youtubeurl` - Outputs a new OAuth URL for YouTube and then exits.
 87 | * `youtubeauth` - Exchanges the provided auth code for an oauth2 token.
 88 | * `youtubeconfig` - The filename for your YouTube OAuth client JSON. (Download JSON in Google Developers Console -> Credentials).
 89 | * `youtubetoken` - The filename to store the oauth2 token.
 90 | * `youtubelivechannelids` - Comma separated list of channel ids to poll.
 91 | * `discordtoken` - Sets the Discord token.
 92 | * `discordemail` - Sets the Discord account email.
 93 | * `discordpassword` - Sets the Discord account password.
 94 | * `discordclientid` - Sets the Discord client id.
 95 | * `ircserver` - Sets the IRC server.
 96 | * `ircusername` - Sets the IRC user name.
 97 | * `ircpassword` - Sets the IRC password.
 98 | * `ircchannels` - Comma separated list of IRC channels.
 99 | * `imgurid` - Sets the Imgur client id, used for uploading images to imgur.
100 | * `imguralbum` - Sets an optional the Imgur album id, used for uploading images to imgur.
101 | * `mashablekey` - Sets the mashable oauth key.
102 | 
103 | ## Special Thanks
104 | 
105 | [Skippy](https://github.com/bwmarrin/discordgo) - For DiscordGo and the Music Plugin.
106 | 


--------------------------------------------------------------------------------
/bot.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"encoding/json"
  6 | 	"errors"
  7 | 	"io"
  8 | 	"io/ioutil"
  9 | 	"log"
 10 | 	"mime/multipart"
 11 | 	"net/http"
 12 | 	"os"
 13 | 	"runtime/debug"
 14 | )
 15 | 
 16 | // VersionString is the current version of the bot
 17 | const VersionString string = "0.12"
 18 | 
 19 | type serviceEntry struct {
 20 | 	Service
 21 | 	Plugins         map[string]Plugin
 22 | 	messageChannels []chan Message
 23 | }
 24 | 
 25 | // Bot enables registering of Services and Plugins.
 26 | type Bot struct {
 27 | 	Services    map[string]*serviceEntry
 28 | 	ImgurID     string
 29 | 	ImgurAlbum  string
 30 | 	MashableKey string
 31 | }
 32 | 
 33 | // MessageRecover is the default panic handler for bruxism.
 34 | func MessageRecover() {
 35 | 	if r := recover(); r != nil {
 36 | 		log.Println("Recovered:", string(debug.Stack()))
 37 | 	}
 38 | }
 39 | 
 40 | // NewBot will create a new bot.
 41 | func NewBot() *Bot {
 42 | 	return &Bot{
 43 | 		Services: make(map[string]*serviceEntry, 0),
 44 | 	}
 45 | }
 46 | 
 47 | func (b *Bot) PluginFile(service Service, plugin Plugin) string {
 48 | 	return service.Name() + "/" + plugin.Name()
 49 | }
 50 | 
 51 | func (b *Bot) getData(service Service, plugin Plugin) []byte {
 52 | 	if b, err := ioutil.ReadFile(b.PluginFile(service, plugin)); err == nil {
 53 | 		return b
 54 | 	}
 55 | 	return nil
 56 | }
 57 | 
 58 | // RegisterService registers a service with the bot.
 59 | func (b *Bot) RegisterService(service Service) {
 60 | 	if b.Services[service.Name()] != nil {
 61 | 		log.Println("Service with that name already registered", service.Name())
 62 | 	}
 63 | 	serviceName := service.Name()
 64 | 	b.Services[serviceName] = &serviceEntry{
 65 | 		Service: service,
 66 | 		Plugins: make(map[string]Plugin, 0),
 67 | 	}
 68 | 	b.RegisterPlugin(service, NewHelpPlugin())
 69 | }
 70 | 
 71 | // RegisterPlugin registers a plugin on a service.
 72 | func (b *Bot) RegisterPlugin(service Service, plugin Plugin) {
 73 | 	s := b.Services[service.Name()]
 74 | 	if s.Plugins[plugin.Name()] != nil {
 75 | 		log.Println("Plugin with that name already registered", plugin.Name())
 76 | 	}
 77 | 	s.Plugins[plugin.Name()] = plugin
 78 | }
 79 | 
 80 | func (b *Bot) listen(service Service, messageChan <-chan Message) {
 81 | 	serviceName := service.Name()
 82 | 	for {
 83 | 		message := <-messageChan
 84 | 		//log.Printf("<%s> %s: %s\n", message.Channel(), message.UserName(), message.Message())
 85 | 		plugins := b.Services[serviceName].Plugins
 86 | 		for _, plugin := range plugins {
 87 | 			go plugin.Message(b, service, message)
 88 | 		}
 89 | 	}
 90 | }
 91 | 
 92 | // Open will open all the current services and begins listening.
 93 | func (b *Bot) Open() {
 94 | 	log.Printf("Bot opening")
 95 | 	for _, service := range b.Services {
 96 | 		log.Printf("Opening service %s\n", service.Name())
 97 | 		if messageChan, err := service.Open(); err == nil {
 98 | 			for _, plugin := range service.Plugins {
 99 | 				err := plugin.Load(b, service.Service, b.getData(service, plugin))
100 | 				if err != nil {
101 | 					log.Printf("Error loading plugin %s/%s: %v\n", service.Name(), plugin.Name(), err)
102 | 				}
103 | 			}
104 | 			go b.listen(service.Service, messageChan)
105 | 			log.Printf("Opened service %s\n", service.Name())
106 | 		} else {
107 | 			log.Printf("Error creating service %s: %v\n", service.Name(), err)
108 | 		}
109 | 	}
110 | 	log.Printf("Bot opened")
111 | }
112 | 
113 | // Save will save the current plugin state for all plugins on all services.
114 | func (b *Bot) Save() {
115 | 	for _, service := range b.Services {
116 | 		serviceName := service.Name()
117 | 		if err := os.Mkdir(serviceName, os.ModePerm); err != nil {
118 | 			if !os.IsExist(err) {
119 | 				log.Println("Error creating service directory.")
120 | 			}
121 | 		}
122 | 		for _, plugin := range service.Plugins {
123 | 			if data, err := plugin.Save(); err != nil {
124 | 				log.Printf("Error saving plugin %s %s. %v", serviceName, plugin.Name(), err)
125 | 			} else if data != nil {
126 | 				if err := ioutil.WriteFile(serviceName+"/"+plugin.Name(), data, os.ModePerm); err != nil {
127 | 					log.Printf("Error saving plugin %s %s. %v", serviceName, plugin.Name(), err)
128 | 				}
129 | 			}
130 | 		}
131 | 	}
132 | }
133 | 
134 | // UploadToImgur uploads image data to Imgur and returns the url to it.
135 | func (b *Bot) UploadToImgur(re io.Reader, filename string) (string, error) {
136 | 	if b.ImgurID == "" {
137 | 		return "", errors.New("No Imgur client ID provided.")
138 | 	}
139 | 
140 | 	bodyBuf := &bytes.Buffer{}
141 | 	bodywriter := multipart.NewWriter(bodyBuf)
142 | 
143 | 	writer, err := bodywriter.CreateFormFile("image", filename)
144 | 	if err != nil {
145 | 		return "", err
146 | 	}
147 | 
148 | 	_, err = io.Copy(writer, re)
149 | 	if err != nil {
150 | 		return "", err
151 | 	}
152 | 
153 | 	contentType := bodywriter.FormDataContentType()
154 | 	if b.ImgurAlbum != "" {
155 | 		bodywriter.WriteField("album", b.ImgurAlbum)
156 | 	}
157 | 	bodywriter.Close()
158 | 
159 | 	r, err := http.NewRequest("POST", "https://api.imgur.com/3/image", bodyBuf)
160 | 	if err != nil {
161 | 		return "", err
162 | 	}
163 | 
164 | 	r.Header.Set("Content-Type", contentType)
165 | 	r.Header.Set("Authorization", "Client-ID "+b.ImgurID)
166 | 
167 | 	resp, err := http.DefaultClient.Do(r)
168 | 	if err != nil {
169 | 		return "", err
170 | 	}
171 | 	defer resp.Body.Close()
172 | 	body, err := ioutil.ReadAll(resp.Body)
173 | 	if err != nil {
174 | 		return "", err
175 | 	}
176 | 
177 | 	if resp.StatusCode != 200 {
178 | 		return "", errors.New(string(body))
179 | 	}
180 | 
181 | 	j := make(map[string]interface{})
182 | 
183 | 	err = json.Unmarshal(body, &j)
184 | 	if err != nil {
185 | 		return "", err
186 | 	}
187 | 
188 | 	return j["data"].(map[string]interface{})["link"].(string), nil
189 | }
190 | 


--------------------------------------------------------------------------------
/carbonitexplugin/carbonitexplugin.go:
--------------------------------------------------------------------------------
 1 | package carbonitexplugin
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"net/url"
 7 | 	"time"
 8 | 
 9 | 	"github.com/iopred/bruxism"
10 | )
11 | 
12 | type carbonitexPlugin struct {
13 | 	bruxism.SimplePlugin
14 | 	key string
15 | }
16 | 
17 | func (p *carbonitexPlugin) carbonitexPluginLoadFunc(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
18 | 	if service.Name() != bruxism.DiscordServiceName {
19 | 		panic("Carbonitex Plugin only supports Discord.")
20 | 	}
21 | 
22 | 	go p.Run(bot, service)
23 | 	return nil
24 | }
25 | 
26 | func (p *carbonitexPlugin) Run(bot *bruxism.Bot, service bruxism.Service) {
27 | 	for {
28 | 		<-time.After(5 * time.Minute)
29 | 
30 | 		http.PostForm("https://www.carbonitex.net/discord/data/botdata.php", url.Values{"key": {p.key}, "servercount": {fmt.Sprintf("%d", service.ChannelCount())}})
31 | 
32 | 		<-time.After(55 * time.Minute)
33 | 	}
34 | 
35 | }
36 | 
37 | // New will create a new carbonitex plugin.
38 | // This plugin reports the server count to the carbonitex service.
39 | func New(key string) bruxism.Plugin {
40 | 	p := &carbonitexPlugin{
41 | 		SimplePlugin: *bruxism.NewSimplePlugin("Carbonitex"),
42 | 		key:          key,
43 | 	}
44 | 	p.LoadFunc = p.carbonitexPluginLoadFunc
45 | 	return p
46 | }
47 | 


--------------------------------------------------------------------------------
/chartplugin/chartplugin.go:
--------------------------------------------------------------------------------
  1 | package chartplugin
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"image/color"
  7 | 	"log"
  8 | 	"math/rand"
  9 | 	"strings"
 10 | 	"time"
 11 | 
 12 | 	"github.com/bwmarrin/discordgo"
 13 | 	"github.com/dustin/go-humanize"
 14 | 	"github.com/iopred/bruxism"
 15 | 	"gonum.org/v1/plot"
 16 | 	"gonum.org/v1/plot/plotter"
 17 | 	"gonum.org/v1/plot/plotutil"
 18 | 	"gonum.org/v1/plot/vg"
 19 | )
 20 | 
 21 | type chartPlugin struct {
 22 | 	bruxism.SimplePlugin
 23 | 
 24 | 	cooldown map[string]time.Time
 25 | }
 26 | 
 27 | var randomDirection = []string{
 28 | 	"up",
 29 | 	"down",
 30 | 	"flat",
 31 | }
 32 | 
 33 | var randomY = []string{
 34 | 	"interest",
 35 | 	"care",
 36 | 	"success",
 37 | 	"fail",
 38 | 	"happiness",
 39 | 	"sadness",
 40 | 	"money",
 41 | }
 42 | 
 43 | var randomX = []string{
 44 | 	"time",
 45 | 	"releases",
 46 | 	"days",
 47 | 	"years",
 48 | }
 49 | 
 50 | func (p *chartPlugin) random(list []string) string {
 51 | 	return list[rand.Intn(len(list))]
 52 | }
 53 | 
 54 | func (p *chartPlugin) randomChart(service bruxism.Service) string {
 55 | 	ticks := ""
 56 | 	if service.Name() == bruxism.DiscordServiceName {
 57 | 		ticks = "`"
 58 | 	}
 59 | 
 60 | 	return fmt.Sprintf("%s%schart %s %s, %s%s", ticks, service.CommandPrefix(), p.random(randomDirection), p.random(randomY), p.random(randomX), ticks)
 61 | }
 62 | 
 63 | func (p *chartPlugin) helpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 64 | 	help := bruxism.CommandHelp(service, "chart", "<up|down|flat> <vertical message>, <horizontal message>", "Creates a chart trending in the desired direction.")
 65 | 
 66 | 	if detailed {
 67 | 		help = append(help, []string{
 68 | 			"Examples:",
 69 | 			bruxism.CommandHelp(service, "chart", "down interest, time", "Creates a chart showing declining interest over time")[0],
 70 | 		}...)
 71 | 	}
 72 | 
 73 | 	return help
 74 | }
 75 | 
 76 | func (p *chartPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
 77 | 	if service.IsMe(message) {
 78 | 		return
 79 | 	}
 80 | 
 81 | 	if !bruxism.MatchesCommand(service, "chart", message) {
 82 | 		return
 83 | 	}
 84 | 
 85 | 	cooldown := p.cooldown[message.UserID()]
 86 | 	if cooldown.After(time.Now()) {
 87 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, you need to wait %s before creating another chart.", message.UserName(), humanize.Time(cooldown)))
 88 | 		return
 89 | 	}
 90 | 	p.cooldown[message.UserID()] = time.Now().Add(10 * time.Second)
 91 | 
 92 | 	query, parts := bruxism.ParseCommand(service, message)
 93 | 	if len(parts) == 0 {
 94 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Invalid chart eg: %s", p.randomChart(service)))
 95 | 		return
 96 | 	}
 97 | 
 98 | 	start, end := 0.5, 0.5
 99 | 
100 | 	switch parts[0] {
101 | 	case "up":
102 | 		start, end = 0, 1
103 | 	case "down":
104 | 		start, end = 1, 0
105 | 	case "flat":
106 | 	case "straight":
107 | 	default:
108 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Invalid chart direction. eg: %s", p.randomChart(service)))
109 | 		return
110 | 	}
111 | 
112 | 	axes := strings.Split(query[len(parts[0]):], ",")
113 | 	if len(axes) != 2 {
114 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Invalid chart axis labels eg: %s", p.randomChart(service)))
115 | 		return
116 | 	}
117 | 
118 | 	service.Typing(message.Channel())
119 | 
120 | 	pl := plot.New()
121 | 	pl.Y.Label.Text = axes[0]
122 | 	pl.X.Label.Text = axes[1]
123 | 
124 | 	num := 5 + rand.Intn(15)
125 | 
126 | 	start *= float64(num)
127 | 	end *= float64(num)
128 | 
129 | 	pts := make(plotter.XYs, num)
130 | 	for i := range pts {
131 | 		pts[i].X = float64(i) + rand.Float64()*0.5 - 0.2
132 | 		pts[i].Y = start + float64(end-start)/float64(num-1)*float64(i) + rand.Float64()*0.5 - 0.25
133 | 	}
134 | 
135 | 	pl.X.Tick.Label.Color = color.Transparent
136 | 	pl.Y.Tick.Label.Color = color.Transparent
137 | 
138 | 	pl.X.Min = -0.5
139 | 	pl.X.Max = float64(num) + 0.5
140 | 
141 | 	pl.Y.Min = -0.5
142 | 	pl.Y.Max = float64(num) + 0.5
143 | 
144 | 	lpLine, lpPoints, err := plotter.NewLinePoints(pts)
145 | 	if err != nil {
146 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your chart.", message.UserName()))
147 | 	}
148 | 	lpLine.Color = plotutil.Color(rand.Int())
149 | 	lpLine.Width = vg.Points(1 + 0.5*rand.Float64())
150 | 	lpLine.Dashes = plotutil.Dashes(rand.Int())
151 | 	lpPoints.Shape = plotutil.Shape(rand.Int())
152 | 	lpPoints.Color = lpLine.Color
153 | 
154 | 	pl.Add(lpLine, lpPoints)
155 | 
156 | 	w, err := pl.WriterTo(320, 240, "png")
157 | 	if err != nil {
158 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your chart.", message.UserName()))
159 | 		return
160 | 	}
161 | 
162 | 	b := &bytes.Buffer{}
163 | 	w.WriteTo(b)
164 | 
165 | 	go func() {
166 | 		if service.Name() == bruxism.DiscordServiceName {
167 | 			discord := service.(*bruxism.Discord)
168 | 			p, err := discord.UserChannelPermissions(service.UserID(), message.Channel())
169 | 			if err == nil && p&discordgo.PermissionAttachFiles == discordgo.PermissionAttachFiles {
170 | 				service.SendFile(message.Channel(), "chart.png", b)
171 | 				return
172 | 			}
173 | 		}
174 | 
175 | 		url, err := bot.UploadToImgur(b, "chart.png")
176 | 		if err != nil {
177 | 			service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem uploading the chart to imgur.", message.UserName()))
178 | 			log.Println("Error uploading chart: ", err)
179 | 			return
180 | 		}
181 | 
182 | 		if service.Name() == bruxism.DiscordServiceName {
183 | 			service.SendMessage(message.Channel(), fmt.Sprintf("Here's your chart <@%s>: %s", message.UserID(), url))
184 | 		} else {
185 | 			service.SendMessage(message.Channel(), fmt.Sprintf("Here's your chart %s: %s", message.UserName(), url))
186 | 		}
187 | 	}()
188 | }
189 | 
190 | // New will create a new chart plugin.
191 | func New() bruxism.Plugin {
192 | 	p := &chartPlugin{
193 | 		SimplePlugin: *bruxism.NewSimplePlugin("Chart"),
194 | 		cooldown:     map[string]time.Time{},
195 | 	}
196 | 	p.MessageFunc = p.messageFunc
197 | 	p.HelpFunc = p.helpFunc
198 | 	return p
199 | }
200 | 


--------------------------------------------------------------------------------
/cmd/bruxism/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"flag"
  5 | 	"log"
  6 | 	"math/rand"
  7 | 	"os"
  8 | 	"os/signal"
  9 | 	"strings"
 10 | 	"time"
 11 | 
 12 | 	"github.com/iopred/bruxism"
 13 | 	"github.com/iopred/bruxism/carbonitexplugin"
 14 | 	"github.com/iopred/bruxism/chartplugin"
 15 | 	"github.com/iopred/bruxism/discordavatarplugin"
 16 | 	"github.com/iopred/bruxism/emojiplugin"
 17 | 	"github.com/iopred/bruxism/inviteplugin"
 18 | 	"github.com/iopred/bruxism/liveplugin"
 19 | 	"github.com/iopred/bruxism/musicplugin"
 20 | 	"github.com/iopred/bruxism/mysonplugin"
 21 | 	"github.com/iopred/bruxism/numbertriviaplugin"
 22 | 	"github.com/iopred/bruxism/playedplugin"
 23 | 	"github.com/iopred/bruxism/playingplugin"
 24 | 	"github.com/iopred/bruxism/reminderplugin"
 25 | 	"github.com/iopred/bruxism/statsplugin"
 26 | 	"github.com/iopred/bruxism/streamerplugin"
 27 | 	"github.com/iopred/bruxism/topstreamersplugin"
 28 | 	"github.com/iopred/bruxism/triviaplugin"
 29 | 	"github.com/iopred/bruxism/youtubejoinplugin"
 30 | )
 31 | 
 32 | var youtubeURL bool
 33 | var youtubeAuth string
 34 | var youtubeConfigFilename string
 35 | var youtubeTokenFilename string
 36 | var youtubeChannelIDs string
 37 | var youtubeInvitePort int
 38 | var discordToken string
 39 | var discordEmail string
 40 | var discordPassword string
 41 | var discordApplicationClientID string
 42 | var discordOwnerUserID string
 43 | var ircServer string
 44 | var ircUsername string
 45 | var ircPassword string
 46 | var ircChannels string
 47 | var slackToken string
 48 | var slackOwnerUserID string
 49 | var imgurID string
 50 | var imgurAlbum string
 51 | var mashableKey string
 52 | var carbonitexKey string
 53 | 
 54 | func init() {
 55 | 	flag.BoolVar(&youtubeURL, "youtubeurl", false, "Generates a URL that provides an auth code.")
 56 | 	flag.StringVar(&youtubeAuth, "youtubeauth", "", "Exchanges the provided auth code for an oauth2 token.")
 57 | 	flag.StringVar(&youtubeConfigFilename, "youtubeconfig", "youtubeoauth2config.json", "The filename that contains the oauth2 config.")
 58 | 	flag.StringVar(&youtubeTokenFilename, "youtubetoken", "youtubeoauth2token.json", "The filename to store the oauth2 token.")
 59 | 	flag.StringVar(&youtubeChannelIDs, "youtubechannelids", "", "Comma separated list of channel ids to poll.")
 60 | 	flag.IntVar(&youtubeInvitePort, "youtubeinviteport", 7777, "The port to listen for invites.")
 61 | 	flag.StringVar(&discordToken, "discordtoken", "", "Discord token.")
 62 | 	flag.StringVar(&discordEmail, "discordemail", "", "Discord account email.")
 63 | 	flag.StringVar(&discordPassword, "discordpassword", "", "Discord account password.")
 64 | 	flag.StringVar(&discordOwnerUserID, "discordowneruserid", "", "Discord owner user id.")
 65 | 	flag.StringVar(&discordApplicationClientID, "discordapplicationclientid", "", "Discord application client id.")
 66 | 	flag.StringVar(&ircServer, "ircserver", "", "IRC server.")
 67 | 	flag.StringVar(&ircUsername, "ircusername", "", "IRC user name.")
 68 | 	flag.StringVar(&ircPassword, "ircpassword", "", "IRC password.")
 69 | 	flag.StringVar(&ircChannels, "ircchannels", "", "Comma separated list of IRC channels.")
 70 | 	flag.StringVar(&slackToken, "slacktoken", "", "Slack token.")
 71 | 	flag.StringVar(&slackOwnerUserID, "slackowneruserid", "", "Slack owner user id.")
 72 | 	flag.StringVar(&imgurID, "imgurid", "", "Imgur client id.")
 73 | 	flag.StringVar(&imgurAlbum, "imguralbum", "", "Imgur album id.")
 74 | 	flag.StringVar(&mashableKey, "mashablekey", "", "Mashable key.")
 75 | 	flag.StringVar(&carbonitexKey, "carbonitexkey", "", "Carbonitex key for discord server count tracking.")
 76 | 	flag.Parse()
 77 | 
 78 | 	rand.Seed(time.Now().UnixNano())
 79 | }
 80 | 
 81 | func main() {
 82 | 	q := make(chan bool)
 83 | 
 84 | 	// Set our variables.
 85 | 	bot := bruxism.NewBot()
 86 | 	bot.ImgurID = imgurID
 87 | 	bot.ImgurAlbum = imgurAlbum
 88 | 	bot.MashableKey = mashableKey
 89 | 
 90 | 	// Generally CommandPlugins don't hold state, so we share one instance of the command plugin for all services.
 91 | 	cp := bruxism.NewCommandPlugin()
 92 | 	cp.AddCommand("invite", inviteplugin.InviteCommand, inviteplugin.InviteHelp)
 93 | 	cp.AddCommand("join", inviteplugin.InviteCommand, nil)
 94 | 	cp.AddCommand("stats", statsplugin.StatsCommand, statsplugin.StatsHelp)
 95 | 	cp.AddCommand("info", statsplugin.StatsCommand, nil)
 96 | 	cp.AddCommand("stat", statsplugin.StatsCommand, nil)
 97 | 	if bot.MashableKey != "" {
 98 | 		cp.AddCommand("numbertrivia", numbertriviaplugin.NumberTriviaCommand, numbertriviaplugin.NumberTriviaHelp)
 99 | 	}
100 | 	cp.AddCommand("quit", func(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, args string, parts []string) {
101 | 		if service.IsBotOwner(message) {
102 | 			q <- true
103 | 		}
104 | 	}, nil)
105 | 
106 | 	youtube := bruxism.NewYouTube(youtubeURL, youtubeAuth, youtubeConfigFilename, youtubeTokenFilename)
107 | 	err := youtube.Init()
108 | 	if err != nil {
109 | 		log.Fatal(err)
110 | 	}
111 | 
112 | 	ytLiveChannel := bruxism.NewYTLiveChannel(youtube.Service)
113 | 	ytip := youtubejoinplugin.New(ytLiveChannel)
114 | 
115 | 	bot.RegisterService(youtube)
116 | 
117 | 	bot.RegisterPlugin(youtube, cp)
118 | 
119 | 	bot.RegisterPlugin(youtube, chartplugin.New())
120 | 	bot.RegisterPlugin(youtube, liveplugin.New(ytLiveChannel))
121 | 	bot.RegisterPlugin(youtube, reminderplugin.New())
122 | 	bot.RegisterPlugin(youtube, streamerplugin.New(youtube))
123 | 	bot.RegisterPlugin(youtube, topstreamersplugin.New(youtube))
124 | 	bot.RegisterPlugin(youtube, triviaplugin.New())
125 | 	bot.RegisterPlugin(youtube, ytip)
126 | 
127 | 	// Register the Discord service if we have an email or token.
128 | 	if (discordEmail != "" && discordPassword != "") || discordToken != "" {
129 | 		var discord *bruxism.Discord
130 | 		if discordToken != "" {
131 | 			discord = bruxism.NewDiscord(discordToken)
132 | 		} else {
133 | 			discord = bruxism.NewDiscord(discordEmail, discordPassword)
134 | 		}
135 | 		discord.ApplicationClientID = discordApplicationClientID
136 | 		discord.OwnerUserID = discordOwnerUserID
137 | 		bot.RegisterService(discord)
138 | 
139 | 		bot.RegisterPlugin(discord, cp)
140 | 
141 | 		if carbonitexKey != "" {
142 | 			bot.RegisterPlugin(discord, carbonitexplugin.New(carbonitexKey))
143 | 		}
144 | 
145 | 		bot.RegisterPlugin(discord, chartplugin.New())
146 | 		bot.RegisterPlugin(discord, discordavatarplugin.New())
147 | 		bot.RegisterPlugin(discord, emojiplugin.New())
148 | 		bot.RegisterPlugin(discord, liveplugin.New(ytLiveChannel))
149 | 		bot.RegisterPlugin(discord, musicplugin.New(discord))
150 | 		bot.RegisterPlugin(discord, mysonplugin.New())
151 | 		bot.RegisterPlugin(discord, playedplugin.New())
152 | 		bot.RegisterPlugin(discord, playingplugin.New())
153 | 		bot.RegisterPlugin(discord, reminderplugin.New())
154 | 		bot.RegisterPlugin(discord, streamerplugin.New(youtube))
155 | 		bot.RegisterPlugin(discord, topstreamersplugin.New(youtube))
156 | 		bot.RegisterPlugin(discord, triviaplugin.New())
157 | 	}
158 | 
159 | 	// Register the IRC service if we have an IRC server and username.
160 | 	if ircServer != "" && ircUsername != "" {
161 | 		irc := bruxism.NewIRC(ircServer, ircUsername, ircPassword, strings.Split(ircChannels, ","))
162 | 		bot.RegisterService(irc)
163 | 
164 | 		bot.RegisterPlugin(irc, cp)
165 | 
166 | 		bot.RegisterPlugin(irc, chartplugin.New())
167 | 		bot.RegisterPlugin(irc, liveplugin.New(ytLiveChannel))
168 | 		bot.RegisterPlugin(irc, reminderplugin.New())
169 | 		bot.RegisterPlugin(irc, streamerplugin.New(youtube))
170 | 		bot.RegisterPlugin(irc, topstreamersplugin.New(youtube))
171 | 		bot.RegisterPlugin(irc, triviaplugin.New())
172 | 	}
173 | 
174 | 	// Register the Slack service if we have a Slack token.
175 | 	if slackToken != "" {
176 | 		slack := bruxism.NewSlack(slackToken)
177 | 		slack.OwnerUserID = slackOwnerUserID
178 | 		bot.RegisterService(slack)
179 | 
180 | 		bot.RegisterPlugin(slack, cp)
181 | 
182 | 		bot.RegisterPlugin(slack, chartplugin.New())
183 | 
184 | 		bot.RegisterPlugin(slack, liveplugin.New(ytLiveChannel))
185 | 		bot.RegisterPlugin(slack, streamerplugin.New(youtube))
186 | 		bot.RegisterPlugin(slack, topstreamersplugin.New(youtube))
187 | 		bot.RegisterPlugin(slack, triviaplugin.New())
188 | 	}
189 | 
190 | 	// Start all our services.
191 | 	bot.Open()
192 | 
193 | 	// Monitor all the youtube channel arguments.
194 | 	// This will cause the youtubejoin plugin to join any live streams on those channels.
195 | 	if youtubeChannelIDs != "" {
196 | 		channelIDs := strings.Split(youtubeChannelIDs, ",")
197 | 		for _, channelID := range channelIDs {
198 | 			ytip.Monitor(channelID)
199 | 		}
200 | 	}
201 | 
202 | 	// Wait for a termination signal, while saving the bot state every minute. Save on close.
203 | 	c := make(chan os.Signal, 1)
204 | 	signal.Notify(c, os.Interrupt, os.Kill)
205 | 
206 | 	t := time.Tick(1 * time.Minute)
207 | 
208 | out:
209 | 	for {
210 | 		select {
211 | 		case <-q:
212 | 			break out
213 | 		case <-c:
214 | 			break out
215 | 		case <-t:
216 | 			bot.Save()
217 | 		}
218 | 	}
219 | 
220 | 	bot.Save()
221 | }
222 | 


--------------------------------------------------------------------------------
/comicplugin/comicplugin.go:
--------------------------------------------------------------------------------
  1 | package comicplugin
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"encoding/json"
  6 | 	"errors"
  7 | 	"fmt"
  8 | 	"image/png"
  9 | 	"log"
 10 | 	"math"
 11 | 	"math/rand"
 12 | 	"regexp"
 13 | 	"strconv"
 14 | 	"strings"
 15 | 	"sync"
 16 | 	"time"
 17 | 
 18 | 	"github.com/bwmarrin/discordgo"
 19 | 	"github.com/dustin/go-humanize"
 20 | 	"github.com/iopred/bruxism"
 21 | 	"github.com/iopred/comicgen"
 22 | )
 23 | 
 24 | const MAX_CHATLOG_SIZE = 100
 25 | 
 26 | var comicEmoji = "<:comic:701265673707454494>"
 27 | var urinalEmoji = "<:urinal:701279094402318387>"
 28 | 
 29 | type comicPlugin struct {
 30 | 	sync.Mutex
 31 | 
 32 | 	bruxism.SimplePlugin
 33 | 	log      map[string][]bruxism.Message
 34 | 	cooldown map[string]time.Time
 35 | 	Comics   int
 36 | 	Public   map[string]bool
 37 | }
 38 | 
 39 | // Load will load plugin state from a byte array.
 40 | func (p *comicPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
 41 | 	if data != nil {
 42 | 		if err := json.Unmarshal(data, p); err != nil {
 43 | 			log.Println("Error loading data", err)
 44 | 		}
 45 | 	}
 46 | 
 47 | 	p.cooldown = map[string]time.Time{}
 48 | 	if p.Public == nil {
 49 | 		p.Public = map[string]bool{}
 50 | 	}
 51 | 
 52 | 	return nil
 53 | }
 54 | 
 55 | // Save will save plugin state to a byte array.
 56 | func (p *comicPlugin) Save() ([]byte, error) {
 57 | 	return json.Marshal(p)
 58 | }
 59 | 
 60 | // Help returns a list of help strings that are printed when the user requests them.
 61 | func (p *comicPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 62 | 	help := bruxism.CommandHelp(service, "comic", "[1-10]", "Creates a comic from recent messages, or a number of messages if provided. eg: comic 3")
 63 | 
 64 | 	ticks := ""
 65 | 	if service.Name() == bruxism.DiscordServiceName {
 66 | 		ticks = "`"
 67 | 	}
 68 | 	if detailed {
 69 | 		help = append(help, []string{
 70 | 			bruxism.CommandHelp(service, "customcomic", "[id|name:] <text> | [id|name:] <text>", fmt.Sprintf("Creates a custom comic. Available names: %s%s%s", ticks, comicgen.CharacterNames(), ticks))[0],
 71 | 			bruxism.CommandHelp(service, "customcomicsimple", "[id:] <text> | [id:] <text>", "Creates a simple custom comic.")[0],
 72 | 		}...)
 73 | 
 74 | 		if service.Name() == bruxism.DiscordServiceName && service.IsChannelOwner(message) {
 75 | 			help = append(help, []string{
 76 | 				bruxism.CommandHelp(service, "comicpublic", "", "Makes comics in this server public.")[0],
 77 | 				bruxism.CommandHelp(service, "comicprivate", "", "Makes comics in this server private (default).")[0],
 78 | 			}...)
 79 | 		}
 80 | 
 81 | 		help = append(help, []string{
 82 | 			"Examples:",
 83 | 			bruxism.CommandHelp(service, "comic", "5", "Creates a comic from the last 5 messages")[0],
 84 | 			bruxism.CommandHelp(service, "customcomic", "A | B | C", "Creates a comic with 3 lines.")[0],
 85 | 			bruxism.CommandHelp(service, "customcomic", "0: Hi! | 1: Hello! | 0: Goodbye.", "Creates a comic with 3 lines, the second line spoken by a different character")[0],
 86 | 			bruxism.CommandHelp(service, "customcomic", "tiki: Hi! | jordy: Hello! | tiki: Goodbye.", "Creates a comic with 3 lines, containing tiki and jordy.")[0],
 87 | 			bruxism.CommandHelp(service, "customcomicsimple", "0: Foo | 1: Bar", "Creates a comic with 2 lines, both spoken by different characters.")[0],
 88 | 		}...)
 89 | 	}
 90 | 
 91 | 	return help
 92 | }
 93 | 
 94 | var emojiRegexp = regexp.MustCompile("<a?:[a-zA-Z0-9]+:([0-9]+)>")
 95 | var imageRegexp = regexp.MustCompile("^(http(s?):)([/|.|\\w|\\s|-])*\\.(?:jpg|jpeg|gif|png)($|\\?\\S*$)")
 96 | 
 97 | func makeScriptFromMessages(service bruxism.Service, message bruxism.Message, messages []bruxism.Message, room string) *comicgen.Script {
 98 | 	avatars := make(map[string]string)
 99 | 	script := []*comicgen.Message{}
100 | 	for _, message := range messages {
101 | 		avatars[message.UserName()] = message.UserAvatar()
102 | 		replacements := map[string]string{}
103 | 		messageMessage := message.Message()
104 | 		matches := emojiRegexp.FindAllStringSubmatch(messageMessage, -1)
105 | 		for _, match := range matches {
106 | 			if _, ok := replacements[match[0]]; !ok {
107 | 				replacements[match[0]] = discordgo.EndpointEmoji(match[1])
108 | 			}
109 | 		}
110 | 
111 | 		imageUrl := ""
112 | 		if imageRegexp.MatchString(messageMessage) {
113 | 			imageUrl = messageMessage
114 | 			messageMessage = ""
115 | 		}
116 | 
117 | 		if dm, ok := message.(*bruxism.DiscordMessage); ok {
118 | 			at := dm.AttachmentURL()
119 | 			if at != "" {
120 | 				imageUrl = at
121 | 			}
122 | 		}
123 | 
124 | 		script = append(script, &comicgen.Message{
125 | 			Text:         messageMessage,
126 | 			Author:       message.UserName(),
127 | 			Replacements: replacements,
128 | 			ImageUrl:	  imageUrl,
129 | 		})
130 | 	}
131 | 	return &comicgen.Script{
132 | 		Messages: script,
133 | 		Author:   fmt.Sprintf(service.UserName()),
134 | 		Avatars:  avatars,
135 | 		Type:     comicgen.ComicTypeChat,
136 | 		Room:	  room,
137 | 	}
138 | }
139 | 
140 | func (p *comicPlugin) makeComic(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, globalID string, script *comicgen.Script) {
141 | 	p.Comics++
142 | 	comic := comicgen.NewComicGen("arial", service.Name() != bruxism.DiscordServiceName)
143 | 	image, err := comic.MakeComic(script)
144 | 	if err != nil {
145 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was an error creating the comic. %s", message.UserName(), err))
146 | 	} else {
147 | 		go func() {
148 | 			if service.Name() == bruxism.DiscordServiceName {
149 | 				discord := service.(*bruxism.Discord)
150 | 				pe, err := discord.UserChannelPermissions(service.UserID(), message.Channel())
151 | 				if err == nil && pe&discordgo.PermissionAttachFiles != 0 {
152 | 					b := &bytes.Buffer{}
153 | 					err = png.Encode(b, image)
154 | 					if err != nil {
155 | 						service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your comic.", message.UserName()))
156 | 						return
157 | 					}
158 | 
159 | 					m, err := discord.Session.ChannelFileSend(message.Channel(), "comic.png", b)
160 | 					if err == nil {
161 | 						if p.Public[globalID] && len(m.Attachments) > 0 {
162 | 							service.SendMessage("367871992503730176", m.Attachments[0].URL)
163 | 						}
164 | 						p.log[message.Channel()] = nil
165 | 						return
166 | 					}
167 | 				}
168 | 			}
169 | 
170 | 			b := &bytes.Buffer{}
171 | 			err = png.Encode(b, image)
172 | 			if err != nil {
173 | 				service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your comic.", message.UserName()))
174 | 				return
175 | 			}
176 | 
177 | 			url, err := bot.UploadToImgur(b, "comic.png")
178 | 			if err != nil {
179 | 				service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem uploading the comic to imgur.", message.UserName()))
180 | 				log.Println("Error uploading comic: ", err)
181 | 				return
182 | 			}
183 | 
184 | 			if service.Name() == bruxism.DiscordServiceName {
185 | 				service.SendMessage(message.Channel(), fmt.Sprintf("Here's your comic <@%s>: %s", message.UserID(), url))
186 | 			} else {
187 | 				service.SendMessage(message.Channel(), fmt.Sprintf("Here's your comic %s: %s", message.UserName(), url))
188 | 			}
189 | 
190 | 			if p.Public[globalID] && service.Name() == bruxism.DiscordServiceName {
191 | 				service.SendMessage("367871992503730176", url)
192 | 			}
193 | 			p.log[message.Channel()] = nil
194 | 		}()
195 | 	}
196 | }
197 | 
198 | func (p *comicPlugin) checkCooldown(service bruxism.Service, message bruxism.Message) bool {
199 | 	cooldown := p.cooldown[message.UserID()]
200 | 	if cooldown.After(time.Now()) {
201 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, you need to wait %s before creating another comic.", message.UserName(), humanize.Time(cooldown)))
202 | 		return true
203 | 	}
204 | 	p.cooldown[message.UserID()] = time.Now().Add(10 * time.Second)
205 | 	return false
206 | }
207 | 
208 | // Message handler.
209 | func (p *comicPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
210 | 	defer bruxism.MessageRecover()
211 | 
212 | 	if service.IsMe(message) {
213 | 		return
214 | 	}
215 | 
216 | 	p.Lock()
217 | 	defer p.Unlock()
218 | 
219 | 	log, ok := p.log[message.Channel()]
220 | 	if !ok {
221 | 		log = []bruxism.Message{}
222 | 	}
223 | 
224 | 	globalID := message.Channel()
225 | 	if discord, ok := service.(*bruxism.Discord); ok {
226 | 		channel, err := discord.Channel(globalID)
227 | 		if err == nil {
228 | 			globalID = channel.GuildID
229 | 		}
230 | 	}
231 | 
232 | 	emoji, ok := message.MatchesCommand("", comicEmoji)
233 | 	if !ok {
234 | 		emoji = false
235 | 	}
236 | 
237 | 	urinal, ok := message.MatchesCommand("", urinalEmoji)
238 | 	if !ok {
239 | 		urinal = false
240 | 	}
241 | 	
242 | 	messageHistory := false
243 | 	if service.Name() == bruxism.DiscordServiceName {
244 | 		pe, err := service.(*bruxism.Discord).UserChannelPermissions(service.UserID(), message.Channel())
245 | 		if err == nil && pe&discordgo.PermissionReadMessageHistory != 0 {
246 | 			messageHistory = true
247 | 		}
248 | 	}
249 | 
250 | 	if service.Name() == bruxism.DiscordServiceName && bruxism.MatchesCommand(service, "comicpublic", message) && service.IsChannelOwner(message) {
251 | 		p.Public[globalID] = true
252 | 		service.SendMessage(message.Channel(), "Comics are now public. Visit https://discord.gg/HWN9pwj to see them all.")
253 | 	} else if service.Name() == bruxism.DiscordServiceName && bruxism.MatchesCommand(service, "comicprivate", message) && service.IsChannelOwner(message) {
254 | 		delete(p.Public, globalID)
255 | 		service.SendMessage(message.Channel(), "Comics are no longer public.")
256 | 	} else if bruxism.MatchesCommand(service, "customcomic", message) || bruxism.MatchesCommand(service, "customcomicsimple", message) {
257 | 
258 | 		ty := comicgen.ComicTypeChat
259 | 		if bruxism.MatchesCommand(service, "customcomicsimple", message) {
260 | 			ty = comicgen.ComicTypeSimple
261 | 		}
262 | 
263 | 		service.Typing(message.Channel())
264 | 
265 | 		messages, err := p.MessagesFromChatlog(service, message)
266 | 
267 | 		if err != nil {
268 | 			service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, that didn't work because: %s", message.UserName(), err.Error()))
269 | 			return
270 | 		}
271 | 
272 | 		// Check for cooldown.
273 | 		if messages == nil {
274 | 			return
275 | 		}
276 | 
277 | 		p.makeComic(bot, service, message, globalID, &comicgen.Script{
278 | 			Messages: messages,
279 | 			Author:   fmt.Sprintf(service.UserName()),
280 | 			Type:     ty,
281 | 		})
282 | 	} else if bruxism.MatchesCommand(service, "comic", message) || emoji || urinal {
283 | 		if !messageHistory && len(log) == 0 {
284 | 			service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, I don't have enough messages to make a comic yet.", message.UserName()))
285 | 			return
286 | 		}
287 | 
288 | 		if p.checkCooldown(service, message) {
289 | 			return
290 | 		}
291 | 		service.Typing(message.Channel())
292 | 
293 | 		lines := 0
294 | 		
295 | 		_, parts := bruxism.ParseCommand(service, message)
296 | 
297 | 		if emoji || urinal {
298 | 			_ , parts, _ = message.ParseCommand("")
299 | 		}
300 | 
301 | 		if len(parts) > 0 {
302 | 			lines, _ = strconv.Atoi(parts[0])
303 | 		}
304 | 
305 | 		if lines <= 0 {
306 | 			lines = 1 + int(math.Floor((math.Pow(2*rand.Float64()-1, 3)/2+0.5)*float64(5)))
307 | 		}
308 | 
309 | 		var messages []bruxism.Message
310 | 		if !messageHistory && len(log) != 0 {
311 | 			if lines > len(log) {
312 | 				lines = len(log)
313 | 			}
314 | 			messages = log[len(log)-lines:]
315 | 		} else {
316 | 			if lines > 10 {
317 | 				lines = 10
318 | 			}
319 | 			if discord, ok := service.(*bruxism.Discord); ok {
320 | 				ms, err := discord.Session.ChannelMessages(message.Channel(), lines, message.MessageID(), "", "")
321 | 				if err != nil {
322 | 					service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was an error creating the comic.", message.UserName()))
323 | 					return
324 | 				}
325 | 				if len(ms) < lines {
326 | 					lines = len(ms)
327 | 				}
328 | 				messages = make([]bruxism.Message, lines)
329 | 				for i := 0; i < lines; i++ {
330 | 					messages[lines - i - 1] = &bruxism.DiscordMessage{
331 | 						Discord:          discord,
332 | 						DiscordgoMessage: ms[i],
333 | 						MessageType:      bruxism.MessageTypeCreate,
334 | 					}
335 | 				}
336 | 			} 
337 | 		}
338 | 
339 | 		room := ""
340 | 		for _, u := range parts {
341 | 			u = strings.ToLower(u)
342 | 			if u == "urinal" || u == "toilet" {
343 | 				urinal = true
344 | 			}
345 | 		}
346 | 
347 | 		if urinal {
348 | 			room = "rooms/urinal.png"
349 | 		}
350 | 
351 | 		p.makeComic(bot, service, message, globalID, makeScriptFromMessages(service, message, messages, room))
352 | 	} else {
353 | 		if messageHistory {
354 | 			return
355 | 		}
356 | 		switch message.Type() {
357 | 		case bruxism.MessageTypeCreate:
358 | 			if len(log) < 10 {
359 | 				log = append(log, message)
360 | 			} else {
361 | 				log = append(log[1:], message)
362 | 			}
363 | 		case bruxism.MessageTypeUpdate:
364 | 			for i, m := range log {
365 | 				if m.MessageID() == message.MessageID() {
366 | 					log[i] = message
367 | 					break
368 | 				}
369 | 			}
370 | 		case bruxism.MessageTypeDelete:
371 | 			for i, m := range log {
372 | 				if m.MessageID() == message.MessageID() {
373 | 					log = append(log[:i], log[i+1:]...)
374 | 					break
375 | 				}
376 | 			}
377 | 		}
378 | 		p.log[message.Channel()] = log
379 | 	}
380 | }
381 | 
382 | func (p *comicPlugin) MessagesFromChatlog(service bruxism.Service, message bruxism.Message) ([]*comicgen.Message, error) {
383 | 	str, _ := bruxism.ParseCommand(service, message)
384 | 
385 | 	splits := strings.Split(str, "|")
386 | 	if len(splits) == 0 || (len(splits) == 1 && len(splits[0]) == 0) {
387 | 		return nil, errors.New("you didn't add any text.")
388 | 	}
389 | 	
390 | 	if p.checkCooldown(service, message) {
391 | 		return nil, nil
392 | 	}
393 | 	
394 | 	if len(splits) > MAX_CHATLOG_SIZE {
395 | 		splits = splits[:MAX_CHATLOG_SIZE]
396 | 	}
397 | 
398 | 	messages := []*comicgen.Message{}
399 | 
400 | 	authorIndex := 0
401 | 	for _, line := range splits {
402 | 		line := strings.Trim(line, " ")
403 | 
404 | 		text := ""
405 | 		author := ""
406 | 		if strings.Index(line, ":") != -1 {
407 | 			lineSplit := strings.Split(line, ":")
408 | 			author = strings.Trim(lineSplit[0], " ")
409 | 			text = strings.Trim(strings.Join(lineSplit[1:], ":"), " ")
410 | 		} else {
411 | 			authorIndex++
412 | 			author = strconv.Itoa(authorIndex)
413 | 			text = line
414 | 		}
415 | 
416 | 		messages = append(messages, &comicgen.Message{
417 | 			Text:    text,
418 | 			Author:  author,
419 | 		})
420 | 	}
421 | 
422 | 	return messages, nil
423 | }
424 | 
425 | // Name returns the name of the plugin.
426 | func (p *comicPlugin) Name() string {
427 | 	return "Comic"
428 | }
429 | 
430 | // Stats will return the stats for a plugin.
431 | func (p *comicPlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
432 | 	return []string{fmt.Sprintf("Comics created: \t%s\n", humanize.Comma(int64(p.Comics)))}
433 | }
434 | 
435 | // New will create a new comic plugin.
436 | func New() bruxism.Plugin {
437 | 	return &comicPlugin{
438 | 		log: make(map[string][]bruxism.Message),
439 | 	}
440 | }
441 | 


--------------------------------------------------------------------------------
/comicplugin/comicplugin_test.go:
--------------------------------------------------------------------------------
 1 | package comicplugin
 2 | 
 3 | import (
 4 | 	"github.com/iopred/bruxism"
 5 | 	"testing"
 6 | 	// "time"
 7 | )
 8 | 
 9 | 
10 | // func TestComicPlugin(t *testing.T) {
11 | // 	c := New()
12 | 
13 | // 	b := bruxism.NewBot()
14 | // 	s := bruxism.NewMockService().SetName("discord").SetUserID("32").SetUserName("Septapus")
15 | 	
16 | // 	b.RegisterService(s)
17 | // 	b.RegisterPlugin(s, c)
18 | // 	b.Open()
19 | 
20 | // 	s.NewMessage(bruxism.NewMockMessage().SetMessage("@Septapus customcomicsimple jordy: hello | xeno: hi!").SetUserName("James").SetUserID("0").SetChannel("#lgv"))
21 | 	
22 | // 	time.Sleep(1 * time.Second)	
23 | // }
24 | 
25 | func TestMessagesFromChatlog(t *testing.T) {
26 | 	c := &comicPlugin{
27 | 		log: make(map[string][]bruxism.Message),
28 | 	}
29 | 
30 | 	b := bruxism.NewBot()
31 | 	s := bruxism.NewMockService().SetName("discord").SetUserID("32").SetUserName("Septapus")
32 | 	
33 | 	b.RegisterService(s)
34 | 	b.RegisterPlugin(s, c)
35 | 	b.Open()
36 | 
37 | 	messages, err := c.MessagesFromChatlog(s, bruxism.NewMockMessage().SetMessage("customcomicsimple   jordy:    hello    |   xeno:   hi! ").SetUserName("James").SetUserID("0").SetChannel("#lgv"))
38 | 	if err != nil {
39 | 		t.Fatal(err)
40 | 	}
41 | 
42 | 	type messageTest struct {
43 |         author string
44 |         text   string
45 | 	}
46 | 
47 | 	var messageTests = []messageTest {
48 | 	    {"jordy", "hello"}, {"xeno", "hi!"},
49 | 	}
50 | 
51 | 
52 | 	if len(messageTests) != len(messages) {
53 | 		t.Errorf("mismatched lengths: expected: %d, actual %d", len(messageTests), len(messages))
54 | 	}
55 | 
56 | 	for i, mt := range messageTests {
57 |         if mt.author != messages[i].Author {
58 |         	t.Errorf("Author: expected: %s, actual %s", mt.author, messages[i].Author)
59 |         }
60 |         if mt.text != messages[i].Text {
61 |         	t.Errorf("Text: expected: %s, actual %s", mt.text, messages[i].Text)
62 |         }
63 |     }
64 | }


--------------------------------------------------------------------------------
/commandplugin.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"strings"
  6 | )
  7 | 
  8 | const commandDelimeter = "!"
  9 | 
 10 | // CommandHelpFunc is the function signature for command help methods.
 11 | type CommandHelpFunc func(bot *Bot, service Service, message Message) (string, string)
 12 | 
 13 | // CommandMessageFunc is the function signature for bot message commands.
 14 | type CommandMessageFunc func(bot *Bot, service Service, message Message, args string, parts []string)
 15 | 
 16 | // NewCommandHelp creates a new Command Help function.
 17 | func NewCommandHelp(args, help string) CommandHelpFunc {
 18 | 	return func(bot *Bot, service Service, message Message) (string, string) {
 19 | 		return args, help
 20 | 	}
 21 | }
 22 | 
 23 | // MatchesCommandStringPrefix returns true if a message matches a command.
 24 | // Commands will be matched ignoring case with a prefix if they are not private messages.
 25 | func MatchesCommandStringPrefix(prefix, commandString string, private bool, message string) bool {
 26 | 	lowerMessage := strings.ToLower(strings.TrimSpace(message))
 27 | 	lowerPrefix := strings.ToLower(prefix)
 28 | 
 29 | 	if strings.HasPrefix(lowerMessage, lowerPrefix) {
 30 | 		lowerMessage = lowerMessage[len(lowerPrefix):]
 31 | 	} else if !private {
 32 | 		return false
 33 | 	}
 34 | 
 35 | 	lowerMessage = strings.TrimSpace(lowerMessage)
 36 | 	lowerCommand := strings.ToLower(commandString)
 37 | 
 38 | 	return lowerMessage == lowerCommand || strings.HasPrefix(lowerMessage, lowerCommand+" ")
 39 | }
 40 | 
 41 | // MatchesCommand returns true if a message matches a command.
 42 | func MatchesCommand(service Service, commandString string, message Message) bool {
 43 | 	// Deleted messages can't trigger commands.
 44 | 	if message.Type() == MessageTypeDelete {
 45 | 		return false
 46 | 	}
 47 | 
 48 | 	prefix := service.CommandPrefix()
 49 | 	private := service.IsPrivate(message)
 50 | 
 51 | 	if !private {
 52 | 		if matches, ok := message.MatchesCommand(prefix, commandString); ok {
 53 | 			return matches
 54 | 		}
 55 | 	}
 56 | 
 57 | 	return MatchesCommandStringPrefix(prefix, commandString, private, message.Message())
 58 | }
 59 | 
 60 | // ParseCommandStringPrefix will strip all prefixes from a message string, and return that string, and a space separated tokenized version of that string.
 61 | func ParseCommandStringPrefix(prefix, message string) (string, []string) {
 62 | 	message = strings.TrimSpace(message)
 63 | 
 64 | 	lowerMessage := strings.ToLower(message)
 65 | 	lowerPrefix := strings.ToLower(prefix)
 66 | 
 67 | 	if strings.HasPrefix(lowerMessage, lowerPrefix) {
 68 | 		message = message[len(lowerPrefix):]
 69 | 	}
 70 | 	parts := strings.Fields(message)
 71 | 
 72 | 	if len(parts) > 1 {
 73 | 		parts = parts[1:]
 74 | 		return strings.Join(parts, " "), parts
 75 | 	}
 76 | 	return "", []string{}
 77 | }
 78 | 
 79 | // ParseCommand parses a message.
 80 | func ParseCommand(service Service, message Message) (string, []string) {
 81 | 	if rest, parts, ok := message.ParseCommand(service.CommandPrefix()); ok {
 82 | 		return rest, parts
 83 | 	}
 84 | 	return ParseCommandStringPrefix(service.CommandPrefix(), message.Message())
 85 | }
 86 | 
 87 | // CommandHelp is a helper message that creates help text for a command.
 88 | // eg. CommandHelp(service, "foo", "<bar>", "Foo bar baz") will return:
 89 | //     !foo <bar> - Foo bar baz
 90 | // The string is automatatically styled in Discord.
 91 | func CommandHelp(service Service, command, arguments, help string) []string {
 92 | 	ticks := ""
 93 | 	if service.Name() == DiscordServiceName {
 94 | 		ticks = "`"
 95 | 	}
 96 | 
 97 | 	if arguments != "" {
 98 | 		return []string{fmt.Sprintf("%s%s%s %s%s - %s", ticks, service.CommandPrefix(), command, arguments, ticks, help)}
 99 | 	}
100 | 	return []string{fmt.Sprintf("%s%s%s%s - %s", ticks, service.CommandPrefix(), command, ticks, help)}
101 | }
102 | 
103 | type command struct {
104 | 	message CommandMessageFunc
105 | 	help    CommandHelpFunc
106 | }
107 | 
108 | // CommandPlugin is a plugin that can have commands registered and will handle messages matching that command by calling functions.
109 | type CommandPlugin struct {
110 | 	commands map[string]*command
111 | }
112 | 
113 | // Name returns the name of the plugin.
114 | func (p *CommandPlugin) Name() string {
115 | 	return "Command"
116 | }
117 | 
118 | // Load will load plugin state from a byte array.
119 | func (p *CommandPlugin) Load(bot *Bot, service Service, data []byte) error {
120 | 	// TODO: Add a generic data store backed by json.
121 | 	return nil
122 | }
123 | 
124 | // Save will save plugin state to a byte array.
125 | func (p *CommandPlugin) Save() ([]byte, error) {
126 | 	// TODO: Add a generic data store backed by json.
127 | 	return nil, nil
128 | }
129 | 
130 | // Help returns a list of help strings that are printed when the user requests them.
131 | func (p *CommandPlugin) Help(bot *Bot, service Service, message Message, detailed bool) []string {
132 | 	if detailed {
133 | 		return nil
134 | 	}
135 | 	help := []string{}
136 | 	for commandString, command := range p.commands {
137 | 		if command.help != nil {
138 | 			arguments, h := command.help(bot, service, message)
139 | 			help = append(help, CommandHelp(service, commandString, arguments, h)...)
140 | 		}
141 | 	}
142 | 	return help
143 | }
144 | 
145 | // Message handler.
146 | // Iterates over the registered commands and executes them if the message matches.
147 | func (p *CommandPlugin) Message(bot *Bot, service Service, message Message) {
148 | 	defer MessageRecover()
149 | 	if !service.IsMe(message) {
150 | 		for commandString, command := range p.commands {
151 | 			if MatchesCommand(service, commandString, message) {
152 | 				args, parts := ParseCommand(service, message)
153 | 				command.message(bot, service, message, args, parts)
154 | 				return
155 | 			}
156 | 		}
157 | 	}
158 | }
159 | 
160 | // AddCommand adds a command.
161 | func (p *CommandPlugin) AddCommand(commandString string, message CommandMessageFunc, help CommandHelpFunc) {
162 | 	p.commands[commandString] = &command{
163 | 		message: message,
164 | 		help:    help,
165 | 	}
166 | }
167 | 
168 | // Stats will return the stats for a plugin.
169 | func (p *CommandPlugin) Stats(bot *Bot, service Service, message Message) []string {
170 | 	return nil
171 | }
172 | 
173 | // NewCommandPlugin will create a new command plugin.
174 | func NewCommandPlugin() *CommandPlugin {
175 | 	return &CommandPlugin{make(map[string]*command)}
176 | }
177 | 


--------------------------------------------------------------------------------
/discord.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"fmt"
  6 | 	"io"
  7 | 	"log"
  8 | 	"regexp"
  9 | 	"strings"
 10 | 	"sync"
 11 | 
 12 | 	"github.com/bwmarrin/discordgo"
 13 | )
 14 | 
 15 | // The number of guilds supported by one shard.
 16 | const numGuildsPerShard = 2400
 17 | 
 18 | // DiscordServiceName is the service name for the Discord service.
 19 | const DiscordServiceName string = "Discord"
 20 | 
 21 | type ParsedCommand struct {
 22 | 	Matches bool
 23 | 	Command string
 24 | 	Rest    string
 25 | 	Parts   []string
 26 | }
 27 | 
 28 | // DiscordMessage is a Message wrapper around discordgo.Message.
 29 | type DiscordMessage struct {
 30 | 	sync.RWMutex
 31 | 	Discord          *Discord
 32 | 	DiscordgoMessage *discordgo.Message
 33 | 	MessageType      MessageType
 34 | 	Nick             *string
 35 | 	Content          *string
 36 | 	parsedCommands   map[string]*ParsedCommand
 37 | }
 38 | 
 39 | // Channel returns the channel id for this message.
 40 | func (m *DiscordMessage) Channel() string {
 41 | 	return m.DiscordgoMessage.ChannelID
 42 | }
 43 | 
 44 | // UserName returns the user name for this message.
 45 | func (m *DiscordMessage) UserName() string {
 46 | 	if m.Nick == nil {
 47 | 		n := m.Discord.Nickname(m)
 48 | 		m.Nick = &n
 49 | 	}
 50 | 	return *m.Nick
 51 | }
 52 | 
 53 | // UserID returns the user id for this message.
 54 | func (m *DiscordMessage) UserID() string {
 55 | 	if m.DiscordgoMessage.Author == nil {
 56 | 		return ""
 57 | 	}
 58 | 
 59 | 	return m.DiscordgoMessage.Author.ID
 60 | }
 61 | 
 62 | // UserAvatar returns the avatar url for this message.
 63 | func (m *DiscordMessage) UserAvatar() string {
 64 | 	if m.DiscordgoMessage.Author == nil {
 65 | 		return ""
 66 | 	}
 67 | 
 68 | 	return discordgo.EndpointUserAvatar(m.DiscordgoMessage.Author.ID, m.DiscordgoMessage.Author.Avatar)
 69 | }
 70 | 
 71 | // Message returns the message content for this message.
 72 | func (m *DiscordMessage) Message() string {
 73 | 	if m.Content == nil {
 74 | 		c := m.DiscordgoMessage.ContentWithMentionsReplaced()
 75 | 		c = m.Discord.replaceRoleNames(m.DiscordgoMessage, c)
 76 | 		c = m.Discord.replaceChannelNames(m.DiscordgoMessage, c)
 77 | 
 78 | 		if c == "" {
 79 | 			c = m.AttachmentURL()
 80 | 		}
 81 | 
 82 | 		m.Content = &c
 83 | 	}
 84 | 	return *m.Content
 85 | }
 86 | 
 87 | // RawMessage returns the raw message content for this message.
 88 | func (m *DiscordMessage) RawMessage() string {
 89 | 	return m.DiscordgoMessage.Content
 90 | }
 91 | 
 92 | // MessageID returns the message ID for this message.
 93 | func (m *DiscordMessage) MessageID() string {
 94 | 	return m.DiscordgoMessage.ID
 95 | }
 96 | 
 97 | // Type returns the type of message.
 98 | func (m *DiscordMessage) Type() MessageType {
 99 | 	return m.MessageType
100 | }
101 | 
102 | func (m *DiscordMessage) AttachmentURL() string {
103 | 	if len(m.DiscordgoMessage.Attachments) == 0 {
104 | 		return ""
105 | 	}
106 | 	a := m.DiscordgoMessage.Attachments[0]
107 | 	if a.ProxyURL != "" {
108 | 		if a.Width != 0 && a.Height != 0 {
109 | 			height := 100
110 | 			width := height * a.Width / a.Height
111 | 			if width > 200 {
112 | 				width = 200
113 | 				height = width * a.Height / a.Width
114 | 			}
115 | 			return fmt.Sprintf("%s?width=%d&height=%d", a.ProxyURL, width, height)
116 | 		}
117 | 		return a.ProxyURL
118 | 	} else if a.URL != "" {
119 | 		return a.URL
120 | 	}
121 | 	return ""
122 | }
123 | 
124 | func (m *DiscordMessage) AttachmentURLLarge() string {
125 | 	if len(m.DiscordgoMessage.Attachments) == 0 {
126 | 		return ""
127 | 	}
128 | 	a := m.DiscordgoMessage.Attachments[0]
129 | 	if a.ProxyURL != "" {
130 | 		return a.ProxyURL
131 | 	} else if a.URL != "" {
132 | 		return a.URL
133 | 	}
134 | 	return ""
135 | }
136 | 
137 | func (m *DiscordMessage) getParsedCommand(prefix string) (parsedCommand *ParsedCommand) {
138 | 	prefix = strings.ToLower(prefix)
139 | 
140 | 	m.Lock()
141 | 	defer m.Unlock()
142 | 
143 | 	if m.parsedCommands == nil {
144 | 		m.parsedCommands = map[string]*ParsedCommand{}
145 | 	} else {
146 | 		parsedCommand = m.parsedCommands[prefix]
147 | 		if parsedCommand != nil {
148 | 			return parsedCommand
149 | 		}
150 | 	}
151 | 
152 | 	parsedCommand = &ParsedCommand{}
153 | 	m.parsedCommands[prefix] = parsedCommand
154 | 
155 | 	trimmedPrefix := strings.ToLower(strings.TrimSpace(prefix))
156 | 	messageLower := strings.ToLower(strings.TrimSpace(m.Message()))
157 | 	if !strings.HasPrefix(messageLower, trimmedPrefix) {
158 | 		return
159 | 	}
160 | 	parsedCommand.Matches = true
161 | 
162 | 	parts := strings.Fields(m.Message())
163 | 	if len(parts) == 0 {
164 | 		return
165 | 	}
166 | 
167 | 	if len(trimmedPrefix) != len(prefix) {
168 | 		if len(parts) > 1 {
169 | 			parts = parts[1:]
170 | 		}
171 | 	} else {
172 | 		parts[0] = parts[0][len(prefix):]
173 | 	}
174 | 
175 | 	parsedCommand.Command = parts[0]
176 | 	if len(parts) > 1 {
177 | 		parsedCommand.Parts = parts[1:]
178 | 		parsedCommand.Rest = strings.Join(parsedCommand.Parts, " ")
179 | 	}
180 | 	return
181 | }
182 | 
183 | func (m *DiscordMessage) MatchesCommand(prefix, command string) (bool, bool) {
184 | 	parsedCommand := m.getParsedCommand(prefix)
185 | 	return parsedCommand.Matches && (command == "" || parsedCommand.Command == strings.ToLower(command)), true
186 | }
187 | 
188 | func (m *DiscordMessage) ParseCommand(prefix string) (string, []string, bool) {
189 | 	parsedCommand := m.getParsedCommand(prefix)
190 | 	return parsedCommand.Rest, parsedCommand.Parts, true
191 | }
192 | 
193 | // Discord is a Service provider for Discord.
194 | type Discord struct {
195 | 	args        []interface{}
196 | 	messageChan chan Message
197 | 
198 | 	// The first session, used to send messages (and maintain backwards compatibility).
199 | 	Session             *discordgo.Session
200 | 	Sessions            []*discordgo.Session
201 | 	OwnerUserID         string
202 | 	ApplicationClientID string
203 | }
204 | 
205 | // NewDiscord creates a new discord service.
206 | func NewDiscord(args ...interface{}) *Discord {
207 | 	return &Discord{
208 | 		args:        args,
209 | 		messageChan: make(chan Message, 200),
210 | 	}
211 | }
212 | 
213 | var channelIDRegex = regexp.MustCompile("<#[0-9]*>")
214 | 
215 | func (d *Discord) replaceChannelNames(message *discordgo.Message, content string) string {
216 | 	return channelIDRegex.ReplaceAllStringFunc(content, func(str string) string {
217 | 		c, err := d.Channel(str[2 : len(str)-1])
218 | 		if err != nil {
219 | 			return str
220 | 		}
221 | 
222 | 		return "#" + c.Name
223 | 	})
224 | }
225 | 
226 | var roleIDRegex = regexp.MustCompile("<@&[0-9]*>")
227 | 
228 | func (d *Discord) replaceRoleNames(message *discordgo.Message, content string) string {
229 | 	return roleIDRegex.ReplaceAllStringFunc(content, func(str string) string {
230 | 		roleID := str[3 : len(str)-1]
231 | 
232 | 		c, err := d.Channel(message.ChannelID)
233 | 		if err != nil {
234 | 			return str
235 | 		}
236 | 
237 | 		g, err := d.Guild(c.GuildID)
238 | 		if err != nil {
239 | 			return str
240 | 		}
241 | 
242 | 		for _, r := range g.Roles {
243 | 			if r.ID == roleID {
244 | 				return "@" + r.Name
245 | 			}
246 | 		}
247 | 
248 | 		return str
249 | 	})
250 | }
251 | 
252 | func (d *Discord) onMessageCreate(s *discordgo.Session, message *discordgo.MessageCreate) {
253 | 	if message.Author != nil && message.Author.Bot {
254 | 		return
255 | 	}
256 | 
257 | 	dm := &DiscordMessage{
258 | 		Discord:          d,
259 | 		DiscordgoMessage: message.Message,
260 | 		MessageType:      MessageTypeCreate,
261 | 	}
262 | 	if dm.Message() != "" {
263 | 		d.messageChan <- dm
264 | 	}
265 | }
266 | 
267 | func (d *Discord) onMessageUpdate(s *discordgo.Session, message *discordgo.MessageUpdate) {
268 | 	if message.Author != nil && message.Author.Bot {
269 | 		return
270 | 	}
271 | 
272 | 	dm := &DiscordMessage{
273 | 		Discord:          d,
274 | 		DiscordgoMessage: message.Message,
275 | 		MessageType:      MessageTypeUpdate,
276 | 	}
277 | 	if dm.Message() != "" {
278 | 		d.messageChan <- dm
279 | 	}
280 | }
281 | 
282 | func (d *Discord) onMessageDelete(s *discordgo.Session, message *discordgo.MessageDelete) {
283 | 	d.messageChan <- &DiscordMessage{
284 | 		Discord:          d,
285 | 		DiscordgoMessage: message.Message,
286 | 		MessageType:      MessageTypeDelete,
287 | 	}
288 | }
289 | 
290 | // Name returns the name of the service.
291 | func (d *Discord) Name() string {
292 | 	return DiscordServiceName
293 | }
294 | 
295 | // Open opens the service and returns a channel which all messages will be sent on.
296 | func (d *Discord) Open() (<-chan Message, error) {
297 | 	gateway, err := discordgo.New(d.args[0].(string))
298 | 	if err != nil {
299 | 		return nil, err
300 | 	}
301 | 
302 | 	s, err := gateway.GatewayBot()
303 | 	if err != nil {
304 | 		return nil, err
305 | 	}
306 | 
307 | 	d.Sessions = make([]*discordgo.Session, s.Shards)
308 | 
309 | 	log.Printf("%s opening with %d shards\n", d.Name(), s.Shards)
310 | 	wg := sync.WaitGroup{}
311 | 	for i := 0; i < s.Shards; i++ {
312 | 		log.Printf("%s opening shard %d\n", d.Name(), i+1)
313 | 		session, err := discordgo.New(d.args[0].(string))
314 | 		if err != nil {
315 | 			return nil, err
316 | 		}
317 | 		if d.Session == nil {
318 | 			d.Session = session
319 | 		}
320 | 		d.Sessions[i] = session
321 | 		session.ShardCount = s.Shards
322 | 		session.ShardID = i
323 | 		session.State.TrackPresences = false
324 | 		wg.Add(1)
325 | 		go func(session *discordgo.Session) {
326 | 			defer wg.Done()
327 | 			err := session.Open()
328 | 			if err != nil {
329 | 				log.Printf("error opening shard %s", err)
330 | 			}
331 | 		}(d.Sessions[i])
332 | 	}
333 | 	wg.Wait()
334 | 
335 | 	for _, session := range d.Sessions {
336 | 		session.AddHandler(d.onMessageCreate)
337 | 		session.AddHandler(d.onMessageUpdate)
338 | 		session.AddHandler(d.onMessageDelete)
339 | 	}
340 | 
341 | 	return d.messageChan, nil
342 | }
343 | 
344 | // IsMe returns whether or not a message was sent by the bot.
345 | func (d *Discord) IsMe(message Message) bool {
346 | 	if d.Session.State.User == nil {
347 | 		return false
348 | 	}
349 | 	return message.UserID() == d.Session.State.User.ID
350 | }
351 | 
352 | // SendMessage sends a message.
353 | func (d *Discord) SendMessage(channel, message string) error {
354 | 	if channel == "" {
355 | 		log.Println("Empty channel could not send message", message)
356 | 		return nil
357 | 	}
358 | 
359 | 	if _, err := d.Session.ChannelMessageSend(channel, message); err != nil {
360 | 		log.Println("Error sending discord message: ", err)
361 | 		return err
362 | 	}
363 | 
364 | 	return nil
365 | }
366 | 
367 | // SendAction sends an action.
368 | func (d *Discord) SendAction(channel, message string) error {
369 | 	if channel == "" {
370 | 		log.Println("Empty channel could not send message", message)
371 | 		return nil
372 | 	}
373 | 
374 | 	p, err := d.UserChannelPermissions(d.UserID(), channel)
375 | 	if err != nil {
376 | 		return d.SendMessage(channel, message)
377 | 	}
378 | 
379 | 	if p&discordgo.PermissionEmbedLinks == discordgo.PermissionEmbedLinks {
380 | 		if _, err := d.Session.ChannelMessageSendEmbed(channel, &discordgo.MessageEmbed{
381 | 			Color:       d.UserColor(d.UserID(), channel),
382 | 			Description: message,
383 | 		}); err != nil {
384 | 			return err
385 | 		}
386 | 		return nil
387 | 	}
388 | 
389 | 	return d.SendMessage(channel, message)
390 | }
391 | 
392 | // DeleteMessage deletes a message.
393 | func (d *Discord) DeleteMessage(channel, messageID string) error {
394 | 	return d.Session.ChannelMessageDelete(channel, messageID)
395 | }
396 | 
397 | // SendFile sends a file.
398 | func (d *Discord) SendFile(channel, name string, r io.Reader) error {
399 | 	if _, err := d.Session.ChannelFileSend(channel, name, r); err != nil {
400 | 		log.Println("Error sending discord message: ", err)
401 | 		return err
402 | 	}
403 | 	return nil
404 | }
405 | 
406 | // BanUser bans a user.
407 | func (d *Discord) BanUser(channel, userID string, duration int) error {
408 | 	return d.Session.GuildBanCreate(channel, userID, 0)
409 | }
410 | 
411 | // UnbanUser unbans a user.
412 | func (d *Discord) UnbanUser(channel, userID string) error {
413 | 	return d.Session.GuildBanDelete(channel, userID)
414 | }
415 | 
416 | // UserName returns the bots name.
417 | func (d *Discord) UserName() string {
418 | 	if d.Session.State.User == nil {
419 | 		return ""
420 | 	}
421 | 	return d.Session.State.User.Username
422 | }
423 | 
424 | // UserID returns the bots user id.
425 | func (d *Discord) UserID() string {
426 | 	if d.Session.State.User == nil {
427 | 		return ""
428 | 	}
429 | 	return d.Session.State.User.ID
430 | }
431 | 
432 | // Join accept an invite or return an error.
433 | // If AlreadyJoinedError is return, @me has already accepted that invite.
434 | func (d *Discord) Join(join string) error {
435 | 	if i, err := d.Session.Invite(join); err == nil {
436 | 		if _, err := d.Guild(i.Guild.ID); err == nil {
437 | 			return ErrAlreadyJoined
438 | 		}
439 | 	}
440 | 
441 | 	if _, err := d.Session.InviteAccept(join); err != nil {
442 | 		return err
443 | 	}
444 | 	return nil
445 | }
446 | 
447 | // Typing sets that the bot is typing.
448 | func (d *Discord) Typing(channel string) error {
449 | 	return d.Session.ChannelTyping(channel)
450 | }
451 | 
452 | // PrivateMessage will send a private message to a user.
453 | func (d *Discord) PrivateMessage(userID, message string) error {
454 | 	c, err := d.Session.UserChannelCreate(userID)
455 | 	if err != nil {
456 | 		return err
457 | 	}
458 | 	return d.SendMessage(c.ID, message)
459 | }
460 | 
461 | // SupportsPrivateMessages returns whether the service supports private messages.
462 | func (d *Discord) SupportsPrivateMessages() bool {
463 | 	return true
464 | }
465 | 
466 | // SupportsMultiline returns whether the service supports multiline messages.
467 | func (d *Discord) SupportsMultiline() bool {
468 | 	return true
469 | }
470 | 
471 | // CommandPrefix returns the command prefix for the service.
472 | func (d *Discord) CommandPrefix() string {
473 | 	return fmt.Sprintf("@%s ", d.UserName())
474 | }
475 | 
476 | // IsBotOwner returns whether or not a message sender was the owner of the bot.
477 | func (d *Discord) IsBotOwner(message Message) bool {
478 | 	return message.UserID() == d.OwnerUserID
479 | }
480 | 
481 | // IsPrivate returns whether or not a message was private.
482 | func (d *Discord) IsPrivate(message Message) bool {
483 | 	c, err := d.Channel(message.Channel())
484 | 	return err == nil && c.Type == discordgo.ChannelTypeDM
485 | }
486 | 
487 | // IsChannelOwner returns whether or not the sender of a message is a moderator.
488 | func (d *Discord) IsChannelOwner(message Message) bool {
489 | 	c, err := d.Channel(message.Channel())
490 | 	if err != nil {
491 | 		return false
492 | 	}
493 | 	g, err := d.Guild(c.GuildID)
494 | 	if err != nil {
495 | 		return false
496 | 	}
497 | 	return g.OwnerID == message.UserID() || d.IsBotOwner(message)
498 | }
499 | 
500 | // IsModerator returns whether or not the sender of a message is a moderator.
501 | func (d *Discord) IsModerator(message Message) bool {
502 | 	isChannelOwner := d.IsChannelOwner(message)
503 | 
504 | 	p, err := d.MessagePermissions(message)
505 | 	if err != nil {
506 | 		return isChannelOwner
507 | 	}
508 | 
509 | 	return isChannelOwner || p&discordgo.PermissionAdministrator == discordgo.PermissionAdministrator || p&discordgo.PermissionManageChannels == discordgo.PermissionManageChannels || p&discordgo.PermissionManageServer == discordgo.PermissionManageServer
510 | }
511 | 
512 | // ChannelCount returns the number of channels the bot is in.
513 | func (d *Discord) ChannelCount() int {
514 | 	return len(d.Guilds())
515 | }
516 | 
517 | func (d *Discord) Channel(channelID string) (channel *discordgo.Channel, err error) {
518 | 	for _, s := range d.Sessions {
519 | 		channel, err = s.State.Channel(channelID)
520 | 		if err == nil {
521 | 			return channel, nil
522 | 		}
523 | 	}
524 | 	return
525 | }
526 | 
527 | func (d *Discord) Guild(guildID string) (guild *discordgo.Guild, err error) {
528 | 	for _, s := range d.Sessions {
529 | 		guild, err = s.State.Guild(guildID)
530 | 		if err == nil {
531 | 			return guild, nil
532 | 		}
533 | 	}
534 | 	return
535 | }
536 | 
537 | func (d *Discord) Member(guildID string, userID string) (member *discordgo.Member, err error) {
538 | 	for _, s := range d.Sessions {
539 | 		member, err = s.State.Member(guildID, userID)
540 | 		if err == nil {
541 | 			return member, nil
542 | 		}
543 | 	}
544 | 	return
545 | }
546 | 
547 | func (d *Discord) Guilds() []*discordgo.Guild {
548 | 	guilds := []*discordgo.Guild{}
549 | 	for _, s := range d.Sessions {
550 | 		guilds = append(guilds, s.State.Guilds...)
551 | 	}
552 | 	return guilds
553 | }
554 | 
555 | func (d *Discord) MessagePermissions(message Message) (apermissions int64, err error) {
556 | 	m, ok := message.(*DiscordMessage)
557 | 	if !ok {
558 | 		return 0, errors.New("invalid message")
559 | 	}
560 | 	for _, s := range d.Sessions {
561 | 		apermissions, err = s.State.MessagePermissions(m.DiscordgoMessage)
562 | 		if err == nil {
563 | 			return apermissions, nil
564 | 		}
565 | 	}
566 | 	return d.UserChannelPermissions(message.UserID(), message.Channel())
567 | }
568 | 
569 | func (d *Discord) UserChannelPermissions(userID, channelID string) (apermissions int64, err error) {
570 | 	for _, s := range d.Sessions {
571 | 		apermissions, err = s.State.UserChannelPermissions(userID, channelID)
572 | 		if err == nil {
573 | 			return apermissions, nil
574 | 		}
575 | 	}
576 | 	return 0, errors.New("could not find user permissions")
577 | }
578 | 
579 | func (d *Discord) MessageColor(message Message) int {
580 | 	m, ok := message.(*DiscordMessage)
581 | 	if !ok {
582 | 		return 0
583 | 	}
584 | 	for _, s := range d.Sessions {
585 | 		color := s.State.MessageColor(m.DiscordgoMessage)
586 | 		if color != 0 {
587 | 			return color
588 | 		}
589 | 	}
590 | 	return 0
591 | }
592 | 
593 | func (d *Discord) UserColor(userID, channelID string) int {
594 | 	for _, s := range d.Sessions {
595 | 		color := s.State.UserColor(userID, channelID)
596 | 		if color != 0 {
597 | 			return color
598 | 		}
599 | 	}
600 | 	return 0
601 | }
602 | 
603 | func (d *Discord) Nickname(message Message) string {
604 | 	m, ok := message.(*DiscordMessage)
605 | 	if !ok {
606 | 		return ""
607 | 	}
608 | 	if m.DiscordgoMessage.Member != nil && m.DiscordgoMessage.Member.Nick != "" {
609 | 		return m.DiscordgoMessage.Member.Nick
610 | 	}
611 | 	if m.DiscordgoMessage.Author == nil {
612 | 		return ""
613 | 	}
614 | 	return d.NicknameForID(message.UserID(), m.DiscordgoMessage.Author.Username, message.Channel())
615 | }
616 | 
617 | func (d *Discord) NicknameForID(userID, userName, channelID string) string {
618 | 	c, err := d.Channel(channelID)
619 | 	if err == nil {
620 | 		g, err := d.Guild(c.GuildID)
621 | 		if err == nil {
622 | 			for _, m := range g.Members {
623 | 				if m.User.ID == userID {
624 | 					if m.Nick != "" {
625 | 						return m.Nick
626 | 					}
627 | 					return m.User.Username
628 | 					break
629 | 				}
630 | 			}
631 | 		}
632 | 	}
633 | 	return userName
634 | }
635 | 
636 | func (d *Discord) UpdateStatus(idle int, game string) {
637 | 	for _, s := range d.Sessions {
638 | 		s.UpdateGameStatus(idle, game)
639 | 	}
640 | }
641 | func (d *Discord) UpdateStreamingStatus(idle int, game string, url string) {
642 | 	for _, s := range d.Sessions {
643 | 		s.UpdateStreamingStatus(idle, game, url)
644 | 	}
645 | }
646 | 


--------------------------------------------------------------------------------
/discord_test.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"testing"
  5 | )
  6 | 
  7 | func TestCommandMatches(t *testing.T) {
  8 | 	tests := []struct {
  9 | 		Prefix   string
 10 | 		Matches  bool
 11 | 		Command  string
 12 | 		Message  string
 13 | 		Argument string
 14 | 	}{
 15 | 		{"", true, "hello", "hello", ""},
 16 | 		{"", true, "hello", " hello", ""},
 17 | 		{"", true, "hello", "hello ", ""},
 18 | 		{"", true, "hello", " hello ", ""},
 19 | 		{"", true, "hello", "hello world", "world"},
 20 | 		{"", true, "hello", " hello world", "world"},
 21 | 		{"", true, "hello", "hello world ", "world"},
 22 | 		{"", true, "hello", " hello world ", "world"},
 23 | 		{"", false, "hello", " helloworld ", ""},
 24 | 		{"", true, "", " hello world ", ""},
 25 | 		{"", true, "", " hello world ", ""},
 26 | 		{"!", true, "hello", "!hello", ""},
 27 | 		{"!", true, "hello", " !hello", ""},
 28 | 		{"!", true, "hello", "!hello ", ""},
 29 | 		{"!", true, "hello", " !hello ", ""},
 30 | 		{"!", true, "hello", "!hello world", "world"},
 31 | 		{"!", true, "hello", " !hello world", "world"},
 32 | 		{"!", true, "hello", "!hello world ", "world"},
 33 | 		{"!", true, "hello", " !hello world ", "world"},
 34 | 		{"!", false, "hello", " !helloworld ", ""},
 35 | 		{"!", false, "hello", " ! hello world ", ""},
 36 | 		{"!", false, "hello", "!", ""},
 37 | 		{"!", false, "", "hello there", ""},
 38 | 		{"!", false, "", "sup mang", ""},
 39 | 		{"@Septapus ", true, "hello", "@Septapus hello", ""},
 40 | 		{"@Septapus ", true, "hello", " @Septapus hello", ""},
 41 | 		{"@Septapus ", true, "hello", "@Septapus hello ", ""},
 42 | 		{"@Septapus ", true, "hello", " @Septapus hello ", ""},
 43 | 		{"@Septapus ", true, "hello", "@Septapus hello world", "world"},
 44 | 		{"@Septapus ", true, "hello", " @Septapus hello world", "world"},
 45 | 		{"@Septapus ", true, "hello", "@Septapus hello world ", "world"},
 46 | 		{"@Septapus ", true, "hello", " @Septapus hello world ", "world"},
 47 | 		{"@Septapus ", false, "hello", " @Septapushello world ", ""},
 48 | 		{"@Septapus ", false, "hello", "@Septapus", ""},
 49 | 		{"@Septapus ", false, "", "hello there ", ""},
 50 | 		{"@Septapus ", false, "", "sup mang", ""},
 51 | 	}
 52 | 
 53 | 	for _, test := range tests {
 54 | 		m := &DiscordMessage{
 55 | 			Content: &test.Message,
 56 | 		}
 57 | 		matches, ok := m.MatchesCommand(test.Prefix, test.Command)
 58 | 		if !ok {
 59 | 			t.Errorf("Not ok with message `%v`. Prefix: %v. Command: %v", test.Message, test.Prefix, test.Command)
 60 | 		}
 61 | 		if matches != test.Matches {
 62 | 			t.Errorf("Incorrect matches with message `%v`: Have %v, Want %v. Prefix: %v. Command: %v", test.Message, matches, test.Matches, test.Prefix, test.Command)
 63 | 		}
 64 | 		if test.Argument != "" {
 65 | 			if str, _, ok := m.ParseCommand(test.Prefix); !ok || str != test.Argument {
 66 | 				t.Errorf("No argument %v with message %v", test.Argument, test.Message)
 67 | 			}
 68 | 		}
 69 | 	}
 70 | }
 71 | 
 72 | func TestCommandMatchesMultiple(t *testing.T) {
 73 | 	text := "@Septapus hello world"
 74 | 	m := &DiscordMessage{
 75 | 		Content: &text,
 76 | 	}
 77 | 	if matches, ok := m.MatchesCommand("@Septapus ", "hello"); !matches || !ok {
 78 | 		t.Errorf("Match failure")
 79 | 	}
 80 | 
 81 | 	if matches, ok := m.MatchesCommand("@Septapus ", "butt"); matches || !ok {
 82 | 		t.Errorf("Match failure")
 83 | 	}
 84 | 
 85 | 	if matches, ok := m.MatchesCommand("@Septapus ", "hello"); !matches || !ok {
 86 | 		t.Errorf("Match failure")
 87 | 	}
 88 | }
 89 | 
 90 | func TestCommandParse(t *testing.T) {
 91 | 	text := "@Septapus hello world  how are you   doing"
 92 | 	m := &DiscordMessage{
 93 | 		Content: &text,
 94 | 	}
 95 | 	if rest, parts, ok := m.ParseCommand("@Septapus "); ok {
 96 | 		if rest != "world how are you doing" {
 97 | 			t.Errorf("Command rest incorrect: %v", rest)
 98 | 		}
 99 | 		if len(parts) != 5 {
100 | 			t.Errorf("Parts length incorrect: %v", len(parts))
101 | 		}
102 | 	} else {
103 | 		t.Errorf("Match failure")
104 | 	}
105 | }
106 | 


--------------------------------------------------------------------------------
/discordavatarplugin/discordavatarplugin.go:
--------------------------------------------------------------------------------
 1 | package discordavatarplugin
 2 | 
 3 | import (
 4 | 	"regexp"
 5 | 	"strings"
 6 | 
 7 | 	"github.com/bwmarrin/discordgo"
 8 | 	"github.com/iopred/bruxism"
 9 | )
10 | 
11 | var userIDRegex = regexp.MustCompile("<@!?([0-9]*)>")
12 | 
13 | func avatarLoadFunc(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
14 | 	if service.Name() != bruxism.DiscordServiceName {
15 | 		panic("DiscordAvatar plugin only supports Discord.")
16 | 	}
17 | 	return nil
18 | }
19 | 
20 | func avatarMessageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
21 | 	if service.IsMe(message) {
22 | 		return
23 | 	}
24 | 
25 | 	if !bruxism.MatchesCommand(service, "avatar", message) {
26 | 		return
27 | 	}
28 | 
29 | 	query := strings.Join(strings.Split(message.RawMessage(), " ")[1:], " ")
30 | 
31 | 	id := message.UserID()
32 | 	match := userIDRegex.FindStringSubmatch(query)
33 | 	if match != nil {
34 | 		id = match[1]
35 | 	}
36 | 
37 | 	discord := service.(*bruxism.Discord)
38 | 
39 | 	u, err := discord.Session.User(id)
40 | 	if err != nil {
41 | 		return
42 | 	}
43 | 
44 | 	service.SendMessage(message.Channel(), discordgo.EndpointUserAvatar(u.ID, u.Avatar))
45 | }
46 | 
47 | func avatarHelpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
48 | 	if detailed {
49 | 		return nil
50 | 	}
51 | 	return bruxism.CommandHelp(service, "avatar", "[@username]", "Returns a big version of your avatar, or a users avatar if provided.")
52 | }
53 | 
54 | // New creates a new discordavatar plugin.
55 | func New() bruxism.Plugin {
56 | 	p := bruxism.NewSimplePlugin("DiscordAvatar")
57 | 	p.LoadFunc = avatarLoadFunc
58 | 	p.MessageFunc = avatarMessageFunc
59 | 	p.HelpFunc = avatarHelpFunc
60 | 	return p
61 | }
62 | 


--------------------------------------------------------------------------------
/emojiplugin/README.md:
--------------------------------------------------------------------------------
 1 | # Emoji Plugin
 2 | 
 3 | This plugin returns a large version of an emoji.
 4 | 
 5 | ## Installation
 6 | 
 7 | Copy all the files from:
 8 | 
 9 | https://github.com/googlei18n/noto-emoji/tree/master/png/128
10 | 
11 | into:
12 | 
13 | $GOPATH/bin/emoji/google
14 | 
15 | Copy all the files from:
16 | 
17 | https://github.com/twitter/twemoji/tree/gh-pages/72x72
18 | 
19 | into:
20 | 
21 | $GOPATH/bin/emoji/twitter
22 | 


--------------------------------------------------------------------------------
/emojiplugin/emojiplugin.go:
--------------------------------------------------------------------------------
  1 | package emojiplugin
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"net/http"
  6 | 	"io/ioutil"
  7 | 	"os"
  8 | 	"regexp"
  9 | 	"strings"
 10 | 
 11 | 	"github.com/bwmarrin/discordgo"
 12 | 	"github.com/iopred/bruxism"
 13 | )
 14 | 
 15 | var emoji map[string]bool = map[string]bool{}
 16 | 
 17 | func init() {
 18 | 	f, err := ioutil.ReadDir("emoji/twitter")
 19 | 	if err != nil {
 20 | 		return
 21 | 	}
 22 | 	for _, file := range f {
 23 | 		emoji[file.Name()] = true
 24 | 	}
 25 | }
 26 | 
 27 | func emojiFile(s string) string {
 28 | 	found := ""
 29 | 	filename := ""
 30 | 	for _, r := range s {
 31 | 		if filename != "" {
 32 | 			filename = fmt.Sprintf("%s-%x", filename, r)
 33 | 		} else {
 34 | 			filename = fmt.Sprintf("%x", r)
 35 | 		}
 36 | 		if emoji[fmt.Sprintf("%s.png", filename)] {
 37 | 			found = filename
 38 | 		}
 39 | 	}
 40 | 	return found
 41 | }
 42 | 
 43 | func emojiLoadFunc(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
 44 | 	if service.Name() != bruxism.DiscordServiceName {
 45 | 		panic("Emoji Plugin only supports Discord.")
 46 | 	}
 47 | 	return nil
 48 | }
 49 | 
 50 | var discordRegex = regexp.MustCompile("<(a?):.*?:(.*?)>")
 51 | 
 52 | func emojiMessageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
 53 | 	if service.Name() != bruxism.DiscordServiceName {
 54 | 		return
 55 | 	}
 56 | 
 57 | 	if service.IsMe(message) {
 58 | 		return
 59 | 	}
 60 | 
 61 | 	if !bruxism.MatchesCommand(service, "emoji", message) && !bruxism.MatchesCommand(service, "hugemoji", message) && !bruxism.MatchesCommand(service, "hugeemoji", message) {
 62 | 		return
 63 | 	}
 64 | 
 65 | 	base := "emoji/twitter"
 66 | 	if bruxism.MatchesCommand(service, "hugemoji", message) || bruxism.MatchesCommand(service, "hugeemoji", message) {
 67 | 		base = "emoji/twitterhuge"
 68 | 	}
 69 | 	_, parts := bruxism.ParseCommand(service, message)
 70 | 	if len(parts) == 1 {
 71 | 		submatches := discordRegex.FindStringSubmatch(parts[0])
 72 | 		if len(submatches) != 0 {
 73 | 			fileType := "png"
 74 | 			url := discordgo.EndpointEmoji(submatches[2])
 75 | 			if submatches[1] == "a" {
 76 | 				fileType = "gif"
 77 | 				url = discordgo.EndpointEmojiAnimated(submatches[2])
 78 | 			}
 79 | 			h, err := http.Get(url)
 80 | 			if err != nil {
 81 | 				return
 82 | 			}
 83 | 
 84 | 			service.SendFile(message.Channel(), "emoji."+fileType, h.Body)
 85 | 			h.Body.Close()
 86 | 
 87 | 			return
 88 | 
 89 | 		}
 90 | 
 91 | 		s := strings.TrimSpace(parts[0])
 92 | 		filename := emojiFile(s)
 93 | 		if filename != "" {
 94 | 			if f, err := os.Open(fmt.Sprintf("%s/%s.png", base, filename)); err == nil {
 95 | 				defer f.Close()
 96 | 				service.SendFile(message.Channel(), "emoji.png", f)
 97 | 
 98 | 				return
 99 | 			}
100 | 		}
101 | 	}
102 | }
103 | 
104 | func emojiHelpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
105 | 	help := bruxism.CommandHelp(service, "emoji", "<emoji>", "Returns a big version of an emoji.")
106 | 
107 | 	if detailed {
108 | 		help = append(help, bruxism.CommandHelp(service, "hugemoji", "<emoji>", "Returns a huge version of an emoji.")[0])
109 | 	}
110 | 
111 | 	return help
112 | }
113 | 
114 | // New creates a new emoji plugin.
115 | func New() bruxism.Plugin {
116 | 	p := bruxism.NewSimplePlugin("Emoji")
117 | 	p.LoadFunc = emojiLoadFunc
118 | 	p.MessageFunc = emojiMessageFunc
119 | 	p.HelpFunc = emojiHelpFunc
120 | 	return p
121 | }
122 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/iopred/bruxism
 2 | 
 3 | require (
 4 | 	github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b // indirect
 5 | 	github.com/atotto/clipboard v0.1.4
 6 | 	github.com/bwmarrin/discordgo v0.25.0
 7 | 	github.com/dustin/go-humanize v1.0.0
 8 | 	github.com/fluffle/goirc v1.2.0
 9 | 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
10 | 	github.com/gorilla/websocket v1.5.0 // indirect
11 | 	github.com/iopred/comicgen v0.0.0-20201007025231-1d7f3d63a039
12 | 	github.com/lithammer/fuzzysearch v1.1.3
13 | 	github.com/nlopes/slack v0.6.0
14 | 	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e // indirect
15 | 	golang.org/x/image v0.0.0-20211028202545-6944b10bf410 // indirect
16 | 	golang.org/x/net v0.0.0-20220531201128-c960675eff93 // indirect
17 | 	golang.org/x/oauth2 v0.0.0-20220524215830-622c5d57e401
18 | 	gonum.org/v1/netlib v0.0.0-20210927171344-7274ea1d1842 // indirect
19 | 	gonum.org/v1/plot v0.10.0
20 | 	google.golang.org/api v0.81.0
21 | 	google.golang.org/genproto v0.0.0-20220531173845-685668d2de03 // indirect
22 | 	google.golang.org/grpc v1.47.0 // indirect
23 | )
24 | 
25 | go 1.14
26 | 


--------------------------------------------------------------------------------
/helpplugin.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"sort"
  8 | 	"strings"
  9 | )
 10 | 
 11 | type helpPlugin struct {
 12 | 	Private map[string]bool
 13 | }
 14 | 
 15 | // Name returns the name of the service.
 16 | func (p *helpPlugin) Name() string {
 17 | 	return "Help"
 18 | }
 19 | 
 20 | // Help returns a list of help strings that are printed when the user requests them.
 21 | func (p *helpPlugin) Help(bot *Bot, service Service, message Message, detailed bool) []string {
 22 | 	privs := service.SupportsPrivateMessages() && !service.IsPrivate(message) && service.IsModerator(message)
 23 | 	if detailed && !privs {
 24 | 		return nil
 25 | 	}
 26 | 
 27 | 	ticks := ""
 28 | 	if service.Name() == DiscordServiceName {
 29 | 		ticks = "`"
 30 | 	}
 31 | 
 32 | 	commands := []string{}
 33 | 
 34 | 	for _, plugin := range bot.Services[service.Name()].Plugins {
 35 | 		hasDetailed := false
 36 | 
 37 | 		if plugin == p {
 38 | 			hasDetailed = privs
 39 | 		} else {
 40 | 			t := plugin.Help(bot, service, message, true)
 41 | 			hasDetailed = t != nil && len(t) > 0
 42 | 		}
 43 | 
 44 | 		if hasDetailed {
 45 | 			commands = append(commands, strings.ToLower(plugin.Name()))
 46 | 		}
 47 | 	}
 48 | 
 49 | 	sort.Strings(commands)
 50 | 
 51 | 	help := []string{}
 52 | 
 53 | 	if len(commands) > 0 {
 54 | 		help = append(help, CommandHelp(service, "help", "[topic]", fmt.Sprintf("Returns help for a specific topic. Available topics: %s%s%s", ticks, strings.Join(commands, ", "), ticks))[0])
 55 | 	}
 56 | 
 57 | 	if detailed {
 58 | 		help = append(help, []string{
 59 | 			CommandHelp(service, "setprivatehelp", "", "Sets help text to be sent through private messages in this channel.")[0],
 60 | 			CommandHelp(service, "setpublichelp", "", "Sets the default help behavior for this channel.")[0],
 61 | 		}...)
 62 | 	}
 63 | 
 64 | 	return help
 65 | }
 66 | 
 67 | func (p *helpPlugin) Message(bot *Bot, service Service, message Message) {
 68 | 	if !service.IsMe(message) {
 69 | 		if MatchesCommand(service, "help", message) || MatchesCommand(service, "command", message) {
 70 | 			if service.Name() == YouTubeServiceName {
 71 | 				service.SendMessage(message.Channel(), "Visit septapus dot com for help.")
 72 | 				return
 73 | 			}
 74 | 
 75 | 			_, parts := ParseCommand(service, message)
 76 | 
 77 | 			help := []string{}
 78 | 
 79 | 			for _, plugin := range bot.Services[service.Name()].Plugins {
 80 | 				var h []string
 81 | 				if len(parts) == 0 {
 82 | 					h = plugin.Help(bot, service, message, false)
 83 | 				} else if len(parts) == 1 && strings.ToLower(parts[0]) == strings.ToLower(plugin.Name()) {
 84 | 					h = plugin.Help(bot, service, message, true)
 85 | 				}
 86 | 				if h != nil && len(h) > 0 {
 87 | 					help = append(help, h...)
 88 | 				}
 89 | 			}
 90 | 
 91 | 			if len(parts) == 0 {
 92 | 				sort.Strings(help)
 93 | 				if service.SupportsPrivateMessages() {
 94 | 					help = append([]string{fmt.Sprintf("All commands can be used in private messages without the `%s` prefix.", service.CommandPrefix())}, help...)
 95 | 				}
 96 | 			}
 97 | 
 98 | 			if len(parts) != 0 && len(help) == 0 {
 99 | 				help = []string{fmt.Sprintf("Unknown topic: %s", parts[0])}
100 | 			}
101 | 
102 | 			if p.Private[message.Channel()] {
103 | 				service.SendMessage(message.Channel(), "Help has been sent via private message.")
104 | 				if service.SupportsMultiline() {
105 | 					service.PrivateMessage(message.UserID(), strings.Join(help, "\n"))
106 | 				} else {
107 | 					for _, h := range help {
108 | 						if err := service.PrivateMessage(message.UserID(), h); err != nil {
109 | 							break
110 | 						}
111 | 					}
112 | 				}
113 | 			} else {
114 | 				if service.SupportsMultiline() {
115 | 					service.SendMessage(message.Channel(), strings.Join(help, "\n"))
116 | 				} else {
117 | 					for _, h := range help {
118 | 						if err := service.SendMessage(message.Channel(), h); err != nil {
119 | 							break
120 | 						}
121 | 					}
122 | 				}
123 | 			}
124 | 		} else if MatchesCommand(service, "setprivatehelp", message) && service.SupportsPrivateMessages() && !service.IsPrivate(message) {
125 | 			if !service.IsModerator(message) {
126 | 				return
127 | 			}
128 | 
129 | 			p.Private[message.Channel()] = true
130 | 
131 | 			service.PrivateMessage(message.UserID(), fmt.Sprintf("Help text in <#%s> will be sent through private messages.", message.Channel()))
132 | 		} else if MatchesCommand(service, "setpublichelp", message) && service.SupportsPrivateMessages() && !service.IsPrivate(message) {
133 | 			if !service.IsModerator(message) {
134 | 				return
135 | 			}
136 | 
137 | 			p.Private[message.Channel()] = false
138 | 
139 | 			service.PrivateMessage(message.UserID(), fmt.Sprintf("Help text in <#%s> will be sent publically.", message.Channel()))
140 | 		}
141 | 	}
142 | }
143 | 
144 | // Load will load plugin state from a byte array.
145 | func (p *helpPlugin) Load(bot *Bot, service Service, data []byte) error {
146 | 	if data != nil {
147 | 		if err := json.Unmarshal(data, p); err != nil {
148 | 			log.Println("Error loading data", err)
149 | 		}
150 | 	}
151 | 	return nil
152 | }
153 | 
154 | // Save will save plugin state to a byte array.
155 | func (p *helpPlugin) Save() ([]byte, error) {
156 | 	return json.Marshal(p)
157 | }
158 | 
159 | // Stats will return the stats for a plugin.
160 | func (p *helpPlugin) Stats(bot *Bot, service Service, message Message) []string {
161 | 	return nil
162 | }
163 | 
164 | // NeHelpPlugin will create a new help plugin.
165 | func NewHelpPlugin() Plugin {
166 | 	p := &helpPlugin{
167 | 		Private: make(map[string]bool),
168 | 	}
169 | 	return p
170 | }
171 | 


--------------------------------------------------------------------------------
/interfaces.go:
--------------------------------------------------------------------------------
 1 | package bruxism
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"io"
 6 | )
 7 | 
 8 | // MessageType is a type used to determine the CRUD state of a message.
 9 | type MessageType string
10 | 
11 | const (
12 | 	// MessageTypeCreate is the message type for message creation.
13 | 	MessageTypeCreate MessageType = "create"
14 | 	// MessageTypeUpdate is the message type for message updates.
15 | 	MessageTypeUpdate = "update"
16 | 	// MessageTypeDelete is the message type for message deletion.
17 | 	MessageTypeDelete = "delete"
18 | )
19 | 
20 | // Message is a message interface, wraps a single message from a service.
21 | type Message interface {
22 | 	Channel() string
23 | 	UserName() string
24 | 	UserID() string
25 | 	UserAvatar() string
26 | 	Message() string
27 | 	RawMessage() string
28 | 	MessageID() string
29 | 	Type() MessageType
30 | 	MatchesCommand(prefix, command string) (bool, bool)
31 | 	ParseCommand(prefix string) (string, []string, bool)
32 | }
33 | 
34 | // ErrAlreadyJoined is an error dispatched on Join if the bot is already joined to the request.
35 | var ErrAlreadyJoined = errors.New("Already joined.")
36 | 
37 | // Service is a service interface, wraps a single service such as YouTube or Discord.
38 | type Service interface {
39 | 	Name() string
40 | 	UserName() string
41 | 	UserID() string
42 | 	Open() (<-chan Message, error)
43 | 	IsMe(message Message) bool
44 | 	SendMessage(channel, message string) error
45 | 	SendAction(channel, message string) error
46 | 	DeleteMessage(channel, messageID string) error
47 | 	SendFile(channel, name string, r io.Reader) error
48 | 	BanUser(channel, userID string, duration int) error
49 | 	UnbanUser(channel, userID string) error
50 | 	Join(join string) error
51 | 	Typing(channel string) error
52 | 	PrivateMessage(userID, messageID string) error
53 | 	IsBotOwner(message Message) bool
54 | 	IsPrivate(message Message) bool
55 | 	IsChannelOwner(message Message) bool
56 | 	IsModerator(message Message) bool
57 | 	SupportsPrivateMessages() bool
58 | 	SupportsMultiline() bool
59 | 	CommandPrefix() string
60 | 	ChannelCount() int
61 | }
62 | 
63 | // LoadFunc is the function signature for a load handler.
64 | type LoadFunc func(*Bot, Service, []byte) error
65 | 
66 | // SaveFunc is the function signature for a save handler.
67 | type SaveFunc func() ([]byte, error)
68 | 
69 | // HelpFunc is the function signature for a help handler.
70 | type HelpFunc func(*Bot, Service, Message, bool) []string
71 | 
72 | // MessageFunc is the function signature for a message handler.
73 | type MessageFunc func(*Bot, Service, Message)
74 | 
75 | // StatsFunc is the function signature for a stats handler.
76 | type StatsFunc func(*Bot, Service, Message) []string
77 | 
78 | // Plugin is a plugin interface, supports loading and saving to a byte array and has help and message handlers.
79 | type Plugin interface {
80 | 	Name() string
81 | 	Load(*Bot, Service, []byte) error
82 | 	Save() ([]byte, error)
83 | 	Help(*Bot, Service, Message, bool) []string
84 | 	Message(*Bot, Service, Message)
85 | 	Stats(*Bot, Service, Message) []string
86 | }
87 | 


--------------------------------------------------------------------------------
/inviteplugin/inviteplugin.go:
--------------------------------------------------------------------------------
 1 | package inviteplugin
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"log"
 6 | 	"strings"
 7 | 
 8 | 	"github.com/iopred/bruxism"
 9 | )
10 | 
11 | func discordInviteID(id string) string {
12 | 	id = strings.Replace(id, "://discordapp.com/invite/", "://discord.gg/", -1)
13 | 	id = strings.Replace(id, "https://discord.gg/", "", -1)
14 | 	id = strings.Replace(id, "http://discord.gg/", "", -1)
15 | 	return id
16 | }
17 | 
18 | // InviteHelp will return the help text for the invite command.
19 | func InviteHelp(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) (string, string) {
20 | 	switch service.Name() {
21 | 	case bruxism.DiscordServiceName:
22 | 		discord := service.(*bruxism.Discord)
23 | 
24 | 		if discord.ApplicationClientID != "" {
25 | 			return "", fmt.Sprintf("Returns a URL to add %s to your server.", service.UserName())
26 | 		}
27 | 		return "<discordinvite>", "Joins the provided Discord server."
28 | 	case bruxism.YouTubeServiceName:
29 | 		return "<videoid>", "Joins the provided YouTube live stream."
30 | 	}
31 | 	return "<channel>", "Joins the provided channel."
32 | }
33 | 
34 | // InviteCommand is a command for accepting an invite to a channel.
35 | func InviteCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) {
36 | 	if service.Name() == bruxism.DiscordServiceName {
37 | 		discord := service.(*bruxism.Discord)
38 | 
39 | 		if discord.ApplicationClientID != "" {
40 | 			service.SendMessage(message.Channel(), fmt.Sprintf("Please visit <https://discordapp.com/oauth2/authorize?client_id=%s&scope=bot&permissions=537394240> to add %s to your server.", discord.ApplicationClientID, service.UserName()))
41 | 			return
42 | 		}
43 | 	}
44 | 
45 | 	if len(parts) == 1 {
46 | 		join := parts[0]
47 | 		if service.Name() == bruxism.DiscordServiceName {
48 | 			join = discordInviteID(join)
49 | 		}
50 | 		if err := service.Join(join); err != nil {
51 | 			if service.Name() == bruxism.DiscordServiceName && err == bruxism.ErrAlreadyJoined {
52 | 				service.PrivateMessage(message.UserID(), "I have already joined that server.")
53 | 				return
54 | 			}
55 | 			log.Println("Error joining %s %v", service.Name(), err)
56 | 		} else if service.Name() == bruxism.DiscordServiceName {
57 | 			service.PrivateMessage(message.UserID(), "I have joined that server.")
58 | 		}
59 | 	}
60 | }
61 | 


--------------------------------------------------------------------------------
/irc.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"io"
  6 | 
  7 | 	"github.com/fluffle/goirc/client"
  8 | )
  9 | 
 10 | // IRCServiceName is the service name for the IRC service.
 11 | const IRCServiceName string = "IRC"
 12 | 
 13 | // IRCMessage is a Message wrapper around client.Line.
 14 | type IRCMessage client.Line
 15 | 
 16 | // Channel returns the channel id for this message.
 17 | func (m *IRCMessage) Channel() string {
 18 | 	i := client.Line(*m)
 19 | 	return i.Target()
 20 | }
 21 | 
 22 | // UserName returns the user name for this message.
 23 | func (m *IRCMessage) UserName() string {
 24 | 	return m.Nick
 25 | }
 26 | 
 27 | // UserID returns the user id for this message.
 28 | func (m *IRCMessage) UserID() string {
 29 | 	return m.Nick
 30 | }
 31 | 
 32 | // UserAvatar returns the avatar url for this message.
 33 | func (m *IRCMessage) UserAvatar() string {
 34 | 	return ""
 35 | }
 36 | 
 37 | // Message returns the message content for this message.
 38 | func (m *IRCMessage) Message() string {
 39 | 	return m.RawMessage()
 40 | }
 41 | 
 42 | // RawMessage returns the raw message content for this message.
 43 | func (m *IRCMessage) RawMessage() string {
 44 | 	i := client.Line(*m)
 45 | 	return i.Text()
 46 | }
 47 | 
 48 | // MessageID returns the message ID for this message.
 49 | func (m *IRCMessage) MessageID() string {
 50 | 	return ""
 51 | }
 52 | 
 53 | // Type returns the type of message.
 54 | func (m *IRCMessage) Type() MessageType {
 55 | 	return MessageTypeCreate
 56 | }
 57 | 
 58 | func (m *IRCMessage) MatchesCommand(prefix, command string) (bool, bool) {
 59 | 	return false, false
 60 | }
 61 | 
 62 | func (m *IRCMessage) ParseCommand(prefix string) (string, []string, bool) {
 63 | 	return "", []string{}, false
 64 | }
 65 | 
 66 | // IRC is a Service provider for IRC.
 67 | type IRC struct {
 68 | 	host        string
 69 | 	nick        string
 70 | 	password    string
 71 | 	channels    []string
 72 | 	Conn        *client.Conn
 73 | 	messageChan chan Message
 74 | }
 75 | 
 76 | // NewIRC creates a new IRC service.
 77 | func NewIRC(host, nick, password string, channels []string) *IRC {
 78 | 	return &IRC{
 79 | 		host:        host,
 80 | 		nick:        nick,
 81 | 		password:    password,
 82 | 		channels:    channels,
 83 | 		messageChan: make(chan Message, 200),
 84 | 	}
 85 | }
 86 | 
 87 | func (i *IRC) onMessage(conn *client.Conn, line *client.Line) {
 88 | 	m := IRCMessage(*line)
 89 | 	i.messageChan <- &m
 90 | }
 91 | 
 92 | func (i *IRC) onConnect(conn *client.Conn, line *client.Line) {
 93 | 	for _, c := range i.channels {
 94 | 		conn.Join(c)
 95 | 	}
 96 | }
 97 | 
 98 | func (i *IRC) onDisconnect(conn *client.Conn, line *client.Line) {
 99 | 	conn.ConnectTo(i.host)
100 | }
101 | 
102 | // Name returns the name of the service.
103 | func (i *IRC) Name() string {
104 | 	return IRCServiceName
105 | }
106 | 
107 | // Open opens the service and returns a channel which all messages will be sent on.
108 | func (i *IRC) Open() (<-chan Message, error) {
109 | 	i.Conn = client.SimpleClient(i.nick, i.nick, i.nick)
110 | 	i.Conn.Config().Version = i.nick
111 | 	i.Conn.Config().QuitMessage = ""
112 | 
113 | 	i.Conn.HandleFunc("connected", i.onConnect)
114 | 	i.Conn.HandleFunc("disconnected", i.onDisconnect)
115 | 	i.Conn.HandleFunc(client.PRIVMSG, i.onMessage)
116 | 
117 | 	go i.Conn.ConnectTo(i.host, i.password)
118 | 
119 | 	return i.messageChan, nil
120 | }
121 | 
122 | // IsMe returns whether or not a message was sent by the bot.
123 | func (i *IRC) IsMe(message Message) bool {
124 | 	return message.UserName() == i.UserName()
125 | }
126 | 
127 | // SendMessage sends a message.
128 | func (i *IRC) SendMessage(channel, message string) error {
129 | 	i.Conn.Privmsg(channel, message)
130 | 	return nil
131 | }
132 | 
133 | // SendAction sends an action.
134 | func (i *IRC) SendAction(channel, message string) error {
135 | 	i.Conn.Action(channel, message)
136 | 	return nil
137 | }
138 | 
139 | // DeleteMessage deletes a message.
140 | func (i *IRC) DeleteMessage(channel, messageID string) error {
141 | 	return errors.New("Deleting messages not supported on IRC.")
142 | }
143 | 
144 | // SendFile sends a file.
145 | func (i *IRC) SendFile(channel, name string, r io.Reader) error {
146 | 	return errors.New("Send file not supported.")
147 | }
148 | 
149 | // BanUser bans a user.
150 | func (i *IRC) BanUser(channel, userID string, duration int) error {
151 | 	i.Conn.Kick(channel, userID)
152 | 	return nil
153 | }
154 | 
155 | // UnbanUser unbans a user.
156 | func (i *IRC) UnbanUser(channel, userID string) error {
157 | 	return errors.New("Unbanning users not supported on IRC.")
158 | }
159 | 
160 | // UserName returns the bots name.
161 | func (i *IRC) UserName() string {
162 | 	return i.Conn.Me().Nick
163 | }
164 | 
165 | // UserID returns the bots user id.
166 | func (i *IRC) UserID() string {
167 | 	return i.Conn.Me().Nick
168 | }
169 | 
170 | // Join will join a channel.
171 | func (i *IRC) Join(join string) error {
172 | 	i.Conn.Join(join)
173 | 	return nil
174 | }
175 | 
176 | // Typing sets that the bot is typing.
177 | func (i *IRC) Typing(channel string) error {
178 | 	return errors.New("Typing not supported on IRC.")
179 | }
180 | 
181 | // PrivateMessage will send a private message to a user.
182 | func (i *IRC) PrivateMessage(userID, message string) error {
183 | 	return i.SendMessage(userID, message)
184 | }
185 | 
186 | // SupportsPrivateMessages returns whether the service supports private messages.
187 | func (i *IRC) SupportsPrivateMessages() bool {
188 | 	return true
189 | }
190 | 
191 | // SupportsMultiline returns whether the service supports multiline messages.
192 | func (i *IRC) SupportsMultiline() bool {
193 | 	return false
194 | }
195 | 
196 | // CommandPrefix returns the command prefix for the service.
197 | func (i *IRC) CommandPrefix() string {
198 | 	return "!"
199 | }
200 | 
201 | // IsBotOwner returns whether or not a message sender was the owner of the bot.
202 | func (i *IRC) IsBotOwner(message Message) bool {
203 | 	return false
204 | }
205 | 
206 | // IsPrivate returns whether or not a message was private.
207 | func (i *IRC) IsPrivate(message Message) bool {
208 | 	return message.UserName() == message.Channel()
209 | }
210 | 
211 | // IsChannelOwner returns whether or not the sender of a message is the owner.
212 | func (i *IRC) IsChannelOwner(message Message) bool {
213 | 	return false
214 | }
215 | 
216 | // IsModerator returns whether or not the sender of a message is a moderator.
217 | func (i *IRC) IsModerator(message Message) bool {
218 | 	return false
219 | }
220 | 
221 | // ChannelCount returns the number of channels the bot is in.
222 | func (i *IRC) ChannelCount() int {
223 | 	return len(i.channels)
224 | }
225 | 


--------------------------------------------------------------------------------
/liveplugin/liveplugin.go:
--------------------------------------------------------------------------------
  1 | package liveplugin
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"strings"
  8 | 	"sync"
  9 | 
 10 | 	"google.golang.org/api/youtube/v3"
 11 | 
 12 | 	"github.com/iopred/bruxism"
 13 | )
 14 | 
 15 | type livePlugin struct {
 16 | 	sync.RWMutex
 17 | 	ytLiveChannel            *bruxism.YTLiveChannel
 18 | 	ChannelToYouTubeChannels map[string]map[string]bool
 19 | 	youTubeChannelToChannels map[string]map[string]bool
 20 | 	liveVideoChan            chan *youtube.Video
 21 | }
 22 | 
 23 | // Name returns the name of the plugin.
 24 | func (p *livePlugin) Name() string {
 25 | 	return "Live"
 26 | }
 27 | 
 28 | // Load will load plugin state from a byte array.
 29 | func (p *livePlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
 30 | 	if data != nil {
 31 | 		if err := json.Unmarshal(data, p); err != nil {
 32 | 			log.Println("Error loading data", err)
 33 | 		}
 34 | 	}
 35 | 
 36 | 	for channel, ytChannels := range p.ChannelToYouTubeChannels {
 37 | 		for ytChannel := range ytChannels {
 38 | 			p.monitor(channel, ytChannel)
 39 | 		}
 40 | 	}
 41 | 
 42 | 	go p.Run(bot, service)
 43 | 	return nil
 44 | }
 45 | 
 46 | func (p *livePlugin) monitor(channel, ytChannel string) error {
 47 | 	p.Lock()
 48 | 	defer p.Unlock()
 49 | 
 50 | 	if p.youTubeChannelToChannels[ytChannel] == nil {
 51 | 		p.youTubeChannelToChannels[ytChannel] = map[string]bool{}
 52 | 		err := p.ytLiveChannel.Monitor(ytChannel, p.liveVideoChan)
 53 | 		if err != nil {
 54 | 			return err
 55 | 		}
 56 | 	}
 57 | 	if p.ChannelToYouTubeChannels[channel] == nil {
 58 | 		p.ChannelToYouTubeChannels[channel] = map[string]bool{}
 59 | 	}
 60 | 	p.ChannelToYouTubeChannels[channel][ytChannel] = true
 61 | 	p.youTubeChannelToChannels[ytChannel][channel] = true
 62 | 	return nil
 63 | }
 64 | 
 65 | // Run will poll YouTube for channels going live and send messages.
 66 | func (p *livePlugin) Run(bot *bruxism.Bot, service bruxism.Service) {
 67 | 	p.RLock()
 68 | 	lvc := p.liveVideoChan
 69 | 	p.RUnlock()
 70 | 	for {
 71 | 		v := <-lvc
 72 | 		p.RLock()
 73 | 		for channel := range p.youTubeChannelToChannels[v.Snippet.ChannelId] {
 74 | 			e := service.SendMessage(channel, fmt.Sprintf("%s has just gone live! http://gaming.youtube.com/watch?v=%s", v.Snippet.ChannelTitle, v.Id))
 75 | 			if e != nil {
 76 | 				if strings.Contains(e.Error(), "Missing Permissions") || strings.Contains(e.Error(), "Unknown Channel") {
 77 | 					delete(p.ChannelToYouTubeChannels[channel], v.Id)
 78 | 					delete(p.youTubeChannelToChannels[v.Id], channel)
 79 | 				}
 80 | 			}
 81 | 		}
 82 | 		p.RUnlock()
 83 | 	}
 84 | }
 85 | 
 86 | // Save will save plugin state to a byte array.
 87 | func (p *livePlugin) Save() ([]byte, error) {
 88 | 	return json.Marshal(p)
 89 | }
 90 | 
 91 | // Help returns a list of help strings that are printed when the user requests them.
 92 | func (p *livePlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 93 | 	if service.IsPrivate(message) {
 94 | 		return nil
 95 | 	}
 96 | 
 97 | 	if detailed {
 98 | 		return []string{
 99 | 			bruxism.CommandHelp(service, "live", "add [youtube channel id]", "Adds a channel to be announced.")[0],
100 | 			bruxism.CommandHelp(service, "live", "remove [youtube channel id]", "Removes a channel from being announced.")[0],
101 | 			bruxism.CommandHelp(service, "live", "list", "Lists all the channels being announced in this channel.")[0],
102 | 		}
103 | 	}
104 | 
105 | 	return bruxism.CommandHelp(service, "live", "<add|remove|list> [youtube channel id]", "Announces when a YouTube Channel goes live.")
106 | }
107 | 
108 | // Message handler.
109 | func (p *livePlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
110 | 	defer bruxism.MessageRecover()
111 | 
112 | 	if service.IsMe(message) {
113 | 		return
114 | 	}
115 | 
116 | 	if !bruxism.MatchesCommand(service, "live", message) {
117 | 		return
118 | 	}
119 | 
120 | 	messageChannel := message.Channel()
121 | 
122 | 	if service.IsPrivate(message) {
123 | 		service.SendMessage(messageChannel, "Sorry, this command doesn't work in private chat.")
124 | 		return
125 | 	}
126 | 
127 | 	ticks := ""
128 | 	if service.Name() == bruxism.DiscordServiceName {
129 | 		ticks = "`"
130 | 	}
131 | 
132 | 	_, parts := bruxism.ParseCommand(service, message)
133 | 
134 | 	if len(parts) == 0 {
135 | 		service.SendMessage(messageChannel, fmt.Sprintf("Incorrect command. eg: %s%slive [add|remove|list] <%s>%s", ticks, service.CommandPrefix(), "UCGmC0A8mEAPdlELQdP9xJbw", ticks))
136 | 		return
137 | 	}
138 | 
139 | 	switch parts[0] {
140 | 	case "list":
141 | 		if !service.IsModerator(message) {
142 | 			service.SendMessage(messageChannel, "I'm sorry, you must be the channel owner to list live announcements.")
143 | 			return
144 | 		}
145 | 		list := []string{}
146 | 		p.Lock()
147 | 		for ytChannel := range p.ChannelToYouTubeChannels[messageChannel] {
148 | 			list = append(list, fmt.Sprintf("%s (%s)", p.ytLiveChannel.ChannelName(ytChannel), ytChannel))
149 | 		}
150 | 		p.Unlock()
151 | 		if len(list) == 0 {
152 | 			service.SendMessage(messageChannel, "No Channels are being announced.")
153 | 		} else {
154 | 			service.SendMessage(messageChannel, fmt.Sprintf("Currently announcing: %s", strings.Join(list, ",")))
155 | 		}
156 | 	case "add":
157 | 		if !service.IsModerator(message) {
158 | 			service.SendMessage(messageChannel, "I'm sorry, you must be the channel owner to add live announcements.")
159 | 			return
160 | 		}
161 | 		if len(parts) != 2 || len(parts[1]) != 24 {
162 | 			service.SendMessage(messageChannel, fmt.Sprintf("Incorrect Channel ID. eg: %s%slive %s %s%s", ticks, service.CommandPrefix(), parts[0], "UCGmC0A8mEAPdlELQdP9xJbw", ticks))
163 | 			return
164 | 		}
165 | 		err := p.monitor(messageChannel, parts[1])
166 | 		if err != nil {
167 | 			service.SendMessage(messageChannel, fmt.Sprintf("Could not add Channel ID. %s", err))
168 | 			return
169 | 		}
170 | 		service.SendMessage(messageChannel, fmt.Sprintf("Messages will be sent here when %s goes live.", p.ytLiveChannel.ChannelName(parts[1])))
171 | 	case "remove":
172 | 		if !service.IsModerator(message) {
173 | 			service.SendMessage(messageChannel, "I'm sorry, you must be the channel owner to remove live announcements.")
174 | 			return
175 | 		}
176 | 		if len(parts) != 2 || len(parts[1]) != 24 {
177 | 			service.SendMessage(messageChannel, fmt.Sprintf("Incorrect Channel ID. eg: %s%slive %s %s%s", ticks, service.CommandPrefix(), parts[0], "UCGmC0A8mEAPdlELQdP9xJbw", ticks))
178 | 			return
179 | 		}
180 | 		p.Lock()
181 | 		delete(p.ChannelToYouTubeChannels[messageChannel], parts[1])
182 | 		delete(p.youTubeChannelToChannels[parts[1]], messageChannel)
183 | 		p.Unlock()
184 | 		service.SendMessage(messageChannel, fmt.Sprintf("Messages will no longer be sent here when %s goes live.", p.ytLiveChannel.ChannelName(parts[1])))
185 | 	}
186 | }
187 | 
188 | // Stats will return the stats for a plugin.
189 | func (p *livePlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
190 | 	return []string{fmt.Sprintf("YouTube channels monitored: \t%d\n", len(p.youTubeChannelToChannels))}
191 | }
192 | 
193 | // New will create a new live plugin.
194 | func New(ytLiveChannel *bruxism.YTLiveChannel) bruxism.Plugin {
195 | 	return &livePlugin{
196 | 		ytLiveChannel:            ytLiveChannel,
197 | 		ChannelToYouTubeChannels: map[string]map[string]bool{},
198 | 		youTubeChannelToChannels: map[string]map[string]bool{},
199 | 		liveVideoChan:            make(chan *youtube.Video),
200 | 	}
201 | }
202 | 


--------------------------------------------------------------------------------
/mockmessage.go:
--------------------------------------------------------------------------------
 1 | package bruxism
 2 | 
 3 | type MockMessage struct {
 4 | 	id, channel, username, userid, avatar, message, rawMessage string
 5 | }
 6 | 
 7 | func NewMockMessage() *MockMessage {
 8 | 	return &MockMessage{}
 9 | }
10 | 
11 | // Functional options to set various properties
12 | func (m *MockMessage) SetChannel(channel string) *MockMessage {
13 | 	m.channel = channel
14 | 	return m
15 | }
16 | 
17 | func (m *MockMessage) SetUserName(username string) *MockMessage {
18 | 	m.username = username
19 | 	return m
20 | }
21 | 
22 | func (m *MockMessage) SetUserID(userid string) *MockMessage {
23 | 	m.userid = userid
24 | 	return m
25 | }
26 | 
27 | func (m *MockMessage) SetAvatar(avatar string) *MockMessage {
28 | 	m.avatar = avatar
29 | 	return m
30 | }
31 | 
32 | func (m *MockMessage) SetMessage(message string) *MockMessage {
33 | 	m.message = message
34 | 	return m
35 | }
36 | 
37 | func (m *MockMessage) SetRawMessage(message string) *MockMessage {
38 | 	m.rawMessage = message
39 | 	return m
40 | }
41 | 
42 | func (m *MockMessage) SetMessageID(messageID string) *MockMessage {
43 | 	m.id = messageID
44 | 	return m
45 | }
46 | 
47 | // Satisfy Message interface below
48 | func (m *MockMessage) Channel() string {
49 | 	return m.channel
50 | }
51 | 
52 | func (m *MockMessage) UserName() string {
53 | 	return m.username
54 | }
55 | 
56 | func (m *MockMessage) UserID() string {
57 | 	return m.userid
58 | }
59 | 
60 | func (m *MockMessage) UserAvatar() string {
61 | 	return m.avatar
62 | }
63 | 
64 | func (m *MockMessage) Message() string {
65 | 	return m.message
66 | }
67 | 
68 | func (m *MockMessage) RawMessage() string {
69 | 	return m.rawMessage
70 | }
71 | 
72 | func (m *MockMessage) MessageID() string {
73 | 	return m.id
74 | }
75 | 
76 | func (m *MockMessage) Type() MessageType {
77 | 	return MessageTypeCreate
78 | }
79 | 
80 | func (m *MockMessage) MatchesCommand(prefix, command string) (bool, bool) {
81 | 	return false, false
82 | }
83 | 
84 | func (m *MockMessage) ParseCommand(prefix string) (string, []string, bool) {
85 | 	return "", []string{}, false
86 | }
87 | 
88 | var _ Message = &MockMessage{}
89 | 


--------------------------------------------------------------------------------
/mockservice.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"io"
  6 | )
  7 | 
  8 | // Service is a service interface, wraps a single service such as YouTube or Discord.
  9 | type MockService struct {
 10 | 	name, username, userid string
 11 | 	messages               chan Message
 12 | }
 13 | 
 14 | func NewMockService() *MockService {
 15 | 	return &MockService{
 16 | 		messages: make(chan Message, 512),
 17 | 	}
 18 | }
 19 | 
 20 | func (m *MockService) SetName(name string) *MockService {
 21 | 	m.name = name
 22 | 	return m
 23 | }
 24 | 
 25 | func (m *MockService) SetUserName(username string) *MockService {
 26 | 	m.username = username
 27 | 	return m
 28 | }
 29 | 
 30 | func (m *MockService) SetUserID(userid string) *MockService {
 31 | 	m.userid = userid
 32 | 	return m
 33 | }
 34 | 
 35 | // Satisfy Service interface below
 36 | 
 37 | func (s *MockService) Name() string {
 38 | 	return s.name
 39 | }
 40 | 
 41 | func (s *MockService) UserName() string {
 42 | 	return s.username
 43 | }
 44 | 
 45 | func (s *MockService) UserID() string {
 46 | 	return s.userid
 47 | }
 48 | 
 49 | func (s *MockService) Open() (<-chan Message, error) {
 50 | 	return s.messages, nil
 51 | }
 52 | 
 53 | func (s *MockService) NewMessage(message Message) {
 54 | 	s.messages <- message
 55 | }
 56 | 
 57 | func (s *MockService) SendFile(channel, name string, r io.Reader) error {
 58 | 	return errors.New("Not implemented")
 59 | }
 60 | 
 61 | func (s *MockService) IsMe(message Message) bool {
 62 | 	if message.UserID() == s.UserID() {
 63 | 		return true
 64 | 	}
 65 | 	return false
 66 | }
 67 | 
 68 | func (s *MockService) SendMessage(channel, message string) error {
 69 | 	return nil
 70 | }
 71 | 
 72 | func (s *MockService) SendAction(channel, message string) error {
 73 | 	return nil
 74 | }
 75 | 
 76 | func (s *MockService) DeleteMessage(channel, messageID string) error {
 77 | 	return nil
 78 | }
 79 | 
 80 | func (s *MockService) BanUser(channel, userID string, duration int) error {
 81 | 	return nil
 82 | }
 83 | 
 84 | func (s *MockService) UnbanUser(channel, userID string) error {
 85 | 	return nil
 86 | }
 87 | 
 88 | func (s *MockService) Join(join string) error {
 89 | 	return nil
 90 | }
 91 | 
 92 | func (s *MockService) Typing(channel string) error {
 93 | 	return nil
 94 | }
 95 | 
 96 | func (s *MockService) PrivateMessage(userID, messageID string) error {
 97 | 	return nil
 98 | }
 99 | 
100 | func (s *MockService) IsBotOwner(message Message) bool {
101 | 	return s.IsChannelOwner(message)
102 | }
103 | 
104 | func (s *MockService) IsPrivate(message Message) bool {
105 | 	return false
106 | }
107 | 
108 | func (s *MockService) IsChannelOwner(message Message) bool {
109 | 	if message.Channel() == message.UserID() {
110 | 		return true
111 | 	}
112 | 	return false
113 | }
114 | 
115 | func (s *MockService) IsModerator(message Message) bool {
116 | 	return false
117 | }
118 | 
119 | func (s *MockService) SupportsPrivateMessages() bool {
120 | 	return false
121 | }
122 | 
123 | func (s *MockService) SupportsMultiline() bool {
124 | 	return false
125 | }
126 | 
127 | func (s *MockService) CommandPrefix() string {
128 | 	return "!"
129 | }
130 | 
131 | func (s *MockService) ChannelCount() int {
132 | 	return 1
133 | }
134 | 
135 | var _ Service = &MockService{}
136 | 


--------------------------------------------------------------------------------
/mtgplugin/mtgplugin.go:
--------------------------------------------------------------------------------
  1 | package mtgplugin
  2 | 
  3 | import (
  4 | 	"bufio"
  5 | 	"encoding/json"
  6 | 	"fmt"
  7 | 	"log"
  8 | 	"os"
  9 | 	"sort"
 10 | 	"strings"
 11 | 
 12 | 	"github.com/iopred/bruxism"
 13 | 	"github.com/lithammer/fuzzysearch/fuzzy"
 14 | )
 15 | 
 16 | // MTGSet is a struct containing all the information on a set of MTG.
 17 | type MTGSet struct {
 18 | 	Cards []*MTGCard `json:"cards"`
 19 | }
 20 | 
 21 | // MTGCard is a struct containing all the information on a card from MTG.
 22 | type MTGCard struct {
 23 | 	Name      string  `json:"name"`
 24 | 	ManaCost  string  `json:"manaCost"`
 25 | 	Type      string  `json:"type"`
 26 | 	Text      string  `json:"text"`
 27 | 	ID        *int    `json:"multiverseid"`
 28 | 	Power     *string `json:"power"`
 29 | 	Toughness *string `json:"toughness"`
 30 | 	Loyalty   *int    `json:"loyalty"`
 31 | }
 32 | 
 33 | // MTGCardMap is a map from card name to card.
 34 | var MTGCardMap = map[string]*MTGCard{}
 35 | 
 36 | // MTGCardNames is an array of card names
 37 | var MTGCardNames []string
 38 | 
 39 | // MTGTextReplacer is a replacer for styling text content of cards.
 40 | var MTGTextReplacer = strings.NewReplacer("(", "*(", ")", ")*")
 41 | 
 42 | // MTGCostReplacer is a replacer for styling text content of card costs.
 43 | var MTGCostReplacer = strings.NewReplacer("{", "", "}", "")
 44 | 
 45 | // MTGRestReplacer is a replacer for styling card info.
 46 | var MTGRestReplacer = strings.NewReplacer("*", "\\*")
 47 | 
 48 | func init() {
 49 | 	file, err := os.Open("mtg/AllSets-x.json")
 50 | 	if err != nil {
 51 | 		log.Println(err)
 52 | 		return
 53 | 	}
 54 | 	defer file.Close()
 55 | 
 56 | 	MTGSets := map[string]*MTGSet{}
 57 | 
 58 | 	d := json.NewDecoder(bufio.NewReader(file))
 59 | 	err = d.Decode(&MTGSets)
 60 | 	if err != nil {
 61 | 		log.Println(err)
 62 | 		return
 63 | 	}
 64 | 
 65 | 	for _, s := range MTGSets {
 66 | 		for _, c := range s.Cards {
 67 | 			c.ManaCost = MTGCostReplacer.Replace(c.ManaCost)
 68 | 			c.Text = MTGCostReplacer.Replace(c.Text)
 69 | 			MTGCardMap[c.Name] = c
 70 | 			MTGCardNames = append(MTGCardNames, c.Name)
 71 | 		}
 72 | 	}
 73 | }
 74 | 
 75 | // MTGCommand is a command for getting information about MTG cards..
 76 | func MTGCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) {
 77 | 	cardNames := fuzzy.RankFindFold(command, MTGCardNames)
 78 | 	if len(cardNames) == 0 {
 79 | 		service.SendMessage(message.Channel(), "Could not find a card with that name, sorry.")
 80 | 		return
 81 | 	}
 82 | 
 83 | 	sort.Sort(cardNames)
 84 | 
 85 | 	card := MTGCardMap[cardNames[0].Target]
 86 | 
 87 | 	rest := ""
 88 | 	if card.Text != "" {
 89 | 		rest += "\n"
 90 | 	}
 91 | 	if card.Power != nil {
 92 | 		rest += MTGRestReplacer.Replace(fmt.Sprintf("%s/%s", *card.Power, *card.Toughness))
 93 | 	}
 94 | 	if card.Loyalty != nil {
 95 | 		rest += MTGRestReplacer.Replace(fmt.Sprintf("%d", *card.Loyalty))
 96 | 	}
 97 | 	if card.ID != nil {
 98 | 		if rest != "" && rest != "\n" {
 99 | 			rest += "\n"
100 | 		}
101 | 		rest += fmt.Sprintf("(http://gatherer.wizards.com/Handlers/Image.ashx?multiverseid=%d&type=card)", *card.ID)
102 | 	}
103 | 
104 | 	if service.Name() == bruxism.DiscordServiceName {
105 | 		service.SendMessage(message.Channel(), fmt.Sprintf("**%s** %s\n*%s*\n%s%s", card.Name, card.ManaCost, card.Type, MTGTextReplacer.Replace(card.Text), rest))
106 | 	} else {
107 | 		service.SendMessage(message.Channel(), strings.Replace(fmt.Sprintf("%s. %s. %s. %s%s", card.Name, card.Type, card.ManaCost, card.Text, rest), "\n", " ", -1))
108 | 	}
109 | }
110 | 
111 | // MTGHelp is the help for the MTG plugin.
112 | var MTGHelp = bruxism.NewCommandHelp("<cardname>", "Returns information about a Magic: The Gathering card.")
113 | 


--------------------------------------------------------------------------------
/musicplugin/README.md:
--------------------------------------------------------------------------------
 1 | =====
 2 | This is a music plugin for the bruxism multi-service bot.
 3 | 
 4 | This code is in very early stages and is still a bit messy.
 5 | 
 6 | 
 7 | ### Requirements
 8 | 
 9 | * [ffmpeg](http://ffmpeg.org/) must be installed and within your PATH
10 | * [youtube-dl](https://github.com/rg3/youtube-dl) must be installed and exist in the same folder as bruxism.
11 | * [dca](https://github.com/bwmarrin/dca) must be installed and exist in the same folder as bruxism.
12 | 
13 | ### Music Plugin Commands
14 | 
15 | * NOTE: All commands must be prefixed with a @mention of your bot
16 | * NOTE: `music` can be abbreviated with just `mu`
17 | 
18 | #### Format
19 | 
20 | `@botname music <required> [optional] [this | or this]`
21 | 
22 | 
23 | #### Commands Quick Reference
24 | 
25 | 
26 | | Command              | Arguments                        | Action
27 | | -------------------- | -------------------------------- | -------------------
28 | | **mu**sic **join**   | `[channelID]`                    | Join channel of caller or provided channel ID
29 | | **mu**sic **leave**  |                                  | Leave the currently connected voice channel.
30 | | **mu**sic **play**   | `[url]`                          | Start queue player and optionally enqueue a URL
31 | | **mu**sic **info**   |                                  | Display plugin / queue / playing song info
32 | | **mu**sic **pause**  |                                  | Pause playback.
33 | | **mu**sic **resume** |                                  | Resume playback.
34 | | **mu**sic **skip**   |                                  | Skip current song.
35 | | **mu**sic **stop**   |                                  | Stop queue player.
36 | | **mu**sic **loop**   |                                  | Toggle Loop Queue setting
37 | | **mu**sic **list**   |                                  | List all items in queue.
38 | | **mu**sic **clear**  |                                  | Clear all items from queue.
39 | 
40 | ### Notes
41 | 
42 | For faster startup of youtube-dl use github cloned version of youtube-dl, see
43 | https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=83763
44 | 
45 | To avoid youtube-dl ffmpeg post processing error, use a youtube-dl version past
46 | this commit https://github.com/rg3/youtube-dl/commit/e38cafe986994d65230e6518752def8b53ad7308
47 | see issue https://github.com/rg3/youtube-dl/issues/8729#event-574790956
48 | 
49 | ### Author
50 | 
51 | [Bruce Marriner](https://github.com/bwmarrin/discordgo)
52 | 


--------------------------------------------------------------------------------
/musicplugin/musicplugin.go:
--------------------------------------------------------------------------------
  1 | package musicplugin
  2 | 
  3 | import (
  4 | 	"bufio"
  5 | 	"encoding/binary"
  6 | 	"encoding/json"
  7 | 	"fmt"
  8 | 	"io"
  9 | 	"log"
 10 | 	"net/url"
 11 | 	"os"
 12 | 	"os/exec"
 13 | 	"strconv"
 14 | 	"strings"
 15 | 	"sync"
 16 | 	"time"
 17 | 
 18 | 	"github.com/bwmarrin/discordgo"
 19 | 	"github.com/iopred/bruxism"
 20 | )
 21 | 
 22 | type MusicPlugin struct {
 23 | 	sync.Mutex
 24 | 
 25 | 	discord *bruxism.Discord
 26 | 
 27 | 	VoiceConnections map[string]*voiceConnection
 28 | }
 29 | 
 30 | type voiceConnection struct {
 31 | 	sync.Mutex
 32 | 	debug bool
 33 | 
 34 | 	GuildID      string
 35 | 	ChannelID    string
 36 | 	MaxQueueSize int
 37 | 	Queue        []song
 38 | 
 39 | 	close   chan struct{}
 40 | 	control chan controlMessage
 41 | 	playing *song
 42 | 	conn    *discordgo.VoiceConnection
 43 | }
 44 | 
 45 | type controlMessage int
 46 | 
 47 | const (
 48 | 	Skip controlMessage = iota
 49 | 	Pause
 50 | 	Resume
 51 | )
 52 | 
 53 | type song struct {
 54 | 	AddedBy     string
 55 | 	ID          string `json:"id"`
 56 | 	Title       string `json:"title"`
 57 | 	Description string `json:"description"`
 58 | 	FullTitle   string `json:"full_title"`
 59 | 	Thumbnail   string `json:"thumbnail"`
 60 | 	URL         string `json:"webpage_url"`
 61 | 	Duration    int    `json:"duration"`
 62 | 	Remaining   int
 63 | }
 64 | 
 65 | // New will create a new music plugin.
 66 | func New(discord *bruxism.Discord) bruxism.Plugin {
 67 | 
 68 | 	p := &MusicPlugin{
 69 | 		discord:          discord,
 70 | 		VoiceConnections: make(map[string]*voiceConnection),
 71 | 	}
 72 | 
 73 | 	return p
 74 | }
 75 | 
 76 | // Name returns the name of the plugin.
 77 | func (p *MusicPlugin) Name() string {
 78 | 	return "Music"
 79 | }
 80 | 
 81 | // Load will load plugin state from a byte array.
 82 | func (p *MusicPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) (err error) {
 83 | 	if service.Name() != bruxism.DiscordServiceName {
 84 | 		panic("Music Plugin only supports Discord.")
 85 | 	}
 86 | 
 87 | 	if data != nil {
 88 | 		if err = json.Unmarshal(data, p); err != nil {
 89 | 			log.Println("musicplugin: loading data err:", err)
 90 | 		}
 91 | 	}
 92 | 
 93 | 	go p.init()
 94 | 
 95 | 	return nil
 96 | }
 97 | 
 98 | func (p *MusicPlugin) init() {
 99 | 	<-time.After(1 * time.Second)
100 | 	for _, s := range p.discord.Sessions {
101 | 		if !s.DataReady {
102 | 			go p.init()
103 | 			return
104 | 		}
105 | 	}
106 | 	p.ready()
107 | }
108 | 
109 | func (p *MusicPlugin) ready() {
110 | 	// Join all registered voice channels and start the playback queue
111 | 	for _, v := range p.VoiceConnections {
112 | 		if v.ChannelID == "" {
113 | 			continue
114 | 		}
115 | 		vc, err := p.join(v.ChannelID)
116 | 		if err != nil {
117 | 			log.Println("musicplugin: join channel err:", err)
118 | 			continue
119 | 		}
120 | 		p.gostart(vc)
121 | 	}
122 | }
123 | 
124 | // Save will save plugin state to a byte array.
125 | func (p *MusicPlugin) Save() ([]byte, error) {
126 | 	return json.Marshal(p)
127 | }
128 | 
129 | // Help returns a list of help strings that are printed when the user requests them.
130 | func (p *MusicPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
131 | 	if service.IsPrivate(message) {
132 | 		return nil
133 | 	}
134 | 
135 | 	// Only show help messages for guilds where we have a voice connection
136 | 	c, err := p.discord.Channel(message.Channel())
137 | 	if err != nil {
138 | 		log.Println("musicplugin: fetching channel err:", err.Error())
139 | 		return nil
140 | 	}
141 | 
142 | 	_, ok := p.VoiceConnections[c.GuildID]
143 | 	if !ok {
144 | 		return nil
145 | 	}
146 | 
147 | 	help := []string{
148 | 		bruxism.CommandHelp(service, "music", "<command>", "Music Plugin, see `help music`")[0],
149 | 	}
150 | 
151 | 	if detailed {
152 | 		help = append(help, []string{
153 | 			"Examples:",
154 | 			bruxism.CommandHelp(service, "music", "join [channelid]", "Join your voice channel or the provided voice channel.")[0],
155 | 			bruxism.CommandHelp(service, "music", "leave", "Leave current voice channel.")[0],
156 | 			bruxism.CommandHelp(service, "music", "play [url]", "Start playing music and optionally enqueue provided url.")[0],
157 | 			bruxism.CommandHelp(service, "music", "info", "Information about this plugin and the currently playing song.")[0],
158 | 			bruxism.CommandHelp(service, "music", "pause", "Pause playback of current song.")[0],
159 | 			bruxism.CommandHelp(service, "music", "resume", "Resume playback of current song.")[0],
160 | 			bruxism.CommandHelp(service, "music", "skip", "Skip current song.")[0],
161 | 			bruxism.CommandHelp(service, "music", "stop", "Stop playing music.")[0],
162 | 			bruxism.CommandHelp(service, "music", "list", "List contents of queue.")[0],
163 | 			bruxism.CommandHelp(service, "music", "clear", "Clear all items from queue.")[0],
164 | 		}...)
165 | 	}
166 | 
167 | 	return help
168 | }
169 | 
170 | // Message handler.
171 | func (p *MusicPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
172 | 	defer bruxism.MessageRecover()
173 | 
174 | 	if service.IsMe(message) {
175 | 		return
176 | 	}
177 | 
178 | 	if !bruxism.MatchesCommand(service, "music", message) && !bruxism.MatchesCommand(service, "mu", message) {
179 | 		return
180 | 	}
181 | 
182 | 	if service.IsPrivate(message) {
183 | 		service.SendMessage(message.Channel(), "Sorry, this command doesn't work in private chat.")
184 | 		return
185 | 	}
186 | 
187 | 	_, parts := bruxism.ParseCommand(service, message)
188 | 
189 | 	if len(parts) == 0 {
190 | 		service.SendMessage(message.Channel(), strings.Join(p.Help(bot, service, message, true), "\n"))
191 | 		return
192 | 	}
193 | 
194 | 	// Get the Channel (and GuildID) for this channel because it's needed in
195 | 	// a few locations below
196 | 	channel, err := p.discord.Channel(message.Channel())
197 | 	if err != nil {
198 | 		log.Println("musicplugin: fetching channel err:", err.Error())
199 | 		return
200 | 	}
201 | 
202 | 	// grab pointer to this channels voice connection, if exists.
203 | 	vc, vcok := p.VoiceConnections[channel.GuildID]
204 | 
205 | 	switch parts[0] {
206 | 
207 | 	case "help":
208 | 		// display extended help information
209 | 		service.SendMessage(message.Channel(), strings.Join(p.Help(bot, service, message, true), "\n"))
210 | 
211 | 	case "stats":
212 | 		// TODO: maybe provide plugin stats, total channels, total song queues, etc
213 | 
214 | 	case "join":
215 | 		if !service.IsBotOwner(message) {
216 | 			service.SendMessage(message.Channel(), "Sorry, only bot owner can join, please ask him to run this command.")
217 | 			return
218 | 		}
219 | 		// join the voice channel of the caller or the provided channel ID
220 | 
221 | 		channelID := ""
222 | 		if len(parts) > 1 {
223 | 			channelID = parts[1]
224 | 		}
225 | 
226 | 		if channelID == "" {
227 | 			messageUserID := message.UserID()
228 | 			for _, g := range p.discord.Guilds() {
229 | 				for _, v := range g.VoiceStates {
230 | 					if v.UserID == messageUserID {
231 | 						channelID = v.ChannelID
232 | 					}
233 | 				}
234 | 			}
235 | 
236 | 			if channelID == "" {
237 | 				service.SendMessage(message.Channel(), "I couldn't find you in any voice channels, please join one.")
238 | 				return
239 | 			}
240 | 		}
241 | 
242 | 		_, err := p.join(channelID)
243 | 		if err != nil {
244 | 			service.SendMessage(message.Channel(), err.Error())
245 | 			break
246 | 		}
247 | 
248 | 		service.SendMessage(message.Channel(), "Now, let's play some music!")
249 | 
250 | 	case "leave":
251 | 		// leave voice channel for this Guild
252 | 		if !service.IsBotOwner(message) {
253 | 			service.SendMessage(message.Channel(), "Sorry, only bot owner can leave, please ask him to run this command.")
254 | 			return
255 | 		}
256 | 
257 | 		if !vcok {
258 | 			service.SendMessage(message.Channel(), "There is no voice connection for this Guild.")
259 | 		}
260 | 
261 | 		vc.conn.Close()
262 | 		delete(p.VoiceConnections, channel.GuildID)
263 | 		service.SendMessage(message.Channel(), "Closed voice connection.")
264 | 
265 | 	case "debug":
266 | 		// enable or disable debug
267 | 
268 | 		if !vcok {
269 | 			service.SendMessage(message.Channel(), fmt.Sprintf("There is no voice connection for this Guild."))
270 | 		}
271 | 
272 | 		vc.Lock()
273 | 		vc.debug = !vc.debug
274 | 		service.SendMessage(message.Channel(), fmt.Sprintf("debug mode set to %v", vc.debug))
275 | 		vc.Unlock()
276 | 
277 | 	case "play":
278 | 		// Start queue player and optionally enqueue provided songs
279 | 
280 | 		p.gostart(vc)
281 | 
282 | 		for _, v := range parts[1:] {
283 | 			url, err := url.Parse(v) // doesn't check much..
284 | 			if err != nil {
285 | 				continue
286 | 			}
287 | 			err = p.enqueue(vc, url.String(), service, message)
288 | 			if err != nil {
289 | 				// TODO: Might need improving.
290 | 				service.SendMessage(message.Channel(), err.Error())
291 | 			}
292 | 		}
293 | 
294 | 	case "stop":
295 | 		// stop the queue player
296 | 
297 | 		if vc.close != nil {
298 | 			close(vc.close)
299 | 			vc.close = nil
300 | 		}
301 | 
302 | 		if vc.control != nil {
303 | 			close(vc.control)
304 | 			vc.control = nil
305 | 		}
306 | 
307 | 	case "skip":
308 | 		// skip current song
309 | 
310 | 		if vc.control == nil {
311 | 			return
312 | 		}
313 | 		vc.control <- Skip
314 | 
315 | 	case "pause":
316 | 		// pause the queue player
317 | 		if vc.control == nil {
318 | 			return
319 | 		}
320 | 		vc.control <- Pause
321 | 
322 | 	case "resume":
323 | 		// resume the queue player
324 | 		if vc.control == nil {
325 | 			return
326 | 		}
327 | 		vc.control <- Resume
328 | 
329 | 	case "info":
330 | 		// report player settings, queue info, and current song
331 | 
332 | 		msg := fmt.Sprintf("`Bruxism MusicPlugin:`\n")
333 | 		msg += fmt.Sprintf("`Voice Channel:` %s\n", vc.ChannelID)
334 | 		msg += fmt.Sprintf("`Queue Size:` %d\n", len(vc.Queue))
335 | 
336 | 		if vc.playing == nil {
337 | 			service.SendMessage(message.Channel(), msg)
338 | 			break
339 | 		}
340 | 
341 | 		msg += fmt.Sprintf("`Now Playing:`\n")
342 | 		msg += fmt.Sprintf("`ID:` %s\n", vc.playing.ID)
343 | 		msg += fmt.Sprintf("`Title:` %s\n", vc.playing.Title)
344 | 		msg += fmt.Sprintf("`Duration:` %ds\n", vc.playing.Duration)
345 | 		msg += fmt.Sprintf("`Remaining:` %ds\n", vc.playing.Remaining)
346 | 		msg += fmt.Sprintf("`Source URL:` <%s>\n", vc.playing.URL)
347 | 		msg += fmt.Sprintf("`Thumbnail:` %s\n", vc.playing.Thumbnail)
348 | 		service.SendMessage(message.Channel(), msg)
349 | 
350 | 	case "list":
351 | 		// list top items in the queue
352 | 
353 | 		if len(vc.Queue) == 0 {
354 | 			service.SendMessage(message.Channel(), "The music queue is empty.")
355 | 			return
356 | 		}
357 | 
358 | 		var msg string
359 | 
360 | 		i := 1
361 | 		i2 := 0
362 | 		for k, v := range vc.Queue {
363 | 			np := ""
364 | 			if vc.playing != nil && *vc.playing == v {
365 | 				np = "**(Now Playing)**"
366 | 			}
367 | 			d := time.Duration(v.Duration) * time.Second
368 | 			msg += fmt.Sprintf("`%.3d:%.15s` **%s** [%s] - *%s* %s\n", k, v.ID, v.Title, d.String(), v.AddedBy, np)
369 | 
370 | 			if i >= 15 {
371 | 				service.SendMessage(message.Channel(), msg)
372 | 				msg = ""
373 | 				i = 0
374 | 				i2++
375 | 
376 | 				if i2 >= 8 {
377 | 					// limit response to 8 messages (120 songs)
378 | 					return
379 | 				}
380 | 			}
381 | 			i++
382 | 		}
383 | 
384 | 		service.SendMessage(message.Channel(), msg)
385 | 
386 | 	case "clear":
387 | 		// clear all items from the queue
388 | 		vc.Lock()
389 | 		vc.Queue = []song{}
390 | 		vc.Unlock()
391 | 
392 | 	default:
393 | 		service.SendMessage(message.Channel(), "Unknown music command, try `help music`")
394 | 	}
395 | }
396 | 
397 | // join a specific voice channel
398 | func (p *MusicPlugin) join(cID string) (vc *voiceConnection, err error) {
399 | 
400 | 	c, err := p.discord.Channel(cID)
401 | 	if err != nil {
402 | 		return
403 | 	}
404 | 
405 | 	if c.Type != discordgo.ChannelTypeGuildVoice {
406 | 		err = fmt.Errorf("That's not a voice channel.")
407 | 		return
408 | 	}
409 | 
410 | 	// Get or Create the VoiceConnection object
411 | 	p.Lock()
412 | 	vc, ok := p.VoiceConnections[c.GuildID]
413 | 	if !ok {
414 | 		vc = &voiceConnection{}
415 | 		p.VoiceConnections[c.GuildID] = vc
416 | 	}
417 | 	p.Unlock()
418 | 
419 | 	guild, err := p.discord.Guild(c.GuildID)
420 | 	if err != nil {
421 | 		return
422 | 	}
423 | 
424 | 	guildId, err := strconv.Atoi(guild.ID)
425 | 	if err != nil {
426 | 		return
427 | 	}
428 | 
429 | 	// NOTE: Setting mute to false, deaf to true.
430 | 	vc.conn, err = p.discord.Sessions[(guildId>>22)%len(p.discord.Sessions)].ChannelVoiceJoin(c.GuildID, cID, false, true)
431 | 	if err != nil {
432 | 		return
433 | 	}
434 | 
435 | 	vc.GuildID = c.GuildID
436 | 	vc.ChannelID = cID
437 | 
438 | 	return
439 | }
440 | 
441 | // enqueue a song/playlest to a VoiceConnections Queue
442 | func (p *MusicPlugin) enqueue(vc *voiceConnection, url string, service bruxism.Service, message bruxism.Message) (err error) {
443 | 
444 | 	if vc == nil {
445 | 		return fmt.Errorf("Cannot enqueue to nil voice connection.")
446 | 	}
447 | 
448 | 	if url == "" {
449 | 		return fmt.Errorf("Cannot enqueue an empty string.")
450 | 	}
451 | 
452 | 	// TODO //////////////////////////////////////////////////////////////////
453 | 	// need to parse the url and have a way to know what we're doing
454 | 	// 1) option to queue local files
455 | 	// 2) option to queue saved playlists
456 | 	// 3) option to queue URL that can be passed directly to ffmpeg without youtube-dl
457 | 	// 4) option to queue youtube-dl playlist
458 | 	// 5) option to queue youtube-dl song
459 | 	// 6) option to queue youtube-dl search result
460 | 
461 | 	// right now option 4 and 5 work, only.
462 | 	//////////////////////////////////////////////////////////////////////////
463 | 
464 | 	cmd := exec.Command("./youtube-dl", "-i", "-j", "--youtube-skip-dash-manifest", url)
465 | 	if vc.debug {
466 | 		cmd.Stderr = os.Stderr
467 | 	}
468 | 
469 | 	output, err := cmd.StdoutPipe()
470 | 	if err != nil {
471 | 		log.Println(err)
472 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Error adding song to playlist."))
473 | 		return
474 | 	}
475 | 
476 | 	err = cmd.Start()
477 | 	if err != nil {
478 | 		log.Println(err)
479 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Error adding song to playlist."))
480 | 		return
481 | 	}
482 | 	defer func() {
483 | 		go cmd.Wait()
484 | 	}()
485 | 
486 | 	scanner := bufio.NewScanner(output)
487 | 
488 | 	for scanner.Scan() {
489 | 		s := song{}
490 | 		err = json.Unmarshal(scanner.Bytes(), &s)
491 | 		if err != nil {
492 | 			log.Println(err)
493 | 			continue
494 | 		}
495 | 
496 | 		s.AddedBy = message.UserName()
497 | 
498 | 		vc.Lock()
499 | 		vc.Queue = append(vc.Queue, s)
500 | 		vc.Unlock()
501 | 	}
502 | 	return
503 | }
504 | 
505 | // little wrapper function for start() to fire it off in a
506 | // go routine if it is not already running.
507 | func (p *MusicPlugin) gostart(vc *voiceConnection) (err error) {
508 | 
509 | 	vc.Lock()
510 | 
511 | 	if vc == nil {
512 | 		vc.Unlock()
513 | 		return fmt.Errorf("gostart cannot start a nil voice connection queue")
514 | 	}
515 | 
516 | 	if vc.close != nil || vc.control != nil {
517 | 		vc.Unlock()
518 | 		return fmt.Errorf("gostart will not start a voice connection with non-nil control channels")
519 | 	}
520 | 
521 | 	vc.close = make(chan struct{})
522 | 	vc.control = make(chan controlMessage)
523 | 
524 | 	// TODO can this be moved lower?
525 | 	vc.Unlock()
526 | 
527 | 	go p.start(vc, vc.close, vc.control)
528 | 
529 | 	return
530 | }
531 | 
532 | // "start" is a goroutine function that loops though the music queue and
533 | // plays songs as they are added
534 | func (p *MusicPlugin) start(vc *voiceConnection, close <-chan struct{}, control <-chan controlMessage) {
535 | 
536 | 	if close == nil || control == nil || vc == nil {
537 | 		log.Println("musicplugin: start() exited due to nil channels")
538 | 		return
539 | 	}
540 | 
541 | 	var i int
542 | 	var Song song
543 | 
544 | 	// main loop keeps this going until close
545 | 	for {
546 | 
547 | 		// exit if close channel is closed
548 | 		select {
549 | 		case <-close:
550 | 			log.Println("musicplugin: start() exited due to close channel.")
551 | 			return
552 | 		default:
553 | 		}
554 | 
555 | 		// loop until voice connection is ready and songs are in the queue.
556 | 		if vc.conn == nil || vc.conn.Ready == false || len(vc.Queue) < 1 {
557 | 			time.Sleep(1 * time.Second)
558 | 			continue
559 | 		}
560 | 
561 | 		// Get song to play and store it in local Song var
562 | 		vc.Lock()
563 | 		if len(vc.Queue)-1 >= i {
564 | 			Song = vc.Queue[i]
565 | 		} else {
566 | 			i = 0
567 | 			vc.Unlock()
568 | 			continue
569 | 		}
570 | 		vc.Unlock()
571 | 
572 | 		vc.playing = &Song
573 | 		p.play(vc, close, control, Song)
574 | 		vc.playing = nil
575 | 
576 | 		vc.Lock()
577 | 		if len(vc.Queue) > 0 {
578 | 			vc.Queue = append(vc.Queue[:i], vc.Queue[i+1:]...)
579 | 		}
580 | 		vc.Unlock()
581 | 	}
582 | }
583 | 
584 | // play an individual song
585 | func (p *MusicPlugin) play(vc *voiceConnection, close <-chan struct{}, control <-chan controlMessage, s song) {
586 | 	var err error
587 | 
588 | 	if close == nil || control == nil || vc == nil || vc.conn == nil {
589 | 		log.Println("musicplugin: play exited because [close|control|vc|vc.conn] is nil.")
590 | 		return
591 | 	}
592 | 
593 | 	ytdl := exec.Command("./youtube-dl", "-v", "-f", "bestaudio", "-o", "-", s.URL)
594 | 	if vc.debug {
595 | 		ytdl.Stderr = os.Stderr
596 | 	}
597 | 	ytdlout, err := ytdl.StdoutPipe()
598 | 	if err != nil {
599 | 		log.Println("musicplugin: ytdl StdoutPipe err:", err)
600 | 		return
601 | 	}
602 | 	ytdlbuf := bufio.NewReaderSize(ytdlout, 16384)
603 | 
604 | 	ffmpeg := exec.Command("ffmpeg", "-i", "pipe:0", "-f", "s16le", "-ar", "48000", "-ac", "2", "pipe:1")
605 | 	ffmpeg.Stdin = ytdlbuf
606 | 	if vc.debug {
607 | 		ffmpeg.Stderr = os.Stderr
608 | 	}
609 | 	ffmpegout, err := ffmpeg.StdoutPipe()
610 | 	if err != nil {
611 | 		log.Println("musicplugin: ffmpeg StdoutPipe err:", err)
612 | 		return
613 | 	}
614 | 	ffmpegbuf := bufio.NewReaderSize(ffmpegout, 16384)
615 | 
616 | 	dca := exec.Command("./dca", "-raw", "-i", "pipe:0")
617 | 	dca.Stdin = ffmpegbuf
618 | 	if vc.debug {
619 | 		dca.Stderr = os.Stderr
620 | 	}
621 | 	dcaout, err := dca.StdoutPipe()
622 | 	if err != nil {
623 | 		log.Println("musicplugin: dca StdoutPipe err:", err)
624 | 		return
625 | 	}
626 | 	dcabuf := bufio.NewReaderSize(dcaout, 16384)
627 | 
628 | 	err = ytdl.Start()
629 | 	if err != nil {
630 | 		log.Println("musicplugin: ytdl Start err:", err)
631 | 		return
632 | 	}
633 | 	defer func() {
634 | 		go ytdl.Wait()
635 | 	}()
636 | 
637 | 	err = ffmpeg.Start()
638 | 	if err != nil {
639 | 		log.Println("musicplugin: ffmpeg Start err:", err)
640 | 		return
641 | 	}
642 | 	defer func() {
643 | 		go ffmpeg.Wait()
644 | 	}()
645 | 
646 | 	err = dca.Start()
647 | 	if err != nil {
648 | 		log.Println("musicplugin: dca Start err:", err)
649 | 		return
650 | 	}
651 | 	defer func() {
652 | 		go dca.Wait()
653 | 	}()
654 | 
655 | 	// header "buffer"
656 | 	var opuslen int16
657 | 
658 | 	// Send "speaking" packet over the voice websocket
659 | 	vc.conn.Speaking(true)
660 | 
661 | 	// Send not "speaking" packet over the websocket when we finish
662 | 	defer vc.conn.Speaking(false)
663 | 
664 | 	start := time.Now()
665 | 	for {
666 | 
667 | 		select {
668 | 		case <-close:
669 | 			log.Println("musicplugin: play() exited due to close channel.")
670 | 			return
671 | 		default:
672 | 		}
673 | 
674 | 		select {
675 | 		case ctl := <-control:
676 | 			switch ctl {
677 | 			case Skip:
678 | 				return
679 | 				break
680 | 			case Pause:
681 | 				done := false
682 | 				for {
683 | 
684 | 					ctl, ok := <-control
685 | 					if !ok {
686 | 						return
687 | 					}
688 | 					switch ctl {
689 | 					case Skip:
690 | 						return
691 | 						break
692 | 					case Resume:
693 | 						done = true
694 | 						break
695 | 					}
696 | 
697 | 					if done {
698 | 						break
699 | 					}
700 | 
701 | 				}
702 | 			}
703 | 		default:
704 | 		}
705 | 
706 | 		// read dca opus length header
707 | 		err = binary.Read(dcabuf, binary.LittleEndian, &opuslen)
708 | 		if err == io.EOF || err == io.ErrUnexpectedEOF {
709 | 			return
710 | 		}
711 | 		if err != nil {
712 | 			log.Println("musicplugin: read opus length from dca err:", err)
713 | 			return
714 | 		}
715 | 
716 | 		// read opus data from dca
717 | 		opus := make([]byte, opuslen)
718 | 		err = binary.Read(dcabuf, binary.LittleEndian, &opus)
719 | 		if err == io.EOF || err == io.ErrUnexpectedEOF {
720 | 			return
721 | 		}
722 | 		if err != nil {
723 | 			log.Println("musicplugin: read opus from dca err:", err)
724 | 			return
725 | 		}
726 | 
727 | 		// Send received PCM to the sendPCM channel
728 | 		vc.conn.OpusSend <- opus
729 | 		// TODO: Add a select and timeout to above
730 | 		// shouldn't ever block longer than maybe 18-25ms
731 | 
732 | 		// this can cause a panic if vc becomes nil while waiting to send
733 | 		// on the opus channel. TODO fix..
734 | 		vc.playing.Remaining = (vc.playing.Duration - int(time.Since(start).Seconds()))
735 | 
736 | 	}
737 | }
738 | 
739 | // Stats will return the stats for a plugin.
740 | func (p *MusicPlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
741 | 	return nil
742 | }
743 | 


--------------------------------------------------------------------------------
/mysonplugin/mysonplugin.go:
--------------------------------------------------------------------------------
 1 | package mysonplugin
 2 | 
 3 | import (
 4 | 	"github.com/bwmarrin/discordgo"
 5 | 	"github.com/iopred/bruxism"
 6 | )
 7 | 
 8 | func messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
 9 | 	if service.IsMe(message) || !bruxism.MatchesCommand(service, "myson", message) || service.Name() != bruxism.DiscordServiceName {
10 | 		return
11 | 	}
12 | 
13 | 	discord := service.(*bruxism.Discord)
14 | 	discord.Session.ChannelMessageSendEmbed(message.Channel(), &discordgo.MessageEmbed{
15 | 		Color:       discord.UserColor(service.UserID(), message.Channel()),
16 | 		Description: "Don't ever talk to me or my son ever again.",
17 | 		Author: &discordgo.MessageEmbedAuthor{
18 | 			Name:    discord.NicknameForID(service.UserID(), service.UserName(), message.Channel()),
19 | 			IconURL: discordgo.EndpointUserAvatar(service.UserID(), discord.Session.State.User.Avatar),
20 | 		},
21 | 	})
22 | }
23 | 
24 | func helpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
25 | 	return nil
26 | }
27 | 
28 | func New() bruxism.Plugin {
29 | 	p := bruxism.NewSimplePlugin("MySon")
30 | 	p.MessageFunc = messageFunc
31 | 	p.HelpFunc = helpFunc
32 | 	return p
33 | }
34 | 


--------------------------------------------------------------------------------
/numbertriviaplugin/numbertriviaplugin.go:
--------------------------------------------------------------------------------
 1 | package numbertriviaplugin
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"fmt"
 6 | 	"io/ioutil"
 7 | 	"math/rand"
 8 | 	"net/http"
 9 | 	"strconv"
10 | 
11 | 	"github.com/iopred/bruxism"
12 | )
13 | 
14 | func numberTrivia(bot *bruxism.Bot, num int, notfound bool) (string, error) {
15 | 	notfoundString := ""
16 | 	if notfound {
17 | 		notfoundString = "?notfound=floor"
18 | 	}
19 | 	r, err := http.NewRequest("GET", fmt.Sprintf("https://numbersapi.p.mashape.com/%d/trivia%s", num, notfoundString), nil)
20 | 	if err != nil {
21 | 		return "", err
22 | 	}
23 | 
24 | 	r.Header.Set("X-Mashape-Authorization", bot.MashableKey)
25 | 	r.Header.Set("Accept", "text/plain")
26 | 
27 | 	resp, err := http.DefaultClient.Do(r)
28 | 	if err != nil {
29 | 		return "", err
30 | 	}
31 | 	defer resp.Body.Close()
32 | 	body, err := ioutil.ReadAll(resp.Body)
33 | 	if err != nil {
34 | 		return "", err
35 | 	}
36 | 
37 | 	if resp.StatusCode != 200 {
38 | 		return "", errors.New(string(body))
39 | 	}
40 | 
41 | 	return string(body), nil
42 | }
43 | 
44 | // NumberTriviaCommand is a command for getting number trivial.
45 | func NumberTriviaCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) {
46 | 	notfound := true
47 | 	num := rand.Intn(1000)
48 | 	if len(parts) == 1 {
49 | 		if i, err := strconv.Atoi(parts[0]); err == nil {
50 | 			num = i
51 | 			notfound = false
52 | 		}
53 | 	}
54 | 
55 | 	service.Typing(message.Channel())
56 | 
57 | 	str, err := numberTrivia(bot, num, notfound)
58 | 	if err != nil {
59 | 		service.SendMessage(message.Channel(), "There was an error requesting trivia, sorry!")
60 | 		return
61 | 	}
62 | 
63 | 	service.SendMessage(message.Channel(), str)
64 | }
65 | 
66 | // NumberTriviaHelp is the help for the number trivia plugin.
67 | var NumberTriviaHelp = bruxism.NewCommandHelp("[number]", "Returns trivia for a random number, or a specified number if provided.")
68 | 


--------------------------------------------------------------------------------
/playedplugin/playedplugin.go:
--------------------------------------------------------------------------------
  1 | package playedplugin
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"regexp"
  8 | 	"sort"
  9 | 	"strings"
 10 | 	"sync"
 11 | 	"time"
 12 | 
 13 | 	"github.com/bwmarrin/discordgo"
 14 | 	"github.com/dustin/go-humanize"
 15 | 	"github.com/iopred/bruxism"
 16 | )
 17 | 
 18 | type playedEntry struct {
 19 | 	Name     string
 20 | 	Duration time.Duration
 21 | }
 22 | 
 23 | type byDuration []*playedEntry
 24 | 
 25 | func (a byDuration) Len() int           { return len(a) }
 26 | func (a byDuration) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 27 | func (a byDuration) Less(i, j int) bool { return a[i].Duration >= a[j].Duration }
 28 | 
 29 | type playedUser struct {
 30 | 	Entries     map[string]*playedEntry
 31 | 	Current     string
 32 | 	LastChanged time.Time
 33 | 	FirstSeen   time.Time
 34 | }
 35 | 
 36 | func (p *playedUser) Update(name string, now time.Time) {
 37 | 	if p.Current != "" {
 38 | 		pe := p.Entries[p.Current]
 39 | 		if pe == nil {
 40 | 			pe = &playedEntry{
 41 | 				Name: p.Current,
 42 | 			}
 43 | 			p.Entries[p.Current] = pe
 44 | 		}
 45 | 		pe.Duration += now.Sub(p.LastChanged)
 46 | 	}
 47 | 
 48 | 	p.Current = name
 49 | 	p.LastChanged = now
 50 | }
 51 | 
 52 | type playedPlugin struct {
 53 | 	sync.RWMutex
 54 | 	Users map[string]*playedUser
 55 | }
 56 | 
 57 | // Load will load plugin state from a byte array.
 58 | func (p *playedPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
 59 | 	if service.Name() != bruxism.DiscordServiceName {
 60 | 		panic("Played Plugin only supports Discord.")
 61 | 	}
 62 | 
 63 | 	if data != nil {
 64 | 		if err := json.Unmarshal(data, p); err != nil {
 65 | 			log.Println("Error loading data", err)
 66 | 		}
 67 | 	}
 68 | 
 69 | 	go p.Run(bot, service)
 70 | 	return nil
 71 | }
 72 | 
 73 | // Save will save plugin state to a byte array.
 74 | func (p *playedPlugin) Save() ([]byte, error) {
 75 | 	return json.Marshal(p)
 76 | }
 77 | 
 78 | func (p *playedPlugin) Update(user string, entry string) {
 79 | 	p.Lock()
 80 | 	defer p.Unlock()
 81 | 
 82 | 	t := time.Now()
 83 | 
 84 | 	u := p.Users[user]
 85 | 	if u == nil {
 86 | 		u = &playedUser{
 87 | 			Entries:     map[string]*playedEntry{},
 88 | 			Current:     entry,
 89 | 			LastChanged: t,
 90 | 			FirstSeen:   t,
 91 | 		}
 92 | 		p.Users[user] = u
 93 | 	}
 94 | 	u.Update(entry, t)
 95 | }
 96 | 
 97 | // Run is the background go routine that executes for the life of the plugin.
 98 | func (p *playedPlugin) Run(bot *bruxism.Bot, service bruxism.Service) {
 99 | 	discord := service.(*bruxism.Discord)
100 | 
101 | 	discord.Session.AddHandler(func(s *discordgo.Session, r *discordgo.Ready) {
102 | 		for _, g := range r.Guilds {
103 | 			for _, pu := range g.Presences {
104 | 				e := ""
105 | 				game := gameName(pu)
106 | 				if game != nil {
107 | 					e = *game
108 | 				}
109 | 				p.Update(pu.User.ID, e)
110 | 			}
111 | 		}
112 | 	})
113 | 
114 | 	discord.Session.AddHandler(func(s *discordgo.Session, g *discordgo.GuildCreate) {
115 | 		if g.Unavailable {
116 | 			return
117 | 		}
118 | 
119 | 		for _, pu := range g.Presences {
120 | 			e := ""
121 | 			game := gameName(pu)
122 | 			if game != nil {
123 | 				e = *game
124 | 			}
125 | 			p.Update(pu.User.ID, e)
126 | 		}
127 | 	})
128 | 
129 | 	discord.Session.AddHandler(func(s *discordgo.Session, pr *discordgo.PresencesReplace) {
130 | 		for _, pu := range *pr {
131 | 			e := ""
132 | 			game := gameName(pu)
133 | 			if game != nil {
134 | 				e = *game
135 | 			}
136 | 			p.Update(pu.User.ID, e)
137 | 		}
138 | 	})
139 | 
140 | 	discord.Session.AddHandler(func(s *discordgo.Session, pu *discordgo.PresenceUpdate) {
141 | 		e := ""
142 | 		game := gameName(&pu.Presence)
143 | 		if game != nil {
144 | 			e = *game
145 | 		}
146 | 		p.Update(pu.User.ID, e)
147 | 	})
148 | }
149 | 
150 | // Help returns a list of help strings that are printed when the user requests them.
151 | func (p *playedPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
152 | 	if detailed {
153 | 		return nil
154 | 	}
155 | 
156 | 	return bruxism.CommandHelp(service, "played", "[@username]", "Returns your most played games, or a users most played games if provided.")
157 | }
158 | 
159 | var userIDRegex = regexp.MustCompile("<@!?([0-9]*)>")
160 | 
161 | func (p *playedPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
162 | 	defer bruxism.MessageRecover()
163 | 	if service.Name() != bruxism.DiscordServiceName {
164 | 		return
165 | 	}
166 | 
167 | 	if service.IsMe(message) {
168 | 		return
169 | 	}
170 | 
171 | 	if !bruxism.MatchesCommand(service, "played", message) {
172 | 		return
173 | 	}
174 | 
175 | 	query := strings.Join(strings.Split(message.RawMessage(), " ")[1:], " ")
176 | 
177 | 	id := message.UserID()
178 | 	match := userIDRegex.FindStringSubmatch(query)
179 | 	if match != nil {
180 | 		id = match[1]
181 | 	}
182 | 
183 | 	p.Lock()
184 | 	defer p.Unlock()
185 | 
186 | 	u := p.Users[id]
187 | 	if u == nil {
188 | 		service.SendMessage(message.Channel(), "I haven't seen that user.")
189 | 		return
190 | 	}
191 | 
192 | 	if len(u.Entries) == 0 {
193 | 		service.SendMessage(message.Channel(), "I haven't seen anything played by that user.")
194 | 		return
195 | 	}
196 | 
197 | 	lc := humanize.Time(u.LastChanged)
198 | 	u.Update(u.Current, time.Now())
199 | 
200 | 	pes := make(byDuration, len(u.Entries))
201 | 	i := 0
202 | 	for _, pe := range u.Entries {
203 | 		pes[i] = pe
204 | 		i++
205 | 	}
206 | 
207 | 	sort.Sort(pes)
208 | 
209 | 	messageText := fmt.Sprintf("*First seen %s, last update %s*\n", humanize.Time(u.FirstSeen), lc)
210 | 	for i = 0; i < len(pes) && i < 5; i++ {
211 | 		pe := pes[i]
212 | 
213 | 		du := pe.Duration
214 | 
215 | 		ds := ""
216 | 		hours := int(du / time.Hour)
217 | 		if hours > 0 {
218 | 			ds += fmt.Sprintf("%dh ", hours)
219 | 			du -= time.Duration(hours) * time.Hour
220 | 		}
221 | 
222 | 		minutes := int(du / time.Minute)
223 | 		if minutes > 0 || len(ds) > 0 {
224 | 			ds += fmt.Sprintf("%dm ", minutes)
225 | 			du -= time.Duration(minutes) * time.Minute
226 | 		}
227 | 
228 | 		seconds := int(du / time.Second)
229 | 		ds += fmt.Sprintf("%ds", seconds)
230 | 
231 | 		messageText += fmt.Sprintf("**%s**: %s\n", pe.Name, ds)
232 | 	}
233 | 	service.SendMessage(message.Channel(), messageText)
234 | }
235 | 
236 | // Name returns the name of the plugin.
237 | func (p *playedPlugin) Name() string {
238 | 	return "Played"
239 | }
240 | 
241 | // Stats will return the stats for a plugin.
242 | func (p *playedPlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
243 | 	return []string{fmt.Sprintf("Users playing: \t%d\n", len(p.Users))}
244 | }
245 | 
246 | // New will create a played plugin.
247 | func New() bruxism.Plugin {
248 | 	return &playedPlugin{
249 | 		Users: map[string]*playedUser{},
250 | 	}
251 | }
252 | 
253 | func gameName(pu *discordgo.Presence) *string {
254 | 	for _, activity := range pu.Activities {
255 | 		if activity.Type == discordgo.ActivityTypeGame {
256 | 			return &activity.Name
257 | 		}
258 | 	}
259 | 	return nil
260 | }
261 | 


--------------------------------------------------------------------------------
/playingplugin/playingplugin.go:
--------------------------------------------------------------------------------
  1 | package playingplugin
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"strings"
  8 | 	"time"
  9 | 
 10 | 	"github.com/iopred/bruxism"
 11 | )
 12 | 
 13 | type playingPlugin struct {
 14 | 	bruxism.SimplePlugin
 15 | 	Game string
 16 | 	URL  string
 17 | }
 18 | 
 19 | // Name returns the name of the plugin.
 20 | func (p *playingPlugin) Name() string {
 21 | 	return "Playing"
 22 | }
 23 | 
 24 | // Load will load plugin state from a byte array.
 25 | func (p *playingPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
 26 | 	if service.Name() != bruxism.DiscordServiceName {
 27 | 		panic("Playing Plugin only supports Discord.")
 28 | 	}
 29 | 
 30 | 	if data != nil {
 31 | 		if err := json.Unmarshal(data, p); err != nil {
 32 | 			log.Println("Error loading data", err)
 33 | 		}
 34 | 	}
 35 | 
 36 | 	go func() {
 37 | 		for {
 38 | 			if p.Game != "" {
 39 | 				service.(*bruxism.Discord).UpdateStreamingStatus(0, p.Game, p.URL)
 40 | 			} else {
 41 | 				service.(*bruxism.Discord).UpdateStatus(0, p.Game)
 42 | 			}
 43 | 			time.Sleep(5 * time.Minute)
 44 | 		}
 45 | 	}()
 46 | 
 47 | 	return nil
 48 | }
 49 | 
 50 | // Save will save plugin state to a byte array.
 51 | func (p *playingPlugin) Save() ([]byte, error) {
 52 | 	return json.Marshal(p)
 53 | }
 54 | 
 55 | // Help returns a list of help strings that are printed when the user requests them.
 56 | func (p *playingPlugin) helpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 57 | 	if detailed {
 58 | 		return nil
 59 | 	}
 60 | 
 61 | 	if !service.IsBotOwner(message) {
 62 | 		return nil
 63 | 	}
 64 | 
 65 | 	return bruxism.CommandHelp(service, "playing", "<game>, <url>", fmt.Sprintf("Set which game %s is playing.", service.UserName()))
 66 | }
 67 | 
 68 | // Message handler.
 69 | func (p *playingPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
 70 | 	if service.IsMe(message) {
 71 | 		return
 72 | 	}
 73 | 
 74 | 	if !bruxism.MatchesCommand(service, "playing", message) {
 75 | 		return
 76 | 	}
 77 | 
 78 | 	if !service.IsBotOwner(message) {
 79 | 		return
 80 | 	}
 81 | 
 82 | 	query, _ := bruxism.ParseCommand(service, message)
 83 | 
 84 | 	split := strings.Split(query, ",")
 85 | 
 86 | 	p.Game = strings.Trim(split[0], " ")
 87 | 	if len(split) > 1 {
 88 | 		p.URL = strings.Trim(split[1], " ")
 89 | 		service.(*bruxism.Discord).UpdateStreamingStatus(0, p.Game, p.URL)
 90 | 	} else {
 91 | 		service.(*bruxism.Discord).UpdateStatus(0, p.Game)
 92 | 	}
 93 | }
 94 | 
 95 | // New will create a new top streamers plugin.
 96 | func New() bruxism.Plugin {
 97 | 	p := &playingPlugin{}
 98 | 	p.MessageFunc = p.messageFunc
 99 | 	p.HelpFunc = p.helpFunc
100 | 	return p
101 | }
102 | 


--------------------------------------------------------------------------------
/reminderplugin/reminderplugin.go:
--------------------------------------------------------------------------------
  1 | package reminderplugin
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"log"
  8 | 	"math/rand"
  9 | 	"strconv"
 10 | 	"strings"
 11 | 	"sync"
 12 | 	"time"
 13 | 
 14 | 	"github.com/dustin/go-humanize"
 15 | 	"github.com/iopred/bruxism"
 16 | )
 17 | 
 18 | // A Reminder holds data about a specific reminder.
 19 | type Reminder struct {
 20 | 	StartTime time.Time
 21 | 	Time      time.Time
 22 | 	Requester string
 23 | 	Target    string
 24 | 	Message   string
 25 | 	IsPrivate bool
 26 | }
 27 | 
 28 | // ReminderPlugin is a plugin that reminds users.
 29 | type ReminderPlugin struct {
 30 | 	sync.RWMutex
 31 | 	bot            *bruxism.Bot
 32 | 	Reminders      []*Reminder
 33 | 	TotalReminders int
 34 | }
 35 | 
 36 | var randomTimes = []string{
 37 | 	"1 minute",
 38 | 	"10 minutes",
 39 | 	"1 hour",
 40 | 	"4 hours",
 41 | 	"tomorrow",
 42 | 	"next week",
 43 | }
 44 | 
 45 | var randomMessages = []string{
 46 | 	"walk the dog",
 47 | 	"take pizza out of the oven",
 48 | 	"check my email",
 49 | 	"feed the baby",
 50 | 	"play some quake",
 51 | }
 52 | 
 53 | func (p *ReminderPlugin) random(list []string) string {
 54 | 	return list[rand.Intn(len(list))]
 55 | }
 56 | 
 57 | func (p *ReminderPlugin) randomReminder(service bruxism.Service) string {
 58 | 	ticks := ""
 59 | 	if service.Name() == bruxism.DiscordServiceName {
 60 | 		ticks = "`"
 61 | 	}
 62 | 
 63 | 	return fmt.Sprintf("%s%sreminder %s %s%s", ticks, service.CommandPrefix(), p.random(randomTimes), p.random(randomMessages), ticks)
 64 | }
 65 | 
 66 | // Help returns a list of help strings that are printed when the user requests them.
 67 | func (p *ReminderPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 68 | 	help := []string{
 69 | 		bruxism.CommandHelp(service, "reminder", "<time> <reminder>", "Sets a reminder that is sent after the provided time.")[0],
 70 | 		bruxism.CommandHelp(service, "reminderlist", "", "List all active reminders.")[0],
 71 | 		bruxism.CommandHelp(service, "reminderdelete", "<index>", "Deletes a reminder by index. eg: reminderdelete 0")[0],
 72 | 	}
 73 | 	if detailed {
 74 | 		help = append(help, []string{
 75 | 			"Examples: ",
 76 | 			p.randomReminder(service),
 77 | 			p.randomReminder(service),
 78 | 		}...)
 79 | 	}
 80 | 	return help
 81 | }
 82 | 
 83 | func (p *ReminderPlugin) parseReminder(parts []string) (time.Time, string, error) {
 84 | 	if parts[0] == "tomorrow" {
 85 | 		return time.Now().Add(1 * time.Hour * 24), strings.Join(parts[1:], " "), nil
 86 | 	}
 87 | 
 88 | 	if parts[0] == "next" {
 89 | 		switch parts[1] {
 90 | 		case "week":
 91 | 			return time.Now().Add(1 * time.Hour * 24 * 7), strings.Join(parts[2:], " "), nil
 92 | 		case "month":
 93 | 			return time.Now().Add(1 * time.Hour * 24 * 7 * 4), strings.Join(parts[2:], " "), nil
 94 | 		case "year":
 95 | 			return time.Now().Add(1 * time.Hour * 24 * 365), strings.Join(parts[2:], " "), nil
 96 | 		default:
 97 | 			return time.Time{}, "", errors.New("Invalid next.")
 98 | 		}
 99 | 	}
100 | 
101 | 	i, err := strconv.Atoi(parts[0])
102 | 	if err != nil {
103 | 		return time.Time{}, "", err
104 | 	}
105 | 
106 | 	switch {
107 | 	case strings.HasPrefix(parts[1], "sec"):
108 | 		return time.Now().Add(time.Duration(i) * time.Second), strings.Join(parts[2:], " "), nil
109 | 	case strings.HasPrefix(parts[1], "min"):
110 | 		return time.Now().Add(time.Duration(i) * time.Minute), strings.Join(parts[2:], " "), nil
111 | 	case strings.HasPrefix(parts[1], "hour"):
112 | 		return time.Now().Add(time.Duration(i) * time.Hour), strings.Join(parts[2:], " "), nil
113 | 	case strings.HasPrefix(parts[1], "day"):
114 | 		return time.Now().Add(time.Duration(i) * time.Hour * 24), strings.Join(parts[2:], " "), nil
115 | 	case strings.HasPrefix(parts[1], "week"):
116 | 		return time.Now().Add(time.Duration(i) * time.Hour * 24 * 7), strings.Join(parts[2:], " "), nil
117 | 	case strings.HasPrefix(parts[1], "month"):
118 | 		return time.Now().Add(time.Duration(i) * time.Hour * 24 * 31), strings.Join(parts[2:], " "), nil
119 | 	case strings.HasPrefix(parts[1], "year"):
120 | 		return time.Now().Add(time.Duration(i) * time.Hour * 24 * 365), strings.Join(parts[2:], " "), nil
121 | 	}
122 | 
123 | 	return time.Time{}, "", errors.New("Invalid string.")
124 | }
125 | 
126 | // AddReminder adds a reminder.
127 | func (p *ReminderPlugin) AddReminder(reminder *Reminder) error {
128 | 	p.Lock()
129 | 	defer p.Unlock()
130 | 
131 | 	i := 0
132 | 	for _, r := range p.Reminders {
133 | 		if r.Requester == reminder.Requester {
134 | 			i++
135 | 			if i > 5 {
136 | 				return errors.New("You have too many reminders already.")
137 | 			}
138 | 		}
139 | 	}
140 | 
141 | 	i = 0
142 | 	for _, r := range p.Reminders {
143 | 		if r.Time.After(reminder.Time) {
144 | 			break
145 | 		}
146 | 		i++
147 | 	}
148 | 
149 | 	p.Reminders = append(p.Reminders, reminder)
150 | 	copy(p.Reminders[i+1:], p.Reminders[i:])
151 | 	p.Reminders[i] = reminder
152 | 	p.TotalReminders++
153 | 
154 | 	return nil
155 | }
156 | 
157 | func (p *ReminderPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
158 | 	defer bruxism.MessageRecover()
159 | 
160 | 	if service.IsMe(message) {
161 | 		return
162 | 	}
163 | 
164 | 	requester := message.UserName()
165 | 	if service.Name() == bruxism.DiscordServiceName {
166 | 		requester = fmt.Sprintf("<@%s>", message.UserID())
167 | 	}
168 | 
169 | 	if bruxism.MatchesCommand(service, "remindlist", message) || bruxism.MatchesCommand(service, "reminderlist", message) {
170 | 		reminders := []string{}
171 | 		i := 0
172 | 		for _, r := range p.Reminders {
173 | 			if r.Requester == requester {
174 | 				reminders = append(reminders, fmt.Sprintf("%d - %s: %s", i, humanize.Time(r.Time), r.Message))
175 | 				i++
176 | 			}
177 | 		}
178 | 		if len(reminders) > 0 {
179 | 			if service.SupportsMultiline() {
180 | 				service.SendMessage(message.Channel(), fmt.Sprintf("Your reminders:\n%s", strings.Join(reminders, "\n")))
181 | 			} else {
182 | 				service.SendMessage(message.Channel(), fmt.Sprintf("Your reminders: %s", strings.Join(reminders, ". ")))
183 | 			}
184 | 		} else {
185 | 			service.SendMessage(message.Channel(), "You have no reminders.")
186 | 		}
187 | 		return
188 | 	}
189 | 
190 | 	if bruxism.MatchesCommand(service, "reminddelete", message) || bruxism.MatchesCommand(service, "reminderdelete", message) {
191 | 		index := 0
192 | 		indexString, parts := bruxism.ParseCommand(service, message)
193 | 		var err error
194 | 		if len(parts) > 0 {
195 | 			index, err = strconv.Atoi(indexString)
196 | 			if err != nil {
197 | 				service.SendMessage(message.Channel(), "Invalid reminder.")
198 | 				return
199 | 			}
200 | 		}
201 | 
202 | 		j := 0
203 | 		for i, r := range p.Reminders {
204 | 			if r.Requester == requester {
205 | 				if j == index {
206 | 					p.Lock()
207 | 					p.Reminders = append(p.Reminders[:i], p.Reminders[i+1:]...)
208 | 					p.Unlock()
209 | 					service.SendMessage(message.Channel(), "Reminder deleted.")
210 | 					return
211 | 				}
212 | 				j++
213 | 			}
214 | 		}
215 | 		return
216 | 	}
217 | 
218 | 	if !bruxism.MatchesCommand(service, "remind", message) && !bruxism.MatchesCommand(service, "reminder", message) {
219 | 		return
220 | 	}
221 | 
222 | 	_, parts := bruxism.ParseCommand(service, message)
223 | 
224 | 	if len(parts) < 2 {
225 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Invalid reminder, no time or message. eg: %s", p.randomReminder(service)))
226 | 		return
227 | 	}
228 | 
229 | 	t, r, err := p.parseReminder(parts)
230 | 
231 | 	now := time.Now()
232 | 
233 | 	if err != nil || t.Before(now) || t.After(now.Add(time.Hour*24*365+time.Hour)) {
234 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Invalid time. eg: %s", strings.Join(randomTimes, ", ")))
235 | 		return
236 | 	}
237 | 
238 | 	if r == "" {
239 | 		service.SendMessage(message.Channel(), fmt.Sprintf("Invalid reminder, no message. eg: %s", p.randomReminder(service)))
240 | 		return
241 | 	}
242 | 
243 | 	if service.Name() == bruxism.DiscordServiceName {
244 | 		if strings.Index(r, "<@") != -1 || strings.Index(strings.ToLower(r), "@everyone") != -1 || strings.Index(strings.ToLower(r), "@here") != -1 {
245 | 			service.SendMessage(message.Channel(), "Invalid reminder, no mentions, sorry.")
246 | 			return
247 | 		}
248 | 	}
249 | 
250 | 	t = t.Add(500 * time.Millisecond)
251 | 
252 | 	err = p.AddReminder(&Reminder{
253 | 		StartTime: now,
254 | 		Time:      t,
255 | 		Requester: requester,
256 | 		Target:    message.Channel(),
257 | 		Message:   r,
258 | 		IsPrivate: service.IsPrivate(message),
259 | 	})
260 | 	if err != nil {
261 | 		service.SendMessage(message.Channel(), err.Error())
262 | 		return
263 | 	}
264 | 
265 | 	service.SendMessage(message.Channel(), fmt.Sprintf("Reminder set for %s.", humanize.Time(t)))
266 | }
267 | 
268 | // SendReminder sends a reminder.
269 | func (p *ReminderPlugin) SendReminder(service bruxism.Service, reminder *Reminder) {
270 | 	if strings.Index(reminder.Message, "<@") != -1 || strings.Index(strings.ToLower(reminder.Message), "@everyone") != -1 || strings.Index(strings.ToLower(reminder.Message), "@here") != -1 {
271 | 		return
272 | 	}
273 | 
274 | 	if reminder.IsPrivate {
275 | 		service.SendMessage(reminder.Target, fmt.Sprintf("%s you set a reminder: %s", humanize.Time(reminder.StartTime), reminder.Message))
276 | 	} else {
277 | 		service.SendMessage(reminder.Target, fmt.Sprintf("%s %s set a reminder: %s", humanize.Time(reminder.StartTime), reminder.Requester, reminder.Message))
278 | 	}
279 | }
280 | 
281 | // Run will block until a reminder needs to be fired and then fire it.
282 | func (p *ReminderPlugin) Run(bot *bruxism.Bot, service bruxism.Service) {
283 | 	for {
284 | 		p.RLock()
285 | 
286 | 		if len(p.Reminders) > 0 {
287 | 			reminder := p.Reminders[0]
288 | 			if time.Now().After(reminder.Time) {
289 | 				p.RUnlock()
290 | 				if time.Now().Before(reminder.Time.Add(48 * time.Hour)) {
291 | 				  p.SendReminder(service, reminder)
292 | 				}
293 | 				p.Lock()
294 | 				p.Reminders = p.Reminders[1:]
295 | 				p.Unlock()
296 | 
297 | 				continue
298 | 			}
299 | 		}
300 | 
301 | 		p.RUnlock()
302 | 		time.Sleep(500 * time.Millisecond)
303 | 	}
304 | }
305 | 
306 | // Load will load plugin state from a byte array.
307 | func (p *ReminderPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
308 | 	if data != nil {
309 | 		if err := json.Unmarshal(data, p); err != nil {
310 | 			log.Println("Error loading data", err)
311 | 		}
312 | 	}
313 | 	if len(p.Reminders) > p.TotalReminders {
314 | 		p.TotalReminders = len(p.Reminders)
315 | 	}
316 | 
317 | 	go p.Run(bot, service)
318 | 	return nil
319 | }
320 | 
321 | // Save will save plugin state to a byte array.
322 | func (p *ReminderPlugin) Save() ([]byte, error) {
323 | 	return json.Marshal(p)
324 | }
325 | 
326 | // Stats will return the stats for a plugin.
327 | func (p *ReminderPlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
328 | 	return []string{fmt.Sprintf("Reminders: \t%s\n", humanize.Comma(int64(p.TotalReminders)))}
329 | }
330 | 
331 | // Name returns the name of the plugin.
332 | func (p *ReminderPlugin) Name() string {
333 | 	return "Reminder"
334 | }
335 | 
336 | // New will create a new Reminder plugin.
337 | func New() bruxism.Plugin {
338 | 	return &ReminderPlugin{
339 | 		Reminders: []*Reminder{},
340 | 	}
341 | }
342 | 


--------------------------------------------------------------------------------
/simpleplugin.go:
--------------------------------------------------------------------------------
 1 | package bruxism
 2 | 
 3 | // SimplePlugin is a simple wrapper around a Plugin that can implement handlers by function reference.
 4 | type SimplePlugin struct {
 5 | 	name        string
 6 | 	LoadFunc    LoadFunc    `json:"-"`
 7 | 	SaveFunc    SaveFunc    `json:"-"`
 8 | 	MessageFunc MessageFunc `json:"-"`
 9 | 	HelpFunc    HelpFunc    `json:"-"`
10 | 	StatsFunc   StatsFunc   `json:"-"`
11 | }
12 | 
13 | // Name returns the name of the plugin.
14 | func (p *SimplePlugin) Name() string {
15 | 	return p.name
16 | }
17 | 
18 | // Load will load plugin state from a byte array.
19 | func (p *SimplePlugin) Load(bot *Bot, service Service, data []byte) error {
20 | 	if p.LoadFunc != nil {
21 | 		return p.LoadFunc(bot, service, data)
22 | 	}
23 | 	return nil
24 | }
25 | 
26 | // Save will save plugin state to a byte array.
27 | func (p *SimplePlugin) Save() ([]byte, error) {
28 | 	if p.SaveFunc != nil {
29 | 		return p.SaveFunc()
30 | 	}
31 | 	return nil, nil
32 | }
33 | 
34 | // Help returns a list of help strings that are printed when the user requests them.
35 | func (p *SimplePlugin) Help(bot *Bot, service Service, message Message, detailed bool) []string {
36 | 	if p.HelpFunc != nil {
37 | 		return p.HelpFunc(bot, service, message, detailed)
38 | 	}
39 | 	return nil
40 | }
41 | 
42 | // Message handler.
43 | func (p *SimplePlugin) Message(bot *Bot, service Service, message Message) {
44 | 	defer MessageRecover()
45 | 	if p.MessageFunc != nil {
46 | 		p.MessageFunc(bot, service, message)
47 | 	}
48 | }
49 | 
50 | func (p *SimplePlugin) Stats(bot *Bot, service Service, message Message) []string {
51 | 	if p.StatsFunc != nil {
52 | 		return p.StatsFunc(bot, service, message)
53 | 	}
54 | 	return nil
55 | }
56 | 
57 | // NewSimplePlugin creates a new simple plugin.
58 | func NewSimplePlugin(name string) *SimplePlugin {
59 | 	return &SimplePlugin{name: name}
60 | }
61 | 


--------------------------------------------------------------------------------
/slack.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"fmt"
  6 | 	"io"
  7 | 
  8 | 	"github.com/nlopes/slack"
  9 | )
 10 | 
 11 | // SlackServiceName is the service name for the Slack service.
 12 | const SlackServiceName string = "Slack"
 13 | 
 14 | // SlackMessage is a Message wrapper around slack.MessageEvent.
 15 | type SlackMessage struct {
 16 | 	SlackMessage *slack.Msg
 17 | 	MessageType  MessageType
 18 | }
 19 | 
 20 | // Channel returns the channel id for this message.
 21 | func (m *SlackMessage) Channel() string {
 22 | 	return m.SlackMessage.Channel
 23 | }
 24 | 
 25 | // UserName returns the user name for this message.
 26 | func (m *SlackMessage) UserName() string {
 27 | 	return m.SlackMessage.Username
 28 | }
 29 | 
 30 | // UserID returns the user id for this message.
 31 | func (m *SlackMessage) UserID() string {
 32 | 	return m.SlackMessage.User
 33 | }
 34 | 
 35 | // UserAvatar returns the avatar url for this message.
 36 | func (m *SlackMessage) UserAvatar() string {
 37 | 	return ""
 38 | }
 39 | 
 40 | // Message returns the message content for this message.
 41 | func (m *SlackMessage) Message() string {
 42 | 	return m.SlackMessage.Text
 43 | }
 44 | 
 45 | // RawMessage returns the raw message content for this message.
 46 | func (m *SlackMessage) RawMessage() string {
 47 | 	return m.SlackMessage.Text
 48 | }
 49 | 
 50 | // MessageID returns the message ID for this message.
 51 | func (m *SlackMessage) MessageID() string {
 52 | 	return m.SlackMessage.Timestamp
 53 | }
 54 | 
 55 | // Type returns the type of message.
 56 | func (m *SlackMessage) Type() MessageType {
 57 | 	return m.MessageType
 58 | }
 59 | 
 60 | func (m *SlackMessage) MatchesCommand(prefix, command string) (bool, bool) {
 61 | 	return false, false
 62 | }
 63 | 
 64 | func (m *SlackMessage) ParseCommand(prefix string) (string, []string, bool) {
 65 | 	return "", []string{}, false
 66 | }
 67 | 
 68 | // Slack is a Service provider for Slack.
 69 | type Slack struct {
 70 | 	token       string
 71 | 	messageChan chan Message
 72 | 
 73 | 	Client *slack.Client
 74 | 	RTM    *slack.RTM
 75 | 	Me     *slack.AuthTestResponse
 76 | 
 77 | 	OwnerUserID string
 78 | }
 79 | 
 80 | // NewSlack creates a new Slack service.
 81 | func NewSlack(token string) *Slack {
 82 | 	return &Slack{
 83 | 		token:       token,
 84 | 		messageChan: make(chan Message, 200),
 85 | 	}
 86 | }
 87 | 
 88 | func (s *Slack) handle() {
 89 | 	for {
 90 | 		select {
 91 | 		case msg := <-s.RTM.IncomingEvents:
 92 | 			switch ev := msg.Data.(type) {
 93 | 			case *slack.MessageEvent:
 94 | 				switch ev.SubType {
 95 | 				case "message_changed":
 96 | 					s.messageChan <- &SlackMessage{ev.SubMessage, MessageTypeUpdate}
 97 | 				case "message_deleted":
 98 | 					ev.Msg.Timestamp = ev.Msg.DeletedTimestamp
 99 | 					s.messageChan <- &SlackMessage{&ev.Msg, MessageTypeDelete}
100 | 				case "":
101 | 					s.messageChan <- &SlackMessage{&ev.Msg, MessageTypeCreate}
102 | 				}
103 | 			}
104 | 		}
105 | 	}
106 | }
107 | 
108 | // Name returns the name of the service.
109 | func (s *Slack) Name() string {
110 | 	return SlackServiceName
111 | }
112 | 
113 | // Open opens the service and returns a channel which all messages will be sent on.
114 | func (s *Slack) Open() (<-chan Message, error) {
115 | 	s.Client = slack.New(s.token)
116 | 
117 | 	var err error
118 | 	s.Me, err = s.Client.AuthTest()
119 | 	if err != nil {
120 | 		return nil, err
121 | 	}
122 | 
123 | 	s.RTM = s.Client.NewRTM()
124 | 	go s.RTM.ManageConnection()
125 | 	go s.handle()
126 | 
127 | 	return s.messageChan, nil
128 | }
129 | 
130 | // IsMe returns whether or not a message was sent by the bot.
131 | func (s *Slack) IsMe(message Message) bool {
132 | 	return message.UserID() == s.Me.UserID
133 | }
134 | 
135 | // SendMessage sends a message.
136 | func (s *Slack) SendMessage(channel, message string) error {
137 | 	s.RTM.SendMessage(s.RTM.NewOutgoingMessage(message, channel))
138 | 	return nil
139 | }
140 | 
141 | // SendAction sends an action.
142 | func (s *Slack) SendAction(channel, message string) error {
143 | 	return s.SendMessage(channel, message)
144 | }
145 | 
146 | // DeleteMessage deletes a message.
147 | func (s *Slack) DeleteMessage(channel, messageID string) error {
148 | 	return errors.New("Slack does not support deleting messages.")
149 | }
150 | 
151 | // SendFile sends a file.
152 | func (s *Slack) SendFile(channel, name string, r io.Reader) error {
153 | 	return errors.New("Slack does not support sending files.")
154 | }
155 | 
156 | // BanUser bans a user.
157 | func (s *Slack) BanUser(channel, userID string, duration int) error {
158 | 	return errors.New("Slack does not support banning.")
159 | }
160 | 
161 | // UnbanUser unbans a user.
162 | func (s *Slack) UnbanUser(channel, userID string) error {
163 | 	return errors.New("Slack does not support unbanning.")
164 | }
165 | 
166 | // UserName returns the bots name.
167 | func (s *Slack) UserName() string {
168 | 	return s.Me.User
169 | }
170 | 
171 | // UserID returns the bots user id.
172 | func (s *Slack) UserID() string {
173 | 	return s.Me.UserID
174 | }
175 | 
176 | // Join accept an invite or return an error.
177 | func (s *Slack) Join(join string) error {
178 | 	_, err := s.Client.JoinChannel(join)
179 | 	return err
180 | }
181 | 
182 | // Typing sets that the bot is typing.
183 | func (s *Slack) Typing(channel string) error {
184 | 	s.RTM.SendMessage(s.RTM.NewTypingMessage(channel))
185 | 	return nil
186 | }
187 | 
188 | // PrivateMessage will send a private message to a user.
189 | func (s *Slack) PrivateMessage(userID, message string) error {
190 | 	s.RTM.SendMessage(s.RTM.NewOutgoingMessage(message, userID))
191 | 	return nil
192 | }
193 | 
194 | // SupportsPrivateMessages returns whether the service supports private messages.
195 | func (s *Slack) SupportsPrivateMessages() bool {
196 | 	return false
197 | }
198 | 
199 | // SupportsMultiline returns whether the service supports multiline messages.
200 | func (s *Slack) SupportsMultiline() bool {
201 | 	return true
202 | }
203 | 
204 | // CommandPrefix returns the command prefix for the service.
205 | func (s *Slack) CommandPrefix() string {
206 | 	return fmt.Sprintf("<@%s>: ", s.Me.UserID)
207 | }
208 | 
209 | // IsBotOwner returns whether or not a message sender was the owner of the bot.
210 | func (s *Slack) IsBotOwner(message Message) bool {
211 | 	return message.UserID() == s.OwnerUserID
212 | }
213 | 
214 | // IsPrivate returns whether or not a message was private.
215 | func (s *Slack) IsPrivate(message Message) bool {
216 | 	return false
217 | }
218 | 
219 | // IsChannelOwner returns whether or not the sender of a message is the owner.
220 | func (s *Slack) IsChannelOwner(message Message) bool {
221 | 	return false
222 | }
223 | 
224 | // IsModerator returns whether or not the sender of a message is a moderator.
225 | func (s *Slack) IsModerator(message Message) bool {
226 | 	return false
227 | }
228 | 
229 | // ChannelCount returns the number of channels the bot is in.
230 | func (s *Slack) ChannelCount() int {
231 | 	c, err := s.Client.GetChannels(true)
232 | 	if err != nil {
233 | 		return 0
234 | 	}
235 | 	return len(c)
236 | }
237 | 


--------------------------------------------------------------------------------
/statsplugin/statsplugin.go:
--------------------------------------------------------------------------------
  1 | package statsplugin
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"runtime"
  7 | 	"sort"
  8 | 	"strconv"
  9 | 	"strings"
 10 | 	"text/tabwriter"
 11 | 	"time"
 12 | 
 13 | 	"github.com/bwmarrin/discordgo"
 14 | 	"github.com/dustin/go-humanize"
 15 | 	"github.com/iopred/bruxism"
 16 | )
 17 | 
 18 | var statsStartTime = time.Now()
 19 | 
 20 | func getDurationString(duration time.Duration) string {
 21 | 	return fmt.Sprintf(
 22 | 		"%0.2d:%02d:%02d",
 23 | 		int(duration.Hours()),
 24 | 		int(duration.Minutes())%60,
 25 | 		int(duration.Seconds())%60,
 26 | 	)
 27 | }
 28 | 
 29 | // StatsCommand returns bot statistics.
 30 | func StatsCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) {
 31 | 	stats := runtime.MemStats{}
 32 | 	runtime.ReadMemStats(&stats)
 33 | 
 34 | 	w := &tabwriter.Writer{}
 35 | 	buf := &bytes.Buffer{}
 36 | 
 37 | 	w.Init(buf, 0, 4, 0, ' ', 0)
 38 | 	if service.Name() == bruxism.DiscordServiceName {
 39 | 		fmt.Fprintf(w, "```\n")
 40 | 	}
 41 | 	fmt.Fprintf(w, "Bruxism: \t%s\n", bruxism.VersionString)
 42 | 	if service.Name() == bruxism.DiscordServiceName {
 43 | 		fmt.Fprintf(w, "Discordgo: \t%s\n", discordgo.VERSION)
 44 | 	}
 45 | 	fmt.Fprintf(w, "Go: \t%s\n", runtime.Version())
 46 | 	fmt.Fprintf(w, "Uptime: \t%s\n", getDurationString(time.Now().Sub(statsStartTime)))
 47 | 	fmt.Fprintf(w, "Memory used: \t%s / %s (%s garbage collected)\n", humanize.Bytes(stats.Alloc), humanize.Bytes(stats.Sys), humanize.Bytes(stats.TotalAlloc))
 48 | 	fmt.Fprintf(w, "Concurrent tasks: \t%s\n",  humanize.Comma(int64(runtime.NumGoroutine())))
 49 | 	if service.Name() == bruxism.DiscordServiceName {
 50 | 		discord := service.(*bruxism.Discord)
 51 | 		fmt.Fprintf(w, "Connected servers: \t%s\n",  humanize.Comma(int64(service.ChannelCount())))
 52 | 		if len(discord.Sessions) > 1 {
 53 | 			shards := 0
 54 | 			for _, s := range discord.Sessions {
 55 | 				if s.DataReady {
 56 | 					shards++
 57 | 				}
 58 | 			}
 59 | 			if shards == len(discord.Sessions) {
 60 | 				fmt.Fprintf(w, "Shards: \t%d\n", shards)
 61 | 			} else {
 62 | 				fmt.Fprintf(w, "Shards: \t%d (%d connected)\n", len(discord.Sessions), shards)
 63 | 			}
 64 | 			guild, err := discord.Channel(message.Channel())
 65 | 			if err == nil {
 66 | 				id, err := strconv.Atoi(guild.ID)
 67 | 				if err == nil {
 68 | 					fmt.Fprintf(w, "Current shard: \t%d\n", ((id>>22)%len(discord.Sessions) + 1))
 69 | 				}
 70 | 			}
 71 | 		}
 72 | 	} else {
 73 | 		fmt.Fprintf(w, "Connected channels: \t%s\n",  humanize.Comma(int64(service.ChannelCount())))
 74 | 	}
 75 | 
 76 | 	plugins := bot.Services[service.Name()].Plugins
 77 | 	names := []string{}
 78 | 	for _, plugin := range plugins {
 79 | 		names = append(names, plugin.Name())
 80 | 		sort.Strings(names)
 81 | 	}
 82 | 
 83 | 	for _, name := range names {
 84 | 		stats := plugins[name].Stats(bot, service, message)
 85 | 		for _, stat := range stats {
 86 | 			fmt.Fprint(w, stat)
 87 | 		}
 88 | 	}
 89 | 
 90 | 	if service.Name() == bruxism.DiscordServiceName {
 91 | 		fmt.Fprintf(w, "\n```")
 92 | 	}
 93 | 
 94 | 	w.Flush()
 95 | 	out := buf.String()
 96 | 
 97 | 	end := ""
 98 | 	if IsSeptapus {
 99 | 		end += "Septapus community: <https://discord.gg/HWN9pwj>\nPatreon: <https://www.patreon.com/iopred>\nBuilt with love by iopred."
100 | 	}
101 | 
102 | 	if service.SupportsMultiline() {
103 | 		if end != "" {
104 | 			out += "\n" + end
105 | 		}
106 | 		service.SendMessage(message.Channel(), out)
107 | 	} else {
108 | 		service.SendMessage(message.Channel(), strings.Join(strings.Split(out, "\n"), " "))
109 | 		service.SendMessage(message.Channel(), strings.Join(strings.Split(end, "\n"), " "))
110 | 	}
111 | }
112 | 
113 | var IsSeptapus bool = false
114 | 
115 | // StatsHelp is the help for the stats command.
116 | var StatsHelp = bruxism.NewCommandHelp("", "Lists bot statistics.")
117 | 


--------------------------------------------------------------------------------
/streamerplugin/streamerplugin.go:
--------------------------------------------------------------------------------
  1 | package streamerplugin
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"time"
  6 | 
  7 | 	"github.com/dustin/go-humanize"
  8 | 	"github.com/iopred/bruxism"
  9 | )
 10 | 
 11 | type streamerPluginRequest struct {
 12 | 	lastUpdate  time.Time
 13 | 	lastMessage string
 14 | }
 15 | 
 16 | type streamerPlugin struct {
 17 | 	bruxism.SimplePlugin
 18 | 	youTube  *bruxism.YouTube
 19 | 	requests map[string]*streamerPluginRequest
 20 | }
 21 | 
 22 | func (p *streamerPlugin) helpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 23 | 	if detailed {
 24 | 		return nil
 25 | 	}
 26 | 	return bruxism.CommandHelp(service, "streamer", "<streamername|streamerid>", "Grabs details about a YouTube streamer.")
 27 | }
 28 | 
 29 | func (p *streamerPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
 30 | 	if service.IsMe(message) {
 31 | 		return
 32 | 	}
 33 | 
 34 | 	if !bruxism.MatchesCommand(service, "streamer", message) {
 35 | 		return
 36 | 	}
 37 | 
 38 | 	query, parts := bruxism.ParseCommand(service, message)
 39 | 
 40 | 	if len(parts) == 0 {
 41 | 		return
 42 | 	}
 43 | 
 44 | 	r, _ := p.requests[query]
 45 | 	if r == nil {
 46 | 		r = &streamerPluginRequest{}
 47 | 		p.requests[query] = r
 48 | 	}
 49 | 
 50 | 	n := time.Now()
 51 | 	if !n.After(r.lastUpdate.Add(60 * time.Minute)) {
 52 | 		if r.lastMessage != "" {
 53 | 			service.SendMessage(message.Channel(), fmt.Sprintf("%s *Last updated %s.*", r.lastMessage, humanize.Time(r.lastUpdate)))
 54 | 		}
 55 | 		return
 56 | 	}
 57 | 
 58 | 	service.Typing(message.Channel())
 59 | 
 60 | 	r.lastUpdate = n
 61 | 
 62 | 	m, err := p.streamer(query, service.Name() == bruxism.DiscordServiceName)
 63 | 	if err != nil {
 64 | 		service.SendMessage(message.Channel(), "There was an error while requesting the streamer, please try again later.")
 65 | 		return
 66 | 	}
 67 | 
 68 | 	service.SendMessage(message.Channel(), m)
 69 | 	r.lastMessage = m
 70 | }
 71 | 
 72 | func (p *streamerPlugin) streamer(search string, bold bool) (string, error) {
 73 | 	channelList, err := p.youTube.Service.Channels.List([]string{"id", "snippet", "statistics"}).ForUsername(search).Do()
 74 | 
 75 | 	if err != nil {
 76 | 		return "", nil
 77 | 	}
 78 | 
 79 | 	// If a straight username lookup failed, do a search.
 80 | 	if len(channelList.Items) == 0 {
 81 | 		list, err := p.youTube.Service.Search.List([]string{"id"}).Q(search).Type("channel").Do()
 82 | 
 83 | 		if err != nil {
 84 | 			return "", err
 85 | 		}
 86 | 
 87 | 		if len(list.Items) == 0 {
 88 | 			return "No users found with that name.", nil
 89 | 		}
 90 | 
 91 | 		channelList, err = p.youTube.Service.Channels.List([]string{"id", "snippet", "statistics"}).Id(list.Items[0].Id.ChannelId).Do()
 92 | 
 93 | 		if err != nil {
 94 | 			return "", nil
 95 | 		}
 96 | 
 97 | 		if len(channelList.Items) == 0 {
 98 | 			return "No users found with that name.", nil
 99 | 		}
100 | 	}
101 | 
102 | 	subscriberCount := ""
103 | 	if !channelList.Items[0].Statistics.HiddenSubscriberCount {
104 | 		subscriberCount = fmt.Sprintf("%s subscribers, ", humanize.Comma(int64(channelList.Items[0].Statistics.SubscriberCount)))
105 | 	}
106 | 
107 | 	b := ""
108 | 	if bold {
109 | 		b = "**"
110 | 	}
111 | 
112 | 	liveText := ""
113 | 
114 | 	liveVideos, err := p.youTube.GetLiveVideos(channelList.Items[0].Id)
115 | 	if err == nil && len(liveVideos) > 0 {
116 | 		liveText = fmt.Sprintf(" %sCurrently live: https://gaming.youtube.com/watch?v=%s%s", b, liveVideos[0].Id, b)
117 | 	}
118 | 
119 | 	return fmt.Sprintf("%s%s%s: %s%s videos, %s views.%s", b, channelList.Items[0].Snippet.Title, b, subscriberCount, humanize.Comma(int64(channelList.Items[0].Statistics.VideoCount)), humanize.Comma(int64(channelList.Items[0].Statistics.ViewCount)), liveText), nil
120 | }
121 | 
122 | // New will create a new streamer plugin.
123 | func New(yt *bruxism.YouTube) bruxism.Plugin {
124 | 	p := &streamerPlugin{
125 | 		SimplePlugin: *bruxism.NewSimplePlugin("Streamer"),
126 | 		youTube:      yt,
127 | 		requests:     make(map[string]*streamerPluginRequest),
128 | 	}
129 | 	p.MessageFunc = p.messageFunc
130 | 	p.HelpFunc = p.helpFunc
131 | 	return p
132 | }
133 | 


--------------------------------------------------------------------------------
/topstreamersplugin/topstreamersplugin.go:
--------------------------------------------------------------------------------
 1 | package topstreamersplugin
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"fmt"
 6 | 	"strings"
 7 | 	"time"
 8 | 
 9 | 	"github.com/dustin/go-humanize"
10 | 	"github.com/iopred/bruxism"
11 | )
12 | 
13 | type topStreamersPlugin struct {
14 | 	bruxism.SimplePlugin
15 | 	youTube     *bruxism.YouTube
16 | 	lastUpdate  time.Time
17 | 	lastMessage string
18 | }
19 | 
20 | func (p *topStreamersPlugin) helpFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
21 | 	if detailed {
22 | 		return nil
23 | 	}
24 | 	return bruxism.CommandHelp(service, "topstreamers", "", "List the current top streamers on YouTube Gaming.")
25 | }
26 | 
27 | func (p *topStreamersPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
28 | 	if service.IsMe(message) {
29 | 		return
30 | 	}
31 | 
32 | 	if !bruxism.MatchesCommand(service, "topstreamers", message) {
33 | 		return
34 | 	}
35 | 
36 | 	n := time.Now()
37 | 	if !n.After(p.lastUpdate.Add(1 * time.Minute)) {
38 | 		if p.lastMessage != "" {
39 | 			service.SendMessage(message.Channel(), fmt.Sprintf("%s *Last updated %s.*", p.lastMessage, humanize.Time(p.lastUpdate)))
40 | 		}
41 | 		return
42 | 	}
43 | 
44 | 	service.Typing(message.Channel())
45 | 
46 | 	p.lastUpdate = n
47 | 
48 | 	m, err := p.topStreamers(5)
49 | 	if err != nil {
50 | 		service.SendMessage(message.Channel(), "There was an error while requesting the top streamers, please try again later.")
51 | 		return
52 | 	}
53 | 
54 | 	service.SendMessage(message.Channel(), m)
55 | 	p.lastMessage = m
56 | }
57 | 
58 | func (p *topStreamersPlugin) topStreamers(count int) (string, error) {
59 | 	videoList, err := p.youTube.GetTopLivestreams(200)
60 | 	if err != nil {
61 | 		return "", err
62 | 	}
63 | 
64 | 	if len(videoList) == 0 {
65 | 		return "", errors.New("No videos returned.")
66 | 	}
67 | 
68 | 	channels := []string{}
69 | 
70 | 	for i, video := range videoList {
71 | 		channels = append(channels, fmt.Sprintf("%s (%s)", video.Snippet.ChannelTitle, humanize.Comma(int64(video.LiveStreamingDetails.ConcurrentViewers))))
72 | 		if i >= count {
73 | 			break
74 | 		}
75 | 	}
76 | 
77 | 	return fmt.Sprintf("Current YouTube Gaming top streamers: %s.", strings.Join(channels, ", ")), nil
78 | }
79 | 
80 | // New will create a new top streamers plugin.
81 | func New(yt *bruxism.YouTube) bruxism.Plugin {
82 | 	p := &topStreamersPlugin{
83 | 		SimplePlugin: *bruxism.NewSimplePlugin("TopStreamers"),
84 | 		youTube:      yt,
85 | 	}
86 | 	p.MessageFunc = p.messageFunc
87 | 	p.HelpFunc = p.helpFunc
88 | 	return p
89 | }
90 | 


--------------------------------------------------------------------------------
/triviaplugin/triviaplugin.go:
--------------------------------------------------------------------------------
  1 | package triviaplugin
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"math/rand"
  8 | 	"strings"
  9 | 	"sync"
 10 | 	"time"
 11 | 
 12 | 	"github.com/iopred/bruxism"
 13 | )
 14 | 
 15 | type question struct {
 16 | 	Question string
 17 | 	Answer   string
 18 | }
 19 | 
 20 | type questions []*question
 21 | 
 22 | func (q questions) Question() *question {
 23 | 	r := q[rand.Intn(len(q))]
 24 | 	if r == nil {
 25 | 		return q.Question()
 26 | 	}
 27 | 	return r
 28 | }
 29 | 
 30 | type trivia struct {
 31 | 	All    questions
 32 | 	Themes map[string]questions
 33 | }
 34 | 
 35 | func (t *trivia) Question(theme string) *question {
 36 | 	q, ok := t.Themes[theme]
 37 | 	if !ok {
 38 | 		q = t.All
 39 | 	}
 40 | 	return q.Question()
 41 | }
 42 | 
 43 | var triviaQuestions *trivia = &trivia{
 44 | 	All:    questions{},
 45 | 	Themes: map[string]questions{},
 46 | }
 47 | 
 48 | type triviaScore struct {
 49 | 	Name  string
 50 | 	Score int
 51 | }
 52 | 
 53 | type triviaChannel struct {
 54 | 	sync.RWMutex
 55 | 
 56 | 	Channel    string
 57 | 	Active     bool
 58 | 	Theme      string
 59 | 	Unanswered int
 60 | 
 61 | 	Answer string
 62 | 	Hint   string
 63 | 	Asked  time.Time
 64 | 
 65 | 	Scores map[string]*triviaScore
 66 | 
 67 | 	hintChan chan bool
 68 | }
 69 | 
 70 | func (t *triviaChannel) Start(bot *bruxism.Bot, service bruxism.Service, theme string) {
 71 | 	t.Lock()
 72 | 	defer t.Unlock()
 73 | 
 74 | 	if t.Active {
 75 | 		return
 76 | 	}
 77 | 
 78 | 	service.SendMessage(t.Channel, "Trivia started.")
 79 | 
 80 | 	t.Active = true
 81 | 	t.Theme = theme
 82 | 	t.Unanswered = 0
 83 | 
 84 | 	go t.question(bot, service)
 85 | 
 86 | 	return
 87 | }
 88 | 
 89 | func (t *triviaChannel) Stop(bot *bruxism.Bot, service bruxism.Service) {
 90 | 	t.Lock()
 91 | 	defer t.Unlock()
 92 | 
 93 | 	if !t.Active {
 94 | 		return
 95 | 	}
 96 | 
 97 | 	t.Active = false
 98 | 	if t.hintChan != nil {
 99 | 		close(t.hintChan)
100 | 		t.hintChan = nil
101 | 	}
102 | 
103 | 	service.SendMessage(t.Channel, "Trivia stopped.")
104 | 
105 | 	return
106 | }
107 | 
108 | func (t *triviaChannel) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
109 | 	if strings.ToLower(message.Message()) == t.Answer {
110 | 		t.Lock()
111 | 		defer t.Unlock()
112 | 
113 | 		if !t.Active {
114 | 			return
115 | 		}
116 | 
117 | 		ts := t.Scores[message.UserID()]
118 | 		if ts == nil {
119 | 			ts = &triviaScore{}
120 | 			t.Scores[message.UserID()] = ts
121 | 		}
122 | 		ts.Name = message.UserName()
123 | 		ts.Score++
124 | 
125 | 		service.SendMessage(message.Channel(), fmt.Sprintf("%s got it! The answer was %s.", message.UserName(), t.Answer))
126 | 		service.SendMessage(message.Channel(), fmt.Sprintf("%s answered in %d seconds and their score is now %d.", message.UserName(), int(time.Now().Sub(t.Asked).Seconds()), ts.Score))
127 | 
128 | 		t.Unanswered = 0
129 | 
130 | 		if t.hintChan != nil {
131 | 			close(t.hintChan)
132 | 			t.hintChan = nil
133 | 		}
134 | 	}
135 | }
136 | 
137 | func (t *triviaChannel) question(bot *bruxism.Bot, service bruxism.Service) {
138 | 	t.Lock()
139 | 	question := triviaQuestions.Question(t.Theme)
140 | 
141 | 	hintChan := make(chan bool)
142 | 	t.hintChan = hintChan
143 | 	t.Answer = strings.ToLower(question.Answer)
144 | 	t.Asked = time.Now()
145 | 	t.Unlock()
146 | 
147 | 	service.SendMessage(t.Channel, question.Question)
148 | 
149 | 	answer := strings.Split(question.Answer, "")
150 | 	hint := make([]string, len(answer))
151 | 
152 | 	chars := 0
153 | 	for i, s := range answer {
154 | 		if s == " " {
155 | 			hint[i] = " "
156 | 		} else {
157 | 			chars++
158 | 			hint[i] = "-"
159 | 		}
160 | 	}
161 | 
162 | 	hints := 3
163 | 	if hints > chars {
164 | 		hints = chars
165 | 	}
166 | 
167 | 	hintTime := (time.Minute * 4) / time.Duration(hints+1)
168 | 	hintCount := chars / (hints + 1)
169 | 
170 | 	func() {
171 | 		for {
172 | 			select {
173 | 			case <-hintChan:
174 | 				return
175 | 			case <-time.After(hintTime):
176 | 				if hints == 0 {
177 | 					service.SendMessage(t.Channel, fmt.Sprintf("Time's up! The answer was: %s.", question.Answer))
178 | 					t.Lock()
179 | 					t.Unanswered++
180 | 					if t.Unanswered > 4 {
181 | 						service.SendMessage(t.Channel, "Too many unanswered questions. Trivia stopped.")
182 | 						t.Active = false
183 | 					}
184 | 					t.Unlock()
185 | 					return
186 | 				} else {
187 | 					hints--
188 | 
189 | 					service.SendMessage(t.Channel, "Hint: "+strings.Join(hint, ""))
190 | 
191 | 					for i := 0; i < hintCount; i++ {
192 | 						for {
193 | 							r := rand.Intn(len(hint))
194 | 							if hint[r] == "-" {
195 | 								hint[r] = answer[r]
196 | 								break
197 | 							}
198 | 						}
199 | 					}
200 | 				}
201 | 			}
202 | 		}
203 | 	}()
204 | 
205 | 	t.RLock()
206 | 	defer t.RUnlock()
207 | 	if t.Active {
208 | 		go t.question(bot, service)
209 | 	}
210 | }
211 | 
212 | type triviaPlugin struct {
213 | 	sync.RWMutex
214 | 	// Map from ChannelID -> triviaChannel
215 | 	Channels map[string]*triviaChannel
216 | }
217 | 
218 | // Name returns the name of the plugin.
219 | func (p *triviaPlugin) Name() string {
220 | 	return "Trivia"
221 | }
222 | 
223 | // Load will load plugin state from a byte array.
224 | func (p *triviaPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
225 | 	if data != nil {
226 | 		if err := json.Unmarshal(data, p); err != nil {
227 | 			log.Println("Error loading data", err)
228 | 		}
229 | 	}
230 | 
231 | 	for _, t := range p.Channels {
232 | 		if t.Active {
233 | 			go t.question(bot, service)
234 | 		}
235 | 	}
236 | 
237 | 	return nil
238 | }
239 | 
240 | // Save will save plugin state to a byte array.
241 | func (p *triviaPlugin) Save() ([]byte, error) {
242 | 	return json.Marshal(p)
243 | }
244 | 
245 | // Help returns a list of help strings that are printed when the user requests them.
246 | func (p *triviaPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
247 | 	if service.IsPrivate(message) || !service.IsModerator(message) {
248 | 		return nil
249 | 	}
250 | 
251 | 	return []string{
252 | 		bruxism.CommandHelp(service, "trivia", "<start|stop>", "Starts or stops trivia.")[0],
253 | 		bruxism.CommandHelp(service, "trivia", "<score>", "Returns your current trivia score.")[0],
254 | 	}
255 | }
256 | 
257 | // Message handler.
258 | func (p *triviaPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
259 | 	defer bruxism.MessageRecover()
260 | 
261 | 	if service.IsMe(message) {
262 | 		return
263 | 	}
264 | 
265 | 	messageChannel := message.Channel()
266 | 
267 | 	isCommand := bruxism.MatchesCommand(service, "trivia", message)
268 | 
269 | 	if isCommand && service.IsPrivate(message) {
270 | 		service.SendMessage(message.Channel(), "Sorry, this command doesn't work in private chat.")
271 | 		return
272 | 	}
273 | 
274 | 	if isCommand && service.IsModerator(message) {
275 | 		p.Lock()
276 | 		tc := p.Channels[messageChannel]
277 | 		if tc == nil {
278 | 			tc = &triviaChannel{
279 | 				Channel: messageChannel,
280 | 				Scores:  map[string]*triviaScore{},
281 | 			}
282 | 			p.Channels[messageChannel] = tc
283 | 		}
284 | 		p.Unlock()
285 | 
286 | 		_, parts := bruxism.ParseCommand(service, message)
287 | 
288 | 		if len(parts) == 0 {
289 | 			return
290 | 		}
291 | 
292 | 		switch parts[0] {
293 | 		case "start":
294 | 			theme := ""
295 | 			if len(parts) >= 2 {
296 | 				theme = parts[1]
297 | 			}
298 | 			tc.Start(bot, service, theme)
299 | 		case "stop":
300 | 			tc.Stop(bot, service)
301 | 		}
302 | 
303 | 	} else {
304 | 		if isCommand {
305 | 			_, parts := bruxism.ParseCommand(service, message)
306 | 			if len(parts) == 0 {
307 | 				return
308 | 			}
309 | 			if parts[0] == "score" {
310 | 				p.RLock()
311 | 				tc := p.Channels[messageChannel]
312 | 
313 | 				if tc != nil {
314 | 					ts := tc.Scores[message.UserID()]
315 | 					if ts != nil {
316 | 						service.SendMessage(message.Channel(), fmt.Sprintf("%s's score is %d.", message.UserName(), ts.Score))
317 | 					} else {
318 | 						service.SendMessage(message.Channel(), fmt.Sprintf("%s's score is 0.", message.UserName()))
319 | 					}
320 | 				}
321 | 
322 | 				p.RUnlock()
323 | 			}
324 | 
325 | 			return
326 | 		}
327 | 
328 | 		p.RLock()
329 | 		tc := p.Channels[messageChannel]
330 | 		p.RUnlock()
331 | 		if tc != nil {
332 | 			tc.Message(bot, service, message)
333 | 		}
334 | 	}
335 | }
336 | 
337 | // Stats will return the stats for a plugin.
338 | func (p *triviaPlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
339 | 	return nil
340 | }
341 | 
342 | // New will create a new trivia plugin.
343 | func New() bruxism.Plugin {
344 | 	return &triviaPlugin{
345 | 		Channels: map[string]*triviaChannel{},
346 | 	}
347 | }
348 | 


--------------------------------------------------------------------------------
/youtube.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"html"
  8 | 	"io"
  9 | 	"io/ioutil"
 10 | 	"log"
 11 | 	"net/http"
 12 | 	"sort"
 13 | 	"strings"
 14 | 	"time"
 15 | 
 16 | 	"github.com/atotto/clipboard"
 17 | 	"google.golang.org/api/youtube/v3"
 18 | 
 19 | 	"golang.org/x/oauth2"
 20 | 	"golang.org/x/oauth2/google"
 21 | )
 22 | 
 23 | // YouTubeServiceName is the service name for the YouTube service.
 24 | const YouTubeServiceName string = "YouTube"
 25 | 
 26 | // Enums for LiveMessageSnippet types.
 27 | const (
 28 | 	LiveChatMessageSnippetTypeText       string = "textMessageEvent"
 29 | 	LiveChatMessageSnippetTypeFanFunding string = "fanFundingEvent"
 30 | )
 31 | 
 32 | // Enums for LiveChatBanSnippet types.
 33 | const (
 34 | 	LiveChatBanSnippetTypeTemporary string = "temporary"
 35 | 	LiveChatBanSnippetTypePermanent        = "permanent"
 36 | )
 37 | 
 38 | const (
 39 | 	LiveChatEndedEvent string = "chatEndedEvent"
 40 | )
 41 | 
 42 | // LiveChatMessage is a Message wrapper around youtube.LiveChatMessage.
 43 | type LiveChatMessage youtube.LiveChatMessage
 44 | 
 45 | // Channel returns the channel id for this message.
 46 | func (m *LiveChatMessage) Channel() string {
 47 | 	return m.Snippet.LiveChatId
 48 | }
 49 | 
 50 | // UserName returns the user name for this message.
 51 | func (m *LiveChatMessage) UserName() string {
 52 | 	return m.AuthorDetails.DisplayName
 53 | }
 54 | 
 55 | // UserID returns the user id for this message.
 56 | func (m *LiveChatMessage) UserID() string {
 57 | 	return m.AuthorDetails.ChannelId
 58 | }
 59 | 
 60 | // UserAvatar returns the avatar url for this message.
 61 | func (m *LiveChatMessage) UserAvatar() string {
 62 | 	return m.AuthorDetails.ProfileImageUrl
 63 | }
 64 | 
 65 | // Message returns the message content for this message.
 66 | func (m *LiveChatMessage) Message() string {
 67 | 	switch m.Snippet.Type {
 68 | 	case LiveChatMessageSnippetTypeText:
 69 | 		return html.UnescapeString(m.Snippet.TextMessageDetails.MessageText)
 70 | 	}
 71 | 	return html.UnescapeString(m.Snippet.DisplayMessage)
 72 | }
 73 | 
 74 | // RawMessage returns the message content for this message.
 75 | func (m *LiveChatMessage) RawMessage() string {
 76 | 	switch m.Snippet.Type {
 77 | 	case LiveChatMessageSnippetTypeText:
 78 | 		return m.Snippet.TextMessageDetails.MessageText
 79 | 	}
 80 | 	return m.Snippet.DisplayMessage
 81 | }
 82 | 
 83 | // MessageID returns the message ID for this message.
 84 | func (m *LiveChatMessage) MessageID() string {
 85 | 	return m.Id
 86 | }
 87 | 
 88 | // Type returns the type of message.
 89 | func (m *LiveChatMessage) Type() MessageType {
 90 | 	return MessageTypeCreate
 91 | }
 92 | 
 93 | func (m *LiveChatMessage) MatchesCommand(prefix, command string) (bool, bool) {
 94 | 	return false, false
 95 | }
 96 | 
 97 | func (m *LiveChatMessage) ParseCommand(prefix string) (string, []string, bool) {
 98 | 	return "", []string{}, false
 99 | }
100 | 
101 | // YouTube is a Service provider for YouTube.
102 | type YouTube struct {
103 | 	url                bool
104 | 	auth               string
105 | 	configFilename     string
106 | 	tokenFilename      string
107 | 	config             *oauth2.Config
108 | 	token              *oauth2.Token
109 | 	Client             *http.Client
110 | 	Service            *youtube.Service
111 | 	messageChan        chan Message
112 | 	InsertChan         chan interface{}
113 | 	DeleteChan         chan interface{}
114 | 	me                 *youtube.Channel
115 | 	channelCount       int
116 | 	joined             map[string]string
117 | 	chatToVideo        map[string]string
118 | 	videoToChat        map[string]string
119 | 	videoToChannel     map[string]string
120 | 	videoToChannelName map[string]string
121 | }
122 | 
123 | // NewYouTube creates a new YouTube service.
124 | func NewYouTube(url bool, auth, configFilename, tokenFilename string) *YouTube {
125 | 	return &YouTube{
126 | 		url:                url,
127 | 		auth:               auth,
128 | 		configFilename:     configFilename,
129 | 		tokenFilename:      tokenFilename,
130 | 		messageChan:        make(chan Message, 200),
131 | 		InsertChan:         make(chan interface{}, 200),
132 | 		DeleteChan:         make(chan interface{}, 200),
133 | 		joined:             make(map[string]string),
134 | 		chatToVideo:        map[string]string{},
135 | 		videoToChat:        map[string]string{},
136 | 		videoToChannel:     map[string]string{},
137 | 		videoToChannelName: map[string]string{},
138 | 	}
139 | }
140 | 
141 | // JoinVideo joins a Video and monitors it for messages on the default message channel.
142 | func (yt *YouTube) JoinVideo(video *youtube.Video) error {
143 | 	return yt.joinVideo(video, yt.messageChan)
144 | }
145 | 
146 | func (yt *YouTube) joinVideo(video *youtube.Video, messageChan chan Message) error {
147 | 	videoID := video.Id
148 | 
149 | 	if yt.joined[videoID] != "" {
150 | 		return ErrAlreadyJoined
151 | 	}
152 | 
153 | 	if video == nil || video.Snippet == nil || video.LiveStreamingDetails == nil || video.LiveStreamingDetails.ActiveLiveChatId == "" {
154 | 		return errors.New("Invalid video")
155 | 	}
156 | 
157 | 	chat := video.LiveStreamingDetails.ActiveLiveChatId
158 | 
159 | 	// If we already have joined this chat, make sure to clear up the old insteance.
160 | 	// This can happen with streamnow.
161 | 	if yt.chatToVideo[chat] != "" {
162 | 		if yt.joined[yt.chatToVideo[chat]] != "" {
163 | 			delete(yt.joined, yt.chatToVideo[chat])
164 | 		}
165 | 	}
166 | 
167 | 	yt.joined[videoID] = chat
168 | 	yt.chatToVideo[chat] = videoID
169 | 	yt.videoToChat[videoID] = chat
170 | 	yt.videoToChannel[videoID] = video.Snippet.ChannelId
171 | 	yt.videoToChannelName[videoID] = video.Snippet.ChannelTitle
172 | 
173 | 	go func() {
174 | 		defer func() {
175 | 			delete(yt.joined, videoID)
176 | 			if messageChan != yt.messageChan {
177 | 				close(messageChan)
178 | 			}
179 | 		}()
180 | 
181 | 		errors := 0
182 | 
183 | 		yt.channelCount++
184 | 		pageToken := ""
185 | 		for {
186 | 			// We have been asked to leave.
187 | 			if yt.joined[videoID] == "" {
188 | 				return
189 | 			}
190 | 
191 | 			list := yt.Service.LiveChatMessages.List(chat, []string{"id","snippet","authorDetails"}).MaxResults(200)
192 | 			if pageToken != "" {
193 | 				list.PageToken(pageToken)
194 | 			}
195 | 
196 | 			liveChatMessageListResponse, err := list.Do()
197 | 
198 | 			if err != nil {
199 | 				errors++
200 | 				if errors > 10 {
201 | 					return
202 | 				}
203 | 			} else {
204 | 				errors = 0
205 | 				// Ignore the first results, we only want new chats.
206 | 				if pageToken != "" {
207 | 					for _, message := range liveChatMessageListResponse.Items {
208 | 						// Use video IDs internally.
209 | 						message.Snippet.LiveChatId = videoID
210 | 						liveChatMessage := LiveChatMessage(*message)
211 | 						messageChan <- &liveChatMessage
212 | 
213 | 						switch message.Snippet.Type {
214 | 						case LiveChatEndedEvent:
215 | 							return
216 | 						}
217 | 					}
218 | 				}
219 | 				pageToken = liveChatMessageListResponse.NextPageToken
220 | 			}
221 | 
222 | 			if liveChatMessageListResponse != nil && liveChatMessageListResponse.PollingIntervalMillis != 0 {
223 | 				time.Sleep(time.Duration(liveChatMessageListResponse.PollingIntervalMillis) * time.Millisecond)
224 | 			} else {
225 | 				time.Sleep(10 * time.Second)
226 | 			}
227 | 		}
228 | 	}()
229 | 
230 | 	return nil
231 | }
232 | 
233 | func (yt *YouTube) generateOauthURLAndExit() {
234 | 	// Redirect user to Google's consent page to ask for permission
235 | 	// for the scopes specified above.
236 | 	url := yt.config.AuthCodeURL("state", oauth2.AccessTypeOffline, oauth2.ApprovalForce)
237 | 	clipboard.WriteAll(url)
238 | 	log.Fatalf("Visit the following URL to generate an auth code, then rerun with -auth=<code> (It has also been copied to your clipboard):\n%s", url)
239 | }
240 | 
241 | func (yt *YouTube) createConfig() error {
242 | 	b, err := ioutil.ReadFile(yt.configFilename)
243 | 	if err != nil {
244 | 		return err
245 | 	}
246 | 
247 | 	yt.config, err = google.ConfigFromJSON(b, "https://www.googleapis.com/auth/youtube")
248 | 	return err
249 | }
250 | 
251 | func (yt *YouTube) createToken() error {
252 | 	if yt.auth != "" {
253 | 		// Let's exchange our code
254 | 		tok, err := yt.config.Exchange(oauth2.NoContext, yt.auth)
255 | 		if err != nil {
256 | 			return err
257 | 		}
258 | 		yt.token = tok
259 | 
260 | 		b, err := json.Marshal(yt.token)
261 | 		if err != nil {
262 | 			return err
263 | 		}
264 | 
265 | 		err = ioutil.WriteFile(yt.tokenFilename, b, 0777)
266 | 		if err != nil {
267 | 			return err
268 | 		}
269 | 	} else {
270 | 		b, err := ioutil.ReadFile(yt.tokenFilename)
271 | 		if err == nil {
272 | 			yt.token = &oauth2.Token{}
273 | 			// A token was found, unmarshall it and use it.
274 | 			err := json.Unmarshal(b, yt.token)
275 | 			if err != nil {
276 | 				return err
277 | 			}
278 | 		} else {
279 | 			// There was an error with the token, maybe it doesn't exist.
280 | 			// If we haven't been given an auth code, we must generate one.
281 | 			yt.generateOauthURLAndExit()
282 | 		}
283 | 	}
284 | 	return nil
285 | }
286 | 
287 | // Name returns the name of the service.
288 | func (yt *YouTube) Name() string {
289 | 	return YouTubeServiceName
290 | }
291 | 
292 | func (yt *YouTube) handleRequests() {
293 | 	// This is a map of channel id's to channels, it is used to send messages to a goroutine that is rate limiting each chatroom.
294 | 	channelInsertChans := make(map[string]chan *youtube.LiveChatMessage)
295 | 
296 | 	// Chat messages need to be separated by one second, they must be handled by a separate goroutine.
297 | 	insertLiveChatMessageLimited := func(liveChatMessage *youtube.LiveChatMessage) {
298 | 		channelInsertChan := channelInsertChans[liveChatMessage.Snippet.LiveChatId]
299 | 		if channelInsertChan == nil {
300 | 			channelInsertChan = make(chan *youtube.LiveChatMessage, 200)
301 | 			channelInsertChans[liveChatMessage.Snippet.LiveChatId] = channelInsertChan
302 | 
303 | 			// Start a goroutine to rate limit sends.
304 | 			go func() {
305 | 				for {
306 | 					if _, err := yt.Service.LiveChatMessages.Insert([]string{"snippet"}, <-channelInsertChan).Do(); err != nil {
307 | 						log.Println(err)
308 | 					}
309 | 
310 | 					time.Sleep(1 * time.Second)
311 | 				}
312 | 			}()
313 | 		}
314 | 		channelInsertChan <- liveChatMessage
315 | 	}
316 | 
317 | 	for {
318 | 		var err error
319 | 		select {
320 | 		case request := <-yt.InsertChan:
321 | 			switch request := request.(type) {
322 | 			case *youtube.LiveChatMessage:
323 | 				// Internally we use video ids as the channel, map back to a chat id.
324 | 				request.Snippet.LiveChatId = yt.videoToChat[request.Snippet.LiveChatId]
325 | 
326 | 				insertLiveChatMessageLimited(request)
327 | 			case *youtube.LiveChatBan:
328 | 				yt.Service.LiveChatBans.Insert([]string{"snippet"}, request).Do()
329 | 			case *youtube.LiveChatModerator:
330 | 				yt.Service.LiveChatModerators.Insert([]string{"snippet"}, request).Do()
331 | 			}
332 | 		case request := <-yt.DeleteChan:
333 | 			switch request := request.(type) {
334 | 			case *youtube.LiveChatMessage:
335 | 				yt.Service.LiveChatMessages.Delete(request.Id).Do()
336 | 			case *youtube.LiveChatBan:
337 | 				yt.Service.LiveChatBans.Delete(request.Id).Do()
338 | 			case *youtube.LiveChatModerator:
339 | 				yt.Service.LiveChatModerators.Delete(request.Id).Do()
340 | 			}
341 | 		}
342 | 		if err != nil {
343 | 			log.Println(err)
344 | 		}
345 | 
346 | 		// Sleep for a millisecond, this will guarantee a maximum QPS of 1000.
347 | 		time.Sleep(1 * time.Millisecond)
348 | 	}
349 | }
350 | 
351 | func (yt *YouTube) Init() error {
352 | 	if err := yt.createConfig(); err != nil {
353 | 		return err
354 | 	}
355 | 
356 | 	// An oauth URL was requested, error early.
357 | 	if yt.url {
358 | 		yt.generateOauthURLAndExit()
359 | 	}
360 | 
361 | 	if err := yt.createToken(); err != nil {
362 | 		return err
363 | 	}
364 | 
365 | 	yt.Client = yt.config.Client(oauth2.NoContext, yt.token)
366 | 
367 | 	if service, err := youtube.New(yt.Client); err == nil {
368 | 		yt.Service = service
369 | 	} else {
370 | 		return err
371 | 	}
372 | 
373 | 	return nil
374 | }
375 | 
376 | // Open opens the service and returns a channel which all messages will be sent on.
377 | func (yt *YouTube) Open() (<-chan Message, error) {
378 | 	me, err := yt.GetMe()
379 | 	if err != nil {
380 | 		return nil, err
381 | 	}
382 | 	yt.me = me
383 | 
384 | 	videos, err := yt.GetLiveVideos(yt.me.Id)
385 | 	if err == nil {
386 | 		for _, v := range videos {
387 | 			yt.JoinVideo(v)
388 | 		}
389 | 	}
390 | 
391 | 	// Start a goroutine to handle all requests.
392 | 	go yt.handleRequests()
393 | 
394 | 	return yt.messageChan, nil
395 | }
396 | 
397 | // IsMe returns whether or not a message was sent by the bot.
398 | func (yt *YouTube) IsMe(message Message) bool {
399 | 	return message.UserID() == yt.me.Id
400 | }
401 | 
402 | var messageReplacer = strings.NewReplacer("<", "(", ">", ")")
403 | 
404 | // SendMessage sends a message.
405 | func (yt *YouTube) SendMessage(channel, message string) error {
406 | 	// Send messages of 200 characters.
407 | 	for i := 0; i < len(message); i += 200 {
408 | 		m := i + 200
409 | 		if m > len(message) {
410 | 			m = len(message)
411 | 		}
412 | 
413 | 		me := message[i:m]
414 | 		yt.InsertChan <- &youtube.LiveChatMessage{
415 | 			Snippet: &youtube.LiveChatMessageSnippet{
416 | 				LiveChatId: channel,
417 | 				Type:       LiveChatMessageSnippetTypeText,
418 | 				TextMessageDetails: &youtube.LiveChatTextMessageDetails{
419 | 					MessageText: messageReplacer.Replace(me),
420 | 				},
421 | 			},
422 | 		}
423 | 	}
424 | 	return nil
425 | }
426 | 
427 | // SendAction sends an action.
428 | func (yt *YouTube) SendAction(channel, message string) error {
429 | 	return yt.SendMessage(channel, message)
430 | }
431 | 
432 | // DeleteMessage deletes a message.
433 | func (yt *YouTube) DeleteMessage(channel, messageID string) error {
434 | 	yt.DeleteChan <- &youtube.LiveChatMessage{Id: messageID}
435 | 	return nil
436 | }
437 | 
438 | // SendFile sends a file.
439 | func (yt *YouTube) SendFile(channel, name string, r io.Reader) error {
440 | 	return errors.New("Send file not supported.")
441 | }
442 | 
443 | // BanUser bans a user.
444 | func (yt *YouTube) BanUser(channel, userID string, duration int) error {
445 | 	liveChatBan := &youtube.LiveChatBan{
446 | 		Snippet: &youtube.LiveChatBanSnippet{
447 | 			LiveChatId: channel,
448 | 			BannedUserDetails: &youtube.ChannelProfileDetails{
449 | 				ChannelId: userID,
450 | 			},
451 | 		},
452 | 	}
453 | 
454 | 	if duration == -1 {
455 | 		liveChatBan.Snippet.Type = LiveChatBanSnippetTypePermanent
456 | 	} else {
457 | 		liveChatBan.Snippet.Type = LiveChatBanSnippetTypeTemporary
458 | 		liveChatBan.Snippet.BanDurationSeconds = uint64(duration)
459 | 	}
460 | 
461 | 	yt.InsertChan <- liveChatBan
462 | 	return nil
463 | }
464 | 
465 | // UnbanUser unbans a user.
466 | func (yt *YouTube) UnbanUser(channel, userID string) error {
467 | 	return errors.New("Unbanning user not supported on YouTube.")
468 | }
469 | 
470 | // UserName returns the bots name.
471 | func (yt *YouTube) UserName() string {
472 | 	return yt.me.Snippet.Title
473 | }
474 | 
475 | // UserID returns the bots user id.
476 | func (yt *YouTube) UserID() string {
477 | 	return yt.me.Id
478 | }
479 | 
480 | // PrivateMessage will send a private message to a user.
481 | func (yt *YouTube) PrivateMessage(userID, message string) error {
482 | 	return errors.New("Private messages not supported on YouTube.")
483 | }
484 | 
485 | // Join will join a video channel.
486 | func (yt *YouTube) Join(videoID string) error {
487 | 	if yt.joined[videoID] != "" {
488 | 		return ErrAlreadyJoined
489 | 	}
490 | 
491 | 	videos, err := yt.GetVideosByIDList([]string{videoID})
492 | 	if err != nil {
493 | 		return errors.New("No video found.")
494 | 	}
495 | 
496 | 	for _, v := range videos {
497 | 		return yt.JoinVideo(v)
498 | 	}
499 | 
500 | 	return errors.New("No video found.")
501 | }
502 | 
503 | // JoinSilent will join a video channel and return a channel of messages.
504 | // Messages will not be broadcast through the bot.
505 | func (yt *YouTube) JoinSilent(videoID string) (chan Message, error) {
506 | 	if yt.joined[videoID] != "" {
507 | 		return nil, ErrAlreadyJoined
508 | 	}
509 | 
510 | 	videos, err := yt.GetVideosByIDList([]string{videoID})
511 | 	if err != nil {
512 | 		return nil, errors.New("No video found.")
513 | 	}
514 | 
515 | 	for _, v := range videos {
516 | 		c := make(chan Message, 200)
517 | 		e := yt.joinVideo(v, c)
518 | 		return c, e
519 | 	}
520 | 
521 | 	return nil, errors.New("No video found.")
522 | }
523 | 
524 | // JoinVideoAnnounce will join a video like normal, but announce to chat when the bot joins.
525 | func (yt *YouTube) JoinVideoAnnounce(video *youtube.Video) {
526 | 	err := yt.JoinVideo(video)
527 | 	if err == nil {
528 | 		yt.SendMessage(video.LiveStreamingDetails.ActiveLiveChatId, "I am here!")
529 | 	}
530 | }
531 | 
532 | // Leave will leave a video channel.
533 | func (yt *YouTube) Leave(videoID string) error {
534 | 	delete(yt.joined, videoID)
535 | 
536 | 	return nil
537 | }
538 | 
539 | // LeaveAll will leave all the video channels for a channel.
540 | func (yt *YouTube) LeaveAll(channelID string) error {
541 | 	videos := []string{}
542 | 	for video, channel := range yt.videoToChannel {
543 | 		if channel == channelID {
544 | 			videos = append(videos, video)
545 | 		}
546 | 	}
547 | 
548 | 	for _, video := range videos {
549 | 		delete(yt.joined, video)
550 | 	}
551 | 
552 | 	return nil
553 | }
554 | 
555 | // ChannelIDForVideoID gets a channelID for a video id.
556 | func (yt *YouTube) ChannelIDForVideoID(videoID string) (channelID string, ok bool) {
557 | 	channelID, ok = yt.videoToChannel[videoID]
558 | 	return
559 | }
560 | 
561 | // ChannelName gets a channel name for a channel id.
562 | func (yt *YouTube) ChannelNameForVideoID(videoID string) string {
563 | 	return yt.videoToChannelName[videoID]
564 | }
565 | 
566 | type videoList []*youtube.Video
567 | 
568 | func (v videoList) Len() int {
569 | 	return len(v)
570 | }
571 | 
572 | func (v videoList) Swap(i, j int) {
573 | 	v[i], v[j] = v[j], v[i]
574 | }
575 | 
576 | func (v videoList) Less(i, j int) bool {
577 | 	return v[i].LiveStreamingDetails.ConcurrentViewers > v[j].LiveStreamingDetails.ConcurrentViewers
578 | }
579 | 
580 | // GetMe gets the channel for the bot.
581 | func (yt *YouTube) GetMe() (*youtube.Channel, error) {
582 | 	channelList, err := yt.Service.Channels.List([]string{"id","snippet"}).Mine(true).Do()
583 | 
584 | 	if err != nil {
585 | 		return nil, err
586 | 	}
587 | 
588 | 	if len(channelList.Items) != 1 {
589 | 		return nil, errors.New("Invalid response while requesting Me")
590 | 	}
591 | 
592 | 	return channelList.Items[0], nil
593 | }
594 | 
595 | // Typing sets that the bot is typing.
596 | func (yt *YouTube) Typing(channel string) error {
597 | 	return errors.New("Tying is not supported on YouTube.")
598 | }
599 | 
600 | // SupportsPrivateMessages returns whether the service supports private messages.
601 | func (yt *YouTube) SupportsPrivateMessages() bool {
602 | 	return false
603 | }
604 | 
605 | // SupportsMultiline returns whether the service supports multiline messages.
606 | func (yt *YouTube) SupportsMultiline() bool {
607 | 	return false
608 | }
609 | 
610 | // CommandPrefix returns the command prefix for the service.
611 | func (yt *YouTube) CommandPrefix() string {
612 | 	return fmt.Sprintf("@%s ", yt.UserName())
613 | }
614 | 
615 | // IsBotOwner returns whether or not a message sender was the owner of the bot.
616 | func (yt *YouTube) IsBotOwner(message Message) bool {
617 | 	m, ok := message.(*LiveChatMessage)
618 | 	if !ok {
619 | 		return false
620 | 	}
621 | 	return m.AuthorDetails.ChannelId == "UCGmC0A8mEAPdlELQdP9xJbw"
622 | }
623 | 
624 | // IsPrivate returns whether or not a message was private.
625 | func (yt *YouTube) IsPrivate(message Message) bool {
626 | 	return false
627 | }
628 | 
629 | // IsChannelOwner returns whether or not the sender of a message is the owner.
630 | func (yt *YouTube) IsChannelOwner(message Message) bool {
631 | 	m, ok := message.(*LiveChatMessage)
632 | 	if !ok {
633 | 		return false
634 | 	}
635 | 	return m.AuthorDetails.IsChatOwner
636 | }
637 | 
638 | // IsModerator returns whether or not the sender of a message is a moderator.
639 | func (yt *YouTube) IsModerator(message Message) bool {
640 | 	m, ok := message.(*LiveChatMessage)
641 | 	if !ok {
642 | 		return false
643 | 	}
644 | 	return m.AuthorDetails.IsChatOwner || m.AuthorDetails.IsChatModerator
645 | }
646 | 
647 | // ChannelCount returns the number of channels the bot is in.
648 | func (yt *YouTube) ChannelCount() int {
649 | 	return yt.channelCount
650 | }
651 | 
652 | // GetTopLivestreamIDs gets the video ids for the current top livestreams.
653 | func (yt *YouTube) GetTopLivestreamIDs(count int) ([]string, error) {
654 | 	ids := []string{}
655 | 
656 | 	pageToken := ""
657 | 
658 | 	for {
659 | 		list := yt.Service.PlaylistItems.List([]string{"id","contentDetails"}).MaxResults(50).PlaylistId("PLiCvVJzBupKmEehQ3hnNbbfBjLUyvGlqx")
660 | 		if pageToken != "" {
661 | 			list.PageToken(pageToken)
662 | 		}
663 | 		playlistItemListResponse, err := list.Do()
664 | 
665 | 		if err != nil {
666 | 			return nil, err
667 | 		}
668 | 
669 | 		for _, playlistItem := range playlistItemListResponse.Items {
670 | 			ids = append(ids, playlistItem.ContentDetails.VideoId)
671 | 		}
672 | 
673 | 		if len(ids) >= count || playlistItemListResponse.NextPageToken == "" {
674 | 			break
675 | 		}
676 | 
677 | 		pageToken = playlistItemListResponse.NextPageToken
678 | 	}
679 | 
680 | 	return ids, nil
681 | }
682 | 
683 | // GetVideosByIDList gets all the videos for a list of video IDs.
684 | func (yt *YouTube) GetVideosByIDList(ids []string) ([]*youtube.Video, error) {
685 | 	videos := []*youtube.Video{}
686 | 
687 | 	i := 0
688 | 	for i < len(ids) {
689 | 		next := i + 50
690 | 		if next >= len(ids) {
691 | 			next = len(ids)
692 | 		}
693 | 		list := yt.Service.Videos.List([]string{"id","snippet","liveStreamingDetails"}).MaxResults(50).Id(strings.Join(ids[i:next], ","))
694 | 
695 | 		videoListResponse, err := list.Do()
696 | 
697 | 		if err != nil {
698 | 			return nil, err
699 | 		}
700 | 
701 | 		videos = append(videos, videoListResponse.Items...)
702 | 
703 | 		if len(videos) != len(ids) {
704 | 			break
705 | 		}
706 | 	}
707 | 
708 | 	return videos, nil
709 | }
710 | 
711 | // GetTopLivestreams gets a list of videos for the current top livestreams.
712 | func (yt *YouTube) GetTopLivestreams(count int) ([]*youtube.Video, error) {
713 | 	ids, err := yt.GetTopLivestreamIDs(count)
714 | 	if err != nil {
715 | 		return nil, err
716 | 	}
717 | 
718 | 	videos, err := yt.GetVideosByIDList(ids)
719 | 	if err != nil {
720 | 		return nil, err
721 | 	}
722 | 
723 | 	videoList := videoList(videos)
724 | 	sort.Sort(videoList)
725 | 
726 | 	return videoList, nil
727 | }
728 | 
729 | // GetLiveVideos gets a list of live videos for a channel
730 | func (yt *YouTube) GetLiveVideos(channelID string) ([]*youtube.Video, error) {
731 | 	if yt.Service == nil {
732 | 		return nil, errors.New("Service not available.")
733 | 	}
734 | 
735 | 	s, err := yt.Service.Search.List([]string{"id"}).ChannelId(channelID).EventType("live").Type("video").Do()
736 | 	if err != nil {
737 | 		return nil, err
738 | 	}
739 | 
740 | 	ids := []string{}
741 | 	for _, sr := range s.Items {
742 | 		ids = append(ids, sr.Id.VideoId)
743 | 	}
744 | 
745 | 	videos, err := yt.GetVideosByIDList(ids)
746 | 	if err != nil {
747 | 		return nil, err
748 | 	}
749 | 
750 | 	liveVideos := []*youtube.Video{}
751 | 
752 | 	for _, v := range videos {
753 | 		if v.LiveStreamingDetails.ActualEndTime == "" {
754 | 			liveVideos = append(liveVideos, v)
755 | 		}
756 | 	}
757 | 
758 | 	return liveVideos, nil
759 | }
760 | 


--------------------------------------------------------------------------------
/youtubejoinplugin/youtubejoinplugin.go:
--------------------------------------------------------------------------------
  1 | package youtubejoinplugin
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"log"
  7 | 	"sync"
  8 | 
  9 | 	"google.golang.org/api/youtube/v3"
 10 | 
 11 | 	"github.com/iopred/bruxism"
 12 | )
 13 | 
 14 | // YouTubeJoinPlugin is a plugin that monitors channels, and when they go live, will join the service
 15 | type YouTubeJoinPlugin struct {
 16 | 	sync.RWMutex
 17 | 	youtube       *bruxism.YouTube
 18 | 	ytLiveChannel *bruxism.YTLiveChannel
 19 | 	liveVideoChan chan *youtube.Video
 20 | 	Channels      map[string]bool
 21 | }
 22 | 
 23 | // Help returns a list of help strings that are printed when the user requests them.
 24 | func (p *YouTubeJoinPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string {
 25 | 	return nil
 26 | }
 27 | 
 28 | // Message handler.
 29 | func (p *YouTubeJoinPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) {
 30 | 	defer bruxism.MessageRecover()
 31 | 
 32 | 	if service.IsChannelOwner(message) && bruxism.MatchesCommand(service, "leave", message) {
 33 | 		channel, ok := p.youtube.ChannelIDForVideoID(message.Channel())
 34 | 		if ok {
 35 | 			p.Unmonitor(channel)
 36 | 		}
 37 | 	}
 38 | }
 39 | 
 40 | // Load will load plugin state from a byte array.
 41 | func (p *YouTubeJoinPlugin) Load(bot *bruxism.Bot, service bruxism.Service, data []byte) error {
 42 | 	if service.Name() != bruxism.YouTubeServiceName {
 43 | 		panic("YouTubeJoin plugin only supports YouTube.")
 44 | 	}
 45 | 
 46 | 	if data != nil {
 47 | 		if err := json.Unmarshal(data, p); err != nil {
 48 | 			log.Println("Error loading data", err)
 49 | 		}
 50 | 	}
 51 | 
 52 | 	p.youtube = service.(*bruxism.YouTube)
 53 | 
 54 | 	for channel, _ := range p.Channels {
 55 | 		p.monitor(channel, false)
 56 | 	}
 57 | 
 58 | 	go p.Run(bot, service)
 59 | 
 60 | 	return nil
 61 | }
 62 | 
 63 | // Run will poll YouTube for channels going live and send messages.
 64 | func (p *YouTubeJoinPlugin) Run(bot *bruxism.Bot, service bruxism.Service) {
 65 | 	p.RLock()
 66 | 	lvc := p.liveVideoChan
 67 | 	p.RUnlock()
 68 | 	for {
 69 | 		v := <-lvc
 70 | 		p.RLock()
 71 | 		if p.Channels[v.Snippet.ChannelId] && v.LiveStreamingDetails != nil && v.LiveStreamingDetails.ActiveLiveChatId != "" {
 72 | 			p.youtube.JoinVideo(v)
 73 | 		}
 74 | 		p.RUnlock()
 75 | 	}
 76 | }
 77 | 
 78 | func (p *YouTubeJoinPlugin) monitor(channel string, announce bool) error {
 79 | 	if p.youtube == nil {
 80 | 		return nil
 81 | 	}
 82 | 	v, err := p.youtube.GetLiveVideos(channel)
 83 | 	if err == nil {
 84 | 		for _, video := range v {
 85 | 			if announce {
 86 | 				p.youtube.JoinVideoAnnounce(video)
 87 | 			} else {
 88 | 				p.youtube.JoinVideo(video)
 89 | 			}
 90 | 		}
 91 | 	}
 92 | 
 93 | 	return p.ytLiveChannel.Monitor(channel, p.liveVideoChan)
 94 | }
 95 | 
 96 | func (p *YouTubeJoinPlugin) Monitor(channel string) error {
 97 | 	p.Lock()
 98 | 	defer p.Unlock()
 99 | 
100 | 	if p.Channels[channel] {
101 | 		return errors.New("already tracking that channel")
102 | 	}
103 | 
104 | 	p.Channels[channel] = true
105 | 
106 | 	return p.monitor(channel, true)
107 | }
108 | 
109 | func (p *YouTubeJoinPlugin) Unmonitor(channel string) error {
110 | 	p.Lock()
111 | 	defer p.Unlock()
112 | 
113 | 	if !p.Channels[channel] {
114 | 		return errors.New("not tracking that channel")
115 | 	}
116 | 
117 | 	delete(p.Channels, channel)
118 | 
119 | 	p.youtube.LeaveAll(channel)
120 | 
121 | 	return p.ytLiveChannel.Unmonitor(channel, p.liveVideoChan)
122 | }
123 | 
124 | func (p *YouTubeJoinPlugin) Check(channel string) bool {
125 | 	return p.Channels[channel]
126 | }
127 | 
128 | // Save will save plugin state to a byte array.
129 | func (p *YouTubeJoinPlugin) Save() ([]byte, error) {
130 | 	return json.Marshal(p)
131 | }
132 | 
133 | // Stats will return the stats for a plugin.
134 | func (p *YouTubeJoinPlugin) Stats(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) []string {
135 | 	return nil
136 | }
137 | 
138 | // Name returns the name of the plugin.
139 | func (p *YouTubeJoinPlugin) Name() string {
140 | 	return "YouTubeJoin"
141 | }
142 | 
143 | // New will create a new YouTubeLive plugin.
144 | func New(ytLiveChannel *bruxism.YTLiveChannel) *YouTubeJoinPlugin {
145 | 	return &YouTubeJoinPlugin{
146 | 		ytLiveChannel: ytLiveChannel,
147 | 		liveVideoChan: make(chan *youtube.Video),
148 | 		Channels:      map[string]bool{},
149 | 	}
150 | }
151 | 


--------------------------------------------------------------------------------
/ytlivechannel.go:
--------------------------------------------------------------------------------
  1 | package bruxism
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"strings"
  6 | 	"sync"
  7 | 	"time"
  8 | 
  9 | 	"google.golang.org/api/youtube/v3"
 10 | )
 11 | 
 12 | // YTLiveChannel is a monitor that will send new live videos to a provided channel.
 13 | type YTLiveChannel struct {
 14 | 	sync.RWMutex
 15 | 	service *youtube.Service
 16 | 
 17 | 	// map channelID -> chan
 18 | 	liveVideoChans map[string][]chan *youtube.Video
 19 | 
 20 | 	channelNames map[string]string
 21 | }
 22 | 
 23 | func NewYTLiveChannel(service *youtube.Service) *YTLiveChannel {
 24 | 	return &YTLiveChannel{
 25 | 		service:        service,
 26 | 		channelNames:   map[string]string{},
 27 | 		liveVideoChans: map[string][]chan *youtube.Video{},
 28 | 	}
 29 | }
 30 | 
 31 | // Monitor monitors a channel for new live videos and sends them down liveVideoChan.
 32 | // If the channel is live when this is called, it will not send the video down the channel.
 33 | func (y *YTLiveChannel) Monitor(channel string, liveVideoChan chan *youtube.Video) error {
 34 | 	y.Lock()
 35 | 	defer y.Unlock()
 36 | 
 37 | 	videoChans := y.liveVideoChans[channel]
 38 | 	for _, v := range videoChans {
 39 | 		if v == liveVideoChan {
 40 | 			return errors.New("already monitoring that channel")
 41 | 		}
 42 | 	}
 43 | 
 44 | 	created := len(y.liveVideoChans[channel]) == 0
 45 | 	y.liveVideoChans[channel] = append(y.liveVideoChans[channel], liveVideoChan)
 46 | 
 47 | 	if created {
 48 | 		go y.poll(channel)
 49 | 	}
 50 | 	return nil
 51 | }
 52 | 
 53 | // UnmonitorAll unmonitors a channel for live videos.
 54 | func (y *YTLiveChannel) Unmonitor(channel string, liveVideoChan chan *youtube.Video) error {
 55 | 	y.Lock()
 56 | 	defer y.Unlock()
 57 | 
 58 | 	videoChans := y.liveVideoChans[channel]
 59 | 	for i, v := range videoChans {
 60 | 		if v == liveVideoChan {
 61 | 			y.liveVideoChans[channel] = append(videoChans[:i], videoChans[i+1:]...)
 62 | 			return nil
 63 | 		}
 64 | 	}
 65 | 
 66 | 	return errors.New("channel not being monitored")
 67 | }
 68 | 
 69 | func (y *YTLiveChannel) ChannelName(channel string) string {
 70 | 	y.RLock()
 71 | 	defer y.RUnlock()
 72 | 
 73 | 	return y.channelNames[channel]
 74 | }
 75 | 
 76 | func (y *YTLiveChannel) poll(channel string) {
 77 | 	var lastAnnounce time.Time
 78 | 	seen := map[string]bool{}
 79 | 	first := true
 80 | 	for {
 81 | 		videos, _ := y.getLiveVideos(channel)
 82 | 		y.Lock()
 83 | 		for k, v := range videos {
 84 | 			if !seen[k] {
 85 | 				seen[k] = true
 86 | 
 87 | 				y.channelNames[channel] = v.Snippet.ChannelTitle
 88 | 
 89 | 				// Don't announce the videos that are already live.
 90 | 				if first {
 91 | 					continue
 92 | 				}
 93 | 				now := time.Now()
 94 | 				// Don't allow more than 1 announcement per hour.
 95 | 				if !now.After(lastAnnounce.Add(1 * time.Hour)) {
 96 | 					continue
 97 | 				}
 98 | 				lastAnnounce = now
 99 | 
100 | 				for _, c := range y.liveVideoChans[channel] {
101 | 					c <- v
102 | 				}
103 | 			}
104 | 		}
105 | 		if len(y.liveVideoChans[channel]) == 0 {
106 | 			y.Unlock()
107 | 			return
108 | 		}
109 | 		y.Unlock()
110 | 		first = false
111 | 		<-time.After(11 * time.Minute)
112 | 	}
113 | 
114 | }
115 | 
116 | func (y *YTLiveChannel) getLiveVideos(channel string) (map[string]*youtube.Video, error) {
117 | 	if y.service == nil {
118 | 		return nil, errors.New("Service not available.")
119 | 	}
120 | 
121 | 	search, err := y.service.Search.List([]string{"id"}).ChannelId(channel).EventType("live").Type("video").Do()
122 | 	if err != nil {
123 | 		return nil, err
124 | 	}
125 | 
126 | 	ids := []string{}
127 | 	for _, searchResult := range search.Items {
128 | 		ids = append(ids, searchResult.Id.VideoId)
129 | 	}
130 | 
131 | 	m := map[string]*youtube.Video{}
132 | 
133 | 	i := 0
134 | 	for i < len(ids) {
135 | 		next := i + 50
136 | 		if next >= len(ids) {
137 | 			next = len(ids)
138 | 		}
139 | 		videoList, err := y.service.Videos.List([]string{"id","snippet","liveStreamingDetails"}).MaxResults(50).Id(strings.Join(ids[i:next], ",")).Do()
140 | 		if err != nil {
141 | 			return nil, err
142 | 		}
143 | 
144 | 		for _, v := range videoList.Items {
145 | 			if v.LiveStreamingDetails.ActualEndTime == "" {
146 | 				m[v.Id] = v
147 | 			}
148 | 		}
149 | 
150 | 		i = next
151 | 	}
152 | 
153 | 	return m, nil
154 | }
155 | 


--------------------------------------------------------------------------------