kcenon::pacs::storage::sync_repository Class Reference

Repository for sync persistence (legacy SQLite interface) More...

#include <sync_repository.h>

Collaboration diagram for kcenon::pacs::storage::sync_repository:

Public Member Functions
	sync_repository (sqlite3 *db)
	~sync_repository ()
	sync_repository (const sync_repository &)=delete
auto	operator= (const sync_repository &) -> sync_repository &=delete
	sync_repository (sync_repository &&) noexcept
auto	operator= (sync_repository &&) noexcept -> sync_repository &
auto	save_config (const client::sync_config &config) -> VoidResult
auto	find_config (std::string_view config_id) const -> std::optional< client::sync_config >
auto	list_configs () const -> std::vector< client::sync_config >
auto	list_enabled_configs () const -> std::vector< client::sync_config >
auto	remove_config (std::string_view config_id) -> VoidResult
auto	update_config_stats (std::string_view config_id, bool success, size_t studies_synced) -> VoidResult
auto	save_conflict (const client::sync_conflict &conflict) -> VoidResult
auto	find_conflict (std::string_view study_uid) const -> std::optional< client::sync_conflict >
auto	list_conflicts (std::string_view config_id) const -> std::vector< client::sync_conflict >
auto	list_unresolved_conflicts () const -> std::vector< client::sync_conflict >
auto	resolve_conflict (std::string_view study_uid, client::conflict_resolution resolution) -> VoidResult
auto	cleanup_old_conflicts (std::chrono::hours max_age) -> Result< size_t >
auto	save_history (const client::sync_history &history) -> VoidResult
auto	list_history (std::string_view config_id, size_t limit=100) const -> std::vector< client::sync_history >
auto	get_last_history (std::string_view config_id) const -> std::optional< client::sync_history >
auto	cleanup_old_history (std::chrono::hours max_age) -> Result< size_t >
auto	count_configs () const -> size_t
auto	count_unresolved_conflicts () const -> size_t
auto	count_syncs_today () const -> size_t
auto	is_valid () const noexcept -> bool

Private Member Functions
auto	parse_config_row (void *stmt) const -> client::sync_config
auto	parse_conflict_row (void *stmt) const -> client::sync_conflict
auto	parse_history_row (void *stmt) const -> client::sync_history

Static Private Member Functions
static auto	serialize_vector (const std::vector< std::string > &vec) -> std::string
static auto	deserialize_vector (std::string_view json) -> std::vector< std::string >

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for sync persistence (legacy SQLite interface)

This is the legacy interface maintained for builds without database_system. New code should use the pacs_database_adapter version when PACS_WITH_DATABASE_SYSTEM is defined.

Definition at line 375 of file sync_repository.h.

Constructor & Destructor Documentation

sync_repository() [1/3]

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

explicit

Definition at line 879 of file sync_repository.cpp.

: db_(db) {}

~sync_repository()

kcenon::pacs::storage::sync_repository::~sync_repository ( )

default

sync_repository() [2/3]

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

delete

sync_repository() [3/3]

kcenon::pacs::storage::sync_repository::sync_repository ( sync_repository && )

defaultnoexcept

Member Function Documentation

cleanup_old_conflicts()

Result< size_t > kcenon::pacs::storage::sync_repository::cleanup_old_conflicts ( std::chrono::hours max_age ) -> Result<size_t>

nodiscard

Definition at line 1310 of file sync_repository.cpp.

                                                                            {
    if (!db_) {
        return kcenon::common::make_error<size_t>(-1,
            "Database not initialized", "sync_repository");
    }
 
    auto cutoff = std::chrono::system_clock::now() - max_age;
    auto cutoff_str = to_timestamp_string(cutoff);
 
    const char* sql = R"(
        DELETE FROM sync_conflicts WHERE resolved = 1 AND resolved_at < ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return kcenon::common::make_error<size_t>(-1,
            "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository");
    }
 
    sqlite3_bind_text(stmt, 1, cutoff_str.c_str(), -1, SQLITE_TRANSIENT);
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return kcenon::common::make_error<size_t>(-1,
            "Failed to cleanup conflicts: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository");
    }
 
    return static_cast<size_t>(sqlite3_changes(db_));
}

