Esempio n. 1
0
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]))
		}})
}
Esempio n. 2
0
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))
			}
		}})
}
Esempio n. 3
0
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)))
		}})
}
Esempio n. 4
0
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"))
			}
		}})
}
Esempio n. 5
0
File: ial.go Progetto: Kaioshi/Kari
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],
			}
		}})
}
Esempio n. 6
0
File: core.go Progetto: Kaioshi/Kari
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))
		}})
}