From 5cd6c33082cd38700479f06158276edc98223528 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dawid=20Wysoki=C5=84ski?= Date: Wed, 27 Mar 2024 07:39:39 +0100 Subject: [PATCH] feat: add PrependSort to models that need it --- internal/domain/ennoblement.go | 16 ++ internal/domain/ennoblement_test.go | 147 ++++++++++++++++++ internal/domain/player_snapshot.go | 16 ++ internal/domain/player_snapshot_test.go | 147 ++++++++++++++++++ internal/domain/tribe_change.go | 16 ++ internal/domain/tribe_change_test.go | 147 ++++++++++++++++++ internal/domain/tribe_snapshot.go | 16 ++ internal/domain/tribe_snapshot_test.go | 147 ++++++++++++++++++ internal/port/handler_http_api_ennoblement.go | 96 ++++++------ .../port/handler_http_api_player_snapshot.go | 24 +-- .../port/handler_http_api_tribe_change.go | 48 +++--- .../port/handler_http_api_tribe_snapshot.go | 24 +-- 12 files changed, 756 insertions(+), 88 deletions(-) diff --git a/internal/domain/ennoblement.go b/internal/domain/ennoblement.go index 9348d51..e493e0b 100644 --- a/internal/domain/ennoblement.go +++ b/internal/domain/ennoblement.go @@ -503,6 +503,22 @@ func (params *ListEnnoblementsParams) SetSort(sort []EnnoblementSort) error { return nil } +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...)) +} + func (params *ListEnnoblementsParams) PrependSortString(sort []string, allowed []EnnoblementSort, maxLength int) error { if len(sort) == 0 { return nil diff --git a/internal/domain/ennoblement_test.go b/internal/domain/ennoblement_test.go index f9918c6..a0fcdd6 100644 --- a/internal/domain/ennoblement_test.go +++ b/internal/domain/ennoblement_test.go @@ -500,6 +500,153 @@ func TestListEnnoblementsParams_SetSort(t *testing.T) { } } +func TestListEnnoblementsParams_PrependSort(t *testing.T) { + t.Parallel() + + defaultNewParams := func(t *testing.T) domain.ListEnnoblementsParams { + t.Helper() + return domain.ListEnnoblementsParams{} + } + + type args struct { + sort []domain.EnnoblementSort + } + + tests := []struct { + name string + newParams func(t *testing.T) domain.ListEnnoblementsParams + args args + expectedErr error + }{ + { + name: "OK", + args: args{ + sort: []domain.EnnoblementSort{ + domain.EnnoblementSortIDASC, + domain.EnnoblementSortServerKeyASC, + domain.EnnoblementSortCreatedAtASC, + }, + }, + }, + { + name: "OK: custom params", + newParams: func(t *testing.T) domain.ListEnnoblementsParams { + t.Helper() + params := domain.NewListEnnoblementsParams() + require.NoError(t, params.SetSort([]domain.EnnoblementSort{ + domain.EnnoblementSortIDASC, + domain.EnnoblementSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.EnnoblementSort{ + domain.EnnoblementSortCreatedAtASC, + }, + }, + }, + { + name: "OK: empty slice", + newParams: func(t *testing.T) domain.ListEnnoblementsParams { + t.Helper() + params := domain.NewListEnnoblementsParams() + require.NoError(t, params.SetSort([]domain.EnnoblementSort{ + domain.EnnoblementSortIDASC, + domain.EnnoblementSortServerKeyASC, + })) + return params + }, + args: args{ + sort: nil, + }, + }, + { + name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)", + newParams: func(t *testing.T) domain.ListEnnoblementsParams { + t.Helper() + params := domain.NewListEnnoblementsParams() + require.NoError(t, params.SetSort([]domain.EnnoblementSort{ + domain.EnnoblementSortIDASC, + domain.EnnoblementSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.EnnoblementSort{ + domain.EnnoblementSortCreatedAtASC, + domain.EnnoblementSortCreatedAtASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListEnnoblementsParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 1, + Current: 2, + }, + }, + }, + { + name: "ERR: len(sort) > 3", + newParams: defaultNewParams, + args: args{ + sort: []domain.EnnoblementSort{ + domain.EnnoblementSortCreatedAtASC, + domain.EnnoblementSortCreatedAtASC, + domain.EnnoblementSortCreatedAtASC, + domain.EnnoblementSortCreatedAtASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListEnnoblementsParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 3, + Current: 4, + }, + }, + }, + { + name: "ERR: conflict", + args: args{ + sort: []domain.EnnoblementSort{ + domain.EnnoblementSortCreatedAtASC, + domain.EnnoblementSortCreatedAtDESC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListEnnoblementsParams", + Field: "sort", + Err: domain.SortConflictError{ + Sort: [2]string{domain.EnnoblementSortCreatedAtASC.String(), domain.EnnoblementSortCreatedAtDESC.String()}, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + newParams := defaultNewParams + if tt.newParams != nil { + newParams = tt.newParams + } + params := newParams(t) + + expectedSort := params.Sort() + + require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr) + if tt.expectedErr != nil { + return + } + assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort()) + }) + } +} + func TestListEnnoblementsParams_PrependSortString(t *testing.T) { t.Parallel() diff --git a/internal/domain/player_snapshot.go b/internal/domain/player_snapshot.go index a872141..252de6a 100644 --- a/internal/domain/player_snapshot.go +++ b/internal/domain/player_snapshot.go @@ -449,6 +449,22 @@ func (params *ListPlayerSnapshotsParams) SetSort(sort []PlayerSnapshotSort) erro return nil } +func (params *ListPlayerSnapshotsParams) PrependSort(sort []PlayerSnapshotSort) error { + if len(sort) == 0 { + return nil + } + + if err := validateSliceLen(sort, 0, max(playerSnapshotSortMaxLength-len(params.sort), 0)); err != nil { + return ValidationError{ + Model: listPlayerSnapshotsParamsModelName, + Field: "sort", + Err: err, + } + } + + return params.SetSort(append(sort, params.sort...)) +} + func (params *ListPlayerSnapshotsParams) PrependSortString( sort []string, allowed []PlayerSnapshotSort, diff --git a/internal/domain/player_snapshot_test.go b/internal/domain/player_snapshot_test.go index 8df6f4a..489e2db 100644 --- a/internal/domain/player_snapshot_test.go +++ b/internal/domain/player_snapshot_test.go @@ -385,6 +385,153 @@ func TestListPlayerSnapshotsParams_SetSort(t *testing.T) { } } +func TestListPlayerSnapshotsParams_PrependSort(t *testing.T) { + t.Parallel() + + defaultNewParams := func(t *testing.T) domain.ListPlayerSnapshotsParams { + t.Helper() + return domain.ListPlayerSnapshotsParams{} + } + + type args struct { + sort []domain.PlayerSnapshotSort + } + + tests := []struct { + name string + newParams func(t *testing.T) domain.ListPlayerSnapshotsParams + args args + expectedErr error + }{ + { + name: "OK", + args: args{ + sort: []domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortIDASC, + domain.PlayerSnapshotSortServerKeyASC, + domain.PlayerSnapshotSortDateASC, + }, + }, + }, + { + name: "OK: custom params", + newParams: func(t *testing.T) domain.ListPlayerSnapshotsParams { + t.Helper() + params := domain.NewListPlayerSnapshotsParams() + require.NoError(t, params.SetSort([]domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortIDASC, + domain.PlayerSnapshotSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortDateASC, + }, + }, + }, + { + name: "OK: empty slice", + newParams: func(t *testing.T) domain.ListPlayerSnapshotsParams { + t.Helper() + params := domain.NewListPlayerSnapshotsParams() + require.NoError(t, params.SetSort([]domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortIDASC, + domain.PlayerSnapshotSortServerKeyASC, + })) + return params + }, + args: args{ + sort: nil, + }, + }, + { + name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)", + newParams: func(t *testing.T) domain.ListPlayerSnapshotsParams { + t.Helper() + params := domain.NewListPlayerSnapshotsParams() + require.NoError(t, params.SetSort([]domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortIDASC, + domain.PlayerSnapshotSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortDateASC, + domain.PlayerSnapshotSortDateASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListPlayerSnapshotsParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 1, + Current: 2, + }, + }, + }, + { + name: "ERR: len(sort) > 3", + newParams: defaultNewParams, + args: args{ + sort: []domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortDateASC, + domain.PlayerSnapshotSortDateASC, + domain.PlayerSnapshotSortDateASC, + domain.PlayerSnapshotSortDateASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListPlayerSnapshotsParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 3, + Current: 4, + }, + }, + }, + { + name: "ERR: conflict", + args: args{ + sort: []domain.PlayerSnapshotSort{ + domain.PlayerSnapshotSortDateASC, + domain.PlayerSnapshotSortDateDESC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListPlayerSnapshotsParams", + Field: "sort", + Err: domain.SortConflictError{ + Sort: [2]string{domain.PlayerSnapshotSortDateASC.String(), domain.PlayerSnapshotSortDateDESC.String()}, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + newParams := defaultNewParams + if tt.newParams != nil { + newParams = tt.newParams + } + params := newParams(t) + + expectedSort := params.Sort() + + require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr) + if tt.expectedErr != nil { + return + } + assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort()) + }) + } +} + func TestListPlayerSnapshotsParams_PrependSortString(t *testing.T) { t.Parallel() diff --git a/internal/domain/tribe_change.go b/internal/domain/tribe_change.go index c9b432a..3edfd5a 100644 --- a/internal/domain/tribe_change.go +++ b/internal/domain/tribe_change.go @@ -555,6 +555,22 @@ func (params *ListTribeChangesParams) SetLimit(limit int) error { return nil } +func (params *ListTribeChangesParams) PrependSort(sort []TribeChangeSort) error { + if len(sort) == 0 { + return nil + } + + if err := validateSliceLen(sort, 0, max(tribeChangeSortMaxLength-len(params.sort), 0)); err != nil { + return ValidationError{ + Model: listTribeChangesParamsModelName, + Field: "sort", + Err: err, + } + } + + return params.SetSort(append(sort, params.sort...)) +} + func (params *ListTribeChangesParams) PrependSortString( sort []string, allowed []TribeChangeSort, diff --git a/internal/domain/tribe_change_test.go b/internal/domain/tribe_change_test.go index b01cc07..2fbe619 100644 --- a/internal/domain/tribe_change_test.go +++ b/internal/domain/tribe_change_test.go @@ -616,6 +616,153 @@ func TestListTribeChangesParams_SetSort(t *testing.T) { } } +func TestListTribeChangesParams_PrependSort(t *testing.T) { + t.Parallel() + + defaultNewParams := func(t *testing.T) domain.ListTribeChangesParams { + t.Helper() + return domain.ListTribeChangesParams{} + } + + type args struct { + sort []domain.TribeChangeSort + } + + tests := []struct { + name string + newParams func(t *testing.T) domain.ListTribeChangesParams + args args + expectedErr error + }{ + { + name: "OK", + args: args{ + sort: []domain.TribeChangeSort{ + domain.TribeChangeSortIDASC, + domain.TribeChangeSortServerKeyASC, + domain.TribeChangeSortCreatedAtASC, + }, + }, + }, + { + name: "OK: custom params", + newParams: func(t *testing.T) domain.ListTribeChangesParams { + t.Helper() + params := domain.NewListTribeChangesParams() + require.NoError(t, params.SetSort([]domain.TribeChangeSort{ + domain.TribeChangeSortIDASC, + domain.TribeChangeSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.TribeChangeSort{ + domain.TribeChangeSortCreatedAtASC, + }, + }, + }, + { + name: "OK: empty slice", + newParams: func(t *testing.T) domain.ListTribeChangesParams { + t.Helper() + params := domain.NewListTribeChangesParams() + require.NoError(t, params.SetSort([]domain.TribeChangeSort{ + domain.TribeChangeSortIDASC, + domain.TribeChangeSortServerKeyASC, + })) + return params + }, + args: args{ + sort: nil, + }, + }, + { + name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)", + newParams: func(t *testing.T) domain.ListTribeChangesParams { + t.Helper() + params := domain.NewListTribeChangesParams() + require.NoError(t, params.SetSort([]domain.TribeChangeSort{ + domain.TribeChangeSortIDASC, + domain.TribeChangeSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.TribeChangeSort{ + domain.TribeChangeSortCreatedAtASC, + domain.TribeChangeSortCreatedAtASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListTribeChangesParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 1, + Current: 2, + }, + }, + }, + { + name: "ERR: len(sort) > 3", + newParams: defaultNewParams, + args: args{ + sort: []domain.TribeChangeSort{ + domain.TribeChangeSortCreatedAtASC, + domain.TribeChangeSortCreatedAtASC, + domain.TribeChangeSortCreatedAtASC, + domain.TribeChangeSortCreatedAtASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListTribeChangesParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 3, + Current: 4, + }, + }, + }, + { + name: "ERR: conflict", + args: args{ + sort: []domain.TribeChangeSort{ + domain.TribeChangeSortCreatedAtASC, + domain.TribeChangeSortCreatedAtDESC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListTribeChangesParams", + Field: "sort", + Err: domain.SortConflictError{ + Sort: [2]string{domain.TribeChangeSortCreatedAtASC.String(), domain.TribeChangeSortCreatedAtDESC.String()}, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + newParams := defaultNewParams + if tt.newParams != nil { + newParams = tt.newParams + } + params := newParams(t) + + expectedSort := params.Sort() + + require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr) + if tt.expectedErr != nil { + return + } + assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort()) + }) + } +} + func TestListTribeChangesParams_PrependSortString(t *testing.T) { t.Parallel() diff --git a/internal/domain/tribe_snapshot.go b/internal/domain/tribe_snapshot.go index 3c83db1..ad9b471 100644 --- a/internal/domain/tribe_snapshot.go +++ b/internal/domain/tribe_snapshot.go @@ -469,6 +469,22 @@ func (params *ListTribeSnapshotsParams) SetSort(sort []TribeSnapshotSort) error return nil } +func (params *ListTribeSnapshotsParams) PrependSort(sort []TribeSnapshotSort) error { + if len(sort) == 0 { + return nil + } + + if err := validateSliceLen(sort, 0, max(tribeSnapshotSortMaxLength-len(params.sort), 0)); err != nil { + return ValidationError{ + Model: listTribeSnapshotsParamsModelName, + Field: "sort", + Err: err, + } + } + + return params.SetSort(append(sort, params.sort...)) +} + func (params *ListTribeSnapshotsParams) PrependSortString( sort []string, allowed []TribeSnapshotSort, diff --git a/internal/domain/tribe_snapshot_test.go b/internal/domain/tribe_snapshot_test.go index 92dc3a3..c539afe 100644 --- a/internal/domain/tribe_snapshot_test.go +++ b/internal/domain/tribe_snapshot_test.go @@ -387,6 +387,153 @@ func TestListTribeSnapshotsParams_SetSort(t *testing.T) { } } +func TestListTribeSnapshotsParams_PrependSort(t *testing.T) { + t.Parallel() + + defaultNewParams := func(t *testing.T) domain.ListTribeSnapshotsParams { + t.Helper() + return domain.ListTribeSnapshotsParams{} + } + + type args struct { + sort []domain.TribeSnapshotSort + } + + tests := []struct { + name string + newParams func(t *testing.T) domain.ListTribeSnapshotsParams + args args + expectedErr error + }{ + { + name: "OK", + args: args{ + sort: []domain.TribeSnapshotSort{ + domain.TribeSnapshotSortIDASC, + domain.TribeSnapshotSortServerKeyASC, + domain.TribeSnapshotSortDateASC, + }, + }, + }, + { + name: "OK: custom params", + newParams: func(t *testing.T) domain.ListTribeSnapshotsParams { + t.Helper() + params := domain.NewListTribeSnapshotsParams() + require.NoError(t, params.SetSort([]domain.TribeSnapshotSort{ + domain.TribeSnapshotSortIDASC, + domain.TribeSnapshotSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.TribeSnapshotSort{ + domain.TribeSnapshotSortDateASC, + }, + }, + }, + { + name: "OK: empty slice", + newParams: func(t *testing.T) domain.ListTribeSnapshotsParams { + t.Helper() + params := domain.NewListTribeSnapshotsParams() + require.NoError(t, params.SetSort([]domain.TribeSnapshotSort{ + domain.TribeSnapshotSortIDASC, + domain.TribeSnapshotSortServerKeyASC, + })) + return params + }, + args: args{ + sort: nil, + }, + }, + { + name: "ERR: custom params + len(sort) > sortMaxLength - len(sort)", + newParams: func(t *testing.T) domain.ListTribeSnapshotsParams { + t.Helper() + params := domain.NewListTribeSnapshotsParams() + require.NoError(t, params.SetSort([]domain.TribeSnapshotSort{ + domain.TribeSnapshotSortIDASC, + domain.TribeSnapshotSortServerKeyASC, + })) + return params + }, + args: args{ + sort: []domain.TribeSnapshotSort{ + domain.TribeSnapshotSortDateASC, + domain.TribeSnapshotSortDateASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListTribeSnapshotsParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 1, + Current: 2, + }, + }, + }, + { + name: "ERR: len(sort) > 3", + newParams: defaultNewParams, + args: args{ + sort: []domain.TribeSnapshotSort{ + domain.TribeSnapshotSortDateASC, + domain.TribeSnapshotSortDateASC, + domain.TribeSnapshotSortDateASC, + domain.TribeSnapshotSortDateASC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListTribeSnapshotsParams", + Field: "sort", + Err: domain.LenOutOfRangeError{ + Min: 0, + Max: 3, + Current: 4, + }, + }, + }, + { + name: "ERR: conflict", + args: args{ + sort: []domain.TribeSnapshotSort{ + domain.TribeSnapshotSortDateASC, + domain.TribeSnapshotSortDateDESC, + }, + }, + expectedErr: domain.ValidationError{ + Model: "ListTribeSnapshotsParams", + Field: "sort", + Err: domain.SortConflictError{ + Sort: [2]string{domain.TribeSnapshotSortDateASC.String(), domain.TribeSnapshotSortDateDESC.String()}, + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + newParams := defaultNewParams + if tt.newParams != nil { + newParams = tt.newParams + } + params := newParams(t) + + expectedSort := params.Sort() + + require.ErrorIs(t, params.PrependSort(tt.args.sort), tt.expectedErr) + if tt.expectedErr != nil { + return + } + assert.Equal(t, append(tt.args.sort, expectedSort...), params.Sort()) + }) + } +} + func TestListTribeSnapshotsParams_PrependSortString(t *testing.T) { t.Parallel() diff --git a/internal/port/handler_http_api_ennoblement.go b/internal/port/handler_http_api_ennoblement.go index b82f500..842cafe 100644 --- a/internal/port/handler_http_api_ennoblement.go +++ b/internal/port/handler_http_api_ennoblement.go @@ -30,18 +30,20 @@ func (h *apiHTTPHandler) ListEnnoblements( return } - sort := []string{domain.EnnoblementSortCreatedAtASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiEnnoblementSortAllowedValues, - apiEnnoblementSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiEnnoblementSortAllowedValues, + apiEnnoblementSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { @@ -113,18 +115,20 @@ func (h *apiHTTPHandler) ListPlayerEnnoblements( return } - sort := []string{domain.EnnoblementSortCreatedAtASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiEnnoblementSortAllowedValues, - apiEnnoblementSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiEnnoblementSortAllowedValues, + apiEnnoblementSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { @@ -196,18 +200,20 @@ func (h *apiHTTPHandler) ListTribeEnnoblements( return } - sort := []string{domain.EnnoblementSortCreatedAtASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiEnnoblementSortAllowedValues, - apiEnnoblementSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiEnnoblementSortAllowedValues, + apiEnnoblementSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { @@ -279,18 +285,20 @@ func (h *apiHTTPHandler) ListVillageEnnoblements( return } - sort := []string{domain.EnnoblementSortCreatedAtASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiEnnoblementSortAllowedValues, - apiEnnoblementSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiEnnoblementSortAllowedValues, + apiEnnoblementSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.EnnoblementSort{domain.EnnoblementSortCreatedAtASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListEnnoblementsErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { diff --git a/internal/port/handler_http_api_player_snapshot.go b/internal/port/handler_http_api_player_snapshot.go index 1871609..4816645 100644 --- a/internal/port/handler_http_api_player_snapshot.go +++ b/internal/port/handler_http_api_player_snapshot.go @@ -36,18 +36,20 @@ func (h *apiHTTPHandler) ListPlayerPlayerSnapshots( return } - sort := []string{domain.PlayerSnapshotSortDateASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiPlayerSnapshotSortAllowedValues, - apiPlayerSnapshotSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListPlayerSnapshotsErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiPlayerSnapshotSortAllowedValues, + apiPlayerSnapshotSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListPlayerSnapshotsErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.PlayerSnapshotSort{domain.PlayerSnapshotSortDateASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListPlayerSnapshotsErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { diff --git a/internal/port/handler_http_api_tribe_change.go b/internal/port/handler_http_api_tribe_change.go index 543d142..3c7c4ce 100644 --- a/internal/port/handler_http_api_tribe_change.go +++ b/internal/port/handler_http_api_tribe_change.go @@ -36,18 +36,20 @@ func (h *apiHTTPHandler) ListPlayerTribeChanges( return } - sort := []string{domain.TribeChangeSortCreatedAtASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiTribeChangeSortAllowedValues, - apiTribeChangeSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiTribeChangeSortAllowedValues, + apiTribeChangeSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.TribeChangeSort{domain.TribeChangeSortCreatedAtASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { @@ -119,18 +121,20 @@ func (h *apiHTTPHandler) ListTribeMemberChanges( return } - sort := []string{domain.TribeChangeSortCreatedAtASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiTribeChangeSortAllowedValues, - apiTribeChangeSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiTribeChangeSortAllowedValues, + apiTribeChangeSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.TribeChangeSort{domain.TribeChangeSortCreatedAtASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListTribeChangesErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil { diff --git a/internal/port/handler_http_api_tribe_snapshot.go b/internal/port/handler_http_api_tribe_snapshot.go index 412ea7c..a9aac59 100644 --- a/internal/port/handler_http_api_tribe_snapshot.go +++ b/internal/port/handler_http_api_tribe_snapshot.go @@ -36,18 +36,20 @@ func (h *apiHTTPHandler) ListTribeTribeSnapshots( return } - sort := []string{domain.TribeSnapshotSortDateASC.String()} if params.Sort != nil { - sort = *params.Sort - } - - if err := domainParams.PrependSortString( - sort, - apiTribeSnapshotSortAllowedValues, - apiTribeSnapshotSortMaxLength, - ); err != nil { - h.errorRenderer.withErrorPathFormatter(formatListTribeSnapshotsErrorPath).render(w, r, err) - return + if err := domainParams.PrependSortString( + *params.Sort, + apiTribeSnapshotSortAllowedValues, + apiTribeSnapshotSortMaxLength, + ); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListTribeSnapshotsErrorPath).render(w, r, err) + return + } + } else { + if err := domainParams.PrependSort([]domain.TribeSnapshotSort{domain.TribeSnapshotSortDateASC}); err != nil { + h.errorRenderer.withErrorPathFormatter(formatListTribeSnapshotsErrorPath).render(w, r, err) + return + } } if err := domainParams.SetServerKeys([]string{serverKey}); err != nil {