2022-05-04 23:13:57 +00:00
|
|
|
use std::time::Instant;
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
use actix_web::{
|
2023-04-24 15:35:32 +00:00
|
|
|
get, http::header as http_header, http::header::HeaderMap, post, web, HttpRequest,
|
|
|
|
HttpResponse, Scope,
|
2021-04-09 00:22:17 +00:00
|
|
|
};
|
|
|
|
use serde::Deserialize;
|
2022-05-04 23:13:57 +00:00
|
|
|
use tokio::sync::Mutex;
|
2021-04-09 00:22:17 +00:00
|
|
|
use uuid::Uuid;
|
|
|
|
|
2023-04-25 13:49:35 +00:00
|
|
|
use fedimovies_config::Config;
|
|
|
|
use fedimovies_models::{
|
2023-04-12 18:13:26 +00:00
|
|
|
database::{get_database_client, DatabaseError, DbPool},
|
2023-01-21 00:23:15 +00:00
|
|
|
emojis::queries::get_local_emoji_by_name,
|
|
|
|
posts::helpers::{add_related_posts, can_view_post},
|
|
|
|
posts::queries::{get_post_by_id, get_posts_by_author},
|
|
|
|
users::queries::get_user_by_name,
|
|
|
|
};
|
2023-03-30 20:27:17 +00:00
|
|
|
|
2023-04-24 15:35:32 +00:00
|
|
|
use super::actors::types::{get_instance_actor, get_local_actor};
|
2023-04-22 01:01:52 +00:00
|
|
|
use super::builders::{
|
|
|
|
announce::build_announce,
|
2023-04-24 15:35:32 +00:00
|
|
|
create_note::{build_create_note, build_emoji_tag, build_note},
|
2021-12-23 21:51:01 +00:00
|
|
|
};
|
2023-04-24 15:35:32 +00:00
|
|
|
use super::collections::{OrderedCollection, OrderedCollectionPage};
|
2022-10-01 16:56:57 +00:00
|
|
|
use super::constants::{AP_MEDIA_TYPE, AS_MEDIA_TYPE};
|
2022-07-15 17:31:02 +00:00
|
|
|
use super::identifiers::{
|
2023-04-24 15:35:32 +00:00
|
|
|
local_actor_followers, local_actor_following, local_actor_outbox, local_actor_subscribers,
|
2022-07-15 17:31:02 +00:00
|
|
|
};
|
2023-04-12 18:13:26 +00:00
|
|
|
use super::receiver::{receive_activity, HandlerError};
|
2023-04-24 15:35:32 +00:00
|
|
|
use crate::errors::HttpError;
|
|
|
|
use crate::web_client::urls::{get_post_page_url, get_profile_page_url, get_tag_page_url};
|
2021-04-09 00:22:17 +00:00
|
|
|
|
2022-12-27 20:26:42 +00:00
|
|
|
pub fn is_activitypub_request(headers: &HeaderMap) -> bool {
|
2023-04-24 15:35:32 +00:00
|
|
|
let maybe_user_agent = headers
|
|
|
|
.get(http_header::USER_AGENT)
|
2023-01-18 13:26:04 +00:00
|
|
|
.and_then(|value| value.to_str().ok());
|
|
|
|
if let Some(user_agent) = maybe_user_agent {
|
|
|
|
if user_agent.contains("THIS. IS. GNU social!!!!") {
|
|
|
|
// GNU Social doesn't send valid Accept headers
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
};
|
2021-12-29 18:36:49 +00:00
|
|
|
const CONTENT_TYPES: [&str; 4] = [
|
2022-10-01 16:56:57 +00:00
|
|
|
AP_MEDIA_TYPE,
|
|
|
|
AS_MEDIA_TYPE,
|
2021-11-13 23:56:15 +00:00
|
|
|
"application/ld+json",
|
|
|
|
"application/json",
|
|
|
|
];
|
2023-02-07 09:45:43 +00:00
|
|
|
if let Some(content_type) = headers.get(http_header::ACCEPT) {
|
2023-04-24 15:35:32 +00:00
|
|
|
let content_type_str = content_type
|
|
|
|
.to_str()
|
|
|
|
.ok()
|
2021-12-29 18:36:49 +00:00
|
|
|
// Take first content type if there are many
|
2021-12-31 17:15:00 +00:00
|
|
|
.and_then(|value| value.split(',').next())
|
2021-12-29 18:36:49 +00:00
|
|
|
.unwrap_or("");
|
2021-11-13 23:56:15 +00:00
|
|
|
return CONTENT_TYPES.contains(&content_type_str);
|
|
|
|
};
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[get("")]
|
2021-11-18 00:51:56 +00:00
|
|
|
async fn actor_view(
|
2021-04-09 00:22:17 +00:00
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2021-11-13 23:56:15 +00:00
|
|
|
request: HttpRequest,
|
2022-04-09 17:04:43 +00:00
|
|
|
username: web::Path<String>,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
|
|
|
let user = get_user_by_name(db_client, &username).await?;
|
2021-12-31 17:15:00 +00:00
|
|
|
if !is_activitypub_request(request.headers()) {
|
2023-04-24 15:35:32 +00:00
|
|
|
let page_url = get_profile_page_url(&config.instance_url(), &user.profile.username);
|
2021-11-13 23:56:15 +00:00
|
|
|
let response = HttpResponse::Found()
|
2023-02-07 09:45:43 +00:00
|
|
|
.append_header((http_header::LOCATION, page_url))
|
2021-11-13 23:56:15 +00:00
|
|
|
.finish();
|
|
|
|
return Ok(response);
|
|
|
|
};
|
2023-04-24 15:35:32 +00:00
|
|
|
let actor =
|
|
|
|
get_local_actor(&user, &config.instance_url()).map_err(|_| HttpError::InternalError)?;
|
|
|
|
let response = HttpResponse::Ok().content_type(AP_MEDIA_TYPE).json(actor);
|
2021-04-09 00:22:17 +00:00
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[post("/inbox")]
|
|
|
|
async fn inbox(
|
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2022-05-04 23:13:57 +00:00
|
|
|
inbox_mutex: web::Data<Mutex<()>>,
|
2021-04-09 00:22:17 +00:00
|
|
|
request: HttpRequest,
|
|
|
|
activity: web::Json<serde_json::Value>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
2023-03-21 16:05:59 +00:00
|
|
|
if !config.federation.enabled {
|
|
|
|
return Err(HttpError::PermissionError);
|
|
|
|
};
|
2021-12-21 00:14:12 +00:00
|
|
|
log::debug!("received activity: {}", activity);
|
2021-12-29 20:52:30 +00:00
|
|
|
let activity_type = activity["type"].as_str().unwrap_or("Unknown");
|
2022-05-30 17:35:43 +00:00
|
|
|
log::info!("received in {}: {}", request.uri().path(), activity_type);
|
2022-05-04 23:13:57 +00:00
|
|
|
let now = Instant::now();
|
|
|
|
// Store mutex guard in a variable to prevent it from being dropped immediately
|
|
|
|
let _guard = inbox_mutex.lock().await;
|
2022-05-06 19:55:28 +00:00
|
|
|
log::debug!(
|
2022-05-04 23:13:57 +00:00
|
|
|
"acquired inbox lock after waiting for {:.2?}: {}",
|
|
|
|
now.elapsed(),
|
|
|
|
activity["id"].as_str().unwrap_or_default(),
|
|
|
|
);
|
2022-02-23 23:07:51 +00:00
|
|
|
let db_client = &mut **get_database_client(&db_pool).await?;
|
2023-04-24 15:35:32 +00:00
|
|
|
receive_activity(&config, db_client, &request, &activity)
|
|
|
|
.await
|
2022-12-11 17:31:48 +00:00
|
|
|
.map_err(|error| {
|
2023-04-12 18:13:26 +00:00
|
|
|
// TODO: preserve original error text in DatabaseError
|
2023-04-24 15:35:32 +00:00
|
|
|
if let HandlerError::DatabaseError(DatabaseError::DatabaseClientError(ref pg_error)) =
|
|
|
|
error
|
2023-04-12 18:13:26 +00:00
|
|
|
{
|
|
|
|
log::error!("database client error: {}", pg_error);
|
|
|
|
};
|
2023-04-24 15:35:32 +00:00
|
|
|
log::warn!("failed to process activity ({}): {}", error, activity,);
|
2022-12-11 17:31:48 +00:00
|
|
|
error
|
2021-12-06 21:19:23 +00:00
|
|
|
})?;
|
2023-01-29 21:13:35 +00:00
|
|
|
Ok(HttpResponse::Accepted().finish())
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct CollectionQueryParams {
|
2021-12-23 21:51:01 +00:00
|
|
|
page: Option<bool>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[get("/outbox")]
|
|
|
|
async fn outbox(
|
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2022-04-09 17:04:43 +00:00
|
|
|
username: web::Path<String>,
|
2021-12-23 21:51:01 +00:00
|
|
|
query_params: web::Query<CollectionQueryParams>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
let instance = config.instance();
|
2022-07-15 17:31:02 +00:00
|
|
|
let collection_id = local_actor_outbox(&instance.url(), &username);
|
2021-12-23 21:51:01 +00:00
|
|
|
let first_page_id = format!("{}?page=true", collection_id);
|
|
|
|
if query_params.page.is_none() {
|
2023-04-24 15:35:32 +00:00
|
|
|
let collection = OrderedCollection::new(collection_id, Some(first_page_id), None);
|
2021-12-23 21:51:01 +00:00
|
|
|
let response = HttpResponse::Ok()
|
2022-10-01 16:56:57 +00:00
|
|
|
.content_type(AP_MEDIA_TYPE)
|
2021-12-23 21:51:01 +00:00
|
|
|
.json(collection);
|
|
|
|
return Ok(response);
|
|
|
|
};
|
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
|
|
|
let user = get_user_by_name(db_client, &username).await?;
|
2022-04-13 20:27:38 +00:00
|
|
|
// Posts are ordered by creation date
|
2023-04-22 01:01:52 +00:00
|
|
|
const COLLECTION_PAGE_SIZE: u16 = 20;
|
2022-10-01 22:06:31 +00:00
|
|
|
let mut posts = get_posts_by_author(
|
2022-01-07 01:10:41 +00:00
|
|
|
db_client,
|
|
|
|
&user.id,
|
|
|
|
None, // include only public posts
|
2023-04-22 01:01:52 +00:00
|
|
|
true, // include replies
|
|
|
|
true, // include reposts
|
2022-09-25 20:59:09 +00:00
|
|
|
None,
|
|
|
|
COLLECTION_PAGE_SIZE,
|
2023-04-24 15:35:32 +00:00
|
|
|
)
|
|
|
|
.await?;
|
2022-10-01 22:06:31 +00:00
|
|
|
add_related_posts(db_client, posts.iter_mut().collect()).await?;
|
2023-04-24 15:35:32 +00:00
|
|
|
let activities = posts
|
|
|
|
.iter()
|
|
|
|
.map(|post| {
|
|
|
|
if post.repost_of_id.is_some() {
|
|
|
|
let activity = build_announce(&instance.url(), post);
|
|
|
|
serde_json::to_value(activity).expect("activity should be serializable")
|
|
|
|
} else {
|
|
|
|
let activity = build_create_note(&instance.hostname(), &instance.url(), post);
|
|
|
|
serde_json::to_value(activity).expect("activity should be serializable")
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
|
|
|
let collection_page = OrderedCollectionPage::new(first_page_id, activities);
|
2021-12-23 21:51:01 +00:00
|
|
|
let response = HttpResponse::Ok()
|
2022-10-01 16:56:57 +00:00
|
|
|
.content_type(AP_MEDIA_TYPE)
|
2021-12-23 21:51:01 +00:00
|
|
|
.json(collection_page);
|
|
|
|
Ok(response)
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
2022-10-31 19:10:55 +00:00
|
|
|
#[post("/outbox")]
|
|
|
|
async fn outbox_client_to_server() -> HttpResponse {
|
|
|
|
HttpResponse::MethodNotAllowed().finish()
|
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[get("/followers")]
|
|
|
|
async fn followers_collection(
|
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2022-04-09 17:04:43 +00:00
|
|
|
username: web::Path<String>,
|
2021-04-09 00:22:17 +00:00
|
|
|
query_params: web::Query<CollectionQueryParams>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
if query_params.page.is_some() {
|
|
|
|
// Social graph is not available
|
|
|
|
return Err(HttpError::PermissionError);
|
2022-09-25 20:59:09 +00:00
|
|
|
};
|
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
|
|
|
let user = get_user_by_name(db_client, &username).await?;
|
2023-04-24 15:35:32 +00:00
|
|
|
let collection_id = local_actor_followers(&config.instance_url(), &username);
|
|
|
|
let collection = OrderedCollection::new(collection_id, None, Some(user.profile.follower_count));
|
2021-04-09 00:22:17 +00:00
|
|
|
let response = HttpResponse::Ok()
|
2022-10-01 16:56:57 +00:00
|
|
|
.content_type(AP_MEDIA_TYPE)
|
2021-04-09 00:22:17 +00:00
|
|
|
.json(collection);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[get("/following")]
|
|
|
|
async fn following_collection(
|
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2022-04-09 17:04:43 +00:00
|
|
|
username: web::Path<String>,
|
2021-04-09 00:22:17 +00:00
|
|
|
query_params: web::Query<CollectionQueryParams>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
if query_params.page.is_some() {
|
|
|
|
// Social graph is not available
|
|
|
|
return Err(HttpError::PermissionError);
|
2022-09-25 20:59:09 +00:00
|
|
|
};
|
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
|
|
|
let user = get_user_by_name(db_client, &username).await?;
|
2023-04-24 15:35:32 +00:00
|
|
|
let collection_id = local_actor_following(&config.instance_url(), &username);
|
|
|
|
let collection =
|
|
|
|
OrderedCollection::new(collection_id, None, Some(user.profile.following_count));
|
2021-04-09 00:22:17 +00:00
|
|
|
let response = HttpResponse::Ok()
|
2022-10-01 16:56:57 +00:00
|
|
|
.content_type(AP_MEDIA_TYPE)
|
2021-04-09 00:22:17 +00:00
|
|
|
.json(collection);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2022-01-15 23:21:13 +00:00
|
|
|
#[get("/subscribers")]
|
|
|
|
async fn subscribers_collection(
|
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2022-04-09 17:04:43 +00:00
|
|
|
username: web::Path<String>,
|
2022-01-15 23:21:13 +00:00
|
|
|
query_params: web::Query<CollectionQueryParams>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
if query_params.page.is_some() {
|
|
|
|
// Subscriber list is hidden
|
|
|
|
return Err(HttpError::PermissionError);
|
2022-09-25 20:59:09 +00:00
|
|
|
};
|
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
|
|
|
let user = get_user_by_name(db_client, &username).await?;
|
2023-04-24 15:35:32 +00:00
|
|
|
let collection_id = local_actor_subscribers(&config.instance_url(), &username);
|
|
|
|
let collection =
|
|
|
|
OrderedCollection::new(collection_id, None, Some(user.profile.subscriber_count));
|
2022-01-15 23:21:13 +00:00
|
|
|
let response = HttpResponse::Ok()
|
2022-10-01 16:56:57 +00:00
|
|
|
.content_type(AP_MEDIA_TYPE)
|
2022-01-15 23:21:13 +00:00
|
|
|
.json(collection);
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2021-11-18 00:51:56 +00:00
|
|
|
pub fn actor_scope() -> Scope {
|
2021-04-09 00:22:17 +00:00
|
|
|
web::scope("/users/{username}")
|
2021-11-18 00:51:56 +00:00
|
|
|
.service(actor_view)
|
2021-04-09 00:22:17 +00:00
|
|
|
.service(inbox)
|
2021-12-23 21:51:01 +00:00
|
|
|
.service(outbox)
|
2022-10-31 19:10:55 +00:00
|
|
|
.service(outbox_client_to_server)
|
2021-04-09 00:22:17 +00:00
|
|
|
.service(followers_collection)
|
|
|
|
.service(following_collection)
|
2022-01-15 23:21:13 +00:00
|
|
|
.service(subscribers_collection)
|
2021-04-09 00:22:17 +00:00
|
|
|
}
|
|
|
|
|
2021-11-20 21:07:03 +00:00
|
|
|
#[get("")]
|
2023-04-24 15:35:32 +00:00
|
|
|
async fn instance_actor_view(config: web::Data<Config>) -> Result<HttpResponse, HttpError> {
|
|
|
|
let actor = get_instance_actor(&config.instance()).map_err(|_| HttpError::InternalError)?;
|
|
|
|
let response = HttpResponse::Ok().content_type(AP_MEDIA_TYPE).json(actor);
|
2021-11-18 00:51:56 +00:00
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2021-11-20 21:07:03 +00:00
|
|
|
#[post("/inbox")]
|
|
|
|
async fn instance_actor_inbox(
|
2023-03-21 16:05:59 +00:00
|
|
|
config: web::Data<Config>,
|
2021-11-20 21:07:03 +00:00
|
|
|
activity: web::Json<serde_json::Value>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
2023-03-21 16:05:59 +00:00
|
|
|
if !config.federation.enabled {
|
|
|
|
return Err(HttpError::PermissionError);
|
|
|
|
};
|
2021-11-22 22:38:47 +00:00
|
|
|
log::info!(
|
|
|
|
"received in instance inbox: {}",
|
|
|
|
activity["type"].as_str().unwrap_or("Unknown"),
|
|
|
|
);
|
2023-01-29 21:13:35 +00:00
|
|
|
Ok(HttpResponse::Accepted().finish())
|
2021-11-20 21:07:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn instance_actor_scope() -> Scope {
|
|
|
|
web::scope("/actor")
|
|
|
|
.service(instance_actor_view)
|
|
|
|
.service(instance_actor_inbox)
|
|
|
|
}
|
|
|
|
|
2021-04-09 00:22:17 +00:00
|
|
|
#[get("/objects/{object_id}")]
|
2021-11-18 00:51:56 +00:00
|
|
|
pub async fn object_view(
|
2021-10-08 18:15:04 +00:00
|
|
|
config: web::Data<Config>,
|
2022-12-03 21:23:52 +00:00
|
|
|
db_pool: web::Data<DbPool>,
|
2021-11-13 23:56:15 +00:00
|
|
|
request: HttpRequest,
|
2022-04-09 17:04:43 +00:00
|
|
|
internal_object_id: web::Path<Uuid>,
|
2021-04-09 00:22:17 +00:00
|
|
|
) -> Result<HttpResponse, HttpError> {
|
2021-10-08 18:15:04 +00:00
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
2022-04-09 17:04:43 +00:00
|
|
|
let internal_object_id = internal_object_id.into_inner();
|
2022-06-15 12:08:53 +00:00
|
|
|
// Try to find local post by ID,
|
|
|
|
// return 404 if not found, or not public, or it is a repost
|
2022-10-01 22:06:31 +00:00
|
|
|
let mut post = get_post_by_id(db_client, &internal_object_id).await?;
|
2022-11-21 18:55:06 +00:00
|
|
|
if !post.is_local() || !can_view_post(db_client, None, &post).await? {
|
2022-10-01 22:06:31 +00:00
|
|
|
return Err(HttpError::NotFoundError("post"));
|
|
|
|
};
|
2021-12-31 17:15:00 +00:00
|
|
|
if !is_activitypub_request(request.headers()) {
|
2021-12-12 19:11:04 +00:00
|
|
|
let page_url = get_post_page_url(&config.instance_url(), &post.id);
|
2021-11-13 23:56:15 +00:00
|
|
|
let response = HttpResponse::Found()
|
2023-02-07 09:45:43 +00:00
|
|
|
.append_header((http_header::LOCATION, page_url))
|
2021-11-13 23:56:15 +00:00
|
|
|
.finish();
|
|
|
|
return Ok(response);
|
|
|
|
};
|
2022-10-01 22:06:31 +00:00
|
|
|
add_related_posts(db_client, vec![&mut post]).await?;
|
2022-06-15 11:10:41 +00:00
|
|
|
let object = build_note(
|
2022-11-24 01:51:43 +00:00
|
|
|
&config.instance().hostname(),
|
2021-11-11 21:51:47 +00:00
|
|
|
&config.instance().url(),
|
2021-12-31 17:15:00 +00:00
|
|
|
&post,
|
2021-11-11 21:51:47 +00:00
|
|
|
);
|
2023-04-24 15:35:32 +00:00
|
|
|
let response = HttpResponse::Ok().content_type(AP_MEDIA_TYPE).json(object);
|
2021-04-09 00:22:17 +00:00
|
|
|
Ok(response)
|
|
|
|
}
|
2021-12-29 18:36:49 +00:00
|
|
|
|
2023-01-21 00:23:15 +00:00
|
|
|
#[get("/objects/emojis/{emoji_name}")]
|
|
|
|
pub async fn emoji_view(
|
|
|
|
config: web::Data<Config>,
|
|
|
|
db_pool: web::Data<DbPool>,
|
|
|
|
emoji_name: web::Path<String>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
let db_client = &**get_database_client(&db_pool).await?;
|
2023-04-24 15:35:32 +00:00
|
|
|
let emoji = get_local_emoji_by_name(db_client, &emoji_name).await?;
|
|
|
|
let object = build_emoji_tag(&config.instance().url(), &emoji);
|
|
|
|
let response = HttpResponse::Ok().content_type(AP_MEDIA_TYPE).json(object);
|
2023-01-21 00:23:15 +00:00
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2023-01-13 21:28:26 +00:00
|
|
|
#[get("/collections/tags/{tag_name}")]
|
|
|
|
pub async fn tag_view(
|
|
|
|
config: web::Data<Config>,
|
|
|
|
tag_name: web::Path<String>,
|
|
|
|
) -> Result<HttpResponse, HttpError> {
|
|
|
|
let page_url = get_tag_page_url(&config.instance_url(), &tag_name);
|
|
|
|
let response = HttpResponse::Found()
|
2023-02-07 09:45:43 +00:00
|
|
|
.append_header((http_header::LOCATION, page_url))
|
2023-01-13 21:28:26 +00:00
|
|
|
.finish();
|
|
|
|
Ok(response)
|
|
|
|
}
|
|
|
|
|
2021-12-29 18:36:49 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2023-04-24 15:35:32 +00:00
|
|
|
use super::*;
|
2022-04-08 18:52:13 +00:00
|
|
|
use actix_web::http::{
|
|
|
|
header,
|
|
|
|
header::{HeaderMap, HeaderValue},
|
|
|
|
};
|
2021-12-29 18:36:49 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_is_activitypub_request_mastodon() {
|
|
|
|
let mut request_headers = HeaderMap::new();
|
|
|
|
request_headers.insert(
|
|
|
|
header::ACCEPT,
|
|
|
|
HeaderValue::from_static(r#"application/activity+json, application/ld+json; profile="https://www.w3.org/ns/activitystreams", text/html;q=0.1"#),
|
|
|
|
);
|
|
|
|
let result = is_activitypub_request(&request_headers);
|
|
|
|
assert_eq!(result, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_is_activitypub_request_pleroma() {
|
|
|
|
let mut request_headers = HeaderMap::new();
|
|
|
|
request_headers.insert(
|
|
|
|
header::ACCEPT,
|
|
|
|
HeaderValue::from_static("application/activity+json"),
|
|
|
|
);
|
|
|
|
let result = is_activitypub_request(&request_headers);
|
|
|
|
assert_eq!(result, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_is_activitypub_request_browser() {
|
|
|
|
let mut request_headers = HeaderMap::new();
|
2023-04-24 15:35:32 +00:00
|
|
|
request_headers.insert(header::ACCEPT, HeaderValue::from_static("text/html"));
|
2021-12-29 18:36:49 +00:00
|
|
|
let result = is_activitypub_request(&request_headers);
|
|
|
|
assert_eq!(result, false);
|
|
|
|
}
|
|
|
|
}
|