bot: github.com/go-chat-bot/bot Index | Files | Directories

package bot

import "github.com/go-chat-bot/bot"

Package bot provides a simple to use IRC, Slack and Telegram bot

Index

Package Files

bot.go cmd.go help.go parser.go

Constants

const (
    // CmdPrefix is the prefix used to identify a command.
    // !hello would be identified as a command
    CmdPrefix = "!"

    // MsgBuffer is the max number of messages which can be buffered
    // while waiting to flush them to the chat service.
    MsgBuffer = 100
)

Variables

var (
    // ErrProtocolServerMismatch server && proto must match
    ErrProtocolServerMismatch = errors.New("the specified protocol and server do not correspond to this bot instance")
)

func RegisterCommand Uses

func RegisterCommand(command, description, exampleArgs string, cmdFunc activeCmdFuncV1)

RegisterCommand adds a new command to the bot. The command(s) should be registered in the Init() func of your package command: String which the user will use to execute the command, example: reverse decription: Description of the command to use in !help, example: Reverses a string exampleArgs: Example args to be displayed in !help <command>, example: string to be reversed cmdFunc: Function which will be executed. It will received a parsed command as a Cmd value

func RegisterCommandV2 Uses

func RegisterCommandV2(command, description, exampleArgs string, cmdFunc activeCmdFuncV2)

RegisterCommandV2 adds a new command to the bot. It is the same as RegisterCommand but the command can specify the channel to reply to

func RegisterCommandV3 Uses

func RegisterCommandV3(command, description, exampleArgs string, cmdFunc activeCmdFuncV3)

RegisterCommandV3 adds a new command to the bot. It is the same as RegisterCommand but the command return a chan

func RegisterFilterCommand Uses

func RegisterFilterCommand(command string, cmdFunc filterCmdFuncV1)

RegisterFilterCommand adds a command that is run every time bot is about to send a message. The comand should be registered in the Init() func of your package. Filter commands receive message and its destination and should return modified version. Returning empty string prevents message being sent completely command: String used to identify the command, for internal use only (ex: silence) cmdFunc: Function which will be executed. It will receive the message, target channel and nick who triggered original message

func RegisterMessageStream Uses

func RegisterMessageStream(streamName string, msgFunc messageStreamFunc)

RegisterMessageStream adds a new message stream to the bot. The command should be registered in the Init() func of your package MessageStreams send messages to a channel streamName: String used to identify the command, for internal use only (ex: webhook) messageStreamFunc: Function which will be executed. It will received a MessageStream with a chan to push

func RegisterPassiveCommand Uses

func RegisterPassiveCommand(command string, cmdFunc passiveCmdFuncV1)

RegisterPassiveCommand adds a new passive command to the bot. The command should be registered in the Init() func of your package Passive commands receives all the text posted to a channel without any parsing command: String used to identify the command, for internal use only (ex: logs) cmdFunc: Function which will be executed. It will received the raw message, channel and nick

func RegisterPassiveCommandV2 Uses

func RegisterPassiveCommandV2(command string, cmdFunc passiveCmdFuncV2)

RegisterPassiveCommandV2 adds a new passive command to the bot. The command should be registered in the Init() func of your package Passive commands receives all the text posted to a channel without any parsing command: String used to identify the command, for internal use only (ex: logs) cmdFunc: Function which will be executed. It will received the raw message, channel and nick

func RegisterPeriodicCommand Uses

func RegisterPeriodicCommand(command string, config PeriodicConfig)

RegisterPeriodicCommand adds a command that is run periodically. The command should be registered in the Init() func of your package config: PeriodicConfig which specify CronSpec and a channel list cmdFunc: A function with single string argument (channel) which gets triggered periodically

func RegisterPeriodicCommandV2 Uses

func RegisterPeriodicCommandV2(command string, config PeriodicConfig)

RegisterPeriodicCommandV2 adds a command that is run periodically. The command should be registered in the Init() func of your package config: PeriodicConfig which specifies CronSpec cmdFuncV2: A no-arg function which gets triggered periodically It should return slice of CmdResults (channel and message to send to it)

type Bot Uses

type Bot struct {

    // Protocol and Server are used by MesssageStreams to
    // determine if this is the correct bot to send a message on
    // see:
    // https://github.com/go-chat-bot/bot/issues/37#issuecomment-277661159
    // https://github.com/go-chat-bot/bot/issues/97#issuecomment-442827599
    Protocol string
    // Server and Protocol are used by MesssageStreams to
    // determine if this is the correct bot to send a message on
    // see:
    // https://github.com/go-chat-bot/bot/issues/37#issuecomment-277661159
    // https://github.com/go-chat-bot/bot/issues/97#issuecomment-442827599
    Server string
    // contains filtered or unexported fields
}

Bot handles the bot instance

func New Uses

func New(h *Handlers, bc *Config) *Bot

New configures a new bot instance

func (*Bot) Close Uses

func (b *Bot) Close()

Close will shut down the message sending capabilities of this bot. Call this when you are done using the bot.

func (*Bot) Disable Uses

func (b *Bot) Disable(cmds []string)

Disable allows disabling commands that were registered. It is useful when running multiple bot instances to disabled some plugins like url which is already present on some protocols.

func (*Bot) MessageReceived Uses

