@tak-ps/cloudtak 12.54.0 → 12.94.0

package/src/workers/atlas-profile.ts

@@ -1,374 +0,0 @@
-import { toRaw } from 'vue';
-import type Atlas from './atlas.ts';
-import { std, stdurl } from '../std.ts';
-import { WorkerMessageType, LocationState } from '../base/events.ts'
-import type { Feature, Group, Server, Profile, Profile_Update, FeaturePropertyCreator } from '../types.ts';
-
-export type ProfileLocation = {
-    source: LocationState
-    accuracy: number | undefined
-    altitude: number | null | undefined
-    coordinates: number[]
-}
-
-export default class AtlasProfile {
-    atlas: Atlas;
-
-    // Interval for reporting location to TAK Server
-    timerSelf: ReturnType<typeof setInterval> | undefined;
-
-    location: ProfileLocation;
-
-    channels: Array<Group>;
-    profile: Profile | null;
-    server: Server | null;
-
-    constructor(atlas: Atlas) {
-        this.atlas = atlas;
-
-        this.timerSelf = undefined;
-
-        this.location = {
-            source: LocationState.Disabled,
-            accuracy: undefined,
-            altitude: undefined,
-            coordinates: [0, 0]
-        };
-
-        this.channels = [];
-        this.profile = null;
-        this.server = null;
-
-    }
-
-    async init(): Promise<string> {
-        this.setupTimer();
-
-        await Promise.all([
-            this.load(),
-            this.loadServer(),
-            this.loadChannels()
-        ])
-
-        if (!this.profile) {
-            throw new Error('Failed loading profile');
-        } else {
-            return this.profile.username;
-        }
-    }
-
-    async username(): Promise<string> {
-        const profile = await this.load();
-        return profile.username;
-    }
-
-    async creator(): Promise<FeaturePropertyCreator> {
-        return {
-            uid: this.uid(),
-            type: 'a-f-G-E-V-C',
-            callsign: await this.callsign(),
-            time: new Date().toISOString(),
-        }
-    }
-
-    async callsign(): Promise<string> {
-        const profile = await this.load();
-        return profile.tak_callsign;
-    }
-
-    async isSystemAdmin(): Promise<boolean> {
-        const profile = await this.load();
-        return profile.system_admin;
-    }
-
-    async isAgencyAdmin(): Promise<boolean> {
-        const profile = await this.load();
-        return profile.agency_admin.length > 0;
-    }
-
-    hasNoConfiguration(): boolean {
-        if (!this.profile) return false;
-        return this.profile.created === this.profile.updated;
-    }
-
-    hasNoChannels(): boolean {
-        for (const ch of this.channels) {
-            if (ch.active) return false
-        }
-
-        return true;
-    }
-
-
-    destroy(): void {
-        if (this.timerSelf) {
-            clearInterval(this.timerSelf);
-            this.timerSelf = undefined;
-        }
-    }
-
-    setupTimer() {
-        if (this.timerSelf) {
-            clearInterval(this.timerSelf);
-        }
-
-        this.timerSelf = setInterval(async () => {
-            // Always send CoT - use GPS coordinates if available, manual location if set, otherwise default to 0,0
-            if (this.location.accuracy) {
-                await this.CoT(this.location.coordinates, this.location.accuracy, this.location.altitude);
-            } else if (this.profile && this.profile.tak_loc) {
-                await this.CoT();
-            } else {
-                // Send 0,0 location when no valid location is available
-                await this.CoT([0, 0]);
-            }
-
-            const me = await this.atlas.db.get(this.uid());
-
-            if (me) {
-                this.atlas.conn.sendCOT(me.as_feature())
-            }
-        }, this.profile ? this.profile.tak_loc_freq : 2000);
-    }
-
-    async loadServer(): Promise<Server> {
-        if (!this.server) {
-            this.server = await std('/api/server', {
-                token: this.atlas.token
-            }) as Server;
-        }
-
-        return this.server;
-    }
-
-    async load(): Promise<Profile> {
-        if (!this.profile) {
-            const profile = await std('/api/profile', {
-                token: this.atlas.token
-            }) as Profile;
-
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Callsign,
-                body: { callsign: profile.tak_callsign }
-            });
-
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Display_Zoom,
-                body: { zoom: profile.display_zoom }
-            });
-
-            this.profile = profile;
-        }
-
-        this.updateLocation()
-
-        return this.profile;
-    }
-
-    updateLocation() {
-        if (
-            this.profile
-            && this.profile.tak_loc
-        ) {
-            this.location.source = LocationState.Preset;
-            this.location.accuracy = undefined;
-            this.location.altitude = undefined;
-            this.location.coordinates = this.profile.tak_loc.coordinates;
-
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Location_Source,
-                body: { source: LocationState.Preset }
-            });
-        } else if (this.profile && !this.profile.tak_loc && this.location.source === LocationState.Preset) {
-            // Reset to disabled when manual location is cleared
-            this.location.source = LocationState.Disabled;
-            this.location.accuracy = undefined;
-            this.location.coordinates = [0, 0];
-
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Location_Source,
-                body: { source: LocationState.Disabled }
-            });
-        }
-    }
-
-    async setChannel(name: string, active: boolean): Promise<Array<Group>> {
-        this.channels.forEach((ch) => {
-            if (ch.name === name) ch.active = active;
-            return ch;
-        });
-
-        await this.atlas.db.clear({
-            ignoreArchived: true,
-            skipNetwork: false
-        })
-
-        return await this.updateChannels(this.channels);
-    }
-
-    async setAllChannels(active: boolean): Promise<Array<Group>> {
-        this.channels.forEach((ch) => {
-            ch.active = active;
-        });
-
-        await this.atlas.db.clear({
-            ignoreArchived: true,
-            skipNetwork: false
-        })
-
-        return await this.updateChannels(this.channels);
-    }
-
-    async updateChannels(channels: Array<Group>): Promise<Array<Group>> {
-        this.channels = channels;
-
-        this.postChannelStatus();
-
-        const url = stdurl('/api/marti/group');
-        await std(url, {
-            method: 'PUT',
-            token: this.atlas.token,
-            body: this.channels
-        });
-
-        return this.channels;
-    }
-
-    postChannelStatus(): void {
-        if (this.hasNoChannels()) {
-            this.atlas.postMessage({ type: WorkerMessageType.Channels_None });
-        } else {
-            this.atlas.postMessage({ type: WorkerMessageType.Channels_List });
-        }
-    }
-
-    async loadChannels(): Promise<Array<Group>> {
-        const url = stdurl('/api/marti/group');
-        url.searchParams.append('useCache', 'true');
-        this.channels = ((await std(url, {
-            token: this.atlas.token
-        })) as {
-            data: Group[]
-        }).data
-
-        this.postChannelStatus();
-
-        return this.channels
-    }
-
-    async update(body: Profile_Update): Promise<void> {
-        if (this.profile && body.tak_loc_freq && this.profile.tak_loc_freq !== body.tak_loc_freq) {
-            this.setupTimer();
-        }
-
-        // Ensure if network request fails user intent is preserved for session
-        if (this.profile) {
-            Object.assign(this.profile, body);
-        }
-
-        if (body.tak_loc) {
-            await this.CoT();
-        }
-
-        if (body.tak_callsign) {
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Callsign,
-                body: { callsign: body.tak_callsign }
-            });
-        }
-
-        if (body.display_zoom) {
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Display_Zoom,
-                body: { zoom: body.display_zoom }
-            });
-        }
-
-        if (body.display_projection) {
-            this.atlas.postMessage({
-                type: WorkerMessageType.Map_Projection,
-                body: { type: body.display_projection }
-            });
-        }
-
-        if (body.display_icon_rotation !== undefined) {
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Icon_Rotation,
-                body: { enabled: body.display_icon_rotation }
-            });
-        }
-
-        if (body.display_distance) {
-            this.atlas.postMessage({
-                type: WorkerMessageType.Profile_Distance_Unit,
-                body: { unit: body.display_distance }
-            });
-        }
-
-        if (body.tak_loc !== undefined || body.tak_type) {
-            this.updateLocation();
-        }
-
-        this.profile = await std('/api/profile', {
-            method: 'PATCH',
-            token: this.atlas.token,
-            body
-        }) as Profile
-
-    }
-
-    uid(): string {
-        if (!this.profile) throw new Error('Profile must be loaded before CoT is called');
-
-        // Need to differentiate between servers eventually
-        return `ANDROID-CloudTAK-${this.profile.username}`;
-    }
-
-    async CoT(coords?: number[], accuracy?: number, altitude?: number | null): Promise<void> {
-        if (!this.profile || !this.server) throw new Error('Profile must be loaded before CoT is called');
-
-        const coordinates = coords || (this.profile.tak_loc ? toRaw(this.profile.tak_loc.coordinates) : [ 0, 0 ]);
-        
-        // HAE = Height Above Ellipsoid (altitude), CE = Circular Error (accuracy)
-        const hae = altitude !== null && altitude !== undefined ? altitude : 0;
-
-        const uid = this.uid();
-       
-        const feat: Feature = {
-            id: uid,
-            path: '/',
-            type: 'Feature',
-            properties: {
-                id: uid,
-                type: this.profile.tak_type,
-                how: 'm-g',
-                callsign: this.profile.tak_callsign,
-                remarks: this.profile.tak_remarks,
-                droid: this.profile.tak_callsign,
-                time: new Date().toISOString(),
-                start: new Date().toISOString(),
-                stale: new Date(new Date().getTime() + (1000 * 60)).toISOString(),
-                center: coordinates,
-                contact: {
-                    endpoint: '*:-1:stcp',
-                    callsign: this.profile.tak_callsign,
-                },
-                group: {
-                    name: this.profile.tak_group,
-                    role: this.profile.tak_role
-                },
-                takv: {
-                    device: navigator.userAgent,
-                    platform: 'CloudTAK',
-                    os: navigator.platform,
-                    version: this.server.version
-                },
-                hae,
-                ...(accuracy !== undefined && { ce: accuracy })
-            } as Feature['properties'],
-            geometry: { type: 'Point', coordinates: [...coordinates, hae] }
-        }
-
-        await this.atlas.db.add(feat);
-    }
-}

