keepice/src/app/mod.rs

493 lines
19 KiB
Rust

use std::{borrow::Cow, fs};
use iced::{
Alignment, Color, Length, Subscription, Task, application, clipboard, event,
keyboard::{self, Key, key},
theme, widget, window,
};
use rfd::{AsyncFileDialog, FileHandle};
use crate::db::{self, EntrySearchExt};
type Element<'a> = iced::Element<'a, Message, iced::Theme, iced::Renderer>;
#[derive(Clone)]
enum Message {
ChangeDbPath(String),
PickDb,
PickedDb(Option<FileHandle>),
ChangeKeyfilePath(String),
PickKeyfile,
PickedKeyfile(Option<FileHandle>),
ChangePassword(String),
ToggleSecurity,
OpenDb,
DbOpened(Result<keepass::Database, String>),
ChangeSelection(usize, db::BasicField),
SelectionLeft,
SelectionDown,
SelectionUp,
SelectionRight,
SelectionTop,
SelectionBottom,
ChangeQuery(String),
Copy,
FocusNext,
FocusPrevious,
FocusSearch,
Quit,
}
#[derive(Default)]
struct State {
db_path: String,
db_path_exists: bool,
keyfile_path: String,
keyfile_path_exists: bool,
is_secure: bool,
password: String,
db: Option<keepass::Database>,
db_view: Vec<keepass::db::Entry>,
selected_entry: usize,
selected_field: db::BasicField,
query: String,
status: Cow<'static, str>,
error: Cow<'static, str>,
}
impl State {
fn new() -> (Self, Task<Message>) {
(
Self {
is_secure: true,
..Default::default()
},
if let Ok(db_path) = db::get_last_opened()
.inspect_err(|e| eprintln!("failed to get last-opened db: {e}"))
{
Task::done(Message::ChangeDbPath(db_path))
} else {
Task::none()
},
)
}
fn update(&mut self, message: Message) -> Task<Message> {
match message {
Message::ChangeDbPath(db_path) => {
self.db_path_exists = fs::exists(&db_path)
.inspect_err(|e| eprintln!("failed to check '{db_path}': {e}"))
.is_ok_and(|exists| exists);
self.db_path = db_path;
}
Message::PickDb => {
return Task::perform(
AsyncFileDialog::new()
.add_filter("kdbx", &["kdbx"])
.pick_file(),
Message::PickedDb,
);
}
Message::PickedDb(Some(file)) => {
return Task::done(Message::ChangeDbPath(
file.path().to_string_lossy().to_string(),
));
}
Message::PickedDb(None) => eprintln!("no path received from picker"),
Message::ChangeKeyfilePath(keyfile_path) => {
self.keyfile_path_exists = fs::exists(&keyfile_path)
.inspect_err(|e| eprintln!("failed to check '{keyfile_path}': {e}"))
.is_ok_and(|exists| exists);
self.keyfile_path = keyfile_path
}
Message::PickKeyfile => {
return Task::perform(AsyncFileDialog::new().pick_file(), Message::PickedKeyfile);
}
Message::PickedKeyfile(Some(file)) => {
return Task::done(Message::ChangeKeyfilePath(
file.path().to_string_lossy().to_string(),
));
}
Message::PickedKeyfile(None) => eprintln!("no path received from picker"),
Message::ChangePassword(password) => self.password = password,
Message::ToggleSecurity => self.is_secure = !self.is_secure,
Message::OpenDb => return self.open_db(),
Message::DbOpened(result) => {
match result {
Ok(db) => {
self.error = "".into();
self.db = Some(db);
self.populate_view();
}
Err(e) => self.error = e.into(),
}
self.status = "".into();
}
Message::ChangeSelection(i, field) => {
self.selected_entry = i;
self.selected_field = field;
return Task::done(Message::Copy);
}
Message::SelectionLeft => self.selected_field.previous(),
Message::SelectionDown => {
self.selected_entry =
(self.selected_entry.saturating_add(1)).clamp(0, self.db_view.len() - 1)
}
Message::SelectionUp => {
self.selected_entry =
(self.selected_entry.saturating_sub(1)).clamp(0, self.db_view.len() - 1)
}
Message::SelectionRight => self.selected_field.next(),
Message::SelectionTop => self.selected_entry = 0,
Message::SelectionBottom => self.selected_entry = self.db_view.len() - 1,
Message::ChangeQuery(str) => {
self.query = str;
self.populate_view();
}
Message::Copy => {
if let Some(entry_ref) = &self.db_view.get(self.selected_entry) {
if let Some(str) = match self.selected_field {
db::BasicField::Title => entry_ref.get_password(),
db::BasicField::Username => entry_ref.get_username(),
db::BasicField::Password => entry_ref.get_password(),
db::BasicField::Url => entry_ref.get_url(),
} {
self.error = "".into();
return clipboard::write(str.to_owned());
} else {
self.error = "nothing to copy!".into();
}
} else {
self.error = "nothing selected!".into();
}
}
Message::FocusNext => return widget::operation::focus_next(),
Message::FocusPrevious => return widget::operation::focus_previous(),
Message::FocusSearch => return widget::operation::focus("search"),
Message::Quit => return window::latest().and_then(window::close),
}
Task::none()
}
fn view(&self) -> Element<'_> {
let main = if self.db.is_some() {
widget::column([
widget::text_input("search query", &self.query)
.on_input(Message::ChangeQuery)
.id("search")
.into(),
widget::scrollable(
widget::grid(self.db_view.iter().enumerate().flat_map(|(i, entry)| {
[
if let Some(title) = entry.get_title() {
let field = db::BasicField::Title;
widget::button(widget::text(title))
.style(
if i == self.selected_entry && field == self.selected_field
{
widget::button::primary
} else {
widget::button::subtle
},
)
.on_press(Message::ChangeSelection(i, field))
.into()
} else {
widget::space().into()
},
if let Some(title) = entry.get_username() {
let field = db::BasicField::Username;
widget::button(widget::text(title))
.style(
if i == self.selected_entry && field == self.selected_field
{
widget::button::primary
} else {
widget::button::subtle
},
)
.on_press(Message::ChangeSelection(i, field))
.into()
} else {
widget::space().into()
},
if entry.get_password().is_some() {
let field = db::BasicField::Password;
widget::button(widget::text("[password hidden]"))
.style(
if i == self.selected_entry && field == self.selected_field
{
widget::button::primary
} else {
widget::button::subtle
},
)
.on_press(Message::ChangeSelection(i, field))
.into()
} else {
widget::space().into()
},
if let Some(title) = entry.get_url() {
let field = db::BasicField::Url;
widget::button(widget::text(title))
.style(
if i == self.selected_entry && field == self.selected_field
{
widget::button::primary
} else {
widget::button::subtle
},
)
.on_press(Message::ChangeSelection(i, field))
.into()
} else {
widget::space().into()
},
]
}))
.height(Length::Shrink)
.columns(4),
)
// I don't know why this needs to be here,
// but without it the search bar isn't shown
.height(Length::Fill)
.into(),
])
.into()
} else {
widget::container(
widget::column([
widget::row([
widget::text_input("database path", &self.db_path)
.on_input(Message::ChangeDbPath)
.into(),
widget::button("pick db")
.style(if self.db_path_exists {
widget::button::primary
} else {
widget::button::danger
})
.on_press(Message::PickDb)
.into(),
])
.into(),
widget::row([
widget::text_input("keyfile path", &self.keyfile_path)
.on_input(Message::ChangeKeyfilePath)
.into(),
widget::button("pick keyfile")
.style(
if self.keyfile_path.is_empty() || self.keyfile_path_exists {
widget::button::primary
} else {
widget::button::danger
},
)
.on_press(Message::PickKeyfile)
.into(),
])
.into(),
widget::row([
widget::text_input("password", &self.password)
.on_input(Message::ChangePassword)
.secure(self.is_secure)
.into(),
widget::checkbox(self.is_secure)
.label("security")
.on_toggle(|_| Message::ToggleSecurity)
.into(),
])
.spacing(10)
.into(),
widget::container(widget::button("open database").on_press_maybe(
if self.db_path_exists
&& (self.keyfile_path.is_empty() || self.keyfile_path_exists)
{
Some(Message::OpenDb)
} else {
None
},
))
.center_x(Length::Fill)
.into(),
])
.spacing(20)
.padding(20),
)
.center(Length::Fill)
.into()
};
let mut bar = Vec::new();
if !self.error.is_empty() {
bar.push(
widget::container(widget::text(&self.error).style(widget::text::danger))
.align_x(Alignment::Start)
.width(Length::Fill)
.into(),
);
}
if !self.status.is_empty() {
bar.push(
widget::container(widget::text(&self.status))
.align_x(Alignment::End)
.width(Length::Fill)
.into(),
);
}
widget::column([main, widget::row(bar).into()]).into()
}
fn subscription(&self) -> Subscription<Message> {
event::listen()
.with((self.db.is_some(), self.db_path_exists))
.filter_map(|((db_loaded, db_path_exists), event)| match event {
iced::Event::Keyboard(keyboard::Event::KeyPressed { key, modifiers, .. }) => {
match key.as_ref() {
Key::Character("p" | "f" | "i") if !db_loaded => Some(Message::PickDb),
Key::Character("v" | "s") if !db_loaded => Some(Message::ToggleSecurity),
Key::Named(key::Named::Enter) if !db_loaded && db_path_exists => {
Some(Message::OpenDb)
}
Key::Named(key::Named::Tab) => Some(if modifiers.shift() {
Message::FocusPrevious
} else {
Message::FocusNext
}),
Key::Character("/" | "f") => Some(Message::FocusSearch),
Key::Character("h") | Key::Named(key::Named::ArrowLeft) => {
Some(Message::SelectionLeft)
}
Key::Character("j") | Key::Named(key::Named::ArrowDown) => {
Some(Message::SelectionDown)
}
Key::Character("k") | Key::Named(key::Named::ArrowUp) => {
Some(Message::SelectionUp)
}
Key::Character("l") | Key::Named(key::Named::ArrowRight) => {
Some(Message::SelectionRight)
}
Key::Character("g") => Some(if modifiers.shift() {
Message::SelectionBottom
} else {
Message::SelectionTop
}),
Key::Named(key::Named::Home) => Some(Message::SelectionTop),
Key::Named(key::Named::End) => Some(Message::SelectionBottom),
Key::Character("y" | "c") if db_loaded => Some(Message::Copy),
Key::Named(key::Named::Escape) => Some(Message::ChangeQuery(String::new())),
Key::Character("q") => Some(Message::Quit),
// ignore unused keys
_ => None,
}
}
// ignore unused events
_ => None,
})
}
fn open_db(&mut self) -> Task<Message> {
debug_assert!(self.db_path_exists);
self.status = "loading...".into();
let (db_path, keyfile_path, password) = (
self.db_path.clone(),
self.keyfile_path.clone(),
self.password.clone(),
);
Task::perform(
async move {
let key = {
let mut key = keepass::DatabaseKey::new();
if !password.is_empty() {
key = key.with_password(&password);
}
if !keyfile_path.is_empty() {
key = key
.with_keyfile(
&mut fs::File::open(&keyfile_path).map_err(|e| e.to_string())?,
)
.map_err(|e| e.to_string())?;
}
key
};
let db = keepass::Database::open(
&mut fs::File::open(&db_path).map_err(|e| e.to_string())?,
key,
)
.map_err(|e| e.to_string())?;
db::set_last_opened(&db_path).map_err(|e| e.to_string())?;
Ok(db)
},
Message::DbOpened,
)
}
fn populate_view(&mut self) {
self.db_view = self
.db
.as_ref()
.unwrap()
.iter_all_entries()
.filter_map(|entry_ref| {
// this matches everything when the query is an empty string,
// which is the desired behavior so that it displays everything
// (when search isn't being used)
entry_ref
.contains(&self.query)
.then(|| entry_ref.to_owned())
})
.collect();
}
}
pub fn run() -> Result<(), iced::Error> {
application(State::new, State::update, State::view)
.subscription(State::subscription)
.theme(theme::Theme::custom(
"high-contrast-dark",
theme::Palette {
background: Color::from_rgb8(10, 10, 10),
text: Color::WHITE,
..theme::Palette::DARK
},
))
.run()
}