func (b *Bot) MessageReceived(channel *ChannelData, message *Message, sender *User)

MessageReceived must be called by the protocol upon receiving a message

func (*Bot) SendMessage Uses

func (b *Bot) SendMessage(om OutgoingMessage)

SendMessage queues a message.

type ChannelData Uses

type ChannelData struct {
    Protocol  string // What protocol the message was sent on (irc, slack, telegram)
    Server    string // The server hostname the message was sent on
    Channel   string // The channel name the message appeared in
    HumanName string // The human readable name of the channel.
    IsPrivate bool   // Whether the channel is a group or private chat
}

ChannelData holds the improved channel info, which includes protocol and server

func (*ChannelData) URI Uses

func (c *ChannelData) URI() string

URI gives back an URI-fied string containing protocol, server and channel.

type Cmd Uses

type Cmd struct {
    Raw         string       // Raw is full string passed to the command
    Channel     string       // Channel where the command was called
    ChannelData *ChannelData // More info about the channel, including network
    User        *User        // User who sent the message
    Message     string       // Full string without the prefix
    MessageData *Message     // Message with extra flags
    Command     string       // Command is the first argument passed to the bot
    RawArgs     string       // Raw arguments after the command
    Args        []string     // Arguments as array
}

Cmd holds the parsed user's input for easier handling of commands

type CmdResult Uses

type CmdResult struct {
    Channel     string // The channel where the bot should send the message
    Message     string // The message to be sent
    ProtoParams interface{}
}

CmdResult is the result message of V2 commands

type CmdResultV3 Uses

type CmdResultV3 struct {
    Channel     string
    Message     chan string
    Done        chan bool
    ProtoParams interface{}
}

CmdResultV3 is the result message of V3 commands

type Config Uses

type Config struct {
    // Protocol and Server are used by MesssageStreams to
    /// determine if this is the correct bot to send a message on
    Protocol string
    // Server and Protocol are used by MesssageStreams to
    // determine if this is the correct bot to send a message on
    Server string
}

Config configuration for this Bot instance

type ErrorHandler Uses

type ErrorHandler func(msg string, err error)

ErrorHandler will be called when an error happens

type FilterCmd Uses

type FilterCmd struct {
    Target  string // Channel or user the message is being sent to
    Message string // Message text being sent
    User    *User  // User who triggered original message
}

FilterCmd holds information about what is output being filtered - message and channel where it is being sent

type Handlers Uses

type Handlers struct {
    Response   ResponseHandler
    ResponseV2 ResponseHandlerV2
    Errored    ErrorHandler
}

Handlers that must be registered to receive callbacks from the bot

type Message Uses

type Message struct {
    Text     string      // The actual content of this Message
    IsAction bool        // True if this was a '/me does something' message
    ProtoMsg interface{} // The underlying object that we got from the protocol pkg
}

Message holds the message info - for IRC and Slack networks, this can include whether the message was an action.

type MessageStream Uses

type MessageStream struct {
    Data chan MessageStreamMessage
    // Done is almost never called, usually the bot should just leave the chan open
    Done chan bool
}

MessageStream allows event information to be transmitted to an arbitrary channel https://github.com/go-chat-bot/bot/issues/97

type MessageStreamMessage Uses

type MessageStreamMessage struct {
    Message     string
    ChannelData *ChannelData
}

MessageStreamMessage the actual Message passed back to MessageStream in a chan

type OutgoingMessage Uses

type OutgoingMessage struct {
    Target      string
    Message     string
    Sender      *User
    ProtoParams interface{}
}

OutgoingMessage collects all the information for a message to go out.

type PassiveCmd Uses

type PassiveCmd struct {
    Raw         string       // Raw message sent to the channel
    MessageData *Message     // Message with extra
    Channel     string       // Channel which the message was sent to
    ChannelData *ChannelData // Channel and network info
    User        *User        // User who sent this message
}

PassiveCmd holds the information which will be passed to passive commands when receiving a message

type PeriodicConfig Uses

type PeriodicConfig struct {
    Version   int
    CronSpec  string                               // CronSpec that schedules some function
    Channels  []string                             // A list of channels to notify, ignored for V2
    CmdFunc   func(channel string) (string, error) // func to be executed at the period specified on CronSpec
    CmdFuncV2 func() ([]CmdResult, error)          // func v2 to be executed at the period specified on CronSpec
}

PeriodicConfig holds a cron specification for periodically notifying the configured channels

type ResponseHandler Uses

type ResponseHandler func(target, message string, sender *User)

ResponseHandler must be implemented by the protocol to handle the bot responses

type ResponseHandlerV2 Uses

type ResponseHandlerV2 func(OutgoingMessage)

ResponseHandlerV2 may be implemented by the protocol to handle the bot responses

type User Uses

type User struct {
    ID       string
    Nick     string
    RealName string
    IsBot    bool
}

User holds user id, nick and real name

Directories

PathSynopsis
debug
google-chat
ircPackage irc implements IRC handlers for github.com/go-chat-bot/bot
rocket
slackPackage slack implements Slack handlers for github.com/go-chat-bot/bot
telegramPackage telegram implements Telegram handlers for github.com/go-chat-bot/bot

Package bot imports 12 packages (graph) and is imported by 100 packages. Updated 2020-10-04. Refresh now. Tools for package owners.