References db_.

cleanup_old_history()

Result< size_t > kcenon::pacs::storage::sync_repository::cleanup_old_history ( std::chrono::hours max_age ) -> Result<size_t>

nodiscard

Definition at line 1446 of file sync_repository.cpp.

                                                                          {
    if (!db_) {
        return kcenon::common::make_error<size_t>(-1,
            "Database not initialized", "sync_repository");
    }
 
    auto cutoff = std::chrono::system_clock::now() - max_age;
    auto cutoff_str = to_timestamp_string(cutoff);
 
    const char* sql = "DELETE FROM sync_history WHERE completed_at < ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return kcenon::common::make_error<size_t>(-1,
            "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository");
    }
 
    sqlite3_bind_text(stmt, 1, cutoff_str.c_str(), -1, SQLITE_TRANSIENT);
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return kcenon::common::make_error<size_t>(-1,
            "Failed to cleanup history: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository");
    }
 
    return static_cast<size_t>(sqlite3_changes(db_));
}

References db_.

count_configs()

size_t kcenon::pacs::storage::sync_repository::count_configs ( ) const -> size_t

nodiscard

Definition at line 1482 of file sync_repository.cpp.

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

References db_.

count_syncs_today()

size_t kcenon::pacs::storage::sync_repository::count_syncs_today ( ) const -> size_t

nodiscard

Definition at line 1520 of file sync_repository.cpp.

                                                {
    if (!db_) return 0;
 
    const char* sql = R"(
        SELECT COUNT(*) FROM sync_history
        WHERE date(completed_at) = date('now')
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return count;
}

References db_.

count_unresolved_conflicts()

size_t kcenon::pacs::storage::sync_repository::count_unresolved_conflicts ( ) const -> size_t

nodiscard

Definition at line 1501 of file sync_repository.cpp.

                                                         {
    if (!db_) return 0;
 
    const char* sql = "SELECT COUNT(*) FROM sync_conflicts WHERE resolved = 0";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return count;
}

References db_.

deserialize_vector()

std::vector< std::string > kcenon::pacs::storage::sync_repository::deserialize_vector ( std::string_view json ) -> std::vector<std::string>

staticnodiscardprivate

Definition at line 836 of file sync_repository.cpp.

                                                                            {
    std::vector<std::string> result;
    if (json.empty() || json == "[]") return result;
 
    size_t pos = 0;
    while (pos < json.size()) {
        auto start = json.find('"', pos);
        if (start == std::string_view::npos) break;
 
        size_t end = start + 1;
        while (end < json.size()) {
            if (json[end] == '\\' && end + 1 < json.size()) {
                end += 2;
            } else if (json[end] == '"') {
                break;
            } else {
                ++end;
            }
        }
 
        if (end < json.size()) {
            std::string value{json.substr(start + 1, end - start - 1)};
            std::string unescaped;
            for (size_t i = 0; i < value.size(); ++i) {
                if (value[i] == '\\' && i + 1 < value.size()) {
                    unescaped += value[++i];
                } else {
                    unescaped += value[i];
                }
            }
            result.push_back(std::move(unescaped));
        }
 
        pos = end + 1;
    }
 
    return result;
}

Referenced by parse_config_row(), and parse_history_row().

Here is the caller graph for this function:

find_config()

std::optional< client::sync_config > kcenon::pacs::storage::sync_repository::find_config ( std::string_view config_id ) const -> std::optional<client::sync_config>

nodiscard

