/**********************************************************************

* $id$

*

* Project: MapServer

* Purpose: OGCAPI Implementation

* Author: Steve Lime and the MapServer team.

*

**********************************************************************

* Copyright (c) 1996-2005 Regents of the University of Minnesota.

*

* Permission is hereby granted, free of charge, to any person obtaining a

* copy of this software and associated documentation files (the "Software"),

* to deal in the Software without restriction, including without limitation

* the rights to use, copy, modify, merge, publish, distribute, sublicense,

* and/or sell copies of the Software, and to permit persons to whom the

* Software is furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies of this Software or works derived from this Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

****************************************************************************/

#include "mapserver.h"

#include "mapogcapi.h"

#include "mapows.h"

#include "mapgml.h"

#include "maptime.h"

#include "mapogcfilter.h"

#include "cql2json.h"

#include "cql2text.h"

#include "cpl_conv.h"

#include "third-party/include_nlohmann_json.hpp"

#include "third-party/include_pantor_inja.hpp"

#include <algorithm>

#include <map>

#include <set>

#include <string>

#include <iostream>

#include <utility>

using namespace inja;

using json = nlohmann::json;

#define OGCAPI_DEFAULT_TITLE "MapServer OGC API"

/*

** HTML Templates

*/

#define OGCAPI_TEMPLATE_HTML_LANDING "landing.html"

#define OGCAPI_TEMPLATE_HTML_CONFORMANCE "conformance.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTION "collection.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTIONS "collections.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTION_ITEMS "collection-items.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTION_ITEM "collection-item.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTION_QUERYABLES "collection-queryables.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTION_SORTABLES "collection-sortables.html"

#define OGCAPI_TEMPLATE_HTML_COLLECTION_SCHEMA "collection-schema.html"

#define OGCAPI_TEMPLATE_HTML_OPENAPI "openapi.html"

#define OGCAPI_DEFAULT_LIMIT 10 // by specification

#define OGCAPI_MAX_LIMIT 10000

#define OGCAPI_DEFAULT_GEOMETRY_PRECISION 6

constexpr const char *EPSG_PREFIX_URL =

"http://www.opengis.net/def/crs/EPSG/0/";

constexpr const char *CRS84_URL =

"http://www.opengis.net/def/crs/OGC/1.3/CRS84";

#ifdef USE_OGCAPI_SVR

/** Returns whether we enforce compliance mode. Defaults to true */

static bool msOGCAPIComplianceMode(const mapObj *map) {

const char *compliance_mode =

msOWSLookupMetadata(&(map->web.metadata), "A", "compliance_mode");

return compliance_mode == NULL || strcasecmp(compliance_mode, "true") == 0;

}

/*

** Returns a JSON object using and a description.

*/

void msOGCAPIOutputError(OGCAPIErrorType errorType,

const std::string &description) {

const char *code = "";

const char *status = "";

switch (errorType) {

case OGCAPI_SERVER_ERROR: {

code = "ServerError";

status = "500";

break;

}

case OGCAPI_CONFIG_ERROR: {

code = "ConfigError";

status = "500";

break;

}

case OGCAPI_PARAM_ERROR: {

code = "InvalidParameterValue";

status = "400";

break;

}

case OGCAPI_NOT_FOUND_ERROR: {

code = "NotFound";

status = "404";

break;

}

}

json j = {{"code", code}, {"description", description}};

msIO_setHeader("Content-Type", "%s", OGCAPI_MIMETYPE_JSON);

msIO_setHeader("Status", "%s", status);

msIO_sendHeaders();

msIO_printf("%s\n", j.dump().c_str());

}

static int includeLayer(mapObj *map, layerObj *layer) {

if (!msOWSRequestIsEnabled(map, layer, "AO", "OGCAPI", MS_FALSE) ||

!msIsLayerSupportedForWFSOrOAPIF(layer) || !msIsLayerQueryable(layer)) {

return MS_FALSE;

} else {

return MS_TRUE;

}

}

/*

** Get stuff...

*/

/*

** Returns the value associated with an item from the request's query string and

*NULL if the item was not found.

*/

static const char *getRequestParameter(const cgiRequestObj *request,

const char *item) {

for (int i = 0; i < request->NumParams; i++) {

if (strcmp(item, request->ParamNames[i]) == 0)

return request->ParamValues[i];

}

return nullptr;

}

