bawt

type Bot struct {
	Config       SlackConfig `json:"Config"`
	Logging      Logging     `json:"Logging"`
	GlobalAdmins []string    `json:"GlobalAdmins"`

	// Slack connectivity
	Slack *slack.Client

	Users    map[string]slack.User
	Groups   []InternalGroup
	Channels map[string]Channel

	Myself slack.UserDetails

	// Storage
	DB *bolt.DB

	// Inter-plugins communications. Use topics like
	// "pluginName:eventType[:someOtherThing]"
	PubSub *pubsub.PubSub

	// Other features
	WebServer WebServer
	Mood      Mood
	// contains filtered or unexported fields
}

type Channel struct {
	ID       string
	Created  time.Time
	IsOpen   bool
	LastRead string
	Name     string
	Creator  string

	// Three mutually exclusives
	IsChannel bool
	IsGroup   bool
	IsIM      bool

	// Only with `IsChannel`
	IsGeneral bool
	Members   []string

	// Only for `IsGroup` (?)
	IsMember   bool
	IsArchived bool

	// Only for `IsIM`
	User          string
	IsUserDeleted bool

	// Only for `IsChannel || IsGroup`
	Topic   slack.Topic
	Purpose slack.Purpose
}

type Command struct {
	Usage    string
	HelpText string
}

type FileUploadParameters slack.FileUploadParameters

type InternalGroup struct {
	Name       string
	SlackGroup slack.UserGroup `json:",omitempty"`
	Members    []string
}

type Listener struct {
	// Name of the app. Used during app listing.
	Name string

	// Description of the app. Used during app listing.
	Description string

	// Slug is a short code used in the help menu
	Slug string

	// Commands are the help documentation for commands
	Commands []Command

	// ListenUntil sets an absolute date at which this Listener
	// expires and stops listening.  ListenUntil and ListenDuration
	// are optional and mutually exclusive.
	ListenUntil time.Time

	// ListenDuration sets a timeout Duration, after which this
	// Listener stops listening and is garbage collected.  A call
	// to `ResetTimeout()` restarts the listening period for another
	// `ListenDuration`.
	ListenDuration time.Duration

	// FromUser filters out incoming messages that are not with
	// `*User` (publicly or privately)
	FromUser *slack.User

	// FromChannel filters messages that are sent to a different room than
	// `Room`. This can be mixed and matched with `FromUser`
	FromChannel *Channel

	// FromAdmin filters messages that are only meant to be said by an admin
	FromAdmin bool

	// FromGroup filters messages that are not from these groups
	FromGroup []slack.Group

	// FromInternalGroup filters out messages not from these groups
	FromInternalGroup []string

	// PrivateOnly filters out public messages.
	PrivateOnly bool

	// PublicOnly filters out private messages.  Mutually exclusive
	// with `PrivateOnly`.
	PublicOnly bool

	// Contains checks whether the `string` is in the message body
	// (after lower-casing both components).
	Contains string

	// ContainsAny checks that any one of the specified strings exist
	// as substrings in the message body.  Mutually exclusive with
	// `Contains`.
	ContainsAny []string

	// Matches checks that the given text matches the given Regexp
	// with a `FindStringSubmatch` call. It will set the `Message.Match`
	// attribute.
	//
	// NOTE: if you spin off a goroutine in the MessageHandlerFunc,
	// make sure to keep a copy of the `Message.Match` object because it
	// will be overwritten by the next Listener the moment your
	// MessageHandlerFunc unblocks.
	Matches *regexp.Regexp

	// ListenForEdits will trigger a message when a user edits a
	// message as well as creates a new one.
	ListenForEdits bool

	// MentionsMe filters out messages that do not mention the Bot's
	// `bot.Config.MentionName`
	MentionsMeOnly bool

	// MatchMyMessages equal to false filters out messages that the bot
	// itself sent.
	MatchMyMessages bool

	// MessageHandlerFunc is a handling function provided by the user, and
	// called when a relevant message comes in.
	MessageHandlerFunc func(*Listener, *Message)

	// EventHandlerFunc is a handling function provided by the user, and
	// called when any event is received. These messages are dispatched
	// to each Listener in turn, after the bot has processed it.
	// If the event is a Message, then the `bawt.Message` will be non-nil.
	//
	// When receiving a `*slack.MessageEvent`, bawt will wrap it in a `*bawt.Message`
	// which embeds the the original event, but adds quite a few functionalities, like
	// reply modes, etc..
	EventHandlerFunc func(*Listener, interface{})

	TimeoutFunc func(*Listener)

	// Bot is a reference to the bot instance.  It will always be populated before being
	// passed to handler functions.
	Bot *Bot
	// contains filtered or unexported fields
}

