ores.refdata.currency

std::string("X")

"Test Currency " + std::to_string(faker::number::integer(1000, 9999))

std::to_string(faker::number::integer(10001, 99999))

[] {
    const auto sym = faker::finance::currencySymbol();
    return sym.empty() ? std::string("$") : std::string(sym);
}()

std::string("c")

100

std::string("Closest")

2

std::string("%3% %1$.2f")

std::string("fiat")

std::string("g10")

std::nullopt

faker::helper::randomElement(std::vector<int>{1, 2})

std::string("ACT/360")

faker::number::integer(1, 100)

drop function if exists ores_refdata_validate_currency_fn;

#include <boost/uuid/uuid.hpp>
#include <chrono>
#include <optional>
#include <string>

#include <optional>
#include <string>

#include "ores.qt/CalendarAssignmentWidget.hpp"

void setupCalendarsTab();
CalendarAssignmentWidget* calendarWidget_ = nullptr;
QWidget* calendarsTab_ = nullptr;

setupCalendarsTab();

if (!hasChanges_ && calendarWidget_ && calendarWidget_->hasPendingChanges()) {
    const auto crSel =
        promptChangeReason(ChangeReasonDialog::OperationType::Amend, true, "common");
    if (!crSel)
        return;
    calendarWidget_->commitChanges(
        crSel->reason_code, crSel->commentary, [this](bool success, const QString& message) {
            if (!success)
                MessageBoxHelper::critical(this, "Calendar Assignment Failed", message);
        });
    return;
}

if (self->calendarWidget_ && self->calendarWidget_->hasPendingChanges()) {
    self->calendarWidget_->commitChanges(
        crReasonCode, crCommentary, [self](bool success, const QString& message) {
            if (!success)
                MessageBoxHelper::critical(self, "Calendar Assignment Failed", message);
        });
}

if (calendarWidget_ && calendarsTab_ && tabWidget()->currentWidget() == calendarsTab_)
    calendarWidget_->setReadOnly(readOnly_ || currency_.iso_code.empty());

void CurrencyDetailDialog::setupCalendarsTab() {
    calendarWidget_ = new CalendarAssignmentWidget(this);
    calendarWidget_->setCallbacks(
        [](ClientManager* cm,
           const std::string& leftKey) -> CalendarAssignmentWidget::LoadResult {
            refdata::messaging::get_currency_calendars_request request;
            request.currency_iso_code = leftKey;
            auto response = cm->process_authenticated_request(std::move(request));
            if (!response)
                return {.success = false, .message = "Failed to communicate with server"};
            CalendarAssignmentWidget::LoadResult result;
            result.success = response->success;
            result.message = QString::fromStdString(response->message);
            for (const auto& cc : response->calendars)
                result.calendarCodes.push_back(cc.calendar_code);
            return result;
        },
        [](ClientManager* cm,
           const std::string& leftKey,
           const std::string& calendarCode,
           const std::string& changeReasonCode,
           const std::string& changeCommentary) -> CalendarAssignmentWidget::MutateResult {
            refdata::messaging::assign_currency_calendar_request request;
            request.currency_iso_code = leftKey;
            request.calendar_code = calendarCode;
            request.change_reason_code = changeReasonCode;
            request.change_commentary = changeCommentary;
            auto response = cm->process_authenticated_request(std::move(request));
            if (!response)
                return {.success = false, .message = "Failed to communicate with server"};
            return {.success = response->success, .message = QString::fromStdString(response->message)};
        },
        [](ClientManager* cm,
           const std::string& leftKey,
           const std::string& calendarCode) -> CalendarAssignmentWidget::MutateResult {
            refdata::messaging::revoke_currency_calendar_request request;
            request.currency_iso_code = leftKey;
            request.calendar_code = calendarCode;
            auto response = cm->process_authenticated_request(std::move(request));
            if (!response)
                return {.success = false, .message = "Failed to communicate with server"};
            return {.success = response->success, .message = QString::fromStdString(response->message)};
        });

    calendarsTab_ = new QWidget();
    auto* layout = new QVBoxLayout(calendarsTab_);
    layout->addWidget(calendarWidget_);
    // Provenance is the base template's own tab and should stay last for
    // consistency across every entity's detail dialog -- insert Calendars
    // before it rather than appending, which would push Provenance out of
    // its usual final position.
    int provenanceTabIndex = -1;
    for (int i = 0; i < tabWidget()->count(); ++i) {
        if (tabWidget()->tabText(i) == tr("Provenance")) {
            provenanceTabIndex = i;
            break;
        }
    }
    if (provenanceTabIndex >= 0)
        tabWidget()->insertTab(provenanceTabIndex, calendarsTab_, tr("Calendars"));
    else
        tabWidget()->addTab(calendarsTab_, tr("Calendars"));

    // calendarWidget_/calendarsTab_ only exist from this point on -- see
    // the calendars_tab_connections paste point above for why these
    // connections live here instead of setupConnections().
    connect(calendarWidget_,
            &CalendarAssignmentWidget::statusMessage,
            this,
            &CurrencyDetailDialog::statusMessage);
    connect(calendarWidget_,
            &CalendarAssignmentWidget::errorMessage,
            this,
            [this](const QString&, const QString& message) { emit errorMessage(message); });
    connect(calendarWidget_,
            &CalendarAssignmentWidget::assignmentsChanged,
            this,
            [this]() { ui_->saveButton->setEnabled(!readOnly_); });
    connect(tabWidget(), &QTabWidget::currentChanged, this, [this](int) {
        if (!calendarWidget_ || !calendarsTab_ || tabWidget()->currentWidget() != calendarsTab_)
            return;
        calendarWidget_->setClientManager(clientManager_);
        calendarWidget_->setImageCache(imageCache());
        calendarWidget_->setLeftKey(currency_.iso_code);
        calendarWidget_->setReadOnly(readOnly_ || currency_.iso_code.empty());
        calendarWidget_->load();
    });
    // Calendar commits are triggered from onSaveClicked itself (see the
    // calendars_tab_save_guard and on_save_success paste points) so both
    // the currency's own fields and calendar assignments share a single
    // change-reason prompt per Save click -- no separate saveButton
    // connection here.
}