static int getMaxLimit(mapObj *map, layerObj *layer) {

int max_limit = OGCAPI_MAX_LIMIT;

const char *value;

// check metadata, layer then map

value = msOWSLookupMetadata(&(layer->metadata), "A", "max_limit");

if (value == NULL)

value = msOWSLookupMetadata(&(map->web.metadata), "A", "max_limit");

if (value != NULL) {

int status = msStringToInt(value, &max_limit, 10);

if (status != MS_SUCCESS)

max_limit = OGCAPI_MAX_LIMIT; // conversion failed

}

return max_limit;

}

static int getDefaultLimit(const mapObj *map, const layerObj *layer) {

int default_limit = OGCAPI_DEFAULT_LIMIT;

// check metadata, layer then map

const char *value =

msOWSLookupMetadata(&(layer->metadata), "A", "default_limit");

if (value == NULL)

value = msOWSLookupMetadata(&(map->web.metadata), "A", "default_limit");

if (value != NULL) {

int status = msStringToInt(value, &default_limit, 10);

if (status != MS_SUCCESS)

default_limit = OGCAPI_DEFAULT_LIMIT; // conversion failed

}

return default_limit;

}

static std::string getExtraParameterString(const mapObj *map,

const layerObj *layer) {

std::string extra_params;

// first check layer metadata if layer is not null

if (layer) {

const char *layerVal =

msOWSLookupMetadata(&(layer->metadata), "AO", "extra_params");

if (layerVal)

extra_params = std::string("&") + layerVal;

}

if (extra_params.empty() && map) {

const char *mapVal =

msOWSLookupMetadata(&(map->web.metadata), "AO", "extra_params");

if (mapVal)

extra_params = std::string("&") + mapVal;

}

return extra_params;

}

static std::set<std::string>

getExtraParameters(const char *pszExtraParameters) {

std::set<std::string> ret;

for (const auto &param : msStringSplit(pszExtraParameters, '&')) {

const auto keyValue = msStringSplit(param.c_str(), '=');

if (!keyValue.empty())

ret.insert(keyValue[0]);

}

return ret;

}

static std::set<std::string> getExtraParameters(const mapObj *map,

const layerObj *layer) {

// first check layer metadata if layer is not null

if (layer) {

const char *layerVal =

msOWSLookupMetadata(&(layer->metadata), "AO", "extra_params");

if (layerVal)

return getExtraParameters(layerVal);

}

if (map) {

const char *mapVal =

msOWSLookupMetadata(&(map->web.metadata), "AO", "extra_params");

if (mapVal)

return getExtraParameters(mapVal);

}

return {};

}

static bool

msOOGCAPICheckQueryParameters(const mapObj *map, const cgiRequestObj *request,

const std::set<std::string> &allowedParameters) {

if (msOGCAPIComplianceMode(map)) {

for (int j = 0; j < request->NumParams; j++) {

const char *paramName = request->ParamNames[j];

if (allowedParameters.find(paramName) == allowedParameters.end()) {

msOGCAPIOutputError(

OGCAPI_PARAM_ERROR,

(std::string("Unknown query parameter: ") + paramName).c_str());

return false;

}

}

}

return true;

}

static std::string getItemAliasOrName(const layerObj *layer,

const std::string &item) {

std::string key = item;

key += "_alias";

if (const char *value =

msOWSLookupMetadata(&(layer->metadata), "OGA", key.c_str())) {

return value;

}

return item;

}

static const char *getGeometryName(const layerObj *layer) {

const char *geometryName =

msOWSLookupMetadata(&(layer->metadata), "A", "geometry_name");

if (!geometryName)

geometryName = "geom";

return geometryName;

}

static const char *getGeometryFormat(const layerObj *layer) {

const char *geometryFormat =

msOWSLookupMetadata(&(layer->metadata), "A", "geometry_format");

if (layer->type == MS_LAYER_POINT)

geometryFormat = "geometry-point-or-multipoint";

else if (layer->type == MS_LAYER_LINE)

geometryFormat = "geometry-linestring-or-multilinestring";

else if (layer->type == MS_LAYER_POLYGON)

geometryFormat = "geometry-polygon-or-multipolygon";

else if (!geometryFormat)

geometryFormat = "geometry-any";

return geometryFormat;

}

namespace {

struct CaseInsensitiveComparator {

bool operator()(const std::string &a, const std::string &b) const {

return strcasecmp(a.c_str(), b.c_str()) < 0;

}

};

} // namespace

