alexandre-normand/slackscot

package slackscot

import (
    "fmt"
    "github.com/alexandre-normand/slackscot/config"
    "io"
    "strings"
)

type helpPlugin struct {
    Plugin

    name                   string
    slackscotVersion       string
    timeLocation           string
    commands               map[string][]ActionDefinition
    hearActions            []ActionDefinition
    pluginScheduledActions []pluginScheduledAction
    cmdPrefix              string
}

const (
    helpPluginName = "help"
)

// pluginScheduledAction represents a plugin's scheduled action with the plugin name and the action's definition
type pluginScheduledAction struct {
    plugin string
    ScheduledActionDefinition
}

func (s *Slackscot) newHelpPlugin(version string) *helpPlugin {
    commands, hearActions, scheduledActions := findAllActions(s.namespaceCommands, s.plugins)

    helpPlugin := new(helpPlugin)
    helpPlugin.timeLocation = s.config.GetString(config.TimeLocationKey)
    helpPlugin.name = s.name
    helpPlugin.slackscotVersion = version
    helpPlugin.commands = commands
    helpPlugin.hearActions = hearActions
    helpPlugin.pluginScheduledActions = scheduledActions
    helpPlugin.cmdPrefix = s.cmdMatcher.UsagePrefix()

    helpPlugin.Plugin = Plugin{Name: helpPluginName, Commands: []ActionDefinition{{
        Match: func(m *IncomingMessage) bool {
            return strings.HasPrefix(m.NormalizedText, "help")
        },
        Usage:       helpPluginName,
        Description: "Reply with usage instructions",
        Answer:      helpPlugin.showHelp,
    }}, HearActions: nil}

    return helpPlugin
}

// showHelp generates a message providing a list of all of the slackscot commands and hear actions.
// Note that ActionDefinitions with the flag Hidden set to true won't be included in the list
func (h *helpPlugin) showHelp(m *IncomingMessage) *Answer {
    var b strings.Builder

    // Get the user's first name using the botservices
    userID := m.User
    user, err := h.UserInfoFinder.GetUserInfo(userID)
    if err != nil {
        h.Logger.Debugf("Error getting user info for user id [%s] so skipping mentioning the name (it would be awkward): %v", userID, err)
    } else {
        fmt.Fprintf(&b, "🤝 Hi, `%s`! ", user.RealName)
    }

    fmt.Fprintf(&b, "I'm `%s` (engine `v%s`) and I listen to the team's chat and provides automated functions :genie:.\n", h.name, h.slackscotVersion)

    if lenCommands(h.commands) > 0 {
        fmt.Fprintf(&b, "\nI currently support the following commands:\n")

        for n, commands := range h.commands {
            appendActions(&b, h.cmdPrefix, n, commands)
        }
    }

    if len(h.hearActions) > 0 {
        fmt.Fprintf(&b, "\nAnd listen for the following:\n")

        appendActions(&b, "", "", h.hearActions)
    }

    if len(h.pluginScheduledActions) > 0 {
        fmt.Fprintf(&b, "\nAnd do those things periodically:\n")

        appendScheduledActions(&b, h.timeLocation, h.pluginScheduledActions)
    }

    return &Answer{Text: b.String(), Options: []AnswerOption{AnswerInThread()}}
}

// lenCommands returns the length of a map of string to array of values by summing
// up the length of all array values
func lenCommands(entries map[string][]ActionDefinition) (length int) {
    length = 0
    for _, v := range entries {
        length = length + len(v)
    }

    return length
}

func appendActions(w io.Writer, prefix string, pluginNamespace string, actions []ActionDefinition) {
    for _, value := range actions {
        if value.Usage != "" && !value.Hidden {
            if len(pluginNamespace) > 0 {
                fmt.Fprintf(w, "\t• `%s%s %s` - %s\n", prefix, pluginNamespace, value.Usage, value.Description)
            } else {
                fmt.Fprintf(w, "\t• `%s%s` - %s\n", prefix, value.Usage, value.Description)
            }
        }
    }
}

func appendScheduledActions(w io.Writer, timeLocationName string, scheduledActions []pluginScheduledAction) {
    for _, value := range scheduledActions {
        if !value.ScheduledActionDefinition.Hidden {
            fmt.Fprintf(w, "\t• [`%s`] `%s` (`%s`) - %s\n", value.plugin, value.ScheduledActionDefinition.Schedule, timeLocationName, value.ScheduledActionDefinition.Description)
        }
    }
}

func findAllActions(namespaceCommands bool, plugins []*Plugin) (commands map[string][]ActionDefinition, hearActions []ActionDefinition, pluginScheduledActions []pluginScheduledAction) {
    commands = make(map[string][]ActionDefinition)
    hearActions = make([]ActionDefinition, 0)
    pluginScheduledActions = make([]pluginScheduledAction, 0)

    for _, p := range plugins {
        namespace := ""
        if namespaceCommands && p.NamespaceCommands {
            namespace = p.Name
        }

        if _, ok := commands[namespace]; !ok {
            commands[namespace] = make([]ActionDefinition, 0)
        }

        commands[namespace] = append(commands[namespace], filterNonHiddenActions(p.Commands)...)
        hearActions = append(hearActions, filterNonHiddenActions(p.HearActions)...)
        pluginScheduledActions = append(pluginScheduledActions, filterNonHiddenScheduledActions(p.Name, p.ScheduledActions)...)
    }

    return commands, hearActions, pluginScheduledActions
}

func filterNonHiddenActions(actions []ActionDefinition) (visibleActions []ActionDefinition) {
    visibleActions = make([]ActionDefinition, 0)
    for _, a := range actions {
        if !a.Hidden {
            visibleActions = append(visibleActions, a)
        }
    }

    return visibleActions
}

func filterNonHiddenScheduledActions(pluginName string, actions []ScheduledActionDefinition) (visibleActions []pluginScheduledAction) {
    visibleActions = make([]pluginScheduledAction, 0)

    for _, sa := range actions {
        if !sa.Hidden {
            visibleActions = append(visibleActions, pluginScheduledAction{plugin: pluginName, ScheduledActionDefinition: sa})
        }
    }

    return visibleActions
}