forked from MapComplete/MapComplete
469 lines
17 KiB
TypeScript
469 lines
17 KiB
TypeScript
import escapeHtml from "escape-html"
|
|
import UserDetails, { OsmConnection } from "./OsmConnection"
|
|
import { UIEventSource } from "../UIEventSource"
|
|
import { ElementStorage } from "../ElementStorage"
|
|
import Locale from "../../UI/i18n/Locale"
|
|
import Constants from "../../Models/Constants"
|
|
import { Changes } from "./Changes"
|
|
import { Utils } from "../../Utils"
|
|
|
|
export interface ChangesetTag {
|
|
key: string
|
|
value: string | number
|
|
aggregate?: boolean
|
|
}
|
|
|
|
export class ChangesetHandler {
|
|
private readonly allElements: ElementStorage
|
|
private osmConnection: OsmConnection
|
|
private readonly changes: Changes
|
|
private readonly _dryRun: UIEventSource<boolean>
|
|
private readonly userDetails: UIEventSource<UserDetails>
|
|
private readonly auth: any
|
|
private readonly backend: string
|
|
|
|
/**
|
|
* Contains previously rewritten IDs
|
|
* @private
|
|
*/
|
|
private readonly _remappings = new Map<string, string>()
|
|
|
|
/**
|
|
* Use 'osmConnection.CreateChangesetHandler' instead
|
|
* @param dryRun
|
|
* @param osmConnection
|
|
* @param allElements
|
|
* @param changes
|
|
* @param auth
|
|
*/
|
|
constructor(
|
|
dryRun: UIEventSource<boolean>,
|
|
osmConnection: OsmConnection,
|
|
allElements: ElementStorage,
|
|
changes: Changes,
|
|
auth
|
|
) {
|
|
this.osmConnection = osmConnection
|
|
this.allElements = allElements
|
|
this.changes = changes
|
|
this._dryRun = dryRun
|
|
this.userDetails = osmConnection.userDetails
|
|
this.backend = osmConnection._oauth_config.url
|
|
this.auth = auth
|
|
|
|
if (dryRun) {
|
|
console.log("DRYRUN ENABLED")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a new list which contains every key at most once
|
|
*
|
|
* ChangesetHandler.removeDuplicateMetaTags([{key: "k", value: "v"}, {key: "k0", value: "v0"}, {key: "k", value:"v"}] // => [{key: "k", value: "v"}, {key: "k0", value: "v0"}]
|
|
*/
|
|
public static removeDuplicateMetaTags(extraMetaTags: ChangesetTag[]): ChangesetTag[] {
|
|
const r: ChangesetTag[] = []
|
|
const seen = new Set<string>()
|
|
for (const extraMetaTag of extraMetaTags) {
|
|
if (seen.has(extraMetaTag.key)) {
|
|
continue
|
|
}
|
|
r.push(extraMetaTag)
|
|
seen.add(extraMetaTag.key)
|
|
}
|
|
return r
|
|
}
|
|
|
|
/**
|
|
* Inplace rewrite of extraMetaTags
|
|
* If the metatags contain a special motivation of the format "<change-type>:node/-<number>", this method will rewrite this negative number to the actual ID
|
|
* The key is changed _in place_; true will be returned if a change has been applied
|
|
* @param extraMetaTags
|
|
* @param rewriteIds
|
|
* @private
|
|
*/
|
|
static rewriteMetaTags(extraMetaTags: ChangesetTag[], rewriteIds: Map<string, string>) {
|
|
let hasChange = false
|
|
for (const tag of extraMetaTags) {
|
|
const match = tag.key.match(/^([a-zA-Z0-9_]+):(node\/-[0-9])$/)
|
|
if (match == null) {
|
|
continue
|
|
}
|
|
// This is a special motivation which has a negative ID -> we check for rewrites
|
|
const [_, reason, id] = match
|
|
if (rewriteIds.has(id)) {
|
|
tag.key = reason + ":" + rewriteIds.get(id)
|
|
hasChange = true
|
|
}
|
|
}
|
|
return hasChange
|
|
}
|
|
|
|
/**
|
|
* The full logic to upload a change to one or more elements.
|
|
*
|
|
* This method will attempt to reuse an existing, open changeset for this theme (or open one if none available).
|
|
* Then, it will upload a changes-xml within this changeset (and leave the changeset open)
|
|
* When upload is successfull, eventual id-rewriting will be handled (aka: don't worry about that)
|
|
*
|
|
* If 'dryrun' is specified, the changeset XML will be printed to console instead of being uploaded
|
|
*
|
|
*/
|
|
public async UploadChangeset(
|
|
generateChangeXML: (csid: number, remappings: Map<string, string>) => string,
|
|
extraMetaTags: ChangesetTag[],
|
|
openChangeset: UIEventSource<number>
|
|
): Promise<void> {
|
|
if (
|
|
!extraMetaTags.some((tag) => tag.key === "comment") ||
|
|
!extraMetaTags.some((tag) => tag.key === "theme")
|
|
) {
|
|
throw "The meta tags should at least contain a `comment` and a `theme`"
|
|
}
|
|
|
|
extraMetaTags = [...extraMetaTags, ...this.defaultChangesetTags()]
|
|
extraMetaTags = ChangesetHandler.removeDuplicateMetaTags(extraMetaTags)
|
|
if (this.userDetails.data.csCount == 0) {
|
|
// The user became a contributor!
|
|
this.userDetails.data.csCount = 1
|
|
this.userDetails.ping()
|
|
}
|
|
if (this._dryRun.data) {
|
|
const changesetXML = generateChangeXML(123456, this._remappings)
|
|
console.log("Metatags are", extraMetaTags)
|
|
console.log(changesetXML)
|
|
return
|
|
}
|
|
|
|
if (openChangeset.data === undefined) {
|
|
// We have to open a new changeset
|
|
try {
|
|
const csId = await this.OpenChangeset(extraMetaTags)
|
|
openChangeset.setData(csId)
|
|
const changeset = generateChangeXML(csId, this._remappings)
|
|
console.trace(
|
|
"Opened a new changeset (openChangeset.data is undefined):",
|
|
changeset
|
|
)
|
|
const changes = await this.UploadChange(csId, changeset)
|
|
const hasSpecialMotivationChanges = ChangesetHandler.rewriteMetaTags(
|
|
extraMetaTags,
|
|
changes
|
|
)
|
|
if (hasSpecialMotivationChanges) {
|
|
// At this point, 'extraMetaTags' will have changed - we need to set the tags again
|
|
this.UpdateTags(csId, extraMetaTags)
|
|
}
|
|
} catch (e) {
|
|
console.error("Could not open/upload changeset due to ", e)
|
|
openChangeset.setData(undefined)
|
|
}
|
|
} else {
|
|
// There still exists an open changeset (or at least we hope so)
|
|
// Let's check!
|
|
const csId = openChangeset.data
|
|
try {
|
|
const oldChangesetMeta = await this.GetChangesetMeta(csId)
|
|
if (!oldChangesetMeta.open) {
|
|
// Mark the CS as closed...
|
|
console.log("Could not fetch the metadata from the already open changeset")
|
|
openChangeset.setData(undefined)
|
|
// ... and try again. As the cs is closed, no recursive loop can exist
|
|
await this.UploadChangeset(generateChangeXML, extraMetaTags, openChangeset)
|
|
return
|
|
}
|
|
|
|
const rewritings = await this.UploadChange(
|
|
csId,
|
|
generateChangeXML(csId, this._remappings)
|
|
)
|
|
|
|
const rewrittenTags = this.RewriteTagsOf(
|
|
extraMetaTags,
|
|
rewritings,
|
|
oldChangesetMeta
|
|
)
|
|
await this.UpdateTags(csId, rewrittenTags)
|
|
} catch (e) {
|
|
console.warn("Could not upload, changeset is probably closed: ", e)
|
|
openChangeset.setData(undefined)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given an existing changeset with metadata and extraMetaTags to add, will fuse them to a new set of metatags
|
|
* Does not yet send data
|
|
* @param extraMetaTags: new changeset tags to add/fuse with this changeset
|
|
* @param rewriteIds: the mapping of ids
|
|
* @param oldChangesetMeta: the metadata-object of the already existing changeset
|
|
*/
|
|
public RewriteTagsOf(
|
|
extraMetaTags: ChangesetTag[],
|
|
rewriteIds: Map<string, string>,
|
|
oldChangesetMeta: {
|
|
open: boolean
|
|
id: number
|
|
uid: number // User ID
|
|
changes_count: number
|
|
tags: any
|
|
}
|
|
): ChangesetTag[] {
|
|
// Note: extraMetaTags is where all the tags are collected into
|
|
|
|
// same as 'extraMetaTag', but indexed
|
|
// Note that updates to 'extraTagsById.get(<key>).value = XYZ' is shared with extraMetatags
|
|
const extraTagsById = new Map<string, ChangesetTag>()
|
|
for (const extraMetaTag of extraMetaTags) {
|
|
extraTagsById.set(extraMetaTag.key, extraMetaTag)
|
|
}
|
|
|
|
const oldCsTags = oldChangesetMeta.tags
|
|
for (const key in oldCsTags) {
|
|
const newMetaTag = extraTagsById.get(key)
|
|
const existingValue = oldCsTags[key]
|
|
|
|
if (newMetaTag !== undefined && newMetaTag.value === existingValue) {
|
|
continue
|
|
}
|
|
if (newMetaTag === undefined) {
|
|
extraMetaTags.push({
|
|
key: key,
|
|
value: oldCsTags[key],
|
|
})
|
|
continue
|
|
}
|
|
|
|
if (newMetaTag.aggregate) {
|
|
let n = Number(newMetaTag.value)
|
|
if (isNaN(n)) {
|
|
n = 0
|
|
}
|
|
let o = Number(oldCsTags[key])
|
|
if (isNaN(o)) {
|
|
o = 0
|
|
}
|
|
// We _update_ the tag itself, as it'll be updated in 'extraMetaTags' straight away
|
|
newMetaTag.value = "" + (n + o)
|
|
} else {
|
|
// The old value is overwritten, thus we drop this old key
|
|
}
|
|
}
|
|
|
|
ChangesetHandler.rewriteMetaTags(extraMetaTags, rewriteIds)
|
|
return extraMetaTags
|
|
}
|
|
|
|
/**
|
|
* Updates the id in the AllElements store, returns the new ID
|
|
* @param node: the XML-element, e.g. <node old_id="-1" new_id="9650458521" new_version="1"/>
|
|
* @param type
|
|
* @private
|
|
*/
|
|
private static parseIdRewrite(node: any, type: string): [string, string] {
|
|
const oldId = parseInt(node.attributes.old_id.value)
|
|
if (node.attributes.new_id === undefined) {
|
|
return [type + "/" + oldId, undefined]
|
|
}
|
|
|
|
const newId = parseInt(node.attributes.new_id.value)
|
|
// The actual mapping
|
|
const result: [string, string] = [type + "/" + oldId, type + "/" + newId]
|
|
if (oldId === newId) {
|
|
return undefined
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Given a diff-result XML of the form
|
|
* <diffResult version="0.6">
|
|
* <node old_id="-1" new_id="9650458521" new_version="1"/>
|
|
* <way old_id="-2" new_id="1050127772" new_version="1"/>
|
|
* </diffResult>,
|
|
* will:
|
|
*
|
|
* - create a mapping `{'node/-1' --> "node/9650458521", 'way/-2' --> "way/9650458521"}
|
|
* - Call this.changes.registerIdRewrites
|
|
* - Call handleIdRewrites as needed
|
|
* @param response
|
|
* @private
|
|
*/
|
|
private parseUploadChangesetResponse(response: XMLDocument): Map<string, string> {
|
|
const nodes = response.getElementsByTagName("node")
|
|
const mappings: [string, string][] = []
|
|
|
|
for (const node of Array.from(nodes)) {
|
|
const mapping = ChangesetHandler.parseIdRewrite(node, "node")
|
|
if (mapping !== undefined) {
|
|
mappings.push(mapping)
|
|
}
|
|
}
|
|
|
|
const ways = response.getElementsByTagName("way")
|
|
for (const way of Array.from(ways)) {
|
|
const mapping = ChangesetHandler.parseIdRewrite(way, "way")
|
|
if (mapping !== undefined) {
|
|
mappings.push(mapping)
|
|
}
|
|
}
|
|
for (const mapping of mappings) {
|
|
const [oldId, newId] = mapping
|
|
this.allElements.addAlias(oldId, newId)
|
|
if (newId !== undefined) {
|
|
this._remappings.set(mapping[0], mapping[1])
|
|
}
|
|
}
|
|
return new Map<string, string>(mappings)
|
|
}
|
|
|
|
private async CloseChangeset(changesetId: number = undefined): Promise<void> {
|
|
const self = this
|
|
return new Promise<void>(function (resolve, reject) {
|
|
if (changesetId === undefined) {
|
|
return
|
|
}
|
|
self.auth.xhr(
|
|
{
|
|
method: "PUT",
|
|
path: "/api/0.6/changeset/" + changesetId + "/close",
|
|
},
|
|
function (err, response) {
|
|
if (response == null) {
|
|
console.log("err", err)
|
|
}
|
|
console.log("Closed changeset ", changesetId)
|
|
resolve()
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
async GetChangesetMeta(csId: number): Promise<{
|
|
id: number
|
|
open: boolean
|
|
uid: number
|
|
changes_count: number
|
|
tags: any
|
|
}> {
|
|
const url = `${this.backend}/api/0.6/changeset/${csId}`
|
|
const csData = await Utils.downloadJson(url)
|
|
return csData.elements[0]
|
|
}
|
|
|
|
/**
|
|
* Puts the specified tags onto the changesets as they are.
|
|
* This method will erase previously set tags
|
|
*/
|
|
private async UpdateTags(csId: number, tags: ChangesetTag[]) {
|
|
tags = ChangesetHandler.removeDuplicateMetaTags(tags)
|
|
|
|
const self = this
|
|
return new Promise<string>(function (resolve, reject) {
|
|
tags = Utils.NoNull(tags).filter(
|
|
(tag) =>
|
|
tag.key !== undefined &&
|
|
tag.value !== undefined &&
|
|
tag.key !== "" &&
|
|
tag.value !== ""
|
|
)
|
|
const metadata = tags.map((kv) => `<tag k="${kv.key}" v="${escapeHtml(kv.value)}"/>`)
|
|
|
|
self.auth.xhr(
|
|
{
|
|
method: "PUT",
|
|
path: "/api/0.6/changeset/" + csId,
|
|
options: { header: { "Content-Type": "text/xml" } },
|
|
content: [`<osm><changeset>`, metadata, `</changeset></osm>`].join(""),
|
|
},
|
|
function (err, response) {
|
|
if (response === undefined) {
|
|
console.error("Updating the tags of changeset " + csId + " failed:", err)
|
|
reject(err)
|
|
} else {
|
|
resolve(response)
|
|
}
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
private defaultChangesetTags(): ChangesetTag[] {
|
|
return [
|
|
["created_by", `MapComplete ${Constants.vNumber}`],
|
|
["locale", Locale.language.data],
|
|
["host", `${window.location.origin}${window.location.pathname}`],
|
|
[
|
|
"source",
|
|
this.changes.state["currentUserLocation"]?.features?.data?.length > 0
|
|
? "survey"
|
|
: undefined,
|
|
],
|
|
["imagery", this.changes.state["backgroundLayer"]?.data?.id],
|
|
].map(([key, value]) => ({
|
|
key,
|
|
value,
|
|
aggretage: false,
|
|
}))
|
|
}
|
|
|
|
/**
|
|
* Opens a changeset with the specified tags
|
|
* @param changesetTags
|
|
* @constructor
|
|
* @private
|
|
*/
|
|
private OpenChangeset(changesetTags: ChangesetTag[]): Promise<number> {
|
|
const self = this
|
|
return new Promise<number>(function (resolve, reject) {
|
|
const metadata = changesetTags
|
|
.map((cstag) => [cstag.key, cstag.value])
|
|
.filter((kv) => (kv[1] ?? "") !== "")
|
|
.map((kv) => `<tag k="${kv[0]}" v="${escapeHtml(kv[1])}"/>`)
|
|
.join("\n")
|
|
|
|
self.auth.xhr(
|
|
{
|
|
method: "PUT",
|
|
path: "/api/0.6/changeset/create",
|
|
options: { header: { "Content-Type": "text/xml" } },
|
|
content: [`<osm><changeset>`, metadata, `</changeset></osm>`].join(""),
|
|
},
|
|
function (err, response) {
|
|
if (response === undefined) {
|
|
console.error("Opening a changeset failed:", err)
|
|
reject(err)
|
|
} else {
|
|
resolve(Number(response))
|
|
}
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Upload a changesetXML
|
|
*/
|
|
private UploadChange(changesetId: number, changesetXML: string): Promise<Map<string, string>> {
|
|
const self = this
|
|
return new Promise(function (resolve, reject) {
|
|
self.auth.xhr(
|
|
{
|
|
method: "POST",
|
|
options: { header: { "Content-Type": "text/xml" } },
|
|
path: "/api/0.6/changeset/" + changesetId + "/upload",
|
|
content: changesetXML,
|
|
},
|
|
function (err, response) {
|
|
if (response == null) {
|
|
console.error("Uploading an actual change failed", err)
|
|
reject(err)
|
|
}
|
|
const changes = self.parseUploadChangesetResponse(response)
|
|
console.log("Uploaded changeset ", changesetId)
|
|
resolve(changes)
|
|
}
|
|
)
|
|
})
|
|
}
|
|
}
|