Field

Description

.CCID

The ID of currently executing custom command in type of int64.

.CCRunCount

Shows run count of triggered custom command, although this is not going to be 100% accurate as it's cached up to 30 minutes.

.IsPremium

Returns boolean true/false whether guild is premium of YAGPDB or not.

Field

Description

.User

The user's username together with discriminator.

.User.Avatar

The user's avatar ID.

.User.AvatarURL "256"

Gives the URL for user's avatar, argument "256" is the size of the picture and can increase/decrease twofold (e.g. 512, 1024 or 128, 64 etc.).

.User.Bot

Determines whether the target user is a bot - if yes, it will return true.

.User.Discriminator

The user's discriminator (The four digits after a person's username).

.User.ID

The user's ID.

.User.Mention

Mentions user.

.User.String

The user's username together with discriminator as string type.

.User.Username

The user's username.

.UsernameHasInvite

Only works with join and leave messages (not join dms). It will determine does the username contain an invite link.

.RealUsername

Only works with join and leave messages (not join DMs). This can be used to send the real username to a staff channel when invites are censored.

Function

Description

userArg mention/userID

Function that can be used to retrieve .User object from a mention or userID.

{{(userArg .User.ID).Mention}} mentions triggering user. Explained more in this section's snippets.

pastUsernames userID offset

Returns a slice of type [ ]*logs.CCNameChange having fields .Name and .Time of previous 15 usernames and skips offset number in that list.

{{range pastUsernames .User.ID 0}} {{.Name}} - {{.Time.Format "Jan _2 2006"}} {{end}}

pastNicknames userID offset

Same as pastUsernames.

Field

Description

.Guild.AfkChannelID

Outputs the AFK channel ID.

.Guild.AfkTimeout

Outputs the time when a user gets moved into the AFK channel while not being active.

.Guild.DefaultMessageNotifications

Outputs the default message notification setting for the guild.

.Guild.EmbedEnabled

Outputs whether guild is embeddable (e.g. widget) or not, true / false.

.Guild.ExplicitContentFilter

Outputs the explicit content filter level for the guild.

.Guild.Icon

Outputs the icon hash ID of the guild's icon.

.Guild.ID

Outputs the ID of the guild.

.Guild.JoinedAt

Outputs the timestamp when YAGPDB joined the guild. To convert it to type time.Time, use .Parse method > .Guild.JoinedAt.Parse

.Guild.MemberCount

Outputs the number of users on a guild.

.Guild.MfaLevel

required MFA level for the guild. If enabled, members with moderation powers will be required to have 2-factor authentication enabled in order to exercise moderation powers.

.Guild.Name

Outputs the name of the guild.

.Guild.OwnerID

Outputs the ID of the owner.

.Guild.Region

Outputs the region of the guild.

.Guild.Roles

Outputs all roles and indexing them gives more information about the role. For example {{len .Guild.Roles}} gives you how many roles are there in that guild. Role struct has following fields.

.Guild.Splash

Outputs the splash hash ID of the guild's splash.

.Guild.SystemChannelID

The id of the channel where guild notices such as welcome messages and boost events are posted.

.Guild.VerificationLevel

Outputs the required verification level for the guild.

.Guild.VoiceStates

Outputs a list of voice states (users connected to VCs) with type *discordgo.VoiceState.

.Guild.WidgetEnabled

Outputs whether or not the Server Widget is enabled or not.

.Guild.WidgetChannelID

Outputs the channel id for the server widget.

Field

Description

.Member.JoinedAt

When member joined the guild/server of type discordgo.Timestamp. Method .Parse will convert this to of type time.Time.

.Member.Nick

The nickname for this member.

.Member.Roles

A slice of role IDs that the member has.

.Member.User

Underlying user on which the member is based on.

Function

Description

editNickname "newNick"

Edits triggering user's nickname, argument has to be of type string. YAGPDB's highest role has to be above the highest role of the member.

getMember

Function returns Member object having above methods.

{{(getMember .User.ID).JoinedAt}} is the same as {{.Member.JoinedAt}}

