1036 lines
38 KiB
C++
1036 lines
38 KiB
C++
#include "tabs.h"
|
|
#include "data_table/data_table.h"
|
|
#include "core/data_table_types.h"
|
|
#include "core/icons_tabler.h"
|
|
#include "core/empty_state.h"
|
|
#include "core/badge.h"
|
|
|
|
#include <imgui.h>
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <ctime>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace data_factory_ui {
|
|
|
|
// data_table::State persistente por panel (issue 0081 pattern).
|
|
static data_table::State g_st_tables;
|
|
static data_table::State g_st_nodes_extractors;
|
|
static data_table::State g_st_nodes_transformers;
|
|
static data_table::State g_st_nodes_sinks;
|
|
static data_table::State g_st_databases;
|
|
static data_table::State g_st_kpis;
|
|
static data_table::State g_st_node_runs;
|
|
static data_table::State g_st_preview;
|
|
|
|
// Backing storage for cell strings (owns chars referenced by TableInput.cells).
|
|
static std::vector<std::string> g_back_extractors;
|
|
static std::vector<const char*> g_ptrs_extractors;
|
|
static std::vector<std::string> g_back_transformers;
|
|
static std::vector<const char*> g_ptrs_transformers;
|
|
static std::vector<std::string> g_back_sinks;
|
|
static std::vector<const char*> g_ptrs_sinks;
|
|
static std::vector<std::string> g_back_tables;
|
|
static std::vector<const char*> g_ptrs_tables;
|
|
static std::vector<std::string> g_back_databases;
|
|
static std::vector<const char*> g_ptrs_databases;
|
|
static std::vector<std::string> g_back_kpis;
|
|
static std::vector<const char*> g_ptrs_kpis;
|
|
static std::vector<std::string> g_back_node_runs;
|
|
static std::vector<const char*> g_ptrs_node_runs;
|
|
static std::vector<std::string> g_back_preview;
|
|
static std::vector<const char*> g_ptrs_preview;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Table preview state (populated by double-click in draw_tables).
|
|
// ---------------------------------------------------------------------------
|
|
|
|
struct PreviewSelection {
|
|
std::string database_id;
|
|
std::string table_name;
|
|
data_factory::TablePreview cache;
|
|
bool loading = false;
|
|
bool loaded = false;
|
|
std::string error;
|
|
int offset = 0;
|
|
int limit = 100;
|
|
};
|
|
|
|
static PreviewSelection& preview_state() {
|
|
static PreviewSelection s;
|
|
return s;
|
|
}
|
|
|
|
static void cells_to_ptrs(const std::vector<std::string>& backing,
|
|
std::vector<const char*>& ptrs) {
|
|
ptrs.resize(backing.size());
|
|
for (size_t i = 0; i < backing.size(); i++) ptrs[i] = backing[i].c_str();
|
|
}
|
|
|
|
// Shared BadgeRules.
|
|
static std::vector<data_table::BadgeRule> run_status_badges() {
|
|
return {
|
|
{"success", "#22c55e", "success"},
|
|
{"failed", "#ef4444", "failed"},
|
|
{"running", "#3b82f6", "running"},
|
|
{"pending", "#94a3b8", "pending"},
|
|
{"cancelled", "#6b7280", "cancelled"},
|
|
};
|
|
}
|
|
|
|
static std::vector<data_table::BadgeRule> kind_badges() {
|
|
return {
|
|
{"extractor", "#0ea5e9", "extractor"},
|
|
{"transformer", "#a855f7", "transformer"},
|
|
{"sink", "#f97316", "sink"},
|
|
{"database", "#14b8a6", "database"},
|
|
{"validator", "#eab308", "validator"},
|
|
};
|
|
}
|
|
|
|
static std::vector<data_table::BadgeRule> enabled_badges() {
|
|
return {
|
|
{"yes", "#22c55e", "yes"},
|
|
{"no", "#6b7280", "no"},
|
|
};
|
|
}
|
|
|
|
// CategoricalChip helpers (dot izquierda + texto, siempre visible).
|
|
static std::vector<data_table::ChipRule> run_status_chips() {
|
|
return {
|
|
{"success", "#22c55e"},
|
|
{"failed", "#ef4444"},
|
|
{"running", "#3b82f6"},
|
|
{"pending", "#94a3b8"},
|
|
{"cancelled", "#6b7280"},
|
|
};
|
|
}
|
|
|
|
static std::vector<data_table::ChipRule> kind_chips() {
|
|
return {
|
|
{"extractor", "#0ea5e9"},
|
|
{"transformer", "#a855f7"},
|
|
{"sink", "#f97316"},
|
|
{"database", "#14b8a6"},
|
|
{"validator", "#eab308"},
|
|
{"duckdb", "#f59e0b"},
|
|
{"sqlite", "#6366f1"},
|
|
};
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Globals
|
|
// ---------------------------------------------------------------------------
|
|
|
|
Selection& selection() {
|
|
static Selection s;
|
|
return s;
|
|
}
|
|
|
|
FunctionCache& function_cache() {
|
|
static FunctionCache fc;
|
|
return fc;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Helpers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
static std::string format_duration(long long ms) {
|
|
if (ms <= 0) return "-";
|
|
if (ms < 1000) return std::to_string(ms) + "ms";
|
|
char buf[32];
|
|
std::snprintf(buf, sizeof(buf), "%.2fs", ms / 1000.0);
|
|
return buf;
|
|
}
|
|
|
|
static std::string format_bytes(long long bytes) {
|
|
if (bytes <= 0) return "-";
|
|
const double kb = 1024.0;
|
|
const double mb = kb * 1024.0;
|
|
const double gb = mb * 1024.0;
|
|
char buf[32];
|
|
if (bytes < (long long)kb) std::snprintf(buf, sizeof(buf), "%lld B", bytes);
|
|
else if (bytes < (long long)mb) std::snprintf(buf, sizeof(buf), "%.1f KB", bytes / kb);
|
|
else if (bytes < (long long)gb) std::snprintf(buf, sizeof(buf), "%.1f MB", bytes / mb);
|
|
else std::snprintf(buf, sizeof(buf), "%.2f GB", bytes / gb);
|
|
return buf;
|
|
}
|
|
|
|
static time_t parse_rfc3339(const std::string& s) {
|
|
if (s.size() < 19) return 0;
|
|
std::tm tm{};
|
|
tm.tm_year = std::atoi(s.substr(0, 4).c_str()) - 1900;
|
|
tm.tm_mon = std::atoi(s.substr(5, 2).c_str()) - 1;
|
|
tm.tm_mday = std::atoi(s.substr(8, 2).c_str());
|
|
tm.tm_hour = std::atoi(s.substr(11, 2).c_str());
|
|
tm.tm_min = std::atoi(s.substr(14, 2).c_str());
|
|
tm.tm_sec = std::atoi(s.substr(17, 2).c_str());
|
|
tm.tm_isdst = -1;
|
|
return std::mktime(&tm);
|
|
}
|
|
|
|
// Pick most-recent run per node from runs_all.
|
|
static const data_factory::Run* last_run_for(
|
|
const std::string& node_id,
|
|
const std::vector<data_factory::Run>& runs_all)
|
|
{
|
|
const data_factory::Run* best = nullptr;
|
|
for (auto& r : runs_all) {
|
|
if (r.node_id != node_id) continue;
|
|
if (!best || r.started_at > best->started_at) best = &r;
|
|
}
|
|
return best;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Generic kind table — used by extractors / transformers / sinks
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Render the node table for a given kind via data_table::render.
|
|
// `kind_label` selects which static State/backing to use (one per kind so the
|
|
// three calls don't clobber each other's sort/filter/breadcrumb state).
|
|
static void draw_node_table(const char* /*table_id*/,
|
|
const std::vector<data_factory::Node>& nodes,
|
|
const std::string& filter_kind,
|
|
const std::vector<data_factory::Run>& runs_all,
|
|
bool show_schedule)
|
|
{
|
|
// Pick the per-kind state + backing.
|
|
data_table::State* st = &g_st_nodes_extractors;
|
|
std::vector<std::string>* backing = &g_back_extractors;
|
|
std::vector<const char*>* ptrs = &g_ptrs_extractors;
|
|
const char* dt_id = "##dt_extractors";
|
|
if (filter_kind == "transformer") {
|
|
st = &g_st_nodes_transformers;
|
|
backing = &g_back_transformers;
|
|
ptrs = &g_ptrs_transformers;
|
|
dt_id = "##dt_transformers";
|
|
} else if (filter_kind == "sink") {
|
|
st = &g_st_nodes_sinks;
|
|
backing = &g_back_sinks;
|
|
ptrs = &g_ptrs_sinks;
|
|
dt_id = "##dt_sinks";
|
|
}
|
|
|
|
// Filter nodes for the current kind, and pre-resolve their last-run.
|
|
std::vector<const data_factory::Node*> filtered;
|
|
filtered.reserve(nodes.size());
|
|
for (auto& n : nodes) if (n.kind == filter_kind) filtered.push_back(&n);
|
|
|
|
data_table::TableInput tbl;
|
|
tbl.name = filter_kind;
|
|
if (show_schedule) {
|
|
tbl.headers = {"Name", "Function", "Schedule", "Last Run", "Status", "Rows/KB", "Enabled"};
|
|
tbl.types = {
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
};
|
|
} else {
|
|
tbl.headers = {"Name", "Function", "Last Run", "Status", "Rows/KB", "Enabled"};
|
|
tbl.types = {
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
};
|
|
}
|
|
tbl.rows = static_cast<int>(filtered.size());
|
|
tbl.cols = static_cast<int>(tbl.headers.size());
|
|
|
|
tbl.column_specs.resize(tbl.cols);
|
|
for (int i = 0; i < tbl.cols; i++) tbl.column_specs[i].id = tbl.headers[i];
|
|
|
|
// Function column (Code renderer not in v1.3.x; keep Text — function_id is plain).
|
|
// Status column (CategoricalChip — dot izquierda + texto, siempre visible).
|
|
int status_col = show_schedule ? 4 : 3;
|
|
tbl.column_specs[status_col].renderer = data_table::CellRenderer::CategoricalChip;
|
|
tbl.column_specs[status_col].chips = run_status_chips();
|
|
|
|
// Enabled column (CategoricalChip yes/no).
|
|
int enabled_col = tbl.cols - 1;
|
|
tbl.column_specs[enabled_col].renderer = data_table::CellRenderer::CategoricalChip;
|
|
tbl.column_specs[enabled_col].chips = {
|
|
{"yes", "#22c55e"},
|
|
{"no", "#6b7280"},
|
|
};
|
|
|
|
backing->clear();
|
|
backing->reserve(filtered.size() * tbl.cols);
|
|
for (auto* pn : filtered) {
|
|
const data_factory::Node& n = *pn;
|
|
const data_factory::Run* lr = last_run_for(n.id, runs_all);
|
|
backing->push_back(n.name);
|
|
backing->push_back(n.function_id.empty() ? "(none)" : n.function_id);
|
|
if (show_schedule)
|
|
backing->push_back(n.schedule_cron.empty() ? "manual" : n.schedule_cron);
|
|
backing->push_back(lr ? lr->started_at : "-");
|
|
backing->push_back(lr ? lr->status : "-");
|
|
if (lr) {
|
|
char buf[64];
|
|
std::snprintf(buf, sizeof(buf), "%lld / %lld", lr->rows_out, lr->kb_out);
|
|
backing->push_back(buf);
|
|
} else {
|
|
backing->push_back("-");
|
|
}
|
|
backing->push_back(n.enabled ? "yes" : "no");
|
|
}
|
|
cells_to_ptrs(*backing, *ptrs);
|
|
tbl.cells = ptrs->data();
|
|
|
|
std::vector<data_table::TableEvent> events;
|
|
data_table::render(dt_id, {tbl}, *st, &events);
|
|
|
|
for (auto& ev : events) {
|
|
if (ev.kind == data_table::TableEventKind::RowDoubleClick &&
|
|
ev.row >= 0 && ev.row < static_cast<int>(filtered.size()))
|
|
{
|
|
const data_factory::Node& n = *filtered[ev.row];
|
|
selection().node_id = n.id;
|
|
if (function_cache().function_id != n.function_id) {
|
|
function_cache() = {};
|
|
function_cache().function_id = n.function_id;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Extractors
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_extractors(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::Node>& nodes,
|
|
const std::vector<data_factory::Run>& runs_all)
|
|
{
|
|
if (!ImGui::Begin(TI_DOWNLOAD " Extractors")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
int count = 0;
|
|
for (auto& n : nodes) if (n.kind == "extractor") count++;
|
|
if (count == 0) {
|
|
empty_state(TI_DOWNLOAD, "No extractors",
|
|
"Register an extractor node via sqlite_api.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
ImGui::TextDisabled("%d extractor nodes. Click row -> see Node Detail.", count);
|
|
draw_node_table("##df_extractors", nodes, "extractor", runs_all, true);
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Transformers
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_transformers(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::Node>& nodes,
|
|
const std::vector<data_factory::Run>& runs_all)
|
|
{
|
|
if (!ImGui::Begin(TI_REFRESH " Transformers")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
int count = 0;
|
|
for (auto& n : nodes) if (n.kind == "transformer") count++;
|
|
if (count == 0) {
|
|
empty_state(TI_REFRESH, "No transformers",
|
|
"Register a transformer node via sqlite_api.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
ImGui::TextDisabled("%d transformer nodes.", count);
|
|
draw_node_table("##df_transformers", nodes, "transformer", runs_all, false);
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Sinks
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_sinks(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::Node>& nodes,
|
|
const std::vector<data_factory::Run>& runs_all)
|
|
{
|
|
if (!ImGui::Begin(TI_UPLOAD " Sinks")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
int count = 0;
|
|
for (auto& n : nodes) if (n.kind == "sink") count++;
|
|
if (count == 0) {
|
|
empty_state(TI_UPLOAD, "No sinks",
|
|
"Register a sink node via sqlite_api.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
ImGui::TextDisabled("%d sink nodes.", count);
|
|
draw_node_table("##df_sinks", nodes, "sink", runs_all, false);
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Tables
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_tables(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::TableEntry>& tables)
|
|
{
|
|
if (!ImGui::Begin(TI_TABLE " Tables")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
if (tables.empty()) {
|
|
empty_state(TI_TABLE, "No tables found",
|
|
"Register databases in data_factory.db to see their tables here.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
// Count errors separately.
|
|
int error_count = 0;
|
|
for (auto& t : tables) if (!t.error.empty()) error_count++;
|
|
if (error_count > 0) {
|
|
ImGui::TextDisabled("%zu tables across all databases (%d error(s)).",
|
|
tables.size(), error_count);
|
|
} else {
|
|
ImGui::TextDisabled("%zu tables across all databases.", tables.size());
|
|
}
|
|
|
|
{
|
|
data_table::TableInput tbl;
|
|
tbl.name = "tables";
|
|
tbl.headers = {"Database", "Kind", "Table", "Rows"};
|
|
tbl.types = {
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::Int,
|
|
};
|
|
tbl.rows = static_cast<int>(tables.size());
|
|
tbl.cols = static_cast<int>(tbl.headers.size());
|
|
|
|
tbl.column_specs.resize(tbl.cols);
|
|
for (int i = 0; i < tbl.cols; i++) tbl.column_specs[i].id = tbl.headers[i];
|
|
|
|
// Kind column: CategoricalChip (duckdb = amber, sqlite = indigo).
|
|
tbl.column_specs[1].renderer = data_table::CellRenderer::CategoricalChip;
|
|
tbl.column_specs[1].chips = kind_chips();
|
|
|
|
// Rows column: ColorScale (0 = dim, up to 10000 = bright).
|
|
tbl.column_specs[3].renderer = data_table::CellRenderer::ColorScale;
|
|
tbl.column_specs[3].range_min = 0.0;
|
|
tbl.column_specs[3].range_max = 10000.0;
|
|
tbl.column_specs[3].range_alpha = 0.25f;
|
|
|
|
g_back_tables.clear();
|
|
g_back_tables.reserve(tables.size() * tbl.cols);
|
|
for (auto& t : tables) {
|
|
g_back_tables.push_back(t.database_label.empty() ? t.database_id : t.database_label);
|
|
g_back_tables.push_back(t.database_kind);
|
|
// Show table name; if error, show the error text in the table cell.
|
|
g_back_tables.push_back(t.error.empty() ? t.table_name
|
|
: t.table_name + " — " + t.error);
|
|
{
|
|
char buf[32];
|
|
std::snprintf(buf, sizeof(buf), "%lld", t.row_count);
|
|
g_back_tables.push_back(buf);
|
|
}
|
|
}
|
|
cells_to_ptrs(g_back_tables, g_ptrs_tables);
|
|
tbl.cells = g_ptrs_tables.data();
|
|
|
|
std::vector<data_table::TableEvent> tbl_events;
|
|
data_table::render("##dt_tables", {tbl}, g_st_tables, &tbl_events);
|
|
for (auto& ev : tbl_events) {
|
|
if (ev.kind == data_table::TableEventKind::RowDoubleClick &&
|
|
ev.row >= 0 && ev.row < static_cast<int>(tables.size()))
|
|
{
|
|
const auto& t = tables[ev.row];
|
|
auto& ps = preview_state();
|
|
// Only reset if selection changed.
|
|
if (ps.database_id != t.database_id || ps.table_name != t.table_name) {
|
|
ps.database_id = t.database_id;
|
|
ps.table_name = t.table_name;
|
|
ps.loaded = false;
|
|
ps.loading = false;
|
|
ps.error.clear();
|
|
ps.offset = 0;
|
|
ps.cache = data_factory::TablePreview{};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Databases
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_databases(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::DatabaseInfo>& dbs)
|
|
{
|
|
if (!ImGui::Begin(TI_DATABASE " Databases")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
if (dbs.empty()) {
|
|
empty_state(TI_DATABASE, "No databases registered",
|
|
"POST /api/datafactory/databases to register a DB.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
{
|
|
data_table::TableInput tbl;
|
|
tbl.name = "databases";
|
|
tbl.headers = {"Label", "Kind", "URI", "Tables", "Size", "Last Seen"};
|
|
tbl.types = {
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::Int,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
};
|
|
tbl.rows = static_cast<int>(dbs.size());
|
|
tbl.cols = static_cast<int>(tbl.headers.size());
|
|
|
|
tbl.column_specs.resize(tbl.cols);
|
|
for (int i = 0; i < tbl.cols; i++) tbl.column_specs[i].id = tbl.headers[i];
|
|
tbl.column_specs[1].renderer = data_table::CellRenderer::CategoricalChip;
|
|
tbl.column_specs[1].chips = kind_chips();
|
|
|
|
g_back_databases.clear();
|
|
g_back_databases.reserve(dbs.size() * tbl.cols);
|
|
for (auto& d : dbs) {
|
|
g_back_databases.push_back(d.label.empty() ? d.id : d.label);
|
|
g_back_databases.push_back(d.kind);
|
|
g_back_databases.push_back(d.uri);
|
|
{
|
|
char buf[32];
|
|
std::snprintf(buf, sizeof(buf), "%lld", d.table_count);
|
|
g_back_databases.push_back(buf);
|
|
}
|
|
g_back_databases.push_back(format_bytes(d.size_bytes));
|
|
g_back_databases.push_back(d.last_seen_at.empty() ? "-" : d.last_seen_at);
|
|
}
|
|
cells_to_ptrs(g_back_databases, g_ptrs_databases);
|
|
tbl.cells = g_ptrs_databases.data();
|
|
|
|
data_table::render("##dt_databases", {tbl}, g_st_databases);
|
|
}
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Health
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_health(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::Run>& runs_all)
|
|
{
|
|
if (!ImGui::Begin(TI_ACTIVITY " Health")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
if (runs_all.empty()) {
|
|
empty_state(TI_ACTIVITY, "No runs yet",
|
|
"Trigger a node to populate health metrics.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
const time_t now = std::time(nullptr);
|
|
const time_t cutoff_24h = now - 86400;
|
|
|
|
int runs_24h = 0, success_24h = 0, failed_24h = 0;
|
|
int pending_total = 0;
|
|
long long rows_24h = 0, kb_24h = 0;
|
|
int success_all = 0, failed_all = 0, cancelled_all = 0;
|
|
|
|
for (auto& r : runs_all) {
|
|
if (r.status == "running" || r.status == "pending") pending_total++;
|
|
if (r.status == "success") success_all++;
|
|
if (r.status == "failed") failed_all++;
|
|
if (r.status == "cancelled") cancelled_all++;
|
|
|
|
time_t t = parse_rfc3339(r.started_at);
|
|
if (t == 0 || t < cutoff_24h) continue;
|
|
runs_24h++;
|
|
rows_24h += r.rows_out;
|
|
kb_24h += r.kb_out;
|
|
if (r.status == "success") success_24h++;
|
|
if (r.status == "failed") failed_24h++;
|
|
}
|
|
|
|
int terminal = success_all + failed_all + cancelled_all;
|
|
float success_rate = (terminal > 0)
|
|
? (100.0f * (float)success_all / (float)terminal) : 0.0f;
|
|
|
|
{
|
|
data_table::TableInput tbl;
|
|
tbl.name = "kpis";
|
|
tbl.headers = {"KPI", "Value", "Detail"};
|
|
tbl.types = {
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
};
|
|
tbl.rows = 4;
|
|
tbl.cols = 3;
|
|
tbl.column_specs.resize(tbl.cols);
|
|
for (int i = 0; i < tbl.cols; i++) tbl.column_specs[i].id = tbl.headers[i];
|
|
|
|
g_back_kpis.clear();
|
|
g_back_kpis.reserve(tbl.rows * tbl.cols);
|
|
char buf[64];
|
|
// Runs (24h)
|
|
g_back_kpis.push_back("Runs (24h)");
|
|
std::snprintf(buf, sizeof(buf), "%d", runs_24h); g_back_kpis.push_back(buf);
|
|
std::snprintf(buf, sizeof(buf), "success: %d", success_24h); g_back_kpis.push_back(buf);
|
|
// Success rate
|
|
g_back_kpis.push_back("Success rate");
|
|
std::snprintf(buf, sizeof(buf), "%.1f%%", success_rate); g_back_kpis.push_back(buf);
|
|
std::snprintf(buf, sizeof(buf), "%d / %d terminal", success_all, terminal);
|
|
g_back_kpis.push_back(buf);
|
|
// Failed (24h)
|
|
g_back_kpis.push_back("Failed (24h)");
|
|
std::snprintf(buf, sizeof(buf), "%d", failed_24h); g_back_kpis.push_back(buf);
|
|
std::snprintf(buf, sizeof(buf), "pending: %d", pending_total); g_back_kpis.push_back(buf);
|
|
// Throughput (24h)
|
|
g_back_kpis.push_back("Throughput (24h)");
|
|
std::snprintf(buf, sizeof(buf), "%lld rows", rows_24h); g_back_kpis.push_back(buf);
|
|
std::snprintf(buf, sizeof(buf), "%lld KB", kb_24h); g_back_kpis.push_back(buf);
|
|
|
|
cells_to_ptrs(g_back_kpis, g_ptrs_kpis);
|
|
tbl.cells = g_ptrs_kpis.data();
|
|
|
|
data_table::render("##dt_kpis", {tbl}, g_st_kpis);
|
|
}
|
|
|
|
ImGui::Separator();
|
|
ImGui::TextDisabled("Computed client-side from %zu runs in cache.", runs_all.size());
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Map (placeholder: flat tree by kind)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_map(const std::string& /*api_url*/,
|
|
const std::vector<data_factory::Node>& nodes)
|
|
{
|
|
if (!ImGui::Begin(TI_LIST " Map")) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
if (nodes.empty()) {
|
|
empty_state(TI_LIST, "No nodes",
|
|
"Register nodes via sqlite_api /api/datafactory/nodes.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
// Group by kind.
|
|
std::map<std::string, std::vector<const data_factory::Node*>> by_kind;
|
|
for (auto& n : nodes) by_kind[n.kind].push_back(&n);
|
|
|
|
static const char* kind_order[] = {
|
|
"extractor", "transformer", "database", "sink", "validator"
|
|
};
|
|
static const char* kind_label[] = {
|
|
"Extractors", "Transformers", "Databases", "Sinks", "Validators"
|
|
};
|
|
const int n_kinds = sizeof(kind_order) / sizeof(kind_order[0]);
|
|
|
|
for (int i = 0; i < n_kinds; i++) {
|
|
auto it = by_kind.find(kind_order[i]);
|
|
int count = (it != by_kind.end()) ? (int)it->second.size() : 0;
|
|
char header[128];
|
|
std::snprintf(header, sizeof(header), "%s (%d)###%s_hdr",
|
|
kind_label[i], count, kind_order[i]);
|
|
if (!ImGui::TreeNodeEx(header, ImGuiTreeNodeFlags_DefaultOpen)) continue;
|
|
if (count == 0) {
|
|
ImGui::TextDisabled(" (empty)");
|
|
} else {
|
|
for (auto* p : it->second) {
|
|
ImGui::PushID(p->id.c_str());
|
|
ImGui::Bullet();
|
|
ImGui::SameLine();
|
|
bool sel = (selection().node_id == p->id);
|
|
if (ImGui::Selectable(p->name.c_str(), sel)) {
|
|
selection().node_id = p->id;
|
|
if (function_cache().function_id != p->function_id) {
|
|
function_cache() = {};
|
|
function_cache().function_id = p->function_id;
|
|
}
|
|
}
|
|
ImGui::SameLine();
|
|
if (!p->function_id.empty()) {
|
|
ImGui::TextDisabled(" -> %s", p->function_id.c_str());
|
|
}
|
|
ImGui::PopID();
|
|
}
|
|
}
|
|
ImGui::TreePop();
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Node detail panel (side)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_node_detail_panel(const std::string& api_url,
|
|
const std::vector<data_factory::Node>& nodes,
|
|
const std::vector<data_factory::Run>& runs_all,
|
|
bool* p_open)
|
|
{
|
|
if (!ImGui::Begin(TI_INFO_CIRCLE " Node Detail", p_open)) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
const std::string& nid = selection().node_id;
|
|
if (nid.empty()) {
|
|
empty_state(TI_INFO_CIRCLE, "Nothing selected",
|
|
"Click a row in any tab to inspect the node.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
const data_factory::Node* node = nullptr;
|
|
for (auto& n : nodes) if (n.id == nid) { node = &n; break; }
|
|
if (!node) {
|
|
ImGui::TextDisabled("Node not in current cache: %s", nid.c_str());
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
// Header
|
|
ImGui::Text("%s %s", TI_INFO_CIRCLE, node->name.c_str());
|
|
ImGui::SameLine();
|
|
badge(node->kind.c_str(), BadgeVariant::Info);
|
|
if (!node->enabled) {
|
|
ImGui::SameLine();
|
|
badge("disabled", BadgeVariant::Default);
|
|
}
|
|
ImGui::Separator();
|
|
|
|
if (!node->description.empty()) {
|
|
ImGui::TextWrapped("%s", node->description.c_str());
|
|
ImGui::Separator();
|
|
}
|
|
ImGui::Text("id: %s", node->id.c_str());
|
|
ImGui::Text("kind: %s", node->kind.c_str());
|
|
if (!node->function_id.empty()) {
|
|
ImGui::Text("function: %s", node->function_id.c_str());
|
|
}
|
|
if (!node->schedule_cron.empty()) {
|
|
ImGui::Text("schedule: %s", node->schedule_cron.c_str());
|
|
}
|
|
if (!node->tags.empty()) {
|
|
ImGui::Text("tags:");
|
|
for (auto& t : node->tags) {
|
|
ImGui::SameLine();
|
|
badge(t.c_str(), BadgeVariant::Default);
|
|
}
|
|
}
|
|
|
|
// Storage info: derive from most recent run with storage populated.
|
|
{
|
|
const data_factory::Run* latest_with_storage = nullptr;
|
|
for (auto& r : runs_all) {
|
|
if (r.node_id != nid) continue;
|
|
if (r.storage_db_id.empty() && r.storage_table.empty()) continue;
|
|
latest_with_storage = &r;
|
|
break;
|
|
}
|
|
if (latest_with_storage) {
|
|
ImGui::Separator();
|
|
ImGui::Text("%s Storage", TI_DATABASE);
|
|
ImGui::SameLine();
|
|
badge(latest_with_storage->storage_db_id.c_str(), BadgeVariant::Info);
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled("table:");
|
|
ImGui::SameLine();
|
|
badge(latest_with_storage->storage_table.c_str(), BadgeVariant::Default);
|
|
}
|
|
}
|
|
|
|
// Function metadata card (lazy load)
|
|
if (!node->function_id.empty()) {
|
|
ImGui::Separator();
|
|
auto& fc = function_cache();
|
|
if (fc.function_id != node->function_id) {
|
|
fc = {};
|
|
fc.function_id = node->function_id;
|
|
}
|
|
if (!fc.loaded && fc.error.empty()) {
|
|
if (data_factory::get_function_http(api_url, fc.function_id, fc.info)) {
|
|
fc.loaded = true;
|
|
} else {
|
|
fc.error = "Failed to fetch /api/functions/" + fc.function_id;
|
|
}
|
|
}
|
|
if (fc.loaded) {
|
|
ImGui::Text("%s Registry function", TI_BOX);
|
|
if (!fc.info.domain.empty()) {
|
|
ImGui::SameLine();
|
|
badge(fc.info.domain.c_str(), BadgeVariant::Info);
|
|
}
|
|
if (!fc.info.purity.empty()) {
|
|
ImGui::SameLine();
|
|
BadgeVariant v = (fc.info.purity == "pure")
|
|
? BadgeVariant::Success : BadgeVariant::Warning;
|
|
badge(fc.info.purity.c_str(), v);
|
|
}
|
|
if (!fc.info.lang.empty()) {
|
|
ImGui::SameLine();
|
|
badge(fc.info.lang.c_str(), BadgeVariant::Default);
|
|
}
|
|
if (!fc.info.signature.empty()) {
|
|
ImGui::TextWrapped("sig: %s", fc.info.signature.c_str());
|
|
}
|
|
if (!fc.info.description.empty()) {
|
|
ImGui::TextWrapped("%s", fc.info.description.c_str());
|
|
}
|
|
} else if (!fc.error.empty()) {
|
|
ImGui::TextColored(ImVec4(0.95f, 0.4f, 0.4f, 1), "%s", fc.error.c_str());
|
|
} else {
|
|
ImGui::TextDisabled("Loading function metadata...");
|
|
}
|
|
}
|
|
|
|
// Recent runs (top 10)
|
|
ImGui::Separator();
|
|
ImGui::Text("%s Recent runs", TI_HISTORY);
|
|
|
|
// Filter + cap.
|
|
std::vector<const data_factory::Run*> shown_runs;
|
|
shown_runs.reserve(10);
|
|
for (auto& r : runs_all) {
|
|
if (r.node_id != nid) continue;
|
|
shown_runs.push_back(&r);
|
|
if (shown_runs.size() >= 10) break;
|
|
}
|
|
|
|
if (shown_runs.empty()) {
|
|
ImGui::TextDisabled("(no runs for this node yet)");
|
|
} else {
|
|
data_table::TableInput tbl;
|
|
tbl.name = "node_runs";
|
|
tbl.headers = {"Started", "Status", "Duration (ms)", "Rows", "Trigger", "Storage DB", "Table"};
|
|
tbl.types = {
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::Float,
|
|
data_table::ColumnType::Int,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
data_table::ColumnType::String,
|
|
};
|
|
tbl.rows = static_cast<int>(shown_runs.size());
|
|
tbl.cols = 7;
|
|
tbl.column_specs.resize(tbl.cols);
|
|
for (int i = 0; i < tbl.cols; i++) tbl.column_specs[i].id = tbl.headers[i];
|
|
tbl.column_specs[1].renderer = data_table::CellRenderer::CategoricalChip;
|
|
tbl.column_specs[1].chips = run_status_chips();
|
|
tbl.column_specs[2].renderer = data_table::CellRenderer::ColorScale;
|
|
tbl.column_specs[2].range_min = 0.0;
|
|
tbl.column_specs[2].range_max = 5000.0;
|
|
tbl.column_specs[2].range_alpha = 0.30f;
|
|
// Default 3-stop green→amber→red usado si range_stops vacio (helper interno).
|
|
// Mantenemos Duration badges semanticos en el viejo path? — no, ColorScale tinta fondo.
|
|
tbl.column_specs[2].duration_warn_ms = 1000.0f;
|
|
tbl.column_specs[2].duration_error_ms = 5000.0f;
|
|
|
|
g_back_node_runs.clear();
|
|
g_back_node_runs.reserve(shown_runs.size() * tbl.cols);
|
|
for (auto* pr : shown_runs) {
|
|
const data_factory::Run& r = *pr;
|
|
g_back_node_runs.push_back(r.started_at);
|
|
g_back_node_runs.push_back(r.status);
|
|
{
|
|
char buf[32];
|
|
std::snprintf(buf, sizeof(buf), "%lld", r.duration_ms);
|
|
g_back_node_runs.push_back(buf);
|
|
}
|
|
{
|
|
char buf[32];
|
|
std::snprintf(buf, sizeof(buf), "%lld", r.rows_out);
|
|
g_back_node_runs.push_back(buf);
|
|
}
|
|
g_back_node_runs.push_back(r.trigger);
|
|
g_back_node_runs.push_back(r.storage_db_id);
|
|
g_back_node_runs.push_back(r.storage_table);
|
|
}
|
|
cells_to_ptrs(g_back_node_runs, g_ptrs_node_runs);
|
|
tbl.cells = g_ptrs_node_runs.data();
|
|
|
|
std::vector<data_table::TableEvent> events;
|
|
data_table::render("##dt_node_runs", {tbl}, g_st_node_runs, &events);
|
|
|
|
for (auto& ev : events) {
|
|
if (ev.kind == data_table::TableEventKind::RowDoubleClick &&
|
|
ev.row >= 0 && ev.row < static_cast<int>(shown_runs.size()))
|
|
{
|
|
selection().run_id = shown_runs[ev.row]->id;
|
|
}
|
|
}
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Table preview panel (opened by double-click in Tables tab)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void draw_table_preview_panel(const std::string& api_url, bool* p_open) {
|
|
if (!ImGui::Begin(TI_EYE " Table Preview", p_open)) {
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
auto& ps = preview_state();
|
|
|
|
if (ps.database_id.empty()) {
|
|
empty_state(TI_EYE, "No table selected",
|
|
"Double-click a row in the Tables tab to preview its data.");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
// Lazy fetch: trigger blocking HTTP fetch on the render thread.
|
|
// This is KISS — data_factory previews are used interactively; the one-off
|
|
// blocking call completes in <200ms over loopback.
|
|
if (!ps.loaded && !ps.loading && ps.error.empty()) {
|
|
ps.loading = true;
|
|
bool ok = data_factory::get_table_preview_http(
|
|
api_url, ps.database_id, ps.table_name, ps.limit, ps.offset, ps.cache);
|
|
ps.loading = false;
|
|
if (ok) {
|
|
ps.loaded = true;
|
|
} else {
|
|
ps.error = "Failed to fetch preview for " + ps.database_id + "." + ps.table_name;
|
|
}
|
|
}
|
|
|
|
// Header: "database_id . table_name (total_rows rows)"
|
|
{
|
|
char hdr[256];
|
|
long long total = ps.loaded ? ps.cache.total_rows : 0;
|
|
std::snprintf(hdr, sizeof(hdr), "%s %s (%lld rows)",
|
|
ps.database_id.c_str(), ps.table_name.c_str(), total);
|
|
ImGui::Text("%s %s", TI_TABLE, hdr);
|
|
}
|
|
ImGui::Separator();
|
|
|
|
if (!ps.loaded && ps.error.empty()) {
|
|
ImGui::TextDisabled("Loading...");
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
if (!ps.error.empty()) {
|
|
ImGui::TextColored(ImVec4(0.95f, 0.4f, 0.4f, 1), "%s", ps.error.c_str());
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
// Schema summary.
|
|
if (!ps.cache.columns.empty()) {
|
|
std::string schema_line;
|
|
for (size_t i = 0; i < ps.cache.columns.size(); i++) {
|
|
if (i > 0) schema_line += " | ";
|
|
schema_line += ps.cache.columns[i].first + " (" + ps.cache.columns[i].second + ")";
|
|
}
|
|
ImGui::TextDisabled("%s", schema_line.c_str());
|
|
ImGui::Separator();
|
|
}
|
|
|
|
// Data table via data_table::render.
|
|
if (!ps.cache.columns.empty()) {
|
|
int ncols = static_cast<int>(ps.cache.columns.size());
|
|
int nrows = static_cast<int>(ps.cache.rows.size());
|
|
|
|
data_table::TableInput tbl;
|
|
tbl.name = "preview";
|
|
tbl.headers.reserve(ncols);
|
|
tbl.types.reserve(ncols);
|
|
tbl.column_specs.resize(ncols);
|
|
for (int i = 0; i < ncols; i++) {
|
|
tbl.headers.push_back(ps.cache.columns[i].first);
|
|
tbl.types.push_back(data_table::ColumnType::String);
|
|
tbl.column_specs[i].id = ps.cache.columns[i].first;
|
|
}
|
|
tbl.rows = nrows;
|
|
tbl.cols = ncols;
|
|
|
|
// Build flat backing array row-major.
|
|
g_back_preview.clear();
|
|
g_back_preview.reserve(static_cast<size_t>(nrows) * ncols);
|
|
for (auto& row : ps.cache.rows) {
|
|
for (int c = 0; c < ncols; c++) {
|
|
g_back_preview.push_back(c < static_cast<int>(row.size()) ? row[c] : "");
|
|
}
|
|
}
|
|
cells_to_ptrs(g_back_preview, g_ptrs_preview);
|
|
tbl.cells = g_ptrs_preview.data();
|
|
|
|
data_table::render("##dt_preview", {tbl}, g_st_preview, nullptr, true);
|
|
}
|
|
|
|
// Pagination controls.
|
|
ImGui::Separator();
|
|
{
|
|
long long showing_from = ps.cache.offset + 1;
|
|
long long showing_to = ps.cache.offset + static_cast<long long>(ps.cache.rows.size());
|
|
long long total = ps.cache.total_rows;
|
|
if (ps.cache.rows.empty()) showing_from = 0;
|
|
char info[128];
|
|
std::snprintf(info, sizeof(info), "showing %lld-%lld of %lld",
|
|
showing_from, showing_to, total);
|
|
ImGui::TextDisabled("%s", info);
|
|
ImGui::SameLine();
|
|
|
|
bool can_prev = (ps.offset > 0);
|
|
bool can_next = (ps.offset + ps.limit < static_cast<int>(ps.cache.total_rows));
|
|
|
|
if (!can_prev) ImGui::BeginDisabled();
|
|
if (ImGui::SmallButton("< Prev")) {
|
|
ps.offset = std::max(0, ps.offset - ps.limit);
|
|
ps.loaded = false;
|
|
ps.error.clear();
|
|
ps.cache = data_factory::TablePreview{};
|
|
}
|
|
if (!can_prev) ImGui::EndDisabled();
|
|
|
|
ImGui::SameLine();
|
|
|
|
if (!can_next) ImGui::BeginDisabled();
|
|
if (ImGui::SmallButton("Next >")) {
|
|
ps.offset += ps.limit;
|
|
ps.loaded = false;
|
|
ps.error.clear();
|
|
ps.cache = data_factory::TablePreview{};
|
|
}
|
|
if (!can_next) ImGui::EndDisabled();
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
|
|
} // namespace data_factory_ui
|