Notfallreaktionssystem mit Vonage Messages API und Java

Einführung

Genaue Standortüberwachung und gute Kommunikation sind wesentliche Bestandteile von Notfalleinsatzsystemen. Dank der Integration moderner Technologien sind innovative Lösungen zur Verbesserung der Notfallmaßnahmen möglich geworden. Eine solche Lösung bietet einen soliden Rahmen für Notfallmaßnahmen und Standortüberwachung, indem sie die Stärken der Vonage Nachrichten-API mit Java und Spring Boot.

Mit Hilfe der Vonage Messages API können Unternehmen und Organisationen die Popularität von WhatsApp für effiziente Nachrichtenübermittlung und Informationsaustausch nutzen. Diese API kann verwendet werden, um ein umfassendes, allumfassendes Notfallreaktionssystem in Kombination mit Java und Spring Boot aufzubauen.

Wenn Sie weiterspringen möchten, finden Sie den Code auf GitHub.

Was wir bauen werden

Die von Vonage Messages API, die in Java (Spring Boot) integriert ist, bietet zahlreiche Vorteile für die Notfallhilfe und Standortverfolgung. Über WhatsApp können Notfallhelfer:

• Kommunikation mit den Betroffenen

• wichtige Informationen zu sammeln und

• Anweisungen zu erteilen, und zwar über eine vertraute und weit verbreitete Nachrichtenplattform

Dies verbessert die Zugänglichkeit und Reichweite der Notfallkommunikation und stellt sicher, dass kritische Nachrichten sofort empfangen und verstanden werden.

Los geht's

Sie müssen sich für ein Vonage-Konto registrieren und dann eine Anwendung innerhalb dieses Kontos erstellen, um die Vonage-APIs nutzen zu können. Die Anwendung erhält einen API-Schlüssel und ein Geheimnis, die Sie zur Authentifizierung Ihrer API-Abfragen verwenden werden.

Hier finden Sie eine Liste der Maßnahmen, die Sie ergreifen müssen:

• Erstellen Sie ein Vonage Developer-Konto, um Zugang zu API-Schlüsseln usw. zu erhalten.

• Erstellen Sie eine neue Anwendung, indem Sie sich im Vonage Dashboard anmelden.

• Sie werden aufgefordert, die API auszuwählen, die Sie bei der Erstellung der Anwendung verwenden möchten. Für dieses Lernprogramm wählen Sie die Nachrichten-API.

• Sobald die Anwendung erstellt wurde, werden ein API-Schlüssel und ein Geheimnis für Sie erstellt. Um Ihre Anfragen zu authentifizieren, müssen Sie diesen Schlüssel und das Geheimnis verwenden.

• Suchen Sie den Schlüssel und das Geheimnis im Abschnitt "API Credentials" des Dashboards.

• [Optional, aber empfohlen] - Lesen Sie die Dokumentation über das Produkt.

Anforderungen

Es wird davon ausgegangen, dass Sie mit der Programmiersprache Java vertraut sind und ausgiebig mit dem Spring Boot-Framework gearbeitet haben, um diesem Tutorial effektiv folgen zu können. Außerdem sollten Sie mit der Erstellung von RESTful-Controllern in Spring Boot vertraut sein und eine Standard-IDE wie IntelliJ installiert haben.

Einrichten der Projektumgebung

Bevor Sie mit der Entwicklung der App beginnen, müssen Sie sicherstellen, dass Ihr Projekt korrekt eingerichtet ist. Erstellen Sie ein neues Spring Boot-Projekt, um mit der Entwicklung der Notfallanwendung zu beginnen. Um ein neues Spring Boot-Projekt zu erstellen, verwenden Sie die Spring Initializr. Gehen Sie zum Projektauswahlmenü und wählen Sie dann "Java" und "Maven". 3.1.0 da dies die neueste und stabilste Version ist. Allerdings scheint es bei dieser Version zu einem Konflikt mit der web Abhängigkeit zu haben, also müssen Sie die pom.xml Datei Ihres Projekts und ändern Sie sie von <version>3.1.0</version> in ändern. <version>3.0.5</version>.

Benennen Sie die Artefakt-Anwendung um in etwas wie responseapp für die Projekt-Metadaten. Dieser Name dient als Anzeigetitel und als Eintragstitel des Projekts. Bitte geben Sie eine Projektbeschreibung an, wenn dies der besseren Organisation dient. Da die Anwendung auf Java 17 und dem eingebauten Tomcat-Server, den Spring Boot bietet, laufen wird, wählen Sie "Jar" als Verpackungstyp. Das unten stehende Bild gibt ein klareres Bild von dem, was wie hier beschrieben erwartet wird:

