Classes
struct	commitment_transaction
	A storage commitment transaction record. More...

struct	parse_result
	Parse a commitment request from JSON body. More...

class	transaction_store
	In-memory store for commitment transactions. More...

Enumerations
enum class	transaction_state { pending , success , partial , failure }
	Transaction state for DICOMweb Storage Commitment. More...

Functions
std::string_view	to_string (transaction_state state) noexcept
	Convert transaction state to string.

std::optional< transaction_state >	parse_state (std::string_view str) noexcept
	Parse transaction state from string.

std::string	transaction_to_json (const commitment_transaction &txn)
	Serialize a commitment transaction to DICOM JSON.

std::string	transactions_to_json (const std::vector< commitment_transaction > &transactions)
	Serialize a list of transactions to DICOM JSON array.

parse_result	parse_commitment_request (std::string_view json_body, std::string_view study_uid="")

Enumeration Type Documentation

◆ transaction_state

enum class kcenon::pacs::web::storage_commitment::transaction_state

strong

Transaction state for DICOMweb Storage Commitment.

Enumerator
pending	Commitment request received, verification in progress.
success	All referenced instances verified present and intact.
partial	Some instances verified, others failed.
failure	Commitment verification failed.

Definition at line 40 of file storage_commitment_endpoints.h.

                             {
    pending,    
    success,    
    partial,    
    failure     
};

Function Documentation

◆ parse_commitment_request()

parse_result kcenon::pacs::web::storage_commitment::parse_commitment_request	(	std::string_view	json_body,
		std::string_view	study_uid = "" )

nodiscard

Definition at line 222 of file storage_commitment_endpoints.cpp.

                              {
 
    parse_result result;
 
    if (json_body.empty()) {
        result.error_message = "Request body is empty";
        return result;
    }
 
    // Look for referencedSOPSequence array
    auto seq_pos = json_body.find("\"referencedSOPSequence\"");
    if (seq_pos == std::string_view::npos) {
        result.error_message = "Missing referencedSOPSequence in request body";
        return result;
    }
 
    // Find the array start
    auto arr_start = json_body.find('[', seq_pos);
    if (arr_start == std::string_view::npos) {
        result.error_message = "Invalid referencedSOPSequence format";
        return result;
    }
 
    // Find matching array end
    size_t depth = 0;
    size_t arr_end = std::string_view::npos;
    for (size_t i = arr_start; i < json_body.size(); ++i) {
        if (json_body[i] == '[') ++depth;
        else if (json_body[i] == ']') {
            --depth;
            if (depth == 0) {
                arr_end = i;
                break;
            }
        }
    }
 
    if (arr_end == std::string_view::npos) {
        result.error_message = "Unterminated referencedSOPSequence array";
        return result;
    }
 
    // Parse individual items in the array
    auto array_content = json_body.substr(arr_start + 1, arr_end - arr_start - 1);
 
    // Find each object in the array
    size_t pos = 0;
    while (pos < array_content.size()) {
        auto obj_start = array_content.find('{', pos);
        if (obj_start == std::string_view::npos) break;
 
        size_t obj_depth = 0;
        size_t obj_end = std::string_view::npos;
        for (size_t i = obj_start; i < array_content.size(); ++i) {
            if (array_content[i] == '{') ++obj_depth;
            else if (array_content[i] == '}') {
                --obj_depth;
                if (obj_depth == 0) {
                    obj_end = i;
                    break;
                }
            }
        }
 
        if (obj_end == std::string_view::npos) break;
 
        auto obj = array_content.substr(obj_start, obj_end - obj_start + 1);
        auto sop_class = extract_json_string(obj, "sopClassUID");
        auto sop_instance = extract_json_string(obj, "sopInstanceUID");
 
        if (sop_instance.empty()) {
            result.error_message = "Missing sopInstanceUID in reference";
            return result;
        }
 
        result.references.push_back({std::move(sop_class), std::move(sop_instance)});
        pos = obj_end + 1;
    }
 
    if (result.references.empty()) {
        result.error_message = "No valid SOP references found in request";
        return result;
    }
 
    // Ignore study_uid parameter (used for context only)
    (void)study_uid;
 
    result.valid = true;
    return result;
}

References kcenon::pacs::web::storage_commitment::parse_result::error_message, kcenon::pacs::web::storage_commitment::parse_result::references, and kcenon::pacs::web::storage_commitment::parse_result::valid.

