@saber-usa/node-common 1.6.207

package/src/checkNetwork.js

@@ -0,0 +1,19 @@
+const _ = require("lodash");
+const {resolve4} = require("dns").promises;
+
+const checkRecord = (hostName) => resolve4(hostName).
+    then((addresss) => !_.isEmpty(addresss)).
+    catch(_.stubFalse);
+
+
+module.exports.checkRecord = checkRecord;
+module.exports.checkNetwork = (domains) => Promise.all(
+    _.map(
+        domains,
+        (hostName) => checkRecord(hostName).
+            then((found) => found
+                ? hostName
+                : null,
+            ),
+    ),
+).then((resolved) => _.flow(_.compact, _.first)(resolved) || null);

package/src/constants.js

@@ -0,0 +1,33 @@
+// Helper math constants
+module.exports.DEG2RAD = Math.PI / 180;
+module.exports.RAD2DEG = 180 / Math.PI;
+module.exports.SEC2RAD = Math.PI / (180.0 * 3600.0); // seconds to radians conversion
+module.exports.ARCSEC2RAD = 1 / (3600 * 180 / Math.PI); // arcseconds to radians conversion (1 arcsec = 1/3600 deg = 1/3600 * π/180 rad)
+module.exports.MILLIS_PER_DAY = 24 * 60 * 60 * 1000; // Number of milliseconds in a day
+
+// Sun Constants
+module.exports.SUN_RADIUS_KM = 695701.0; // Sun radius in kilometers
+module.exports.AU_KM = 149597870.7; // Astronomical Unit in kilometers
+
+// Earth Constants
+module.exports.MU = 3.986004418e14; // (m^3)/(s^2) WGS-84 Earth Mu
+module.exports.GRAV_CONST = 6.6743e-11; // N⋅m2⋅kg−2
+module.exports.EARTH_MASS = 5.97219e24; // kg
+module.exports.WGS72_EARTH_EQUATORIAL_RADIUS_KM = 6378.135; // in km. Use this when calculations are done with SGP4 which uses WGS72 assumptions.
+module.exports.WGS84_EARTH_EQUATORIAL_RADIUS_KM = 6378.137; // in km. Use this for general calculations.
+module.exports.EARTH_RADIUS_KM = 6378.135; // still in use for backwards compatibility with old code. Has been removed from nps, ingest, node-common. TODO: refactor from all other js projects using node-common.
+module.exports.GEO_ALTITUDE_KM = 35786; // Km
+
+module.exports.REGIMES = {
+    Undetermined: 1,
+    Leo: 2,
+    Heo: 4,
+    GeoInclined: 8,
+    Meo: 16,
+    Molniya: 32,
+    Sso: 64,
+    Polar: 128,
+    GeoStationary: 256,
+    GeoDrifter: 512,
+};
+

package/src/fixDate.js

@@ -0,0 +1,69 @@
+const {isValid, parseISO, format} = require("date-fns");
+
+/**
+ * Formats a date how MySQL wants it.
+ * Note: We chop off the timezone, otherwise the date-fns converts it into your local timezone, when we want UTC
+ * @param {string} date in ISO format used by the UDL
+ * @return {string} date formatted for MySQL
+ */
+const fixDate = (date) => isValid(parseISO(date))
+    ? format(parseISO(date.replace("Z", "")), "yyyy-MM-dd HH:mm:ss")
+    : null;
+
+/**
+ * Converts a Javascript date into a MySQL formatted  date string
+ * @param {Date} date
+ * @return {string} Mysql formatted date string
+ */
+const dateToMySqlDate = (date) => new Date(date).toISOString().slice(0, 19).replace("T", " ");
+
+/**
+ * Converts string, int, or Date input into a Date. Adds Z to end of string if not present
+ * @param {*} date
+ * @return {Date} date
+ */
+const parseDate = (date) => {
+    const corrected = (typeof date !== "string" || date.endsWith("Z")) ? date : (date+"Z");
+    return new Date(corrected);
+};
+
+/**
+ * Checks if MySql date-time, if so appends UTC timezone and convets to JS date-time object.
+ * If not, assumes timezone is specified in date-time string and converts to JS date-time object.
+ * @param {String} dt date time string
+ * @return {Date} Date object in UTC
+ */
+const dtStrtoJsDt = (dt) => {
+    if (isSqlDate(dt)) {
+        // MySql date-time format
+        return mySqlDateToJs(dt);
+    }
+    return new Date(dt);
+};
+
+/** Converts MySql date-time to JS date-time
+ * @param {String} dt MySql date-time format must be yyyy-mm-dd hh:mm:ss
+ * @return {Date} JS date-time
+ */
+const mySqlDateToJs = (dt) => {
+    // check the date is in MySQL format
+    if (isSqlDate(dt)) {
+        return new Date(dt+"Z");
+    } else {
+        throw new Error("Invalid MySql date format");
+    }
+};
+
+/** Checks if a Date is a valid mySQL date, with microseconds precision (i.e. up to 6 digits).
+ * @param {String} dt The date string to test
+ * @return {Boolean} True if is SQL date, false otherwise
+ */
+const isSqlDate = (dt) => dt.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{1,6})?$/);
+
+module.exports = {
+    fixDate: fixDate,
+    parseDate: parseDate,
+    dateToMySqlDate: dateToMySqlDate,
+    mySqlDateToJs: mySqlDateToJs,
+    dtStrtoJsDt: dtStrtoJsDt,
+};