onlineCount

Returns the count of online users/members on current server.

onlineCountBots

Returns the count of online bots.

Field

Description

.Channel.ID

The ID of the channel.

.Channel.Name

The name of the channel.

.Channel.NSFW

Outputs whether this channel is NSFW or not.

.Channel.ParentID

The ID of the channel's parent (category), returns 0 if none.

.Channel.Topic

The topic of the channel.

Function

Description

editChannelName channel "newName"

Function edits channel's name. channel can be either ID, "name" or even nil if triggered in that channel name change is intended to happen. "newName" has to be of type string. For example >{{editChannelName nil (joinStr "" "YAG - " (randInt 1000))}}

editChannelTopic channel "newTopic"

Function edits channel's topic/description. channel can be either ID, "name" or even nil if triggered in that channel name change is intended to happen. "newTopic" has to be of type string. For example >

{{editChannelTopic nil "YAG is cool"}}

getChannel channel

Function returns full channel object of given channel argument which can be either its ID, name or nil for triggering channel, and is of type *dstate.ChannelState. For example > {{(getChannel nil).Name}} returns the name of the channel command was triggered in.

Field

Description

.Message.Attachments

Attachments of this message (slice of attachment objects).

.Message.Author

Author of the message (User object).

.Message.ChannelID

Channel ID this message is in.

.Message.Content

Text content on this message.

.Message.EditedTimestamp

The time at which the last edit of the message occurred, if it has been edited. As with .Message.Timestamp, it is of type discordgo.Timestamp.

.Message.Embeds

Embeds of this message (slice of embed objects).

.Message.GuildID

Guild ID in which the message is.

.Message.ID

ID of the message.

.Message.MentionEveryone

Whether the message mentions everyone.

.Message.MentionRoles

The roles mentioned in the message.

.Message.Mentions

Users this message mentions.

.Message.Pinned

Whether this message is pinned.

.Message.Reactions

Reactions on this message (only available from getMessage).

.Message.Timestamp

Timestamp of the message in type discordgo.Timestamp (use .Message.Timestamp.Parse to get type time.Time and .Parse.String method returns type string).

.Message.Type

The type of the message.

.Args

List of everything that is passed to .Message.Content. .Args is a slice of type string.

.Cmd

.Cmd is of type string and shows all arguments that trigger custom command, part of .Args. Starting from {{index .Args 0}}.

.CmdArgs

List of all the arguments passed after .Cmd (.Cmd is the actual trigger) .CmdArgs is a slice of type string. Examples in misc. snippets.

.StrippedMsg

"Strips" or cuts off the triggering part of the message and prints out everything else after that. Bear in mind, when using regex as trigger, for example "day" and input message is "Have a nice day my dear YAG!" output will be "my dear YAG!" - rest is cut off.

Field

Description

.Reaction

Returns reaction object which has following fields UserID, MessageID, Emoji.(ID/Name/...), ChannelID, GuildID. Emoji.ID is the ID of the emoji for custom emojis, and Emoji.Name will hold the unicode emoji if its a default one. (otherwise the name of the custom emoji).

.ReactionAdded

Returns a boolean type bool true/false indicating whether reaction was added or removed.

.ReactionMessage

Returns the message object reaction was added to.

{{range .ReactionMessage.Reactions}} {{.Count}} - {{.Emoji.Name}} {{end}}

Returns emoji count and their name.

Has an alias .Message and works it works the same way.

Field

Description

.DiscordEpoch

Gives you Discord Epoch time in time.Time. {{.DiscordEpoch.Unix}} would return in seconds > 1420070400.

.UnixEpoch

Gives you Unix Epoch time in time.Time.

.TimeHour

Variable of time.Duration type and returns 1 hour > 1h0m0s.

.TimeMinute

Variable of time.Duration type and returns 1 minute > 1m0s.

.TimeSecond

Variable of time.Duration type and returns 1 second > 1s.

Function

Description

currentTime

