handlers

Documentation

Index

• Variables
• type Handler
  • func NewClient(token string, DB *mongo.Database) (*Handler, error)
  • func (handler *Handler) HandleMessages(event *slack.MessageEvent)
  • func (handler *Handler) Listen()
• type HandlerDefinition
• type ReplyFn

Variables

var BigShaqHandler = &HandlerDefinition{
	Match: func(message string) bool {
		matched, _ := regexp.MatchString("ting go\\?", message)
		return matched
	},
	Handle: func(reply ReplyFn, event *slack.MessageEvent, handler *Handler) {

		rand.Seed(time.Now().Unix())
		length := rand.Intn(15)

		buf := "ting go"

		for i := 0; i < length; i++ {
			index := rand.Intn(len(noisesTheTingMakes) - 2)
			buf += fmt.Sprintf(" %s", noisesTheTingMakes[index])
		}
		reply(event, buf)
	},
}

BigShaqHandler responds to messages containing the string "ting go?"

var KarmaHandler = &HandlerDefinition{
	Match: func(message string) bool {
		if len(message) <= 2 {
			return false
		}

		matched, err := regexp.Match(karmaRegex, []byte(message))
		if err != nil {
			return false
		}

		return matched
	},
	Handle: func(reply ReplyFn, event *slack.MessageEvent, handler *Handler) {
		expression, err := regexp.Compile(karmaRegex)
		if err != nil {
			reply(event, "Could not track karma on your message, sorry!")
			return
		}

		subjects := expression.FindAllString(event.Text, -1)
		for i, s := range subjects {
			subjects[i] = strings.ToLower(s)
		}

		const add = byte('+')
		const subtract = byte('-')

		toUpdate := make(map[string]int, 0)
		var updates []*update

		ignoreUserCheck := false
		userName := ""
		user, err := handler.API.GetUserInfo(event.User)
		if err != nil {
			ignoreUserCheck = true
		} else {
			userName = user.Profile.RealName
		}
		chibotDelta := 0

		for _, subject := range subjects {
			action := subject[len(subject)-1]
			subject := subject[:len(subject)-2]
			skip := false

			if !ignoreUserCheck && action == add {
				for _, s := range strings.Split(userName, " ") {
					if strings.Contains(strings.ToLower(s), strings.ToLower(subject)) {
						skip = true
						break
					}
				}
			}

			if skip {
				continue
			}

			if action == add {
				toUpdate[subject]++
				if strings.ToLower(subject) == "chibot" {
					chibotDelta++
				}
			} else if action == subtract {
				toUpdate[subject]--
				if strings.ToLower(subject) == "chibot" {
					chibotDelta--
				}
			}
		}

		for name, score := range toUpdate {
			updates = append(
				updates,
				&update{
					filter: bson.M{"name": name},
					update: bson.M{"$inc": bson.M{"score": score}},
				})
		}

		emoji := "heavy_check_mark"
		if chibotDelta > 0 {
			emoji = "sdab"
		} else if chibotDelta < 0 {
			emoji = "cry"
		}

		opts := options.Update().SetUpsert(true)
		collection := handler.DB.Collection("karma")
		for _, u := range updates {
			u := u

			_, err := collection.UpdateOne(context.TODO(), u.filter, u.update, opts)
			if err != nil {
				emoji = "bangbang"
				continue
			}
		}

		handler.API.AddReaction(emoji, slack.NewRefToMessage(event.Channel, event.Timestamp))
	},
}

KarmaHandler responds to a message ending in ++ or -- by tracking score on the word in the message

var MinecraftHandler = &HandlerDefinition{
	Match: func(message string) bool {
		return strings.Contains(strings.ToLower(message), "minecraft server up") || strings.Contains(strings.ToLower(message), "server up")
	},
	Handle: func(reply ReplyFn, event *slack.MessageEvent, handler *Handler) {
		noConnection := func() {
			handler.API.AddReaction("no_entry_sign", slack.NewRefToMessage(event.Channel, event.Timestamp))
		}
		portsString, err := utils.GetEnv("MINECRAFT_PORTS")
		if err != nil {
			noConnection()
			return
		}

		ports := strings.Split(portsString, ",")

		buf := ""
		pubIP, err := pubip.GetStr()
		if err != nil {
			noConnection()
			return
		}

		for i, port := range ports {
			minestat.Init(pubIP, port, 2)

			primaryServer := "Primary "
			server := ""
			if i != 0 {
				server = strconv.Itoa(i + 1)
				primaryServer = ""
			}

			if minestat.Online {
				buf += fmt.Sprintf(`
--------------------------
*%sserver %s*
Address: %s:%s
Players: %s/%s
Version: %s
%s
__________________________
				`,
					primaryServer,
					server,
					minestat.Address,
					minestat.Port,
					minestat.Current_players,
					minestat.Max_players,
					minestat.Version,
					minestat.Motd,
				)
			}
		}

		if buf == "" {
			noConnection()
			return
		}

		reply(event, buf)
	},
}

