kcenon::pacs::storage::routing_repository Class Reference

Repository for routing rule persistence (legacy SQLite interface) More...

#include <routing_repository.h>

Collaboration diagram for kcenon::pacs::storage::routing_repository:

Public Member Functions
	routing_repository (sqlite3 *db)
	~routing_repository ()
	routing_repository (const routing_repository &)=delete
auto	operator= (const routing_repository &) -> routing_repository &=delete
	routing_repository (routing_repository &&) noexcept
auto	operator= (routing_repository &&) noexcept -> routing_repository &
auto	save (const client::routing_rule &rule) -> VoidResult
auto	find_by_id (std::string_view rule_id) const -> std::optional< client::routing_rule >
auto	find_by_pk (int64_t pk) const -> std::optional< client::routing_rule >
auto	find_rules (const routing_rule_query_options &options={}) const -> std::vector< client::routing_rule >
auto	find_enabled_rules () const -> std::vector< client::routing_rule >
auto	remove (std::string_view rule_id) -> VoidResult
auto	exists (std::string_view rule_id) const -> bool
auto	update_priority (std::string_view rule_id, int priority) -> VoidResult
auto	enable_rule (std::string_view rule_id) -> VoidResult
auto	disable_rule (std::string_view rule_id) -> VoidResult
auto	increment_triggered (std::string_view rule_id) -> VoidResult
auto	increment_success (std::string_view rule_id) -> VoidResult
auto	increment_failure (std::string_view rule_id) -> VoidResult
auto	reset_statistics (std::string_view rule_id) -> VoidResult
auto	count () const -> size_t
auto	count_enabled () const -> size_t
auto	is_valid () const noexcept -> bool

Private Member Functions
auto	parse_row (void *stmt) const -> client::routing_rule

Static Private Member Functions
static auto	serialize_conditions (const std::vector< client::routing_condition > &conditions) -> std::string
static auto	deserialize_conditions (std::string_view json) -> std::vector< client::routing_condition >
static auto	serialize_actions (const std::vector< client::routing_action > &actions) -> std::string
static auto	deserialize_actions (std::string_view json) -> std::vector< client::routing_action >

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for routing rule persistence (legacy SQLite interface)

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

Definition at line 266 of file routing_repository.h.

Constructor & Destructor Documentation

routing_repository() [1/3]

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

explicit

Definition at line 1062 of file routing_repository.cpp.

: db_(db) {}

~routing_repository()

kcenon::pacs::storage::routing_repository::~routing_repository ( )

default

routing_repository() [2/3]

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

delete

routing_repository() [3/3]

kcenon::pacs::storage::routing_repository::routing_repository ( routing_repository && )

defaultnoexcept

Member Function Documentation

count()

size_t kcenon::pacs::storage::routing_repository::count ( ) const -> size_t

nodiscard

Definition at line 1549 of file routing_repository.cpp.

                                           : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
