Skip to main content

​
Overview

Alarm management actions provide CRUD operations for alarms, analytics, and acknowledgment workflows. All functions are located in src/app/actions/alarms.ts.

​
Alarm Operations

​
getAlarmsService

Retrieves a paginated list of alarms with optional filtering.
​
params
object
Query parameters for filtering and pagination
​
page
number
Page number (default: 1)
​
limit
number
Items per page (default: 10)
​
site_id
string
Filter by site ID
​
severity
string
Filter by severity level
​
data
Alarm[]
Array of alarm objects
​
meta
AlarmsMeta
Pagination metadata
​
page
number
Current page number
​
limit
number
Items per page
​
total
number
Total number of alarms
​
total_pages
number
Total number of pages
​
has_next
boolean
Whether there is a next page
​
has_prev
boolean
Whether there is a previous page
"use server";
import { getAlarmsService } from "@/app/actions";

export default async function AlarmsPage({ searchParams }) {
  const params = await searchParams;
  const page = parseInt(String(params?.page ?? 1), 10);
  const limit = parseInt(String(params?.limit ?? 10), 10);

  const { data: alarms, meta } = await getAlarmsService({ 
    page, 
    limit 
  });

  return <AlarmTable data={alarms} meta={meta} />;
}
On API errors, this function returns an empty data array with default pagination metadata instead of throwing.

​
getAlarmService

Retrieves a single alarm by ID.
​
id
string
required
Unique alarm identifier
​
data
Alarm
Complete alarm object with linked recommendations
import { getAlarmService } from "@/app/actions";

const alarm = await getAlarmService("alarm-123");

console.log(alarm.parameter);
console.log(alarm.acknowledged_status);
console.log(alarm.linked_recommendations);

​
addAlarmService

Creates a new alarm.
​
payload
AddAlarmPayload
required
Alarm creation data
​
parameter
string
required
Alarm parameter/condition (e.g., “High Temperature”, “Excessive Wear”)
​
site
object
required
​
id
string
required
Site ID where alarm occurred
​
first_detected
string
required
Date when alarm was first detected (ISO format)
​
acknowledged_status
boolean
required
Whether the alarm has been acknowledged
​
linked_recommendations
object[]
Array of linked recommendation IDs
​
id
string
required
Recommendation ID
​
response
ApiResponse
Standard API response object
​
success
boolean
Whether the operation succeeded
​
statusCode
number
HTTP status code
​
message
string
Response message
​
data
object
Created alarm data
"use client";
import { addAlarmService } from "@/app/actions";
import { AddAlarmPayload } from "@/schema";
import { toast } from "sonner";

export function AddAlarmForm() {
  const handleSubmit = async (data: AddAlarmPayload) => {
    const payload: AddAlarmPayload = {
      parameter: data.parameter,
      site: { id: data.site.id },
      first_detected: new Date().toISOString(),
      acknowledged_status: false,
      linked_recommendations: [],
    };

    const response = await addAlarmService(payload);
    
    if (response.success) {
      toast.success("Alarm created successfully");
      router.push("/alarms");
    } else {
      toast.error(response.message || "Failed to create alarm");
    }
  };

  return <form onSubmit={handleSubmit}>...</form>;
}

​
editAlarmService

Updates an existing alarm (typically used for acknowledgment).
​
id
string
required
Alarm ID to update
​
payload
EditAlarmPayload
required
Updated alarm data (same structure as AddAlarmPayload)
​
response
ApiResponse
Standard API response object
import { editAlarmService, getAlarmService } from "@/app/actions";
import { toast } from "sonner";

const handleAcknowledge = async (alarmId: string) => {
  // Get current alarm data
  const alarm = await getAlarmService(alarmId);
  
  // Update acknowledgment status
  const payload = {
    parameter: alarm.parameter,
    site: { id: alarm.site.id },
    first_detected: alarm.first_detected,
    acknowledged_status: true,
    linked_recommendations: alarm.linked_recommendations,
  };

  const response = await editAlarmService(alarmId, payload);
  
  if (response.success) {
    toast.success("Alarm acknowledged successfully");
  } else {
    toast.error(response.message);
  }
};

​
deleteAlarmService

Deletes an alarm.
​
id
string
required
Alarm ID to delete
​
response
ApiResponse
Standard API response object
import { deleteAlarmService } from "@/app/actions";
import { toast } from "sonner";