, junction_repo_(ctx_)

#include <boost/uuid/uuid.hpp>
#include "ores.refdata.core/repository/party_currency_repository.hpp"

#include <algorithm>
#include <boost/uuid/uuid_io.hpp>
#include <unordered_set>

/**
 * @brief Lists currencies visible to a specific party, with pagination.
 *
 * Uses the party_currencies junction to filter the full currency list
 * to only those the given party is permitted to see.
 *
 * @param party_id The UUID of the party.
 * @param offset Number of records to skip.
 * @param limit Maximum number of records to return.
 * @return Vector of visible currencies for the requested page.
 */
std::vector<domain::currency> list_currencies_for_party(const boost::uuids::uuid& party_id,
                                                        std::uint32_t offset,
                                                        std::uint32_t limit);

/**
 * @brief Gets the total count of currencies visible to a specific party.
 *
 * @param party_id The UUID of the party.
 * @return Number of currencies the party is permitted to see.
 */
std::uint32_t count_currencies_for_party(const boost::uuids::uuid& party_id);

repository::party_currency_repository junction_repo_;

std::vector<domain::currency> currency_service::list_currencies_for_party(
    const boost::uuids::uuid& party_id, std::uint32_t offset, std::uint32_t limit) {
    BOOST_LOG_SEV(lg(), debug) << "Listing currencies for party: " << party_id
                               << " offset=" << offset << " limit=" << limit;

    const auto junctions = junction_repo_.read_latest_by_party(party_id);
    std::unordered_set<std::string> visible;
    visible.reserve(junctions.size());
    for (const auto& j : junctions)
        visible.insert(j.currency_iso_code);

    auto all = repo_.read_latest(ctx_);
    std::vector<domain::currency> filtered;
    filtered.reserve(visible.size());
    for (auto& c : all) {
        if (visible.count(c.iso_code))
            filtered.push_back(std::move(c));
    }

    if (offset >= filtered.size())
        return {};
    const auto end = std::min<std::size_t>(offset + limit, filtered.size());
    return std::vector<domain::currency>(filtered.begin() + offset, filtered.begin() + end);
}

