kcenon::pacs::storage::viewer_state_repository Class Reference

Repository for viewer state persistence (legacy SQLite interface) More...

#include <viewer_state_repository.h>

Collaboration diagram for kcenon::pacs::storage::viewer_state_repository:

Public Member Functions
	viewer_state_repository (sqlite3 *db)
	~viewer_state_repository ()
	viewer_state_repository (const viewer_state_repository &)=delete
auto	operator= (const viewer_state_repository &) -> viewer_state_repository &=delete
	viewer_state_repository (viewer_state_repository &&) noexcept
auto	operator= (viewer_state_repository &&) noexcept -> viewer_state_repository &
auto	save_state (const viewer_state_record &record) -> VoidResult
auto	find_state_by_id (std::string_view state_id) const -> std::optional< viewer_state_record >
auto	find_states_by_study (std::string_view study_uid) const -> std::vector< viewer_state_record >
auto	search_states (const viewer_state_query &query) const -> std::vector< viewer_state_record >
auto	remove_state (std::string_view state_id) -> VoidResult
auto	count_states () const -> size_t
auto	record_study_access (std::string_view user_id, std::string_view study_uid) -> VoidResult
auto	get_recent_studies (std::string_view user_id, size_t limit=20) const -> std::vector< recent_study_record >
auto	clear_recent_studies (std::string_view user_id) -> VoidResult
auto	count_recent_studies (std::string_view user_id) const -> size_t
auto	is_valid () const noexcept -> bool

Private Member Functions
auto	parse_state_row (void *stmt) const -> viewer_state_record
auto	parse_recent_study_row (void *stmt) const -> recent_study_record

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for viewer state persistence (legacy SQLite interface)

This is the legacy interface maintained for builds without database_system.

Definition at line 229 of file viewer_state_repository.h.

Constructor & Destructor Documentation

viewer_state_repository() [1/3]

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

explicit

Definition at line 432 of file viewer_state_repository.cpp.

: db_(db) {}

~viewer_state_repository()

kcenon::pacs::storage::viewer_state_repository::~viewer_state_repository ( )

default

viewer_state_repository() [2/3]

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

delete

viewer_state_repository() [3/3]

kcenon::pacs::storage::viewer_state_repository::viewer_state_repository ( viewer_state_repository && )

defaultnoexcept

Member Function Documentation

clear_recent_studies()

VoidResult kcenon::pacs::storage::viewer_state_repository::clear_recent_studies ( std::string_view user_id ) -> VoidResult

nodiscard

Definition at line 693 of file viewer_state_repository.cpp.

                                                                               {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "viewer_state_repository"});
    }
 
    static constexpr const char* sql = "DELETE FROM recent_studies WHERE user_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, user_id.data(),
                      static_cast<int>(user_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to clear recent studies: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }

count_recent_studies()

size_t kcenon::pacs::storage::viewer_state_repository::count_recent_studies ( std::string_view user_id ) const -> size_t

nodiscard

Definition at line 723 of file viewer_state_repository.cpp.

                                                                                 {
    if (!db_) return 0;
 
    static constexpr const char* sql =
        "SELECT COUNT(*) FROM recent_studies WHERE user_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    sqlite3_bind_text(stmt, 1, user_id.data(),
                      static_cast<int>(user_id.size()), SQLITE_TRANSIENT);
 
    size_t result = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 

count_states()

size_t kcenon::pacs::storage::viewer_state_repository::count_states ( ) const -> size_t

nodiscard

Definition at line 597 of file viewer_state_repository.cpp.

                                                   {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM viewer_states";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    size_t result = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 

find_state_by_id()

std::optional< viewer_state_record > kcenon::pacs::storage::viewer_state_repository::find_state_by_id ( std::string_view state_id ) const -> std::optional<viewer_state_record>

nodiscard

Definition at line 489 of file viewer_state_repository.cpp.

                                   {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, state_id, study_uid, user_id, state_json, created_at, updated_at
        FROM viewer_states WHERE state_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, state_id.data(),
                      static_cast<int>(state_id.size()), SQLITE_TRANSIENT);
 
    std::optional<viewer_state_record> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_state_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_state_row().

Here is the call graph for this function:

find_states_by_study()

std::vector< viewer_state_record > kcenon::pacs::storage::viewer_state_repository::find_states_by_study ( std::string_view study_uid ) const -> std::vector<viewer_state_record>

nodiscard

Definition at line 515 of file viewer_state_repository.cpp.

                                    {
    viewer_state_query query;
    query.study_uid = std::string(study_uid);
    return search_states(query);
}

References search_states().

Here is the call graph for this function:

get_recent_studies()

std::vector< recent_study_record > kcenon::pacs::storage::viewer_state_repository::get_recent_studies ( std::string_view user_id, size_t limit = 20 ) const -> std::vector<recent_study_record>

nodiscard

Definition at line 662 of file viewer_state_repository.cpp.

                        {
    std::vector<recent_study_record> result;
    if (!db_) return result;
 
    static constexpr const char* sql = R"(
        SELECT pk, user_id, study_uid, accessed_at
        FROM recent_studies
        WHERE user_id = ?
        ORDER BY accessed_at DESC, pk DESC
        LIMIT ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    sqlite3_bind_text(stmt, 1, user_id.data(),
                      static_cast<int>(user_id.size()), SQLITE_TRANSIENT);
    sqlite3_bind_int64(stmt, 2, static_cast<int64_t>(limit));
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_recent_study_row(stmt));
    }
 

