@tak-ps/cloudtak 12.54.0

package/src/base/subscription.ts

@@ -0,0 +1,489 @@
+import { db } from './database.ts'
+import { std, stdurl } from '../std.ts';
+import SubscriptionLog from './subscription-log.ts';
+import SubscriptionFeature from './subscription-feature.ts';
+import type {
+    Mission,
+    MissionRole,
+    MissionList,
+    MissionLayer,
+    MissionChanges,
+    MissionLayerList,
+    MissionLayer_Create,
+    MissionLayer_Update,
+    MissionSubscriptions
+} from '../types.ts';
+
+export enum SubscriptionEventType {
+    CREATE = 'subscription::create',
+    UPDATE = 'subscription::update',
+    DELETE = 'subscription::delete'
+}
+
+export type SubscriptionEvent = {
+    guid: string;
+    type: SubscriptionEventType;
+    state: {
+        dirty: boolean;
+        subscribed: boolean;
+    }
+}
+
+/**
+ * High Level Wrapper around the Data/Mission Sync API
+ *
+ * @property {string} guid - The unique identifier for the mission
+ * @property {string} name - The name of the mission
+ * @property {Mission} meta - The mission metadata
+ * @property {MissionRole} role - The role of the user in the mission
+ * @property {string} token - The CloudTAK Authentication token for API calls
+ * @property {string} [missiontoken] - The mission token for authentication
+ *
+ * @property {boolean} subscribed - Whether the user is subscribed to the mission
+ */
+export default class Subscription {
+    guid: string;
+    name: string;
+
+    meta: Mission;
+    role: MissionRole;
+
+    log: SubscriptionLog;
+    feature: SubscriptionFeature;
+
+    token: string;
+    missiontoken?: string;
+
+    dirty: boolean;
+    subscribed: boolean;
+
+    _sync: BroadcastChannel
+
+    constructor(
+        mission: Mission,
+        role: MissionRole,
+        opts: {
+            subscribed: boolean,
+            token: string,
+            missiontoken?: string,
+        }
+    ) {
+        this._sync = new BroadcastChannel('subscription');
+
+        this._sync.onmessage = async (ev: MessageEvent<SubscriptionEvent>) => {
+            if (ev.data.guid === this.guid) {
+                await this.reload();
+            }
+        };
+
+        this.log = new SubscriptionLog(mission.guid, {
+            missiontoken: opts.missiontoken,
+            token: opts.token
+        });
+
+        this.feature = new SubscriptionFeature(this, {
+            missiontoken: opts.missiontoken,
+            token: opts.token
+        });
+
+        this.subscribed = opts.subscribed;
+
+        this.guid = mission.guid;
+        this.name = mission.name;
+        this.meta = mission;
+        this.role = role;
+
+        this.token = opts.token;
+
+        if (opts?.missiontoken) this.missiontoken = opts.missiontoken;
+
+        this.dirty = false;
+    }
+
+    /**
+     * Return a Subscription instance of one already exists in the local DB,
+     */
+    static async from(
+        guid: string,
+        token: string,
+        opts?: {
+            subscribed?: boolean
+        }
+    ): Promise<Subscription | undefined> {
+        const exists = await db.subscription
+            .get(guid)
+
+        if (!exists || (opts?.subscribed !== undefined && exists.subscribed !== opts.subscribed)) {
+            return;
+        }
+
+        return new Subscription(
+            exists.meta,
+            exists.role,
+            {
+                token: token,
+                missiontoken: exists.token,
+                subscribed: opts?.subscribed !== undefined ? opts.subscribed : exists.subscribed,
+            }
+        );
+    }
+
+    /**
+     * Loads an existing Subscription from the local DB an refreshes it,
+     * or creates a new Subscription from the server if it does not exist locally.
+     *
+     * @param guid - The unique identifier for the mission
+     * @param opts - Options for loading the subscription
+     * @param opts.token - The CloudTAK Authentication token for API calls
+     * @param opts.reload - Whether to reload the mission from the local DB
+     * @param opts.missiontoken - The mission token for authentication
+     * @param opts.subscribed - Whether the user is subscribed to the mission
+     */
+    static async load(
+        guid: string,
+        opts: {
+            token: string
+            reload?: boolean,
+            missiontoken?: string,
+            subscribed?: boolean
+        }
+    ): Promise<Subscription> {
+        const exists = await this.from(guid, opts.token);
+
+        if (exists) {
+            if (opts.subscribed !== undefined || opts.missiontoken !== undefined) {
+                await exists.update({
+                    subscribed: opts.subscribed ?? exists.subscribed,
+                    token: opts.missiontoken ?? exists.token
+                });
+            }
+
+            if (opts.reload !== false) {
+                await exists.refresh({
+                    refreshMission: true
+                });
+            }
+
+            return exists;
+        } else {
+            if (!opts.subscribed) opts.subscribed = false;
+
+            const url = stdurl('/api/marti/missions/' + encodeURIComponent(guid));
+
+            const mission = await std(url, {
+                headers: Subscription.headers(opts.missiontoken),
+                token: opts.token
+            }) as Mission;
+
+            const role = await std('/api/marti/missions/' + encodeURIComponent(guid) + '/role', {
+                headers: Subscription.headers(opts.missiontoken),
+                token: opts.token
+            }) as MissionRole;
+
+            const sub = new Subscription(
+                mission,
+                role,
+                {
+                    subscribed: false,
+                    ...opts
+                }
+            );
+
+            await db.subscription.put({
+                guid: sub.meta.guid,
+                name: sub.meta.name,
+                dirty: sub.dirty,
+                subscribed: sub.subscribed,
+                meta: sub.meta,
+                role: sub.role,
+                token: opts.missiontoken || ''
+            });
+
+            await sub.refresh();
+
+            return sub;
+        }
+    }
+
+    async update(
+        body: {
+            dirty?: boolean,
+            subscribed?: boolean,
+            token?: string,
+            description?: string
+        }
+    ): Promise<void> {
+        if (body.subscribed !== undefined) {
+            this.subscribed = body.subscribed;
+        }
+
+        if (body.dirty !== undefined) {
+            this.dirty = body.dirty;
+        }
+
+        if (body.token !== undefined) {
+            this.token = body.token;
+        }
+
+        if (body.description !== undefined) {
+            this.meta.description = body.description;
+        }
+
+        await db.subscription.update(this.guid, {
+            dirty: this.dirty,
+            subscribed: this.subscribed,
+            token: this.token
+        });
+
+        if (body.description !== undefined) {
+            const url = stdurl(`/api/marti/missions/${this.guid}`);
+            this.meta = await std(url, {
+                method: 'PATCH',
+                headers: Subscription.headers(this.missiontoken),
+                token: this.token,
+                body: {
+                    description: body.description
+                }
+            }) as Mission;
+
+            await db.subscription.update(this.guid, {
+                meta: JSON.parse(JSON.stringify(this.meta)),
+            });
+        }
+
+        this._sync.postMessage({
+            guid: this.guid,
+            type: SubscriptionEventType.UPDATE,
+            state: {
+                dirty: this.dirty,
+                subscribed: this.subscribed,
+            }
+        });
+    }
+
+    async delete(): Promise<void> {
+        const url = stdurl(`/api/marti/missions/${this.guid}`);
+        const list = await std(url, {
+            method: 'DELETE',
+            headers: Subscription.headers(this.missiontoken),
+            token: this.token
+        }) as { data: Array<unknown> };
+
+        if (list.data.length !== 1) throw new Error('Mission Error');
+
+        await db.subscription.delete(this.meta.guid);
+
+        this._sync.postMessage({
+            guid: this.guid,
+            type: SubscriptionEventType.DELETE,
+            state: {
+                dirty: this.dirty,
+                subscribed: this.subscribed,
+            }
+        });
+    }
+
+    headers(): Record<string, string> {
+        return Subscription.headers(this.missiontoken);
+    }
+
+    /**
+     * Reload the Mission from the local Database
+     */
+    async reload(): Promise<void> {
+        const exists = await db.subscription
+            .get(this.guid)
+
+        if (exists) {
+            this.meta = exists.meta;
+            this.role = exists.role;
+            this.missiontoken = exists.token;
+            this.subscribed = exists.subscribed;
+        }
+    };
+
+    /**
+     * Perform a hard refresh of the Mission from the Server
+     */
+    async refresh(opts?: {
+        refreshMission?: boolean
+    }): Promise<void> {
+        if (opts?.refreshMission) {
+            await this.fetch();
+        }
+
+        await Promise.all([
+            this.log.refresh(),
+            this.feature.refresh(),
+        ]);
+    };
+
+    async fetch(): Promise<void> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.guid));
+
+        this.meta = await std(url, {
+            headers: Subscription.headers(this.missiontoken),
+            token: this.token
+        }) as Mission;
+    }
+
+    /**
+     * List all locally stored missions, with optional filtering
+     *
+     * @param filter - Filter options for the local mission list
+     * @param filter.role - Filter by minimum role
+     * @param filter.subscribed - Filter by subscription status
+     * @param filter.dirty - Filter by dirty status
+     */
+    static async localList(
+        filter?: {
+            role?: 'MISSION_OWNER' | 'MISSION_SUBSCRIBER' | 'MISSION_READONLY_SUBSCRIBER',
+            subscribed?: boolean,
+            dirty?: boolean
+        }
+    ): Promise<Set<{
+        guid: string;
+        name: string;
+    }>> {
+        let collection = db.subscription.toCollection();
+
+        if (filter?.subscribed !== undefined) {
+            collection = collection.filter((sub) => sub.subscribed === filter.subscribed);
+        }
+
+        if (filter?.dirty !== undefined) {
+            collection = collection.filter((sub) => sub.dirty === filter.dirty);
+        }
+
+        if (filter?.role !== undefined) {
+            collection = collection.filter((sub) => {
+                if (!sub.role) return false;
+
+                if (filter.role === 'MISSION_OWNER') {
+                    return sub.role.type === 'MISSION_OWNER'
+                } else if (filter.role === 'MISSION_SUBSCRIBER') {
+                    return sub.role.type === 'MISSION_OWNER' || sub.role.type === 'MISSION_SUBSCRIBER'
+                } else {
+                    return true;
+                }
+            });
+        }
+
+
+        const list = await collection
+            .sortBy('name');
+
+        const guids = new Set<{
+            guid: string;
+            name: string;
+        }>();
+
+        for (const sub of list) {
+            guids.add({
+                name: sub.name,
+                guid: sub.guid
+            });
+        }
+
+        return guids;
+    }
+
+    static async list(opts: {
+        passwordProtected?: boolean;
+        defaultRole?: boolean;
+    } = {}): Promise<MissionList> {
+        if (opts.passwordProtected === undefined) opts.passwordProtected = true;
+        if (opts.defaultRole === undefined) opts.defaultRole = true;
+
+        const url = stdurl('/api/marti/mission');
+        url.searchParams.append('passwordProtected', String(opts.passwordProtected));
+        url.searchParams.append('defaultRole', String(opts.defaultRole));
+        return await std(url) as MissionList;
+    }
+
+    static headers(token?: string): Record<string, string> {
+        const headers: Record<string, string> = {};
+        if (token) headers.MissionAuthorization = token;
+        return headers;
+    }
+
+    async subscriptions(): Promise<MissionSubscriptions> {
+        const url = stdurl(`/api/marti/missions/${encodeURIComponent(this.guid)}/subscriptions/roles`);
+
+        const res = await std(url, {
+            method: 'GET',
+            token: this.token,
+            headers: Subscription.headers(this.missiontoken)
+        }) as {
+            data: MissionSubscriptions
+        };
+
+        return res.data
+    }
+
+    async changes(): Promise<MissionChanges> {
+        const url = stdurl('/api/marti/missions/' + encodeURIComponent(this.guid) + '/changes');
+
+        return await std(url, {
+            method: 'GET',
+            token: this.token,
+            headers: Subscription.headers(this.missiontoken)
+        }) as MissionChanges;
+    }
+
+    async layerList(): Promise<MissionLayerList> {
+        const url = stdurl(`/api/marti/missions/${encodeURIComponent(this.guid)}/layer`);
+
+        const list = await std(url, {
+            method: 'GET',
+            token: this.token,
+            headers: Subscription.headers(this.missiontoken)
+        }) as MissionLayerList;
+
+        list.data.sort((a, b) => {
+            // Consistent sort by name
+            return a.name.localeCompare(b.name);
+        });
+
+        return list;
+    }
+
+    async layerUpdate(
+        guid: string,
+        layerid: string,
+        layer: MissionLayer_Update
+    ): Promise<MissionLayer> {
+        const url = stdurl(`/api/marti/missions/${this.guid}/layer/${layerid}`);
+
+        return await std(url, {
+            method: 'PATCH',
+            body: layer,
+            token: this.token,
+            headers: Subscription.headers(this.missiontoken)
+        }) as MissionLayer;
+    }
+
+    async layerCreate(
+        layer: MissionLayer_Create
+    ): Promise<MissionLayer> {
+        const url = stdurl(`/api/marti/missions/${this.guid}/layer`);
+
+        return await std(url, {
+            method: 'POST',
+            body: layer,
+            token: this.token,
+            headers: Subscription.headers(this.missiontoken)
+        }) as MissionLayer;
+    }
+
+    async layerDelete(
+        layeruid: string
+    ): Promise<void> {
+        const url = stdurl(`/api/marti/missions/${this.guid}/layer/${layeruid}`);
+        await std(url, {
+            method: 'DELETE',
+            token: this.token,
+            headers: Subscription.headers(this.missiontoken)
+        })
+    }
+}