@tak-ps/node-tak 8.3.0 → 8.4.1

package/lib/api/oauth.ts

@@ -0,0 +1,68 @@
+import Err from '@openaddresses/batch-error';
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+
+export const LoginInput = Type.Object({
+    username: Type.String(),
+    password: Type.String()
+})
+
+export const TokenContents = Type.Object({
+    sub: Type.String(),
+    aud: Type.String(),
+    nbf: Type.Number(),
+    exp: Type.Number(),
+    iat: Type.Number()
+})
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    parse(jwt: string): Static<typeof TokenContents>{
+        const split = Buffer.from(jwt, 'base64').toString().split('}').map((ext) => { return ext + '}'});
+        if (split.length < 2) throw new Err(500, null, 'Unexpected TAK JWT Format');
+        const contents: { sub: string; aud: string; nbf: number; exp: number; iat: number; } = JSON.parse(split[1]);
+
+        return contents;
+    }
+
+    async login(query: Static<typeof LoginInput>): Promise<{
+        token: string;
+        contents: Static<typeof TokenContents>
+    }> {
+        const url = new URL(`/oauth/token`, this.api.url);
+
+        url.searchParams.append('grant_type', 'password');
+        url.searchParams.append('username', query.username);
+        url.searchParams.append('password', query.password);
+
+        const authres = await this.api.fetch(url, {
+            method: 'POST'
+        }, true);
+
+        const text = await authres.text();
+
+        if (authres.status === 401) {
+            throw new Err(400, new Error(text), 'TAK Server reports incorrect Username or Password');
+        } else if (!authres.ok) {
+            throw new Err(400, new Error(`Status: ${authres.status}: ${text}`), 'Non-200 Response from Auth Server - Token');
+        }
+
+        const body: any = JSON.parse(text);
+
+        if (body.error === 'invalid_grant' && body.error_description.startsWith('Bad credentials')) {
+            throw new Err(400, null, 'Invalid Username or Password');
+        } else if (body.error || !body.access_token) {
+            throw new Err(500, new Error(body.error_description), 'Unknown Login Error');
+        }
+
+        return {
+            token: body.access_token,
+            contents: this.parse(body.access_token)
+        };
+    }
+}

package/lib/api/package.ts

@@ -0,0 +1,56 @@
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+
+export const Package = Type.Object({
+    EXPIRATION: Type.String(),
+    UID: Type.String(),
+    SubmissionDateTime: Type.String(),
+    Keywords: Type.Array(Type.String()),
+    MIMEType: Type.String(),
+    Size: Type.String(),
+    SubmissionUser: Type.String(),
+    PrimaryKey: Type.String(),
+    Hash: Type.String(),
+    CreatorUid: Type.Optional(Type.Union([Type.Null(), Type.String()])),
+    Name: Type.String(),
+    Tool: Type.String()
+});
+
+export const ListInput = Type.Object({
+    tool: Type.Optional(Type.String()),
+    uid: Type.Optional(Type.String())
+});
+
+/**
+ * @class
+ */
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(query: Static<typeof ListInput>): Promise<{
+        resultCount: number;
+        results: Array<Static<typeof Package>>
+    }> {
+        const url = new URL(`/Marti/sync/search`, this.api.url);
+
+        let q: keyof Static<typeof ListInput>;
+        for (q in query) {
+            if (query[q] !== undefined) {
+                url.searchParams.append(q, String(query[q]));
+            }
+        }
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        });
+
+        return JSON.parse(res) as {
+            resultCount: number;
+            results: Array<Static<typeof Package>>
+        };
+    }
+}

package/lib/api/query.ts

