[FEAT] 동방 현황 기능을 구현합니다.

modules/domain/src/main/java/com/whoz_in/domain/device/DeviceRepository.java

@@ -1,11 +1,13 @@
 package com.whoz_in.domain.device;
 
 import com.whoz_in.domain.device.model.Device;
+import java.util.List;
 import com.whoz_in.domain.device.model.DeviceId;
 import java.util.Optional;
 
 public interface DeviceRepository {
     void save(Device device);
+    List<Device> findAll();
 
     //해당 mac을 포함하는 device를 찾는 메서드
     Optional<Device> findByMac(String mac);

modules/domain/src/main/java/com/whoz_in/domain/member/model/AccountType.java

@@ -17,7 +17,7 @@ public static AccountType findAccountType(String accountType){
         return Arrays.stream(AccountType.values())
                 .filter(at -> at.name().equals(accountType))
                 .findFirst()
-                .orElseThrow(() -> new IllegalArgumentException("no account type"));
+                .orElseThrow(() -> new IllegalStateException("no account type"));
     }
 
 }

modules/domain/src/main/java/com/whoz_in/domain/member/model/SocialProvider.java

@@ -19,7 +19,7 @@ public static SocialProvider findSocialProvider(String socialProvider){
         return Arrays.stream(SocialProvider.values())
                 .filter(provider -> provider.getProviderName().equals(socialProvider))
                 .findFirst()
-                .orElseThrow(() -> new IllegalArgumentException("no social provider"));
+                .orElseThrow(() -> new IllegalStateException("no social provider"));
     }
 
 }

modules/domain/src/main/java/com/whoz_in/domain/network_log/MonitorLogRepository.java

@@ -2,10 +2,14 @@
 
 import java.time.LocalDateTime;
 import java.util.Collection;
