Blockchain Audit Trail

// FabricLedgerCliService.java:82
public String listDocsRaw(String idType, String idNumber) {
    List<String> cmd = List.of(nodeBin, listDocsScript, idType, idNumber);
    
    ExternalToolsService.ExecResult res = externalToolsService.exec(cmd, fabricWorkdir, Map.of());
    
    if (res.getExitCode() != 0) {
        throw new RuntimeException("Fabric listDocs falló (exit=" + res.getExitCode() + "): " 
                                  + res.getStderr());
    }
    return res.getStdout();
}

node list-docs.js <idType> <idNumber>

// FabricLedgerCliService.java:115
public List<FabricDocView> listDocsView(String idType, String idNumber) {
    try {
        String stdout = listDocsRaw(idType, idNumber);
        String json = extractJsonArray(stdout); // Extracts first [...] from output
        
        List<Map<String, Object>> items = mapper.readValue(
            json, new TypeReference<List<Map<String, Object>>>() {}
        );
        
        return items.stream().map(m -> {
            String docId = asString(m.get("docId"));
            String title = asString(m.get("title"));
            String issuingEntity = asString(m.get("issuingEntity"));
            String filePath = asString(m.get("filePath"));
            Long sizeBytes = asLong(m.get("sizeBytes"));
            String createdAt = asString(m.get("createdAt"));
            
            return new FabricDocView(
                docId, title, issuingEntity, null, createdAt, sizeBytes, filePath
            );
        }).toList();
        
    } catch (Exception e) {
        throw new RuntimeException("No se pudo parsear listDocs desde Fabric", e);
    }
}

public record FabricDocView(
    String docId,
    String title,
    String issuingEntity,
    String status,
    String createdAtHuman,
    Long sizeBytes,
    String filePath
) {
    public String sizeHuman() {
        if (sizeBytes == null) return "N/A";
        return formatBytes(sizeBytes);
    }
}

// FabricAuditCliService.java
@Service
public class FabricAuditCliService {
    
    public record AuditCommand(
        String idType,              // Person's ID type
        String idNumber,            // Person's ID number
        String eventType,           // Event classification
        Long accessRequestId,       // Related access request (if any)
        Long personDocumentId,      // Related document (if any)
        String fabricDocId,         // Fabric ledger doc reference
        String documentTitle,       // Human-readable doc title
        Long entityId,              // Actor entity ID
        String entityName,          // Actor entity name
        String action,              // Technical action name
        String result,              // OK or FAIL
        String reason,              // Explanation or error detail
        String actorType,           // ISSUER, USER, ADMIN, SYSTEM
        String actorId,             // Actor identifier
        String source               // CCDIGITAL_SPRING, etc.
    ) {}
    
    public void recordEvent(AuditCommand cmd) {
        List<String> command = List.of(
            nodeBin,
            recordAccessScript,
            cmd.idType(),
            cmd.idNumber(),
            cmd.eventType(),
            String.valueOf(cmd.accessRequestId()),
            // ... all other parameters
        );
        
        ExternalToolsService.ExecResult result = 
            externalToolsService.exec(command, fabricWorkdir, Map.of());
        
        if (result.getExitCode() != 0) {
            throw new RuntimeException(
                "Fabric audit recording failed: " + result.getStderr()
            );
        }
    }
}

// BlockchainTraceDetailService.java
@Service
public class BlockchainTraceDetailService {
    
    public Map<String, Object> getBlockDetailByRef(String blockRef) {
        List<String> cmd = List.of(nodeBin, blockReaderScript, blockRef);
        
        ExternalToolsService.ExecResult res = 
            externalToolsService.exec(cmd, fabricWorkdir, Map.of());
        
        if (res.getExitCode() != 0) {
            throw new RuntimeException("Failed to read block: " + res.getStderr());
        }
        
        String json = extractJsonObject(res.getStdout());
        return objectMapper.readValue(json, new TypeReference<Map<String, Object>>() {});
    }
}

// AccessRequestService.java:426
@Transactional(readOnly = true)
public DocumentBlockchainTrace loadApprovedDocumentBlockchainTrace(
        Long entityId, Long requestId, Long personDocumentId) {
    
    // ... authorization checks ...
    
    PersonDocument pd = personDocumentRepository.findByIdWithFiles(personDocumentId)
        .orElseThrow(() -> new IllegalArgumentException("Documento no encontrado"));
    
    FileRecord latest = findLatestFile(pd);
    List<FabricDocView> fabricDocs = loadFabricDocsForPerson(request.getPerson());
    
    FabricDocView fabricDoc = findMatchingFabricDoc(fabricDocs, pd, latest)
        .orElseThrow(() -> new IllegalArgumentException(
            "No se encontró la referencia del documento en Fabric para esta solicitud."
        ));
    
    // Record trace query audit event
    recordAuditStrict(request, pd, fabricDoc, "DOC_BLOCK_TRACE_QUERY", "OK",
                     "Consulta de detalle blockchain de documento autorizado",
                     "READ_BLOCK_TRACE", "ISSUER", String.valueOf(entityId));
    
    return new DocumentBlockchainTrace(
        "Hyperledger Fabric",
        fabricDoc.docId(),
        fabricDoc.title(),
        fabricDoc.issuingEntity(),
        fabricDoc.status(),
        fabricDoc.createdAtHuman(),
        fabricDoc.sizeHuman(),
        "documento",
        fabricDoc.filePath()
    );
}

// FabricAuditCliService.java
public List<Map<String, Object>> listAccessEvents(String idType, String idNumber, Integer limit) {
    List<String> cmd = new ArrayList<>();
    cmd.add(nodeBin);
    cmd.add(listAccessScript);
    cmd.add(idType);
    cmd.add(idNumber);
    if (limit != null) {
        cmd.add(String.valueOf(limit));
    }
    
    ExternalToolsService.ExecResult res = externalToolsService.exec(cmd, fabricWorkdir, Map.of());
    
    if (res.getExitCode() != 0) {
        throw new RuntimeException("Failed to list access events: " + res.getStderr());
    }
    
    String json = extractJsonArray(res.getStdout());
    return objectMapper.readValue(json, new TypeReference<List<Map<String, Object>>>() {});
}

// AdminReportService.java
public AuditTrailReport generateAuditTrailReport(String idType, String idNumber) {
    List<Map<String, Object>> events = fabricAuditCliService.listAccessEvents(idType, idNumber, 100);
    
    // Aggregate by event type, actor, time period, etc.
    return buildAuditReport(events);
}

// AccessRequestService.java:643
private Optional<FabricDocView> findMatchingFabricDoc(List<FabricDocView> fabricDocs,
                                                      PersonDocument pd,
                                                      FileRecord latest) {
    String dbRelativePath = normalizePath(latest.getStoragePath());
    String title = pd.getDocumentDefinition() != null 
                   ? pd.getDocumentDefinition().getTitle() 
                   : null;
    
    return fabricDocs.stream()
        .filter(Objects::nonNull)
        .filter(doc -> matchesFilePath(doc.filePath(), dbRelativePath) 
                    || matchesTitle(doc.title(), title))
        .findFirst();
}

private boolean matchesFilePath(String fabricPath, String dbRelativePath) {
    if (fabricPath == null || dbRelativePath == null) return false;
    
    String fabricNorm = normalizePath(fabricPath);
    String dbNorm = normalizePath(dbRelativePath);
    
    // Exact match or suffix match (handles absolute vs relative paths)
    return fabricNorm.equals(dbNorm)
        || fabricNorm.endsWith("/" + dbNorm)
        || fabricNorm.endsWith(dbNorm);
}