598 lines
20 KiB
PHP
598 lines
20 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Models\LoRaMessage;
|
|
use App\Models\VibrationReading;
|
|
use App\Models\PirReading;
|
|
use App\Models\DoorAccessReading;
|
|
use App\Models\Device;
|
|
use App\Services\NotificationService;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Illuminate\Support\Facades\Http;
|
|
|
|
class LoRaProcessingService
|
|
{
|
|
protected $notificationService;
|
|
|
|
public function __construct(NotificationService $notificationService)
|
|
{
|
|
$this->notificationService = $notificationService;
|
|
}
|
|
|
|
/**
|
|
* Process inbound LoRa message
|
|
*/
|
|
public function processInboundMessage(LoRaMessage $message): array
|
|
{
|
|
try {
|
|
// Parse payload
|
|
$parsedData = $message->parsePayload();
|
|
|
|
// Update message dengan parsed data
|
|
$message->update([
|
|
'parsed_data' => $parsedData
|
|
]);
|
|
|
|
$result = ['success' => false, 'action' => 'none'];
|
|
|
|
// Process berdasarkan message type
|
|
switch ($message->message_type) {
|
|
case 'sensor_data':
|
|
$result = $this->processSensorData($message, $parsedData);
|
|
break;
|
|
|
|
case 'heartbeat':
|
|
$result = $this->processHeartbeat($message, $parsedData);
|
|
break;
|
|
|
|
case 'ack':
|
|
$result = $this->processAcknowledgment($message, $parsedData);
|
|
break;
|
|
|
|
default:
|
|
$result = ['success' => true, 'action' => 'logged'];
|
|
}
|
|
|
|
// Mark message as processed
|
|
$message->markAsProcessed($result['success'], $result['error'] ?? null);
|
|
|
|
Log::info("LoRa message processed", [
|
|
'message_id' => $message->id,
|
|
'node_id' => $message->node_id,
|
|
'message_type' => $message->message_type,
|
|
'result' => $result
|
|
]);
|
|
|
|
return $result;
|
|
|
|
} catch (\Exception $e) {
|
|
$message->markAsProcessed(false, $e->getMessage());
|
|
|
|
Log::error("LoRa message processing failed", [
|
|
'message_id' => $message->id,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
|
|
return ['success' => false, 'error' => $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process sensor data dari LoRa message
|
|
*/
|
|
private function processSensorData(LoRaMessage $message, array $parsedData): array
|
|
{
|
|
if (!isset($parsedData['sensor_type'])) {
|
|
return ['success' => false, 'error' => 'Missing sensor type'];
|
|
}
|
|
|
|
$sensorType = strtoupper($parsedData['sensor_type']);
|
|
|
|
switch ($sensorType) {
|
|
case 'VIBRATION':
|
|
return $this->processVibrationData($message, $parsedData);
|
|
|
|
case 'PIR':
|
|
return $this->processPirData($message, $parsedData);
|
|
|
|
case 'DOOR':
|
|
return $this->processDoorAccessData($message, $parsedData);
|
|
|
|
default:
|
|
return ['success' => false, 'error' => 'Unknown sensor type: ' . $sensorType];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process vibration sensor data
|
|
*/
|
|
private function processVibrationData(LoRaMessage $message, array $data): array
|
|
{
|
|
try {
|
|
// Normalisasi field — JSON ESP32 bisa kirim "x" atau "x_axis"
|
|
$xAxis = (float) ($data['x_axis'] ?? $data['x'] ?? 0);
|
|
$yAxis = (float) ($data['y_axis'] ?? $data['y'] ?? 0);
|
|
$zAxis = (float) ($data['z_axis'] ?? $data['z'] ?? 0);
|
|
|
|
$magnitude = sqrt(pow($xAxis, 2) + pow($yAxis, 2) + pow($zAxis, 2));
|
|
$threshold = (float) ($data['threshold'] ?? 2.0);
|
|
$isAbnormal = $magnitude > $threshold;
|
|
|
|
$status = 'normal';
|
|
if ($magnitude > $threshold * 1.5) {
|
|
$status = 'critical';
|
|
} elseif ($magnitude > $threshold) {
|
|
$status = 'warning';
|
|
}
|
|
|
|
// Resolve device_id
|
|
$deviceId = $message->device_id ?? Device::where('is_active', true)->first()?->id ?? Device::first()?->id;
|
|
|
|
if (!$deviceId) {
|
|
return ['success' => false, 'error' => 'No device found'];
|
|
}
|
|
|
|
// Simpan ke VibrationReading
|
|
$vibrationReading = VibrationReading::create([
|
|
'device_id' => $deviceId,
|
|
'x_axis' => $xAxis,
|
|
'y_axis' => $yAxis,
|
|
'z_axis' => $zAxis,
|
|
'magnitude' => $magnitude,
|
|
'is_abnormal' => $isAbnormal,
|
|
'threshold' => $threshold,
|
|
'status' => $status,
|
|
'metadata' => [
|
|
'lora_message_id' => $message->id,
|
|
'node_id' => $message->node_id,
|
|
'rssi' => $message->rssi,
|
|
'snr' => $message->snr,
|
|
'source' => 'lora',
|
|
],
|
|
'recorded_at' => $message->received_at ?? now(),
|
|
]);
|
|
|
|
Device::markOnline($deviceId);
|
|
|
|
return [
|
|
'success' => true,
|
|
'action' => 'vibration_data_saved',
|
|
'vibration_reading_id' => $vibrationReading->id,
|
|
'magnitude' => $magnitude,
|
|
'status' => $status,
|
|
'is_abnormal' => $isAbnormal,
|
|
];
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => 'Vibration processing failed: ' . $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process PIR sensor data
|
|
*/
|
|
private function processPirData(LoRaMessage $message, array $data): array
|
|
{
|
|
try {
|
|
$isAuthorizedTime = $this->checkAuthorizedTime();
|
|
|
|
// Normalisasi field — JSON ESP32 bisa kirim "motion" atau "motion_detected"
|
|
$motionDetected = filter_var(
|
|
$data['motion_detected'] ?? $data['motion'] ?? false,
|
|
FILTER_VALIDATE_BOOLEAN
|
|
);
|
|
|
|
$isSuspicious = $this->determineSuspiciousPirMotion($data, $isAuthorizedTime);
|
|
|
|
$motionType = 'normal';
|
|
if (!$isAuthorizedTime) {
|
|
$motionType = 'unauthorized';
|
|
} elseif ($isSuspicious) {
|
|
$motionType = 'suspicious';
|
|
}
|
|
|
|
// Resolve device_id — gunakan dari message atau fallback
|
|
$deviceId = $message->device_id ?? Device::where('is_active', true)->first()?->id ?? Device::first()?->id;
|
|
|
|
if (!$deviceId) {
|
|
return ['success' => false, 'error' => 'No device found'];
|
|
}
|
|
|
|
// Simpan ke PirReading
|
|
$pirReading = PirReading::create([
|
|
'device_id' => $deviceId,
|
|
'motion_detected' => $motionDetected,
|
|
'motion_intensity' => (int) ($data['motion_intensity'] ?? ($motionDetected ? 50 : 0)),
|
|
'duration_seconds' => (int) ($data['duration_seconds'] ?? 0),
|
|
'is_authorized_time' => $isAuthorizedTime,
|
|
'is_suspicious' => $isSuspicious,
|
|
'motion_type' => $motionType,
|
|
'detection_zone' => $data['detection_zone'] ?? 'center',
|
|
'metadata' => [
|
|
'lora_message_id' => $message->id,
|
|
'node_id' => $message->node_id,
|
|
'rssi' => $message->rssi,
|
|
'snr' => $message->snr,
|
|
'source' => 'lora',
|
|
],
|
|
'recorded_at' => $message->received_at ?? now(),
|
|
]);
|
|
|
|
Device::markOnline($deviceId);
|
|
|
|
return [
|
|
'success' => true,
|
|
'action' => 'pir_data_saved',
|
|
'pir_reading_id' => $pirReading->id,
|
|
'motion_type' => $motionType,
|
|
'is_suspicious' => $isSuspicious,
|
|
];
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => 'PIR processing failed: ' . $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process door access sensor data
|
|
*/
|
|
private function processDoorAccessData(LoRaMessage $message, array $data): array
|
|
{
|
|
try {
|
|
$isAuthorizedTime = $this->checkAuthorizedTime();
|
|
|
|
// Normalisasi field — JSON ESP32 bisa kirim "door", "door_opened", atau "door_open"
|
|
$doorOpened = filter_var(
|
|
$data['door_opened'] ?? $data['door'] ?? $data['door_open'] ?? false,
|
|
FILTER_VALIDATE_BOOLEAN
|
|
);
|
|
|
|
$isAuthorizedAccess = $this->determineAuthorizedDoorAccess($data, $isAuthorizedTime);
|
|
$isSuspicious = $this->determineSuspiciousDoorAccess($data, $isAuthorizedAccess);
|
|
$accessType = $this->determineDoorAccessType($data, $isAuthorizedAccess, $isAuthorizedTime);
|
|
|
|
// Resolve device_id
|
|
$deviceId = $message->device_id ?? Device::where('is_active', true)->first()?->id ?? Device::first()?->id;
|
|
|
|
if (!$deviceId) {
|
|
return ['success' => false, 'error' => 'No device found'];
|
|
}
|
|
|
|
// Simpan ke DoorAccessReading
|
|
$doorReading = DoorAccessReading::create([
|
|
'device_id' => $deviceId,
|
|
'door_opened' => $doorOpened,
|
|
'is_authorized_access'=> $isAuthorizedAccess,
|
|
'access_type' => $accessType,
|
|
'access_method' => $data['access_method'] ?? 'unknown',
|
|
'user_id_card' => $data['user_id_card'] ?? null,
|
|
'duration_seconds' => (int) ($data['duration_seconds'] ?? 0),
|
|
'is_suspicious' => $isSuspicious,
|
|
'door_location' => $data['door_location'] ?? 'main_entrance',
|
|
'is_forced_entry' => ($data['access_method'] ?? '') === 'force',
|
|
'metadata' => [
|
|
'lora_message_id' => $message->id,
|
|
'node_id' => $message->node_id,
|
|
'rssi' => $message->rssi,
|
|
'snr' => $message->snr,
|
|
'source' => 'lora',
|
|
],
|
|
'recorded_at' => $message->received_at ?? now(),
|
|
]);
|
|
|
|
Device::markOnline($deviceId);
|
|
|
|
return [
|
|
'success' => true,
|
|
'action' => 'door_access_data_saved',
|
|
'door_reading_id' => $doorReading->id,
|
|
'access_type' => $accessType,
|
|
'is_suspicious' => $isSuspicious,
|
|
];
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => 'Door access processing failed: ' . $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process heartbeat message
|
|
*/
|
|
private function processHeartbeat(LoRaMessage $message, array $data): array
|
|
{
|
|
try {
|
|
// Update device last seen
|
|
if ($message->device) {
|
|
$message->device->update([
|
|
'last_seen' => $message->received_at ?? now(),
|
|
'status' => 'online'
|
|
]);
|
|
}
|
|
|
|
// Check battery level untuk alert
|
|
$batteryLevel = $data['battery_level'] ?? null;
|
|
if ($batteryLevel !== null && $batteryLevel < 20) {
|
|
$this->sendLowBatteryAlert($message, $batteryLevel);
|
|
}
|
|
|
|
return [
|
|
'success' => true,
|
|
'action' => 'heartbeat_processed',
|
|
'battery_level' => $batteryLevel,
|
|
'signal_strength' => $data['signal_strength'] ?? null,
|
|
'uptime' => $data['uptime_seconds'] ?? null
|
|
];
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => 'Heartbeat processing failed: ' . $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process acknowledgment message
|
|
*/
|
|
private function processAcknowledgment(LoRaMessage $message, array $data): array
|
|
{
|
|
try {
|
|
$commandId = $data['command_id'] ?? null;
|
|
|
|
if ($commandId) {
|
|
// Cari outbound message yang sesuai
|
|
$outboundMessage = LoRaMessage::where('direction', 'outbound')
|
|
->where('metadata->command_id', $commandId)
|
|
->first();
|
|
|
|
if ($outboundMessage) {
|
|
$outboundMessage->markAsAcknowledged();
|
|
}
|
|
}
|
|
|
|
return [
|
|
'success' => true,
|
|
'action' => 'acknowledgment_processed',
|
|
'command_id' => $commandId,
|
|
'ack_status' => $data['ack_status'] ?? 'unknown'
|
|
];
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => 'ACK processing failed: ' . $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Transmit message ke LoRa gateway
|
|
*/
|
|
public function transmitMessage(LoRaMessage $message): array
|
|
{
|
|
try {
|
|
// Implementasi tergantung jenis LoRa gateway yang digunakan
|
|
// Contoh untuk HTTP-based gateway
|
|
|
|
$gatewayUrl = config('lora.gateway_url', 'http://localhost:8080/lora/send');
|
|
|
|
$payload = [
|
|
'node_id' => $message->node_id,
|
|
'payload' => $message->payload,
|
|
'spreading_factor' => $message->spreading_factor ?? 7,
|
|
'frequency' => $message->frequency ?? 868.1,
|
|
'tx_power' => 14
|
|
];
|
|
|
|
// Kirim ke gateway (simulasi)
|
|
Log::info("LoRa message would be transmitted", [
|
|
'gateway_url' => $gatewayUrl,
|
|
'payload' => $payload
|
|
]);
|
|
|
|
// TODO: Implementasi actual transmission
|
|
/*
|
|
$response = Http::timeout(10)->post($gatewayUrl, $payload);
|
|
|
|
if ($response->successful()) {
|
|
$message->update(['status' => 'transmitted']);
|
|
return ['success' => true, 'gateway_response' => $response->json()];
|
|
} else {
|
|
$message->update(['status' => 'failed']);
|
|
return ['success' => false, 'error' => 'Gateway transmission failed'];
|
|
}
|
|
*/
|
|
|
|
// Simulasi sukses
|
|
$message->update(['status' => 'transmitted']);
|
|
return ['success' => true, 'simulated' => true];
|
|
|
|
} catch (\Exception $e) {
|
|
$message->update(['status' => 'failed', 'error_message' => $e->getMessage()]);
|
|
|
|
Log::error("LoRa transmission failed", [
|
|
'message_id' => $message->id,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
|
|
return ['success' => false, 'error' => $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send low battery alert
|
|
*/
|
|
private function sendLowBatteryAlert(LoRaMessage $message, int $batteryLevel): void
|
|
{
|
|
try {
|
|
Log::warning("Low battery alert", [
|
|
'node_id' => $message->node_id,
|
|
'battery_level' => $batteryLevel,
|
|
'rssi' => $message->rssi
|
|
]);
|
|
|
|
// TODO: Implementasi notification untuk low battery
|
|
// $this->notificationService->sendLowBatteryAlert($message, $batteryLevel);
|
|
|
|
} catch (\Exception $e) {
|
|
Log::error("Failed to send low battery alert: " . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check authorized time (jam kerja)
|
|
*/
|
|
private function checkAuthorizedTime(): bool
|
|
{
|
|
$hour = now()->hour;
|
|
return $hour >= 8 && $hour < 17;
|
|
}
|
|
|
|
/**
|
|
* Determine suspicious PIR motion
|
|
*/
|
|
private function determineSuspiciousPirMotion(array $data, bool $isAuthorizedTime): bool
|
|
{
|
|
if (!$isAuthorizedTime) {
|
|
return true;
|
|
}
|
|
|
|
$intensity = $data['motion_intensity'] ?? 0;
|
|
$duration = $data['duration_seconds'] ?? 0;
|
|
|
|
return $intensity > 80 || $duration > 300;
|
|
}
|
|
|
|
/**
|
|
* Determine authorized door access
|
|
*/
|
|
private function determineAuthorizedDoorAccess(array $data, bool $isAuthorizedTime): bool
|
|
{
|
|
$method = $data['access_method'] ?? 'unknown';
|
|
$idCard = $data['user_id_card'] ?? null;
|
|
|
|
if ($method === 'force') {
|
|
return false;
|
|
}
|
|
|
|
if ($method === 'emergency') {
|
|
return true;
|
|
}
|
|
|
|
if ($method === 'keycard' && $idCard && preg_match('/^EMP-\d{4}$/', $idCard)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determine suspicious door access
|
|
*/
|
|
private function determineSuspiciousDoorAccess(array $data, bool $isAuthorizedAccess): bool
|
|
{
|
|
if (!$isAuthorizedAccess) {
|
|
return true;
|
|
}
|
|
|
|
$duration = $data['duration_seconds'] ?? 0;
|
|
return $duration > 180;
|
|
}
|
|
|
|
/**
|
|
* Determine door access type
|
|
*/
|
|
private function determineDoorAccessType(array $data, bool $isAuthorizedAccess, bool $isAuthorizedTime): string
|
|
{
|
|
$method = $data['access_method'] ?? 'unknown';
|
|
|
|
if ($method === 'force') {
|
|
return 'forced_entry';
|
|
}
|
|
|
|
if ($method === 'emergency') {
|
|
return 'emergency';
|
|
}
|
|
|
|
if ($method === 'maintenance') {
|
|
return 'maintenance';
|
|
}
|
|
|
|
if ($isAuthorizedAccess && $isAuthorizedTime) {
|
|
return 'authorized';
|
|
}
|
|
|
|
if (!$isAuthorizedTime) {
|
|
return 'after_hours';
|
|
}
|
|
|
|
return 'unauthorized';
|
|
}
|
|
|
|
/**
|
|
* Send command to LoRa node
|
|
*/
|
|
public function sendCommandToNode(string $nodeId, string $action, array $parameters = []): array
|
|
{
|
|
try {
|
|
$commandId = uniqid('CMD_');
|
|
$payload = LoRaMessage::generateCommandPayload($action, $parameters, $commandId);
|
|
|
|
$message = LoRaMessage::create([
|
|
'node_id' => $nodeId,
|
|
'gateway_id' => 'GATEWAY_001',
|
|
'direction' => 'outbound',
|
|
'message_type' => 'command',
|
|
'payload' => $payload,
|
|
'status' => 'pending',
|
|
'metadata' => [
|
|
'command_id' => $commandId,
|
|
'action' => $action,
|
|
'parameters' => $parameters
|
|
],
|
|
'transmitted_at' => now()
|
|
]);
|
|
|
|
$result = $this->transmitMessage($message);
|
|
|
|
return array_merge($result, [
|
|
'message_id' => $message->id,
|
|
'command_id' => $commandId
|
|
]);
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => $e->getMessage()];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send configuration to LoRa node
|
|
*/
|
|
public function sendConfigToNode(string $nodeId, string $parameter, $value): array
|
|
{
|
|
try {
|
|
$configId = uniqid('CFG_');
|
|
$payload = LoRaMessage::generateConfigPayload($parameter, $value, $configId);
|
|
|
|
$message = LoRaMessage::create([
|
|
'node_id' => $nodeId,
|
|
'gateway_id' => 'GATEWAY_001',
|
|
'direction' => 'outbound',
|
|
'message_type' => 'config',
|
|
'payload' => $payload,
|
|
'status' => 'pending',
|
|
'metadata' => [
|
|
'config_id' => $configId,
|
|
'parameter' => $parameter,
|
|
'value' => $value
|
|
],
|
|
'transmitted_at' => now()
|
|
]);
|
|
|
|
$result = $this->transmitMessage($message);
|
|
|
|
return array_merge($result, [
|
|
'message_id' => $message->id,
|
|
'config_id' => $configId
|
|
]);
|
|
|
|
} catch (\Exception $e) {
|
|
return ['success' => false, 'error' => $e->getMessage()];
|
|
}
|
|
}
|
|
} |