grishka/lemmy
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Split lemmy_db into separate workspaces

Browse source
This commit is contained in:
Felix Ableitner 2020-12-18 17:17:21 +01:00
parent 6d96f105c6
commit 089d812dc8
47 changed files with 269 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
Cargo.lock generated
View file

@ -1789,6 +1789,7 @@ dependencies = [
"chrono", "chrono",
"diesel", "diesel",
"lazy_static", "lazy_static",
"lemmy_db_schema",
"lemmy_utils", "lemmy_utils",
"log", "log",
"regex", "regex",
@ -1800,6 +1801,13 @@ dependencies = [
"url", "url",
] ]
[[package]]
name = "lemmy_db_schema"
version = "0.1.0"
dependencies = [
"diesel",
]
[[package]] [[package]]
name = "lemmy_rate_limit" name = "lemmy_rate_limit"
version = "0.1.0" version = "0.1.0"
@ -1835,6 +1843,7 @@ dependencies = [
"lemmy_api", "lemmy_api",
"lemmy_apub", "lemmy_apub",
"lemmy_db", "lemmy_db",
"lemmy_db_schema",
"lemmy_rate_limit", "lemmy_rate_limit",
"lemmy_structs", "lemmy_structs",
"lemmy_utils", "lemmy_utils",

2
Cargo.toml
View file

@ -12,6 +12,7 @@ members = [
"lemmy_apub", "lemmy_apub",
"lemmy_utils", "lemmy_utils",
"lemmy_db", "lemmy_db",
"lemmy_db_schema",
"lemmy_structs", "lemmy_structs",
"lemmy_rate_limit", "lemmy_rate_limit",
"lemmy_websocket", "lemmy_websocket",
@ -21,6 +22,7 @@ members = [
lemmy_api = { path = "./lemmy_api" } lemmy_api = { path = "./lemmy_api" }
lemmy_apub = { path = "./lemmy_apub" } lemmy_apub = { path = "./lemmy_apub" }
lemmy_utils = { path = "./lemmy_utils" } lemmy_utils = { path = "./lemmy_utils" }
lemmy_db_schema = { path = "./lemmy_db_schema" }
lemmy_db = { path = "./lemmy_db" } lemmy_db = { path = "./lemmy_db" }
lemmy_structs = { path = "./lemmy_structs" } lemmy_structs = { path = "./lemmy_structs" }
lemmy_rate_limit = { path = "./lemmy_rate_limit" } lemmy_rate_limit = { path = "./lemmy_rate_limit" }

1
lemmy_db/Cargo.toml
View file

@ -9,6 +9,7 @@ path = "src/lib.rs"
[dependencies] [dependencies]
lemmy_utils = { path = "../lemmy_utils" } lemmy_utils = { path = "../lemmy_utils" }
lemmy_db_schema = { path = "../lemmy_db_schema" }
diesel = { version = "1.4.5", features = ["postgres","chrono","r2d2","serde_json"] } diesel = { version = "1.4.5", features = ["postgres","chrono","r2d2","serde_json"] }
chrono = { version = "0.4.19", features = ["serde"] } chrono = { version = "0.4.19", features = ["serde"] }
serde = { version = "1.0.118", features = ["derive"] } serde = { version = "1.0.118", features = ["derive"] }

2
lemmy_db/src/aggregates/comment_aggregates.rs
View file

@ -1,5 +1,5 @@
use crate::schema::comment_aggregates;
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::comment_aggregates;
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)] #[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)]

2
lemmy_db/src/aggregates/community_aggregates.rs
View file

@ -1,5 +1,5 @@
use crate::schema::community_aggregates;
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::community_aggregates;
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)] #[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)]

2
lemmy_db/src/aggregates/post_aggregates.rs
View file

@ -1,5 +1,5 @@
use crate::schema::post_aggregates;
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::post_aggregates;
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)] #[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)]

2
lemmy_db/src/aggregates/site_aggregates.rs
View file

@ -1,5 +1,5 @@
use crate::schema::site_aggregates;
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::site_aggregates;
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)] #[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)]

2
lemmy_db/src/aggregates/user_aggregates.rs
View file

@ -1,5 +1,5 @@
use crate::schema::user_aggregates;
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::user_aggregates;
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)] #[derive(Queryable, Associations, Identifiable, PartialEq, Debug, Serialize, Clone)]

1
lemmy_db/src/lib.rs
View file

@ -12,7 +12,6 @@ use serde::{Deserialize, Serialize};
use std::{env, env::VarError}; use std::{env, env::VarError};
pub mod aggregates; pub mod aggregates;
pub mod schema;
pub mod source; pub mod source;
pub mod views; pub mod views;

13
lemmy_db/src/source/activity.rs
View file

@ -1,5 +1,6 @@
use crate::{schema::activity, Crud}; use crate::Crud;
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::activity;
use log::debug; use log::debug;
use serde::Serialize; use serde::Serialize;
use serde_json::Value; use serde_json::Value;
@ -32,12 +33,12 @@ pub struct ActivityForm {
impl Crud<ActivityForm> for Activity { impl Crud<ActivityForm> for Activity {
fn read(conn: &PgConnection, activity_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, activity_id: i32) -> Result<Self, Error> {
use crate::schema::activity::dsl::*; use lemmy_db_schema::schema::activity::dsl::*;
activity.find(activity_id).first::<Self>(conn) activity.find(activity_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, new_activity: &ActivityForm) -> Result<Self, Error> { fn create(conn: &PgConnection, new_activity: &ActivityForm) -> Result<Self, Error> {
use crate::schema::activity::dsl::*; use lemmy_db_schema::schema::activity::dsl::*;
insert_into(activity) insert_into(activity)
.values(new_activity) .values(new_activity)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -48,13 +49,13 @@ impl Crud<ActivityForm> for Activity {
activity_id: i32, activity_id: i32,
new_activity: &ActivityForm, new_activity: &ActivityForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::activity::dsl::*; use lemmy_db_schema::schema::activity::dsl::*;
diesel::update(activity.find(activity_id)) diesel::update(activity.find(activity_id))
.set(new_activity) .set(new_activity)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn delete(conn: &PgConnection, activity_id: i32) -> Result<usize, Error> { fn delete(conn: &PgConnection, activity_id: i32) -> Result<usize, Error> {
use crate::schema::activity::dsl::*; use lemmy_db_schema::schema::activity::dsl::*;
diesel::delete(activity.find(activity_id)).execute(conn) diesel::delete(activity.find(activity_id)).execute(conn)
} }
} }
@ -89,7 +90,7 @@ impl Activity {
} }
pub fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> { pub fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> {
use crate::schema::activity::dsl::*; use lemmy_db_schema::schema::activity::dsl::*;
activity.filter(ap_id.eq(object_id)).first::<Self>(conn) activity.filter(ap_id.eq(object_id)).first::<Self>(conn)
} }
} }

6
lemmy_db/src/source/category.rs
View file

@ -1,8 +1,6 @@
use crate::{ use crate::Crud;
schema::{category, category::dsl::*},
Crud,
};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{category, category::dsl::*};
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Clone)] #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Clone)]

44
lemmy_db/src/source/comment.rs
View file

