@atmosx/event-product-parser 3.0.44 → 3.0.47

package/src/@manager/manager.updateListener.ts

@@ -0,0 +1,163 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { TypeEvent } from "../@types/type.event";
+import { TypeListener } from "../@types/type.listener";
+import { bootstrap } from "../bootstrap"
+import { setEasTone } from "../@modules/@eas/eas.setEasTone"
+import { setTimeoutAction } from "../@modules/@utilities/utilities.setTimeoutAction";
+import { getEmebed } from "../@parsers/@text/text.getEmbed";
+import { getCleanedEvent } from "../@building/building.clean"
+import { createHttp } from "../@modules/@utilities/utilities.createHttp";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+import FormData from "form-data";
+
+
+
+export const updateListener = async (event: TypeEvent): Promise<void> => {
+    const settings = bootstrap.settings;
+    const listeners = settings.ListenerSettings as TypeListener[];
+    const properties = event.properties;
+    const metadata = { 
+        file: null,
+        eas: null,
+        name: properties.event,
+        status: properties.status,
+        description: properties.description,
+        tracking: properties.metadata.tracking,
+        header: properties.metadata.header,
+        raw: properties.metadata.raw,
+        expired: properties.status_metadata.is_expired,
+        attachments: properties.metadata.attachments
+    }
+
+    for (const listener of listeners) {
+        const events = listener?.events;
+        const webhook = listener?.webhook;
+        const uploads = listener?.uploads
+        const isMatched = events.some(pattern => {
+            if (!pattern) return false;
+            if (pattern === "*" || pattern === metadata.name) return true;
+            if (pattern.includes("*")) {
+                const regex = "^" +
+                    pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$";
+                return new RegExp(regex).test(metadata.name);
+            }
+            return false;
+        });
+
+        if (events?.length == 0 || isMatched) {
+            if (uploads?.eas) { 
+                metadata.eas = await setEasTone({
+                    title: `${metadata.name}_${metadata.status}_${metadata.tracking}`,
+                    message: metadata.description,
+                    header: metadata.header
+                });
+            }
+
+            if (uploads?.file) {
+                const fDestination = settings.GlobalSettings.ArchiveSettings.TextDirectory;
+                if (fDestination) {
+                    if (!existsSync(fDestination)) { mkdirSync(fDestination, { recursive: true }); }
+                    if (existsSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`)) {
+                        appendFileSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`, metadata.raw);
+                    } else {
+                        writeFileSync(`${fDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.txt`, metadata.raw);
+                    }
+                }
+                metadata.file = metadata.raw;
+            }
+
+            if (uploads?.event) {
+                const eDestination = settings.GlobalSettings.ArchiveSettings.EventDirectory;
+                if (eDestination) {
+                    if (!existsSync(eDestination)) { mkdirSync(eDestination, { recursive: true }); }
+                    writeFileSync(`${eDestination}/${metadata.name}_${metadata.status}_${metadata.tracking}.json`, JSON.stringify(getCleanedEvent(event), null, 2));
+                }
+            }
+
+            if (webhook.enabled && webhook.destination) {
+                const ratelimit = setTimeoutAction({ identifier: webhook.destination, interval: webhook.ratelimit, max: webhook.ratelimit, addTime: true })
+                const form = new FormData();
+                const embed = {
+                    title: `${metadata.name} (${metadata.status})`,
+                    description: getEmebed(event),
+                    fields: [],
+                    color: 16711680,
+                    timestamp: new Date().toISOString(),
+                    footer: { text: webhook.title ?? `AtmosphericX` }
+                };
+
+                if (ratelimit.limited) { return } 
+
+
+                if (metadata.description && !metadata.expired) {
+                    if (metadata.description.length > 900) {   
+                        metadata.description = metadata.description.substring(0, 900) + "\n\n[Message truncated due to length]";
+                    }
+                    embed.fields.push({
+                        name: "Description", 
+                        value: metadata.description ? '```' + '\n' + metadata.description.split('\n').map(l => l.trim()).filter(Boolean).join('\n') + '\n' + '```' : ""
+                    });
+                }
+
+
+                if (metadata.attachments?.length > 0) {
+                    metadata.attachments = metadata.attachments.slice(0, 5);
+                    embed.fields.push({
+                        name: "Attachments", 
+                        value: metadata.attachments.map(attachment => `- [${attachment.name.length > 45 ? attachment.name.substring(0, 45) + '...' : attachment.name}](${attachment.link})`).join('\n')
+                    });
+                }
+
+                if (uploads?.file) { 
+                    form.append("fUpload", Buffer.from(metadata.file), { 
+                        filename: `${properties.event}_${properties.status}_${properties.metadata.tracking}.txt`, 
+                        contentType: "application/text" 
+                    });
+                }
+
+                if (uploads?.eas) { 
+                    if (metadata.eas) {
+                        const file = readFileSync(metadata.eas)
+                        form.append("fEas", Buffer.from(file), { 
+                            filename: `${properties.event}_${properties.status}_${properties.metadata.tracking}_eas.mp3`, 
+                            contentType: "audio/mpeg" 
+                        });
+                    }
+                }
+
+                form.append("payload_json", JSON.stringify({
+                    username: webhook.title ?? "AtmosphericX",
+                    content: webhook.message ?? "",
+                    embeds: [embed]
+                }));
+
+                await createHttp({
+                    url: webhook.destination,
+                    timeout: 5000,
+                    method: `POST`,
+                    headers: form.getHeaders(),
+                    body: form
+                })
+            }
+        }
+    }
+}

