feat(dataset-groups): CRUD, latest-in-group, group SLD with dataset fallback, CreateRasterFromFile

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/transport/http/dataset_group_handler.go

@@ -0,0 +1,236 @@
+package http
+
+import (
+	"io"
+	"net/http"
+	"strings"
+
+	"gis/internal/domain"
+	"gis/internal/service"
+	"gis/pkg/httputil"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-playground/validator/v10"
+)
+
+// DatasetGroupHandler serves the /dataset-groups routes.
+type DatasetGroupHandler struct {
+	svc      *service.DatasetGroupService
+	validate *validator.Validate
+}
+
+// NewDatasetGroupHandler returns a DatasetGroupHandler.
+func NewDatasetGroupHandler(svc *service.DatasetGroupService, validate *validator.Validate) *DatasetGroupHandler {
+	return &DatasetGroupHandler{svc: svc, validate: validate}
+}
+
+// Register mounts the dataset-group routes on r.
+func (h *DatasetGroupHandler) Register(r chi.Router) {
+	r.Get("/", h.list)
+	r.Post("/", h.create)
+	r.Get("/{id}", h.get)
+	r.Put("/{id}", h.update)
+	r.Delete("/{id}", h.delete)
+	r.Get("/{id}/latest", h.latest)
+	r.Post("/{id}/sld", h.uploadSLD)
+	r.Get("/{id}/sld", h.downloadSLD)
+}
+
+type datasetGroupRequest struct {
+	Code        string `json:"code" validate:"required,max=255,slug"`
+	Name        string `json:"name" validate:"required,max=255"`
+	Description string `json:"description" validate:"max=2000"`
+}
+
+func (r datasetGroupRequest) toInput() service.DatasetGroupInput {
+	return service.DatasetGroupInput{Code: r.Code, Name: r.Name, Description: r.Description}
+}
+
+func (h *DatasetGroupHandler) create(w http.ResponseWriter, r *http.Request) {
+	req, err := httputil.DecodeJSON[datasetGroupRequest](w, r)
+	if err != nil {
+		httputil.WriteError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	if err := h.validate.Struct(req); err != nil {
+		httputil.WriteValidationErrors(w, err)
+		return
+	}
+
+	group, err := h.svc.Create(r.Context(), req.toInput())
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	httputil.WriteJSON(w, http.StatusCreated, group)
+}
+
+func (h *DatasetGroupHandler) list(w http.ResponseWriter, r *http.Request) {
+	var code *string
+	if v := strings.TrimSpace(r.URL.Query().Get("code")); v != "" {
+		code = &v
+	}
+
+	page, ok := parsePositiveIntQuery(w, r, "page", 1)
+	if !ok {
+		return
+	}
+	pageSize, ok := parsePositiveIntQuery(w, r, "page_size", service.DefaultPageSize)
+	if !ok {
+		return
+	}
+
+	result, err := h.svc.List(r.Context(), code, page, pageSize)
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	httputil.WriteJSON(w, http.StatusOK, newPaginated(result.Items, result.Page, result.PageSize, result.Total))
+}
+
+func (h *DatasetGroupHandler) get(w http.ResponseWriter, r *http.Request) {
+	id, ok := parseUUIDParam(w, r, "id")
+	if !ok {
+		return
+	}
+	group, err := h.svc.Get(r.Context(), id)
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	httputil.WriteJSON(w, http.StatusOK, group)
+}
+
+func (h *DatasetGroupHandler) update(w http.ResponseWriter, r *http.Request) {
+	id, ok := parseUUIDParam(w, r, "id")
+	if !ok {
+		return
+	}
+	req, err := httputil.DecodeJSON[datasetGroupRequest](w, r)
+	if err != nil {
+		httputil.WriteError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+	if err := h.validate.Struct(req); err != nil {
+		httputil.WriteValidationErrors(w, err)
+		return
+	}
+
+	group, err := h.svc.Update(r.Context(), id, req.toInput())
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	httputil.WriteJSON(w, http.StatusOK, group)
+}
+
+// delete removes a group. A group still referenced by datasets yields 409.
+func (h *DatasetGroupHandler) delete(w http.ResponseWriter, r *http.Request) {
+	id, ok := parseUUIDParam(w, r, "id")
+	if !ok {
+		return
+	}
+	if err := h.svc.Delete(r.Context(), id); err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// latest returns the freshest dataset of the group (greatest end_date, NULLs
+// last, then newest), optionally narrowed by ?status= and ?file_type=.
+func (h *DatasetGroupHandler) latest(w http.ResponseWriter, r *http.Request) {
+	id, ok := parseUUIDParam(w, r, "id")
+	if !ok {
+		return
+	}
+
+	var status *string
+	if v := strings.TrimSpace(r.URL.Query().Get("status")); v != "" {
+		if !domain.ValidDatasetStatus(v) {
+			httputil.WriteError(w, http.StatusBadRequest, "invalid status")
+			return
+		}
+		status = &v
+	}
+
+	var fileType *domain.FileType
+	if v := strings.TrimSpace(r.URL.Query().Get("file_type")); v != "" {
+		ft := domain.FileType(v)
+		if !ft.Valid() {
+			httputil.WriteError(w, http.StatusBadRequest, "file_type must be one of: vector_with_kato, vector, raster")
+			return
+		}
+		fileType = &ft
+	}
+
+	dataset, err := h.svc.Latest(r.Context(), id, status, fileType)
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	httputil.WriteJSON(w, http.StatusOK, dataset)
+}
+
+func (h *DatasetGroupHandler) uploadSLD(w http.ResponseWriter, r *http.Request) {
+	id, ok := parseUUIDParam(w, r, "id")
+	if !ok {
+		return
+	}
+	if err := r.ParseMultipartForm(maxUploadBytes); err != nil {
+		httputil.WriteError(w, http.StatusBadRequest, "request must be multipart/form-data")
+		return
+	}
+
+	file, header, err := r.FormFile("file")
+	if err != nil {
+		httputil.WriteError(w, http.StatusBadRequest, "file is required")
+		return
+	}
+	defer file.Close()
+
+	contentType := header.Header.Get("Content-Type")
+	if contentType == "" {
+		contentType = "application/xml"
+	}
+
+	group, err := h.svc.UploadSLD(r.Context(), id, service.UploadSLDInput{
+		Filename:    header.Filename,
+		ContentType: contentType,
+		Size:        header.Size,
+		Reader:      file,
+	})
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	httputil.WriteJSON(w, http.StatusOK, group)
+}
+
+func (h *DatasetGroupHandler) downloadSLD(w http.ResponseWriter, r *http.Request) {
+	id, ok := parseUUIDParam(w, r, "id")
+	if !ok {
+		return
+	}
+	group, obj, err := h.svc.DownloadSLD(r.Context(), id)
+	if err != nil {
+		respondDomainError(w, err)
+		return
+	}
+	defer obj.Close()
+
+	contentType := "application/xml"
+	if group.SldContentType != nil && *group.SldContentType != "" {
+		contentType = *group.SldContentType
+	}
+	filename := "style.sld"
+	if group.SldFilename != nil && *group.SldFilename != "" {
+		filename = *group.SldFilename
+	}
+	w.Header().Set("Content-Type", contentType)
+	w.Header().Set("Content-Disposition", `attachment; filename="`+filename+`"`)
+	if _, err := io.Copy(w, obj); err != nil {
+		// Headers are already sent; nothing useful to return to the client.
+		return
+	}
+}

internal/transport/http/router.go

@@ -10,11 +10,13 @@ import (
 
 // RouterDeps holds the handlers and dependencies the router mounts.
 type RouterDeps struct {
-	Logger      *slog.Logger
-	Health      *HealthHandler
-	Categories  *CategoryHandler
-	Datasets    *DatasetHandler
-	OpenAPISpec []byte
+	Logger     *slog.Logger
+	Health     *HealthHandler
+	Categories *CategoryHandler
+	Datasets   *DatasetHandler
+	// DatasetGroups serves the /dataset-groups routes.
+	DatasetGroups *DatasetGroupHandler
+	OpenAPISpec   []byte
 }
 
 // NewRouter builds the application's HTTP handler with middleware and routes.
@@ -37,6 +39,7 @@ func NewRouter(deps RouterDeps) http.Handler {
 	// Domain routes. Add future feature routers here.
 	r.Route("/categories", deps.Categories.Register)
 	r.Route("/datasets", deps.Datasets.Register)
+	r.Route("/dataset-groups", deps.DatasetGroups.Register)
 
 	return r
 }