common

README

Common

Common code shared between my bots.

Features

• Creation of the bot (commands, status, handlers)
• Basic config
• Redis connection
• Postgres connection
• Various useful things (logger, timers)

Technologies

• Go 1.21
• go-redis
• pelletier/go-toml
• GORM

Documentation

Index

• Constants
• Variables
• func Get(cfg any, defaultConfig string, name string) error
• func SetupConfigs(cfgInfo []ConfigInfo) error
• type BaseConfig
• type Bot
  • func (b *Bot) Start()
• type Cmd
• type ConfigInfo
• type DatabaseCredentials
  • func (dc *DatabaseCredentials) Connect() (*gorm.DB, error)
• type GCommandChoice
  • func NewChoice(name string, value interface{}) *GCommandChoice
  • func (c *GCommandChoice) ToDiscordChoice() *discordgo.ApplicationCommandOptionChoice
• type GCommandOption
  • func NewOption(t discordgo.ApplicationCommandOptionType, name string, description string) *GCommandOption
  • func (o *GCommandOption) AddChoice(c *GCommandChoice) *GCommandOption
  • func (o *GCommandOption) IsRequired() *GCommandOption
  • func (o *GCommandOption) ToDiscordOption() *discordgo.ApplicationCommandOption
• type GeneralCommand
  • func NewCommand(name string, description string) *GeneralCommand
  • func (c *GeneralCommand) AddOption(s *GCommandOption) *GeneralCommand
  • func (c *GeneralCommand) AddSub(s *GeneralCommand) *GeneralCommand
  • func (c *GeneralCommand) ContainsSub() *GeneralCommand
  • func (c *GeneralCommand) DM() *GeneralCommand
  • func (c *GeneralCommand) HasOption() *GeneralCommand
  • func (c *GeneralCommand) SetHandler(handler func(s *discordgo.Session, i *discordgo.InteractionCreate)) *GeneralCommand
  • func (c *GeneralCommand) SetPermission(p int64) *GeneralCommand
  • func (c *GeneralCommand) ToCmd() *Cmd
  • func (c *GeneralCommand) ToSubCmd() *SubCmd
• type Main
• type RedisCredentials
  • func (rc *RedisCredentials) Get() (*redis.Client, error)
• type SimpleSubCmd
• type Status
• type SubCmd
  • func (s *SubCmd) ToSimple() *SimpleSubCmd
• type UserBase
  • func (p *UserBase) GenKey() string

Constants

const (
	GameStatus      = 0
	WatchStatus     = 1
	StreamingStatus = 2
	ListeningStatus = 3

	AdminPermission int64 = discordgo.PermissionManageServer // AdminPermission of the command
)

Variables

var (
	Debug bool

	ErrBadStatusType     = errors.New("bad status type, please use the constant")
	ErrStatusUrlNotFound = errors.New("status url not found")
)

var (
	//go:embed resources/config.toml
	DefaultBaseConfig string

	// BaseCfg is the BaseConfig used by the bot
	BaseCfg BaseConfig

	ErrImpossibleToConnectDB    = errors.New("impossible to connect to the database")
	ErrImpossibleToConnectRedis = errors.New("impossible to connect to redis")
)

var (
	ErrGuildIDDiscordIDNotPresent = errors.New("guild_id or discord_id not informed")
	ErrNilClient                  = errors.New("redis.NewClient is nil")
)

var Ctx = context.Background()

Ctx background

var DB *gorm.DB

DB used

var (
	ErrSubsAreNil = errors.New("subs are nil in general handler")
)

Functions

func Get

func Get(cfg any, defaultConfig string, name string) error

Get a config (already called on start)

func SetupConfigs

func SetupConfigs(cfgInfo []ConfigInfo) error

SetupConfigs with the given configs (+ base config which is available at BaseCfg)

Types

type BaseConfig

type BaseConfig struct {
	Main     Main
	Redis    RedisCredentials
	Database DatabaseCredentials
}

BaseConfig is all basic configuration (debug, redis connection and database connection)

type Bot

type Bot struct {
	Token    string        // Token of the Bot
	Status   []*Status     // Status of the Bot
	Commands []*Cmd        // Commands of the Bot
	Handlers []interface{} // Handlers of the Bot
}

Bot is the representation of a discord bot

func (*Bot) Start

func (b *Bot) Start()

Start the Bot

type Cmd

type Cmd struct {
	*discordgo.ApplicationCommand
	Handler func(s *discordgo.Session, i *discordgo.InteractionCreate) // Handler called
	Subs    []*SimpleSubCmd
}

Cmd is a discordgo.ApplicationCommand + its handler

Use AdminPermission to set the admin permission

type ConfigInfo

type ConfigInfo struct {
	Cfg     any    // pointer to the struct
	Name    string // name of the config
	Default string // default content of the config
}

ConfigInfo has all required information to get a config

type DatabaseCredentials

type DatabaseCredentials struct {
	Host     string
	User     string
	Password string
	DBName   string
	Port     int
}

func (*DatabaseCredentials) Connect

func (dc *DatabaseCredentials) Connect() (*gorm.DB, error)