std::uint32_t currency_service::count_currencies_for_party(const boost::uuids::uuid& party_id) {
    BOOST_LOG_SEV(lg(), debug) << "Counting currencies for party: " << party_id;
    const auto junctions = junction_repo_.read_latest_by_party(party_id);
    return static_cast<std::uint32_t>(junctions.size());
}

/**
 * @brief Generates a set of currencies using Unicode symbols.
 *
 * Used for testing internationalisation and symbol rendering.
 */
ORES_REFDATA_API_EXPORT std::vector<domain::currency>
generate_synthetic_unicode_currencies(utility::generation::generation_context& ctx);

/**
 * @brief Generates N synthetic currencies with unique ISO codes.
 */
ORES_REFDATA_API_EXPORT std::vector<domain::currency>
generate_unique_synthetic_currencies(std::size_t n, utility::generation::generation_context& ctx);

/**
 * @brief Generates a set of fictional currencies.
 *
 * These are intentionally fake currencies with made-up ISO codes that do not
 * correspond to any real ISO 4217 codes. Useful for testing and demo
 * purposes where real currency data should not be used.
 *
 * @param n Number of currencies to generate. If n is 0 or greater than the
 *          available set (50), returns all available fictional currencies.
 */
ORES_REFDATA_API_EXPORT std::vector<domain::currency>
generate_fictional_currencies(std::size_t n, utility::generation::generation_context& ctx);

std::vector<domain::currency>
generate_synthetic_unicode_currencies(utility::generation::generation_context& ctx) {
    const auto modified_by = ctx.env().get_or(generation_keys::modified_by, "system");
    const auto tid = ctx.env().get_or(generation_keys::tenant_id, "system");
    const auto parsed_tid = utility::uuid::tenant_id::from_string(tid);
    const auto tenant_id =
        parsed_tid.has_value() ? parsed_tid.value() : utility::uuid::tenant_id::system();

    static std::atomic<std::size_t> batch{0};
    const auto b = ++batch;
    const auto suffix = "_" + std::to_string(b);
    const auto now = ctx.past_timepoint();

    std::vector<domain::currency> r;
    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XU" + std::to_string(b),
                 .name = "Test Dollar" + suffix,
                 .numeric_code = "90001",
                 .symbol = "$",
                 .fraction_symbol = "\xC2\xA2",
                 .fractions_per_unit = 100,
                 .rounding_type = "Closest",
                 .rounding_precision = 2,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});

    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XE" + std::to_string(b),
                 .name = "Test Euro" + suffix,
                 .numeric_code = "90002",
                 .symbol = "\xE2\x82\xAC",
                 .fraction_symbol = "\xC2\xA2",
                 .fractions_per_unit = 100,
                 .rounding_type = "Closest",
                 .rounding_precision = 2,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});

    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XG" + std::to_string(b),
                 .name = "Test Pound" + suffix,
                 .numeric_code = "90003",
                 .symbol = "\xC2\xA3",
                 .fraction_symbol = "p",
                 .fractions_per_unit = 100,
                 .rounding_type = "Closest",
                 .rounding_precision = 2,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});

    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XJ" + std::to_string(b),
                 .name = "Test Yen" + suffix,
                 .numeric_code = "90004",
                 .symbol = "\xC2\xA5",
                 .fraction_symbol = "",
                 .fractions_per_unit = 0,
                 .rounding_type = "Closest",
                 .rounding_precision = 0,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});

    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XI" + std::to_string(b),
                 .name = "Test Rupee" + suffix,
                 .numeric_code = "90005",
                 .symbol = "\xE2\x82\xB9",
                 .fraction_symbol = "\xE0\xA4\xAA",
                 .fractions_per_unit = 100,
                 .rounding_type = "Closest",
                 .rounding_precision = 2,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});

    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XB" + std::to_string(b),
                 .name = "Test Crypto" + suffix,
                 .numeric_code = "90006",
                 .symbol = "\xE2\x82\xBF",
                 .fraction_symbol = "s",
                 .fractions_per_unit = 100000000,
                 .rounding_type = "Closest",
                 .rounding_precision = 2,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});

    r.push_back({.tenant_id = tenant_id,
                 .iso_code = "XR" + std::to_string(b),
                 .name = "Test Ruble" + suffix,
                 .numeric_code = "90007",
                 .symbol = "\xE2\x82\xBD",
                 .fraction_symbol = "\xD0\xBA",
                 .fractions_per_unit = 100,
                 .rounding_type = "Closest",
                 .rounding_precision = 2,
                 .format = "%3% %1$.2f",
                 .monetary_nature = "fiat",
                 .market_tier = "g10",
                 .modified_by = modified_by,
                 .change_reason_code = "system.test",
                 .change_commentary = "Synthetic test data",
                 .recorded_at = now});
    return r;
}