package/src/index.js

@@ -0,0 +1,11 @@
+module.exports = {
+    ...require("./loggerFactory.js"),
+    ...require("./transform.js"),
+    ...require("./checkNetwork.js"),
+    ...require("./fixDate.js"),
+    ...require("./astro.js"),
+    ...require("./launchNominal.js"),
+    ...require("./LaunchNominalClass.js"),
+    ...require("./OrbitUtils.js"),
+    udl: require("./udl"),
+};

package/src/launchNominal.js

@@ -0,0 +1,215 @@
+const {
+    twoline2satrec,
+    propagate,
+    gstime,
+    eciToGeodetic,
+    degreesToRadians,
+    radiansToDegrees,
+    eciToEcf,
+    ecfToLookAngles,
+    degreesLong,
+    degreesLat,
+} = require("satellite.js");
+const {distGeodetic} = require("./astro.js");
+const {
+    wrapToRange,
+} = require("./utils.js");
+
+const notamToCoordArray = (notam) => {
+    const regexPatterns = [
+        /(\d{4,6}[NS]|[N|S]\d{6})(\d{4,7}[EW]|[E|W]\d{7})/g,
+    ];
+
+    // clean up the NOTAM. Remove all spaces and unwanted characters and convert to upper case
+    notam = notam
+        .replace(/\s/g, "")
+        .replace(/-/g, "")
+        .replace(/\./g, "")
+        .toUpperCase();
+
+    const coordArray = [];
+    let matchFound = false;
+    let match;
+    for (const regex of regexPatterns) {
+        while ((match = regex.exec(notam)) !== null) {
+            matchFound = true;
+            // Depending on the pattern, you might need to adjust the indexing in convertToDecimal calls
+            const lat = match[1];
+            const lon = match[2];
+            const decimalLat = convertToDecimal(lat);
+            const decimalLon = convertToDecimal(lon);
+            coordArray.push([decimalLat, decimalLon]);
+        }
+        if (matchFound) break; // Stop iterating through patterns if a match is found
+    }
+
+    return coordArray;
+};
+
+// Helper function to convert coordinate string to decimal
+const convertToDecimal = (coord) => {
+    // Determine if the direction is at the beginning or the end
+    const direction = coord.charAt(0).match(/[NSWE]/) ? coord.charAt(0) : coord.charAt(coord.length - 1);
+    let degrees;
+    let minutes;
+    let seconds = 0; // Default to 0 for formats without seconds
+
+    if (direction === coord.charAt(0)) { // Direction at the beginning
+        coord = coord.substr(1); // Remove direction from coord for processing
+    } else { // Direction at the end
+        coord = coord.substr(0, coord.length - 1); // Remove direction from coord for processing
+    }
+
+    // Now, coord contains only the numeric part
+    if (coord.length === 4) { // Format DDMM
+        degrees = parseInt(coord.substr(0, 2), 10);
+        minutes = parseInt(coord.substr(2, 2), 10);
+    } else if (coord.length === 5) { // Format DDDMM
+        degrees = parseInt(coord.substr(0, 3), 10);
+        minutes = parseInt(coord.substr(3, 2), 10);
+    } else if (coord.length === 6) { // Format DDMMSS
+        degrees = parseInt(coord.substr(0, 2), 10);
+        minutes = parseInt(coord.substr(2, 2), 10);
+        seconds = parseInt(coord.substr(4, 2), 10);
+    } else if (coord.length === 7) { // Format DDDMMSS
+        degrees = parseInt(coord.substr(0, 3), 10);
+        minutes = parseInt(coord.substr(3, 2), 10);
+        seconds = parseInt(coord.substr(5, 2), 10);
+    } else {
+        return 0; // Invalid format
+    }
+
+    // Convert to decimal format
+    let decimal = degrees + (minutes / 60) + (seconds / 3600);
+    decimal = (direction === "S" || direction === "W") ? -decimal : decimal;
+    return decimal;
+};
+
+/** Gets the bearing of an orbiting object relative to it's launch pad.
+ * @param {String} line1 The first line of the TLE
+ * @param {String} line2 The second line of the TLE
+ * @param {Date} otop The OTOP time (object time over pad) in UTC
+ * @param {Object} opop The OPOP object with the following properties:
+ * - latitude: The geocentric latitude of the object in degrees
+ * - longitude: The geocentric longitude of the object in degrees
+ * @return {Number} The bearing of the object in degrees
+ */
+const getBearingFromTle = (line1, line2, otop, opop) => {
+    const satrec = twoline2satrec(line1, line2);
+    const propTime = new Date(otop.getTime() + 10000);
+    const propPos = eciToGeodetic(
+        propagate(satrec, propTime).position,
+        gstime(propTime),
+    );
+
+    const ascending = degreesToRadians(opop.latitude) < propPos.latitude;
+
+    return getBearing(
+        radiansToDegrees(satrec.inclo),
+        opop.latitude,
+        ascending,
+    );
+};
+
+/**
+ * Calculates the bearing angle given inclination, latitude, and whether the orbit is ascending.
+ * @param {number} i - Inclination angle in degrees.
+ * @param {number} lat - Latitude angle in degrees.
+ * @param {boolean} ascending - Whether the orbit is ascending. Defaults to true.
+ * @return {number} The azimuth angle in degrees, wrapped to [0, 360).
+ */
+const getBearing = (i, lat, ascending = true) => {
+    i = degreesToRadians(i);
+    lat = degreesToRadians(lat);
+    const azimuthRadians = Math.asin(Math.cos(i) / Math.cos(lat));
+    let azimuthDegrees = radiansToDegrees(azimuthRadians);
+
+    if (!ascending) {
+        azimuthDegrees = 180 - azimuthDegrees;
+    }
+
+    return wrapToRange(azimuthDegrees, 0, 360);
+};
+
+/** Gets the OPOP (Object Position Over Pad) and OTOP (Object Time Over Pad) of an orbiting object relative to it's launch pad.
+ * @param {String} line1 The first line of the TLE
+ * @param {String} line2 The second line of the TLE
+ * @param {Number} padLat The latitude of the launch pad in degrees
+ * @param {Number} padLon The longitude of the launch pad in degrees
+ * @param {Number} padAlt The altitude of the launch pad in km
+ * @param {Date} launchTime The launch time of the object
+ * @param {Number} flyoutTimeThresholdMin The flyout time threshold in minutes, defaults to 20 min
+ * @param {Number} opopDistThresholdKm The OPOP distance threshold in km, defaults to 250 km
+ * @param {Number} maxIterations The maximum number of iterations, defaults to 100
+ * @return {Object} The OPOP object with the following properties:
+ * - opopLat: The geocentric latitude of the object in degrees
+ * - opopLon: The geocentric longitude of the object in degrees
+ * - otop: The time of the object over the pad in UTC
+ */
+const getOpopOtop = (
+    line1,
+    line2,
+    padLat,
+    padLon,
+    padAlt,
+    launchTime,
+    flyoutTimeThresholdMin = 20,
+    opopDistThresholdKm = 250,
+    maxIterations = 100,
+) => {
+    const satrec = twoline2satrec(line1, line2);
+
+    // iterate time to find the time with closest range
+    let time = launchTime;
+    let stepSize = 60000; // 1 minute
+    let lastRange;
+    const timeTreshold = 500; // half second
+    for (let i = 0; i < maxIterations; i++) {
+        const sv = propagate(satrec, time);
+        const gmst = gstime(time);
+        const satEcf = eciToEcf(sv.position, gmst);
+        const padGd = {
+            longitude: degreesToRadians(padLon),
+            latitude: degreesToRadians(padLat),
+            height: padAlt,
+        };
+        const range = ecfToLookAngles(padGd, satEcf).rangeSat;
+        if (lastRange && lastRange < range) {
+            // we went too far, half the step size and invert the sign
+            stepSize = (-1 * stepSize) / 2;
+        }
+        time = new Date(time.getTime() + stepSize);
+        lastRange = range;
+
+        if (Math.abs(stepSize) < timeTreshold) {
+            break;
+        }
+    }
+
+    if (Math.abs(stepSize) >= timeTreshold) {
+        throw new Error(`Failed to converge on OPOP after ${maxIterations} iterations`);
+    }
+    if (Math.abs(time.getTime() - launchTime.getTime()) > flyoutTimeThresholdMin * 60000) {
+        throw new Error(`OTOP is more than ${flyoutTimeThresholdMin} minute(s) from launch`);
+    }
+
+    const sv = propagate(satrec, time);
+    const opop = eciToGeodetic(sv.position, gstime(time));
+    const opopLat = degreesLat(opop.latitude);
+    const opopLon = degreesLong(opop.longitude);
+
+    if (distGeodetic(opopLat, opopLon, padLat, padLon) > opopDistThresholdKm * 1000) {
+        throw new Error(`OPOP is more than ${opopDistThresholdKm}km from launch pad`);
+    }
+
+    return {
+        opopLat: opopLat,
+        opopLon: opopLon,
+        otop: time,
+    };
+};
+
+module.exports.notamToCoordArray = notamToCoordArray;
+module.exports.getBearingFromTle = getBearingFromTle;
+module.exports.getBearing = getBearing;
+module.exports.getOpopOtop = getOpopOtop;

