@tak-ps/cloudtak 12.54.0

package/src/base/database.ts

@@ -0,0 +1,150 @@
+import Dexie, { type EntityTable } from 'dexie';
+import type {
+    Feature,
+    Mission,
+    MissionRole
+} from '../types.ts';
+
+export interface DBIcon {
+    name: string;
+}
+
+export interface DBFeature {
+    id: string;
+    path: string;
+    properties: Feature["properties"];
+    geometry: Feature["geometry"];
+}
+
+export interface DBChatroom {
+    id: string;
+    name: string;
+    created: string;
+    updated: string;
+    last_read: string | null;
+}
+
+export interface DBChatroomChat {
+    id: string;
+    chatroom: string;
+    sender: string;
+    sender_uid: string;
+    message: string;
+    created: string;
+}
+
+export interface DBIconset {
+    uid: string;
+    created: string;
+    updated: string;
+    version: number;
+    name: string;
+    username: string | null;
+    default_group: string | null;
+    default_friendly: string | null;
+    default_hostile: string | null;
+    default_neutral: string | null;
+    default_unknown: string | null;
+    skip_resize: boolean;
+}
+
+export interface DBFilter {
+    id: string;
+    external: string;
+    name: string;
+    source: string;
+    internal: boolean;
+    query: string;
+}
+
+export enum NotificationType {
+    Contact = 'Contact',
+    Import = 'Import',
+    Alert = 'Alert',
+    Medical = 'Medical',
+    Mission = 'Mission',
+    Chat = 'Chat'
+}
+
+export interface DBNotification {
+    id: string;
+    type: NotificationType;
+    name: string;
+    body: string;
+    url: string;
+    toast: boolean;
+    read: boolean;
+    created: string;
+}
+
+export interface DBVideo {
+    id: string;
+    created: string;
+    updated: string;
+    lease: number;
+    username: string;
+}
+
+export interface DBSubscriptionFeature {
+    id: string;
+    path: string;
+    mission: string;
+    properties: Feature["properties"];
+    geometry: Feature["geometry"];
+}
+
+export interface DBSubscription {
+    guid: string;
+    name: string;
+    meta: Mission;
+    role: MissionRole;
+    token?: string;
+
+    dirty: boolean;
+    subscribed: boolean;
+}
+
+export interface DBSubscriptionLog {
+    id: string;
+    dtg?: string;
+    missionNames: string[],
+    created: string;
+    servertime: string,
+    mission: string;
+    content: string;
+    creatorUid: string;
+    contentHashes: unknown[];
+    keywords: string[];
+}
+
+export type DatabaseType = Dexie & {
+    icon: EntityTable<DBIcon, 'name'>,
+    iconset: EntityTable<DBIconset, 'uid'>,
+    video: EntityTable<DBVideo, 'id'>,
+    filter: EntityTable<DBFilter, 'id'>,
+    feature: EntityTable<DBFeature, 'id'>,
+    chatroom: EntityTable<DBChatroom, 'id'>,
+    chatroom_chats: EntityTable<DBChatroomChat, 'id'>,
+    notification: EntityTable<DBNotification, 'id'>,
+    subscription: EntityTable<DBSubscription, 'guid'>,
+    subscription_log: EntityTable<DBSubscriptionLog, 'id'>
+    subscription_feature: EntityTable<DBSubscriptionFeature, 'id'>,
+};
+
+export const db = new Dexie('CloudTAK') as DatabaseType;
+
+db.version(1).stores({
+    icon: 'name',
+    iconset: 'uid, name',
+    filter: 'id, external',
+    video: 'id, username',
+    feature: 'id, path',
+
+    chatroom: 'id',
+    chatroom_chats: 'id, chatroom',
+
+    notification: 'id, type, name, body, url, created, toast, read',
+    subscription: 'guid, name',
+    subscription_log: 'id, [mission+id]',
+    subscription_feature: 'id, mission, [mission+id]',
+});

