query_scp.cpp

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include "kcenon/pacs/services/query_scp.h"
 
#include "kcenon/pacs/core/dicom_tag_constants.h"
#include "kcenon/pacs/core/events.h"
#include "kcenon/pacs/core/result.h"
#include "kcenon/pacs/network/dimse/command_field.h"
#include "kcenon/pacs/network/dimse/status_codes.h"
#include "kcenon/pacs/security/atna_service_auditor.h"
 
#include <kcenon/common/patterns/event_bus.h>
 
namespace kcenon::pacs::services {
 
namespace {
// Convert services::query_level to events::query_level
kcenon::pacs::events::query_level to_event_level(query_level level) {
    switch (level) {
        case query_level::patient: return kcenon::pacs::events::query_level::patient;
        case query_level::study: return kcenon::pacs::events::query_level::study;
        case query_level::series: return kcenon::pacs::events::query_level::series;
        case query_level::image: return kcenon::pacs::events::query_level::image;
        default: return kcenon::pacs::events::query_level::patient;
    }
}
}  // namespace
 
// =============================================================================
// Construction
// =============================================================================
 
query_scp::query_scp(std::shared_ptr<di::ILogger> logger)
    : scp_service(std::move(logger)) {}
 
// =============================================================================
// Configuration
// =============================================================================
 
void query_scp::set_handler(query_handler handler) {
    handler_ = std::move(handler);
}
 
void query_scp::set_max_results(size_t max) noexcept {
    max_results_ = max;
}
 
size_t query_scp::max_results() const noexcept {
    return max_results_;
}
 
void query_scp::set_cancel_check(cancel_check check) {
    cancel_check_ = std::move(check);
}
 
void query_scp::set_audit_handler(
    std::shared_ptr<kcenon::pacs::security::atna_service_auditor> auditor) {
    auditor_ = std::move(auditor);
}
 
// =============================================================================
// scp_service Interface Implementation
// =============================================================================
 
std::vector<std::string> query_scp::supported_sop_classes() const {
    return {
        std::string(patient_root_find_sop_class_uid),
        std::string(study_root_find_sop_class_uid)
    };
}
 
network::Result<std::monostate> query_scp::handle_message(
    network::association& assoc,
    uint8_t context_id,
    const network::dimse::dimse_message& request) {
 
    using namespace network::dimse;
    auto start_time = std::chrono::steady_clock::now();
    std::string calling_ae{assoc.calling_ae()};
 
    // Verify the message is a C-FIND request
    if (request.command() != command_field::c_find_rq) {
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::find_unexpected_command,
            "Expected C-FIND-RQ but received " +
            std::string(to_string(request.command())));
    }
 
    // Verify we have a handler
    if (!handler_) {
        kcenon::common::get_event_bus().publish(
            kcenon::pacs::events::query_failed_event{
                calling_ae,
                static_cast<int>(kcenon::pacs::error_codes::find_handler_not_set),
                "No query handler configured"
            }
        );
        return kcenon::pacs::pacs_void_error(
            kcenon::pacs::error_codes::find_handler_not_set,
            "No query handler configured");
    }
 
    // Get the SOP Class UID from the request
    auto sop_class_uid = request.affected_sop_class_uid();
 
    // Verify we have a dataset
    if (!request.has_dataset()) {
        return send_final_response(
            assoc, context_id, request.message_id(),
            sop_class_uid, status_error_cannot_understand);
    }
 
    // Extract query level
    const auto& query_keys = request.dataset().value().get();
    auto level = extract_query_level(query_keys);
 
    if (!level.has_value()) {
        // Invalid or missing query level
        return send_final_response(
            assoc, context_id, request.message_id(),
            sop_class_uid, status_error_cannot_understand);
    }
 
    // Call the handler to get matching results
    auto results = handler_(level.value(), query_keys, calling_ae);
 
    // Apply max results limit if configured
    if (max_results_ > 0 && results.size() > max_results_) {
        results.resize(max_results_);
    }
 
    // Send pending responses for each result
    for (const auto& result : results) {
        // Check for cancel request
        if (cancel_check_ && cancel_check_()) {
            // Increment statistics
            ++queries_processed_;
 
            // Send cancel response
            return send_final_response(
                assoc, context_id, request.message_id(),
                sop_class_uid, status_cancel);
        }
 
        // Send pending response with matching dataset
        auto send_result = send_pending_response(
            assoc, context_id, request.message_id(),
            sop_class_uid, result);
 
        if (send_result.is_err()) {
            return send_result;
        }
    }
 
    // Increment statistics
    ++queries_processed_;
 
    // Calculate execution time
    auto end_time = std::chrono::steady_clock::now();
    auto execution_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time).count();
 
    // Publish query executed event
    kcenon::common::get_event_bus().publish(
        kcenon::pacs::events::query_executed_event{
            to_event_level(level.value()),
            calling_ae,
            results.size(),
            static_cast<uint64_t>(execution_time_ms)
        }
    );
 
    // Emit ATNA audit event
    if (auditor_) {
        auditor_->audit_query(
            calling_ae,
            std::string(assoc.called_ae()),
            std::string(to_string(level.value())),
            true);
    }
 
    // Send final success response (no dataset)
    return send_final_response(
        assoc, context_id, request.message_id(),
        sop_class_uid, status_success);
}
 
std::string_view query_scp::service_name() const noexcept {
    return "Query SCP";
}
 
// =============================================================================
// Statistics
// =============================================================================
 
size_t query_scp::queries_processed() const noexcept {
    return queries_processed_.load();
}
 
void query_scp::reset_statistics() noexcept {
    queries_processed_ = 0;
}
 
// =============================================================================
// Private Implementation
// =============================================================================
 
std::optional<query_level> query_scp::extract_query_level(
    const core::dicom_dataset& dataset) const {
 
    // Get Query/Retrieve Level tag (0008,0052)
    auto level_str = dataset.get_string(core::tags::query_retrieve_level);
 
    if (level_str.empty()) {
        return std::nullopt;
    }
 
    return parse_query_level(level_str);
}
 
network::Result<std::monostate> query_scp::send_pending_response(
    network::association& assoc,
    uint8_t context_id,
    uint16_t message_id,
    std::string_view sop_class_uid,
    const core::dicom_dataset& result) {
 
    using namespace network::dimse;
 
    // Create C-FIND response with pending status
    auto response = make_c_find_rsp(
        message_id,
        sop_class_uid,
        status_pending
    );
 
    // Attach the matching dataset
    response.set_dataset(result);
 
    // Send the response
    return assoc.send_dimse(context_id, response);
}
 
network::Result<std::monostate> query_scp::send_final_response(
    network::association& assoc,
    uint8_t context_id,
    uint16_t message_id,
    std::string_view sop_class_uid,
    network::dimse::status_code status) {
 
    using namespace network::dimse;
 
    // Create C-FIND response with final status (no dataset)
    auto response = make_c_find_rsp(
        message_id,
        sop_class_uid,
        status
    );
 
    // Send the response
    return assoc.send_dimse(context_id, response);
}
 
}  // namespace kcenon::pacs::services