Definition at line 959 of file sync_repository.cpp.

                                    {
    if (!db_) return std::nullopt;
 
    const char* sql = R"(
        SELECT pk, config_id, source_node_id, name, enabled,
               lookback_hours, modalities_json, patient_patterns_json,
               sync_direction, delete_missing, overwrite_existing, sync_metadata_only,
               schedule_cron, last_sync, last_successful_sync,
               total_syncs, studies_synced
        FROM sync_configs WHERE config_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
 
    std::optional<client::sync_config> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_config_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_config_row().

Here is the call graph for this function:

find_conflict()

std::optional< client::sync_conflict > kcenon::pacs::storage::sync_repository::find_conflict ( std::string_view study_uid ) const -> std::optional<client::sync_conflict>

nodiscard

Definition at line 1191 of file sync_repository.cpp.

                                    {
    if (!db_) return std::nullopt;
 
    const char* sql = R"(
        SELECT pk, config_id, study_uid, patient_id, conflict_type,
               local_modified, remote_modified,
               local_instance_count, remote_instance_count,
               resolved, resolution, detected_at, resolved_at
        FROM sync_conflicts WHERE study_uid = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, study_uid.data(), static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
 
    std::optional<client::sync_conflict> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_conflict_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_conflict_row().

Here is the call graph for this function:

get_last_history()

std::optional< client::sync_history > kcenon::pacs::storage::sync_repository::get_last_history ( std::string_view config_id ) const -> std::optional<client::sync_history>

nodiscard

Definition at line 1419 of file sync_repository.cpp.

                                    {
    if (!db_) return std::nullopt;
 
    const char* sql = R"(
        SELECT pk, config_id, job_id, success,
               studies_checked, studies_synced, conflicts_found,
               errors_json, started_at, completed_at
        FROM sync_history WHERE config_id = ? ORDER BY started_at DESC LIMIT 1
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
 
    std::optional<client::sync_history> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_history_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_history_row().

Here is the call graph for this function:

is_valid()

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

nodiscardnoexcept

Definition at line 1546 of file sync_repository.cpp.

                                              {
    return db_ != nullptr;
}

References db_.

list_configs()

std::vector< client::sync_config > kcenon::pacs::storage::sync_repository::list_configs ( ) const -> std::vector<client::sync_config>

nodiscard

Definition at line 988 of file sync_repository.cpp.

                                                                 {
    std::vector<client::sync_config> result;
    if (!db_) return result;
 
    const char* sql = R"(
        SELECT pk, config_id, source_node_id, name, enabled,
               lookback_hours, modalities_json, patient_patterns_json,
               sync_direction, delete_missing, overwrite_existing, sync_metadata_only,
               schedule_cron, last_sync, last_successful_sync,
               total_syncs, studies_synced
        FROM sync_configs ORDER BY name
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_config_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_config_row().

Here is the call graph for this function:

list_conflicts()

std::vector< client::sync_conflict > kcenon::pacs::storage::sync_repository::list_conflicts ( std::string_view config_id ) const -> std::vector<client::sync_conflict>

nodiscard

Definition at line 1219 of file sync_repository.cpp.

                                    {
    std::vector<client::sync_conflict> result;
    if (!db_) return result;
 
    const char* sql = R"(
        SELECT pk, config_id, study_uid, patient_id, conflict_type,
               local_modified, remote_modified,
               local_instance_count, remote_instance_count,
               resolved, resolution, detected_at, resolved_at
        FROM sync_conflicts WHERE config_id = ? ORDER BY detected_at DESC
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    sqlite3_bind_text(stmt, 1, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_conflict_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_conflict_row().

Here is the call graph for this function:

list_enabled_configs()

std::vector< client::sync_config > kcenon::pacs::storage::sync_repository::list_enabled_configs ( ) const -> std::vector<client::sync_config>

nodiscard

Definition at line 1014 of file sync_repository.cpp.

                                                                         {
    std::vector<client::sync_config> result;
    if (!db_) return result;
 
    const char* sql = R"(
        SELECT pk, config_id, source_node_id, name, enabled,
               lookback_hours, modalities_json, patient_patterns_json,
               sync_direction, delete_missing, overwrite_existing, sync_metadata_only,
               schedule_cron, last_sync, last_successful_sync,
               total_syncs, studies_synced
        FROM sync_configs WHERE enabled = 1 ORDER BY name
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_config_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_config_row().

Here is the call graph for this function:

list_history()

std::vector< client::sync_history > kcenon::pacs::storage::sync_repository::list_history ( std::string_view config_id, size_t limit = 100 ) const -> std::vector<client::sync_history>

nodiscard

Definition at line 1391 of file sync_repository.cpp.

                                                  {
    std::vector<client::sync_history> result;
    if (!db_) return result;
 
    const char* sql = R"(
        SELECT pk, config_id, job_id, success,
               studies_checked, studies_synced, conflicts_found,
               errors_json, started_at, completed_at
        FROM sync_history WHERE config_id = ? ORDER BY started_at DESC LIMIT ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    sqlite3_bind_text(stmt, 1, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
    sqlite3_bind_int64(stmt, 2, static_cast<int64_t>(limit));
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_history_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_history_row().

Here is the call graph for this function:

list_unresolved_conflicts()

std::vector< client::sync_conflict > kcenon::pacs::storage::sync_repository::list_unresolved_conflicts ( ) const -> std::vector<client::sync_conflict>

nodiscard

Definition at line 1247 of file sync_repository.cpp.

                                                                                {
    std::vector<client::sync_conflict> result;
    if (!db_) return result;
 
    const char* sql = R"(
        SELECT pk, config_id, study_uid, patient_id, conflict_type,
               local_modified, remote_modified,
               local_instance_count, remote_instance_count,
               resolved, resolution, detected_at, resolved_at
        FROM sync_conflicts WHERE resolved = 0 ORDER BY detected_at DESC
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_conflict_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_conflict_row().

Here is the call graph for this function:

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_config_row()

client::sync_config kcenon::pacs::storage::sync_repository::parse_config_row ( void * stmt ) const -> client::sync_config

nodiscardprivate

Definition at line 1554 of file sync_repository.cpp.

                                                                        {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::sync_config config;
 
    config.pk = get_int64_column(stmt, 0);
    config.config_id = get_text_column(stmt, 1);
    config.source_node_id = get_text_column(stmt, 2);
    config.name = get_text_column(stmt, 3);
    config.enabled = get_int_column(stmt, 4) != 0;
    config.lookback = std::chrono::hours(get_int_column(stmt, 5, 24));
    config.modalities = deserialize_vector(get_text_column(stmt, 6));
    config.patient_id_patterns = deserialize_vector(get_text_column(stmt, 7));
    config.direction = client::sync_direction_from_string(get_text_column(stmt, 8));
    config.delete_missing = get_int_column(stmt, 9) != 0;
    config.overwrite_existing = get_int_column(stmt, 10) != 0;
    config.sync_metadata_only = get_int_column(stmt, 11) != 0;
    config.schedule_cron = get_text_column(stmt, 12);
    config.last_sync = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 13)));
    config.last_successful_sync = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 14)));
    config.total_syncs = static_cast<size_t>(get_int64_column(stmt, 15));
    config.studies_synced = static_cast<size_t>(get_int64_column(stmt, 16));
 
    return config;
}

References kcenon::pacs::client::sync_config::config_id, kcenon::pacs::client::sync_config::delete_missing, deserialize_vector(), kcenon::pacs::client::sync_config::direction, kcenon::pacs::client::sync_config::enabled, kcenon::pacs::client::sync_config::last_successful_sync, kcenon::pacs::client::sync_config::last_sync, kcenon::pacs::client::sync_config::lookback, kcenon::pacs::client::sync_config::modalities, kcenon::pacs::client::sync_config::name, kcenon::pacs::client::sync_config::overwrite_existing, kcenon::pacs::client::sync_config::patient_id_patterns, kcenon::pacs::client::sync_config::pk, kcenon::pacs::client::sync_config::schedule_cron, kcenon::pacs::client::sync_config::source_node_id, kcenon::pacs::client::sync_config::studies_synced, kcenon::pacs::client::sync_direction_from_string(), kcenon::pacs::client::sync_config::sync_metadata_only, and kcenon::pacs::client::sync_config::total_syncs.

Referenced by find_config(), list_configs(), and list_enabled_configs().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_conflict_row()

client::sync_conflict kcenon::pacs::storage::sync_repository::parse_conflict_row ( void * stmt ) const -> client::sync_conflict

nodiscardprivate

Definition at line 1581 of file sync_repository.cpp.

                                                                            {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::sync_conflict conflict;
 
    conflict.pk = get_int64_column(stmt, 0);
    conflict.config_id = get_text_column(stmt, 1);
    conflict.study_uid = get_text_column(stmt, 2);
    conflict.patient_id = get_text_column(stmt, 3);
    conflict.conflict_type = client::sync_conflict_type_from_string(get_text_column(stmt, 4));
    conflict.local_modified = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 5)));
    conflict.remote_modified = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 6)));
    conflict.local_instance_count = static_cast<size_t>(get_int64_column(stmt, 7));
    conflict.remote_instance_count = static_cast<size_t>(get_int64_column(stmt, 8));
    conflict.resolved = get_int_column(stmt, 9) != 0;
    conflict.resolution_used = client::conflict_resolution_from_string(get_text_column(stmt, 10));
    conflict.detected_at = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 11)));
 
    auto resolved_at_str = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 12));
    if (resolved_at_str && resolved_at_str[0] != '\0') {
        conflict.resolved_at = from_timestamp_string(resolved_at_str);
    }
 
    return conflict;
}

