kcenon::pacs::storage::ups_repository Class Reference

#include <ups_repository.h>

Collaboration diagram for kcenon::pacs::storage::ups_repository:

Public Member Functions
	ups_repository (sqlite3 *db)
	~ups_repository ()
	ups_repository (const ups_repository &)=delete
auto	operator= (const ups_repository &) -> ups_repository &=delete
	ups_repository (ups_repository &&) noexcept
auto	operator= (ups_repository &&) noexcept -> ups_repository &
auto	create_ups_workitem (const ups_workitem &workitem) -> Result< int64_t >
auto	update_ups_workitem (const ups_workitem &workitem) -> VoidResult
auto	change_ups_state (std::string_view workitem_uid, std::string_view new_state, std::string_view transaction_uid="") -> VoidResult
auto	find_ups_workitem (std::string_view workitem_uid) const -> std::optional< ups_workitem >
auto	search_ups_workitems (const ups_workitem_query &query) const -> Result< std::vector< ups_workitem > >
auto	delete_ups_workitem (std::string_view workitem_uid) -> VoidResult
auto	ups_workitem_count () const -> Result< size_t >
auto	ups_workitem_count (std::string_view state) const -> Result< size_t >
auto	subscribe_ups (const ups_subscription &subscription) -> Result< int64_t >
auto	unsubscribe_ups (std::string_view subscriber_ae, std::string_view workitem_uid="") -> VoidResult
auto	get_ups_subscriptions (std::string_view subscriber_ae) const -> Result< std::vector< ups_subscription > >
auto	get_ups_subscribers (std::string_view workitem_uid) const -> Result< std::vector< std::string > >

Private Member Functions
auto	parse_ups_workitem_row (void *stmt) const -> ups_workitem

Static Private Member Functions
static auto	to_like_pattern (std::string_view pattern) -> std::string
static auto	parse_timestamp (const std::string &str) -> std::chrono::system_clock::time_point

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Definition at line 100 of file ups_repository.h.

Constructor & Destructor Documentation

ups_repository() [1/3]

kcenon::pacs::storage::ups_repository::ups_repository ( sqlite3 * db )

explicit

Definition at line 793 of file ups_repository.cpp.

: db_(db) {}

~ups_repository()

kcenon::pacs::storage::ups_repository::~ups_repository ( )

default

ups_repository() [2/3]

kcenon::pacs::storage::ups_repository::ups_repository ( const ups_repository & )

delete

ups_repository() [3/3]

kcenon::pacs::storage::ups_repository::ups_repository ( ups_repository && other )

noexcept

Definition at line 797 of file ups_repository.cpp.

                                                              : db_(other.db_) {
    other.db_ = nullptr;
}

Member Function Documentation

change_ups_state()

auto kcenon::pacs::storage::ups_repository::change_ups_state ( std::string_view workitem_uid, std::string_view new_state, std::string_view transaction_uid = "" ) -> VoidResult

nodiscard