@@ -0,0 +1,79 @@
+import TAKAPI from '../api.js';
+import Err from '@openaddresses/batch-error';
+import xmljs from 'xml-js';
+import { Type, Static } from '@sinclair/typebox';
+import CoT from '@tak-ps/node-cot';
+import type { Feature } from '@tak-ps/node-cot';
+
+export const HistoryOptions = Type.Object({
+    start: Type.Optional(Type.String()),
+    end: Type.Optional(Type.String()),
+    secago: Type.Optional(Type.String()),
+})
+
+export default class COTQuery {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async singleFeat(uid: string): Promise<Static<typeof Feature.Feature>> {
+        const cotstr = await this.single(uid);
+        return new CoT(cotstr).to_geojson();
+    }
+
+    async single(uid: string): Promise<string> {
+        const url = new URL(`/Marti/api/cot/xml/${encodeURIComponent(uid)}`, this.api.url);
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        }, true);
+
+        const body = await res.text();
+
+        if (body.trim().length === 0) {
+            throw new Err(404, null, 'CoT by that UID Not Found');
+        }
+
+        return body;
+    }
+
+    async historyFeats(uid: string, opts?: Static<typeof HistoryOptions>): Promise<Array<Static<typeof Feature.Feature>>> {
+        const feats: Static<typeof Feature.Feature>[] = [];
+
+        const res: any = xmljs.xml2js(await this.history(uid, opts), { compact: true });
+
+        if (!Object.keys(res).length || !Object.keys(res.events).length) return feats;
+        if (!res.events.event || (Array.isArray(res.events.event) && !res.events.event.length)) return feats;
+
+        for (const event of Array.isArray(res.events.event) ? res.events.event : [res.events.event] ) {
+            feats.push((new CoT({ event })).to_geojson());
+        }
+
+        return feats;
+    }
+
+    async history(uid: string, opts?: Static<typeof HistoryOptions>): Promise<string> {
+        const url = new URL(`/Marti/api/cot/xml/${encodeURIComponent(uid)}/all`, this.api.url);
+
+        if (opts) {
+            let q: keyof Static<typeof HistoryOptions>;
+            for (q in opts) {
+                if (opts[q] !== undefined) {
+                    url.searchParams.append(q, String(opts[q]));
+                }
+            }
+        }
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        }, true);
+
+        const body = await res.text();
+
+        console.error(body);
+
+        return body;
+    }
+}

package/lib/api/subscriptions.ts

@@ -0,0 +1,84 @@
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+import { Group } from './groups.js';
+import { TAKList } from './types.js';
+
+export const Subscription = Type.Object({
+    dn: Type.Union([Type.String(), Type.Null()]),
+    callsign: Type.String(),
+    clientUid: Type.String(),
+    lastReportMilliseconds: Type.Integer(),
+    takClient: Type.String(),
+    takVersion: Type.String(),
+    username: Type.String(),
+    groups: Type.Array(Group),
+    role: Type.String(),
+    team: Type.String(),
+    ipAddress: Type.String(),
+    port: Type.String(),
+    pendingWrites: Type.Integer(),
+    numProcessed: Type.Integer(),
+    protocol: Type.String(),
+    xpath: Type.Union([Type.String(), Type.Null()]),
+    subscriptionUid: Type.String(),
+    appFramerate: Type.String(),
+    battery: Type.String(),
+    batteryStatus: Type.String(),
+    batteryTemp: Type.String(),
+    deviceDataRx: Type.String(),
+    deviceDataTx: Type.String(),
+    heapCurrentSize: Type.String(),
+    heapFreeSize: Type.String(),
+    heapMaxSize: Type.String(),
+    deviceIPAddress: Type.String(),
+    storageAvailable: Type.String(),
+    storageTotal: Type.String(),
+    incognito: Type.Boolean(),
+    handlerType: Type.String(),
+    lastReportDiffMilliseconds: Type.Integer()
+});
+
+export const ListSubscriptionInput = Type.Object({
+    sortBy: Type.String({
+        default: 'CALLSIGN',
+        enum: ['CALLSIGN', 'UID']
+    }),
+    direction: Type.String({
+        default: 'ASCENDING',
+        enum: ['ASCENDING', 'DESCENDING']
+    }),
+    page: Type.Integer({
+        default: -1
+    }),
+    limit: Type.Integer({
+        default: -1
+    })
+})
+
+export const TAKList_Subscription = TAKList(Subscription);
+
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(
+        query: Static<typeof ListSubscriptionInput>
+    ): Promise<Static<typeof TAKList_Subscription>> {
+        const url = new URL(`/Marti/api/subscriptions/all`, this.api.url);
+
+        let q: keyof Static<typeof ListSubscriptionInput>;
+        for (q in query) {
+            if (query[q] !== undefined) {
+                url.searchParams.append(q, String(query[q]));
+            }
+        }
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+}

package/lib/api/types.ts

@@ -0,0 +1,43 @@
+import { TSchema, Type } from '@sinclair/typebox';
+
+export const TAKItem = <T extends TSchema>(T: T) => {
+    return Type.Object({
+        version: Type.String(),
+        type: Type.String(),
+        data: T,
+        messages: Type.Optional(Type.Array(Type.String())),
+        nodeId: Type.Optional(Type.String())
+    })
+};
+
+export const TAKList = <T extends TSchema>(T: T) => {
+    return TAKItem(Type.Array(T));
+}
+
+export enum TAKGroup {
+    WHITE = "White",
+    YELLOW = "Yellow",
+    ORANGE = "Orange",
+    MAGENTA = "Magenta",
+    RED = "Red",
+    MAROON = "Maroon",
+    PURPLE = "Purple",
+    DARK_BLUE = "Dark Blue",
+    BLUE = "Blue",
+    CYAN = "Cyan",
+    TEAL = "Teal",
+    GREEN = "Green",
+    DARK_GREEN = "Dark Green",
+    BROWN = "Brown"
+}
+
+export enum TAKRole {
+    TEAM_MEMBER = "Team Member",
+    TEAM_LEAD = "Team Lead",
+    HQ = "HQ",
+    SNIPER = "Sniper",
+    MEDIC = "Medic",
+    FORWARD_OBSERVER = "Forward Observer",
+    RTO = "RTO",
+    K9 = "K9"
+}

