dcbot/internal/domain/group.go

package domain

import (
	"fmt"
	"time"
)

type Group struct {
	ID            string
	ServerID      string // Discord server ID
	ChannelGains  string
	ChannelLosses string
	Internals     bool   // Show conquers in the same group
	Barbarians    bool   // Show barbarian conquers
	ServerKey     string // TW server key (e.g. en130)
	VersionCode   string
	LanguageTag   string // BCP 47 language tag
	CreatedAt     time.Time
}

type GroupWithMonitors struct {
	Group

	Monitors []Monitor
}

func (g GroupWithMonitors) CanSendEnnoblementNotificationTypeGain(e Ennoblement) bool {
	if g.ChannelGains == "" {
		return false
	}

	if !g.Barbarians && e.IsBarbarian() {
		return false
	}

	if !g.Internals && g.IsInternal(e) {
		return false
	}

	return g.IsGain(e)
}

func (g GroupWithMonitors) CanSendEnnoblementNotificationTypeLoss(e Ennoblement) bool {
	return g.ChannelLosses != "" && !g.IsInternal(e) && g.IsLoss(e)
}

func (g GroupWithMonitors) IsGain(e Ennoblement) bool {
	var n bool

	for _, m := range g.Monitors {
		if m.TribeID == e.NewOwner.Player.Tribe.Tribe.ID {
			n = true
			break
		}
	}

	return n && !e.IsSelfConquer()
}

func (g GroupWithMonitors) IsInternal(e Ennoblement) bool {
	var n, o bool

	for _, m := range g.Monitors {
		if m.TribeID == e.NewOwner.Player.Tribe.Tribe.ID {
			n = true
		}

		if m.TribeID == e.Village.Player.Player.Tribe.Tribe.ID {
			o = true
		}
	}

	return n && o
}

func (g GroupWithMonitors) IsLoss(e Ennoblement) bool {
	var o bool

	for _, m := range g.Monitors {
		if m.TribeID == e.Village.Player.Player.Tribe.Tribe.ID {
			o = true
			break
		}
	}

	return o && !e.IsSelfConquer()
}

type GroupWithMonitorsAndTribes struct {
	Group

	Monitors []MonitorWithTribe
}

type CreateGroupParams struct {
	serverID      string
	serverKey     string
	versionCode   string
	channelGains  string
	channelLosses string
	barbarians    bool
	internals     bool
	languageTag   string
}

func NewCreateGroupParams(
	serverID, versionCode, serverKey, languageTag, channelGains, channelLosses string,
	barbarians, internals bool,
) (CreateGroupParams, error) {
	if serverID == "" {
		return CreateGroupParams{}, RequiredError{Field: "ServerID"}
	}

	if versionCode == "" {
		return CreateGroupParams{}, RequiredError{Field: "VersionCode"}
	}

	if serverKey == "" {
		return CreateGroupParams{}, RequiredError{Field: "ServerKey"}
	}

	if languageTag == "" {
		return CreateGroupParams{}, RequiredError{Field: "LanguageTag"}
	}

	return CreateGroupParams{
		serverID:      serverID,
		serverKey:     serverKey,
		versionCode:   versionCode,
		channelGains:  channelGains,
		channelLosses: channelLosses,
		barbarians:    barbarians,
		internals:     internals,
		languageTag:   languageTag,
	}, nil
}

func (c CreateGroupParams) ServerID() string {
	return c.serverID
}

func (c CreateGroupParams) VersionCode() string {
	return c.versionCode
}

func (c CreateGroupParams) LanguageTag() string {
	return c.languageTag
}

func (c CreateGroupParams) ServerKey() string {
	return c.serverKey
}

func (c CreateGroupParams) ChannelGains() string {
	return c.channelGains
}

func (c CreateGroupParams) ChannelLosses() string {
	return c.channelLosses
}

func (c CreateGroupParams) Barbarians() bool {
	return c.barbarians
}

func (c CreateGroupParams) Internals() bool {
	return c.internals
}

type UpdateGroupParams struct {
	ChannelGains  NullString
	ChannelLosses NullString
	LanguageTag   NullString
	Internals     NullBool
	Barbarians    NullBool
}

func (u UpdateGroupParams) IsZero() bool {
	return !u.ChannelGains.Valid &&
		!u.ChannelLosses.Valid &&
		!u.Internals.Valid &&
		!u.Barbarians.Valid &&
		!u.LanguageTag.Valid
}

type ListGroupsParams struct {
	ServerIDs            []string // DC server IDs
	VersionCode          NullString
	ServerKeys           []string
	EnabledNotifications NullBool // check if ChannelGains != null && ChannelLosses != null
	CreatedAtLTE         time.Time
}

type GroupLimitReachedError struct {
	Current int // current number of groups
	Limit   int // maximum number of groups
}

var _ TranslatableError = GroupLimitReachedError{}

func (e GroupLimitReachedError) Error() string {
	return fmt.Sprintf("group limit has been reached (%d/%d)", e.Current, e.Limit)
}

func (e GroupLimitReachedError) Slug() string {
	return "group-limit-reached"
}

func (e GroupLimitReachedError) Params() map[string]any {
	return map[string]any{
		"Current": e.Current,
		"Limit":   e.Limit,
	}
}

type GroupNotFoundError struct {
	ID string
}

var _ TranslatableError = GroupNotFoundError{}

func (e GroupNotFoundError) Error() string {
	return fmt.Sprintf("group (id=%s) not found", e.ID)
}

func (e GroupNotFoundError) Slug() string {
	return "group-not-found"
}

func (e GroupNotFoundError) Params() map[string]any {
	return map[string]any{
		"ID": e.ID,
	}
}

type GroupDoesNotExistError struct {
	ID string
}

var _ TranslatableError = GroupDoesNotExistError{}

func (e GroupDoesNotExistError) Error() string {
	return fmt.Sprintf("group (id=%s) doesn't exist", e.ID)
}

func (e GroupDoesNotExistError) Slug() string {
	return "group-does-not-exist"
}

func (e GroupDoesNotExistError) Params() map[string]any {
	return map[string]any{
		"ID": e.ID,
	}
}