143 lines
3.3 KiB
Go
143 lines
3.3 KiB
Go
package commands
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
|
|
"dislate/internals/guilddb"
|
|
gdb "dislate/internals/guilddb"
|
|
"dislate/internals/translator/lang"
|
|
|
|
dgo "github.com/bwmarrin/discordgo"
|
|
)
|
|
|
|
type ManageChannel struct {
|
|
db gdb.GuildDB
|
|
}
|
|
|
|
func NewManageChannel(db gdb.GuildDB) ManageChannel {
|
|
return ManageChannel{db}
|
|
}
|
|
func (c ManageChannel) Info() *dgo.ApplicationCommand {
|
|
var permissions int64 = dgo.PermissionManageChannels
|
|
|
|
return &dgo.ApplicationCommand{
|
|
Name: "channel",
|
|
Description: "Manages a channel options",
|
|
DefaultMemberPermissions: &permissions,
|
|
}
|
|
}
|
|
func (c ManageChannel) Subcommands() []Command {
|
|
return []Command{ChannelsInfo(c)}
|
|
}
|
|
func (c ManageChannel) Handle(s *dgo.Session, i *dgo.InteractionCreate) error {
|
|
return nil
|
|
}
|
|
func (c ManageChannel) Components() []Component {
|
|
return []Component{}
|
|
}
|
|
|
|
type ChannelsInfo struct {
|
|
db gdb.GuildDB
|
|
}
|
|
|
|
func (c ChannelsInfo) Info() *dgo.ApplicationCommand {
|
|
var permissions int64 = dgo.PermissionManageChannels
|
|
|
|
return &dgo.ApplicationCommand{
|
|
Name: "info",
|
|
Description: "Get information about a channel",
|
|
DefaultMemberPermissions: &permissions,
|
|
Options: []*dgo.ApplicationCommandOption{{
|
|
Type: dgo.ApplicationCommandOptionChannel,
|
|
Name: "channel",
|
|
Description: "The channel to manage",
|
|
ChannelTypes: []dgo.ChannelType{
|
|
dgo.ChannelTypeGuildText,
|
|
},
|
|
}},
|
|
}
|
|
}
|
|
func (c ChannelsInfo) Handle(s *dgo.Session, ic *dgo.InteractionCreate) error {
|
|
opts := getOptions(ic)
|
|
|
|
var err error
|
|
|
|
var dch *dgo.Channel
|
|
if c, ok := opts["channel"]; ok {
|
|
dch = c.ChannelValue(s)
|
|
} else {
|
|
dch, err = s.Channel(ic.ChannelID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
ch, err := getChannel(c.db, dch.GuildID, dch.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
info, err := getChannelInfo(c.db, ch)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = s.InteractionRespond(ic.Interaction, &dgo.InteractionResponse{
|
|
Type: dgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &dgo.InteractionResponseData{
|
|
Embeds: []*dgo.MessageEmbed{info},
|
|
Flags: dgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
func (c ChannelsInfo) Components() []Component {
|
|
return []Component{}
|
|
}
|
|
func (c ChannelsInfo) Subcommands() []Command {
|
|
return []Command{}
|
|
}
|
|
|
|
func getChannel(db guilddb.GuildDB, guildID, channelID string) (gdb.Channel, error) {
|
|
ch, err := db.Channel(guildID, channelID)
|
|
if err != nil && errors.Is(err, gdb.ErrNotFound) {
|
|
if err := db.ChannelInsert(gdb.NewChannel(guildID, channelID, lang.EN)); err != nil {
|
|
return gdb.Channel{}, err
|
|
}
|
|
ch, err = db.Channel(guildID, channelID)
|
|
if err != nil {
|
|
return gdb.Channel{}, err
|
|
}
|
|
} else if err != nil {
|
|
return gdb.Channel{}, err
|
|
}
|
|
|
|
return ch, nil
|
|
}
|
|
|
|
func getChannelInfo(db guilddb.GuildDB, ch gdb.Channel) (*dgo.MessageEmbed, error) {
|
|
group, err := db.ChannelGroup(ch.GuildID, ch.ID)
|
|
if err != nil && !errors.Is(err, gdb.ErrNotFound) {
|
|
return nil, err
|
|
}
|
|
|
|
g := make([]string, len(group))
|
|
for i, gi := range group {
|
|
g[i] = "<#" + gi.ID + ">"
|
|
}
|
|
|
|
return &dgo.MessageEmbed{Title: "Channel Information",
|
|
Fields: []*dgo.MessageEmbedField{
|
|
{Name: "ID", Value: ch.ID, Inline: true},
|
|
{Name: "Language", Value: string(ch.Language), Inline: true},
|
|
{Name: "Linked Channels", Value: strings.Join(g, ", "), Inline: true},
|
|
},
|
|
}, nil
|
|
}
|