#include <ups_push_scu.h>

Collaboration diagram for kcenon::pacs::services::ups_push_scu:

Public Member Functions
	ups_push_scu (std::shared_ptr< di::ILogger > logger=nullptr)
	Construct UPS Push SCU with default configuration.

	ups_push_scu (const ups_push_scu_config &config, std::shared_ptr< di::ILogger > logger=nullptr)
	Construct UPS Push SCU with custom configuration.

	~ups_push_scu ()=default

	ups_push_scu (const ups_push_scu &)=delete

ups_push_scu &	operator= (const ups_push_scu &)=delete

	ups_push_scu (ups_push_scu &&)=delete

ups_push_scu &	operator= (ups_push_scu &&)=delete

network::Result< ups_result >	create (network::association &assoc, const ups_create_data &data)
	Create a new UPS workitem on the remote SCP (N-CREATE)

network::Result< ups_result >	set (network::association &assoc, const ups_set_data &data)
	Modify an existing UPS workitem (N-SET)

network::Result< ups_result >	get (network::association &assoc, const ups_get_data &data)
	Retrieve UPS workitem attributes from remote SCP (N-GET)

network::Result< ups_result >	change_state (network::association &assoc, const ups_change_state_data &data)
	Change UPS workitem state (N-ACTION Type 1)

network::Result< ups_result >	request_cancel (network::association &assoc, const ups_request_cancel_data &data)
	Request cancellation of a UPS workitem (N-ACTION Type 3)

size_t	creates_performed () const noexcept

size_t	sets_performed () const noexcept

size_t	gets_performed () const noexcept

size_t	actions_performed () const noexcept

void	reset_statistics () noexcept

Private Member Functions
core::dicom_dataset	build_create_dataset (const ups_create_data &data) const

core::dicom_dataset	build_change_state_dataset (const ups_change_state_data &data) const

core::dicom_dataset	build_request_cancel_dataset (const ups_request_cancel_data &data) const

std::string	generate_workitem_uid () const

uint16_t	next_message_id () noexcept

Private Attributes
std::shared_ptr< di::ILogger >	logger_

ups_push_scu_config	config_

std::atomic< uint16_t >	message_id_counter_ {1}

std::atomic< size_t >	creates_performed_ {0}

std::atomic< size_t >	sets_performed_ {0}

std::atomic< size_t >	gets_performed_ {0}

std::atomic< size_t >	actions_performed_ {0}

Detailed Description

Definition at line 229 of file ups_push_scu.h.

Constructor & Destructor Documentation

◆ ups_push_scu() [1/4]

kcenon::pacs::services::ups_push_scu::ups_push_scu ( std::shared_ptr< di::ILogger > logger = nullptr )

explicit

Construct UPS Push SCU with default configuration.

Parameters

logger Logger instance (nullptr uses null_logger)

Definition at line 78 of file ups_push_scu.cpp.

79 : logger_(logger ? std::move(logger) : di::null_logger()) {}

kcenon::pacs::services::ups_push_scu::logger_

std::shared_ptr< di::ILogger > logger_

Definition ups_push_scu.h:370

kcenon::pacs::di::null_logger

std::shared_ptr< ILogger > null_logger()

Get a shared null logger instance.

Definition ilogger.h:271

◆ ups_push_scu() [2/4]

kcenon::pacs::services::ups_push_scu::ups_push_scu	(	const ups_push_scu_config &	config,
		std::shared_ptr< di::ILogger >	logger = nullptr )

explicit

Construct UPS Push SCU with custom configuration.

Parameters

config	Configuration options
logger	Logger instance (nullptr uses null_logger)

Definition at line 81 of file ups_push_scu.cpp.

83 : logger_(logger ? std::move(logger) : di::null_logger()),

84 config_(config) {}

kcenon::pacs::services::ups_push_scu::config_

ups_push_scu_config config_

Definition ups_push_scu.h:371

◆ ~ups_push_scu()

kcenon::pacs::services::ups_push_scu::~ups_push_scu ( )

default

◆ ups_push_scu() [3/4]

kcenon::pacs::services::ups_push_scu::ups_push_scu ( const ups_push_scu & )

delete

◆ ups_push_scu() [4/4]

