diff --git a/discord/command.go b/discord/command.go
index 7ff0f14..426b4a9 100644
--- a/discord/command.go
+++ b/discord/command.go
@@ -13,8 +13,8 @@ func (cmd Command) String() string {
 	return string(cmd)
 }
 
-func (cmd Command) WithPrefix(prefix string) Command {
-	return Command(prefix + cmd.String())
+func (cmd Command) WithPrefix(prefix string) string {
+	return prefix + cmd.String()
 }
 
 type commandCtx struct {
@@ -22,25 +22,19 @@ type commandCtx struct {
 	localizer *i18n.Localizer
 }
 
-type commandHandler struct {
-	cmd                   Command
-	requireAdmPermissions bool
-	fn                    func(ctx *commandCtx, m *discordgo.MessageCreate, args ...string)
+type commandHandler interface {
+	cmd() Command
+	requireAdmPermissions() bool
+	execute(ctx *commandCtx, m *discordgo.MessageCreate, args ...string)
 }
 
-type commandHandlers []*commandHandler
+type commandHandlers []commandHandler
 
-func (hs commandHandlers) find(cmd Command) *commandHandler {
+func (hs commandHandlers) find(prefix, cmd string) commandHandler {
 	for _, h := range hs {
-		if h.cmd == cmd {
+		if h.cmd().WithPrefix(prefix) == cmd {
 			return h
 		}
 	}
 	return nil
 }
-
-type commandHandlerInterface interface {
-	cmd() Command
-	requireAdmPermissions() bool
-	execute(ctx *commandCtx, m *discordgo.MessageCreate, args ...string)
-}
diff --git a/discord/coords_translation.go b/discord/coords_translation.go
index 9d2a1e3..0826145 100644
--- a/discord/coords_translation.go
+++ b/discord/coords_translation.go
@@ -26,7 +26,7 @@ type commandCoordsTranslation struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandCoordsTranslation{}
+var _ commandHandler = &commandCoordsTranslation{}
 
 func (c *commandCoordsTranslation) cmd() Command {
 	return CoordsTranslationCommand
@@ -78,54 +78,11 @@ func (c *commandCoordsTranslation) execute(ctx *commandCtx, m *discordgo.Message
 		}))
 }
 
-func (s *Session) handleCoordsTranslationCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpCoordsTranslation,
-				DefaultMessage: message.FallbackMsg(message.HelpCoordsTranslation,
-					"**{{.Command}}** [server] - enables coords translation feature."),
-				TemplateData: map[string]interface{}{
-					"Command": CoordsTranslationCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	serverKey := args[0]
-	server, err := s.cfg.API.Server.Read(serverKey, nil)
-	if err != nil || server == nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.CoordsTranslationServerNotFound,
-				DefaultMessage: message.FallbackMsg(message.CoordsTranslationServerNotFound, "{{.Mention}} Server not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	ctx.server.CoordsTranslation = serverKey
-	go s.cfg.ServerRepository.Update(context.Background(), ctx.server)
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.CoordsTranslationSuccess,
-			DefaultMessage: message.FallbackMsg(message.CoordsTranslationSuccess,
-				"{{.Mention}} Coords translation feature has been enabled."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandDisableCoordsTranslation struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandDisableCoordsTranslation{}
+var _ commandHandler = &commandDisableCoordsTranslation{}
 
 func (c *commandDisableCoordsTranslation) cmd() Command {
 	return DisableCoordsTranslationCommand
@@ -148,21 +105,6 @@ func (c *commandDisableCoordsTranslation) execute(ctx *commandCtx, m *discordgo.
 		}))
 }
 
-func (s *Session) handleDisableCoordsTranslationCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	ctx.server.CoordsTranslation = ""
-	go s.cfg.ServerRepository.Update(context.Background(), ctx.server)
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.DisableCoordsTranslationSuccess,
-			DefaultMessage: message.FallbackMsg(message.DisableCoordsTranslationSuccess,
-				"{{.Mention}} Coords translation feature has been disabled."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 func (s *Session) translateCoords(ctx *commandCtx, m *discordgo.MessageCreate) {
 	if ctx.server.CoordsTranslation == "" {
 		return
@@ -213,8 +155,6 @@ func (s *Session) translateCoords(ctx *commandCtx, m *discordgo.MessageCreate) {
 
 			msg.Append(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 				MessageID: message.CoordsTranslationMessage,
-				DefaultMessage: message.FallbackMsg(message.CoordsTranslationMessage,
-					"{{.Village}} owned by {{.Player}} (Tribe: {{.Tribe}})."),
 				TemplateData: map[string]interface{}{
 					"Village": BuildLink(village.FullName(), villageURL),
 					"Player":  BuildLink(playerName, playerURL),
@@ -225,8 +165,7 @@ func (s *Session) translateCoords(ctx *commandCtx, m *discordgo.MessageCreate) {
 
 		s.SendEmbed(m.ChannelID, NewEmbed().
 			SetTitle(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.CoordsTranslationTitle,
-				DefaultMessage: message.FallbackMsg(message.CoordsTranslationTitle, "Villages"),
+				MessageID: message.CoordsTranslationTitle,
 			})).
 			SetFields(msg.ToMessageEmbedFields()))
 	}
diff --git a/discord/discord.go b/discord/discord.go
index c26a54c..007b523 100644
--- a/discord/discord.go
+++ b/discord/discord.go
@@ -54,93 +54,24 @@ func New(cfg SessionConfig) (*Session, error) {
 
 func (s *Session) init() error {
 	s.handlers = commandHandlers{
-		&commandHandler{
-			cmd: HelpCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:  s.handleHelpCommand,
-		},
-		&commandHandler{
-			cmd: AuthorCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:  s.handleAuthorCommand,
-		},
-		&commandHandler{
-			cmd: TribeCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:  s.handleTribeCommand,
-		},
-		&commandHandler{
-			cmd:                   ChangeLanguageCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleChangeLanguageCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   AddGroupCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleAddGroupCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   DeleteGroupCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleDeleteGroupCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleGroupsCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   ObserveCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleObserveCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   DeleteObservationCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleDeleteObservationCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   ObservationsCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleObservationsCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   ConqueredVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleConqueredVillagesCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   DisableConqueredVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleDisableConqueredVillagesCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   LostVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleLostVillagesCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   DisableLostVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleDisableLostVillagesCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   ShowEnnobledBarbariansCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleShowEnnobledBarbariansCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   ShowInternalsCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleShowInternalsCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   CoordsTranslationCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleCoordsTranslationCommand,
-			requireAdmPermissions: true,
-		},
-		&commandHandler{
-			cmd:                   DisableCoordsTranslationCommand.WithPrefix(s.cfg.CommandPrefix),
-			fn:                    s.handleDisableCoordsTranslationCommand,
-			requireAdmPermissions: true,
-		},
+		&commandHelp{s},
+		&commandAuthor{s},
+		&commandTribe{s},
+		&commandChangeLanguage{s},
+		&commandAddGroup{s},
+		&commandDeleteGroup{s},
+		&commandGroups{s},
+		&commandObserve{s},
+		&commandDeleteObservation{s},
+		&commandObservations{s},
+		&commandConqueredVillages{s},
+		&commandDisableConqueredVillages{s},
+		&commandLostVillages{s},
+		&commandDisableLostVillages{s},
+		&commandShowEnnobledBarbarians{s},
+		&commandShowInternals{s},
+		&commandCoordsTranslation{s},
+		&commandDisableCoordsTranslation{s},
 	}
 
 	s.dg.AddHandler(s.handleNewMessage)
@@ -222,10 +153,9 @@ func (s *Session) handleNewMessage(_ *discordgo.Session, m *discordgo.MessageCre
 		localizer: message.NewLocalizer(svr.Lang),
 	}
 
-	cmd := Command(parts[0])
-	h := s.handlers.find(cmd)
+	h := s.handlers.find(s.cfg.CommandPrefix, parts[0])
 	if h != nil {
-		if h.requireAdmPermissions {
+		if h.requireAdmPermissions() {
 			if m.GuildID == "" {
 				return
 			}
@@ -238,13 +168,13 @@ func (s *Session) handleNewMessage(_ *discordgo.Session, m *discordgo.MessageCre
 			WithFields(logrus.Fields{
 				"serverID":       svr.ID,
 				"lang":           svr.Lang,
-				"command":        cmd,
+				"command":        parts[0],
 				"args":           args,
 				"authorID":       m.Author.ID,
 				"authorUsername": m.Author.Username,
 			}).
-			Info("handleNewMessage: Executing command...")
-		h.fn(ctx, m, args...)
+			Infof("handleNewMessage: Executing command %s...", parts[0])
+		h.execute(ctx, m, args...)
 		return
 	}
 
diff --git a/discord/observations.go b/discord/observations.go
index 840029e..dce1a8a 100644
--- a/discord/observations.go
+++ b/discord/observations.go
@@ -43,7 +43,7 @@ type commandAddGroup struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandAddGroup{}
+var _ commandHandler = &commandAddGroup{}
 
 func (c *commandAddGroup) cmd() Command {
 	return AddGroupCommand
@@ -93,57 +93,11 @@ func (c *commandAddGroup) execute(ctx *commandCtx, m *discordgo.MessageCreate, a
 		}))
 }
 
-func (s *Session) handleAddGroupCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	if len(ctx.server.Groups) >= groupsPerServer {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.AddGroupLimitHasBeenReached,
-				DefaultMessage: message.FallbackMsg(message.AddGroupLimitHasBeenReached,
-					"{{.Mention}} The group limit has been reached ({{.Total}}/{{.Limit}})."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-					"Total":   len(ctx.server.Groups),
-					"Limit":   groupsPerServer,
-				},
-			}))
-		return
-	}
-
-	group := &model.Group{
-		ServerID:               m.GuildID,
-		ShowEnnobledBarbarians: true,
-	}
-
-	if err := s.cfg.GroupRepository.Store(context.Background(), group); err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.InternalServerError,
-				DefaultMessage: message.FallbackMsg(message.InternalServerError,
-					"{{.Mention}} An internal server error has occurred, please try again later."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.AddGroupSuccess,
-			DefaultMessage: message.FallbackMsg(message.AddGroupSuccess,
-				"{{.Mention}} A new group has been created (ID: {{.ID}})."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-				"ID":      group.ID,
-			},
-		}))
-}
-
 type commandDeleteGroup struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandDeleteGroup{}
+var _ commandHandler = &commandDeleteGroup{}
 
 func (c *commandDeleteGroup) cmd() Command {
 	return DeleteGroupCommand
@@ -193,51 +147,11 @@ func (c *commandDeleteGroup) execute(ctx *commandCtx, m *discordgo.MessageCreate
 		}))
 }
 
-func (s *Session) handleDeleteGroupCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpDeleteGroup,
-				TemplateData: map[string]interface{}{
-					"Command":       DeleteGroupCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DeleteGroupInvalidID,
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	go s.cfg.GroupRepository.Delete(context.Background(), &model.GroupFilter{
-		ID:       []int{groupID},
-		ServerID: []string{m.GuildID},
-	})
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.DeleteGroupSuccess,
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandGroups struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandGroups{}
+var _ commandHandler = &commandGroups{}
 
 func (c *commandGroups) cmd() Command {
 	return GroupsCommand
@@ -284,52 +198,11 @@ func (c *commandGroups) execute(ctx *commandCtx, m *discordgo.MessageCreate, arg
 		}), msg))
 }
 
-func (s *Session) handleGroupsCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	groups, _, err := s.cfg.GroupRepository.Fetch(context.Background(), &model.GroupFilter{
-		ServerID: []string{m.GuildID},
-		DefaultFilter: model.DefaultFilter{
-			Order: []string{"id ASC"},
-		},
-	})
-	if err != nil {
-		return
-	}
-
-	msg := ""
-	for i, groups := range groups {
-		msg += fmt.Sprintf("**%d** | %d | %s | %s | %s | %s\n", i+1,
-			groups.ID,
-			boolToEmoji(groups.ConqueredVillagesChannelID != ""),
-			boolToEmoji(groups.LostVillagesChannelID != ""),
-			boolToEmoji(groups.ShowEnnobledBarbarians),
-			boolToEmoji(groups.ShowInternals),
-		)
-	}
-
-	if msg == "" {
-		msg = ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.GroupsNoGroupsAdded,
-			DefaultMessage: message.FallbackMsg(message.GroupsNoGroupsAdded,
-				"No records to display."),
-		})
-	}
-
-	s.SendEmbed(m.ChannelID, NewEmbed().
-		SetTitle(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.GroupsTitle,
-			DefaultMessage: message.FallbackMsg(message.GroupsTitle, "Group list"),
-		})).
-		AddField(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.GroupsFieldTitle,
-			DefaultMessage: message.FallbackMsg(message.GroupsFieldTitle, "Index | ID | Conquer | Loss | Barbarian | Internal"),
-		}), msg))
-}
-
 type commandConqueredVillages struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandConqueredVillages{}