package/src/workers/atlas-team.ts

@@ -1,90 +0,0 @@
-import type Atlas from './atlas.ts';
-import { std, stdurl } from '../std.ts';
-import type COT from '../base/cot.ts';
-import TAKNotification, { NotificationType } from '../base/notification.ts';
-import {
-    WorkerMessageType
-} from '../base/events.ts';
-
-import type { ContactList, Contact } from '../types.ts';
-
-export default class AtlasTeam {
-    atlas: Atlas;
-    contacts: Map<string, Contact>
-
-    constructor(atlas: Atlas) {
-        this.atlas = atlas;
-
-        this.contacts = new Map();
-    }
-
-    async init(): Promise<void> {
-        await Promise.all([ this.load() ])
-    }
-
-    async set(cot: COT): Promise<Contact> {
-        if (!cot.properties.group) {
-            throw new Error('Contact Marker must have group property');
-        }
-
-        const entry = this.contacts.get(cot.id);
-
-        if (entry) {
-            return entry;
-        } else {
-            const contact: Contact = {
-                uid: cot.id,
-                notes: '',
-                filterGroups: null,
-                callsign: cot.properties.callsign,
-                team: cot.properties.group.name,
-                role: cot.properties.group.role,
-                takv: ''
-            }
-
-            this.contacts.set(cot.id, contact);
-
-            this.atlas.postMessage({
-                type: WorkerMessageType.Contact_Change
-            });
-
-            if (this.atlas.profile.uid() !== cot.id) {
-                await TAKNotification.create(
-                    NotificationType.Contact,
-                    'Online Contact',
-                    `${cot.properties.callsign} is now Online`,
-                    `/cot/${cot.id}`,
-                    false
-                );
-            }
-
-            return contact;
-        }
-    }
-
-    async get(uid: string): Promise<Contact | undefined> {
-        return this.contacts.get(uid);
-    }
-
-    async getByCallsign(callsign: string): Promise<Contact | undefined> {
-        for (const contact of this.contacts.values()) {
-            if (contact.callsign === callsign) return contact;
-        }
-    }
-
-    async load(): Promise<Map<string, Contact>> {
-        const url = stdurl('/api/marti/api/contacts/all');
-        const contacts = await std(url, {
-            token: this.atlas.token
-        }) as ContactList;
-
-        this.contacts.clear();
-
-        for (const contact of contacts) {
-            if (!contact.uid) continue;
-            this.contacts.set(contact.uid, contact);
-        }
-
-        return this.contacts;
-    }
-}