kcenon::pacs::services::ups_push_scu::ups_push_scu ( ups_push_scu && )

delete

Member Function Documentation

◆ actions_performed()

size_t kcenon::pacs::services::ups_push_scu::actions_performed ( ) const

nodiscardnoexcept

Definition at line 579 of file ups_push_scu.cpp.

                                                      {
    return actions_performed_.load(std::memory_order_relaxed);
}

References actions_performed_.

◆ build_change_state_dataset()

core::dicom_dataset kcenon::pacs::services::ups_push_scu::build_change_state_dataset ( const ups_change_state_data & data ) const

nodiscardprivate

Definition at line 647 of file ups_push_scu.cpp.

                                             {
 
    using namespace core;
    using namespace encoding;
 
    dicom_dataset ds;
 
    // Requested state
    ds.set_string(ups_tags::procedure_step_state, vr_type::CS,
                  data.requested_state);
 
    // Transaction UID
    ds.set_string(ups_tags::transaction_uid, vr_type::UI,
                  data.transaction_uid);
 
    return ds;
}

References kcenon::pacs::services::ups_tags::procedure_step_state, kcenon::pacs::services::ups_change_state_data::requested_state, kcenon::pacs::services::ups_change_state_data::transaction_uid, and kcenon::pacs::services::ups_tags::transaction_uid.

Referenced by change_state().

Here is the caller graph for this function:

◆ build_create_dataset()

core::dicom_dataset kcenon::pacs::services::ups_push_scu::build_create_dataset ( const ups_create_data & data ) const

nodiscardprivate

Definition at line 594 of file ups_push_scu.cpp.

                                       {
 
    using namespace core;
    using namespace encoding;
 
    dicom_dataset ds;
 
    // Procedure Step State - always SCHEDULED for N-CREATE
    ds.set_string(ups_tags::procedure_step_state, vr_type::CS, "SCHEDULED");
 
    // Procedure Step Label (required)
    if (!data.procedure_step_label.empty()) {
        ds.set_string(ups_tags::procedure_step_label, vr_type::LO,
                      data.procedure_step_label);
    }
 
    // Worklist Label
    if (!data.worklist_label.empty()) {
        ds.set_string(ups_tags::worklist_label, vr_type::LO,
                      data.worklist_label);
    }
 
    // Priority
    if (!data.priority.empty()) {
        ds.set_string(ups_tags::scheduled_procedure_step_priority, vr_type::CS,
                      data.priority);
    }
 
    // Scheduled start datetime
    if (!data.scheduled_start_datetime.empty()) {
        ds.set_string(
            dicom_tag{0x0040, 0x4005}, vr_type::DT,
            data.scheduled_start_datetime);
    }
 
    // Expected completion datetime
    if (!data.expected_completion_datetime.empty()) {
        ds.set_string(
            dicom_tag{0x0040, 0x4011}, vr_type::DT,
            data.expected_completion_datetime);
    }
 
    // Scheduled Station Name
    if (!data.scheduled_station_name.empty()) {
        ds.set_string(
            dicom_tag{0x0040, 0x4001}, vr_type::CS,
            data.scheduled_station_name);
    }
 
    return ds;
}

Referenced by create().

Here is the caller graph for this function:

◆ build_request_cancel_dataset()

core::dicom_dataset kcenon::pacs::services::ups_push_scu::build_request_cancel_dataset ( const ups_request_cancel_data & data ) const

nodiscardprivate

Definition at line 666 of file ups_push_scu.cpp.

                                               {
 
    using namespace core;
    using namespace encoding;
 
    dicom_dataset ds;
 
    if (!data.reason.empty()) {
        ds.set_string(ups_tags::reason_for_cancellation, vr_type::LT,
                      data.reason);
    }
 
    return ds;
}

References kcenon::pacs::services::ups_request_cancel_data::reason, and kcenon::pacs::services::ups_tags::reason_for_cancellation.

Referenced by request_cancel().

Here is the caller graph for this function:

◆ change_state()

network::Result< ups_result > kcenon::pacs::services::ups_push_scu::change_state	(	network::association &	assoc,
		const ups_change_state_data &	data )

nodiscard

Change UPS workitem state (N-ACTION Type 1)

