mirror of https://github.com/LemmyNet/lemmy
Add cargo feature for building lemmy_api_common with mininum deps (#2243)
parent
dd5835fb6e
commit
3aa3d75a1e
@ -0,0 +1,274 @@
|
||||
use crate::post::SiteMetadata;
|
||||
use encoding::{all::encodings, DecoderTrap};
|
||||
use lemmy_utils::{settings::structs::Settings, version::VERSION, LemmyError, REQWEST_TIMEOUT};
|
||||
use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
|
||||
use reqwest_middleware::ClientWithMiddleware;
|
||||
use serde::Deserialize;
|
||||
use tracing::info;
|
||||
use url::Url;
|
||||
use webpage::HTML;
|
||||
|
||||
/// Fetches the post link html tags (like title, description, image, etc)
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn fetch_site_metadata(
|
||||
client: &ClientWithMiddleware,
|
||||
url: &Url,
|
||||
) -> Result<SiteMetadata, LemmyError> {
|
||||
info!("Fetching site metadata for url: {}", url);
|
||||
let response = client
|
||||
.get(url.as_str())
|
||||
.timeout(REQWEST_TIMEOUT)
|
||||
.send()
|
||||
.await?;
|
||||
|
||||
// Can't use .text() here, because it only checks the content header, not the actual bytes
|
||||
// https://github.com/LemmyNet/lemmy/issues/1964
|
||||
let html_bytes = response.bytes().await.map_err(LemmyError::from)?.to_vec();
|
||||
|
||||
let tags = html_to_site_metadata(&html_bytes)?;
|
||||
|
||||
Ok(tags)
|
||||
}
|
||||
|
||||
fn html_to_site_metadata(html_bytes: &[u8]) -> Result<SiteMetadata, LemmyError> {
|
||||
let html = String::from_utf8_lossy(html_bytes);
|
||||
|
||||
// Make sure the first line is doctype html
|
||||
let first_line = html
|
||||
.trim_start()
|
||||
.lines()
|
||||
.into_iter()
|
||||
.next()
|
||||
.ok_or_else(|| LemmyError::from_message("No lines in html"))?
|
||||
.to_lowercase();
|
||||
|
||||
if !first_line.starts_with("<!doctype html>") {
|
||||
return Err(LemmyError::from_message(
|
||||
"Site metadata page fetch is not DOCTYPE html",
|
||||
));
|
||||
}
|
||||
|
||||
let mut page = HTML::from_string(html.to_string(), None)?;
|
||||
|
||||
// If the web page specifies that it isn't actually UTF-8, re-decode the received bytes with the
|
||||
// proper encoding. If the specified encoding cannot be found, fall back to the original UTF-8
|
||||
// version.
|
||||
if let Some(charset) = page.meta.get("charset") {
|
||||
if charset.to_lowercase() != "utf-8" {
|
||||
if let Some(encoding_ref) = encodings().iter().find(|e| e.name() == charset) {
|
||||
if let Ok(html_with_encoding) = encoding_ref.decode(html_bytes, DecoderTrap::Replace) {
|
||||
page = HTML::from_string(html_with_encoding, None)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let page_title = page.title;
|
||||
let page_description = page.description;
|
||||
|
||||
let og_description = page
|
||||
.opengraph
|
||||
.properties
|
||||
.get("description")
|
||||
.map(|t| t.to_string());
|
||||
let og_title = page
|
||||
.opengraph
|
||||
.properties
|
||||
.get("title")
|
||||
.map(|t| t.to_string());
|
||||
let og_image = page
|
||||
.opengraph
|
||||
.images
|
||||
.get(0)
|
||||
.and_then(|ogo| Url::parse(&ogo.url).ok());
|
||||
|
||||
let title = og_title.or(page_title);
|
||||
let description = og_description.or(page_description);
|
||||
let image = og_image;
|
||||
|
||||
Ok(SiteMetadata {
|
||||
title,
|
||||
description,
|
||||
image,
|
||||
html: None,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Debug, Clone)]
|
||||
pub(crate) struct PictrsResponse {
|
||||
files: Vec<PictrsFile>,
|
||||
msg: String,
|
||||
}
|
||||
|
||||
#[derive(Deserialize, Debug, Clone)]
|
||||
pub(crate) struct PictrsFile {
|
||||
file: String,
|
||||
#[allow(dead_code)]
|
||||
delete_token: String,
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub(crate) async fn fetch_pictrs(
|
||||
client: &ClientWithMiddleware,
|
||||
settings: &Settings,
|
||||
image_url: &Url,
|
||||
) -> Result<PictrsResponse, LemmyError> {
|
||||
if let Some(pictrs_url) = settings.pictrs_url.to_owned() {
|
||||
is_image_content_type(client, image_url).await?;
|
||||
|
||||
let fetch_url = format!(
|
||||
"{}/image/download?url={}",
|
||||
pictrs_url,
|
||||
utf8_percent_encode(image_url.as_str(), NON_ALPHANUMERIC) // TODO this might not be needed
|
||||
);
|
||||
|
||||
let response = client
|
||||
.get(&fetch_url)
|
||||
.timeout(REQWEST_TIMEOUT)
|
||||
.send()
|
||||
.await?;
|
||||
|
||||
let response: PictrsResponse = response.json().await.map_err(LemmyError::from)?;
|
||||
|
||||
if response.msg == "ok" {
|
||||
Ok(response)
|
||||
} else {
|
||||
Err(LemmyError::from_message(&response.msg))
|
||||
}
|
||||
} else {
|
||||
Err(LemmyError::from_message("pictrs_url not set up in config"))
|
||||
}
|
||||
}
|
||||
|
||||
/// Both are options, since the URL might be either an html page, or an image
|
||||
/// Returns the SiteMetadata, and a Pictrs URL, if there is a picture associated
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn fetch_site_data(
|
||||
client: &ClientWithMiddleware,
|
||||
settings: &Settings,
|
||||
url: Option<&Url>,
|
||||
) -> (Option<SiteMetadata>, Option<Url>) {
|
||||
match &url {
|
||||
Some(url) => {
|
||||
// Fetch metadata
|
||||
// Ignore errors, since it may be an image, or not have the data.
|
||||
// Warning, this may ignore SSL errors
|
||||
let metadata_option = fetch_site_metadata(client, url).await.ok();
|
||||
|
||||
// Fetch pictrs thumbnail
|
||||
let pictrs_hash = match &metadata_option {
|
||||
Some(metadata_res) => match &metadata_res.image {
|
||||
// Metadata, with image
|
||||
// Try to generate a small thumbnail if there's a full sized one from post-links
|
||||
Some(metadata_image) => fetch_pictrs(client, settings, metadata_image)
|
||||
.await
|
||||
.map(|r| r.files[0].file.to_owned()),
|
||||
// Metadata, but no image
|
||||
None => fetch_pictrs(client, settings, url)
|
||||
.await
|
||||
.map(|r| r.files[0].file.to_owned()),
|
||||
},
|
||||
// No metadata, try to fetch the URL as an image
|
||||
None => fetch_pictrs(client, settings, url)
|
||||
.await
|
||||
.map(|r| r.files[0].file.to_owned()),
|
||||
};
|
||||
|
||||
// The full urls are necessary for federation
|
||||
let pictrs_thumbnail = pictrs_hash
|
||||
.map(|p| {
|
||||
Url::parse(&format!(
|
||||
"{}/pictrs/image/{}",
|
||||
settings.get_protocol_and_hostname(),
|
||||
p
|
||||
))
|
||||
.ok()
|
||||
})
|
||||
.ok()
|
||||
.flatten();
|
||||
|
||||
(metadata_option, pictrs_thumbnail)
|
||||
}
|
||||
None => (None, None),
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
async fn is_image_content_type(client: &ClientWithMiddleware, url: &Url) -> Result<(), LemmyError> {
|
||||
let response = client
|
||||
.get(url.as_str())
|
||||
.timeout(REQWEST_TIMEOUT)
|
||||
.send()
|
||||
.await?;
|
||||
if response
|
||||
.headers()
|
||||
.get("Content-Type")
|
||||
.ok_or_else(|| LemmyError::from_message("No Content-Type header"))?
|
||||
.to_str()?
|
||||
.starts_with("image/")
|
||||
{
|
||||
Ok(())
|
||||
} else {
|
||||
Err(LemmyError::from_message("Not an image type."))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build_user_agent(settings: &Settings) -> String {
|
||||
format!(
|
||||
"Lemmy/{}; +{}",
|
||||
VERSION,
|
||||
settings.get_protocol_and_hostname()
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::request::{build_user_agent, fetch_site_metadata, SiteMetadata};
|
||||
use lemmy_utils::settings::structs::Settings;
|
||||
use url::Url;
|
||||
|
||||
// These helped with testing
|
||||
#[actix_rt::test]
|
||||
async fn test_site_metadata() {
|
||||
let settings = Settings::init().unwrap();
|
||||
let client = reqwest::Client::builder()
|
||||
.user_agent(build_user_agent(&settings))
|
||||
.build()
|
||||
.unwrap()
|
||||
.into();
|
||||
let sample_url = Url::parse("https://gitlab.com/IzzyOnDroid/repo/-/wikis/FAQ").unwrap();
|
||||
let sample_res = fetch_site_metadata(&client, &sample_url).await.unwrap();
|
||||
assert_eq!(
|
||||
SiteMetadata {
|
||||
title: Some("FAQ · Wiki · IzzyOnDroid / repo · GitLab".to_string()),
|
||||
description: Some(
|
||||
"The F-Droid compatible repo at https://apt.izzysoft.de/fdroid/".to_string()
|
||||
),
|
||||
image: Some(
|
||||
Url::parse("https://gitlab.com/uploads/-/system/project/avatar/4877469/iod_logo.png")
|
||||
.unwrap()
|
||||
),
|
||||
html: None,
|
||||
},
|
||||
sample_res
|
||||
);
|
||||
|
||||
let youtube_url = Url::parse("https://www.youtube.com/watch?v=IquO_TcMZIQ").unwrap();
|
||||
let youtube_res = fetch_site_metadata(&client, &youtube_url).await.unwrap();
|
||||
assert_eq!(
|
||||
SiteMetadata {
|
||||
title: Some("A Hard Look at Rent and Rent Seeking with Michael Hudson & Pepe Escobar".to_string()),
|
||||
description: Some("An interactive discussion on wealth inequality and the “Great Game” on the control of natural resources.In this webinar organized jointly by the Henry George...".to_string()),
|
||||
image: Some(Url::parse("https://i.ytimg.com/vi/IquO_TcMZIQ/maxresdefault.jpg").unwrap()),
|
||||
html: None,
|
||||
}, youtube_res);
|
||||
}
|
||||
|
||||
// #[test]
|
||||
// fn test_pictshare() {
|
||||
// let res = fetch_pictshare("https://upload.wikimedia.org/wikipedia/en/2/27/The_Mandalorian_logo.jpg");
|
||||
// assert!(res.is_ok());
|
||||
// let res_other = fetch_pictshare("https://upload.wikimedia.org/wikipedia/en/2/27/The_Mandalorian_logo.jpgaoeu");
|
||||
// assert!(res_other.is_err());
|
||||
// }
|
||||
}
|
@ -0,0 +1,605 @@
|
||||
use crate::{sensitive::Sensitive, site::FederatedInstances};
|
||||
use lemmy_db_schema::{
|
||||
newtypes::{CommunityId, DbUrl, LocalUserId, PersonId, PostId},
|
||||
source::{
|
||||
comment::Comment,
|
||||
community::Community,
|
||||
email_verification::{EmailVerification, EmailVerificationForm},
|
||||
password_reset_request::PasswordResetRequest,
|
||||
person::Person,
|
||||
person_block::PersonBlock,
|
||||
post::{Post, PostRead, PostReadForm},
|
||||
registration_application::RegistrationApplication,
|
||||
secret::Secret,
|
||||
site::Site,
|
||||
},
|
||||
traits::{Crud, Readable},
|
||||
utils::DbPool,
|
||||
};
|
||||
use lemmy_db_views::{
|
||||
comment_view::CommentQueryBuilder,
|
||||
structs::{LocalUserSettingsView, LocalUserView},
|
||||
};
|
||||
use lemmy_db_views_actor::structs::{
|
||||
CommunityModeratorView,
|
||||
CommunityPersonBanView,
|
||||
CommunityView,
|
||||
};
|
||||
use lemmy_utils::{
|
||||
claims::Claims,
|
||||
email::{send_email, translations::Lang},
|
||||
settings::structs::Settings,
|
||||
utils::generate_random_string,
|
||||
LemmyError,
|
||||
};
|
||||
use rosetta_i18n::{Language, LanguageId};
|
||||
use tracing::warn;
|
||||
|
||||
pub async fn blocking<F, T>(pool: &DbPool, f: F) -> Result<T, LemmyError>
|
||||
where
|
||||
F: FnOnce(&diesel::PgConnection) -> T + Send + 'static,
|
||||
T: Send + 'static,
|
||||
{
|
||||
let pool = pool.clone();
|
||||
let blocking_span = tracing::info_span!("blocking operation");
|
||||
let res = actix_web::web::block(move || {
|
||||
let entered = blocking_span.enter();
|
||||
let conn = pool.get()?;
|
||||
let res = (f)(&conn);
|
||||
drop(entered);
|
||||
Ok(res) as Result<T, LemmyError>
|
||||
})
|
||||
.await?;
|
||||
|
||||
res
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn is_mod_or_admin(
|
||||
pool: &DbPool,
|
||||
person_id: PersonId,
|
||||
community_id: CommunityId,
|
||||
) -> Result<(), LemmyError> {
|
||||
let is_mod_or_admin = blocking(pool, move |conn| {
|
||||
CommunityView::is_mod_or_admin(conn, person_id, community_id)
|
||||
})
|
||||
.await?;
|
||||
if !is_mod_or_admin {
|
||||
return Err(LemmyError::from_message("not_a_mod_or_admin"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn is_admin(local_user_view: &LocalUserView) -> Result<(), LemmyError> {
|
||||
if !local_user_view.person.admin {
|
||||
return Err(LemmyError::from_message("not_an_admin"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn get_post(post_id: PostId, pool: &DbPool) -> Result<Post, LemmyError> {
|
||||
blocking(pool, move |conn| Post::read(conn, post_id))
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_post"))
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn mark_post_as_read(
|
||||
person_id: PersonId,
|
||||
post_id: PostId,
|
||||
pool: &DbPool,
|
||||
) -> Result<PostRead, LemmyError> {
|
||||
let post_read_form = PostReadForm { post_id, person_id };
|
||||
|
||||
blocking(pool, move |conn| {
|
||||
PostRead::mark_as_read(conn, &post_read_form)
|
||||
})
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read"))
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn mark_post_as_unread(
|
||||
person_id: PersonId,
|
||||
post_id: PostId,
|
||||
pool: &DbPool,
|
||||
) -> Result<usize, LemmyError> {
|
||||
let post_read_form = PostReadForm { post_id, person_id };
|
||||
|
||||
blocking(pool, move |conn| {
|
||||
PostRead::mark_as_unread(conn, &post_read_form)
|
||||
})
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_mark_post_as_read"))
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn get_local_user_view_from_jwt(
|
||||
jwt: &str,
|
||||
pool: &DbPool,
|
||||
secret: &Secret,
|
||||
) -> Result<LocalUserView, LemmyError> {
|
||||
let claims = Claims::decode(jwt, &secret.jwt_secret)
|
||||
.map_err(|e| e.with_message("not_logged_in"))?
|
||||
.claims;
|
||||
let local_user_id = LocalUserId(claims.sub);
|
||||
let local_user_view =
|
||||
blocking(pool, move |conn| LocalUserView::read(conn, local_user_id)).await??;
|
||||
// Check for a site ban
|
||||
if local_user_view.person.is_banned() {
|
||||
return Err(LemmyError::from_message("site_ban"));
|
||||
}
|
||||
|
||||
// Check for user deletion
|
||||
if local_user_view.person.deleted {
|
||||
return Err(LemmyError::from_message("deleted"));
|
||||
}
|
||||
|
||||
check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
|
||||
|
||||
Ok(local_user_view)
|
||||
}
|
||||
|
||||
/// Checks if user's token was issued before user's password reset.
|
||||
pub fn check_validator_time(
|
||||
validator_time: &chrono::NaiveDateTime,
|
||||
claims: &Claims,
|
||||
) -> Result<(), LemmyError> {
|
||||
let user_validation_time = validator_time.timestamp();
|
||||
if user_validation_time > claims.iat {
|
||||
Err(LemmyError::from_message("not_logged_in"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn get_local_user_view_from_jwt_opt(
|
||||
jwt: Option<&Sensitive<String>>,
|
||||
pool: &DbPool,
|
||||
secret: &Secret,
|
||||
) -> Result<Option<LocalUserView>, LemmyError> {
|
||||
match jwt {
|
||||
Some(jwt) => Ok(Some(get_local_user_view_from_jwt(jwt, pool, secret).await?)),
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn get_local_user_settings_view_from_jwt(
|
||||
jwt: &Sensitive<String>,
|
||||
pool: &DbPool,
|
||||
secret: &Secret,
|
||||
) -> Result<LocalUserSettingsView, LemmyError> {
|
||||
let claims = Claims::decode(jwt.as_ref(), &secret.jwt_secret)
|
||||
.map_err(|e| e.with_message("not_logged_in"))?
|
||||
.claims;
|
||||
let local_user_id = LocalUserId(claims.sub);
|
||||
let local_user_view = blocking(pool, move |conn| {
|
||||
LocalUserSettingsView::read(conn, local_user_id)
|
||||
})
|
||||
.await??;
|
||||
// Check for a site ban
|
||||
if local_user_view.person.is_banned() {
|
||||
return Err(LemmyError::from_message("site_ban"));
|
||||
}
|
||||
|
||||
check_validator_time(&local_user_view.local_user.validator_time, &claims)?;
|
||||
|
||||
Ok(local_user_view)
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn get_local_user_settings_view_from_jwt_opt(
|
||||
jwt: Option<&Sensitive<String>>,
|
||||
pool: &DbPool,
|
||||
secret: &Secret,
|
||||
) -> Result<Option<LocalUserSettingsView>, LemmyError> {
|
||||
match jwt {
|
||||
Some(jwt) => Ok(Some(
|
||||
get_local_user_settings_view_from_jwt(jwt, pool, secret).await?,
|
||||
)),
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn check_community_ban(
|
||||
person_id: PersonId,
|
||||
community_id: CommunityId,
|
||||
pool: &DbPool,
|
||||
) -> Result<(), LemmyError> {
|
||||
let is_banned =
|
||||
move |conn: &'_ _| CommunityPersonBanView::get(conn, person_id, community_id).is_ok();
|
||||
if blocking(pool, is_banned).await? {
|
||||
Err(LemmyError::from_message("community_ban"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn check_community_deleted_or_removed(
|
||||
community_id: CommunityId,
|
||||
pool: &DbPool,
|
||||
) -> Result<(), LemmyError> {
|
||||
let community = blocking(pool, move |conn| Community::read(conn, community_id))
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_find_community"))?;
|
||||
if community.deleted || community.removed {
|
||||
Err(LemmyError::from_message("deleted"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn check_post_deleted_or_removed(post: &Post) -> Result<(), LemmyError> {
|
||||
if post.deleted || post.removed {
|
||||
Err(LemmyError::from_message("deleted"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn check_person_block(
|
||||
my_id: PersonId,
|
||||
potential_blocker_id: PersonId,
|
||||
pool: &DbPool,
|
||||
) -> Result<(), LemmyError> {
|
||||
let is_blocked = move |conn: &'_ _| PersonBlock::read(conn, potential_blocker_id, my_id).is_ok();
|
||||
if blocking(pool, is_blocked).await? {
|
||||
Err(LemmyError::from_message("person_block"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn check_downvotes_enabled(score: i16, pool: &DbPool) -> Result<(), LemmyError> {
|
||||
if score == -1 {
|
||||
let site = blocking(pool, Site::read_local_site).await??;
|
||||
if !site.enable_downvotes {
|
||||
return Err(LemmyError::from_message("downvotes_disabled"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn check_private_instance(
|
||||
local_user_view: &Option<LocalUserView>,
|
||||
pool: &DbPool,
|
||||
) -> Result<(), LemmyError> {
|
||||
if local_user_view.is_none() {
|
||||
let site = blocking(pool, Site::read_local_site).await?;
|
||||
|
||||
// The site might not be set up yet
|
||||
if let Ok(site) = site {
|
||||
if site.private_instance {
|
||||
return Err(LemmyError::from_message("instance_is_private"));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tracing::instrument(skip_all)]
|
||||
pub async fn build_federated_instances(
|
||||
pool: &DbPool,
|
||||
settings: &Settings,
|
||||
) -> Result<Option<FederatedInstances>, LemmyError> {
|
||||
let federation_config = &settings.federation;
|
||||
let hostname = &settings.hostname;
|
||||
let federation = federation_config.to_owned();
|
||||
if federation.enabled {
|
||||
let distinct_communities = blocking(pool, move |conn| {
|
||||
Community::distinct_federated_communities(conn)
|
||||
})
|
||||
.await??;
|
||||
|
||||
let allowed = federation.allowed_instances;
|
||||
let blocked = federation.blocked_instances;
|
||||
|
||||
let mut linked = distinct_communities
|
||||
.iter()
|
||||
.map(|actor_id| Ok(actor_id.host_str().unwrap_or("").to_string()))
|
||||
.collect::<Result<Vec<String>, LemmyError>>()?;
|
||||
|
||||
if let Some(allowed) = allowed.as_ref() {
|
||||
linked.extend_from_slice(allowed);
|
||||
}
|
||||
|
||||
if let Some(blocked) = blocked.as_ref() {
|
||||
linked.retain(|a| !blocked.contains(a) && !a.eq(hostname));
|
||||
}
|
||||
|
||||
// Sort and remove dupes
|
||||
linked.sort_unstable();
|
||||
linked.dedup();
|
||||
|
||||
Ok(Some(FederatedInstances {
|
||||
linked,
|
||||
allowed,
|
||||
blocked,
|
||||
}))
|
||||
} else {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks the password length
|
||||
pub fn password_length_check(pass: &str) -> Result<(), LemmyError> {
|
||||
if !(10..=60).contains(&pass.len()) {
|
||||
Err(LemmyError::from_message("invalid_password"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks the site description length
|
||||
pub fn site_description_length_check(description: &str) -> Result<(), LemmyError> {
|
||||
if description.len() > 150 {
|
||||
Err(LemmyError::from_message("site_description_length_overflow"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks for a honeypot. If this field is filled, fail the rest of the function
|
||||
pub fn honeypot_check(honeypot: &Option<String>) -> Result<(), LemmyError> {
|
||||
if honeypot.is_some() {
|
||||
Err(LemmyError::from_message("honeypot_fail"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn send_email_to_user(
|
||||
local_user_view: &LocalUserView,
|
||||
subject: &str,
|
||||
body: &str,
|
||||
settings: &Settings,
|
||||
) {
|
||||
if local_user_view.person.banned || !local_user_view.local_user.send_notifications_to_email {
|
||||
return;
|
||||
}
|
||||
|
||||
if let Some(user_email) = &local_user_view.local_user.email {
|
||||
match send_email(
|
||||
subject,
|
||||
user_email,
|
||||
&local_user_view.person.name,
|
||||
body,
|
||||
settings,
|
||||
) {
|
||||
Ok(_o) => _o,
|
||||
Err(e) => warn!("{}", e),
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn send_password_reset_email(
|
||||
user: &LocalUserView,
|
||||
pool: &DbPool,
|
||||
settings: &Settings,
|
||||
) -> Result<(), LemmyError> {
|
||||
// Generate a random token
|
||||
let token = generate_random_string();
|
||||
|
||||
// Insert the row
|
||||
let token2 = token.clone();
|
||||
let local_user_id = user.local_user.id;
|
||||
blocking(pool, move |conn| {
|
||||
PasswordResetRequest::create_token(conn, local_user_id, &token2)
|
||||
})
|
||||
.await??;
|
||||
|
||||
let email = &user.local_user.email.to_owned().expect("email");
|
||||
let lang = get_user_lang(user);
|
||||
let subject = &lang.password_reset_subject(&user.person.name);
|
||||
let protocol_and_hostname = settings.get_protocol_and_hostname();
|
||||
let reset_link = format!("{}/password_change/{}", protocol_and_hostname, &token);
|
||||
let body = &lang.password_reset_body(&user.person.name, reset_link);
|
||||
send_email(subject, email, &user.person.name, body, settings)
|
||||
}
|
||||
|
||||
/// Send a verification email
|
||||
pub async fn send_verification_email(
|
||||
user: &LocalUserView,
|
||||
new_email: &str,
|
||||
pool: &DbPool,
|
||||
settings: &Settings,
|
||||
) -> Result<(), LemmyError> {
|
||||
let form = EmailVerificationForm {
|
||||
local_user_id: user.local_user.id,
|
||||
email: new_email.to_string(),
|
||||
verification_token: generate_random_string(),
|
||||
};
|
||||
let verify_link = format!(
|
||||
"{}/verify_email/{}",
|
||||
settings.get_protocol_and_hostname(),
|
||||
&form.verification_token
|
||||
);
|
||||
blocking(pool, move |conn| EmailVerification::create(conn, &form)).await??;
|
||||
|
||||
let lang = get_user_lang(user);
|
||||
let subject = lang.verify_email_subject(&settings.hostname);
|
||||
let body = lang.verify_email_body(&user.person.name, &settings.hostname, verify_link);
|
||||
send_email(&subject, new_email, &user.person.name, &body, settings)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn send_email_verification_success(
|
||||
user: &LocalUserView,
|
||||
settings: &Settings,
|
||||
) -> Result<(), LemmyError> {
|
||||
let email = &user.local_user.email.to_owned().expect("email");
|
||||
let lang = get_user_lang(user);
|
||||
let subject = &lang.email_verified_subject(&user.person.actor_id);
|
||||
let body = &lang.email_verified_body();
|
||||
send_email(subject, email, &user.person.name, body, settings)
|
||||
}
|
||||
|
||||
pub fn get_user_lang(user: &LocalUserView) -> Lang {
|
||||
let user_lang = LanguageId::new(user.local_user.lang.clone());
|
||||
Lang::from_language_id(&user_lang).unwrap_or_else(|| {
|
||||
let en = LanguageId::new("en");
|
||||
Lang::from_language_id(&en).expect("default language")
|
||||
})
|
||||
}
|
||||
|
||||
pub fn send_application_approved_email(
|
||||
user: &LocalUserView,
|
||||
settings: &Settings,
|
||||
) -> Result<(), LemmyError> {
|
||||
let email = &user.local_user.email.to_owned().expect("email");
|
||||
let lang = get_user_lang(user);
|
||||
let subject = lang.registration_approved_subject(&user.person.actor_id);
|
||||
let body = lang.registration_approved_body(&settings.hostname);
|
||||
send_email(&subject, email, &user.person.name, &body, settings)
|
||||
}
|
||||
|
||||
pub async fn check_registration_application(
|
||||
site: &Site,
|
||||
local_user_view: &LocalUserView,
|
||||
pool: &DbPool,
|
||||
) -> Result<(), LemmyError> {
|
||||
if site.require_application
|
||||
&& !local_user_view.local_user.accepted_application
|
||||
&& !local_user_view.person.admin
|
||||
{
|
||||
// Fetch the registration, see if its denied
|
||||
let local_user_id = local_user_view.local_user.id;
|
||||
let registration = blocking(pool, move |conn| {
|
||||
RegistrationApplication::find_by_local_user_id(conn, local_user_id)
|
||||
})
|
||||
.await??;
|
||||
if let Some(deny_reason) = registration.deny_reason {
|
||||
let lang = get_user_lang(local_user_view);
|
||||
let registration_denied_message = format!("{}: {}", lang.registration_denied(), &deny_reason);
|
||||
return Err(LemmyError::from_message(®istration_denied_message));
|
||||
} else {
|
||||
return Err(LemmyError::from_message("registration_application_pending"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// TODO this check should be removed after https://github.com/LemmyNet/lemmy/issues/868 is done.
|
||||
pub async fn check_private_instance_and_federation_enabled(
|
||||
pool: &DbPool,
|
||||
settings: &Settings,
|
||||
) -> Result<(), LemmyError> {
|
||||
let site_opt = blocking(pool, Site::read_local_site).await?;
|
||||
|
||||
if let Ok(site) = site_opt {
|
||||
if site.private_instance && settings.federation.enabled {
|
||||
return Err(LemmyError::from_message(
|
||||
"Cannot have both private instance and federation enabled.",
|
||||
));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn remove_user_data(banned_person_id: PersonId, pool: &DbPool) -> Result<(), LemmyError> {
|
||||
// Posts
|
||||
blocking(pool, move |conn: &'_ _| {
|
||||
Post::update_removed_for_creator(conn, banned_person_id, None, true)
|
||||
})
|
||||
.await??;
|
||||
|
||||
// Communities
|
||||
// Remove all communities where they're the top mod
|
||||
// for now, remove the communities manually
|
||||
let first_mod_communities = blocking(pool, move |conn: &'_ _| {
|
||||
CommunityModeratorView::get_community_first_mods(conn)
|
||||
})
|
||||
.await??;
|
||||
|
||||
// Filter to only this banned users top communities
|
||||
let banned_user_first_communities: Vec<CommunityModeratorView> = first_mod_communities
|
||||
.into_iter()
|
||||
.filter(|fmc| fmc.moderator.id == banned_person_id)
|
||||
.collect();
|
||||
|
||||
for first_mod_community in banned_user_first_communities {
|
||||
blocking(pool, move |conn: &'_ _| {
|
||||
Community::update_removed(conn, first_mod_community.community.id, true)
|
||||
})
|
||||
.await??;
|
||||
}
|
||||
|
||||
// Comments
|
||||
blocking(pool, move |conn: &'_ _| {
|
||||
Comment::update_removed_for_creator(conn, banned_person_id, true)
|
||||
})
|
||||
.await??;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn remove_user_data_in_community(
|
||||
community_id: CommunityId,
|
||||
banned_person_id: PersonId,
|
||||
pool: &DbPool,
|
||||
) -> Result<(), LemmyError> {
|
||||
// Posts
|
||||
blocking(pool, move |conn| {
|
||||
Post::update_removed_for_creator(conn, banned_person_id, Some(community_id), true)
|
||||
})
|
||||
.await??;
|
||||
|
||||
// Comments
|
||||
// TODO Diesel doesn't allow updates with joins, so this has to be a loop
|
||||
let comments = blocking(pool, move |conn| {
|
||||
CommentQueryBuilder::create(conn)
|
||||
.creator_id(banned_person_id)
|
||||
.community_id(community_id)
|
||||
.limit(std::i64::MAX)
|
||||
.list()
|
||||
})
|
||||
.await??;
|
||||
|
||||
for comment_view in &comments {
|
||||
let comment_id = comment_view.comment.id;
|
||||
blocking(pool, move |conn| {
|
||||
Comment::update_removed(conn, comment_id, true)
|
||||
})
|
||||
.await??;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn delete_user_account(person_id: PersonId, pool: &DbPool) -> Result<(), LemmyError> {
|
||||
// Comments
|
||||
let permadelete = move |conn: &'_ _| Comment::permadelete_for_creator(conn, person_id);
|
||||
blocking(pool, permadelete)
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
|
||||
|
||||
// Posts
|
||||
let permadelete = move |conn: &'_ _| Post::permadelete_for_creator(conn, person_id);
|
||||
blocking(pool, permadelete)
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_post"))?;
|
||||
|
||||
blocking(pool, move |conn| Person::delete_account(conn, person_id)).await??;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn check_image_has_local_domain(url: &Option<DbUrl>) -> Result<(), LemmyError> {
|
||||
if let Some(url) = url {
|
||||
let settings = Settings::get();
|
||||
let domain = url.domain().expect("url has domain");
|
||||
if domain != settings.hostname {
|
||||
return Err(LemmyError::from_message("image_not_local"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
@ -0,0 +1,121 @@
|
||||
use crate::PerformCrud;
|
||||
use actix_web::web::Data;
|
||||
use lemmy_api_common::{
|
||||
comment::{CommentResponse, RemoveComment},
|
||||
utils::{blocking, check_community_ban, get_local_user_view_from_jwt, is_mod_or_admin},
|
||||
};
|
||||
use lemmy_apub::activities::deletion::{send_apub_delete_in_community, DeletableObjects};
|
||||
use lemmy_db_schema::{
|
||||
source::{
|
||||
comment::Comment,
|
||||
community::Community,
|
||||
moderator::{ModRemoveComment, ModRemoveCommentForm},
|
||||
post::Post,
|
||||
},
|
||||
traits::Crud,
|
||||
};
|
||||
use lemmy_db_views::structs::CommentView;
|
||||
use lemmy_utils::{ConnectionId, LemmyError};
|
||||
use lemmy_websocket::{
|
||||
send::{send_comment_ws_message, send_local_notifs},
|
||||
LemmyContext,
|
||||
UserOperationCrud,
|
||||
};
|
||||
|
||||
#[async_trait::async_trait(?Send)]
|
||||
impl PerformCrud for RemoveComment {
|
||||
type Response = CommentResponse;
|
||||
|
||||
#[tracing::instrument(skip(context, websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
websocket_id: Option<ConnectionId>,
|
||||
) -> Result<CommentResponse, LemmyError> {
|
||||
let data: &RemoveComment = self;
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
|
||||
|
||||
let comment_id = data.comment_id;
|
||||
let orig_comment = blocking(context.pool(), move |conn| {
|
||||
CommentView::read(conn, comment_id, None)
|
||||
})
|
||||
.await??;
|
||||
|
||||
check_community_ban(
|
||||
local_user_view.person.id,
|
||||
orig_comment.community.id,
|
||||
context.pool(),
|
||||
)
|
||||
.await?;
|
||||
|
||||
// Verify that only a mod or admin can remove
|
||||
is_mod_or_admin(
|
||||
context.pool(),
|
||||
local_user_view.person.id,
|
||||
orig_comment.community.id,
|
||||
)
|
||||
.await?;
|
||||
|
||||
// Do the remove
|
||||
let removed = data.removed;
|
||||
let updated_comment = blocking(context.pool(), move |conn| {
|
||||
Comment::update_removed(conn, comment_id, removed)
|
||||
})
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_comment"))?;
|
||||
|
||||
// Mod tables
|
||||
let form = ModRemoveCommentForm {
|
||||
mod_person_id: local_user_view.person.id,
|
||||
comment_id: data.comment_id,
|
||||
removed: Some(removed),
|
||||
reason: data.reason.to_owned(),
|
||||
};
|
||||
blocking(context.pool(), move |conn| {
|
||||
ModRemoveComment::create(conn, &form)
|
||||
})
|
||||
.await??;
|
||||
|
||||
let post_id = updated_comment.post_id;
|
||||
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
|
||||
let recipient_ids = send_local_notifs(
|
||||
vec![],
|
||||
&updated_comment,
|
||||
&local_user_view.person.clone(),
|
||||
&post,
|
||||
false,
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let res = send_comment_ws_message(
|
||||
data.comment_id,
|
||||
UserOperationCrud::RemoveComment,
|
||||
websocket_id,
|
||||
None, // TODO maybe this might clear other forms
|
||||
Some(local_user_view.person.id),
|
||||
recipient_ids,
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
|
||||
// Send the apub message
|
||||
let community = blocking(context.pool(), move |conn| {
|
||||
Community::read(conn, orig_comment.post.community_id)
|
||||
})
|
||||
.await??;
|
||||
let deletable = DeletableObjects::Comment(Box::new(updated_comment.clone().into()));
|
||||
send_apub_delete_in_community(
|
||||
local_user_view.person,
|
||||
community,
|
||||
deletable,
|
||||
data.reason.clone().or_else(|| Some("".to_string())),
|
||||
removed,
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
|
||||
Ok(res)
|
||||
}
|
||||
}
|
@ -0,0 +1,80 @@
|
||||
use crate::PerformCrud;
|
||||
use actix_web::web::Data;
|
||||
use lemmy_api_common::{
|
||||
community::{CommunityResponse, RemoveCommunity},
|
||||
utils::{blocking, get_local_user_view_from_jwt, is_admin},
|
||||
};
|
||||
use lemmy_apub::activities::deletion::{send_apub_delete_in_community, DeletableObjects};
|
||||
use lemmy_db_schema::{
|
||||
source::{
|
||||
community::Community,
|
||||
moderator::{ModRemoveCommunity, ModRemoveCommunityForm},
|
||||
},
|
||||
traits::Crud,
|
||||
};
|
||||
use lemmy_utils::{utils::naive_from_unix, ConnectionId, LemmyError};
|
||||
use lemmy_websocket::{send::send_community_ws_message, LemmyContext, UserOperationCrud};
|
||||
|
||||
#[async_trait::async_trait(?Send)]
|
||||
impl PerformCrud for RemoveCommunity {
|
||||
type Response = CommunityResponse;
|
||||
|
||||
#[tracing::instrument(skip(context, websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
websocket_id: Option<ConnectionId>,
|
||||
) -> Result<CommunityResponse, LemmyError> {
|
||||
let data: &RemoveCommunity = self;
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
|
||||
|
||||
// Verify its an admin (only an admin can remove a community)
|
||||
is_admin(&local_user_view)?;
|
||||
|
||||
// Do the remove
|
||||
let community_id = data.community_id;
|
||||
let removed = data.removed;
|
||||
let updated_community = blocking(context.pool(), move |conn| {
|
||||
Community::update_removed(conn, community_id, removed)
|
||||
})
|
||||
.await?
|
||||
.map_err(|e| LemmyError::from_error_message(e, "couldnt_update_community"))?;
|
||||
|
||||
// Mod tables
|
||||
let expires = data.expires.map(naive_from_unix);
|
||||
let form = ModRemoveCommunityForm {
|
||||
mod_person_id: local_user_view.person.id,
|
||||
community_id: data.community_id,
|
||||
removed: Some(removed),
|
||||
reason: data.reason.to_owned(),
|
||||
expires,
|
||||
};
|
||||
blocking(context.pool(), move |conn| {
|
||||
ModRemoveCommunity::create(conn, &form)
|
||||
})
|
||||
.await??;
|
||||
|
||||
let res = send_community_ws_message(
|
||||
data.community_id,
|
||||
UserOperationCrud::RemoveCommunity,
|
||||
websocket_id,
|
||||
Some(local_user_view.person.id),
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
|
||||
// Apub messages
|
||||
let deletable = DeletableObjects::Community(Box::new(updated_community.clone().into()));
|
||||
send_apub_delete_in_community(
|
||||
local_user_view.person,
|
||||
updated_community,
|
||||
deletable,
|
||||
data.reason.clone().or_else(|| Some("".to_string())),
|
||||
removed,
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
Ok(res)
|
||||
}
|
||||
}
|
@ -0,0 +1,97 @@
|
||||
use crate::PerformCrud;
|
||||
use actix_web::web::Data;
|
||||
use lemmy_api_common::{
|
||||
post::{PostResponse, RemovePost},
|
||||
utils::{blocking, check_community_ban, get_local_user_view_from_jwt, is_mod_or_admin},
|
||||
};
|
||||
use lemmy_apub::activities::deletion::{send_apub_delete_in_community, DeletableObjects};
|
||||
use lemmy_db_schema::{
|
||||
source::{
|
||||
community::Community,
|
||||
moderator::{ModRemovePost, ModRemovePostForm},
|
||||
post::Post,
|
||||
},
|
||||
traits::Crud,
|
||||
};
|
||||
use lemmy_utils::{ConnectionId, LemmyError};
|
||||
use lemmy_websocket::{send::send_post_ws_message, LemmyContext, UserOperationCrud};
|
||||
|
||||
#[async_trait::async_trait(?Send)]
|
||||
impl PerformCrud for RemovePost {
|
||||
type Response = PostResponse;
|
||||
|
||||
#[tracing::instrument(skip(context, websocket_id))]
|
||||
async fn perform(
|
||||
&self,
|
||||
context: &Data<LemmyContext>,
|
||||
websocket_id: Option<ConnectionId>,
|
||||
) -> Result<PostResponse, LemmyError> {
|
||||
let data: &RemovePost = self;
|
||||
let local_user_view =
|
||||
get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
|
||||
|
||||
let post_id = data.post_id;
|
||||
let orig_post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
|
||||
|
||||
check_community_ban(
|
||||
local_user_view.person.id,
|
||||
orig_post.community_id,
|
||||
context.pool(),
|
||||
)
|
||||
.await?;
|
||||
|
||||
// Verify that only the mods can remove
|
||||
is_mod_or_admin(
|
||||
context.pool(),
|
||||
local_user_view.person.id,
|
||||
orig_post.community_id,
|
||||
)
|
||||
.await?;
|
||||
|
||||
// Update the post
|
||||
let post_id = data.post_id;
|
||||
let removed = data.removed;
|
||||
let updated_post = blocking(context.pool(), move |conn| {
|
||||
Post::update_removed(conn, post_id, removed)
|
||||
})
|
||||
.await??;
|
||||
|
||||
// Mod tables
|
||||
let form = ModRemovePostForm {
|
||||
mod_person_id: local_user_view.person.id,
|
||||
post_id: data.post_id,
|
||||
removed: Some(removed),
|
||||
reason: data.reason.to_owned(),
|
||||
};
|
||||
blocking(context.pool(), move |conn| {
|
||||
ModRemovePost::create(conn, &form)
|
||||
})
|
||||
.await??;
|
||||
|
||||
let res = send_post_ws_message(
|
||||
data.post_id,
|
||||
UserOperationCrud::RemovePost,
|
||||
websocket_id,
|
||||
Some(local_user_view.person.id),
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
|
||||
// apub updates
|
||||
let community = blocking(context.pool(), move |conn| {
|
||||
Community::read(conn, orig_post.community_id)
|
||||
})
|
||||
.await??;
|
||||
let deletable = DeletableObjects::Post(Box::new(updated_post.into()));
|
||||
send_apub_delete_in_community(
|
||||
local_user_view.person,
|
||||
community,
|
||||
deletable,
|
||||
data.reason.clone().or_else(|| Some("".to_string())),
|
||||
removed,
|
||||
context,
|
||||
)
|
||||
.await?;
|
||||
Ok(res)
|
||||
}
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue