Add plantings backend: plop CRUD, derived counts, removed_at (#14)

- domain: Planting gains a computed (non-persisted) DerivedCount field. - store/plantings.go: Get/Create/Update (version-guarded)/Delete alongside the existing /full read helper. - service/plantings.go: place/move/resize/soft-remove a plop; editor role on the object's garden; object must be plantable; plant_id must be visible to the actor (built-in or own) else ErrInvalidInput; center must sit within the object's unrotated local bounds (radius may overhang); planted_at defaults to today. derivedCount = max(1, round(π·r²/spacing²)) — one unit-tested helper, reused by /full (via a spacing map, no N+1) and single responses. - api: POST /objects/:id/plantings, PATCH/DELETE /plantings/:id; nullable count/label/plantedAt/removedAt use RawMessage so null (clear) is distinct from absent (unchanged). removedAt is the soft-remove / "clear bed" seam. - /full now enriches each active plop with its derivedCount. Service tests: formula edge cases (tiny radius → 1), defaults + derived, count override, move/resize + clear override, non-plantable rejection, foreign/unknown plant rejection, bounds, soft-remove leaves /full, version conflict, cross-user masking, delete. Plus an API-level create/patch/full/delete flow. GOWORK=off go build/vet/test ./internal/... green. Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]> Claude-Session: https://claude.ai/code/session_01JdQpdYYsTgtkJBxbcpAszi
2026-07-18 22:26:15 -04:00
parent e4505ed9a7
commit 2f3699f7fa
8 changed files with 895 additions and 0 deletions
@@ -89,6 +89,13 @@ func New(cfg *config.Config, svc *service.Service) *gin.Engine {
 	objects := v1.Group("/objects", h.requireAuth())
 	objects.PATCH("/:id", h.updateObject)
 	objects.DELETE("/:id", h.deleteObject)
+	objects.POST("/:id/plantings", h.createPlanting) // place a plop in this object
+
+	// Plantings ("plops") are addressed by their own id; the service resolves the
+	// owning object/garden for the permission check.
+	plantings := v1.Group("/plantings", h.requireAuth())
+	plantings.PATCH("/:id", h.updatePlanting)
+	plantings.DELETE("/:id", h.deletePlanting)

 	// Plant catalog: built-ins (seeded, read-only) plus the actor's own rows.
 	plants := v1.Group("/plants", h.requireAuth())
@@ -0,0 +1,132 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"gitea.stevedudenhoeffer.com/steve/pansy/internal/domain"
+	"gitea.stevedudenhoeffer.com/steve/pansy/internal/service"
+)
+
+// plantingCreateRequest is the body for POST /objects/:id/plantings. x/y are in
+// the object's local frame (origin at object center); count omitted = derived;
+// plantedAt omitted = today.
+type plantingCreateRequest struct {
+	PlantID   int64   `json:"plantId" binding:"required"`
+	XCM       float64 `json:"xCm"`
+	YCM       float64 `json:"yCm"`
+	RadiusCM  float64 `json:"radiusCm"`
+	Count     *int    `json:"count"`
+	Label     *string `json:"label"`
+	PlantedAt *string `json:"plantedAt"`
+}
+
+func (r plantingCreateRequest) toInput() service.PlantingInput {
+	return service.PlantingInput{
+		PlantID: r.PlantID, XCM: r.XCM, YCM: r.YCM, RadiusCM: r.RadiusCM,
+		Count: r.Count, Label: r.Label, PlantedAt: r.PlantedAt,
+	}
+}
+
+// plantingUpdateRequest is the body for PATCH /plantings/:id: every field
+// optional (absent = unchanged) plus the required current version. The nullable
+// fields are json.RawMessage so an explicit null (clear) is distinct from an
+// absent field (unchanged) — e.g. `removedAt: "2026-07-01"` soft-removes and
+// `removedAt: null` un-removes.
+type plantingUpdateRequest struct {
+	PlantID   *int64          `json:"plantId"`
+	XCM       *float64        `json:"xCm"`
+	YCM       *float64        `json:"yCm"`
+	RadiusCM  *float64        `json:"radiusCm"`
+	Count     json.RawMessage `json:"count"`
+	Label     json.RawMessage `json:"label"`
+	PlantedAt json.RawMessage `json:"plantedAt"`
+	RemovedAt json.RawMessage `json:"removedAt"`
+	Version   int64           `json:"version" binding:"required,min=1"`
+}
+
+func (r plantingUpdateRequest) toPatch() (service.PlantingPatch, error) {
+	count, setCount, err := parseNullableInt(r.Count)
+	if err != nil {
+		return service.PlantingPatch{}, err
+	}
+	label, setLabel, err := parseNullableString(r.Label)
+	if err != nil {
+		return service.PlantingPatch{}, err
+	}
+	plantedAt, setPlantedAt, err := parseNullableString(r.PlantedAt)
+	if err != nil {
+		return service.PlantingPatch{}, err
+	}
+	removedAt, setRemovedAt, err := parseNullableString(r.RemovedAt)
+	if err != nil {
+		return service.PlantingPatch{}, err
+	}
+	return service.PlantingPatch{
+		PlantID: r.PlantID, XCM: r.XCM, YCM: r.YCM, RadiusCM: r.RadiusCM,
+		SetCount: setCount, Count: count,
+		SetLabel: setLabel, Label: label,
+		SetPlantedAt: setPlantedAt, PlantedAt: plantedAt,
+		SetRemovedAt: setRemovedAt, RemovedAt: removedAt,
+	}, nil
+}
+
+func (h *handlers) createPlanting(c *gin.Context) {
+	objectID, ok := parseIDParam(c, "id")
+	if !ok {
+		return
+	}
+	var req plantingCreateRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		writeAPIError(c, http.StatusBadRequest, "INVALID_INPUT", "invalid planting: a plantId is required")
+		return
+	}
+	p, err := h.svc.CreatePlanting(c.Request.Context(), mustActor(c).ID, objectID, req.toInput())
+	if err != nil {
+		writeServiceError(c, err)
+		return
+	}
+	c.JSON(http.StatusCreated, p)
+}
+
+func (h *handlers) updatePlanting(c *gin.Context) {
+	id, ok := parseIDParam(c, "id")
+	if !ok {
+		return
+	}
+	var req plantingUpdateRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		writeAPIError(c, http.StatusBadRequest, "INVALID_INPUT", "invalid update: a current version is required")
+		return
+	}
+	patch, err := req.toPatch()
+	if err != nil {
+		writeAPIError(c, http.StatusBadRequest, "INVALID_INPUT", "invalid update payload")
+		return
+	}
+	p, err := h.svc.UpdatePlanting(c.Request.Context(), mustActor(c).ID, id, patch, req.Version)
+	if err != nil {
+		if errors.Is(err, domain.ErrVersionConflict) {
+			writeVersionConflict(c, p)
+			return
+		}
+		writeServiceError(c, err)
+		return
+	}
+	c.JSON(http.StatusOK, p)
+}
+
+func (h *handlers) deletePlanting(c *gin.Context) {
+	id, ok := parseIDParam(c, "id")
+	if !ok {
+		return
+	}
+	if err := h.svc.DeletePlanting(c.Request.Context(), mustActor(c).ID, id); err != nil {
+		writeServiceError(c, err)
+		return
+	}
+	c.Status(http.StatusNoContent)
+}
@@ -0,0 +1,99 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+	"testing"
+)
+
+func plantingPath(id int64) string        { return "/api/v1/plantings/" + strconv.FormatInt(id, 10) }
+func objectPlantingsPath(id int64) string { return objectPath(id) + "/plantings" }
+
+func TestPlantingCreatePatchFullDelete(t *testing.T) {
+	r := authEngine(t, localCfg())
+	cookie := registerAndCookie(t, r, "[email protected]")
+	gid := createGardenAPI(t, r, cookie, "Yard")
+
+	// A plantable bed centered in the garden.
+	w := doJSON(t, r, http.MethodPost, objectsPath(gid),
+		map[string]any{"kind": "bed", "xCm": 500, "yCm": 500, "widthCm": 200, "heightCm": 200}, cookie)
+	oid := int64(decodeMap(t, w.Body.Bytes())["id"].(float64))
+
+	// A seeded built-in plant to place.
+	w = doJSON(t, r, http.MethodGet, "/api/v1/plants", nil, cookie)
+	plantID, _ := firstBuiltinID(t, w.Body.Bytes())
+
+	// Place a plop → 201 with a derivedCount.
+	w = doJSON(t, r, http.MethodPost, objectPlantingsPath(oid),
+		map[string]any{"plantId": plantID, "xCm": 0, "yCm": 0, "radiusCm": 20}, cookie)
+	if w.Code != http.StatusCreated {
+		t.Fatalf("create planting: status %d, body %s", w.Code, w.Body.String())
+	}
+	pl := decodeMap(t, w.Body.Bytes())
+	pid := int64(pl["id"].(float64))
+	dc, ok := pl["derivedCount"].(float64)
+	if !ok || dc < 1 {
+		t.Errorf("response missing a positive derivedCount: %+v", pl)
+	}
+
+	// /full includes the plop and its referenced plant.
+	w = doJSON(t, r, http.MethodGet, fullPath(gid), nil, cookie)
+	var full struct {
+		Plantings []map[string]any `json:"plantings"`
+		Plants    []map[string]any `json:"plants"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &full); err != nil {
+		t.Fatalf("decode full: %v", err)
+	}
+	if len(full.Plantings) != 1 || len(full.Plants) != 1 {
+		t.Fatalf("full = %d plantings / %d plants, want 1 / 1", len(full.Plantings), len(full.Plants))
+	}
+
+	// Soft-remove (clear-bed style) → it leaves /full.
+	w = doJSON(t, r, http.MethodPatch, plantingPath(pid), map[string]any{"removedAt": "2026-07-01", "version": 1}, cookie)
+	if w.Code != http.StatusOK {
+		t.Fatalf("soft-remove: status %d, body %s", w.Code, w.Body.String())
+	}
+	w = doJSON(t, r, http.MethodGet, fullPath(gid), nil, cookie)
+	full.Plantings = nil
+	json.Unmarshal(w.Body.Bytes(), &full)
+	if len(full.Plantings) != 0 {
+		t.Errorf("removed plop still in /full: %d", len(full.Plantings))
+	}
+
+	// Hard delete → 204.
+	if w := doJSON(t, r, http.MethodDelete, plantingPath(pid), nil, cookie); w.Code != http.StatusNoContent {
+		t.Errorf("delete planting = %d, want 204", w.Code)
+	}
+}
+
+func TestPlantingIntoNonPlantableIsRejected(t *testing.T) {
+	r := authEngine(t, localCfg())
+	cookie := registerAndCookie(t, r, "[email protected]")
+	gid := createGardenAPI(t, r, cookie, "Yard")
+
+	// A tree is not plantable.
+	w := doJSON(t, r, http.MethodPost, objectsPath(gid),
+		map[string]any{"kind": "tree", "xCm": 500, "yCm": 500, "widthCm": 100, "heightCm": 100}, cookie)
+	oid := int64(decodeMap(t, w.Body.Bytes())["id"].(float64))
+
+	w = doJSON(t, r, http.MethodGet, "/api/v1/plants", nil, cookie)
+	plantID, _ := firstBuiltinID(t, w.Body.Bytes())
+
+	w = doJSON(t, r, http.MethodPost, objectPlantingsPath(oid),
+		map[string]any{"plantId": plantID, "xCm": 0, "yCm": 0, "radiusCm": 10}, cookie)
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("plant into tree = %d, want 400", w.Code)
+	}
+}
+
+func TestPlantingsRequireAuth(t *testing.T) {
+	r := authEngine(t, localCfg())
+	if w := doJSON(t, r, http.MethodPost, "/api/v1/objects/1/plantings", map[string]any{"plantId": 1}, nil); w.Code != http.StatusUnauthorized {
+		t.Errorf("unauthenticated create = %d, want 401", w.Code)
+	}
+	if w := doJSON(t, r, http.MethodDelete, "/api/v1/plantings/1", nil, nil); w.Code != http.StatusUnauthorized {
+		t.Errorf("unauthenticated delete = %d, want 401", w.Code)
+	}
+}