worklist_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 worklist_status {
    scheduled,   
    started,     
    completed    
};
 
[[nodiscard]] inline auto to_string(worklist_status status) -> std::string {
    switch (status) {
        case worklist_status::scheduled:
            return "SCHEDULED";
        case worklist_status::started:
            return "STARTED";
        case worklist_status::completed:
            return "COMPLETED";
        default:
            return "SCHEDULED";
    }
}
 
[[nodiscard]] inline auto parse_worklist_status(std::string_view str)
    -> std::optional<worklist_status> {
    if (str == "SCHEDULED") {
        return worklist_status::scheduled;
    }
    if (str == "STARTED") {
        return worklist_status::started;
    }
    if (str == "COMPLETED") {
        return worklist_status::completed;
    }
    return std::nullopt;
}
 
struct worklist_item {
    int64_t pk{0};
 
    std::string step_id;
 
    std::string step_status;
 
    std::string patient_id;
 
    std::string patient_name;
 
    std::string birth_date;
 
    std::string sex;
 
    std::string accession_no;
 
    std::string requested_proc_id;
 
    std::string study_uid;
 
    std::string scheduled_datetime;
 
    std::string station_ae;
 
    std::string station_name;
 
    std::string modality;
 
    std::string procedure_desc;
 
    std::string protocol_code;
 
    std::string referring_phys;
 
    std::string referring_phys_id;
 
    std::chrono::system_clock::time_point created_at;
 
    std::chrono::system_clock::time_point updated_at;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return !step_id.empty() && !patient_id.empty() && !modality.empty() &&
               !scheduled_datetime.empty();
    }
 
    [[nodiscard]] auto is_scheduled() const noexcept -> bool {
        return step_status == "SCHEDULED" || step_status.empty();
    }
 
    [[nodiscard]] auto get_status() const -> std::optional<worklist_status> {
        return parse_worklist_status(step_status);
    }
};
 
struct worklist_query {
    std::optional<std::string> station_ae;
 
    std::optional<std::string> modality;
 
    std::optional<std::string> scheduled_date_from;
 
    std::optional<std::string> scheduled_date_to;
 
    std::optional<std::string> patient_id;
 
    std::optional<std::string> patient_name;
 
    std::optional<std::string> accession_no;
 
    std::optional<std::string> step_id;
 
    bool include_all_status{false};
 
    size_t limit{0};
 
    size_t offset{0};
 
    [[nodiscard]] auto has_criteria() const noexcept -> bool {
        return station_ae.has_value() || modality.has_value() ||
               scheduled_date_from.has_value() || scheduled_date_to.has_value() ||
               patient_id.has_value() || patient_name.has_value() ||
               accession_no.has_value() || step_id.has_value();
    }
};
 
}  // namespace kcenon::pacs::storage