1375 lines
52 KiB
Rust
1375 lines
52 KiB
Rust
//! Terminal UI module for Baobab Actor
|
|
//!
|
|
//! This module contains all the TUI logic, structures, and rendering functions
|
|
//! for the actor monitoring and job dispatch interface.
|
|
|
|
use anyhow::Result;
|
|
use crossterm::{
|
|
event::{self, Event, KeyCode, KeyEventKind},
|
|
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
|
|
execute,
|
|
};
|
|
use hero_job::{Job, JobStatus, ScriptType};
|
|
use log::error;
|
|
use ratatui::{
|
|
backend::{Backend, CrosstermBackend},
|
|
layout::{Alignment, Constraint, Direction, Layout, Rect},
|
|
style::{Color, Modifier, Style},
|
|
text::{Line, Span},
|
|
widgets::{Block, Borders, List, ListItem, ListState, Paragraph, Tabs, Wrap},
|
|
Frame, Terminal,
|
|
};
|
|
use redis::AsyncCommands;
|
|
use std::fs;
|
|
use std::io;
|
|
use std::path::PathBuf;
|
|
use std::time::{Duration, Instant};
|
|
use uuid::Uuid;
|
|
|
|
// Public exports for the cmd binary
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub enum AppState {
|
|
Main,
|
|
JobCreation,
|
|
JobDetails,
|
|
ExampleSelection,
|
|
Confirmation,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub enum TabState {
|
|
Dashboard,
|
|
Jobs,
|
|
NewJob,
|
|
Examples,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub enum JobFormField {
|
|
CallerId,
|
|
ContextId,
|
|
Timeout,
|
|
ScriptContent,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct JobCreationForm {
|
|
pub caller_id: String,
|
|
pub context_id: String,
|
|
pub timeout: String,
|
|
pub script_content: String,
|
|
pub script_type: ScriptType,
|
|
pub current_field: JobFormField,
|
|
}
|
|
|
|
impl Default for JobCreationForm {
|
|
fn default() -> Self {
|
|
Self {
|
|
caller_id: String::new(),
|
|
context_id: String::new(),
|
|
timeout: "300".to_string(),
|
|
script_content: String::new(),
|
|
script_type: ScriptType::OSIS,
|
|
current_field: JobFormField::CallerId,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ExampleScript {
|
|
pub name: String,
|
|
pub path: PathBuf,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum ExampleTreeNode {
|
|
File {
|
|
name: String,
|
|
path: PathBuf,
|
|
},
|
|
Folder {
|
|
name: String,
|
|
path: PathBuf,
|
|
children: Vec<ExampleTreeNode>,
|
|
expanded: bool,
|
|
},
|
|
}
|
|
|
|
impl ExampleTreeNode {
|
|
pub fn name(&self) -> &str {
|
|
match self {
|
|
ExampleTreeNode::File { name, .. } => name,
|
|
ExampleTreeNode::Folder { name, .. } => name,
|
|
}
|
|
}
|
|
|
|
pub fn path(&self) -> &PathBuf {
|
|
match self {
|
|
ExampleTreeNode::File { path, .. } => path,
|
|
ExampleTreeNode::Folder { path, .. } => path,
|
|
}
|
|
}
|
|
|
|
pub fn is_file(&self) -> bool {
|
|
matches!(self, ExampleTreeNode::File { .. })
|
|
}
|
|
|
|
pub fn is_folder(&self) -> bool {
|
|
matches!(self, ExampleTreeNode::Folder { .. })
|
|
}
|
|
|
|
pub fn is_expanded(&self) -> bool {
|
|
match self {
|
|
ExampleTreeNode::File { .. } => false,
|
|
ExampleTreeNode::Folder { expanded, .. } => *expanded,
|
|
}
|
|
}
|
|
|
|
pub fn toggle_expanded(&mut self) {
|
|
if let ExampleTreeNode::Folder { expanded, .. } = self {
|
|
*expanded = !*expanded;
|
|
}
|
|
}
|
|
|
|
pub fn set_expanded(&mut self, expand: bool) {
|
|
if let ExampleTreeNode::Folder { expanded, .. } = self {
|
|
*expanded = expand;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ExampleTreeItem {
|
|
pub node: ExampleTreeNode,
|
|
pub depth: usize,
|
|
pub index: usize,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct JobInfo {
|
|
pub job: Job,
|
|
pub status: JobStatus,
|
|
pub output: Option<String>,
|
|
pub error: Option<String>,
|
|
pub created_at: Instant,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct App {
|
|
pub actor_id: String,
|
|
pub actor_path: PathBuf,
|
|
pub redis_client: redis::Client,
|
|
pub current_tab: TabState,
|
|
pub app_state: AppState,
|
|
pub should_quit: bool,
|
|
pub jobs: Vec<JobInfo>,
|
|
pub job_list_state: ListState,
|
|
pub job_form: JobCreationForm,
|
|
pub examples: Vec<ExampleScript>,
|
|
pub example_list_state: ListState,
|
|
pub selected_example: Option<ExampleScript>,
|
|
pub status_message: Option<String>,
|
|
pub last_executed_job: Option<JobInfo>,
|
|
pub last_refresh: Instant,
|
|
// New hierarchical examples system
|
|
pub example_tree: Vec<ExampleTreeNode>,
|
|
pub example_tree_items: Vec<ExampleTreeItem>,
|
|
pub example_tree_state: ListState,
|
|
pub selected_tree_item: Option<ExampleTreeItem>,
|
|
}
|
|
|
|
pub struct ActorTui;
|
|
|
|
impl ActorTui {
|
|
pub fn new() -> Self {
|
|
Self
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
pub fn new(actor_id: String, actor_path: PathBuf, redis_url: String, example_dir: Option<PathBuf>) -> Result<Self> {
|
|
let redis_client = redis::Client::open(redis_url)?;
|
|
|
|
let mut app = Self {
|
|
actor_id,
|
|
actor_path,
|
|
redis_client,
|
|
current_tab: TabState::Dashboard,
|
|
app_state: AppState::Main,
|
|
should_quit: false,
|
|
jobs: Vec::new(),
|
|
job_list_state: ListState::default(),
|
|
job_form: JobCreationForm::default(),
|
|
examples: Vec::new(),
|
|
example_list_state: ListState::default(),
|
|
selected_example: None,
|
|
status_message: None,
|
|
last_executed_job: None,
|
|
last_refresh: Instant::now(),
|
|
// Initialize new hierarchical examples system
|
|
example_tree: Vec::new(),
|
|
example_tree_items: Vec::new(),
|
|
example_tree_state: ListState::default(),
|
|
selected_tree_item: None,
|
|
};
|
|
|
|
if let Some(dir) = example_dir {
|
|
if let Err(e) = app.load_examples_tree(dir) {
|
|
error!("Failed to load examples tree: {}", e);
|
|
}
|
|
}
|
|
|
|
Ok(app)
|
|
}
|
|
|
|
pub fn load_examples_tree(&mut self, dir: PathBuf) -> Result<()> {
|
|
if !dir.exists() {
|
|
return Ok(());
|
|
}
|
|
|
|
// Load hierarchical tree structure
|
|
self.example_tree = self.load_example_tree(&dir)?;
|
|
self.rebuild_tree_items();
|
|
|
|
if !self.example_tree_items.is_empty() {
|
|
self.example_tree_state.select(Some(0));
|
|
self.selected_tree_item = Some(self.example_tree_items[0].clone());
|
|
|
|
// Update selected_example for backward compatibility
|
|
if let Some(first_file) = self.find_first_file_in_tree() {
|
|
self.selected_example = Some(ExampleScript {
|
|
name: first_file.name().to_string(),
|
|
path: first_file.path().clone(),
|
|
});
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn load_example_tree(&self, dir: &PathBuf) -> Result<Vec<ExampleTreeNode>> {
|
|
let mut nodes = Vec::new();
|
|
|
|
let mut entries: Vec<_> = fs::read_dir(dir)?
|
|
.collect::<Result<Vec<_>, _>>()?;
|
|
|
|
// Sort entries: directories first, then files, both alphabetically
|
|
entries.sort_by(|a, b| {
|
|
let a_is_dir = a.path().is_dir();
|
|
let b_is_dir = b.path().is_dir();
|
|
|
|
match (a_is_dir, b_is_dir) {
|
|
(true, false) => std::cmp::Ordering::Less,
|
|
(false, true) => std::cmp::Ordering::Greater,
|
|
_ => a.file_name().cmp(&b.file_name()),
|
|
}
|
|
});
|
|
|
|
for entry in entries {
|
|
let path = entry.path();
|
|
let name = entry.file_name().to_string_lossy().to_string();
|
|
|
|
if path.is_dir() {
|
|
let children = self.load_example_tree(&path)?;
|
|
nodes.push(ExampleTreeNode::Folder {
|
|
name,
|
|
path,
|
|
children,
|
|
expanded: false, // Folders collapsed by default
|
|
});
|
|
} else if path.extension().map_or(false, |ext| ext == "rhai") {
|
|
nodes.push(ExampleTreeNode::File {
|
|
name: path.file_stem()
|
|
.and_then(|s| s.to_str())
|
|
.unwrap_or(&name)
|
|
.to_string(),
|
|
path,
|
|
});
|
|
}
|
|
}
|
|
|
|
Ok(nodes)
|
|
}
|
|
|
|
fn load_flat_examples(&mut self, dir: &PathBuf) -> Result<()> {
|
|
let mut examples = Vec::new();
|
|
self.collect_all_rhai_files(&mut examples, dir)?;
|
|
self.examples = examples;
|
|
|
|
if !self.examples.is_empty() {
|
|
self.example_list_state.select(Some(0));
|
|
if self.selected_example.is_none() {
|
|
self.selected_example = Some(self.examples[0].clone());
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn collect_all_rhai_files(&self, examples: &mut Vec<ExampleScript>, dir: &PathBuf) -> Result<()> {
|
|
for entry in fs::read_dir(dir)? {
|
|
let entry = entry?;
|
|
let path = entry.path();
|
|
|
|
if path.is_dir() {
|
|
self.collect_all_rhai_files(examples, &path)?;
|
|
} else if path.extension().map_or(false, |ext| ext == "rhai") {
|
|
if let Some(name) = path.file_stem().and_then(|s| s.to_str()) {
|
|
examples.push(ExampleScript {
|
|
name: name.to_string(),
|
|
path,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn rebuild_tree_items(&mut self) {
|
|
self.example_tree_items.clear();
|
|
let mut index = 0;
|
|
let tree_clone = self.example_tree.clone();
|
|
for node in &tree_clone {
|
|
self.add_tree_items_recursive(node, 0, &mut index);
|
|
}
|
|
}
|
|
|
|
fn add_tree_items_recursive(&mut self, node: &ExampleTreeNode, depth: usize, index: &mut usize) {
|
|
// Always add the current node to the flattened list
|
|
self.example_tree_items.push(ExampleTreeItem {
|
|
node: node.clone(),
|
|
depth,
|
|
index: *index,
|
|
});
|
|
*index += 1;
|
|
|
|
// For folders, add children only if the folder is expanded
|
|
if let ExampleTreeNode::Folder { children, expanded, .. } = node {
|
|
if *expanded {
|
|
for child in children {
|
|
self.add_tree_items_recursive(child, depth + 1, index);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn find_first_file_in_tree(&self) -> Option<&ExampleTreeNode> {
|
|
for item in &self.example_tree_items {
|
|
if item.node.is_file() {
|
|
return Some(&item.node);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub async fn refresh_jobs(&mut self) -> Result<()> {
|
|
let mut conn = self.redis_client.get_multiplexed_async_connection().await?;
|
|
|
|
// Get all job keys for this actor
|
|
let pattern = format!("hero:job:*");
|
|
let keys: Vec<String> = conn.keys(pattern).await?;
|
|
|
|
self.jobs.clear();
|
|
|
|
for key in keys {
|
|
if let Ok(job_data) = conn.hgetall::<String, std::collections::HashMap<String, String>>(key).await {
|
|
// Filter jobs by script_type field (e.g., "OSIS" for OSIS actor)
|
|
if let Some(script_type) = job_data.get("script_type") {
|
|
if script_type.to_uppercase() == self.actor_id.to_uppercase() {
|
|
if let Ok(job) = self.parse_job_from_redis(&job_data) {
|
|
let status = match job_data.get("status").map(|s| s.as_str()).unwrap_or("dispatched") {
|
|
"started" => JobStatus::Started,
|
|
"finished" => JobStatus::Finished,
|
|
"error" => JobStatus::Error,
|
|
"waiting_for_prerequisites" => JobStatus::WaitingForPrerequisites,
|
|
_ => JobStatus::Dispatched,
|
|
};
|
|
let output = job_data.get("output").cloned();
|
|
let error = job_data.get("error").cloned();
|
|
let job_info = JobInfo {
|
|
job,
|
|
status,
|
|
output,
|
|
error,
|
|
created_at: Instant::now(),
|
|
};
|
|
self.jobs.push(job_info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort jobs by creation time (newest first)
|
|
self.jobs.sort_by(|a, b| b.created_at.cmp(&a.created_at));
|
|
self.last_refresh = Instant::now();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_job_from_redis(&self, data: &std::collections::HashMap<String, String>) -> Result<Job> {
|
|
let id = data.get("jobId").unwrap_or(&String::new()).clone();
|
|
let caller_id = data.get("callerId").unwrap_or(&String::new()).clone();
|
|
let context_id = data.get("contextId").unwrap_or(&String::new()).clone();
|
|
let script = data.get("script").unwrap_or(&String::new()).clone();
|
|
let timeout_secs = data.get("timeout").unwrap_or(&"300".to_string()).parse().unwrap_or(300u64);
|
|
let timeout = Duration::from_secs(timeout_secs);
|
|
let retries = data.get("retries").map_or(0u8, |v| v.parse().unwrap_or(0));
|
|
|
|
let _status = match data.get("status").map(|s| s.as_str()).unwrap_or("Dispatched") {
|
|
"Dispatched" => JobStatus::Dispatched,
|
|
"WaitingForPrerequisites" => JobStatus::WaitingForPrerequisites,
|
|
"Started" => JobStatus::Started,
|
|
"Error" => JobStatus::Error,
|
|
"Finished" => JobStatus::Finished,
|
|
_ => JobStatus::Dispatched,
|
|
};
|
|
|
|
let _output = data.get("output").cloned();
|
|
let _error = data.get("error").cloned();
|
|
|
|
let script_type = match data.get("script_type").map(|s| s.as_str()).unwrap_or("OSIS") {
|
|
"OSIS" => ScriptType::OSIS,
|
|
"SAL" => ScriptType::SAL,
|
|
"V" => ScriptType::V,
|
|
"Python" => ScriptType::Python,
|
|
_ => ScriptType::OSIS,
|
|
};
|
|
|
|
let job = Job {
|
|
id,
|
|
caller_id,
|
|
context_id,
|
|
script,
|
|
script_type,
|
|
timeout,
|
|
retries,
|
|
concurrent: false,
|
|
log_path: None,
|
|
env_vars: std::collections::HashMap::new(),
|
|
prerequisites: Vec::new(),
|
|
dependents: Vec::new(),
|
|
created_at: chrono::Utc::now(),
|
|
updated_at: chrono::Utc::now(),
|
|
};
|
|
|
|
Ok(job)
|
|
}
|
|
|
|
pub async fn create_and_dispatch_job(&mut self) -> Result<()> {
|
|
let job_id = Uuid::new_v4().to_string();
|
|
|
|
let timeout_secs: u64 = self.job_form.timeout.parse().unwrap_or(300);
|
|
|
|
let job = Job {
|
|
id: job_id.clone(),
|
|
caller_id: self.job_form.caller_id.clone(),
|
|
context_id: self.job_form.context_id.clone(),
|
|
script: self.job_form.script_content.clone(),
|
|
script_type: self.job_form.script_type.clone(),
|
|
timeout: Duration::from_secs(timeout_secs),
|
|
retries: 0,
|
|
concurrent: false,
|
|
log_path: None,
|
|
env_vars: std::collections::HashMap::new(),
|
|
prerequisites: Vec::new(),
|
|
dependents: Vec::new(),
|
|
created_at: chrono::Utc::now(),
|
|
updated_at: chrono::Utc::now(),
|
|
};
|
|
|
|
// Store job info for tracking
|
|
let job_info = JobInfo {
|
|
job: job.clone(),
|
|
status: JobStatus::Dispatched,
|
|
output: None,
|
|
error: None,
|
|
created_at: Instant::now(),
|
|
};
|
|
self.last_executed_job = Some(job_info);
|
|
|
|
// Store job in Redis using the proper Job::store_in_redis method
|
|
let mut conn = self.redis_client.get_multiplexed_async_connection().await?;
|
|
job.store_in_redis(&mut conn).await?;
|
|
|
|
// Add to work queue
|
|
let queue_name = format!("hero:job:actor_queue:{}", self.actor_id.to_lowercase());
|
|
let _: () = conn.lpush(&queue_name, &job_id).await?;
|
|
|
|
self.status_message = Some(format!("Job {} dispatched successfully", job_id));
|
|
|
|
// Refresh jobs to show the new job
|
|
self.refresh_jobs().await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn dispatch_example(&mut self, example: &ExampleScript) -> Result<()> {
|
|
let script_content = fs::read_to_string(&example.path)?;
|
|
self.job_form.script_content = script_content;
|
|
self.create_and_dispatch_job().await
|
|
}
|
|
|
|
pub fn load_example_to_new_job(&mut self, example: &ExampleScript) -> Result<()> {
|
|
let script_content = fs::read_to_string(&example.path)?;
|
|
self.job_form.script_content = script_content;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn handle_char_input(&mut self, c: char) {
|
|
match self.job_form.current_field {
|
|
JobFormField::CallerId => {
|
|
self.job_form.caller_id.push(c);
|
|
}
|
|
JobFormField::ContextId => {
|
|
self.job_form.context_id.push(c);
|
|
}
|
|
JobFormField::Timeout => {
|
|
if c.is_ascii_digit() {
|
|
self.job_form.timeout.push(c);
|
|
}
|
|
}
|
|
JobFormField::ScriptContent => {
|
|
self.job_form.script_content.push(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn handle_backspace(&mut self) {
|
|
match self.job_form.current_field {
|
|
JobFormField::CallerId => {
|
|
self.job_form.caller_id.pop();
|
|
}
|
|
JobFormField::ContextId => {
|
|
self.job_form.context_id.pop();
|
|
}
|
|
JobFormField::Timeout => {
|
|
self.job_form.timeout.pop();
|
|
}
|
|
JobFormField::ScriptContent => {
|
|
self.job_form.script_content.pop();
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn next_job(&mut self) {
|
|
if self.jobs.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let selected = match self.job_list_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.jobs.len() - 1 {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.job_list_state.select(Some(selected));
|
|
}
|
|
|
|
pub fn previous_job(&mut self) {
|
|
if self.jobs.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let selected = match self.job_list_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.jobs.len() - 1
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.job_list_state.select(Some(selected));
|
|
}
|
|
|
|
pub fn next_example(&mut self) {
|
|
if self.example_tree_items.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let i = match self.example_tree_state.selected() {
|
|
Some(i) => {
|
|
if i >= self.example_tree_items.len() - 1 {
|
|
0
|
|
} else {
|
|
i + 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.example_tree_state.select(Some(i));
|
|
self.selected_tree_item = Some(self.example_tree_items[i].clone());
|
|
|
|
// Update selected_example for backward compatibility
|
|
if self.example_tree_items[i].node.is_file() {
|
|
self.selected_example = Some(ExampleScript {
|
|
name: self.example_tree_items[i].node.name().to_string(),
|
|
path: self.example_tree_items[i].node.path().clone(),
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn previous_example(&mut self) {
|
|
if self.example_tree_items.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let i = match self.example_tree_state.selected() {
|
|
Some(i) => {
|
|
if i == 0 {
|
|
self.example_tree_items.len() - 1
|
|
} else {
|
|
i - 1
|
|
}
|
|
}
|
|
None => 0,
|
|
};
|
|
self.example_tree_state.select(Some(i));
|
|
self.selected_tree_item = Some(self.example_tree_items[i].clone());
|
|
|
|
// Update selected_example for backward compatibility
|
|
if self.example_tree_items[i].node.is_file() {
|
|
self.selected_example = Some(ExampleScript {
|
|
name: self.example_tree_items[i].node.name().to_string(),
|
|
path: self.example_tree_items[i].node.path().clone(),
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn expand_selected_folder(&mut self) {
|
|
if let Some(selected_index) = self.example_tree_state.selected() {
|
|
if selected_index < self.example_tree_items.len() {
|
|
let item = &self.example_tree_items[selected_index];
|
|
if item.node.is_folder() {
|
|
let path = item.node.path().clone();
|
|
self.expand_folder_by_path(&path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn collapse_selected_folder(&mut self) {
|
|
if let Some(selected_index) = self.example_tree_state.selected() {
|
|
if selected_index < self.example_tree_items.len() {
|
|
let item = &self.example_tree_items[selected_index];
|
|
if item.node.is_folder() {
|
|
let path = item.node.path().clone();
|
|
self.collapse_folder_by_path(&path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn toggle_selected_folder(&mut self) {
|
|
if let Some(selected_index) = self.example_tree_state.selected() {
|
|
if selected_index < self.example_tree_items.len() {
|
|
let item = &self.example_tree_items[selected_index];
|
|
if item.node.is_folder() {
|
|
let path = item.node.path().clone();
|
|
let is_expanded = item.node.is_expanded();
|
|
if is_expanded {
|
|
self.collapse_folder_by_path(&path);
|
|
} else {
|
|
self.expand_folder_by_path(&path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn expand_folder_by_path(&mut self, target_path: &PathBuf) {
|
|
Self::set_folder_expanded_by_path_static(&mut self.example_tree, target_path, true);
|
|
self.rebuild_tree_items();
|
|
}
|
|
|
|
fn collapse_folder_by_path(&mut self, target_path: &PathBuf) {
|
|
Self::set_folder_expanded_by_path_static(&mut self.example_tree, target_path, false);
|
|
self.rebuild_tree_items();
|
|
}
|
|
|
|
fn set_folder_expanded_by_path_static(nodes: &mut Vec<ExampleTreeNode>, target_path: &PathBuf, expanded: bool) {
|
|
for node in nodes {
|
|
match node {
|
|
ExampleTreeNode::Folder { path, children, expanded: node_expanded, .. } => {
|
|
if path == target_path {
|
|
*node_expanded = expanded;
|
|
return;
|
|
}
|
|
Self::set_folder_expanded_by_path_static(children, target_path, expanded);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
pub fn next_field(&mut self) {
|
|
self.job_form.current_field = match self.job_form.current_field {
|
|
JobFormField::CallerId => JobFormField::ContextId,
|
|
JobFormField::ContextId => JobFormField::Timeout,
|
|
JobFormField::Timeout => JobFormField::ScriptContent,
|
|
JobFormField::ScriptContent => JobFormField::CallerId,
|
|
};
|
|
}
|
|
|
|
pub fn previous_field(&mut self) {
|
|
self.job_form.current_field = match self.job_form.current_field {
|
|
JobFormField::CallerId => JobFormField::ScriptContent,
|
|
JobFormField::ContextId => JobFormField::CallerId,
|
|
JobFormField::Timeout => JobFormField::ContextId,
|
|
JobFormField::ScriptContent => JobFormField::Timeout,
|
|
};
|
|
}
|
|
}
|
|
|
|
/// Setup terminal and run the TUI application
|
|
pub async fn setup_and_run_tui(mut app: App) -> Result<()> {
|
|
// Initial job refresh
|
|
if let Err(e) = app.refresh_jobs().await {
|
|
error!("Failed to refresh jobs: {}", e);
|
|
}
|
|
|
|
// Setup terminal
|
|
enable_raw_mode()?;
|
|
let mut stdout = io::stdout();
|
|
execute!(stdout, EnterAlternateScreen)?;
|
|
let backend = CrosstermBackend::new(stdout);
|
|
let mut terminal = Terminal::new(backend)?;
|
|
|
|
// Run the app
|
|
let res = run_app(&mut terminal, app).await;
|
|
|
|
// Restore terminal
|
|
disable_raw_mode()?;
|
|
execute!(
|
|
terminal.backend_mut(),
|
|
LeaveAlternateScreen,
|
|
)?;
|
|
terminal.show_cursor()?;
|
|
|
|
if let Err(err) = res {
|
|
println!("{:?}", err);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn ui(f: &mut Frame, app: &mut App) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([Constraint::Length(3), Constraint::Min(0), Constraint::Length(3)])
|
|
.split(f.area());
|
|
|
|
// Title
|
|
let title = Paragraph::new(format!("Baobab Actor UI - Actor: {}", app.actor_id))
|
|
.style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
|
|
.alignment(Alignment::Center)
|
|
.block(Block::default().borders(Borders::ALL));
|
|
f.render_widget(title, chunks[0]);
|
|
|
|
// Main content area
|
|
match app.app_state {
|
|
AppState::Main => render_main_view(f, app, chunks[1]),
|
|
AppState::JobCreation => render_job_creation(f, app, chunks[1]),
|
|
_ => render_main_view(f, app, chunks[1]),
|
|
}
|
|
|
|
// Status bar
|
|
let status_text = if let Some(ref msg) = app.status_message {
|
|
msg.clone()
|
|
} else {
|
|
format!("Jobs: {} | Press Esc to quit, [ ] to switch tabs, Tab for fields, 'r' to refresh | Last refresh: {:.1}s ago",
|
|
app.jobs.len(), app.last_refresh.elapsed().as_secs_f32())
|
|
};
|
|
|
|
let status = Paragraph::new(status_text)
|
|
.style(Style::default().fg(Color::White))
|
|
.alignment(Alignment::Left)
|
|
.block(Block::default().borders(Borders::ALL));
|
|
f.render_widget(status, chunks[2]);
|
|
}
|
|
|
|
fn render_main_view(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([Constraint::Length(3), Constraint::Min(0)])
|
|
.split(area);
|
|
|
|
// Tabs
|
|
let tab_titles: Vec<Line> = vec!["Dashboard", "Jobs", "New Job", "Examples"]
|
|
.iter()
|
|
.cloned()
|
|
.map(Line::from)
|
|
.collect();
|
|
|
|
let selected_tab = match app.current_tab {
|
|
TabState::Dashboard => 0,
|
|
TabState::Jobs => 1,
|
|
TabState::NewJob => 2,
|
|
TabState::Examples => 3,
|
|
};
|
|
|
|
let tabs = Tabs::new(tab_titles)
|
|
.block(Block::default().borders(Borders::ALL).title("Tabs (Use [ ] to navigate, Tab for fields, q to quit)"))
|
|
.style(Style::default().fg(Color::White))
|
|
.highlight_style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD))
|
|
.select(selected_tab);
|
|
f.render_widget(tabs, chunks[0]);
|
|
|
|
// Tab content
|
|
match app.current_tab {
|
|
TabState::Dashboard => render_dashboard(f, app, chunks[1]),
|
|
TabState::Jobs => render_jobs(f, app, chunks[1]),
|
|
TabState::NewJob => render_new_job(f, app, chunks[1]),
|
|
TabState::Examples => render_examples(f, app, chunks[1]),
|
|
}
|
|
}
|
|
|
|
fn render_dashboard(f: &mut Frame, app: &App, area: Rect) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
|
|
.split(area);
|
|
|
|
// Actor info
|
|
let actor_info = vec![
|
|
Line::from(vec![Span::raw(format!("Actor ID: {}", app.actor_id))]),
|
|
Line::from(vec![Span::raw(format!("Actor Path: {}", app.actor_path.display()))]),
|
|
Line::from(vec![Span::raw(format!("Total Jobs: {}", app.jobs.len()))]),
|
|
Line::from(vec![Span::raw(format!("Examples Loaded: {}", app.examples.len()))]),
|
|
];
|
|
|
|
let actor_block = Paragraph::new(actor_info)
|
|
.block(Block::default().borders(Borders::ALL).title("Actor Information"))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(actor_block, chunks[0]);
|
|
|
|
// Job status summary
|
|
let dispatched = app.jobs.len(); // Placeholder - all jobs shown as dispatched
|
|
|
|
let job_status = vec![
|
|
Line::from(vec![Span::raw(format!("Dispatched: {}", dispatched))]),
|
|
Line::from(vec![Span::raw("Waiting: 0")]),
|
|
Line::from(vec![Span::raw("Started: 0")]),
|
|
Line::from(vec![Span::raw("Finished: 0")]),
|
|
Line::from(vec![Span::raw("Error: 0")]),
|
|
];
|
|
|
|
let status_block = Paragraph::new(job_status)
|
|
.block(Block::default().borders(Borders::ALL).title("Job Status Summary"))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(status_block, chunks[1]);
|
|
}
|
|
|
|
fn render_jobs(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let main_chunks = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([Constraint::Percentage(60), Constraint::Percentage(40)])
|
|
.split(area);
|
|
|
|
// Job list (left side)
|
|
let jobs: Vec<ListItem> = app.jobs
|
|
.iter()
|
|
.map(|job_info| {
|
|
// Safely truncate job ID to avoid out-of-bounds panic
|
|
let job_id_display = if job_info.job.id.len() >= 8 {
|
|
&job_info.job.id[..8]
|
|
} else {
|
|
&job_info.job.id
|
|
};
|
|
|
|
let content = vec![
|
|
Line::from(vec![
|
|
Span::styled(format!("[{}] ", job_id_display), Style::default().fg(Color::Yellow)),
|
|
Span::raw(format!("Caller: {} | Context: {}", job_info.job.caller_id, job_info.job.context_id)),
|
|
]),
|
|
];
|
|
ListItem::new(content)
|
|
})
|
|
.collect();
|
|
|
|
let jobs_list = List::new(jobs)
|
|
.block(Block::default().borders(Borders::ALL).title("Jobs"))
|
|
.highlight_style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD))
|
|
.highlight_symbol("> ");
|
|
|
|
f.render_stateful_widget(jobs_list, main_chunks[0], &mut app.job_list_state);
|
|
|
|
// Right side: split into job details (top) and results (bottom)
|
|
let right_chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([Constraint::Percentage(70), Constraint::Percentage(30)])
|
|
.split(main_chunks[1]);
|
|
|
|
// Job details (top right)
|
|
if let Some(selected) = app.job_list_state.selected() {
|
|
if let Some(job_info) = app.jobs.get(selected) {
|
|
let details = vec![
|
|
Line::from(vec![Span::raw(format!("ID: {}", job_info.job.id))]),
|
|
Line::from(vec![Span::raw(format!("Status: {:?}", job_info.status))]),
|
|
Line::from(vec![Span::raw(format!("Caller ID: {}", job_info.job.caller_id))]),
|
|
Line::from(vec![Span::raw(format!("Context ID: {}", job_info.job.context_id))]),
|
|
Line::from(vec![Span::raw(format!("Script Type: {:?}", job_info.job.script_type))]),
|
|
Line::from(vec![Span::raw(format!("Timeout: {}s", job_info.job.timeout.as_secs()))]),
|
|
Line::from(vec![Span::raw(format!("Retries: {}", job_info.job.retries))]),
|
|
Line::from(""),
|
|
Line::from(vec![Span::styled("Script:", Style::default().fg(Color::Green).add_modifier(Modifier::BOLD))]),
|
|
Line::from(vec![Span::raw(job_info.job.script.clone())]),
|
|
];
|
|
|
|
let details_block = Paragraph::new(details)
|
|
.block(Block::default().borders(Borders::ALL).title("Job Details"))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(details_block, right_chunks[0]);
|
|
|
|
// Job results (bottom right)
|
|
let result_content = if let Some(ref output) = job_info.output {
|
|
format!("Output:\n{}", output)
|
|
} else if let Some(ref error) = job_info.error {
|
|
format!("Error:\n{}", error)
|
|
} else {
|
|
match job_info.status {
|
|
JobStatus::Dispatched => "Job dispatched, waiting for execution...".to_string(),
|
|
JobStatus::Started => "Job is currently running...".to_string(),
|
|
JobStatus::WaitingForPrerequisites => "Waiting for prerequisites to complete...".to_string(),
|
|
_ => "No output available yet.".to_string(),
|
|
}
|
|
};
|
|
|
|
let result_color = match job_info.status {
|
|
JobStatus::Finished => Color::Green,
|
|
JobStatus::Error => Color::Red,
|
|
JobStatus::Started => Color::Yellow,
|
|
_ => Color::Gray,
|
|
};
|
|
|
|
let result_block = Paragraph::new(result_content)
|
|
.block(Block::default().borders(Borders::ALL).title("Job Results"))
|
|
.style(Style::default().fg(result_color))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(result_block, right_chunks[1]);
|
|
}
|
|
} else {
|
|
let placeholder = Paragraph::new("Select a job to view details")
|
|
.block(Block::default().borders(Borders::ALL).title("Job Details"))
|
|
.alignment(Alignment::Center);
|
|
f.render_widget(placeholder, right_chunks[0]);
|
|
|
|
let result_placeholder = Paragraph::new("Select a job to view results")
|
|
.block(Block::default().borders(Borders::ALL).title("Job Results"))
|
|
.alignment(Alignment::Center);
|
|
f.render_widget(result_placeholder, right_chunks[1]);
|
|
}
|
|
}
|
|
|
|
fn render_new_job(f: &mut Frame, app: &App, area: Rect) {
|
|
// Split into left (job config) and right (job output) panes
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
|
|
.split(area);
|
|
|
|
// Left pane: Job configuration form
|
|
render_job_config_form(f, app, chunks[0]);
|
|
|
|
// Right pane: Job execution results
|
|
render_job_output(f, app, chunks[1]);
|
|
}
|
|
|
|
fn render_job_config_form(f: &mut Frame, app: &App, area: Rect) {
|
|
// Split form into 4 sections for the 4 fields
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(3), // caller_id
|
|
Constraint::Length(3), // context_id
|
|
Constraint::Length(3), // timeout
|
|
Constraint::Min(4), // script (takes remaining space)
|
|
])
|
|
.split(area);
|
|
|
|
// Field styles based on current selection
|
|
let caller_id_style = if app.job_form.current_field == JobFormField::CallerId {
|
|
Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Color::White)
|
|
};
|
|
|
|
let context_id_style = if app.job_form.current_field == JobFormField::ContextId {
|
|
Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Color::White)
|
|
};
|
|
|
|
let timeout_style = if app.job_form.current_field == JobFormField::Timeout {
|
|
Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Color::White)
|
|
};
|
|
|
|
let script_style = if app.job_form.current_field == JobFormField::ScriptContent {
|
|
Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)
|
|
} else {
|
|
Style::default().fg(Color::White)
|
|
};
|
|
|
|
// Render form fields
|
|
let caller_id_input = Paragraph::new(app.job_form.caller_id.clone())
|
|
.block(Block::default().borders(Borders::ALL).title("Caller ID").border_style(caller_id_style))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(caller_id_input, chunks[0]);
|
|
|
|
let context_id_input = Paragraph::new(app.job_form.context_id.clone())
|
|
.block(Block::default().borders(Borders::ALL).title("Context ID").border_style(context_id_style))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(context_id_input, chunks[1]);
|
|
|
|
let timeout_input = Paragraph::new(app.job_form.timeout.clone())
|
|
.block(Block::default().borders(Borders::ALL).title("Timeout (seconds)").border_style(timeout_style))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(timeout_input, chunks[2]);
|
|
|
|
let script_input = Paragraph::new(app.job_form.script_content.clone())
|
|
.block(Block::default().borders(Borders::ALL).title("Script Content (Press Enter to execute)").border_style(script_style))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(script_input, chunks[3]);
|
|
}
|
|
|
|
fn render_job_output(f: &mut Frame, app: &App, area: Rect) {
|
|
if let Some(ref last_job) = app.last_executed_job {
|
|
// Find the latest version of this job from the jobs list for real-time updates
|
|
let current_job_info = app.jobs
|
|
.iter()
|
|
.find(|job| job.job.id == last_job.job.id)
|
|
.unwrap_or(last_job); // Fallback to last_executed_job if not found in list
|
|
|
|
// Split into header and output sections
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Vertical)
|
|
.constraints([
|
|
Constraint::Length(6), // Job header
|
|
Constraint::Min(4), // Output content
|
|
])
|
|
.split(area);
|
|
|
|
// Job header with ID, status, created_at
|
|
let header_lines = vec![
|
|
Line::from(vec![Span::raw(format!("Job ID: {}", current_job_info.job.id))]),
|
|
Line::from(vec![Span::raw(format!("Status: {:?}", current_job_info.status))]),
|
|
Line::from(vec![Span::raw(format!("Caller ID: {}", current_job_info.job.caller_id))]),
|
|
Line::from(vec![Span::raw(format!("Context ID: {}", current_job_info.job.context_id))]),
|
|
Line::from(vec![Span::raw(format!("Created: {:.1}s ago", current_job_info.created_at.elapsed().as_secs_f32()))]),
|
|
];
|
|
|
|
let header_block = Paragraph::new(header_lines)
|
|
.block(Block::default().borders(Borders::ALL).title("Job Details"))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(header_block, chunks[0]);
|
|
|
|
// Output content - use current job info for real-time updates
|
|
let mut output_lines = Vec::new();
|
|
|
|
if let Some(ref output) = current_job_info.output {
|
|
output_lines.push(Line::from(vec![Span::styled("Output:", Style::default().fg(Color::Green).add_modifier(Modifier::BOLD))]));
|
|
for line in output.lines() {
|
|
output_lines.push(Line::from(vec![Span::raw(line)]));
|
|
}
|
|
}
|
|
|
|
if let Some(ref error) = current_job_info.error {
|
|
if !output_lines.is_empty() {
|
|
output_lines.push(Line::from(""));
|
|
}
|
|
output_lines.push(Line::from(vec![Span::styled("Error:", Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))]));
|
|
for line in error.lines() {
|
|
output_lines.push(Line::from(vec![Span::styled(line, Style::default().fg(Color::Red))]));
|
|
}
|
|
}
|
|
|
|
if output_lines.is_empty() {
|
|
// Show status-appropriate message based on current job status
|
|
let status_message = match current_job_info.status {
|
|
JobStatus::Dispatched => "Job dispatched, waiting for execution...",
|
|
JobStatus::Started => "Job is currently running...",
|
|
JobStatus::WaitingForPrerequisites => "Waiting for prerequisites to complete...",
|
|
JobStatus::Finished => "Job completed successfully (no output)",
|
|
JobStatus::Error => "Job failed (check error details above)",
|
|
};
|
|
output_lines.push(Line::from(vec![Span::styled(status_message, Style::default().fg(Color::Yellow))]));
|
|
}
|
|
|
|
let output_block = Paragraph::new(output_lines)
|
|
.block(Block::default().borders(Borders::ALL).title("Job Output"))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(output_block, chunks[1]);
|
|
} else {
|
|
// No job executed yet
|
|
let placeholder_text = vec![
|
|
Line::from("No job executed yet."),
|
|
Line::from(""),
|
|
Line::from("Configure a job in the left pane and press Enter to execute."),
|
|
Line::from(""),
|
|
Line::from("Use Tab to navigate between fields:"),
|
|
Line::from("• Caller ID"),
|
|
Line::from("• Context ID"),
|
|
Line::from("• Timeout (seconds)"),
|
|
Line::from("• Script Content"),
|
|
];
|
|
|
|
let placeholder_block = Paragraph::new(placeholder_text)
|
|
.block(Block::default().borders(Borders::ALL).title("Job Output"))
|
|
.alignment(Alignment::Center);
|
|
f.render_widget(placeholder_block, area);
|
|
}
|
|
}
|
|
|
|
fn render_examples(f: &mut Frame, app: &mut App, area: Rect) {
|
|
let chunks = Layout::default()
|
|
.direction(Direction::Horizontal)
|
|
.constraints([Constraint::Percentage(40), Constraint::Percentage(60)])
|
|
.split(area);
|
|
|
|
// Hierarchical example tree list
|
|
let tree_items: Vec<ListItem> = app.example_tree_items
|
|
.iter()
|
|
.map(|item| {
|
|
let indent = " ".repeat(item.depth);
|
|
let (icon, name) = match &item.node {
|
|
ExampleTreeNode::File { name, .. } => ("📄", name.as_str()),
|
|
ExampleTreeNode::Folder { name, expanded, .. } => {
|
|
if *expanded {
|
|
("📂", name.as_str())
|
|
} else {
|
|
("📁", name.as_str())
|
|
}
|
|
}
|
|
};
|
|
|
|
let display_text = format!("{}{} {}", indent, icon, name);
|
|
ListItem::new(Line::from(vec![Span::raw(display_text)]))
|
|
})
|
|
.collect();
|
|
|
|
let examples_list = List::new(tree_items)
|
|
.block(Block::default().borders(Borders::ALL).title("Example Scripts (→ expand, ← collapse)"))
|
|
.highlight_style(Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD))
|
|
.highlight_symbol("> ");
|
|
|
|
f.render_stateful_widget(examples_list, chunks[0], &mut app.example_tree_state);
|
|
|
|
// Example content
|
|
if let Some(ref example) = app.selected_example {
|
|
if let Ok(content) = fs::read_to_string(&example.path) {
|
|
let lines: Vec<Line> = content.lines().map(|line| Line::from(vec![Span::raw(line)])).collect();
|
|
let example_content = Paragraph::new(lines)
|
|
.block(Block::default().borders(Borders::ALL).title(format!("Script: {}", example.name)))
|
|
.wrap(Wrap { trim: true });
|
|
f.render_widget(example_content, chunks[1]);
|
|
} else {
|
|
let error_msg = Paragraph::new("Failed to read example file")
|
|
.block(Block::default().borders(Borders::ALL).title("Script Content"))
|
|
.alignment(Alignment::Center);
|
|
f.render_widget(error_msg, chunks[1]);
|
|
}
|
|
} else {
|
|
let placeholder = Paragraph::new("Select an example to view its content")
|
|
.block(Block::default().borders(Borders::ALL).title("Script Content"))
|
|
.alignment(Alignment::Center);
|
|
f.render_widget(placeholder, chunks[1]);
|
|
}
|
|
}
|
|
|
|
fn render_job_creation(f: &mut Frame, app: &App, area: Rect) {
|
|
let instructions_text = vec![
|
|
Line::from("Job Creation Mode"),
|
|
Line::from(""),
|
|
Line::from("Use Tab to navigate between fields:"),
|
|
Line::from("• Caller ID"),
|
|
Line::from("• Context ID"),
|
|
Line::from("• Timeout (seconds)"),
|
|
Line::from("• Script Content"),
|
|
Line::from(""),
|
|
Line::from("Press Enter to create and dispatch the job."),
|
|
Line::from("Press Esc to return to main view."),
|
|
];
|
|
|
|
let instructions = Paragraph::new(instructions_text)
|
|
.alignment(Alignment::Center)
|
|
.block(Block::default().borders(Borders::ALL).title("Instructions"));
|
|
f.render_widget(instructions, area);
|
|
}
|
|
|
|
async fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> Result<()> {
|
|
let mut last_tick = Instant::now();
|
|
let tick_rate = Duration::from_millis(250);
|
|
|
|
loop {
|
|
terminal.draw(|f| ui(f, &mut app))?;
|
|
|
|
let timeout = tick_rate
|
|
.checked_sub(last_tick.elapsed())
|
|
.unwrap_or_else(|| Duration::from_secs(0));
|
|
|
|
if crossterm::event::poll(timeout)? {
|
|
if let Event::Key(key) = event::read()? {
|
|
if key.kind == KeyEventKind::Press {
|
|
match app.app_state {
|
|
AppState::Main => {
|
|
match key.code {
|
|
KeyCode::Esc => {
|
|
app.should_quit = true;
|
|
}
|
|
KeyCode::Char('1') => app.current_tab = TabState::Dashboard,
|
|
KeyCode::Char('2') => app.current_tab = TabState::Jobs,
|
|
KeyCode::Char('3') => app.current_tab = TabState::NewJob,
|
|
KeyCode::Char('4') => app.current_tab = TabState::Examples,
|
|
KeyCode::Char('[') => {
|
|
app.current_tab = match app.current_tab {
|
|
TabState::Dashboard => TabState::Examples,
|
|
TabState::Jobs => TabState::Dashboard,
|
|
TabState::NewJob => TabState::Jobs,
|
|
TabState::Examples => TabState::NewJob,
|
|
};
|
|
}
|
|
KeyCode::Char(']') => {
|
|
app.current_tab = match app.current_tab {
|
|
TabState::Dashboard => TabState::Jobs,
|
|
TabState::Jobs => TabState::NewJob,
|
|
TabState::NewJob => TabState::Examples,
|
|
TabState::Examples => TabState::Dashboard,
|
|
};
|
|
}
|
|
KeyCode::Tab => {
|
|
// Tab key now handles field navigation within tabs
|
|
if app.current_tab == TabState::NewJob {
|
|
app.next_field();
|
|
}
|
|
}
|
|
KeyCode::BackTab => {
|
|
// Shift+Tab for reverse field navigation
|
|
if app.current_tab == TabState::NewJob {
|
|
app.previous_field();
|
|
}
|
|
}
|
|
|
|
KeyCode::Down => {
|
|
match app.current_tab {
|
|
TabState::Jobs => app.next_job(),
|
|
TabState::Examples => app.next_example(),
|
|
_ => {}
|
|
}
|
|
}
|
|
KeyCode::Up => {
|
|
match app.current_tab {
|
|
TabState::Jobs => app.previous_job(),
|
|
TabState::Examples => app.previous_example(),
|
|
_ => {}
|
|
}
|
|
}
|
|
KeyCode::Left => {
|
|
if app.current_tab == TabState::Examples {
|
|
app.collapse_selected_folder();
|
|
}
|
|
}
|
|
KeyCode::Right => {
|
|
if app.current_tab == TabState::Examples {
|
|
app.expand_selected_folder();
|
|
}
|
|
}
|
|
KeyCode::Enter => {
|
|
if app.current_tab == TabState::Examples {
|
|
// Handle hierarchical tree navigation
|
|
if let Some(selected_index) = app.example_tree_state.selected() {
|
|
if selected_index < app.example_tree_items.len() {
|
|
let item = app.example_tree_items[selected_index].clone();
|
|
match &item.node {
|
|
ExampleTreeNode::Folder { .. } => {
|
|
// Toggle folder expand/collapse
|
|
app.toggle_selected_folder();
|
|
}
|
|
ExampleTreeNode::File { path, name, .. } => {
|
|
// Load file into New Job tab
|
|
let example = ExampleScript {
|
|
name: name.clone(),
|
|
path: path.clone(),
|
|
};
|
|
if let Err(e) = app.load_example_to_new_job(&example) {
|
|
app.status_message = Some(format!("Error loading example: {}", e));
|
|
} else {
|
|
app.current_tab = TabState::NewJob;
|
|
app.status_message = Some(format!("Loaded example '{}' into New Job tab", name));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if app.current_tab == TabState::NewJob {
|
|
if let Err(e) = app.create_and_dispatch_job().await {
|
|
app.status_message = Some(format!("Error creating job: {}", e));
|
|
}
|
|
}
|
|
}
|
|
KeyCode::Char(c) => {
|
|
// Handle character input in New Job tab
|
|
if app.current_tab == TabState::NewJob {
|
|
app.handle_char_input(c);
|
|
}
|
|
}
|
|
KeyCode::Backspace => {
|
|
// Handle backspace in New Job tab
|
|
if app.current_tab == TabState::NewJob {
|
|
app.handle_backspace();
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
AppState::JobCreation => {
|
|
match key.code {
|
|
KeyCode::Esc => {
|
|
app.app_state = AppState::Main;
|
|
}
|
|
KeyCode::Enter => {
|
|
if let Err(e) = app.create_and_dispatch_job().await {
|
|
app.status_message = Some(format!("Error creating job: {}", e));
|
|
}
|
|
}
|
|
KeyCode::Char(c) => {
|
|
app.handle_char_input(c);
|
|
}
|
|
KeyCode::Backspace => {
|
|
app.handle_backspace();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
_ => {
|
|
if key.code == KeyCode::Esc {
|
|
app.app_state = AppState::Main;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if last_tick.elapsed() >= tick_rate {
|
|
last_tick = Instant::now();
|
|
}
|
|
|
|
if app.should_quit {
|
|
break;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|