twhelp
/
dcbot
1
0
Fork 0
Code Issues 1 Pull Requests 4 Packages Projects Releases Wiki Activity

refactor: move service.ennoblementNotificationBuilder logic to domain models
continuous-integration/drone/push Build is passing Details

This commit is contained in:
Dawid Wysokiński 2023-07-09 07:44:35 +02:00
parent f9dfe1c998
commit 79f19b7a23
Signed by: Kichiyaki
GPG Key ID: B5445E357FB8B892
8 changed files with 1042 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
internal/domain/ennoblement_notification.go
View File

@ -14,3 +14,31 @@ type EnnoblementNotification struct {
LanguageTag string
Ennoblement Ennoblement
}
func NewEnnoblementNotifications(g GroupWithMonitors, ennoblements []Ennoblement) []EnnoblementNotification {
var notifications []EnnoblementNotification
for _, e := range ennoblements {
if g.CanSendEnnoblementNotificationTypeGain(e) {
notifications = append(notifications, EnnoblementNotification{
Type: EnnoblementNotificationTypeGain,
ServerID: g.ServerID,
ChannelID: g.ChannelGains,
LanguageTag: g.LanguageTag,
Ennoblement: e,
})
}
if g.CanSendEnnoblementNotificationTypeLoss(e) {
notifications = append(notifications, EnnoblementNotification{
Type: EnnoblementNotificationTypeLoss,
ServerID: g.ServerID,
ChannelID: g.ChannelLosses,
LanguageTag: g.LanguageTag,
Ennoblement: e,
})
}
}
return notifications
}

172
internal/domain/ennoblement_notification_test.go Normal file
View File

@ -0,0 +1,172 @@
package domain_test
import (
"strconv"
"testing"
"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
)
func TestNewEnnoblementNotifications(t *testing.T) {
t.Parallel()
tests := []struct {
group domain.GroupWithMonitors
ennoblements []domain.Ennoblement
gainIndexes []int
lossIndexes []int
}{
{
group: domain.GroupWithMonitors{
Group: domain.Group{
ChannelGains: uuid.NewString(),
ChannelLosses: uuid.NewString(),
},
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
},
ennoblements: []domain.Ennoblement{
{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
},
{ // Barbarians == false
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
{ // Internals == false
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 125,
},
Valid: true,
},
},
Valid: true,
},
},
},
{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 153,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
},
},
gainIndexes: []int{0},
lossIndexes: []int{3},
},
}
for i := range tests {
tt := tests[i]
t.Run(strconv.Itoa(i), func(t *testing.T) {
t.Parallel()
notifications := domain.NewEnnoblementNotifications(tt.group, tt.ennoblements)
assert.Len(t, notifications, len(tt.gainIndexes)+len(tt.lossIndexes))
for _, idx := range tt.gainIndexes {
assert.Contains(t, notifications, domain.EnnoblementNotification{
Type: domain.EnnoblementNotificationTypeGain,
ServerID: tt.group.ServerID,
ChannelID: tt.group.ChannelGains,
LanguageTag: tt.group.LanguageTag,
Ennoblement: tt.ennoblements[idx],
})
}
for _, idx := range tt.lossIndexes {
assert.Contains(t, notifications, domain.EnnoblementNotification{
Type: domain.EnnoblementNotificationTypeLoss,
ServerID: tt.group.ServerID,
ChannelID: tt.group.ChannelLosses,
LanguageTag: tt.group.LanguageTag,
Ennoblement: tt.ennoblements[idx],
})
}
})
}
}

62
internal/domain/group.go
View File

