Chore: rework image uploading, should work better now

src/Logic/ImageProviders/ImageUploadManager.ts

@@ -0,0 +1,150 @@
+import { ImageUploader } from "./ImageUploader";
+import LinkImageAction from "../Osm/Actions/LinkImageAction";
+import FeaturePropertiesStore from "../FeatureSource/Actors/FeaturePropertiesStore";
+import { OsmId, OsmTags } from "../../Models/OsmFeature";
+import LayoutConfig from "../../Models/ThemeConfig/LayoutConfig";
+import { Store, UIEventSource } from "../UIEventSource";
+import { OsmConnection } from "../Osm/OsmConnection";
+import { Changes } from "../Osm/Changes";
+import Translations from "../../UI/i18n/Translations";
+
+
+/**
+ * The ImageUploadManager has a
+ */
+export class ImageUploadManager {
+
+  private readonly _uploader: ImageUploader;
+  private readonly _featureProperties: FeaturePropertiesStore;
+  private readonly _layout: LayoutConfig;
+
+  private readonly _uploadStarted: Map<string, UIEventSource<number>> = new Map();
+  private readonly _uploadFinished: Map<string, UIEventSource<number>> = new Map();
+  private readonly _uploadFailed: Map<string, UIEventSource<number>> = new Map();
+  private readonly _uploadRetried: Map<string, UIEventSource<number>> = new Map();
+  private readonly _uploadRetriedSuccess: Map<string, UIEventSource<number>> = new Map();
+  private readonly _osmConnection: OsmConnection;
+  private readonly _changes: Changes;
+
+  constructor(layout: LayoutConfig, uploader: ImageUploader, featureProperties: FeaturePropertiesStore, osmConnection: OsmConnection, changes: Changes) {
+    this._uploader = uploader;
+    this._featureProperties = featureProperties;
+    this._layout = layout;
+    this._osmConnection = osmConnection;
+    this._changes = changes;
+  }
+
+  /**
+   * Gets various counters.
+   * Note that counters can only increase
+   * If a retry was a success, both 'retrySuccess' _and_ 'uploadFinished' will be increased
+   * @param featureId: the id of the feature you want information for. '*' has a global counter
+   */
+  public getCountsFor(featureId: string | "*"): {
+    retried: Store<number>;
+    uploadStarted: Store<number>;
+    retrySuccess: Store<number>;
+    failed: Store<number>;
+    uploadFinished: Store<number>
+  } {
+    return {
+      uploadStarted: this.getCounterFor(this._uploadStarted, featureId),
+      uploadFinished: this.getCounterFor(this._uploadFinished, featureId),
+      retried: this.getCounterFor(this._uploadRetried, featureId),
+      failed: this.getCounterFor(this._uploadFailed, featureId),
+      retrySuccess: this.getCounterFor(this._uploadRetriedSuccess, featureId)
+
+    };
+  }
+
+  /**
+   * Uploads the given image, applies the correct title and license for the known user
+   */
+  public async uploadImageAndApply(file: File, tags: OsmTags) {
+
+      const sizeInBytes = file.size
+    const featureId = <OsmId> tags.id
+      console.log(file.name + " has a size of " + sizeInBytes + " Bytes, attaching to", tags.id)
+      const self = this
+      if (sizeInBytes > this._uploader.maxFileSizeInMegabytes * 1000000) {
+          this.increaseCountFor(this._uploadStarted, featureId)
+          this.increaseCountFor(this._uploadFailed, featureId)
+          throw(
+            Translations.t.image.toBig.Subs({
+                actual_size: Math.floor(sizeInBytes / 1000000) + "MB",
+                max_size: self._uploader.maxFileSizeInMegabytes + "MB",
+            }).txt
+          )
+      }
+
+
+    const licenseStore = this._osmConnection?.GetPreference("pictures-license", "CC0");
+    const license = licenseStore?.data ?? "CC0";
+
+    const matchingLayer = this._layout?.getMatchingLayer(tags);
+
+    const title =
+      matchingLayer?.title?.GetRenderValue(tags)?.Subs(tags)?.textFor("en") ??
+      tags.name ??
+      "https//osm.org/" + tags.id;
+    const description = [
+      "author:" + this._osmConnection.userDetails.data.name,
+      "license:" + license,
+      "osmid:" + tags.id
+    ].join("\n");
+
+    console.log("Upload done, creating ")
+    const action = await this.uploadImageWithLicense(featureId, title, description, file);
+    await this._changes.applyAction(action);
+  }
+
+  private async uploadImageWithLicense(
+    featureId: OsmId,
+    title: string, description: string, blob: File
+  ): Promise<LinkImageAction> {
+    this.increaseCountFor(this._uploadStarted, featureId);
+    const properties = this._featureProperties.getStore(featureId);
+    let key: string;
+    let value: string;
+    try {
+      ({ key, value } = await this._uploader.uploadImage(title, description, blob));
+    } catch (e) {
+      this.increaseCountFor(this._uploadRetried, featureId);
+      console.error("Could not upload image, trying again:", e);
+      try {
+
+        ({ key, value } = await this._uploader.uploadImage(title, description, blob));
+        this.increaseCountFor(this._uploadRetriedSuccess, featureId);
+      } catch (e) {
+        console.error("Could again not upload image due to", e);
+        this.increaseCountFor(this._uploadFailed, featureId);
+      }
+
+    }
+    console.log("Uploading done, creating action for", featureId)
+    const action = new LinkImageAction(featureId, key, value, properties, {
+      theme: this._layout.id,
+      changeType: "add-image"
+    });
+    this.increaseCountFor(this._uploadFinished, featureId);
+    return action;
+  }
+
+  private getCounterFor(collection: Map<string, UIEventSource<number>>, key: string | "*") {
+    if (this._featureProperties.aliases.has(key)) {
+      key = this._featureProperties.aliases.get(key);
+    }
+    if (!collection.has(key)) {
+      collection.set(key, new UIEventSource<number>(0));
+    }
+    return collection.get(key);
+  }
+
+  private increaseCountFor(collection: Map<string, UIEventSource<number>>, key: string | "*") {
+    const counter = this.getCounterFor(collection, key);
+    counter.setData(counter.data + 1);
+    const global = this.getCounterFor(collection, "*");
+    global.setData(counter.data + 1);
+  }
+
+}