+var _ commandHandler = &commandConqueredVillages{}
 
 func (c *commandConqueredVillages) cmd() Command {
 	return ConqueredVillagesCommand
@@ -391,71 +264,11 @@ func (c *commandConqueredVillages) execute(ctx *commandCtx, m *discordgo.Message
 		}))
 }
 
-func (s *Session) handleConqueredVillagesCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpConqueredVillages,
-				DefaultMessage: message.FallbackMsg(message.HelpConqueredVillages,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] - sets the channel on which notifications about conquered village will be displayed. **IMPORTANT!** Run this command on the channel you want to display these notifications."),
-				TemplateData: map[string]interface{}{
-					"Command":       ConqueredVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ConqueredVillagesInvalidID,
-				DefaultMessage: message.FallbackMsg(message.ConqueredVillagesInvalidID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	groups, _, err := s.cfg.GroupRepository.Fetch(context.Background(), &model.GroupFilter{
-		ID:       []int{groupID},
-		ServerID: []string{m.GuildID},
-	})
-	if err != nil || len(groups) == 0 {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ConqueredVillagesGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.ConqueredVillagesGroupNotFound,
-					"{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	groups[0].ConqueredVillagesChannelID = m.ChannelID
-	go s.cfg.GroupRepository.Update(context.Background(), groups[0])
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.ConqueredVillagesSuccess,
-			DefaultMessage: message.FallbackMsg(message.ConqueredVillagesSuccess,
-				"{{.Mention}} The channel has been successfully set."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandDisableConqueredVillages struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandDisableConqueredVillages{}
+var _ commandHandler = &commandDisableConqueredVillages{}
 
 func (c *commandDisableConqueredVillages) cmd() Command {
 	return DisableConqueredVillagesCommand
@@ -519,73 +332,11 @@ func (c *commandDisableConqueredVillages) execute(ctx *commandCtx, m *discordgo.
 		}))
 }
 
-func (s *Session) handleDisableConqueredVillagesCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpDisableConqueredVillages,
-				DefaultMessage: message.FallbackMsg(message.HelpDisableConqueredVillages,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] - disables notifications about conquered villages."),
-				TemplateData: map[string]interface{}{
-					"Command":       DisableConqueredVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DisableConqueredVillagesInvalidID,
-				DefaultMessage: message.FallbackMsg(message.DisableConqueredVillagesInvalidID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	groups, _, err := s.cfg.GroupRepository.Fetch(context.Background(), &model.GroupFilter{
-		ID:       []int{groupID},
-		ServerID: []string{m.GuildID},
-	})
-	if err != nil || len(groups) == 0 {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DisableConqueredVillagesGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.DisableConqueredVillagesGroupNotFound,
-					"{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	if groups[0].ConqueredVillagesChannelID != "" {
-		groups[0].ConqueredVillagesChannelID = ""
-		go s.cfg.GroupRepository.Update(context.Background(), groups[0])
-	}
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.DisableConqueredVillagesSuccess,
-			DefaultMessage: message.FallbackMsg(message.DisableConqueredVillagesSuccess,
-				"{{.Mention}} Notifications about conquered villages will no longer show up."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandLostVillages struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandLostVillages{}
+var _ commandHandler = &commandLostVillages{}
 
 func (c *commandLostVillages) cmd() Command {
 	return LostVillagesCommand
@@ -648,72 +399,11 @@ func (c *commandLostVillages) execute(ctx *commandCtx, m *discordgo.MessageCreat
 		}))
 }
 
-func (s *Session) handleLostVillagesCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpLostVillages,
-				DefaultMessage: message.FallbackMsg(message.HelpLostVillages,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] sets the channel on which notifications about lost village will be displayed. **IMPORTANT!** Run this command on the channel you want to display these notifications."),
-				TemplateData: map[string]interface{}{
-					"Command":       LostVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.LostVillagesInvalidID,
-				DefaultMessage: message.FallbackMsg(message.LostVillagesInvalidID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	groups, _, err := s.cfg.GroupRepository.Fetch(context.Background(), &model.GroupFilter{
-		ID:       []int{groupID},
-		ServerID: []string{m.GuildID},
-	})
-	if err != nil || len(groups) == 0 {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.LostVillagesGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.LostVillagesGroupNotFound,
-					"{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	groups[0].LostVillagesChannelID = m.ChannelID
-	go s.cfg.GroupRepository.Update(context.Background(), groups[0])
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.LostVillagesSuccess,
-			DefaultMessage: message.FallbackMsg(message.LostVillagesSuccess,
-				"{{.Mention}} The channel has been successfully set."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandDisableLostVillages struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandDisableLostVillages{}
+var _ commandHandler = &commandDisableLostVillages{}
 
 func (c *commandDisableLostVillages) cmd() Command {
 	return DisableLostVillagesCommand
@@ -778,74 +468,11 @@ func (c *commandDisableLostVillages) execute(ctx *commandCtx, m *discordgo.Messa
 		}))
 }
 
-func (s *Session) handleDisableLostVillagesCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpDisableLostVillages,
-				DefaultMessage: message.FallbackMsg(message.HelpDisableLostVillages,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] - disables notifications about lost villages."),
-				TemplateData: map[string]interface{}{
-					"Command":       DisableLostVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DisableLostVillagesInvalidID,
-				DefaultMessage: message.FallbackMsg(message.DisableLostVillagesInvalidID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	groups, _, err := s.cfg.GroupRepository.Fetch(context.Background(), &model.GroupFilter{
-		ID:       []int{groupID},
-		ServerID: []string{m.GuildID},
-	})
-	if err != nil || len(groups) == 0 {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DisableLostVillagesGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.DisableLostVillagesGroupNotFound,
-					"{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	if groups[0].LostVillagesChannelID != "" {
-		groups[0].LostVillagesChannelID = ""
-		go s.cfg.GroupRepository.Update(context.Background(), groups[0])
-	}
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.DisableLostVillagesSuccess,
-			DefaultMessage: message.FallbackMsg(message.DisableLostVillagesSuccess,
-				"{{.Mention}} Notifications about lost villages will no longer show up."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandObserve struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandObserve{}
+var _ commandHandler = &commandObserve{}
 
 func (c *commandObserve) cmd() Command {
 	return ObserveCommand
@@ -978,147 +605,11 @@ func (c *commandObserve) execute(ctx *commandCtx, m *discordgo.MessageCreate, ar
 	}))
 }
 
-func (s *Session) handleObserveCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 3 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpObserve,
-				DefaultMessage: message.FallbackMsg(message.HelpObserve,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] [server] [tribe id or tribe tag] - command adds a tribe to the observation group."),
-				TemplateData: map[string]interface{}{
-					"Command":       ObserveCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ObserveInvalidGroupID,
-				DefaultMessage: message.FallbackMsg(message.ObserveInvalidGroupID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	serverKey := args[1]
-	tribeTag := strings.TrimSpace(args[2])
-	tribeID, err := strconv.Atoi(tribeTag)
-	if (err != nil || tribeID <= 0) && tribeTag == "" {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ObserveInvalidTribeID,
-				DefaultMessage: message.FallbackMsg(message.ObserveInvalidTribeID,
-					"{{.Mention}} The third parameter must be a number greater than 0 or a valid string."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	server, err := s.cfg.API.Server.Read(serverKey, nil)
-	if err != nil || server == nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.ObserveServerNotFound,
-				DefaultMessage: message.FallbackMsg(message.ObserveServerNotFound, "{{.Mention}} Server not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	if server.Status == twmodel.ServerStatusClosed {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.ObserveServerIsClosed,
-				DefaultMessage: message.FallbackMsg(message.ObserveServerIsClosed, "{{.Mention}} Server is closed."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	var tribe *twmodel.Tribe
-	if tribeID > 0 {
-		tribe, err = s.cfg.API.Tribe.Read(server.Key, tribeID)
-	} else {
-		list := &sdk.TribeList{}
-		list, err = s.cfg.API.Tribe.Browse(server.Key, 1, 0, []string{}, &twmodel.TribeFilter{
-			Tag: []string{tribeTag},
-		})
-		if list != nil && list.Items != nil && len(list.Items) > 0 {
-			tribe = list.Items[0]
-		}
-	}
-	if err != nil || tribe == nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.ObserveTribeNotFound,
-				DefaultMessage: message.FallbackMsg(message.ObserveTribeNotFound, "{{.Mention}} Tribe not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	group, err := s.cfg.GroupRepository.GetByID(context.Background(), groupID)
-	if err != nil || group.ServerID != m.GuildID {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.ObserveGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.ObserveGroupNotFound, "{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	if len(group.Observations) >= observationsPerGroup {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ObserveLimitHasBeenReached,
-				DefaultMessage: message.FallbackMsg(message.ObserveLimitHasBeenReached,
-					"{{.Mention}} The observation limit for this group has been reached ({{.Total}}/{{.Limit}})."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-					"Total":   len(group.Observations),
-					"Limit":   observationsPerGroup,
-				},
-			}))
-		return
-	}
-
-	go s.cfg.ObservationRepository.Store(context.Background(), &model.Observation{
-		Server:  server.Key,
-		TribeID: tribe.ID,
-		GroupID: groupID,
-	})
-
-	s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-		MessageID:      message.ObserveSuccess,
-		DefaultMessage: message.FallbackMsg(message.ObserveSuccess, "{{.Mention}} The tribe has been added to the group."),
-		TemplateData: map[string]interface{}{
-			"Mention": m.Author.Mention(),
-		},
-	}))
-}
-
 type commandDeleteObservation struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandDeleteObservation{}
+var _ commandHandler = &commandDeleteObservation{}
 
 func (c *commandDeleteObservation) cmd() Command {
 	return DeleteObservationCommand
@@ -1191,82 +682,11 @@ func (c *commandDeleteObservation) execute(ctx *commandCtx, m *discordgo.Message
 	}))
 }
 
-func (s *Session) handleDeleteObservationCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 2 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpDeleteObservation,
-				DefaultMessage: message.FallbackMsg(message.HelpDeleteObservation,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] [id from {{.ObservationsCommand}}] - removes a tribe from the observation group."),
-				TemplateData: map[string]interface{}{
-					"Command":             DeleteObservationCommand.WithPrefix(s.cfg.CommandPrefix),
-					"ObservationsCommand": ObservationsCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand":       GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DeleteObservationInvalidGroupID,
-				DefaultMessage: message.FallbackMsg(message.DeleteObservationInvalidGroupID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	observationID, err := strconv.Atoi(args[1])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.DeleteObservationInvalidTribeID,
-				DefaultMessage: message.FallbackMsg(message.DeleteObservationInvalidTribeID,
-					"{{.Mention}} The tribe ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	group, err := s.cfg.GroupRepository.GetByID(context.Background(), groupID)
-	if err != nil || group.ServerID != m.GuildID {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.DeleteObservationGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.DeleteObservationGroupNotFound, "{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	go s.cfg.ObservationRepository.Delete(context.Background(), &model.ObservationFilter{
-		GroupID: []int{groupID},
-		ID:      []int{observationID},
-	})
-
-	s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-		MessageID:      message.DeleteObservationSuccess,
-		DefaultMessage: message.FallbackMsg(message.DeleteObservationSuccess, "{{.Mention}} The tribe has been removed from the group."),
-		TemplateData: map[string]interface{}{
-			"Mention": m.Author.Mention(),
-		},
-	}))
-}
-
 type commandObservations struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandObservations{}
+var _ commandHandler = &commandObservations{}
 
 func (c *commandObservations) cmd() Command {
 	return ObservationsCommand
@@ -1394,150 +814,15 @@ func (c *commandObservations) execute(ctx *commandCtx, m *discordgo.MessageCreat
 	c.SendEmbed(m.ChannelID, NewEmbed().
 		SetTitle(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 			MessageID: message.ObservationsTitle,
-			DefaultMessage: message.FallbackMsg(message.ObservationsTitle,
-				"Observed tribes\nIndex | ID - Server - Tribe"),
 		})).
 		SetFields(bldr.ToMessageEmbedFields()))
 }
 
-func (s *Session) handleObservationsCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpObservations,
-				DefaultMessage: message.FallbackMsg(message.HelpObservations,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] - shows a list of monitored tribes added to this group."),
-				TemplateData: map[string]interface{}{
-					"Command":       ObservationsCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ObservationsInvalidGroupID,
-				DefaultMessage: message.FallbackMsg(message.ObservationsInvalidGroupID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	group, err := s.cfg.GroupRepository.GetByID(context.Background(), groupID)
-	if err != nil || group.ServerID != m.GuildID {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.ObservationsGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.ObservationsGroupNotFound, "{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	observations, _, err := s.cfg.ObservationRepository.Fetch(context.Background(), &model.ObservationFilter{
-		GroupID: []int{groupID},
-		DefaultFilter: model.DefaultFilter{
-			Order: []string{"id ASC"},
-		},
-	})
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.InternalServerError,
-				DefaultMessage: message.FallbackMsg(message.InternalServerError,
-					"{{.Mention}} An internal server error has occurred, please try again later."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	tribeIDsByServer := make(map[string][]int)
-	var versionCodes []twmodel.VersionCode
-	for _, observation := range observations {
-		tribeIDsByServer[observation.Server] = append(tribeIDsByServer[observation.Server], observation.TribeID)
-		currentCode := twmodel.VersionCodeFromServerKey(observation.Server)
-		unique := true
-		for _, code := range versionCodes {
-			if code == currentCode {
-				unique = false
-				break
-			}
-		}
-		if unique {
-			versionCodes = append(versionCodes, currentCode)
-		}
-	}
-	for server, tribeIDs := range tribeIDsByServer {
-		list, err := s.cfg.API.Tribe.Browse(server, 0, 0, []string{}, &twmodel.TribeFilter{
-			ID: tribeIDs,
-		})
-		if err != nil {
-			s.SendMessage(m.ChannelID,
-				ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-					MessageID: message.InternalServerError,
-					DefaultMessage: message.FallbackMsg(message.InternalServerError,
-						"{{.Mention}} An internal server error has occurred, please try again later."),
-					TemplateData: map[string]interface{}{
-						"Mention": m.Author.Mention(),
-					},
-				}))
-			return
-		}
-		for _, tribe := range list.Items {
-			for _, observation := range observations {
-				if observation.TribeID == tribe.ID && observation.Server == server {
-					observation.Tribe = tribe
-					break
-				}
-			}
-		}
-	}
-	versionList, err := s.cfg.API.Version.Browse(0, 0, []string{}, &twmodel.VersionFilter{
-		Code: versionCodes,
-	})
-
-	msg := &MessageEmbedFieldBuilder{}
-	if len(observations) <= 0 || err != nil || versionList == nil || versionList.Items == nil {
-		msg.Append("-")
-	} else {
-		for i, observation := range observations {
-			tag := "Unknown"
-			if observation.Tribe != nil {
-				tag = observation.Tribe.Tag
-			}
-			version := twutil.FindVersionByCode(versionList.Items, twmodel.VersionCodeFromServerKey(observation.Server))
-			tribeURL := ""
-			if version != nil {
-				tribeURL = twurlbuilder.BuildTribeURL(observation.Server, version.Host, observation.TribeID)
-			}
-			msg.Append(fmt.Sprintf("**%d** | %d - %s - %s\n", i+1, observation.ID,
-				observation.Server,
-				BuildLink(tag, tribeURL)))
-		}
-	}
-	s.SendEmbed(m.ChannelID, NewEmbed().
-		SetTitle(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.ObservationsTitle,
-			DefaultMessage: message.FallbackMsg(message.ObservationsTitle,
-				"Observed tribes\nIndex | ID - Server - Tribe"),
-		})).
-		SetFields(msg.ToMessageEmbedFields()))
-}
-
 type commandShowEnnobledBarbarians struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandShowEnnobledBarbarians{}
+var _ commandHandler = &commandShowEnnobledBarbarians{}
 
 func (c *commandShowEnnobledBarbarians) cmd() Command {
 	return ShowEnnobledBarbariansCommand
@@ -1616,80 +901,11 @@ func (c *commandShowEnnobledBarbarians) execute(ctx *commandCtx, m *discordgo.Me
 		}))
 }
 
-func (s *Session) handleShowEnnobledBarbariansCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpShowEnnobledBarbs,
-				TemplateData: map[string]interface{}{
-					"Command":       ShowEnnobledBarbariansCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil || groupID <= 0 {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ShowEnnobledBarbsInvalidGroupID,
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	group, err := s.cfg.GroupRepository.GetByID(context.Background(), groupID)
-	if err != nil || group.ServerID != m.GuildID {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ShowEnnobledBarbsGroupNotFound,
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	oldValue := group.ShowEnnobledBarbarians
-	group.ShowEnnobledBarbarians = !oldValue
-	if err := s.cfg.GroupRepository.Update(context.Background(), group); err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.InternalServerError,
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	if oldValue {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ShowEnnobledBarbsSuccess1,
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-	} else {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ShowEnnobledBarbsSuccess2,
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-	}
-}
-
 type commandChangeLanguage struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandChangeLanguage{}
+var _ commandHandler = &commandChangeLanguage{}
 
 func (c *commandChangeLanguage) cmd() Command {
 	return ChangeLanguageCommand
@@ -1748,68 +964,11 @@ func (c *commandChangeLanguage) execute(ctx *commandCtx, m *discordgo.MessageCre
 		}))
 }
 
