backend/src/main/java/ru/diplom/vision/service/ExternalInspectionImportService.java - master - Sturon/Diplom

backend/src/main/java/ru/diplom/vision/service/ExternalInspectionImportService.java
115 строк5 KB
Sturon
Initial
03 июн 2026, 15:01
03 июн 2026, 15:0117b44a2
package ru.diplom.vision.service;

import java.time.LocalDateTime;
import java.util.List;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.server.ResponseStatusException;
import ru.diplom.vision.api.dto.ExternalDefectRequest;
import ru.diplom.vision.api.dto.ExternalInspectionRequest;
import ru.diplom.vision.domain.DetectedDefect;
import ru.diplom.vision.domain.InspectionItem;
import ru.diplom.vision.domain.InspectionProfile;
import ru.diplom.vision.domain.InspectionStatus;
import ru.diplom.vision.repository.InspectionItemRepository;
import static org.springframework.http.HttpStatus.BAD_REQUEST;
import static org.springframework.http.HttpStatus.NOT_FOUND;

@Service
@Transactional
public class ExternalInspectionImportService {

    private final InspectionProfileService inspectionProfileService;
    private final StorageService storageService;
    private final InspectionItemRepository inspectionItemRepository;

    public ExternalInspectionImportService(
            InspectionProfileService inspectionProfileService,
            StorageService storageService,
            InspectionItemRepository inspectionItemRepository
    ) {
        this.inspectionProfileService = inspectionProfileService;
        this.storageService = storageService;
        this.inspectionItemRepository = inspectionItemRepository;
    }

    public InspectionItem importResult(ExternalInspectionRequest request, MultipartFile image, MultipartFile annotatedImage) {
        if (image == null || image.isEmpty()) {
            throw new ResponseStatusException(BAD_REQUEST, "Файл кадра обязателен");
        }

        InspectionItem item = resolveInspectionItem(request);
        InspectionProfile profile = item.getProfile();
        StorageService.StoredFileDescriptor sourceImage = storageService.storeUploadedImage(
                "inspection-items/raw",
                image,
                profile.getName() + "-external"
        );

        item.setInspectedAt(LocalDateTime.now());
        item.setStatus(Boolean.TRUE.equals(request.result()) ? InspectionStatus.OK : InspectionStatus.DEFECT);
        item.setSourceImagePath(sourceImage.relativePath());
        if (annotatedImage != null && !annotatedImage.isEmpty()) {
            item.setAnnotatedImagePath(storageService.storeUploadedImage(
                    "inspection-items/annotated",
                    annotatedImage,
                    profile.getName() + "-annotated-external"
            ).relativePath());
        } else {
            item.setAnnotatedImagePath(null);
        }
        item.setDefectCount(request.defectCount());
        item.setProcessingTimeMs(request.processingTimeMs());
        item.setSummary(request.summary());
        item.getDefects().clear();

        List<ExternalDefectRequest> defects = request.defects() == null ? List.of() : request.defects();
        for (ExternalDefectRequest defectRequest : defects) {
            DetectedDefect defect = new DetectedDefect();
            defect.setDefectType(defectRequest.defectType());
            defect.setRoiName(defectRequest.roiName());
            defect.setRoiOrder(defectRequest.roiOrder());
            defect.setConfidence(defectRequest.confidence());
            defect.setX(defectRequest.x());
            defect.setY(defectRequest.y());
            defect.setWidth(defectRequest.width());
            defect.setHeight(defectRequest.height());
            defect.setNotes(defectRequest.notes());
            item.addDefect(defect);
        }

        return inspectionItemRepository.save(item);
    }

    @Transactional(readOnly = true)
    public InspectionItem getPendingForCamera(Long cameraId) {
        return inspectionItemRepository.findPendingByCameraId(cameraId).stream()
                .findFirst()
                .orElseThrow(() -> new ResponseStatusException(NOT_FOUND, "Нет ожидающих проверок для камеры"));
    }

    private InspectionItem resolveInspectionItem(ExternalInspectionRequest request) {
        if (request.inspectionItemId() != null) {
            InspectionItem item = inspectionItemRepository.findById(request.inspectionItemId())
                    .orElseThrow(() -> new ResponseStatusException(NOT_FOUND, "Проверка не найдена"));
            if (item.getStatus() != InspectionStatus.PENDING) {
                throw new ResponseStatusException(BAD_REQUEST, "Проверка уже завершена");
            }
            return item;
        }

        if (request.profileId() == null) {
            throw new ResponseStatusException(BAD_REQUEST, "profileId обязателен, если inspectionItemId не задан");
        }

        InspectionProfile profile = inspectionProfileService.getRequired(request.profileId());
        if (!profile.isAnalysisEnabled()) {
            throw new ResponseStatusException(BAD_REQUEST, "Анализатор для точки контроля не запущен");
        }

        InspectionItem item = new InspectionItem();
        item.setProfile(profile);
        return item;
    }
}