@tak-ps/cloudtak 12.54.0

package/src/base/subscription-feature.ts

@@ -0,0 +1,224 @@
+import { db } from './database.ts';
+import Filter from './filter.ts';
+import COT from './cot.ts';
+import Subscription from './subscription.ts';
+import type Atlas from '../workers/atlas.ts';
+import { std, stdurl } from '../std.ts';
+import { bbox } from '@turf/bbox';
+import type { BBox, FeatureCollection as GeoJSONFeatureCollection } from 'geojson'
+import type { Feature, FeatureCollection } from '../types.ts';
+
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ */
+export default class SubscriptionFeature {
+    parent: Subscription;
+
+    token: string;
+    missiontoken?: string;
+
+    constructor(
+        parent: Subscription,
+        opts: {
+            token: string,
+            missiontoken?: string,
+        }
+    ) {
+        this.parent = parent;
+
+        this.token = opts.token;
+        this.missiontoken = opts.missiontoken;
+    }
+
+    headers(): Record<string, string> {
+        const headers: Record<string, string> = {};
+        if (this.missiontoken) headers.MissionAuthorization = this.missiontoken;
+        return headers;
+    }
+
+    async refresh(): Promise<void> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.parent.guid) + '/cot');
+
+        const list = await std(url, {
+            method: 'GET',
+            token: this.token,
+            headers: this.headers()
+        }) as FeatureCollection;
+
+        for (const feat of list.features) {
+            await COT.style(feat);
+        }
+
+        await db.transaction('rw', db.subscription_feature, async () => {
+            await db.subscription_feature
+                .where('mission')
+                .equals(this.parent.guid)
+                .delete();
+
+            for (const feature of list.features) {
+                await db.subscription_feature.put({
+                    id: feature.id,
+                    mission: this.parent.guid,
+                    path: feature.path,
+                    properties: feature.properties,
+                    geometry: feature.geometry,
+                });
+            }
+        });
+    }
+
+    async list(
+        opts?: {
+            refresh: false,
+        }
+    ): Promise<Array<Feature>> {
+        if (opts?.refresh) {
+            await this.refresh();
+        }
+
+        const feats = await db.subscription_feature
+            .where("mission")
+            .equals(this.parent.guid)
+            .toArray();
+
+        return feats.map(f => ({
+            id: f.id,
+            type: 'Feature',
+            path: f.path,
+            properties: f.properties,
+            geometry: f.geometry,
+        }));
+    }
+
+    async collection(raw = true): Promise<FeatureCollection> {
+        const features = await this.list();
+
+        if (raw) {
+            return {
+                type: 'FeatureCollection',
+                features: features.map((feat) => {
+                    return feat
+                })
+            } as FeatureCollection;
+        } else {
+            const filters = await Filter.list();
+            const filtered: Feature[] = [];
+
+            for (const feat of features) {
+                let blocked = false;
+                for (const filter of filters) {
+                    if (await filter.test(feat)) {
+                        blocked = true;
+                        break;
+                    }
+                }
+
+                if (!blocked) filtered.push(feat);
+            }
+
+            return {
+                type: 'FeatureCollection',
+                features: filtered
+            } as FeatureCollection;
+        }
+    }
+
+    async bounds(): Promise<BBox> {
+        return bbox(await this.collection() as GeoJSONFeatureCollection);
+    }
+
+    async from(
+        uid: string
+    ): Promise<Feature | undefined> {
+        const f = await db.subscription_feature
+            .where("[mission+id]")
+            .equals([this.parent.guid, uid])
+            .first();
+
+        if (!f) return;
+
+        return {
+            id: f.id,
+            type: 'Feature',
+            path: f.path,
+            properties: f.properties,
+            geometry: f.geometry,
+        }
+    }
+
+    /**
+     * Upsert a feature into the mission.
+     * This will udpate the feature in the local DB, submit it to the TAK Server and
+     * mark the subscription as dirty for a re-render
+     *
+     * @param atlas - The Atlas instance
+     * @param cot - The COT object to upsert
+     * @param opts - Options for updating the feature
+     * @param opts.skipNetwork - If true, the feature will not be updated on the server - IE in response to a Mission Change event
+     */
+    async update(
+        atlas: Atlas,
+        cot: COT,
+        opts: {
+            skipNetwork?: boolean
+        } = {}
+    ): Promise<void> {
+        await db.subscription_feature.put({
+            id: cot.id,
+            mission: this.parent.guid,
+            path: cot.path,
+            properties: cot.properties,
+            geometry: cot.geometry,
+        });
+
+        await this.parent.update({
+            dirty: true
+        })
+
+        const feat = cot.as_feature({
+            clone: true
+        });
+
+        feat.properties.dest = [{
+            'mission-guid': this.parent.guid
+        }];
+
+        if (!opts.skipNetwork) {
+            await atlas.conn.sendCOT(feat);
+        }
+    }
+
+    /**
+     * Delete a feature from the mission.
+     *
+     * @param atlas - The Atlas instance
+     * @param uid - The unique ID of the feature to delete
+     * @param opts - Options for deleting the feature
+     * @param opts.skipNetwork - If true, the feature will not be deleted from the server - IE in response to a Mission Change event
+     */
+    async delete(
+        atlas: Atlas,
+        uid: string,
+        opts: {
+            skipNetwork?: boolean
+        } = {}
+    ): Promise<void> {
+        await db.subscription_feature
+            .where("[mission+id]")
+            .equals([this.parent.guid, uid])
+            .delete();
+
+        await this.parent.update({
+            dirty: true
+        })
+
+        if (!opts.skipNetwork) {
+            const url = stdurl(`/api/marti/missions/${this.parent.guid}/cot/${uid}`);
+            await std(url, {
+                method: 'DELETE',
+                headers: this.headers(),
+                token:  atlas.token
+            })
+        }
+    }
+}