package/src/workers/atlas.ts

@@ -1,81 +0,0 @@
-/*
-* ConnectionStore - Maintain the WebSocket connection with CloudTAK Server
-*/
-
-import { WorkerMessageType, LocationState } from '../base/events.ts';
-import type { WorkerMessage } from '../base/events.ts';
-import * as Comlink from 'comlink';
-import AtlasProfile from './atlas-profile.ts';
-import type { ProfileLocation } from './atlas-profile.ts';
-import AtlasTeam from './atlas-team.ts';
-import AtlasDatabase from './atlas-database.ts';
-import AtlasConnection from './atlas-connection.ts';
-import { CloudTAKTransferHandler } from '../base/handler.ts';
-
-export default class Atlas {
-    channel: BroadcastChannel;
-    sync: BroadcastChannel;
-
-    token: string;
-
-    db = Comlink.proxy(new AtlasDatabase(this));
-    team = Comlink.proxy(new AtlasTeam(this));
-    conn = Comlink.proxy(new AtlasConnection(this));
-    profile = Comlink.proxy(new AtlasProfile(this));
-
-    constructor() {
-        this.channel = new BroadcastChannel('cloudtak');
-        this.sync = new BroadcastChannel('sync');
-        this.token = '';
-
-        this.channel.onmessage = (event: MessageEvent<WorkerMessage>) => {
-            const msg = event.data;
-            if (!msg || !msg.type) return;
-
-            if (msg.type === WorkerMessageType.Profile_Location_Coordinates) {
-                // Only process GPS coordinates if not in manual location mode
-                if (this.profile.location.source !== LocationState.Preset) {
-                    this.postMessage({
-                        type: WorkerMessageType.Profile_Location_Source,
-                        body: {
-                            source: LocationState.Live
-                        }
-                    })
-
-                    this.profile.location = {
-                        source: LocationState.Live,
-                        ...msg.body
-                    } as ProfileLocation;
-                }
-            }
-        }
-    }
-
-    async postMessage(msg: WorkerMessage): Promise<void> {
-        return this.channel.postMessage(msg);
-    }
-
-    async init(authToken: string) {
-        if (this.token) return;
-
-        this.token = authToken;
-
-        const username = await this.profile.init();
-        await this.conn.connect(username)
-
-        await Promise.all([
-            this.db.init(),
-            this.team.init()
-        ])
-    }
-
-    destroy() {
-        this.conn.destroy();
-    }
-}
-
-const atlas = new Atlas()
-
-new CloudTAKTransferHandler(atlas, Comlink.transferHandlers, false);
-
-Comlink.expose(Comlink.proxy(atlas));