package/src/loggerFactory.js

@@ -0,0 +1,98 @@
+const winston = require("winston");
+const {
+    createLogger,
+    format,
+    transports,
+} = winston;
+const cj = (data) => Object.keys(data).length > 0
+    ? JSON.stringify(data, null, 2)
+    : null;
+
+const isTest = process.env.NODE_ENV === "test";
+
+const defaultLogger = new transports.Console({
+    silent: isTest,
+    level: "warn",
+    format: format.errors({stack: true}),
+    timestamp: true,
+});
+
+const errorLogger = new transports.Console({
+    silent: isTest,
+    format: format.errors({stack: true}),
+});
+
+/**
+ * Creates a logger
+ *
+ * @param {String} nameSpace Namespace for the logger
+ * @param {Object} additionalData additional data to include with logging
+ * @param {string} level Default logging level to set (overwrites environment setting)
+ * @return {winston.Logger}
+ */
+module.exports.loggerFactory = ({
+    nameSpace = "saber",
+    additionalData = {},
+    level,
+} = {}) => {
+    const logLevel = process.env.LOG_LEVEL || "warn";
+    const isConsole = !!(process.env.CONSOLE_LOG);
+
+    const loggerTransport = isConsole
+        ? new transports.Console({
+            defaultMeta: additionalData,
+            level: level || logLevel,
+            format: format.combine(
+                format.errors({stack: true}),
+                format.cli(),
+                // eslint-disable-next-line max-len
+                format.printf(({
+                    level,
+                    message,
+                    nameSpace,
+                    stack,
+                    ...rest
+                }) =>
+                    [
+                        level,
+                        `[${nameSpace}]`,
+                        ":",
+                        message,
+                        stack,
+                        cj(rest),
+                    ].filter((value) => !!value)
+                        .join(" "),
+                ),
+            ),
+        })
+        : defaultLogger;
+
+    const config = {
+        levels: {
+            // RFC5424
+            emerg: 0,
+            alert: 1,
+            crit: 2,
+            error: 3,
+            warning: 4,
+            notice: 5,
+            info: 6,
+            debug: 7,
+            // npm levels
+            warn: 4,
+            verbose: 6,
+            silly: 8,
+        },
+        exitOnError: false,
+        transports: [loggerTransport],
+        // Console logger from above will log errors
+        exceptionHandlers: !isConsole ? [errorLogger] : [],
+        rejectionHandlers: !isConsole ? [errorLogger] : [],
+    };
+
+    return createLogger(config)
+        .child({
+            ...additionalData,
+            nameSpace: nameSpace,
+        });
+};

