Initial commit
This commit is contained in:
Uber Veng
376
src/app.rs
Normal file
376
src/app.rs
Normal file
@@ -0,0 +1,376 @@
|
||||
// src/app.rs
|
||||
use crate::config::Config;
|
||||
use crate::error::Result;
|
||||
use crate::executor;
|
||||
use crate::menu::{Action, InteractionMode, MenuItem, MenuItemKind, MenuRoot};
|
||||
use crate::network;
|
||||
use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEventKind};
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Event {
|
||||
Crossterm(CrosstermEvent),
|
||||
MenuLoaded(Result<MenuRoot>),
|
||||
ActionCompleted,
|
||||
Error(String),
|
||||
StructuredCommand(executor::StructuredCommand), // для structured сессии
|
||||
StructuredOutput(String), // строка вывода от скрипта
|
||||
StructuredFinished(i32), // код завершения
|
||||
}
|
||||
|
||||
pub struct App {
|
||||
pub config: Config,
|
||||
pub menu: Option<MenuRoot>,
|
||||
pub error: Option<String>,
|
||||
|
||||
// Навигация: стек индексов к текущей категории
|
||||
pub breadcrumbs: Vec<usize>,
|
||||
pub selected_index: usize, // индекс в текущем списке
|
||||
|
||||
// Состояние popup'а
|
||||
pub popup: Option<Popup>,
|
||||
|
||||
// Канал для отправки событий самому себе (из асинхронных задач)
|
||||
pub event_tx: UnboundedSender<Event>,
|
||||
}
|
||||
|
||||
pub enum Popup {
|
||||
Confirming { action: Action, item_title: String },
|
||||
ExecutingBashTerminal { child: tokio::process::Child },
|
||||
ExecutingStructured {
|
||||
reply_tx: tokio::sync::mpsc::UnboundedSender<String>,
|
||||
log_buffer: Vec<String>,
|
||||
current_command: Option<executor::StructuredCommand>,
|
||||
input_buffer: String,
|
||||
},
|
||||
Downloading { progress: f32, message: String },
|
||||
Message { text: String, level: MessageLevel },
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum MessageLevel {
|
||||
Info,
|
||||
Warn,
|
||||
Error,
|
||||
}
|
||||
|
||||
impl App {
|
||||
pub fn new(config: Config, event_tx: UnboundedSender<Event>) -> Self {
|
||||
Self {
|
||||
config,
|
||||
menu: None,
|
||||
error: None,
|
||||
breadcrumbs: Vec::new(),
|
||||
selected_index: 0,
|
||||
popup: None,
|
||||
event_tx,
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn load_menu(&mut self) {
|
||||
let server_url = self.config.server_url.clone();
|
||||
let timeout = self.config.timeout_sec;
|
||||
let tx = self.event_tx.clone();
|
||||
|
||||
tokio::spawn(async move {
|
||||
let result = network::fetch_menu(&server_url, timeout).await;
|
||||
let _ = tx.send(Event::MenuLoaded(result));
|
||||
});
|
||||
}
|
||||
|
||||
/// Возвращает текущий список пунктов меню (категория или корень)
|
||||
pub fn current_items(&self) -> Vec<&MenuItem> {
|
||||
if self.breadcrumbs.is_empty() {
|
||||
self.menu
|
||||
.as_ref()
|
||||
.map(|root| root.menu.iter().collect())
|
||||
.unwrap_or_default()
|
||||
} else {
|
||||
let mut items = &self.menu.as_ref().unwrap().menu;
|
||||
for &idx in &self.breadcrumbs {
|
||||
if let MenuItemKind::Category { children } = &items[idx].kind {
|
||||
items = children;
|
||||
} else {
|
||||
return vec![];
|
||||
}
|
||||
}
|
||||
items.iter().collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// Получить выбранный пункт
|
||||
pub fn selected_item(&self) -> Option<&MenuItem> {
|
||||
let items = self.current_items();
|
||||
items.get(self.selected_index).copied()
|
||||
}
|
||||
|
||||
/// Обработка событий
|
||||
pub async fn handle_event(&mut self, event: Event) -> Result<bool> {
|
||||
match event {
|
||||
Event::Crossterm(evt) => self.handle_crossterm_event(evt).await,
|
||||
Event::MenuLoaded(Ok(menu)) => {
|
||||
self.menu = Some(menu);
|
||||
self.error = None;
|
||||
Ok(false)
|
||||
}
|
||||
Event::MenuLoaded(Err(e)) => {
|
||||
self.error = Some(format!("Ошибка загрузки меню: {}", e));
|
||||
Ok(false)
|
||||
}
|
||||
Event::Error(msg) => {
|
||||
self.error = Some(msg);
|
||||
Ok(false)
|
||||
}
|
||||
Event::ActionCompleted => {
|
||||
self.popup = None;
|
||||
Ok(false)
|
||||
}
|
||||
Event::StructuredCommand(cmd) => {
|
||||
if let Some(Popup::ExecutingStructured { current_command, .. }) = &mut self.popup {
|
||||
*current_command = Some(cmd);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
Event::StructuredOutput(line) => {
|
||||
if let Some(Popup::ExecutingStructured { log_buffer, .. }) = &mut self.popup {
|
||||
log_buffer.push(line);
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
Event::StructuredFinished(exit_code) => {
|
||||
self.popup = Some(Popup::Message {
|
||||
text: format!("Скрипт завершился с кодом {}", exit_code),
|
||||
level: if exit_code == 0 { MessageLevel::Info } else { MessageLevel::Error },
|
||||
});
|
||||
Ok(false)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle_crossterm_event(&mut self, evt: CrosstermEvent) -> Result<bool> {
|
||||
match evt {
|
||||
CrosstermEvent::Key(key) if key.kind == KeyEventKind::Press => {
|
||||
// Если есть popup, передаём ему
|
||||
if let Some(popup) = &mut self.popup {
|
||||
match popup {
|
||||
Popup::Confirming { action, item_title } => {
|
||||
match key.code {
|
||||
KeyCode::Char('y') | KeyCode::Char('Y') => {
|
||||
let action = action.clone();
|
||||
self.popup = None;
|
||||
self.run_action(action).await?;
|
||||
}
|
||||
KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
|
||||
self.popup = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
Popup::ExecutingStructured {
|
||||
reply_tx,
|
||||
input_buffer,
|
||||
current_command,
|
||||
..
|
||||
} => {
|
||||
match key.code {
|
||||
KeyCode::Char(c) => {
|
||||
input_buffer.push(c);
|
||||
}
|
||||
KeyCode::Backspace => {
|
||||
input_buffer.pop();
|
||||
}
|
||||
KeyCode::Enter => {
|
||||
if let Some(cmd) = current_command.take() {
|
||||
let response = match &cmd {
|
||||
executor::StructuredCommand::Input { .. } => {
|
||||
input_buffer.clone()
|
||||
}
|
||||
executor::StructuredCommand::Confirm { .. } => {
|
||||
if input_buffer.to_lowercase() == "y" { "y".to_string() } else { "n".to_string() }
|
||||
}
|
||||
executor::StructuredCommand::Menu { .. } => {
|
||||
input_buffer.clone()
|
||||
}
|
||||
_ => String::new(),
|
||||
};
|
||||
let _ = reply_tx.send(response);
|
||||
input_buffer.clear();
|
||||
}
|
||||
}
|
||||
KeyCode::Esc => {
|
||||
self.popup = None;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
return Ok(false);
|
||||
}
|
||||
Popup::Message { .. } => {
|
||||
self.popup = None;
|
||||
return Ok(false);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
// Навигация по меню
|
||||
match key.code {
|
||||
KeyCode::Char('q') => return Ok(true),
|
||||
KeyCode::Up => {
|
||||
let len = self.current_items().len();
|
||||
if len > 0 {
|
||||
self.selected_index = (self.selected_index + len - 1) % len;
|
||||
}
|
||||
}
|
||||
KeyCode::Down => {
|
||||
let len = self.current_items().len();
|
||||
if len > 0 {
|
||||
self.selected_index = (self.selected_index + 1) % len;
|
||||
}
|
||||
}
|
||||
KeyCode::Enter => {
|
||||
if let Some(item) = self.selected_item().cloned() {
|
||||
self.activate_item(item).await?;
|
||||
}
|
||||
}
|
||||
KeyCode::Esc => {
|
||||
if !self.breadcrumbs.is_empty() {
|
||||
self.breadcrumbs.pop();
|
||||
self.selected_index = 0;
|
||||
}
|
||||
}
|
||||
KeyCode::Char('r') | KeyCode::Char('R') => {
|
||||
self.load_menu().await;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
async fn activate_item(&mut self, item: MenuItem) -> Result<()> {
|
||||
match item.kind {
|
||||
MenuItemKind::Category { children: _ } => {
|
||||
// Переход в категорию
|
||||
if let Some(idx) = self
|
||||
.current_items()
|
||||
.iter()
|
||||
.position(|i| i.id == item.id)
|
||||
{
|
||||
self.breadcrumbs.push(idx);
|
||||
self.selected_index = 0;
|
||||
}
|
||||
}
|
||||
MenuItemKind::Action { action } => {
|
||||
// Если требуется подтверждение
|
||||
if action.confirm() {
|
||||
self.popup = Some(Popup::Confirming {
|
||||
action,
|
||||
item_title: item.title,
|
||||
});
|
||||
} else {
|
||||
self.run_action(action).await?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_action(&mut self, action: Action) -> Result<()> {
|
||||
match action {
|
||||
Action::Bash {
|
||||
script,
|
||||
interaction,
|
||||
confirm: _,
|
||||
} => match interaction {
|
||||
InteractionMode::Terminal => {
|
||||
// Запуск в PTY (упрощённо)
|
||||
self.run_bash_terminal(&script).await?;
|
||||
}
|
||||
InteractionMode::Structured => {
|
||||
self.run_bash_structured(&script).await?;
|
||||
}
|
||||
},
|
||||
Action::Download {
|
||||
url,
|
||||
filename: _,
|
||||
target_dir: _,
|
||||
confirm: _,
|
||||
} => {
|
||||
// Заглушка
|
||||
self.popup = Some(Popup::Message {
|
||||
text: format!("Скачивание {} пока не реализовано", url),
|
||||
level: MessageLevel::Info,
|
||||
});
|
||||
}
|
||||
Action::DownloadAndRun { .. } => {}
|
||||
Action::HttpRequest { .. } => {}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_bash_terminal(&mut self, script: &str) -> Result<()> {
|
||||
use tokio::process::Command;
|
||||
// В реальности здесь нужно создавать PTY через дополнительную библиотеку
|
||||
// Пока заглушка
|
||||
let child = Command::new("bash")
|
||||
.arg("-c")
|
||||
.arg(script)
|
||||
.spawn()?;
|
||||
self.popup = Some(Popup::ExecutingBashTerminal { child });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_bash_structured(&mut self, script: &str) -> Result<()> {
|
||||
let (output_rx, command_rx, finished_rx, reply_tx) =
|
||||
executor::structured::spawn(script)?;
|
||||
|
||||
let tx_output = self.event_tx.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut rx = output_rx;
|
||||
while let Some(line) = rx.recv().await {
|
||||
if tx_output.send(Event::StructuredOutput(line)).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let tx_cmd = self.event_tx.clone();
|
||||
tokio::spawn(async move {
|
||||
let mut rx = command_rx;
|
||||
while let Some(cmd) = rx.recv().await {
|
||||
if tx_cmd.send(Event::StructuredCommand(cmd)).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let tx_finished = self.event_tx.clone();
|
||||
tokio::spawn(async move {
|
||||
let code = finished_rx.await.unwrap_or(1);
|
||||
let _ = tx_finished.send(Event::StructuredFinished(code));
|
||||
});
|
||||
|
||||
self.popup = Some(Popup::ExecutingStructured {
|
||||
reply_tx,
|
||||
log_buffer: Vec::new(),
|
||||
current_command: None,
|
||||
input_buffer: String::new(),
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Action {
|
||||
fn confirm(&self) -> bool {
|
||||
match self {
|
||||
Action::Bash { confirm, .. } => *confirm,
|
||||
Action::Download { confirm, .. } => *confirm,
|
||||
Action::DownloadAndRun { confirm, .. } => *confirm,
|
||||
Action::HttpRequest { confirm, .. } => *confirm,
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user