std::vector<domain::currency>
generate_unique_synthetic_currencies(std::size_t n, utility::generation::generation_context& ctx) {
    std::unordered_set<std::string> seen;
    seen.reserve(n);

    std::vector<domain::currency> r;
    r.reserve(n);

    std::size_t suffix = 0;
    while (r.size() < n) {
        auto currency = generate_synthetic_currency(ctx);
        if (!seen.insert(currency.iso_code).second) {
            auto base_code = currency.iso_code;
            do {
                currency.iso_code = base_code + std::to_string(++suffix);
            } while (!seen.insert(currency.iso_code).second);
        }
        r.push_back(std::move(currency));
    }
    return r;
}

std::vector<domain::currency>
generate_fictional_currencies(std::size_t n, utility::generation::generation_context& ctx) {
    const auto modified_by = ctx.env().get_or(generation_keys::modified_by, "system");
    const auto tid = ctx.env().get_or(generation_keys::tenant_id, "system");
    const auto parsed_tid = utility::uuid::tenant_id::from_string(tid);
    const auto tenant_id =
        parsed_tid.has_value() ? parsed_tid.value() : utility::uuid::tenant_id::system();
    const auto now = ctx.past_timepoint();

    std::vector<domain::currency> all;
    all.reserve(50);

    // Fictional currencies intentionally omit fraction_symbol. These are
    // synthetic test data; no real sub-unit symbol is needed, and
    // fractions_per_unit controls numeric precision in calculations only.
    all.push_back({.tenant_id = tenant_id, .iso_code = "XAE", .name = "Aerilonian Dollar",
                   .numeric_code = "10001", .symbol = "A$", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XAR", .name = "Arcturian Arct",
                   .numeric_code = "10002", .symbol = "Ar", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XBL", .name = "Balthorian Florin",
                   .numeric_code = "10003", .symbol = "Bf", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XBE", .name = "Bellorian Bell",
                   .numeric_code = "10004", .symbol = "Bb", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XCA", .name = "Calandrian Crown",
                   .numeric_code = "10005", .symbol = "Cc", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XCL", .name = "Caledonian Caled",
                   .numeric_code = "10006", .symbol = "Cd", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XDA", .name = "Daelorian Dinar",
                   .numeric_code = "10007", .symbol = "Dd", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XDL", .name = "Delvadian Delv",
                   .numeric_code = "10008", .symbol = "De", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XER", .name = "Eriadoran Euro",
                   .numeric_code = "10009", .symbol = "Er", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XES", .name = "Esterian Est",
                   .numeric_code = "10010", .symbol = "Es", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XFE", .name = "Felorian Franc",
                   .numeric_code = "10011", .symbol = "Ff", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XFN", .name = "Fendarian Fen",
                   .numeric_code = "10012", .symbol = "Fn", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XGA", .name = "Galdorian Galleon",
                   .numeric_code = "10013", .symbol = "Gg", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XGR", .name = "Grendorian Grend",
                   .numeric_code = "10014", .symbol = "Gr", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XHE", .name = "Helvetian Franc",
                   .numeric_code = "10015", .symbol = "Hf", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XHY", .name = "Hydronian Hyd",
                   .numeric_code = "10016", .symbol = "Hy", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XIR", .name = "Iridian Dollar",
                   .numeric_code = "10017", .symbol = "I$", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XIT", .name = "Ithacan Ith",
                   .numeric_code = "10018", .symbol = "It", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XJE", .name = "Jethronian Jet",
                   .numeric_code = "10019", .symbol = "Je", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XJO", .name = "Jorvikian Krona",
                   .numeric_code = "10020", .symbol = "Jk", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XKA", .name = "Kaelorian Krown",
                   .numeric_code = "10021", .symbol = "Kk", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XKR", .name = "Krynnish Krynn",
                   .numeric_code = "10022", .symbol = "Kr", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XLU", .name = "Luminian Lum",
                   .numeric_code = "10023", .symbol = "Lu", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XLY", .name = "Lysandrian Lira",
                   .numeric_code = "10024", .symbol = "Ly", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XMA", .name = "Maldorian Mal",
                   .numeric_code = "10025", .symbol = "Mm", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XMR", .name = "Mariposan Peso",
                   .numeric_code = "10026", .symbol = "Mp", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XNE", .name = "Nektonian Nek",
                   .numeric_code = "10027", .symbol = "Ne", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XNT", .name = "Netharian Naira",
                   .numeric_code = "10028", .symbol = "Nt", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XOR", .name = "Orinocan Bolivar",
                   .numeric_code = "10029", .symbol = "Ob", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XOL", .name = "Orlanthian Orl",
                   .numeric_code = "10030", .symbol = "Ol", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XPL", .name = "Paldorian Peso",
                   .numeric_code = "10031", .symbol = "Pp", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XPY", .name = "Pyrrhian Pyr",
                   .numeric_code = "10032", .symbol = "Py", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XQU", .name = "Quentarian Quen",
                   .numeric_code = "10033", .symbol = "Qu", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XQN", .name = "Quinarian Quetzal",
                   .numeric_code = "10034", .symbol = "Qn", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XRE", .name = "Rendellian Rend",
                   .numeric_code = "10035", .symbol = "Re", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XRI", .name = "Rivenian Ruble",
                   .numeric_code = "10036", .symbol = "Ri", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XSE", .name = "Serendian Shilling",
                   .numeric_code = "10037", .symbol = "Ss", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XSI", .name = "Sildorian Sild",
                   .numeric_code = "10038", .symbol = "Si", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XTA", .name = "Tandorian Taka",
                   .numeric_code = "10039", .symbol = "Ta", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XTE", .name = "Tenebrian Ten",
                   .numeric_code = "10040", .symbol = "Te", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XUL", .name = "Uldorian Uld",
                   .numeric_code = "10041", .symbol = "Ul", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XUT", .name = "Utopian Unit",
                   .numeric_code = "10042", .symbol = "Ut", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XVA", .name = "Valorian Valt",
                   .numeric_code = "10043", .symbol = "Vv", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XVL", .name = "Valtarian Val",
                   .numeric_code = "10044", .symbol = "Vl", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XWI", .name = "Wintervalean Won",
                   .numeric_code = "10045", .symbol = "Ww", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XWY", .name = "Wysterian Wys",
                   .numeric_code = "10046", .symbol = "Wy", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XAN", .name = "Xandrian Xan",
                   .numeric_code = "10047", .symbol = "Xa", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XEN", .name = "Xenorian Xen",
                   .numeric_code = "10048", .symbol = "Xe", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XYS", .name = "Yslandian Yen",
                   .numeric_code = "10049", .symbol = "Ys", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});
    all.push_back({.tenant_id = tenant_id, .iso_code = "XZE", .name = "Zephyrian Zephyr",
                   .numeric_code = "10050", .symbol = "Ze", .fractions_per_unit = 100,
                   .rounding_type = "Closest", .rounding_precision = 2, .format = "%3% %1$.2f",
                   .monetary_nature = "fiat", .market_tier = "g10", .modified_by = modified_by,
                   .change_reason_code = "system.test", .change_commentary = "Synthetic test data",
                   .recorded_at = now});

    if (n == 0 || n >= all.size())
        return all;

    return std::vector<domain::currency>(all.begin(), all.begin() + n);
}

