forked from MapComplete/MapComplete
291 lines
12 KiB
TypeScript
291 lines
12 KiB
TypeScript
import { SpecialVisualization, SpecialVisualizationState } from "../SpecialVisualization"
|
|
import Maproulette from "../../Logic/Maproulette"
|
|
import SvelteUIElement from "../Base/SvelteUIElement"
|
|
import MaprouletteSetStatus from "../MapRoulette/MaprouletteSetStatus.svelte"
|
|
import TagApplyButton from "../Popup/TagApplyButton"
|
|
import { PointImportButtonViz } from "../Popup/ImportButtons/PointImportButtonViz"
|
|
import WayImportButtonViz from "../Popup/ImportButtons/WayImportButtonViz"
|
|
import ConflateImportButtonViz from "../Popup/ImportButtons/ConflateImportButtonViz"
|
|
import { PlantNetDetectionViz } from "../Popup/PlantNetDetectionViz"
|
|
import Constants from "../../Models/Constants"
|
|
import { Store, Stores, UIEventSource } from "../../Logic/UIEventSource"
|
|
import { Feature, GeoJsonProperties } from "geojson"
|
|
import LayerConfig from "../../Models/ThemeConfig/LayerConfig"
|
|
import BaseUIElement from "../BaseUIElement"
|
|
import LinkedDataLoader from "../../Logic/Web/LinkedDataLoader"
|
|
import Toggle from "../Input/Toggle"
|
|
import ComparisonTool from "../Comparison/ComparisonTool.svelte"
|
|
import { Utils } from "../../Utils"
|
|
|
|
export class DataImportSpecialVisualisations {
|
|
public static initList(): (SpecialVisualization & { group })[] {
|
|
return [
|
|
new TagApplyButton(),
|
|
new PointImportButtonViz(),
|
|
new WayImportButtonViz(),
|
|
new ConflateImportButtonViz(),
|
|
new PlantNetDetectionViz(),
|
|
{
|
|
funcName: "maproulette_set_status",
|
|
group: "data_import",
|
|
docs: "Change the status of the given MapRoulette task",
|
|
needsUrls: [Maproulette.defaultEndpoint],
|
|
example:
|
|
" The following example sets the status to '2' (false positive)\n" +
|
|
"\n" +
|
|
"```json\n" +
|
|
"{\n" +
|
|
" \"id\": \"mark_duplicate\",\n" +
|
|
" \"render\": {\n" +
|
|
" \"special\": {\n" +
|
|
" \"type\": \"maproulette_set_status\",\n" +
|
|
" \"message\": {\n" +
|
|
" \"en\": \"Mark as not found or false positive\"\n" +
|
|
" },\n" +
|
|
" \"status\": \"2\",\n" +
|
|
" \"image\": \"close\"\n" +
|
|
" }\n" +
|
|
" }\n" +
|
|
"}\n" +
|
|
"```",
|
|
args: [
|
|
{
|
|
name: "message",
|
|
doc: "A message to show to the user"
|
|
},
|
|
{
|
|
name: "image",
|
|
doc: "Image to show",
|
|
defaultValue: "confirm"
|
|
},
|
|
{
|
|
name: "message_confirm",
|
|
doc: "What to show when the task is closed, either by the user or was already closed."
|
|
},
|
|
{
|
|
name: "status",
|
|
doc: "A statuscode to apply when the button is clicked. 1 = `close`, 2 = `false_positive`, 3 = `skip`, 4 = `deleted`, 5 = `already fixed` (on the map, e.g. for duplicates), 6 = `too hard`",
|
|
defaultValue: "1"
|
|
},
|
|
{
|
|
name: "maproulette_id",
|
|
doc: "The property name containing the maproulette id",
|
|
defaultValue: "mr_taskId"
|
|
},
|
|
{
|
|
name: "ask_feedback",
|
|
doc: "If not an empty string, this will be used as question to ask some additional feedback. A text field will be added",
|
|
defaultValue: ""
|
|
}
|
|
],
|
|
|
|
constr: (state, tagsSource, args) => {
|
|
let [
|
|
message,
|
|
image,
|
|
message_closed,
|
|
statusToSet,
|
|
maproulette_id_key,
|
|
askFeedback
|
|
] = args
|
|
if (image === "") {
|
|
image = "confirm"
|
|
}
|
|
if (maproulette_id_key === "" || maproulette_id_key === undefined) {
|
|
maproulette_id_key = "mr_taskId"
|
|
}
|
|
statusToSet = statusToSet ?? "1"
|
|
return new SvelteUIElement(MaprouletteSetStatus, {
|
|
state,
|
|
tags: tagsSource,
|
|
message,
|
|
image,
|
|
message_closed,
|
|
statusToSet,
|
|
maproulette_id_key,
|
|
askFeedback
|
|
})
|
|
}
|
|
},
|
|
{
|
|
funcName: "linked_data_from_website",
|
|
group: "data_import",
|
|
docs: "Attempts to load (via a proxy) the specified website and parsed ld+json from there. Suitable data will be offered to import into OSM. Note: this element is added by default",
|
|
args: [
|
|
{
|
|
name: "key",
|
|
defaultValue: "website",
|
|
doc: "Attempt to load ld+json from the specified URL. This can be in an embedded <script type='ld+json'>"
|
|
},
|
|
{
|
|
name: "useProxy",
|
|
defaultValue: "yes",
|
|
doc: "If 'yes', uses the provided proxy server. This proxy server will scrape HTML and search for a script with `lang='ld+json'`. If `no`, the data will be downloaded and expects a linked-data-json directly"
|
|
},
|
|
{
|
|
name: "host",
|
|
doc: "If not using a proxy, define what host the website is allowed to connect to"
|
|
},
|
|
{
|
|
name: "mode",
|
|
doc: "If `display`, only show the data in tabular and readonly form, ignoring already existing tags. This is used to explicitly show all the tags. If unset or anything else, allow to apply/import on OSM"
|
|
},
|
|
{
|
|
name: "collapsed",
|
|
defaultValue: "yes",
|
|
doc: "If the containing accordion should be closed"
|
|
}
|
|
],
|
|
needsUrls: [Constants.linkedDataProxy, "http://www.schema.org"],
|
|
constr(
|
|
state: SpecialVisualizationState,
|
|
tags: UIEventSource<Record<string, string>>,
|
|
argument: string[],
|
|
feature: Feature,
|
|
layer: LayerConfig
|
|
): BaseUIElement {
|
|
const key = argument[0] ?? "website"
|
|
const useProxy = argument[1] !== "no"
|
|
const readonly = argument[3] === "readonly"
|
|
const isClosed = (argument[4] ?? "yes") === "yes"
|
|
|
|
const countryStore: Store<string | undefined> = tags.mapD(
|
|
(tags) => tags._country
|
|
)
|
|
const sourceUrl: Store<string | undefined> = tags.mapD((tags) => {
|
|
if (!tags[key] || tags[key] === "undefined") {
|
|
return null
|
|
}
|
|
return tags[key]
|
|
})
|
|
const externalData: Store<{ success: GeoJsonProperties } | { error }> =
|
|
sourceUrl.bindD(
|
|
(url) => {
|
|
const country = countryStore.data
|
|
if (url.startsWith("https://data.velopark.be/")) {
|
|
return Stores.FromPromiseWithErr(
|
|
(async () => {
|
|
try {
|
|
const loadAll =
|
|
layer.id.toLowerCase().indexOf("maproulette") >=
|
|
0 // Dirty hack
|
|
const features =
|
|
await LinkedDataLoader.fetchVeloparkEntry(
|
|
url,
|
|
loadAll
|
|
)
|
|
const feature =
|
|
features.find(
|
|
(f) => f.properties["ref:velopark"] === url
|
|
) ?? features[0]
|
|
const properties = feature.properties
|
|
properties["ref:velopark"] = url
|
|
console.log(
|
|
"Got properties from velopark:",
|
|
properties
|
|
)
|
|
return properties
|
|
} catch (e) {
|
|
console.error(e)
|
|
throw e
|
|
}
|
|
})()
|
|
)
|
|
}
|
|
if (country === undefined) {
|
|
return undefined
|
|
}
|
|
return Stores.FromPromiseWithErr(
|
|
(async () => {
|
|
try {
|
|
return await LinkedDataLoader.fetchJsonLd(
|
|
url,
|
|
{ country },
|
|
useProxy ? "proxy" : "fetch-lod"
|
|
)
|
|
} catch (e) {
|
|
console.log(
|
|
"Could not get with proxy/download LOD, attempting to download directly. Error for ",
|
|
url,
|
|
"is",
|
|
e
|
|
)
|
|
return await LinkedDataLoader.fetchJsonLd(
|
|
url,
|
|
{ country },
|
|
"fetch-raw"
|
|
)
|
|
}
|
|
})()
|
|
)
|
|
},
|
|
[countryStore]
|
|
)
|
|
|
|
externalData.addCallbackAndRunD((lod) =>
|
|
console.log("linked_data_from_website received the following data:", lod)
|
|
)
|
|
|
|
return new Toggle(
|
|
new SvelteUIElement(ComparisonTool, {
|
|
feature,
|
|
state,
|
|
tags,
|
|
layer,
|
|
externalData,
|
|
sourceUrl,
|
|
readonly,
|
|
collapsed: isClosed
|
|
}),
|
|
undefined,
|
|
sourceUrl.map((url) => !!url)
|
|
)
|
|
}
|
|
},
|
|
{
|
|
funcName: "compare_data",
|
|
group: "data_import",
|
|
needsUrls: (args) => args[1].split(";"),
|
|
args: [
|
|
{
|
|
name: "url",
|
|
required: true,
|
|
doc: "The attribute containing the url where to fetch more data"
|
|
},
|
|
{
|
|
name: "host",
|
|
required: true,
|
|
doc: "The domain name(s) where data might be fetched from - this is needed to set the CSP. A domain must include 'https', e.g. 'https://example.com'. For multiple domains, separate them with ';'. If you don't know the possible domains, use '*'. "
|
|
},
|
|
{
|
|
name: "readonly",
|
|
required: false,
|
|
doc: "If 'yes', will not show 'apply'-buttons"
|
|
}
|
|
],
|
|
docs: "Gives an interactive element which shows a tag comparison between the OSM-object and the upstream object. This allows to copy some or all tags into OSM",
|
|
constr(
|
|
state: SpecialVisualizationState,
|
|
tagSource: UIEventSource<Record<string, string>>,
|
|
args: string[],
|
|
feature: Feature,
|
|
layer: LayerConfig
|
|
): BaseUIElement {
|
|
const url = args[0]
|
|
const readonly = args[3] === "yes"
|
|
const externalData = Stores.FromPromiseWithErr(Utils.downloadJson(url))
|
|
return new SvelteUIElement(ComparisonTool, {
|
|
url,
|
|
state,
|
|
tags: tagSource,
|
|
layer,
|
|
feature,
|
|
readonly,
|
|
externalData
|
|
})
|
|
}
|
|
}
|
|
|
|
]
|
|
}
|
|
}
|