dev add monitoring basic

2026-02-27 17:57:55 +07:00
parent 76aa04e174
commit c09a3a3a18
21 changed files with 815 additions and 7 deletions
@@ -0,0 +1,101 @@
+package ru.soune.nocopy.service.monitoring;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.soune.nocopy.dto.BaseResponse;
+import ru.soune.nocopy.dto.monitoring.MonitoringStatusResponse;
+import ru.soune.nocopy.entity.file.*;
+import ru.soune.nocopy.entity.monitoring.FileMonitoringEntity;
+import ru.soune.nocopy.entity.monitoring.MonitoringType;
+import ru.soune.nocopy.exception.NotValidFieldException;
+import ru.soune.nocopy.exception.UserNotHavePermission;
+import ru.soune.nocopy.repository.FileEntityRepository;
+import ru.soune.nocopy.repository.FileMonitoringRepository;
+import ru.soune.nocopy.repository.FoundViolationRepository;
+
+import java.io.FileNotFoundException;
+import java.time.LocalDateTime;
+import java.time.temporal.TemporalAdjusters;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class FileMonitoringService {
+
+    private final FileMonitoringRepository monitoringRepository;
+    private final FileEntityRepository fileRepository;
+    private final FoundViolationRepository violationRepository;
+
+    @Transactional
+    public FileMonitoringEntity setMonitoring(Long userId, String fileId, MonitoringType type) throws FileNotFoundException {
+        FileEntity file = fileRepository.findById(fileId)
+                .orElseThrow(() -> new FileNotFoundException(fileId));
+
+        if (!file.getUserId().equals(userId)) {
+            throw new UserNotHavePermission("User not Have permission for file");
+        }
+
+        FileMonitoringEntity monitoring = monitoringRepository.findByFileId(fileId)
+                .orElse(FileMonitoringEntity.builder()
+                        .file(file)
+                        .userId(userId)
+                        .build());
+
+        monitoring.setMonitoringType(type);
+        monitoring.setActive(type != MonitoringType.NONE);
+        monitoring.setNextRun(calculateNextRun(type, LocalDateTime.now()));
+        monitoring.setUpdatedAt(LocalDateTime.now());
+
+        if (monitoring.getCreatedAt() == null) {
+            monitoring.setCreatedAt(LocalDateTime.now());
+        }
+
+        return monitoringRepository.save(monitoring);
+    }
+
+    @Transactional
+    public void updateNextRun(FileMonitoringEntity monitoring) {
+        if (monitoring.isActive() && monitoring.getMonitoringType() != MonitoringType.NONE) {
+            LocalDateTime nextRun = calculateNextRun(monitoring.getMonitoringType(), LocalDateTime.now());
+            monitoring.setNextRun(nextRun);
+            monitoringRepository.save(monitoring);
+        }
+    }
+
+
+    private LocalDateTime calculateNextRun(MonitoringType type, LocalDateTime from) {
+        LocalDateTime nextRun = from.withHour(2).withMinute(0).withSecond(0).withNano(0);
+
+        if (from.isAfter(nextRun)) {
+            nextRun = nextRun.plusDays(1);
+        }
+
+        return switch (type) {
+            case MONITORING_DAILY -> nextRun;
+            case MONITORING_WEEKLY -> nextRun.with(TemporalAdjusters.nextOrSame(java.time.DayOfWeek.MONDAY));
+            case MONITORING_MONTHLY -> nextRun.with(TemporalAdjusters.firstDayOfNextMonth());
+            case NONE -> null;
+        };
+    }
+
+    public MonitoringStatusResponse getMonitoringStatus(String fileId, Long userId) {
+        FileMonitoringEntity monitoring = monitoringRepository.findByFileId(fileId).orElse(null);
+        FileEntity file = fileRepository.findById(fileId).orElseThrow();
+
+        long newViolations = violationRepository.countNewByUserId(userId);
+
+        return MonitoringStatusResponse.builder()
+                .fileId(fileId)
+                .fileName(file.getOriginalFileName())
+                .monitoringType(monitoring != null ? monitoring.getMonitoringType() : MonitoringType.NONE)
+                .nextRun(monitoring != null ? monitoring.getNextRun() : null)
+                .lastRun(monitoring != null ? monitoring.getLastRun() : null)
+                .lastRunStatus(monitoring != null ? monitoring.getLastRunStatus() : null)
+                .isActive(monitoring != null && monitoring.isActive())
+                .newViolationsCount(newViolations)
+                .build();
+    }
+
+}
@@ -0,0 +1,130 @@
+package ru.soune.nocopy.service.monitoring;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import ru.soune.nocopy.dto.file.YandexSearchResponse;
+import ru.soune.nocopy.entity.file.*;
+import ru.soune.nocopy.entity.monitoring.FileMonitoringEntity;
+import ru.soune.nocopy.entity.monitoring.FoundViolationEntity;
+import ru.soune.nocopy.entity.monitoring.MonitoringType;
+import ru.soune.nocopy.entity.monitoring.SearchEngine;
+import ru.soune.nocopy.repository.FileMonitoringRepository;
+import ru.soune.nocopy.repository.FoundViolationRepository;
+import ru.soune.nocopy.service.search.SearchImageService;
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.TimeoutException;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class MonitoringSearchService {
+
+    private final SearchImageService searchImageService;
+    private final FoundViolationRepository violationRepository;
+    private final FileMonitoringRepository monitoringRepository;
+
+    @Transactional
+    public void processFileSearch(FileMonitoringEntity monitoring) {
+        String searchSessionId = UUID.randomUUID().toString();
+        log.info("Starting search session: {} for file: {}", searchSessionId, monitoring.getFile().getId());
+
+        monitoring.setLastRun(LocalDateTime.now());
+        monitoring.setLastRunStatus("IN_PROGRESS");
+        monitoringRepository.save(monitoring);
+
+        try {
+            String yandexResponse = searchImageService.searchReverseByPublicUrl(
+                    monitoring.getFile(), "yandex_reverse_image", "visual_matches");
+
+            List<YandexSearchResponse.ImageResult> yandexImages =
+                    searchImageService.getAllImagesWithoutPagination(yandexResponse, "visual_matches");
+
+            int savedCount = saveFoundImages(monitoring, yandexImages, SearchEngine.YANDEX, searchSessionId);
+
+            try {
+                String googleResponse = searchImageService.searchReverseByPublicUrl(
+                        monitoring.getFile(), "google_lens", "exact_matches");
+
+                List<YandexSearchResponse.ImageResult> googleImages =
+                        searchImageService.getAllImagesWithoutPagination(googleResponse, "exact_matches");
+
+                savedCount += saveFoundImages(monitoring, googleImages, SearchEngine.GOOGLE, searchSessionId);
+
+            } catch (TimeoutException | IOException e) {
+                log.warn("Google search failed for session: {}", searchSessionId, e);
+            }
+
+            monitoring.setLastRunStatus("SUCCESS - Found " + savedCount + " violations");
+
+        } catch (Exception e) {
+            log.error("Search failed for session: {}", searchSessionId, e);
+            monitoring.setLastRunStatus("ERROR: " + e.getMessage());
+        } finally {
+            updateNextRun(monitoring);
+            monitoringRepository.save(monitoring);
+        }
+    }
+
+    private int saveFoundImages(FileMonitoringEntity monitoring,
+                                List<YandexSearchResponse.ImageResult> images,
+                                SearchEngine engine,
+                                String sessionId) {
+        int savedCount = 0;
+
+        for (YandexSearchResponse.ImageResult image : images) {
+            List<FoundViolationEntity> existing = violationRepository.findDuplicate(
+                    monitoring.getFile().getId(), image.getUrl());
+
+            if (existing.isEmpty()) {
+                FoundViolationEntity violation = FoundViolationEntity.builder()
+                        .file(monitoring.getFile())
+                        .fileId(monitoring.getFile().getId())
+                        .fileName(monitoring.getFile().getOriginalFileName())
+                        .userId(monitoring.getUserId())
+                        .foundUrl(image.getUrl())
+                        .pageUrl(image.getPageUrl())
+                        .pageTitle(image.getPageTitle())
+                        .host(image.getHost())
+                        .imageWidth(image.getWidth())
+                        .imageHeight(image.getHeight())
+                        .searchEngine(engine)
+                        .searchSessionId(sessionId)
+                        .isNew(true)
+                        .isNotified(false)
+                        .build();
+
+                violationRepository.save(violation);
+                savedCount++;
+            }
+        }
+
+        return savedCount;
+    }
+
+    private void updateNextRun(FileMonitoringEntity monitoring) {
+        LocalDateTime nextRun = calculateNextRun(monitoring.getMonitoringType());
+        monitoring.setNextRun(nextRun);
+    }
+
+    private LocalDateTime calculateNextRun(MonitoringType type) {
+        LocalDateTime now = LocalDateTime.now();
+        LocalDateTime nextRun = now.withHour(2).withMinute(0).withSecond(0).withNano(0);
+
+        if (now.isAfter(nextRun)) {
+            nextRun = nextRun.plusDays(1);
+        }
+
+        return switch (type) {
+            case MONITORING_DAILY -> nextRun;
+            case MONITORING_WEEKLY -> nextRun.plusWeeks(1);
+            case MONITORING_MONTHLY -> nextRun.plusMonths(1);
+            default -> null;
+        };
+    }
+}
@@ -160,6 +160,10 @@ public class AuthService {
        return authTokenRepository.save(genereateAuthToken(user));
    }