@ -1,13 +1,7 @@
use super::post::Post; use super::post::Post;
use crate::{ use crate::{naive_now, ApubObject, Crud, Likeable, Saveable};
naive_now,
schema::{comment, comment_alias_1, comment_like, comment_saved},
ApubObject,
Crud,
Likeable,
Saveable,
};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{comment, comment_alias_1, comment_like, comment_saved};
use serde::Serialize; use serde::Serialize;
use url::{ParseError, Url}; use url::{ParseError, Url};
@ -78,17 +72,17 @@ impl CommentForm {
impl Crud<CommentForm> for Comment { impl Crud<CommentForm> for Comment {
fn read(conn: &PgConnection, comment_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, comment_id: i32) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
comment.find(comment_id).first::<Self>(conn) comment.find(comment_id).first::<Self>(conn)
} }
fn delete(conn: &PgConnection, comment_id: i32) -> Result<usize, Error> { fn delete(conn: &PgConnection, comment_id: i32) -> Result<usize, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::delete(comment.find(comment_id)).execute(conn) diesel::delete(comment.find(comment_id)).execute(conn)
} }
fn create(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> { fn create(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
insert_into(comment) insert_into(comment)
.values(comment_form) .values(comment_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -99,7 +93,7 @@ impl Crud<CommentForm> for Comment {
comment_id: i32, comment_id: i32,
comment_form: &CommentForm, comment_form: &CommentForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.find(comment_id)) diesel::update(comment.find(comment_id))
.set(comment_form) .set(comment_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -108,12 +102,12 @@ impl Crud<CommentForm> for Comment {
impl ApubObject<CommentForm> for Comment { impl ApubObject<CommentForm> for Comment {
fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> { fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
comment.filter(ap_id.eq(object_id)).first::<Self>(conn) comment.filter(ap_id.eq(object_id)).first::<Self>(conn)
} }
fn upsert(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> { fn upsert(conn: &PgConnection, comment_form: &CommentForm) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
insert_into(comment) insert_into(comment)
.values(comment_form) .values(comment_form)
.on_conflict(ap_id) .on_conflict(ap_id)
@ -129,7 +123,7 @@ impl Comment {
comment_id: i32, comment_id: i32,
apub_id: String, apub_id: String,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.find(comment_id)) diesel::update(comment.find(comment_id))
.set(ap_id.eq(apub_id)) .set(ap_id.eq(apub_id))
@ -140,7 +134,7 @@ impl Comment {
conn: &PgConnection, conn: &PgConnection,
for_creator_id: i32, for_creator_id: i32,
) -> Result<Vec<Self>, Error> { ) -> Result<Vec<Self>, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.filter(creator_id.eq(for_creator_id))) diesel::update(comment.filter(creator_id.eq(for_creator_id)))
.set(( .set((
content.eq("*Permananently Deleted*"), content.eq("*Permananently Deleted*"),
@ -155,7 +149,7 @@ impl Comment {
comment_id: i32, comment_id: i32,
new_deleted: bool, new_deleted: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.find(comment_id)) diesel::update(comment.find(comment_id))
.set((deleted.eq(new_deleted), updated.eq(naive_now()))) .set((deleted.eq(new_deleted), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -166,7 +160,7 @@ impl Comment {
comment_id: i32, comment_id: i32,
new_removed: bool, new_removed: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.find(comment_id)) diesel::update(comment.find(comment_id))
.set((removed.eq(new_removed), updated.eq(naive_now()))) .set((removed.eq(new_removed), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -177,14 +171,14 @@ impl Comment {
for_creator_id: i32, for_creator_id: i32,
new_removed: bool, new_removed: bool,
) -> Result<Vec<Self>, Error> { ) -> Result<Vec<Self>, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.filter(creator_id.eq(for_creator_id))) diesel::update(comment.filter(creator_id.eq(for_creator_id)))
.set((removed.eq(new_removed), updated.eq(naive_now()))) .set((removed.eq(new_removed), updated.eq(naive_now())))
.get_results::<Self>(conn) .get_results::<Self>(conn)
} }
pub fn update_read(conn: &PgConnection, comment_id: i32, new_read: bool) -> Result<Self, Error> { pub fn update_read(conn: &PgConnection, comment_id: i32, new_read: bool) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.find(comment_id)) diesel::update(comment.find(comment_id))
.set(read.eq(new_read)) .set(read.eq(new_read))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -195,7 +189,7 @@ impl Comment {
comment_id: i32, comment_id: i32,
new_content: &str, new_content: &str,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
diesel::update(comment.find(comment_id)) diesel::update(comment.find(comment_id))
.set((content.eq(new_content), updated.eq(naive_now()))) .set((content.eq(new_content), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -225,7 +219,7 @@ pub struct CommentLikeForm {
impl Likeable<CommentLikeForm> for CommentLike { impl Likeable<CommentLikeForm> for CommentLike {
fn like(conn: &PgConnection, comment_like_form: &CommentLikeForm) -> Result<Self, Error> { fn like(conn: &PgConnection, comment_like_form: &CommentLikeForm) -> Result<Self, Error> {
use crate::schema::comment_like::dsl::*; use lemmy_db_schema::schema::comment_like::dsl::*;
insert_into(comment_like) insert_into(comment_like)
.values(comment_like_form) .values(comment_like_form)
.on_conflict((comment_id, user_id)) .on_conflict((comment_id, user_id))
@ -234,7 +228,7 @@ impl Likeable<CommentLikeForm> for CommentLike {
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn remove(conn: &PgConnection, user_id: i32, comment_id: i32) -> Result<usize, Error> { fn remove(conn: &PgConnection, user_id: i32, comment_id: i32) -> Result<usize, Error> {
use crate::schema::comment_like::dsl; use lemmy_db_schema::schema::comment_like::dsl;
diesel::delete( diesel::delete(
dsl::comment_like dsl::comment_like
.filter(dsl::comment_id.eq(comment_id)) .filter(dsl::comment_id.eq(comment_id))
@ -263,7 +257,7 @@ pub struct CommentSavedForm {
impl Saveable<CommentSavedForm> for CommentSaved { impl Saveable<CommentSavedForm> for CommentSaved {
fn save(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<Self, Error> { fn save(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<Self, Error> {
use crate::schema::comment_saved::dsl::*; use lemmy_db_schema::schema::comment_saved::dsl::*;
insert_into(comment_saved) insert_into(comment_saved)
.values(comment_saved_form) .values(comment_saved_form)
.on_conflict((comment_id, user_id)) .on_conflict((comment_id, user_id))
@ -272,7 +266,7 @@ impl Saveable<CommentSavedForm> for CommentSaved {
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn unsave(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<usize, Error> { fn unsave(conn: &PgConnection, comment_saved_form: &CommentSavedForm) -> Result<usize, Error> {
use crate::schema::comment_saved::dsl::*; use lemmy_db_schema::schema::comment_saved::dsl::*;
diesel::delete( diesel::delete(
comment_saved comment_saved
.filter(comment_id.eq(comment_saved_form.comment_id)) .filter(comment_id.eq(comment_saved_form.comment_id))

10
lemmy_db/src/source/comment_report.rs
View file

@ -1,8 +1,8 @@
use crate::{naive_now, source::comment::Comment, Reportable};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::comment_report;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::{naive_now, schema::comment_report, source::comment::Comment, Reportable};
#[derive(Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone)] #[derive(Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone)]
#[belongs_to(Comment)] #[belongs_to(Comment)]
#[table_name = "comment_report"] #[table_name = "comment_report"]
@ -33,7 +33,7 @@ impl Reportable<CommentReportForm> for CommentReport {
/// * `conn` - the postgres connection /// * `conn` - the postgres connection
/// * `comment_report_form` - the filled CommentReportForm to insert /// * `comment_report_form` - the filled CommentReportForm to insert
fn report(conn: &PgConnection, comment_report_form: &CommentReportForm) -> Result<Self, Error> { fn report(conn: &PgConnection, comment_report_form: &CommentReportForm) -> Result<Self, Error> {
use crate::schema::comment_report::dsl::*; use lemmy_db_schema::schema::comment_report::dsl::*;
insert_into(comment_report) insert_into(comment_report)
.values(comment_report_form) .values(comment_report_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -45,7 +45,7 @@ impl Reportable<CommentReportForm> for CommentReport {
/// * `report_id` - the id of the report to resolve /// * `report_id` - the id of the report to resolve
/// * `by_resolver_id` - the id of the user resolving the report /// * `by_resolver_id` - the id of the user resolving the report
fn resolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> { fn resolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> {
use crate::schema::comment_report::dsl::*; use lemmy_db_schema::schema::comment_report::dsl::*;
update(comment_report.find(report_id)) update(comment_report.find(report_id))
.set(( .set((
resolved.eq(true), resolved.eq(true),
@ -61,7 +61,7 @@ impl Reportable<CommentReportForm> for CommentReport {
/// * `report_id` - the id of the report to unresolve /// * `report_id` - the id of the report to unresolve
/// * `by_resolver_id` - the id of the user unresolving the report /// * `by_resolver_id` - the id of the user unresolving the report
fn unresolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> { fn unresolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> {
use crate::schema::comment_report::dsl::*; use lemmy_db_schema::schema::comment_report::dsl::*;
update(comment_report.find(report_id)) update(comment_report.find(report_id))
.set(( .set((
resolved.eq(false), resolved.eq(false),

54
lemmy_db/src/source/community.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
naive_now, naive_now,
schema::{community, community_follower, community_moderator, community_user_ban},
views::{community::community_moderator_view::CommunityModeratorView, user_view::UserViewSafe}, views::{community::community_moderator_view::CommunityModeratorView, user_view::UserViewSafe},
ApubObject, ApubObject,
Bannable, Bannable,
@ -9,6 +8,12 @@ use crate::{
Joinable, Joinable,
}; };
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{
community,
community_follower,
community_moderator,
community_user_ban,
};
use serde::Serialize; use serde::Serialize;
#[derive(Clone, Queryable, Identifiable, PartialEq, Debug, Serialize)] #[derive(Clone, Queryable, Identifiable, PartialEq, Debug, Serialize)]
@ -56,7 +61,8 @@ pub struct CommunitySafe {
} }
mod safe_type { mod safe_type {
use crate::{schema::community::columns::*, source::community::Community, ToSafe}; use crate::{source::community::Community, ToSafe};
use lemmy_db_schema::schema::community::columns::*;
type Columns = ( type Columns = (
id, id,
name, name,
@ -123,17 +129,17 @@ pub struct CommunityForm {
impl Crud<CommunityForm> for Community { impl Crud<CommunityForm> for Community {
fn read(conn: &PgConnection, community_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, community_id: i32) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
community.find(community_id).first::<Self>(conn) community.find(community_id).first::<Self>(conn)
} }
fn delete(conn: &PgConnection, community_id: i32) -> Result<usize, Error> { fn delete(conn: &PgConnection, community_id: i32) -> Result<usize, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
diesel::delete(community.find(community_id)).execute(conn) diesel::delete(community.find(community_id)).execute(conn)
} }
fn create(conn: &PgConnection, new_community: &CommunityForm) -> Result<Self, Error> { fn create(conn: &PgConnection, new_community: &CommunityForm) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
insert_into(community) insert_into(community)
.values(new_community) .values(new_community)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -144,7 +150,7 @@ impl Crud<CommunityForm> for Community {
community_id: i32, community_id: i32,
new_community: &CommunityForm, new_community: &CommunityForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
diesel::update(community.find(community_id)) diesel::update(community.find(community_id))
.set(new_community) .set(new_community)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -153,14 +159,14 @@ impl Crud<CommunityForm> for Community {
impl ApubObject<CommunityForm> for Community { impl ApubObject<CommunityForm> for Community {
fn read_from_apub_id(conn: &PgConnection, for_actor_id: &str) -> Result<Self, Error> { fn read_from_apub_id(conn: &PgConnection, for_actor_id: &str) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
community community
.filter(actor_id.eq(for_actor_id)) .filter(actor_id.eq(for_actor_id))
.first::<Self>(conn) .first::<Self>(conn)
} }
fn upsert(conn: &PgConnection, community_form: &CommunityForm) -> Result<Community, Error> { fn upsert(conn: &PgConnection, community_form: &CommunityForm) -> Result<Community, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
insert_into(community) insert_into(community)
.values(community_form) .values(community_form)
.on_conflict(actor_id) .on_conflict(actor_id)
@ -172,7 +178,7 @@ impl ApubObject<CommunityForm> for Community {
impl Community { impl Community {
pub fn read_from_name(conn: &PgConnection, community_name: &str) -> Result<Self, Error> { pub fn read_from_name(conn: &PgConnection, community_name: &str) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
community community
.filter(local.eq(true)) .filter(local.eq(true))
.filter(name.eq(community_name)) .filter(name.eq(community_name))
@ -184,7 +190,7 @@ impl Community {
community_id: i32, community_id: i32,
new_deleted: bool, new_deleted: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
diesel::update(community.find(community_id)) diesel::update(community.find(community_id))
.set((deleted.eq(new_deleted), updated.eq(naive_now()))) .set((deleted.eq(new_deleted), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -195,7 +201,7 @@ impl Community {
community_id: i32, community_id: i32,
new_removed: bool, new_removed: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
diesel::update(community.find(community_id)) diesel::update(community.find(community_id))
.set((removed.eq(new_removed), updated.eq(naive_now()))) .set((removed.eq(new_removed), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -206,7 +212,7 @@ impl Community {
for_creator_id: i32, for_creator_id: i32,
new_removed: bool, new_removed: bool,
) -> Result<Vec<Self>, Error> { ) -> Result<Vec<Self>, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
diesel::update(community.filter(creator_id.eq(for_creator_id))) diesel::update(community.filter(creator_id.eq(for_creator_id)))
.set((removed.eq(new_removed), updated.eq(naive_now()))) .set((removed.eq(new_removed), updated.eq(naive_now())))
.get_results::<Self>(conn) .get_results::<Self>(conn)
@ -217,7 +223,7 @@ impl Community {
community_id: i32, community_id: i32,
new_creator_id: i32, new_creator_id: i32,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
diesel::update(community.find(community_id)) diesel::update(community.find(community_id))
.set((creator_id.eq(new_creator_id), updated.eq(naive_now()))) .set((creator_id.eq(new_creator_id), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -235,7 +241,7 @@ impl Community {
} }
pub fn distinct_federated_communities(conn: &PgConnection) -> Result<Vec<String>, Error> { pub fn distinct_federated_communities(conn: &PgConnection) -> Result<Vec<String>, Error> {
use crate::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
community.select(actor_id).distinct().load::<String>(conn) community.select(actor_id).distinct().load::<String>(conn)
} }
@ -268,7 +274,7 @@ impl Joinable<CommunityModeratorForm> for CommunityModerator {
conn: &PgConnection, conn: &PgConnection,
community_user_form: &CommunityModeratorForm, community_user_form: &CommunityModeratorForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community_moderator::dsl::*; use lemmy_db_schema::schema::community_moderator::dsl::*;
insert_into(community_moderator) insert_into(community_moderator)
.values(community_user_form) .values(community_user_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -278,7 +284,7 @@ impl Joinable<CommunityModeratorForm> for CommunityModerator {
conn: &PgConnection, conn: &PgConnection,
community_user_form: &CommunityModeratorForm, community_user_form: &CommunityModeratorForm,
) -> Result<usize, Error> { ) -> Result<usize, Error> {
use crate::schema::community_moderator::dsl::*; use lemmy_db_schema::schema::community_moderator::dsl::*;
diesel::delete( diesel::delete(
community_moderator community_moderator
.filter(community_id.eq(community_user_form.community_id)) .filter(community_id.eq(community_user_form.community_id))
@ -290,7 +296,7 @@ impl Joinable<CommunityModeratorForm> for CommunityModerator {
impl CommunityModerator { impl CommunityModerator {
pub fn delete_for_community(conn: &PgConnection, for_community_id: i32) -> Result<usize, Error> { pub fn delete_for_community(conn: &PgConnection, for_community_id: i32) -> Result<usize, Error> {
use crate::schema::community_moderator::dsl::*; use lemmy_db_schema::schema::community_moderator::dsl::*;
diesel::delete(community_moderator.filter(community_id.eq(for_community_id))).execute(conn) diesel::delete(community_moderator.filter(community_id.eq(for_community_id))).execute(conn)
} }
@ -298,7 +304,7 @@ impl CommunityModerator {
conn: &PgConnection, conn: &PgConnection,
for_user_id: i32, for_user_id: i32,
) -> Result<Vec<i32>, Error> { ) -> Result<Vec<i32>, Error> {
use crate::schema::community_moderator::dsl::*; use lemmy_db_schema::schema::community_moderator::dsl::*;
community_moderator community_moderator
.filter(user_id.eq(for_user_id)) .filter(user_id.eq(for_user_id))
.select(community_id) .select(community_id)
@ -328,7 +334,7 @@ impl Bannable<CommunityUserBanForm> for CommunityUserBan {
conn: &PgConnection, conn: &PgConnection,
community_user_ban_form: &CommunityUserBanForm, community_user_ban_form: &CommunityUserBanForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community_user_ban::dsl::*; use lemmy_db_schema::schema::community_user_ban::dsl::*;
insert_into(community_user_ban) insert_into(community_user_ban)
.values(community_user_ban_form) .values(community_user_ban_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -338,7 +344,7 @@ impl Bannable<CommunityUserBanForm> for CommunityUserBan {
conn: &PgConnection, conn: &PgConnection,
community_user_ban_form: &CommunityUserBanForm, community_user_ban_form: &CommunityUserBanForm,
) -> Result<usize, Error> { ) -> Result<usize, Error> {
use crate::schema::community_user_ban::dsl::*; use lemmy_db_schema::schema::community_user_ban::dsl::*;
diesel::delete( diesel::delete(
community_user_ban community_user_ban
.filter(community_id.eq(community_user_ban_form.community_id)) .filter(community_id.eq(community_user_ban_form.community_id))
@ -372,7 +378,7 @@ impl Followable<CommunityFollowerForm> for CommunityFollower {
conn: &PgConnection, conn: &PgConnection,
community_follower_form: &CommunityFollowerForm, community_follower_form: &CommunityFollowerForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::community_follower::dsl::*; use lemmy_db_schema::schema::community_follower::dsl::*;
insert_into(community_follower) insert_into(community_follower)
.values(community_follower_form) .values(community_follower_form)
.on_conflict((community_id, user_id)) .on_conflict((community_id, user_id))
@ -384,7 +390,7 @@ impl Followable<CommunityFollowerForm> for CommunityFollower {
where where
Self: Sized, Self: Sized,
{ {
use crate::schema::community_follower::dsl::*; use lemmy_db_schema::schema::community_follower::dsl::*;
diesel::update( diesel::update(
community_follower community_follower
.filter(community_id.eq(community_id_)) .filter(community_id.eq(community_id_))
@ -397,7 +403,7 @@ impl Followable<CommunityFollowerForm> for CommunityFollower {
conn: &PgConnection, conn: &PgConnection,
community_follower_form: &CommunityFollowerForm, community_follower_form: &CommunityFollowerForm,
) -> Result<usize, Error> { ) -> Result<usize, Error> {
use crate::schema::community_follower::dsl::*; use lemmy_db_schema::schema::community_follower::dsl::*;
diesel::delete( diesel::delete(
community_follower community_follower
.filter(community_id.eq(&community_follower_form.community_id)) .filter(community_id.eq(&community_follower_form.community_id))
@ -408,7 +414,7 @@ impl Followable<CommunityFollowerForm> for CommunityFollower {
// TODO: this function name only makes sense if you call it with a remote community. for a local // TODO: this function name only makes sense if you call it with a remote community. for a local
// community, it will also return true if only remote followers exist // community, it will also return true if only remote followers exist
fn has_local_followers(conn: &PgConnection, community_id_: i32) -> Result<bool, Error> { fn has_local_followers(conn: &PgConnection, community_id_: i32) -> Result<bool, Error> {
use crate::schema::community_follower::dsl::*; use lemmy_db_schema::schema::community_follower::dsl::*;
diesel::select(exists( diesel::select(exists(
community_follower.filter(community_id.eq(community_id_)), community_follower.filter(community_id.eq(community_id_)),
)) ))

80
lemmy_db/src/source/moderator.rs
View file

@ -1,18 +1,16 @@
use crate::{ use crate::Crud;
schema::{
mod_add,
mod_add_community,
mod_ban,
mod_ban_from_community,
mod_lock_post,
mod_remove_comment,
mod_remove_community,
mod_remove_post,
mod_sticky_post,
},
Crud,
};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{
mod_add,
mod_add_community,
mod_ban,
mod_ban_from_community,
mod_lock_post,
mod_remove_comment,
mod_remove_community,
mod_remove_post,
mod_sticky_post,
};
use serde::Serialize; use serde::Serialize;
#[derive(Clone, Queryable, Identifiable, PartialEq, Debug, Serialize)] #[derive(Clone, Queryable, Identifiable, PartialEq, Debug, Serialize)]
@ -37,19 +35,19 @@ pub struct ModRemovePostForm {
impl Crud<ModRemovePostForm> for ModRemovePost { impl Crud<ModRemovePostForm> for ModRemovePost {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_remove_post::dsl::*; use lemmy_db_schema::schema::mod_remove_post::dsl::*;
mod_remove_post.find(from_id).first::<Self>(conn) mod_remove_post.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModRemovePostForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModRemovePostForm) -> Result<Self, Error> {
use crate::schema::mod_remove_post::dsl::*; use lemmy_db_schema::schema::mod_remove_post::dsl::*;
insert_into(mod_remove_post) insert_into(mod_remove_post)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModRemovePostForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModRemovePostForm) -> Result<Self, Error> {
use crate::schema::mod_remove_post::dsl::*; use lemmy_db_schema::schema::mod_remove_post::dsl::*;
diesel::update(mod_remove_post.find(from_id)) diesel::update(mod_remove_post.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -76,19 +74,19 @@ pub struct ModLockPostForm {
impl Crud<ModLockPostForm> for ModLockPost { impl Crud<ModLockPostForm> for ModLockPost {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_lock_post::dsl::*; use lemmy_db_schema::schema::mod_lock_post::dsl::*;
mod_lock_post.find(from_id).first::<Self>(conn) mod_lock_post.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModLockPostForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModLockPostForm) -> Result<Self, Error> {
use crate::schema::mod_lock_post::dsl::*; use lemmy_db_schema::schema::mod_lock_post::dsl::*;
insert_into(mod_lock_post) insert_into(mod_lock_post)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModLockPostForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModLockPostForm) -> Result<Self, Error> {
use crate::schema::mod_lock_post::dsl::*; use lemmy_db_schema::schema::mod_lock_post::dsl::*;
diesel::update(mod_lock_post.find(from_id)) diesel::update(mod_lock_post.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -115,19 +113,19 @@ pub struct ModStickyPostForm {
impl Crud<ModStickyPostForm> for ModStickyPost { impl Crud<ModStickyPostForm> for ModStickyPost {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_sticky_post::dsl::*; use lemmy_db_schema::schema::mod_sticky_post::dsl::*;
mod_sticky_post.find(from_id).first::<Self>(conn) mod_sticky_post.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModStickyPostForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModStickyPostForm) -> Result<Self, Error> {
use crate::schema::mod_sticky_post::dsl::*; use lemmy_db_schema::schema::mod_sticky_post::dsl::*;
insert_into(mod_sticky_post) insert_into(mod_sticky_post)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModStickyPostForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModStickyPostForm) -> Result<Self, Error> {
use crate::schema::mod_sticky_post::dsl::*; use lemmy_db_schema::schema::mod_sticky_post::dsl::*;
diesel::update(mod_sticky_post.find(from_id)) diesel::update(mod_sticky_post.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -156,19 +154,19 @@ pub struct ModRemoveCommentForm {
impl Crud<ModRemoveCommentForm> for ModRemoveComment { impl Crud<ModRemoveCommentForm> for ModRemoveComment {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_remove_comment::dsl::*; use lemmy_db_schema::schema::mod_remove_comment::dsl::*;
mod_remove_comment.find(from_id).first::<Self>(conn) mod_remove_comment.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModRemoveCommentForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModRemoveCommentForm) -> Result<Self, Error> {
use crate::schema::mod_remove_comment::dsl::*; use lemmy_db_schema::schema::mod_remove_comment::dsl::*;
insert_into(mod_remove_comment) insert_into(mod_remove_comment)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModRemoveCommentForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModRemoveCommentForm) -> Result<Self, Error> {
use crate::schema::mod_remove_comment::dsl::*; use lemmy_db_schema::schema::mod_remove_comment::dsl::*;
diesel::update(mod_remove_comment.find(from_id)) diesel::update(mod_remove_comment.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -199,12 +197,12 @@ pub struct ModRemoveCommunityForm {
impl Crud<ModRemoveCommunityForm> for ModRemoveCommunity { impl Crud<ModRemoveCommunityForm> for ModRemoveCommunity {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_remove_community::dsl::*; use lemmy_db_schema::schema::mod_remove_community::dsl::*;
mod_remove_community.find(from_id).first::<Self>(conn) mod_remove_community.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModRemoveCommunityForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModRemoveCommunityForm) -> Result<Self, Error> {
use crate::schema::mod_remove_community::dsl::*; use lemmy_db_schema::schema::mod_remove_community::dsl::*;
insert_into(mod_remove_community) insert_into(mod_remove_community)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -215,7 +213,7 @@ impl Crud<ModRemoveCommunityForm> for ModRemoveCommunity {
from_id: i32, from_id: i32,
form: &ModRemoveCommunityForm, form: &ModRemoveCommunityForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::mod_remove_community::dsl::*; use lemmy_db_schema::schema::mod_remove_community::dsl::*;
diesel::update(mod_remove_community.find(from_id)) diesel::update(mod_remove_community.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -248,12 +246,12 @@ pub struct ModBanFromCommunityForm {
impl Crud<ModBanFromCommunityForm> for ModBanFromCommunity { impl Crud<ModBanFromCommunityForm> for ModBanFromCommunity {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_ban_from_community::dsl::*; use lemmy_db_schema::schema::mod_ban_from_community::dsl::*;
mod_ban_from_community.find(from_id).first::<Self>(conn) mod_ban_from_community.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModBanFromCommunityForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModBanFromCommunityForm) -> Result<Self, Error> {
use crate::schema::mod_ban_from_community::dsl::*; use lemmy_db_schema::schema::mod_ban_from_community::dsl::*;
insert_into(mod_ban_from_community) insert_into(mod_ban_from_community)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -264,7 +262,7 @@ impl Crud<ModBanFromCommunityForm> for ModBanFromCommunity {
from_id: i32, from_id: i32,
form: &ModBanFromCommunityForm, form: &ModBanFromCommunityForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::mod_ban_from_community::dsl::*; use lemmy_db_schema::schema::mod_ban_from_community::dsl::*;
diesel::update(mod_ban_from_community.find(from_id)) diesel::update(mod_ban_from_community.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -295,17 +293,17 @@ pub struct ModBanForm {
impl Crud<ModBanForm> for ModBan { impl Crud<ModBanForm> for ModBan {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_ban::dsl::*; use lemmy_db_schema::schema::mod_ban::dsl::*;
mod_ban.find(from_id).first::<Self>(conn) mod_ban.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModBanForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModBanForm) -> Result<Self, Error> {
use crate::schema::mod_ban::dsl::*; use lemmy_db_schema::schema::mod_ban::dsl::*;
insert_into(mod_ban).values(form).get_result::<Self>(conn) insert_into(mod_ban).values(form).get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModBanForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModBanForm) -> Result<Self, Error> {
use crate::schema::mod_ban::dsl::*; use lemmy_db_schema::schema::mod_ban::dsl::*;
diesel::update(mod_ban.find(from_id)) diesel::update(mod_ban.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -334,19 +332,19 @@ pub struct ModAddCommunityForm {
impl Crud<ModAddCommunityForm> for ModAddCommunity { impl Crud<ModAddCommunityForm> for ModAddCommunity {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_add_community::dsl::*; use lemmy_db_schema::schema::mod_add_community::dsl::*;
mod_add_community.find(from_id).first::<Self>(conn) mod_add_community.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModAddCommunityForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModAddCommunityForm) -> Result<Self, Error> {
use crate::schema::mod_add_community::dsl::*; use lemmy_db_schema::schema::mod_add_community::dsl::*;
insert_into(mod_add_community) insert_into(mod_add_community)
.values(form) .values(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModAddCommunityForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModAddCommunityForm) -> Result<Self, Error> {
use crate::schema::mod_add_community::dsl::*; use lemmy_db_schema::schema::mod_add_community::dsl::*;
diesel::update(mod_add_community.find(from_id)) diesel::update(mod_add_community.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -373,17 +371,17 @@ pub struct ModAddForm {
impl Crud<ModAddForm> for ModAdd { impl Crud<ModAddForm> for ModAdd {
fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
use crate::schema::mod_add::dsl::*; use lemmy_db_schema::schema::mod_add::dsl::*;
mod_add.find(from_id).first::<Self>(conn) mod_add.find(from_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, form: &ModAddForm) -> Result<Self, Error> { fn create(conn: &PgConnection, form: &ModAddForm) -> Result<Self, Error> {
use crate::schema::mod_add::dsl::*; use lemmy_db_schema::schema::mod_add::dsl::*;
insert_into(mod_add).values(form).get_result::<Self>(conn) insert_into(mod_add).values(form).get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, from_id: i32, form: &ModAddForm) -> Result<Self, Error> { fn update(conn: &PgConnection, from_id: i32, form: &ModAddForm) -> Result<Self, Error> {
use crate::schema::mod_add::dsl::*; use lemmy_db_schema::schema::mod_add::dsl::*;
diesel::update(mod_add.find(from_id)) diesel::update(mod_add.find(from_id))
.set(form) .set(form)
.get_result::<Self>(conn) .get_result::<Self>(conn)

7
lemmy_db/src/source/password_reset_request.rs
View file

@ -1,8 +1,6 @@
use crate::{ use crate::Crud;
schema::{password_reset_request, password_reset_request::dsl::*},
Crud,
};
use diesel::{dsl::*, result::Error, PgConnection, *}; use diesel::{dsl::*, result::Error, PgConnection, *};
use lemmy_db_schema::schema::{password_reset_request, password_reset_request::dsl::*};
use sha2::{Digest, Sha256}; use sha2::{Digest, Sha256};
#[derive(Queryable, Identifiable, PartialEq, Debug)] #[derive(Queryable, Identifiable, PartialEq, Debug)]
@ -23,7 +21,6 @@ pub struct PasswordResetRequestForm {
impl Crud<PasswordResetRequestForm> for PasswordResetRequest { impl Crud<PasswordResetRequestForm> for PasswordResetRequest {
fn read(conn: &PgConnection, password_reset_request_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, password_reset_request_id: i32) -> Result<Self, Error> {
use crate::schema::password_reset_request::dsl::*;
password_reset_request password_reset_request
.find(password_reset_request_id) .find(password_reset_request_id)
.first::<Self>(conn) .first::<Self>(conn)

53
lemmy_db/src/source/post.rs
View file

@ -1,13 +1,6 @@
use crate::{ use crate::{naive_now, ApubObject, Crud, Likeable, Readable, Saveable};
naive_now,
schema::{post, post_like, post_read, post_saved},
ApubObject,
Crud,
Likeable,
Readable,
Saveable,
};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{post, post_like, post_read, post_saved};
use serde::Serialize; use serde::Serialize;
use url::{ParseError, Url}; use url::{ParseError, Url};
@ -66,22 +59,22 @@ impl PostForm {
impl Crud<PostForm> for Post { impl Crud<PostForm> for Post {
fn read(conn: &PgConnection, post_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, post_id: i32) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
post.find(post_id).first::<Self>(conn) post.find(post_id).first::<Self>(conn)
} }
fn delete(conn: &PgConnection, post_id: i32) -> Result<usize, Error> { fn delete(conn: &PgConnection, post_id: i32) -> Result<usize, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::delete(post.find(post_id)).execute(conn) diesel::delete(post.find(post_id)).execute(conn)
} }
fn create(conn: &PgConnection, new_post: &PostForm) -> Result<Self, Error> { fn create(conn: &PgConnection, new_post: &PostForm) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
insert_into(post).values(new_post).get_result::<Self>(conn) insert_into(post).values(new_post).get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, post_id: i32, new_post: &PostForm) -> Result<Self, Error> { fn update(conn: &PgConnection, post_id: i32, new_post: &PostForm) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::update(post.find(post_id)) diesel::update(post.find(post_id))
.set(new_post) .set(new_post)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -90,12 +83,12 @@ impl Crud<PostForm> for Post {
impl ApubObject<PostForm> for Post { impl ApubObject<PostForm> for Post {
fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> { fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
post.filter(ap_id.eq(object_id)).first::<Self>(conn) post.filter(ap_id.eq(object_id)).first::<Self>(conn)
} }
fn upsert(conn: &PgConnection, post_form: &PostForm) -> Result<Post, Error> { fn upsert(conn: &PgConnection, post_form: &PostForm) -> Result<Post, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
insert_into(post) insert_into(post)
.values(post_form) .values(post_form)
.on_conflict(ap_id) .on_conflict(ap_id)
@ -107,7 +100,7 @@ impl ApubObject<PostForm> for Post {
impl Post { impl Post {
pub fn read(conn: &PgConnection, post_id: i32) -> Result<Self, Error> { pub fn read(conn: &PgConnection, post_id: i32) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
post.filter(id.eq(post_id)).first::<Self>(conn) post.filter(id.eq(post_id)).first::<Self>(conn)
} }
@ -115,7 +108,7 @@ impl Post {
conn: &PgConnection, conn: &PgConnection,
the_community_id: i32, the_community_id: i32,
) -> Result<Vec<Self>, Error> { ) -> Result<Vec<Self>, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
post post
.filter(community_id.eq(the_community_id)) .filter(community_id.eq(the_community_id))
.then_order_by(published.desc()) .then_order_by(published.desc())
@ -125,7 +118,7 @@ impl Post {
} }
pub fn update_ap_id(conn: &PgConnection, post_id: i32, apub_id: String) -> Result<Self, Error> { pub fn update_ap_id(conn: &PgConnection, post_id: i32, apub_id: String) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::update(post.find(post_id)) diesel::update(post.find(post_id))
.set(ap_id.eq(apub_id)) .set(ap_id.eq(apub_id))
@ -136,7 +129,7 @@ impl Post {
conn: &PgConnection, conn: &PgConnection,
for_creator_id: i32, for_creator_id: i32,
) -> Result<Vec<Self>, Error> { ) -> Result<Vec<Self>, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
let perma_deleted = "*Permananently Deleted*"; let perma_deleted = "*Permananently Deleted*";
let perma_deleted_url = "https://deleted.com"; let perma_deleted_url = "https://deleted.com";
@ -157,7 +150,7 @@ impl Post {
post_id: i32, post_id: i32,
new_deleted: bool, new_deleted: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::update(post.find(post_id)) diesel::update(post.find(post_id))
.set((deleted.eq(new_deleted), updated.eq(naive_now()))) .set((deleted.eq(new_deleted), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -168,7 +161,7 @@ impl Post {
post_id: i32, post_id: i32,
new_removed: bool, new_removed: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::update(post.find(post_id)) diesel::update(post.find(post_id))
.set((removed.eq(new_removed), updated.eq(naive_now()))) .set((removed.eq(new_removed), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -180,7 +173,7 @@ impl Post {
for_community_id: Option<i32>, for_community_id: Option<i32>,
new_removed: bool, new_removed: bool,
) -> Result<Vec<Self>, Error> { ) -> Result<Vec<Self>, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
let mut update = diesel::update(post).into_boxed(); let mut update = diesel::update(post).into_boxed();
update = update.filter(creator_id.eq(for_creator_id)); update = update.filter(creator_id.eq(for_creator_id));
@ -195,7 +188,7 @@ impl Post {
} }
pub fn update_locked(conn: &PgConnection, post_id: i32, new_locked: bool) -> Result<Self, Error> { pub fn update_locked(conn: &PgConnection, post_id: i32, new_locked: bool) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::update(post.find(post_id)) diesel::update(post.find(post_id))
.set(locked.eq(new_locked)) .set(locked.eq(new_locked))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -206,7 +199,7 @@ impl Post {
post_id: i32, post_id: i32,
new_stickied: bool, new_stickied: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
diesel::update(post.find(post_id)) diesel::update(post.find(post_id))
.set(stickied.eq(new_stickied)) .set(stickied.eq(new_stickied))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -238,7 +231,7 @@ pub struct PostLikeForm {
impl Likeable<PostLikeForm> for PostLike { impl Likeable<PostLikeForm> for PostLike {
fn like(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result<Self, Error> { fn like(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result<Self, Error> {
use crate::schema::post_like::dsl::*; use lemmy_db_schema::schema::post_like::dsl::*;
insert_into(post_like) insert_into(post_like)
.values(post_like_form) .values(post_like_form)
.on_conflict((post_id, user_id)) .on_conflict((post_id, user_id))
@ -247,7 +240,7 @@ impl Likeable<PostLikeForm> for PostLike {
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn remove(conn: &PgConnection, user_id: i32, post_id: i32) -> Result<usize, Error> { fn remove(conn: &PgConnection, user_id: i32, post_id: i32) -> Result<usize, Error> {
use crate::schema::post_like::dsl; use lemmy_db_schema::schema::post_like::dsl;
diesel::delete( diesel::delete(
dsl::post_like dsl::post_like
.filter(dsl::post_id.eq(post_id)) .filter(dsl::post_id.eq(post_id))
@ -276,7 +269,7 @@ pub struct PostSavedForm {
impl Saveable<PostSavedForm> for PostSaved { impl Saveable<PostSavedForm> for PostSaved {
fn save(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<Self, Error> { fn save(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
use crate::schema::post_saved::dsl::*; use lemmy_db_schema::schema::post_saved::dsl::*;
insert_into(post_saved) insert_into(post_saved)
.values(post_saved_form) .values(post_saved_form)
.on_conflict((post_id, user_id)) .on_conflict((post_id, user_id))
@ -285,7 +278,7 @@ impl Saveable<PostSavedForm> for PostSaved {
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn unsave(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<usize, Error> { fn unsave(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
use crate::schema::post_saved::dsl::*; use lemmy_db_schema::schema::post_saved::dsl::*;
diesel::delete( diesel::delete(
post_saved post_saved
.filter(post_id.eq(post_saved_form.post_id)) .filter(post_id.eq(post_saved_form.post_id))
@ -318,14 +311,14 @@ pub struct PostReadForm {
impl Readable<PostReadForm> for PostRead { impl Readable<PostReadForm> for PostRead {
fn mark_as_read(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<Self, Error> { fn mark_as_read(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<Self, Error> {
use crate::schema::post_read::dsl::*; use lemmy_db_schema::schema::post_read::dsl::*;
insert_into(post_read) insert_into(post_read)
.values(post_read_form) .values(post_read_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
fn mark_as_unread(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<usize, Error> { fn mark_as_unread(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<usize, Error> {
use crate::schema::post_read::dsl::*; use lemmy_db_schema::schema::post_read::dsl::*;
diesel::delete( diesel::delete(
post_read post_read
.filter(post_id.eq(post_read_form.post_id)) .filter(post_id.eq(post_read_form.post_id))

10
lemmy_db/src/source/post_report.rs
View file

@ -1,8 +1,8 @@
use crate::{naive_now, source::post::Post, Reportable};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::post_report;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::{naive_now, schema::post_report, source::post::Post, Reportable};
#[derive(Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone)] #[derive(Identifiable, Queryable, Associations, PartialEq, Serialize, Deserialize, Debug, Clone)]
#[belongs_to(Post)] #[belongs_to(Post)]
#[table_name = "post_report"] #[table_name = "post_report"]
@ -37,7 +37,7 @@ impl Reportable<PostReportForm> for PostReport {
/// * `conn` - the postgres connection /// * `conn` - the postgres connection
/// * `post_report_form` - the filled CommentReportForm to insert /// * `post_report_form` - the filled CommentReportForm to insert
fn report(conn: &PgConnection, post_report_form: &PostReportForm) -> Result<Self, Error> { fn report(conn: &PgConnection, post_report_form: &PostReportForm) -> Result<Self, Error> {
use crate::schema::post_report::dsl::*; use lemmy_db_schema::schema::post_report::dsl::*;
insert_into(post_report) insert_into(post_report)
.values(post_report_form) .values(post_report_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -49,7 +49,7 @@ impl Reportable<PostReportForm> for PostReport {
/// * `report_id` - the id of the report to resolve /// * `report_id` - the id of the report to resolve
/// * `by_resolver_id` - the id of the user resolving the report /// * `by_resolver_id` - the id of the user resolving the report
fn resolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> { fn resolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> {
use crate::schema::post_report::dsl::*; use lemmy_db_schema::schema::post_report::dsl::*;
update(post_report.find(report_id)) update(post_report.find(report_id))
.set(( .set((
resolved.eq(true), resolved.eq(true),
@ -65,7 +65,7 @@ impl Reportable<PostReportForm> for PostReport {
/// * `report_id` - the id of the report to unresolve /// * `report_id` - the id of the report to unresolve
/// * `by_resolver_id` - the id of the user unresolving the report /// * `by_resolver_id` - the id of the user unresolving the report
fn unresolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> { fn unresolve(conn: &PgConnection, report_id: i32, by_resolver_id: i32) -> Result<usize, Error> {
use crate::schema::post_report::dsl::*; use lemmy_db_schema::schema::post_report::dsl::*;
update(post_report.find(report_id)) update(post_report.find(report_id))
.set(( .set((
resolved.eq(false), resolved.eq(false),

23
lemmy_db/src/source/private_message.rs
View file

@ -1,5 +1,6 @@
use crate::{naive_now, schema::private_message, ApubObject, Crud}; use crate::{naive_now, ApubObject, Crud};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::private_message;
use serde::Serialize; use serde::Serialize;
#[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)] #[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)]
@ -33,12 +34,12 @@ pub struct PrivateMessageForm {
impl Crud<PrivateMessageForm> for PrivateMessage { impl Crud<PrivateMessageForm> for PrivateMessage {
fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
private_message.find(private_message_id).first::<Self>(conn) private_message.find(private_message_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> { fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
insert_into(private_message) insert_into(private_message)
.values(private_message_form) .values(private_message_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -49,7 +50,7 @@ impl Crud<PrivateMessageForm> for PrivateMessage {
private_message_id: i32, private_message_id: i32,
private_message_form: &PrivateMessageForm, private_message_form: &PrivateMessageForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
diesel::update(private_message.find(private_message_id)) diesel::update(private_message.find(private_message_id))
.set(private_message_form) .set(private_message_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -61,14 +62,14 @@ impl ApubObject<PrivateMessageForm> for PrivateMessage {
where where
Self: Sized, Self: Sized,
{ {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
private_message private_message
.filter(ap_id.eq(object_id)) .filter(ap_id.eq(object_id))
.first::<Self>(conn) .first::<Self>(conn)
} }
fn upsert(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> { fn upsert(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
insert_into(private_message) insert_into(private_message)
.values(private_message_form) .values(private_message_form)
.on_conflict(ap_id) .on_conflict(ap_id)
@ -84,7 +85,7 @@ impl PrivateMessage {
private_message_id: i32, private_message_id: i32,
apub_id: String, apub_id: String,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
diesel::update(private_message.find(private_message_id)) diesel::update(private_message.find(private_message_id))
.set(ap_id.eq(apub_id)) .set(ap_id.eq(apub_id))
@ -96,7 +97,7 @@ impl PrivateMessage {
private_message_id: i32, private_message_id: i32,
new_content: &str, new_content: &str,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
diesel::update(private_message.find(private_message_id)) diesel::update(private_message.find(private_message_id))
.set((content.eq(new_content), updated.eq(naive_now()))) .set((content.eq(new_content), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -107,7 +108,7 @@ impl PrivateMessage {
private_message_id: i32, private_message_id: i32,
new_deleted: bool, new_deleted: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
diesel::update(private_message.find(private_message_id)) diesel::update(private_message.find(private_message_id))
.set(deleted.eq(new_deleted)) .set(deleted.eq(new_deleted))
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -118,14 +119,14 @@ impl PrivateMessage {
private_message_id: i32, private_message_id: i32,
new_read: bool, new_read: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
diesel::update(private_message.find(private_message_id)) diesel::update(private_message.find(private_message_id))
.set(read.eq(new_read)) .set(read.eq(new_read))
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
pub fn mark_all_as_read(conn: &PgConnection, for_recipient_id: i32) -> Result<Vec<Self>, Error> { pub fn mark_all_as_read(conn: &PgConnection, for_recipient_id: i32) -> Result<Vec<Self>, Error> {
use crate::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
diesel::update( diesel::update(
private_message private_message
.filter(recipient_id.eq(for_recipient_id)) .filter(recipient_id.eq(for_recipient_id))

11
lemmy_db/src/source/site.rs
View file

@ -1,5 +1,6 @@
use crate::{naive_now, schema::site, Crud}; use crate::{naive_now, Crud};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::site;
use serde::Serialize; use serde::Serialize;
#[derive(Queryable, Identifiable, PartialEq, Debug, Clone, Serialize)] #[derive(Queryable, Identifiable, PartialEq, Debug, Clone, Serialize)]
@ -35,17 +36,17 @@ pub struct SiteForm {
impl Crud<SiteForm> for Site { impl Crud<SiteForm> for Site {
fn read(conn: &PgConnection, _site_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, _site_id: i32) -> Result<Self, Error> {
use crate::schema::site::dsl::*; use lemmy_db_schema::schema::site::dsl::*;
site.first::<Self>(conn) site.first::<Self>(conn)
} }
fn create(conn: &PgConnection, new_site: &SiteForm) -> Result<Self, Error> { fn create(conn: &PgConnection, new_site: &SiteForm) -> Result<Self, Error> {
use crate::schema::site::dsl::*; use lemmy_db_schema::schema::site::dsl::*;
insert_into(site).values(new_site).get_result::<Self>(conn) insert_into(site).values(new_site).get_result::<Self>(conn)
} }
fn update(conn: &PgConnection, site_id: i32, new_site: &SiteForm) -> Result<Self, Error> { fn update(conn: &PgConnection, site_id: i32, new_site: &SiteForm) -> Result<Self, Error> {
use crate::schema::site::dsl::*; use lemmy_db_schema::schema::site::dsl::*;
diesel::update(site.find(site_id)) diesel::update(site.find(site_id))
.set(new_site) .set(new_site)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -54,7 +55,7 @@ impl Crud<SiteForm> for Site {
impl Site { impl Site {
pub fn transfer(conn: &PgConnection, new_creator_id: i32) -> Result<Self, Error> { pub fn transfer(conn: &PgConnection, new_creator_id: i32) -> Result<Self, Error> {
use crate::schema::site::dsl::*; use lemmy_db_schema::schema::site::dsl::*;
diesel::update(site.find(1)) diesel::update(site.find(1))
.set((creator_id.eq(new_creator_id), updated.eq(naive_now()))) .set((creator_id.eq(new_creator_id), updated.eq(naive_now())))
.get_result::<Self>(conn) .get_result::<Self>(conn)

20
lemmy_db/src/source/user.rs
View file

@ -1,12 +1,7 @@
use crate::{ use crate::{is_email_regex, naive_now, ApubObject, Crud};
is_email_regex,
naive_now,
schema::{user_, user_::dsl::*, user_alias_1, user_alias_2},
ApubObject,
Crud,
};
use bcrypt::{hash, DEFAULT_COST}; use bcrypt::{hash, DEFAULT_COST};
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{user_, user_::dsl::*, user_alias_1, user_alias_2};
use lemmy_utils::settings::Settings; use lemmy_utils::settings::Settings;
use serde::Serialize; use serde::Serialize;
@ -62,7 +57,8 @@ pub struct UserSafe {
} }
mod safe_type { mod safe_type {
use crate::{schema::user_::columns::*, source::user::User_, ToSafe}; use crate::{source::user::User_, ToSafe};
use lemmy_db_schema::schema::user_::columns::*;
type Columns = ( type Columns = (
id, id,
name, name,
@ -154,7 +150,8 @@ pub struct UserSafeAlias1 {
} }
mod safe_type_alias_1 { mod safe_type_alias_1 {
use crate::{schema::user_alias_1::columns::*, source::user::UserAlias1, ToSafe}; use crate::{source::user::UserAlias1, ToSafe};
use lemmy_db_schema::schema::user_alias_1::columns::*;
type Columns = ( type Columns = (
id, id,
name, name,
@ -246,7 +243,8 @@ pub struct UserSafeAlias2 {
} }
mod safe_type_alias_2 { mod safe_type_alias_2 {
use crate::{schema::user_alias_2::columns::*, source::user::UserAlias2, ToSafe}; use crate::{source::user::UserAlias2, ToSafe};
use lemmy_db_schema::schema::user_alias_2::columns::*;
type Columns = ( type Columns = (
id, id,
name, name,
@ -338,7 +336,7 @@ impl Crud<UserForm> for User_ {
impl ApubObject<UserForm> for User_ { impl ApubObject<UserForm> for User_ {
fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> { fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> {
use crate::schema::user_::dsl::*; use lemmy_db_schema::schema::user_::dsl::*;
user_ user_
.filter(deleted.eq(false)) .filter(deleted.eq(false))
.filter(actor_id.eq(object_id)) .filter(actor_id.eq(object_id))

13
lemmy_db/src/source/user_mention.rs
View file

@ -1,6 +1,7 @@
use super::comment::Comment; use super::comment::Comment;
use crate::{schema::user_mention, Crud}; use crate::Crud;
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::user_mention;
use serde::Serialize; use serde::Serialize;
#[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)] #[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)]
@ -24,12 +25,12 @@ pub struct UserMentionForm {
impl Crud<UserMentionForm> for UserMention { impl Crud<UserMentionForm> for UserMention {
fn read(conn: &PgConnection, user_mention_id: i32) -> Result<Self, Error> { fn read(conn: &PgConnection, user_mention_id: i32) -> Result<Self, Error> {
use crate::schema::user_mention::dsl::*; use lemmy_db_schema::schema::user_mention::dsl::*;
user_mention.find(user_mention_id).first::<Self>(conn) user_mention.find(user_mention_id).first::<Self>(conn)
} }
fn create(conn: &PgConnection, user_mention_form: &UserMentionForm) -> Result<Self, Error> { fn create(conn: &PgConnection, user_mention_form: &UserMentionForm) -> Result<Self, Error> {
use crate::schema::user_mention::dsl::*; use lemmy_db_schema::schema::user_mention::dsl::*;
// since the return here isnt utilized, we dont need to do an update // since the return here isnt utilized, we dont need to do an update
// but get_result doesnt return the existing row here // but get_result doesnt return the existing row here
insert_into(user_mention) insert_into(user_mention)
@ -45,7 +46,7 @@ impl Crud<UserMentionForm> for UserMention {
user_mention_id: i32, user_mention_id: i32,
user_mention_form: &UserMentionForm, user_mention_form: &UserMentionForm,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::user_mention::dsl::*; use lemmy_db_schema::schema::user_mention::dsl::*;
diesel::update(user_mention.find(user_mention_id)) diesel::update(user_mention.find(user_mention_id))
.set(user_mention_form) .set(user_mention_form)
.get_result::<Self>(conn) .get_result::<Self>(conn)
@ -58,14 +59,14 @@ impl UserMention {
user_mention_id: i32, user_mention_id: i32,
new_read: bool, new_read: bool,
) -> Result<Self, Error> { ) -> Result<Self, Error> {
use crate::schema::user_mention::dsl::*; use lemmy_db_schema::schema::user_mention::dsl::*;
diesel::update(user_mention.find(user_mention_id)) diesel::update(user_mention.find(user_mention_id))
.set(read.eq(new_read)) .set(read.eq(new_read))
.get_result::<Self>(conn) .get_result::<Self>(conn)
} }
pub fn mark_all_as_read(conn: &PgConnection, for_recipient_id: i32) -> Result<Vec<Self>, Error> { pub fn mark_all_as_read(conn: &PgConnection, for_recipient_id: i32) -> Result<Vec<Self>, Error> {
use crate::schema::user_mention::dsl::*; use lemmy_db_schema::schema::user_mention::dsl::*;
diesel::update( diesel::update(
user_mention user_mention
.filter(recipient_id.eq(for_recipient_id)) .filter(recipient_id.eq(for_recipient_id))

10
lemmy_db/src/views/comment_report_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{comment, comment_report, community, post, user_, user_alias_1, user_alias_2},
source::{ source::{
comment::Comment, comment::Comment,
comment_report::CommentReport, comment_report::CommentReport,
@ -13,6 +12,15 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{
comment,
comment_report,
community,
post,
user_,
user_alias_1,
user_alias_2,
};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, PartialEq, Serialize, Clone)] #[derive(Debug, PartialEq, Serialize, Clone)]

26
lemmy_db/src/views/comment_view.rs
View file

@ -3,19 +3,6 @@ use crate::{
functions::hot_rank, functions::hot_rank,
fuzzy_search, fuzzy_search,
limit_and_offset, limit_and_offset,
schema::{
comment,
comment_aggregates,
comment_alias_1,
comment_like,
comment_saved,
community,
community_follower,
community_user_ban,
post,
user_,
user_alias_1,
},
source::{ source::{
comment::{Comment, CommentAlias1, CommentSaved}, comment::{Comment, CommentAlias1, CommentSaved},
community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan}, community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan},
@ -29,6 +16,19 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{
comment,
comment_aggregates,
comment_alias_1,
comment_like,
comment_saved,
community,
community_follower,
community_user_ban,
post,
user_,
user_alias_1,
};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, PartialEq, Serialize, Clone)] #[derive(Debug, PartialEq, Serialize, Clone)]

2
lemmy_db/src/views/community/community_follower_view.rs
View file

@ -1,5 +1,4 @@
use crate::{ use crate::{
schema::{community, community_follower, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
user::{UserSafe, User_}, user::{UserSafe, User_},
@ -8,6 +7,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, community_follower, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/community/community_moderator_view.rs
View file

@ -1,5 +1,4 @@
use crate::{ use crate::{
schema::{community, community_moderator, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
user::{UserSafe, User_}, user::{UserSafe, User_},
@ -8,6 +7,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, community_moderator, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/community/community_user_ban_view.rs
View file

@ -1,5 +1,4 @@
use crate::{ use crate::{
schema::{community, community_user_ban, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
user::{UserSafe, User_}, user::{UserSafe, User_},
@ -7,6 +6,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, community_user_ban, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

8
lemmy_db/src/views/community/community_view.rs
View file

@ -3,7 +3,6 @@ use crate::{
functions::hot_rank, functions::hot_rank,
fuzzy_search, fuzzy_search,
limit_and_offset, limit_and_offset,
schema::{category, community, community_aggregates, community_follower, user_},
source::{ source::{
category::Category, category::Category,
community::{Community, CommunityFollower, CommunitySafe}, community::{Community, CommunityFollower, CommunitySafe},
@ -15,6 +14,13 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{
category,
community,
community_aggregates,
community_follower,
user_,
};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_add_community_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, mod_add_community, user_, user_alias_1},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
moderator::ModAddCommunity, moderator::ModAddCommunity,
@ -10,6 +9,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, mod_add_community, user_, user_alias_1};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_add_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{mod_add, user_, user_alias_1},
source::{ source::{
moderator::ModAdd, moderator::ModAdd,
user::{UserAlias1, UserSafe, UserSafeAlias1, User_}, user::{UserAlias1, UserSafe, UserSafeAlias1, User_},
@ -9,6 +8,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{mod_add, user_, user_alias_1};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_ban_from_community_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, mod_ban_from_community, user_, user_alias_1},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
moderator::ModBanFromCommunity, moderator::ModBanFromCommunity,
@ -10,6 +9,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, mod_ban_from_community, user_, user_alias_1};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_ban_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{mod_ban, user_, user_alias_1},
source::{ source::{
moderator::ModBan, moderator::ModBan,
user::{UserAlias1, UserSafe, UserSafeAlias1, User_}, user::{UserAlias1, UserSafe, UserSafeAlias1, User_},
@ -9,6 +8,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{mod_ban, user_, user_alias_1};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_lock_post_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, mod_lock_post, post, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
moderator::ModLockPost, moderator::ModLockPost,
@ -11,6 +10,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, mod_lock_post, post, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_remove_comment_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{comment, community, mod_remove_comment, post, user_, user_alias_1},
source::{ source::{
comment::Comment, comment::Comment,
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
@ -12,6 +11,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{comment, community, mod_remove_comment, post, user_, user_alias_1};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_remove_community_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, mod_remove_community, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
moderator::ModRemoveCommunity, moderator::ModRemoveCommunity,
@ -10,6 +9,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, mod_remove_community, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_remove_post_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, mod_remove_post, post, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
moderator::ModRemovePost, moderator::ModRemovePost,
@ -11,6 +10,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, mod_remove_post, post, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/moderator/mod_sticky_post_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, mod_sticky_post, post, user_},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
moderator::ModStickyPost, moderator::ModStickyPost,
@ -11,6 +10,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, mod_sticky_post, post, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

2
lemmy_db/src/views/post_report_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{community, post, post_report, user_, user_alias_1, user_alias_2},
source::{ source::{
community::{Community, CommunitySafe}, community::{Community, CommunitySafe},
post::Post, post::Post,
@ -12,6 +11,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{community, post, post_report, user_, user_alias_1, user_alias_2};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, PartialEq, Serialize, Clone)] #[derive(Debug, PartialEq, Serialize, Clone)]

22
lemmy_db/src/views/post_view.rs
View file

@ -3,17 +3,6 @@ use crate::{
functions::hot_rank, functions::hot_rank,
fuzzy_search, fuzzy_search,
limit_and_offset, limit_and_offset,
schema::{
community,
community_follower,
community_user_ban,
post,
post_aggregates,
post_like,
post_read,
post_saved,
user_,
},
source::{ source::{
community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan}, community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan},
post::{Post, PostRead, PostSaved}, post::{Post, PostRead, PostSaved},
@ -26,6 +15,17 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{
community,
community_follower,
community_user_ban,
post,
post_aggregates,
post_like,
post_read,
post_saved,
user_,
};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, PartialEq, Serialize, Clone)] #[derive(Debug, PartialEq, Serialize, Clone)]

2
lemmy_db/src/views/private_message_view.rs
View file

@ -1,6 +1,5 @@
use crate::{ use crate::{
limit_and_offset, limit_and_offset,
schema::{private_message, user_, user_alias_1},
source::{ source::{
private_message::PrivateMessage, private_message::PrivateMessage,
user::{UserAlias1, UserSafe, UserSafeAlias1, User_}, user::{UserAlias1, UserSafe, UserSafeAlias1, User_},
@ -10,6 +9,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{private_message, user_, user_alias_1};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, PartialEq, Serialize, Clone)] #[derive(Debug, PartialEq, Serialize, Clone)]

2
lemmy_db/src/views/site_view.rs
View file

@ -1,5 +1,4 @@
use crate::{ use crate::{
schema::{site, user_},
source::{ source::{
site::Site, site::Site,
user::{UserSafe, User_}, user::{UserSafe, User_},
@ -7,6 +6,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{site, user_};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

26
lemmy_db/src/views/user_mention_view.rs
View file

@ -2,19 +2,6 @@ use crate::{
aggregates::comment_aggregates::CommentAggregates, aggregates::comment_aggregates::CommentAggregates,
functions::hot_rank, functions::hot_rank,
limit_and_offset, limit_and_offset,
schema::{
comment,
comment_aggregates,
comment_like,
comment_saved,
community,
community_follower,
community_user_ban,
post,
user_,
user_alias_1,
user_mention,
},
source::{ source::{
comment::{Comment, CommentSaved}, comment::{Comment, CommentSaved},
community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan}, community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan},
@ -28,6 +15,19 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{result::Error, *}; use diesel::{result::Error, *};
use lemmy_db_schema::schema::{
comment,
comment_aggregates,
comment_like,
comment_saved,
community,
community_follower,
community_user_ban,
post,
user_,
user_alias_1,
user_mention,
};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, PartialEq, Serialize, Clone)] #[derive(Debug, PartialEq, Serialize, Clone)]

2
lemmy_db/src/views/user_view.rs
View file

@ -2,7 +2,6 @@ use crate::{
aggregates::user_aggregates::UserAggregates, aggregates::user_aggregates::UserAggregates,
fuzzy_search, fuzzy_search,
limit_and_offset, limit_and_offset,
schema::{user_, user_aggregates},
source::user::{UserSafe, User_}, source::user::{UserSafe, User_},
views::ViewToVec, views::ViewToVec,
MaybeOptional, MaybeOptional,
@ -10,6 +9,7 @@ use crate::{
ToSafe, ToSafe,
}; };
use diesel::{dsl::*, result::Error, *}; use diesel::{dsl::*, result::Error, *};
use lemmy_db_schema::schema::{user_, user_aggregates};
use serde::Serialize; use serde::Serialize;
#[derive(Debug, Serialize, Clone)] #[derive(Debug, Serialize, Clone)]

7
lemmy_db_schema/Cargo.toml Normal file
View file

@ -0,0 +1,7 @@
[package]
name = "lemmy_db_schema"
version = "0.1.0"
edition = "2018"
[dependencies]
diesel = { version = "1.4.5", features = ["postgres","chrono","r2d2","serde_json"] }

4
lemmy_db_schema/src/lib.rs Normal file
View file

@ -0,0 +1,4 @@
#[macro_use]
extern crate diesel;
pub mod schema;

0
lemmy_db/src/schema.rs → lemmy_db_schema/src/schema.rs
View file

12
src/code_migrations.rs
View file

@ -33,7 +33,7 @@ pub fn run_advanced_migrations(conn: &PgConnection) -> Result<(), LemmyError> {
} }
fn user_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> { fn user_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> {
use lemmy_db::schema::user_::dsl::*; use lemmy_db_schema::schema::user_::dsl::*;
info!("Running user_updates_2020_04_02"); info!("Running user_updates_2020_04_02");
@ -86,7 +86,7 @@ fn user_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> {
} }
fn community_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> { fn community_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> {
use lemmy_db::schema::community::dsl::*; use lemmy_db_schema::schema::community::dsl::*;
info!("Running community_updates_2020_04_02"); info!("Running community_updates_2020_04_02");
@ -132,7 +132,7 @@ fn community_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> {
} }
fn post_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> { fn post_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> {
use lemmy_db::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
info!("Running post_updates_2020_04_03"); info!("Running post_updates_2020_04_03");
@ -157,7 +157,7 @@ fn post_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> {
} }
fn comment_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> { fn comment_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> {
use lemmy_db::schema::comment::dsl::*; use lemmy_db_schema::schema::comment::dsl::*;
info!("Running comment_updates_2020_04_03"); info!("Running comment_updates_2020_04_03");
@ -182,7 +182,7 @@ fn comment_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> {
} }
fn private_message_updates_2020_05_05(conn: &PgConnection) -> Result<(), LemmyError> { fn private_message_updates_2020_05_05(conn: &PgConnection) -> Result<(), LemmyError> {
use lemmy_db::schema::private_message::dsl::*; use lemmy_db_schema::schema::private_message::dsl::*;
info!("Running private_message_updates_2020_05_05"); info!("Running private_message_updates_2020_05_05");
@ -203,7 +203,7 @@ fn private_message_updates_2020_05_05(conn: &PgConnection) -> Result<(), LemmyEr
} }
fn post_thumbnail_url_updates_2020_07_27(conn: &PgConnection) -> Result<(), LemmyError> { fn post_thumbnail_url_updates_2020_07_27(conn: &PgConnection) -> Result<(), LemmyError> {
use lemmy_db::schema::post::dsl::*; use lemmy_db_schema::schema::post::dsl::*;
info!("Running post_thumbnail_url_updates_2020_07_27"); info!("Running post_thumbnail_url_updates_2020_07_27");