ores.refdata.calendar

std::string("X")

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

std::string("public_holiday")

std::string("ZZ")

-- Paste block: doesn't fit soft_fk_validations (joins on id, not
-- an alpha-2 code column) or the Validations table
-- (ores_refdata_validate_country_fn only checks non-null/empty,
-- not existence).
if not exists (
    select 1 from ores_refdata_countries_tbl
    where tenant_id = NEW.tenant_id
      and alpha2_code = NEW.country_code
      and valid_to = ores_utility_infinity_timestamp_fn()
) then
    raise exception 'Invalid country_code: %. Must be a valid ISO 3166-1 alpha-2 code (or the ZZ sentinel).',
        NEW.country_code;
end if;

std::nullopt

std::string("quantlib")

false

std::nullopt

-- Paste block: self-referential soft FK (joins the same table
-- against itself), doesn't fit soft_fk_validations. Only checked
-- when present -- a null base_calendar_code is always valid (a
-- base-less template, QuantLib or user-authored).
if NEW.base_calendar_code is not null and not exists (
    select 1 from ores_refdata_calendars_tbl
    where tenant_id = NEW.tenant_id
      and code = NEW.base_calendar_code
      and valid_to = ores_utility_infinity_timestamp_fn()
) then
    raise exception 'Invalid base_calendar_code: %. No active calendar found with this code.',
        NEW.base_calendar_code;
end if;

drop function if exists ores_refdata_validate_calendar_fn;

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

#include <optional>
#include <string>

/**
 * @brief Generates the full QuantLib calendar set as real reference data.
 *
 * Transcribed from QuantLib's calendar headers (ql/time/calendars/):
 * one row per concrete calendar token, including sub-market variants
 * (e.g. UnitedStates.NYSE, UnitedStates.GovernmentBond) as distinct
 * rows rather than a joined variant field. This is real reference
 * data, not fictional test data — every code matches ORE's XML
 * <Calendar> vocabulary verbatim.
 */
ORES_REFDATA_API_EXPORT std::vector<domain::calendar>
generate_quantlib_calendars(utility::generation::generation_context& ctx);