+    public AuthToken getAuthToken(String token) {
+        return authTokenRepository.findByToken(token).get();
+    }
+
    private AuthToken genereateAuthToken(User user) {
        AuthToken authToken = new AuthToken();
        authToken.setToken(generateAuthToken());
@@ -220,6 +220,37 @@ public class TariffInitializationService {
                tariff.setMaxUsers(0L);
                tariff.setTariffAccountType("token");
                break;
+
+
+            case MONITORING_DAILY:
+                tariff.setName("monitoring_daily");
+                tariff.setPrice(0);
+                tariff.setTokens(10);
+                tariff.setMaxFilesCount(0);
+                tariff.setDiskSize(0L);
+                tariff.setMaxUsers(0L);
+                tariff.setTariffAccountType("monitoring");
+                break;
+
+            case MONITORING_WEEKLY:
+                tariff.setName("monitoring_weekly");
+                tariff.setPrice(0);
+                tariff.setTokens(25);
+                tariff.setMaxFilesCount(0);
+                tariff.setDiskSize(0L);
+                tariff.setMaxUsers(0L);
+                tariff.setTariffAccountType("monitoring");
+                break;
+
+            case MONITORING_MONTHLY:
+                tariff.setName("monitoring_monthly");
+                tariff.setPrice(0);
+                tariff.setTokens(50);
+                tariff.setMaxFilesCount(0);
+                tariff.setDiskSize(0L);
+                tariff.setMaxUsers(0L);
+                tariff.setTariffAccountType("monitoring");
+                break;
        }

        tariffRepository.save(tariff);