, calendar_repo_(ctx_)

#include "ores.refdata.core/repository/currency_calendar_repository.hpp"

/**
 * @brief Lists the calendars assigned to a currency for spot/settlement
 * date computation, via the currency_calendars junction.
 *
 * @param currency_iso_code The ISO 4217 code of the currency.
 * @return Vector of calendar assignment rows for the currency.
 */
std::vector<ores::refdata::domain::currency_calendar>
list_calendars_for_currency(const std::string& currency_iso_code);

/**
 * @brief Assigns a calendar to a currency (creates the junction row).
 *
 * @param row The currency_calendar row to write; caller is responsible
 * for stamping tenant_id/modified_by/performed_by/change_reason_code
 * before calling (see ores::service::messaging::stamp()).
 */
void assign_calendar_to_currency(const ores::refdata::domain::currency_calendar& row);

/**
 * @brief Revokes a calendar from a currency (removes the junction row).
 *
 * @param currency_iso_code The ISO 4217 code of the currency.
 * @param calendar_code The QuantLib/ORE calendar token to revoke.
 */
void revoke_calendar_from_currency(const std::string& currency_iso_code,
                                   const std::string& calendar_code);

repository::currency_calendar_repository calendar_repo_;

std::vector<ores::refdata::domain::currency_calendar>
currency_service::list_calendars_for_currency(const std::string& currency_iso_code) {
    BOOST_LOG_SEV(lg(), debug) << "Listing calendars for currency: " << currency_iso_code;
    return calendar_repo_.read_latest_by_currency(currency_iso_code);
}