const handleDelete = async (alarmId: string) => {
  const response = await deleteAlarmService(alarmId);
  
  if (response.success) {
    toast.success("Alarm deleted successfully");
  } else {
    toast.error(response.message);
  }
};

​
Analytics Operations

​
getAlarmsAnalyticsService

Retrieves alarm analytics for dashboard metrics and trend analysis.
​
data
AlarmAnalytics | null
Alarm analytics data or null on error
​
total_alarms
number
Total number of alarms in the system
​
alarm_trend
object
Alarm growth trend
​
growth
number
Number of new alarms in period
​
percentage
number
Percentage change from previous period
​
open_overdue_alarms
number
Number of open and overdue alarms
​
open_overdue_trend
object
Trend for open/overdue alarms
​
growth
number
Change in overdue alarms
​
percentage
number
Percentage change
​
forecast_alarms
number
Forecasted number of future alarms
​
forecast_trend
object
Forecast trend data
​
growth
number
Predicted growth
​
percentage
number
Percentage change prediction
import { getAlarmsAnalyticsService } from "@/app/actions";

export default async function AlarmsDashboard() {
  const analytics = await getAlarmsAnalyticsService();

  if (!analytics) {
    return <div>Analytics unavailable</div>;
  }

  return (
    <div>
      <MetricCard 
        title="Total Alarms" 
        value={analytics.total_alarms}
        trend={analytics.alarm_trend.percentage}
      />
      <MetricCard 
        title="Open & Overdue" 
        value={analytics.open_overdue_alarms}
        trend={analytics.open_overdue_trend.percentage}
      />
      <MetricCard 
        title="Forecast" 
        value={analytics.forecast_alarms}
        trend={analytics.forecast_trend.percentage}
      />
    </div>
  );
}
Returns null on permission errors (403), non-JSON responses, or network issues instead of throwing. Always check for null before accessing properties.

​
Common Workflows

​
Alarm Acknowledgment Workflow

import { 
  getAlarmService, 
  editAlarmService, 
  getRecommendationsService 
} from "@/app/actions";
import { toast } from "sonner";

// 1. Fetch alarm details
const alarm = await getAlarmService(alarmId);

// 2. Show alarm details and recommendations
const recommendations = await getRecommendationsService({
  site_id: alarm.site.id,
});

// 3. Acknowledge alarm
const acknowledgeAlarm = async () => {
  const response = await editAlarmService(alarmId, {
    ...alarm,
    acknowledged_status: true,
  });
  
  if (response.success) {
    toast.success("Alarm acknowledged");
  }
};

// 4. Link recommendation to alarm
const linkRecommendation = async (recId: string) => {
  const response = await editAlarmService(alarmId, {
    ...alarm,
    linked_recommendations: [
      ...alarm.linked_recommendations,
      { id: recId },
    ],
  });
  
  if (response.success) {
    toast.success("Recommendation linked");
  }
};

​
Dashboard Alarm Monitoring

import { 
  getAlarmsService, 
  getAlarmsAnalyticsService 
} from "@/app/actions";

export default async function AlarmsDashboard() {
  const [alarms, analytics] = await Promise.all([
    getAlarmsService({ limit: 10 }),
    getAlarmsAnalyticsService(),
  ]);

  return (
    <div>
      {analytics && (
        <div className="grid grid-cols-3 gap-4">
          <MetricCard 
            title="Total Alarms"
            value={analytics.total_alarms}
          />
          <MetricCard 
            title="Overdue"
            value={analytics.open_overdue_alarms}
          />
          <MetricCard 
            title="Forecasted"
            value={analytics.forecast_alarms}
          />
        </div>
      )}
      
      <AlarmTable data={alarms.data} meta={alarms.meta} />
    </div>
  );
}

​
Type Definitions

Import types from @/types and schemas from @/schema: 
import { Alarm, AlarmAnalytics } from "@/types";
import { 
  AddAlarmPayload, 
  EditAlarmPayload, 
  ADD_ALARM_SCHEMA 
} from "@/schema";
import { ApiResponse } from "@/app/actions";
import { AlarmsMeta } from "@/app/actions/alarms";

Build docs developers (and LLMs) love

Get started for freeTalk to us