Connect to the postgres database using the given config.DatabaseCredentials

type GCommandChoice

type GCommandChoice struct {
	Name  string
	Value interface{}
}

GCommandChoice represents a generic choice of GCommandOption

func NewChoice

func NewChoice(name string, value interface{}) *GCommandChoice

NewChoice creates a new choice for GCommandOption

func (*GCommandChoice) ToDiscordChoice

func (c *GCommandChoice) ToDiscordChoice() *discordgo.ApplicationCommandOptionChoice

ToDiscordChoice turns GCommandChoice into a discordgo.ApplicationCommandOptionChoice (internal use of the API only)

type GCommandOption

type GCommandOption struct {
	Type        discordgo.ApplicationCommandOptionType
	Name        string
	Description string
	Required    bool
	Choices     []*GCommandChoice
}

GCommandOption represents a generic option of GeneralCommand

func NewOption

func NewOption(t discordgo.ApplicationCommandOptionType, name string, description string) *GCommandOption

NewOption creates a new GCommandOption

func (*GCommandOption) AddChoice

func (o *GCommandOption) AddChoice(c *GCommandChoice) *GCommandOption

AddChoice to the GCommandOption

func (*GCommandOption) IsRequired

func (o *GCommandOption) IsRequired() *GCommandOption

IsRequired informs that the GCommandOption is required

func (*GCommandOption) ToDiscordOption

func (o *GCommandOption) ToDiscordOption() *discordgo.ApplicationCommandOption

ToDiscordOption turns GCommandOption into a discordgo.ApplicationCommandOption (internal use of the API only)

type GeneralCommand

type GeneralCommand struct {
	HasSub      bool
	IsSub       bool
	Name        string
	Permission  int64
	CanDM       bool
	Description string
	Options     []*GCommandOption
	Subs        []*GeneralCommand
	Handler     func(s *discordgo.Session, i *discordgo.InteractionCreate) // Handler called
}

GeneralCommand represents a generic command

func NewCommand

func NewCommand(name string, description string) *GeneralCommand

NewCommand creates a GeneralCommand

func (*GeneralCommand) AddOption

func (c *GeneralCommand) AddOption(s *GCommandOption) *GeneralCommand

AddOption to the GeneralCommand (also call HasOption)

func (*GeneralCommand) AddSub

func (c *GeneralCommand) AddSub(s *GeneralCommand) *GeneralCommand

AddSub to the GeneralCommand (also call ContainsSub)

func (*GeneralCommand) ContainsSub

func (c *GeneralCommand) ContainsSub() *GeneralCommand

ContainsSub makes the GeneralCommand able to contain subcommands

func (*GeneralCommand) DM

func (c *GeneralCommand) DM() *GeneralCommand

DM makes the GeneralCommand used in DM

func (*GeneralCommand) HasOption

func (c *GeneralCommand) HasOption() *GeneralCommand

HasOption makes the GeneralCommand able to contains GCommandOption

func (*GeneralCommand) SetHandler

func (c *GeneralCommand) SetHandler(handler func(s *discordgo.Session, i *discordgo.InteractionCreate)) *GeneralCommand

SetHandler of the GeneralCommand (if GeneralCommand contains subcommand, it will never be called)

func (*GeneralCommand) SetPermission

func (c *GeneralCommand) SetPermission(p int64) *GeneralCommand

SetPermission of the GeneralCommand

func (*GeneralCommand) ToCmd

func (c *GeneralCommand) ToCmd() *Cmd

ToCmd turns GeneralCommand into a Cmd (internal use of the API only)

func (*GeneralCommand) ToSubCmd

func (c *GeneralCommand) ToSubCmd() *SubCmd

ToSubCmd turns GeneralCommand into a SubCmd (internal use of the API only)

type Main

type Main struct {
	Debug bool
}

type RedisCredentials

type RedisCredentials struct {
	Address  string
	Password string
	DB       int
}

var Credentials RedisCredentials

Credentials of redis

func (*RedisCredentials) Get

func (rc *RedisCredentials) Get() (*redis.Client, error)

Get the redis.Client with the given RedisCredentials

type SimpleSubCmd

type SimpleSubCmd struct {
	Name    string
	Handler func(s *discordgo.Session, i *discordgo.InteractionCreate) // Handler called
}

SimpleSubCmd is for the internal use of the API

type Status

type Status struct {
	Type    int    // Type of the Status (use GameStatus or WatchStatus or StreamingStatus or ListeningStatus)
	Content string // Content of the Status
	Url     string // Url of the StreamingStatus
}

Status contains all required information for updating the status

type SubCmd

type SubCmd struct {
	*discordgo.ApplicationCommandOption
	Handler func(s *discordgo.Session, i *discordgo.InteractionCreate) // Handler called
}

SubCmd is for the internal use of the API

func (*SubCmd) ToSimple

func (s *SubCmd) ToSimple() *SimpleSubCmd

ToSimple turns SubCmd into a SimpleSubCmd

type UserBase

type UserBase struct {
	DiscordID string
	GuildID   string
}

UserBase is the minimum struct required to store a used in redis

func (*UserBase) GenKey

func (p *UserBase) GenKey() string