Definition at line 1049 of file ups_repository.cpp.

                  {
    if (!parse_ups_state(new_state).has_value()) {
        return make_error<std::monostate>(
            -1, kcenon::pacs::compat::format("Invalid UPS state: {}", new_state),
            "storage");
    }
 
    auto existing = find_ups_workitem(workitem_uid);
    if (!existing.has_value()) {
        return make_error<std::monostate>(
            -1,
            kcenon::pacs::compat::format("UPS workitem not found: {}", workitem_uid),
            "storage");
    }
 
    auto current = existing->get_state();
    auto target = parse_ups_state(new_state);
 
    if (existing->is_final()) {
        return make_error<std::monostate>(
            -1,
            kcenon::pacs::compat::format("Cannot change state from final state: {}",
                                 existing->state),
            "storage");
    }
 
    if (current == ups_state::scheduled) {
        if (target != ups_state::in_progress &&
            target != ups_state::canceled) {
            return make_error<std::monostate>(
                -1,
                kcenon::pacs::compat::format(
                    "Invalid transition from SCHEDULED to {}", new_state),
                "storage");
        }
    } else if (current == ups_state::in_progress) {
        if (target != ups_state::completed &&
            target != ups_state::canceled) {
            return make_error<std::monostate>(
                -1,
                kcenon::pacs::compat::format(
                    "Invalid transition from IN PROGRESS to {}", new_state),
                "storage");
        }
    }
 
    if (target == ups_state::in_progress && transaction_uid.empty()) {
        return make_error<std::monostate>(
            -1, "Transaction UID is required for IN PROGRESS transition",
            "storage");
    }
 
    const char* sql = R"(
        UPDATE ups_workitems SET
            state = ?,
            transaction_uid = ?,
            updated_at = datetime('now')
        WHERE workitem_uid = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare state change: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, new_state.data(), static_cast<int>(new_state.size()),
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, transaction_uid.data(),
                      static_cast<int>(transaction_uid.size()),
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, workitem_uid.data(),
                      static_cast<int>(workitem_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to change UPS state: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok(std::monostate{});
}

References kcenon::pacs::storage::canceled, kcenon::pacs::storage::completed, kcenon::pacs::storage::in_progress, kcenon::pacs::storage::parse_ups_state(), and kcenon::pacs::storage::scheduled.

Here is the call graph for this function:

create_ups_workitem()

auto kcenon::pacs::storage::ups_repository::create_ups_workitem ( const ups_workitem & workitem ) -> Result<int64_t>

nodiscard

Definition at line 865 of file ups_repository.cpp.

                       {
    if (workitem.workitem_uid.empty()) {
        return make_error<int64_t>(-1, "UPS workitem UID is required",
                                   "storage");
    }
 
    const char* sql = R"(
        INSERT INTO ups_workitems (
            workitem_uid, state, procedure_step_label, worklist_label,
            priority, scheduled_start_datetime, expected_completion_datetime,
            scheduled_station_name, scheduled_station_class,
            scheduled_station_geographic, scheduled_human_performers,
            input_information, performing_ae, progress_description,
            progress_percent, output_information, transaction_uid,
            updated_at
        ) VALUES (?, 'SCHEDULED', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
        RETURNING workitem_pk;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<int64_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare UPS insert: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, workitem.workitem_uid.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, workitem.procedure_step_label.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, workitem.worklist_label.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(
        stmt, 4,
        workitem.priority.empty() ? "MEDIUM" : workitem.priority.c_str(), -1,
        SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 5, workitem.scheduled_start_datetime.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6,
                      workitem.expected_completion_datetime.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, workitem.scheduled_station_name.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 8, workitem.scheduled_station_class.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 9,
                      workitem.scheduled_station_geographic.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 10,
                      workitem.scheduled_human_performers.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 11, workitem.input_information.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 12, workitem.performing_ae.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 13, workitem.progress_description.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 14, workitem.progress_percent);
    sqlite3_bind_text(stmt, 15, workitem.output_information.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 16, workitem.transaction_uid.c_str(), -1,
                      SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        auto error_msg = sqlite3_errmsg(db_);
        sqlite3_finalize(stmt);
        return make_error<int64_t>(
            rc,
            kcenon::pacs::compat::format("Failed to create UPS workitem: {}",
                                 error_msg),
            "storage");
    }
 
    auto pk = sqlite3_column_int64(stmt, 0);
    sqlite3_finalize(stmt);
    return pk;
}

delete_ups_workitem()

auto kcenon::pacs::storage::ups_repository::delete_ups_workitem ( std::string_view workitem_uid ) -> VoidResult

nodiscard

Definition at line 1239 of file ups_repository.cpp.

                  {
    const char* sql = "DELETE FROM ups_workitems WHERE workitem_uid = ?;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare UPS delete: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, workitem_uid.data(),
                      static_cast<int>(workitem_uid.size()), SQLITE_TRANSIENT);
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to delete UPS workitem: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok(std::monostate{});
}

find_ups_workitem()

auto kcenon::pacs::storage::ups_repository::find_ups_workitem ( std::string_view workitem_uid ) const -> std::optional<ups_workitem>

nodiscard

Definition at line 1144 of file ups_repository.cpp.

                                 {
    const char* sql = "SELECT * FROM ups_workitems WHERE workitem_uid = ?;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, workitem_uid.data(),
                      static_cast<int>(workitem_uid.size()), SQLITE_TRANSIENT);
 
    std::optional<ups_workitem> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_ups_workitem_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

get_ups_subscribers()

auto kcenon::pacs::storage::ups_repository::get_ups_subscribers ( std::string_view workitem_uid ) const -> Result<std::vector<std::string>>

nodiscard

Definition at line 1439 of file ups_repository.cpp.

                                    {
    const char* sql = R"(
        SELECT DISTINCT subscriber_ae FROM ups_subscriptions
        WHERE workitem_uid = ? OR workitem_uid IS NULL;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<std::string>>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare subscriber query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, workitem_uid.data(),
                      static_cast<int>(workitem_uid.size()), SQLITE_TRANSIENT);
 
    std::vector<std::string> results;
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(get_text(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

get_ups_subscriptions()

auto kcenon::pacs::storage::ups_repository::get_ups_subscriptions ( std::string_view subscriber_ae ) const -> Result<std::vector<ups_subscription>>

nodiscard

Definition at line 1405 of file ups_repository.cpp.

                                           {
    const char* sql =
        "SELECT * FROM ups_subscriptions WHERE subscriber_ae = ?;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<ups_subscription>>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare subscription query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, subscriber_ae.data(),
                      static_cast<int>(subscriber_ae.size()), SQLITE_TRANSIENT);
 
    std::vector<ups_subscription> results;
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        ups_subscription sub;
        sub.pk = sqlite3_column_int64(stmt, 0);
        sub.subscriber_ae = get_text(stmt, 1);
        sub.workitem_uid = get_text(stmt, 2);
        sub.deletion_lock = sqlite3_column_int(stmt, 3) != 0;
        sub.filter_criteria = get_text(stmt, 4);
        sub.created_at = parse_datetime(get_text(stmt, 5).c_str());
        results.push_back(std::move(sub));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

References kcenon::pacs::storage::ups_subscription::created_at, kcenon::pacs::storage::ups_subscription::deletion_lock, kcenon::pacs::storage::ups_subscription::filter_criteria, kcenon::pacs::storage::ups_subscription::pk, kcenon::pacs::storage::ups_subscription::subscriber_ae, and kcenon::pacs::storage::ups_subscription::workitem_uid.

operator=() [1/2]

auto kcenon::pacs::storage::ups_repository::operator= ( const ups_repository & ) -> ups_repository &=delete

delete

operator=() [2/2]

auto kcenon::pacs::storage::ups_repository::operator= ( ups_repository && other ) -> ups_repository&

noexcept

Definition at line 801 of file ups_repository.cpp.

                       {
    if (this != &other) {
        db_ = other.db_;
        other.db_ = nullptr;
    }
    return *this;
}

parse_timestamp()

auto kcenon::pacs::storage::ups_repository::parse_timestamp ( const std::string & str ) -> std::chrono::system_clock::time_point

staticnodiscardprivate

Definition at line 831 of file ups_repository.cpp.

                                       {
    return parse_datetime(str.c_str());
}

parse_ups_workitem_row()

auto kcenon::pacs::storage::ups_repository::parse_ups_workitem_row ( void * stmt ) const -> ups_workitem

nodiscardprivate

Definition at line 836 of file ups_repository.cpp.

                    {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    ups_workitem item;
 
    item.pk = sqlite3_column_int64(stmt, 0);
    item.workitem_uid = get_text(stmt, 1);
    item.state = get_text(stmt, 2);
    item.procedure_step_label = get_text(stmt, 3);
    item.worklist_label = get_text(stmt, 4);
    item.priority = get_text(stmt, 5);
    item.scheduled_start_datetime = get_text(stmt, 6);
    item.expected_completion_datetime = get_text(stmt, 7);
    item.scheduled_station_name = get_text(stmt, 8);
    item.scheduled_station_class = get_text(stmt, 9);
    item.scheduled_station_geographic = get_text(stmt, 10);
    item.scheduled_human_performers = get_text(stmt, 11);
    item.input_information = get_text(stmt, 12);
    item.performing_ae = get_text(stmt, 13);
    item.progress_description = get_text(stmt, 14);
    item.progress_percent = sqlite3_column_int(stmt, 15);
    item.output_information = get_text(stmt, 16);
    item.transaction_uid = get_text(stmt, 17);
    item.created_at = parse_datetime(get_text(stmt, 18).c_str());
    item.updated_at = parse_datetime(get_text(stmt, 19).c_str());
 
    return item;
}

search_ups_workitems()

auto kcenon::pacs::storage::ups_repository::search_ups_workitems ( const ups_workitem_query & query ) const -> Result<std::vector<ups_workitem>>

nodiscard

Definition at line 1166 of file ups_repository.cpp.

                                       {
    std::string sql = "SELECT * FROM ups_workitems WHERE 1=1";
    std::vector<std::string> params;
 
    if (query.workitem_uid.has_value()) {
        sql += " AND workitem_uid = ?";
        params.push_back(query.workitem_uid.value());
    }
    if (query.state.has_value()) {
        sql += " AND state = ?";
        params.push_back(query.state.value());
    }
    if (query.priority.has_value()) {
        sql += " AND priority = ?";
        params.push_back(query.priority.value());
    }
    if (query.procedure_step_label.has_value()) {
        sql += " AND procedure_step_label LIKE ?";
        params.push_back(to_like_pattern(*query.procedure_step_label));
    }
    if (query.worklist_label.has_value()) {
        sql += " AND worklist_label LIKE ?";
        params.push_back(to_like_pattern(*query.worklist_label));
    }
    if (query.performing_ae.has_value()) {
        sql += " AND performing_ae = ?";
        params.push_back(query.performing_ae.value());
    }
    if (query.scheduled_date_from.has_value()) {
        sql += " AND scheduled_start_datetime >= ?";
        params.push_back(query.scheduled_date_from.value());
    }
    if (query.scheduled_date_to.has_value()) {
        sql += " AND scheduled_start_datetime <= ?";
        params.push_back(query.scheduled_date_to.value() + "235959");
    }
 
    sql += " ORDER BY scheduled_start_datetime ASC";
 
    if (query.limit > 0) {
        sql += " LIMIT " + std::to_string(query.limit);
    }
    if (query.offset > 0) {
        sql += " OFFSET " + std::to_string(query.offset);
    }
 
    sql += ";";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<ups_workitem>>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare UPS search: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    for (size_t i = 0; i < params.size(); ++i) {
        sqlite3_bind_text(stmt, static_cast<int>(i + 1), params[i].c_str(), -1,
                          SQLITE_TRANSIENT);
    }
 
    std::vector<ups_workitem> results;
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_ups_workitem_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

subscribe_ups()

auto kcenon::pacs::storage::ups_repository::subscribe_ups ( const ups_subscription & subscription ) -> Result<int64_t>

nodiscard

Definition at line 1313 of file ups_repository.cpp.

                       {
    if (subscription.subscriber_ae.empty()) {
        return make_error<int64_t>(-1, "Subscriber AE Title is required",
                                   "storage");
    }
 
    const char* sql = R"(
        INSERT OR REPLACE INTO ups_subscriptions (
            subscriber_ae, workitem_uid, deletion_lock, filter_criteria
        ) VALUES (?, ?, ?, ?)
        RETURNING subscription_pk;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<int64_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare subscription insert: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, subscription.subscriber_ae.c_str(), -1,
                      SQLITE_TRANSIENT);
    if (subscription.workitem_uid.empty()) {
        sqlite3_bind_null(stmt, 2);
    } else {
        sqlite3_bind_text(stmt, 2, subscription.workitem_uid.c_str(), -1,
                          SQLITE_TRANSIENT);
    }
    sqlite3_bind_int(stmt, 3, subscription.deletion_lock ? 1 : 0);
    sqlite3_bind_text(stmt, 4, subscription.filter_criteria.c_str(), -1,
                      SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        auto error_msg = sqlite3_errmsg(db_);
        sqlite3_finalize(stmt);
        return make_error<int64_t>(
            rc, kcenon::pacs::compat::format("Failed to create subscription: {}", error_msg),
            "storage");
    }
 
    auto pk = sqlite3_column_int64(stmt, 0);
    sqlite3_finalize(stmt);
    return pk;
}

to_like_pattern()

auto kcenon::pacs::storage::ups_repository::to_like_pattern ( std::string_view pattern ) -> std::string

staticnodiscardprivate

Definition at line 810 of file ups_repository.cpp.

                 {
    std::string result;
    result.reserve(pattern.size());
 
    for (char c : pattern) {
        if (c == '*') {
            result += '%';
        } else if (c == '?') {
            result += '_';
        } else if (c == '%' || c == '_') {
            result += '\\';
            result += c;
        } else {
            result += c;
        }
    }
 
    return result;
}

unsubscribe_ups()

auto kcenon::pacs::storage::ups_repository::unsubscribe_ups ( std::string_view subscriber_ae, std::string_view workitem_uid = "" ) -> VoidResult

nodiscard

Definition at line 1363 of file ups_repository.cpp.

                  {
    std::string sql;
    if (workitem_uid.empty()) {
        sql = "DELETE FROM ups_subscriptions WHERE subscriber_ae = ?;";
    } else {
        sql = "DELETE FROM ups_subscriptions WHERE subscriber_ae = ? AND workitem_uid = ?;";
    }
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare unsubscribe: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, subscriber_ae.data(),
                      static_cast<int>(subscriber_ae.size()), SQLITE_TRANSIENT);
    if (!workitem_uid.empty()) {
        sqlite3_bind_text(stmt, 2, workitem_uid.data(),
                          static_cast<int>(workitem_uid.size()),
                          SQLITE_TRANSIENT);
    }
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to unsubscribe: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok(std::monostate{});
}

update_ups_workitem()

auto kcenon::pacs::storage::ups_repository::update_ups_workitem ( const ups_workitem & workitem ) -> VoidResult

nodiscard

Definition at line 948 of file ups_repository.cpp.

                  {
    if (workitem.workitem_uid.empty()) {
        return make_error<std::monostate>(
            -1, "UPS workitem UID is required for update", "storage");
    }
 
    auto existing = find_ups_workitem(workitem.workitem_uid);
    if (!existing.has_value()) {
        return make_error<std::monostate>(
            -1,
            kcenon::pacs::compat::format("UPS workitem not found: {}",
                                 workitem.workitem_uid),
            "storage");
    }
 
    if (existing->is_final()) {
        return make_error<std::monostate>(
            -1,
            kcenon::pacs::compat::format("Cannot update workitem in final state: {}",
                                 existing->state),
            "storage");
    }
 
    const char* sql = R"(
        UPDATE ups_workitems SET
            procedure_step_label = ?,
            worklist_label = ?,
            priority = ?,
            scheduled_start_datetime = ?,
            expected_completion_datetime = ?,
            scheduled_station_name = ?,
            scheduled_station_class = ?,
            scheduled_station_geographic = ?,
            scheduled_human_performers = ?,
            input_information = ?,
            performing_ae = ?,
            progress_description = ?,
            progress_percent = ?,
            output_information = ?,
            updated_at = datetime('now')
        WHERE workitem_uid = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare UPS update: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, workitem.procedure_step_label.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, workitem.worklist_label.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, workitem.priority.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 4, workitem.scheduled_start_datetime.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 5,
                      workitem.expected_completion_datetime.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, workitem.scheduled_station_name.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, workitem.scheduled_station_class.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 8,
                      workitem.scheduled_station_geographic.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 9,
                      workitem.scheduled_human_performers.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 10, workitem.input_information.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 11, workitem.performing_ae.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 12, workitem.progress_description.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 13, workitem.progress_percent);
    sqlite3_bind_text(stmt, 14, workitem.output_information.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 15, workitem.workitem_uid.c_str(), -1,
                      SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to update UPS workitem: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok(std::monostate{});
}

ups_workitem_count() [1/2]

auto kcenon::pacs::storage::ups_repository::ups_workitem_count ( ) const -> Result<size_t>

nodiscard

Definition at line 1269 of file ups_repository.cpp.

                                                                {
    const char* sql = "SELECT COUNT(*) FROM ups_workitems;";
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<size_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
    sqlite3_finalize(stmt);
    return ok(count);
}

References db_.

ups_workitem_count() [2/2]

auto kcenon::pacs::storage::ups_repository::ups_workitem_count ( std::string_view state ) const -> Result<size_t>

nodiscard

Definition at line 1289 of file ups_repository.cpp.

                      {
    const char* sql = "SELECT COUNT(*) FROM ups_workitems WHERE state = ?;";
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<size_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, state.data(), static_cast<int>(state.size()),
                      SQLITE_TRANSIENT);
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
    sqlite3_finalize(stmt);
    return ok(count);
}

Member Data Documentation

db_

sqlite3* kcenon::pacs::storage::ups_repository::db_ {nullptr}

private

Definition at line 144 of file ups_repository.h.

{nullptr};

Referenced by ups_workitem_count().

---

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

• include/kcenon/pacs/storage/ups_repository.h
• src/storage/ups_repository.cpp