void currency_service::assign_calendar_to_currency(
    const ores::refdata::domain::currency_calendar& row) {
    BOOST_LOG_SEV(lg(), debug) << "Assigning calendar to currency: " << row.currency_iso_code
                               << "/" << row.calendar_code;
    calendar_repo_.write(row);
    BOOST_LOG_SEV(lg(), info) << "Assigned calendar to currency: " << row.currency_iso_code
                              << "/" << row.calendar_code;
}

void currency_service::revoke_calendar_from_currency(const std::string& currency_iso_code,
                                                      const std::string& calendar_code) {
    BOOST_LOG_SEV(lg(), debug) << "Revoking calendar from currency: " << currency_iso_code
                               << "/" << calendar_code;
    calendar_repo_.remove(currency_iso_code, calendar_code);
    BOOST_LOG_SEV(lg(), info) << "Revoked calendar from currency: " << currency_iso_code
                              << "/" << calendar_code;
}

#include "ores.refdata.api/domain/currency_calendar.hpp"

struct get_currency_calendars_request {
    using response_type = struct get_currency_calendars_response;
    static constexpr std::string_view nats_subject = "refdata.v1.currencies.calendars.list";
    std::string currency_iso_code;
};

struct get_currency_calendars_response {
    std::vector<ores::refdata::domain::currency_calendar> calendars;
    bool success = false;
    std::string message;
};

struct assign_currency_calendar_request {
    using response_type = struct assign_currency_calendar_response;
    static constexpr std::string_view nats_subject = "refdata.v1.currencies.calendars.assign";
    std::string currency_iso_code;
    std::string calendar_code;
    std::string change_reason_code;
    std::string change_commentary;
};

struct assign_currency_calendar_response {
    bool success = false;
    std::string message;
};

struct revoke_currency_calendar_request {
    using response_type = struct revoke_currency_calendar_response;
    static constexpr std::string_view nats_subject = "refdata.v1.currencies.calendars.revoke";
    std::string currency_iso_code;
    std::string calendar_code;
};

struct revoke_currency_calendar_response {
    bool success = false;
    std::string message;
};

void list_calendars(ores::nats::message msg) {
    BOOST_LOG_SEV(currency_handler_lg(), debug) << "Handling " << msg.subject;
    auto req_ctx_expected = ores::service::service::make_request_context(
        ctx_, msg, verifier_);
    if (!req_ctx_expected) {
        error_reply(nats_, msg, req_ctx_expected.error());
        return;
    }
    const auto& req_ctx = *req_ctx_expected;
    service::currency_service svc(req_ctx);
    if (auto req = decode<get_currency_calendars_request>(msg)) {
        get_currency_calendars_response resp;
        try {
            resp.calendars = svc.list_calendars_for_currency(req->currency_iso_code);
            resp.success = true;
        } catch (const std::exception& e) {
            BOOST_LOG_SEV(currency_handler_lg(), error)
                << msg.subject << " failed: " << e.what();
            resp.success = false;
            resp.message = e.what();
        }
        BOOST_LOG_SEV(currency_handler_lg(), debug) << "Completed " << msg.subject;
        reply(nats_, msg, resp);
    } else {
        BOOST_LOG_SEV(currency_handler_lg(), warn) << "Failed to decode: " << msg.subject;
        error_reply(nats_, msg, ores::service::error_code::bad_request);
    }
}