package/src/s3.js

@@ -0,0 +1,59 @@
+const {S3Client, PutObjectCommand, HeadObjectCommand} = require("@aws-sdk/client-s3");
+const {readFileSync} = require("fs");
+const {basename} = require("path");
+const dotenv = require("dotenv");
+dotenv.config();
+
+const s3Client = new S3Client({
+    region: "us-west-1", // Replace with your AWS region
+    credentials: {
+        accessKeyId: process.env.S3_ACCESS_KEY,
+        secretAccessKey: process.env.S3_SECRET,
+    },
+});
+
+
+/**
+ * Takes either a filename, or a buffer. If array buffer is supplied, then filename is just used to name the file.
+ * If no array buffer is supplied, it will attempt to read the file at the fileName path.
+ * Example Usage:
+ * await s3Upload("imageName.png", "image/png", imageBuffer);
+ * await s3Upload("/path/to/local/image.png");
+ * @param {string} fileName
+ * @param {string} type
+ * @param {Array|Buffer|null} buffer
+ * @return {Promise<Object>}
+ */
+module.exports.s3Upload = async (fileName, type = "image/png", buffer = null) => {
+    try {
+        const fileContent = buffer ? buffer : readFileSync(fileName);
+        return await s3Client.send(new PutObjectCommand({
+            Bucket: "saber-probe-images", // S3 Bucket name
+            Key: buffer ? fileName : basename(fileName), // File name to save as in S3
+            Body: fileContent, // File content (either buffer or file read)
+            ContentType: type, // File content type
+        }));
+    } catch (err) {
+        console.error("Error uploading file or buffer to S3: ", err);
+        throw err; // Re-throw the error so it can be caught by the calling function if needed
+    }
+};
+
+module.exports.doesS3ObjectExist = async (fileName) => {
+    try {
+        // Try to fetch the metadata of the object to check if it exists
+        await s3Client.send(new HeadObjectCommand({
+            Bucket: "saber-probe-images",
+            Key: fileName, // The key (file name) to check in the S3 bucket
+        }));
+        return true;
+    } catch (err) {
+        // If a 404 error is thrown, the object does not exist
+        if (err.name === "NotFound") {
+            return false;
+        }
+        // Other errors (such as permission errors) should be thrown
+        console.error("Error checking if file exists in S3: ", err);
+        throw err;
+    }
+};

