From 96f0d3989108adb1a2edb431d33ce2335da74a4b Mon Sep 17 00:00:00 2001 From: ikafly144 Date: Fri, 1 Dec 2023 00:05:11 +0900 Subject: [PATCH] =?UTF-8?q?mee6=E3=82=A4=E3=83=B3=E3=83=9D=E3=83=BC?= =?UTF-8?q?=E3=83=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: ikafly144 --- bot/commands/level/level.go | 100 ++++++++++++++++++++++++++++++++++++ bot/commands/level/mee6.go | 50 ++++++++++++++++++ ent/guild.go | 13 +++++ ent/guild/guild.go | 10 ++++ ent/guild/where.go | 15 ++++++ ent/guild_create.go | 25 +++++++++ ent/guild_update.go | 34 ++++++++++++ ent/migrate/schema.go | 3 +- ent/mutation.go | 56 +++++++++++++++++++- ent/runtime.go | 4 ++ ent/schema/guild.go | 2 + lang/ja.yaml | 6 ++- 12 files changed, 315 insertions(+), 3 deletions(-) create mode 100644 bot/commands/level/mee6.go diff --git a/bot/commands/level/level.go b/bot/commands/level/level.go index 68ab9226..3ad5d65a 100644 --- a/bot/commands/level/level.go +++ b/bot/commands/level/level.go @@ -1,7 +1,10 @@ package level import ( + "encoding/json" "fmt" + "log/slog" + "net/http" "slices" "strconv" "strings" @@ -11,6 +14,7 @@ import ( "github.com/disgoorg/disgo/bot" "github.com/disgoorg/disgo/discord" "github.com/disgoorg/disgo/events" + "github.com/disgoorg/snowflake/v2" "github.com/sabafly/gobot/bot/components" "github.com/sabafly/gobot/bot/components/generic" "github.com/sabafly/gobot/ent/member" @@ -132,6 +136,10 @@ func Command(c *components.Components) components.Command { }, }, }, + discord.ApplicationCommandOptionSubCommand{ + Name: "import-mee6", + Description: "import xp point from mee6", + }, }, }, }, @@ -428,6 +436,98 @@ func Command(c *components.Components) components.Command { return nil }, }, + "/level/import-mee6": generic.PCommandHandler{ + PCommandHandler: generic.PermissionCommandCheck("level.import-mee6"), + CommandHandler: func(c *components.Components, event *events.ApplicationCommandInteractionCreate) errors.Error { + g, err := c.GuildCreateID(event, *event.GuildID()) + if err != nil { + return errors.NewError(err) + } + + if g.LevelMee6Imported { + return errors.NewError(errors.ErrorMessage("components.level.import-mee6.message.already", event)) + } + + members := []discord.Member{} + member_count := 1000 + afterID := snowflake.ID(0) + for member_count == 1000 { + m, err := event.Client().Rest().GetMembers(*event.GuildID(), member_count, afterID) + if err != nil { + return errors.NewError(err) + } + member_count = len(m) + members = append(members, m...) + afterID = m[len(m)-1].User.ID + } + + slog.Info("mee6インポート", slog.Any("gid", event.GuildID()), slog.Int("member_count", len(members))) + + member_count = 0 + url := fmt.Sprintf("https://mee6.xyz/api/plugins/levels/leaderboard/%s", event.GuildID().String()) + for page := 0; true; page++ { + response, err := http.Get(fmt.Sprintf("%s?page=%d", url, page)) + if err != nil || response.StatusCode != http.StatusOK { + switch response.StatusCode { + case http.StatusUnauthorized: + if err := event.RespondMessage( + discord.NewMessageBuilder(). + SetContent( + fmt.Sprintf("# FAILED\n```| STATUS CODE | %d\n| RESPONSE | %v```%s", + response.StatusCode, + err, + translate.Message(event.Locale(), "components.level.import-mee6.message.unauthorized", + translate.WithTemplate(map[string]any{"GuildID": *event.GuildID()}), + ), + ), + ), + ); err != nil { + return errors.NewError(err) + } + return nil + default: + if err := event.RespondMessage( + discord.NewMessageBuilder(). + SetContent(fmt.Sprintf("# FAILED\n```| STATUS CODE | %d\n| RESPONSE | %v```", response.StatusCode, err)), + ); err != nil { + return errors.NewError(err) + } + return nil + } + } + var leaderboard mee6LeaderBoard + if err := json.NewDecoder(response.Body).Decode(&leaderboard); err != nil { + return errors.NewError(err) + } + if len(leaderboard.Players) < 1 { + break + } + for _, player := range leaderboard.Players { + index := slices.IndexFunc(members, func(m discord.Member) bool { return m.User.ID == player.ID }) + if index == -1 { + continue + } + slog.Info("mee6メンバーインポート", slog.Any("gid", event.GuildID()), slog.Any("member_id", player.ID)) + m, err := c.MemberCreate(event, members[index].User, *event.GuildID()) + if err != nil { + return errors.NewError(err) + } + m.Update().SetXp(xppoint.XP(player.Xp)).ExecX(event) + member_count++ + } + } + + g.Update().SetLevelMee6Imported(true).ExecX(event) + + if err := event.RespondMessage( + discord.NewMessageBuilder(). + SetContent(fmt.Sprintf("# SUCCEED\n```| IMPORTED MEMBER COUNT | %d```", member_count)), + ); err != nil { + return errors.NewError(err) + } + return nil + }, + }, }, ModalHandlers: map[string]generic.ModalHandler{ "level:up_message_modal": func(c *components.Components, event *events.ModalSubmitInteractionCreate) errors.Error { diff --git a/bot/commands/level/mee6.go b/bot/commands/level/mee6.go new file mode 100644 index 00000000..a790849e --- /dev/null +++ b/bot/commands/level/mee6.go @@ -0,0 +1,50 @@ +package level + +import "github.com/disgoorg/snowflake/v2" + +type mee6LeaderBoard struct { + Admin bool `json:"admin"` + BannerURL *string `json:"banner_url"` + Country string `json:"country"` + Guild mee6Guild `json:"guild"` + IsMember bool `json:"is_member"` + MonetizeOptions mee6MonetizeOptions `json:"monetize_options"` + Page int `json:"page"` + Player *mee6Player `json:"player"` + Players []mee6Player `json:"players"` + RoleRewards []any `json:"role_rewards"` + UserGuildSettings any `json:"user_guild_settings"` + XpPerMessage []int `json:"xp_per_message"` + XpRate float64 `json:"xp_rate"` +} + +type mee6Guild struct { + AllowJoin bool `json:"allow_join"` + ApplicationCommandsEnabled bool `json:"application_commands_enabled"` + CommandsPrefix string `json:"commands_prefix"` + Icon string `json:"icon"` + ID string `json:"id"` + InviteLeaderboard bool `json:"invite_leaderboard"` + LeaderboardURL string `json:"leaderboard_url"` + Name string `json:"name"` + Premium bool `json:"premium"` +} + +type mee6MonetizeOptions struct { + DisplayPlans bool `json:"display_plans"` + ShowcaseSubscribers bool `json:"showcase_subscribers"` +} + +type mee6Player struct { + Avatar string `json:"avatar"` + DetailedXp []int64 `json:"detailed_xp"` + Discriminator string `json:"discriminator"` + GuildID string `json:"guild_id"` + ID snowflake.ID `json:"id"` + IsMonetizeSubscriber bool `json:"is_monetize_subscriber"` + Level int64 `json:"level"` + MessageCount int64 `json:"message_count"` + MonetizeXpBoost int64 `json:"monetize_xp_boost"` + Username string `json:"username"` + Xp int64 `json:"xp"` +} diff --git a/ent/guild.go b/ent/guild.go index 12c01b07..cb2ef48b 100644 --- a/ent/guild.go +++ b/ent/guild.go @@ -31,6 +31,8 @@ type Guild struct { LevelUpChannel *snowflake.ID `json:"level_up_channel,omitempty"` // LevelUpExcludeChannel holds the value of the "level_up_exclude_channel" field. LevelUpExcludeChannel []snowflake.ID `json:"level_up_exclude_channel,omitempty"` + // LevelMee6Imported holds the value of the "level_mee6_imported" field. + LevelMee6Imported bool `json:"level_mee6_imported,omitempty"` // Permissions holds the value of the "permissions" field. Permissions map[snowflake.ID]permissions.Permission `json:"permissions,omitempty"` // Edges holds the relations/edges for other nodes in the graph. @@ -124,6 +126,8 @@ func (*Guild) scanValues(columns []string) ([]any, error) { switch columns[i] { case guild.FieldLevelUpExcludeChannel, guild.FieldPermissions: values[i] = new([]byte) + case guild.FieldLevelMee6Imported: + values[i] = new(sql.NullBool) case guild.FieldID, guild.FieldLevelUpChannel: values[i] = new(sql.NullInt64) case guild.FieldName, guild.FieldLocale, guild.FieldLevelUpMessage: @@ -184,6 +188,12 @@ func (gu *Guild) assignValues(columns []string, values []any) error { return fmt.Errorf("unmarshal field level_up_exclude_channel: %w", err) } } + case guild.FieldLevelMee6Imported: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field level_mee6_imported", values[i]) + } else if value.Valid { + gu.LevelMee6Imported = value.Bool + } case guild.FieldPermissions: if value, ok := values[i].(*[]byte); !ok { return fmt.Errorf("unexpected type %T for field permissions", values[i]) @@ -282,6 +292,9 @@ func (gu *Guild) String() string { builder.WriteString("level_up_exclude_channel=") builder.WriteString(fmt.Sprintf("%v", gu.LevelUpExcludeChannel)) builder.WriteString(", ") + builder.WriteString("level_mee6_imported=") + builder.WriteString(fmt.Sprintf("%v", gu.LevelMee6Imported)) + builder.WriteString(", ") builder.WriteString("permissions=") builder.WriteString(fmt.Sprintf("%v", gu.Permissions)) builder.WriteByte(')') diff --git a/ent/guild/guild.go b/ent/guild/guild.go index 5f84a771..8379d2dd 100644 --- a/ent/guild/guild.go +++ b/ent/guild/guild.go @@ -23,6 +23,8 @@ const ( FieldLevelUpChannel = "level_up_channel" // FieldLevelUpExcludeChannel holds the string denoting the level_up_exclude_channel field in the database. FieldLevelUpExcludeChannel = "level_up_exclude_channel" + // FieldLevelMee6Imported holds the string denoting the level_mee6_imported field in the database. + FieldLevelMee6Imported = "level_mee6_imported" // FieldPermissions holds the string denoting the permissions field in the database. FieldPermissions = "permissions" // EdgeOwner holds the string denoting the owner edge name in mutations. @@ -91,6 +93,7 @@ var Columns = []string{ FieldLevelUpMessage, FieldLevelUpChannel, FieldLevelUpExcludeChannel, + FieldLevelMee6Imported, FieldPermissions, } @@ -126,6 +129,8 @@ var ( DefaultLevelUpMessage string // LevelUpMessageValidator is a validator for the "level_up_message" field. It is called by the builders before save. LevelUpMessageValidator func(string) error + // DefaultLevelMee6Imported holds the default value on creation for the "level_mee6_imported" field. + DefaultLevelMee6Imported bool ) // OrderOption defines the ordering options for the Guild queries. @@ -156,6 +161,11 @@ func ByLevelUpChannel(opts ...sql.OrderTermOption) OrderOption { return sql.OrderByField(FieldLevelUpChannel, opts...).ToFunc() } +// ByLevelMee6Imported orders the results by the level_mee6_imported field. +func ByLevelMee6Imported(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldLevelMee6Imported, opts...).ToFunc() +} + // ByOwnerField orders the results by owner field. func ByOwnerField(field string, opts ...sql.OrderTermOption) OrderOption { return func(s *sql.Selector) { diff --git a/ent/guild/where.go b/ent/guild/where.go index f7f52ec3..5fc8746f 100644 --- a/ent/guild/where.go +++ b/ent/guild/where.go @@ -77,6 +77,11 @@ func LevelUpChannel(v snowflake.ID) predicate.Guild { return predicate.Guild(sql.FieldEQ(FieldLevelUpChannel, vc)) } +// LevelMee6Imported applies equality check predicate on the "level_mee6_imported" field. It's identical to LevelMee6ImportedEQ. +func LevelMee6Imported(v bool) predicate.Guild { + return predicate.Guild(sql.FieldEQ(FieldLevelMee6Imported, v)) +} + // NameEQ applies the EQ predicate on the "name" field. func NameEQ(v string) predicate.Guild { return predicate.Guild(sql.FieldEQ(FieldName, v)) @@ -365,6 +370,16 @@ func LevelUpExcludeChannelNotNil() predicate.Guild { return predicate.Guild(sql.FieldNotNull(FieldLevelUpExcludeChannel)) } +// LevelMee6ImportedEQ applies the EQ predicate on the "level_mee6_imported" field. +func LevelMee6ImportedEQ(v bool) predicate.Guild { + return predicate.Guild(sql.FieldEQ(FieldLevelMee6Imported, v)) +} + +// LevelMee6ImportedNEQ applies the NEQ predicate on the "level_mee6_imported" field. +func LevelMee6ImportedNEQ(v bool) predicate.Guild { + return predicate.Guild(sql.FieldNEQ(FieldLevelMee6Imported, v)) +} + // PermissionsIsNil applies the IsNil predicate on the "permissions" field. func PermissionsIsNil() predicate.Guild { return predicate.Guild(sql.FieldIsNull(FieldPermissions)) diff --git a/ent/guild_create.go b/ent/guild_create.go index 0d40406c..59c902e1 100644 --- a/ent/guild_create.go +++ b/ent/guild_create.go @@ -83,6 +83,20 @@ func (gc *GuildCreate) SetLevelUpExcludeChannel(s []snowflake.ID) *GuildCreate { return gc } +// SetLevelMee6Imported sets the "level_mee6_imported" field. +func (gc *GuildCreate) SetLevelMee6Imported(b bool) *GuildCreate { + gc.mutation.SetLevelMee6Imported(b) + return gc +} + +// SetNillableLevelMee6Imported sets the "level_mee6_imported" field if the given value is not nil. +func (gc *GuildCreate) SetNillableLevelMee6Imported(b *bool) *GuildCreate { + if b != nil { + gc.SetLevelMee6Imported(*b) + } + return gc +} + // SetPermissions sets the "permissions" field. func (gc *GuildCreate) SetPermissions(m map[snowflake.ID]permissions.Permission) *GuildCreate { gc.mutation.SetPermissions(m) @@ -224,6 +238,10 @@ func (gc *GuildCreate) defaults() { v := guild.DefaultLevelUpMessage gc.mutation.SetLevelUpMessage(v) } + if _, ok := gc.mutation.LevelMee6Imported(); !ok { + v := guild.DefaultLevelMee6Imported + gc.mutation.SetLevelMee6Imported(v) + } } // check runs all checks and user-defined validators on the builder. @@ -252,6 +270,9 @@ func (gc *GuildCreate) check() error { return &ValidationError{Name: "level_up_message", err: fmt.Errorf(`ent: validator failed for field "Guild.level_up_message": %w`, err)} } } + if _, ok := gc.mutation.LevelMee6Imported(); !ok { + return &ValidationError{Name: "level_mee6_imported", err: errors.New(`ent: missing required field "Guild.level_mee6_imported"`)} + } if _, ok := gc.mutation.OwnerID(); !ok { return &ValidationError{Name: "owner", err: errors.New(`ent: missing required edge "Guild.owner"`)} } @@ -307,6 +328,10 @@ func (gc *GuildCreate) createSpec() (*Guild, *sqlgraph.CreateSpec) { _spec.SetField(guild.FieldLevelUpExcludeChannel, field.TypeJSON, value) _node.LevelUpExcludeChannel = value } + if value, ok := gc.mutation.LevelMee6Imported(); ok { + _spec.SetField(guild.FieldLevelMee6Imported, field.TypeBool, value) + _node.LevelMee6Imported = value + } if value, ok := gc.mutation.Permissions(); ok { _spec.SetField(guild.FieldPermissions, field.TypeJSON, value) _node.Permissions = value diff --git a/ent/guild_update.go b/ent/guild_update.go index 05b00c9c..88e94afa 100644 --- a/ent/guild_update.go +++ b/ent/guild_update.go @@ -125,6 +125,20 @@ func (gu *GuildUpdate) ClearLevelUpExcludeChannel() *GuildUpdate { return gu } +// SetLevelMee6Imported sets the "level_mee6_imported" field. +func (gu *GuildUpdate) SetLevelMee6Imported(b bool) *GuildUpdate { + gu.mutation.SetLevelMee6Imported(b) + return gu +} + +// SetNillableLevelMee6Imported sets the "level_mee6_imported" field if the given value is not nil. +func (gu *GuildUpdate) SetNillableLevelMee6Imported(b *bool) *GuildUpdate { + if b != nil { + gu.SetLevelMee6Imported(*b) + } + return gu +} + // SetPermissions sets the "permissions" field. func (gu *GuildUpdate) SetPermissions(m map[snowflake.ID]permissions.Permission) *GuildUpdate { gu.mutation.SetPermissions(m) @@ -430,6 +444,9 @@ func (gu *GuildUpdate) sqlSave(ctx context.Context) (n int, err error) { if gu.mutation.LevelUpExcludeChannelCleared() { _spec.ClearField(guild.FieldLevelUpExcludeChannel, field.TypeJSON) } + if value, ok := gu.mutation.LevelMee6Imported(); ok { + _spec.SetField(guild.FieldLevelMee6Imported, field.TypeBool, value) + } if value, ok := gu.mutation.Permissions(); ok { _spec.SetField(guild.FieldPermissions, field.TypeJSON, value) } @@ -797,6 +814,20 @@ func (guo *GuildUpdateOne) ClearLevelUpExcludeChannel() *GuildUpdateOne { return guo } +// SetLevelMee6Imported sets the "level_mee6_imported" field. +func (guo *GuildUpdateOne) SetLevelMee6Imported(b bool) *GuildUpdateOne { + guo.mutation.SetLevelMee6Imported(b) + return guo +} + +// SetNillableLevelMee6Imported sets the "level_mee6_imported" field if the given value is not nil. +func (guo *GuildUpdateOne) SetNillableLevelMee6Imported(b *bool) *GuildUpdateOne { + if b != nil { + guo.SetLevelMee6Imported(*b) + } + return guo +} + // SetPermissions sets the "permissions" field. func (guo *GuildUpdateOne) SetPermissions(m map[snowflake.ID]permissions.Permission) *GuildUpdateOne { guo.mutation.SetPermissions(m) @@ -1132,6 +1163,9 @@ func (guo *GuildUpdateOne) sqlSave(ctx context.Context) (_node *Guild, err error if guo.mutation.LevelUpExcludeChannelCleared() { _spec.ClearField(guild.FieldLevelUpExcludeChannel, field.TypeJSON) } + if value, ok := guo.mutation.LevelMee6Imported(); ok { + _spec.SetField(guild.FieldLevelMee6Imported, field.TypeBool, value) + } if value, ok := guo.mutation.Permissions(); ok { _spec.SetField(guild.FieldPermissions, field.TypeJSON, value) } diff --git a/ent/migrate/schema.go b/ent/migrate/schema.go index c9153a8a..b54b969c 100644 --- a/ent/migrate/schema.go +++ b/ent/migrate/schema.go @@ -16,6 +16,7 @@ var ( {Name: "level_up_message", Type: field.TypeString, Default: "{user}がレベルアップしたよ！🥳\n**{before_level} レベル → {after_level} レベル**"}, {Name: "level_up_channel", Type: field.TypeUint64, Nullable: true}, {Name: "level_up_exclude_channel", Type: field.TypeJSON, Nullable: true}, + {Name: "level_mee6_imported", Type: field.TypeBool, Default: false}, {Name: "permissions", Type: field.TypeJSON, Nullable: true}, {Name: "user_own_guilds", Type: field.TypeUint64}, } @@ -27,7 +28,7 @@ var ( ForeignKeys: []*schema.ForeignKey{ { Symbol: "guilds_users_own_guilds", - Columns: []*schema.Column{GuildsColumns[7]}, + Columns: []*schema.Column{GuildsColumns[8]}, RefColumns: []*schema.Column{UsersColumns[0]}, OnDelete: schema.NoAction, }, diff --git a/ent/mutation.go b/ent/mutation.go index fc0305c3..8f6e99b5 100644 --- a/ent/mutation.go +++ b/ent/mutation.go @@ -60,6 +60,7 @@ type GuildMutation struct { addlevel_up_channel *snowflake.ID level_up_exclude_channel *[]snowflake.ID appendlevel_up_exclude_channel []snowflake.ID + level_mee6_imported *bool permissions *map[snowflake.ID]permissions.Permission clearedFields map[string]struct{} owner *snowflake.ID @@ -431,6 +432,42 @@ func (m *GuildMutation) ResetLevelUpExcludeChannel() { delete(m.clearedFields, guild.FieldLevelUpExcludeChannel) } +// SetLevelMee6Imported sets the "level_mee6_imported" field. +func (m *GuildMutation) SetLevelMee6Imported(b bool) { + m.level_mee6_imported = &b +} + +// LevelMee6Imported returns the value of the "level_mee6_imported" field in the mutation. +func (m *GuildMutation) LevelMee6Imported() (r bool, exists bool) { + v := m.level_mee6_imported + if v == nil { + return + } + return *v, true +} + +// OldLevelMee6Imported returns the old "level_mee6_imported" field's value of the Guild entity. +// If the Guild object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *GuildMutation) OldLevelMee6Imported(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldLevelMee6Imported is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldLevelMee6Imported requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldLevelMee6Imported: %w", err) + } + return oldValue.LevelMee6Imported, nil +} + +// ResetLevelMee6Imported resets all changes to the "level_mee6_imported" field. +func (m *GuildMutation) ResetLevelMee6Imported() { + m.level_mee6_imported = nil +} + // SetPermissions sets the "permissions" field. func (m *GuildMutation) SetPermissions(value map[snowflake.ID]permissions.Permission) { m.permissions = &value @@ -823,7 +860,7 @@ func (m *GuildMutation) Type() string { // order to get all numeric fields that were incremented/decremented, call // AddedFields(). func (m *GuildMutation) Fields() []string { - fields := make([]string, 0, 6) + fields := make([]string, 0, 7) if m.name != nil { fields = append(fields, guild.FieldName) } @@ -839,6 +876,9 @@ func (m *GuildMutation) Fields() []string { if m.level_up_exclude_channel != nil { fields = append(fields, guild.FieldLevelUpExcludeChannel) } + if m.level_mee6_imported != nil { + fields = append(fields, guild.FieldLevelMee6Imported) + } if m.permissions != nil { fields = append(fields, guild.FieldPermissions) } @@ -860,6 +900,8 @@ func (m *GuildMutation) Field(name string) (ent.Value, bool) { return m.LevelUpChannel() case guild.FieldLevelUpExcludeChannel: return m.LevelUpExcludeChannel() + case guild.FieldLevelMee6Imported: + return m.LevelMee6Imported() case guild.FieldPermissions: return m.Permissions() } @@ -881,6 +923,8 @@ func (m *GuildMutation) OldField(ctx context.Context, name string) (ent.Value, e return m.OldLevelUpChannel(ctx) case guild.FieldLevelUpExcludeChannel: return m.OldLevelUpExcludeChannel(ctx) + case guild.FieldLevelMee6Imported: + return m.OldLevelMee6Imported(ctx) case guild.FieldPermissions: return m.OldPermissions(ctx) } @@ -927,6 +971,13 @@ func (m *GuildMutation) SetField(name string, value ent.Value) error { } m.SetLevelUpExcludeChannel(v) return nil + case guild.FieldLevelMee6Imported: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetLevelMee6Imported(v) + return nil case guild.FieldPermissions: v, ok := value.(map[snowflake.ID]permissions.Permission) if !ok { @@ -1034,6 +1085,9 @@ func (m *GuildMutation) ResetField(name string) error { case guild.FieldLevelUpExcludeChannel: m.ResetLevelUpExcludeChannel() return nil + case guild.FieldLevelMee6Imported: + m.ResetLevelMee6Imported() + return nil case guild.FieldPermissions: m.ResetPermissions() return nil diff --git a/ent/runtime.go b/ent/runtime.go index 801e3936..cd87c8e1 100644 --- a/ent/runtime.go +++ b/ent/runtime.go @@ -42,6 +42,10 @@ func init() { guild.DefaultLevelUpMessage = guildDescLevelUpMessage.Default.(string) // guild.LevelUpMessageValidator is a validator for the "level_up_message" field. It is called by the builders before save. guild.LevelUpMessageValidator = guildDescLevelUpMessage.Validators[0].(func(string) error) + // guildDescLevelMee6Imported is the schema descriptor for level_mee6_imported field. + guildDescLevelMee6Imported := guildFields[6].Descriptor() + // guild.DefaultLevelMee6Imported holds the default value on creation for the level_mee6_imported field. + guild.DefaultLevelMee6Imported = guildDescLevelMee6Imported.Default.(bool) memberFields := schema.Member{}.Fields() _ = memberFields // memberDescPermission is the schema descriptor for permission field. diff --git a/ent/schema/guild.go b/ent/schema/guild.go index d353d6fa..42f2b0b1 100644 --- a/ent/schema/guild.go +++ b/ent/schema/guild.go @@ -36,6 +36,8 @@ func (Guild) Fields() []ent.Field { GoType(snowflake.ID(0)), field.JSON("level_up_exclude_channel", []snowflake.ID{}). Optional(), + field.Bool("level_mee6_imported"). + Default(false), field.JSON("permissions", map[snowflake.ID]permissions.Permission{}). Optional(), } diff --git a/lang/ja.yaml b/lang/ja.yaml index ac9b4c4b..d935d8a8 100644 --- a/lang/ja.yaml +++ b/lang/ja.yaml @@ -516,9 +516,13 @@ components.level.up.message-channel.default: 「レベルアップした時の components.level.exclude-channel.add.message: "{{.Channel}}を除外します" components.level.exclude-channel.clear.message: "除外チャンネルをクリアします" components.level.exclude-channel.remove.message: "{{.Channel}}の除外を解除します" +components.level.import-mee6.message.already: インポートできません +components.level.import-mee6.message.already.description: 二回以上インポートすることはできません +components.level.import-mee6.message.unauthorized: |- + mee6リーダーボードがパブリックではありません。 + [設定]()からリーダーボードを公開してください。 # エラーメッセージ - errors.generic.message: エラーが発生しました errors.panic.message: 致命的なエラー errors.invalid.bot.target: ボットは選択できません