ores.refdata.party

std::vector<domain::party>
read_system_party(context ctx, const std::string& tenant_id);

#include <boost/uuid/uuid_io.hpp>
#include <boost/lexical_cast.hpp>
#include "ores.utility/uuid/tenant_id.hpp"

std::vector<domain::party>
party_repository::read_system_party(context ctx, const std::string& tenant_id) {
    BOOST_LOG_SEV(lg(), debug) << "Reading system party for tenant: " << tenant_id;
    const std::string sql =
        "SELECT * FROM ores_refdata_read_system_party_fn('" + tenant_id + "'::uuid)";
    const auto rows = execute_raw_multi_column_query(ctx, sql, lg(),
        "Reading system party by tenant");
    std::vector<domain::party> result;
    result.reserve(rows.size());
    static constexpr std::array required_columns = {0, 1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14};
    for (const auto& row : rows) {
        if (row.size() >= 16 &&
            std::ranges::all_of(required_columns,
                [&row](int i) { return static_cast<bool>(row[i]); })) {
            domain::party p;
            p.id = boost::lexical_cast<boost::uuids::uuid>(*row[0]);
            p.tenant_id = utility::uuid::tenant_id::from_string(*row[1]).value();
            p.version = std::stoi(*row[2]);
            p.full_name = *row[3];
            p.short_code = *row[4];
            p.party_category = *row[5];
            p.party_type = *row[6];
            if (row[7])
                p.parent_party_id = boost::lexical_cast<boost::uuids::uuid>(*row[7]);
            if (row[8])
                p.business_center_code = *row[8];
            p.status = *row[9];
            p.modified_by = *row[10];
            result.push_back(p);
        }
    }
    return result;
}

std::vector<domain::party>
read_latest(context ctx, std::uint32_t offset, std::uint32_t limit);

#include <cstdint>

std::vector<domain::party>
party_repository::read_latest(context ctx, std::uint32_t offset, std::uint32_t limit) {
    BOOST_LOG_SEV(lg(), debug) << "Reading latest parties. Offset: " << offset << " limit: " << limit;
    static auto max(make_timestamp(MAX_TIMESTAMP, lg()));
    const auto query = sqlgen::read<std::vector<party_entity>> |
        where("valid_to"_c == max.value()) |
        order_by("full_name"_c) |
        sqlgen::offset(offset) |
        sqlgen::limit(limit);
    return execute_read_query<party_entity, domain::party>(
        ctx, query,
        [](const auto& entities) { return party_mapper::map(entities); },
        lg(), "Reading latest parties with pagination.");
}

std::uint32_t get_total_party_count(context ctx);

std::uint32_t party_repository::get_total_party_count(context ctx) {
    BOOST_LOG_SEV(lg(), debug) << "Getting total active party count";
    static auto max(make_timestamp(MAX_TIMESTAMP, lg()));
    struct count_result { long long count; };
    const auto query = sqlgen::select_from<party_entity>(
        sqlgen::count().as<"count">()) |
        where("valid_to"_c == max.value()) |
        sqlgen::to<count_result>;
    const auto r = sqlgen::session(ctx.connection_pool()).and_then(query);
    ensure_success(r, lg());
    return static_cast<std::uint32_t>(r->count);
}

std::vector<boost::uuids::uuid>
read_descendants(context ctx, const boost::uuids::uuid& root_id);

#include <boost/uuid/uuid_io.hpp>
#include <boost/lexical_cast.hpp>

std::vector<boost::uuids::uuid>
party_repository::read_descendants(context ctx, const boost::uuids::uuid& root_id) {
    BOOST_LOG_SEV(lg(), debug) << "Reading party descendants. Root: " << root_id;
    const auto id_str = boost::uuids::to_string(root_id);
    const std::string sql =
        "WITH RECURSIVE party_tree AS ("
        "  SELECT id FROM ores_refdata_parties_tbl"
        "  WHERE id = '" + id_str + "' AND valid_to = '" + MAX_TIMESTAMP + "'"
        "  UNION ALL"
        "  SELECT p.id FROM ores_refdata_parties_tbl p"
        "  JOIN party_tree pt ON p.parent_party_id = pt.id"
        "  WHERE p.valid_to = '" + MAX_TIMESTAMP + "'"
        ") SELECT id FROM party_tree";
    const auto rows = execute_raw_multi_column_query(ctx, sql, lg(),
        "Reading party descendants");
    std::vector<boost::uuids::uuid> result;
    result.reserve(rows.size());
    for (const auto& row : rows)
        if (!row.empty() && row[0])
            result.push_back(boost::lexical_cast<boost::uuids::uuid>(*row[0]));
    return result;
}