2024-01-04 10:44:36 +00:00
|
|
|
package domain
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"math"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
2024-03-24 08:49:01 +00:00
|
|
|
const EnnoblementRetentionForClosedServers = 365 * 24 * time.Hour
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
type Ennoblement struct {
|
|
|
|
id int
|
|
|
|
serverKey string
|
|
|
|
villageID int
|
|
|
|
newOwnerID int
|
|
|
|
newTribeID int
|
|
|
|
oldOwnerID int
|
|
|
|
oldTribeID int
|
|
|
|
points int
|
|
|
|
createdAt time.Time
|
|
|
|
}
|
|
|
|
|
|
|
|
const ennoblementModelName = "Ennoblement"
|
|
|
|
|
|
|
|
// UnmarshalEnnoblementFromDatabase unmarshals Ennoblement from the database.
|
|
|
|
//
|
|
|
|
// It should be used only for unmarshalling from the database!
|
|
|
|
// You can't use UnmarshalEnnoblementFromDatabase as constructor - It may put domain into the invalid state!
|
|
|
|
func UnmarshalEnnoblementFromDatabase(
|
|
|
|
id int,
|
|
|
|
serverKey string,
|
|
|
|
villageID int,
|
|
|
|
newOwnerID int,
|
|
|
|
newTribeID int,
|
|
|
|
oldOwnerID int,
|
|
|
|
oldTribeID int,
|
|
|
|
points int,
|
|
|
|
createdAt time.Time,
|
|
|
|
) (Ennoblement, error) {
|
|
|
|
if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
|
|
|
|
return Ennoblement{}, ValidationError{
|
|
|
|
Model: ennoblementModelName,
|
|
|
|
Field: "id",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := validateServerKey(serverKey); err != nil {
|
|
|
|
return Ennoblement{}, ValidationError{
|
|
|
|
Model: ennoblementModelName,
|
|
|
|
Field: "serverKey",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Ennoblement{
|
|
|
|
id: id,
|
|
|
|
serverKey: serverKey,
|
|
|
|
villageID: villageID,
|
|
|
|
newOwnerID: newOwnerID,
|
|
|
|
newTribeID: newTribeID,
|
|
|
|
oldOwnerID: oldOwnerID,
|
|
|
|
oldTribeID: oldTribeID,
|
|
|
|
points: points,
|
|
|
|
createdAt: createdAt,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) ID() int {
|
|
|
|
return e.id
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) ServerKey() string {
|
|
|
|
return e.serverKey
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) VillageID() int {
|
|
|
|
return e.villageID
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) NewOwnerID() int {
|
|
|
|
return e.newOwnerID
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) NewTribeID() int {
|
|
|
|
return e.newTribeID
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) OldOwnerID() int {
|
|
|
|
return e.oldOwnerID
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) OldTribeID() int {
|
|
|
|
return e.oldTribeID
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) Points() int {
|
|
|
|
return e.points
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e Ennoblement) CreatedAt() time.Time {
|
|
|
|
return e.createdAt
|
|
|
|
}
|
|
|
|
|
2024-03-10 09:37:44 +00:00
|
|
|
func (e Ennoblement) WithRelations(
|
|
|
|
village VillageMeta,
|
2024-03-18 07:01:47 +00:00
|
|
|
newOwner PlayerMeta,
|
2024-03-10 09:37:44 +00:00
|
|
|
newTribe NullTribeMeta,
|
|
|
|
oldOwner NullPlayerMeta,
|
|
|
|
oldTribe NullTribeMeta,
|
|
|
|
) EnnoblementWithRelations {
|
|
|
|
return EnnoblementWithRelations{
|
|
|
|
ennoblement: e,
|
|
|
|
village: village,
|
|
|
|
newOwner: newOwner,
|
|
|
|
newTribe: newTribe,
|
|
|
|
oldOwner: oldOwner,
|
|
|
|
oldTribe: oldTribe,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
func (e Ennoblement) ToCursor() (EnnoblementCursor, error) {
|
|
|
|
return NewEnnoblementCursor(e.id, e.serverKey, e.createdAt)
|
|
|
|
}
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
func (e Ennoblement) Base() BaseEnnoblement {
|
|
|
|
return BaseEnnoblement{
|
|
|
|
villageID: e.villageID,
|
|
|
|
newOwnerID: e.newOwnerID,
|
|
|
|
newTribeID: e.newTribeID,
|
|
|
|
oldOwnerID: e.oldOwnerID,
|
|
|
|
oldTribeID: e.oldTribeID,
|
|
|
|
points: e.points,
|
|
|
|
createdAt: e.createdAt,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
func (e Ennoblement) IsZero() bool {
|
|
|
|
return e == Ennoblement{}
|
|
|
|
}
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
type Ennoblements []Ennoblement
|
|
|
|
|
2024-03-10 09:37:44 +00:00
|
|
|
type EnnoblementWithRelations struct {
|
|
|
|
ennoblement Ennoblement
|
|
|
|
village VillageMeta
|
2024-03-18 07:01:47 +00:00
|
|
|
newOwner PlayerMeta
|
2024-03-10 09:37:44 +00:00
|
|
|
newTribe NullTribeMeta
|
|
|
|
oldOwner NullPlayerMeta
|
|
|
|
oldTribe NullTribeMeta
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e EnnoblementWithRelations) Ennoblement() Ennoblement {
|
|
|
|
return e.ennoblement
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e EnnoblementWithRelations) Village() VillageMeta {
|
|
|
|
return e.village
|
|
|
|
}
|
|
|
|
|
2024-03-18 07:01:47 +00:00
|
|
|
func (e EnnoblementWithRelations) NewOwner() PlayerMeta {
|
2024-03-10 09:37:44 +00:00
|
|
|
return e.newOwner
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e EnnoblementWithRelations) NewTribe() NullTribeMeta {
|
|
|
|
return e.newTribe
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e EnnoblementWithRelations) OldOwner() NullPlayerMeta {
|
|
|
|
return e.oldOwner
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e EnnoblementWithRelations) OldTribe() NullTribeMeta {
|
|
|
|
return e.oldTribe
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e EnnoblementWithRelations) IsZero() bool {
|
|
|
|
return e.ennoblement.IsZero()
|
|
|
|
}
|
|
|
|
|
|
|
|
type EnnoblementsWithRelations []EnnoblementWithRelations
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
type CreateEnnoblementParams struct {
|
|
|
|
base BaseEnnoblement
|
|
|
|
serverKey string
|
|
|
|
}
|
|
|
|
|
|
|
|
const createEnnoblementParamsModelName = "CreateEnnoblementParams"
|
|
|
|
|
|
|
|
func NewCreateEnnoblementParams(serverKey string, ennoblements BaseEnnoblements) ([]CreateEnnoblementParams, error) {
|
|
|
|
if err := validateServerKey(serverKey); err != nil {
|
|
|
|
return nil, ValidationError{
|
|
|
|
Model: createEnnoblementParamsModelName,
|
|
|
|
Field: "serverKey",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params := make([]CreateEnnoblementParams, 0, len(ennoblements))
|
|
|
|
|
|
|
|
for i, e := range ennoblements {
|
|
|
|
if e.IsZero() {
|
|
|
|
return nil, fmt.Errorf("ennoblements[%d] is an empty struct", i)
|
|
|
|
}
|
|
|
|
|
|
|
|
params = append(params, CreateEnnoblementParams{
|
|
|
|
base: e,
|
|
|
|
serverKey: serverKey,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
return params, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params CreateEnnoblementParams) Base() BaseEnnoblement {
|
|
|
|
return params.base
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params CreateEnnoblementParams) ServerKey() string {
|
|
|
|
return params.serverKey
|
|
|
|
}
|
|
|
|
|
|
|
|
type EnnoblementSort uint8
|
|
|
|
|
|
|
|
const (
|
|
|
|
EnnoblementSortCreatedAtASC EnnoblementSort = iota + 1
|
|
|
|
EnnoblementSortCreatedAtDESC
|
2024-01-11 06:13:28 +00:00
|
|
|
EnnoblementSortIDASC
|
|
|
|
EnnoblementSortIDDESC
|
2024-01-04 10:44:36 +00:00
|
|
|
EnnoblementSortServerKeyASC
|
|
|
|
EnnoblementSortServerKeyDESC
|
|
|
|
)
|
|
|
|
|
2024-03-02 08:49:42 +00:00
|
|
|
// IsInConflict returns true if two sorts can't be used together (e.g. EnnoblementSortIDASC and EnnoblementSortIDDESC).
|
|
|
|
func (s EnnoblementSort) IsInConflict(s2 EnnoblementSort) bool {
|
2024-03-15 06:57:21 +00:00
|
|
|
return isSortInConflict(s, s2)
|
2024-03-02 08:49:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//nolint:gocyclo
|
|
|
|
func (s EnnoblementSort) String() string {
|
|
|
|
switch s {
|
|
|
|
case EnnoblementSortCreatedAtASC:
|
|
|
|
return "createdAt:ASC"
|
|
|
|
case EnnoblementSortCreatedAtDESC:
|
|
|
|
return "createdAt:DESC"
|
|
|
|
case EnnoblementSortIDASC:
|
|
|
|
return "id:ASC"
|
|
|
|
case EnnoblementSortIDDESC:
|
|
|
|
return "id:DESC"
|
|
|
|
case EnnoblementSortServerKeyASC:
|
|
|
|
return "serverKey:ASC"
|
|
|
|
case EnnoblementSortServerKeyDESC:
|
|
|
|
return "serverKey:DESC"
|
|
|
|
default:
|
|
|
|
return "unknown ennoblement sort"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
type EnnoblementCursor struct {
|
|
|
|
id int
|
|
|
|
serverKey string
|
|
|
|
createdAt time.Time
|
|
|
|
}
|
|
|
|
|
|
|
|
const ennoblementCursorModelName = "EnnoblementCursor"
|
|
|
|
|
|
|
|
func NewEnnoblementCursor(id int, serverKey string, createdAt time.Time) (EnnoblementCursor, error) {
|
|
|
|
if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
|
|
|
|
return EnnoblementCursor{}, ValidationError{
|
|
|
|
Model: ennoblementCursorModelName,
|
|
|
|
Field: "id",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := validateServerKey(serverKey); err != nil {
|
|
|
|
return EnnoblementCursor{}, ValidationError{
|
|
|
|
Model: ennoblementCursorModelName,
|
|
|
|
Field: "serverKey",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return EnnoblementCursor{
|
|
|
|
id: id,
|
|
|
|
serverKey: serverKey,
|
|
|
|
createdAt: createdAt,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
//nolint:gocyclo
|
|
|
|
func decodeEnnoblementCursor(encoded string) (EnnoblementCursor, error) {
|
|
|
|
m, err := decodeCursor(encoded)
|
|
|
|
if err != nil {
|
|
|
|
return EnnoblementCursor{}, err
|
|
|
|
}
|
|
|
|
|
|
|
|
id, err := m.int("id")
|
|
|
|
if err != nil {
|
|
|
|
return EnnoblementCursor{}, ErrInvalidCursor
|
|
|
|
}
|
|
|
|
|
|
|
|
serverKey, err := m.string("serverKey")
|
|
|
|
if err != nil {
|
|
|
|
return EnnoblementCursor{}, ErrInvalidCursor
|
|
|
|
}
|
|
|
|
|
|
|
|
createdAt, err := m.time("createdAt")
|
|
|
|
if err != nil {
|
|
|
|
return EnnoblementCursor{}, ErrInvalidCursor
|
|
|
|
}
|
|
|
|
|
|
|
|
ec, err := NewEnnoblementCursor(
|
|
|
|
id,
|
|
|
|
serverKey,
|
|
|
|
createdAt,
|
|
|
|
)
|
|
|
|
if err != nil {
|
|
|
|
return EnnoblementCursor{}, ErrInvalidCursor
|
|
|
|
}
|
|
|
|
|
|
|
|
return ec, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec EnnoblementCursor) ID() int {
|
|
|
|
return ec.id
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec EnnoblementCursor) ServerKey() string {
|
|
|
|
return ec.serverKey
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec EnnoblementCursor) CreatedAt() time.Time {
|
|
|
|
return ec.createdAt
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec EnnoblementCursor) IsZero() bool {
|
|
|
|
return ec == EnnoblementCursor{}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ec EnnoblementCursor) Encode() string {
|
|
|
|
if ec.IsZero() {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
return encodeCursor([]keyValuePair{
|
|
|
|
{"id", ec.id},
|
|
|
|
{"serverKey", ec.serverKey},
|
|
|
|
{"createdAt", ec.createdAt},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
type ListEnnoblementsParams struct {
|
|
|
|
serverKeys []string
|
2024-03-11 09:05:29 +00:00
|
|
|
villageIDs []int
|
|
|
|
playerIDs []int // Ennoblement.NewOwnerID or Ennoblement.OldOwnerID
|
|
|
|
tribeIDs []int // Ennoblement.NewTribeID or Ennoblement.OldTribeID
|
|
|
|
since NullTime
|
|
|
|
before NullTime
|
2024-01-04 10:44:36 +00:00
|
|
|
sort []EnnoblementSort
|
2024-03-10 08:30:03 +00:00
|
|
|
cursor EnnoblementCursor
|
2024-01-04 10:44:36 +00:00
|
|
|
limit int
|
|
|
|
}
|
|
|
|
|
2024-01-27 08:37:12 +00:00
|
|
|
const (
|
2024-03-11 07:16:29 +00:00
|
|
|
EnnoblementListMaxLimit = 500
|
2024-01-27 08:37:12 +00:00
|
|
|
listEnnoblementsParamsModelName = "ListEnnoblementsParams"
|
|
|
|
)
|
2024-01-04 10:44:36 +00:00
|
|
|
|
|
|
|
func NewListEnnoblementsParams() ListEnnoblementsParams {
|
|
|
|
return ListEnnoblementsParams{
|
|
|
|
sort: []EnnoblementSort{
|
|
|
|
EnnoblementSortServerKeyASC,
|
|
|
|
EnnoblementSortCreatedAtASC,
|
2024-01-11 06:13:28 +00:00
|
|
|
EnnoblementSortIDASC,
|
2024-01-04 10:44:36 +00:00
|
|
|
},
|
|
|
|
limit: EnnoblementListMaxLimit,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) ServerKeys() []string {
|
|
|
|
return params.serverKeys
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetServerKeys(serverKeys []string) error {
|
2024-03-03 06:23:46 +00:00
|
|
|
for i, sk := range serverKeys {
|
|
|
|
if err := validateServerKey(sk); err != nil {
|
|
|
|
return SliceElementValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "serverKeys",
|
|
|
|
Index: i,
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
params.serverKeys = serverKeys
|
2024-03-03 06:23:46 +00:00
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-03-11 09:05:29 +00:00
|
|
|
func (params *ListEnnoblementsParams) VillageIDs() []int {
|
|
|
|
return params.villageIDs
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetVillageIDs(villageIDs []int) error {
|
|
|
|
for i, id := range villageIDs {
|
|
|
|
if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
|
|
|
|
return SliceElementValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "villageIDs",
|
|
|
|
Index: i,
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params.villageIDs = villageIDs
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) PlayerIDs() []int {
|
|
|
|
return params.playerIDs
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetPlayerIDs(playerIDs []int) error {
|
|
|
|
for i, id := range playerIDs {
|
|
|
|
if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
|
|
|
|
return SliceElementValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "playerIDs",
|
|
|
|
Index: i,
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params.playerIDs = playerIDs
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) TribeIDs() []int {
|
|
|
|
return params.tribeIDs
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetTribeIDs(tribeIDs []int) error {
|
|
|
|
for i, id := range tribeIDs {
|
|
|
|
if err := validateIntInRange(id, 1, math.MaxInt); err != nil {
|
|
|
|
return SliceElementValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "tribeIDs",
|
|
|
|
Index: i,
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params.tribeIDs = tribeIDs
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) Since() NullTime {
|
|
|
|
return params.since
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetSince(since NullTime) error {
|
|
|
|
params.since = since
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) Before() NullTime {
|
|
|
|
return params.before
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetBefore(before NullTime) error {
|
|
|
|
params.before = before
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
func (params *ListEnnoblementsParams) Sort() []EnnoblementSort {
|
|
|
|
return params.sort
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
2024-03-25 07:29:37 +00:00
|
|
|
ennoblementSortMinLength = 0
|
2024-01-11 06:13:28 +00:00
|
|
|
ennoblementSortMaxLength = 3
|
2024-01-04 10:44:36 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetSort(sort []EnnoblementSort) error {
|
2024-03-02 08:49:42 +00:00
|
|
|
if err := validateSort(sort, ennoblementSortMinLength, ennoblementSortMaxLength); err != nil {
|
2024-01-04 10:44:36 +00:00
|
|
|
return ValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "sort",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params.sort = sort
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-03-27 06:39:39 +00:00
|
|
|
func (params *ListEnnoblementsParams) PrependSort(sort []EnnoblementSort) error {
|
|
|
|
if len(sort) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := validateSliceLen(sort, 0, max(ennoblementSortMaxLength-len(params.sort), 0)); err != nil {
|
|
|
|
return ValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "sort",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return params.SetSort(append(sort, params.sort...))
|
|
|
|
}
|
|
|
|
|
2024-03-25 07:29:37 +00:00
|
|
|
func (params *ListEnnoblementsParams) PrependSortString(sort []string, allowed []EnnoblementSort, maxLength int) error {
|
|
|
|
if len(sort) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := validateSliceLen(sort, 0, max(min(ennoblementSortMaxLength-len(params.sort), maxLength), 0)); err != nil {
|
2024-03-11 09:05:29 +00:00
|
|
|
return ValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "sort",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
toPrepend := make([]EnnoblementSort, 0, len(sort))
|
|
|
|
|
|
|
|
for i, s := range sort {
|
2024-03-25 07:29:37 +00:00
|
|
|
converted, err := newSortFromString(s, allowed...)
|
2024-03-11 09:05:29 +00:00
|
|
|
if err != nil {
|
|
|
|
return SliceElementValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "sort",
|
|
|
|
Index: i,
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
toPrepend = append(toPrepend, converted)
|
|
|
|
}
|
|
|
|
|
|
|
|
return params.SetSort(append(toPrepend, params.sort...))
|
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
func (params *ListEnnoblementsParams) Cursor() EnnoblementCursor {
|
|
|
|
return params.cursor
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetCursor(cursor EnnoblementCursor) error {
|
|
|
|
params.cursor = cursor
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetEncodedCursor(encoded string) error {
|
|
|
|
decoded, err := decodeEnnoblementCursor(encoded)
|
|
|
|
if err != nil {
|
|
|
|
return ValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "cursor",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params.cursor = decoded
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-01-04 10:44:36 +00:00
|
|
|
func (params *ListEnnoblementsParams) Limit() int {
|
|
|
|
return params.limit
|
|
|
|
}
|
|
|
|
|
|
|
|
func (params *ListEnnoblementsParams) SetLimit(limit int) error {
|
|
|
|
if err := validateIntInRange(limit, 1, EnnoblementListMaxLimit); err != nil {
|
|
|
|
return ValidationError{
|
|
|
|
Model: listEnnoblementsParamsModelName,
|
|
|
|
Field: "limit",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
params.limit = limit
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
type ListEnnoblementsResult struct {
|
|
|
|
ennoblements Ennoblements
|
|
|
|
self EnnoblementCursor
|
|
|
|
next EnnoblementCursor
|
2024-01-04 10:44:36 +00:00
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
const listEnnoblementsResultModelName = "ListEnnoblementsResult"
|
|
|
|
|
|
|
|
func NewListEnnoblementsResult(ennoblements Ennoblements, next Ennoblement) (ListEnnoblementsResult, error) {
|
|
|
|
var err error
|
|
|
|
res := ListEnnoblementsResult{
|
|
|
|
ennoblements: ennoblements,
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(ennoblements) > 0 {
|
|
|
|
res.self, err = ennoblements[0].ToCursor()
|
|
|
|
if err != nil {
|
|
|
|
return ListEnnoblementsResult{}, ValidationError{
|
|
|
|
Model: listEnnoblementsResultModelName,
|
|
|
|
Field: "self",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !next.IsZero() {
|
|
|
|
res.next, err = next.ToCursor()
|
|
|
|
if err != nil {
|
|
|
|
return ListEnnoblementsResult{}, ValidationError{
|
|
|
|
Model: listEnnoblementsResultModelName,
|
|
|
|
Field: "next",
|
|
|
|
Err: err,
|
|
|
|
}
|
2024-01-04 10:44:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
return res, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (res ListEnnoblementsResult) Ennoblements() Ennoblements {
|
|
|
|
return res.ennoblements
|
|
|
|
}
|
2024-01-04 10:44:36 +00:00
|
|
|
|
2024-03-10 08:30:03 +00:00
|
|
|
func (res ListEnnoblementsResult) Self() EnnoblementCursor {
|
|
|
|
return res.self
|
|
|
|
}
|
|
|
|
|
|
|
|
func (res ListEnnoblementsResult) Next() EnnoblementCursor {
|
|
|
|
return res.next
|
2024-01-04 10:44:36 +00:00
|
|
|
}
|
2024-03-10 09:37:44 +00:00
|
|
|
|
|
|
|
type ListEnnoblementsWithRelationsResult struct {
|
|
|
|
ennoblements EnnoblementsWithRelations
|
|
|
|
self EnnoblementCursor
|
|
|
|
next EnnoblementCursor
|
|
|
|
}
|
|
|
|
|
|
|
|
const listEnnoblementsWithRelationsResultModelName = "ListEnnoblementsWithRelationsResult"
|
|
|
|
|
|
|
|
func NewListEnnoblementsWithRelationsResult(
|
|
|
|
ennoblements EnnoblementsWithRelations,
|
|
|
|
next EnnoblementWithRelations,
|
|
|
|
) (ListEnnoblementsWithRelationsResult, error) {
|
|
|
|
var err error
|
|
|
|
res := ListEnnoblementsWithRelationsResult{
|
|
|
|
ennoblements: ennoblements,
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(ennoblements) > 0 {
|
|
|
|
res.self, err = ennoblements[0].Ennoblement().ToCursor()
|
|
|
|
if err != nil {
|
|
|
|
return ListEnnoblementsWithRelationsResult{}, ValidationError{
|
|
|
|
Model: listEnnoblementsWithRelationsResultModelName,
|
|
|
|
Field: "self",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !next.IsZero() {
|
|
|
|
res.next, err = next.Ennoblement().ToCursor()
|
|
|
|
if err != nil {
|
|
|
|
return ListEnnoblementsWithRelationsResult{}, ValidationError{
|
|
|
|
Model: listEnnoblementsWithRelationsResultModelName,
|
|
|
|
Field: "next",
|
|
|
|
Err: err,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return res, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (res ListEnnoblementsWithRelationsResult) Ennoblements() EnnoblementsWithRelations {
|
|
|
|
return res.ennoblements
|
|
|
|
}
|
|
|
|
|
|
|
|
func (res ListEnnoblementsWithRelationsResult) Self() EnnoblementCursor {
|
|
|
|
return res.self
|
|
|
|
}
|
|
|
|
|
|
|
|
func (res ListEnnoblementsWithRelationsResult) Next() EnnoblementCursor {
|
|
|
|
return res.next
|
|
|
|
}
|