kcenon::pacs::storage::mpps_repository Class Reference

#include <mpps_repository.h>

Collaboration diagram for kcenon::pacs::storage::mpps_repository:

Public Member Functions
	mpps_repository (sqlite3 *db)
	~mpps_repository ()
	mpps_repository (const mpps_repository &)=delete
auto	operator= (const mpps_repository &) -> mpps_repository &=delete
	mpps_repository (mpps_repository &&) noexcept
auto	operator= (mpps_repository &&) noexcept -> mpps_repository &
auto	create_mpps (std::string_view mpps_uid, std::string_view station_ae="", std::string_view modality="", std::string_view study_uid="", std::string_view accession_no="", std::string_view start_datetime="") -> Result< int64_t >
auto	create_mpps (const mpps_record &record) -> Result< int64_t >
auto	update_mpps (std::string_view mpps_uid, std::string_view new_status, std::string_view end_datetime="", std::string_view performed_series="") -> VoidResult
auto	update_mpps (const mpps_record &record) -> VoidResult
auto	find_mpps (std::string_view mpps_uid) const -> std::optional< mpps_record >
auto	find_mpps_by_pk (int64_t pk) const -> std::optional< mpps_record >
auto	list_active_mpps (std::string_view station_ae) const -> Result< std::vector< mpps_record > >
auto	find_mpps_by_study (std::string_view study_uid) const -> Result< std::vector< mpps_record > >
auto	search_mpps (const mpps_query &query) const -> Result< std::vector< mpps_record > >
auto	delete_mpps (std::string_view mpps_uid) -> VoidResult
auto	mpps_count () const -> Result< size_t >
auto	mpps_count (std::string_view status) const -> Result< size_t >

Private Member Functions
auto	parse_mpps_row (void *stmt) const -> mpps_record

Static Private Member Functions
static auto	parse_timestamp (const std::string &str) -> std::chrono::system_clock::time_point

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Definition at line 99 of file mpps_repository.h.

Constructor & Destructor Documentation

mpps_repository() [1/3]

kcenon::pacs::storage::mpps_repository::mpps_repository ( sqlite3 * db )

explicit

Definition at line 541 of file mpps_repository.cpp.

: db_(db) {}

~mpps_repository()

kcenon::pacs::storage::mpps_repository::~mpps_repository ( )

default

mpps_repository() [2/3]

kcenon::pacs::storage::mpps_repository::mpps_repository ( const mpps_repository & )

delete

mpps_repository() [3/3]

kcenon::pacs::storage::mpps_repository::mpps_repository ( mpps_repository && other )

noexcept

Definition at line 545 of file mpps_repository.cpp.

    : db_(other.db_) {
    other.db_ = nullptr;
}

Member Function Documentation

create_mpps() [1/2]

auto kcenon::pacs::storage::mpps_repository::create_mpps ( const mpps_record & record ) -> Result<int64_t>

nodiscard

Definition at line 605 of file mpps_repository.cpp.

                                                                              {
    if (record.mpps_uid.empty()) {
        return make_error<int64_t>(-1, "MPPS SOP Instance UID is required",
                                   "storage");
    }
 
    if (!record.status.empty() && record.status != "IN PROGRESS") {
        return make_error<int64_t>(
            -1, "N-CREATE must create MPPS with status 'IN PROGRESS'",
            "storage");
    }
 
    const char* sql = R"(
        INSERT INTO mpps (
            mpps_uid, status, start_datetime, station_ae, station_name,
            modality, study_uid, accession_no, scheduled_step_id,
            requested_proc_id, performed_series, updated_at
        ) VALUES (?, 'IN PROGRESS', ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
        RETURNING mpps_pk;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<int64_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare statement: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, record.mpps_uid.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, record.start_datetime.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, record.station_ae.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 4, record.station_name.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 5, record.modality.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, record.study_uid.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, record.accession_no.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 8, record.scheduled_step_id.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 9, record.requested_proc_id.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 10, record.performed_series.c_str(), -1,
                      SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        auto error_msg = sqlite3_errmsg(db_);
        sqlite3_finalize(stmt);
        return make_error<int64_t>(
            rc, kcenon::pacs::compat::format("Failed to create MPPS: {}", error_msg),
            "storage");
    }
 
    auto pk = sqlite3_column_int64(stmt, 0);
    sqlite3_finalize(stmt);
    return pk;
}