/** Return the list of queryable items */

static std::vector<std::string> msOOGCAPIGetLayerQueryables(

layerObj *layer, const std::set<std::string> &reservedParams, bool &error) {

error = false;

std::vector<std::string> queryableItems;

if (const char *value =

msOWSLookupMetadata(&(layer->metadata), "OGA", "queryable_items")) {

queryableItems = msStringSplit(value, ',');

if (!queryableItems.empty()) {

if (msLayerOpen(layer) != MS_SUCCESS ||

msLayerGetItems(layer) != MS_SUCCESS) {

msOGCAPIOutputError(OGCAPI_SERVER_ERROR, "Cannot get layer fields");

return {};

}

if (queryableItems[0] == "all") {

queryableItems.clear();

for (int i = 0; i < layer->numitems; ++i) {

if (reservedParams.find(layer->items[i]) == reservedParams.end()) {

queryableItems.push_back(layer->items[i]);

}

}

} else {

std::set<std::string, CaseInsensitiveComparator> validItems;

for (int i = 0; i < layer->numitems; ++i) {

validItems.insert(layer->items[i]);

}

for (const auto &item : queryableItems) {

if (validItems.find(item) == validItems.end()) {

// This is not a known field

msOGCAPIOutputError(OGCAPI_CONFIG_ERROR,

"Invalid item '" + item +

"' in queryable_items");

error = true;

return {};

} else if (reservedParams.find(item) != reservedParams.end()) {

// Check clashes with OGC API Features reserved keywords (bbox,

// etc.)

msOGCAPIOutputError(

OGCAPI_CONFIG_ERROR,

"Item '" + item +

"' in queryable_items is a reserved parameter name");

error = true;

return {};

}

}

}

}

}

return queryableItems;

}

/** Return the list of sortable items */

static std::vector<std::string> msOOGCAPIGetLayerSortables(

layerObj *layer, const std::set<std::string> &reservedParams, bool &error) {

error = false;

std::vector<std::string> sortableItems;

if (const char *value =

msOWSLookupMetadata(&(layer->metadata), "OGA", "sortable_items")) {

sortableItems = msStringSplit(value, ',');

if (!sortableItems.empty()) {

if (msLayerOpen(layer) != MS_SUCCESS ||

msLayerGetItems(layer) != MS_SUCCESS) {

msOGCAPIOutputError(OGCAPI_SERVER_ERROR, "Cannot get layer fields");

return {};

}

if (sortableItems[0] == "all") {

sortableItems.clear();

for (int i = 0; i < layer->numitems; ++i) {

if (reservedParams.find(layer->items[i]) == reservedParams.end()) {

sortableItems.push_back(layer->items[i]);

}

}

} else {

std::set<std::string, CaseInsensitiveComparator> validItems;

for (int i = 0; i < layer->numitems; ++i) {

validItems.insert(layer->items[i]);

}

for (const auto &item : sortableItems) {

if (validItems.find(item) == validItems.end()) {

// This is not a known field

msOGCAPIOutputError(OGCAPI_CONFIG_ERROR, "Invalid item '" + item +

"' in sortable_items");

error = true;

return {};

} else if (reservedParams.find(item) != reservedParams.end()) {

// Check clashes with OGC API Features reserved keywords (bbox,

// etc.)

msOGCAPIOutputError(

OGCAPI_CONFIG_ERROR,

"Item '" + item +

"' in sortable_items is a reserved parameter name");

error = true;

return {};

}

}

}

}

}

return sortableItems;

}

/*

** Returns the limit as an int - between 1 and getMaxLimit(). We always return a

*valid value...

*/

static int getLimit(mapObj *map, cgiRequestObj *request, layerObj *layer,

int *limit) {

int status;

const char *p;

int max_limit;

max_limit = getMaxLimit(map, layer);

p = getRequestParameter(request, "limit");

if (!p || (p && strlen(p) == 0)) { // missing or empty

*limit = MS_MIN(getDefaultLimit(map, layer),

max_limit); // max could be smaller than the default

} else {

status = msStringToInt(p, limit, 10);

if (status != MS_SUCCESS)

return MS_FAILURE;

if (*limit <= 0) {

*limit = MS_MIN(getDefaultLimit(map, layer),

max_limit); // max could be smaller than the default

} else {

*limit = MS_MIN(*limit, max_limit);

}

}

return MS_SUCCESS;

}