package/src/transform.js

@@ -0,0 +1,40 @@
+const _ = require("lodash");
+
+const transformObjectKeys = (transform, object, deep = true) => _.cond([
+    [
+        (transformItem) => _.isPlainObject(transformItem),
+        (transformItem) => _.fromPairs(
+            _.map(
+                _.toPairs(transformItem),
+                ([key, value]) => [
+                    transform(key),
+                    deep && _.isPlainObject(value)
+                        ? transformObjectKeys(transform, value)
+                        : value,
+                ],
+            ),
+        ),
+    ],
+    [_.stubTrue, _.identity],
+])(object);
+
+const pascalCase = (string) => _.upperFirst(_.camelCase(string));
+
+const lowerCaseObjectKeys = (transformItem, deep) => transformObjectKeys(
+    _.toLower,
+    transformItem,
+    deep,
+);
+
+const pascalCaseObjectKeys = (transformItem, deep) => transformObjectKeys(
+    pascalCase,
+    transformItem,
+    deep,
+);
+
+module.exports = {
+    transformObjectKeys,
+    lowerCaseObjectKeys,
+    pascalCaseObjectKeys,
+    pascalCase,
+};

package/src/udl.js

@@ -0,0 +1,115 @@
+const {fixDate} = require("./fixDate.js");
+const {calcRegime, getElsetUdlFromTle, getLonAndDrift, getRaanPrecession} = require("./astro.js");
+const {lowerCaseObjectKeys} = require("./transform.js");
+const {isDefined} = require("./utils.js");
+const _ = require("lodash");
+
+const udlToNpsElset = (udlRow) => {
+    let derivedElset;
+    try {
+        derivedElset = getElsetUdlFromTle(udlRow.line1, udlRow.line2, udlRow.dataMode);
+    } catch {
+        // invalid TLE
+        derivedElset = null;
+    }
+    const enrichedUdlFields = [];
+    const enrichField = (field) => {
+        if (derivedElset && (derivedElset[field] || derivedElset[field] === 0)) {
+            enrichedUdlFields.push(field);
+            return derivedElset[field];
+        }
+        return null;
+    };
+    const lonAndDrift = getLonAndDrift(udlRow.line1, udlRow.line2);
+
+    const getElsetValue = (value, defaultValueFunc) => {
+        return (isDefined(value)) ? value : defaultValueFunc();
+    };
+
+    const npsElset = lowerCaseObjectKeys({
+        Satno: getElsetValue(udlRow.satNo, ()=>enrichField("satNo")),
+        Epoch: fixDate(getElsetValue(udlRow.epoch, ()=>enrichField("epoch"))),
+        MeanMotion: getElsetValue(udlRow.meanMotion, ()=>enrichField("meanMotion")),
+        Eccentricity: getElsetValue(udlRow.eccentricity, ()=>enrichField("eccentricity")),
+        Inclination: getElsetValue(udlRow.inclination, ()=>enrichField("inclination")),
+        Raan: getElsetValue(udlRow.raan, ()=>enrichField("raan")),
+        ArgOfPerigee: getElsetValue(udlRow.argOfPerigee, ()=>enrichField("argOfPerigee")),
+        MeanAnomaly: getElsetValue(udlRow.meanAnomaly, ()=>enrichField("meanAnomaly")),
+        BStar: getElsetValue(udlRow.bStar, ()=>enrichField("bStar")),
+        SemiMajorAxis: getElsetValue(udlRow.semiMajorAxis, ()=>enrichField("semiMajorAxis")),
+        Period: getElsetValue(udlRow.period, ()=>enrichField("period")),
+        Apogee: getElsetValue(udlRow.apogee, ()=>enrichField("apogee")),
+        Perigee: getElsetValue(udlRow.perigee, ()=>enrichField("perigee")),
+        Line1: getElsetValue(udlRow.line1, ()=>null),
+        Line2: getElsetValue(udlRow.line2, ()=>null),
+        Source: getElsetValue(udlRow.source, ()=>null),
+        DataMode: getElsetValue(udlRow.dataMode, ()=>null),
+        CreatedAt: fixDate(getElsetValue(udlRow.createdAt, ()=>null)),
+        Origin: getElsetValue(udlRow.origin, ()=>null),
+        Algorithm: getElsetValue(udlRow.algorithm, ()=>null),
+        Latitude: lonAndDrift.latitude,
+        Longitude: lonAndDrift.longitude,
+        LonDriftDegreesPerDay: lonAndDrift.lonDriftDegreesPerDay,
+        RaanPrecessionDegreesPerDay: getRaanPrecession(udlRow.line1, udlRow.line2),
+        // Ensure we reset all the derived calcs so we know if they have been updated by Sentinel or not.
+        MinEccentricity: 0,
+        MaxEccentricity: 0,
+        MinInclination: 0,
+        MaxInclination: 0,
+        MinRaan: 0,
+        MaxRaan: 0,
+        MinArgOfPerigee: 0,
+        MaxArgOfPerigee: 0,
+        MinSemiMajorAxis: 0,
+        MaxSemiMajorAxis: 0,
+    });
+    npsElset.regime = calcRegime(npsElset);
+    npsElset.enrichedudlfields = enrichedUdlFields.join(",");
+    return npsElset;
+};
+
+const udlToNpsGroundSite = (udlRow) => ({
+    SensorId: _.get(udlRow, "idSensor", null),
+    Number: _.get(udlRow, "sensorNumber", null),
+    Name: _.get(udlRow, "sensorName", null),
+    Source: _.get(udlRow, "source", null),
+    Description: null,
+    LastObsTime: _.get(udlRow, "sensorStats[0].lastObTime", null),
+    CountryCode: _.get(udlRow, "entity.countryCode", "None"),
+    Taskable: _.get(udlRow, "entity.taskable", 0),
+    Type: _.get(udlRow, "sensorType.id", 0),
+    Latitude: _.get(udlRow, "entity.location.lat", 0),
+    Longitude: _.get(udlRow, "entity.location.lon", 0),
+    KmAboveSeaLevel: _.get(udlRow, "entity.location.altitude", 0),
+    MinRangeKm: _.get(udlRow, "sensorcharacteristics[0].minRangeLimit", null),
+    MaxRangeKm: _.get(udlRow, "sensorcharacteristics[0].maxRangeLimit", null),
+    ClassificationLevel: _.get(
+        udlRow,
+        "sensorcharacteristics[0].classificationMarking",
+        "",
+    ),
+    createdAt: fixDate(_.get(udlRow, "createdAt")),
+});
+
+/**
+ * Formats the response data based on the topic
+ *
+ * @param {String} topic
+ * @param {Object[]} udlData
+ * @return {Object[]}
+ */
+module.exports.formatUdlData = (topic, udlData) => {
+    switch (topic) {
+        case "Elsets":
+            return _.map(udlData, udlToNpsElset);
+
+        case "GroundSites":
+            return _.map(udlData, udlToNpsGroundSite);
+
+        default:
+            return udlData;
+    }
+};
+
+module.exports.udlToNpsElset = udlToNpsElset;
+module.exports.udlToNpsGroundSite = udlToNpsGroundSite;