maps-service/pkg/service/maps.go

package service

import (
	"context"
	"time"

	"git.itzana.me/strafesnet/go-grpc/maps"
	"git.itzana.me/strafesnet/maps-service/pkg/datastore"
	"git.itzana.me/strafesnet/maps-service/pkg/model"
)

// Optional map used to update an object
type MapUpdate datastore.OptionalMap

func NewMapUpdate() MapUpdate {
	update := datastore.Optional()
	return MapUpdate(update)
}

func (update MapUpdate) SetDisplayName(display_name string) {
	datastore.OptionalMap(update).Add("display_name", display_name)
}
func (update MapUpdate) SetCreator(creator string) {
	datastore.OptionalMap(update).Add("creator", creator)
}
func (update MapUpdate) SetGameID(game_id uint32) {
	datastore.OptionalMap(update).Add("game_id", game_id)
}
func (update MapUpdate) SetDate(date int64) {
	datastore.OptionalMap(update).Add("date", time.Unix(date, 0))
}
func (update MapUpdate) SetSubmitter(submitter uint64) {
	datastore.OptionalMap(update).Add("submitter", submitter)
}
func (update MapUpdate) SetThumbnail(thumbnail uint64) {
	datastore.OptionalMap(update).Add("thumbnail", thumbnail)
}
func (update MapUpdate) SetAssetVersion(asset_version uint64) {
	datastore.OptionalMap(update).Add("asset_version", asset_version)
}
func (update MapUpdate) SetModes(modes uint32) {
	datastore.OptionalMap(update).Add("modes", modes)
}

// getters
func (update MapUpdate) GetDisplayName() (string, bool) {
	value, ok := datastore.OptionalMap(update).Map()["display_name"].(string)
	return value, ok
}
func (update MapUpdate) GetGameID() (uint32, bool) {
	value, ok := datastore.OptionalMap(update).Map()["game_id"].(uint32)
	return value, ok
}
func (update MapUpdate) GetThumbnail() (uint64, bool) {
	value, ok := datastore.OptionalMap(update).Map()["thumbnail"].(uint64)
	return value, ok
}

// Optional map used to find matching objects
type MapFilter datastore.OptionalMap

func NewMapFilter(
) MapFilter {
	filter := datastore.Optional()
	return MapFilter(filter)
}
func (update MapFilter) SetDisplayName(display_name string) {
	datastore.OptionalMap(update).Add("display_name", display_name)
}
func (update MapFilter) SetDisplayNameSubstring(display_name string) {
	datastore.OptionalMap(update).Add("display_name_substring", display_name)
}
func (update MapFilter) SetCreator(creator string) {
	datastore.OptionalMap(update).Add("creator", creator)
}
func (update MapFilter) SetGameID(game_id uint32) {
	datastore.OptionalMap(update).Add("game_id", game_id)
}
func (update MapFilter) SetSubmitter(submitter uint64) {
	datastore.OptionalMap(update).Add("submitter", submitter)
}

func (svc *Service) CreateMap(ctx context.Context, item model.Map) (int64, error) {
	// 2 jobs:
	// create map on maps-service
	map_item, err := svc.db.Maps().Create(ctx, item)
	if err != nil {
		return 0, err
	}
	// create map on data-service
	game_id := int32(item.GameID)
	_, err = svc.maps.Create(ctx, &maps.MapRequest{
		ID:          item.ID,
		DisplayName: &item.DisplayName,
		GameID:      &game_id,
		Thumbnail:   &item.Thumbnail,
	})
	if err != nil {
		return 0, err
	}

	return map_item.ID, nil
}

func (svc *Service) GetAllMaps(ctx context.Context) ([]model.Map, error) {
	return svc.db.Maps().GetAll(ctx)
}

func (svc *Service) ListMaps(ctx context.Context, filter MapFilter, page model.Page) ([]model.Map, error) {
	return svc.db.Maps().List(ctx, datastore.OptionalMap(filter), page)
}

func (svc *Service) GetMapList(ctx context.Context, ids []int64) ([]model.Map, error) {
	return svc.db.Maps().GetList(ctx, ids)
}

func (svc *Service) DeleteMap(ctx context.Context, id int64) error {
	// Do not delete the "embedded" map, since it deletes times.
	// _, err := svc.maps.Delete(ctx, &maps.IdMessage{ID: id})
	return svc.db.Maps().Delete(ctx, id)
}

func (svc *Service) GetMap(ctx context.Context, id int64) (model.Map, error) {
	return svc.db.Maps().Get(ctx, id)
}

func (svc *Service) UpdateMap(ctx context.Context, id int64, pmap MapUpdate) error {
	// 2 jobs:
	// update map on maps-service
	err := svc.db.Maps().Update(ctx, id, datastore.OptionalMap(pmap))
	if err != nil {
		return err
	}
	// update map on data-service
	update := maps.MapRequest{
		ID: id,
	}
	if display_name, ok := pmap.GetDisplayName(); ok {
		update.DisplayName = &display_name
	}
	if game_id, ok := pmap.GetGameID(); ok {
		game_id_int32 := int32(game_id)
		update.GameID = &game_id_int32
	}
	if thumbnail, ok := pmap.GetThumbnail(); ok {
		update.Thumbnail = &thumbnail
	}
	_, err = svc.maps.Update(ctx, &update)
	if err != nil {
		return err
	}
	return nil
}

func (svc *Service) IncrementMapLoadCount(ctx context.Context, id int64) error {
	return svc.db.Maps().IncrementLoadCount(ctx, id)
}