@atmosx/event-product-parser 3.0.3 → 3.0.6

package/src/@building/{building.validate.ts → ValidateEvents.ts}

@@ -17,20 +17,23 @@
 
 */
 
-import { createHash } from "crypto"
-import { TypeEvent } from "../@types/type.event";
-import { TypeSettings } from "../@types/types.settings";
+import { TypeEvent } from "../@types/Event";
+import { TypeSettings } from "../@types/Settings";
 import { bootstrap } from "../bootstrap"
-import { getEventEnhancedName } from "./building.enhance";
-import { getEventSignature } from "./building.signature"
-import { mkEvent } from "../@manager/manager.mkEvent";
-import { rmEvent } from "../@manager/manager.rmEvent";
-import { getEventGeometry } from "./building.geometry";
-import { updateNode } from "../@manager/manager.updateNodes";
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
+import { GetEventEnhancedName } from "./GetEventEnhancedName";
+import { GetEventSignature } from "./GetEventSignature"
+import { MakeEvent } from "../@manager/MakeEvent";
+import { RemoveEvent } from "../@manager/RemoveEvent";
+import { GetEventAttachments } from "./GetEventAttachments";
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
+import { SetDebug } from "../@modules/@utilities/SetDebug";
+import { GetMatched } from "../@modules/@utilities/GetMatched";
+import { GetEventGeometry } from "./GetEventGeometry";
+import { createHash } from "crypto"
 
