From 11fd926030c45495be112f396b1800a61a8b4f70 Mon Sep 17 00:00:00 2001
From: Ashish <51633862+ashishjh-bst@users.noreply.github.com>
Date: Fri, 19 Apr 2024 22:55:10 +0530
Subject: [PATCH] Added support for 20k chars long ccs for premium servers
 (#1641)

Co-authored-by: Ashish Jhanwar <ashishjh-bst@users.noreply.github.com>
---
 .../assets/customcommands-editcmd.html        |   6 +-
 .../assets/customcommands-public.html         |   8 +-
 customcommands/assets/customcommands.html     |   7 +
 customcommands/bot.go                         |  17 +--
 customcommands/customcommands.go              | 133 +++++-------------
 customcommands/migration.go                   |  76 ----------
 customcommands/web.go                         |  25 +++-
 premium/plugin_bot.go                         |   2 +-
 premium/premium.go                            |   5 -
 rolecommands/menu.go                          |   2 +-
 web/validation.go                             |   4 +-
 11 files changed, 83 insertions(+), 202 deletions(-)
 delete mode 100644 customcommands/migration.go

diff --git a/customcommands/assets/customcommands-editcmd.html b/customcommands/assets/customcommands-editcmd.html
index b43982640e..41b905ce37 100644
--- a/customcommands/assets/customcommands-editcmd.html
+++ b/customcommands/assets/customcommands-editcmd.html
@@ -277,7 +277,7 @@ <h2 class="card-title">
                             <div class="col-lg-12">
                                 <div class="form-group">
                                     <label for="responses">Response (<span
-                                            class="cc-length-counter">x</span>/10000)</label>
+                                            class="cc-length-counter">x</span>/{{.MaxCCLength}})</label>
                                     <!-- Use .btn-add for simplicity and let the page loader adjust. -->
                                     {{range .CC.Responses}}
                                     <div id="cc-responses" class="entry input-group  input-group-sm">
@@ -659,8 +659,8 @@ <h2 class="card-title">Custom Command Information</h2>
   
       var display = document.querySelector(".cc-length-counter")
       display.textContent = combinedLength
