Merge branch 'structs_separate' into main

This commit is contained in:
Dessalines 2020-09-03 09:02:03 -05:00
commit 17df0ee6b3
57 changed files with 940 additions and 845 deletions

10
docker/dev/Dockerfile vendored
View file

@ -20,12 +20,18 @@ RUN USER=root cargo new server
# Install cargo-build-deps
RUN cargo install --git https://github.com/romac/cargo-build-deps.git
WORKDIR /app/server
RUN mkdir -p lemmy_db/src/ lemmy_utils/src/
RUN mkdir -p lemmy_db/src/ \
lemmy_utils/src/ \
lemmy_api_structs/src/ \
lemmy_rate_limit/src/ \
lemmy
# Copy the cargo tomls
COPY server/Cargo.toml server/Cargo.lock ./
COPY server/lemmy_db/Cargo.toml ./lemmy_db/
COPY server/lemmy_utils/Cargo.toml ./lemmy_utils/
COPY server/lemmy_api_structs/Cargo.toml ./lemmy_api_structs/
COPY server/lemmy_rate_limit/Cargo.toml ./lemmy_rate_limit/
# Cache the deps
RUN cargo build-deps
@ -34,6 +40,8 @@ RUN cargo build-deps
COPY server/src ./src/
COPY server/lemmy_db/src ./lemmy_db/src/
COPY server/lemmy_utils/src/ ./lemmy_utils/src/
COPY server/lemmy_api_structs/src/ ./lemmy_api_structs/src/
COPY server/lemmy_rate_limit/src/ ./lemmy_rate_limit/src/
COPY server/migrations ./migrations/
# Build for debug

View file

@ -13,6 +13,8 @@ WORKDIR /app/server
COPY server/Cargo.toml server/Cargo.lock ./
COPY server/lemmy_db ./lemmy_db
COPY server/lemmy_utils ./lemmy_utils
COPY server/lemmy_api_structs ./lemmy_api_structs
COPY server/lemmy_rate_limit ./lemmy_rate_limit
RUN mkdir -p ./src/bin \
&& echo 'fn main() { println!("Dummy") }' > ./src/bin/main.rs
RUN cargo build --release

27
server/Cargo.lock generated vendored
View file