Spring Initializr

Der Browser lädt eine .zip-Datei herunter, die den Boilerplate-Code für das Projekt enthält, wenn Sie auf die Schaltfläche Erzeugen unten auf der Seite klicken. Öffnen Sie das Projekt in Ihrer IDE, nachdem Sie die.zip-Datei extrahiert haben. In diesem Projekt ist die verwendete IDE die IntelliJ IDEA. Die Ultimate-Version ist kostenpflichtig, aber Sie können jederzeit die Community- oder Education-Editionen kostenlos erhalten.

Außerdem muss das Vonage Java SDK als Abhängigkeit in Ihrem Projekt hinzugefügt werden. Dies kann durch Einfügen des folgenden Codes in Ihre pom.xml-Datei erreicht werden. Speichern Sie die Änderungen in der Datei. Ersetzen Sie die aktuellen Abhängigkeiten in der Datei pom.xml Datei durch die unten aufgeführten Abhängigkeiten:

<dependencies>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
     <dependency>
       	 <groupId>org.springframework.boot</groupId>
       	 <artifactId>spring-boot-starter-data-jpa</artifactId>
     </dependency>
    <dependency>
     	<groupId>com.vonage</groupId>
        	<artifactId>client</artifactId>
     	<version>7.1.1</version>
    </dependency>
</dependencies>

Nachstehend finden Sie eine Liste der Funktionen der einzelnen Abhängigkeiten:

• spring-boot-starter-web: Diese Abhängigkeit stellt die erforderlichen Bibliotheken und Komponenten für die Entwicklung von Webanwendungen mit Spring Boot bereit. Sie umfasst Funktionen wie einen eingebetteten Tomcat-Server, das Spring MVC-Framework und andere Dienstprogramme, die für die Bearbeitung von HTTP-Anfragen, das Routing und die Erstellung von RESTful-APIs erforderlich sind.

• lombok: Lombok ist eine Bibliothek, die durch die automatische Generierung von Getter/Setter-Methoden, Konstruktoren, toString, equals und anderen gängigen Methoden dazu beiträgt, Boilerplate-Code in Java-Klassen zu reduzieren. Sie vereinfacht den Entwicklungsprozess und verbessert die Lesbarkeit und Wartbarkeit des Codes. Der <optional>true</optional>-Tag zeigt an, dass diese Abhängigkeit optional ist und für das Funktionieren der Anwendung nicht erforderlich ist, aber oft aus Bequemlichkeit verwendet wird.

• spring-boot-starter-test: Diese Abhängigkeit wird für das Schreiben von Tests in einer Spring Boot-Anwendung verwendet. Sie bietet Hilfsprogramme und Frameworks für das Schreiben von Unit-, Integrations- und anderen Tests. Das <scope>test</scope>-Tag zeigt an, dass diese Abhängigkeit nur während der Testphase benötigt wird und nicht in der endgültigen Anwendung enthalten ist.

• spring-boot-jpa: Spring JPA ist ein Teil des Spring Frameworks, das die Arbeit mit der Java Persistence API (JPA) unterstützt. JPA ist eine Standard-API für die Arbeit mit relationalen Datenbanken in Java, und Spring JPA bietet eine Reihe von Tools und Bibliotheken, die die Arbeit mit JPA erleichtern.

Datenbank einrichten

Die Objekte und Ereignisse der Emergency Response App werden in einer MySQL-Datenbank gespeichert. Bitte denken Sie daran, dass Sie jeden beliebigen Datenbankanbieter verwenden können. In diesem Tutorial wird MySQL Workbench verwendet. Um loszulegen, müssen Sie zunächst den MySQL-Server installieren. Folgen Sie dazu den offiziellen Installationsseiten für Windows und Linuxbzw. - je nach Betriebssystem - die offiziellen Installationsseiten für Windows bzw. Linux, um dies zu bewerkstelligen. Nun ist es an der Zeit, sich mit der MySQL Workbench zu beschäftigen. Gehen Sie zu ihrer offiziellen Download-Website, wählen Sie Ihr Betriebssystem aus und laden Sie das entsprechende Paket für Ihr Betriebssystem herunter.

MySQL Community Downloads

Öffnen Sie die MySQL Workbench. Klicken Sie zunächst auf das + Symbol rechts neben MySQL-Verbindungen (siehe unten). Dadurch können wir eine neue MySQL-Instanzumgebung bereitstellen, in der alle Datenbanken erstellt und verwaltet werden können. Erstellen Sie eine Tabelle mit einem beliebigen Namen in der Workbench.

