193 lines
4.0 KiB
Go
193 lines
4.0 KiB
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
|
|
}
|
|
|
|
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,
|
|
}
|
|
}
|