Requests a state transition for the specified workitem. Valid transitions: SCHEDULED→IN PROGRESS, IN PROGRESS→COMPLETED, IN PROGRESS→CANCELED, SCHEDULED→CANCELED.

Parameters

assoc	The established association to use
data	The state change data including Transaction UID

Returns: Result containing ups_result on success, or error

Definition at line 375 of file ups_push_scu.cpp.

                                       {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    if (data.workitem_uid.empty()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_missing_uid,
            "Workitem UID is required for state change");
    }
 
    if (data.transaction_uid.empty()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_missing_transaction_uid,
            "Transaction UID is required for state change");
    }
 
    auto context_id = assoc.accepted_context_id(ups_push_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_context_not_accepted,
            "No accepted presentation context for UPS Push SOP Class");
    }
 
    // Build the N-ACTION request with action dataset
    auto request = make_n_action_rq(
        next_message_id(),
        ups_push_sop_class_uid,
        data.workitem_uid,
        ups_action_change_state);
 
    // Attach dataset with state and transaction UID
    auto action_dataset = build_change_state_dataset(data);
    request.set_dataset(std::move(action_dataset));
 
    logger_->debug("Sending N-ACTION (Change State) for UPS workitem: " +
                   data.workitem_uid + " -> " + data.requested_state);
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-ACTION: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-ACTION response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_action_rsp) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_unexpected_command,
            "Expected N-ACTION-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    ups_result result;
    result.workitem_uid = data.workitem_uid;
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = elapsed;
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    actions_performed_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-ACTION (Change State) successful for UPS workitem: " +
                      data.workitem_uid + " -> " + data.requested_state);
    } else {
        logger_->warn("N-ACTION returned status 0x" +
                      std::to_string(result.status) +
                      " for UPS workitem: " + data.workitem_uid);
    }
 
    return result;
}

Here is the call graph for this function:

◆ create()

network::Result< ups_result > kcenon::pacs::services::ups_push_scu::create	(	network::association &	assoc,
		const ups_create_data &	data )

nodiscard

Create a new UPS workitem on the remote SCP (N-CREATE)

Creates a new workitem with SCHEDULED state. If workitem_uid is empty and auto_generate_uid is true, a unique UID will be generated.

Parameters

assoc	The established association to use
data	The workitem creation data

Returns: Result containing ups_result on success, or error

Definition at line 90 of file ups_push_scu.cpp.

                                 {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    // Verify association is established
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    // Get accepted presentation context for UPS Push
    auto context_id = assoc.accepted_context_id(ups_push_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_context_not_accepted,
            "No accepted presentation context for UPS Push SOP Class");
    }
 
    // Generate or use provided workitem UID
    std::string uid = data.workitem_uid;
    if (uid.empty() && config_.auto_generate_uid) {
        uid = generate_workitem_uid();
    }
 
    if (uid.empty()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_missing_uid,
            "Workitem UID is required");
    }
 
    // Build the creation dataset
    auto dataset = build_create_dataset(data);
 
    // Create the N-CREATE request
    auto request = make_ups_n_create_rq(next_message_id(), uid, std::move(dataset));
 
    logger_->debug("Sending N-CREATE request for UPS workitem: " + uid);
 
    // Send the request
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-CREATE: " + send_result.error().message);
        return send_result.error();
    }
 
    // Receive the response
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-CREATE response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    // Verify it's an N-CREATE response
    if (response.command() != command_field::n_create_rsp) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_unexpected_command,
            "Expected N-CREATE-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    // Build result
    ups_result result;
    result.workitem_uid = uid;
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = elapsed;
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    creates_performed_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-CREATE successful for UPS workitem: " + uid);
    } else {
        logger_->warn("N-CREATE returned status 0x" +
                      std::to_string(result.status) +
                      " for UPS workitem: " + uid);
    }
 
    return result;
}

Referenced by operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ creates_performed()

size_t kcenon::pacs::services::ups_push_scu::creates_performed ( ) const

nodiscardnoexcept

Definition at line 567 of file ups_push_scu.cpp.

                                                      {
    return creates_performed_.load(std::memory_order_relaxed);
}

References creates_performed_.

◆ generate_workitem_uid()

