Merge pull request #16 from PDOK/PDOK-17804-wms-mapfilegenerator-input

PDOK-17804 Added WMS mapserver input

Author: Daimanta

api/v2beta1/wms_conversion.go

@@ -26,12 +26,11 @@ package v2beta1
 
 import (
 	"errors"
-	"log"
-	"strconv"
-
 	sharedModel "github.com/pdok/smooth-operator/model"
-
+	"log"
 	"sigs.k8s.io/controller-runtime/pkg/conversion"
+	"strconv"
+	"strings"
 
 	pdoknlv3 "github.com/pdok/mapserver-operator/api/v3"
 )
@@ -300,11 +299,27 @@ func (v2Service WMSService) MapLayersToV3() pdoknlv3.Layer {
 	// it needs to be created with defaults from the service
 	// and in this case the middleLayers are all layers without a group
 	if topLayer == nil {
+		boundingBoxes := make([]pdoknlv3.WMSBoundingBox, 0)
+		if v2Service.Extent != nil {
+			bboxStringList := strings.Split(*v2Service.Extent, " ")
+			bbox := pdoknlv3.WMSBoundingBox{
+				CRS: v2Service.DataEPSG,
+				BBox: sharedModel.BBox{
+					MinX: bboxStringList[0],
+					MaxX: bboxStringList[2],
+					MinY: bboxStringList[1],
+					MaxY: bboxStringList[3],
+				},
+			}
+			boundingBoxes = append(boundingBoxes, bbox)
+		}
+
 		topLayer = &pdoknlv3.Layer{
-			Title:    &v2Service.Title,
-			Abstract: &v2Service.Abstract,
-			Keywords: v2Service.Keywords,
-			Layers:   &[]pdoknlv3.Layer{},
+			Title:         &v2Service.Title,
+			Abstract:      &v2Service.Abstract,
+			Keywords:      v2Service.Keywords,
+			Layers:        &[]pdoknlv3.Layer{},
+			BoundingBoxes: boundingBoxes,
 		}
 
 		// adding the bottom layers to the middle layers they are grouped by

api/v3/wms_types.go

@@ -25,14 +25,13 @@ SOFTWARE.
 package v3
 
 import (
-	"maps"
-	"slices"
-	"sort"
-
 	shared_model "github.com/pdok/smooth-operator/model"
 	autoscalingv2 "k8s.io/api/autoscaling/v2"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"maps"
+	"slices"
+	"sort"
 )
 
 const (
@@ -112,6 +111,17 @@ type WMSBoundingBox struct {
 	BBox shared_model.BBox `json:"bbox"`
 }
 
+func (wmsBoundingBox *WMSBoundingBox) ToExtent() string {
+	return wmsBoundingBox.BBox.ToExtent()
+}
+
+func (wmsBoundingBox *WMSBoundingBox) Combine(other *WMSBoundingBox) {
+	if wmsBoundingBox.CRS != other.CRS {
+		return
+	}
+	wmsBoundingBox.BBox.Combine(other.BBox)
+}
+
 type Authority struct {
 	Name                     string `json:"name"`
 	URL                      string `json:"url"`
@@ -163,6 +173,96 @@ func init() {
 	SchemeBuilder.Register(&WMS{}, &WMSList{})
 }
 
+func (wmsService *WMSService) GetBoundingBox() WMSBoundingBox {
+	var boundingBox *WMSBoundingBox
+
+	allLayers := wmsService.GetAllLayers()
+	for _, layer := range allLayers {
+		if layer.BoundingBoxes != nil && len(layer.BoundingBoxes) > 0 {
+			for _, bbox := range wmsService.Layer.BoundingBoxes {
+				if boundingBox == nil {
+					boundingBox = &bbox
+				} else {
+					boundingBox.Combine(&bbox)
+				}
+			}
+		}
+	}
+
+	if boundingBox != nil {
+		return *boundingBox
+	} else {
+		return WMSBoundingBox{
+			CRS: "EPSG:28992",
+			BBox: shared_model.BBox{
+				MinX: "-25000",
+				MaxX: "280000",
+				MinY: "250000",
+				MaxY: "860000",
+			},
+		}
+	}
+
+}
+
+type AnnotatedLayer struct {
+	// The name of the group that this layer belongs to, nil if it is not a member of a group. Groups can be a member of the toplayer as a group
+	GroupName *string
+	// Only for spec.Service.Layer
+	IsTopLayer bool
+	// Top layer or layer below the toplayer with children itself
+	IsGroupLayer bool
+	// Contains actual data
+	IsDataLayer bool
+	Layer       Layer
+}
+
+func (wmsService *WMSService) GetAnnotatedLayers() []AnnotatedLayer {
+	result := make([]AnnotatedLayer, 0)
+
+	topLayer := wmsService.Layer
+	annotatedTopLayer := AnnotatedLayer{
+		GroupName:    nil,
+		IsTopLayer:   true,
+		IsGroupLayer: topLayer.Name != nil,
+		IsDataLayer:  false,
+		Layer:        topLayer,
+	}
+	result = append(result, annotatedTopLayer)
+
+	for _, topLayerChild := range *topLayer.Layers {
+		groupName := topLayer.Name
+		isGroupLayer := topLayerChild.Layers != nil && len(*topLayerChild.Layers) > 0
+		isDataLayer := !isGroupLayer
+		result = append(result, AnnotatedLayer{
+			GroupName:    groupName,
+			IsTopLayer:   false,
+			IsGroupLayer: isGroupLayer,
+			IsDataLayer:  isDataLayer,
+			Layer:        topLayerChild,
+		})
+
+		if topLayerChild.Layers != nil && len(*topLayerChild.Layers) > 0 {
+			for _, middleLayerChild := range *topLayerChild.Layers {
+				groupName = topLayerChild.Name
+				result = append(result, AnnotatedLayer{
+					GroupName:    groupName,
+					IsTopLayer:   false,
+					IsGroupLayer: false,
+					IsDataLayer:  true,
+					Layer:        middleLayerChild,
+				})
+			}
+		}
+	}
+
+	return result
+}
+
+func (wmsService *WMSService) GetAllLayers() (layers []Layer) {
+	return wmsService.Layer.GetAllLayers()
+}
+
 func (layer *Layer) GetAllLayers() (layers []Layer) {
 	layers = append(layers, *layer)
 	if layer.Layers != nil {
@@ -232,6 +332,10 @@ func (layer *Layer) IsGroupLayer() bool {
 	return layer.Layers != nil && len(*layer.Layers) > 0
 }
 
+func (layer *Layer) IsTopLayer(service *WMSService) bool {
+	return layer.Name == service.Layer.Name
+}
+
 func (layer *Layer) hasBoundingBoxForCRS(crs string) bool {
 	for _, bbox := range layer.BoundingBoxes {
 		if bbox.CRS == crs {

internal/controller/mapfilegenerator/mapfile_generator.go

@@ -2,7 +2,6 @@ package mapfilegenerator
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"strings"
 
@@ -50,8 +49,8 @@ func GetConfig[W pdoknlv3.WMSWFS](webservice W, ownerInfo *smoothoperatorv1.Owne
 			return createConfigForWFS(WFS, ownerInfo)
 		}
 	case *pdoknlv3.WMS:
-		if _, ok := any(webservice).(*pdoknlv3.WMS); ok {
-			return "", errors.New("not implemented for WMS")
+		if WMS, ok := any(webservice).(*pdoknlv3.WMS); ok {
+			return createConfigForWMS(WMS, ownerInfo)
 		}
 	default:
 		return "", fmt.Errorf("unexpected input, webservice should be of type WFS or WMS, webservice: %v", webservice)
@@ -71,3 +70,16 @@ func createConfigForWFS(wfs *pdoknlv3.WFS, ownerInfo *smoothoperatorv1.OwnerInfo
 	}
 	return string(jsonConfig), nil
 }
+
+func createConfigForWMS(wms *pdoknlv3.WMS, ownerInfo *smoothoperatorv1.OwnerInfo) (config string, err error) {
+	input, err := MapWMSToMapfileGeneratorInput(wms, ownerInfo)
+	if err != nil {
+		return "", err
+	}
+
+	jsonConfig, err := json.MarshalIndent(input, "", "    ")
+	if err != nil {
+		return "", err
+	}
+	return string(jsonConfig), nil
+}