annis-web 0.2.0

This is an experimental version of ANNIS corpus search frontend.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use std::sync::Arc;

use axum::{
    extract::State,
    response::Html,
    response::IntoResponse,
    routing::{get, post},
    Form, Router,
};
use minijinja::context;
use serde::{Deserialize, Serialize};

use crate::{
    client::corpora,
    state::{GlobalAppState, Session, SessionArg},
    Result,
};

pub fn create_routes() -> Result<Router<Arc<GlobalAppState>>> {
    let result = Router::new().route("/", get(show)).route("/", post(update));
    Ok(result)
}

#[derive(Serialize)]
struct Corpus {
    name: String,
    selected: bool,
}

async fn show(
    session: Session,
    State(app_state): State<Arc<GlobalAppState>>,
) -> Result<impl IntoResponse> {
    let selected_corpora = &session.selected_corpora();

    let corpora: Vec<_> = corpora::list(&SessionArg::Session(session.clone()), app_state.as_ref())
        .await?
        .into_iter()
        .map(|name| Corpus {
            selected: selected_corpora.contains(&name),
            name,
        })
        .collect();

    let html = app_state
        .templates
        .get_template("corpora.html")?
        .render(context! {
            corpora,
            session => session,
            filter => "",
        })?;

    Ok(Html(html))
}

#[derive(Deserialize, Debug)]
struct Params {
    filter: String,
    add_corpus: Option<String>,
    remove_corpus: Option<String>,
    add_all_corpora: Option<String>,
    clear_selection: Option<String>,
}

async fn update(
    mut session: Session,
    State(app_state): State<Arc<GlobalAppState>>,
    Form(payload): Form<Params>,
) -> Result<impl IntoResponse> {
    let corpora = corpora::list(&SessionArg::Session(session.clone()), app_state.as_ref()).await?;
    let mut filtered_corpora: Vec<_> = corpora
        .iter()
        .filter(|c| c.to_lowercase().contains(&payload.filter.to_lowercase()))
        .cloned()
        .collect();
    filtered_corpora.sort_by_key(|k| k.to_lowercase());

    let mut selected_corpora = session.selected_corpora().clone();

    if let Some(add_corpus) = payload.add_corpus {
        selected_corpora.insert(add_corpus);
    }

    if let Some(remove_corpus) = payload.remove_corpus {
        selected_corpora.remove(&remove_corpus);
    }
    if payload.add_all_corpora == Some("true".to_string()) {
        // Add all the filtered corpora to the selection
        for c in &filtered_corpora {
            selected_corpora.insert(c.clone());
        }
    }

    if payload.clear_selection == Some("true".to_string()) {
        // Unselect all corpora
        selected_corpora.clear();
    }

    // Update the session
    session.set_selected_corpora(selected_corpora)?;

    let corpora: Vec<Corpus> = filtered_corpora
        .into_iter()
        .map(|name| Corpus {
            selected: session.selected_corpora().contains(&name),
            name,
        })
        .collect();

    let html = app_state
        .templates
        .get_template("corpora.html")?
        .render(context! {
            corpora,
            filter => payload.filter,
            session => session,
        })?;

    Ok(Html(html))
}

#[cfg(test)]
mod tests;