// Return the content of the "crs" member of the /collections/{name} response

static json getCrsList(mapObj *map, layerObj *layer) {

char *pszSRSList = NULL;

msOWSGetEPSGProj(&(layer->projection), &(layer->metadata), "AOF", MS_FALSE,

&pszSRSList);

if (!pszSRSList)

msOWSGetEPSGProj(&(map->projection), &(map->web.metadata), "AOF", MS_FALSE,

&pszSRSList);

json jCrsList;

if (pszSRSList) {

const auto tokens = msStringSplit(pszSRSList, ' ');

for (const auto &crs : tokens) {

if (crs.find("EPSG:") == 0) {

if (jCrsList.empty()) {

jCrsList.push_back(CRS84_URL);

}

const std::string url =

std::string(EPSG_PREFIX_URL) + crs.substr(strlen("EPSG:"));

jCrsList.push_back(url);

}

}

msFree(pszSRSList);

}

return jCrsList;

}

// Return the content of the "storageCrs" member of the /collections/{name}

// response

static std::string getStorageCrs(layerObj *layer) {

std::string storageCrs;

char *pszFirstSRS = nullptr;

msOWSGetEPSGProj(&(layer->projection), &(layer->metadata), "AOF", MS_TRUE,

&pszFirstSRS);

if (pszFirstSRS) {

if (std::string(pszFirstSRS).find("EPSG:") == 0) {

storageCrs =

std::string(EPSG_PREFIX_URL) + (pszFirstSRS + strlen("EPSG:"));

}

msFree(pszFirstSRS);

}

return storageCrs;

}

/*

** Returns the bbox in output CRS (CRS84 by default, or "bbox-crs" request

*parameter when specified)

*/

static bool getBbox(mapObj *map, layerObj *layer, cgiRequestObj *request,

rectObj *bbox, projectionObj *outputProj) {

int status;

const char *bboxParam = getRequestParameter(request, "bbox");

if (!bboxParam || strlen(bboxParam) == 0) { // missing or empty extent

rectObj rect;

if (FLTLayerSetInvalidRectIfSupported(map, layer, &rect, "AO")) {

bbox->minx = rect.minx;

bbox->miny = rect.miny;

bbox->maxx = rect.maxx;

bbox->maxy = rect.maxy;

} else {

// assign map->extent (no projection necessary)

bbox->minx = map->extent.minx;

bbox->miny = map->extent.miny;

bbox->maxx = map->extent.maxx;

bbox->maxy = map->extent.maxy;

}

} else {

const auto tokens = msStringSplit(bboxParam, ',');

if (tokens.size() != 4) {

msOGCAPIOutputError(OGCAPI_PARAM_ERROR, "Bad value for bbox.");

return false;

}

double values[4];

for (int i = 0; i < 4; i++) {

status = msStringToDouble(tokens[i].c_str(), &values[i]);

if (status != MS_SUCCESS) {

msOGCAPIOutputError(OGCAPI_PARAM_ERROR, "Bad value for bbox.");

return false;

}

}

bbox->minx = values[0]; // assign

bbox->miny = values[1];

bbox->maxx = values[2];

bbox->maxy = values[3];

// validate bbox is well-formed (degenerate is ok)

if (MS_VALID_SEARCH_EXTENT(*bbox) != MS_TRUE) {

msOGCAPIOutputError(OGCAPI_PARAM_ERROR, "Bad value for bbox.");

return false;

}

std::string bboxCrs = "EPSG:4326";

bool axisInverted =

false; // because above EPSG:4326 is meant to be OGC:CRS84 actually

const char *bboxCrsParam = getRequestParameter(request, "bbox-crs");

if (bboxCrsParam) {

bool isExpectedCrs = false;

for (const auto &crsItem : getCrsList(map, layer)) {

if (bboxCrsParam == crsItem.get<std::string>()) {

isExpectedCrs = true;

break;

}

}

if (!isExpectedCrs) {

msOGCAPIOutputError(OGCAPI_PARAM_ERROR, "Bad value for bbox-crs.");

return false;

}

if (std::string(bboxCrsParam) != CRS84_URL) {

if (std::string(bboxCrsParam).find(EPSG_PREFIX_URL) == 0) {

const char *code = bboxCrsParam + strlen(EPSG_PREFIX_URL);

bboxCrs = std::string("EPSG:") + code;

axisInverted = msIsAxisInverted(atoi(code));

}

}

}

if (axisInverted) {

std::swap(bbox->minx, bbox->miny);

std::swap(bbox->maxx, bbox->maxy);

}

projectionObj bboxProj;

msInitProjection(&bboxProj);

msProjectionInheritContextFrom(&bboxProj, &(map->projection));

if (msLoadProjectionString(&bboxProj, bboxCrs.c_str()) != 0) {

msFreeProjection(&bboxProj);

msOGCAPIOutputError(OGCAPI_SERVER_ERROR, "Cannot process bbox-crs.");

return false;

}

status = msProjectRect(&bboxProj, outputProj, bbox);

msFreeProjection(&bboxProj);

if (status != MS_SUCCESS) {

msOGCAPIOutputError(OGCAPI_SERVER_ERROR,

"Cannot reproject bbox from bbox-crs to output CRS.");

return false;

}

}

return true;

}

