708 lines
21 KiB
Rust
708 lines
21 KiB
Rust
use super::{PaginatedQuery, render_error};
|
|
use crate::{
|
|
assets::initial_context, check_user_blocked_or_private, get_lang, get_user_from_token, State,
|
|
};
|
|
use axum::{
|
|
extract::{Path, Query},
|
|
response::{Html, IntoResponse},
|
|
Extension,
|
|
};
|
|
use axum_extra::extract::CookieJar;
|
|
use serde::Deserialize;
|
|
use tetratto_core::model::{
|
|
auth::DefaultTimelineChoice, permissions::FinePermission, requests::ActionType, Error,
|
|
};
|
|
use std::fs::read_to_string;
|
|
use pathbufd::PathBufD;
|
|
|
|
pub async fn not_found(jar: CookieJar, Extension(data): Extension<State>) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = get_user_from_token!(jar, data.0);
|
|
Html(
|
|
render_error(
|
|
Error::GeneralNotFound("page".to_string()),
|
|
&jar,
|
|
&data,
|
|
&user,
|
|
)
|
|
.await,
|
|
)
|
|
}
|
|
|
|
/// `/`
|
|
pub async fn index_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return {
|
|
// all timeline for unauthenticated users
|
|
// i'm only changing this for stripe
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &None).await;
|
|
|
|
context.insert("page", &req.page);
|
|
Html(data.1.render("timelines/all.html", &context).unwrap())
|
|
};
|
|
}
|
|
};
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user!, data);
|
|
|
|
let list = match data
|
|
.0
|
|
.get_posts_from_user_communities(user.id, 12, req.page)
|
|
.await
|
|
{
|
|
Ok(l) => match data
|
|
.0
|
|
.fill_posts_with_community(l, user.id, &ignore_users, &Some(user.clone()))
|
|
.await
|
|
{
|
|
Ok(l) => data
|
|
.0
|
|
.posts_muted_phrase_filter(&l, Some(&user.settings.muted)),
|
|
Err(e) => return Html(render_error(e, &jar, &data, &Some(user)).await),
|
|
},
|
|
Err(e) => return Html(render_error(e, &jar, &data, &Some(user)).await),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("page", &req.page);
|
|
Html(data.1.render("timelines/home.html", &context).unwrap())
|
|
}
|
|
|
|
/// `/popular`
|
|
pub async fn popular_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = get_user_from_token!(jar, data.0);
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &user).await;
|
|
|
|
context.insert("page", &req.page);
|
|
Html(data.1.render("timelines/popular.html", &context).unwrap())
|
|
}
|
|
|
|
/// `/following`
|
|
pub async fn following_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &None).await,
|
|
));
|
|
}
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("page", &req.page);
|
|
Ok(Html(
|
|
data.1.render("timelines/following.html", &context).unwrap(),
|
|
))
|
|
}
|
|
|
|
/// `/all`
|
|
pub async fn all_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = get_user_from_token!(jar, data.0);
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &user).await;
|
|
|
|
context.insert("page", &req.page);
|
|
Html(data.1.render("timelines/all.html", &context).unwrap())
|
|
}
|
|
|
|
/// `/questions`
|
|
pub async fn index_questions_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Html(render_error(Error::NotAllowed, &jar, &data, &None).await);
|
|
}
|
|
};
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user!, data);
|
|
|
|
let list = match data
|
|
.0
|
|
.get_questions_from_user_communities(user.id, 12, req.page)
|
|
.await
|
|
{
|
|
Ok(l) => match data.0.fill_questions(l, &ignore_users).await {
|
|
Ok(l) => l,
|
|
Err(e) => return Html(render_error(e, &jar, &data, &Some(user)).await),
|
|
},
|
|
Err(e) => return Html(render_error(e, &jar, &data, &Some(user)).await),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("page", &req.page);
|
|
Html(
|
|
data.1
|
|
.render("timelines/home_questions.html", &context)
|
|
.unwrap(),
|
|
)
|
|
}
|
|
|
|
/// `/popular/questions`
|
|
pub async fn popular_questions_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Html(render_error(Error::NotAllowed, &jar, &data, &None).await);
|
|
}
|
|
};
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user!, data);
|
|
|
|
let list = match data
|
|
.0
|
|
.get_popular_global_questions(12, req.page, 604_800_000)
|
|
.await
|
|
{
|
|
Ok(l) => match data.0.fill_questions(l, &ignore_users).await {
|
|
Ok(l) => l,
|
|
Err(e) => return Html(render_error(e, &jar, &data, &Some(user)).await),
|
|
},
|
|
Err(e) => return Html(render_error(e, &jar, &data, &Some(user)).await),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("page", &req.page);
|
|
Html(
|
|
data.1
|
|
.render("timelines/popular_questions.html", &context)
|
|
.unwrap(),
|
|
)
|
|
}
|
|
|
|
/// `/following/questions`
|
|
pub async fn following_questions_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &None).await,
|
|
));
|
|
}
|
|
};
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user!, data);
|
|
|
|
let list = match data
|
|
.0
|
|
.get_questions_from_user_following(user.id, 12, req.page)
|
|
.await
|
|
{
|
|
Ok(l) => match data.0.fill_questions(l, &ignore_users).await {
|
|
Ok(l) => l,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
},
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("page", &req.page);
|
|
Ok(Html(
|
|
data.1
|
|
.render("timelines/following_questions.html", &context)
|
|
.unwrap(),
|
|
))
|
|
}
|
|
|
|
/// `/all/questions`
|
|
pub async fn all_questions_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<PaginatedQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = get_user_from_token!(jar, data.0);
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user, data);
|
|
|
|
let list = match data.0.get_latest_global_questions(12, req.page).await {
|
|
Ok(l) => match data.0.fill_questions(l, &ignore_users).await {
|
|
Ok(l) => l,
|
|
Err(e) => return Html(render_error(e, &jar, &data, &user).await),
|
|
},
|
|
Err(e) => return Html(render_error(e, &jar, &data, &user).await),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &user).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("page", &req.page);
|
|
Html(
|
|
data.1
|
|
.render("timelines/all_questions.html", &context)
|
|
.unwrap(),
|
|
)
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct NotificationsProps {
|
|
#[serde(default)]
|
|
pub id: usize,
|
|
#[serde(default)]
|
|
pub page: usize,
|
|
}
|
|
|
|
/// `/notifs`
|
|
pub async fn notifications_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(props): Query<NotificationsProps>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &None).await,
|
|
));
|
|
}
|
|
};
|
|
|
|
let profile = if props.id != 0 && user.permissions.check(FinePermission::MANAGE_NOTIFICATIONS) {
|
|
match data.0.get_user_by_id(props.id).await {
|
|
Ok(p) => p,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &None).await)),
|
|
}
|
|
} else {
|
|
user.clone()
|
|
};
|
|
|
|
let notifications = match data
|
|
.0
|
|
.get_notifications_by_owner_paginated(profile.id, 12, props.page)
|
|
.await
|
|
{
|
|
Ok(p) => p,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("page", &props.page);
|
|
context.insert("profile", &profile);
|
|
context.insert("notifications", ¬ifications);
|
|
|
|
// return
|
|
Ok(Html(
|
|
data.1.render("misc/notifications.html", &context).unwrap(),
|
|
))
|
|
}
|
|
|
|
/// `/requests`
|
|
pub async fn requests_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(props): Query<NotificationsProps>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &None).await,
|
|
));
|
|
}
|
|
};
|
|
|
|
let profile = if props.id != 0 && user.permissions.check(FinePermission::MANAGE_REQUESTS) {
|
|
match data.0.get_user_by_id(props.id).await {
|
|
Ok(p) => p,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &None).await)),
|
|
}
|
|
} else {
|
|
user.clone()
|
|
};
|
|
|
|
let requests = match data
|
|
.0
|
|
.get_requests_by_owner_paginated(
|
|
if props.id != 0 { props.id } else { user.id },
|
|
12,
|
|
props.page,
|
|
)
|
|
.await
|
|
{
|
|
Ok(p) => p,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
};
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user!, data);
|
|
|
|
let questions = match data
|
|
.0
|
|
.fill_questions(
|
|
{
|
|
let mut q = Vec::new();
|
|
|
|
for req in &requests {
|
|
if req.action_type != ActionType::Answer {
|
|
continue;
|
|
}
|
|
|
|
q.push(match data.0.get_question_by_id(req.linked_asset).await {
|
|
Ok(p) => p,
|
|
Err(_) => {
|
|
if let Err(e) = data
|
|
.0
|
|
.delete_request(req.id, req.linked_asset, &user, true)
|
|
.await
|
|
{
|
|
return Err(Html(render_error(e, &jar, &data, &Some(user)).await));
|
|
}
|
|
|
|
continue;
|
|
}
|
|
});
|
|
}
|
|
|
|
q
|
|
},
|
|
&ignore_users,
|
|
)
|
|
.await
|
|
{
|
|
Ok(q) => q,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("page", &props.page);
|
|
context.insert("profile", &profile);
|
|
context.insert("requests", &requests);
|
|
context.insert("questions", &questions);
|
|
|
|
// return
|
|
Ok(Html(data.1.render("misc/requests.html", &context).unwrap()))
|
|
}
|
|
|
|
/// `/doc/{file_name}`
|
|
pub async fn markdown_document_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Path(name): Path<String>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = get_user_from_token!(jar, data.0);
|
|
|
|
if name.contains("//") | name.contains("..") | name.starts_with("/") {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &user).await,
|
|
));
|
|
}
|
|
|
|
let path = PathBufD::current().extend(&[&data.0.0.0.dirs.docs, &name]);
|
|
let file = match read_to_string(&path) {
|
|
Ok(f) => f,
|
|
Err(e) => {
|
|
return Err(Html(
|
|
render_error(Error::MiscError(e.to_string()), &jar, &data, &user).await,
|
|
));
|
|
}
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &user).await;
|
|
context.insert("file", &file);
|
|
context.insert("file_name", &name);
|
|
|
|
// return
|
|
Ok(Html(data.1.render("misc/markdown.html", &context).unwrap()))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct SearchQuery {
|
|
#[serde(default)]
|
|
pub query: String,
|
|
#[serde(default)]
|
|
pub profile: usize,
|
|
#[serde(default)]
|
|
pub page: usize,
|
|
}
|
|
|
|
/// `/search`
|
|
pub async fn search_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(mut req): Query<SearchQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = match get_user_from_token!(jar, data.0) {
|
|
Some(ua) => ua,
|
|
None => {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &None).await,
|
|
));
|
|
}
|
|
};
|
|
|
|
if req.profile == 0 && !user.permissions.check(FinePermission::SUPPORTER) {
|
|
req.query = String::new();
|
|
}
|
|
|
|
req.query = req.query.trim().replace(" ", " & "); // change spaces into & for tsquery
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user!, data);
|
|
|
|
let list = if req.query.is_empty() {
|
|
Vec::new()
|
|
} else {
|
|
if req.profile != 0 {
|
|
match data
|
|
.0
|
|
.get_posts_by_user_searched(req.profile, 12, req.page, &req.query, &Some(&user))
|
|
.await
|
|
{
|
|
Ok(l) => match data
|
|
.0
|
|
.fill_posts_with_community(l, user.id, &ignore_users, &Some(user.clone()))
|
|
.await
|
|
{
|
|
Ok(l) => data
|
|
.0
|
|
.posts_muted_phrase_filter(&l, Some(&user.settings.muted)),
|
|
Err(_) => Vec::new(),
|
|
},
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
}
|
|
} else {
|
|
match data.0.get_posts_searched(12, req.page, &req.query).await {
|
|
Ok(l) => match data
|
|
.0
|
|
.fill_posts_with_community(l, user.id, &ignore_users, &Some(user.clone()))
|
|
.await
|
|
{
|
|
Ok(l) => data
|
|
.0
|
|
.posts_muted_phrase_filter(&l, Some(&user.settings.muted)),
|
|
Err(_) => Vec::new(),
|
|
},
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
}
|
|
}
|
|
};
|
|
|
|
let profile = if req.profile != 0 {
|
|
Some(match data.0.get_user_by_id(req.profile).await {
|
|
Ok(ua) => {
|
|
check_user_blocked_or_private!(Some(user.clone()), ua, data, jar);
|
|
ua
|
|
}
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &Some(user)).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("profile", &profile);
|
|
context.insert("query", &req.query);
|
|
context.insert("page", &req.page);
|
|
|
|
Ok(Html(
|
|
data.1.render("timelines/search.html", &context).unwrap(),
|
|
))
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct TimelineQuery {
|
|
#[serde(default)]
|
|
pub tl: DefaultTimelineChoice,
|
|
#[serde(default)]
|
|
pub page: usize,
|
|
#[serde(default)]
|
|
pub stack_id: usize,
|
|
#[serde(default)]
|
|
pub user_id: usize,
|
|
#[serde(default)]
|
|
pub tag: String,
|
|
#[serde(default)]
|
|
pub paginated: bool,
|
|
}
|
|
|
|
/// `/_swiss_army_timeline`
|
|
pub async fn swiss_army_timeline_request(
|
|
jar: CookieJar,
|
|
Extension(data): Extension<State>,
|
|
Query(req): Query<TimelineQuery>,
|
|
) -> impl IntoResponse {
|
|
let data = data.read().await;
|
|
let user = get_user_from_token!(jar, data.0);
|
|
|
|
let ignore_users = crate::ignore_users_gen!(user, data);
|
|
|
|
let list = if req.stack_id != 0 {
|
|
// stacks
|
|
if let Some(ref ua) = user {
|
|
match data
|
|
.0
|
|
.get_stack_posts(
|
|
ua.id,
|
|
req.stack_id,
|
|
12,
|
|
req.page,
|
|
&ignore_users,
|
|
&Some(ua.to_owned()),
|
|
)
|
|
.await
|
|
{
|
|
Ok(l) => l,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
|
|
}
|
|
} else {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &user).await,
|
|
));
|
|
}
|
|
} else {
|
|
match if req.user_id != 0 {
|
|
// users
|
|
let other_user = match data.0.get_user_by_id(req.user_id).await {
|
|
Ok(ua) => ua,
|
|
Err(e) => return Err(Html(render_error(e, &jar, &data, &user).await)),
|
|
};
|
|
|
|
check_user_blocked_or_private!(user, other_user, data, jar);
|
|
|
|
if req.tag.is_empty() {
|
|
data.0
|
|
.get_posts_by_user(req.user_id, 12, req.page, &user)
|
|
.await
|
|
} else {
|
|
data.0
|
|
.get_posts_by_user_tag(req.user_id, &req.tag, 12, req.page, &user)
|
|
.await
|
|
}
|
|
} else {
|
|
// everything else
|
|
match req.tl {
|
|
DefaultTimelineChoice::AllPosts => data.0.get_latest_posts(12, req.page).await,
|
|
DefaultTimelineChoice::PopularPosts => {
|
|
data.0.get_popular_posts(12, req.page, 604_800_000).await
|
|
}
|
|
DefaultTimelineChoice::FollowingPosts => {
|
|
if let Some(ref ua) = user {
|
|
data.0
|
|
.get_posts_from_user_following(ua.id, 12, req.page)
|
|
.await
|
|
} else {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &user).await,
|
|
));
|
|
}
|
|
}
|
|
DefaultTimelineChoice::MyCommunities => {
|
|
if let Some(ref ua) = user {
|
|
data.0
|
|
.get_posts_from_user_communities(ua.id, 12, req.page)
|
|
.await
|
|
} else {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &user).await,
|
|
));
|
|
}
|
|
}
|
|
// questions bad
|
|
_ => {
|
|
return Err(Html(
|
|
render_error(Error::NotAllowed, &jar, &data, &user).await,
|
|
));
|
|
}
|
|
}
|
|
} {
|
|
Ok(l) => match data
|
|
.0
|
|
.fill_posts_with_community(
|
|
l,
|
|
if let Some(ref ua) = user { ua.id } else { 0 },
|
|
&ignore_users,
|
|
&user,
|
|
)
|
|
.await
|
|
{
|
|
Ok(l) => data.0.posts_muted_phrase_filter(
|
|
&l,
|
|
if let Some(ref ua) = user {
|
|
Some(&ua.settings.muted)
|
|
} else {
|
|
None
|
|
},
|
|
),
|
|
Err(e) => return Ok(Html(render_error(e, &jar, &data, &user).await)),
|
|
},
|
|
Err(e) => return Ok(Html(render_error(e, &jar, &data, &user).await)),
|
|
}
|
|
};
|
|
|
|
let lang = get_lang!(jar, data.0);
|
|
let mut context = initial_context(&data.0.0.0, lang, &user).await;
|
|
|
|
context.insert("list", &list);
|
|
context.insert("page", &req.page);
|
|
context.insert("paginated", &req.paginated);
|
|
Ok(Html(
|
|
data.1
|
|
.render("timelines/swiss_army.html", &context)
|
|
.unwrap(),
|
|
))
|
|
}
|