mapcomplete/Logic/Web/MangroveReviews.ts

import * as mangrove from "mangrove-reviews"
import { UIEventSource } from "../UIEventSource"
import { Review } from "./Review"
import { Utils } from "../../Utils"

export class MangroveIdentity {
    public keypair: any = undefined
    public readonly kid: UIEventSource<string> = new UIEventSource<string>(undefined)
    private readonly _mangroveIdentity: UIEventSource<string>

    constructor(mangroveIdentity: UIEventSource<string>) {
        const self = this
        this._mangroveIdentity = mangroveIdentity
        mangroveIdentity.addCallbackAndRunD((str) => {
            if (str === "") {
                return
            }
            mangrove.jwkToKeypair(JSON.parse(str)).then((keypair) => {
                self.keypair = keypair
                mangrove.publicToPem(keypair.publicKey).then((pem) => {
                    console.log("Identity loaded")
                    self.kid.setData(pem)
                })
            })
        })
        try {
            if (!Utils.runningFromConsole && (mangroveIdentity.data ?? "") === "") {
                this.CreateIdentity()
            }
        } catch (e) {
            console.error("Could not create identity: ", e)
        }
    }

    /**
     * Creates an identity if none exists already.
     * Is written into the UIEventsource, which was passed into the constructor
     * @constructor
     */
    private CreateIdentity() {
        if ("" !== (this._mangroveIdentity.data ?? "")) {
            throw "Identity already defined - not creating a new one"
        }
        const self = this
        mangrove.generateKeypair().then((keypair) => {
            self.keypair = keypair
            mangrove.keypairToJwk(keypair).then((jwk) => {
                self._mangroveIdentity.setData(JSON.stringify(jwk))
            })
        })
    }
}

export default class MangroveReviews {
    private static _reviewsCache = {}
    private static didWarn = false
    private readonly _lon: number
    private readonly _lat: number
    private readonly _name: string
    private readonly _reviews: UIEventSource<Review[]> = new UIEventSource<Review[]>([])
    private _dryRun: boolean
    private _mangroveIdentity: MangroveIdentity
    private _lastUpdate: Date = undefined

    private constructor(
        lon: number,
        lat: number,
        name: string,
        identity: MangroveIdentity,
        dryRun?: boolean
    ) {
        this._lon = lon
        this._lat = lat
        this._name = name
        this._mangroveIdentity = identity
        this._dryRun = dryRun
        if (dryRun && !MangroveReviews.didWarn) {
            MangroveReviews.didWarn = true
            console.warn("Mangrove reviews will _not_ be saved as dryrun is specified")
        }
    }

    public static Get(
        lon: number,
        lat: number,
        name: string,
        identity: MangroveIdentity,
        dryRun?: boolean
    ) {
        const newReviews = new MangroveReviews(lon, lat, name, identity, dryRun)

        const uri = newReviews.GetSubjectUri()
        const cached = MangroveReviews._reviewsCache[uri]
        if (cached !== undefined) {
            return cached
        }
        MangroveReviews._reviewsCache[uri] = newReviews

        return newReviews
    }

    /**
     * Gets an URI which represents the item in a mangrove-compatible way
     * @constructor
     */
    public GetSubjectUri() {
        let uri = `geo:${this._lat},${this._lon}?u=50`
        if (this._name !== undefined && this._name !== null) {
            uri += "&q=" + this._name
        }
        return uri
    }

    /**
     * Gives a UIEVentsource with all reviews.
     * Note: rating is between 1 and 100
     */
    public GetReviews(): UIEventSource<Review[]> {
        if (
            this._lastUpdate !== undefined &&
            this._reviews.data !== undefined &&
            new Date().getTime() - this._lastUpdate.getTime() < 15000
        ) {
            // Last update was pretty recent
            return this._reviews
        }
        this._lastUpdate = new Date()

        const self = this
        mangrove
            .getReviews({ sub: this.GetSubjectUri() })
            .then((data) => {
                const reviews = []
                const reviewsByUser = []
                for (const review of data.reviews) {
                    const r = review.payload

                    console.log(
                        "PublicKey is ",
                        self._mangroveIdentity.kid.data,
                        "reviews.kid is",
                        review.kid
                    )
                    const byUser = self._mangroveIdentity.kid.map(
                        (data) => data === review.signature
                    )
                    const rev: Review = {
                        made_by_user: byUser,
                        date: new Date(r.iat * 1000),
                        comment: r.opinion,
                        author: r.metadata.nickname,
                        affiliated: r.metadata.is_affiliated,
                        rating: r.rating, // percentage points
                    }

                    ;(rev.made_by_user ? reviewsByUser : reviews).push(rev)
                }
                self._reviews.setData(reviewsByUser.concat(reviews))
            })
            .catch((e) => {
                console.error("Could not download review for ", e)
            })
        return this._reviews
    }

    AddReview(r: Review, callback?: () => void) {
        callback =
            callback ??
            (() => {
                return undefined
            })

        const payload = {
            sub: this.GetSubjectUri(),
            rating: r.rating,
            opinion: r.comment,
            metadata: {
                nickname: r.author,
            },
        }
        if (r.affiliated) {
            // @ts-ignore
            payload.metadata.is_affiliated = true
        }
        if (this._dryRun) {
            console.warn("DRYRUNNING mangrove reviews: ", payload)
            if (callback) {
                if (callback) {
                    callback()
                }
                this._reviews.data.push(r)
                this._reviews.ping()
            }
        } else {
            mangrove.signAndSubmitReview(this._mangroveIdentity.keypair, payload).then(() => {
                if (callback) {
                    callback()
                }
                this._reviews.data.push(r)
                this._reviews.ping()
            })
        }
    }
}