package/src/base/events.ts

@@ -0,0 +1,43 @@
+export enum WorkerMessageType {
+    Map_FlyTo = 'cloudtak:map:flyto',
+    Map_FitBounds = 'cloudtak:map:fitbounds',
+    Map_Projection = 'cloudtak:map:projection',
+
+    Profile_Callsign = 'cloudtak:profile:callsign',
+    Profile_Display_Zoom = 'cloudtak:profile:display:zoom',
+
+    Profile_Icon_Rotation = 'cloudtak:profile:icon:rotation',
+
+    Profile_Distance_Unit = 'cloudtak:profile:distance:unit',
+
+    Profile_Location_Coordinates = 'cloudtak:profile:location:coordinates',
+    Profile_Location_Source = 'cloudtak:profile:location:source',
+
+    Feature_Archived_Added = 'cloudtak:feature:archived:added',
+    Feature_Archived_Removed = 'cloudtak:feature:archived:removed',
+
+    Channels_None = 'channels:none',
+    Channels_List = 'channels:list',
+
+    Contact_Change = 'contact:change',
+
+    Connection_Open = 'connection:open',
+    Connection_Close = 'connection:close',
+
+    Mission_Change_Feature = 'mission:change:feature',
+    Mission_Invite = 'mission:invite',
+}
+
+export type WorkerMessage = {
+    type: WorkerMessageType,
+    // TODO Strongly type this
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    body?: any
+}
+
+export enum LocationState {
+    Loading,
+    Disabled,
+    Preset,
+    Live
+}

package/src/base/filter.ts

@@ -0,0 +1,163 @@
+import { db } from './database.ts'
+import type { Feature } from '../types.ts';
+import jsonata from 'jsonata';
+import { v4 as randomUUID } from 'uuid';
+
+/**
+ * High Level Wrapper around the Data Filters
+ *
+ * TODO: Once all COTs are in IndexDB, apply the filter on to a new field in the COT
+ * called "filtered": [ <filterid>, ... ] so we don't have to re-evaluate the filter each time
+ *
+ * @property {string} id - The unique identifier for the filter
+ * @property {string} external - The external ID of the filter
+ * @property {string} name - The name of the filter
+ * @property {string} source - The source of the filter
+ * @property {boolean} internal - Whether the filter is internal
+ * @property {string} query - The JSONata query string for the filter
+ */
+export default class Filter {
+    id: string;
+    external: string;
+    name: string;
+    source: string;
+    internal: boolean;
+    query: string;
+
+    expression: jsonata.Expression;
+
+    constructor(
+        name: string,
+        external: string,
+        source: string,
+        internal: boolean,
+        query: string
+    ) {
+        this.id = randomUUID();
+
+        this.name = name;
+        this.external = external;
+        this.source = source;
+        this.internal = internal;
+        this.query = query;
+
+        this.expression = jsonata(this.query);
+    }
+
+    async test(feature: Feature): Promise<boolean> {
+        return await this.expression.evaluate(feature);
+    }
+
+    static async list(): Promise<Filter[]> {
+        const filters = await db.filter.toArray();
+
+        return filters.map(f => {
+            const filter = new Filter(
+                f.name,
+                f.external,
+                f.source,
+                f.internal,
+                f.query
+            );
+
+            filter.id = f.id;
+
+            return filter;
+        });
+    }
+
+    static async from(
+        id: string
+    ): Promise<Filter | null> {
+        const exists = await db.filter
+            .get(id)
+
+        if (!exists) return null;
+
+        const filter = new Filter(
+            exists.name,
+            exists.external,
+            exists.source,
+            exists.internal,
+            exists.query
+        );
+
+        filter.id = exists.id;
+
+        return filter;
+    }
+
+    async update(
+        body: {
+            name?: string;
+            external?: string;
+            source?: string;
+            internal?: boolean;
+            query?: string;
+        }
+    ): Promise<void> {
+        if (body.name !== undefined) this.name = body.name;
+        if (body.external !== undefined) this.external = body.external;
+        if (body.source !== undefined) this.source = body.source;
+        if (body.internal !== undefined) this.internal = body.internal;
+        if (body.query !== undefined) this.query = body.query;
+
+        await db.filter.update(this.id, {
+            name: this.name,
+            external: this.external,
+            source: this.source,
+            internal: this.internal,
+            query: this.query,
+        });
+    }
+
+    static async create(
+        name: string,
+        external: string,
+        source: string,
+        internal: boolean,
+        query: string
+    ): Promise<Filter> {
+        const filter = new Filter(
+            name,
+            external,
+            source,
+            internal,
+            query
+        );
+
+        await db.filter.add({
+            id: filter.id,
+            name: filter.name,
+            external: filter.external,
+            source: filter.source,
+            internal: filter.internal,
+            query: filter.query,
+        });
+
+        return filter;
+    }
+
+    async delete(): Promise<void> {
+        await Filter.delete({ id: this.id });
+    }
+
+    static async delete(id: {
+        id?: string;
+        external?: string;
+    }): Promise<void> {
+        if (!id.id && !id.external) {
+            throw new Error('Either id or external must be provided for deletion.');
+        } else if (id.id) {
+            await db.filter
+                .where('id')
+                .equals(id.id)
+                .delete();
+        } else if (id.external) {
+            await db.filter
+                .where('external')
+                .equals(id.external)
+                .delete();
+        }
+    }
+}

