@tak-ps/node-tak 8.3.0 → 8.4.0

package/dist/lib/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../lib/stream.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc;IACtD,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC3C,MAAM,IAAI,GAAG,KAAK,EAAU,CAAC;QAC7B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7C,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrD,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE,CAAC,MAAM,CAAC,6BAA6B,GAAG,EAAE,CAAC,CAAC,CAAC;IACnF,CAAC,CAAC,CAAC;AACP,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../index.ts","../test/default.test.ts","../test/findCoT.test.ts"],"version":"5.8.3"}
+{"root":["../index.ts","../test/default.test.ts","../test/findCoT.test.ts","../lib/api.ts","../lib/auth.ts","../lib/fetch.ts","../lib/stream.ts","../lib/api/contacts.ts","../lib/api/credentials.ts","../lib/api/export.ts","../lib/api/files.ts","../lib/api/groups.ts","../lib/api/mission-layer.ts","../lib/api/mission-log.ts","../lib/api/mission.ts","../lib/api/oauth.ts","../lib/api/package.ts","../lib/api/query.ts","../lib/api/subscriptions.ts","../lib/api/types.ts","../lib/api/video.ts"],"version":"5.8.3"}

package/index.ts

@@ -3,6 +3,9 @@ import tls from 'node:tls';
 import CoT from '@tak-ps/node-cot';
 import type { TLSSocket } from 'node:tls'
 
+export * from './lib/api.js';
+export * from './lib/auth.js';
+
 /* eslint-disable no-control-regex */
 export const REGEX_CONTROL = /[\u000B-\u001F\u007F-\u009F]/g;
 
@@ -234,4 +237,6 @@ export default class TAK extends EventEmitter {
     }
 }
 
-export { CoT }
+export {
+    CoT,
+}

package/lib/api/contacts.ts

@@ -0,0 +1,27 @@
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+
+export const Contact = Type.Object({
+    filterGroups: Type.Any(), // I'm not familiar with this one
+    notes: Type.String(),
+    callsign: Type.String(),
+    team: Type.String(),
+    role: Type.String(),
+    takv: Type.String(),
+    uid: Type.String()
+});
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(): Promise<Array<Static<typeof Contact>>> {
+        const url = new URL(`/Marti/api/contacts/all`, this.api.url);
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+}

package/lib/api/credentials.ts

@@ -0,0 +1,74 @@
+import TAKAPI from '../api.js';
+import { APIAuthPassword } from '../auth.js';
+import { Static, Type } from '@sinclair/typebox';
+import pem from 'pem';
+import xml2js from 'xml2js';
+
+export const CertificateResponse = Type.Object({
+    cert: Type.String(),
+    key: Type.String()
+});
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async config() {
+        const url = new URL(`/Marti/api/tls/config`, this.api.url);
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async generate(): Promise<Static<typeof CertificateResponse>> {
+        if (!(this.api.auth instanceof APIAuthPassword)) throw new Error('Must use Password Auth');
+
+        const config = await xml2js.parseStringPromise(await this.config());
+
+        let organization = null;
+        let organizationUnit = null;
+        for (const nameEntry of config['ns2:certificateConfig'].nameEntries) {
+            for (const ne of nameEntry.nameEntry) {
+                if (ne['$'].name === 'O') organization = ne['$'].value;
+                if (ne['$'].name === 'OU') organizationUnit = ne['$'].value;
+            }
+        }
+
+        const createCSR = pem.promisified.createCSR;
+
+        const keys: {
+            csr: string,
+            clientKey: string
+        } = await createCSR({
+            organization,
+            organizationUnit,
+            commonName: this.api.auth.username
+        });
+
+        const url = new URL(`/Marti/api/tls/signClient/v2`, this.api.url);
+        url.searchParams.append('clientUid', this.api.auth.username + ' (ETL)');
+        url.searchParams.append('version', '3');
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            nocookies: true,
+            headers: {
+                Accept: 'application/json',
+                Authorization: 'Basic ' + btoa(this.api.auth.username + ":" + this.api.auth.password)
+            },
+            body: keys.csr
+        });
+
+        let cert = '-----BEGIN CERTIFICATE-----\n' + res.signedCert;
+        if (!res.signedCert.endsWith('\n')) cert = cert + '\n';
+        cert = cert + '-----END CERTIFICATE-----';
+
+        return {
+            cert,
+            key: keys.clientKey
+        }
+    }
+}