std::string kcenon::pacs::services::ups_push_scu::generate_workitem_uid ( ) const

nodiscardprivate

Definition at line 686 of file ups_push_scu.cpp.

                                                    {
    static std::mt19937_64 gen{std::random_device{}()};
    static std::uniform_int_distribution<uint64_t> dist;
 
    auto now = std::chrono::system_clock::now();
    auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()).count();
 
    return std::string(uid_root) + "." + std::to_string(timestamp) +
           "." + std::to_string(dist(gen) % 100000);
}

Referenced by create().

Here is the caller graph for this function:

◆ get()

network::Result< ups_result > kcenon::pacs::services::ups_push_scu::get	(	network::association &	assoc,
		const ups_get_data &	data )

nodiscard

Retrieve UPS workitem attributes from remote SCP (N-GET)

Parameters

assoc	The established association to use
data	The query data including workitem UID and optional tags

Returns: Result containing ups_result with attributes on success

Definition at line 276 of file ups_push_scu.cpp.

                              {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    if (data.workitem_uid.empty()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_missing_uid,
            "Workitem UID is required for N-GET");
    }
 
    auto context_id = assoc.accepted_context_id(ups_push_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_context_not_accepted,
            "No accepted presentation context for UPS Push SOP Class");
    }
 
    // Use the global factory function for N-GET
    auto request = make_n_get_rq(
        next_message_id(),
        ups_push_sop_class_uid,
        data.workitem_uid,
        data.attribute_tags);
 
    logger_->debug("Sending N-GET request for UPS workitem: " + data.workitem_uid +
                   " (attributes: " +
                   (data.attribute_tags.empty() ? "all" :
                    std::to_string(data.attribute_tags.size())) + ")");
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-GET: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-GET response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_get_rsp) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_unexpected_command,
            "Expected N-GET-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    ups_result result;
    result.workitem_uid = data.workitem_uid;
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = elapsed;
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    // Extract returned attributes from response dataset
    if (response.has_dataset()) {
        auto dataset_result = response.dataset();
        if (dataset_result.is_ok()) {
            result.attributes = dataset_result.value().get();
        }
    }
 
    gets_performed_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-GET successful for UPS workitem: " + data.workitem_uid);
    } else {
        logger_->warn("N-GET returned status 0x" +
                      std::to_string(result.status) +
                      " for UPS workitem: " + data.workitem_uid);
    }
 
    return result;
}

Here is the call graph for this function:

◆ gets_performed()

size_t kcenon::pacs::services::ups_push_scu::gets_performed ( ) const

nodiscardnoexcept

Definition at line 575 of file ups_push_scu.cpp.

                                                   {
    return gets_performed_.load(std::memory_order_relaxed);
}

References gets_performed_.

◆ next_message_id()

uint16_t kcenon::pacs::services::ups_push_scu::next_message_id ( )

nodiscardprivatenoexcept

Definition at line 698 of file ups_push_scu.cpp.

                                                {
    uint16_t id = message_id_counter_.fetch_add(1, std::memory_order_relaxed);
    if (id == 0) {
        id = message_id_counter_.fetch_add(1, std::memory_order_relaxed);
    }
    return id;
}

References message_id_counter_.

Referenced by change_state(), create(), get(), request_cancel(), and set().

Here is the caller graph for this function:

◆ operator=() [1/2]

ups_push_scu & kcenon::pacs::services::ups_push_scu::operator= ( const ups_push_scu & )

delete

◆ operator=() [2/2]

ups_push_scu & kcenon::pacs::services::ups_push_scu::operator= ( ups_push_scu && )

delete

References create(), and set().

Here is the call graph for this function:

◆ request_cancel()

network::Result< ups_result > kcenon::pacs::services::ups_push_scu::request_cancel	(	network::association &	assoc,
		const ups_request_cancel_data &	data )

nodiscard

Request cancellation of a UPS workitem (N-ACTION Type 3)

Parameters

assoc	The established association to use
data	The cancellation request data

Returns: Result containing ups_result on success, or error