package/src/base/handler.ts

@@ -0,0 +1,67 @@
+/*
+* ConnectionStore - Maintain the WebSocket connection with CloudTAK Server
+*/
+
+import COT from '../base/cot.ts';
+import type Atlas from '../workers/atlas.ts';
+import type { Remote, TransferHandler } from 'comlink'
+import type { Feature } from '../types.ts';
+
+export class CloudTAKTransferHandler {
+    atlas: Atlas | Remote<Atlas>;
+    remote: boolean;
+
+    constructor(
+        atlas: Atlas | Remote<Atlas>,
+        transferHandlers: Map<string, TransferHandler<unknown, unknown>>,
+        remote: boolean
+    ) {
+        this.atlas = atlas;
+        this.remote = remote;
+
+        transferHandlers.set("cot", this.cot);
+        transferHandlers.set("cots", this.cots);
+    }
+
+    cots: TransferHandler<Set<COT>, Array<Feature>> = {
+        canHandle: (obj): obj is Set<COT> => {
+            if (!(obj instanceof Set)) return false;
+            for (const val of obj.values()) {
+                if (!(val instanceof COT)) return false;
+            }
+            return true;
+        },
+        serialize: (cots: Set<COT>) => {
+            const feats = [];
+            for (const cot of cots.values()) {
+                feats.push(cot.as_feature());
+            }
+            return [feats, []];
+        },
+        deserialize: (feats) => {
+            const set = new Set<COT>;
+            for (const feat of feats) {
+                set.add(new COT(this.atlas, feat, feat.origin, {
+                    remote: this.remote
+                }));
+            }
+
+            return set;
+        }
+    }
+
+    cot: TransferHandler<COT, Feature> = {
+        canHandle: (obj): obj is COT => {
+            return obj instanceof COT;
+        },
+        serialize: (cot: COT) => {
+            const feat = cot.as_feature();
+            return [feat, []];
+        },
+        deserialize: (feat: Feature): COT => {
+            return new COT(this.atlas, feat, feat.origin, {
+                remote: true
+            });
+        }
+    }
+}

package/src/base/icon.ts

@@ -0,0 +1,16 @@
+import { db } from './database.ts';
+
+export default class Icon {
+    static async has(icon: string): Promise<boolean> {
+        return await db.icon
+            .where("name")
+            .equals(icon)
+            .count() > 0;
+    }
+
+    static async populate(icons: string[]): Promise<void> {
+        await db.icon.bulkPut(
+            icons.map((name) => ({ name })),
+        );
+    }
+}

