Plume/src/routes/blogs.rs

163 lines
5.2 KiB
Rust
Raw Normal View History

2018-06-21 21:07:04 +00:00
use activitypub::collection::OrderedCollection;
2018-09-01 20:08:26 +00:00
use atom_syndication::{Entry, FeedBuilder};
2018-05-19 07:39:59 +00:00
use rocket::{
http::ContentType,
2018-06-24 16:58:57 +00:00
request::LenientForm,
response::{Redirect, Flash, content::Content}
2018-05-19 07:39:59 +00:00
};
use rocket_i18n::I18n;
use std::{collections::HashMap, borrow::Cow};
2018-07-06 09:51:19 +00:00
use validator::{Validate, ValidationError, ValidationErrors};
2018-04-23 10:54:37 +00:00
use plume_common::activity_pub::{ActivityStream, ApRequest};
use plume_common::utils;
use plume_models::{
2018-05-19 07:39:59 +00:00
blog_authors::*,
blogs::*,
db_conn::DbConn,
2018-05-19 07:39:59 +00:00
instance::Instance,
posts::Post,
users::User
};
use routes::Page;
use template_utils::Ructe;
use Searcher;
2018-04-23 10:54:37 +00:00
#[get("/~/<name>?<page>", rank = 2)]
pub fn details(intl: I18n, name: String, conn: DbConn, user: Option<User>, page: Option<Page>) -> Result<Ructe, Ructe> {
let page = page.unwrap_or_default();
let blog = Blog::find_by_fqn(&*conn, &name)
.ok_or_else(|| render!(errors::not_found(&(&*conn, &intl.catalog, user.clone()))))?;
let posts = Post::blog_page(&*conn, &blog, page.limits());
let articles_count = Post::count_for_blog(&*conn, &blog);
let authors = &blog.list_authors(&*conn);
Ok(render!(blogs::details(
&(&*conn, &intl.catalog, user.clone()),
blog.clone(),
blog.get_fqn(&*conn),
authors,
articles_count,
page.0,
Page::total(articles_count as i32),
user.map(|x| x.is_author_in(&*conn, &blog)).unwrap_or(false),
posts
)))
2018-04-23 10:54:37 +00:00
}
#[get("/~/<name>", rank = 1)]
pub fn activity_details(name: String, conn: DbConn, _ap: ApRequest) -> Option<ActivityStream<CustomGroup>> {
let blog = Blog::find_local(&*conn, &name)?;
Some(ActivityStream::new(blog.to_activity(&*conn)))
2018-04-23 15:09:05 +00:00
}
2018-04-23 10:54:37 +00:00
#[get("/blogs/new")]
pub fn new(user: User, conn: DbConn, intl: I18n) -> Ructe {
render!(blogs::new(
&(&*conn, &intl.catalog, Some(user)),
&NewBlogForm::default(),
ValidationErrors::default()
))
2018-04-23 10:54:37 +00:00
}
2018-06-04 19:57:03 +00:00
#[get("/blogs/new", rank = 2)]
pub fn new_auth(i18n: I18n) -> Flash<Redirect>{
utils::requires_login(
i18n!(i18n.catalog, "You need to be logged in order to create a new blog"),
uri!(new)
)
2018-06-04 19:57:03 +00:00
}
#[derive(Default, FromForm, Validate, Serialize)]
pub struct NewBlogForm {
#[validate(custom(function = "valid_slug", message = "Invalid name"))]
pub title: String,
2018-04-23 10:54:37 +00:00
}
2018-06-29 12:56:00 +00:00
fn valid_slug(title: &str) -> Result<(), ValidationError> {
let slug = utils::make_actor_id(title);
if slug.is_empty() {
2018-06-29 12:56:00 +00:00
Err(ValidationError::new("empty_slug"))
} else {
Ok(())
}
}
#[post("/blogs/new", data = "<form>")]
pub fn create(conn: DbConn, form: LenientForm<NewBlogForm>, user: User, intl: I18n) -> Result<Redirect, Ructe> {
let slug = utils::make_actor_id(&form.title);
2018-07-06 09:51:19 +00:00
let mut errors = match form.validate() {
Ok(_) => ValidationErrors::new(),
Err(e) => e
};
if Blog::find_local(&*conn, &slug).is_some() {
errors.add("title", ValidationError {
code: Cow::from("existing_slug"),
message: Some(Cow::from("A blog with the same name already exists.")),
params: HashMap::new()
});
2018-07-06 09:51:19 +00:00
}
if errors.is_empty() {
let blog = Blog::insert(&*conn, NewBlog::new_local(
2018-07-06 09:51:19 +00:00
slug.clone(),
form.title.to_string(),
String::from(""),
Instance::local_id(&*conn)
));
blog.update_boxes(&*conn);
2018-04-23 13:22:07 +00:00
BlogAuthor::insert(&*conn, NewBlogAuthor {
blog_id: blog.id,
author_id: user.id,
is_owner: true
});
Ok(Redirect::to(uri!(details: name = slug.clone(), page = _)))
2018-07-06 09:51:19 +00:00
} else {
Err(render!(blogs::new(
&(&*conn, &intl.catalog, Some(user)),
&*form,
errors
)))
}
2018-04-23 10:54:37 +00:00
}
2018-04-29 17:49:56 +00:00
2018-10-20 13:03:59 +00:00
#[post("/~/<name>/delete")]
pub fn delete(conn: DbConn, name: String, user: Option<User>, intl: I18n, searcher: Searcher) -> Result<Redirect, Option<Ructe>>{
let blog = Blog::find_local(&*conn, &name).ok_or(None)?;
if user.clone().map(|u| u.is_author_in(&*conn, &blog)).unwrap_or(false) {
blog.delete(&conn, &searcher);
2018-10-20 13:03:59 +00:00
Ok(Redirect::to(uri!(super::instance::index)))
} else {
// TODO actually return 403 error code
Err(Some(render!(errors::not_authorized(
&(&*conn, &intl.catalog, user),
"You are not allowed to delete this blog."
))))
2018-10-20 13:03:59 +00:00
}
}
2018-04-29 17:49:56 +00:00
#[get("/~/<name>/outbox")]
pub fn outbox(name: String, conn: DbConn) -> Option<ActivityStream<OrderedCollection>> {
let blog = Blog::find_local(&*conn, &name)?;
Some(blog.outbox(&*conn))
2018-04-29 17:49:56 +00:00
}
2018-09-01 20:08:26 +00:00
#[get("/~/<name>/atom.xml")]
pub fn atom_feed(name: String, conn: DbConn) -> Option<Content<String>> {
let blog = Blog::find_by_fqn(&*conn, &name)?;
2018-09-01 20:08:26 +00:00
let feed = FeedBuilder::default()
.title(blog.title.clone())
.id(Instance::get_local(&*conn).expect("blogs::atom_feed: local instance not found error")
.compute_box("~", &name, "atom.xml"))
2018-09-01 20:08:26 +00:00
.entries(Post::get_recents_for_blog(&*conn, &blog, 15)
.into_iter()
.map(|p| super::post_to_atom(p, &*conn))
.collect::<Vec<Entry>>())
.build()
.expect("blogs::atom_feed: feed creation error");
Some(Content(ContentType::new("application", "atom+xml"), feed.to_string()))
2018-09-01 20:08:26 +00:00
}