References kcenon::pacs::client::conflict_resolution_from_string(), and kcenon::pacs::client::sync_conflict_type_from_string().

Referenced by find_conflict(), list_conflicts(), and list_unresolved_conflicts().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_history_row()

client::sync_history kcenon::pacs::storage::sync_repository::parse_history_row ( void * stmt ) const -> client::sync_history

nodiscardprivate

Definition at line 1609 of file sync_repository.cpp.

                                                                          {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::sync_history history;
 
    history.pk = get_int64_column(stmt, 0);
    history.config_id = get_text_column(stmt, 1);
    history.job_id = get_text_column(stmt, 2);
    history.success = get_int_column(stmt, 3) != 0;
    history.studies_checked = static_cast<size_t>(get_int64_column(stmt, 4));
    history.studies_synced = static_cast<size_t>(get_int64_column(stmt, 5));
    history.conflicts_found = static_cast<size_t>(get_int64_column(stmt, 6));
    history.errors = deserialize_vector(get_text_column(stmt, 7));
    history.started_at = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 8)));
    history.completed_at = from_timestamp_string(
        reinterpret_cast<const char*>(sqlite3_column_text(stmt, 9)));
 
    return history;
}

References kcenon::pacs::client::sync_history::completed_at, kcenon::pacs::client::sync_history::config_id, kcenon::pacs::client::sync_history::conflicts_found, deserialize_vector(), kcenon::pacs::client::sync_history::errors, kcenon::pacs::client::sync_history::job_id, kcenon::pacs::client::sync_history::pk, kcenon::pacs::client::sync_history::started_at, kcenon::pacs::client::sync_history::studies_checked, kcenon::pacs::client::sync_history::studies_synced, and kcenon::pacs::client::sync_history::success.