package/src/base/notification.ts

@@ -0,0 +1,163 @@
+import { db, NotificationType } from './database.ts'
+import type { DBNotification } from './database.ts';
+import { v4 as randomUUID } from 'uuid';
+
+export { NotificationType };
+
+export default class TAKNotification {
+    id: string;
+    type: NotificationType;
+    name: string;
+    body: string;
+    url: string;
+    created: string;
+    toast: boolean;
+    read: boolean;
+
+    constructor(
+        id: string,
+        type: NotificationType,
+        name: string,
+        body: string,
+        url: string,
+        opts?: {
+            read?: boolean,
+            toast?: boolean,
+            created?: string
+        }
+    ) {
+        this.id = id;
+        this.type = type;
+        this.name = name;
+        this.body = body;
+        this.url = url;
+        this.created = opts?.created || new Date().toISOString();
+        this.toast = opts?.toast || false;
+        this.read = opts?.read || false;
+    }
+
+    /**
+     * Return a Notification instance if one already exists in the local DB,
+     */
+    static async from(
+        id: string
+    ): Promise<TAKNotification | null> {
+        const exists = await db.notification
+            .get(id)
+
+        if (!exists) {
+            return null;
+        }
+
+        return new TAKNotification(
+            exists.id,
+            exists.type,
+            exists.name,
+            exists.body,
+            exists.url,
+            {
+                read: exists.read,
+                toast: exists.toast,
+                created: exists.created
+            }
+        );
+    }
+
+    static async create(
+        type: NotificationType,
+        name: string,
+        body: string,
+        url: string,
+        toast?: boolean
+    ): Promise<TAKNotification> {
+        const id = randomUUID();
+
+        const notification = new TAKNotification(
+            id,
+            type,
+            name,
+            body,
+            url,
+            {
+                created: new Date().toISOString(),
+                toast: toast || false,
+                read: false
+            }
+        );
+
+        await db.notification.add({
+            id: notification.id,
+            type: notification.type,
+            name: notification.name,
+            body: notification.body,
+            url: notification.url,
+            created: notification.created,
+            toast: notification.toast,
+            read: notification.read
+        });
+
+        return notification;
+    }
+
+    static async update(id: string, opts: {
+        read?: boolean,
+        toast?: boolean
+    }): Promise<void> {
+        const n = await TAKNotification.from(id);
+        await n?.update(opts);
+    }
+
+    async update(opts: {
+        read?: boolean
+        toast?: boolean
+    }): Promise<void> {
+        await db.notification.put({
+            id: this.id,
+            type: this.type,
+            name: this.name,
+            body: this.body,
+            url: this.url,
+            created: this.created,
+            toast: opts.toast ?? this.toast,
+            read: opts.read ?? this.read
+        });
+    }
+
+    async popup(): Promise<void> {
+        if ('Notification' in self && Notification && Notification.permission !== 'denied') {
+            const n = new Notification(this.name, {
+                body: this.body
+            });
+
+            n.onclick = (event) => {
+                event.preventDefault(); // prevent the browser from focusing the Notification's tab
+            };
+        }
+    }
+
+    static async clear(): Promise<void> {
+        await db.notification.clear();
+    }
+
+    static async delete(id: string): Promise<void> {
+        await db.notification.delete(id);
+    }
+
+    async delete(): Promise<void> {
+        await db.notification.delete(this.id);
+    }
+
+    static async count(): Promise<number> {
+        const collection = await db.notification.toCollection();
+
+        return await collection
+            .count();
+    }
+
+    static async list(): Promise<DBNotification[]> {
+        const collection = await db.notification.toCollection();
+
+        return await collection
+            .sortBy('created');
+    }
+}