Referenced by kcenon::pacs::web::endpoints::register_storage_commitment_endpoints_impl().

Here is the caller graph for this function:

◆ parse_state()

std::optional< transaction_state > kcenon::pacs::web::storage_commitment::parse_state ( std::string_view str )

nodiscardnoexcept

Parse transaction state from string.

Definition at line 53 of file storage_commitment_endpoints.cpp.

                                                                        {
    if (str == "PENDING") return transaction_state::pending;
    if (str == "SUCCESS") return transaction_state::success;
    if (str == "PARTIAL") return transaction_state::partial;
    if (str == "FAILURE") return transaction_state::failure;
    return std::nullopt;
}

References failure, partial, pending, and success.

◆ to_string()

std::string_view kcenon::pacs::web::storage_commitment::to_string ( transaction_state state )

nodiscardnoexcept

Convert transaction state to string.

Definition at line 43 of file storage_commitment_endpoints.cpp.

                                                           {
    switch (state) {
        case transaction_state::pending: return "PENDING";
        case transaction_state::success: return "SUCCESS";
        case transaction_state::partial: return "PARTIAL";
        case transaction_state::failure: return "FAILURE";
    }
    return "UNKNOWN";
}

References failure, partial, pending, and success.

Referenced by transaction_to_json().

Here is the caller graph for this function:

◆ transaction_to_json()

std::string kcenon::pacs::web::storage_commitment::transaction_to_json ( const commitment_transaction & txn )

nodiscard

Serialize a commitment transaction to DICOM JSON.

Parameters

txn	The transaction to serialize

Returns: JSON string

Definition at line 144 of file storage_commitment_endpoints.cpp.

                                                                 {
    std::ostringstream ss;
    ss << R"({"transactionUID":")" << json_escape(txn.transaction_uid) << R"(",)";
    ss << R"("state":")" << to_string(txn.state) << R"(",)";
 
    if (!txn.study_instance_uid.empty()) {
        ss << R"("studyInstanceUID":")" << json_escape(txn.study_instance_uid) << R"(",)";
    }
 
    ss << R"("createdAt":")" << format_timestamp(txn.created_at) << R"(",)";
 
    if (txn.completed_at.has_value()) {
        ss << R"("completedAt":")" << format_timestamp(*txn.completed_at) << R"(",)";
    }
 
    // Requested references
    ss << R"("requestedReferences":[)";
    for (size_t i = 0; i < txn.requested_references.size(); ++i) {
        if (i > 0) ss << ",";
        ss << sop_reference_to_json(txn.requested_references[i]);
    }
    ss << "],";
 
    // Success references
    ss << R"("successReferences":[)";
    for (size_t i = 0; i < txn.success_references.size(); ++i) {
        if (i > 0) ss << ",";
        ss << sop_reference_to_json(txn.success_references[i]);
    }
    ss << "],";
 
    // Failed references
    ss << R"("failedReferences":[)";
    for (size_t i = 0; i < txn.failed_references.size(); ++i) {
        if (i > 0) ss << ",";
        ss << failed_reference_to_json(txn.failed_references[i]);
    }
    ss << "]}";
 
    return ss.str();
}

Referenced by kcenon::pacs::web::endpoints::register_storage_commitment_endpoints_impl(), and transactions_to_json().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transactions_to_json()

std::string kcenon::pacs::web::storage_commitment::transactions_to_json ( const std::vector< commitment_transaction > & transactions )

nodiscard

Serialize a list of transactions to DICOM JSON array.

Parameters

transactions The transactions to serialize

Returns: JSON array string

Definition at line 186 of file storage_commitment_endpoints.cpp.

                                                           {
    std::ostringstream ss;
    ss << "[";
    for (size_t i = 0; i < transactions.size(); ++i) {
        if (i > 0) ss << ",";
        ss << transaction_to_json(transactions[i]);
    }
    ss << "]";
    return ss.str();
}

References transaction_to_json().

Referenced by kcenon::pacs::web::endpoints::register_storage_commitment_endpoints_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Enumerations

Functions

Enumeration Type Documentation

◆ transaction_state

Function Documentation

◆ parse_commitment_request()

◆ parse_state()

◆ to_string()

◆ transaction_to_json()

◆ transactions_to_json()