std::vector<domain::calendar>
generate_quantlib_calendars(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();

    struct row { const char* code; const char* name; const char* type; const char* country; };
    static constexpr row rows[] = {
        // Supranational
        {"TARGET", "TARGET (Euro area)", "public_holiday", "ZZ"},
        {"WeekendsOnly", "Weekends Only", "public_holiday", "ZZ"},
        // Single-market national calendars
        {"Argentina", "Argentina", "public_holiday", "AR"},
        {"Australia", "Australia", "public_holiday", "AU"},
        {"Austria", "Austria", "public_holiday", "AT"},
        {"Botswana", "Botswana", "public_holiday", "BW"},
        {"Brazil", "Brazil", "public_holiday", "BR"},
        {"Chile", "Chile", "public_holiday", "CL"},
        {"CzechRepublic", "Czech Republic", "public_holiday", "CZ"},
        {"Denmark", "Denmark", "public_holiday", "DK"},
        {"Finland", "Finland", "public_holiday", "FI"},
        {"France", "France", "public_holiday", "FR"},
        {"HongKong", "Hong Kong", "public_holiday", "HK"},
        {"Hungary", "Hungary", "public_holiday", "HU"},
        {"Iceland", "Iceland", "public_holiday", "IS"},
        {"India", "India (National Stock Exchange)", "financial_centre", "IN"},
        {"Italy", "Italy", "public_holiday", "IT"},
        {"Japan", "Japan", "public_holiday", "JP"},
        {"Mexico", "Mexico", "public_holiday", "MX"},
        {"NewZealand", "New Zealand", "public_holiday", "NZ"},
        {"Norway", "Norway", "public_holiday", "NO"},
        {"Poland", "Poland", "public_holiday", "PL"},
        {"Romania", "Romania", "public_holiday", "RO"},
        {"Russia", "Russia", "public_holiday", "RU"},
        {"SaudiArabia", "Saudi Arabia", "public_holiday", "SA"},
        {"Singapore", "Singapore", "public_holiday", "SG"},
        {"Slovakia", "Slovakia", "public_holiday", "SK"},
        {"SouthAfrica", "South Africa", "public_holiday", "ZA"},
        {"Sweden", "Sweden", "public_holiday", "SE"},
        {"Switzerland", "Switzerland", "public_holiday", "CH"},
        {"Taiwan", "Taiwan", "public_holiday", "TW"},
        {"Thailand", "Thailand", "public_holiday", "TH"},
        {"Turkey", "Turkey", "public_holiday", "TR"},
        {"Ukraine", "Ukraine", "public_holiday", "UA"},
        // United States (Market enum)
        {"UnitedStates.Settlement", "United States (Settlement)", "public_holiday", "US"},
        {"UnitedStates.NYSE", "United States (NYSE)", "financial_centre", "US"},
        {"UnitedStates.GovernmentBond", "United States (Government Bond)", "financial_centre", "US"},
        {"UnitedStates.NERC", "United States (NERC)", "financial_centre", "US"},
        {"UnitedStates.LiborImpact", "United States (Libor Impact)", "financial_centre", "US"},
        {"UnitedStates.FederalReserve", "United States (Federal Reserve)", "financial_centre", "US"},
        {"UnitedStates.SOFR", "United States (SOFR)", "financial_centre", "US"},
        // United Kingdom (Market enum)
        {"UnitedKingdom.Settlement", "United Kingdom (Settlement)", "public_holiday", "GB"},
        {"UnitedKingdom.Exchange", "United Kingdom (Exchange)", "financial_centre", "GB"},
        {"UnitedKingdom.Metals", "United Kingdom (Metals)", "financial_centre", "GB"},
        // China (Market enum)
        {"China.SSE", "China (Shanghai Stock Exchange)", "financial_centre", "CN"},
        {"China.IB", "China (Interbank)", "financial_centre", "CN"},
        // Germany (Market enum)
        {"Germany.Settlement", "Germany (Settlement)", "public_holiday", "DE"},
        {"Germany.FrankfurtStockExchange", "Germany (Frankfurt Stock Exchange)", "financial_centre", "DE"},
        {"Germany.Xetra", "Germany (Xetra)", "financial_centre", "DE"},
        {"Germany.Eurex", "Germany (Eurex)", "financial_centre", "DE"},
        {"Germany.Euwax", "Germany (Euwax)", "financial_centre", "DE"},
        // Canada (Market enum)
        {"Canada.Settlement", "Canada (Settlement)", "public_holiday", "CA"},
        {"Canada.TSX", "Canada (Toronto Stock Exchange)", "financial_centre", "CA"},
        // South Korea (Market enum)
        {"SouthKorea.Settlement", "South Korea (Settlement)", "public_holiday", "KR"},
        {"SouthKorea.KRX", "South Korea (Korea Exchange)", "financial_centre", "KR"},
        // Indonesia (Market enum)
        {"Indonesia.BEJ", "Indonesia (Jakarta SE, legacy BEJ)", "financial_centre", "ID"},
        {"Indonesia.JSX", "Indonesia (Jakarta SE, legacy JSX)", "financial_centre", "ID"},
        {"Indonesia.IDX", "Indonesia (Indonesia Stock Exchange)", "financial_centre", "ID"},
        // Israel (Market enum)
        {"Israel.Settlement", "Israel (Settlement)", "public_holiday", "IL"},
        {"Israel.TASE", "Israel (Tel-Aviv Stock Exchange)", "financial_centre", "IL"},
    };

    std::vector<domain::calendar> result;
    result.reserve(std::size(rows));
    for (const auto& r : rows) {
        result.push_back({.tenant_id = tenant_id,
                          .code = r.code,
                          .name = r.name,
                          .calendar_type = r.type,
                          .country_code = r.country,
                          .modified_by = modified_by,
                          .change_reason_code = "system.initial_load",
                          .change_commentary = "QuantLib calendar reference data",
                          .recorded_at = now});
    }
    return result;
}

setReadOnly(!calendar_.is_editable);

if (regenerateAction_)
    regenerateAction_->setEnabled(!createMode);