-func (s *Session) handleChangeLanguageCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpChangageLanguage,
-				DefaultMessage: message.FallbackMsg(message.HelpChangageLanguage,
-					"**{{.Command}}** [{{.Languages}}] - changes language."),
-				TemplateData: map[string]interface{}{
-					"Command":   ChangeLanguageCommand.WithPrefix(s.cfg.CommandPrefix),
-					"Languages": getAvailableLanguages(),
-				},
-			}))
-		return
-	}
-
-	lang := args[0]
-	valid := isValidLanguageTag(lang)
-	if !valid {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ChangeLanguageLanguageNotSupported,
-				DefaultMessage: message.FallbackMsg(message.ChangeLanguageLanguageNotSupported,
-					"{{.Mention}} Language not supported."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	ctx.server.Lang = lang
-	if err := s.cfg.ServerRepository.Update(context.Background(), ctx.server); err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.InternalServerError,
-				DefaultMessage: message.FallbackMsg(message.InternalServerError,
-					"{{.Mention}} An internal server error has occurred, please try again later."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	ctx.localizer = message.NewLocalizer(lang)
-
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.ChangeLanguageSuccess,
-			DefaultMessage: message.FallbackMsg(message.ChangeLanguageSuccess,
-				"{{.Mention}} The language has been changed."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
-
 type commandShowInternals struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandShowInternals{}
+var _ commandHandler = &commandShowInternals{}
 
 func (c *commandShowInternals) cmd() Command {
 	return ShowInternalsCommand
@@ -1887,83 +1046,3 @@ func (c *commandShowInternals) execute(ctx *commandCtx, m *discordgo.MessageCrea
 			},
 		}))
 }
-
-func (s *Session) handleShowInternalsCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength != 1 {
-		s.SendMessage(m.ChannelID,
-			m.Author.Mention()+" "+ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.HelpShowInternals,
-				DefaultMessage: message.FallbackMsg(message.HelpShowInternals,
-					"**{{.Command}}** [group id from {{.GroupsCommand}}] - enables/disables notifications about in-group/in-tribe conquering."),
-				TemplateData: map[string]interface{}{
-					"Command":       ShowInternalsCommand.WithPrefix(s.cfg.CommandPrefix),
-					"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-				},
-			}))
-		return
-	}
-
-	groupID, err := strconv.Atoi(args[0])
-	if err != nil || groupID <= 0 {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ShowInternalsInvalidGroupID,
-				DefaultMessage: message.FallbackMsg(message.ShowInternalsInvalidGroupID,
-					"{{.Mention}} The group ID must be a number greater than 0."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	group, err := s.cfg.GroupRepository.GetByID(context.Background(), groupID)
-	if err != nil || group.ServerID != m.GuildID {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID:      message.ShowInternalsGroupNotFound,
-				DefaultMessage: message.FallbackMsg(message.ShowInternalsGroupNotFound, "{{.Mention}} Group not found."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	oldValue := group.ShowInternals
-	group.ShowInternals = !oldValue
-	if err := s.cfg.GroupRepository.Update(context.Background(), group); err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.InternalServerError,
-				DefaultMessage: message.FallbackMsg(message.InternalServerError,
-					"{{.Mention}} An internal server error has occurred, please try again later."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-
-	if oldValue {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ShowInternalsSuccess1,
-				DefaultMessage: message.FallbackMsg(message.ShowInternalsSuccess1,
-					"{{.Mention}} Notifications about internals will no longer show up."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	s.SendMessage(m.ChannelID,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.ShowInternalsSuccess2,
-			DefaultMessage: message.FallbackMsg(message.ShowInternalsSuccess2,
-				"{{.Mention}} Notifications about internals have been enabled."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-}
diff --git a/discord/public_commands.go b/discord/public_commands.go
index cbb9ebe..2a4d321 100644
--- a/discord/public_commands.go
+++ b/discord/public_commands.go
@@ -32,7 +32,7 @@ type commandHelp struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandHelp{}
+var _ commandHandler = &commandHelp{}
 
 func (c *commandHelp) cmd() Command {
 	return HelpCommand
@@ -54,31 +54,31 @@ func (c *commandHelp) execute(ctx *commandCtx, m *discordgo.MessageCreate, args
 		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 			MessageID: message.HelpTribeTopODA,
 			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODACommand,
+				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODACommand.String(),
 			},
 		}),
 		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 			MessageID: message.HelpTribeTopODD,
 			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODDCommand,
+				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODDCommand.String(),
 			},
 		}),
 		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 			MessageID: message.HelpTribeTopODS,
 			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODSCommand,
+				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODSCommand.String(),
 			},
 		}),
 		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 			MessageID: message.HelpTribeTopOD,
 			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODCommand,
+				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopODCommand.String(),
 			},
 		}),
 		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
 			MessageID: message.HelpTribeTopPoints,
 			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopPointsCommand,
