@tak-ps/cloudtak 12.54.0 → 12.94.0

package/src/base/subscription-feature.ts

@@ -1,224 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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);
-    }
-}