/*

** Returns the template directory location or NULL if it isn't set.

*/

std::string msOGCAPIGetTemplateDirectory(const mapObj *map, const char *key,

const char *envvar) {

const char *directory = NULL;

if (map != NULL) {

directory = msOWSLookupMetadata(&(map->web.metadata), "A", key);

}

if (directory == NULL) {

directory = CPLGetConfigOption(envvar, NULL);

}

std::string s;

if (directory != NULL) {

s = directory;

if (!s.empty() && (s.back() != '/' && s.back() != '\\')) {

// add a trailing slash if missing

std::string slash = "/";

#ifdef _WIN32

slash = "\\";

#endif

s += slash;

}

}

return s;

}

/*

** Returns the service title from oga_{key} and/or ows_{key} or a default value

*if not set.

*/

static const char *getWebMetadata(const mapObj *map, const char *domain,

const char *key, const char *defaultVal) {

const char *value;

if ((value = msOWSLookupMetadata(&(map->web.metadata), domain, key)) != NULL)

return value;

else

return defaultVal;

}

/*

** Returns the service title from oga|ows_title or a default value if not set.

*/

static const char *getTitle(const mapObj *map) {

return getWebMetadata(map, "OA", "title", OGCAPI_DEFAULT_TITLE);

}

/*

** Returns the API root URL from oga_onlineresource or builds a value if not

*set.

*/

std::string msOGCAPIGetApiRootUrl(const mapObj *map,

const cgiRequestObj *request,

const char *namespaces) {

const char *root;

if ((root = msOWSLookupMetadata(&(map->web.metadata), namespaces,

"onlineresource")) != NULL) {

return std::string(root);

}

std::string api_root;

if (char *res = msBuildOnlineResource(NULL, request)) {

api_root = res;

free(res);

// find last ogcapi in the string and strip the rest to get the root API

std::size_t pos = api_root.rfind("ogcapi");

if (pos != std::string::npos) {

api_root = api_root.substr(0, pos + std::string("ogcapi").size());

} else {

// strip trailing '?' or '/' and append "/ogcapi"

while (!api_root.empty() &&

(api_root.back() == '?' || api_root.back() == '/')) {

api_root.pop_back();

}

api_root += "/ogcapi";

}

}

if (api_root.empty()) {

api_root = "/ogcapi";

}

return api_root;

}

static json getFeatureConstant(const gmlConstantObj *constant) {

json j; // empty (null)

if (!constant)

throw std::runtime_error("Null constant metadata.");

if (!constant->value)

return j;

// initialize

j = {{constant->name, constant->value}};

return j;

}

static json getFeatureItem(const gmlItemObj *item, const char *value) {

json j; // empty (null)

const char *key;

if (!item)

throw std::runtime_error("Null item metadata.");

if (!item->visible)

return j;

if (item->alias)

key = item->alias;

else

key = item->name;

// initialize

j = {{key, value}};

if (item->type &&

(EQUAL(item->type, "Date") || EQUAL(item->type, "DateTime") ||

EQUAL(item->type, "Time"))) {

struct tm tm;

if (msParseTime(value, &tm) == MS_TRUE) {

char tmpValue[64];

if (EQUAL(item->type, "Date"))

snprintf(tmpValue, sizeof(tmpValue), "%04d-%02d-%02d",

tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);

else if (EQUAL(item->type, "Time"))

snprintf(tmpValue, sizeof(tmpValue), "%02d:%02d:%02dZ", tm.tm_hour,

tm.tm_min, tm.tm_sec);

else

snprintf(tmpValue, sizeof(tmpValue), "%04d-%02d-%02dT%02d:%02d:%02dZ",

tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,

tm.tm_min, tm.tm_sec);

j = {{key, tmpValue}};

}

} else if (item->type &&

(EQUAL(item->type, "Integer") || EQUAL(item->type, "Long"))) {

try {

j = {{key, std::stoll(value)}};

} catch (const std::exception &) {

}

} else if (item->type && EQUAL(item->type, "Real")) {

try {

j = {{key, std::stod(value)}};

} catch (const std::exception &) {

}

} else if (item->type && EQUAL(item->type, "Boolean")) {

if (EQUAL(value, "0") || EQUAL(value, "false")) {

j = {{key, false}};

} else {

j = {{key, true}};

}

}

return j;

}