Referenced by get_last_history(), and list_history().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_config()

VoidResult kcenon::pacs::storage::sync_repository::remove_config ( std::string_view config_id ) -> VoidResult

nodiscard

Definition at line 1040 of file sync_repository.cpp.

                                                                  {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "sync_repository"});
    }
 
    const char* sql = "DELETE FROM sync_configs WHERE config_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_)),
            "sync_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to delete config: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    return kcenon::common::ok();
}

References db_.

resolve_conflict()

VoidResult kcenon::pacs::storage::sync_repository::resolve_conflict ( std::string_view study_uid, client::conflict_resolution resolution ) -> VoidResult

nodiscard

Definition at line 1272 of file sync_repository.cpp.

                                          {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "sync_repository"});
    }
 
    const char* sql = R"(
        UPDATE sync_conflicts SET
            resolved = 1,
            resolution = ?,
            resolved_at = datetime('now')
        WHERE study_uid = ? AND resolved = 0
    )";
 
    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_)),
            "sync_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, to_string(resolution), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, study_uid.data(), static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to resolve conflict: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    return kcenon::common::ok();
}

References db_, and kcenon::pacs::storage::to_string().

Here is the call graph for this function:

save_config()

VoidResult kcenon::pacs::storage::sync_repository::save_config ( const client::sync_config & config ) -> VoidResult

nodiscard