type Logging struct {
	Logger *logrus.Logger
	Level  string `json:"level" mapstructure:"level"`
	Type   string `json:"type" mapstructure:"type"`
}

type Message struct {
	*slack.Msg
	SubMessage *slack.Msg

	MentionsMe  bool
	IsEdit      bool
	FromMe      bool
	FromUser    *slack.User
	FromChannel *Channel

	// Match contains the result of
	// Listener.Matches.FindStringSubmatch(msg.Text), when `Matches`
	// is set on the `Listener`.
	Match []string
	// contains filtered or unexported fields
}

type Mood int

type Plugin interface{}

type PluginInitializer interface {
	InitPlugin(*Bot)
}

type ReactionEvent struct {
	// Type can be `ReactionAdded` or `ReactionRemoved`
	Type      reaction
	User      string
	Emoji     string
	Timestamp string
	Item      struct {
		Type        string `json:"type"`
		Channel     string `json:"channel,omitempty"`
		File        string `json:"file,omitempty"`
		FileComment string `json:"file_comment,omitempty"`
		Timestamp   string `json:"ts,omitempty"`
	}

	// Original objects regarding the reaction, when called on a `Reply`.
	OriginalReply      *Reply
	OriginalAckMessage *slack.AckMessage

	// When called on `Message`
	OriginalMessage *Message

	// Listener is a reference to the thing listening for incoming Reactions
	// you can call .Close() on it after a certain amount of time or after
	// the user you were interested in processed its things.
	Listener *ReactionListener
}

type ReactionListener struct {
	ListenUntil    time.Time
	ListenDuration time.Duration
	FromUser       *slack.User
	Emoji          string
	Type           reaction

	HandlerFunc func(listen *ReactionListener, event *ReactionEvent)
	TimeoutFunc func(*ReactionListener)
	// contains filtered or unexported fields
}

type Reply struct {
	*slack.OutgoingMessage
	// contains filtered or unexported fields
}

type ReplyWithFile struct {
	*slack.File
	// contains filtered or unexported fields
}

type SlackConfig struct {
	Nickname       string
	JoinChannels   []string `json:"join_channels" mapstructure:"join_channels"`
	GeneralChannel string   `json:"general_channel" mapstructure:"general_channel"`
	TeamDomain     string   `json:"team_domain" mapstructure:"team_domain"`
	TeamID         string   `json:"team_id" mapstructure:"team_id"`
	APIToken       string   `json:"api_token" mapstructure:"api_token"`
	WebBaseURL     string   `json:"web_base_url" mapstructure:"web_base_url"`
	DBPath         string   `json:"db_path" mapstructure:"db_path"`
}

type UpdateableReply struct {
	// contains filtered or unexported fields
}

type WebPlugin interface {
	InitWebPlugin(bot *Bot, private *mux.Router, public *mux.Router)
}

type WebServer interface {
	// Used internally by the `bawt` library.
	InitWebServer(*Bot, []string)
	RunServer()

	// Used by an Auth provider.
	SetAuthMiddleware(func(http.Handler) http.Handler)
	SetAuthenticatedUserFunc(func(req *http.Request) (*slack.User, error))

	// Can be called by any plugins.
	PrivateRouter() *mux.Router
	PublicRouter() *mux.Router
	GetSession(*http.Request) *sessions.Session
	AuthenticatedUser(*http.Request) (*slack.User, error)
}

type WebServerAuth interface {
	InitWebServerAuth(bot *Bot, webserver WebServer)
}