+				"Command": TribeCommand.WithPrefix(c.cfg.CommandPrefix) + " " + TopPointsCommand.String(),
 			},
 		}),
 		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
@@ -233,248 +233,11 @@ func (c *commandHelp) execute(ctx *commandCtx, m *discordgo.MessageCreate, args
 		AddField(forAdmins+" 2", commandsForGuildAdmins2))
 }
 
-func (s *Session) handleHelpCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	commandsForAll := fmt.Sprintf(`
-- %s
-- %s
-- %s
-- %s
-- %s
-- %s
-				`,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpTribeTopODA,
-			DefaultMessage: message.FallbackMsg(message.HelpTribeTopODA,
-				"**{{.Command}}** [server] [page] [tribe id or tribe tag, you can enter more than one] - generates a player list from selected tribes ordered by ODA."),
-			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(s.cfg.CommandPrefix) + " " + TopODACommand,
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpTribeTopODD,
-			DefaultMessage: message.FallbackMsg(message.HelpTribeTopODD,
-				"**{{.Command}}** [server] [page] [tribe id or tribe tag, you can enter more than one] - generates a player list from selected tribes ordered by ODD."),
-			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(s.cfg.CommandPrefix) + " " + TopODDCommand,
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpTribeTopODS,
-			DefaultMessage: message.FallbackMsg(message.HelpTribeTopODS,
-				"**{{.Command}}** [server] [page] [tribe id or tribe tag, you can enter more than one] - generates a player list from selected tribes ordered by ODS."),
-			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(s.cfg.CommandPrefix) + " " + TopODSCommand,
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpTribeTopOD,
-			DefaultMessage: message.FallbackMsg(message.HelpTribeTopOD,
-				"**{{.Command}}** [server] [page] [tribe id or tribe tag, you can enter more than one] - generates a player list from selected tribes ordered by OD."),
-			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(s.cfg.CommandPrefix) + " " + TopODCommand,
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpTribeTopPoints,
-			DefaultMessage: message.FallbackMsg(message.HelpTribeTopPoints,
-				"**{{.Command}}** [server] [page] [tribe id or tribe tag, you can enter more than one] - generates a player list from selected tribes ordered by points."),
-			TemplateData: map[string]interface{}{
-				"Command": TribeCommand.WithPrefix(s.cfg.CommandPrefix) + " " + TopPointsCommand,
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpAuthor,
-			DefaultMessage: message.FallbackMsg(message.HelpAuthor,
-				"**{{.Command}}** - shows how to get in touch with the author."),
-			TemplateData: map[string]interface{}{
-				"Command": AuthorCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-	)
-
-	commandsForGuildAdmins := fmt.Sprintf(`
-- %s
-- %s
-- %s
-- %s
-- %s
-- %s
-- %s
-- %s
-- %s
-				`,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpAddGroup,
-			DefaultMessage: message.FallbackMsg(message.HelpAddGroup,
-				"**{{.Command}}** - adds a new observation group."),
-			TemplateData: map[string]interface{}{
-				"Command": AddGroupCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpGroups,
-			DefaultMessage: message.FallbackMsg(message.HelpGroups,
-				"**{{.Command}}** - shows you a list of groups created by this server."),
-			TemplateData: map[string]interface{}{
-				"Command": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpDeleteGroup,
-			DefaultMessage: message.FallbackMsg(message.HelpDeleteGroup,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - deletes an observation group."),
-			TemplateData: map[string]interface{}{
-				"Command":       DeleteGroupCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpShowEnnobledBarbs,
-			DefaultMessage: message.FallbackMsg(message.HelpShowEnnobledBarbs,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - enables/disables notifications about ennobling barbarian villages."),
-			TemplateData: map[string]interface{}{
-				"Command":       ShowEnnobledBarbariansCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpObserve,
-			DefaultMessage: message.FallbackMsg(message.HelpObserve,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] [server] [tribe id or tribe tag] - adds a tribe to the observation group."),
-			TemplateData: map[string]interface{}{
-				"Command":       ObserveCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpGroups,
-			DefaultMessage: message.FallbackMsg(message.HelpGroups,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - shows a list of monitored tribes added to this group."),
-			TemplateData: map[string]interface{}{
-				"Command":       ObservationsCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpDeleteObservation,
-			DefaultMessage: message.FallbackMsg(message.HelpDeleteObservation,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] [id from {{.ObservationsCommand}}] - removes a tribe from the observation group."),
-			TemplateData: map[string]interface{}{
-				"Command":             DeleteObservationCommand.WithPrefix(s.cfg.CommandPrefix),
-				"ObservationsCommand": ObservationsCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand":       GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpConqueredVillages,
-			DefaultMessage: message.FallbackMsg(message.HelpConqueredVillages,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - sets the channel on which notifications about conquered village will be displayed. IMPORTANT! Call this command on the channel you want to display these notifications."),
-			TemplateData: map[string]interface{}{
-				"Command":       ConqueredVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpDisableConqueredVillages,
-			DefaultMessage: message.FallbackMsg(message.HelpDisableConqueredVillages,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - disables notifications about conquered villages."),
-			TemplateData: map[string]interface{}{
-				"Command":       DisableConqueredVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-	)
-
-	commandsForGuildAdmins2 := fmt.Sprintf(`
-- %s
-- %s
-- %s
-- %s
-- %s
-- %s
-				`,
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpLostVillages,
-			DefaultMessage: message.FallbackMsg(message.HelpLostVillages,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - sets the channel on which notifications about lost village will be displayed. IMPORTANT! Call this command on the channel you want to display these notifications."),
-			TemplateData: map[string]interface{}{
-				"Command":       LostVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpDisableLostVillages,
-			DefaultMessage: message.FallbackMsg(message.HelpDisableLostVillages,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - sets the channel on which notifications about lost village will be displayed. IMPORTANT! Call this command on the channel you want to display these notifications."),
-			TemplateData: map[string]interface{}{
-				"Command":       DisableLostVillagesCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpShowInternals,
-			DefaultMessage: message.FallbackMsg(message.HelpShowInternals,
-				"**{{.Command}}** [group id from {{.GroupsCommand}}] - enables/disables notifications about in-group/in-tribe conquering."),
-			TemplateData: map[string]interface{}{
-				"Command":       ShowInternalsCommand.WithPrefix(s.cfg.CommandPrefix),
-				"GroupsCommand": GroupsCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpChangageLanguage,
-			DefaultMessage: message.FallbackMsg(message.HelpChangageLanguage,
-				"**{{.Command}}** [{{.Languages}}] - changes language."),
-			TemplateData: map[string]interface{}{
-				"Command":   ChangeLanguageCommand.WithPrefix(s.cfg.CommandPrefix),
-				"Languages": getAvailableLanguages(),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpCoordsTranslation,
-			DefaultMessage: message.FallbackMsg(message.HelpCoordsTranslation,
-				"**{{.Command}}** [server] - enables coords translation feature."),
-			TemplateData: map[string]interface{}{
-				"Command": CoordsTranslationCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-		ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.HelpDisableCoordsTranslation,
-			DefaultMessage: message.FallbackMsg(message.HelpDisableCoordsTranslation,
-				"**{{.Command}}** - disables coords translation feature."),
-			TemplateData: map[string]interface{}{
-				"Command": DisableCoordsTranslationCommand.WithPrefix(s.cfg.CommandPrefix),
-			},
-		}),
-	)
-
-	forAdmins := ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-		MessageID:      message.HelpForAdmins,
-		DefaultMessage: message.FallbackMsg(message.HelpForAdmins, "For admins"),
-	})
-
-	s.SendEmbed(m.ChannelID, NewEmbed().
-		SetTitle(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.HelpTitle,
-			DefaultMessage: message.FallbackMsg(message.HelpTitle, "Help"),
-		})).
-		SetURL("https://dcbot.tribalwarshelp.com/").
-		SetDescription(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.HelpDescription,
-			DefaultMessage: message.FallbackMsg(message.HelpDescription, "Command list"),
-		})).
-		AddField(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.HelpForAllUsers,
-			DefaultMessage: message.FallbackMsg(message.HelpForAllUsers, "For everyone"),
-		}), commandsForAll).
-		AddField(forAdmins, commandsForGuildAdmins).
-		AddField(forAdmins+" 2", commandsForGuildAdmins2))
-}
-
 type commandAuthor struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandAuthor{}
+var _ commandHandler = &commandAuthor{}
 
 func (c *commandAuthor) cmd() Command {
 	return AuthorCommand
@@ -490,17 +253,11 @@ func (c *commandAuthor) execute(ctx *commandCtx, m *discordgo.MessageCreate, arg
 			m.Author.Mention()))
 }
 
-func (s *Session) handleAuthorCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	s.SendMessage(m.ChannelID,
-		fmt.Sprintf("%s Discord: Kichiyaki#2064 | https://dwysokinski.me/#contact.",
-			m.Author.Mention()))
-}
-
 type commandTribe struct {
 	*Session
 }
 
-var _ commandHandlerInterface = &commandTribe{}
+var _ commandHandler = &commandTribe{}
 
 func (c *commandTribe) cmd() Command {
 	return TribeCommand
@@ -710,221 +467,3 @@ func (c *commandTribe) execute(ctx *commandCtx, m *discordgo.MessageCreate, args
 			},
 		})))
 }
-
-func (s *Session) handleTribeCommand(ctx *commandCtx, m *discordgo.MessageCreate, args ...string) {
-	argsLength := len(args)
-	if argsLength < 3 {
-		return
-	}
-
-	command := Command(args[0])
-	server := args[1]
-	page, err := strconv.Atoi(args[2])
-	if err != nil || page <= 0 {
-		s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeInvalidPage,
-			DefaultMessage: message.FallbackMsg(message.TribeInvalidPage, "{{.Mention}} The page must be a number greater than 0."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-		return
-	}
-	var ids []int
-	var tags []string
-	for _, arg := range args[3:argsLength] {
-		trimmed := strings.TrimSpace(arg)
-		if trimmed == "" {
-			continue
-		}
-		id, err := strconv.Atoi(trimmed)
-		if err != nil || id <= 0 {
-			tags = append(tags, trimmed)
-		} else {
-			ids = append(ids, id)
-		}
-	}
-	if len(ids) == 0 && len(tags) == 0 {
-		s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeNoTribeID,
-			DefaultMessage: message.FallbackMsg(message.TribeNoTribeID, "{{.Mention}} At least one tribe id/tag is required."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-		return
-	}
-
-	exists := true
-	limit := 10
-	offset := (page - 1) * limit
-	filter := &twmodel.PlayerFilter{
-		Exists: &exists,
-		TribeFilter: &twmodel.TribeFilter{
-			Or: &twmodel.TribeFilterOr{
-				ID:  ids,
-				Tag: tags,
-			},
-		},
-	}
-	title := ""
-	sort := ""
-	switch command {
-	case TopODACommand:
-		filter.RankAttGTE = 1
-		sort = "rankAtt ASC"
-		title = ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeTitleOrderedByODA,
-			DefaultMessage: message.FallbackMsg(message.TribeTitleOrderedByODA, "Ordered by ODA"),
-		})
-	case TopODDCommand:
-		filter.RankDefGTE = 1
-		sort = "rankDef ASC"
-		title = ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeTitleOrderedByODD,
-			DefaultMessage: message.FallbackMsg(message.TribeTitleOrderedByODD, "Ordered by ODD"),
-		})
-	case TopODSCommand:
-		filter.RankSupGTE = 1
-		sort = "rankSup ASC"
-		title = ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeTitleOrderedByODS,
-			DefaultMessage: message.FallbackMsg(message.TribeTitleOrderedByODS, "Ordered by ODS"),
-		})
-	case TopODCommand:
-		filter.RankTotalGTE = 1
-		sort = "rankTotal ASC"
-		title = ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeTitleOrderedByOD,
-			DefaultMessage: message.FallbackMsg(message.TribeTitleOrderedByOD, "Ordered by OD"),
-		})
-	case TopPointsCommand:
-		sort = "rank ASC"
-		title = ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeTitleOrderedByPoints,
-			DefaultMessage: message.FallbackMsg(message.TribeTitleOrderedByPoints, "Ordered by points"),
-		})
-	default:
-		return
-	}
-
-	playerList, err := s.cfg.API.Player.Browse(server,
-		limit,
-		offset,
-		[]string{sort},
-		filter,
-		&sdk.PlayerInclude{
-			Tribe: true,
-		})
-	if err != nil {
-		s.SendMessage(m.ChannelID,
-			ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-				MessageID: message.ApiDefaultError,
-				DefaultMessage: message.FallbackMsg(message.ApiDefaultError,
-					"{{.Mention}} Can't fetch data from the API at the moment, please try again later."),
-				TemplateData: map[string]interface{}{
-					"Mention": m.Author.Mention(),
-				},
-			}))
-		return
-	}
-	if playerList == nil || playerList.Total == 0 {
-		s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.TribeTribesNotFound,
-			DefaultMessage: message.FallbackMsg(message.TribeTribesNotFound, "{{.Mention}} Tribes not found."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-		return
-	}
-	totalPages := int(math.Ceil(float64(playerList.Total) / float64(limit)))
-	if page > totalPages {
-		s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.TribeExceededMaximumNumberOfPages,
-			DefaultMessage: message.FallbackMsg(message.TribeExceededMaximumNumberOfPages,
-				"{{.Mention}} You have exceeded the maximum number of pages ({{.Page}}/{{.MaxPage}})."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-				"Page":    page,
-				"MaxPage": totalPages,
-			},
-		}))
-		return
-	}
-
-	code := twmodel.VersionCodeFromServerKey(server)
-	version, err := s.cfg.API.Version.Read(code)
-	if err != nil || version == nil {
-		s.SendMessage(m.ChannelID, ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.InternalServerError,
-			DefaultMessage: message.FallbackMsg(message.InternalServerError,
-				"{{.Mention}} An internal server error has occurred, please try again later."),
-			TemplateData: map[string]interface{}{
-				"Mention": m.Author.Mention(),
-			},
-		}))
-		return
-	}
-
-	msg := &MessageEmbedFieldBuilder{}
-	for i, player := range playerList.Items {
-		if player == nil {
-			continue
-		}
-
-		rank := 0
-		score := 0
-		switch command {
-		case TopODACommand:
-			rank = player.RankAtt
-			score = player.ScoreAtt
-		case TopODDCommand:
-			rank = player.RankDef
-			score = player.ScoreDef
-		case TopODSCommand:
-			rank = player.RankSup
-			score = player.ScoreSup
-		case TopODCommand:
-			rank = player.RankTotal
-			score = player.ScoreTotal
-		case TopPointsCommand:
-			rank = player.Rank
-			score = player.Points
-		}
-
-		tribeTag := "-"
-		tribeURL := "-"
-		if player.Tribe != nil {
-			tribeTag = player.Tribe.Tag
-			tribeURL = twurlbuilder.BuildTribeURL(server, version.Host, player.Tribe.ID)
-		}
-
-		msg.Append(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID: message.TribeMessageLine,
-			DefaultMessage: message.FallbackMsg(message.TribeMessageLine,
-				"**{{.Index}}**. [`{{.PlayerName}}`]({{.PlayerURL}}) (Tribe: [`{{.TribeTag}}`]({{.TribeURL}}) | Rank: **{{.Rank}}** | Score: **{{.Score}}**)\n"),
-			TemplateData: map[string]interface{}{
-				"Index":      offset + i + 1,
-				"PlayerName": player.Name,
-				"PlayerURL":  twurlbuilder.BuildPlayerURL(server, version.Host, player.ID),
-				"TribeTag":   tribeTag,
-				"TribeURL":   tribeURL,
-				"Rank":       rank,
-				"Score":      humanize.Comma(int64(score)),
-			},
-		}))
-	}
-
-	s.SendEmbed(m.ChannelID, NewEmbed().
-		SetTitle(title).
-		SetFields(msg.ToMessageEmbedFields()).
-		SetFooter(ctx.localizer.MustLocalize(&i18n.LocalizeConfig{
-			MessageID:      message.PaginationLabelDisplayedPage,
-			DefaultMessage: message.FallbackMsg(message.PaginationLabelDisplayedPage, "{{.Page}} of {{.MaxPage}}"),
-			TemplateData: map[string]interface{}{
-				"Page":    page,
-				"MaxPage": totalPages,
-			},
-		})))
-}
diff --git a/main.go b/main.go
index 46000ca..0770e0b 100644
--- a/main.go
+++ b/main.go
@@ -31,7 +31,7 @@ const (
 	commandPrefix = "tw!"
 )
 
-var status = "tribalwarshelp.com | " + discord.HelpCommand.WithPrefix(commandPrefix).String()
+var status = "tribalwarshelp.com | " + discord.HelpCommand.WithPrefix(commandPrefix)
 
 func init() {
 	os.Setenv("TZ", "UTC")