sync_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 <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kcenon::pacs::client {
 
// =============================================================================
// Sync Direction
// =============================================================================
 
enum class sync_direction {
    pull,          
    push,          
    bidirectional  
};
 
[[nodiscard]] constexpr const char* to_string(sync_direction direction) noexcept {
    switch (direction) {
        case sync_direction::pull: return "pull";
        case sync_direction::push: return "push";
        case sync_direction::bidirectional: return "bidirectional";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline sync_direction sync_direction_from_string(
    std::string_view str) noexcept {
    if (str == "pull") return sync_direction::pull;
    if (str == "push") return sync_direction::push;
    if (str == "bidirectional") return sync_direction::bidirectional;
    return sync_direction::pull;
}
 
// =============================================================================
// Conflict Type
// =============================================================================
 
enum class sync_conflict_type {
    missing_local,   
    missing_remote,  
    modified,        
    count_mismatch   
};
 
[[nodiscard]] constexpr const char* to_string(sync_conflict_type type) noexcept {
    switch (type) {
        case sync_conflict_type::missing_local: return "missing_local";
        case sync_conflict_type::missing_remote: return "missing_remote";
        case sync_conflict_type::modified: return "modified";
        case sync_conflict_type::count_mismatch: return "count_mismatch";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline sync_conflict_type sync_conflict_type_from_string(
    std::string_view str) noexcept {
    if (str == "missing_local") return sync_conflict_type::missing_local;
    if (str == "missing_remote") return sync_conflict_type::missing_remote;
    if (str == "modified") return sync_conflict_type::modified;
    if (str == "count_mismatch") return sync_conflict_type::count_mismatch;
    return sync_conflict_type::missing_local;
}
 
// =============================================================================
// Conflict Resolution
// =============================================================================
 
enum class conflict_resolution {
    prefer_local,   
    prefer_remote,  
    prefer_newer    
};
 
[[nodiscard]] constexpr const char* to_string(
    conflict_resolution resolution) noexcept {
    switch (resolution) {
        case conflict_resolution::prefer_local: return "prefer_local";
        case conflict_resolution::prefer_remote: return "prefer_remote";
        case conflict_resolution::prefer_newer: return "prefer_newer";
        default: return "unknown";
    }
}
 
[[nodiscard]] inline conflict_resolution conflict_resolution_from_string(
    std::string_view str) noexcept {
    if (str == "prefer_local") return conflict_resolution::prefer_local;
    if (str == "prefer_remote") return conflict_resolution::prefer_remote;
    if (str == "prefer_newer") return conflict_resolution::prefer_newer;
    return conflict_resolution::prefer_remote;
}
 
// =============================================================================
// Sync Config
// =============================================================================
 
struct sync_config {
    // =========================================================================
    // Identification
    // =========================================================================
 
    std::string config_id;       
    std::string source_node_id;  
    std::string name;            
    bool enabled{true};          
 
    // =========================================================================
    // Sync Scope
    // =========================================================================
 
    std::chrono::hours lookback{24};            
    std::vector<std::string> modalities;        
    std::vector<std::string> patient_id_patterns;  
 
    // =========================================================================
    // Sync Behavior
    // =========================================================================
 
    sync_direction direction{sync_direction::pull};  
    bool delete_missing{false};       
    bool overwrite_existing{false};   
    bool sync_metadata_only{false};   
 
    // =========================================================================
    // Schedule
    // =========================================================================
 
    std::string schedule_cron;  
 
    // =========================================================================
    // Statistics
    // =========================================================================
 
    std::chrono::system_clock::time_point last_sync;
    std::chrono::system_clock::time_point last_successful_sync;
    size_t total_syncs{0};
    size_t studies_synced{0};
 
    // =========================================================================
    // Database Fields
    // =========================================================================
 
    int64_t pk{0};  
};
 
// =============================================================================
// Sync Conflict
// =============================================================================
 
struct sync_conflict {
    std::string config_id;   
    std::string study_uid;   
    std::string patient_id;  
 
    sync_conflict_type conflict_type;  
 
    std::chrono::system_clock::time_point local_modified;
    std::chrono::system_clock::time_point remote_modified;
 
    size_t local_instance_count{0};
    size_t remote_instance_count{0};
 
    bool resolved{false};                  
    conflict_resolution resolution_used;   
 
    std::chrono::system_clock::time_point detected_at;
    std::optional<std::chrono::system_clock::time_point> resolved_at;
 
    // =========================================================================
    // Database Fields
    // =========================================================================
 
    int64_t pk{0};  
};
 
// =============================================================================
// Sync Result
// =============================================================================
 
struct sync_result {
    std::string config_id;   
    std::string job_id;      
    bool success{false};     
 
    // =========================================================================
    // Counts
    // =========================================================================
 
    size_t studies_checked{0};       
    size_t studies_synced{0};        
    size_t studies_skipped{0};       
    size_t instances_transferred{0}; 
    size_t bytes_transferred{0};     
 
    // =========================================================================
    // Issues
    // =========================================================================
 
    std::vector<sync_conflict> conflicts;  
    std::vector<std::string> errors;       
 
    // =========================================================================
    // Timing
    // =========================================================================
 
    std::chrono::system_clock::time_point started_at;
    std::chrono::system_clock::time_point completed_at;
    std::chrono::milliseconds elapsed{0};
};
 
// =============================================================================
// Sync History
// =============================================================================
 
struct sync_history {
    std::string config_id;
    std::string job_id;
    bool success{false};
 
    size_t studies_checked{0};
    size_t studies_synced{0};
    size_t conflicts_found{0};
 
    std::vector<std::string> errors;
 
    std::chrono::system_clock::time_point started_at;
    std::chrono::system_clock::time_point completed_at;
 
    int64_t pk{0};
};
 
// =============================================================================
// Sync Manager Configuration
// =============================================================================
 
struct sync_manager_config {
    size_t max_concurrent_syncs{2};                        
    std::chrono::seconds comparison_timeout{300};          
    bool auto_resolve_conflicts{false};                    
    conflict_resolution default_resolution{conflict_resolution::prefer_remote};
};
 
// =============================================================================
// Sync Statistics
// =============================================================================
 
struct sync_statistics {
    size_t total_syncs{0};
    size_t successful_syncs{0};
    size_t failed_syncs{0};
    size_t total_studies_synced{0};
    size_t total_bytes_transferred{0};
    size_t total_conflicts_detected{0};
    size_t total_conflicts_resolved{0};
};
 
// =============================================================================
// Callbacks
// =============================================================================
 
using sync_progress_callback = std::function<void(
    const std::string& config_id,
    size_t studies_synced,
    size_t studies_total)>;
 
using sync_completion_callback = std::function<void(
    const std::string& config_id,
    const sync_result& result)>;
 
using sync_conflict_callback = std::function<void(const sync_conflict& conflict)>;
 
}  // namespace kcenon::pacs::client