+import java.util.List;
 
 public interface MonitorLogRepository {
     void save(MonitorLog log);
     void saveAll(Collection<MonitorLog> logs);
+    List<MonitorLog> findAll();
+    List<MonitorLog> findByUpdatedAtAfterOrderByUpdatedAtDesc(LocalDateTime updatedAt); // 해당 시간 이후의 로그를 가져오기
+    // TODO: 이전 로그까지 가져와야 할까?
     boolean existsAfter(String mac, LocalDateTime time);
     default void mustExistAfter(String mac, LocalDateTime time){
         if (!existsAfter(mac, time))

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/config/ApiQueryJpaConfig.java

@@ -38,6 +38,8 @@ public static class DataSourceProperties {
     @Getter
     @Setter
     public static class HibernateProperties {
+        private String ddlAuto;
+        private String physicalNamingStrategy;
         private boolean formatSql;
         private boolean showSql;
     }
@@ -80,7 +82,9 @@ public LocalContainerEntityManagerFactoryBean apiQueryJpaEntityManagerFactory(
                 .properties(
                         Map.of(
                                 "hibernate.show_sql", hibernateProperties.showSql,
-                                "hibernate.format_sql", hibernateProperties.formatSql
+                                "hibernate.format_sql", hibernateProperties.formatSql,
+                                "hibernate.hbm2ddl.auto", hibernateProperties.ddlAuto,
+                                "hibernate.physical_naming_strategy", hibernateProperties.physicalNamingStrategy
                         )
                 )
                 .build();

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/ActiveDeviceEntity.java

@@ -0,0 +1,58 @@
+package com.whoz_in.api_query_jpa.device;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.Objects;
+import java.util.UUID;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class ActiveDeviceEntity {
+
+    @Id
+    private UUID deviceId;
+
+    @Column(nullable = false)
+    private LocalDateTime connectedTime;
+
+    private LocalDateTime disConnectedTime;
+
+    private Duration totalActiveTime;
+
+    private boolean isActive;
+
+    private ActiveDeviceEntity(UUID deviceId, LocalDateTime connectedTime) {
+        this.deviceId = deviceId;
+        this.connectedTime = connectedTime;
+        this.isActive = true;
+    }
+
+    public void activeOn(LocalDateTime connectedTime){
+        this.isActive = true;
+        this.connectedTime = connectedTime;
+        this.disConnectedTime = null;
+    }
+
+    public void inActiveOn(LocalDateTime disConnectedTime){
+        this.isActive = false;
+        this.disConnectedTime = disConnectedTime;
+        addTotalActiveTime();
+    }
+
+    private void addTotalActiveTime(){
+        Duration add = Duration.between(connectedTime, disConnectedTime).abs();
+        this.totalActiveTime = Objects.nonNull(totalActiveTime) ? totalActiveTime.plus(add) :  add;
+    }
+
+    public static ActiveDeviceEntity create(UUID deviceId, LocalDateTime connectedTime){
+        return new ActiveDeviceEntity(deviceId, connectedTime);
+    }
+
+}

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/ActiveDeviceJpaViewer.java

@@ -0,0 +1,60 @@
+package com.whoz_in.api_query_jpa.device;
+
+import com.whoz_in.api_query_jpa.member.Member;
+import com.whoz_in.api_query_jpa.member.MemberRepository;
+import com.whoz_in.main_api.query.device.application.active.ActiveDevice;
+import com.whoz_in.main_api.query.device.application.active.ActiveDeviceViewer;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class ActiveDeviceJpaViewer implements ActiveDeviceViewer {
+
+    private final ActiveDeviceRepository activeDeviceRepository;
+    private final DeviceRepository deviceRepository;
+    private final MemberRepository memberRepository;
+
+    @Override
+    public Optional<ActiveDevice> findByDeviceId(String deviceId) {
+        ActiveDeviceEntity activeDevice = activeDeviceRepository.findByDeviceId(UUID.fromString(deviceId)).orElse(null);
+        Member member = memberRepository.findByDeviceId(UUID.fromString(deviceId)).orElse(null);
+
+        if(member == null || activeDevice == null) return Optional.empty();
+
+        return createOptionalActiveDevice(activeDevice, member);
+    }
+
+    @Override
+    public List<ActiveDevice> findAll() {
+        List<ActiveDeviceEntity> entities = activeDeviceRepository.findAll();
+        List<UUID> deviceIds = entities.stream().map(ActiveDeviceEntity::getDeviceId).toList();
+        List<Device> devices = deviceRepository.findAll();
+        List<Member> members = memberRepository.findByDeviceIds(deviceIds);
+
+        return entities.stream()
+                .map(entity-> {
+                    Device device = devices.stream().filter(d -> d.getId().equals(entity.getDeviceId())).findFirst().orElse(null);
+                    if(device == null) return null;
+                    Member member = members.stream().filter(m -> m.getId().equals(device.getMemberId())).findFirst().orElse(null);
+                    if (member == null) return null;
+                    return createOptionalActiveDevice(entity, member).orElse(null);
+                })
+                .filter(Objects::nonNull)
+                .toList();
+    }
+
+    private Optional<ActiveDevice> createOptionalActiveDevice(ActiveDeviceEntity entity, Member member){
+        return Optional.of(new ActiveDevice(
+                entity.getDeviceId(),
+                member.getId(),
+                entity.getConnectedTime(),
+                entity.getDisConnectedTime(),
+                entity.getTotalActiveTime(),
+                entity.isActive()));
+    }
+}

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/ActiveDeviceRepository.java

@@ -0,0 +1,13 @@
+package com.whoz_in.api_query_jpa.device;
+
+import java.util.Optional;
+import java.util.UUID;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ActiveDeviceRepository extends JpaRepository<ActiveDeviceEntity, UUID> {
+
+    Optional<ActiveDeviceEntity> findByDeviceId(UUID deviceId);
+
+    void deleteByDeviceId(UUID deviceId);
+
+}

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/Device.java

@@ -2,8 +2,8 @@
 
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
 import jakarta.persistence.Id;
+import jakarta.persistence.FetchType;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.OneToMany;
 import java.util.List;
@@ -33,4 +33,4 @@ public class Device {
     @JoinColumn(name = "device_id", referencedColumnName = "id")
     private List<DeviceInfo> deviceInfos;
 
-}
+}

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/DeviceRepository.java

@@ -3,7 +3,13 @@
 import java.util.List;
 import java.util.UUID;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+public interface DeviceRepository extends JpaRepository<Device, UUID> {
+
+    @Query(nativeQuery = true,
+            value = "SELECT id , member_id FROM device_entity")
+    List<Device> findAll();
 
-public interface DeviceRepository extends JpaRepository<Device, Long> {
     List<Device> findAllByMemberId(UUID ownerId);
 }

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/InMemoryActiveDeviceRepository.java

@@ -0,0 +1,47 @@
+package com.whoz_in.api_query_jpa.device;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@Slf4j
+public class InMemoryActiveDeviceRepository {
+
+    private final Map<UUID, ActiveDeviceEntity> repository;
+
+    public InMemoryActiveDeviceRepository(){
+        this.repository = new ConcurrentHashMap<>();
+    }
+
+    public UUID save(ActiveDeviceEntity device){
+        UUID id = device.getDeviceId();
+        repository.put(id, device); // 갱신된 데이터가 삽입될 수 있도록
+        return device.getDeviceId();
+    }
+
+    public void saveAll(List<ActiveDeviceEntity> devices){
+        devices.forEach(this::save);
+    }
+
+    public List<ActiveDeviceEntity> findAll(){
+        return repository.values().stream().toList();
+    }
+
+    public Optional<ActiveDeviceEntity> findByDeviceId(UUID deviceId){
+        if(repository.containsKey(deviceId))
+            return Optional.of(repository.get(deviceId));
+        return Optional.empty();
+    }
+
+    public void deleteById(UUID deviceId){
+        repository.remove(deviceId);
+    }
+
+
+}

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/event/ActiveDeviceEventHandler.java

@@ -0,0 +1,67 @@
+package com.whoz_in.api_query_jpa.device.event;
+
+import com.whoz_in.api_query_jpa.device.ActiveDeviceEntity;
+import com.whoz_in.api_query_jpa.device.ActiveDeviceRepository;
+import com.whoz_in.api_query_jpa.device.InMemoryActiveDeviceRepository;
+import com.whoz_in.main_api.query.device.application.active.event.ActiveDeviceFinded;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class ActiveDeviceEventHandler {
+
+    private final ActiveDeviceRepository activeDeviceRepository;
+
+    @Transactional(isolation = Isolation.SERIALIZABLE)
+    @EventListener(ActiveDeviceFinded.class)
+    public void saveActiveDevices(ActiveDeviceFinded event) {
+        List<UUID> deviceIds = event.getDevices();
+        List<ActiveDeviceEntity> activeDeviceEntities = activeDeviceRepository.findAll();
+
+        List<UUID> deviceIdFromDB = activeDeviceEntities.stream().map(ActiveDeviceEntity::getDeviceId).toList();
+
+        List<ActiveDeviceEntity> firstActiveDevices = deviceIds.stream()
+                .filter(deviceId -> deviceIdFromDB.stream().noneMatch(idFromDB -> idFromDB.equals(deviceId)))
+                .map(deviceId -> ActiveDeviceEntity.create(deviceId, LocalDateTime.now())) // TODO: active Time 을 이 시점으로 설정해도 될까?
+                .toList();
+
+
+        List<ActiveDeviceEntity> nonFirstActiveDevice = deviceIds.stream()
+                .filter(deviceId -> deviceIdFromDB.stream().anyMatch(idFromDB -> idFromDB.equals(deviceId)))
+                .map(deviceId -> {
+                        return activeDeviceEntities.stream()
+                                    .filter(active -> active.getDeviceId().equals(deviceId))
+                                    .findAny()
+                                    .orElse(null);
+                        })
+                .filter(Objects::nonNull)
+                .toList();
+
+
+        saveFirstActive(firstActiveDevices);
+        saveNonFirstActive(nonFirstActiveDevice);
+    }
+
+    private void saveFirstActive(List<ActiveDeviceEntity> entities){
+        // 처음으로 Active 된 Device 는 그냥 저장 가능
+        activeDeviceRepository.saveAll(entities);
+    }
+
+    private void saveNonFirstActive(List<ActiveDeviceEntity> entities){
+        // 참조를 이용한 JPA 변경 감지 짝퉁
+        entities.forEach(activeDevice -> {
+                    if(!activeDevice.isActive()) activeDevice.activeOn(LocalDateTime.now());
+                });
+    }
+
+}

modules/infrastructure/api-query-jpa/src/main/java/com/whoz_in/api_query_jpa/device/event/InActiveDeviceEventHandler.java

@@ -0,0 +1,36 @@
+package com.whoz_in.api_query_jpa.device.event;
+
+import com.whoz_in.api_query_jpa.device.ActiveDeviceEntity;
+import com.whoz_in.api_query_jpa.device.ActiveDeviceRepository;
+import com.whoz_in.api_query_jpa.device.InMemoryActiveDeviceRepository;
+import com.whoz_in.main_api.query.device.application.active.event.InActiveDeviceFinded;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@RequiredArgsConstructor
+public class InActiveDeviceEventHandler {
+
+    private final ActiveDeviceRepository activeDeviceRepository;
+
+    // ActiveDeviceEvent 핸들러에서 데이터를 수정할 수 있으므로 격리 수준을 serializable 로 설정
+    @Transactional(isolation = Isolation.SERIALIZABLE)
+    @EventListener(InActiveDeviceFinded.class)
+    public void processInActiveDevices(InActiveDeviceFinded event) {
+        // InActiveDevice 찾는 로직
+        List<UUID> devices = event.getDevices();
+        List<ActiveDeviceEntity> entities = activeDeviceRepository.findAll();
+
+        entities.stream()
+                .filter(activeDevice -> devices.stream()
+                        .anyMatch(device -> device.equals(activeDevice.getDeviceId())))
+                .forEach(activeDevice -> activeDevice.inActiveOn(LocalDateTime.now()));
+    }
+
+}