package/lib/api/video.ts

@@ -0,0 +1,155 @@
+import Err from '@openaddresses/batch-error';
+import { Static, Type } from '@sinclair/typebox';
+import { randomUUID } from 'node:crypto';
+import TAKAPI from '../api.js';
+
+export const FeedInput = Type.Object({
+    uuid: Type.Optional(Type.String()),
+    active: Type.Boolean({ default: true }),
+    alias: Type.String(),
+    url: Type.String(),
+});
+
+export const VideoConnectionInput = Type.Object({
+    uuid: Type.Optional(Type.String()),
+    active: Type.Boolean({
+        default: true
+    }),
+    alias: Type.String(),
+    feeds: Type.Array(FeedInput)
+});
+
+export const Feed = Type.Object({
+    uuid: Type.String(),
+    active: Type.Boolean(),
+    alias: Type.String(),
+    url: Type.String(),
+
+    order: Type.Union([Type.Integer(), Type.Null()]),
+    macAddress: Type.String(),
+    roverPort: Type.String(),
+    ignoreEmbeddedKLV: Type.String(),
+    source: Type.Union([Type.String(), Type.Null()]),
+    networkTimeout: Type.String(),
+    bufferTime: Type.String(),
+    rtspReliable: Type.String(),
+    thumbnail: Type.Union([Type.String(), Type.Null()]),
+    classification: Type.Union([Type.String(), Type.Null()]),
+    latitude: Type.Union([Type.String(), Type.Null()]),
+    longitude: Type.Union([Type.String(), Type.Null()]),
+    fov: Type.Union([Type.String(), Type.Null()]),
+    heading: Type.Union([Type.String(), Type.Null()]),
+    range: Type.Union([Type.String(), Type.Null()]),
+    width: Type.Union([Type.Integer(), Type.Null()]),
+    height: Type.Union([Type.Integer(), Type.Null()]),
+    bitrate: Type.Union([Type.Integer(), Type.Null()]),
+});
+
+export const VideoConnection = Type.Object({
+    uuid: Type.String(),
+    active: Type.Boolean(),
+    alias: Type.String(),
+    thumbnail: Type.Union([Type.String(), Type.Null()]),
+    classification: Type.Union([Type.String(), Type.Null()]),
+    feeds: Type.Array(Feed)
+})
+
+export const VideoConnectionList = Type.Object({
+    videoConnections: Type.Array(VideoConnection)
+});
+
+export const VideoConnectionListInput = Type.Object({
+    protocol: Type.Optional(Type.String())
+})
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(
+        query: Static<typeof VideoConnectionListInput> = {}
+    ): Promise<Static<typeof VideoConnectionList>> {
+        const url = new URL(`/Marti/api/video`, this.api.url);
+
+        let q: keyof Static<typeof VideoConnectionListInput>;
+        for (q in query) {
+            if (query[q] !== undefined) {
+                url.searchParams.append(q, String(query[q]));
+            }
+        }
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async update(
+        connection: Static<typeof VideoConnectionInput>
+    ): Promise<Static<typeof VideoConnection>> {
+        const url = new URL(`/Marti/api/video/${connection.uuid}`, this.api.url);
+
+        if (!connection.uuid) throw new Err(400, null, 'UUID must be set when updating Video');
+
+        await this.api.fetch(url, {
+            method: 'PUT',
+            body: {
+                ...connection,
+                feeds: connection.feeds.map((feed) => {
+                    if (!feed.uuid) feed.uuid = randomUUID();
+                    return feed;
+                })
+            }
+        });
+
+        return await this.get(connection.uuid);
+    }
+
+    async create(
+        connection: Static<typeof VideoConnectionInput>
+    ): Promise<Static<typeof VideoConnection>> {
+        const url = new URL(`/Marti/api/video`, this.api.url);
+
+        const uuid = connection.uuid || randomUUID();
+
+        await this.api.fetch(url, {
+            method: 'POST',
+            body: {
+                videoConnections: [{
+                    uuid,
+                    ...connection,
+                    feeds: connection.feeds.map((feed) => {
+                        return {
+                            uuid: randomUUID(),
+                            ...feed,
+                        }
+                    })
+                }]
+            }
+        });
+
+        return await this.get(uuid);
+    }
+
+    async get(
+        uid: string
+    ): Promise<Static<typeof VideoConnection>> {
+        const url = new URL(`/Marti/api/video/${encodeURIComponent(uid)}`, this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async delete(
+        uid: string
+    ): Promise<void> {
+        const url = new URL(`/Marti/api/video/${encodeURIComponent(uid)}`, this.api.url);
+
+        await this.api.fetch(url, {
+            method: 'DELETE'
+        });
+    }
+}

package/lib/api.ts

@@ -0,0 +1,136 @@
+import FormData from 'form-data';
+import OAuth from './api/oauth.js';
+import Package from './api/package.js';
+import Query from './api/query.js';
+import Mission from './api/mission.js';
+import MissionLog from './api/mission-log.js';
+import MissionLayer from './api/mission-layer.js';
+import Credentials from './api/credentials.js';
+import Contacts from './api/contacts.js';
+import Files from './api/files.js';
+import Group from './api/groups.js';
+import Subscription from './api/subscriptions.js';
+import Video from './api/video.js';
+import Export from './api/export.js';
+import Err from '@openaddresses/batch-error';
+import * as auth from './auth.js';
+
+/**
+ * Handle TAK HTTP API Operations
+ * @class
+ */
+export default class TAKAPI {
+    auth: auth.APIAuth;
+    url: URL;
+    Package: Package;
+    OAuth: OAuth;
+    Mission: Mission;
+    MissionLog: MissionLog;
+    MissionLayer: MissionLayer;
+    Credentials: Credentials;
+    Contacts: Contacts;
+    Subscription: Subscription;
+    Group: Group;
+    Video: Video;
+    Export: Export;
+    Query: Query;
+    Files: Files;
+
+    constructor(url: URL, auth: auth.APIAuth) {
+        this.url = url;
+        this.auth = auth;
+
+        this.Query = new Query(this);
+        this.Package = new Package(this);
+        this.OAuth = new OAuth(this);
+        this.Export = new Export(this);
+        this.Mission = new Mission(this);
+        this.MissionLog = new MissionLog(this);
+        this.MissionLayer = new MissionLayer(this);
+        this.Credentials = new Credentials(this);
+        this.Contacts = new Contacts(this);
+        this.Subscription = new Subscription(this);
+        this.Group = new Group(this);
+        this.Video = new Video(this);
+        this.Files = new Files(this);
+    }
+
+    static async init(url: URL, auth: auth.APIAuth): Promise<TAKAPI> {
+        const api = new TAKAPI(url, auth);
+
+        await api.auth.init(api);
+
+        return api;
+    }
+
+    stdurl(url: string | URL) {
+        try {
+            url = new URL(url);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (err) {
+            url = new URL(url, this.url);
+        }
+
+        return url;
+    }
+
+    /**
+     * Standardize interactions with the backend API
+     *
+     * @param {URL|String} url      - Full URL or API fragment to request
+     * @param {Object} [opts={}]    - Options
+     */
+    async fetch(url: URL, opts: any = {}, raw=false) {
+        url = this.stdurl(url);
+
+        try {
+            if (!opts.headers) opts.headers = {};
+
+            if (
+                (isPlainObject(opts.body) || Array.isArray(opts.body))
+                && (
+                    !opts.headers['Content-Type']
+                    || opts.headers['Content-Type'].startsWith('application/json')
+                )
+            ) {
+                opts.body = JSON.stringify(opts.body);
+                opts.headers['Content-Type'] = 'application/json';
+            } else if (opts.body instanceof FormData) {
+                opts.headers = opts.body.getHeaders();
+            } else if (opts.body instanceof URLSearchParams) {
+                opts.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+                opts.body = String(opts.body);
+            }
+
+            const res = await this.auth.fetch(this, url, opts)
+
+            if (raw) return res;
+
+            let bdy: any = {};
+
+            if ((res.status < 200 || res.status >= 400)) {
+                try {
+                    bdy = await res.text();
+                } catch (err) {
+                    console.error(err);
+                    bdy = null;
+                }
+
+                throw new Err(res.status, null, bdy || `Status Code: ${res.status}`);
+            }
+
+            if (res.headers.get('content-type') === 'application/json') {
+                return await res.json();
+            } else {
+                return await res.text();
+            }
+        } catch (err) {
+            if (err instanceof Error && err.name === 'PublicError') throw err;
+            throw new Err(400, null, err instanceof Error ? err.message : String(err));
+        }
+    }
+}
+
+function isPlainObject(value: object) {
+    return  value?.constructor === Object;
+}