lemmy/crates/routes/src/nodeinfo.rs

107 lines
3.1 KiB
Rust
Raw Normal View History

use actix_web::{error::ErrorBadRequest, web, Error, HttpResponse, Result};
use anyhow::anyhow;
use lemmy_api_common::context::LemmyContext;
use lemmy_db_schema::source::local_site::RegistrationMode;
use lemmy_db_views::structs::SiteView;
use lemmy_utils::{error::LemmyError, version};
2020-05-16 14:04:08 +00:00
use serde::{Deserialize, Serialize};
use url::Url;
2019-11-15 02:08:25 +00:00
pub fn config(cfg: &mut web::ServiceConfig) {
cfg
.route("/nodeinfo/2.0.json", web::get().to(node_info))
.route("/.well-known/nodeinfo", web::get().to(node_info_well_known));
}
async fn node_info_well_known(
context: web::Data<LemmyContext>,
2021-12-14 13:30:37 +00:00
) -> Result<HttpResponse, LemmyError> {
2020-01-19 11:32:02 +00:00
let node_info = NodeInfoWellKnown {
links: vec![NodeInfoWellKnownLinks {
2020-04-08 12:37:05 +00:00
rel: Url::parse("http://nodeinfo.diaspora.software/ns/schema/2.0")?,
href: Url::parse(&format!(
"{}/nodeinfo/2.0.json",
&context.settings().get_protocol_and_hostname(),
2020-04-08 12:37:05 +00:00
))?,
}],
2020-01-19 11:32:02 +00:00
};
2020-04-08 12:37:05 +00:00
Ok(HttpResponse::Ok().json(node_info))
2019-11-15 02:08:25 +00:00
}
async fn node_info(context: web::Data<LemmyContext>) -> Result<HttpResponse, Error> {
2022-11-09 10:05:00 +00:00
let site_view = SiteView::read_local(context.pool())
.await
.map_err(|_| ErrorBadRequest(LemmyError::from(anyhow!("not_found"))))?;
let protocols = if site_view.local_site.federation_enabled {
Some(vec!["activitypub".to_string()])
} else {
None
};
let open_registrations = Some(site_view.local_site.registration_mode == RegistrationMode::Open);
let json = NodeInfo {
version: Some("2.0".to_string()),
software: Some(NodeInfoSoftware {
name: Some("lemmy".to_string()),
version: Some(version::VERSION.to_string()),
}),
protocols,
usage: Some(NodeInfoUsage {
users: Some(NodeInfoUsers {
total: Some(site_view.counts.users),
active_halfyear: Some(site_view.counts.users_active_half_year),
active_month: Some(site_view.counts.users_active_month),
}),
local_posts: Some(site_view.counts.posts),
local_comments: Some(site_view.counts.comments),
}),
open_registrations,
};
Ok(HttpResponse::Ok().json(json))
2019-11-15 02:08:25 +00:00
}
2020-01-19 11:32:02 +00:00
#[derive(Serialize, Deserialize, Debug)]
struct NodeInfoWellKnown {
pub links: Vec<NodeInfoWellKnownLinks>,
2020-01-19 11:32:02 +00:00
}
#[derive(Serialize, Deserialize, Debug)]
struct NodeInfoWellKnownLinks {
2020-04-08 12:37:05 +00:00
pub rel: Url,
pub href: Url,
2020-01-19 11:32:02 +00:00
}
#[derive(Serialize, Deserialize, Debug, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct NodeInfo {
pub version: Option<String>,
pub software: Option<NodeInfoSoftware>,
pub protocols: Option<Vec<String>>,
pub usage: Option<NodeInfoUsage>,
pub open_registrations: Option<bool>,
2020-01-19 11:32:02 +00:00
}
#[derive(Serialize, Deserialize, Debug, Default)]
#[serde(default)]
pub struct NodeInfoSoftware {
pub name: Option<String>,
pub version: Option<String>,
2020-01-19 11:32:02 +00:00
}
#[derive(Serialize, Deserialize, Debug, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct NodeInfoUsage {
pub users: Option<NodeInfoUsers>,
pub local_posts: Option<i64>,
pub local_comments: Option<i64>,
2020-01-19 11:32:02 +00:00
}
#[derive(Serialize, Deserialize, Debug, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct NodeInfoUsers {
pub total: Option<i64>,
pub active_halfyear: Option<i64>,
pub active_month: Option<i64>,
2020-01-19 11:32:02 +00:00
}