create_mpps() [2/2]

auto kcenon::pacs::storage::mpps_repository::create_mpps ( std::string_view mpps_uid, std::string_view station_ae = "", std::string_view modality = "", std::string_view study_uid = "", std::string_view accession_no = "", std::string_view start_datetime = "" ) -> Result<int64_t>

nodiscard

Definition at line 587 of file mpps_repository.cpp.

                       {
    mpps_record record;
    record.mpps_uid = std::string(mpps_uid);
    record.station_ae = std::string(station_ae);
    record.modality = std::string(modality);
    record.study_uid = std::string(study_uid);
    record.accession_no = std::string(accession_no);
    record.start_datetime = std::string(start_datetime);
    record.status = "IN PROGRESS";
    return create_mpps(record);
}

delete_mpps()

auto kcenon::pacs::storage::mpps_repository::delete_mpps ( std::string_view mpps_uid ) -> VoidResult

nodiscard

Definition at line 963 of file mpps_repository.cpp.

                                                                       {
    const char* sql = "DELETE FROM mpps WHERE mpps_uid = ?;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare delete: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, mpps_uid.data(),
                      static_cast<int>(mpps_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to delete MPPS: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok();
}

find_mpps()

auto kcenon::pacs::storage::mpps_repository::find_mpps ( std::string_view mpps_uid ) const -> std::optional<mpps_record>

nodiscard

Definition at line 754 of file mpps_repository.cpp.

                                {
    const char* sql = R"(
        SELECT mpps_pk, mpps_uid, status, start_datetime, end_datetime,
               station_ae, station_name, modality, study_uid, accession_no,
               scheduled_step_id, requested_proc_id, performed_series,
               created_at, updated_at
        FROM mpps
        WHERE mpps_uid = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, mpps_uid.data(),
                      static_cast<int>(mpps_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return std::nullopt;
    }
 
    auto record = parse_mpps_row(stmt);
    sqlite3_finalize(stmt);
    return record;
}

find_mpps_by_pk()

auto kcenon::pacs::storage::mpps_repository::find_mpps_by_pk ( int64_t pk ) const -> std::optional<mpps_record>

nodiscard

Definition at line 785 of file mpps_repository.cpp.

                                {
    const char* sql = R"(
        SELECT mpps_pk, mpps_uid, status, start_datetime, end_datetime,
               station_ae, station_name, modality, study_uid, accession_no,
               scheduled_step_id, requested_proc_id, performed_series,
               created_at, updated_at
        FROM mpps
        WHERE mpps_pk = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_int64(stmt, 1, pk);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return std::nullopt;
    }
 
    auto record = parse_mpps_row(stmt);
    sqlite3_finalize(stmt);
    return record;
}

find_mpps_by_study()

auto kcenon::pacs::storage::mpps_repository::find_mpps_by_study ( std::string_view study_uid ) const -> Result<std::vector<mpps_record>>

nodiscard

