jap_learn/src/pages/history.rs

use crate::app::AppState;
use crate::data::entities::{HistoryNote, WordData};
use crate::data::repositories::Repository;
use crate::navigation::*;
use crate::styling::*;
use chrono::Local;
use iced::alignment::Horizontal::Center;
use iced::widget::space::horizontal;
use iced::widget::*;
use iced::{Element, Fill, FillPortion, Task};
use std::sync::Arc;
use HistoryMessage::Back;

#[derive(Clone)]
pub struct HistoryState {
    list: Vec<(WordData, HistoryNote)>,
    pub state: AppState,
}

impl NavigatedPage<HistoryMessage> for HistoryState {
    fn navigate(&mut self, message: &HistoryMessage) -> Option<Page> {
        match message {
            Back => Some(Page::PreviousPage),
        }
    }
    fn navigated(&mut self) {}
    fn update(&mut self, _: HistoryMessage) -> Task<RootMessage> {
        Task::none()
    }

    fn view(&self) -> Element<'_, HistoryMessage> {
        back_overlay(
            iced::widget::row![
                horizontal().width(FillPortion(1)),
                scrollable(self.history_lines().padding(DEFAULT_SPACING))
                    .height(Fill)
                    .width(FillPortion(5)),
                horizontal().width(FillPortion(1))
            ]
                .height(Fill)
                .width(Fill)
                .into(),
            Back,
        )
    }
}

impl HistoryState {
    pub fn new(id: crate::data::Id, state: AppState) -> Self {
        let dict = &state.dictionary.read();
        let history_repo = &mut state.history.write();
        history_repo.init().expect("TODO: panic message");
        let id = id.clone();
        let mut history = history_repo.query(Arc::new(move |h| h.deck_id == id));
        let words = history
            .iter(history_repo)
            .map(
                |item| {let handle = dict.handle_by_id(item.word_id);
                    let word = dict.get_static(handle).unwrap_or(WordData {
                        id: Default::default(),
                        group_id: Default::default(),
                        key: "Удаленное слово".to_string(),
                        value: "".to_string(),
                        tags: "".to_string(),
                        additional: Default::default(),
                    });
                    (word, item.clone())
                }
            )
            .collect();
        Self {
            list: words,
            state: state.clone(),
        }
    }

    fn history_lines(&self) -> Column<'_, HistoryMessage> {
        let mut column = Column::new();
        for (index, item) in &self.list {

            let activity = item;
            column = column.push(
                row![
                    iced::widget::column![
                        text!("{}", index.key)
                            .width(Fill)
                            .align_x(Center),
                        text!("{}", index.value)
                            .width(Fill)
                            .align_x(Center),
                    ]
                    .align_x(Center),
                    iced::widget::column![
                        text!("{} ➞ {}", activity.before, activity.after),
                        text!(
                            "{}",
                            activity.timestamp.with_timezone(&Local).format("%d.%m %H:%M")
                        )
                    ]
                    .spacing(5)
                    .align_x(Center)
                ]
                    .spacing(5),
            );
            column = column.push(rule::horizontal(1));
        }
        column.spacing(5)
    }
}

#[derive(Clone)]
pub enum HistoryMessage {
    Back,
}