tag_action.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/core/dicom_tag.h>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
namespace kcenon::pacs::security {
 
enum class tag_action : std::uint8_t {
    remove = 0,
 
    empty = 1,
 
    remove_or_empty = 2,
 
    keep = 3,
 
    replace = 4,
 
    replace_uid = 5,
 
    hash = 6,
 
    encrypt = 7,
 
    shift_date = 8
};
 
[[nodiscard]] constexpr auto to_string(tag_action action) noexcept
    -> std::string_view {
    switch (action) {
        case tag_action::remove:
            return "remove";
        case tag_action::empty:
            return "empty";
        case tag_action::remove_or_empty:
            return "remove_or_empty";
        case tag_action::keep:
            return "keep";
        case tag_action::replace:
            return "replace";
        case tag_action::replace_uid:
            return "replace_uid";
        case tag_action::hash:
            return "hash";
        case tag_action::encrypt:
            return "encrypt";
        case tag_action::shift_date:
            return "shift_date";
    }
    return "unknown";
}
 
struct tag_action_config {
    tag_action action{tag_action::remove};
 
    std::string replacement_value;
 
    std::string hash_algorithm{"SHA256"};
 
    bool use_salt{true};
 
    [[nodiscard]] static auto make_remove() -> tag_action_config {
        return {.action = tag_action::remove};
    }
 
    [[nodiscard]] static auto make_empty() -> tag_action_config {
        return {.action = tag_action::empty};
    }
 
    [[nodiscard]] static auto make_keep() -> tag_action_config {
        return {.action = tag_action::keep};
    }
 
    [[nodiscard]] static auto make_replace(std::string value) -> tag_action_config {
        return {.action = tag_action::replace, .replacement_value = std::move(value)};
    }
 
    [[nodiscard]] static auto make_hash(
        std::string algorithm = "SHA256",
        bool salt = true
    ) -> tag_action_config {
        return {
            .action = tag_action::hash,
            .hash_algorithm = std::move(algorithm),
            .use_salt = salt
        };
    }
};
 
struct tag_action_record {
    core::dicom_tag tag;
 
    tag_action action{tag_action::remove};
 
    std::string original_value;
 
    std::string new_value;
 
    bool success{true};
 
    std::string error_message;
};
 
struct anonymization_report {
    std::size_t total_tags_processed{0};
 
    std::size_t tags_removed{0};
 
    std::size_t tags_emptied{0};
 
    std::size_t tags_replaced{0};
 
    std::size_t uids_replaced{0};
 
    std::size_t tags_kept{0};
 
    std::size_t dates_shifted{0};
 
    std::size_t values_hashed{0};
 
    std::size_t private_tags_removed{0};
 
    std::vector<tag_action_record> action_records;
 
    std::string profile_name;
 
    std::optional<std::chrono::days> date_offset;
 
    std::chrono::system_clock::time_point timestamp;
 
    std::vector<std::string> warnings;
 
    std::vector<std::string> errors;
 
    [[nodiscard]] auto is_successful() const noexcept -> bool {
        return errors.empty();
    }
 
    [[nodiscard]] auto total_modifications() const noexcept -> std::size_t {
        return tags_removed + tags_emptied + tags_replaced +
               uids_replaced + dates_shifted + values_hashed +
               private_tags_removed;
    }
};
 
namespace hipaa_identifiers {
    [[nodiscard]] auto get_name_tags() -> std::vector<core::dicom_tag>;
 
    [[nodiscard]] auto get_geographic_tags() -> std::vector<core::dicom_tag>;
 
    [[nodiscard]] auto get_date_tags() -> std::vector<core::dicom_tag>;
 
    [[nodiscard]] auto get_communication_tags() -> std::vector<core::dicom_tag>;
 
    [[nodiscard]] auto get_unique_id_tags() -> std::vector<core::dicom_tag>;
 
    [[nodiscard]] auto get_all_identifier_tags() -> std::vector<core::dicom_tag>;
} // namespace hipaa_identifiers
 
} // namespace kcenon::pacs::security