audit_record.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 <optional>
#include <string>
 
namespace kcenon::pacs::storage {
 
enum class audit_event_type {
    association_established,
    association_released,
    c_store,
    c_find,
    c_move,
    c_get,
    security_event,
    configuration_change,
    system_startup,
    system_shutdown,
    user_login,
    user_logout,
    data_access,
    data_export,
    error
};
 
[[nodiscard]] inline auto to_string(audit_event_type type) -> std::string {
    switch (type) {
        case audit_event_type::association_established:
            return "ASSOCIATION_ESTABLISHED";
        case audit_event_type::association_released:
            return "ASSOCIATION_RELEASED";
        case audit_event_type::c_store:
            return "C_STORE";
        case audit_event_type::c_find:
            return "C_FIND";
        case audit_event_type::c_move:
            return "C_MOVE";
        case audit_event_type::c_get:
            return "C_GET";
        case audit_event_type::security_event:
            return "SECURITY_EVENT";
        case audit_event_type::configuration_change:
            return "CONFIGURATION_CHANGE";
        case audit_event_type::system_startup:
            return "SYSTEM_STARTUP";
        case audit_event_type::system_shutdown:
            return "SYSTEM_SHUTDOWN";
        case audit_event_type::user_login:
            return "USER_LOGIN";
        case audit_event_type::user_logout:
            return "USER_LOGOUT";
        case audit_event_type::data_access:
            return "DATA_ACCESS";
        case audit_event_type::data_export:
            return "DATA_EXPORT";
        case audit_event_type::error:
            return "ERROR";
        default:
            return "UNKNOWN";
    }
}
 
[[nodiscard]] inline auto parse_audit_event_type(std::string_view str)
    -> std::optional<audit_event_type> {
    if (str == "ASSOCIATION_ESTABLISHED") {
        return audit_event_type::association_established;
    }
    if (str == "ASSOCIATION_RELEASED") {
        return audit_event_type::association_released;
    }
    if (str == "C_STORE") {
        return audit_event_type::c_store;
    }
    if (str == "C_FIND") {
        return audit_event_type::c_find;
    }
    if (str == "C_MOVE") {
        return audit_event_type::c_move;
    }
    if (str == "C_GET") {
        return audit_event_type::c_get;
    }
    if (str == "SECURITY_EVENT") {
        return audit_event_type::security_event;
    }
    if (str == "CONFIGURATION_CHANGE") {
        return audit_event_type::configuration_change;
    }
    if (str == "SYSTEM_STARTUP") {
        return audit_event_type::system_startup;
    }
    if (str == "SYSTEM_SHUTDOWN") {
        return audit_event_type::system_shutdown;
    }
    if (str == "USER_LOGIN") {
        return audit_event_type::user_login;
    }
    if (str == "USER_LOGOUT") {
        return audit_event_type::user_logout;
    }
    if (str == "DATA_ACCESS") {
        return audit_event_type::data_access;
    }
    if (str == "DATA_EXPORT") {
        return audit_event_type::data_export;
    }
    if (str == "ERROR") {
        return audit_event_type::error;
    }
    return std::nullopt;
}
 
enum class audit_outcome {
    success,
    failure,
    warning
};
 
[[nodiscard]] inline auto to_string(audit_outcome outcome) -> std::string {
    switch (outcome) {
        case audit_outcome::success:
            return "SUCCESS";
        case audit_outcome::failure:
            return "FAILURE";
        case audit_outcome::warning:
            return "WARNING";
        default:
            return "UNKNOWN";
    }
}
 
struct audit_record {
    int64_t pk{0};
 
    std::string event_type;
 
    std::string outcome;
 
    std::chrono::system_clock::time_point timestamp;
 
    std::string user_id;
 
    std::string source_ae;
 
    std::string target_ae;
 
    std::string source_ip;
 
    std::string patient_id;
 
    std::string study_uid;
 
    std::string message;
 
    std::string details;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return !event_type.empty();
    }
};
 
struct audit_query {
    std::optional<std::string> event_type;
 
    std::optional<std::string> outcome;
 
    std::optional<std::string> user_id;
 
    std::optional<std::string> source_ae;
 
    std::optional<std::string> patient_id;
 
    std::optional<std::string> study_uid;
 
    std::optional<std::string> date_from;
 
    std::optional<std::string> date_to;
 
    size_t limit{0};
 
    size_t offset{0};
 
    [[nodiscard]] auto has_criteria() const noexcept -> bool {
        return event_type.has_value() || outcome.has_value() ||
               user_id.has_value() || source_ae.has_value() ||
               patient_id.has_value() || study_uid.has_value() ||
               date_from.has_value() || date_to.has_value();
    }
};
 
}  // namespace kcenon::pacs::storage