@atmosx/event-product-parser 3.0.1 → 3.0.3

package/src/@events/events.ugc.ts

@@ -20,7 +20,7 @@
 import { TypeAttributes } from "../@types/types.attributes";
 import { TypeStanzaCompiled } from "../@types/types.compiled"
 import { TypeEvent } from "../@types/type.event";
-import { eventsOffshore } from "../@dictionaries/dictionaries.eventsOffshore";
+import { eventsMatchText } from "../@dictionaries/dictionaries.eventsMatchText";
 import { ugcExtract } from "../@parsers/@ugc/ugc.extract";
 import { properties } from "../@building/building.properties";
 import { getEventHeader } from "../@building/building.headers";
@@ -41,11 +41,13 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
         if (ugc != null ) {
             const props = properties({ message, attributes, ugc: ugc })
             const issued = new Date(attributes.issue)
-            const expires = new Date(issued.getTime() + 12 * 60 * 60 * 1000)
+            const expires = new Date(ugc.expires)
             const header = getEventHeader({properties: props, getType: stanza.getType })
-            let event = Object.keys(eventsOffshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
+            let event = Object.keys(eventsMatchText).find(event => message.toLowerCase().includes(event.toLowerCase()));
+            let isStatement = false;
             if (!event) { 
                 event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+                isStatement = true;
             }
             processed.push({
                 type: `Feature`,
@@ -56,9 +58,9 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 properties: { 
                     event: event,
                     parent: event,
-                    status: `Issued`,
+                    status: isStatement ? `Statement` : `Issued`,
                     issued: (!isNaN(issued.getTime())) ? issued.toISOString() : new Date().toISOString(),
-                    expires: (!isNaN(expires.getTime())) ? expires.toISOString() : new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+                    expires: isStatement ? new Date(issued.getTime() + 120 * 1000).toISOString() : (!isNaN(expires.getTime())) ? expires.toISOString() : new Date(Date.now() + 60 * 60 * 1000).toISOString(),
                     ...props,
                     metadata: {
                         ms: performance.now() - tick,

package/src/@manager/manager.rmEvent.ts

@@ -24,6 +24,9 @@ import { updateWebhooks } from "./manager.updateWebhooks";
 
 export const rmEvent = (event: TypeEvent): void => {
     const getEvent = bootstrap.cache.events.features.find(f => f?.properties?.metadata?.tracking === event?.properties?.metadata?.tracking);
+    const cachedStatus = event.properties.status;
+    event.properties.expires = new Date().toISOString();
+    event.properties.status = `Expired`;
     if (getEvent) {
         setEventEmit({
             event: `onEventStatus`,
@@ -34,7 +37,7 @@ export const rmEvent = (event: TypeEvent): void => {
             message: `[Removed] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
         })
         setEventEmit({ event: `onExpiredProduct`, metadata: event })
-        updateWebhooks(event)
+        if (cachedStatus != `Statement`) updateWebhooks(event)
         bootstrap.cache.events.features.splice(bootstrap.cache.events.features.indexOf(getEvent), 1);
         bootstrap.cache.hashes = bootstrap.cache.hashes.filter(hash => hash.tracking !== event.properties.metadata.tracking);
     }

package/src/@manager/manager.updateEvents.ts

@@ -0,0 +1,35 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { getFormattedTime } from "../@modules/@utilities/utilities.getFormattedTime";
+import { TypeEvent } from "../@types/type.event";
+import { bootstrap } from "../bootstrap"
+import { rmEvent } from "./manager.rmEvent";
+
+
+export const updateEvents = async (selectedEvent?: TypeEvent): Promise<void> => {
+    const events = bootstrap.cache.events.features;
+    async function update(evt: TypeEvent) {
+        if (new Date(evt.properties.expires) < new Date()) {
+            rmEvent(evt);
+        }
+    }
+    if (!selectedEvent) { await Promise.all(events.map(async (evt) => { await update(evt) })) } 
+    if (selectedEvent) { await update(selectedEvent) }
+}

package/src/@modules/@utilities/utilities.createWebhook.ts

@@ -32,10 +32,11 @@ interface CreateWebhookOptions {
 export const createWebhook = async (options: CreateWebhookOptions): Promise<void> => {
     const event = options.event.properties;
     const settings = options.webhook;
+    
     let body = [
         event.locations ? `**Locations**: ${event.locations.slice(0,100)}` : null,
         event.issued ? `**Issued**: <t:${Math.floor(new Date(event.issued).getTime()/1000)}:R>` : null,
-        event.expires ? `**Expires**: <t:${Math.floor(new Date(event.expires).getTime()/1000)}:R>` : null,
+        event.expires && event.status != `Statement` ? `**Expires**: <t:${Math.floor(new Date(event.expires).getTime()/1000)}:R>` : null,
         (() => {
             const val = event.parameters.estimated_wind_gusts ?? null
             const th = event.parameters.wind_threat ?? null
@@ -50,6 +51,20 @@ export const createWebhook = async (options: CreateWebhookOptions): Promise<void
         event.parameters.damage_threat ? `**Damage Threat**: ${event.parameters.damage_threat}` : null,
         event.parameters.flood_threat ? `**Flood Threat**: ${event.parameters.flood_threat}` : null,
         event.parameters.tornado_threat ? `**Tornado Threat**: ${event.parameters.tornado_threat}` : null,
+        event.spc_parameters.spc_max_tornado ? `**Max Tornado Threat**: ${event.spc_parameters.spc_max_tornado}` : null,
+        event.spc_parameters.spc_max_hail ? `**Max Hail Threat**: ${event.spc_parameters.spc_max_hail}` : null,
+        event.spc_parameters.spc_max_wind ? `**Max Wind Threat**: ${event.spc_parameters.spc_max_wind}` : null,
+        event.spc_parameters.spc_watch_issuance ? `**Watch Issuance**: ${event.spc_parameters.spc_watch_issuance}%` : null,
+        event.watch_parameters.watch_number ? `**Watch Number**: ${event.watch_parameters.watch_number}` : null,
+        event.watch_parameters.strong_tornadoes_probability ? `**Strong Tornadoes Probability**: ${event.watch_parameters.strong_tornadoes_probability}%` : null,
+        event.watch_parameters.additional_tornadoes_probability ? `**Additional Tornadoes Probability**: ${event.watch_parameters.additional_tornadoes_probability}%` : null,
+        event.watch_parameters.combined_hail_wind_probability ? `**Combined Hail/Wind Probability**: ${event.watch_parameters.combined_hail_wind_probability}%` : null,        
+        event.watch_parameters.severe_hail_probability ? `**Severe Hail Probability**: ${event.watch_parameters.severe_hail_probability}%` : null,
+        event.watch_parameters.hail_2in_probability ? `**Hail ≥2in Probability**: ${event.watch_parameters.hail_2in_probability}%` : null,
+        event.watch_parameters.max_hail_in ? `**Max Hail Inches**: ${event.watch_parameters.max_hail_in}` : null,
+        event.watch_parameters.severe_wind_probability ? `**Severe Wind Probability**: ${event.watch_parameters.severe_wind_probability}%` : null,
+        event.watch_parameters.max_wind_surface ? `**Max Surface Wind**: ${event.watch_parameters.max_wind_surface}` : null,
+        event.watch_parameters.max_tops_x100feet ? `**Max Tops (x100 feet)**: ${event.watch_parameters.max_tops_x100feet}` : null,
         (event.parameters.tags?.length > 0) ? `**Tags**: ${event.parameters.tags.join(', ')}` : null,
         (() => {
             const val = event.geocode?.office?.name ?? `N/A`
@@ -57,8 +72,6 @@ export const createWebhook = async (options: CreateWebhookOptions): Promise<void
             return (val || th) ? `**Sender**: ${val} ${th ? `(${th})` : ''}` : null;
         })(),
         event.metadata?.tracking ? `**Tracking**: ${event.metadata.tracking}` : null,
-        event.metadata?.vtec?.vtec ? `**VTEC**: ${event.metadata.vtec?.vtec}` : null,
-        event.metadata?.filtered_proximity != null ? `**Currently in polygon (Node)**: ${event.metadata.filtered_proximity ? 'Yes' : 'No'}` : null,
         (() => {
             const desc = (event.description || '').split('\n').map(l => l.trim()).filter(Boolean).join('\n');
             return desc ? '```' + '\n' + desc + '\n' + '```' : null;
@@ -86,10 +99,12 @@ export const createWebhook = async (options: CreateWebhookOptions): Promise<void
         content: settings.message ?? "",
         embeds: [embed]
     }));
-    form.append("file", Buffer.from(JSON.stringify({ type: "FeatureCollection", features: [(getCleanedEvent(options.event))] }, null, 2)), {
-        filename: `${event.event}_${event.status}_${event.metadata.tracking}.json`,
-        contentType: "application/json"
-    });
+    if (settings.upload) {
+        form.append("file", Buffer.from(JSON.stringify((getCleanedEvent(event)), null, 2)), {
+            filename: `${event.event}_${event.status}_${event.metadata.tracking}.json`,
+            contentType: "application/json"
+        });
+    }
     await createHttp({
         url: settings.webhook,
         timeout: 2000,

package/src/@types/type.event.ts

@@ -38,6 +38,7 @@ export type TypeEvent = {
             is_updated?: boolean
             is_expired?: boolean
             is_test?: boolean
+            is_statement?: boolean
         }
         metadata: {
             ms: number

package/src/@types/types.webhook.ts

@@ -21,6 +21,7 @@ export type TypeWebhook = {
     webhook: string
     title: string
     message: string
+    upload: boolean
     rate: number
     events: string[]
 }

package/src/bootstrap.ts

@@ -21,7 +21,7 @@ import path from 'path'
 import { EventEmitter } from 'node:events';
 
 export const bootstrap = {
-    version: `3.0.1`,
+    version: `3.0.3`,
     isReady: true,
     ratelimits: {},
     session_xmpp: null,

package/src/index.ts

@@ -23,7 +23,7 @@ import { getEventGeometry } from "./@building/building.geometry";
 import { getCleanedEvent } from "./@building/building.clean"
 import { setEventEmit } from './@modules/@utilities/utilities.setEventEmit';
 import { setWarning } from './@modules/@utilities/utilities.setWarning';
-import { listener } from "./@core/core.listener"
+import { createListener } from "./@core/core.createListener"
 import { startService } from "./@core/core.start"
 import { stopService } from "./@core/core.stop"
 import { setEasTone } from './@modules/@eas/eas.setEasTone';
@@ -31,12 +31,13 @@ import { setNode } from "./@core/core.setNode"
 import { getEvents } from "./@core/core.getEvents"
 import { getNodes } from "./@core/core.getNodes"
 import { getRandomEvent } from './@core/core.getRandomEvent';
+import { clearEvents } from './@core/core.clearEvents';
 
 export class Manager { 
     constructor(settings: TypeSettings) { this.trycatch(); startService(settings) }
 
     on(event: string, callback: () => void) {
-        listener(event, callback)
+        createListener(event, callback)
     }
 
     trycatch() {
@@ -62,8 +63,8 @@ export class Manager {
 export default Manager;
 export type { TypeEvent } from './@types/type.event';
 export { 
-    setSettings, getEventGeometry,
-    getCleanedEvent, stopService,
+    setSettings, getEventGeometry, 
+    getCleanedEvent, stopService, clearEvents,
     startService, setNode, getRandomEvent,
     getEvents, getNodes, setEasTone
 }

package/test.js

@@ -34,6 +34,7 @@ const NOAAWeatherWireService = new Manager({
             webhook: "https://discord.com/api/webhooks/XXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", 
             title: "AtmosphericX - (Severe Weather Events)", 
             message: `<@user_id>`, 
+            upload: true,
             events: [`Severe Thunderstorm Warning`, `Radar Indicated Tornado Warning`],
             rate: 1,
         },
@@ -41,6 +42,7 @@ const NOAAWeatherWireService = new Manager({
             webhook: "https://discord.com/api/webhooks/XXXXXXXXXXXXXX/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", 
             title: "AtmosphericX - (All Events)", 
             message: `<@user_id>`, 
+            upload: false,
             events: [],
             rate: 5,
         }