Definition at line 890 of file sync_repository.cpp.

                                                                       {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "sync_repository"});
    }
 
    const char* sql = R"(
        INSERT INTO sync_configs (
            config_id, source_node_id, name, enabled,
            lookback_hours, modalities_json, patient_patterns_json,
            sync_direction, delete_missing, overwrite_existing, sync_metadata_only,
            schedule_cron, last_sync, last_successful_sync,
            total_syncs, studies_synced
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(config_id) DO UPDATE SET
            source_node_id = excluded.source_node_id,
            name = excluded.name,
            enabled = excluded.enabled,
            lookback_hours = excluded.lookback_hours,
            modalities_json = excluded.modalities_json,
            patient_patterns_json = excluded.patient_patterns_json,
            sync_direction = excluded.sync_direction,
            delete_missing = excluded.delete_missing,
            overwrite_existing = excluded.overwrite_existing,
            sync_metadata_only = excluded.sync_metadata_only,
            schedule_cron = excluded.schedule_cron,
            last_sync = excluded.last_sync,
            last_successful_sync = excluded.last_successful_sync,
            total_syncs = excluded.total_syncs,
            studies_synced = excluded.studies_synced,
            updated_at = datetime('now')
    )";
 
    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_)),
            "sync_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, config.config_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, config.source_node_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, config.name.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 4, config.enabled ? 1 : 0);
    sqlite3_bind_int(stmt, 5, static_cast<int>(config.lookback.count()));
    sqlite3_bind_text(stmt, 6, serialize_vector(config.modalities).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, serialize_vector(config.patient_id_patterns).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 8, to_string(config.direction), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 9, config.delete_missing ? 1 : 0);
    sqlite3_bind_int(stmt, 10, config.overwrite_existing ? 1 : 0);
    sqlite3_bind_int(stmt, 11, config.sync_metadata_only ? 1 : 0);
    sqlite3_bind_text(stmt, 12, config.schedule_cron.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 13, to_timestamp_string(config.last_sync).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 14, to_timestamp_string(config.last_successful_sync).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int64(stmt, 15, static_cast<int64_t>(config.total_syncs));
    sqlite3_bind_int64(stmt, 16, static_cast<int64_t>(config.studies_synced));
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to save config: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    return kcenon::common::ok();
}

References kcenon::pacs::storage::to_string().

Here is the call graph for this function:

save_conflict()

VoidResult kcenon::pacs::storage::sync_repository::save_conflict ( const client::sync_conflict & conflict ) -> VoidResult

nodiscard

Definition at line 1129 of file sync_repository.cpp.

                                                                             {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "sync_repository"});
    }
 
    const char* sql = R"(
        INSERT INTO sync_conflicts (
            config_id, study_uid, patient_id, conflict_type,
            local_modified, remote_modified,
            local_instance_count, remote_instance_count,
            resolved, resolution, detected_at, resolved_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(config_id, study_uid) DO UPDATE SET
            patient_id = excluded.patient_id,
            conflict_type = excluded.conflict_type,
            local_modified = excluded.local_modified,
            remote_modified = excluded.remote_modified,
            local_instance_count = excluded.local_instance_count,
            remote_instance_count = excluded.remote_instance_count,
            resolved = excluded.resolved,
            resolution = excluded.resolution,
            detected_at = excluded.detected_at,
            resolved_at = excluded.resolved_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_)),
            "sync_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, conflict.config_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, conflict.study_uid.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, conflict.patient_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 4, to_string(conflict.conflict_type), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 5, to_timestamp_string(conflict.local_modified).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, to_timestamp_string(conflict.remote_modified).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int64(stmt, 7, static_cast<int64_t>(conflict.local_instance_count));
    sqlite3_bind_int64(stmt, 8, static_cast<int64_t>(conflict.remote_instance_count));
    sqlite3_bind_int(stmt, 9, conflict.resolved ? 1 : 0);
    sqlite3_bind_text(stmt, 10, conflict.resolved ? to_string(conflict.resolution_used) : "", -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 11, to_timestamp_string(conflict.detected_at).c_str(), -1, SQLITE_TRANSIENT);
    if (conflict.resolved_at.has_value()) {
        sqlite3_bind_text(stmt, 12, to_timestamp_string(conflict.resolved_at.value()).c_str(), -1, SQLITE_TRANSIENT);
    } else {
        sqlite3_bind_null(stmt, 12);
    }
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to save conflict: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    return kcenon::common::ok();
}

References db_, and kcenon::pacs::storage::to_string().

Here is the call graph for this function:

save_history()

VoidResult kcenon::pacs::storage::sync_repository::save_history ( const client::sync_history & history ) -> VoidResult

