ups_workitem.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>
#include <vector>
 
namespace kcenon::pacs::storage {
 
enum class ups_state {
    scheduled,     
    in_progress,   
    completed,     
    canceled       
};
 
[[nodiscard]] inline auto to_string(ups_state state) -> std::string {
    switch (state) {
        case ups_state::scheduled:
            return "SCHEDULED";
        case ups_state::in_progress:
            return "IN PROGRESS";
        case ups_state::completed:
            return "COMPLETED";
        case ups_state::canceled:
            return "CANCELED";
        default:
            return "SCHEDULED";
    }
}
 
[[nodiscard]] inline auto parse_ups_state(std::string_view str)
    -> std::optional<ups_state> {
    if (str == "SCHEDULED") {
        return ups_state::scheduled;
    }
    if (str == "IN PROGRESS") {
        return ups_state::in_progress;
    }
    if (str == "COMPLETED") {
        return ups_state::completed;
    }
    if (str == "CANCELED") {
        return ups_state::canceled;
    }
    return std::nullopt;
}
 
enum class ups_priority {
    low,      
    medium,   
    high      
};
 
[[nodiscard]] inline auto to_string(ups_priority priority) -> std::string {
    switch (priority) {
        case ups_priority::low:
            return "LOW";
        case ups_priority::medium:
            return "MEDIUM";
        case ups_priority::high:
            return "HIGH";
        default:
            return "MEDIUM";
    }
}
 
[[nodiscard]] inline auto parse_ups_priority(std::string_view str)
    -> std::optional<ups_priority> {
    if (str == "LOW") {
        return ups_priority::low;
    }
    if (str == "MEDIUM") {
        return ups_priority::medium;
    }
    if (str == "HIGH") {
        return ups_priority::high;
    }
    return std::nullopt;
}
 
struct ups_workitem {
    int64_t pk{0};
 
    std::string workitem_uid;
 
    std::string state;
 
    std::string procedure_step_label;
 
    std::string worklist_label;
 
    std::string priority;
 
    std::string scheduled_start_datetime;
 
    std::string expected_completion_datetime;
 
    std::string scheduled_station_name;
 
    std::string scheduled_station_class;
 
    std::string scheduled_station_geographic;
 
    std::string scheduled_human_performers;
 
    std::string input_information;
 
    std::string performing_ae;
 
    std::string progress_description;
 
    int progress_percent{0};
 
    std::string output_information;
 
    std::string transaction_uid;
 
    std::chrono::system_clock::time_point created_at;
 
    std::chrono::system_clock::time_point updated_at;
 
    [[nodiscard]] auto is_valid() const noexcept -> bool {
        return !workitem_uid.empty();
    }
 
    [[nodiscard]] auto is_final() const noexcept -> bool {
        return state == "COMPLETED" || state == "CANCELED";
    }
 
    [[nodiscard]] auto get_state() const -> std::optional<ups_state> {
        return parse_ups_state(state);
    }
 
    [[nodiscard]] auto get_priority() const -> std::optional<ups_priority> {
        return parse_ups_priority(priority);
    }
};
 
struct ups_subscription {
    int64_t pk{0};
 
    std::string subscriber_ae;
 
    std::string workitem_uid;
 
    bool deletion_lock{false};
 
    std::string filter_criteria;
 
    std::chrono::system_clock::time_point created_at;
 
    [[nodiscard]] auto is_global() const noexcept -> bool {
        return workitem_uid.empty() && filter_criteria.empty();
    }
 
    [[nodiscard]] auto is_workitem_specific() const noexcept -> bool {
        return !workitem_uid.empty();
    }
};
 
struct ups_workitem_query {
    std::optional<std::string> workitem_uid;
 
    std::optional<std::string> state;
 
    std::optional<std::string> priority;
 
    std::optional<std::string> procedure_step_label;
 
    std::optional<std::string> worklist_label;
 
    std::optional<std::string> performing_ae;
 
    std::optional<std::string> scheduled_date_from;
 
    std::optional<std::string> scheduled_date_to;
 
    size_t limit{0};
 
    size_t offset{0};
 
    [[nodiscard]] auto has_criteria() const noexcept -> bool {
        return workitem_uid.has_value() || state.has_value() ||
               priority.has_value() || procedure_step_label.has_value() ||
               worklist_label.has_value() || performing_ae.has_value() ||
               scheduled_date_from.has_value() || scheduled_date_to.has_value();
    }
};
 
}  // namespace kcenon::pacs::storage