connector impl

game/internal/controller/controller.go

@@ -110,6 +110,14 @@ func GenerateTurn(configure func(*Param)) (err error) {
 	return
 }
 
+func LoadReport(configure func(*Param), actor string, turn uint) (*report.Report, error) {
+	ec, err := NewRepoController(configure)
+	if err != nil {
+		return nil, err
+	}
+	return ec.loadReport(actor, turn)
+}
+
 func ExecuteCommand(configure func(*Param), consumer func(c Ctrl) error) (err error) {
 	ec, err := NewRepoController(configure)
 	if err != nil {
@@ -197,6 +205,18 @@ func (ec *RepoController) validateOrder(actor string, cmd ...order.DecodableComm
 	})
 }
 
+func (ec *RepoController) loadReport(actor string, turn uint) (r *report.Report, err error) {
+	execErr := ec.executeSafe(func(t uint, c *Controller) (exErr error) {
+		id, exErr := c.RaceID(actor)
+		if exErr == nil {
+			r, exErr = ec.Repo.LoadReport(turn, id)
+		}
+		return
+	})
+	err = errors.Join(err, execErr)
+	return
+}
+
 func (ec *RepoController) executeCommand(consumer func(*Controller) error) (err error) {
 	return ec.executeLocked(func(c *Controller) error {
 		err = consumer(c)

game/internal/controller/generate_game.go

@@ -29,6 +29,12 @@ func newGameOnMap(r Repo, races []string, m generator.Map) (uuid.UUID, error) {
 	if err := r.SaveNewTurn(0, g); err != nil {
 		return uuid.Nil, err
 	}
+	c := NewCache(g)
+	for rep := range c.Report(c.g.Turn, nil, nil) {
+		if err := r.SaveReport(c.g.Turn, rep); err != nil {
+			return uuid.Nil, err
+		}
+	}
 	return g.ID, nil
 }
 

game/internal/router/handler/handler.go

@@ -6,6 +6,7 @@ import (
 	"os"
 
 	"galaxy/model/order"
+	"galaxy/model/report"
 	"galaxy/model/rest"
 
 	e "galaxy/error"
@@ -21,6 +22,7 @@ type CommandExecutor interface {
 	GenerateGame([]string) (rest.StateResponse, error)
 	GenerateTurn() (rest.StateResponse, error)
 	GameState() (rest.StateResponse, error)
+	LoadReport(actor string, turn uint) (*report.Report, error)
 	Execute(cmd ...Command) error
 	ValidateOrder(actor string, cmd ...order.DecodableCommand) error
 }
@@ -84,6 +86,10 @@ func (e *executor) GameState() (rest.StateResponse, error) {
 	return stateResponse(s), nil
 }
 
+func (e *executor) LoadReport(actor string, turn uint) (*report.Report, error) {
+	return controller.LoadReport(e.cfg, actor, turn)
+}
+
 func stateResponse(s game.State) rest.StateResponse {
 	result := &rest.StateResponse{
 		ID:      s.ID,

game/internal/router/handler/report.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type reportParam struct {
+	Player string `form:"player" binding:"required,notblank"`
+	Turn   int    `form:"turn" binding:"gte=0"`
+}
+
+func ReportHandler(c *gin.Context, executor CommandExecutor) {
+	p := &reportParam{}
+	err := c.ShouldBindQuery(p)
+	if errorResponse(c, err) {
+		return
+	}
+
+	r, err := executor.LoadReport(p.Player, uint(p.Turn))
+	if errorResponse(c, err) {
+		return
+	}
+
+	c.JSON(http.StatusOK, r)
+}

game/internal/router/report_test.go

@@ -0,0 +1,60 @@
+package router_test
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"galaxy/model/rest"
+
+	"galaxy/game/internal/controller"
+	"galaxy/game/internal/router"
+	"galaxy/game/internal/router/handler"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetReport(t *testing.T) {
+	root := t.ArtifactDir()
+
+	r := router.SetupRouter(handler.NewDefaultConfigExecutor(func(p *controller.Param) { p.StoragePath = root }))
+
+	payload := generateInitRequest(10)
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("POST", "/api/v1/init", asBody(payload))
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusCreated, w.Code, w.Body)
+	var initResponse rest.StateResponse
+	assert.NoError(t, json.Unmarshal(w.Body.Bytes(), &initResponse))
+	assert.NoError(t, uuid.Validate(initResponse.ID.String()))
+	assert.NotEqual(t, uuid.Nil, uuid.MustParse(initResponse.ID.String()))
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("GET", "/api/v1/report", nil)
+	r.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusBadRequest, w.Code, w.Body)
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("GET", "/api/v1/report?player=", nil)
+	r.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusBadRequest, w.Code, w.Body)
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("GET", "/api/v1/report?player=&turn=0", nil)
+	r.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusBadRequest, w.Code, w.Body)
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("GET", "/api/v1/report?player=Race_01&turn=-1", nil)
+	r.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusBadRequest, w.Code, w.Body)
+
+	w = httptest.NewRecorder()
+	req, _ = http.NewRequest("GET", "/api/v1/report?player=Race_01&turn=0", nil)
+	r.ServeHTTP(w, req)
+	assert.Equal(t, http.StatusOK, w.Code, w.Body)
+}

game/internal/router/router.go

@@ -67,6 +67,7 @@ func setupRouter(executor handler.CommandExecutor) *gin.Engine {
 
 	groupV1.GET("/status", func(ctx *gin.Context) { handler.StatusHandler(ctx, executor) })
 	groupV1.POST("/init", func(ctx *gin.Context) { handler.InitHandler(ctx, executor) })
+	groupV1.GET("/report", func(ctx *gin.Context) { handler.ReportHandler(ctx, executor) })
 	groupV1.PUT("/command", LimitMiddleware(1), func(ctx *gin.Context) { handler.CommandHandler(ctx, executor) })
 	groupV1.PUT("/order", func(ctx *gin.Context) { handler.OrderHandler(ctx, executor) })
 	groupV1.PUT("/turn", func(ctx *gin.Context) { handler.TurnHandler(ctx, executor) })

game/internal/router/router_helper_test.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 
 	"galaxy/model/order"
+	"galaxy/model/report"
 	"galaxy/model/rest"
 
 	"galaxy/game/internal/router"
@@ -55,6 +56,10 @@ func (e *dummyExecutor) GameState() (rest.StateResponse, error) {
 	return rest.StateResponse{}, nil
 }
 
+func (e *dummyExecutor) LoadReport(actor string, turn uint) (*report.Report, error) {
+	return &report.Report{}, nil
+}
+
 func setupRouter() *gin.Engine {
 	return setupRouterExecutor(newExecutor())
 }