routing_types.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "kcenon/pacs/client/job_types.h"
 
#include <chrono>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kcenon::pacs::client {
 
// =============================================================================
// Routing Condition Field
// =============================================================================
 
enum class routing_field {
    modality,              
    station_ae,            
    institution,           
    department,            
    referring_physician,   
    study_description,     
    series_description,    
    body_part,             
    patient_id_pattern,    
    sop_class_uid          
};
 
[[nodiscard]] constexpr const char* to_string(routing_field field) noexcept {
    switch (field) {
        case routing_field::modality: return "modality";
        case routing_field::station_ae: return "station_ae";
        case routing_field::institution: return "institution";
        case routing_field::department: return "department";
        case routing_field::referring_physician: return "referring_physician";
        case routing_field::study_description: return "study_description";
        case routing_field::series_description: return "series_description";
        case routing_field::body_part: return "body_part";
        case routing_field::patient_id_pattern: return "patient_id_pattern";
        case routing_field::sop_class_uid: return "sop_class_uid";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline routing_field routing_field_from_string(
    std::string_view str) noexcept {
    if (str == "modality") return routing_field::modality;
    if (str == "station_ae") return routing_field::station_ae;
    if (str == "institution") return routing_field::institution;
    if (str == "department") return routing_field::department;
    if (str == "referring_physician") return routing_field::referring_physician;
    if (str == "study_description") return routing_field::study_description;
    if (str == "series_description") return routing_field::series_description;
    if (str == "body_part") return routing_field::body_part;
    if (str == "patient_id_pattern") return routing_field::patient_id_pattern;
    if (str == "sop_class_uid") return routing_field::sop_class_uid;
    return routing_field::modality;
}
 
// =============================================================================
// Routing Condition
// =============================================================================
 
struct routing_condition {
    routing_field match_field;     
    std::string pattern;           
    bool case_sensitive{false};    
    bool negate{false};            
 
    routing_condition() = default;
 
    routing_condition(routing_field field, std::string pat,
                     bool case_sens = false, bool neg = false)
        : match_field(field)
        , pattern(std::move(pat))
        , case_sensitive(case_sens)
        , negate(neg) {}
};
 
// =============================================================================
// Routing Action
// =============================================================================
 
struct routing_action {
    std::string destination_node_id;      
    job_priority priority{job_priority::normal};  
    std::chrono::minutes delay{0};        
    bool delete_after_send{false};        
    bool notify_on_failure{true};         
 
    routing_action() = default;
 
    routing_action(std::string dest_node_id,
                  job_priority prio = job_priority::normal,
                  std::chrono::minutes del = std::chrono::minutes{0})
        : destination_node_id(std::move(dest_node_id))
        , priority(prio)
        , delay(del) {}
};
 
// =============================================================================
// Routing Rule
// =============================================================================
 
struct routing_rule {
    // =========================================================================
    // Identification
    // =========================================================================
 
    std::string rule_id;          
    std::string name;             
    std::string description;      
 
    // =========================================================================
    // Rule State
    // =========================================================================
 
    bool enabled{true};           
    int priority{0};              
 
    // =========================================================================
    // Matching Configuration
    // =========================================================================
 
    std::vector<routing_condition> conditions;  
    std::vector<routing_action> actions;        
 
    // =========================================================================
    // Schedule (Optional)
    // =========================================================================
 
    std::optional<std::string> schedule_cron;   
    std::optional<std::chrono::system_clock::time_point> effective_from;
    std::optional<std::chrono::system_clock::time_point> effective_until;
 
    // =========================================================================
    // Statistics
    // =========================================================================
 
    size_t triggered_count{0};    
    size_t success_count{0};      
    size_t failure_count{0};      
    std::chrono::system_clock::time_point last_triggered;
    std::chrono::system_clock::time_point created_at;
    std::chrono::system_clock::time_point updated_at;
 
    // =========================================================================
    // Database Fields
    // =========================================================================
 
    int64_t pk{0};                
 
    // =========================================================================
    // Convenience Methods
    // =========================================================================
 
    [[nodiscard]] bool is_effective_now() const noexcept {
        if (!enabled) return false;
 
        auto now = std::chrono::system_clock::now();
 
        if (effective_from.has_value() && now < effective_from.value()) {
            return false;
        }
 
        if (effective_until.has_value() && now > effective_until.value()) {
            return false;
        }
 
        return true;
    }
};
 
// =============================================================================
// Routing Event Callback
// =============================================================================
 
using routing_event_callback = std::function<void(
    const std::string& rule_id,
    const std::string& instance_uid,
    const std::vector<routing_action>& triggered_actions)>;
 
// =============================================================================
// Routing Manager Configuration
// =============================================================================
 
struct routing_manager_config {
    bool enabled{true};                            
    size_t max_rules{100};                         
    std::chrono::seconds evaluation_timeout{5};    
};
 
// =============================================================================
// Routing Statistics
// =============================================================================
 
struct routing_statistics {
    size_t total_evaluated{0};    
    size_t total_matched{0};      
    size_t total_forwarded{0};    
    size_t total_failed{0};       
};
 
// =============================================================================
// Test Result
// =============================================================================
 
struct routing_test_result {
    bool matched{false};                          
    std::string matched_rule_id;                  
    std::vector<routing_action> actions;          
};
 
}  // namespace kcenon::pacs::client