-export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
-    if (events.length === 0) return;
+export const ValidateEvents = async (events: TypeEvent[]): Promise<void> => {
+    const tick = performance.now();
+    if (events.length === 0) return
     const configurations = bootstrap.settings as TypeSettings
     const sets = {} as Record<string, Set<string>>;
     const bools = {} as Record<string, boolean>;
@@ -40,108 +43,112 @@ export const validateEvents = async (events: TypeEvent[]): Promise<void> => {
         if (Array.isArray(setting)) { sets[key] = new Set(setting.map(item => item.toLowerCase())); }
         if (typeof setting === 'boolean') { bools[key] = setting; }
     }
-    const filterd = events.filter((event: TypeEvent) => {
-        const define = getEventSignature(event) as TypeEvent;
+
+    const isFiltered = (define: TypeEvent): boolean => {
         const properties = define.properties;
         const zones = properties.geocode.ugc;
         const icao = properties.geocode.office.office
-        const enhancedEventName = properties.event = getEventEnhancedName(event)
-        const filteredProperties = JSON.parse(JSON.stringify(properties)) as typeof properties;
-        if (filteredProperties?.metadata && 'ms' in filteredProperties.metadata) {
-            delete filteredProperties.metadata.ms;
-        }
-        filteredProperties.metadata = filteredProperties.metadata ?? {} as any;
-        filteredProperties.metadata.hash = createHash("sha256").update(JSON.stringify(filteredProperties)).digest("hex")
-        
-        setEventEmit({ event: `onProductType${enhancedEventName.replace(/\s+/g, '')}`, metadata: define });
-        
+
         if (properties.status_metadata.is_test) { 
-            setEventEmit({ event: `onTestProduct`, metadata: define })
-            if (bools?.IgnoreTestProducts) return false; 
+            SetEventEmit({ event: `onTestProduct`, metadata: define })
+            if (bools?.IgnoreTestProducts) return true; 
         }
         
         if (properties.status_metadata.is_expired) { 
-            setEventEmit({ event: `onExpiredProduct`, metadata: define })
-            rmEvent(define)
-            return false; 
+            SetEventEmit({ event: `onExpiredProduct`, metadata: define })
+            RemoveEvent(define, false)
+            return true; 
         }
         
-        if (properties.metadata?.vtec?.is_watch) {
+        if (properties.metadata?.vtec?.is_watch && properties.metadata.source != `events.api`) {
             const isSPC = properties.metadata?.vtec?.prediction_center;
-            setEventEmit({ event: isSPC ? `onStormPredictionWatch` : `onNonStormPredictionWatch`, metadata: define })
+            SetEventEmit({ event: isSPC ? `onStormPredictionWatch` : `onNonStormPredictionWatch`, metadata: define })
             if (bools?.SPCWatchesOnly && !isSPC) {
-                return false;
+                return true;
             }
             if ((!bools?.SPCWatchesOnly) && isSPC) {
-                return false 
+                return true 
              }
         }
-        
 
         for (const key in sets) {
             const setting = sets[key]
-            if (key === 'ListeningEvents' && setting.size > 0 && !setting.has(define.properties.event.toLowerCase())) { 
-                setEventEmit({
+            const values = [...setting];
+            if (key === 'ListeningEvents' && setting.size > 0 && !GetMatched(values, define.properties.event)) {
+                SetEventEmit({
                     event: `onFilteredEvent`,
                     metadata: define
                 }); 
-                return false 
+                return true 
             } 
-            if (key === 'IgnoredEvents' && setting.size > 0 && setting.has(define.properties.event.toLowerCase())) { 
-                setEventEmit({
+            if (key === 'IgnoredEvents' && setting.size > 0 && GetMatched(values, define.properties.event)) {
+                SetEventEmit({
                     event: `onIgnoredEvent`,
                     metadata: define
                 }); 
-                return false 
+                return true 
             } 
             if (key === 'ListeningICAO' && setting.size > 0 && icao != null && !setting.has(icao.toLowerCase())) { 
-                setEventEmit({
+                SetEventEmit({
                     event: `onFilteredICAO`,
                     metadata: define
                 }); 
-                return false 
+                return true 
             }
             if (key === 'IgnoredICAO' && setting.size > 0 && icao != null && setting.has(icao.toLowerCase())) { 
-                setEventEmit({
+                SetEventEmit({
                     event: `onIgnoredICAO`,
                     metadata: define
                 }); 
-                return false 
+                return true 
             }
             if (key === 'ListeningUGC' && setting.size > 0 && zones.length > 0 && !zones.some((ugc: string) => setting.has(ugc.toLowerCase()))) { 
-                setEventEmit({
+                SetEventEmit({
                     event: `onFilteredUGC`,
                     metadata: define
                 }); 
-                return false 
+                return true 
             }
             if (key === 'ListeningStates' && setting.size > 0 && zones.length > 0 && !zones.some((ugc: string) => setting.has(ugc.substring(0, 2).toLowerCase()))) { 
-                setEventEmit({
+                SetEventEmit({
                     event: `onFilteredState`,
                     metadata: define
                 }); 
-                return false 
+                return true 
             }
         }
-        return true;
-    })
+        return false
+    }
 
-    
-    if (!configurations?.GlobalSettings?.DisableGeometryParsing) {
-        for (const event of filterd) {
-            event.geometry = await getEventGeometry(event)
+    const filtering = events.filter((event: TypeEvent) => {
+        bootstrap.cache.processed = bootstrap.cache.processed.filter((e) => e !== event);
+        const define = GetEventSignature(event) as TypeEvent;
+        const pre = {...define,properties: {...define.properties,  metadata: {...define.properties.metadata }}};
+        const properties = define.properties; delete pre.properties.metadata.ms; delete pre.properties.metadata.header;
+        const enhanced = properties.event = GetEventEnhancedName(event)
+        const filtered = isFiltered(define)
+        if (!filtered) {
+            event.geometry = !bools?.DisableGeometryParsing ? GetEventGeometry(event) : null;
+            properties.metadata.attachments = GetEventAttachments(event)
         }
-    }
+        properties.metadata.hash = createHash("sha256").update(JSON.stringify(pre)).digest("hex")  
+        SetEventEmit({ event: `onProductType${enhanced.replace(/\s+/g, '')}`, metadata: define });
+        return !filtered
+    })
+    
+    SetDebug({ title: `ValidateEvents (PRE) (${filtering.length}/${events.length})`, message: `${Math.round(performance.now() - tick)}ms` })
 
-    if (filterd.length > 0) {
-        for (const event of filterd) {
-            await mkEvent(event)
+    if (filtering.length > 0) {
+        for (const event of filtering) {
+            await MakeEvent(event)
         }
     }
-    await updateNode()
-    setEventEmit({
+    
+    SetEventEmit({
         event: `onEventCache`,
         metadata: bootstrap.cache.events,
         limited: true
     })
+
+    SetDebug({ title: `ValidateEvents (${filtering.length}/${events.length})`, message: `${Math.round(performance.now() - tick)}ms` })
 }

package/src/@core/{core.clearEvents.ts → ClearEvents.ts}

@@ -18,13 +18,12 @@
 */
 
 import { bootstrap } from "../bootstrap";
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
 
-
-export const clearEvents = (): void => {
+export const ClearEvents = (): void => {
     bootstrap.cache.events.features = [];
     bootstrap.cache.hashes = [];
-    setEventEmit({
+    SetEventEmit({
         event: `onEventCache`,
         metadata: bootstrap.cache.events,
         message: `Manually cleared event cache.`

package/src/@core/{core.createListener.ts → CreateListener.ts}

@@ -17,8 +17,8 @@
 
 */
 
-import { setListener } from "../@modules/@utilities/utilities.setListener";
+import { SetListener } from "../@modules/@utilities/SetListener";
 
-export const createListener = (event: string, callback: () => void) => {
-    setListener({event, callback})
+export const CreateListener = (event: string, callback: () => void) => {
+    SetListener({event, callback})
 }

package/src/@core/{core.getEvents.ts → GetEvents.ts}

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
-export const getEvents = (): any => {
+export const GetEvents = (): any => {
     return bootstrap.cache.events
 }

package/src/@core/{core.getNodes.ts → GetNodes.ts}

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
-export const getNodes = (): any => {
+export const GetNodes = (): any => {
     return bootstrap.cache.nodes
 }

package/src/@core/{core.getRandomEvent.ts → GetRandomEvent.ts}

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
-export const getRandomEvent = (): any => {
+export const GetRandomEvent = (): any => {
     return bootstrap.cache.events.features[Math.floor(Math.random() * bootstrap.cache.events.features.length)]
 }

package/src/@core/{core.getVersion.ts → GetVersion.ts}

@@ -19,7 +19,6 @@
 
 import { bootstrap } from "../bootstrap";
 
-
-export const getVersion = (): any => {
+export const GetVersion = (): any => {
     return bootstrap.version
 }

package/src/@core/ManualEvent.ts

@@ -0,0 +1,56 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeAttributes } from "../@types/Attributes";
+import { EnumExpressions } from "../@enums/Expressions"
+import { GetAwipsType } from "../@modules/@stanza/GetAwipsType";
+import { CreateEvent } from "../@building/CreateEvent";
+
+interface CreateEventOptions {
+    message: string
+    awipsid?: string
+}
+
+export const ManualEvent = async (options: CreateEventOptions): Promise<void> => {
+    const isCapEvent = options.message.includes(`<?xml`);
+    const isCapAreaDescription = options.message.includes(`<areaDesc>`)
+    const isVTEC = options.message.match(EnumExpressions.pvtec) != null;
+    const isUGC = options.message.match(EnumExpressions.ugc1) != null;
+    const attributes = {
+        "xmlns": "@atmosx/event-product-parser",
+        "id": "manual_processor.0000",
+        "issue": new Date().toISOString(),
+        "ttaaii": "XXXXX",
+        "cccc": "XXX",
+        "awipsid": options.awipsid ?? "XXXXXX",
+    }
+    const getType = GetAwipsType({ attributes })
+    const result = { 
+        message: options.message, 
+        attributes,
+        isCapEvent, 
+        isVTEC, 
+        isUGC, 
+        isCapAreaDescription, 
+        isIgnored: false, 
+        isNWWS: true, 
+        getType 
+    }
+    await CreateEvent(result);
+}

package/src/@core/QueryStanza.ts

@@ -0,0 +1,39 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeStanza } from "../@types/Stanza";
+import { bootstrap } from "../bootstrap";
+
+interface QueryStanzaOptions {
+    search: string
+    max?: number
+}
+
+type QueryStanza = {
+    rowid: number
+    stanza: string
+}
+
+export const QueryStanza = async (options: QueryStanzaOptions): Promise<TypeStanza[]> => {
+    const get = await bootstrap.database.prepare(
+        `SELECT * FROM stanzas WHERE stanza LIKE ? LIMIT ?`)
+    .all(`%${options.search}%`, options.max ?? 100) as QueryStanza[];
+    const events = get.map((row) => JSON.parse(row.stanza));
+    return events as TypeStanza[];
+}

package/src/@core/{core.setNode.ts → SetNode.ts}

@@ -18,23 +18,23 @@
 */
 
 import { bootstrap } from "../bootstrap";
-import { setWarning } from "../@modules/@utilities/utilities.setWarning"
-import { setEventEmit } from "../@modules/@utilities/utilities.setEventEmit";
+import { SetWarning } from "../@modules/@utilities/SetWarning"
+import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
 
-interface GetAddChaserOptions {
+interface GetNodeOptions {
     identifier: string
     delete?: boolean
     coordinates: { longitude: number; latitude: number }
 }
 
-export const setNode = (options: GetAddChaserOptions) => {
+export const SetNode = (options: GetNodeOptions) => {
     const nodes = bootstrap.cache.nodes.features;
     const exists = nodes.find((node) => node.properties.identifier === options.identifier);
     if (options.delete) {
         if (exists) {
             const index = nodes.indexOf(exists);
             nodes.splice(index, 1);
-            return setEventEmit({
+            return SetEventEmit({
                 event: `onNodeDelete`,
                 metadata: {
                     type: `node-delete`,
@@ -42,7 +42,7 @@ export const setNode = (options: GetAddChaserOptions) => {
                 }
             })
         }
-        return setWarning({ message: `Node with identifier '${options.identifier}' not found.` })
+        return SetWarning({ message: `Node with identifier '${options.identifier}' not found.` })
     }
     if (exists) {
         const index = nodes.indexOf(exists);
@@ -53,7 +53,7 @@ export const setNode = (options: GetAddChaserOptions) => {
                 coordinates: [options.coordinates.longitude, options.coordinates.latitude]
             }
         };
-        return setEventEmit({
+        return SetEventEmit({
             event: `onNodeUpdate`,
             metadata: {
                 type: `node-update`,
@@ -71,7 +71,7 @@ export const setNode = (options: GetAddChaserOptions) => {
             identifier: options.identifier
         }
     });
-    return setEventEmit({
+    return SetEventEmit({
         event: `onNodeAdd`,
         metadata: {
             type: `node-add`,

package/src/@core/{core.start.ts → StartService.ts}

@@ -17,45 +17,45 @@
 
 */
 
-import { TypeSettings } from "../@types/types.settings";
+import { TypeSettings } from "../@types/Settings";
 import { bootstrap } from "../bootstrap";
-import { setWarning } from "../@modules/@utilities/utilities.setWarning"
-import { setSettings } from "../@modules/@utilities/utilities.setSettings"
-import { xDeploy } from "../@modules/@xmpp/xmpp.xDeploy"
-import { initializeDatabase } from "../@modules/@database/database.init";
-import { getCachedEvents } from "../@modules/@database/database.cache";
-import { setCronSchedule } from "../@modules/@utilities/utilities.setCronSchedule";
-import { updateNode } from "../@manager/manager.updateNodes";
-import { updateEvents } from "../@manager/manager.updateEvents";
+import { SetWarning } from "../@modules/@utilities/SetWarning"
+import { SetSettings } from "../@modules/@utilities/SetSettings"
+import { DeployXMPP } from "../@modules/@xmpp/DeployXMPP"
+import { InitializeDatabase } from "../@modules/@database/InitializeDatabase";
+import { GetCachedEvents } from "../@modules/@database/GetCachedEvents";
+import { SetCronSchedule } from "../@modules/@utilities/SetCronSchedule";
+import { UpdateNode } from "../@manager/UpdateNode";
+import { UpdateEvents } from "../@manager/UpdateEvents";
 import { Cron } from "croner";
 
-export const startService = async (settings: TypeSettings): Promise<void> => {
+export const StartService = async (configurations: TypeSettings): Promise<void> => {
     if (!bootstrap.isReady) { 
-        return setWarning({ 
+        return SetWarning({ 
             message: `You can not create another instance without shutting down the current one first, please make sure to call the stop() method first!` 
         })
     }
-    setSettings(settings);
+    const settings = SetSettings(configurations);
     bootstrap.isReady = true;
-    await initializeDatabase();
+    await InitializeDatabase();
     if (settings.EnableWireService) {
         (async () => {
-            await getCachedEvents();
-            await xDeploy()
+            await GetCachedEvents();
+            await DeployXMPP()
         })();
     }
-    await setCronSchedule()
+    await SetCronSchedule()
     let scheduleInterval = !settings.EnableWireService ? settings.NationalWeatherServiceSettings.CallbackInterval : 1;
     if (!settings.EnableWireService && scheduleInterval < 15) {
-        setWarning({ message: `Schedule Interval of ${scheduleInterval} seconds is too low, setting to 15 seconds` })
+        SetWarning({ message: `Schedule interval of ${scheduleInterval} seconds is too low, setting to 15 seconds` })
         bootstrap.settings.NationalWeatherServiceSettings.CallbackInterval = 15;
         scheduleInterval = 15;
     }
     bootstrap.cron = new Cron(`*/${scheduleInterval} * * * * *`, async () => {
-        await setCronSchedule();
+        await SetCronSchedule();
     })
-    bootstrap.cron = new Cron(`* * * * * *`, async () => {
-        await updateNode();
-        await updateEvents();
+    bootstrap.cron = new Cron(`* * * * * *`, async () => { 
+        await UpdateNode();
+        await UpdateEvents();
     })
 }

package/src/@core/{core.stop.ts → StopService.ts}

@@ -19,7 +19,7 @@
 
 import { bootstrap } from "../bootstrap";
 
-export const stopService = async (): Promise<void> => {
+export const StopService = async (): Promise<void> => {
     if (bootstrap.isReady) {
         bootstrap.isReady = false;
         if (bootstrap.session_xmpp) {