#include "ores.refdata.api/messaging/calendar_materialisation_protocol.hpp"
#include <QDate>
#include <QInputDialog>

QAction* regenerateAction_{nullptr};
void onRegenerateClicked();

regenerateAction_ = toolBar_->addAction(
    IconUtils::createRecoloredIcon(Icon::ArrowSync, IconUtils::DefaultIconColor),
    tr("Regenerate"));
regenerateAction_->setToolTip(
    tr("Regenerate this calendar's holidays up to a chosen year"));
regenerateAction_->setEnabled(!createMode_);
connect(regenerateAction_, &QAction::triggered,
        this, &CalendarDetailDialog::onRegenerateClicked);

void browseHolidaysRequested(const QString& code);

QAction* browseHolidaysAction_{nullptr};
void onBrowseHolidaysClicked();

browseHolidaysAction_ = toolBar_->addAction(
    IconUtils::createRecoloredIcon(Icon::Table, IconUtils::DefaultIconColor),
    tr("Browse Holidays"));
browseHolidaysAction_->setToolTip(tr("Browse this calendar's materialised holiday dates"));
browseHolidaysAction_->setEnabled(!createMode_);
connect(browseHolidaysAction_, &QAction::triggered,
        this, &CalendarDetailDialog::onBrowseHolidaysClicked);

if (browseHolidaysAction_)
    browseHolidaysAction_->setEnabled(!createMode);

void CalendarDetailDialog::onBrowseHolidaysClicked() {
    emit browseHolidaysRequested(code());
}

/**
 * @brief Relayed from CalendarDetailDialog's "Browse Holidays" toolbar
 * action; RefdataPlugin connects this to
 * CalendarDateController::openForParent(calendarCode).
 */
void browseHolidaysRequested(const QString& calendarCode);

connect(detailDialog, &CalendarDetailDialog::browseHolidaysRequested,
        this, &CalendarController::browseHolidaysRequested);

void CalendarDetailDialog::onRegenerateClicked() {
    if (!clientManager_ || !clientManager_->isConnected()) {
        MessageBoxHelper::warning(this, "Disconnected",
            "Cannot regenerate while disconnected from server.");
        return;
    }

    bool ok = false;
    const int currentYear = QDate::currentDate().year();
    const int endYear = QInputDialog::getInt(this, tr("Regenerate Holidays"),
        tr("Regenerate up to year:"), currentYear + 10,
        currentYear, currentYear + 100, 1, &ok);
    if (!ok) return;

    const std::string calendarCode = calendar_.code;
    QPointer<CalendarDetailDialog> self = this;

    struct RegenerateResult {
        bool success;
        std::string message;
        std::uint64_t rows_written;
    };

    auto task = [self, calendarCode, endYear]() -> RegenerateResult {
        if (!self || !self->clientManager_) {
            return {false, "Dialog closed", 0};
        }

        refdata::messaging::regenerate_calendar_dates_request request;
        request.calendar_code = calendarCode;
        request.end_year = endYear;
        auto response_result = self->clientManager_->
            process_authenticated_request(std::move(request));

        if (!response_result) {
            return {false, "Failed to communicate with server", 0};
        }

        return {response_result->success, response_result->message,
                response_result->rows_written};
    };

    auto* watcher = new QFutureWatcher<RegenerateResult>(self);
    connect(watcher, &QFutureWatcher<RegenerateResult>::finished, self, [self, watcher]() {
        auto result = watcher->result();
        watcher->deleteLater();
        if (!self) return;

        if (result.success) {
            BOOST_LOG_SEV(lg(), info) << "Regenerated " << result.rows_written
                                      << " calendar_dates rows";
            emit self->statusMessage(
                tr("Regenerated %1 holiday row(s)").arg(result.rows_written));
        } else {
            QString errorMsg = QString::fromStdString(result.message);
            emit self->errorMessage(errorMsg);
            MessageBoxHelper::critical(self, "Regenerate Failed", errorMsg);
        }
    });

    QFuture<RegenerateResult> future = QtConcurrent::run(task);
    watcher->setFuture(future);
}