Gets the current time, value is of type time.Time which can be used in a custom embed. More info here.

formatTime Time "arg"

Outputs given time in RFC822 formatting, first argument Time shows it needs to be of type time.Time, also with extra layout if second argument is given - e.g. {{formatTime currentUserCreated "3:04PM"}} would output 11:22AM if that would have been user's creating time.

humanizeDurationHours

Returns given integer (whole number) or time.Duration argument in nanoseconds in human readable format - as how long it would take to get towards given time - e.g. {{humanizeDurationHours 9000000000000000000}} returns 285 years 20 weeks 6 days and 16 hours. More in Snippets.

humanizeDurationMinutes

Sames as humanizeDurationHours, this time duration is returned in minutes - e.g. {{humanizeDurationMinutes 3500000000000}} would return 58 minutes.

humanizeDurationSeconds

Sames as both humanize functions above, this time duration is returned in seconds - e.g. {{humanizeDurationSeconds 3500000000000}} would return 58 minutes and 20 seconds.

humanizeTimeSinceDays

Returns time passed since given argument of type time.Time in human readable format - e.g. {{humanizeTimeSinceDays currentUserCreated}}

newDate year month day hour minute second [timezone]

Returns new type time.Time object in UTC using given syntax (all arguments need to be of type int), for example > {{humanizeDurationHours ((newDate 2059 1 2 12 34 56).Sub currentTime)}} will give you how much time till year 2059 January 2nd 12:34:56. More examples in Snippets.

timezone is an optional string argument which uses golang's LoadLocation function and ZONEINFO syntax. For example: {{newDate 2020 4 20 12 34 56 "Atlantic/Reykjavik"}} would return that time in GMT+0.

Function

Description

cslice value1 value2 ...

Function creates a slice of type templates.Slice that can be used elsewhere (as an argument for cembed and sdict for example).

Example: cslice 1 "2" (dict "three" 3) 4.5 returns [1 2 map[three:3] 4.5], having length of 4 and index positions from 0 to 3. Notice that thanks to type interface{} value, templates.Slice elements' inherent type does not change.

Method

Description

.Append arg

Creates a new cslice having given argument appended fully by its type to current value. Has max size of 10 000 length.

.AppendSlice arg

Creates a new cslice from argument of type slice appended/joined with current value. Has max size of 10 000 length.

.Set int value

Changes/sets given int argument as index position of current cslice to new value. Note that .Set can only set indexes which already exist in the slice.

.StringSlice strict-flag

Compares slice contents - are they of type string, based on the strict-flag which is boolean and is by default false. Under these circumstances if the element is a string then those elements will be included as a part of the []string slice and rest simply ignored. Also time.Time elements - their default string notation will be included. If none are string an empty []string slice is returned.

If strict-flag is set to true it will return a []string only if all elements are pure string, else <no value> is returned.

Example in this section's Snippets.

Function

Description

sdict "key1" value1 "key2" value2 ...

Like dict function, creating a templates.SDict type map, key must be of type string. Can be used for example in cembed. If only one argument is passed to sdict function having type map[string]interface{}; for example .ExecData and data retrieved from database can be of such type if sdict was used, it is converted to a new sdict.

​

Example: sdict "one" 1 "two" 2 "three" (cslice 3 4) "five" 5.5 returns unordered map[five:5.5 one:1 three:[3 4] two:2], having length of four and index positions are its keys. Notice that thanks to type interface{} value, templates.SDict elements' inherent type does not change.

Method

Description

.Del "key"

Deletes given key from sdict.

.Get "key"

Retrieves given key from sdict.

.Set "key" value

Changes/sets given key to a new value or creates new one, if no such key exists in sdict.

Function

Description

json value

Traverses given value through MarshalJSON (more here) and returns it as type string. For example {{json .TimeHour}} outputs type string; before this .TimeHour was of type time.Duration. Basically it's good to use if multistep type conversion is needed (toString (toInt value) ) and certain parts of cembed need this for example.

structToSdict struct

