Golang core.Gobot类代码示例

func Create(bot *core.Gobot, config map[string]interface{}) {
	bot.ListenFor("!all", func(msg core.Message, matches []string) core.Response {
		names := make([]string, 0)
		for _, name := range msg.Names() {
			if name != msg.User && name != bot.Name {
				names = append(names, name)
			}
		}
		if len(names) > 0 {
			sort.Strings(names)
			msg.Send("cc: " + strings.Join(names, " "))
		}
		return bot.Stop()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	prefix, found := config["prefix"].(string)
	if !found {
		log.Printf("Can't find graphite prefix!")
		return
	}

	pattern := fmt.Sprintf(`%s(\S+)`, prefix)
	bot.ListenFor(pattern, func(msg core.Message, matches []string) core.Response {
		url := matches[0]
		if !strings.HasSuffix(url, ".png") {
			msg.Ftfy(url + "&lol.png")
		}
		return bot.Stop()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	name := bot.Name

	bot.ListenFor(fmt.Sprintf("(?i)kill %s", name), func(msg core.Message, matches []string) core.Response {
		msg.Reply("EAT SHIT")
		return bot.Stop()
	})

	bot.ListenFor(fmt.Sprintf("(?i)(hey|h(a?)i|hello) %s", name), func(msg core.Message, matches []string) core.Response {
		msg.Send(fmt.Sprintf("why, hello there %s", msg.User))
		return bot.Stop()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	if len(config) == 0 {
		log.Printf("No pagerduty config found")
		return
	}

	account := pagerduty.SetupAccount(config["subdomain"].(string), config["apiKey"].(string))

	bot.ListenFor("^pd (.*)", func(msg core.Message, matches []string) core.Response {
		switch matches[1] {
		case "incidents":
			params := map[string]string{
				"status": "acknowledged,triggered",
			}

			incidents, err := account.Incidents(params)
			if err != nil {
				return bot.Error(err)
			}

			msg.Send(fmt.Sprintf("There are currently %d OPEN (ack,unack) incidents.", len(incidents)))
		}

		return bot.Stop()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	// matches is actually a map[string]string
	matches, found := config["matches"]
	if !found {
		log.Printf("Can't find matcher/matches plugin conf. Plugin will not run.")
		return
	}

	switch matches := matches.(type) {
	case map[string]interface{}:
		for pattern, replacement := range matches {
			switch replacement := replacement.(type) {
			case string:
				bot.ListenFor(pattern, func(msg core.Message, matches []string) core.Response {
					msg.Send(replacement)
					return bot.KeepGoing()
				})
			}
		}
	}

}

func Create(bot *core.Gobot, config map[string]interface{}) {
	defaultUrl, useDefault := config["default"].(string)
	exclusions := getExclusions(config)
	bot.ListenFor("^gis (.*)", func(msg core.Message, matches []string) core.Response {
		for _, ex := range exclusions {
			if ex == msg.Channel {
				return bot.Stop()
			}
		}
		link, err := search(matches[1])
		if err != nil {
			if useDefault {
				link = defaultUrl
			} else {
				return bot.Error(err)
			}
		}
		msg.Ftfy(link)
		return bot.Stop()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	results, ok := config["results"].(float64)
	if !ok {
		log.Print("Failed to load config for 'youtube' plugin. Using default result count of 1")
		results = 1
	}

	bot.ListenFor("^yt (.*)", func(msg core.Message, matches []string) core.Response {
		link, err := search(matches[1], int(results))
		if err != nil {
			return bot.Error(err)
		}
		if link != "" {
			msg.Ftfy(link)
		}
		return bot.Stop()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) error {
	username, password, err := loadCredentials(config)
	if err != nil {
		log.Printf("Error starting up memegenerator plugin: %s", err)
		return err
	}

	fry := memeGen{username, password, fryGenerator, fryImage}

	bot.ListenFor(`(?i)(not sure|unsure) if (.*) or (.*)`, func(msg core.Message, matches []string) core.Response {
		result, err := fry.generate(matches[1]+" if "+matches[2], " or "+matches[3])
		if err != nil {
			return bot.Error(err)
		}
		if result != "" {
			msg.Reply(result)
		}
		return bot.Stop()
	})
	return nil
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	if len(config) == 0 {
		log.Printf("No sensu config found")
		return
	}

	envs := make(map[string]string)
	for e, u := range config["environments"].(map[string]interface{}) {
		envs[e] = fmt.Sprintf("%s", u)
	}

	bot.ListenFor("^sensu (.*)", func(msg core.Message, matches []string) core.Response {
		cmdArgs := strings.Split(matches[1], " ")
		switch cmdArgs[0] {
		case "events":
			if len(cmdArgs) > 1 {
				if err, events := getEvents(envs[cmdArgs[1]]); err != nil {
					return bot.Error(err)
				} else {
					msg.Send(fmt.Sprintf("%s: Total events: %d.", cmdArgs[1], len(events)))

					for _, event := range events {
						msg.SendPriv(fmt.Sprintf("%s: %s", cmdArgs[1], event.toString()))
					}
				}
			} else {
				for env, url := range envs {
					if err, events := getEvents(url); err != nil {
						return bot.Error(err)
					} else {
						msg.Send(fmt.Sprintf("%s: Total events: %d.", env, len(events)))

						for _, event := range events {
							msg.SendPriv(fmt.Sprintf("%s: %s", env, event.toString()))
						}
					}
				}
			}
		case "silence":
			var (
				env    string
				target string
			)

			if len(cmdArgs) > 2 {
				env = envs[cmdArgs[1]]
				target = cmdArgs[2]
			} else {
				env = ""
				target = cmdArgs[1]
			}

			if err := silence(env, target); err != nil {
				return bot.Error(err)
			} else {
				msg.Send(fmt.Sprintf("silenced %s in env: %s", cmdArgs[2], cmdArgs[1]))
			}
		case "silenced":
			if len(cmdArgs) > 1 {
				if err, silenced := getSilenced(envs[cmdArgs[1]]); err != nil {
					return bot.Error(err)
				} else {
					msg.Send(fmt.Sprintf("%s: Total silenced: %d.", cmdArgs[1], len(silenced)))

					for _, s := range silenced {
						msg.SendPriv(fmt.Sprintf("%s: %s", cmdArgs[1], s))
					}
				}
			} else {
				for env, url := range envs {
					if err, silenced := getSilenced(url); err != nil {
						return bot.Error(err)
					} else {
						msg.Send(fmt.Sprintf("%s: Total silenced: %d.", env, len(silenced)))

						for _, s := range silenced {
							msg.SendPriv(fmt.Sprintf("%s: %s", env, s))
						}
					}
				}
			}
		case "unsilence":
			var (
				env    string
				target string
			)

			if len(cmdArgs) > 2 {
				env = envs[cmdArgs[1]]
				target = cmdArgs[2]
			} else {
				env = ""
				target = cmdArgs[1]
			}

			if err := unsilence(env, target); err != nil {
				fmt.Println(err)
			} else {
				msg.Send(fmt.Sprintf("silenced %s in env: %s", cmdArgs[2], cmdArgs[1]))
			}
//.........这里部分代码省略.........

func Create(bot *core.Gobot, config map[string]interface{}) {
	if err := pluginState.Load(&markov); err != nil {
		log.Printf("Could not load plugin state: %s", err)
	}

	bot.ListenFor("^ *markov *$", func(msg core.Message, matches []string) core.Response {
		mutex.Lock()
		defer mutex.Unlock()
		output, err := generateRandom()
		if err != nil {
			return bot.Error(err)
		}
		msg.Send(output)
		return bot.KeepGoing()
	})

	// generate a chain for the specified user
	bot.ListenFor("^ *markov +(.+)", func(msg core.Message, matches []string) core.Response {
		mutex.Lock()
		defer mutex.Unlock()
		output, err := generate(matches[1])
		if err != nil {
			return bot.Error(err)
		}
		msg.Send(output)
		return bot.KeepGoing()
	})

	// listen to everything
	bot.ListenFor("(.*)", func(msg core.Message, matches []string) core.Response {
		mutex.Lock()
		defer mutex.Unlock()
		user := msg.User
		text := matches[0]
		record(user, text)
		return bot.KeepGoing()
	})
}

func Create(bot *core.Gobot, config map[string]interface{}) {
	token, ok := config["token"].(string)
	if !ok {
		log.Println("Could not find token in config. Twitter plugin won't work")
		return
	}

	bot.ListenFor("^describe (\\w+)", func(msg core.Message, matches []string) core.Response {
		described, err := describe(token, matches[1])
		if err != nil {
			return bot.Error(err)
		}
		msg.Send(described)
		return bot.Stop()
	})

	bot.ListenFor("twitter\\.com/(\\w+)/status/(\\d+)", func(msg core.Message, matches []string) core.Response {
		user, tweet, err := getTweet(token, matches[2])
		if err != nil {
			return bot.Error(err)
		}
		if err == nil && tweet != "" {
			// Split multi-line tweets into separate PRIVMSG calls
			fields := strings.FieldsFunc(tweet, func(r rune) bool {
				return r == '\r' || r == '\n'
			})
			for _, field := range fields {
				if field != "" {
					msg.Send(fmt.Sprintf("%s: %s", user, field))
				}
			}
		}
		return bot.KeepGoing()
	})
}