static double round_down(double value, int decimal_places) {

const double multiplier = std::pow(10.0, decimal_places);

return std::floor(value * multiplier) / multiplier;

}

// https://stackoverflow.com/questions/25925290/c-round-a-double-up-to-2-decimal-places

static double round_up(double value, int decimal_places) {

const double multiplier = std::pow(10.0, decimal_places);

return std::ceil(value * multiplier) / multiplier;

}

static json getFeatureGeometry(shapeObj *shape, int precision,

bool outputCrsAxisInverted) {

json geometry; // empty (null)

int *outerList = NULL, numOuterRings = 0;

if (!shape)

throw std::runtime_error("Null shape.");

switch (shape->type) {

case (MS_SHAPE_POINT):

if (shape->numlines == 0 ||

shape->line[0].numpoints == 0) // not enough info for a point

return geometry;

if (shape->line[0].numpoints == 1) {

geometry["type"] = "Point";

double x = shape->line[0].point[0].x;

double y = shape->line[0].point[0].y;

if (outputCrsAxisInverted)

std::swap(x, y);

geometry["coordinates"] = {round_up(x, precision),

round_up(y, precision)};

} else {

geometry["type"] = "MultiPoint";

geometry["coordinates"] = json::array();

for (int j = 0; j < shape->line[0].numpoints; j++) {

double x = shape->line[0].point[j].x;

double y = shape->line[0].point[j].y;

if (outputCrsAxisInverted)

std::swap(x, y);

geometry["coordinates"].push_back(

{round_up(x, precision), round_up(y, precision)});

}

}

break;

case (MS_SHAPE_LINE):

if (shape->numlines == 0 ||

shape->line[0].numpoints < 2) // not enough info for a line

return geometry;

if (shape->numlines == 1) {

geometry["type"] = "LineString";

geometry["coordinates"] = json::array();

for (int j = 0; j < shape->line[0].numpoints; j++) {

double x = shape->line[0].point[j].x;

double y = shape->line[0].point[j].y;

if (outputCrsAxisInverted)

std::swap(x, y);

geometry["coordinates"].push_back(

{round_up(x, precision), round_up(y, precision)});

}

} else {

geometry["type"] = "MultiLineString";

geometry["coordinates"] = json::array();

for (int i = 0; i < shape->numlines; i++) {

json part = json::array();

for (int j = 0; j < shape->line[i].numpoints; j++) {

double x = shape->line[i].point[j].x;

double y = shape->line[i].point[j].y;

if (outputCrsAxisInverted)

std::swap(x, y);

part.push_back({round_up(x, precision), round_up(y, precision)});

}

geometry["coordinates"].push_back(part);

}

}

break;

case (MS_SHAPE_POLYGON):

if (shape->numlines == 0 ||

shape->line[0].numpoints <

4) // not enough info for a polygon (first=last)

return geometry;

outerList = msGetOuterList(shape);

if (outerList == NULL)

throw std::runtime_error("Unable to allocate list of outer rings.");

for (int k = 0; k < shape->numlines; k++) {

if (outerList[k] == MS_TRUE)

numOuterRings++;

}

if (numOuterRings == 1) {

geometry["type"] = "Polygon";

geometry["coordinates"] = json::array();

for (int i = 0; i < shape->numlines; i++) {

json part = json::array();

for (int j = 0; j < shape->line[i].numpoints; j++) {

double x = shape->line[i].point[j].x;

double y = shape->line[i].point[j].y;

if (outputCrsAxisInverted)

std::swap(x, y);

part.push_back({round_up(x, precision), round_up(y, precision)});

}

geometry["coordinates"].push_back(part);

}

} else {

geometry["type"] = "MultiPolygon";

geometry["coordinates"] = json::array();

for (int k = 0; k < shape->numlines; k++) {

if (outerList[k] ==

MS_TRUE) { // outer ring: generate polygon and add to coordinates

int *innerList = msGetInnerList(shape, k, outerList);

if (innerList == NULL) {

msFree(outerList);

throw std::runtime_error("Unable to allocate list of inner rings.");

}

json polygon = json::array();

for (int i = 0; i < shape->numlines; i++) {

if (i == k ||

innerList[i] ==

MS_TRUE) { // add outer ring (k) and any inner rings

json part = json::array();

for (int j = 0; j < shape->line[i].numpoints; j++) {

double x = shape->line[i].point[j].x;

double y = shape->line[i].point[j].y;

if (outputCrsAxisInverted)

std::swap(x, y);

part.push_back(

{round_up(x, precision), round_up(y, precision)});

}

polygon.push_back(part);

}

}

msFree(innerList);

geometry["coordinates"].push_back(polygon);

}

}

}

msFree(outerList);

break;

default:

throw std::runtime_error("Invalid shape type.");

break;

}

return geometry;

}