Function converts exported field-value pairs of a struct to an sdict. For example it is useful for editing embeds, rather than having to reconstruct the embed field by field manually. Exampe: {{$x := cembed "title" "Something rules!" "color" 0x89aa00}} {{$x.Title}} {{$x = structToSdict $x}} {{- x.Set "Title" "No, YAGPDB rules!!!" -}} {{$x.Title}} {{$x}} will return No, YAGPDB rules!!! and whole sdict-mapped cembed.

toByte "arg"

Function converts input to a slice of bytes - meaning []uint8. {{toByte "YAG€"}} would output [89 65 71 226 130 172]. toString is capable of converting that slice back to string.

toDuration

Converts the argument, number or string to type time.Duration. Number represents nanoseconds. String can be with time modifier (second, minute, hour, day etc) s, m, h, d, w, mo, y,without a modifier string will be converted to minutes. Usage:(toDuration x). Example in section's Snippets.

toFloat

Converts argument (int or string type of a number) to type float64. Usage: (toFloat x). Function will return 0, if type can't be converted to float64.

toInt

Converts something into an integer of type int. Usage: (toInt x). Function will return 0, if type can't be converted to int.

toInt64

Converts something into an int64. Usage: (toInt64 x). Function will return 0, if type can't be converted to int64.

toRune "arg"

Function converts input to a slice of runes - meaning []int32. {{toRune "YAG€"}}would output [89 65 71 8364]. These two functions - the one above, are good for further analysis of Unicode strings. toString is capable of converting that slice back to string.

toString

Has alias str. Converts some other types into a string. Usage: (toString x).

Function

Description

joinStr "separator" "str1" (arg1)(arg2) "str2" ...

Joins several strings into one, separated by the first argument"separator", example:{{joinStr "" "1" "2" "3"}} returns 123. Also if functions have string or easily convertible return, they can be used inside joinStr e.g. {{joinStr "" "Let's calculate " (add (mult 13 3) 1 2) ", was returned at " (currentTime.Format "15:04") "."}}

lower "string"

Converts the string to lowercase.

upper "string"

Converts the string to uppercase.

slice "string"|slice integer (integer2)

Function's first argument must be of type string or slice.