package/src/@modules/@database/database.broadcastify.ts

@@ -0,0 +1,67 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { bootstrap } from "../../bootstrap"
+import { createHttp } from '../@utilities/utilities.createHttp'
+import { setWarning } from "../@utilities/utilities.setWarning";
+
+export const importBroadcastify = async (): Promise<void> => {
+    const settings = bootstrap.settings;
+    
+    const isBroadcastifyImported = bootstrap.database
+        .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='broadcastify';`)
+        .get();
+
+
+    if (!settings.BroadcastifySettings.BroadcastifyAttachments) { return }
+    if (isBroadcastifyImported) { return } 
+
+    const broadcastify = await createHttp({
+        url: settings.BroadcastifySettings.BroadcastifyDatabase,
+        timeout: 5000,
+    });
+    if (!broadcastify.error) {  
+        bootstrap.database.prepare(`CREATE TABLE broadcastify ( state TEXT, county TEXT, feed TEXT, type TEXT, link TEXT);`)
+            .run();
+        const states = JSON.parse(broadcastify.message);
+        const insert = bootstrap.database.prepare(`INSERT INTO broadcastify (state, county, feed, type, link) VALUES (?, ?, ?, ?, ?)`);
+        const transaction = bootstrap.database.transaction((rows: any[]) => {
+            for (const row of rows) {
+                insert.run(row);
+            }
+        });
+        const batch: any[] = [];
+        for (const state of states) {
+            setWarning({ message: `Importing ${state.counties.length} counties from ${state.state} for Broadcastify` });
+            for (const county of state.counties) {
+                const countyName = county.county;
+                for (const feed of county.feeds) {
+                    batch.push([
+                        state.state,
+                        countyName,
+                        feed.name,
+                        feed.type,
+                        feed.link
+                    ]);
+                }
+            }
+        }
+        transaction(batch);
+    }
+};

package/src/@modules/@database/database.init.ts

@@ -23,6 +23,7 @@ import { TypeSettings } from "../../@types/type.settings"
 import { bootstrap } from "../../bootstrap"
 import { setWarning } from '../@utilities/utilities.setWarning'
 import { importShapefiles } from './database.shapefiles'
+import { importBroadcastify } from "./database.broadcastify"
 
 export const initializeDatabase = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
@@ -38,7 +39,19 @@ export const initializeDatabase = async (): Promise<void> => {
         bootstrap.database
             .prepare(`CREATE TABLE IF NOT EXISTS shapefiles (id TEXT PRIMARY KEY, location TEXT, geometry TEXT)`)
             .run();
-        await importShapefiles();
+        const isNeedingShapefiles = bootstrap.database
+            .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='shapefiles';`)
+            .get();
+        const isNeedingBroadcastify = bootstrap.database
+            .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='broadcastify';`)
+            .get();
+
+        if (!isNeedingShapefiles || !isNeedingBroadcastify) {
+            setWarning({message: `Required database tables are currently building, please ${bootstrap.ansi_colors.RED}DO NOT${bootstrap.ansi_colors.RESET} close your terminal. The building will not finish and will remain incomplete. If you do mess up, you will need to delete ${settings.Database} and restart the application.` })
+            await importBroadcastify();
+            await importShapefiles();
+            setWarning({ message: `Building has completed, you can now continue or close the terminal`})
+        }
     } catch (error) {
         setWarning({ message: `An error occurred while initializing the database: ${error.message}` })
     }

package/src/@modules/@database/database.shapefiles.ts

@@ -25,7 +25,7 @@ import { TypeSettings } from "../../@types/type.settings"
 import { bootstrap } from "../../bootstrap"
 import { setSleep } from '../@utilities/utilities.setSleep'
 import { setWarning } from '../@utilities/utilities.setWarning'
-import { shapefileLinks } from '../../@dictionaries/dictionaries.shapefileLinks'
+import { dict_shapefiles } from '../../@dictionaries/dictionaries.shapefiles'
 
 export const importShapefiles = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
@@ -35,8 +35,7 @@ export const importShapefiles = async (): Promise<void> => {
             .get().count;
         if (tShapefiles === 0) {
             await setSleep({timeout: 1e3});
-            setWarning({ message: `Shapefiles are currently building, please DO NOT close your terminal. The shapefiles will not finish and will remain incomplete. If you do mess up, you will need to delete ${settings.Database} and restart the application.` })
-            for (const shapefile of shapefileLinks) {
+            for (const shapefile of dict_shapefiles) {
                 const response = await fetch(shapefile.link);
                 const arrayBuff = await response.arrayBuffer();
                 const content = await loadAsync(arrayBuff);
@@ -56,7 +55,7 @@ export const importShapefiles = async (): Promise<void> => {
                     filepath,
                     filepath,
                 );
-                setWarning({ message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id}` })
+                setWarning({ message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id} for Shapefiles` })
                 const insert = bootstrap.database
                     .prepare(`INSERT OR REPLACE INTO shapefiles (id, location, geometry) VALUES (?, ?, ?)`)
                 const transaction = bootstrap.database.transaction((entries: any[]) => {
@@ -84,10 +83,8 @@ export const importShapefiles = async (): Promise<void> => {
                 })
                 fs.unlinkSync(`${filepath}.shp`)
                 fs.unlinkSync(`${filepath}.dbf`)
-                setWarning({ message: `Cleaned up temporary files for ${shapefile.name}_${shapefile.id}` })
                 transaction(features)
             }
-            setWarning({ message: `Shapefiles have finished compiling, you can now continue and close this terminal` })
             fs.rm(resolve(__dirname, '../../shapefiles'), { recursive: true, force: true }, () => {});
         }
     } catch (error) {

package/src/@modules/@eas/eas.getCleanDescription.ts

@@ -77,9 +77,11 @@ export const getCleanDescription = (message: string): string => {
         message = message.replace(regex, replacement)
     }
     return message
+        .replace(/'/g, "''")
         .replace(/\b(\d{1,2}):(\d{2})\s*(AM|PM)\b/gi, (_, h, m, ap) => fmt(+h, +m, ap.toUpperCase()))
         .replace(/\b(\d{1,2})\s+(\d{2})\s+(AM|PM)\b/gi, (_, h, m, ap) => fmt(+h, +m, ap.toUpperCase()))
         .replace(/\b(\d{2})(\d{2})\s+(AM|PM)\b/gi, (_, hh, mm, ap) => fmt(+hh, +mm, ap.toUpperCase()))
+        .replace(/\b(\d{1,2})\s+(AM|PM)\b/gi, (_, h, ap) => fmt(+h, 0, ap.toUpperCase()))
         .replace(/\*+/g, " ")
         .replace(/-/g, " ")
         .replace(/\n/g, " ")

package/src/@modules/@eas/eas.getTTS.ts

@@ -19,23 +19,34 @@
 */
 
 import { platform } from 'os'
+import { writeFileSync } from "fs"
 import { execSync } from 'child_process'
 
 export const getTTS = async (text: string, outputPath: string): Promise<void> => {
     const vPlatform = platform();
     switch (vPlatform) {
         case 'win32': {
-            const command =
-                `Add-Type -AssemblyName System.Speech;` +
-                `$speak = New-Object System.Speech.Synthesis.SpeechSynthesizer;` +
-                `$speak.SetOutputToWaveFile('${outputPath}');` +
-                `$speak.Speak('${text}');` +
-                `$speak.Dispose();`;
-            execSync(`powershell -Command "${command}"`, { stdio: 'ignore' });
+            try {
+                const txtPath = outputPath + ".txt";
+                writeFileSync(txtPath, text, "utf8");
+                const command = [
+                    "Add-Type -AssemblyName System.Speech;",
+                    `$speak = New-Object System.Speech.Synthesis.SpeechSynthesizer;`,
+                    `$text = Get-Content -Raw -LiteralPath '${txtPath}';`,
+                    `$speak.SetOutputToWaveFile('${outputPath}');`,
+                    `$speak.Speak($text);`,
+                    `$speak.Dispose();`
+                ].join(" ");
+                execSync(`powershell -Command "${command}"`, { stdio: 'inherit' })
+            } catch(error) {
+                console.error('Error occurred while generating TTS:', error);
+            }
             break;
         }
         case 'linux':
-            execSync(`espeak -w "${outputPath}" "${text.replace(/"/g, '\\"')}"`);
+            try {
+                execSync(`espeak -w "${outputPath}" "${text.replace(/"/g, '\\"')}"`);
+            } catch {}
             break;
         default: break;
     }