@ -1794,6 +1794,15 @@ version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "lemmy_api_structs"
version = "0.1.0"
dependencies = [
"lemmy_db",
"serde 1.0.114",
"thiserror",
]
[[package]]
name = "lemmy_db"
version = "0.1.0"
@ -1812,6 +1821,20 @@ dependencies = [
"url",
]
[[package]]
name = "lemmy_rate_limit"
version = "0.1.0"
dependencies = [
"actix-web",
"futures",
"lemmy_api_structs",
"lemmy_utils",
"log",
"strum",
"strum_macros",
"tokio",
]
[[package]]
name = "lemmy_server"
version = "0.0.1"
@ -1841,7 +1864,9 @@ dependencies = [
"itertools",
"jsonwebtoken",
"lazy_static",
"lemmy_api_structs",
"lemmy_db",
"lemmy_rate_limit",
"lemmy_utils",
"log",
"openssl",
@ -1864,6 +1889,8 @@ dependencies = [
name = "lemmy_utils"
version = "0.1.0"
dependencies = [
"actix-web",
"anyhow",
"chrono",
"comrak",
"config",

6
server/Cargo.toml vendored
View file

@ -9,12 +9,16 @@ lto = true
[workspace]
members = [
"lemmy_utils",
"lemmy_db"
"lemmy_db",
"lemmy_api_structs",
"lemmy_rate_limit",
]
[dependencies]
lemmy_utils = { path = "./lemmy_utils" }
lemmy_db = { path = "./lemmy_db" }
lemmy_api_structs = { path = "./lemmy_api_structs" }
lemmy_rate_limit = { path = "./lemmy_rate_limit" }
diesel = "1.4.4"
diesel_migrations = "1.4.0"
dotenv = "0.15.0"

14
server/lemmy_api_structs/Cargo.toml vendored Normal file
View file

@ -0,0 +1,14 @@
[package]
name = "lemmy_api_structs"
version = "0.1.0"
authors = ["Felix Ableitner <me@nutomic.com>"]
edition = "2018"
[lib]
name = "lemmy_api_structs"
path = "src/lib.rs"
[dependencies]
lemmy_db = { path = "../lemmy_db" }
serde = { version = "1.0.105", features = ["derive"] }
thiserror = "1.0.20"

View file

@ -0,0 +1,77 @@
use lemmy_db::comment_view::CommentView;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub struct CreateComment {
pub content: String,
pub parent_id: Option<i32>,
pub post_id: i32,
pub form_id: Option<String>,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditComment {
pub content: String,
pub edit_id: i32,
pub form_id: Option<String>,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeleteComment {
pub edit_id: i32,
pub deleted: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct RemoveComment {
pub edit_id: i32,
pub removed: bool,
pub reason: Option<String>,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct MarkCommentAsRead {
pub edit_id: i32,
pub read: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct SaveComment {
pub comment_id: i32,
pub save: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct CommentResponse {
pub comment: CommentView,
pub recipient_ids: Vec<i32>,
pub form_id: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct CreateCommentLike {
pub comment_id: i32,
pub score: i16,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetComments {
pub type_: String,
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub community_id: Option<i32>,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetCommentsResponse {
pub comments: Vec<CommentView>,
}

View file

@ -0,0 +1,131 @@
use lemmy_db::{
community_view::{CommunityFollowerView, CommunityModeratorView, CommunityView},
user_view::UserView,
};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub struct GetCommunity {
pub id: Option<i32>,
pub name: Option<String>,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetCommunityResponse {
pub community: CommunityView,
pub moderators: Vec<CommunityModeratorView>,
pub online: usize,
}
#[derive(Serialize, Deserialize)]
pub struct CreateCommunity {
pub name: String,
pub title: String,
pub description: Option<String>,
pub icon: Option<String>,
pub banner: Option<String>,
pub category_id: i32,
pub nsfw: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct CommunityResponse {
pub community: CommunityView,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ListCommunities {
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ListCommunitiesResponse {
pub communities: Vec<CommunityView>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct BanFromCommunity {
pub community_id: i32,
pub user_id: i32,
pub ban: bool,
pub remove_data: Option<bool>,
pub reason: Option<String>,
pub expires: Option<i64>,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct BanFromCommunityResponse {
pub user: UserView,
pub banned: bool,
}
#[derive(Serialize, Deserialize)]
pub struct AddModToCommunity {
pub community_id: i32,
pub user_id: i32,
pub added: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddModToCommunityResponse {
pub moderators: Vec<CommunityModeratorView>,
}
#[derive(Serialize, Deserialize)]
pub struct EditCommunity {
pub edit_id: i32,
pub title: String,
pub description: Option<String>,
pub icon: Option<String>,
pub banner: Option<String>,
pub category_id: i32,
pub nsfw: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeleteCommunity {
pub edit_id: i32,
pub deleted: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct RemoveCommunity {
pub edit_id: i32,
pub removed: bool,
pub reason: Option<String>,
pub expires: Option<i64>,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct FollowCommunity {
pub community_id: i32,
pub follow: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetFollowedCommunities {
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetFollowedCommunitiesResponse {
pub communities: Vec<CommunityFollowerView>,
}
#[derive(Serialize, Deserialize)]
pub struct TransferCommunity {
pub community_id: i32,
pub user_id: i32,
pub auth: String,
}

View file

@ -0,0 +1,24 @@
pub extern crate serde;
pub extern crate thiserror;
pub mod comment;
pub mod community;
pub mod post;
pub mod site;
pub mod user;
use thiserror::Error;
#[derive(Debug, Error)]
#[error("{{\"error\":\"{message}\"}}")]
pub struct APIError {
pub message: String,
}
impl APIError {
pub fn err(msg: &str) -> Self {
APIError {
message: msg.to_string(),
}
}
}

View file

@ -0,0 +1,105 @@
use lemmy_db::{
comment_view::CommentView,
community_view::{CommunityModeratorView, CommunityView},
post_view::PostView,
};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
pub struct CreatePost {
pub name: String,
pub url: Option<String>,
pub body: Option<String>,
pub nsfw: bool,
pub community_id: i32,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PostResponse {
pub post: PostView,
}
#[derive(Serialize, Deserialize)]
pub struct GetPost {
pub id: i32,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetPostResponse {
pub post: PostView,
pub comments: Vec<CommentView>,
pub community: CommunityView,
pub moderators: Vec<CommunityModeratorView>,
pub online: usize,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct GetPosts {
pub type_: String,
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub community_id: Option<i32>,
pub community_name: Option<String>,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct GetPostsResponse {
pub posts: Vec<PostView>,
}
#[derive(Serialize, Deserialize)]
pub struct CreatePostLike {
pub post_id: i32,
pub score: i16,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditPost {
pub edit_id: i32,
pub name: String,
pub url: Option<String>,
pub body: Option<String>,
pub nsfw: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeletePost {
pub edit_id: i32,
pub deleted: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct RemovePost {
pub edit_id: i32,
pub removed: bool,
pub reason: Option<String>,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct LockPost {
pub edit_id: i32,
pub locked: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct StickyPost {
pub edit_id: i32,
pub stickied: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct SavePost {
pub post_id: i32,
pub save: bool,
pub auth: String,
}

View file

@ -0,0 +1,127 @@
use lemmy_db::{
category::*,
comment_view::*,
community_view::*,
moderator_views::*,
post_view::*,
site_view::*,
user::*,
user_view::*,
};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
pub struct ListCategories {}
#[derive(Serialize, Deserialize)]
pub struct ListCategoriesResponse {
pub categories: Vec<Category>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Search {
pub q: String,
pub type_: String,
pub community_id: Option<i32>,
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SearchResponse {
pub type_: String,
pub comments: Vec<CommentView>,
pub posts: Vec<PostView>,
pub communities: Vec<CommunityView>,
pub users: Vec<UserView>,
}
#[derive(Serialize, Deserialize)]
pub struct GetModlog {
pub mod_user_id: Option<i32>,
pub community_id: Option<i32>,
pub page: Option<i64>,
pub limit: Option<i64>,
}
#[derive(Serialize, Deserialize)]
pub struct GetModlogResponse {
pub removed_posts: Vec<ModRemovePostView>,
pub locked_posts: Vec<ModLockPostView>,
pub stickied_posts: Vec<ModStickyPostView>,
pub removed_comments: Vec<ModRemoveCommentView>,
pub removed_communities: Vec<ModRemoveCommunityView>,
pub banned_from_community: Vec<ModBanFromCommunityView>,
pub banned: Vec<ModBanView>,
pub added_to_community: Vec<ModAddCommunityView>,
pub added: Vec<ModAddView>,
}
#[derive(Serialize, Deserialize)]
pub struct CreateSite {
pub name: String,
pub description: Option<String>,
pub icon: Option<String>,
pub banner: Option<String>,
pub enable_downvotes: bool,
pub open_registration: bool,
pub enable_nsfw: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditSite {
pub name: String,
pub description: Option<String>,
pub icon: Option<String>,
pub banner: Option<String>,
pub enable_downvotes: bool,
pub open_registration: bool,
pub enable_nsfw: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetSite {
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct SiteResponse {
pub site: SiteView,
}
#[derive(Serialize, Deserialize)]
pub struct GetSiteResponse {
pub site: Option<SiteView>,
pub admins: Vec<UserView>,
pub banned: Vec<UserView>,
pub online: usize,
pub version: String,
pub my_user: Option<User_>,
pub federated_instances: Vec<String>,
}
#[derive(Serialize, Deserialize)]
pub struct TransferSite {
pub user_id: i32,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetSiteConfig {
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetSiteConfigResponse {
pub config_hjson: String,
}
#[derive(Serialize, Deserialize)]
pub struct SaveSiteConfig {
pub config_hjson: String,
pub auth: String,
}

View file

@ -0,0 +1,239 @@
use lemmy_db::{
comment_view::{CommentView, ReplyView},
community_view::{CommunityFollowerView, CommunityModeratorView},
post_view::PostView,
private_message_view::PrivateMessageView,
user_mention_view::UserMentionView,
user_view::UserView,
};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
pub struct Login {
pub username_or_email: String,
pub password: String,
}
#[derive(Serialize, Deserialize)]
pub struct Register {
pub username: String,
pub email: Option<String>,
pub password: String,
pub password_verify: String,
pub admin: bool,
pub show_nsfw: bool,
pub captcha_uuid: Option<String>,
pub captcha_answer: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetCaptcha {}
#[derive(Serialize, Deserialize)]
pub struct GetCaptchaResponse {
pub ok: Option<CaptchaResponse>,
}
#[derive(Serialize, Deserialize)]
pub struct CaptchaResponse {
pub png: String, // A Base64 encoded png
pub wav: Option<String>, // A Base64 encoded wav audio
pub uuid: String,
}
#[derive(Serialize, Deserialize)]
pub struct SaveUserSettings {
pub show_nsfw: bool,
pub theme: String,
pub default_sort_type: i16,
pub default_listing_type: i16,
pub lang: String,
pub avatar: Option<String>,
pub banner: Option<String>,
pub preferred_username: Option<String>,
pub email: Option<String>,
pub bio: Option<String>,
pub matrix_user_id: Option<String>,
pub new_password: Option<String>,
pub new_password_verify: Option<String>,
pub old_password: Option<String>,
pub show_avatars: bool,
pub send_notifications_to_email: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct LoginResponse {
pub jwt: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserDetails {
pub user_id: Option<i32>,
pub username: Option<String>,
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub community_id: Option<i32>,
pub saved_only: bool,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserDetailsResponse {
pub user: UserView,
pub follows: Vec<CommunityFollowerView>,
pub moderates: Vec<CommunityModeratorView>,
pub comments: Vec<CommentView>,
pub posts: Vec<PostView>,
}
#[derive(Serialize, Deserialize)]
pub struct GetRepliesResponse {
pub replies: Vec<ReplyView>,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserMentionsResponse {
pub mentions: Vec<UserMentionView>,
}
#[derive(Serialize, Deserialize)]
pub struct MarkAllAsRead {
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct AddAdmin {
pub user_id: i32,
pub added: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddAdminResponse {
pub admins: Vec<UserView>,
}
#[derive(Serialize, Deserialize)]
pub struct BanUser {
pub user_id: i32,
pub ban: bool,
pub remove_data: Option<bool>,
pub reason: Option<String>,
pub expires: Option<i64>,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct BanUserResponse {
pub user: UserView,
pub banned: bool,
}
#[derive(Serialize, Deserialize)]
pub struct GetReplies {
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub unread_only: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserMentions {
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub unread_only: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct MarkUserMentionAsRead {
pub user_mention_id: i32,
pub read: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct UserMentionResponse {
pub mention: UserMentionView,
}
#[derive(Serialize, Deserialize)]
pub struct DeleteAccount {
pub password: String,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct PasswordReset {
pub email: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PasswordResetResponse {}
#[derive(Serialize, Deserialize)]
pub struct PasswordChange {
pub token: String,
pub password: String,
pub password_verify: String,
}
#[derive(Serialize, Deserialize)]
pub struct CreatePrivateMessage {
pub content: String,
pub recipient_id: i32,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditPrivateMessage {
pub edit_id: i32,
pub content: String,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeletePrivateMessage {
pub edit_id: i32,
pub deleted: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct MarkPrivateMessageAsRead {
pub edit_id: i32,
pub read: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetPrivateMessages {
pub unread_only: bool,
pub page: Option<i64>,
pub limit: Option<i64>,
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PrivateMessagesResponse {
pub messages: Vec<PrivateMessageView>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PrivateMessageResponse {
pub message: PrivateMessageView,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct UserJoin {
pub auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct UserJoinResponse {
pub user_id: i32,
}

19
server/lemmy_rate_limit/Cargo.toml vendored Normal file
View file

@ -0,0 +1,19 @@
[package]
name = "lemmy_rate_limit"
version = "0.1.0"
authors = ["Felix Ableitner <me@nutomic.com>"]
edition = "2018"
[lib]
name = "lemmy_rate_limit"
path = "src/lib.rs"
[dependencies]
lemmy_utils = { path = "../lemmy_utils" }
lemmy_api_structs = { path = "../lemmy_api_structs" }
tokio = "0.2.21"
strum = "0.18.0"
strum_macros = "0.18.0"
futures = "0.3.5"
actix-web = { version = "3.0.0-alpha.3", features = ["rustls"] }
log = "0.4.0"

View file

@ -1,8 +1,17 @@
use super::IPAddr;
use crate::{get_ip, LemmyError};
#[macro_use]
pub extern crate strum_macros;
pub extern crate actix_web;
pub extern crate futures;
pub extern crate log;
pub extern crate tokio;
use actix_web::dev::{Service, ServiceRequest, ServiceResponse, Transform};
use futures::future::{ok, Ready};
use lemmy_utils::settings::{RateLimitConfig, Settings};
use lemmy_utils::{
get_ip,
settings::{RateLimitConfig, Settings},
LemmyError,
};
use rate_limiter::{RateLimitType, RateLimiter};
use std::{
future::Future,

View file

@ -1,5 +1,5 @@
use super::IPAddr;
use crate::{api::APIError, LemmyError};
use lemmy_api_structs::APIError;
use lemmy_utils::{IPAddr, LemmyError};
use log::debug;
use std::{collections::HashMap, time::SystemTime};
use strum::IntoEnumIterator;
@ -27,7 +27,7 @@ pub struct RateLimiter {
impl Default for RateLimiter {
fn default() -> Self {
Self {
buckets: HashMap::new(),
buckets: HashMap::<RateLimitType, HashMap<IPAddr, RateLimitBucket>>::new(),
}
}
}

View file

@ -24,3 +24,5 @@ comrak = "0.7"
lazy_static = "1.3.0"
openssl = "0.10"
url = { version = "2.1.1", features = ["serde"] }
actix-web = "3.0.0-alpha.3"
anyhow = "1.0.32"

View file

@ -1,5 +1,7 @@
#[macro_use]
pub extern crate lazy_static;
pub extern crate actix_web;
pub extern crate anyhow;
pub extern crate comrak;
pub extern crate lettre;
pub extern crate lettre_email;
@ -12,6 +14,7 @@ pub extern crate url;
pub mod settings;
use crate::settings::Settings;
use actix_web::dev::ConnectionInfo;
use chrono::{DateTime, FixedOffset, Local, NaiveDateTime};
use itertools::Itertools;
use lettre::{
@ -31,6 +34,12 @@ use regex::{Regex, RegexBuilder};
use std::io::{Error, ErrorKind};
use url::Url;
pub type ConnectionId = usize;
pub type PostId = i32;
pub type CommunityId = i32;
pub type UserId = i32;
pub type IPAddr = String;
#[macro_export]
macro_rules! location_info {
() => {
@ -43,6 +52,28 @@ macro_rules! location_info {
};
}
#[derive(Debug)]
pub struct LemmyError {
inner: anyhow::Error,
}
impl<T> From<T> for LemmyError
where
T: Into<anyhow::Error>,
{
fn from(t: T) -> Self {
LemmyError { inner: t.into() }
}
}
impl std::fmt::Display for LemmyError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.inner.fmt(f)
}
}
impl actix_web::error::ResponseError for LemmyError {}
pub fn naive_from_unix(time: i64) -> NaiveDateTime {
NaiveDateTime::from_timestamp(time, 0)
}
@ -346,3 +377,13 @@ pub fn make_apub_endpoint(endpoint_type: EndpointType, name: &str) -> Url {
))
.unwrap()
}
pub fn get_ip(conn_info: &ConnectionInfo) -> String {
conn_info
.realip_remote_addr()
.unwrap_or("127.0.0.1:12345")
.split(':')
.next()
.unwrap_or("127.0.0.1")
.to_string()
}

View file

@ -5,7 +5,6 @@ use crate::{
get_user_from_jwt,
get_user_from_jwt_opt,
is_mod_or_admin,
APIError,
Perform,
},
apub::{ApubLikeableType, ApubObjectType},
@ -14,12 +13,11 @@ use crate::{
messages::{JoinCommunityRoom, SendComment},
UserOperation,
},
ConnectionId,
DbPool,
LemmyContext,
LemmyError,
};
use actix_web::web::Data;
use lemmy_api_structs::{comment::*, APIError};
use lemmy_db::{
comment::*,
comment_view::*,
@ -40,88 +38,14 @@ use lemmy_utils::{
scrape_text_for_mentions,
send_email,
settings::Settings,
ConnectionId,
EndpointType,
LemmyError,
MentionData,
};
use log::error;
use serde::{Deserialize, Serialize};
use std::str::FromStr;
#[derive(Serialize, Deserialize)]
pub struct CreateComment {
content: String,
parent_id: Option<i32>,
pub post_id: i32,
form_id: Option<String>,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditComment {
content: String,
edit_id: i32,
form_id: Option<String>,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeleteComment {
edit_id: i32,
deleted: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct RemoveComment {
edit_id: i32,
removed: bool,
reason: Option<String>,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct MarkCommentAsRead {
edit_id: i32,
read: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct SaveComment {
comment_id: i32,
save: bool,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct CommentResponse {
pub comment: CommentView,
pub recipient_ids: Vec<i32>,
pub form_id: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct CreateCommentLike {
comment_id: i32,
score: i16,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetComments {
type_: String,
sort: String,
page: Option<i64>,
limit: Option<i64>,
pub community_id: Option<i32>,
auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetCommentsResponse {
comments: Vec<CommentView>,
}
#[async_trait::async_trait(?Send)]
impl Perform for CreateComment {
type Response = CommentResponse;

View file

@ -6,7 +6,6 @@ use crate::{
get_user_from_jwt_opt,
is_admin,
is_mod_or_admin,
APIError,
Perform,
},
apub::ActorType,
@ -15,12 +14,11 @@ use crate::{
messages::{GetCommunityUsersOnline, JoinCommunityRoom, SendCommunityRoomMessage},
UserOperation,
},
ConnectionId,
LemmyContext,
LemmyError,
};
use actix_web::web::Data;
use anyhow::Context;
use lemmy_api_structs::{community::*, APIError};
use lemmy_db::{
comment::Comment,
comment_view::CommentQueryBuilder,
@ -44,137 +42,12 @@ use lemmy_utils::{
location_info,
make_apub_endpoint,
naive_from_unix,
ConnectionId,
EndpointType,
LemmyError,
};
use serde::{Deserialize, Serialize};
use std::str::FromStr;
#[derive(Serialize, Deserialize)]
pub struct GetCommunity {
id: Option<i32>,
pub name: Option<String>,
auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetCommunityResponse {
pub community: CommunityView,
pub moderators: Vec<CommunityModeratorView>,
pub online: usize,
}
#[derive(Serialize, Deserialize)]
pub struct CreateCommunity {
name: String,
title: String,
description: Option<String>,
icon: Option<String>,
banner: Option<String>,
category_id: i32,
nsfw: bool,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct CommunityResponse {
pub community: CommunityView,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ListCommunities {
pub sort: String,
pub page: Option<i64>,
pub limit: Option<i64>,
pub auth: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct ListCommunitiesResponse {
pub communities: Vec<CommunityView>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct BanFromCommunity {
pub community_id: i32,
user_id: i32,
ban: bool,
remove_data: Option<bool>,
reason: Option<String>,
expires: Option<i64>,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct BanFromCommunityResponse {
user: UserView,
banned: bool,
}
#[derive(Serialize, Deserialize)]
pub struct AddModToCommunity {
pub community_id: i32,
user_id: i32,
added: bool,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddModToCommunityResponse {
moderators: Vec<CommunityModeratorView>,
}
#[derive(Serialize, Deserialize)]
pub struct EditCommunity {
pub edit_id: i32,
title: String,
description: Option<String>,
icon: Option<String>,
banner: Option<String>,
category_id: i32,
nsfw: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeleteCommunity {
pub edit_id: i32,
deleted: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct RemoveCommunity {
pub edit_id: i32,
removed: bool,
reason: Option<String>,
expires: Option<i64>,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct FollowCommunity {
community_id: i32,
follow: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetFollowedCommunities {
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetFollowedCommunitiesResponse {
communities: Vec<CommunityFollowerView>,
}
#[derive(Serialize, Deserialize)]
pub struct TransferCommunity {
community_id: i32,
user_id: i32,
auth: String,
}
#[async_trait::async_trait(?Send)]
impl Perform for GetCommunity {
type Response = GetCommunityResponse;

View file

@ -1,5 +1,6 @@
use crate::{api::claims::Claims, blocking, ConnectionId, DbPool, LemmyContext, LemmyError};
use crate::{api::claims::Claims, blocking, DbPool, LemmyContext};
use actix_web::web::Data;
use lemmy_api_structs::APIError;
use lemmy_db::{
community::Community,
community_view::CommunityUserBanView,
@ -7,8 +8,7 @@ use lemmy_db::{
user::User_,
Crud,
};
use lemmy_utils::{slur_check, slurs_vec_to_str};
use thiserror::Error;
use lemmy_utils::{slur_check, slurs_vec_to_str, ConnectionId, LemmyError};
pub mod claims;
pub mod comment;
@ -17,20 +17,6 @@ pub mod post;
pub mod site;
pub mod user;
#[derive(Debug, Error)]
#[error("{{\"error\":\"{message}\"}}")]
pub struct APIError {
pub message: String,
}
impl APIError {
pub fn err(msg: &str) -> Self {
APIError {
message: msg.to_string(),
}
}
}
#[async_trait::async_trait(?Send)]
pub trait Perform {
type Response: serde::ser::Serialize + Send;

View file

@ -6,7 +6,6 @@ use crate::{
get_user_from_jwt,
get_user_from_jwt_opt,
is_mod_or_admin,
APIError,
Perform,
},
apub::{ApubLikeableType, ApubObjectType},
@ -16,11 +15,10 @@ use crate::{
messages::{GetPostUsersOnline, JoinCommunityRoom, JoinPostRoom, SendPost},
UserOperation,
},
ConnectionId,
LemmyContext,
LemmyError,
};
use actix_web::web::Data;
use lemmy_api_structs::{post::*, APIError};
use lemmy_db::{
comment_view::*,
community_view::*,
@ -35,110 +33,16 @@ use lemmy_db::{
Saveable,
SortType,
};
use lemmy_utils::{is_valid_post_title, make_apub_endpoint, EndpointType};
use serde::{Deserialize, Serialize};
use lemmy_utils::{
is_valid_post_title,
make_apub_endpoint,
ConnectionId,
EndpointType,
LemmyError,
};
use std::str::FromStr;
use url::Url;
#[derive(Serialize, Deserialize, Debug)]
pub struct CreatePost {
name: String,
url: Option<String>,
body: Option<String>,
nsfw: bool,
pub community_id: i32,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PostResponse {
pub post: PostView,
}
#[derive(Serialize, Deserialize)]
pub struct GetPost {
pub id: i32,
auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetPostResponse {
post: PostView,
comments: Vec<CommentView>,
community: CommunityView,
moderators: Vec<CommunityModeratorView>,
pub online: usize,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct GetPosts {
type_: String,
sort: String,
page: Option<i64>,
limit: Option<i64>,
pub community_id: Option<i32>,
pub community_name: Option<String>,
auth: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct GetPostsResponse {
pub posts: Vec<PostView>,
}
#[derive(Serialize, Deserialize)]
pub struct CreatePostLike {
post_id: i32,
score: i16,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditPost {
pub edit_id: i32,
name: String,
url: Option<String>,
body: Option<String>,
nsfw: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeletePost {
pub edit_id: i32,
deleted: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct RemovePost {
pub edit_id: i32,
removed: bool,
reason: Option<String>,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct LockPost {
pub edit_id: i32,
locked: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct StickyPost {
pub edit_id: i32,
stickied: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct SavePost {
post_id: i32,
save: bool,
auth: String,
}
#[async_trait::async_trait(?Send)]
impl Perform for CreatePost {
type Response = PostResponse;

View file

@ -1,4 +1,3 @@
use super::user::Register;
use crate::{
api::{
check_slurs,
@ -6,7 +5,6 @@ use crate::{
get_user_from_jwt,
get_user_from_jwt_opt,
is_admin,
APIError,
Perform,
},
apub::fetcher::search_by_apub_id,
@ -16,12 +14,11 @@ use crate::{
messages::{GetUsersOnline, SendAllMessage},
UserOperation,
},
ConnectionId,
LemmyContext,
LemmyError,
};
use actix_web::web::Data;
use anyhow::Context;
use lemmy_api_structs::{site::*, user::Register, APIError};
use lemmy_db::{
category::*,
comment_view::*,
@ -33,133 +30,15 @@ use lemmy_db::{
post_view::*,
site::*,
site_view::*,
user::*,
user_view::*,
Crud,
SearchType,
SortType,
};
use lemmy_utils::{location_info, settings::Settings};
use lemmy_utils::{location_info, settings::Settings, ConnectionId, LemmyError};
use log::{debug, info};
use serde::{Deserialize, Serialize};
use std::str::FromStr;
#[derive(Serialize, Deserialize)]
pub struct ListCategories {}
#[derive(Serialize, Deserialize)]
pub struct ListCategoriesResponse {
categories: Vec<Category>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Search {
q: String,
type_: String,
community_id: Option<i32>,
sort: String,
page: Option<i64>,
limit: Option<i64>,
auth: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SearchResponse {
pub type_: String,
pub comments: Vec<CommentView>,
pub posts: Vec<PostView>,
pub communities: Vec<CommunityView>,
pub users: Vec<UserView>,
}
#[derive(Serialize, Deserialize)]
pub struct GetModlog {
mod_user_id: Option<i32>,
community_id: Option<i32>,
page: Option<i64>,
limit: Option<i64>,
}
#[derive(Serialize, Deserialize)]
pub struct GetModlogResponse {
removed_posts: Vec<ModRemovePostView>,
locked_posts: Vec<ModLockPostView>,
stickied_posts: Vec<ModStickyPostView>,
removed_comments: Vec<ModRemoveCommentView>,
removed_communities: Vec<ModRemoveCommunityView>,
banned_from_community: Vec<ModBanFromCommunityView>,
banned: Vec<ModBanView>,
added_to_community: Vec<ModAddCommunityView>,
added: Vec<ModAddView>,
}
#[derive(Serialize, Deserialize)]
pub struct CreateSite {
pub name: String,
pub description: Option<String>,
pub icon: Option<String>,
pub banner: Option<String>,
pub enable_downvotes: bool,
pub open_registration: bool,
pub enable_nsfw: bool,
pub auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditSite {
name: String,
description: Option<String>,
icon: Option<String>,
banner: Option<String>,
enable_downvotes: bool,
open_registration: bool,
enable_nsfw: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetSite {
auth: Option<String>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct SiteResponse {
site: SiteView,
}
#[derive(Serialize, Deserialize)]
pub struct GetSiteResponse {
site: Option<SiteView>,
admins: Vec<UserView>,
banned: Vec<UserView>,
pub online: usize,
version: String,
my_user: Option<User_>,
federated_instances: Vec<String>,
}
#[derive(Serialize, Deserialize)]
pub struct TransferSite {
user_id: i32,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetSiteConfig {
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetSiteConfigResponse {
config_hjson: String,
}
#[derive(Serialize, Deserialize)]
pub struct SaveSiteConfig {
config_hjson: String,
auth: String,
}
#[async_trait::async_trait(?Send)]
impl Perform for ListCategories {
type Response = ListCategoriesResponse;

View file

@ -1,13 +1,5 @@
use crate::{
api::{
check_slurs,
claims::Claims,
get_user_from_jwt,
get_user_from_jwt_opt,
is_admin,
APIError,
Perform,
},
api::{check_slurs, claims::Claims, get_user_from_jwt, get_user_from_jwt_opt, is_admin, Perform},
apub::ApubObjectType,
blocking,
captcha_espeak_wav_base64,
@ -15,15 +7,14 @@ use crate::{
messages::{CaptchaItem, CheckCaptcha, JoinUserRoom, SendAllMessage, SendUserRoomMessage},
UserOperation,
},
ConnectionId,
LemmyContext,
LemmyError,
};
use actix_web::web::Data;
use anyhow::Context;
use bcrypt::verify;
use captcha::{gen, Difficulty};
use chrono::Duration;
use lemmy_api_structs::{user::*, APIError};
use lemmy_db::{
comment::*,
comment_view::*,
@ -60,242 +51,13 @@ use lemmy_utils::{
remove_slurs,
send_email,
settings::Settings,
ConnectionId,
EndpointType,
LemmyError,
};
use log::error;
use serde::{Deserialize, Serialize};
use std::str::FromStr;
#[derive(Serialize, Deserialize, Debug)]
pub struct Login {
username_or_email: String,
password: String,
}
#[derive(Serialize, Deserialize)]
pub struct Register {
pub username: String,
pub email: Option<String>,
pub password: String,
pub password_verify: String,
pub admin: bool,
pub show_nsfw: bool,
pub captcha_uuid: Option<String>,
pub captcha_answer: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetCaptcha {}
#[derive(Serialize, Deserialize)]
pub struct GetCaptchaResponse {
ok: Option<CaptchaResponse>,
}
#[derive(Serialize, Deserialize)]
pub struct CaptchaResponse {
png: String, // A Base64 encoded png
wav: Option<String>, // A Base64 encoded wav audio
uuid: String,
}
#[derive(Serialize, Deserialize)]
pub struct SaveUserSettings {
show_nsfw: bool,
theme: String,
default_sort_type: i16,
default_listing_type: i16,
lang: String,
avatar: Option<String>,
banner: Option<String>,
preferred_username: Option<String>,
email: Option<String>,
bio: Option<String>,
matrix_user_id: Option<String>,
new_password: Option<String>,
new_password_verify: Option<String>,
old_password: Option<String>,
show_avatars: bool,
send_notifications_to_email: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct LoginResponse {
pub jwt: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserDetails {
user_id: Option<i32>,
username: Option<String>,
sort: String,
page: Option<i64>,
limit: Option<i64>,
community_id: Option<i32>,
saved_only: bool,
auth: Option<String>,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserDetailsResponse {
user: UserView,
follows: Vec<CommunityFollowerView>,
moderates: Vec<CommunityModeratorView>,
comments: Vec<CommentView>,
posts: Vec<PostView>,
}
#[derive(Serialize, Deserialize)]
pub struct GetRepliesResponse {
replies: Vec<ReplyView>,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserMentionsResponse {
mentions: Vec<UserMentionView>,
}
#[derive(Serialize, Deserialize)]
pub struct MarkAllAsRead {
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct AddAdmin {
user_id: i32,
added: bool,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct AddAdminResponse {
admins: Vec<UserView>,
}
#[derive(Serialize, Deserialize)]
pub struct BanUser {
user_id: i32,
ban: bool,
remove_data: Option<bool>,
reason: Option<String>,
expires: Option<i64>,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct BanUserResponse {
user: UserView,
banned: bool,
}
#[derive(Serialize, Deserialize)]
pub struct GetReplies {
sort: String,
page: Option<i64>,
limit: Option<i64>,
unread_only: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetUserMentions {
sort: String,
page: Option<i64>,
limit: Option<i64>,
unread_only: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct MarkUserMentionAsRead {
user_mention_id: i32,
read: bool,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct UserMentionResponse {
mention: UserMentionView,
}
#[derive(Serialize, Deserialize)]
pub struct DeleteAccount {
password: String,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct PasswordReset {
email: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PasswordResetResponse {}
#[derive(Serialize, Deserialize)]
pub struct PasswordChange {
token: String,
password: String,
password_verify: String,
}
#[derive(Serialize, Deserialize)]
pub struct CreatePrivateMessage {
content: String,
pub recipient_id: i32,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct EditPrivateMessage {
edit_id: i32,
content: String,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct DeletePrivateMessage {
edit_id: i32,
deleted: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct MarkPrivateMessageAsRead {
edit_id: i32,
read: bool,
auth: String,
}
#[derive(Serialize, Deserialize)]
pub struct GetPrivateMessages {
unread_only: bool,
page: Option<i64>,
limit: Option<i64>,
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PrivateMessagesResponse {
messages: Vec<PrivateMessageView>,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct PrivateMessageResponse {
pub message: PrivateMessageView,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct UserJoin {
auth: String,
}
#[derive(Serialize, Deserialize, Clone)]
pub struct UserJoinResponse {
pub user_id: i32,
}
#[async_trait::async_trait(?Send)]
impl Perform for Login {
type Response = LoginResponse;

View file

@ -1,14 +1,13 @@
use crate::{
apub::{activity_queue::send_activity, community::do_announce, insert_activity},
LemmyContext,
LemmyError,
};
use activitystreams::{
base::{Extends, ExtendsExt},
object::AsObject,
};
use lemmy_db::{community::Community, user::User_};
use lemmy_utils::{get_apub_protocol_string, settings::Settings};
use lemmy_utils::{get_apub_protocol_string, settings::Settings, LemmyError};
use serde::{export::fmt::Debug, Serialize};
use url::{ParseError, Url};
use uuid::Uuid;

View file

@ -1,7 +1,4 @@
use crate::{
apub::{check_is_apub_id_valid, extensions::signatures::sign, ActorType},
LemmyError,
};
use crate::apub::{check_is_apub_id_valid, extensions::signatures::sign, ActorType};
use activitystreams::{
base::{Extends, ExtendsExt},
object::AsObject,
@ -17,7 +14,7 @@ use background_jobs::{
QueueHandle,
WorkerConfig,
};
use lemmy_utils::{location_info, settings::Settings};
use lemmy_utils::{location_info, settings::Settings, LemmyError};
use log::warn;
use serde::{Deserialize, Serialize};
use std::{future::Future, pin::Pin};

View file

@ -20,7 +20,6 @@ use crate::{
blocking,
DbPool,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{
@ -54,6 +53,7 @@ use lemmy_utils::{
location_info,
remove_slurs,
scrape_text_for_mentions,
LemmyError,
MentionData,
};
use log::debug;

View file

@ -18,7 +18,6 @@ use crate::{
blocking,
DbPool,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{
@ -48,7 +47,7 @@ use lemmy_db::{
post::Post,
user::User_,
};
use lemmy_utils::{convert_datetime, get_apub_protocol_string, location_info};
use lemmy_utils::{convert_datetime, get_apub_protocol_string, location_info, LemmyError};
use serde::Deserialize;
use url::Url;

View file

@ -1,8 +1,8 @@
use crate::LemmyError;
use activitystreams::unparsed::UnparsedMutExt;
use activitystreams_ext::UnparsedExtension;
use diesel::PgConnection;
use lemmy_db::{category::Category, Crud};
use lemmy_utils::LemmyError;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Default, Deserialize, Serialize)]

View file

@ -1,4 +1,4 @@
use crate::{apub::ActorType, LemmyError};
use crate::apub::ActorType;
use activitystreams::unparsed::UnparsedMutExt;
use activitystreams_ext::UnparsedExtension;
use actix_web::{client::ClientRequest, HttpRequest};
@ -7,7 +7,7 @@ use http_signature_normalization_actix::{
digest::{DigestClient, SignExt},
Config,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
use log::debug;
use openssl::{
hash::MessageDigest,

View file

@ -1,5 +1,4 @@
use crate::{
api::site::SearchResponse,
apub::{
check_is_apub_id_valid,
ActorType,
@ -12,12 +11,12 @@ use crate::{
blocking,
request::{retry, RecvError},
LemmyContext,
LemmyError,
};
use activitystreams::{base::BaseExt, collection::OrderedCollection, object::Note, prelude::*};
use anyhow::{anyhow, Context};
use chrono::NaiveDateTime;
use diesel::result::Error::NotFound;
use lemmy_api_structs::site::SearchResponse;
use lemmy_db::{
comment::{Comment, CommentForm},
comment_view::CommentView,
@ -32,7 +31,7 @@ use lemmy_db::{
Joinable,
SearchType,
};
use lemmy_utils::{get_apub_protocol_string, location_info};
use lemmy_utils::{get_apub_protocol_string, location_info, LemmyError};
use log::debug;
use reqwest::Client;
use serde::Deserialize;

View file

@ -12,7 +12,6 @@ use crate::{
shared_inbox::{get_community_id_from_activity, receive_unhandled_activity},
},
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::*,
@ -21,7 +20,7 @@ use activitystreams::{
};
use actix_web::HttpResponse;
use anyhow::Context;
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
pub async fn receive_announce(
activity: AnyBase,

View file

@ -1,8 +1,5 @@
use crate::{
api::{
comment::{send_local_notifs, CommentResponse},
post::PostResponse,
},
api::comment::send_local_notifs,
apub::{
inbox::shared_inbox::{
announce_if_community_is_local,
@ -19,18 +16,18 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{activity::Create, base::AnyBase, object::Note, prelude::*};
use actix_web::HttpResponse;
use anyhow::Context;
use lemmy_api_structs::{comment::CommentResponse, post::PostResponse};
use lemmy_db::{
comment::{Comment, CommentForm},
comment_view::CommentView,
post::{Post, PostForm},
post_view::PostView,
};
use lemmy_utils::{location_info, scrape_text_for_mentions};
use lemmy_utils::{location_info, scrape_text_for_mentions, LemmyError};
pub async fn receive_create(
activity: AnyBase,

View file

@ -1,5 +1,4 @@
use crate::{
api::{comment::CommentResponse, community::CommunityResponse, post::PostResponse},
apub::{
fetcher::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
inbox::shared_inbox::{
@ -18,11 +17,15 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{activity::Delete, base::AnyBase, object::Note, prelude::*};
use actix_web::HttpResponse;
use anyhow::Context;
use lemmy_api_structs::{
comment::CommentResponse,
community::CommunityResponse,
post::PostResponse,
};
use lemmy_db::{
comment::{Comment, CommentForm},
comment_view::CommentView,
@ -33,7 +36,7 @@ use lemmy_db::{
post_view::PostView,
Crud,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
pub async fn receive_delete(
activity: AnyBase,

View file

@ -1,5 +1,4 @@
use crate::{
api::{comment::CommentResponse, post::PostResponse},
apub::{
fetcher::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
inbox::shared_inbox::{
@ -16,11 +15,11 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{activity::Dislike, base::AnyBase, object::Note, prelude::*};
use actix_web::HttpResponse;
use anyhow::Context;
use lemmy_api_structs::{comment::CommentResponse, post::PostResponse};
use lemmy_db::{
comment::{CommentForm, CommentLike, CommentLikeForm},
comment_view::CommentView,
@ -28,7 +27,7 @@ use lemmy_db::{
post_view::PostView,
Likeable,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
pub async fn receive_dislike(
activity: AnyBase,

View file

@ -1,5 +1,4 @@
use crate::{
api::{comment::CommentResponse, post::PostResponse},
apub::{
fetcher::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
inbox::shared_inbox::{
@ -16,11 +15,11 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{activity::Like, base::AnyBase, object::Note, prelude::*};
use actix_web::HttpResponse;
use anyhow::Context;
use lemmy_api_structs::{comment::CommentResponse, post::PostResponse};
use lemmy_db::{
comment::{CommentForm, CommentLike, CommentLikeForm},
comment_view::CommentView,
@ -28,7 +27,7 @@ use lemmy_db::{
post_view::PostView,
Likeable,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
pub async fn receive_like(
activity: AnyBase,

View file

@ -1,5 +1,4 @@
use crate::{
api::{comment::CommentResponse, community::CommunityResponse, post::PostResponse},
apub::{
fetcher::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
inbox::shared_inbox::{
@ -19,11 +18,15 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{activity::Remove, base::AnyBase, object::Note, prelude::*};
use actix_web::HttpResponse;
use anyhow::{anyhow, Context};
use lemmy_api_structs::{
comment::CommentResponse,
community::CommunityResponse,
post::PostResponse,
};
use lemmy_db::{
comment::{Comment, CommentForm},
comment_view::CommentView,
@ -34,7 +37,7 @@ use lemmy_db::{
post_view::PostView,
Crud,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
pub async fn receive_remove(
activity: AnyBase,

View file

@ -1,5 +1,4 @@
use crate::{
api::{comment::CommentResponse, community::CommunityResponse, post::PostResponse},
apub::{
fetcher::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
inbox::shared_inbox::{
@ -18,7 +17,6 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::*,
@ -28,6 +26,11 @@ use activitystreams::{
};
use actix_web::HttpResponse;
use anyhow::{anyhow, Context};
use lemmy_api_structs::{
comment::CommentResponse,
community::CommunityResponse,
post::PostResponse,
};
use lemmy_db::{
comment::{Comment, CommentForm, CommentLike},
comment_view::CommentView,
@ -39,7 +42,7 @@ use lemmy_db::{
Crud,
Likeable,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
pub async fn receive_undo(
activity: AnyBase,

View file

@ -1,8 +1,5 @@
use crate::{
api::{
comment::{send_local_notifs, CommentResponse},
post::PostResponse,
},
api::comment::send_local_notifs,
apub::{
fetcher::{get_or_fetch_and_insert_comment, get_or_fetch_and_insert_post},
inbox::shared_inbox::{
@ -20,11 +17,11 @@ use crate::{
UserOperation,
},
LemmyContext,
LemmyError,
};
use activitystreams::{activity::Update, base::AnyBase, object::Note, prelude::*};
use actix_web::HttpResponse;
use anyhow::Context;
use lemmy_api_structs::{comment::CommentResponse, post::PostResponse};
use lemmy_db::{
comment::{Comment, CommentForm},
comment_view::CommentView,
@ -32,7 +29,7 @@ use lemmy_db::{
post_view::PostView,
Crud,
};
use lemmy_utils::{location_info, scrape_text_for_mentions};
use lemmy_utils::{location_info, scrape_text_for_mentions, LemmyError};
pub async fn receive_update(
activity: AnyBase,

View file

@ -8,7 +8,6 @@ use crate::{
},
blocking,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{ActorAndObject, Follow, Undo},
@ -22,7 +21,7 @@ use lemmy_db::{
user::User_,
Followable,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
use log::debug;
use serde::{Deserialize, Serialize};
use std::fmt::Debug;

View file

@ -21,7 +21,6 @@ use crate::{
insert_activity,
},
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{ActorAndObject, ActorAndObjectRef},
@ -32,7 +31,7 @@ use activitystreams::{
use actix_web::{web, HttpRequest, HttpResponse};
use anyhow::Context;
use lemmy_db::user::User_;
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
use log::debug;
use serde::{Deserialize, Serialize};
use std::fmt::Debug;

View file

@ -1,5 +1,4 @@
use crate::{
api::user::PrivateMessageResponse,
apub::{
check_is_apub_id_valid,
extensions::signatures::verify,
@ -10,7 +9,6 @@ use crate::{
blocking,
websocket::{messages::SendUserRoomMessage, UserOperation},
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{Accept, ActorAndObject, Create, Delete, Undo, Update},
@ -20,6 +18,7 @@ use activitystreams::{
};
use actix_web::{web, HttpRequest, HttpResponse};
use anyhow::Context;
use lemmy_api_structs::user::PrivateMessageResponse;
use lemmy_db::{
community::{CommunityFollower, CommunityFollowerForm},
naive_now,
@ -29,7 +28,7 @@ use lemmy_db::{
Crud,
Followable,
};
use lemmy_utils::location_info;
use lemmy_utils::{location_info, LemmyError};
use log::debug;
use serde::{Deserialize, Serialize};
use std::fmt::Debug;

View file

@ -20,7 +20,6 @@ use crate::{
routes::webfinger::WebFingerResponse,
DbPool,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::Follow,
@ -40,6 +39,7 @@ use lemmy_utils::{
get_apub_protocol_string,
location_info,
settings::Settings,
LemmyError,
MentionData,
};
use log::debug;

View file

@ -18,7 +18,6 @@ use crate::{
blocking,
DbPool,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{
@ -44,7 +43,7 @@ use lemmy_db::{
user::User_,
Crud,
};
use lemmy_utils::{convert_datetime, location_info, remove_slurs};
use lemmy_utils::{convert_datetime, location_info, remove_slurs, LemmyError};
use serde::Deserialize;
use url::Url;

View file

@ -15,7 +15,6 @@ use crate::{
blocking,
DbPool,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{
@ -34,7 +33,7 @@ use lemmy_db::{
user::User_,
Crud,
};
use lemmy_utils::{convert_datetime, location_info};
use lemmy_utils::{convert_datetime, location_info, LemmyError};
use url::Url;
#[async_trait::async_trait(?Send)]

View file

@ -15,7 +15,6 @@ use crate::{
blocking,
DbPool,
LemmyContext,
LemmyError,
};
use activitystreams::{
activity::{
@ -34,7 +33,7 @@ use lemmy_db::{
naive_now,
user::{UserForm, User_},
};
use lemmy_utils::{convert_datetime, location_info};
use lemmy_utils::{convert_datetime, location_info, LemmyError};
use serde::Deserialize;
use url::Url;

View file

@ -1,5 +1,4 @@
// This is for db migrations that require code
use crate::LemmyError;
use diesel::{
sql_types::{Nullable, Text},
*,
@ -19,6 +18,7 @@ use lemmy_utils::{
make_apub_endpoint,
settings::Settings,
EndpointType,
LemmyError,
};
use log::info;

View file

@ -24,20 +24,19 @@ pub extern crate strum;
pub mod api;
pub mod apub;
pub mod code_migrations;
pub mod rate_limit;
pub mod request;
pub mod routes;
pub mod version;
pub mod websocket;
use crate::request::{retry, RecvError};
use crate::websocket::chat_server::ChatServer;
use crate::{
request::{retry, RecvError},
websocket::chat_server::ChatServer,
};
use actix::Addr;
use actix_web::dev::ConnectionInfo;
use anyhow::anyhow;
use background_jobs::QueueHandle;
use lemmy_utils::{get_apub_protocol_string, settings::Settings};
use lemmy_utils::{get_apub_protocol_string, settings::Settings, LemmyError};
use log::error;
use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
use reqwest::Client;
@ -45,33 +44,6 @@ use serde::Deserialize;
use std::process::Command;
pub type DbPool = diesel::r2d2::Pool<diesel::r2d2::ConnectionManager<diesel::PgConnection>>;
pub type ConnectionId = usize;
pub type PostId = i32;
pub type CommunityId = i32;
pub type UserId = i32;
pub type IPAddr = String;
#[derive(Debug)]
pub struct LemmyError {
inner: anyhow::Error,
}
impl<T> From<T> for LemmyError
where
T: Into<anyhow::Error>,
{
fn from(t: T) -> Self {
LemmyError { inner: t.into() }
}
}
impl std::fmt::Display for LemmyError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.inner.fmt(f)
}
}
impl actix_web::error::ResponseError for LemmyError {}
pub struct LemmyContext {
pub pool: DbPool,
@ -252,16 +224,6 @@ pub async fn is_image_content_type(client: &Client, test: &str) -> Result<(), Le
}
}
pub fn get_ip(conn_info: &ConnectionInfo) -> String {
conn_info
.realip_remote_addr()
.unwrap_or("127.0.0.1:12345")
.split(':')
.next()
.unwrap_or("127.0.0.1")
.to_string()
}
pub async fn blocking<F, T>(pool: &DbPool, f: F) -> Result<T, LemmyError>
where
F: FnOnce(&diesel::PgConnection) -> T + Send + 'static,

View file

@ -18,17 +18,16 @@ use diesel::{
PgConnection,
};
use lemmy_db::get_database_url_from_env;
use lemmy_rate_limit::{rate_limiter::RateLimiter, RateLimit};
use lemmy_server::{
apub::activity_queue::create_activity_queue,
blocking,
code_migrations::run_advanced_migrations,
rate_limit::{rate_limiter::RateLimiter, RateLimit},
routes::*,
websocket::chat_server::ChatServer,
LemmyContext,
LemmyError,
};
use lemmy_utils::{settings::Settings, CACHE_CONTROL_REGEX};
use lemmy_utils::{settings::Settings, LemmyError, CACHE_CONTROL_REGEX};
use reqwest::Client;
use std::sync::Arc;
use tokio::sync::Mutex;

View file

@ -1,5 +1,5 @@
use crate::LemmyError;
use anyhow::anyhow;
use lemmy_utils::LemmyError;
use std::future::Future;
use thiserror::Error;

View file

@ -1,9 +1,7 @@
use crate::{
api::{comment::*, community::*, post::*, site::*, user::*, Perform},
rate_limit::RateLimit,
LemmyContext,
};
use crate::{api::Perform, LemmyContext};
use actix_web::{error::ErrorBadRequest, *};
use lemmy_api_structs::{comment::*, community::*, post::*, site::*, user::*};
use lemmy_rate_limit::RateLimit;
use serde::Serialize;
pub fn config(cfg: &mut web::ServiceConfig, rate_limit: &RateLimit) {

View file

@ -1,4 +1,4 @@
use crate::{api::claims::Claims, blocking, LemmyContext, LemmyError};
use crate::{api::claims::Claims, blocking, LemmyContext};
use actix_web::{error::ErrorBadRequest, *};
use anyhow::anyhow;
use chrono::{DateTime, NaiveDateTime, Utc};
@ -13,7 +13,7 @@ use lemmy_db::{
ListingType,
SortType,
};
use lemmy_utils::{markdown_to_html, settings::Settings};
use lemmy_utils::{markdown_to_html, settings::Settings, LemmyError};
use rss::{CategoryBuilder, ChannelBuilder, GuidBuilder, Item, ItemBuilder};
use serde::Deserialize;
use std::str::FromStr;

View file

@ -1,7 +1,7 @@
use crate::rate_limit::RateLimit;
use actix::clock::Duration;
use actix_web::{body::BodyStream, http::StatusCode, *};
use awc::Client;
use lemmy_rate_limit::RateLimit;
use lemmy_utils::settings::Settings;
use serde::{Deserialize, Serialize};

View file

@ -1,8 +1,8 @@
use crate::{blocking, version, LemmyContext, LemmyError};
use crate::{blocking, version, LemmyContext};
use actix_web::{body::Body, error::ErrorBadRequest, *};
use anyhow::anyhow;
use lemmy_db::site_view::SiteView;
use lemmy_utils::{get_apub_protocol_string, settings::Settings};
use lemmy_utils::{get_apub_protocol_string, settings::Settings, LemmyError};
use serde::{Deserialize, Serialize};
use url::Url;

View file

@ -1,8 +1,13 @@
use crate::{blocking, LemmyContext, LemmyError};
use crate::{blocking, LemmyContext};
use actix_web::{error::ErrorBadRequest, web::Query, *};
use anyhow::anyhow;
use lemmy_db::{community::Community, user::User_};
use lemmy_utils::{settings::Settings, WEBFINGER_COMMUNITY_REGEX, WEBFINGER_USER_REGEX};
use lemmy_utils::{
settings::Settings,
LemmyError,
WEBFINGER_COMMUNITY_REGEX,
WEBFINGER_USER_REGEX,
};
use serde::{Deserialize, Serialize};
#[derive(Deserialize)]

View file

@ -1,5 +1,4 @@
use crate::{
get_ip,
websocket::{
chat_server::ChatServer,
messages::{Connect, Disconnect, StandardMessage, WSMessage},
@ -9,6 +8,7 @@ use crate::{
use actix::prelude::*;
use actix_web::*;
use actix_web_actors::ws;
use lemmy_utils::get_ip;
use log::{debug, error, info};
use std::time::{Duration, Instant};

View file

@ -1,18 +1,10 @@
use crate::{
api::{comment::*, community::*, post::*, site::*, user::*, APIError},
rate_limit::RateLimit,
websocket::{
handlers::{do_user_operation, to_json_string, Args},
messages::*,
UserOperation,
},
CommunityId,
ConnectionId,
IPAddr,
LemmyContext,
LemmyError,
PostId,
UserId,
};
use actix::prelude::*;
use anyhow::Context as acontext;
@ -21,7 +13,9 @@ use diesel::{
r2d2::{ConnectionManager, Pool},
PgConnection,
};
use lemmy_utils::location_info;
use lemmy_api_structs::{comment::*, community::*, post::*, site::*, user::*, APIError};
use lemmy_rate_limit::RateLimit;
use lemmy_utils::{location_info, CommunityId, ConnectionId, IPAddr, LemmyError, PostId, UserId};
use rand::rngs::ThreadRng;
use reqwest::Client;
use serde::Serialize;

View file

@ -1,19 +1,17 @@
use crate::{
api::Perform,
rate_limit::RateLimit,
websocket::{
chat_server::{ChatServer, SessionInfo},
messages::*,
UserOperation,
},
ConnectionId,
IPAddr,
LemmyContext,
LemmyError,
};
use actix::{Actor, Context, Handler, ResponseFuture};
use actix_web::web;
use lemmy_db::naive_now;
use lemmy_rate_limit::RateLimit;
use lemmy_utils::{ConnectionId, IPAddr, LemmyError};
use log::{error, info};
use rand::Rng;
use serde::{Deserialize, Serialize};

View file

@ -1,13 +1,7 @@
use crate::{
api::{comment::CommentResponse, post::PostResponse},
websocket::UserOperation,
CommunityId,
ConnectionId,
IPAddr,
PostId,
UserId,
};
use crate::websocket::UserOperation;
use actix::{prelude::*, Recipient};
use lemmy_api_structs::{comment::CommentResponse, post::PostResponse};
use lemmy_utils::{CommunityId, ConnectionId, IPAddr, PostId, UserId};
use serde::{Deserialize, Serialize};
/// Chat server sends this messages to session