559 lines
19 KiB
Rust
559 lines
19 KiB
Rust
use crate::data_provider::import::{ImportData, ImportGroup, get_words_of_group, load_groups};
|
|
use crate::data_provider::words::{add_group, add_words};
|
|
use crate::pages::import::ImportMessage::*;
|
|
use crate::data::entities::{WordData, WordGroup};
|
|
use crate::navigation::{NavigatedPage, Page, RootMessage};
|
|
use crate::notification::NotificationData::OpenFileError;
|
|
use crate::notification::NotificationData;
|
|
use crate::styling::*;
|
|
use iced::widget::button::danger;
|
|
use iced::widget::container::success;
|
|
use iced::widget::{
|
|
Row, button, checkbox, column, container, progress_bar, row, rule, text, text_input,
|
|
};
|
|
use iced::widget::{scrollable, space};
|
|
use iced::{Element, Task};
|
|
use iced_core::Alignment::Center;
|
|
use iced_core::Length::Fill;
|
|
use iced_core::Padding;
|
|
use parking_lot::Mutex;
|
|
use rfd::AsyncFileDialog;
|
|
use rusqlite::Connection;
|
|
use std::fs::{File, OpenOptions};
|
|
use std::io::BufReader;
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
use log::info;
|
|
use tokio::task::spawn_blocking;
|
|
use zip::ZipArchive;
|
|
use crate::app::AppState;
|
|
use crate::fs::*;
|
|
use crate::push_error;
|
|
|
|
const DEFAULT_FIELDS: [&str; 6] = ["key", "value", "tags", "reading", "context", "description"];
|
|
|
|
#[derive(Clone)]
|
|
pub struct ImportState {
|
|
state: Arc<Mutex<AppState>>,
|
|
path: Option<PathBuf>,
|
|
import_data: Option<ImportData>,
|
|
selected_index: usize,
|
|
selected_property: Option<String>,
|
|
custom_property_name: String,
|
|
skip_empty: bool,
|
|
separator: String,
|
|
progress: Option<Arc<Mutex<f32>>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub enum ImportMessage {
|
|
Back,
|
|
SelectFile,
|
|
UpdateFile(PathBuf),
|
|
UpdateImport(ImportData),
|
|
NextGroup,
|
|
PreviousGroup,
|
|
OpenPropertyMapper(String),
|
|
EditCustomProperty(String),
|
|
SetupCustomProperty,
|
|
SetupDefaultProperty(String),
|
|
SetupDirect,
|
|
RemoveMapping(String),
|
|
SwitchSkipEmpty(bool),
|
|
EditSeparator(String),
|
|
StartImport,
|
|
NextProgress,
|
|
ImportFinished,
|
|
}
|
|
|
|
impl NavigatedPage<ImportMessage> for ImportState {
|
|
fn navigate(&mut self, message: &ImportMessage) -> Option<Page> {
|
|
if self.progress.is_some() {
|
|
return None;
|
|
}
|
|
|
|
if let Back = message {
|
|
return Some(Page::PreviousPage);
|
|
}
|
|
None
|
|
}
|
|
|
|
fn navigated(&mut self) {}
|
|
|
|
fn update(&mut self, message: ImportMessage) -> Task<RootMessage> {
|
|
match message {
|
|
Back => {}
|
|
UpdateFile(path) => {
|
|
self.path = Some(path);
|
|
self.import_data = None;
|
|
return self.load_package();
|
|
}
|
|
SelectFile => return Self::select_import_file(),
|
|
UpdateImport(import) => {
|
|
self.selected_index = 0;
|
|
self.import_data = Some(import);
|
|
}
|
|
NextGroup => {
|
|
self.selected_index += 1;
|
|
self.selected_property = None;
|
|
self.custom_property_name.clear();
|
|
}
|
|
PreviousGroup => {
|
|
self.selected_index -= 1;
|
|
self.selected_property = None;
|
|
self.custom_property_name.clear();
|
|
}
|
|
OpenPropertyMapper(prop) => self.selected_property = Some(prop),
|
|
EditCustomProperty(prop_name) => self.custom_property_name = prop_name,
|
|
SetupCustomProperty => {
|
|
self.setup_mapping(self.custom_property_name.clone());
|
|
}
|
|
SetupDefaultProperty(prop_name) => {
|
|
self.setup_mapping(prop_name);
|
|
}
|
|
SetupDirect => {
|
|
self.setup_mapping(self.selected_property.clone().unwrap());
|
|
}
|
|
RemoveMapping(pro_name) => {
|
|
self.remove_mapping(pro_name);
|
|
}
|
|
SwitchSkipEmpty(skip) => {
|
|
self.skip_empty = skip;
|
|
}
|
|
EditSeparator(separator) => {
|
|
self.separator = separator.clone();
|
|
}
|
|
StartImport => {
|
|
self.progress = Some(Arc::new(Mutex::new(0.0)));
|
|
return Task::batch([self.start_import(), self.next_progress()]);
|
|
}
|
|
NextProgress => {
|
|
if self.progress.is_none() {
|
|
return Task::none();
|
|
}
|
|
return self.next_progress();
|
|
}
|
|
ImportFinished => {
|
|
self.progress = None;
|
|
let group = &mut self.import_data.as_mut().unwrap().0[self.selected_index];
|
|
group.imported = true;
|
|
}
|
|
}
|
|
Task::none()
|
|
}
|
|
|
|
fn view(&self) -> Element<'_, ImportMessage> {
|
|
back_overlay(
|
|
{
|
|
if let Some(value) = &self.progress {
|
|
column![progress_bar(0f32..=1f32, *value.lock()),]
|
|
.spacing(QUARTER_SPACING)
|
|
.into()
|
|
} else {
|
|
scrollable(
|
|
column![
|
|
row![
|
|
button("Выбрать файл").style(jl_button).on_press(SelectFile),
|
|
text!("{}", {
|
|
if let Some(path) = &self.path {
|
|
path.to_string_lossy().to_string()
|
|
} else {
|
|
"Файл не выбран".to_string()
|
|
}
|
|
})
|
|
]
|
|
.align_y(Center)
|
|
.spacing(DEFAULT_SPACING),
|
|
self.selected_group()
|
|
]
|
|
.spacing(DEFAULT_SPACING),
|
|
)
|
|
.into()
|
|
}
|
|
},
|
|
Back,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl ImportState {
|
|
fn selected_group(&self) -> Element<'_, ImportMessage> {
|
|
if let Some(data) = &self.import_data {
|
|
let group = &data.0[self.selected_index];
|
|
return column![
|
|
row![
|
|
self.back_button(),
|
|
space().width(Fill),
|
|
text!("{}", group.name.clone()),
|
|
space().width(Fill),
|
|
self.next_button()
|
|
]
|
|
.width(Fill),
|
|
text!("Количество карточек: {}", group.length),
|
|
self.property_mapper(group),
|
|
self.import_settings(),
|
|
self.import_button(group),
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.into();
|
|
}
|
|
space().into()
|
|
}
|
|
|
|
fn import_button(&self, group: &ImportGroup) -> Element<'_, ImportMessage> {
|
|
if group.imported {
|
|
return container(text!("Группа слов успешно импортирована"))
|
|
.padding(HALF_SPACING)
|
|
.align_x(Center)
|
|
.style(success)
|
|
.width(Fill)
|
|
.into();
|
|
}
|
|
button("Начать импорт")
|
|
.style(cta_button)
|
|
.on_press(StartImport)
|
|
.into()
|
|
}
|
|
|
|
fn property_mapper(&self, group: &ImportGroup) -> Element<'_, ImportMessage> {
|
|
column![
|
|
self.property_list(group),
|
|
rule::horizontal(2),
|
|
self.property_selector()
|
|
]
|
|
.spacing(HALF_SPACING)
|
|
.into()
|
|
}
|
|
|
|
fn property_list(&self, group: &ImportGroup) -> Element<'_, ImportMessage> {
|
|
let mut row = Row::new();
|
|
for prop in &group.fields {
|
|
let primary_button_name = (*prop).clone();
|
|
if let Some(mapped) = group.mapping.get(prop.clone().as_str()) {
|
|
row = row.push(
|
|
column![
|
|
button(text!("{}", primary_button_name)),
|
|
"↕",
|
|
button(text!("{}", mapped))
|
|
.style(danger)
|
|
.on_press(RemoveMapping(mapped.as_str().to_string())),
|
|
]
|
|
.align_x(Center),
|
|
);
|
|
} else {
|
|
row = row.push(
|
|
button(text!("{}", primary_button_name))
|
|
.on_press(OpenPropertyMapper(prop.clone())),
|
|
);
|
|
}
|
|
}
|
|
scrollable(row.spacing(HALF_SPACING).padding(Padding {
|
|
top: 0.0,
|
|
right: 0.0,
|
|
bottom: DEFAULT_SPACING,
|
|
left: 0.0,
|
|
}))
|
|
.horizontal()
|
|
.into()
|
|
}
|
|
|
|
fn property_selector(&self) -> Element<'_, ImportMessage> {
|
|
if self.selected_property.is_none() {
|
|
return space().into();
|
|
}
|
|
column![
|
|
self.available_properties(),
|
|
button("Добавить напрямую").on_press(SetupDirect),
|
|
row![
|
|
text_input("Пользовательское поле", &self.custom_property_name)
|
|
.on_input(EditCustomProperty),
|
|
button("Установить привязку").on_press(SetupCustomProperty)
|
|
]
|
|
.spacing(QUARTER_SPACING)
|
|
]
|
|
.spacing(HALF_SPACING)
|
|
.into()
|
|
}
|
|
|
|
fn available_properties(&self) -> Element<'_, ImportMessage> {
|
|
let mut row = Row::new();
|
|
|
|
for default in DEFAULT_FIELDS {
|
|
row = row.push(
|
|
button(text!("{default}")).on_press(SetupDefaultProperty(default.to_string())),
|
|
);
|
|
}
|
|
row.spacing(HALF_SPACING).into()
|
|
}
|
|
|
|
fn import_settings(&self) -> Element<'_, ImportMessage> {
|
|
column![
|
|
checkbox(self.skip_empty)
|
|
.label("Пропускать пустые строки")
|
|
.on_toggle(SwitchSkipEmpty),
|
|
column![
|
|
text!("Разделитель при множественном объединении"),
|
|
text_input("", &self.separator).on_input(EditSeparator)
|
|
]
|
|
]
|
|
.spacing(DEFAULT_SPACING)
|
|
.into()
|
|
}
|
|
|
|
fn back_button(&self) -> Element<'_, ImportMessage> {
|
|
let mut button = button("←").style(button::text);
|
|
if self.selected_index > 0 {
|
|
button = button.on_press(PreviousGroup);
|
|
}
|
|
button.into()
|
|
}
|
|
|
|
fn next_button(&self) -> Element<'_, ImportMessage> {
|
|
let mut button = button("→").style(button::text);
|
|
if self.selected_index < self.import_data.as_ref().unwrap().0.len() - 1 {
|
|
button = button.on_press(NextGroup);
|
|
}
|
|
button.into()
|
|
}
|
|
}
|
|
|
|
impl ImportState {
|
|
pub fn new(state: Arc<Mutex<AppState>>) -> ImportState {
|
|
ImportState {
|
|
state,
|
|
path: None,
|
|
import_data: None,
|
|
selected_index: 0,
|
|
selected_property: None,
|
|
custom_property_name: "".to_string(),
|
|
skip_empty: true,
|
|
separator: ", ".to_string(),
|
|
progress: None,
|
|
}
|
|
}
|
|
|
|
fn select_import_file() -> Task<RootMessage> {
|
|
Task::perform(
|
|
async {
|
|
let file = AsyncFileDialog::new()
|
|
.add_filter("Anki", &["apkg"])
|
|
.pick_file()
|
|
.await;
|
|
if let Some(file) = file {
|
|
return Some(file.path().into());
|
|
}
|
|
None
|
|
},
|
|
|result| {
|
|
if let Some(path) = result {
|
|
RootMessage::Import(UpdateFile(path))
|
|
} else {
|
|
RootMessage::None
|
|
}
|
|
},
|
|
)
|
|
}
|
|
|
|
pub fn load_package(&self) -> Task<RootMessage> {
|
|
let path = self.path.clone().unwrap();
|
|
Task::perform(
|
|
async {
|
|
spawn_blocking(move || {
|
|
Self::extract_import_file(path)?;
|
|
let data = Self::read_import_file()?;
|
|
Ok(data)
|
|
})
|
|
.await
|
|
.unwrap()
|
|
},
|
|
|result: Result<ImportData, NotificationData>| match result {
|
|
Ok(import) => RootMessage::Import(UpdateImport(import)),
|
|
Err(err) => push_error!(err),
|
|
},
|
|
)
|
|
}
|
|
|
|
fn extract_import_file(path: PathBuf) -> Result<(), NotificationData> {
|
|
let file = File::open(path).map_err(|_| OpenFileError)?;
|
|
let reader = BufReader::new(file);
|
|
let mut archive = ZipArchive::new(reader).map_err(|_| OpenFileError)?;
|
|
let temp_file_path = temp_import_path();
|
|
let mut temp_file = OpenOptions::new()
|
|
.write(true)
|
|
.create(true)
|
|
.truncate(true)
|
|
.open(&temp_file_path)
|
|
.map_err(|_| OpenFileError)?;
|
|
if let Ok(mut file) = archive.by_name("collection.anki21") {
|
|
std::io::copy(&mut file, &mut temp_file).map_err(|_| OpenFileError)?;
|
|
Ok(())
|
|
} else if let Ok(mut file) = archive.by_name("collection.anki2") {
|
|
std::io::copy(&mut file, &mut temp_file).map_err(|_| OpenFileError)?;
|
|
Ok(())
|
|
} else {
|
|
Err(OpenFileError)
|
|
}
|
|
}
|
|
fn read_import_file() -> Result<ImportData, NotificationData> {
|
|
let temp_file_path = temp_import_path();
|
|
let connection = Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
|
|
let data = load_groups(&connection)?;
|
|
Ok(data)
|
|
}
|
|
fn setup_mapping(&mut self, property_name: String) {
|
|
let group = self.import_data.as_mut().unwrap();
|
|
let group = &mut group.0[self.selected_index];
|
|
group
|
|
.mapping
|
|
.insert(self.selected_property.clone().unwrap(), property_name);
|
|
self.selected_property = None;
|
|
self.custom_property_name.clear();
|
|
}
|
|
fn remove_mapping(&mut self, property_name: String) {
|
|
let group = self.import_data.as_mut().unwrap();
|
|
let group = &mut group.0[self.selected_index];
|
|
let remove_key = group
|
|
.mapping
|
|
.keys()
|
|
.find(|key| group.mapping[*key] == property_name)
|
|
.unwrap();
|
|
group.mapping.remove(remove_key.clone().as_str());
|
|
self.selected_property = None;
|
|
self.custom_property_name.clear();
|
|
}
|
|
|
|
fn start_import(&self) -> Task<RootMessage> {
|
|
let state = self.state.clone();
|
|
let separator = self.separator.clone();
|
|
let skip_empty = self.skip_empty;
|
|
let group = self.import_data.as_ref().unwrap().0[self.selected_index].clone();
|
|
let progress = self.progress.clone().unwrap();
|
|
info!("{}", group.name);
|
|
Task::perform(
|
|
async move {
|
|
spawn_blocking(move || {
|
|
let temp_file_path = temp_import_path();
|
|
let connection = Connection::open(&temp_file_path).map_err(|_| OpenFileError)?;
|
|
let import_list = get_words_of_group(&connection, group.id)?;
|
|
let mut words_list = Vec::with_capacity(import_list.len());
|
|
|
|
let map_indices = Self::get_mapping_indices(&group);
|
|
let mut group_entity = WordGroup {
|
|
id: 0.into(),
|
|
name: group.name.clone(),
|
|
};
|
|
{
|
|
let state = state.lock();
|
|
add_group(&mut group_entity, &state.connection)?;
|
|
}
|
|
|
|
let group_id = group_entity.id;
|
|
for import in import_list {
|
|
let mut word = WordData::new();
|
|
|
|
word.tags = import.tags.trim().replace(" ", ", ");
|
|
word.group_id = group_id;
|
|
for (dest, indices) in &map_indices {
|
|
let collected_string = Self::collect_strings(
|
|
&import.fields,
|
|
indices,
|
|
&separator,
|
|
skip_empty,
|
|
);
|
|
match dest.as_str() {
|
|
"key" => {
|
|
word.key = collected_string;
|
|
}
|
|
"value" => {
|
|
word.value = collected_string;
|
|
}
|
|
"tags" => {
|
|
word.tags = collected_string;
|
|
}
|
|
&_ => {
|
|
word.additional.insert((*dest).clone(), collected_string);
|
|
}
|
|
}
|
|
}
|
|
|
|
words_list.push(word);
|
|
}
|
|
|
|
let mut state = state.lock();
|
|
let connection = &mut state.connection;
|
|
let mut index = 0;
|
|
let total_len = words_list.len() as f32 / 1024.0;
|
|
for word in &mut words_list.chunks_mut(1024) {
|
|
add_words(word, connection)?;
|
|
index += 1;
|
|
let mut progress = progress.lock();
|
|
*progress = (index as f32 / total_len).min(1.0);
|
|
}
|
|
|
|
state.dictionary.append(&mut words_list);
|
|
state.word_groups.push(group_entity);
|
|
|
|
Ok(())
|
|
})
|
|
.await
|
|
.unwrap()
|
|
},
|
|
|r: Result<(), NotificationData>| match r {
|
|
Ok(_) => RootMessage::Import(ImportFinished),
|
|
Err(err) => push_error!(err)
|
|
}
|
|
)
|
|
}
|
|
|
|
fn get_mapping_indices(group: &ImportGroup) -> Vec<(String, Vec<usize>)> {
|
|
let mut final_props = group.mapping.values().cloned().collect::<Vec<_>>();
|
|
final_props.sort();
|
|
final_props.dedup();
|
|
let mut result = final_props
|
|
.iter()
|
|
.map(|name| (name.clone(), Vec::<usize>::with_capacity(1)))
|
|
.collect::<Vec<_>>();
|
|
for (key, endpoint) in &group.mapping {
|
|
let property_index = group
|
|
.fields
|
|
.iter()
|
|
.position(|f| f == key)
|
|
.expect("Unknown property");
|
|
let group_index = result
|
|
.iter()
|
|
.position(|(name, _)| name == endpoint)
|
|
.unwrap();
|
|
result[group_index].1.push(property_index);
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
fn collect_strings(
|
|
properties: &[String],
|
|
indices: &[usize],
|
|
separator: &str,
|
|
skip_empty: bool,
|
|
) -> String {
|
|
let mut working_words = Vec::with_capacity(indices.len());
|
|
for index in indices {
|
|
let str = &properties[*index];
|
|
if skip_empty && str.is_empty() {
|
|
continue;
|
|
}
|
|
working_words.push(str.as_str());
|
|
}
|
|
|
|
working_words.join(separator)
|
|
}
|
|
|
|
fn next_progress(&self) -> Task<RootMessage> {
|
|
Task::perform(
|
|
async {
|
|
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
|
|
},
|
|
|_| RootMessage::Import(NextProgress),
|
|
)
|
|
}
|
|
}
|