Definition at line 471 of file ups_push_scu.cpp.

                                         {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    if (data.workitem_uid.empty()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_missing_uid,
            "Workitem UID is required for cancel request");
    }
 
    auto context_id = assoc.accepted_context_id(ups_push_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_context_not_accepted,
            "No accepted presentation context for UPS Push SOP Class");
    }
 
    // Build the N-ACTION request for cancel
    auto request = make_n_action_rq(
        next_message_id(),
        ups_push_sop_class_uid,
        data.workitem_uid,
        ups_action_request_cancel);
 
    // Attach dataset with cancellation reason if provided
    if (!data.reason.empty()) {
        auto cancel_dataset = build_request_cancel_dataset(data);
        request.set_dataset(std::move(cancel_dataset));
    }
 
    logger_->debug("Sending N-ACTION (Request Cancel) for UPS workitem: " +
                   data.workitem_uid);
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-ACTION: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-ACTION response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_action_rsp) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_unexpected_command,
            "Expected N-ACTION-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    ups_result result;
    result.workitem_uid = data.workitem_uid;
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = elapsed;
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    actions_performed_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-ACTION (Request Cancel) successful for UPS workitem: " +
                      data.workitem_uid);
    } else {
        logger_->warn("N-ACTION (Request Cancel) returned status 0x" +
                      std::to_string(result.status) +
                      " for UPS workitem: " + data.workitem_uid);
    }
 
    return result;
}

Here is the call graph for this function:

◆ reset_statistics()

void kcenon::pacs::services::ups_push_scu::reset_statistics ( )

noexcept

Definition at line 583 of file ups_push_scu.cpp.

                                             {
    creates_performed_.store(0, std::memory_order_relaxed);
    sets_performed_.store(0, std::memory_order_relaxed);
    gets_performed_.store(0, std::memory_order_relaxed);
    actions_performed_.store(0, std::memory_order_relaxed);
}

References actions_performed_, creates_performed_, gets_performed_, and sets_performed_.

◆ set()

network::Result< ups_result > kcenon::pacs::services::ups_push_scu::set	(	network::association &	assoc,
		const ups_set_data &	data )

nodiscard

Modify an existing UPS workitem (N-SET)

Parameters

assoc	The established association to use
data	The modification data including workitem UID and dataset

Returns: Result containing ups_result on success, or error

Definition at line 189 of file ups_push_scu.cpp.

                              {
 
    using namespace network::dimse;
 
    auto start_time = std::chrono::steady_clock::now();
 
    if (!assoc.is_established()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::association_not_established,
            "Association not established");
    }
 
    if (data.workitem_uid.empty()) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_missing_uid,
            "Workitem UID is required for N-SET");
    }
 
    auto context_id = assoc.accepted_context_id(ups_push_sop_class_uid);
    if (!context_id) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_context_not_accepted,
            "No accepted presentation context for UPS Push SOP Class");
    }
 
    // Create the N-SET request with modification dataset
    auto request = make_ups_n_set_rq(
        next_message_id(),
        data.workitem_uid,
        core::dicom_dataset(data.modifications));
 
    logger_->debug("Sending N-SET request for UPS workitem: " + data.workitem_uid);
 
    auto send_result = assoc.send_dimse(*context_id, request);
    if (send_result.is_err()) {
        logger_->error("Failed to send N-SET: " + send_result.error().message);
        return send_result.error();
    }
 
    auto recv_result = assoc.receive_dimse(config_.timeout);
    if (recv_result.is_err()) {
        logger_->error("Failed to receive N-SET response: " +
                       recv_result.error().message);
        return recv_result.error();
    }
 
    const auto& [recv_context_id, response] = recv_result.value();
 
    if (response.command() != command_field::n_set_rsp) {
        return kcenon::pacs::pacs_error<ups_result>(
            kcenon::pacs::error_codes::ups_unexpected_command,
            "Expected N-SET-RSP but received " +
            std::string(to_string(response.command())));
    }
 
    auto end_time = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
 
    ups_result result;
    result.workitem_uid = data.workitem_uid;
    result.status = static_cast<uint16_t>(response.status());
    result.elapsed = elapsed;
 
    if (response.command_set().contains(tag_error_comment)) {
        result.error_comment = response.command_set().get_string(tag_error_comment);
    }
 
    sets_performed_.fetch_add(1, std::memory_order_relaxed);
 
    if (result.is_success()) {
        logger_->info("N-SET successful for UPS workitem: " + data.workitem_uid);
    } else {
        logger_->warn("N-SET returned status 0x" +
                      std::to_string(result.status) +
                      " for UPS workitem: " + data.workitem_uid);
    }
 
    return result;
}

