Dawid Wysokiński
f9dfe1c998
All checks were successful
continuous-integration/drone/push Build is passing
273 lines
6.9 KiB
Go
273 lines
6.9 KiB
Go
package adapter
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
|
|
"gitea.dwysokinski.me/twhelp/dcbot/internal/twhelp"
|
|
)
|
|
|
|
type TWHelpHTTP struct {
|
|
client *twhelp.Client
|
|
}
|
|
|
|
func NewTWHelpHTTP(client *twhelp.Client) *TWHelpHTTP {
|
|
return &TWHelpHTTP{client: client}
|
|
}
|
|
|
|
func (t *TWHelpHTTP) ListVersions(ctx context.Context) ([]domain.TWVersion, error) {
|
|
versions, err := t.client.ListVersions(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := make([]domain.TWVersion, 0, len(versions))
|
|
for _, v := range versions {
|
|
res = append(res, t.convertVersionToDomain(v))
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) ListOpenServers(ctx context.Context, version string, offset, limit int32) ([]domain.TWServer, error) {
|
|
return t.listServers(ctx, version, twhelp.ListServersQueryParams{
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Open: twhelp.NullBool{
|
|
Bool: true,
|
|
Valid: true,
|
|
},
|
|
})
|
|
}
|
|
|
|
func (t *TWHelpHTTP) ListClosedServers(ctx context.Context, version string, offset, limit int32) ([]domain.TWServer, error) {
|
|
return t.listServers(ctx, version, twhelp.ListServersQueryParams{
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Open: twhelp.NullBool{
|
|
Bool: false,
|
|
Valid: true,
|
|
},
|
|
})
|
|
}
|
|
|
|
func (t *TWHelpHTTP) listServers(ctx context.Context, version string, params twhelp.ListServersQueryParams) ([]domain.TWServer, error) {
|
|
servers, err := t.client.ListServers(ctx, version, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := make([]domain.TWServer, 0, len(servers))
|
|
for _, s := range servers {
|
|
res = append(res, t.convertServerToDomain(s))
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) GetOpenServer(ctx context.Context, versionCode, serverKey string) (domain.TWServer, error) {
|
|
server, err := t.client.GetServer(ctx, versionCode, serverKey)
|
|
if err != nil {
|
|
var apiErr twhelp.APIError
|
|
if !errors.As(err, &apiErr) || apiErr.Code != twhelp.ErrorCodeEntityNotFound {
|
|
return domain.TWServer{}, err
|
|
}
|
|
return domain.TWServer{}, domain.TWServerNotFoundError{
|
|
VersionCode: versionCode,
|
|
Key: serverKey,
|
|
}
|
|
}
|
|
if !server.Open {
|
|
return domain.TWServer{}, domain.TWServerNotFoundError{
|
|
VersionCode: versionCode,
|
|
Key: serverKey,
|
|
}
|
|
}
|
|
return t.convertServerToDomain(server), nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) GetTribeByID(ctx context.Context, versionCode, serverKey string, id int64) (domain.Tribe, error) {
|
|
tribe, err := t.client.GetTribeByID(ctx, versionCode, serverKey, id)
|
|
if err != nil {
|
|
var apiErr twhelp.APIError
|
|
if !errors.As(err, &apiErr) || apiErr.Code != twhelp.ErrorCodeEntityNotFound {
|
|
return domain.Tribe{}, err
|
|
}
|
|
return domain.Tribe{}, domain.TribeIDNotFoundError{
|
|
VersionCode: versionCode,
|
|
ServerKey: serverKey,
|
|
ID: id,
|
|
}
|
|
}
|
|
return t.convertTribeToDomain(tribe), nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) GetExistingTribeByTag(ctx context.Context, versionCode, serverKey, tribeTag string) (domain.Tribe, error) {
|
|
tribes, err := t.client.ListTribes(ctx, versionCode, serverKey, twhelp.ListTribesQueryParams{
|
|
Limit: 1,
|
|
Tags: []string{tribeTag},
|
|
Deleted: twhelp.NullBool{
|
|
Valid: true,
|
|
Bool: false,
|
|
},
|
|
})
|
|
if err != nil {
|
|
return domain.Tribe{}, err
|
|
}
|
|
if len(tribes) == 0 {
|
|
return domain.Tribe{}, domain.TribeTagNotFoundError{
|
|
VersionCode: versionCode,
|
|
ServerKey: serverKey,
|
|
Tag: tribeTag,
|
|
}
|
|
}
|
|
return t.convertTribeToDomain(tribes[0]), nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) ListTribesByTag(
|
|
ctx context.Context,
|
|
versionCode, serverKey string,
|
|
tribeTags []string,
|
|
offset, limit int32,
|
|
) ([]domain.Tribe, error) {
|
|
tribes, err := t.client.ListTribes(ctx, versionCode, serverKey, twhelp.ListTribesQueryParams{
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Tags: tribeTags,
|
|
Deleted: twhelp.NullBool{
|
|
Valid: true,
|
|
Bool: false,
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := make([]domain.Tribe, 0, len(tribes))
|
|
for _, tr := range tribes {
|
|
res = append(res, t.convertTribeToDomain(tr))
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) ListVillagesByCoords(
|
|
ctx context.Context,
|
|
versionCode, serverKey string,
|
|
coords []string,
|
|
offset, limit int32,
|
|
) ([]domain.Village, error) {
|
|
villages, err := t.client.ListVillages(ctx, versionCode, serverKey, twhelp.ListVillagesQueryParams{
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Coords: coords,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := make([]domain.Village, 0, len(villages))
|
|
for _, v := range villages {
|
|
res = append(res, t.convertVillageToDomain(v))
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) ListEnnoblementsSince(
|
|
ctx context.Context,
|
|
versionCode, serverKey string,
|
|
since time.Time,
|
|
offset, limit int32,
|
|
) ([]domain.Ennoblement, error) {
|
|
ennoblements, err := t.client.ListEnnoblements(ctx, versionCode, serverKey, twhelp.ListEnnoblementsQueryParams{
|
|
Limit: limit,
|
|
Offset: offset,
|
|
Since: since,
|
|
Sort: []twhelp.EnnoblementSort{
|
|
twhelp.EnnoblementSortCreatedAtASC,
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := make([]domain.Ennoblement, 0, len(ennoblements))
|
|
for _, e := range ennoblements {
|
|
res = append(res, t.convertEnnoblementToDomain(e))
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertVersionToDomain(v twhelp.Version) domain.TWVersion {
|
|
return domain.TWVersion(v)
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertServerToDomain(s twhelp.Server) domain.TWServer {
|
|
return domain.TWServer(s)
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertTribeToDomain(tr twhelp.Tribe) domain.Tribe {
|
|
return domain.Tribe(tr)
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertTribeMetaToDomain(tr twhelp.TribeMeta) domain.TribeMeta {
|
|
return domain.TribeMeta(tr)
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertNullTribeMetaToDomain(tr twhelp.NullTribeMeta) domain.NullTribeMeta {
|
|
return domain.NullTribeMeta{
|
|
Tribe: t.convertTribeMetaToDomain(tr.Tribe),
|
|
Valid: tr.Valid,
|
|
}
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertPlayerMetaToDomain(p twhelp.PlayerMeta) domain.PlayerMeta {
|
|
return domain.PlayerMeta{
|
|
ID: p.ID,
|
|
Name: p.Name,
|
|
ProfileURL: p.ProfileURL,
|
|
Tribe: t.convertNullTribeMetaToDomain(p.Tribe),
|
|
}
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertNullPlayerMetaToDomain(p twhelp.NullPlayerMeta) domain.NullPlayerMeta {
|
|
return domain.NullPlayerMeta{
|
|
Player: t.convertPlayerMetaToDomain(p.Player),
|
|
Valid: p.Valid,
|
|
}
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertVillageToDomain(v twhelp.Village) domain.Village {
|
|
return domain.Village{
|
|
ID: v.ID,
|
|
FullName: v.FullName,
|
|
ProfileURL: v.ProfileURL,
|
|
Points: v.Points,
|
|
X: v.X,
|
|
Y: v.Y,
|
|
Player: t.convertNullPlayerMetaToDomain(v.Player),
|
|
}
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertVillageMetaToDomain(v twhelp.VillageMeta) domain.VillageMeta {
|
|
return domain.VillageMeta{
|
|
ID: v.ID,
|
|
FullName: v.FullName,
|
|
ProfileURL: v.ProfileURL,
|
|
Player: t.convertNullPlayerMetaToDomain(v.Player),
|
|
}
|
|
}
|
|
|
|
func (t *TWHelpHTTP) convertEnnoblementToDomain(e twhelp.Ennoblement) domain.Ennoblement {
|
|
return domain.Ennoblement{
|
|
ID: e.ID,
|
|
Village: t.convertVillageMetaToDomain(e.Village),
|
|
NewOwner: t.convertNullPlayerMetaToDomain(e.NewOwner),
|
|
CreatedAt: e.CreatedAt,
|
|
}
|
|
}
|