294 lines
8.3 KiB
Go
294 lines
8.3 KiB
Go
package repositories
|
|
|
|
import (
|
|
"context"
|
|
json "history-api/pkg/jsonx"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
|
|
"history-api/internal/gen/sqlc"
|
|
"history-api/internal/models"
|
|
"history-api/pkg/cache"
|
|
"history-api/pkg/constants"
|
|
"history-api/pkg/convert"
|
|
)
|
|
|
|
type BattleReplayRepository interface {
|
|
GetByID(ctx context.Context, id pgtype.UUID) (*models.BattleReplayEntity, error)
|
|
GetByIDs(ctx context.Context, ids []string) ([]*models.BattleReplayEntity, error)
|
|
GetByGeometryID(ctx context.Context, geometryID pgtype.UUID) ([]*models.BattleReplayEntity, error)
|
|
GetByGeometryIDs(ctx context.Context, geometryIDs []string) ([]*models.BattleReplayEntity, error)
|
|
Create(ctx context.Context, params sqlc.CreateBattleReplayParams) (*models.BattleReplayEntity, error)
|
|
Update(ctx context.Context, params sqlc.UpdateBattleReplayParams) (*models.BattleReplayEntity, error)
|
|
Delete(ctx context.Context, id pgtype.UUID) error
|
|
DeleteByIDs(ctx context.Context, ids []pgtype.UUID) error
|
|
GetByProjectID(ctx context.Context, projectID pgtype.UUID) ([]*models.BattleReplayEntity, error)
|
|
WithTx(tx pgx.Tx) BattleReplayRepository
|
|
}
|
|
|
|
type battleReplayRepository struct {
|
|
q *sqlc.Queries
|
|
c cache.Cache
|
|
}
|
|
|
|
func NewBattleReplayRepository(db sqlc.DBTX, c cache.Cache) BattleReplayRepository {
|
|
return &battleReplayRepository{
|
|
q: sqlc.New(db),
|
|
c: c,
|
|
}
|
|
}
|
|
|
|
func (r *battleReplayRepository) WithTx(tx pgx.Tx) BattleReplayRepository {
|
|
return &battleReplayRepository{
|
|
q: r.q.WithTx(tx),
|
|
c: r.c,
|
|
}
|
|
}
|
|
|
|
func (r *battleReplayRepository) rowToEntity(row sqlc.BattleReplay) *models.BattleReplayEntity {
|
|
return &models.BattleReplayEntity{
|
|
ID: convert.UUIDToString(row.ID),
|
|
GeometryID: convert.UUIDToString(row.GeometryID),
|
|
ProjectID: convert.UUIDToString(row.ProjectID),
|
|
TargetGeometryIDs: row.TargetGeometryIds,
|
|
Detail: row.Detail,
|
|
IsDeleted: row.IsDeleted,
|
|
CreatedAt: convert.TimeToPtr(row.CreatedAt),
|
|
UpdatedAt: convert.TimeToPtr(row.UpdatedAt),
|
|
}
|
|
}
|
|
|
|
func (r *battleReplayRepository) getByIDsWithFallback(ctx context.Context, ids []string) ([]*models.BattleReplayEntity, error) {
|
|
if len(ids) == 0 {
|
|
return []*models.BattleReplayEntity{}, nil
|
|
}
|
|
keys := make([]string, len(ids))
|
|
for i, id := range ids {
|
|
keys[i] = cache.Key("battle_replay:id", id)
|
|
}
|
|
raws := r.c.MGet(ctx, keys...)
|
|
|
|
items := make([]*models.BattleReplayEntity, 0, len(ids))
|
|
missingToCache := make(map[string]any, len(ids))
|
|
|
|
missingPgIds := make([]pgtype.UUID, 0, len(ids))
|
|
for i, b := range raws {
|
|
if len(b) == 0 {
|
|
pgId := pgtype.UUID{}
|
|
err := pgId.Scan(ids[i])
|
|
if err == nil {
|
|
missingPgIds = append(missingPgIds, pgId)
|
|
}
|
|
}
|
|
}
|
|
|
|
dbMap := make(map[string]*models.BattleReplayEntity, len(missingPgIds))
|
|
if len(missingPgIds) > 0 {
|
|
dbRows, err := r.q.GetBattleReplaysByIDs(ctx, missingPgIds)
|
|
if err == nil {
|
|
for _, row := range dbRows {
|
|
item := r.rowToEntity(row)
|
|
dbMap[item.ID] = item
|
|
}
|
|
}
|
|
}
|
|
|
|
for i, b := range raws {
|
|
if len(b) > 0 {
|
|
var u models.BattleReplayEntity
|
|
if err := json.Unmarshal(b, &u); err == nil {
|
|
items = append(items, &u)
|
|
}
|
|
} else {
|
|
if item, ok := dbMap[ids[i]]; ok {
|
|
items = append(items, item)
|
|
missingToCache[keys[i]] = item
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(missingToCache) > 0 {
|
|
_ = r.c.MSet(ctx, missingToCache, constants.NormalCacheDuration)
|
|
}
|
|
|
|
return items, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) GetByIDs(ctx context.Context, ids []string) ([]*models.BattleReplayEntity, error) {
|
|
return r.getByIDsWithFallback(ctx, ids)
|
|
}
|
|
|
|
func (r *battleReplayRepository) GetByID(ctx context.Context, id pgtype.UUID) (*models.BattleReplayEntity, error) {
|
|
cacheId := cache.Key("battle_replay:id", convert.UUIDToString(id))
|
|
var item models.BattleReplayEntity
|
|
err := r.c.Get(ctx, cacheId, &item)
|
|
if err == nil {
|
|
_ = r.c.Set(ctx, cacheId, item, constants.NormalCacheDuration)
|
|
return &item, nil
|
|
}
|
|
|
|
row, err := r.q.GetBattleReplayById(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
entity := r.rowToEntity(row)
|
|
_ = r.c.Set(ctx, cacheId, entity, constants.NormalCacheDuration)
|
|
|
|
return entity, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) GetByGeometryID(ctx context.Context, geometryID pgtype.UUID) ([]*models.BattleReplayEntity, error) {
|
|
cacheKey := cache.Key("battle_replay:geometry", convert.UUIDToString(geometryID))
|
|
var cachedIDs []string
|
|
err := r.c.Get(ctx, cacheKey, &cachedIDs)
|
|
if err == nil {
|
|
if len(cachedIDs) == 0 {
|
|
return []*models.BattleReplayEntity{}, nil
|
|
}
|
|
return r.getByIDsWithFallback(ctx, cachedIDs)
|
|
}
|
|
|
|
rows, err := r.q.GetBattleReplaysByGeometryId(ctx, geometryID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
items := make([]*models.BattleReplayEntity, 0, len(rows))
|
|
ids := make([]string, 0, len(rows))
|
|
itemToCache := make(map[string]any, len(rows))
|
|
|
|
for _, row := range rows {
|
|
item := r.rowToEntity(row)
|
|
ids = append(ids, item.ID)
|
|
items = append(items, item)
|
|
itemToCache[cache.Key("battle_replay:id", item.ID)] = item
|
|
}
|
|
|
|
if len(itemToCache) > 0 {
|
|
_ = r.c.MSet(ctx, itemToCache, constants.NormalCacheDuration)
|
|
}
|
|
_ = r.c.Set(ctx, cacheKey, ids, constants.ListCacheDuration)
|
|
|
|
return items, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) GetByGeometryIDs(ctx context.Context, geometryIDs []string) ([]*models.BattleReplayEntity, error) {
|
|
if len(geometryIDs) == 0 {
|
|
return []*models.BattleReplayEntity{}, nil
|
|
}
|
|
|
|
pgIds := make([]pgtype.UUID, 0, len(geometryIDs))
|
|
for _, id := range geometryIDs {
|
|
pgId := pgtype.UUID{}
|
|
if err := pgId.Scan(id); err == nil {
|
|
pgIds = append(pgIds, pgId)
|
|
}
|
|
}
|
|
|
|
rows, err := r.q.GetBattleReplaysByGeometryIDs(ctx, pgIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
items := make([]*models.BattleReplayEntity, 0, len(rows))
|
|
itemToCache := make(map[string]any, len(rows))
|
|
|
|
for _, row := range rows {
|
|
item := r.rowToEntity(row)
|
|
items = append(items, item)
|
|
itemToCache[cache.Key("battle_replay:id", item.ID)] = item
|
|
}
|
|
|
|
if len(itemToCache) > 0 {
|
|
_ = r.c.MSet(ctx, itemToCache, constants.NormalCacheDuration)
|
|
}
|
|
|
|
return items, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) GetByProjectID(ctx context.Context, projectID pgtype.UUID) ([]*models.BattleReplayEntity, error) {
|
|
cacheKey := cache.Key("battle_replay:project", convert.UUIDToString(projectID))
|
|
var cachedIDs []string
|
|
err := r.c.Get(ctx, cacheKey, &cachedIDs)
|
|
if err == nil {
|
|
if len(cachedIDs) == 0 {
|
|
return []*models.BattleReplayEntity{}, nil
|
|
}
|
|
return r.getByIDsWithFallback(ctx, cachedIDs)
|
|
}
|
|
|
|
rows, err := r.q.GetBattleReplaysByProjectId(ctx, projectID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
items := make([]*models.BattleReplayEntity, 0, len(rows))
|
|
ids := make([]string, 0, len(rows))
|
|
itemToCache := make(map[string]any, len(rows))
|
|
|
|
for _, row := range rows {
|
|
item := r.rowToEntity(row)
|
|
ids = append(ids, item.ID)
|
|
items = append(items, item)
|
|
itemToCache[cache.Key("battle_replay:id", item.ID)] = item
|
|
}
|
|
|
|
if len(itemToCache) > 0 {
|
|
_ = r.c.MSet(ctx, itemToCache, constants.NormalCacheDuration)
|
|
}
|
|
_ = r.c.Set(ctx, cacheKey, ids, constants.ListCacheDuration)
|
|
|
|
return items, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) Create(ctx context.Context, params sqlc.CreateBattleReplayParams) (*models.BattleReplayEntity, error) {
|
|
row, err := r.q.CreateBattleReplay(ctx, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
entity := r.rowToEntity(row)
|
|
|
|
_ = r.c.Del(ctx, cache.Key("battle_replay:project", entity.ProjectID))
|
|
_ = r.c.Del(ctx, cache.Key("battle_replay:geometry", entity.GeometryID))
|
|
|
|
return entity, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) Update(ctx context.Context, params sqlc.UpdateBattleReplayParams) (*models.BattleReplayEntity, error) {
|
|
row, err := r.q.UpdateBattleReplay(ctx, params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
entity := r.rowToEntity(row)
|
|
_ = r.c.Del(ctx, cache.Key("battle_replay:id", entity.ID))
|
|
return entity, nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) Delete(ctx context.Context, id pgtype.UUID) error {
|
|
err := r.q.DeleteBattleReplay(ctx, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = r.c.Del(ctx, cache.Key("battle_replay:id", convert.UUIDToString(id)))
|
|
return nil
|
|
}
|
|
|
|
func (r *battleReplayRepository) DeleteByIDs(ctx context.Context, ids []pgtype.UUID) error {
|
|
err := r.q.DeleteBattleReplaysByIDs(ctx, ids)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(ids) > 0 {
|
|
keys := make([]string, len(ids))
|
|
for i, id := range ids {
|
|
keys[i] = cache.Key("battle_replay:id", convert.UUIDToString(id))
|
|
}
|
|
_ = r.c.Del(ctx, keys...)
|
|
}
|
|
return nil
|
|
}
|