References kcenon::pacs::network::association::accepted_context_id(), kcenon::pacs::error_codes::association_not_established, config_, kcenon::pacs::services::ups_result::elapsed, kcenon::pacs::services::ups_result::error_comment, kcenon::pacs::network::association::is_established(), kcenon::pacs::services::ups_result::is_success(), logger_, kcenon::pacs::services::ups_set_data::modifications, next_message_id(), kcenon::pacs::pacs_error(), kcenon::pacs::network::association::receive_dimse(), kcenon::pacs::network::association::send_dimse(), sets_performed_, kcenon::pacs::services::ups_result::status, kcenon::pacs::services::ups_push_scu_config::timeout, kcenon::pacs::services::to_string(), kcenon::pacs::error_codes::ups_context_not_accepted, kcenon::pacs::error_codes::ups_missing_uid, kcenon::pacs::services::ups_push_sop_class_uid, kcenon::pacs::error_codes::ups_unexpected_command, kcenon::pacs::services::ups_result::workitem_uid, and kcenon::pacs::services::ups_set_data::workitem_uid.

Referenced by operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sets_performed()

size_t kcenon::pacs::services::ups_push_scu::sets_performed ( ) const

nodiscardnoexcept

Definition at line 571 of file ups_push_scu.cpp.

                                                   {
    return sets_performed_.load(std::memory_order_relaxed);
}

References sets_performed_.

Member Data Documentation

◆ actions_performed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scu::actions_performed_ {0}

private

Definition at line 376 of file ups_push_scu.h.

376{0};

Referenced by actions_performed(), change_state(), request_cancel(), and reset_statistics().

◆ config_

ups_push_scu_config kcenon::pacs::services::ups_push_scu::config_

private

Definition at line 371 of file ups_push_scu.h.

Referenced by change_state(), create(), get(), request_cancel(), and set().

◆ creates_performed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scu::creates_performed_ {0}

private

Definition at line 373 of file ups_push_scu.h.

373{0};

Referenced by create(), creates_performed(), and reset_statistics().

◆ gets_performed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scu::gets_performed_ {0}

private

Definition at line 375 of file ups_push_scu.h.

375{0};

Referenced by get(), gets_performed(), and reset_statistics().

◆ logger_

std::shared_ptr<di::ILogger> kcenon::pacs::services::ups_push_scu::logger_

private

Definition at line 370 of file ups_push_scu.h.

Referenced by change_state(), create(), get(), request_cancel(), and set().

◆ message_id_counter_

std::atomic<uint16_t> kcenon::pacs::services::ups_push_scu::message_id_counter_ {1}

private

Definition at line 372 of file ups_push_scu.h.

372{1};

Referenced by next_message_id().

◆ sets_performed_

std::atomic<size_t> kcenon::pacs::services::ups_push_scu::sets_performed_ {0}

private

Definition at line 374 of file ups_push_scu.h.

374{0};

Referenced by reset_statistics(), set(), and sets_performed().

The documentation for this class was generated from the following files:

include/kcenon/pacs/services/ups/ups_push_scu.h
src/services/ups/ups_push_scu.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ups_push_scu() [1/4]

◆ ups_push_scu() [2/4]

◆ ~ups_push_scu()

◆ ups_push_scu() [3/4]

◆ ups_push_scu() [4/4]

Member Function Documentation

◆ actions_performed()

◆ build_change_state_dataset()

◆ build_create_dataset()

◆ build_request_cancel_dataset()

◆ change_state()

◆ create()

◆ creates_performed()

◆ generate_workitem_uid()

◆ get()

◆ gets_performed()

◆ next_message_id()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ request_cancel()

◆ reset_statistics()

◆ set()

◆ sets_performed()

Member Data Documentation

◆ actions_performed_

◆ config_

◆ creates_performed_

◆ gets_performed_

◆ logger_

◆ message_id_counter_

◆ sets_performed_