-  
-      if (combinedLength > 10000) {
+      
+      if (combinedLength > {{.MaxCCLength}}) {
         display.classList.add("text-danger");
       } else {
         display.classList.remove("text-danger");
diff --git a/customcommands/assets/customcommands-public.html b/customcommands/assets/customcommands-public.html
index 9c2e961136..1d251fb0d5 100644
--- a/customcommands/assets/customcommands-public.html
+++ b/customcommands/assets/customcommands-public.html
@@ -220,7 +220,7 @@ <h2 class="card-title">
             <div class="row mb-2">
               <div class="col-lg-12">
                 <div class="form-group">
-                  <label for="responses">Response (<span class="cc-length-counter">x</span>/10000)</label>
+                  <label for="responses">Total Response Length: <span class="cc-length-counter">x</span> <br/><span id="premium-only-import"><span></label>
                   {{range $i, $r := .CC.Responses}}
                   <div id="cc-responses" class="entry input-group  input-group-sm">
                     <textarea id="response-{{$i}}" class="form-control response-text-area tab-textbox cc-editor" id=""
@@ -334,10 +334,10 @@ <h2 class="card-title">WARNING: IMPORTING A CUSTOM COMMAND</h2>
     var display = document.querySelector(".cc-length-counter")
     display.textContent = combinedLength
 
+    var premiumOnlyImport = document.querySelector("#premium-only-import")
     if (combinedLength > 10000) {
-      display.classList.add("text-danger");
-    } else {
-      display.classList.remove("text-danger");
+      premiumOnlyImport.textContent = "This CC can only be imported to Premium servers, as it exceeds Free server limits.";
+      premiumOnlyImport.classList.add("text-danger");
     }
   }
   function isTextTrigger(t) {
diff --git a/customcommands/assets/customcommands.html b/customcommands/assets/customcommands.html
index 5b4578c0d0..ff4ac99b17 100644
--- a/customcommands/assets/customcommands.html
+++ b/customcommands/assets/customcommands.html
@@ -180,6 +180,13 @@ <h2 class="card-title">
 <link rel="stylesheet" href="/static/vendorr/highlightjs/atom-one-dark.css">
 
 <script>
+  $(function () {
+    let search = new URLSearchParams(window.location.search);
+    if (search.has('import_err') && search.get('import_err') == 'true') {
+      alert('Failed to import command, please check the url or the command itself.');
+      window.location.search = '';
+    }
+  })
 
     // Register the custom language
     // its based off markdown with custom stuff in tags
diff --git a/customcommands/bot.go b/customcommands/bot.go
index 4856ce8059..0ea462999d 100644
--- a/customcommands/bot.go
+++ b/customcommands/bot.go
@@ -561,6 +561,10 @@ func (p *Plugin) OnRemovedPremiumGuild(GuildID int64) error {
 		return errors.WrapIf(err, "Failed disabling trigger on edits on premium removal")
 	}
 
+	_, err = models.CustomCommands(qm.Where("guild_id = ? AND length(regexp_replace(array_to_string(responses, ''), E'\\r', '', 'g')) > ?", GuildID, MaxCCResponsesLength)).UpdateAllG(context.Background(), models.M{"disabled": true})
+	if err != nil {
+		return errors.WrapIf(err, "Failed disabling long customs commands on premium removal")
+	}
 	return nil
 }
 
@@ -654,7 +658,7 @@ func HandleMessageUpdate(evt *eventsystem.EventData) {
 	mu := evt.MessageUpdate()
 	cs := evt.CSOrThread()
 
-	if isPremium, _ := premium.IsGuildPremiumCached(mu.GuildID); !isPremium {
+	if isPremium, _ := premium.IsGuildPremium(mu.GuildID); !isPremium {
 		return
 	}
 
@@ -769,7 +773,7 @@ func findMessageTriggerCustomCommands(ctx context.Context, cs *dstate.ChannelSta
 	sortTriggeredCCs(matched)
 
 	limit := CCMessageExecLimitNormal
-	if isPremium, _ := premium.IsGuildPremiumCached(msg.GuildID); isPremium {
+	if isPremium, _ := premium.IsGuildPremium(msg.GuildID); isPremium {
 		limit = CCMessageExecLimitPremium
 	}
 
@@ -827,7 +831,7 @@ func findReactionTriggerCustomCommands(ctx context.Context, cs *dstate.ChannelSt
 	sortTriggeredCCs(filtered)
 
 	limit := CCMessageExecLimitNormal
-	if isPremium, _ := premium.IsGuildPremiumCached(cs.GuildID); isPremium {
+	if isPremium, _ := premium.IsGuildPremium(cs.GuildID); isPremium {
 		limit = CCMessageExecLimitPremium
 	}
 
@@ -1128,13 +1132,6 @@ func updatePostCommandRan(cmd *models.CustomCommand, runErr error) {
 	if err != nil {
 		logger.WithError(err).WithField("guild", cmd.GuildID).Error("failed running post command executed query")
 	}
-
-	// if runErr != nil {
-	// 	err := pubsub.Publish("custom_commands_clear_cache", cmd.GuildID, nil)
-	// 	if err != nil {
-	// 		logger.WithError(err).Error("failed creating cache eviction pubsub event in updatePostCommandRan")
-	// 	}
-	// }
 }
 
 // CheckMatch returns true if the given cmd matches, as well as the arguments
diff --git a/customcommands/customcommands.go b/customcommands/customcommands.go
index f58f2cd6cf..b066a4704d 100644
--- a/customcommands/customcommands.go
+++ b/customcommands/customcommands.go
@@ -7,7 +7,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"math"
-	"sort"
 	"strings"
 	"unicode/utf8"
 
@@ -20,7 +19,6 @@ import (
 	"github.com/botlabs-gg/yagpdb/v2/premium"
 	"github.com/botlabs-gg/yagpdb/v2/web"
 	"github.com/karlseguin/ccache"
-	"github.com/mediocregopher/radix/v3"
 	"github.com/volatiletech/null/v8"
 	"github.com/volatiletech/sqlboiler/v4/queries/qm"
 )
@@ -72,8 +70,8 @@ const (
 	CommandTriggerContains   CommandTriggerType = 2
 	CommandTriggerRegex      CommandTriggerType = 3
 	CommandTriggerExact      CommandTriggerType = 4
-	CommandTriggerReaction   CommandTriggerType = 6
 	CommandTriggerInterval   CommandTriggerType = 5
+	CommandTriggerReaction   CommandTriggerType = 6
 )
 
 var (
@@ -114,15 +112,13 @@ type CustomCommand struct {
 	TriggerType     CommandTriggerType `json:"trigger_type"`
 	TriggerTypeForm string             `json:"-" schema:"type"`
 	Trigger         string             `json:"trigger" schema:"trigger" valid:",0,1000"`
-	// TODO: Retire the legacy Response field.
-	Response      string   `json:"response,omitempty" schema:"response" valid:"template,10000"`
-	Responses     []string `json:"responses" schema:"responses" valid:"template,10000"`
-	CaseSensitive bool     `json:"case_sensitive" schema:"case_sensitive"`
-	ID            int64    `json:"id"`
-	Name          string   `json:"name" schema:"name" valid:",0,100"`
-	IsEnabled     bool     `json:"is_enabled" schema:"is_enabled"`
-	Public        bool     `json:"public" schema:"public"`
-	PublicID      string   `json:"public_id" schema:"public_id"`
+	Responses       []string           `json:"responses" schema:"responses" valid:"template,20000"`
+	CaseSensitive   bool               `json:"case_sensitive" schema:"case_sensitive"`
+	ID              int64              `json:"id"`
+	Name            string             `json:"name" schema:"name" valid:",0,100"`
+	IsEnabled       bool               `json:"is_enabled" schema:"is_enabled"`
+	Public          bool               `json:"public" schema:"public"`
+	PublicID        string             `json:"public_id" schema:"public_id"`
 
 	ContextChannel int64 `schema:"context_channel" valid:"channel,true"`
 
@@ -148,7 +144,22 @@ type CustomCommand struct {
 
 var _ web.CustomValidator = (*CustomCommand)(nil)
 
-func (cc *CustomCommand) Validate(tmpl web.TemplateData) (ok bool) {
+func validateCCResponseLength(responses []string, guild_id int64) bool {
+	combinedSize := 0
+	for _, v := range responses {
+		combinedSize += utf8.RuneCountInString(v)
+	}
+
+	ccMaxLength := MaxCCResponsesLength
+	isGuildPremium, _ := premium.IsGuildPremium(guild_id)
+	if isGuildPremium {
+		ccMaxLength = MaxCCResponsesLengthPremium
+	}
+
+	return combinedSize <= ccMaxLength
+}
+
+func (cc *CustomCommand) Validate(tmpl web.TemplateData, guild_id int64) (ok bool) {
 	if len(cc.Responses) > MaxUserMessages {
 		tmpl.AddAlerts(web.ErrorAlert(fmt.Sprintf("Too many responses, max %d", MaxUserMessages)))
 		return false
@@ -167,13 +178,10 @@ func (cc *CustomCommand) Validate(tmpl web.TemplateData) (ok bool) {
 		return false
 	}
 
-	combinedSize := 0
-	for _, v := range cc.Responses {
-		combinedSize += utf8.RuneCountInString(v)
-	}
+	isValidCCLength := validateCCResponseLength(cc.Responses, guild_id)
 
-	if combinedSize > 10000 {
-		tmpl.AddAlerts(web.ErrorAlert("Max combined command size can be 10k"))
+	if cc.IsEnabled && !isValidCCLength {
+		tmpl.AddAlerts(web.ErrorAlert("Max combined command size can be 10k for free servers, and 20k for premium servers"))
 		return false
 	}
 
@@ -259,22 +267,12 @@ func CmdRunsInChannel(cc *models.CustomCommand, channel int64) bool {
 	// check command specifc restrictions
 	for _, v := range cc.Channels {
 		if v == channel {
-			if cc.ChannelsWhitelistMode {
-				return true
-			}
-
-			// Ignore the channel
-			return false
+			return cc.ChannelsWhitelistMode
 		}
 	}
 
 	// Not found
-	if cc.ChannelsWhitelistMode {
-		return false
-	}
-
-	// Not in ignore list
-	return true
+	return !cc.ChannelsWhitelistMode
 }
 
 func CmdRunsForUser(cc *models.CustomCommand, ms *dstate.MemberState) bool {
@@ -292,74 +290,17 @@ func CmdRunsForUser(cc *models.CustomCommand, ms *dstate.MemberState) bool {
 	// check command specific restrictions
 	if len(cc.Roles) == 0 {
 		// Fast path
-		if cc.RolesWhitelistMode {
-			return false
-		}
-
-		return true
+		return !cc.RolesWhitelistMode
 	}
 
 	for _, v := range cc.Roles {
 		if common.ContainsInt64Slice(ms.Member.Roles, v) {
-			if cc.RolesWhitelistMode {
-				return true
-			}
-
-			return false
+			return cc.RolesWhitelistMode
 		}
 	}
 
 	// Not found
-	if cc.RolesWhitelistMode {
-		return false
-	}
-
-	return true
-}
-
-// Migrate modifies a CustomCommand to remove legacy fields.
-func (cc *CustomCommand) Migrate() *CustomCommand {
-	cc.Responses = filterEmptyResponses(cc.Response, cc.Responses...)
-	cc.Response = ""
-	if len(cc.Responses) > MaxUserMessages {
-		cc.Responses = cc.Responses[:MaxUserMessages]
-	}
-
-	return cc
-}
-
-func LegacyGetCommands(guild int64) ([]*CustomCommand, int64, error) {
-	var hashMap map[string]string
-
-	err := common.RedisPool.Do(radix.Cmd(&hashMap, "HGETALL", KeyCommands(guild)))
-	if err != nil {
-		return nil, 0, err
-	}
-
-	highest := int64(0)
-	result := make([]*CustomCommand, len(hashMap))
-
-	// Decode the commands, and also calculate the highest id
-	i := 0
-	for k, raw := range hashMap {
-		var decoded *CustomCommand
-		err = json.Unmarshal([]byte(raw), &decoded)
-		if err != nil {
-			logger.WithError(err).WithField("guild", guild).WithField("custom_command", k).Error("Failed decoding custom command")
-			result[i] = &CustomCommand{}
-		} else {
-			result[i] = decoded.Migrate()
-			if decoded.ID > highest {
-				highest = decoded.ID
-			}
-		}
-		i++
-	}
-
-	// Sort by id
-	sort.Sort(CustomCommandSlice(result))
-
-	return result, highest, nil
+	return !cc.RolesWhitelistMode
 }
 
 type CustomCommandSlice []*CustomCommand
@@ -398,10 +339,12 @@ func filterEmptyResponses(s string, ss ...string) []string {
 }
 
 const (
-	MaxCommands        = 100
-	MaxCommandsPremium = 250
-	MaxUserMessages    = 20
-	MaxGroups          = 50
+	MaxCommands                 = 100
+	MaxCommandsPremium          = 250
+	MaxCCResponsesLength        = 10000
+	MaxCCResponsesLengthPremium = 20000
+	MaxUserMessages             = 20
+	MaxGroups                   = 50
 )
 
 func MaxCommandsForContext(ctx context.Context) int {
diff --git a/customcommands/migration.go b/customcommands/migration.go
deleted file mode 100644
index 1635a46c71..0000000000
--- a/customcommands/migration.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package customcommands
-
-import (
-	"context"
-	"strconv"
-	"strings"
-
-	"github.com/botlabs-gg/yagpdb/v2/common"
-	"github.com/mediocregopher/radix/v3"
-	"github.com/volatiletech/sqlboiler/v4/boil"
-)
-
-// contains stuff for migrating from redis to postgres based configs
-
-func migrateFromRedis() {
-	common.RedisPool.Do(radix.WithConn("custom_commands:", func(conn radix.Conn) error {
-		scanner := radix.NewScanner(conn, radix.ScanOpts{
-			Command: "scan",
-			Pattern: "custom_commands:*",
-		})
-
-		// san over all the keys
-		var key string
-		for scanner.Next(&key) {
-			// retrieve the guild id from the key
-			split := strings.SplitN(key, ":", 2)
-			guildID, err := strconv.ParseInt(split[1], 10, 64)
-			if err != nil {
-				logger.WithError(err).WithField("str", key).Error("custom commands: failed migrating from redis, key is invalid")
-				continue
-			}
-
-			// perform the migration
-			err = migrateGuildConfig(conn, guildID)
-			if err != nil {
-				logger.WithError(err).WithField("str", key).Error("custom commands: failed migrating from redis")
-				continue
-			}
-		}
-
-		if err := scanner.Close(); err != nil {
-			logger.WithError(err).Error("failed scanning keys while migrating custom commands")
-			return err
-		}
-
-		return nil
-	}))
-}
-
-func migrateGuildConfig(rc radix.Client, guildID int64) error {
-	commands, _, err := LegacyGetCommands(guildID)
-	if err != nil || len(commands) < 1 {
-		return err
-	}
-
-	for _, cmd := range commands {
-		localID, err := common.GenLocalIncrID(guildID, "custom_command")
-		if err != nil {
-			return err
-		}
-
-		pqCommand := cmd.ToDBModel()
-		pqCommand.GuildID = guildID
-		pqCommand.LocalID = localID
-
-		err = pqCommand.InsertG(context.Background(), boil.Infer())
-		if err != nil {
-			return err
-		}
-
-	}
-
-	err = rc.Do(radix.Cmd(nil, "DEL", KeyCommands(guildID)))
-	logger.Println("migrated ", len(commands), " custom commands from ", guildID)
-	return err
-}
diff --git a/customcommands/web.go b/customcommands/web.go
index e1cfd15027..31b92a3e96 100644
--- a/customcommands/web.go
+++ b/customcommands/web.go
@@ -273,9 +273,14 @@ func handleGetCommand(w http.ResponseWriter, r *http.Request) (web.TemplateData,
 	if err != nil {
 		return templateData, errors.WithStackIf(err)
 	}
+	allowedCCLength := MaxCCResponsesLength
+	if premium.ContextPremium(r.Context()) {
+		allowedCCLength = MaxCCResponsesLengthPremium
+	}
 	templateData["CC"] = cc
 	templateData["Commands"] = true
 	templateData["IsGuildPremium"] = premium.ContextPremium(r.Context())
+	templateData["MaxCCLength"] = allowedCCLength
 	templateData["PublicLink"] = getPublicLink(cc)
 
 	return serveGroupSelected(r, templateData, cc.GroupID.Int64, cc.GuildID)
@@ -294,9 +299,9 @@ func handleGetPublicCommand(w http.ResponseWriter, r *http.Request) (web.Templat
 		templateData.AddAlerts(web.ErrorAlert("Command couldn't be found via shortlink"))
 		return templateData, errors.WithStackIf(err)
 	}
+
 	templateData["CC"] = cc
 	templateData["Commands"] = true
-	templateData["PublicID"] = cc.PublicID
 	templateData["PublicLink"] = getPublicLink(cc)
 
 	return serveGroupSelected(r, templateData, cc.GroupID.Int64, cc.GuildID)
@@ -387,7 +392,7 @@ func handleNewCommand(w http.ResponseWriter, r *http.Request) (web.TemplateData,
 	}
 
 	if int(c) >= MaxCommandsForContext(ctx) {
-		return templateData, web.NewPublicError(fmt.Sprintf("Max %d custom commands allowed (or %d for premium servers)", MaxCommands, MaxCommandsPremium))
+		return templateData.AddAlerts(web.ErrorAlert(fmt.Sprintf("Max %d custom commands allowed (or %d for premium servers)", MaxCommands, MaxCommandsPremium))), nil
 	}
 
 	localID, err := common.GenLocalIncrID(activeGuild.ID, "custom_command")
@@ -420,8 +425,13 @@ func handleNewCommand(w http.ResponseWriter, r *http.Request) (web.TemplateData,
 		importCC, err = models.CustomCommands(
 			models.CustomCommandWhere.PublicID.EQ(importID)).OneG(r.Context())
 		if err != nil {
-			http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
-			return templateData, err
+			http.Redirect(w, r, fmt.Sprintf("/manage/%d/customcommands?import_failed=true", activeGuild.ID), http.StatusSeeOther)
+			return templateData, nil
+		}
+		isValidCCLength := validateCCResponseLength(importCC.Responses, activeGuild.ID)
+		if !isValidCCLength {
+			http.Redirect(w, r, fmt.Sprintf("/manage/%d/customcommands?import_failed=true", activeGuild.ID), http.StatusSeeOther)
+			return templateData, nil
 		}
 		dbModel.Name = importCC.Name
 		dbModel.ReactionTriggerMode = importCC.ReactionTriggerMode
@@ -464,6 +474,11 @@ func handleUpdateCommand(w http.ResponseWriter, r *http.Request) (web.TemplateDa
 	activeGuild, templateData := web.GetBaseCPContextData(ctx)
 
 	cmdEdit := ctx.Value(common.ContextKeyParsedForm).(*CustomCommand)
+	isCmdValid := cmdEdit.Validate(templateData, activeGuild.ID)
+	if !isCmdValid {
+		return templateData, nil
+	}
+
 	cmdSaved, err := models.FindCustomCommandG(context.Background(), activeGuild.ID, int64(cmdEdit.ID))
 	if err != nil {
 		logrus.WithError(err).WithFields(logrus.Fields{
@@ -472,6 +487,7 @@ func handleUpdateCommand(w http.ResponseWriter, r *http.Request) (web.TemplateDa
 		}).Error("Error in fetching command")
 		return templateData, err
 	}
+
 	if cmdSaved.Disabled && !cmdEdit.ToDBModel().Disabled {
 		c, err := models.CustomCommands(qm.Where("guild_id = ? and disabled = false", activeGuild.ID)).CountG(ctx)
 		if err != nil {
@@ -862,7 +878,6 @@ func PublicCommandMW(inner http.Handler) http.Handler {
 
 		if cc.Public {
 			templateData["PublicAccess"] = true
-
 			if _, ok := ctx.Value(common.ContextKeyUser).(*discordgo.User); ok {
 				guilds, _ := web.GetUserAccessibleGuilds(r.Context(), true)
 				templateData["UserGuilds"] = guilds
diff --git a/premium/plugin_bot.go b/premium/plugin_bot.go
index 84fba18c3d..ed629c6b2a 100644
--- a/premium/plugin_bot.go
+++ b/premium/plugin_bot.go
@@ -13,7 +13,7 @@ var _ commands.CommandProvider = (*Plugin)(nil)
 func init() {
 	oldF := bot.StateLimitsF
 	bot.StateLimitsF = func(guildID int64) (int, time.Duration) {
-		premium, err := IsGuildPremiumCached(guildID)
+		premium, err := IsGuildPremium(guildID)
 		if err != nil {
 			logger.WithError(err).WithField("guild", guildID).Error("Failed checking if guild is premium")
 			return oldF(guildID)
diff --git a/premium/premium.go b/premium/premium.go
index 7b5488bde2..46107f2121 100644
--- a/premium/premium.go
+++ b/premium/premium.go
@@ -139,11 +139,6 @@ func IsGuildPremium(guildID int64) (bool, error) {
 	return featureflags.GuildHasFlag(guildID, FeatureFlagPremiumPlus)
 }
 
-// This function is deprecated and is exactly the same as calling IsguildPremium
-func IsGuildPremiumCached(guildID int64) (bool, error) {
-	return IsGuildPremium(guildID)
-}
-
 func PremiumProvidedBy(guildID int64) (int64, error) {
 	if confAllGuildsPremium.GetBool() {
 		return int64(common.BotUser.ID), nil
diff --git a/rolecommands/menu.go b/rolecommands/menu.go
index 6a7e110b5d..176a748a7f 100644
--- a/rolecommands/menu.go
+++ b/rolecommands/menu.go
@@ -626,7 +626,7 @@ func removeOtherReactions(rm *models.RoleMenu, option *models.RoleMenuOption, us
 		return
 	}
 
-	isPremium, err := premium.IsGuildPremiumCached(rm.GuildID)
+	isPremium, err := premium.IsGuildPremium(rm.GuildID)
 	if err != nil {
 		logger.WithError(err).WithField("guild", rm.GuildID).Error("Failed checking if guild is premium")
 		return
diff --git a/web/validation.go b/web/validation.go
index 6c725542e5..832243bb95 100644
--- a/web/validation.go
+++ b/web/validation.go
@@ -43,7 +43,7 @@ import (
 )
 
 type CustomValidator interface {
-	Validate(tmplData TemplateData) (ok bool)
+	Validate(tmplData TemplateData, guild int64) (ok bool)
 }
 
 type ValidationTag struct {
@@ -210,7 +210,7 @@ func ValidateForm(guild *dstate.GuildSet, tmpl TemplateData, form interface{}) b
 	}
 
 	if validator, okc := form.(CustomValidator); okc {
-		ok2 := validator.Validate(tmpl)
+		ok2 := validator.Validate(tmpl, guild.ID)
 		if !ok2 {
 			ok = false
 		}