workqueue

type ChannelJoinHandler func(ctx Context, cj *slackevents.MemberJoinedChannelEvent) (shouldRetry, discarded bool, err error)

type ChannelSvc interface {
	Lookup(channelName string) (slack.Channel, bool, error)
}

type Config struct {
	// ConsumerName is this node's unique identifier. Leave blank to use
	// hostname.
	ConsumerName string

	// ConsumerGroup is likely this node's application or service name. Leave
	// blank to use hostname, although that's not recommended. If you are only
	// producing events this is safe to be kept blank.
	ConsumerGroup string

	// VisibilityTimeout is how long a consumer will wait for others to finish a
	// task before assuming they are dead and stealing it. If you're acting as
	// only a producer this can be left as its zero value.
	VisibilityTimeout time.Duration

	// RedisClient is the *redis.Client to use for the workqueue.
	RedisClient *redis.Client

	// Logger is the logger
	Logger *zerolog.Logger

	// SlackClient is the client we give to handlers
	SlackClient *slack.Client

	// SlackUser is the slack user that this consumer is running as.
	SlackUser *slack.User

	// ChannelCache is the cache the workqueue will present as the ChannelSvc.
	// Generally this is implemented by a *cache.Channel.
	ChannelCache ChannelSvc
}

type Context interface {
	context.Context

	// Meta is the event metadata about this job. When did Slack emit it, when
	// did we ingest it, etc.
	Meta() EventMetadata

	// Logger presents the logger create for this handler. This logger isn't
	// global, and is instead request local
	Logger() *zerolog.Logger

	// Slack is the Slack client.
	Slack() *slack.Client

	// Self is the info for the bot user we're using the credentials of.
	Self() slack.User

	// ChannelSvc provides a way to work with the internal channel metadata
	// cache.
	ChannelSvc() ChannelSvc
}

type Event string

type EventMetadata struct {
	// ID represents the ID as given to us by Slack.
	ID string

	// Time is the time the event was emitted according to Slack.
	Time time.Time

	// IngestTime is the time we received the event from Slack.
	IngestTime time.Time

	// RedisEvent is the ID of the message sent through the Redis queue.
	RedisEvent string
}

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

type MessageHandler func(ctx Context, me *slackevents.MessageEvent) (shouldRetry, discarded bool, err error)

type Publisher interface {
	Publish(e Event, eventTimestamp int64, eventID, requetID string, jsonData []byte) error
}

type Q interface {
	Publisher
	Registerer
}

type Registerer interface {
	RegisterTeamJoinsHandler(timeout time.Duration, fn TeamJoinHandler)
	RegisterChannelJoinsHandler(timeout time.Duration, fn ChannelJoinHandler)
	RegisterPublicMessagesHandler(timeout time.Duration, fn MessageHandler)
	RegisterPrivateMessagesHandler(timeout time.Duration, fn MessageHandler)
}

type TeamJoinHandler func(ctx Context, tj *slack.TeamJoinEvent) (shouldRetry, discarded bool, err error)