package/src/base/subscription-log.ts

@@ -0,0 +1,174 @@
+import { db } from './database.ts';
+import { std, stdurl } from '../std.ts';
+import type {
+    MissionLog,
+    MissionLogList
+} from '../types.ts'
+
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ */
+export default class SubscriptionLog {
+    guid: string;
+
+    token: string;
+    missiontoken?: string;
+
+    constructor(
+        guid: string,
+        opts: {
+            token: string,
+            missiontoken?: string,
+        }
+    ) {
+        this.token = opts.token;
+        this.missiontoken = opts.missiontoken;
+
+        this.guid = guid;
+    }
+
+    headers(): Record<string, string> {
+        const headers: Record<string, string> = {};
+        if (this.missiontoken) headers.MissionAuthorization = this.missiontoken;
+        return headers;
+    }
+
+    async refresh(): Promise<void> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.guid) + '/log');
+
+        const list = await std(url, {
+            method: 'GET',
+            token: this.token,
+            headers: this.headers()
+        }) as MissionLogList;
+
+        await db.transaction('rw', db.subscription_log, async () => {
+            await db.subscription_log
+                .where('mission')
+                .equals(this.guid)
+                .delete();
+
+            for (const log of list.items) {
+                await db.subscription_log.put({
+                    id: log.id,
+                    dtg: log.dtg,
+                    created: log.created,
+                    mission: this.guid,
+                    content: log.content || '',
+                    missionNames: log.missionNames,
+                    servertime: log.servertime,
+                    creatorUid: log.creatorUid,
+                    contentHashes: log.contentHashes,
+                    keywords: log.keywords
+                });
+            }
+        });
+    }
+
+    async list(
+        opts?: {
+            filter?: string,
+            refresh: false,
+        }
+    ): Promise<Array<MissionLog>> {
+        if (opts?.refresh) {
+            await this.refresh();
+        }
+
+        const logs = await db.subscription_log
+            .where("mission")
+            .equals(this.guid)
+            .toArray();
+
+        logs.sort((a, b) => {
+            return new Date(b.created).getTime() - new Date(a.created).getTime();
+        }).reverse();
+
+        return logs;
+    }
+
+    async create(
+        body: {
+            dtg?: string;
+            content: string;
+            contentHashes?: Array<string>;
+            keywords?: Array<string>;
+        }
+    ): Promise<MissionLog> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.guid) + '/log');
+
+        const log = await std(url, {
+            method: 'POST',
+            body: body,
+            token: this.token,
+            headers: this.headers()
+        }) as {
+            data: MissionLog
+        };
+
+        await db.subscription_log.put({
+            id: log.data.id,
+            dtg: log.data.dtg,
+            created: log.data.created,
+            mission: this.guid,
+            content: log.data.content || '',
+            missionNames: log.data.missionNames,
+            servertime: log.data.servertime,
+            creatorUid: log.data.creatorUid,
+            contentHashes: log.data.contentHashes,
+            keywords: log.data.keywords
+        });
+
+        return log.data;
+    }
+
+    async update(
+        logid: string,
+        body: {
+            dtg?: string;
+            content: string;
+            contentHashes?: Array<string>;
+            keywords?: Array<string>;
+        },
+    ): Promise<MissionLog> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.guid) + '/log/' + encodeURIComponent(logid));
+
+        const log = await std(url, {
+            method: 'PATCH',
+            body: body,
+            token: this.token,
+            headers: this.headers()
+        }) as {
+            data: MissionLog
+        };
+
+        await db.subscription_log.put({
+            id: log.data.id,
+            dtg: log.data.dtg,
+            created: log.data.created,
+            mission: this.guid,
+            missionNames: log.data.missionNames,
+            servertime: log.data.servertime,
+            content: log.data.content || '',
+            creatorUid: log.data.creatorUid,
+            contentHashes: log.data.contentHashes,
+            keywords: log.data.keywords
+        });
+
+        return log.data;
+    }
+
+    async delete(
+        logid: string,
+    ): Promise<void> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.guid) + '/log/' + encodeURIComponent(logid));
+
+        await std(url, {
+            method: 'DELETE',
+            token: this.token,
+            headers: this.headers()
+        });
+
+        await db.subscription_log.delete(logid);
+    }
+}