is_valid()

bool kcenon::pacs::storage::viewer_state_repository::is_valid ( ) const -> bool

nodiscardnoexcept

Definition at line 750 of file viewer_state_repository.cpp.

References db_.

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_recent_study_row()

recent_study_record kcenon::pacs::storage::viewer_state_repository::parse_recent_study_row ( void * stmt ) const -> recent_study_record

nodiscardprivate

Definition at line 778 of file viewer_state_repository.cpp.

                                                                                        {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    recent_study_record record;
 
    int col = 0;
    record.pk = get_int64_column(stmt, col++);
    record.user_id = get_text_column(stmt, col++);
    record.study_uid = get_text_column(stmt, col++);
 
    auto accessed_str = get_text_column(stmt, col++);
    record.accessed_at = from_timestamp_string(accessed_str.c_str());

parse_state_row()

viewer_state_record kcenon::pacs::storage::viewer_state_repository::parse_state_row ( void * stmt ) const -> viewer_state_record

nodiscardprivate

Definition at line 758 of file viewer_state_repository.cpp.

                                                                                 {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    viewer_state_record record;
 
    int col = 0;
    record.pk = get_int64_column(stmt, col++);
    record.state_id = get_text_column(stmt, col++);
    record.study_uid = get_text_column(stmt, col++);
    record.user_id = get_text_column(stmt, col++);
    record.state_json = get_text_column(stmt, col++);
 
    auto created_str = get_text_column(stmt, col++);
    record.created_at = from_timestamp_string(created_str.c_str());
 
    auto updated_str = get_text_column(stmt, col++);
    record.updated_at = from_timestamp_string(updated_str.c_str());

Referenced by find_state_by_id(), and search_states().

Here is the caller graph for this function:

record_study_access()

VoidResult kcenon::pacs::storage::viewer_state_repository::record_study_access ( std::string_view user_id, std::string_view study_uid ) -> VoidResult

nodiscard

Definition at line 620 of file viewer_state_repository.cpp.

                              {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "viewer_state_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO recent_studies (user_id, study_uid, accessed_at)
        VALUES (?, ?, ?)
        ON CONFLICT(user_id, study_uid) DO UPDATE SET
            accessed_at = excluded.accessed_at
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }
 
    auto now_str = to_timestamp_string(std::chrono::system_clock::now());
 
    sqlite3_bind_text(stmt, 1, user_id.data(),
                      static_cast<int>(user_id.size()), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, study_uid.data(),
                      static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, now_str.c_str(), -1, SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to record study access: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }

References db_.

remove_state()

VoidResult kcenon::pacs::storage::viewer_state_repository::remove_state ( std::string_view state_id ) -> VoidResult

nodiscard

Definition at line 567 of file viewer_state_repository.cpp.

                                                                        {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "viewer_state_repository"});
    }
 
    static constexpr const char* sql = "DELETE FROM viewer_states WHERE state_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, state_id.data(),
                      static_cast<int>(state_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to delete viewer state: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }

save_state()

VoidResult kcenon::pacs::storage::viewer_state_repository::save_state ( const viewer_state_record & record ) -> VoidResult

nodiscard

Definition at line 445 of file viewer_state_repository.cpp.

                                                                                {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "viewer_state_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO viewer_states (
            state_id, study_uid, user_id, state_json, created_at, updated_at
        ) VALUES (?, ?, ?, ?, ?, ?)
        ON CONFLICT(state_id) DO UPDATE SET
            state_json = excluded.state_json,
            updated_at = excluded.updated_at
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }
 
    auto now_str = to_timestamp_string(std::chrono::system_clock::now());
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, record.state_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.study_uid.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.user_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.state_json.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, now_str.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, now_str.c_str(), -1, SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to save viewer state: " + std::string(sqlite3_errmsg(db_)),
            "viewer_state_repository"});
    }
 
    return kcenon::common::ok();
}

search_states()

std::vector< viewer_state_record > kcenon::pacs::storage::viewer_state_repository::search_states ( const viewer_state_query & query ) const -> std::vector<viewer_state_record>

nodiscard

Definition at line 522 of file viewer_state_repository.cpp.

                                           {
    std::vector<viewer_state_record> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, state_id, study_uid, user_id, state_json, created_at, updated_at
        FROM viewer_states WHERE 1=1
    )";
 
    std::vector<std::pair<int, std::string>> bindings;
    int param_idx = 1;
 
    if (query.study_uid.has_value()) {
        sql << " AND study_uid = ?";
        bindings.emplace_back(param_idx++, query.study_uid.value());
    }
 
    if (query.user_id.has_value()) {
        sql << " AND user_id = ?";
        bindings.emplace_back(param_idx++, query.user_id.value());
    }
 
    sql << " ORDER BY updated_at DESC";
 
    if (query.limit > 0) {
        sql << " LIMIT " << query.limit << " OFFSET " << query.offset;
    }
 
    sqlite3_stmt* stmt = nullptr;
    auto sql_str = sql.str();
    if (sqlite3_prepare_v2(db_, sql_str.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    for (const auto& [idx, value] : bindings) {
        sqlite3_bind_text(stmt, idx, value.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_state_row(stmt));
    }
 

References db_, and parse_state_row().

Referenced by find_states_by_study().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

db_

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

private

Definition at line 266 of file viewer_state_repository.h.

{nullptr};

Referenced by find_state_by_id(), is_valid(), record_study_access(), and search_states().

---

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

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