Outputs the "string" after cutting/slicing off integer (numeric) value of symbols (actually starting the string's index from integer through integer2) - e.g. {{slice "Fox runs" 2}}outputs x runs. When using also integer2 - e.g. {{slice "Fox runs" 1 7}}, it outputs ox run. For slicing whole arguments, let's say words, see example in section's Snippets.

​

This slice function is not the same as basic dynamically-sized slice data type discussed in this reference doc. Also it's custom, not having 3-indices as the default one from text/template package.

urlescape "string"

Escapes the string so it can be safely placed inside a URL path segment - e.g. "Hello, YAGPDB!" becomes "Hello%2C%20YAGPDB%21"

split "string" "sepr"

Splits given "string" to substrings separated by "sepr"arg and returns new slice of the substrings between given separator e.g. {{split "YAG, is cool!" ","}} returns [YAG is cool!] slice where YAG is at index position 0 and is cool! at index position 1. Example also in section's Snippets.

title "string"

Returns string with the first letter of each word capitalized.

reFind "regex" "string"

Compares "string" to regex pattern and returns first match. {{reFind "AG" "YAGPDB is cool!"}}returns AG (regex pattern is case sensitive).

reFindAll "regex" "string"

Adds all regex matches from the "string" to a slice. Example in section's Snippets.

reFindAllSubmatches "regex" "string"

Returns whole-pattern matches and also the sub-matches within those matches as slices inside a slice. {{reFindAllSubmatches "(?i)y([a-z]+)g" "youngish YAGPDB"}} returns [[young oun] [YAG A]] (regex pattern here is case insensitive).

reReplace "regex" "string1" "string2"

Replaces "string1" contents with "string2" at regex match point. {{reReplace "I am" "I am cool!" "YAGPDB is"}}returns YAGPDB is cool! (regex pattern here is case sensitive).

print, printf, println

These are GO template package's predefined functions and are aliases for fmt.Sprint, fmt.Sprintf and fmt.Sprintln. Formatting is also discussed here. printf is usable for example to determine the type of the value > {{printf "%T" currentTime}} outputs currentTime functions output value type of time.Time. In many cases, printf is a great alternative to joinStr for concatenate strings.

Function

Description

add x y z ...

Returns x + y + z + ..., detects first number's type - is it int or float and based on that adds. (use toFloat on the first argument to force floating point math.){{add 5 4 3 2 -1}} sums all these numbers and returns 13.

sub x y z ...

Returns x - y -z - ... Works like add, just subtracts.

mult x y z ...

Multiplication, like add or div, detects first number's type. {{mult 3.14 2}} returns 6.28

div x y z ...

Division, like add or mult, detects number's type first. {{div 11 3}} returns 3 whereas {{div 11.1 3}} returns 3.6999999999999997

fdiv x y z ...

Meant specifically for floating point numbers division.

log x base

Log is a logarithm function using (log base of x). Arguments can be any type of numbers, as long as they follow logarithm logic. Return value is of type float64. If base argument is not given It is using natural logarithm (base e - The Euler's constant) as default, also is the default to change the base.{{ log "123" 2 }} will return 6.94251450533924.

mod x y

Mod returns the floating-point remainder of x/y. mod 17 3 returns 2 of type float64.

pow x y

Pow returns x**y, the base-x exponential of y which have to be both numbers. Type is returned as float64. {{ pow 2 3 }} returns 8.

randInt (stop, or start stop)

Returns a random integer between 0 and stop, or start - stop if two args are provided.

Result will be start <= random number < stop. Example in section's Snippets.

round

Returns the nearest integer, rounding half away from zero. Regular rounding > 10.4 is 10 and 10.5 is 11. All round functions return type float64, so use conversion functions to get integers. For more complex rounding, example in section's Snippets.

roundCeil

Returns the least integer value greater than or equal to input or rounds up. {{roundCeil 1.1}} returns 2.

roundFloor

Returns the greatest integer value less than or equal to input or rounds down. {{roundFloor 1.9}} returns 1.

roundEven

Returns the nearest integer, rounding ties to even. {{roundEven 10.5}} returns 10 {{roundEven 11.5}} returns 12.

sqrt

Returns the square root of a number as type float64. {{sqrt 49}} returns 7, {{sqrt 12.34 | printf "%.4f"}} returns 3.5128

Function

Description

addMessageReactions channel messageID reactions

Same as addReactions or addResponseReactions, but can be used on any messages using its ID. channel can be either nil, channel's ID or its name. Example in section's Snippets.

addReactions "👍" "👎" ...

Adds each emoji as a reaction to the message that triggered the command (recognizes Unicode emojis and emojiName:emojiID).

addResponseReactions "👍" "👎" ...

Adds each emoji as a reaction to the response message (recognizes Unicode emojis and emojiName:emojiID).

complexMessage "content" args "embed" args "file" args

complexMessage creates a so-called bundle of different message fields for sendMessage... functions to send them out all together. Its arguments need to be preceded by predefined keys "content" for regular text, "embed" for embed arguments created by cembed or sdict, "file" for printing out content as a file (max 100 000 characters ca100kB). Example in this section's Snippets.

complexMessageEdit "content" args "embed" args

Special case for editMessage function - either if complexMessage is involved or works even with regular message. Has two parameters "content" and "embed" to edit regular text part or embed part. If "embed" is set to nil, it deletes whole embed. Example in this section's Snippets.

deleteAllMessageReactions channel messageID

Deletes all reactions pointed message has. channel can be ID, "name" or nil.

deleteMessageReaction channel messageID userID emojis

Deletes reaction(s) from a message. channel can be ID, "name" or nil. emojis argument can be up to 10 emojis, syntax is emojiName for Unicode/Discord's default emojis and emojiName:emojiID for custom emotes. Example: {{deleteMessageReaction nil (index .Args 1) .User.ID "👍" "👎"}} will delete current user's reactions with thumbsUp/Down emotes from current running channel's message which ID is given to command as first argument (index .Args 1). Also usable with Reaction trigger.

deleteMessage channel messageID (delay)

Deletes message with given messageID from channel. Channel can be either nil, channel's ID or its name. (delay) is optional and like following two delete functions, it defaults to 10 seconds, max being 1 day or 86400 seconds. Example in section's Snippets.

deleteResponse (delay)

Deletes the response after a certain time from optional delay argument (max 86400 seconds = 1 day). Defaults to 10 seconds.

deleteTrigger (delay)

Deletes the trigger after a certain time from optional delay argument (max 86400 seconds = 1 day). Defaults to 10 seconds.

editMessage channel messageID newMessageContent

Edits the message in channel, channel can be either nil, channel's ID or "name". Light example in section's Snippets.

editMessageNoEscape channel messageID newMessageContent

Edits the message in channel and has same logic in escaping characters as sendMessageNoEscape.

getMessage channelID messageID

Returns a Message object.

sendDM "message here"

Sends the user a direct message, only one DM can be sent per custom command (accepts embed objects). YAG will only DM triggering user.

sendMessage channel message

Sends message (string or embed) in channel, channel can be either nil, the channel ID or the channel's "name".

sendMessageNoEscape channel message

Sends message (string or embed) in channel, channel can be either nil, the channel ID or the channel "name". Doesn't escape mentions (e.g. role mentions or @here/@everyone).

sendMessageRetID channel message

Same as sendMessage, but also returns messageID to assigned variable for later use. Example in section's Snippets.

sendMessageNoEscapeRetID channel message

Same as sendMessageNoEscape, but also returns messageID to assigned variable for later use.

Function

Description

mentionEveryone

Mentions @everyone.

mentionHere

Mentions @here.

mentionRoleName "rolename"

Mentions the first role found with the provided name (case-insensitive).

mentionRoleID roleID

Mentions the role found with the provided ID.

Function

Description

addRoleID roleID

Adds the role with the given ID to the user that triggered the command (use the listroles command for a list of roles).

addRoleName roleName

Adds the role with given name to the user that triggered the command (use the listroles command for a list of roles).

giveRoleID userID roleID

Gives a role by ID to the target.

giveRoleName userID "roleName"

Gives a role by name to the target.

hasRoleID roleID

Returns true if the user has the role with the specified ID (use the listroles command for a list of roles).

hasRoleName "rolename"

Returns true if the user has the role with the specified name (case-insensitive).

removeRoleID roleID (delay)

Removes the role with the given ID from the user that triggered the command (use the listroles command for a list of roles). Delay is optional argument in seconds.

removeRoleName roleName (delay)

Removes the role with given name from the user that triggered the command (use the listroles command for a list of roles). Delay is optional argument in seconds.

takeRoleID userID roleID (delay)

Takes away a role by ID from the target. Delay is optional argument in seconds.

takeRoleName userID "roleName" (delay)

Takes away a role by name from the target. Delay is optional argument in seconds.

targetHasRoleID userID roleID

Returns true if the given user has the role with the specified ID (use the listroles command for a list of roles). Example in section's Snippets.

targetHasRoleName userID "roleName"

Returns true if the given user has the role with the specified name (case-insensitive).

Function

Description

currentUserCreated

Returns value of type time.Time and shows when the current user was created.

currentUserAgeHuman

The account age of the current user in more human readable format (Eg:3 days 2 hours).

currentUserAgeMinutes

The account age of the current user in minutes.

Function

Description

adjective

Returns a random adjective.

cembed "list of embed values"

Function to generate embed inside custom command. More in-depth here.

cslice, sdict

These functions are covered in their own section here.

dict key1 value1 key2 value2 ...

Creates an unordered collection of key-value pairs, a dictionary so to say. The number of parameters to form key-value pairs must be even. Example here. Keys and values can be of any type. Key is not restricted to string only as in case with sdict. dict also has helper methods .Del, .Get and .Set and they function the same way as sdict ones discussed here.

exec "command" "args" "args" "args" ...

Executes a YAGPDB command (e.g. roll, kick etc) in a custom command. Exec can be run max 5 times per command. If real command returns an embed - exec will return raw data of type embed, so you can use embed fields for better formatting - e.g. {{$resp := exec "whois"}} {{$resp.Title}} Joined at > {{(index $resp.Fields 4).Value}} will return the title (username#discriminator) and "Joined at" field's value from whois command. NB! This will not work for un/nn commands!

​

exec syntax is exec "command" arguments - this means you format it the same way as you would type the command regularly, just without the prefix, e.g. if you want to clear 2 messages and avoiding the pinned message > {{exec "clear 2 -nopin"}}, where "command" part is whole "clear 2 -nopin". If you change that number inside CC somewhere then you have to use arguments part of exec formatting > {{$x := 2}} {{exec "clear" $x "-nopin"}} Here "clear" is the "command" and it is followed by arguments, one variable $x and one string "-nopin". Last example is the same as {{exec (joinStr " " "clear" $x "-nopin")}}(also notice the space in joinStr separator).

execAdmin "command" "args" "args" "args" ...

Functions same way as exec but effectively runs the command as the bot user (YAGPDB). This has essentially the same effect as if a user with the same permissions and roles as YAGPDB ran the command: for example, if YAGPDB had ban members permission but the user which ran the command did not, {{exec "ban" 12345}} would error due to insufficient permissions but {{execAdmin "ban" 12345}} would succeed.

humanizeThousands arg

This function places comma to separate groups of thousands of a number. arg can be int or string, has to be a whole number, e.g. {{humanizeThousands "1234567890"}} will return 1,234,567,890

in list value

Returns bool true/false whether case-sensitive value is in list/slice. {{ in (cslice "YAGPDB" "is cool") "yagpdb" }} returns false.

len arg

Returns the integer length of its argument. arg can be an array, slice, map, or string.

{{ len (cslice 1 2 3) }}

returns 3.

index arg ...keys

Returns the result of indexing its first argument by the following arguments. Each indexed item must be a map, slice or array.

​

Example: {{index .Args 1}} returns first argument after trigger which is always at position 0.

inFold

Same as in, but is case-insensitive. {{inFold (cslice "YAGPDB" "is cool") "yagpdb"}} returns true.

kindOf value (flag)

This function helps to determine what kind of data type we are dealing with. flag part is a bool and if set as true (false is optional) returns the value where given value points to. Example: {{kindOf cembed false}} {{kindOf cembed true}} will return ptr and struct.

noun

Returns a random noun.

parseArgs required_args error_message ...carg

Checks the arguments for a specific type. Has methods .Get and .IsSet. More in depth here and example in Custom Command Examples.​

carg "type" "name"

Required by parseArgs and it defines the type of argument for parseArgs. More in depth here and an example in Custom Command Examples.​

range slice/array

Iterates (loops) over the given slice or array and sets successive elements as active data (the dot) to be further handled inside the range action. Example usage here. More in-depth here.

sendTemplate channel templateName data

Function sends a formulated template to another channel. Channel is like always either name, number or nil. Also returns messageID.

Example: {{define "logsTemplate"}}This text will output on different channel, you can also use functions like {{currentTime}}. {{.TemplateArgs}} would be additional data sent out. {{end}}

Now we call that "logs" in the same custom command.{{sendTemplate "logs" "logsTemplate" "YAG rules!"}}

sendTemplateDM templateName data

Works the same way as function above. Only channel's name is not in the arguments. YAGPDB will only DM the triggering user.

seq start stop

Creates a new slice of type int, beginning from start number, increasing in sequence and ending at stop (not included). {{seq -4 2}} returns a slice [ -4 -3 -2 -1 0 1 ]. Sequence's max length is 10 000.

shuffle list

Returns a shuffled, randomized version of a list/slice.

sleep seconds

Pauses execution of template's action-structure inside custom command for max 60 seconds combined. Argumentsecondsis an integer (whole number). Example in Snippets.

Function

Description

execCC ccID channel delay data

Function that executes another custom command specified by ccID,max recursion depth is 2 (using .StackDepth shows the current depth) and it's rate-limited strictly at max 10 delayed custom commands executed per channel per minute, if you go over that it will be simply thrown away. Argument channel can be nil, channel's ID or name. Thedelay argument is execution delay of another CC is in seconds. The data argument is content that you pass to the other executed custom command. To retrieve that data you use .ExecData. This example is important > execCC example also next snippet which shows you same thing run using the same custom command > Snippets.

scheduleUniqueCC ccID channel delay key data

Same as execCCexcept there can only be 1 scheduled cc execution per server per key, if key already exists then it is overwritten with the new data and delay (as above, in seconds).

An example would be a mute command that schedules the unmute action sometime in the future. However, let's say you use the unmute command again on the same user, you would want to override the last scheduled unmute to the new one. This can be used for that.

cancelScheduledUniqueCC ccID key

Cancels a previously scheduled custom command execution using scheduleUniqueCC

Function

Description

dbSet userID key value

Sets the value for the specified key for the specific userID to the specified value. userID can be any number of type int64. Values are stored either as of type float64 (for numbers, oct or hex) or as varying type in bytes (for slices, maps, strings etc) depending on input argument.

dbSetExpire userID key value ttl

Same as dbSet but with an expiration in seconds.

dbIncr userID key incrBy

Increments the value for specified key for the specified user, if there was no value then it will be set to incrBy . Also returns the entry's current, increased value.

dbGet userID key

Retrieves a value from the database for the specified user, this returns DBEntry object.

dbGetPattern userID pattern amount nSkip

Retrieves up toamount (max 100)entries from the database in ascending order.

dbGetPatternReverse userID pattern amount nSkip

Retrievesamount (max 100)entries from the database in descending order.

dbDel userID key

Deletes the specified key for the specified value from the database.

dbDelByID userID ID

Deletes database entry by its ID.

dbTopEntries pattern amount nSkip

Returns amount (max 100)top entries from the database, sorted by the value in a descending order.

dbBottomEntries pattern amount nSkip

Returns amount (max 100)top entries from the database, sorted by the value in a ascending order.

dbCount (userID|key)

Returns the count of all database entries which are not expired. Optional arguments: if userID is given, counts entries for that userID or if key, then only those keys are counted.

Fields

Description

.ID

ID of the entry.

.GuildID

ID of the server.

.UserID

ID of the user.

.User

​user object.

.CreatedAt

When this entry was created.

.UpdatedAt

When this entry was last updated.

.ExpiresAt

When entry will expire.

.Key

The key of the entry.

.Value

The value of the entry.

Case

Example

if

{{if (condition)}} output {{end}}

Initialization statement can also be inside if statement with conditional statement, limiting the initialized scope to that if statement. {{$x := 24}} {{if eq ($x := 42) 42}} Inside: {{$x}} {{end}} Outside: {{$x}}

else if

{{if (condition)}} output1 {{else if (condition)}} output2 {{end}}

You can have as manyelse ifstatements as many different conditionals you have.

else

{{if (condition)}} output1 {{else}} output2 {{end}}

not

{{if not (condition)}} output {{end}}

and

{{if and (cond1) (cond2) (cond3)}} output {{end}}

or

{{if or (cond1) (cond2) (cond3)}} output {{end}}

Equal: eq

{{if eq .Channel.ID ########}} output {{end}}

Not equal: ne

{{$x := 7}} {{$y := 8}} {{ne $x $y}} returns true

Less than: lt

{{if lt (len .Args) 5}} output {{end}}

Less than or equal: le

{{$x := 7}} {{$y := 8}} {{le $x $y}} returns true

Greater than: gt

{{if gt (len .Args) 1}} output {{end}}

Greater than or equal: ge

{{$x := 7}} {{$y := 8}} {{ge $x $y}} returns false