@ -24,6 +24,68 @@ type GroupWithMonitors struct {
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

681
internal/domain/group_test.go
View File

@ -4,10 +4,691 @@ import (
"testing"
"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
"golang.org/x/text/language"
)
func TestGroupWithMonitors_CanSendEnnoblementNotificationTypeGain(t *testing.T) {
t.Parallel()
assert.True(t, domain.GroupWithMonitors{
Group: domain.Group{
ChannelGains: uuid.NewString(),
},
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{ // ChannelGains == ""
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.True(t, domain.GroupWithMonitors{ // Barbarians=true
Group: domain.Group{
ChannelGains: uuid.NewString(),
Barbarians: true,
},
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
}))
assert.False(t, domain.GroupWithMonitors{ // Barbarians=false
Group: domain.Group{
ChannelGains: uuid.NewString(),
},
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
}))
assert.True(t, domain.GroupWithMonitors{ // Internals=true
Group: domain.Group{
ChannelGains: uuid.NewString(),
Internals: true,
},
Monitors: []domain.Monitor{
{
TribeID: 151,
},
{
TribeID: 150,
},
},
}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{ // Internals=false
Group: domain.Group{
ChannelGains: uuid.NewString(),
},
Monitors: []domain.Monitor{
{
TribeID: 151,
},
{
TribeID: 150,
},
},
}.CanSendEnnoblementNotificationTypeGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
}
func TestGroupWithMonitors_CanSendEnnoblementNotificationTypeLoss(t *testing.T) {
t.Parallel()
assert.True(t, domain.GroupWithMonitors{
Group: domain.Group{
ChannelLosses: uuid.NewString(),
},
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 151,
},
},
}.CanSendEnnoblementNotificationTypeLoss(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{ // ChannelLosses == ""
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 151,
},
},
}.CanSendEnnoblementNotificationTypeLoss(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{ // Internal
Group: domain.Group{
ChannelLosses: uuid.NewString(),
},
Monitors: []domain.Monitor{
{
TribeID: 150,
},
{
TribeID: 151,
},
},
}.CanSendEnnoblementNotificationTypeLoss(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 130,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 151,
},
Valid: true,
},
},
Valid: true,
},
},
}))
}
func TestGroupWithMonitors_IsGain(t *testing.T) {
t.Parallel()
assert.True(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
}))
assert.False(t, domain.GroupWithMonitors{ // self conquer
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 151,
},
},
}.IsGain(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
}))
assert.False(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 151,
},
},
}.IsGain(domain.Ennoblement{}))
}
func TestGroupWithMonitors_IsLoss(t *testing.T) {
t.Parallel()
assert.True(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsLoss(domain.Ennoblement{
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{ // self conquer
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsLoss(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 151,
},
},
}.IsLoss(domain.Ennoblement{
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 151,
},
},
}.IsLoss(domain.Ennoblement{}))
}
func TestGroupWithMonitors_IsInternal(t *testing.T) {
t.Parallel()
assert.True(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsInternal(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 125,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.True(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsInternal(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
}))
assert.False(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsInternal(domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
}))
assert.False(t, domain.GroupWithMonitors{
Monitors: []domain.Monitor{
{
TribeID: 125,
},
{
TribeID: 150,
},
},
}.IsInternal(domain.Ennoblement{
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
Tribe: domain.NullTribeMeta{
Tribe: domain.TribeMeta{
ID: 150,
},
Valid: true,
},
},
Valid: true,
},
},
}))
}
func TestNewCreateGroupParams(t *testing.T) {
t.Parallel()

8
internal/domain/tw.go
View File

@ -74,6 +74,14 @@ type Ennoblement struct {
CreatedAt time.Time
}
func (e Ennoblement) IsBarbarian() bool {
return !e.Village.Player.Valid
}
func (e Ennoblement) IsSelfConquer() bool {
return e.NewOwner.Player.ID == e.Village.Player.Player.ID
}
type TWServerNotFoundError struct {
VersionCode string
Key string

85
internal/domain/tw_test.go Normal file
View File

@ -0,0 +1,85 @@
package domain_test
import (
"testing"
"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
"github.com/stretchr/testify/assert"
)
func TestEnnoblement_IsBarbarian(t *testing.T) {
t.Parallel()
assert.True(t, domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 123,
},
Valid: true,
},
}.IsBarbarian())
assert.False(t, domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 123,
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
},
Valid: true,
},
},
}.IsBarbarian())
}
func TestEnnoblement_IsSelfConquer(t *testing.T) {
t.Parallel()
assert.True(t, domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 123,
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 123,
},
Valid: true,
},
},
}.IsSelfConquer())
assert.False(t, domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 123,
},
Valid: true,
},
}.IsSelfConquer())
assert.False(t, domain.Ennoblement{
NewOwner: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 123,
},
Valid: true,
},
Village: domain.VillageMeta{
Player: domain.NullPlayerMeta{
Player: domain.PlayerMeta{
ID: 125,
},
Valid: true,
},
},
}.IsSelfConquer())
}