MinecraftHandler checks the status of running minecraft servers

var ShowKarmaHandler = &HandlerDefinition{
	Match: func(message string) bool {
		return strings.HasPrefix(strings.ToLower(message), "karma") && len(strings.TrimSpace(message)) > len("karma")
	},
	Handle: func(reply ReplyFn, event *slack.MessageEvent, handler *Handler) {
		subjects := funk.UniqString(strings.Split(strings.ToLower(event.Text), " ")[1:])

		buf := ""
		collection := handler.DB.Collection("karma")
		for _, subject := range subjects {
			subject := subject

			var result bson.M
			err := collection.FindOne(context.TODO(), bson.M{"name": subject}).Decode(&result)
			if err != nil {
				buf += fmt.Sprintf("No karma found for `%s`\n", subject)
				continue
			}

			karma := result["score"]

			buf += fmt.Sprintf("Karma for `%s` is `%d`\n", subject, karma)
		}

		reply(event, buf)
	},
}

ShowKarmaHandler reports the store karma value of everything after the word "karma"

var TacoHandler = &HandlerDefinition{
	Match: func(message string) bool {
		validFood := false

		for _, food := range goodFoods {
			if strings.Contains(strings.ToLower(message), food) {
				validFood = true
				continue
			}
		}

		return validFood
	},
	Handle: func(reply ReplyFn, event *slack.MessageEvent, handler *Handler) {
		goodFood, found := funk.FindString(goodFoods, func(food string) bool {
			if strings.Contains(event.Text, food) {
				return true
			}

			return false
		})

		if !found {
			reply(event, "mmm... food...")
			return
		}

		buf := fmt.Sprintf("mmm... %s...", goodFood)
		reply(event, buf)
	},
}

TacoHandler responds to a message containing the substring "taco"

var ThingGotHandler = &HandlerDefinition{
	Match: func(message string) bool {
		matched, _ := regexp.MatchString(ThingGotRegex, message)
		return matched
	},
	Handle: func(reply ReplyFn, event *slack.MessageEvent, handler *Handler) {
		matchRE := regexp.MustCompile(ThingGotRegex)
		match := matchRE.FindStringSubmatch(event.Text)

		if len(adjectives) == 0 {

			adjectives = utils.PopulateAdjectivesFromFile()
		}

		if len(match) < 3 {
			return
		}

		rand.Seed(time.Now().Unix())
		index := rand.Intn(len(adjectives) - 1)
		adjective := adjectives[index]
		aestheticAdjective := strings.Join(strings.Split(adjective, ""), " ")

		// Handle prepositions
		var substr string
		if len(match) == 4 {
			substr = fmt.Sprintf("%s*%s* %s", match[2],
				aestheticAdjective, match[3])
		} else {
			substr = fmt.Sprintf("*%s* %s", adjective,
				match[2])
		}

		if strings.ToLower(match[1]) == "i" {
			user, _ := handler.API.GetUserInfo(event.User)
			match[1] = user.Profile.RealName

			myRE := regexp.MustCompile("(?i)(my)")
			substr = myRE.ReplaceAllLiteralString(substr, "their")
		}

		if strings.ToLower(match[1]) == "chibot" {
			match[1] = "I"
		}

		buf := fmt.Sprintf("%s got %s\n", match[1], substr)
		reply(event, buf)
	},
}

ThingGotHandler responds to a message that contain a substring that matches the regex "(\w+) got (\w+)?"

var ThingGotRegex = "(\\w+) (?i)got (?i)(a |that |an |dat |them |some |sum |its )?(.*)\\?"

ThingGotRegex - for use in ThingGotHandler()

Types

type Handler

type Handler struct {
	Reply ReplyFn
	RTM   *slack.RTM
	API   *slack.Client
	ID    string
	DB    *mongo.Database
}

Handler contains utils to help message handlers respond to messages

func NewClient

func NewClient(token string, DB *mongo.Database) (*Handler, error)

NewClient returns a slack client that is ready to listen to real time messages

func (*Handler) HandleMessages

func (handler *Handler) HandleMessages(event *slack.MessageEvent)

HandleMessages from the real time messaging api, passing them off to the correct fn

func (*Handler) Listen

func (handler *Handler) Listen()

Listen infinitely for slack events (messages) in real time

type HandlerDefinition

type HandlerDefinition struct {
	Match  func(string) bool
	Handle func(ReplyFn, *slack.MessageEvent, *Handler)
}

HandlerDefinition models a function that replies to a message that matches its criteria

type ReplyFn

type ReplyFn func(*slack.MessageEvent, string)

ReplyFn replies to the channel that triggered this event with a message