package/src/@modules/@eas/eas.setEasTone.ts

@@ -38,14 +38,16 @@ import { platform } from 'os'
 interface GenerateEASOptions { 
     message: string
     header: string
+    title: string
 }
 
 export const setEasTone = async (options: GenerateEASOptions): Promise<string> => {
     const settings = bootstrap.settings as TypeSettings;
-    const directory = settings.GlobalSettings.EASSettings.ArchiveDirectory;
-    const prefix = settings.GlobalSettings.EASSettings.IntroWavFile;
+    const directory = settings.GlobalSettings.ArchiveSettings.EasDirectory;
+    const prefix = settings.GlobalSettings.ArchiveSettings.EasToneout;
     let message = options.message;
     let header = options.header;
+    let title = options.title ?? `${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}`;
     if (!message || !header) {
         setWarning({
             title: `EAS`,
@@ -60,15 +62,15 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
     if (!existsSync(directory)) {
         mkdirSync(directory, { recursive: true });
     }
-    if (!existsSync(join(directory, `/temp`))) {
-        mkdirSync(join(directory, `/temp`), { recursive: true });
+    if (!existsSync(join(directory, `/tts`))) {
+        mkdirSync(join(directory, `/tts`), { recursive: true });
     }
-    if (!existsSync(join(directory, `/output`))) {
-        mkdirSync(join(directory, `/output`), { recursive: true });
+    if (!existsSync(join(directory, `/encoded`))) {
+        mkdirSync(join(directory, `/encoded`), { recursive: true });
     }
 
-    const tmpTTS = join(directory, `/temp/${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}.wav`)
-    const outTTS = join(directory, `/output/${Math.random().toString(36).substring(2, 15)}-${header.replace(/[^a-zA-Z0-9]/g, '')}.wav`)
+    const tmpTTS = join(directory, `/tts/${title}.wav`)
+    const outTTS = join(directory, `/encoded/${title}.wav`)
     const vPlatform = platform();
 
     if (vPlatform === 'darwin') {
@@ -83,10 +85,13 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
     await new Promise<void>((resolve, reject) => {
         const tMsg = getCleanDescription(message)
         getTTS(tMsg, tmpTTS).then(() => {
-            buffTTS = readFileSync(tmpTTS);
             resolve();
         });
     });
+    if (!existsSync(tmpTTS)) {
+        return null;
+    }
+    buffTTS = readFileSync(tmpTTS);
     const vWav = getWavPCM16(buffTTS);
     const vSamples = getSampledPCM16(vWav.samples, vWav.sampleRate, 8000)
     const vRadio = setRadioEffect(vSamples, 8000)
@@ -97,7 +102,7 @@ export const setEasTone = async (options: GenerateEASOptions): Promise<string> =
 
         if (tWav == null) {
             try {
-                const converted = join(directory, `/temp/${Math.random().toString(36).substring(2, 15)}.converted.wav`)
+                const converted = join(directory, `/tts/${title}.converted.wav`)
                 execSync(`ffmpeg -y -i "${prefix}" -ar 8000 -ac 1 -sample_fmt s16 "${converted}"`, { stdio: 'ignore' })
                 if (existsSync(converted)) {
                     tBuffer = readFileSync(converted)

package/src/@modules/@stanza/stanza.getAwipsType.ts

@@ -18,7 +18,7 @@
 */
 
 import { TypeAttributes } from "../../@types/type.attributes"
-import { eventAwipAbreviations } from "../../@dictionaries/dictionaries.eventAwipAbreviations"
+import { dict_awips } from "../../@dictionaries/dictionaries.awips"
 
 interface ValidateOptions { 
     attributes: TypeAttributes
@@ -37,7 +37,7 @@ export const getAwipsType = (options: ValidateOptions): ValidiateResponse => {
             prefix: null
         }
     }
-    for (const [prefix, type] of Object.entries(eventAwipAbreviations)) {
+    for (const [prefix, type] of Object.entries(dict_awips)) {
         if (attributes.awipsid.startsWith(prefix)) {
             return { type, prefix }
         }

package/src/@modules/@stanza/stanza.validate.ts

@@ -19,7 +19,7 @@
 
 import { TypeStanza } from "../../@types/type.stanza"
 import { TypeStanzaCompiled } from "../../@types/type.compiled"
-import { regExp } from "../../@dictionaries/dictionaries.regExp"
+import { dict_expressions } from "../../@dictionaries/dictionaries.expressions"
 import { getAwipsType } from "./stanza.getAwipsType"
 
 interface ValidateOptions { 
@@ -35,8 +35,8 @@ export const validate = (options: ValidateOptions): TypeStanzaCompiled => {
             if (attributes.awipsid && attributes.awipsid.length > 1) { 
                 const isCapEvent = message.includes(`<?xml`);
                 const isCapAreaDescription = message.includes(`<areaDesc>`)
-                const isVTEC = message.match(regExp.pvtec) != null;
-                const isUGC = message.match(regExp.ugc1) != null;
+                const isVTEC = message.match(dict_expressions.pvtec) != null;
+                const isUGC = message.match(dict_expressions.ugc1) != null;
                 const getType = getAwipsType({ attributes: attributes})
                 if (getType.type != null) {
                     return { 

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

@@ -31,55 +31,64 @@ interface CreateHttpOptions {
 
 export const createHttp = async (options: CreateHttpOptions): Promise<any> => {
     return new Promise((resolve, reject) => {
-        const requestOptions = { 
-            url: options.url ?? `https://api.weather.gov/alerts/active`,
-            headers: options.headers ?? {
-                "User-Agent": "AtmosphericX",
-                "Accept": "application/geo+json, text/plain, */*; q=0.9",
-                "Accept-Language": "en-US,en;q=0.9"
-            }, 
-            method: options.method ?? `GET`,
-            timeout: options.timeout ?? 10e3,
-            proxy: options.proxy ?? null,
-            maxRedirects: 1, 
-        };
-        if (options.formData) {
-            requestOptions['formData'] = options.formData;
-        } else if (options.body) {
-            requestOptions['body'] = options.body;
-        }
-        
-        request(requestOptions, (error, response, body) => {
-            if (error) { 
-                return resolve({
-                    error: true,
-                    options: requestOptions,
-                    status: -1,
-                    message: error.message ?? `Unknown Error`
-                })
+        try {
+            const requestOptions = { 
+                url: options.url ?? `https://api.weather.gov/alerts/active`,
+                headers: options.headers ?? {
+                    "User-Agent": "AtmosphericX",
+                    "Accept": "application/geo+json, text/plain, */*; q=0.9",
+                    "Accept-Language": "en-US,en;q=0.9"
+                }, 
+                method: options.method ?? `GET`,
+                timeout: options.timeout ?? 10e3,
+                proxy: options.proxy ?? null,
+                maxRedirects: 1, 
+            };
+            if (options.formData) {
+                requestOptions['formData'] = options.formData;
+            } else if (options.body) {
+                requestOptions['body'] = options.body;
             }
-            if (response.statusCode < 200 || response.statusCode >= 300) {
-                return resolve({
-                    error: true,
+            
+            request(requestOptions, (error, response, body) => {
+                if (error) { 
+                    return resolve({
+                        error: true,
+                        options: requestOptions,
+                        status: -1,
+                        message: error.message ?? `Unknown Error`
+                    })
+                }
+                if (response.statusCode < 200 || response.statusCode >= 300) {
+                    return resolve({
+                        error: true,
+                        options: requestOptions,
+                        status: response.statusCode ?? -1,
+                        message: `HTTP Status Code ${response.statusCode ?? `Unknown Status Code`} (${body})`
+                    })
+                }
+                if (body == undefined || body == null) { 
+                    return resolve({
+                        error: true,
+                        options: requestOptions,
+                        status: response.statusCode ?? -1,
+                        message: `Empty Response Body`
+                    })
+                }
+                resolve({
+                    error: false,
                     options: requestOptions,
                     status: response.statusCode ?? -1,
-                    message: `HTTP Status Code ${response.statusCode ?? `Unknown Status Code`} (${body})`
-                })
-            }
-            if (body == undefined || body == null) { 
-                return resolve({
-                    error: true,
-                    options: requestOptions,
-                    status: response.statusCode ?? -1,
-                    message: `Empty Response Body`
-                })
-            }
-            resolve({
-                error: false,
-                options: requestOptions,
-                status: response.statusCode ?? -1,
-                message: body
-            })  
-        })
+                    message: body
+                })  
+            })
+        } catch (error) {
+            return resolve({
+                error: true,
+                options: {},
+                status: -1,
+                message: error.message ?? `Unknown Error`
+            })
+        }
     })
 }

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

@@ -30,8 +30,9 @@ import { join } from "path";
 export const setCronSchedule = async (): Promise<void> => {
     const settings = bootstrap.settings as TypeSettings;
 
-    const TTL = settings.GlobalSettings.EASSettings.ArchiveTTL
+    const TTL = settings.GlobalSettings.ArchiveSettings.TTL
     const TTLCUT = Date.now() - TTL * 1000;
+
     const walk = (dir: string): void => {
         if (existsSync(dir)) {
             const entries = readdirSync(dir, { withFileTypes: true });
@@ -49,7 +50,9 @@ export const setCronSchedule = async (): Promise<void> => {
             }
         }
     };
-    walk(settings.GlobalSettings.EASSettings.ArchiveDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.TextDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.EasDirectory)
+    walk(settings.GlobalSettings.ArchiveSettings.EventDirectory)
 
 
 

package/src/@modules/@xmpp/xmpp.xReconnect.ts

@@ -50,7 +50,7 @@ export const xReconnect = async (interval: number): Promise<void> => {
                         },
                         type: `reconnect`,
                         error: true
-                    },
+                    }, message: `Attempting to reconnect to XMPP Service (Reconnect Attempt ${bootstrap.cache.tReconnects})`,
                 })
                 await bootstrap.session_xmpp.stop().catch(() => {});
                 await bootstrap.session_xmpp.start().catch(() => {});

package/src/@parsers/@hvtec/hvtec.extract.ts

@@ -18,22 +18,22 @@
 */
 
 import { TypeHVTEC } from "../../@types/type.hvtec";
-import { eventCauses } from "../../@dictionaries/dictionaries.eventCauses";
-import { eventRecords } from "../../@dictionaries/dictionaries.eventRecords";
-import { regExp } from "../../@dictionaries/dictionaries.regExp";
-import { eventSeverity } from "../../@dictionaries/dictionaries.eventSeverity";
+import { dict_causes } from "../../@dictionaries/dictionaries.causes";
+import { dict_records } from "../../@dictionaries/dictionaries.records";
+import { dict_expressions } from "../../@dictionaries/dictionaries.expressions";
+import { dict_severity } from "../../@dictionaries/dictionaries.severity";
 
 export const hvExtract = (message: string): TypeHVTEC[] | null => {
-    const getHVTECs = message.match(regExp.hvtec) ?? [];
+    const getHVTECs = message.match(dict_expressions.hvtec) ?? [];
     const vtecs: TypeHVTEC[] = [];
     for (const vtec of getHVTECs) {
         const sub = vtec.split(`.`);
         if (sub.length < 7) continue;
         vtecs.push({
             hvtec: vtec,
-            severity: eventSeverity[sub[1]],
-            cause: eventCauses[sub[2]],
-            record: eventRecords[sub[6]]
+            severity: dict_severity[sub[1]],
+            cause: dict_causes[sub[2]],
+            record: dict_records[sub[6]]
         })
     }
     return vtecs.length > 0 ? vtecs : null;