Feature/frb 187

.gitignore

@@ -264,4 +264,5 @@ $RECYCLE.BIN/
 
 *.html
 
-custom-kibana/
+custom-kibana/
+/src/main/resources/fcm_root_key/monitory-28aad-firebase-adminsdk-fbsvc-0d7886e5f5.json

build.gradle

@@ -43,7 +43,7 @@ dependencies {
     implementation 'org.bouncycastle:bcpkix-jdk15on:1.70'
 
     // swagger doc
-    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.5.0'
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.8'
 
     // flyway db
     implementation 'org.flywaydb:flyway-core'
@@ -68,8 +68,9 @@ dependencies {
     implementation 'org.springframework.kafka:spring-kafka'
     testImplementation 'org.springframework.kafka:spring-kafka-test'
 
-    // WebSocket
-    implementation 'org.springframework.boot:spring-boot-starter-websocket'
+    // firebase cloud messaging(FCM)
+    // https://mvnrepository.com/artifact/com.google.firebase/firebase-admin
+    implementation("com.google.firebase:firebase-admin:9.4.3")
 }
 
 tasks.named('test') {

src/main/java/com/factoreal/backend/domain/abnormalLog/api/AbnormalController.java

@@ -1,8 +1,11 @@
 package com.factoreal.backend.domain.abnormalLog.api;
 
 import com.factoreal.backend.domain.abnormalLog.application.AbnormalLogService;
+import com.factoreal.backend.domain.abnormalLog.dto.TargetType;
 import com.factoreal.backend.domain.abnormalLog.dto.request.AbnormalPagingRequest;
 import com.factoreal.backend.domain.abnormalLog.dto.response.AbnormalLogResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
 import org.springframework.http.ResponseEntity;
@@ -11,23 +14,26 @@
 @RestController
 @RequestMapping("/api/abnormal")
 @RequiredArgsConstructor
+@Tag(name = "상태 로그 조회 API", description = "작업자/환경/설비 이상의 로그를 조회하는 API")
 public class AbnormalController {
-
     private final AbnormalLogService abnormalLogService;
 
     // 전체 로그 조회
     @GetMapping
+    @Operation(summary = "전체 로그 조회", description = "페이징 인자를 기준으로 로그를 요정 개수 만큼 반환해줍니다.")
     public Page<AbnormalLogResponse> getAllAbnormalLogs(@ModelAttribute AbnormalPagingRequest pagingDto) {
         return abnormalLogService.findAllAbnormalLogs(pagingDto);
     }
 
     @GetMapping("/unread")
+    @Operation(summary = "미확인 로그 조회", description = "페이징 인자를 기준으로 읽지 않은 로그를 요정 개수 만큼 반환해줍니다.")
     public Page<AbnormalLogResponse> getAllAbnormalLogsUnRead(@ModelAttribute AbnormalPagingRequest pagingDto) {
         return abnormalLogService.findAllAbnormalLogsUnRead(pagingDto);
     }
 
     // 특정 이상 유형으로 필터링
     @GetMapping("/type/{abnormalType}")
+    @Operation(summary = "위험별 로그 조회", description = "페이징 인자를 기준으로 위험별 로그를 요정 개수 만큼 반환해줍니다.")
     public Page<AbnormalLogResponse> getAbnormalLogsByType(
             @ModelAttribute AbnormalPagingRequest pagingDto,
             @PathVariable String abnormalType) {
@@ -36,22 +42,25 @@ public Page<AbnormalLogResponse> getAbnormalLogsByType(
 
     // 특정 타겟 ID로 필터링
     @GetMapping("/target/{targetType}/{targetId}")
+    @Operation(summary = "유형별 로그 조회", description = "페이징 인자를 기준으로 유형별 로그를 요정 개수 만큼 반환해줍니다.")
     public Page<AbnormalLogResponse> getAbnormalLogsByTarget(
             @ModelAttribute AbnormalPagingRequest pagingDto,
-            @PathVariable String targetType,
+            @PathVariable TargetType targetType,
             @PathVariable String targetId) {
         return abnormalLogService.findAbnormalLogsByTargetId(pagingDto, targetType, targetId);
     }
 
     // 알람 읽음 처리
     @PostMapping("/{abnormalId}/read")
+    @Operation(summary = "로그 읽음 처리", description = "abnormalId와 일치하는 로그를 읽음 처리합니다.")
     public ResponseEntity<Void> markAlarmAsRead(@PathVariable Long abnormalId) {
         boolean success = abnormalLogService.readCheck(abnormalId);
         return success ? ResponseEntity.ok().build() : ResponseEntity.notFound().build();
     }
-
+    // 웹 페이지 첫 렌더링 시 호출되는 api
     // 읽지 않은 알람 개수 반환 -> websocket으로 전부 보내주기
     @GetMapping("/unread-count")
+    @Operation(summary = "미확인 로그 개수 조회", description = "미확인 로그 개수를 반환합니다. 페이지이 첫 렌더링 시(웹소켓으로 정보를 받기전) 호출합니다.")
     public ResponseEntity<Long> getUnreadAlarmCount() {
         Long count = abnormalLogService.readRequired();
         return ResponseEntity.ok(count);

src/main/java/com/factoreal/backend/domain/abnormalLog/application/AbnormalLogService.java

@@ -1,16 +1,20 @@
 package com.factoreal.backend.domain.abnormalLog.application;
 
-import com.factoreal.backend.domain.abnormalLog.dto.LogType;
+import com.factoreal.backend.domain.abnormalLog.dao.AbnLogRepository;
+import com.factoreal.backend.domain.abnormalLog.dto.TargetType;
 import com.factoreal.backend.domain.abnormalLog.dto.request.AbnormalPagingRequest;
 import com.factoreal.backend.domain.abnormalLog.dto.response.AbnormalLogResponse;
-import com.factoreal.backend.domain.sensor.dto.SensorKafkaDto;
 import com.factoreal.backend.domain.abnormalLog.entity.AbnormalLog;
-import com.factoreal.backend.domain.zone.dao.ZoneRepository;
+import com.factoreal.backend.domain.sensor.dto.SensorKafkaDto;
+import com.factoreal.backend.domain.zone.application.ZoneHistoryService;
+import com.factoreal.backend.domain.zone.application.ZoneService;
 import com.factoreal.backend.domain.zone.entity.Zone;
-import com.factoreal.backend.domain.abnormalLog.dao.AbnLogRepository;
+import com.factoreal.backend.domain.zone.entity.ZoneHist;
+import com.factoreal.backend.messaging.kafka.dto.WearableKafkaDto;
 import com.factoreal.backend.messaging.kafka.strategy.alarmMessage.RiskMessageProvider;
 import com.factoreal.backend.messaging.kafka.strategy.enums.RiskLevel;
 import com.factoreal.backend.messaging.kafka.strategy.enums.SensorType;
+import com.factoreal.backend.messaging.kafka.strategy.enums.WearableDataType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -23,28 +27,36 @@
 import org.springframework.web.server.ResponseStatusException;
 
 import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Objects;
 
 @Service
 @Slf4j
 @RequiredArgsConstructor
 public class AbnormalLogService {
     private final AbnLogRepository abnLogRepository;
-    private final ZoneRepository zoneRepository;
+    private final ZoneService zoneService;
     private final RiskMessageProvider riskMessageProvider;
     private final ObjectMapper objectMapper;
-
-    // 알람 객체를 받아와서 로그 객체 생성.
+    private final ZoneHistoryService zoneHistoryService;
+
+    /**
+     * 센서 데이터 기반의 알람 로그 생성.
+     * @param sensorKafkaDto kafka에서 EQUIPMENT 및 ENVIRONMENT 토픽으로 들어오는 DTO
+     * @param sensorType 센서 종류: current, dust, temp, humid, vibration, voc
+     * @param riskLevel 위험 레벨: 시스템 로그에 저장할 메세지를 조회하기 위해 필요(센서별 위험도에 해당되는 메세지)
+     * @param targetType 타겟 종류 : Sensor(공간), Worker(작업자), Equip(설비-머신러닝)
+     * @return
+     * @throws Exception
+     */
     @Transactional(rollbackFor = Exception.class)
-    public AbnormalLog saveAbnormalLogFromKafkaDto(
-                                                        SensorKafkaDto sensorKafkaDto,
-                                                        SensorType sensorType,
-                                                        RiskLevel riskLevel,
-                                                        LogType targetType
-                                                ) throws Exception{
-
-
-        Zone zone = zoneRepository.findByZoneId(sensorKafkaDto.getZoneId());
-
+    public AbnormalLog saveAbnormalLogFromSensorKafkaDto(
+            SensorKafkaDto sensorKafkaDto,
+            SensorType sensorType,
+            RiskLevel riskLevel,
+            TargetType targetType
+    ) throws Exception{
+        Zone zone = zoneService.findByZoneId(sensorKafkaDto.getZoneId());
 
         if (zone == null) {
             throw new ResponseStatusException(HttpStatus.NOT_FOUND, "존재하지 않는 공간 ID: " + sensorKafkaDto.getZoneId());
@@ -58,8 +70,9 @@ public AbnormalLog saveAbnormalLogFromKafkaDto(
         AbnormalLog abnormalLog = AbnormalLog.builder()
                 .targetId(sensorKafkaDto.getSensorId())
                 .targetType(targetType)
-                .abnormalType(riskMessageProvider.getMessage(sensorType,riskLevel))
+                .abnormalType(riskMessageProvider.getRiskMessageBySensor(sensorType,riskLevel))
                 .abnVal(sensorKafkaDto.getVal())
+                .dangerLevel(riskLevel.getPriority())
                 .zone(zone)
                 .detectedAt(LocalDateTime.parse(sensorKafkaDto.getTime()))
                 .isRead(false)
@@ -68,63 +81,76 @@ public AbnormalLog saveAbnormalLogFromKafkaDto(
         return abnLogRepository.save(abnormalLog);
     }
 
+    /**
+     * 센서 데이터 기반의 알람 로그 생성.
+     * @param wearableKafkaDto kafka에서 WEARABLE 토픽으로 들어오는 DTO
+     * @param wearableDataType 생체 데이터 종류: 현재는 heartRate 만 보내는 중(확장성 고려해서 해당 객체 사용)
+     * @param riskLevel 위험 레벨: 시스템 로그에 저장할 메세지를 조회하기 위해 필요(생체 데이터 별 위험도에 해당되는 메세지)
+     * @param targetType 타겟 종류 : Sensor(공간), Worker(작업자), Equip(설비-머신러닝)
+     * @return
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public AbnormalLog saveAbnormalLogFromWearableKafkaDto(
+            WearableKafkaDto wearableKafkaDto,
+            WearableDataType wearableDataType,
+            RiskLevel riskLevel,
+            TargetType targetType
+    ){
+        // workerId에 해당되는 사람이 제일 최근에 있던 공간 조회
+        ZoneHist zonehist = zoneHistoryService.
+                findByWorker_WorkerIdAndExistFlag(wearableKafkaDto.getWorkerId(), 1);
+        Zone zone;
+        if (zonehist == null){
+            zone = zoneService.findByZoneId("00000000000000-000");
+        }else{
+            zone = zonehist.getZone();
+        }
+
+        AbnormalLog abnormalLog = AbnormalLog.builder()
+                .targetId(wearableKafkaDto.getWearableDeviceId())
+                .targetType(targetType)
+                .abnormalType(riskMessageProvider.getRiskMessageByWearble(wearableDataType,riskLevel))
+                .abnVal(Double.valueOf(wearableKafkaDto.getVal()))
+                .detectedAt(LocalDateTime.parse(wearableKafkaDto.getTime()))
+                .dangerLevel(riskLevel.getPriority())
+                .zone(zone)
+                .isRead(false)
+                .build();
+       return abnLogRepository.save(abnormalLog);
+    }
 
     public Page<AbnormalLogResponse> findAllAbnormalLogs(AbnormalPagingRequest abnormalPagingDto) {
         // 한번에 DB전체를 주는 것이 아닌 구간 나눠서 전달하기 위함
         Pageable pageable = getPageable(abnormalPagingDto);
         Page<AbnormalLog> abnormalLogs = abnLogRepository.findAll(pageable);
-        return abnormalLogs.map(abn_log ->
-                AbnormalLogResponse.builder()
-                        .id(abn_log.getId())
-                        .targetType(abn_log.getTargetType())
-                        .targetId(abn_log.getTargetId())
-                        .abnormalType(abn_log.getAbnormalType())
-                        .abnVal(abn_log.getAbnVal())
-                        .detectedAt(abn_log.getDetectedAt())
-                        .zoneId(abn_log.getZone().getZoneId())
-                        .zoneName(abn_log.getZone().getZoneName())
-                        .build()
-        );
+        return abnormalLogs.map(AbnormalLog::fromEntity);
     }
 
     public Page<AbnormalLogResponse> findAllAbnormalLogsUnRead(AbnormalPagingRequest abnormalPagingRequest) {
         // 한번에 DB전체를 주는 것이 아닌 구간 나눠서 전달하기 위함
         Pageable pageable = getPageable(abnormalPagingRequest);
-        Page<AbnormalLog> abnormalLogs = abnLogRepository.findAllByIsReadIsFalse(pageable);
-        return abnormalLogs.map(abn_log ->
-                AbnormalLogResponse.builder()
-                        .id(abn_log.getId())
-                        .targetType(abn_log.getTargetType())
-                        .targetId(abn_log.getTargetId())
-                        .abnormalType(abn_log.getAbnormalType())
-                        .abnVal(abn_log.getAbnVal())
-                        .detectedAt(abn_log.getDetectedAt())
-                        .zoneId(abn_log.getZone().getZoneId())
-                        .zoneName(abn_log.getZone().getZoneName())
-                        .build()
-        );
+        Page<AbnormalLog> abnormalLogs = abnLogRepository.findAllByIsReadIsFalseOrderByDetectedAtDesc(pageable);
+        return abnormalLogs.map(AbnormalLog::fromEntity);
     }
 
     public Page<AbnormalLogResponse> findAbnormalLogsByAbnormalType(AbnormalPagingRequest abnormalPagingRequest, String abnormalType){
         // 한번에 DB전체를 주는 것이 아닌 구간 나눠서 전달하기 위함
         Pageable pageable = getPageable(abnormalPagingRequest);
         Page<AbnormalLog> abnormalLogs = abnLogRepository.findAbnormalLogsByAbnormalType(abnormalType,pageable);
-        return abnormalLogs.map(abn_log ->
-                AbnormalLogResponse.builder()
-                        .id(abn_log.getId())
-                        .targetType(abn_log.getTargetType())
-                        .targetId(abn_log.getTargetId())
-                        .abnormalType(abn_log.getAbnormalType())
-                        .abnVal(abn_log.getAbnVal())
-                        .detectedAt(abn_log.getDetectedAt())
-                        .zoneId(abn_log.getZone().getZoneId())
-                        .zoneName(abn_log.getZone().getZoneName())
-                        .build()
-        );
+        return abnormalLogs.map(AbnormalLog::fromEntity);
     }
 
-    //
-    public Page<AbnormalLogResponse> findAbnormalLogsByTargetId(AbnormalPagingRequest abnormalPagingRequest, String targetType, String targetId){
+    public List<AbnormalLogResponse> findLatestAbnormalLogsForTargets(TargetType targetType, List<String> targetIds) {
+        return targetIds.stream()
+            .map(targetId ->
+                abnLogRepository.findFirstByTargetTypeAndTargetIdOrderByDetectedAtDesc(targetType, targetId)
+                    .map(AbnormalLog::fromEntity) // 또는 objectMapper.convertValue(...)
+                    .orElse(null) // 값이 없으면 null
+            )
+            .filter(Objects::nonNull) // null 제거
+            .toList();
+    }
+    public Page<AbnormalLogResponse> findAbnormalLogsByTargetId(AbnormalPagingRequest abnormalPagingRequest, TargetType targetType, String targetId){
         // 한번에 DB전체를 주는 것이 아닌 구간 나눠서 전달하기 위함
         Pageable pageable = getPageable(abnormalPagingRequest);
         Page<AbnormalLog> abnormalLogs = abnLogRepository.findAbnormalLogsByTargetTypeAndTargetId(

src/main/java/com/factoreal/backend/domain/abnormalLog/dao/AbnLogRepository.java

@@ -1,17 +1,24 @@
 package com.factoreal.backend.domain.abnormalLog.dao;
 
+import com.factoreal.backend.domain.abnormalLog.dto.TargetType;
 import com.factoreal.backend.domain.abnormalLog.entity.AbnormalLog;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 
+import java.util.Optional;
+
 public interface AbnLogRepository extends JpaRepository<AbnormalLog,Long> {
     Page<AbnormalLog> findAbnormalLogsByAbnormalType(String abnormalType, Pageable pageable);
 
-    Page<AbnormalLog> findAbnormalLogsByTargetTypeAndTargetId(String targetType, String targetId, Pageable pageable);
+    Page<AbnormalLog> findAbnormalLogsByTargetTypeAndTargetId(TargetType targetType, String targetId, Pageable pageable);
+    // Pageable 객체 없이도 사용할 수 있도록 오버라이딩
+    Optional<AbnormalLog> findFirstByTargetTypeAndTargetIdOrderByDetectedAtDesc(TargetType targetType, String targetId);
+
+
     long countByIsReadFalse(); // 읽지 않은 로그의 개수 반환
 
-    Page<AbnormalLog> findAllByIsReadIsFalse(Pageable pageable);
+    Page<AbnormalLog> findAllByIsReadIsFalseOrderByDetectedAtDesc(Pageable pageable);
 
     // zoneId로 페이징 처리된 로그 조회
     Page<AbnormalLog> findByZone_ZoneIdOrderByDetectedAtDesc(String zoneId, Pageable pageable);

src/main/java/com/factoreal/backend/domain/abnormalLog/dto/LogType.java → src/main/java/com/factoreal/backend/domain/abnormalLog/dto/TargetType.java

@@ -1,6 +1,6 @@
 package com.factoreal.backend.domain.abnormalLog.dto;
 
-public enum LogType {
+public enum TargetType {
     Sensor,
     Worker,
     Equip

src/main/java/com/factoreal/backend/domain/abnormalLog/dto/response/AbnormalLogResponse.java

@@ -1,6 +1,6 @@
 package com.factoreal.backend.domain.abnormalLog.dto.response;
 
-import com.factoreal.backend.domain.abnormalLog.dto.LogType;
+import com.factoreal.backend.domain.abnormalLog.dto.TargetType;
 import lombok.Builder;
 import lombok.Data;
 
@@ -10,10 +10,11 @@
 @Builder
 public class AbnormalLogResponse {
     private Long id;
-    private LogType targetType;
+    private TargetType targetType;
     private String targetId;
     private String abnormalType;
     private Double abnVal;
+    private Integer dangerLevel;
     private LocalDateTime detectedAt;
     private String zoneId;       // zone 정보를 자세히 담고 싶으면 zoneName 등 추가 가능
     private String zoneName;   // 예: "공장 A의 2번 존"