MySQL Workbench

Ein Klick auf die Schaltfläche + Schaltfläche wird ein modales Formular angezeigt, in dem Sie eine Connection Name, Username, und Password. Die anderen Felder können Sie in ihrer Voreinstellung belassen. Der Benutzername und das Passwort sind Ihre Anmeldeinformationen für den Zugriff auf jede Datenbank in dieser Verbindung von Ihrem Projekt aus.

MySQL Setting up a Connection

Sobald dies geschehen ist, ist es an der Zeit, eine Datenbank zu erstellen. Öffnen Sie die Verbindung und schauen Sie in die obere rechte Ecke. Unter der Option View finden Sie ein Symbol, das wie ein Stapel kleiner Zylinder aussieht. Klicken Sie darauf, um Create New Schema. Ein Schema ist ein anderes Wort für die Datenbank. Sie können diese Datenbank mit einem Namen Ihrer Wahl benennen, aber beachten Sie, dass er dem Namen entsprechen muss, den Sie in Ihr Projekt eingeben. In diesem Fall heißt die Datenbank `vonage-dev. Nach dem Speichern beenden Sie das Programm. Gehen Sie nun zu 'resources' in Ihrem Projekt, öffnen Sie die Datei 'application.properties' und fügen Sie Folgendes ein:

spring.datasource.url=jdbc:mysql://localhost:3306/vonage-dev?serviceTimezone=UTC
spring.datasource.username=<your-connection-username>
spring.datasource.password=<your-connection-password>
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.ddl-auto=update

Modelle

Es ist an der Zeit, die Modelle zu erstellen, die die Einheiten in der Notfallhilfe-App darstellen. Es muss jemanden geben, der meldet, etwas, das gemeldet werden soll, und jemanden, der sich um die gemeldeten Dinge kümmert.

Benutzermodell

Erstellen Sie eine Datei mit dem Namen AppUser.java im Paket 'model'. Fügen Sie den folgenden Code in die Datei ein:

import jakarta.persistence.Entity;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import jakarta.persistence.*;
import java.util.HashMap;
import java.util.Map;

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@Entity

public class AppUser {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String fullName;
	private String emailAddress;
	private String phoneNumber;
	@ElementCollection
	private Map<String, Object> contactList = new HashMap<>();
}

Die Klasse hat mehrere private Instanzvariablen (id, fullName, emailAddress, phoneNumber und contactList), die verschiedene Attribute eines Benutzers darstellen.

• Das Feld id ist mit den Anmerkungen @Id und @GeneratedValue versehen, was bedeutet, dass es der Primärschlüssel der Entität ist und sein Wert automatisch von der zugrunde liegenden Datenbank generiert wird.

• Die Felder fullName, emailAddress und phoneNumber stellen den vollständigen Namen, die E-Mail-Adresse bzw. die Telefonnummer des Benutzers dar. Diese Felder haben keine spezifischen Anmerkungen, so dass ihre Werte als einfache String-Werte gespeichert werden.

• Das Feld contactList ist mit @ElementCollection annotiert, was bedeutet, dass es eine Sammlung von Elementen darstellt, die als separate, mit der Tabelle AppUser verknüpfte Tabelle zu speichern ist. In diesem Fall ist contactList eine Map<String, Object>, die die Kontaktliste des Benutzers darstellt, wobei der Schlüssel ein Name (String) und der Wert ein Objekt (normalerweise eine Telefonnummer) ist.

Unter Verwendung der @ElementCollection-Annotation wird das Feld contactList in einer separaten Tabelle mit einem Fremdschlüsselverweis auf die Tabelle AppUser gespeichert. Die Zuordnungseinträge werden als einzelne Zeilen in der Tabelle gespeichert, mit dem Namen als eine Spalte und dem entsprechenden Objektwert als weitere Spalte.

Störfall-Modell

Erstellen Sie eine weitere Datei im selben Verzeichnis, nennen Sie sie Incident.javaund fügen Sie auch hier den folgenden Code ein:

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@Entity

public class Incident {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;
private Long userId;
private String incidentDescription;

@ElementCollection

	private Map<String, Object> incidentLocation = new HashMap<>();

private LocalDateTime incidentTime;
private String status;
private boolean respondedTo;
private Long responder;
}

Die Klasse hat mehrere private Instanzvariablen (userId, incidentDescription, incidentLocation, incidentTime, status, respondedTo und responder), die verschiedene Attribute eines Vorfalls darstellen.

• Das Feld userId steht für die Kennung des Benutzers, der mit dem Vorfall verbunden ist.

• Das Feld incidentDescription enthält eine Beschreibung des Vorfalls.

• Das Feld incidentLocation ist mit @ElementCollection versehen, was anzeigt, dass es eine Sammlung von Elementen darstellt, die als separate, mit der Tabelle Incident verknüpfte Tabelle gespeichert werden sollen. In diesem Fall ist incidentLocation eine Map<String, Object>, die die Standortinformationen des Vorfalls darstellt, wobei der Schlüssel eine Zeichenkette ist (z. B. "longitude", "latitude") und der Wert ein Objekt ist, das die entsprechenden Standortdaten darstellt.

• Das Feld incidentTime gibt das Datum und die Uhrzeit an, zu der das Ereignis eingetreten ist. Es verwendet die Klasse LocalDateTime aus dem Java 8 java.time Paket.

• Das Statusfeld gibt den aktuellen Status des Vorfalls an.

• Das Feld respondedTo ist ein boolesches Flag, das angibt, ob auf den Vorfall reagiert wurde.

• Das Feld Responder steht für die Kennung des Responders, der mit dem Vorfall in Verbindung steht.

Responder-Modell

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import jakarta.persistence.*;

@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@Entity

public class Responder {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String responderName;
	private String responderNumber;
	private boolean isAvailable;
}

Die Klasse hat mehrere private Instanzvariablen (id, responderName, responderNumber und isAvailable), die verschiedene Attribute eines Responders darstellen.

• Das Feld id ist mit den Anmerkungen @Id und @GeneratedValue versehen, was bedeutet, dass es der Primärschlüssel der Entität ist und sein Wert automatisch von der zugrunde liegenden Datenbank generiert wird.

• Das Feld ResponderName steht für den Namen des Responders.

• Das Feld responderNumber steht für die Telefonnummer des Responders.

• Das Feld isAvailable ist ein boolesches Flag, das angibt, ob der Responder derzeit verfügbar ist.

Vorfall-Status Enum

public enum IncidentStatus {
	UNRESOLVED,
	BEING_RESOLVED,
	RESOLVED,
	ABANDONED;
}

Die Aufzählung besteht aus vier Werten: UNRESOLVED, BEING_RESOLVED, RESOLVED und ABANDONED.

• Jeder Wert steht für einen anderen Status, den ein Vorfall haben kann. Diese Status stellen verschiedene Stadien oder Zustände des Lebenszyklus eines Vorfalls dar.

• Enums sind eine Möglichkeit, eine feste Gruppe von konstanten Werten zu definieren. Sie bieten eine bequeme Möglichkeit, eine Gruppe zusammengehöriger Werte darzustellen und die möglichen Werte, die eine Variable haben kann, einzuschränken.

• In diesem Fall wird IncidentStatus enum verwendet, um die möglichen Zustände zu definieren, die ein Vorfall haben kann, z. B. ob er ungelöst, in Bearbeitung, gelöst oder aufgegeben ist.

Repositories

Erstellen Sie drei neue Dateien unter dem repository Unterverzeichnis an: UserRepository.java, ResponderRepository.java, und IncidentRepository.java. Fügen Sie die folgenden Codeschnipsel in jede der entsprechenden Dateien ein:

import com.response.emergency.model.AppUser;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<AppUser, Long> {

}

import com.response.emergency.model.Responder;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface ResponderRepository extends JpaRepository<Responder, Long> {

}

import com.response.emergency.model.Incident;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface IncidentRepository extends JpaRepository<Incident, Long>{

}

Konfiguration - VonageConfig.java

Diese Datei enthält die Anmeldedaten für die erfolgreiche Interaktion mit dem Vonage SDK. Fügen Sie den Codeschnipsel aus dem folgenden Block in diese Datei ein:

import com.vonage.client.VonageClient;
import org.springframework.beans.factory.annotation.Value;

public class VonageConfig {
	@Value("${APPLICATION_ID}")
	private static String applicationId;
	@Value("${PRIVATE_KEY}")

	private static String privateKey;
	private static VonageClient instance;

	private VonageConfig() {}

	public static VonageClient getInstance() {
    	
		if (instance == null) {
        	instance = VonageClient.builder()
                	.applicationId(applicationId)
                	.privateKeyPath(privateKey)
                	.build();
    	}

    	return instance;
	}
}

Der Code stellt eine Java-Klasse namens VonageConfig.java die für die Konfiguration und Bereitstellung einer Instanz des VonageClient aus der Vonage API verantwortlich ist:

• Die Klasse hat zwei private statische Variablen: applicationId und privateKey. Diese Variablen sind annotiert mit @Value annotiert und ihnen werden Werte aus externen Konfigurationseigenschaften zugewiesen, wobei der Spring-Mechanismus zur Injektion von Eigenschaften verwendet wird. Die Werte werden von Eigenschaften mit den Schlüsseln APPLICATION_ID und PRIVATE_KEYabgerufen.

• Die Klasse hat eine private statische Instanzvariable vom Typ VonageClientdie die Singleton-Instanz des Vonage-Clients darstellt.

• Der Konstruktor der Klasse ist als privat gekennzeichnet, was bedeutet, dass die Klasse nicht von außen instanziiert werden kann.

• Die Klasse bietet eine öffentliche statische Methode getInstance() die die Singleton-Instanz der VonageClient. Wenn die Instanz noch nicht erstellt wurde, erstellt die Methode sie mit Hilfe der Methode VonageClient.builder() und setzt die applicationId und privateKey unter Verwendung der aus der Konfiguration erhaltenen Werte. Schließlich erstellt sie die Instanz und gibt sie zurück.

Standort-Service

In dem service Paket, erstellen Sie die LocationService.java Datei und fügen Sie den folgenden Codeausschnitt ein:

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

@Service
@Slf4j

public class LocationService {

	Map<String, Object> getLocation() {
    	Map<String, Object> coordinates = new HashMap<>();
    	coordinates.put("longitude", generateDummyCoordinate());
    	coordinates.put("latitude", generateDummyCoordinate());
    	return coordinates;
	}

	public static double generateDummyCoordinate() {
    	double minValue = 111.00;
    	double maxValue = 999.99;
    	Random random = new Random();

    	return minValue + (maxValue - minValue) * random.nextDouble();
	}
}

Die Klasse LocationService stellt einen Dienst dar, der für das Abrufen der Standortinformationen zuständig ist. Sie enthält eine Methode namens getLocation() die eine Karte mit Koordinaten zurückgibt, und zwar longitude und latitude. Innerhalb der getLocation() Methode wird eine neue HashMap namens coordinates erstellt, um die Koordinaten zu speichern. Die Methode generateDummyCoordinate() Methode wird zweimal aufgerufen, um zufällige longitude und latitude Werte zu erzeugen. Diese Werte werden dann in die coordinates Karte hinzugefügt, wobei die Schlüssel "Längengrad" und "Breitengrad" verwendet werden.

Die Klasse LocationService Klasse bietet eine einfache Implementierung zur Erzeugung und Rückgabe von Dummy-Standortkoordinaten in einer Karte. Dies kann weiter ausgebaut werden, um den Standort des Geräts über GPS oder andere Standortdienste abzurufen. Dazu müssen Sie sich zum Beispiel mit der vollständigen Android-Entwicklung befassen, was den Rahmen dieses Artikels sprengen würde. Die Idee, mit der wir hier arbeiten, ist, dass wir den Standort eines Vorfalls auswählen, wenn er vom Ort des Geschehens aus gemeldet wird.

Notdienst

Navigieren Sie zu dem Verzeichnis service Verzeichnis und erstellen Sie eine EmergencyService Datei. Fügen Sie das Codeschnipsel in die erstellte Datei ein.

import com.response.emergency.model.*;
import com.response.emergency.repository.IncidentRepository;
import com.response.emergency.repository.ResponderRepository;
import com.response.emergency.repository.UserRepository;
import com.response.emergency.requests.CreateIncidentRequest;
import com.response.emergency.requests.PickIncidentRequest;
import com.response.emergency.requests.ReportIncidentRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.time.LocalDateTime;

@Service
@Slf4j

public class EmergencyService {

	@Autowired
	private UserRepository userRepository;
	@Autowired
	private ResponderRepository respondentRepository;
	@Autowired
	private IncidentRepository incidentRepository;
	@Autowired
	private LocationService locationService;

	@Autowired
	private VonageService vonageService;
	public AppUser createUser(AppUser user) {

    	return userRepository.save(user);
	}

	public Responder createRespondent(Responder responder) {

    	return respondentRepository.save(responder);
	}

	public String addUserToEmergencyList(Long userId, String name, String phoneNumber) {

    	AppUser appUser = userRepository.findById(userId).orElse(null);
    	assert appUser != null;
    	appUser.getContactList().put(name, phoneNumber);
    	userRepository.save(appUser);
    	return "User successfully added to your emergency contact list";
	}

	public Incident createAndSendIncident(CreateIncidentRequest createIncidentRequest) {

    	Incident incident = new Incident();
    	incident.setUserId(createIncidentRequest.getUserId());
    	incident.setIncidentDescription(createIncidentRequest.getIncidentDescription());
    	incident.setStatus(IncidentStatus.UNRESOLVED.name());
    	incident.setIncidentTime(LocalDateTime.now());
    	incident.setRespondedTo(false);
    	incident.setResponder(null);

    	if (createIncidentRequest.isReportingFromScene()) {

        	Map<String, Object> locationMap = locationService.getLocation();
        	incident.getIncidentLocation().put("longitude", locationMap.get("longitude"));
        	incident.getIncidentLocation().put("latitude", locationMap.get("latitude"));

    	}

    	else {

        	incident.getIncidentLocation().put("longitude", createIncidentRequest.getLongitude());
        	incident.getIncidentLocation().put("latitude", createIncidentRequest.getLatitude());
    	}

    	// send whatsapp here

    	AppUser user = userRepository.findById(createIncidentRequest.getUserId()).orElse(null);
    	String message = "There has been an incident reported by your friend at a location. " +
            	"Please help report to authorities";

    	assert user != null;

    	for (Map.Entry<String, Object> entry : user.getContactList().entrySet()) {
        	vonageService.sendWhatsApp(String.valueOf(entry.getValue()), message);
    	}

    	return incidentRepository.save(incident);
	}

	public String pickIncident(PickIncidentRequest pickIncidentRequest) {

    	Incident incident = incidentRepository.findById(pickIncidentRequest.getIncidentId()).orElse(null);

    	assert incident != null;

    	if (incident.isRespondedTo()) {

        	return "This incident has already been picked for attention";

    	}

    	incident.setStatus(IncidentStatus.BEING_RESOLVED.name());
    	incident.setRespondedTo(true);
    	incident.setResponder(pickIncidentRequest.getResponderId());
    	incidentRepository.save(incident);

    	return "Incident successfully picked. Kindly hurry to the scene";

	}

	public String reportIncidentStatus(ReportIncidentRequest reportIncidentRequest) {

    	Incident incident = incidentRepository.findById(reportIncidentRequest.getIncidentId()).orElse(null);

    	assert incident != null;

    	if (!incident.isRespondedTo()) {
        	return "This incident has not been picked for attention";
    	}

    	if (reportIncidentRequest.getStatus().equalsIgnoreCase("Abandoned")) {
        	incident.setStatus(IncidentStatus.ABANDONED.name());
    	}

    	else {
        	incident.setStatus((IncidentStatus.RESOLVED.name()));
    	}

    	incident.setRespondedTo(true);
    	incident.setResponder(reportIncidentRequest.getResponderId());
    	incidentRepository.save(incident);
    	return "Incident successfully picked. Kindly hurry to the scene";
	}
}

Dieser Code in der obigen Klasse bietet verschiedene Funktionen für unsere Notfallmelde-App. Lassen Sie uns den Code durchgehen und seine Komponenten verstehen:

• Die Klasse ist annotiert mit @Autowiredannotiert, was darauf hinweist, dass sie von einem Spring-Framework verwaltet wird und Dependency Injection verwendet wird, um die erforderlichen Abhängigkeiten zu injizieren.

• Die Klasse hat mehrere Instanzvariablen (userRepository, respondentRepository, incidentRepository, locationService, und vonageService), die über den Abhängigkeitsinjektionsmechanismus von Spring automatisch verdrahtet werden. Bei diesen Abhängigkeiten handelt es sich um von Spring verwaltete Beans, die Datenzugriff, Standortdienste und Kommunikationsfunktionen von Vonage bereitstellen.

• Die Klasse bietet mehrere öffentliche Methoden, um verschiedene Aktionen im Zusammenhang mit Notfallereignissen und Benutzern durchzuführen:

• createUser() und createRespondent() Methoden speichern einen neuen Benutzer bzw. Befragten über ihre entsprechenden repository Schnittstellen.

• addUserToEmergencyList() Methode fügt die Kontaktinformationen eines Benutzers (Name und Telefonnummer) zu seiner Notfallkontaktliste hinzu, die in dem AppUser Objekt gespeichert sind. Die aktualisierte AppUser wird dann mit der Methode userRepository.

• createAndSendIncident() Methode erstellt einen neuen Vorfall auf der Grundlage der Informationen, die in der CreateIncidentRequest. Sie legt die Details des Vorfalls fest, einschließlich der Beschreibung des Vorfalls, des Status, der Zeit und des Standorts. Wenn der Vorfall vom Tatort aus gemeldet wird, verwendet die Methode den locationService, um den aktuellen Standort abzurufen, und fügt ihn dem Vorfallsobjekt hinzu. Danach sendet sie eine WhatsApp-Nachricht an die Notfallkontaktliste des Benutzers unter Verwendung der Option vonageService mit den Details des Vorfalls.

• pickIncident() Methode markiert einen Vorfall als von einem Responder zur Bearbeitung ausgewählt. Sie aktualisiert den Status des Vorfalls, markiert ihn als beantwortet und setzt die ID des Responders. Der aktualisierte Vorfall wird in der Datei incidentRepository.

• reportIncidentStatus() Methode aktualisiert den Status eines kommissionierten Vorfalls auf der Grundlage der ReportIncidentRequest. Sie setzt den Status entweder als Abandoned oder Resolved und aktualisiert die ID des Responders. Der aktualisierte Vorfall wird in der Datei incidentRepository.

Notfall-Controller

Im Paket Ihres Projekts namens controller. Erstellen Sie darin eine Datei mit dem Namen EmergencyController.java. Fügen Sie den folgenden Code ein:

import com.response.emergency.model.AppUser;
import com.response.emergency.model.Responder;
import com.response.emergency.requests.AddContactRequest;
import com.response.emergency.requests.CreateIncidentRequest;
import com.response.emergency.requests.PickIncidentRequest;
import com.response.emergency.requests.ReportIncidentRequest;
import com.response.emergency.service.EmergencyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController

@RequestMapping("/api/")

public class EmergencyController {
	@Autowired
	private EmergencyService emergencyService;
	@PostMapping("/create-user")

	public ResponseEntity<?> createUser(@RequestBody AppUser user) {
    	return new ResponseEntity<>(emergencyService.createUser(user), HttpStatus.OK);
	}

	@PostMapping("/create-responder")

	public ResponseEntity<?> createResponder(@RequestBody Responder responder) {
    	return new ResponseEntity<>(emergencyService.createRespondent(responder), HttpStatus.OK);
	}

	@PostMapping("/add-contact")

	public ResponseEntity<?> addUserToEmergencyList(@RequestBody AddContactRequest addContactRequest) {

    	return new ResponseEntity<>(emergencyService.addUserToEmergencyList(addContactRequest), HttpStatus.OK);
	}

	@PostMapping("/report-incident")

	public ResponseEntity<?> createAndSendIncident(@RequestBody CreateIncidentRequest createIncidentRequest) {

    	return new ResponseEntity<>(emergencyService.createAndSendIncident(createIncidentRequest), HttpStatus.OK);
	}

	@PostMapping("/pick-incident")

	public ResponseEntity<?> pickIncident(@RequestBody PickIncidentRequest pickIncidentRequest) {

    	return new ResponseEntity<>(emergencyService.pickIncident(pickIncidentRequest), HttpStatus.OK);
	}

	@PostMapping("/report-incident-status")

	public ResponseEntity<?> reportIncidentStatus(@RequestBody ReportIncidentRequest reportIncidentRequest) {

    	return new ResponseEntity<>(emergencyService.reportIncidentStatus(reportIncidentRequest), HttpStatus.OK);
	}
}

Die Klasse EmergencyController ist ein Spring MVC-Controller, der für die Bearbeitung von HTTP-Anfragen im Zusammenhang mit Notfallmaßnahmen zuständig ist. Sie ist mit @RequestMapping annotiert, um den Basispfad "/api/" für alle ihre Endpunkte zu definieren.

Der Controller ist von der Klasse EmergencyService abhängig, die mit der Annotation @Autowired autowired ist. Dies ermöglicht dem Controller den Zugriff auf die vom Dienst bereitgestellten Methoden.

Der Controller definiert mehrere HTTP-POST-Endpunkte, die verschiedenen Notfalloperationen entsprechen:

• /create-user: Dieser Endpunkt behandelt die Erstellung eines neuen Benutzers. Er erwartet einen JSON-Payload im Anfragekörper, der die Benutzerdetails enthält. Die Methode createUser() des EmergencyService wird aufgerufen, um den Benutzer zu erstellen, und die Antwort wird in ein ResponseEntity-Objekt mit einem HTTP-Status von 200 (OK) verpackt.

• /erstellen-responder: Dieser Endpunkt behandelt die Erstellung eines neuen Responders. Er erwartet einen JSON-Payload im Request Body, der die Responder-Details enthält. Die Methode createResponder() des EmergencyService wird aufgerufen, um den Responder zu erstellen, und die Antwort wird in ein ResponseEntity-Objekt mit einem HTTP-Status von 200 (OK) verpackt.

• /add-contact: Dieser Endpunkt dient dazu, einen Kontakt zur Liste der Notfallkontakte eines Benutzers hinzuzufügen. Er erwartet einen JSON-Payload im Anfragekörper, der die Benutzer-ID, den Namen und die Telefonnummer des hinzuzufügenden Kontakts enthält. Die Methode addUserToEmergencyList() des EmergencyService wird aufgerufen, um den Kontakt hinzuzufügen, und die Antwort wird in ein ResponseEntity-Objekt mit einem HTTP-Status von 200 (OK) verpackt.

• /vorfall-berichten: Dieser Endpunkt behandelt die Meldung eines Vorfalls. Er erwartet eine JSON-Nutzlast im Anforderungskörper, die die Einzelheiten des Vorfalls enthält. Die Methode createAndSendIncident() des EmergencyService wird aufgerufen, um den Vorfall zu erstellen und zu senden, und die Antwort wird in ein ResponseEntity-Objekt mit einem HTTP-Status von 200 (OK) verpackt.

• /pick-incident: Dieser Endpunkt dient dazu, einen Vorfall zur Bearbeitung durch einen Responder auszuwählen. Er erwartet einen JSON-Payload im Anfragekörper, der die Vorfall-ID und die Responder-ID enthält. Die Methode pickIncident() des EmergencyService wird aufgerufen, um den Vorfall auszuwählen, und die Antwort wird in ein ResponseEntity-Objekt mit einem HTTP-Status von 200 (OK) verpackt.

• /report-incident-status: Dieser Endpunkt dient der Meldung des Status eines Vorfalls. Er erwartet einen JSON-Payload im Anfragekörper, der die Vorfall-ID, die Responder-ID und den Status (z. B. "Abandoned" oder "Resolved") enthält. Die Methode reportIncidentStatus() des EmergencyService wird aufgerufen, um den Status des Vorfalls zu melden, und die Antwort wird in ein ResponseEntity-Objekt mit einem HTTP-Status von 200 (OK) verpackt.

Verbesserung Ihrer Umsetzung

Insgesamt zielte dieses Tutorial darauf ab, die Leistungsfähigkeit der Nachrichten-API von Vonage zu nutzen, wobei der Schwerpunkt auf dem WhatsApp-Kanal lag. Die hier beschriebenen Schritte können für jede andere Vonage-API nachgeahmt werden, und es können sogar weitere Serviceaufrufe für die WhatsApp-API implementiert werden. Wenn beispielsweise ein Vorfall geklärt ist, könnte eine WhatsApp-Benachrichtigung an den Benutzer, der den Vorfall gemeldet hat, und an alle Mitglieder gesendet werden, um ihnen die Sicherheit der Opfer zu versichern.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass das Emergency Response and Location System, das die Vonage Messages API und Java/Spring Boot nutzt, eine effiziente Lösung zur Verbesserung der Notfallmanagement-Funktionen darstellt. Durch die Integration dieser Technologien können Organisationen nahtlose Kommunikationskanäle einrichten und den Standort von Personen in Not verfolgen, was eine schnelle Reaktion und Hilfe in kritischen Situationen ermöglicht. Die Verwendung von Java und Spring Boot im System bietet eine solide Grundlage für den Aufbau eines sicheren und skalierbaren Notfallmanagementsystems. Unter sorgfältiger Berücksichtigung des Datenschutzes und der Einhaltung gesetzlicher Bestimmungen kann dieses System zur Sicherheit und zum Wohlbefinden von Gemeinschaften beitragen.

Durch die Nutzung des Systems können Rettungskräfte schnell den Telefonstandort einer Person ermitteln und so wichtige Informationen für die rasche Entsendung von Hilfe erhalten. Das Java-basierte Codebeispiel zeigt die Integration der Standortverfolgung mit verschiedenen Techniken, einschließlich GPS, netzwerkbasierten Diensten oder APIs von Drittanbietern.

Es ist jedoch zu beachten, dass bei der Implementierung eines solchen Systems die Aspekte des Datenschutzes, der Sicherheit und der Einhaltung gesetzlicher Vorschriften sorgfältig berücksichtigt werden müssen. Der Umgang mit sensiblen Standortdaten und die Sicherstellung einer ordnungsgemäßen Zustimmung und Autorisierung sind entscheidend, um das Vertrauen der Nutzer zu erhalten und die geltenden Vorschriften einzuhalten. Der Code für diesen Artikel ist zu finden hier.