package/lib/api/export.ts

@@ -0,0 +1,44 @@
+import TAKAPI from '../api.js';
+import { Type, Static } from '@sinclair/typebox';
+import { Readable } from 'node:stream';
+
+export const ExportInput = Type.Object({
+    startTime: Type.String(),
+    endTime: Type.String(),
+    groups: Type.Array(Type.String()),
+    format: Type.String({ enum: ['kmz', 'kml'] }),
+    interval: Type.Optional(Type.Number()),
+    multiTrackThreshold: Type.Optional(Type.String()),
+    extendedData: Type.Optional(Type.Boolean()),
+    optimizeExport: Type.Optional(Type.Boolean()),
+});
+
+/**
+ * @class
+ */
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async export(query: Static<typeof ExportInput>): Promise<Readable> {
+        const url = new URL(`/Marti/ExportMissionKML`, this.api.url);
+
+        const params = new URLSearchParams();
+        let q: keyof Static<typeof ExportInput>;
+        for (q in query) {
+            if (query[q] !== undefined ) {
+                params.append(q, String(query[q]));
+            }
+        }
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            body: params
+        }, true);
+
+        return res.body;
+    }
+}

package/lib/api/files.ts

@@ -0,0 +1,151 @@
+import TAKAPI from '../api.js';
+import FormData from 'form-data';
+import { Readable } from 'node:stream';
+import mime from 'mime';
+import { Type, Static } from '@sinclair/typebox';
+
+export const Content = Type.Object({
+  UID: Type.String(),
+  SubmissionDateTime: Type.String(),
+  Keywords: Type.Array(Type.String()),
+  MIMEType: Type.String(),
+  SubmissionUser: Type.String(),
+  PrimaryKey: Type.String(),
+  Hash: Type.String(),
+  CreatorUid: Type.String(),
+  Name: Type.String()
+});
+
+export const Config = Type.Object({
+    uploadSizeLimit: Type.Integer()
+})
+
+export default class File {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    // TODO Investigate this endpoint
+    list() {
+        new URL(`/Marti/api/sync/search`, this.api.url);
+        // param hash=<hash>
+    } 
+
+    async meta(hash: string): Promise<string> {
+        const url = new URL(`/Marti/sync/${encodeURIComponent(hash)}/metadata`, this.api.url);
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        }, true);
+
+        const body = await res.text();
+
+        return body;
+    }
+
+    async download(hash: string): Promise<Readable> {
+        const url = new URL(`/Marti/sync/content`, this.api.url);
+        url.searchParams.append('hash', hash);
+
+        const res = await this.api.fetch(url, {
+            method: 'GET'
+        }, true);
+
+        return res.body;
+    }
+
+    async adminDelete(hash: string) {
+        const url = new URL(`/Marti/api/files/${hash}`, this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'DELETE',
+        });
+    }
+
+    async delete(hash: string) {
+        const url = new URL(`/Marti/sync/delete`, this.api.url);
+        url.searchParams.append('hash', hash)
+
+        return await this.api.fetch(url, {
+            method: 'DELETE',
+        });
+    }
+
+    // TODO Return a Content Object
+    async uploadPackage(opts: {
+        name: string;
+        creatorUid: string;
+        hash: string;
+    }, body: Readable | Buffer): Promise<string> {
+        const url = new URL(`/Marti/sync/missionupload`, this.api.url);
+        url.searchParams.append('filename', opts.name)
+        url.searchParams.append('creatorUid', opts.creatorUid)
+        url.searchParams.append('hash', opts.hash)
+
+        if (body instanceof Buffer) {
+            body = Readable.from(body as Buffer);
+        }
+
+        const form = new FormData()
+        form.append('assetfile', body as Readable);
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            body: form
+        }) as string;
+
+        return res;
+    }
+
+    async upload(opts: {
+        name: string;
+        contentLength: number;
+        contentType?: string;
+        keywords: string[];
+        creatorUid: string;
+        latitude?: string;
+        longitude?: string;
+        altitude?: string;
+    }, body: Readable | Buffer): Promise<Static<typeof Content>> {
+        const url = new URL(`/Marti/sync/upload`, this.api.url);
+        url.searchParams.append('name', opts.name)
+        url.searchParams.append('keywords', opts.keywords.join(','))
+        url.searchParams.append('creatorUid', opts.creatorUid)
+        if (opts.altitude) url.searchParams.append('altitude', opts.altitude);
+        if (opts.longitude) url.searchParams.append('longitude', opts.longitude);
+        if (opts.latitude) url.searchParams.append('latitude', opts.latitude);
+
+        if (body instanceof Buffer) {
+            body = Readable.from(body as Buffer);
+        }
+
+        const res = await this.api.fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': opts.contentType ? opts.contentType : mime.getType(opts.name),
+                'Content-Length': opts.contentLength
+            },
+            body: body as Readable
+        });
+
+        return JSON.parse(res);
+    }
+
+    async count() {
+        const url = new URL('/Marti/api/files/metadata/count', this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+
+    async config(): Promise<Static<typeof Config>> {
+        const url = new URL('/files/api/config', this.api.url);
+
+        return await this.api.fetch(url, {
+            method: 'GET'
+        });
+    }
+}

package/lib/api/groups.ts

@@ -0,0 +1,63 @@
+import { Static, Type } from '@sinclair/typebox';
+import TAKAPI from '../api.js';
+import { TAKList } from './types.js';
+
+export const Group = Type.Object({
+    name: Type.String(),
+    direction: Type.String(),
+    created: Type.String(),
+    type: Type.String(),
+    bitpos: Type.Number(),
+    active: Type.Boolean(),
+    description: Type.Optional(Type.String())
+})
+
+export const GroupListInput = Type.Object({
+    useCache: Type.Optional(Type.Boolean())
+})
+
+export const TAKList_Group = TAKList(Group);
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    async list(
+        query: Static<typeof GroupListInput> = {}
+    ): Promise<Static<typeof TAKList_Group>> {
+        const url = new URL(`/Marti/api/groups/all`, this.api.url);
+
+        let q: keyof Static<typeof GroupListInput>;
+        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(
+        body: Static<typeof Group>[],
+        query: Static<typeof GroupListInput> = {}
+    ): Promise<void> {
+        const url = new URL(`/Marti/api/groups/active`, this.api.url);
+
+        let q: keyof Static<typeof GroupListInput>;
+        for (q in query) {
+            if (query[q] !== undefined) {
+                url.searchParams.append(q, String(query[q]));
+            }
+        }
+
+        await this.api.fetch(url, {
+            method: 'PUT',
+            body
+        });
+    }
+}

package/lib/api/mission-layer.ts

@@ -0,0 +1,312 @@
+import TAKAPI from '../api.js';
+import { TAKList, TAKItem } from './types.js';
+import { Type, Static } from '@sinclair/typebox';
+import type { MissionOptions } from './mission.js';
+import { GUIDMatch } from './mission.js';
+import Err from '@openaddresses/batch-error';
+import type { Feature } from '@tak-ps/node-cot';
+
+export enum MissionLayerType {
+    GROUP = 'GROUP',
+    UID = 'UID',
+    CONTENTS = 'CONTENTS',
+    MAPLAYER = 'MAPLAYER',
+    ITEM = 'ITEM'
+}
+
+export const MissionLayer = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    type: Type.Enum(MissionLayerType),
+    parentUid: Type.Optional(Type.String()),
+    uid: Type.String(),
+    mission_layers: Type.Optional(Type.Array(Type.Any())),
+    uids: Type.Optional(Type.Array(Type.Object({
+        data: Type.String({
+            description: 'The UID of the COT'
+        }),
+        timestamp: Type.String(),
+        creatorUid: Type.String(),
+        keywords: Type.Optional(Type.Array(Type.String())),
+        details: Type.Optional(Type.Object({
+            type: Type.String(),
+            callsign: Type.String(),
+            color: Type.Optional(Type.String()),
+            location: Type.Object({
+                lat: Type.Number(),
+                lon: Type.Number()
+            })
+        }))
+    }))),
+    contents: Type.Optional(Type.Array(Type.Any())),
+    maplayers: Type.Optional(Type.Array(Type.Any()))
+});
+
+export const DeleteInput = Type.Object({
+    uid: Type.Array(Type.String()),
+    creatorUid: Type.String(),
+});
+
+export const RenameInput = Type.Object({
+    name: Type.String(),
+    creatorUid: Type.String(),
+});
+
+export const CreateInput = Type.Object({
+    name: Type.String(),
+    type: Type.Enum(MissionLayerType),
+    uid: Type.Optional(Type.String()),
+    parentUid: Type.Optional(Type.String()),
+    afterUid: Type.Optional(Type.String()),
+    creatorUid: Type.String()
+})
+
+export const TAKList_MissionLayer = TAKList(MissionLayer);
+export const TAKItem_MissionLayer = TAKItem(MissionLayer);
+
+export default class {
+    api: TAKAPI;
+
+    constructor(api: TAKAPI) {
+        this.api = api;
+    }
+
+    #encodeName(name: string): string {
+        return encodeURIComponent(name.trim())
+    }
+
+    #isGUID(id: string): boolean {
+        return GUIDMatch.test(id)
+    }
+
+    #headers(opts?: Static<typeof MissionOptions>): object {
+        if (opts && opts.token) {
+            return {
+                MissionAuthorization: `Bearer ${opts.token}`
+            }
+        } else {
+            return {};
+        }
+    }
+
+    isEmpty(layer: Static<typeof MissionLayer>): boolean {
+        if (layer.mission_layers && layer.mission_layers.length) return false;
+        if (layer.uids && layer.uids.length) return false;
+        if (layer.contents && layer.contents.length) return false;
+        if (layer.maplayers && layer.maplayers.length) return false;
+        return true;
+    }
+
+    async listAsPathMap(
+        name: string,
+        opts?: Static<typeof MissionOptions>
+    ): Promise<Map<string, Static<typeof MissionLayer>>> {
+        const layers = (await this.list(name, opts)).data;
+
+        const pathMap: Map<string, Static<typeof MissionLayer>> = new Map();
+
+        for (const layer of layers) {
+            this.#listAsPathMapRecurse(pathMap, '', layer);
+        }
+
+        return pathMap;
+    }
+
+    #listAsPathMapRecurse(
+        pathMap: Map<string, Static<typeof MissionLayer>>,
+        pathCurrent: string,
+        layer: Static<typeof MissionLayer>
+    ) {
+        pathCurrent = `${pathCurrent}/${encodeURIComponent(layer.name)}`;
+        pathMap.set(`${pathCurrent}/`, layer);
+
+        for (const l of (layer.mission_layers || []) as Array<Static<typeof MissionLayer>>) {
+            this.#listAsPathMapRecurse(pathMap, pathCurrent, l);
+        }
+    }
+
+    async list(
+        name: string,
+        opts?: Static<typeof MissionOptions>
+    ): Promise<Static<typeof TAKList_MissionLayer>> {
+        let res;
+
+        if (this.#isGUID(name)) {
+            const url = new URL(`/Marti/api/missions/guid/${this.#encodeName(name)}/layers`, this.api.url);
+
+            res = await this.api.fetch(url, {
+                method: 'GET',
+                headers: this.#headers(opts),
+            });
+        } else {
+            const url = new URL(`/Marti/api/missions/${this.#encodeName(name)}/layers`, this.api.url);
+
+            res = await this.api.fetch(url, {
+                method: 'GET',
+                headers: this.#headers(opts),
+            });
+        }
+
+        res.data.map((l: Static<typeof MissionLayer>) => {
+            if (l.type === MissionLayerType.UID && !l.uids) {
+                l.uids = [];
+            }
+            return l;
+        })
+
+        return res;
+    }
+
+    /**
+     * Stopgap function until the main latestFeats function can accept a path
+     * parameter
+     */
+    async latestFeats(
+        name: string,
+        layerUid: string, // Layer UID
+        opts?: Static<typeof MissionOptions>
+    ): Promise<Static<typeof Feature.Feature>[]> {
+        const layer = (await this.get(name, layerUid, opts)).data;
+        const feats = await this.api.Mission.latestFeats(name, opts);
+
+        const layerUids = new Set((layer.uids || []).map((u) => {
+            return u.data
+        }));
+
+        const filtered = feats.filter((f) => {
+            return layerUids.has(f.id)
+        });
+
+        return filtered;
+    }
+
+    async get(
+        name: string,
+        layerUid: string, // Layer UID
+        opts?: Static<typeof MissionOptions>
+    ): Promise<Static<typeof TAKItem_MissionLayer>> {
+        const layers = await this.list(name, opts);
+
+        // TODO this will only return top level layers - need to recurse to lower level layers
+        for (const layer of layers.data) {
+            if (layer.uid === layerUid) {
+                return {
+                    version: layers.version,
+                    type: layers.type,
+                    data: layer,
+                    nodeId: layers.nodeId
+                }
+            }
+        }
+
+        throw new Err(404, null, `Layer ${layerUid} not found - only top level layers will be returned`);
+    }
+
+    async create(
+        name: string,
+        query: Static<typeof CreateInput>,
+        opts?: Static<typeof MissionOptions>
+    ): Promise<Static<typeof TAKItem_MissionLayer>> {
+        if (this.#isGUID(name)) {
+            const url = new URL(`/Marti/api/missions/guid/${this.#encodeName(name)}/layers`, this.api.url);
+
+            let q: keyof Static<typeof CreateInput>;
+            for (q in query) {
+                if (query[q] !== undefined) {
+                    url.searchParams.append(q, String(query[q]));
+                }
+            }
+
+            return await this.api.fetch(url, {
+                method: 'PUT',
+                headers: this.#headers(opts),
+            });
+        } else {
+            const url = new URL(`/Marti/api/missions/${this.#encodeName(name)}/layers`, this.api.url);
+
+            let q: keyof Static<typeof CreateInput>;
+            for (q in query) {
+                if (query[q] !== undefined) {
+                    url.searchParams.append(q, String(query[q]));
+                }
+            }
+
+            return await this.api.fetch(url, {
+                method: 'PUT',
+                headers: this.#headers(opts),
+            });
+        }
+    }
+
+    async rename(
+        name: string,
+        layer: string,
+        query: Static<typeof RenameInput>,
+        opts?: Static<typeof MissionOptions>
+    ) {
+        if (this.#isGUID(name)) {
+            const url = new URL(`/Marti/api/missions/guid/${this.#encodeName(name)}/layers/${layer}/name`, this.api.url);
+
+            let q: keyof Static<typeof RenameInput>;
+            for (q in query) {
+                if (query[q] !== undefined) {
+                    url.searchParams.append(q, String(query[q]));
+                }
+            }
+
+            return await this.api.fetch(url, {
+                method: 'PUT',
+                headers: this.#headers(opts),
+            });
+        } else {
+            const url = new URL(`/Marti/api/missions/${this.#encodeName(name)}/layers/${layer}/name`, this.api.url);
+
+            let q: keyof Static<typeof RenameInput>;
+            for (q in query) {
+                if (query[q] !== undefined) {
+                    url.searchParams.append(q, String(query[q]));
+                }
+            }
+
+            return await this.api.fetch(url, {
+                method: 'PUT',
+                headers: this.#headers(opts),
+            });
+        }
+    }
+
+    async delete(
+        name: string,
+        query: Static<typeof DeleteInput>,
+        opts?: Static<typeof MissionOptions>
+    ) {
+        if (this.#isGUID(name)) {
+            const url = new URL(`/Marti/api/missions/guid/${this.#encodeName(name)}/layers`, this.api.url);
+
+            let q: keyof Static<typeof DeleteInput>;
+            for (q in query) {
+                if (query[q] !== undefined) {
+                    url.searchParams.append(q, String(query[q]));
+                }
+            }
+
+            return await this.api.fetch(url, {
+                method: 'DELETE',
+                headers: this.#headers(opts),
+            });
+        } else {
+            const url = new URL(`/Marti/api/missions/${this.#encodeName(name)}/layers`, this.api.url);
+
+            let q: keyof Static<typeof DeleteInput>;
+            for (q in query) {
+                if (query[q] !== undefined) {
+                    url.searchParams.append(q, String(query[q]));
+                }
+            }
+
+            return await this.api.fetch(url, {
+                method: 'DELETE',
+                headers: this.#headers(opts),
+            });
+        }
+    }
+}