Definition at line 850 of file mpps_repository.cpp.

                                      {
    std::vector<mpps_record> results;
 
    const char* sql = R"(
        SELECT mpps_pk, mpps_uid, status, start_datetime, end_datetime,
               station_ae, station_name, modality, study_uid, accession_no,
               scheduled_step_id, requested_proc_id, performed_series,
               created_at, updated_at
        FROM mpps
        WHERE study_uid = ?
        ORDER BY start_datetime DESC;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<mpps_record>>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, study_uid.data(),
                      static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_mpps_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

list_active_mpps()

auto kcenon::pacs::storage::mpps_repository::list_active_mpps ( std::string_view station_ae ) const -> Result<std::vector<mpps_record>>

nodiscard

Definition at line 815 of file mpps_repository.cpp.

                                      {
    std::vector<mpps_record> results;
 
    const char* sql = R"(
        SELECT mpps_pk, mpps_uid, status, start_datetime, end_datetime,
               station_ae, station_name, modality, study_uid, accession_no,
               scheduled_step_id, requested_proc_id, performed_series,
               created_at, updated_at
        FROM mpps
        WHERE status = 'IN PROGRESS' AND station_ae = ?
        ORDER BY start_datetime DESC;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<mpps_record>>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, station_ae.data(),
                      static_cast<int>(station_ae.size()), SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_mpps_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

mpps_count() [1/2]

auto kcenon::pacs::storage::mpps_repository::mpps_count ( ) const -> Result<size_t>

nodiscard

Definition at line 993 of file mpps_repository.cpp.

                                                         {
    const char* sql = "SELECT COUNT(*) FROM mpps;";
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<size_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
    sqlite3_finalize(stmt);
    return ok(count);
}

References db_.

mpps_count() [2/2]

auto kcenon::pacs::storage::mpps_repository::mpps_count ( std::string_view status ) const -> Result<size_t>

nodiscard

Definition at line 1013 of file mpps_repository.cpp.

                      {
    const char* sql = "SELECT COUNT(*) FROM mpps WHERE status = ?;";
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<size_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, status.data(), static_cast<int>(status.size()),
                      SQLITE_TRANSIENT);
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
    sqlite3_finalize(stmt);
    return ok(count);
}

operator=() [1/2]

auto kcenon::pacs::storage::mpps_repository::operator= ( const mpps_repository & ) -> mpps_repository &=delete

delete

operator=() [2/2]

auto kcenon::pacs::storage::mpps_repository::operator= ( mpps_repository && other ) -> mpps_repository&

noexcept

Definition at line 550 of file mpps_repository.cpp.

                        {
    if (this != &other) {
        db_ = other.db_;
        other.db_ = nullptr;
    }
    return *this;
}

parse_mpps_row()

auto kcenon::pacs::storage::mpps_repository::parse_mpps_row ( void * stmt ) const -> mpps_record

nodiscardprivate

Definition at line 564 of file mpps_repository.cpp.

                                                                        {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    mpps_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.mpps_uid = get_text(stmt, 1);
    record.status = get_text(stmt, 2);
    record.start_datetime = get_text(stmt, 3);
    record.end_datetime = get_text(stmt, 4);
    record.station_ae = get_text(stmt, 5);
    record.station_name = get_text(stmt, 6);
    record.modality = get_text(stmt, 7);
    record.study_uid = get_text(stmt, 8);
    record.accession_no = get_text(stmt, 9);
    record.scheduled_step_id = get_text(stmt, 10);
    record.requested_proc_id = get_text(stmt, 11);
    record.performed_series = get_text(stmt, 12);
    record.created_at = parse_datetime(get_text(stmt, 13).c_str());
    record.updated_at = parse_datetime(get_text(stmt, 14).c_str());
 
    return record;
}

parse_timestamp()

auto kcenon::pacs::storage::mpps_repository::parse_timestamp ( const std::string & str ) -> std::chrono::system_clock::time_point

staticnodiscardprivate

Definition at line 559 of file mpps_repository.cpp.

                                       {
    return parse_datetime(str.c_str());
}

search_mpps()

auto kcenon::pacs::storage::mpps_repository::search_mpps ( const mpps_query & query ) const -> Result<std::vector<mpps_record>>

nodiscard

Definition at line 885 of file mpps_repository.cpp.

                                      {
    std::vector<mpps_record> results;
    std::string sql = R"(
        SELECT mpps_pk, mpps_uid, status, start_datetime, end_datetime,
               station_ae, station_name, modality, study_uid, accession_no,
               scheduled_step_id, requested_proc_id, performed_series,
               created_at, updated_at
        FROM mpps
        WHERE 1=1
    )";
    std::vector<std::string> params;
 
    if (query.mpps_uid.has_value()) {
        sql += " AND mpps_uid = ?";
        params.push_back(*query.mpps_uid);
    }
    if (query.status.has_value()) {
        sql += " AND status = ?";
        params.push_back(*query.status);
    }
    if (query.station_ae.has_value()) {
        sql += " AND station_ae = ?";
        params.push_back(*query.station_ae);
    }
    if (query.modality.has_value()) {
        sql += " AND modality = ?";
        params.push_back(*query.modality);
    }
    if (query.study_uid.has_value()) {
        sql += " AND study_uid = ?";
        params.push_back(*query.study_uid);
    }
    if (query.accession_no.has_value()) {
        sql += " AND accession_no = ?";
        params.push_back(*query.accession_no);
    }
    if (query.start_date_from.has_value()) {
        sql += " AND substr(start_datetime, 1, 8) >= ?";
        params.push_back(*query.start_date_from);
    }
    if (query.start_date_to.has_value()) {
        sql += " AND substr(start_datetime, 1, 8) <= ?";
        params.push_back(*query.start_date_to);
    }
 
    sql += " ORDER BY start_datetime DESC";
 
    if (query.limit > 0) {
        sql += kcenon::pacs::compat::format(" LIMIT {}", query.limit);
    }
    if (query.offset > 0) {
        sql += kcenon::pacs::compat::format(" OFFSET {}", query.offset);
    }
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<mpps_record>>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    for (size_t i = 0; i < params.size(); ++i) {
        sqlite3_bind_text(stmt, static_cast<int>(i + 1), params[i].c_str(), -1,
                          SQLITE_TRANSIENT);
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_mpps_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

update_mpps() [1/2]

auto kcenon::pacs::storage::mpps_repository::update_mpps ( const mpps_record & record ) -> VoidResult

nodiscard

Definition at line 744 of file mpps_repository.cpp.

                                                                         {
    if (record.mpps_uid.empty()) {
        return make_error<std::monostate>(-1, "MPPS UID is required for update",
                                          "storage");
    }
 
    return update_mpps(record.mpps_uid, record.status, record.end_datetime,
                       record.performed_series);
}

update_mpps() [2/2]

auto kcenon::pacs::storage::mpps_repository::update_mpps ( std::string_view mpps_uid, std::string_view new_status, std::string_view end_datetime = "", std::string_view performed_series = "" ) -> VoidResult

nodiscard

Definition at line 667 of file mpps_repository.cpp.

                  {
    if (new_status != "COMPLETED" && new_status != "DISCONTINUED" &&
        new_status != "IN PROGRESS") {
        return make_error<std::monostate>(
            -1,
            "Invalid status. Must be 'IN PROGRESS', 'COMPLETED', or "
            "'DISCONTINUED'",
            "storage");
    }
 
    auto current = find_mpps(mpps_uid);
    if (!current.has_value()) {
        return make_error<std::monostate>(-1, "MPPS not found", "storage");
    }
 
    if (current->status == "COMPLETED" || current->status == "DISCONTINUED") {
        return make_error<std::monostate>(
            -1,
            kcenon::pacs::compat::format(
                "Cannot update MPPS in final state '{}'. COMPLETED and "
                "DISCONTINUED are final states.",
                current->status),
            "storage");
    }
 
    const char* sql = R"(
        UPDATE mpps
        SET status = ?,
            end_datetime = CASE WHEN ? != '' THEN ? ELSE end_datetime END,
            performed_series = CASE WHEN ? != '' THEN ? ELSE performed_series END,
            updated_at = datetime('now')
        WHERE mpps_uid = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare statement: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, new_status.data(),
                      static_cast<int>(new_status.size()), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, end_datetime.data(),
                      static_cast<int>(end_datetime.size()), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, end_datetime.data(),
                      static_cast<int>(end_datetime.size()), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 4, performed_series.data(),
                      static_cast<int>(performed_series.size()),
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 5, performed_series.data(),
                      static_cast<int>(performed_series.size()),
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, mpps_uid.data(),
                      static_cast<int>(mpps_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to update MPPS: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok();
}

Member Data Documentation

db_

sqlite3* kcenon::pacs::storage::mpps_repository::db_ {nullptr}

private

Definition at line 143 of file mpps_repository.h.

{nullptr};

Referenced by mpps_count().

---

The documentation for this class was generated from the following files:

• include/kcenon/pacs/storage/mpps_repository.h
• src/storage/mpps_repository.cpp