Document Lifecycle Management

// PersonDocument.java
@Entity
@Table(name = "person_documents")
public class PersonDocument {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "person_id", nullable = false)
    private Person person;
    
    @ManyToOne
    @JoinColumn(name = "document_id", nullable = false)
    private DocumentDefinition documentDefinition;
    
    @Enumerated(EnumType.STRING)
    @Column(name = "status")
    private PersonDocumentStatus status; // VIGENTE, VENCIDO, REVOCADO
    
    @Column(name = "issued_at")
    private LocalDate issueDate;
    
    @Column(name = "expires_at")
    private LocalDate expiryDate;
    
    @ManyToOne
    @JoinColumn(name = "issuer_entity_id")
    private IssuingEntity issuerEntity;
    
    // Review workflow fields
    @Enumerated(EnumType.STRING)
    @Column(name = "review_status")
    private ReviewStatus reviewStatus; // PENDING, APPROVED, REJECTED
    
    @Column(name = "reviewed_by_user")
    private Long reviewedByUserId;
    
    @Column(name = "reviewed_at")
    private LocalDateTime reviewedAt;
    
    @Column(name = "review_notes")
    private String reviewNotes;
    
    @OneToMany(mappedBy = "personDocument", cascade = CascadeType.ALL)
    private List<FileRecord> files;
}

// PersonDocumentService.java:107
@Transactional
public PersonDocument create(PersonDocumentRequest request) {
    Person person = personRepository.findById(request.getPersonId())
        .orElseThrow(() -> new IllegalArgumentException("Persona no encontrada"));
    
    DocumentDefinition def = documentDefinitionService.findById(request.getDocumentId())
        .orElseThrow(() -> new IllegalArgumentException("Documento no encontrado"));
    
    PersonDocument pd = new PersonDocument();
    pd.setPerson(person);
    pd.setDocumentDefinition(def);
    pd.setReviewStatus(ReviewStatus.PENDING);
    
    PersonDocument saved = personDocumentRepository.save(pd);
    
    // If storagePath provided, create FileRecord
    if (request.getStoragePath() != null) {
        FileRecord fr = new FileRecord();
        fr.setPersonDocument(saved);
        fr.setStoragePath(request.getStoragePath());
        fr.setHashSha256(request.getHashSha256());
        fr.setStoredAs(FileStoredAs.PATH);
        fileRecordRepository.save(fr);
    }
    
    return saved;
}

// FileStorageService.java
@Service
public class FileStorageService {
    
    @Value("${ccdigital.fs.base-path}")
    private String basePath;
    
    public StoredFileInfo storePersonFile(Person person, MultipartFile file) {
        // Create person folder with normalized name
        String folderName = normalizePersonFolderName(person);
        Path personDir = Paths.get(basePath, folderName);
        Files.createDirectories(personDir);
        
        // Generate unique filename
        String originalName = file.getOriginalFilename();
        String fileName = generateUniqueFileName(originalName);
        Path targetPath = personDir.resolve(fileName);
        
        // Copy file and calculate SHA256
        file.transferTo(targetPath);
        String sha256 = calculateSHA256(targetPath);
        
        // Return relative path from base
        String relativePath = basePath.relativize(targetPath).toString();
        
        return new StoredFileInfo(
            originalName,
            relativePath,
            file.getSize(),
            sha256
        );
    }
}

@Entity
@Table(name = "files")
public class FileRecord {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "person_document_id")
    private PersonDocument personDocument;
    
    @Column(name = "original_name")
    private String originalName;
    
    @Column(name = "mime_type")
    private String mimeType;
    
    @Column(name = "byte_size")
    private Long byteSize;
    
    @Column(name = "hash_sha256")
    private String hashSha256;
    
    @Enumerated(EnumType.STRING)
    @Column(name = "stored_as")
    private FileStoredAs storedAs; // PATH or BLOB
    
    @Column(name = "storage_path")
    private String storagePath;
    
    @Column(name = "version")
    private Integer version;
}