113
internal/service/ennoblement_notification_builder.go
View File

@ -1,113 +0,0 @@
package service
import (
"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
)
type ennoblementNotificationBuilder struct {
groups []domain.GroupWithMonitors
ennoblements listEnnoblementsResult
}
func (b ennoblementNotificationBuilder) build() []domain.EnnoblementNotification {
var notifications []domain.EnnoblementNotification
for _, g := range b.groups {
notifications = append(notifications, b.buildGroup(g)...)
}
return notifications
}
func (b ennoblementNotificationBuilder) buildGroup(g domain.GroupWithMonitors) []domain.EnnoblementNotification {
var notifications []domain.EnnoblementNotification
for _, e := range b.ennoblements.find(g.VersionCode, g.ServerKey) {
if b.canSendEnnoblementNotificationTypeGain(g, e) {
notifications = append(notifications, domain.EnnoblementNotification{
Type: domain.EnnoblementNotificationTypeGain,
ServerID: g.ServerID,
ChannelID: g.ChannelGains,
LanguageTag: g.LanguageTag,
Ennoblement: e,
})
}
if b.canSendEnnoblementNotificationTypeLoss(g, e) {
notifications = append(notifications, domain.EnnoblementNotification{
Type: domain.EnnoblementNotificationTypeLoss,
ServerID: g.ServerID,
ChannelID: g.ChannelLosses,
LanguageTag: g.LanguageTag,
Ennoblement: e,
})
}
}
return notifications
}
func (b ennoblementNotificationBuilder) canSendEnnoblementNotificationTypeGain(g domain.GroupWithMonitors, e domain.Ennoblement) bool {
if g.ChannelGains == "" {
return false
}
if !g.Barbarians && b.isBarbarian(e) {
return false
}
if !g.Internals && b.isInternal(e, g.Monitors) {
return false
}
return b.isGain(e, g.Monitors)
}
func (b ennoblementNotificationBuilder) canSendEnnoblementNotificationTypeLoss(g domain.GroupWithMonitors, e domain.Ennoblement) bool {
if g.ChannelLosses == "" {
return false
}
if b.isInternal(e, g.Monitors) {
return false
}
return b.isLoss(e, g.Monitors)
}
func (b ennoblementNotificationBuilder) isInternal(e domain.Ennoblement, monitors []domain.Monitor) bool {
var n, o bool
for _, m := range 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 (b ennoblementNotificationBuilder) isBarbarian(e domain.Ennoblement) bool {
return !e.Village.Player.Valid
}
func (b ennoblementNotificationBuilder) isGain(e domain.Ennoblement, monitors []domain.Monitor) bool {
var n bool
for _, m := range monitors {
if m.TribeID == e.NewOwner.Player.Tribe.Tribe.ID {
n = true
break
}
}
return n && e.NewOwner.Player.ID != e.Village.Player.Player.ID
}
func (b ennoblementNotificationBuilder) isLoss(e domain.Ennoblement, monitors []domain.Monitor) bool {
var o bool
for _, m := range monitors {
if m.TribeID == e.Village.Player.Player.Tribe.Tribe.ID {
o = true
break
}
}
return o && e.NewOwner.Player.ID != e.Village.Player.Player.ID
}

10
internal/service/group.go
View File

@ -319,10 +319,12 @@ func (g *Group) Execute(ctx context.Context) ([]domain.EnnoblementNotification,
return nil, err
}
return ennoblementNotificationBuilder{
groups: groups,
ennoblements: res,
}.build(), nil
var notifications []domain.EnnoblementNotification
for _, group := range groups {
notifications = append(notifications, domain.NewEnnoblementNotifications(group, res.find(group.VersionCode, group.ServerKey))...)
}
return notifications, nil
}
type listEnnoblementsSingleResult struct {