void assign_calendar(ores::nats::message msg) {
    BOOST_LOG_SEV(currency_handler_lg(), debug) << "Handling " << msg.subject;
    auto req_ctx_expected = ores::service::service::make_request_context(
        ctx_, msg, verifier_);
    if (!req_ctx_expected) {
        error_reply(nats_, msg, req_ctx_expected.error());
        return;
    }
    const auto& req_ctx = *req_ctx_expected;
    if (!has_permission(req_ctx, "refdata::currencies:write")) {
        error_reply(nats_, msg, ores::service::error_code::forbidden);
        return;
    }
    service::currency_service svc(req_ctx);
    if (auto req = decode<assign_currency_calendar_request>(msg)) {
        try {
            domain::currency_calendar row;
            row.currency_iso_code = req->currency_iso_code;
            row.calendar_code = req->calendar_code;
            row.change_reason_code = req->change_reason_code;
            row.change_commentary = req->change_commentary;
            ores::service::messaging::stamp(row, req_ctx);
            svc.assign_calendar_to_currency(row);
            BOOST_LOG_SEV(currency_handler_lg(), debug) << "Completed " << msg.subject;
            reply(nats_, msg, assign_currency_calendar_response{.success = true});
        } catch (const std::exception& e) {
            BOOST_LOG_SEV(currency_handler_lg(), error)
                << msg.subject << " failed: " << e.what();
            reply(nats_, msg, assign_currency_calendar_response{
                .success = false, .message = e.what()});
        }
    } else {
        BOOST_LOG_SEV(currency_handler_lg(), warn) << "Failed to decode: " << msg.subject;
        error_reply(nats_, msg, ores::service::error_code::bad_request);
    }
}

void revoke_calendar(ores::nats::message msg) {
    BOOST_LOG_SEV(currency_handler_lg(), debug) << "Handling " << msg.subject;
    auto req_ctx_expected = ores::service::service::make_request_context(
        ctx_, msg, verifier_);
    if (!req_ctx_expected) {
        error_reply(nats_, msg, req_ctx_expected.error());
        return;
    }
    const auto& req_ctx = *req_ctx_expected;
    if (!has_permission(req_ctx, "refdata::currencies:write")) {
        error_reply(nats_, msg, ores::service::error_code::forbidden);
        return;
    }
    service::currency_service svc(req_ctx);
    if (auto req = decode<revoke_currency_calendar_request>(msg)) {
        try {
            svc.revoke_calendar_from_currency(req->currency_iso_code, req->calendar_code);
            BOOST_LOG_SEV(currency_handler_lg(), debug) << "Completed " << msg.subject;
            reply(nats_, msg, revoke_currency_calendar_response{.success = true});
        } catch (const std::exception& e) {
            BOOST_LOG_SEV(currency_handler_lg(), error)
                << msg.subject << " failed: " << e.what();
            reply(nats_, msg, revoke_currency_calendar_response{
                .success = false, .message = e.what()});
        }
    } else {
        BOOST_LOG_SEV(currency_handler_lg(), warn) << "Failed to decode: " << msg.subject;
        error_reply(nats_, msg, ores::service::error_code::bad_request);
    }
}

subs.push_back(nats.queue_subscribe(
    get_currency_calendars_request::nats_subject, queue_group,
    [h](ores::nats::message msg) { h->list_calendars(std::move(msg)); }));
subs.push_back(nats.queue_subscribe(
    assign_currency_calendar_request::nats_subject, queue_group,
    [h](ores::nats::message msg) { h->assign_calendar(std::move(msg)); }));
subs.push_back(nats.queue_subscribe(
    revoke_currency_calendar_request::nats_subject, queue_group,
    [h](ores::nats::message msg) { h->revoke_calendar(std::move(msg)); }));