Refactor alert report model and update related routes for improved report handling

Author: nicomontanari

src/models/alert-report.ts

@@ -0,0 +1,37 @@
+import { database } from '..'
+
+const tableName = 'alert_reports'
+
+export interface AlertReport {
+    id: number
+    report_number: string
+    created_on: string
+    starts_on: string
+    ends_on: string
+    emitted_on: string
+    estofex_sent: boolean
+    pretemp_sent: boolean
+    is_critic: boolean
+}
+
+type EditableAlertReport = Omit<AlertReport, 'id'>
+
+export const getLastAlertReport = async (): Promise<AlertReport> => {
+    const query = `SELECT * FROM ${tableName} ORDER BY id DESC LIMIT 1`
+
+    const reports = await database.query<AlertReport>(query)
+
+    if (reports.length === 0) {
+        throw new Error('No last alert report found')
+    }
+
+    return reports[0]
+}
+
+export const createAlertReport = async (report: EditableAlertReport): Promise<AlertReport> => {
+    return database.create<AlertReport>(tableName, report)
+}
+
+export const updateLastAlertReport = async (report: Partial<EditableAlertReport>, id: number): Promise<AlertReport> => {
+    return database.edit<AlertReport>(tableName, report, id)
+}

src/models/last-alert-report.ts

@@ -3,7 +3,7 @@ import { checkEstofexReport } from '../utilites/estofex'
 import { getEstofexImage, getEstofexReport } from '../services/estofex'
 import { getTomorrowPretempReport } from '../services/pretemp'
 import { sendPhotoMessage } from '../services/telegram'
-import { getLastAlertReport, updateLastAlertReport } from '../models/last-alert-report'
+import { getLastAlertReport, updateLastAlertReport } from '../models/alert-report'
 
 export const registerForecastReportsRoutes = (fastify) => {
     fastify.route({
@@ -24,9 +24,12 @@ export const registerForecastReportsRoutes = (fastify) => {
 
             await sendPhotoMessage(config.chat_id, tomorrowReport, 'Nuovo report Pretemp disponibile')
 
-            await updateLastAlertReport({
-                pretemp_sent: true,
-            })
+            await updateLastAlertReport(
+                {
+                    pretemp_sent: true,
+                },
+                lastAlertReport.id
+            )
 
             reply.status(204).send(undefined)
         },
@@ -53,9 +56,12 @@ export const registerForecastReportsRoutes = (fastify) => {
 
             await sendPhotoMessage(config.chat_id, estofexImage, 'Nuovo report Estofex disponibile')
 
-            await updateLastAlertReport({
-                estofex_sent: true,
-            })
+            await updateLastAlertReport(
+                {
+                    estofex_sent: true,
+                },
+                lastAlertReport.id
+            )
 
             reply.status(204).send(undefined)
         },

src/routes/forecast-reports.ts

@@ -1,5 +1,5 @@
 import { sendNewTomorrowAlertMessage } from '../utilites/telegram'
-import { getLastAlertReport, updateLastAlertReport } from '../models/last-alert-report'
+import { createAlertReport, getLastAlertReport } from '../models/alert-report'
 import { getTomorrowMeteoAlert } from '../services/meteo-alerts'
 import { parseMeteoAlert } from '../utilites/meteo-alerts'
 
@@ -18,14 +18,20 @@ export const registerMeteoAlertsRoutes = (fastify) => {
 
             const lastAlertReport = await getLastAlertReport()
 
-            if (lastAlertReport.report_id !== parsedAlert.id) {
+            if (lastAlertReport.report_number !== parsedAlert.id) {
                 if (parsedAlert.isCritic) {
                     sendNewTomorrowAlertMessage(parsedAlert)
                 }
 
-                await updateLastAlertReport({
-                    report_id: parsedAlert.id,
+                await createAlertReport({
+                    report_number: parsedAlert.id,
                     is_critic: parsedAlert.isCritic,
+                    estofex_sent: false,
+                    pretemp_sent: false,
+                    created_on: new Date().toISOString(),
+                    starts_on: parsedAlert.dataInizio,
+                    ends_on: parsedAlert.dataFine,
+                    emitted_on: parsedAlert.dataEmissione,
                 })
             }
 

src/routes/meteo-alerts.ts

@@ -93,6 +93,22 @@ export default class PostgreSQL {
         }
     }
 
+    public async create<T = any>(tableName: string, object: Omit<T, 'id'>) {
+        const keys = Object.keys(object)
+            .map((key) => checkAndTransformKey(key))
+            .join(', ')
+
+        const values: any[] = Object.values(object)
+
+        const query = `INSERT INTO ${checkAndTransformKey(
+            tableName
+        )} (${keys}) VALUES (${values.map((_, i) => `$${i + 1}`).join(', ')}) RETURNING *`
+
+        const rows = await this.query<T>(query, values)
+
+        return rows[0]
+    }
+
     public async edit<T>(tableName: string, object: Omit<Partial<T>, 'id'>, objectId: number) {
         const keys = Object.keys(object).map((key, index) => `${checkAndTransformKey(key)} = $${index + 1}`)
 
@@ -104,6 +120,12 @@ export default class PostgreSQL {
 
         return rows[0]
     }
+
+    public async delete(tableName: string, itemId: number) {
+        const query = `DELETE FROM ${checkAndTransformKey(tableName)} WHERE id = $1`
+
+        await this.query<void>(query, [itemId])[0]
+    }
 }
 
 // Add backtick to sql reserved keywords