func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(lib.TimeNow(), "Loading the TitleSnarfer plugin"))
events.EvListenComplex(&events.ComplexEventListener{
Handle: "titlesnarfer",
Event: "PRIVMSG",
Regex: "(https?:\\/\\/[^\001 ]+)",
Callback: func(input *events.Params) {
if input.Command == "" {
bot.Say(input.Context, web.GetTitle(input.Match))
}
}})
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(lib.TimeNow(), "Loading the Google plugin"))
events.CmdListen(&events.CmdListener{
Commands: []string{"google", "g"},
Help: "Googles stuff~",
Syntax: bot.Config.Prefix + "g <search terms>",
Callback: func(input *events.Params) {
g := web.Google(input.Data, 1)
if g.Error != "" {
bot.Say(input.Context, g.Error)
return
}
bot.Say(input.Context, fmt.Sprintf("%s ~ %s ~ %s",
g.Results.Data[0].Title, g.Results.Data[0].URL,
lib.StripHtml(g.Results.Data[0].Content)))
}})
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(lib.TimeNow(), "Loading the Urban Dictionary plugin"))
events.CmdListen(&events.CmdListener{
Commands: []string{"urbandictionary", "ud"},
Help: "Looks up Urban Dictionary entries. NSFW",
Syntax: bot.Config.Prefix + "ud <term> - Example: " + bot.Config.Prefix + "ud scrobble",
Callback: func(input *events.Params) {
uri := fmt.Sprintf("http://api.urbandictionary.com/v0/define?term=%s", url.QueryEscape(input.Data))
body, err := web.Get(&uri)
if err != "" {
bot.Say(input.Context, err)
return
}
ud := &UDResponse{}
jserr := json.Unmarshal(body, &ud)
if jserr != nil {
logger.Error("Couldn't parse UD's JSON: " + jserr.Error())
return
}
if ud.Result == "no_results" {
bot.Say(input.Context, fmt.Sprintf("\"%s\" is not a thing on Urban Dictionary.", input.Data))
return
}
var resp string = ""
var max int = 3
if len(ud.List) < max {
max = len(ud.List)
}
for i := 0; i < max; i++ {
resp += fmt.Sprintf("%d) %s, ", i+1, ud.List[i].Definition)
}
bot.Say(input.Context, ud.List[0].Word+" ~ "+lib.SingleSpace(resp[0:len(resp)-2]))
}})
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(time.Now(), "Loading the YouTube plugin"))
events.CmdListen(&events.CmdListener{
Commands: []string{"youtube", "yt"},
Help: "YouTubes stuff.",
Syntax: bot.Config.Prefix + "yt <search terms> - Example: " + bot.Config.Prefix + "yt we like big booty bitches",
Callback: func(input *events.Params) {
ytr := &YouTubeResults{}
uri := fmt.Sprintf("http://gdata.youtube.com/feeds/api/videos?q=%s&max-results=1&v=2&alt=json",
url.QueryEscape(input.Data))
body, err := web.Get(&uri)
if err != "" {
logger.Error("YouTube Failed: " + err)
bot.Say(input.Context, "Woops.")
return
}
errr := json.Unmarshal(body, &ytr)
if errr != nil {
logger.Error("Couldn't parse youtube's JSON:" + errr.Error())
bot.Say(input.Context, "Herp. Check logs")
return
}
if len(ytr.Feed.Entry) == 0 {
bot.Say(input.Context, fmt.Sprintf("\"%s\" is not a thing on YouTube.", input.Data))
return
}
yt := &ytr.Feed.Entry[0]
duration, errr := time.ParseDuration(yt.Info.Duration["seconds"] + "s")
resp := fmt.Sprintf("%s ~ [%s] %s - %s views ~ http://youtu.be/%s ~ %s",
*yt.Title["$t"], &duration, yt.Info.Date["$t"][0:10],
lib.CommaNum(yt.Stats["viewCount"]), yt.Info.ID["$t"],
yt.Info.Description["$t"])
bot.Say(input.Context, resp)
resp = ""
ytr = nil
}})
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(lib.TimeNow(), "Loading the Alias Frontend plugin"))
events.CmdListen(&events.CmdListener{
Command: "var",
Help: "Allows you to set variables.",
Syntax: fmt.Sprintf("%svar <add/remove/list/info> <varname> [<data>] - Example: %svar add butts are nice",
bot.Config.Prefix, bot.Config.Prefix),
Callback: func(input *events.Params) {
var argLen int = len(input.Args)
if argLen == 0 {
bot.Say(input.Context, events.Help("var", "syntax"))
return
}
switch strings.ToLower(input.Args[0]) {
case "add":
if argLen < 3 {
bot.Say(input.Context, events.Help("var", "syntax"))
return
}
alias.Vars.SaveOne(input.Args[1], strings.Join(input.Args[2:], " "))
bot.Say(input.Context, "Added!")
case "remove":
if argLen < 2 {
bot.Say(input.Context, events.Help("var", "syntax"))
return
}
if ok := alias.Vars.RemoveOne(input.Args[1]); ok {
bot.Say(input.Context, "Removed!")
} else {
bot.Say(input.Context, fmt.Sprintf("There is no %q variable.", input.Args[1]))
}
case "info":
if argLen < 2 {
bot.Say(input.Context, events.Help("var", "syntax"))
return
}
varInfo := alias.Vars.GetOne(input.Args[1])
if varInfo == "" {
bot.Say(input.Context, fmt.Sprintf("There is no %q variable.", input.Args[1]))
} else {
bot.Say(input.Context, fmt.Sprintf("Variable %q contains: %s", input.Args[1], varInfo))
}
case "list":
variables := alias.Vars.GetKeys()
if len(variables) == 0 {
bot.Say(input.Context, "There are no variables defined.")
} else {
bot.Say(input.Context, fmt.Sprintf("Variables: %s", strings.Join(variables, ", ")))
}
default:
bot.Say(input.Context, events.Help("var", "syntax"))
}
}})
events.CmdListen(&events.CmdListener{
Command: "alias",
Help: "Aliases things!",
Syntax: fmt.Sprintf("%salias <add/remove/list/info> <command> <args> - Example: %salias add whip action whips {args*}'s buttocks!",
bot.Config.Prefix, bot.Config.Prefix),
Callback: func(input *events.Params) {
var argLen int = len(input.Args)
if argLen == 0 {
bot.Say(input.Context, events.Help("alias", "syntax"))
return
}
switch strings.ToLower(input.Args[0]) {
case "list":
aliases := alias.DB.GetKeys()
if len(aliases) == 0 {
bot.Say(input.Context, "There are no aliases defined.")
} else {
bot.Say(input.Context, fmt.Sprintf("Aliases: %s", strings.Join(aliases, ", ")))
}
case "info":
if argLen < 2 {
bot.Say(input.Context, events.Help("alias", "syntax"))
return
}
aliasInfo := alias.DB.GetOne(input.Args[1])
if aliasInfo == "" {
bot.Say(input.Context, fmt.Sprintf("There is no %q alias.", input.Args[1]))
} else {
bot.Say(input.Context, fmt.Sprintf("Alias %q contains: %s", input.Args[1], aliasInfo))
}
case "add":
if argLen < 3 {
bot.Say(input.Context, events.Help("alias", "syntax"))
return
}
alias.DB.SaveOne(input.Args[1], strings.Join(input.Args[2:], " "))
bot.Say(input.Context, "Added!")
case "remove":
if argLen < 2 {
bot.Say(input.Context, events.Help("alias", "syntax"))
return
}
if ok := alias.DB.RemoveOne(input.Args[1]); ok {
bot.Say(input.Context, "Removed!")
} else {
bot.Say(input.Context, fmt.Sprintf("There is no %q alias.", input.Args[1]))
}
default:
bot.Say(input.Context, events.Help("alias", "syntax"))
}
}})
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(lib.TimeNow(), "Loading the Internal Address List plugin"))
events.CmdListen(&events.CmdListener{
Command: "ial",
Help: "Shows ial internal details",
Syntax: "TBD",
Callback: func(input *events.Params) {
fmt.Println(globals.Channels)
}})
events.EvListen(&events.EvListener{ // grab our nick on connect
Handle: "ial001",
Event: "001",
Callback: func(input *events.Params) {
bot.Info.Nick = input.Args[1]
}})
events.EvListen(&events.EvListener{
Handle: "ialJoin",
Event: "JOIN",
Callback: func(input *events.Params) {
if input.Nick == bot.Info.Nick {
bot.Send("WHO " + input.Context)
bot.Send("MODE " + input.Context)
if bot.Info.User == "" {
bot.Info.User = input.Nick + "!" + input.Address
}
bot.Info.Channels.Add(input.Context)
chdata := &globals.ChannelData{User: make(map[string]*globals.UserData)}
globals.Channels[strings.ToLower(input.Context)] = chdata
} else {
globals.Channels[strings.ToLower(input.Context)].User[strings.ToLower(input.Nick)] = &globals.UserData{
Nick: input.Nick,
User: input.Address[:strings.Index(input.Address, "@")],
Address: input.Address[strings.Index(input.Address, "@")+1:],
Fulluser: input.Args[0][1:],
}
}
}})
events.EvListen(&events.EvListener{
Handle: "ialPart",
Event: "PART",
Callback: func(input *events.Params) {
if input.Nick == bot.Info.Nick {
delete(globals.Channels, strings.ToLower(input.Context))
} else {
delete(globals.Channels[strings.ToLower(input.Context)].User, strings.ToLower(input.Nick))
}
}})
events.EvListen(&events.EvListener{
Handle: "ialKick",
Event: "KICK",
Callback: func(input *events.Params) {
for channel, _ := range globals.Channels {
for key, user := range globals.Channels[channel].User {
if user.Nick == input.Kicknick {
delete(globals.Channels[channel].User, key)
}
}
}
}})
events.EvListen(&events.EvListener{
Handle: "ialQuit",
Event: "QUIT",
Callback: func(input *events.Params) {
for channel, _ := range globals.Channels {
for key, user := range globals.Channels[channel].User {
if user.Nick == input.Nick {
delete(globals.Channels[channel].User, key)
}
}
}
}})
events.EvListen(&events.EvListener{
Handle: "ialNick",
Event: "NICK",
Callback: func(input *events.Params) {
for channel, _ := range globals.Channels {
for key, user := range globals.Channels[channel].User {
if user.Nick == input.Nick {
newuser := &globals.UserData{ // assigned in this order because of pure case nick changes
Nick: input.Newnick, // ie nick -> NICK
User: user.User,
Address: user.Address,
Fulluser: input.Newnick + "!" + user.User + "@" + user.Address,
}
delete(globals.Channels[channel].User, key)
globals.Channels[channel].User[strings.ToLower(input.Newnick)] = newuser
}
}
}
}})
events.EvListen(&events.EvListener{
Handle: "ialWho",
Event: "352",
Callback: func(input *events.Params) {
globals.Channels[strings.ToLower(input.Context)].User[strings.ToLower(input.Args[6])] = &globals.UserData{
Nick: input.Args[6],
User: input.Args[3],
Address: input.Args[4],
Fulluser: input.Args[6] + "!" + input.Args[3] + "@" + input.Args[4],
}
}})
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(time.Now(), "Loading the MangaStream plugin"))
timer.AddEvent("Checking Manga Sources", 900, func() {
checkUpdates(bot, "mangafox", "")
checkUpdates(bot, "mangastream", "")
})
events.CmdListen(&events.CmdListener{
Commands: []string{"mangastream", "ms"},
Help: "Manages the MangaStream release watcher",
Syntax: fmt.Sprintf("%sms <add/remove/list> <manga title> - Example: %sms add One Piece",
bot.Config.Prefix, bot.Config.Prefix),
Callback: func(input *events.Params) {
if len(input.Args) == 0 {
bot.Say(input.Context, events.Help("ms", "syntax"))
return
}
var manga Manga
loadWatched(&manga)
switch strings.ToLower(input.Args[0]) {
case "list":
if len(manga.MangaStream) == 0 {
bot.Say(input.Context, "I'm not watching for any MangaStream releases right now. :<")
return
}
var titles string
for _, entry := range manga.MangaStream {
if entry.Manga == "" {
titles += entry.Title + ", "
} else {
titles += entry.Manga + ", "
}
}
bot.Say(input.Context, fmt.Sprintf("I'm currently watching for %s updates to %s.",
"MangaStream", titles[:len(titles)-2]))
case "add":
if len(input.Args) < 2 {
bot.Say(input.Context, events.Help("ms", "syntax"))
return
}
bot.Say(input.Context, addManga(&manga, strings.Join(input.Args[1:], " "), input.Context, "MangaStream", bot))
case "remove":
if len(input.Args) < 2 {
bot.Say(input.Context, events.Help("ms", "syntax"))
return
}
bot.Say(input.Context, removeManga(&manga, strings.Join(input.Args[1:], " "), "MangaStream"))
case "check":
checkUpdates(bot, "mangastream", input.Context)
}
}})
events.CmdListen(&events.CmdListener{ // not sure how to make this neat yet ^ v
Commands: []string{"mangafox", "mf"},
Help: "Manages the MangaFox release watcher",
Syntax: fmt.Sprintf("%smf <add/remove/list> <manga title> - Example: %smf add One Piece",
bot.Config.Prefix, bot.Config.Prefix),
Callback: func(input *events.Params) {
if len(input.Args) == 0 {
bot.Say(input.Context, events.Help("mf", "syntax"))
return
}
var manga Manga
loadWatched(&manga)
switch strings.ToLower(input.Args[0]) {
case "list":
if len(manga.MangaFox) == 0 {
bot.Say(input.Context, "I'm not watching for any MangaFox releases right now. :<")
return
}
var titles string
for _, entry := range manga.MangaFox {
if entry.Manga == "" {
titles += entry.Title + ", "
} else {
titles += entry.Manga + ", "
}
}
bot.Say(input.Context, fmt.Sprintf("I'm currently watching for %s updates to %s.",
"MangaFox", titles[:len(titles)-2]))
case "add":
if len(input.Args) < 2 {
bot.Say(input.Context, events.Help("mf", "syntax"))
return
}
bot.Say(input.Context, addManga(&manga, strings.Join(input.Args[1:], " "), input.Context, "MangaFox", bot))
case "remove":
if len(input.Args) < 2 {
bot.Say(input.Context, events.Help("mf", "syntax"))
return
}
bot.Say(input.Context, removeManga(&manga, strings.Join(input.Args[1:], " "), "MangaFox"))
case "check":
checkUpdates(bot, "mangafox", input.Context)
}
}})
}
func checkUpdates(bot *irc.IRC, source string, context string) {
var manga Manga
var uri, message string
var watched map[string]MangaEntry
loadWatched(&manga)
switch source {
case "mangafox":
uri = "http://mangafox.me/rss/latest_manga_chapters.xml"
watched = manga.MangaFox
case "mangastream":
uri = "http://mangastream.com/rss"
watched = manga.MangaStream
}
data, err := web.Get(&uri)
if err != "" {
logger.Error(err)
return
}
var entries map[string]MangaEntry
entries, perr := parseRSS(data, source)
if perr != nil {
logger.Error(perr.Error())
return
}
keys := getKeys(source)
updates := make([]irc.RatedMessage, 0)
var method string
var newEntry MangaEntry
for title, entry := range entries {
for _, key := range keys {
if strings.Index(title, key) > -1 {
if entry.Date > watched[key].Date {
// update found
switch source {
case "mangastream":
message = fmt.Sprintf("%s is out! \\o/ ~ %s ~ %q",
entry.Title, entry.Link, entry.Desc)
newEntry = MangaEntry{
Manga: entry.Title[:len(key)],
Title: entry.Title,
Date: entry.Date,
Desc: entry.Desc,
Link: entry.Link,
Announce: watched[key].Announce,
}
case "mangafox":
message = fmt.Sprintf("%s is out! \\o/ ~ %s", entry.Title, entry.Link)
newEntry = MangaEntry{
Manga: entry.Title[:len(key)],
Title: entry.Title,
Date: entry.Date,
Link: entry.Link,
Announce: watched[key].Announce,
}
}
delete(watched, key)
watched[key] = newEntry
if context != "" && !lib.HasElementString(watched[key].Announce, context) {
if context[0:1] == "#" {
method = "say"
} else {
method = "notice"
}
updates = append(updates, irc.RatedMessage{
Method: method,
Target: context,
Message: message,
})
}
for _, target := range watched[key].Announce {
if target[0:1] == "#" {
method = "say"
} else {
method = "notice"
}
updates = append(updates, irc.RatedMessage{
Method: method,
Target: target,
Message: message,
})
}
}
}
}
}
if len(updates) > 0 {
bot.Rated(&updates)
saveWatched(&manga)
} else if context != "" {
bot.Say(context, "Nothing new. :\\")
}
}
func Register(bot *irc.IRC) {
defer logger.Info(lib.TimeTrack(lib.TimeNow(), "Loading the Core plugin"))
// autojoin
events.EvListen(&events.EvListener{
Handle: "autojoin",
Event: "376",
Callback: func(input *events.Params) {
bot.Join(strings.Join(bot.Config.Autojoin, ","))
}})
// nick is taken
events.EvListen(&events.EvListener{
Handle: "nickTaken",
Event: "433",
Callback: func(input *events.Params) {
bot.Config.Nicknames = append(bot.Config.Nicknames[:0], bot.Config.Nicknames[1:]...)
bot.Send("NICK " + bot.Config.Nicknames[0])
}})
events.CmdListen(&events.CmdListener{
Command: "help",
Help: "Helps!",
Syntax: bot.Config.Prefix + "help [<command>] - Example: " + bot.Config.Prefix + "help help",
Callback: func(input *events.Params) {
commands := events.CommandList()
if len(input.Args) == 0 {
bot.Say(input.Context, fmt.Sprintf("Commands: %s", strings.Join(commands, ", ")))
return
}
input.Args[0] = strings.ToLower(input.Args[0])
for _, command := range commands {
if input.Args[0] == command {
bot.Say(input.Context, events.Help(command, "help"))
bot.Say(input.Context, events.Help(command, "syntax"))
return
}
}
bot.Say(input.Context, fmt.Sprintf("\"%s\" isn't a command.", input.Args[0]))
}})
// say
events.CmdListen(&events.CmdListener{
Command: "say",
Help: "Says stuff!",
Syntax: bot.Config.Prefix + "say <thing you want to say>",
Callback: func(input *events.Params) {
bot.Say(input.Context, input.Data)
}})
// action
events.CmdListen(&events.CmdListener{
Command: "action",
Help: "/me's stuff!",
Syntax: bot.Config.Prefix + "action <thing you want the bot to emote>",
Callback: func(input *events.Params) {
bot.Action(input.Context, input.Data)
}})
// join
events.CmdListen(&events.CmdListener{
Command: "join",
Help: "Joins channels!",
Syntax: bot.Config.Prefix + "join #channel",
Callback: func(input *events.Params) {
if len(input.Args) < 1 || input.Args[0][0:1] != "#" {
bot.Say(input.Context, "That ain't how you join a channel sucka")
return
}
bot.Join(input.Args[0])
}})
// part
events.CmdListen(&events.CmdListener{
Command: "part",
Help: "Parts channels!",
Syntax: bot.Config.Prefix + "part #channel",
Callback: func(input *events.Params) {
if len(input.Args) < 1 {
if input.Context[0:1] == "#" {
bot.Part(input.Context)
} else {
bot.Say(input.Context, "Either specify the channel to part or use the command in the channel.")
}
} else if input.Args[0][0:1] != "#" {
bot.Say(input.Context, "That ain't how you part a channel sucka")
return
} else {
bot.Part(input.Args[0])
}
}})
// raw
events.CmdListen(&events.CmdListener{
Command: "raw",
Help: "Sends raw commands to the server",
Syntax: bot.Config.Prefix + "raw <command>",
Callback: func(input *events.Params) {
bot.Send(input.Data)
}})
// memstats
events.CmdListen(&events.CmdListener{
Command: "memstats",
Help: "Shows mem stats~",
Syntax: bot.Config.Prefix + "memstats",
Callback: func(input *events.Params) {
m := &runtime.MemStats{}
runtime.ReadMemStats(m)
bot.Say(input.Context, fmt.Sprintf("Sys: %d KiB, Allocated and in use: %d KiB, Total Allocated (including freed): %d KiB, Lookups: %d, Mallocs: %d, Frees: %d",
(m.Sys/1024.0), (m.Alloc/1024), (m.TotalAlloc/1024), m.Lookups, m.Mallocs, m.Frees))
}})
}