Example Python code and XML-file for editing metadata in ArcGIS Online

ArcGIS Online hosted feature service in lezen in R

This example demonstrates how to read and visualize the Dutch national heritage register (Rijksmonumenten) from an ArcGIS Online hosted feature service. It shows the full workflow of querying the service's metadata, counting features, and paginating through all 64,020 records, then maps them with `tmap` and `sf`. The code uses the `httr` and `jsonlite` packages to construct URL requests and parse JSON, while `sf::st_read()` reads the GeoJSON response. It explicitly checks pagination support via the service’s `advancedQueryCapabilities` and explains an anomaly where the initial page returns more records than `maxRecordCount` suggests. The final map is rendered with `qtm()`, and summary statistics (min/max OBJECTID) are computed via the service’s `outStatistics` parameter.

46% match

<title>{$info[1]}

This example demonstrates a metadata transformation from TEI to MODS, converting bibliographic details from an XML source document. The code uses XQuery 3.0 with custom functions `local:gather-information` and `local:generate-mods` to extract fields like title, author, language, publication info, and abstract from the TEI file, then constructs a MODS record and stores it via `xmldb:store`. The visualization shows how structured metadata can be programmatically reshaped between standards, relying on XPath queries and namespace declarations to map data accurately.

45% match

Converts from XML to GEOJson

This example shows the conversion of a single XML item containing place-name, latitude, and longitude data into a GeoJSON FeatureCollection with a Point geometry. It demonstrates a direct data-shape transformation. The code constructs the output JSON structure explicitly, mapping the XML text value to a `properties` field and the numeric coordinates into a `coordinates` array. The conversion relies on the MarkLogic `json:serialize` function to produce the final GeoJSON output from the hand-built `json` element. The snippet does not include any rendering or mapping library.

Get Zotero JSON from API

This example demonstrates how to retrieve and parse Zotero library items as structured XML from the Zotero API. It uses the XQuery `fetch:text` function to download JSON data from the API endpoint, then parses that JSON with `json:parse`. The code extracts all `note` elements from the parsed data and converts each into an XML fragment using `fn:parse-xml-fragment`. This approach shows a direct pipeline from API response to manipulable XML nodes, useful for further processing or transformation in an XQuery environment.

Prototype for https://knowledge.safe.com/questions/88427/using-xfmap-to-create-multiple-values-for-one-attr.html

This prototype demonstrates how to use the XFMAP (XML Feature Mapping) to generate multiple attribute values from a single XML source within an FME workspace. It reads an XML file, parses its structure, and produces features with repeated attributes—enabling the transformation of nested XML elements into flat, multi-valued table rows. The workspace visually maps out the data flow with reader, transformer, and writer nodes, showing how list attributes and feature merging can be orchestrated to flatten hierarchical data. The visualization highlights the workflow logic, not the data itself, serving as a template for FME users seeking to handle similar XML-to-attribute transformations.

Adapted the script by Yonhah: https://github.com/yonghah/esri2sf/blob/master/R/esri2sf.R

This example demonstrates how to fetch GIS feature data from an ArcGIS REST server and convert it into simple features for spatial analysis in R. It shows a workflow that queries a specified layer, retrieves object IDs, and then pulls the corresponding attributes and geometries as GeoJSON. The code relies on the `httr` package for HTTP requests, `jsonlite` for parsing JSON responses, and `sf` for handling spatial data. It also includes a helper function to generate authentication tokens when the server requires login. The implementation uses the ArcGIS REST API's `query` endpoint to request data in batches of 500 IDs, ensuring efficient retrieval of large datasets.

A model MODS document

This example shows a blank metadata template for a MODS document, a standard XML format for bibliographic records. It visualizes the empty structure of the schema, including fields for title, creator, language, subject, and publication details. The code parses the XML using JavaScript’s DOMParser and renders the hierarchy as a node-link diagram with d3.forceSimulation for layout and d3.hierarchy for tree traversal. The visualization does not load external data beyond the provided mods.xml file, focusing solely on the schema’s skeleton.

43% match

FME workspace for https://knowledge.safe.com/questions/88318/api-watch.html

This example uses an FME workspace to demonstrate how to monitor an ArcGIS Open Data REST API for changes. A Creator transformer initiates the workflow, and an HTTPCaller sends a request to the API endpoint with query parameters for the catalog and page size. The workspace is designed to retrieve data from the specified ArcGIS portal, showcasing a pattern for API polling or scheduled data extraction within FME.