nodiscard

Definition at line 1348 of file sync_repository.cpp.

                                                                          {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "sync_repository"});
    }
 
    const char* sql = R"(
        INSERT INTO sync_history (
            config_id, job_id, success,
            studies_checked, studies_synced, conflicts_found,
            errors_json, started_at, completed_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
    )";
 
    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_)),
            "sync_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, history.config_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, history.job_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 3, history.success ? 1 : 0);
    sqlite3_bind_int64(stmt, 4, static_cast<int64_t>(history.studies_checked));
    sqlite3_bind_int64(stmt, 5, static_cast<int64_t>(history.studies_synced));
    sqlite3_bind_int64(stmt, 6, static_cast<int64_t>(history.conflicts_found));
    sqlite3_bind_text(stmt, 7, serialize_vector(history.errors).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 8, to_timestamp_string(history.started_at).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 9, to_timestamp_string(history.completed_at).c_str(), -1, SQLITE_TRANSIENT);
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to save history: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    return kcenon::common::ok();
}

References kcenon::pacs::client::sync_history::completed_at, kcenon::pacs::client::sync_history::config_id, kcenon::pacs::client::sync_history::conflicts_found, db_, kcenon::pacs::client::sync_history::errors, kcenon::pacs::client::sync_history::job_id, serialize_vector(), kcenon::pacs::client::sync_history::started_at, kcenon::pacs::client::sync_history::studies_checked, kcenon::pacs::client::sync_history::studies_synced, and kcenon::pacs::client::sync_history::success.

Here is the call graph for this function:

serialize_vector()

std::string kcenon::pacs::storage::sync_repository::serialize_vector ( const std::vector< std::string > & vec ) -> std::string

staticnodiscardprivate

Definition at line 817 of file sync_repository.cpp.

                                                                           {
    if (vec.empty()) return "[]";
 
    std::ostringstream oss;
    oss << "[";
    for (size_t i = 0; i < vec.size(); ++i) {
        if (i > 0) oss << ",";
        oss << "\"";
        for (char c : vec[i]) {
            if (c == '"') oss << "\\\"";
            else if (c == '\\') oss << "\\\\";
            else oss << c;
        }
        oss << "\"";
    }
    oss << "]";
    return oss.str();
}

Referenced by save_history().

Here is the caller graph for this function:

update_config_stats()

VoidResult kcenon::pacs::storage::sync_repository::update_config_stats ( std::string_view config_id, bool success, size_t studies_synced ) -> VoidResult

nodiscard

Definition at line 1069 of file sync_repository.cpp.

                           {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "sync_repository"});
    }
 
    std::string sql;
    if (success) {
        sql = R"(
            UPDATE sync_configs SET
                total_syncs = total_syncs + 1,
                studies_synced = studies_synced + ?,
                last_sync = datetime('now'),
                last_successful_sync = datetime('now'),
                updated_at = datetime('now')
            WHERE config_id = ?
        )";
    } else {
        sql = R"(
            UPDATE sync_configs SET
                total_syncs = total_syncs + 1,
                last_sync = datetime('now'),
                updated_at = datetime('now')
            WHERE config_id = ?
        )";
    }
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    if (success) {
        sqlite3_bind_int64(stmt, 1, static_cast<int64_t>(studies_synced));
        sqlite3_bind_text(stmt, 2, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
    } else {
        sqlite3_bind_text(stmt, 1, config_id.data(), static_cast<int>(config_id.size()), SQLITE_TRANSIENT);
    }
 
    int rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to update config stats: " + std::string(sqlite3_errmsg(db_)),
            "sync_repository"});
    }
 
    return kcenon::common::ok();
}

References db_, and kcenon::pacs::storage::success.

Member Data Documentation

db_

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

private

Definition at line 434 of file sync_repository.h.

{nullptr};

Referenced by cleanup_old_conflicts(), cleanup_old_history(), count_configs(), count_syncs_today(), count_unresolved_conflicts(), find_config(), find_conflict(), get_last_history(), is_valid(), list_configs(), list_conflicts(), list_enabled_configs(), list_history(), list_unresolved_conflicts(), remove_config(), resolve_conflict(), save_conflict(), save_history(), and update_config_stats().

---

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

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