size_t routing_repository::count() const {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM routing_rules";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    size_t result = 0;

count_enabled()

size_t kcenon::pacs::storage::routing_repository::count_enabled ( ) const -> size_t

nodiscard

Definition at line 1568 of file routing_repository.cpp.

                                               {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM routing_rules WHERE enabled = 1";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    size_t result = 0;

deserialize_actions()

std::vector< client::routing_action > kcenon::pacs::storage::routing_repository::deserialize_actions ( std::string_view json ) -> std::vector<client::routing_action>

staticnodiscardprivate

Definition at line 996 of file routing_repository.cpp.

                         {
    std::vector<client::routing_action> result;
    if (json.empty() || json == "[]") return result;
 
    size_t pos = 0;
    while (pos < json.size()) {
        auto obj_start = json.find('{', pos);
        if (obj_start == std::string_view::npos) break;
 
        auto obj_end = json.find('}', obj_start);
        if (obj_end == std::string_view::npos) break;
 
        auto obj = json.substr(obj_start, obj_end - obj_start + 1);
 
        client::routing_action action;
 
        // Parse destination
        auto dest_pos = obj.find("\"destination\"");
        if (dest_pos != std::string_view::npos) {
            auto [dest_value, next] = extract_json_string(obj, dest_pos + 13);
            action.destination_node_id = dest_value;
        }
 
        // Parse priority
        auto prio_pos = obj.find("\"priority\"");
        if (prio_pos != std::string_view::npos) {
            auto [prio_value, next] = extract_json_string(obj, prio_pos + 10);
            action.priority = client::job_priority_from_string(prio_value);
        }
 
        // Parse delay_minutes
        auto delay_pos = obj.find("\"delay_minutes\"");
        if (delay_pos != std::string_view::npos) {
            auto colon = obj.find(':', delay_pos);
            if (colon != std::string_view::npos) {
                int minutes = 0;
                std::sscanf(obj.data() + colon + 1, "%d", &minutes);
                action.delay = std::chrono::minutes{minutes};
            }
        }
 
        // Parse delete_after_send
        auto delete_pos = obj.find("\"delete_after_send\"");
        if (delete_pos != std::string_view::npos) {
            action.delete_after_send = (obj.find("true", delete_pos) != std::string_view::npos &&
                                        obj.find("true", delete_pos) < obj.find(',', delete_pos + 20));
        }
 
        // Parse notify_on_failure
        auto notify_pos = obj.find("\"notify_on_failure\"");
        if (notify_pos != std::string_view::npos) {
            action.notify_on_failure = (obj.find("true", notify_pos) != std::string_view::npos);
        }
 
        result.push_back(std::move(action));
        pos = obj_end + 1;
    }
 
    return result;
}

References kcenon::pacs::client::routing_action::delay, kcenon::pacs::client::routing_action::delete_after_send, kcenon::pacs::client::routing_action::destination_node_id, kcenon::pacs::client::job_priority_from_string(), kcenon::pacs::client::routing_action::notify_on_failure, and kcenon::pacs::client::routing_action::priority.

Here is the call graph for this function:

deserialize_conditions()

std::vector< client::routing_condition > kcenon::pacs::storage::routing_repository::deserialize_conditions ( std::string_view json ) -> std::vector<client::routing_condition>

staticnodiscardprivate

Definition at line 920 of file routing_repository.cpp.

                         {
    std::vector<client::routing_condition> result;
    if (json.empty() || json == "[]") return result;
 
    size_t pos = 0;
    while (pos < json.size()) {
        auto obj_start = json.find('{', pos);
        if (obj_start == std::string_view::npos) break;
 
        auto obj_end = json.find('}', obj_start);
        if (obj_end == std::string_view::npos) break;
 
        auto obj = json.substr(obj_start, obj_end - obj_start + 1);
 
        client::routing_condition cond;
 
        // Parse field
        auto field_pos = obj.find("\"field\"");
        if (field_pos != std::string_view::npos) {
            auto [field_value, next] = extract_json_string(obj, field_pos + 7);
            cond.match_field = client::routing_field_from_string(field_value);
        }
 
        // Parse pattern
        auto pattern_pos = obj.find("\"pattern\"");
        if (pattern_pos != std::string_view::npos) {
            auto [pattern_value, next] = extract_json_string(obj, pattern_pos + 9);
            cond.pattern = pattern_value;
        }
 
        // Parse case_sensitive
        auto case_pos = obj.find("\"case_sensitive\"");
        if (case_pos != std::string_view::npos) {
            cond.case_sensitive = (obj.find("true", case_pos) != std::string_view::npos &&
                                   obj.find("true", case_pos) < obj.find(',', case_pos));
        }
 
        // Parse negate
        auto negate_pos = obj.find("\"negate\"");
        if (negate_pos != std::string_view::npos) {
            cond.negate = (obj.find("true", negate_pos) != std::string_view::npos);
        }
 
        result.push_back(std::move(cond));
        pos = obj_end + 1;
    }
 
    return result;
}

References kcenon::pacs::client::routing_condition::case_sensitive, kcenon::pacs::client::routing_condition::match_field, kcenon::pacs::client::routing_condition::negate, kcenon::pacs::client::routing_condition::pattern, and kcenon::pacs::client::routing_field_from_string().

Here is the call graph for this function:

disable_rule()

VoidResult kcenon::pacs::storage::routing_repository::disable_rule ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1379 of file routing_repository.cpp.

                                      : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult routing_repository::disable_rule(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET
            enabled = 0,
            updated_at = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

enable_rule()

VoidResult kcenon::pacs::storage::routing_repository::enable_rule ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1345 of file routing_repository.cpp.

                                          : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult routing_repository::enable_rule(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET
            enabled = 1,
            updated_at = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

exists()

bool kcenon::pacs::storage::routing_repository::exists ( std::string_view rule_id ) const -> bool

nodiscard

Definition at line 1289 of file routing_repository.cpp.

                                      : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
bool routing_repository::exists(std::string_view rule_id) const {
    if (!db_) return false;
 
    static constexpr const char* sql = "SELECT 1 FROM routing_rules WHERE rule_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return false;
    }

find_by_id()

std::optional< client::routing_rule > kcenon::pacs::storage::routing_repository::find_by_id ( std::string_view rule_id ) const -> std::optional<client::routing_rule>

nodiscard

Definition at line 1162 of file routing_repository.cpp.

                                  {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, rule_id, name, description, enabled, priority,
               conditions_json, actions_json,
               schedule_cron, effective_from, effective_until,
               triggered_count, success_count, failure_count,
               last_triggered, created_at, updated_at
        FROM routing_rules WHERE rule_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    std::optional<client::routing_rule> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_row().

Here is the call graph for this function:

find_by_pk()

std::optional< client::routing_rule > kcenon::pacs::storage::routing_repository::find_by_pk ( int64_t pk ) const -> std::optional<client::routing_rule>

nodiscard

Definition at line 1191 of file routing_repository.cpp.

                                                                               {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, rule_id, name, description, enabled, priority,
               conditions_json, actions_json,
               schedule_cron, effective_from, effective_until,
               triggered_count, success_count, failure_count,
               last_triggered, created_at, updated_at
        FROM routing_rules WHERE pk = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_int64(stmt, 1, pk);
 
    std::optional<client::routing_rule> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_row().

Here is the call graph for this function:

find_enabled_rules()

std::vector< client::routing_rule > kcenon::pacs::storage::routing_repository::find_enabled_rules ( ) const -> std::vector<client::routing_rule>

nodiscard

Definition at line 1253 of file routing_repository.cpp.

find_rules()

std::vector< client::routing_rule > kcenon::pacs::storage::routing_repository::find_rules ( const routing_rule_query_options & options = {} ) const -> std::vector<client::routing_rule>

nodiscard

Definition at line 1219 of file routing_repository.cpp.

                                                     {
    std::vector<client::routing_rule> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, rule_id, name, description, enabled, priority,
               conditions_json, actions_json,
               schedule_cron, effective_from, effective_until,
               triggered_count, success_count, failure_count,
               last_triggered, created_at, updated_at
        FROM routing_rules WHERE 1=1
    )";
 
    if (options.enabled_only.has_value()) {
        sql << " AND enabled = " << (options.enabled_only.value() ? "1" : "0");
    }
 
    if (options.order_by_priority) {
        sql << " ORDER BY priority DESC, created_at ASC";
    } else {
        sql << " ORDER BY created_at DESC";
    }
 
    sql << " LIMIT " << options.limit << " OFFSET " << options.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;
    }
 

References db_.

Referenced by remove().

Here is the caller graph for this function:

increment_failure()

VoidResult kcenon::pacs::storage::routing_repository::increment_failure ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1482 of file routing_repository.cpp.

                                            : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult routing_repository::increment_failure(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET failure_count = failure_count + 1 WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

increment_success()

VoidResult kcenon::pacs::storage::routing_repository::increment_success ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1451 of file routing_repository.cpp.

                                              : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult routing_repository::increment_success(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET success_count = success_count + 1 WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

increment_triggered()

VoidResult kcenon::pacs::storage::routing_repository::increment_triggered ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1417 of file routing_repository.cpp.

                                                                         {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET
            triggered_count = triggered_count + 1,
            last_triggered = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

is_valid()

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

nodiscardnoexcept

Definition at line 1591 of file routing_repository.cpp.

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_row()

client::routing_rule kcenon::pacs::storage::routing_repository::parse_row ( void * stmt ) const -> client::routing_rule

nodiscardprivate

Definition at line 1599 of file routing_repository.cpp.

                                                                     {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::routing_rule rule;
 
    int col = 0;
    rule.pk = get_int64_column(stmt, col++);
    rule.rule_id = get_text_column(stmt, col++);
    rule.name = get_text_column(stmt, col++);
    rule.description = get_text_column(stmt, col++);
    rule.enabled = (get_int_column(stmt, col++) != 0);
    rule.priority = get_int_column(stmt, col++);
 
    auto conditions_json = get_text_column(stmt, col++);
    rule.conditions = deserialize_conditions(conditions_json);
 
    auto actions_json = get_text_column(stmt, col++);
    rule.actions = deserialize_actions(actions_json);
 
    rule.schedule_cron = get_optional_text(stmt, col++);
 
    auto effective_from_str = get_text_column(stmt, col++);
    rule.effective_from = from_optional_timestamp(effective_from_str.c_str());
 
    auto effective_until_str = get_text_column(stmt, col++);
    rule.effective_until = from_optional_timestamp(effective_until_str.c_str());
 
    rule.triggered_count = static_cast<size_t>(get_int64_column(stmt, col++));
    rule.success_count = static_cast<size_t>(get_int64_column(stmt, col++));
    rule.failure_count = static_cast<size_t>(get_int64_column(stmt, col++));
 
    auto last_triggered_str = get_text_column(stmt, col++);
    rule.last_triggered = from_timestamp_string(last_triggered_str.c_str());
 
    auto created_str = get_text_column(stmt, col++);

Referenced by find_by_id(), and find_by_pk().

Here is the caller graph for this function:

remove()

VoidResult kcenon::pacs::storage::routing_repository::remove ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1260 of file routing_repository.cpp.

                                                                           {
    routing_rule_query_options options;
    options.enabled_only = true;
    options.order_by_priority = true;
    return find_rules(options);
}
 
VoidResult routing_repository::remove(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = "DELETE FROM routing_rules WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

References kcenon::pacs::storage::routing_rule_query_options::enabled_only, and find_rules().

Here is the call graph for this function:

reset_statistics()

VoidResult kcenon::pacs::storage::routing_repository::reset_statistics ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1513 of file routing_repository.cpp.

                                            : " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult routing_repository::reset_statistics(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET
            triggered_count = 0,
            success_count = 0,
            failure_count = 0,
            last_triggered = NULL
        WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

save()

VoidResult kcenon::pacs::storage::routing_repository::save ( const client::routing_rule & rule ) -> VoidResult

nodiscard

Definition at line 1074 of file routing_repository.cpp.

                                                                  {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO routing_rules (
            rule_id, name, description, enabled, priority,
            conditions_json, actions_json,
            schedule_cron, effective_from, effective_until,
            triggered_count, success_count, failure_count,
            last_triggered, created_at, updated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(rule_id) DO UPDATE SET
            name = excluded.name,
            description = excluded.description,
            enabled = excluded.enabled,
            priority = excluded.priority,
            conditions_json = excluded.conditions_json,
            actions_json = excluded.actions_json,
            schedule_cron = excluded.schedule_cron,
            effective_from = excluded.effective_from,
            effective_until = excluded.effective_until,
            updated_at = CURRENT_TIMESTAMP
    )";
 
    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_)),
            "routing_repository"});
    }
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, rule.rule_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, rule.name.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, rule.description.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, idx++, rule.enabled ? 1 : 0);
    sqlite3_bind_int(stmt, idx++, rule.priority);
 
    auto conditions_json = serialize_conditions(rule.conditions);
    sqlite3_bind_text(stmt, idx++, conditions_json.c_str(), -1, SQLITE_TRANSIENT);
 
    auto actions_json = serialize_actions(rule.actions);
    sqlite3_bind_text(stmt, idx++, actions_json.c_str(), -1, SQLITE_TRANSIENT);
 
    bind_optional_text(stmt, idx++, rule.schedule_cron);
    bind_optional_timestamp(stmt, idx++, rule.effective_from);
    bind_optional_timestamp(stmt, idx++, rule.effective_until);
 
    sqlite3_bind_int64(stmt, idx++, static_cast<int64_t>(rule.triggered_count));
    sqlite3_bind_int64(stmt, idx++, static_cast<int64_t>(rule.success_count));
    sqlite3_bind_int64(stmt, idx++, static_cast<int64_t>(rule.failure_count));
 
    auto last_triggered_str = to_timestamp_string(rule.last_triggered);
    if (last_triggered_str.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, last_triggered_str.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    auto created_str = to_timestamp_string(rule.created_at);
    if (created_str.empty()) {
        sqlite3_bind_text(stmt, idx++, "CURRENT_TIMESTAMP", -1, SQLITE_STATIC);
    } else {
        sqlite3_bind_text(stmt, idx++, created_str.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    auto updated_str = to_timestamp_string(rule.updated_at);
    if (updated_str.empty()) {
        sqlite3_bind_text(stmt, idx++, "CURRENT_TIMESTAMP", -1, SQLITE_STATIC);
    } else {
        sqlite3_bind_text(stmt, idx++, updated_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 rule: " + std::string(sqlite3_errmsg(db_)),
            "routing_repository"});
    }
 
    return kcenon::common::ok();
}

serialize_actions()

std::string kcenon::pacs::storage::routing_repository::serialize_actions ( const std::vector< client::routing_action > & actions ) -> std::string

staticnodiscardprivate

Definition at line 975 of file routing_repository.cpp.

                                                    {
    if (actions.empty()) return "[]";
 
    std::ostringstream oss;
    oss << "[";
    for (size_t i = 0; i < actions.size(); ++i) {
        if (i > 0) oss << ",";
        const auto& action = actions[i];
        oss << "{";
        oss << "\"destination\":\"" << escape_json_string(action.destination_node_id) << "\",";
        oss << "\"priority\":\"" << client::to_string(action.priority) << "\",";
        oss << "\"delay_minutes\":" << action.delay.count() << ",";
        oss << "\"delete_after_send\":" << (action.delete_after_send ? "true" : "false") << ",";
        oss << "\"notify_on_failure\":" << (action.notify_on_failure ? "true" : "false");
        oss << "}";
    }
    oss << "]";
    return oss.str();
}

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

Here is the call graph for this function:

serialize_conditions()

std::string kcenon::pacs::storage::routing_repository::serialize_conditions ( const std::vector< client::routing_condition > & conditions ) -> std::string

staticnodiscardprivate

Definition at line 900 of file routing_repository.cpp.

                                                          {
    if (conditions.empty()) return "[]";
 
    std::ostringstream oss;
    oss << "[";
    for (size_t i = 0; i < conditions.size(); ++i) {
        if (i > 0) oss << ",";
        const auto& cond = conditions[i];
        oss << "{";
        oss << "\"field\":\"" << client::to_string(cond.match_field) << "\",";
        oss << "\"pattern\":\"" << escape_json_string(cond.pattern) << "\",";
        oss << "\"case_sensitive\":" << (cond.case_sensitive ? "true" : "false") << ",";
        oss << "\"negate\":" << (cond.negate ? "true" : "false");
        oss << "}";
    }
    oss << "]";
    return oss.str();
}

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

Here is the call graph for this function:

update_priority()

VoidResult kcenon::pacs::storage::routing_repository::update_priority ( std::string_view rule_id, int priority ) -> VoidResult

nodiscard

Definition at line 1310 of file routing_repository.cpp.

                                                                                   {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "routing_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE routing_rules SET
            priority = ?,
            updated_at = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "routing_repository"});
    }
 
    sqlite3_bind_int(stmt, 1, priority);
    sqlite3_bind_text(stmt, 2, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

Member Data Documentation

db_

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

private

Definition at line 319 of file routing_repository.h.

{nullptr};

Referenced by find_by_id(), find_by_pk(), and find_rules().

---

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

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