/*

** Return a GeoJSON representation of a shape.

*/

static json getFeature(layerObj *layer, shapeObj *shape, gmlItemListObj *items,

gmlConstantListObj *constants, int geometry_precision,

bool outputCrsAxisInverted) {

int i;

json feature; // empty (null)

if (!layer || !shape)

throw std::runtime_error("Null arguments.");

// initialize

feature = {{"type", "Feature"}, {"properties", json::object()}};

// id

const char *featureIdItem =

msOWSLookupMetadata(&(layer->metadata), "AGFO", "featureid");

if (featureIdItem == NULL)

throw std::runtime_error(

"Missing required featureid metadata."); // should have been trapped

// earlier

for (i = 0; i < items->numitems; i++) {

if (strcasecmp(featureIdItem, items->items[i].name) == 0) {

feature["id"] = shape->values[i];

break;

}

}

if (i == items->numitems)

throw std::runtime_error("Feature id not found.");

// properties - build from items and constants, no group support for now

for (int i = 0; i < items->numitems; i++) {

try {

json item = getFeatureItem(&(items->items[i]), shape->values[i]);

if (!item.is_null())

feature["properties"].insert(item.begin(), item.end());

} catch (const std::runtime_error &) {

throw std::runtime_error("Error fetching item.");

}

}

for (int i = 0; i < constants->numconstants; i++) {

try {

json constant = getFeatureConstant(&(constants->constants[i]));

if (!constant.is_null())

feature["properties"].insert(constant.begin(), constant.end());

} catch (const std::runtime_error &) {

throw std::runtime_error("Error fetching constant.");

}

}

// geometry

try {

json geometry =

getFeatureGeometry(shape, geometry_precision, outputCrsAxisInverted);

if (!geometry.is_null())

feature["geometry"] = std::move(geometry);

} catch (const std::runtime_error &) {

throw std::runtime_error("Error fetching geometry.");

}

return feature;

}

static json getLink(hashTableObj *metadata, const std::string &name) {

json link;

const char *href =

msOWSLookupMetadata(metadata, "A", (name + "_href").c_str());

if (!href)

throw std::runtime_error("Missing required link href property.");

const char *title =

msOWSLookupMetadata(metadata, "A", (name + "_title").c_str());

const char *type =

msOWSLookupMetadata(metadata, "A", (name + "_type").c_str());

link = {{"href", href},

{"title", title ? title : href},

{"type", type ? type : "text/html"}};

return link;

}

static const char *getCollectionDescription(layerObj *layer) {

const char *description =

msOWSLookupMetadata(&(layer->metadata), "A", "description");

if (!description)

description = msOWSLookupMetadata(&(layer->metadata), "OF",

"abstract"); // fallback on abstract

if (!description)

description =

"<!-- Warning: unable to set the collection description. -->"; // finally

// a

// warning...

return description;

}

static const char *getCollectionTitle(layerObj *layer) {

const char *title = msOWSLookupMetadata(&(layer->metadata), "AOF", "title");

if (!title)

title = layer->name; // revert to layer name if no title found

return title;

}

static int getGeometryPrecision(mapObj *map, layerObj *layer) {

int geometry_precision = OGCAPI_DEFAULT_GEOMETRY_PRECISION;