Mirrors/lemmy
2
0
Fork 0
mirror of https://github.com/LemmyNet/lemmy synced 2024-11-10 06:54:12 +00:00
Code Issues Projects Releases Packages Wiki Activity

Removing old postview.

Browse source
This commit is contained in:
Dessalines 2020-12-11 10:27:33 -05:00
parent afc79ce0e3
commit 35bf50ab15
14 changed files with 423 additions and 817 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
lemmy_api/src/post.rs
View file

@ -15,10 +15,10 @@ use lemmy_db::{
naive_now,
post::*,
post_report::*,
post_view::*,
views::{
community_moderator_view::CommunityModeratorView,
community_view::CommunityView,
post_view::{PostQueryBuilder, PostView},
site_view::SiteView,
},
Crud,
@ -145,7 +145,7 @@ impl Perform for CreatePost {
Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
};
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePost,
@ -190,13 +190,13 @@ impl Perform for GetPost {
})
.await??;
let community_id = post_view.community_id;
let community_id = post_view.community.id;
let community = blocking(context.pool(), move |conn| {
CommunityView::read(conn, community_id, user_id)
})
.await??;
let community_id = post_view.community_id;
let community_id = post_view.community.id;
let moderators = blocking(context.pool(), move |conn| {
CommunityModeratorView::for_community(conn, community_id)
})
@ -210,7 +210,7 @@ impl Perform for GetPost {
// Return the jwt
Ok(GetPostResponse {
post: post_view,
post_view,
comments,
community,
moderators,
@ -249,13 +249,12 @@ impl Perform for GetPosts {
let community_id = data.community_id;
let community_name = data.community_name.to_owned();
let posts = match blocking(context.pool(), move |conn| {
PostQueryBuilder::create(conn)
PostQueryBuilder::create(conn, user_id)
.listing_type(&type_)
.sort(&sort)
.show_nsfw(show_nsfw)
.for_community_id(community_id)
.for_community_name(community_name)
.my_user_id(user_id)
.page(page)
.limit(limit)
.list()
@ -338,7 +337,7 @@ impl Perform for CreatePostLike {
Err(_e) => return Err(APIError::err("couldnt_find_post").into()),
};
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePostLike,
@ -431,7 +430,7 @@ impl Perform for EditPost {
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::EditPost,
@ -487,7 +486,7 @@ impl Perform for DeletePost {
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::DeletePost,
@ -554,7 +553,7 @@ impl Perform for RemovePost {
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::RemovePost,
@ -612,7 +611,7 @@ impl Perform for LockPost {
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::LockPost,
@ -674,7 +673,7 @@ impl Perform for StickyPost {
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::StickyPost,
@ -722,7 +721,7 @@ impl Perform for SavePost {
})
.await??;
Ok(PostResponse { post: post_view })
Ok(PostResponse { post_view })
}
}
@ -772,19 +771,19 @@ impl Perform for CreatePostReport {
let user_id = user.id;
let post_id = data.post_id;
let post = blocking(context.pool(), move |conn| {
let post_view = blocking(context.pool(), move |conn| {
PostView::read(&conn, post_id, None)
})
.await??;
check_community_ban(user_id, post.community_id, context.pool()).await?;
check_community_ban(user_id, post_view.community.id, context.pool()).await?;
let report_form = PostReportForm {
creator_id: user_id,
post_id,
original_post_name: post.name,
original_post_url: post.url,
original_post_body: post.body,
original_post_name: post_view.post.name,
original_post_url: post_view.post.url,
original_post_body: post_view.post.body,
reason: data.reason.to_owned(),
};
@ -809,7 +808,7 @@ impl Perform for CreatePostReport {
context.chat_server().do_send(SendModRoomMessage {
op: UserOperation::CreatePostReport,
response: report,
community_id: post.community_id,
community_id: post_view.community.id,
websocket_id,
});

10
lemmy_api/src/site.rs
View file

@ -17,10 +17,10 @@ use lemmy_db::{
moderator::*,
moderator_views::*,
naive_now,
post_view::*,
site::*,
views::{
community_view::CommunityQueryBuilder,
post_view::PostQueryBuilder,
site_view::SiteView,
user_view::{UserQueryBuilder, UserViewSafe},
},
@ -365,13 +365,12 @@ impl Perform for Search {
match type_ {
SearchType::Posts => {
posts = blocking(context.pool(), move |conn| {
PostQueryBuilder::create(conn)
PostQueryBuilder::create(conn, user_id)
.sort(&sort)
.show_nsfw(true)
.for_community_id(community_id)
.for_community_name(community_name)
.search_term(q)
.my_user_id(user_id)
.page(page)
.limit(limit)
.list()
@ -414,13 +413,12 @@ impl Perform for Search {
}
SearchType::All => {
posts = blocking(context.pool(), move |conn| {
PostQueryBuilder::create(conn)
PostQueryBuilder::create(conn, user_id)
.sort(&sort)
.show_nsfw(true)
.for_community_id(community_id)
.for_community_name(community_name)
.search_term(q)
.my_user_id(user_id)
.page(page)
.limit(limit)
.list()
@ -469,7 +467,7 @@ impl Perform for Search {
}
SearchType::Url => {
posts = blocking(context.pool(), move |conn| {
PostQueryBuilder::create(conn)
PostQueryBuilder::create(conn, None)
.sort(&sort)
.show_nsfw(true)
.for_community_id(community_id)

5
lemmy_api/src/user.rs
View file

@ -25,7 +25,6 @@ use lemmy_db::{
password_reset_request::*,
post::*,
post_report::PostReportView,
post_view::*,
private_message::*,
private_message_view::*,
site::*,
@ -35,6 +34,7 @@ use lemmy_db::{
views::{
community_follower_view::CommunityFollowerView,
community_moderator_view::CommunityModeratorView,
post_view::PostQueryBuilder,
site_view::SiteView,
user_view::{UserViewDangerous, UserViewSafe},
},
@ -534,12 +534,11 @@ impl Perform for GetUserDetails {
let community_id = data.community_id;
let (posts, comments) = blocking(context.pool(), move |conn| {
let mut posts_query = PostQueryBuilder::create(conn)
let mut posts_query = PostQueryBuilder::create(conn, user_id)
.sort(&sort)
.show_nsfw(show_nsfw)
.saved_only(saved_only)
.for_community_id(community_id)
.my_user_id(user_id)
.page(page)
.limit(limit);

14
lemmy_apub/src/activities/receive/post.rs
View file

@ -6,7 +6,7 @@ use activitystreams::{
use anyhow::Context;
use lemmy_db::{
post::{Post, PostLike, PostLikeForm},
post_view::PostView,
views::post_view::PostView,
Likeable,
};
use lemmy_structs::{blocking, post::PostResponse};
@ -31,7 +31,7 @@ pub(crate) async fn receive_create_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePost,
@ -60,7 +60,7 @@ pub(crate) async fn receive_update_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::EditPost,
@ -98,7 +98,7 @@ pub(crate) async fn receive_like_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePostLike,
@ -136,7 +136,7 @@ pub(crate) async fn receive_dislike_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePostLike,
@ -163,7 +163,7 @@ pub(crate) async fn receive_delete_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::EditPost,
post: res,
@ -190,7 +190,7 @@ pub(crate) async fn receive_remove_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::EditPost,
post: res,

10
lemmy_apub/src/activities/receive/post_undo.rs
View file

@ -2,7 +2,7 @@ use crate::activities::receive::get_actor_as_user;
use activitystreams::activity::{Dislike, Like};
use lemmy_db::{
post::{Post, PostLike},
post_view::PostView,
views::post_view::PostView,
Likeable,
};
use lemmy_structs::{blocking, post::PostResponse};
@ -30,7 +30,7 @@ pub(crate) async fn receive_undo_like_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePostLike,
@ -62,7 +62,7 @@ pub(crate) async fn receive_undo_dislike_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::CreatePostLike,
@ -89,7 +89,7 @@ pub(crate) async fn receive_undo_delete_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::EditPost,
post: res,
@ -115,7 +115,7 @@ pub(crate) async fn receive_undo_remove_post(
})
.await??;
let res = PostResponse { post: post_view };
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
op: UserOperation::EditPost,

3
lemmy_apub/src/fetcher.rs
View file

@ -18,9 +18,8 @@ use lemmy_db::{
community::{Community, CommunityModerator, CommunityModeratorForm},
naive_now,
post::Post,
post_view::PostView,
user::User_,
views::{community_view::CommunityView, user_view::UserViewSafe},
views::{community_view::CommunityView, post_view::PostView, user_view::UserViewSafe},
ApubObject,
Joinable,
SearchType,

1
lemmy_db/src/lib.rs
View file

@ -23,7 +23,6 @@ pub mod moderator_views;
pub mod password_reset_request;
pub mod post;
pub mod post_report;
pub mod post_view;
pub mod private_message;
pub mod private_message_view;
pub mod schema;

641
lemmy_db/src/post_view.rs
View file

@ -1,641 +0,0 @@
use super::post_view::post_fast_view::BoxedQuery;
use crate::{fuzzy_search, limit_and_offset, ListingType, MaybeOptional, SortType};
use diesel::{dsl::*, pg::Pg, result::Error, *};
use serde::Serialize;
// The faked schema since diesel doesn't do views
table! {
post_view (id) {
id -> Int4,
name -> Varchar,
url -> Nullable<Text>,
body -> Nullable<Text>,
creator_id -> Int4,
community_id -> Int4,
removed -> Bool,
locked -> Bool,
published -> Timestamp,
updated -> Nullable<Timestamp>,
deleted -> Bool,
nsfw -> Bool,
stickied -> Bool,
embed_title -> Nullable<Text>,
embed_description -> Nullable<Text>,
embed_html -> Nullable<Text>,
thumbnail_url -> Nullable<Text>,
ap_id -> Text,
local -> Bool,
creator_actor_id -> Text,
creator_local -> Bool,
creator_name -> Varchar,
creator_preferred_username -> Nullable<Varchar>,
creator_published -> Timestamp,
creator_avatar -> Nullable<Text>,
banned -> Bool,
banned_from_community -> Bool,
community_actor_id -> Text,
community_local -> Bool,
community_name -> Varchar,
community_icon -> Nullable<Text>,
community_removed -> Bool,
community_deleted -> Bool,
community_nsfw -> Bool,
number_of_comments -> BigInt,
score -> BigInt,
upvotes -> BigInt,
downvotes -> BigInt,
hot_rank -> Int4,
hot_rank_active -> Int4,
newest_activity_time -> Timestamp,
user_id -> Nullable<Int4>,
my_vote -> Nullable<Int4>,
subscribed -> Nullable<Bool>,
read -> Nullable<Bool>,
saved -> Nullable<Bool>,
}
}
table! {
post_fast_view (id) {
id -> Int4,
name -> Varchar,
url -> Nullable<Text>,
body -> Nullable<Text>,
creator_id -> Int4,
community_id -> Int4,
removed -> Bool,
locked -> Bool,
published -> Timestamp,
updated -> Nullable<Timestamp>,
deleted -> Bool,
nsfw -> Bool,
stickied -> Bool,
embed_title -> Nullable<Text>,
embed_description -> Nullable<Text>,
embed_html -> Nullable<Text>,
thumbnail_url -> Nullable<Text>,
ap_id -> Text,
local -> Bool,
creator_actor_id -> Text,
creator_local -> Bool,
creator_name -> Varchar,
creator_preferred_username -> Nullable<Varchar>,
creator_published -> Timestamp,
creator_avatar -> Nullable<Text>,
banned -> Bool,
banned_from_community -> Bool,
community_actor_id -> Text,
community_local -> Bool,
community_name -> Varchar,
community_icon -> Nullable<Text>,
community_removed -> Bool,
community_deleted -> Bool,
community_nsfw -> Bool,
number_of_comments -> BigInt,
score -> BigInt,
upvotes -> BigInt,
downvotes -> BigInt,
hot_rank -> Int4,
hot_rank_active -> Int4,
newest_activity_time -> Timestamp,
user_id -> Nullable<Int4>,
my_vote -> Nullable<Int4>,
subscribed -> Nullable<Bool>,
read -> Nullable<Bool>,
saved -> Nullable<Bool>,
}
}
#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, QueryableByName, Clone)]
#[table_name = "post_fast_view"]
pub struct PostView {
pub id: i32,
pub name: String,
pub url: Option<String>,
pub body: Option<String>,
pub creator_id: i32,
pub community_id: i32,
pub removed: bool,
pub locked: bool,
pub published: chrono::NaiveDateTime,
pub updated: Option<chrono::NaiveDateTime>,
pub deleted: bool,
pub nsfw: bool,
pub stickied: bool,
pub embed_title: Option<String>,
pub embed_description: Option<String>,
pub embed_html: Option<String>,
pub thumbnail_url: Option<String>,
pub ap_id: String,
pub local: bool,
pub creator_actor_id: String,
pub creator_local: bool,
pub creator_name: String,
pub creator_preferred_username: Option<String>,
pub creator_published: chrono::NaiveDateTime,
pub creator_avatar: Option<String>,
pub banned: bool,
pub banned_from_community: bool,
pub community_actor_id: String,
pub community_local: bool,
pub community_name: String,
pub community_icon: Option<String>,
pub community_removed: bool,
pub community_deleted: bool,
pub community_nsfw: bool,
pub number_of_comments: i64,
pub score: i64,
pub upvotes: i64,
pub downvotes: i64,
pub hot_rank: i32,
pub hot_rank_active: i32,
pub newest_activity_time: chrono::NaiveDateTime,
pub user_id: Option<i32>,
pub my_vote: Option<i32>,
pub subscribed: Option<bool>,
pub read: Option<bool>,
pub saved: Option<bool>,
}
pub struct PostQueryBuilder<'a> {
conn: &'a PgConnection,
query: BoxedQuery<'a, Pg>,
listing_type: &'a ListingType,
sort: &'a SortType,
my_user_id: Option<i32>,
for_creator_id: Option<i32>,
for_community_id: Option<i32>,
for_community_name: Option<String>,
search_term: Option<String>,
url_search: Option<String>,
show_nsfw: bool,
saved_only: bool,
unread_only: bool,
page: Option<i64>,
limit: Option<i64>,
}
impl<'a> PostQueryBuilder<'a> {
pub fn create(conn: &'a PgConnection) -> Self {
use super::post_view::post_fast_view::dsl::*;
let query = post_fast_view.into_boxed();
PostQueryBuilder {
conn,
query,
listing_type: &ListingType::All,
sort: &SortType::Hot,
my_user_id: None,
for_creator_id: None,
for_community_id: None,
for_community_name: None,
search_term: None,
url_search: None,
show_nsfw: true,
saved_only: false,
unread_only: false,
page: None,
limit: None,
}
}
pub fn listing_type(mut self, listing_type: &'a ListingType) -> Self {
self.listing_type = listing_type;
self
}
pub fn sort(mut self, sort: &'a SortType) -> Self {
self.sort = sort;
self
}
pub fn for_community_id<T: MaybeOptional<i32>>(mut self, for_community_id: T) -> Self {
self.for_community_id = for_community_id.get_optional();
self
}
pub fn for_community_name<T: MaybeOptional<String>>(mut self, for_community_name: T) -> Self {
self.for_community_name = for_community_name.get_optional();
self
}
pub fn for_creator_id<T: MaybeOptional<i32>>(mut self, for_creator_id: T) -> Self {
self.for_creator_id = for_creator_id.get_optional();
self
}
pub fn search_term<T: MaybeOptional<String>>(mut self, search_term: T) -> Self {
self.search_term = search_term.get_optional();
self
}
pub fn url_search<T: MaybeOptional<String>>(mut self, url_search: T) -> Self {
self.url_search = url_search.get_optional();
self
}
pub fn my_user_id<T: MaybeOptional<i32>>(mut self, my_user_id: T) -> Self {
self.my_user_id = my_user_id.get_optional();
self
}
pub fn show_nsfw(mut self, show_nsfw: bool) -> Self {
self.show_nsfw = show_nsfw;
self
}
pub fn saved_only(mut self, saved_only: bool) -> Self {
self.saved_only = saved_only;
self
}
pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
self.page = page.get_optional();
self
}
pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
self.limit = limit.get_optional();
self
}
pub fn list(self) -> Result<Vec<PostView>, Error> {
use super::post_view::post_fast_view::dsl::*;
let mut query = self.query;
query = match self.listing_type {
ListingType::Subscribed => query.filter(subscribed.eq(true)),
ListingType::Local => query.filter(community_local.eq(true)),
_ => query,
};
if let Some(for_community_id) = self.for_community_id {
query = query
.filter(community_id.eq(for_community_id))
.then_order_by(stickied.desc());
}
if let Some(for_community_name) = self.for_community_name {
query = query
.filter(community_name.eq(for_community_name))
.filter(community_local.eq(true))
.then_order_by(stickied.desc());
}
if let Some(url_search) = self.url_search {
query = query.filter(url.eq(url_search));
}
if let Some(search_term) = self.search_term {
let searcher = fuzzy_search(&search_term);
query = query.filter(name.ilike(searcher.to_owned()).or(body.ilike(searcher)));
}
query = match self.sort {
SortType::Active => query
.then_order_by(hot_rank_active.desc())
.then_order_by(published.desc()),
SortType::Hot => query
.then_order_by(hot_rank.desc())
.then_order_by(published.desc()),
SortType::New => query.then_order_by(published.desc()),
SortType::TopAll => query.then_order_by(score.desc()),
SortType::TopYear => query
.filter(published.gt(now - 1.years()))
.then_order_by(score.desc()),
SortType::TopMonth => query
.filter(published.gt(now - 1.months()))
.then_order_by(score.desc()),
SortType::TopWeek => query
.filter(published.gt(now - 1.weeks()))
.then_order_by(score.desc()),
SortType::TopDay => query
.filter(published.gt(now - 1.days()))
.then_order_by(score.desc()),
};
// The view lets you pass a null user_id, if you're not logged in
query = if let Some(my_user_id) = self.my_user_id {
query.filter(user_id.eq(my_user_id))
} else {
query.filter(user_id.is_null())
};
// If its for a specific user, show the removed / deleted
if let Some(for_creator_id) = self.for_creator_id {
query = query.filter(creator_id.eq(for_creator_id));
} else {
query = query
.filter(removed.eq(false))
.filter(deleted.eq(false))
.filter(community_removed.eq(false))
.filter(community_deleted.eq(false));
}
if !self.show_nsfw {
query = query
.filter(nsfw.eq(false))
.filter(community_nsfw.eq(false));
};
// TODO these are wrong, bc they'll only show saved for your logged in user, not theirs
if self.saved_only {
query = query.filter(saved.eq(true));
};
if self.unread_only {
query = query.filter(read.eq(false));
};
let (limit, offset) = limit_and_offset(self.page, self.limit);
query = query
.limit(limit)
.offset(offset)
.filter(removed.eq(false))
.filter(deleted.eq(false))
.filter(community_removed.eq(false))
.filter(community_deleted.eq(false));
query.load::<PostView>(self.conn)
}
}
impl PostView {
pub fn read(
conn: &PgConnection,
from_post_id: i32,
my_user_id: Option<i32>,
) -> Result<Self, Error> {
use super::post_view::post_fast_view::dsl::*;
use diesel::prelude::*;
let mut query = post_fast_view.into_boxed();
query = query.filter(id.eq(from_post_id));
if let Some(my_user_id) = my_user_id {
query = query.filter(user_id.eq(my_user_id));
} else {
query = query.filter(user_id.is_null());
};
query.first::<Self>(conn)
}
}
#[cfg(test)]
mod tests {
use crate::{
community::*,
post::*,
post_view::*,
tests::establish_unpooled_connection,
user::*,
Crud,
Likeable,
*,
};
#[test]
fn test_crud() {
let conn = establish_unpooled_connection();
let user_name = "tegan".to_string();
let community_name = "test_community_3".to_string();
let post_name = "test post 3".to_string();
let new_user = UserForm {
name: user_name.to_owned(),
preferred_username: None,
password_encrypted: "nope".into(),
email: None,
matrix_user_id: None,
avatar: None,
banner: None,
published: None,
updated: None,
admin: false,
banned: Some(false),
show_nsfw: false,
theme: "browser".into(),
default_sort_type: SortType::Hot as i16,
default_listing_type: ListingType::Subscribed as i16,
lang: "browser".into(),
show_avatars: true,
send_notifications_to_email: false,
actor_id: None,
bio: None,
local: true,
private_key: None,
public_key: None,
last_refreshed_at: None,
};
let inserted_user = User_::create(&conn, &new_user).unwrap();
let new_community = CommunityForm {
name: community_name.to_owned(),
title: "nada".to_owned(),
description: None,
creator_id: inserted_user.id,
category_id: 1,
removed: None,
deleted: None,
updated: None,
nsfw: false,
actor_id: None,
local: true,
private_key: None,
public_key: None,
last_refreshed_at: None,
published: None,
icon: None,
banner: None,
};
let inserted_community = Community::create(&conn, &new_community).unwrap();
let new_post = PostForm {
name: post_name.to_owned(),
url: None,
body: None,
creator_id: inserted_user.id,
community_id: inserted_community.id,
removed: None,
deleted: None,
locked: None,
stickied: None,
updated: None,
nsfw: false,
embed_title: None,
embed_description: None,
embed_html: None,
thumbnail_url: None,
ap_id: None,
local: true,
published: None,
};
let inserted_post = Post::create(&conn, &new_post).unwrap();
let post_like_form = PostLikeForm {
post_id: inserted_post.id,
user_id: inserted_user.id,
score: 1,
};
let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap();
let expected_post_like = PostLike {
id: inserted_post_like.id,
post_id: inserted_post.id,
user_id: inserted_user.id,
published: inserted_post_like.published,
score: 1,
};
let read_post_listings_with_user = PostQueryBuilder::create(&conn)
.listing_type(&ListingType::Community)
.sort(&SortType::New)
.for_community_id(inserted_community.id)
.my_user_id(inserted_user.id)
.list()
.unwrap();
let read_post_listings_no_user = PostQueryBuilder::create(&conn)
.listing_type(&ListingType::Community)
.sort(&SortType::New)
.for_community_id(inserted_community.id)
.list()
.unwrap();
let read_post_listing_no_user = PostView::read(&conn, inserted_post.id, None).unwrap();
let read_post_listing_with_user =
PostView::read(&conn, inserted_post.id, Some(inserted_user.id)).unwrap();
// the non user version
let expected_post_listing_no_user = PostView {
user_id: None,
my_vote: None,
id: inserted_post.id,
name: post_name.to_owned(),
url: None,
body: None,
creator_id: inserted_user.id,
creator_name: user_name.to_owned(),
creator_preferred_username: None,
creator_published: inserted_user.published,
creator_avatar: None,
banned: false,
banned_from_community: false,
community_id: inserted_community.id,
removed: false,
deleted: false,
locked: false,
stickied: false,
community_name: community_name.to_owned(),
community_icon: None,
community_removed: false,
community_deleted: false,
community_nsfw: false,
number_of_comments: 0,
score: 1,
upvotes: 1,
downvotes: 0,
hot_rank: read_post_listing_no_user.hot_rank,
hot_rank_active: read_post_listing_no_user.hot_rank_active,
published: inserted_post.published,
newest_activity_time: inserted_post.published,
updated: None,
subscribed: None,
read: None,
saved: None,
nsfw: false,
embed_title: None,
embed_description: None,
embed_html: None,
thumbnail_url: None,
ap_id: inserted_post.ap_id.to_owned(),
local: true,
creator_actor_id: inserted_user.actor_id.to_owned(),
creator_local: true,
community_actor_id: inserted_community.actor_id.to_owned(),
community_local: true,
};
let expected_post_listing_with_user = PostView {
user_id: Some(inserted_user.id),
my_vote: Some(1),
id: inserted_post.id,
name: post_name,
url: None,
body: None,
removed: false,
deleted: false,
locked: false,
stickied: false,
creator_id: inserted_user.id,
creator_name: user_name,
creator_preferred_username: None,
creator_published: inserted_user.published,
creator_avatar: None,
banned: false,
banned_from_community: false,
community_id: inserted_community.id,
community_name,
community_icon: None,
community_removed: false,
community_deleted: false,
community_nsfw: false,
number_of_comments: 0,
score: 1,
upvotes: 1,
downvotes: 0,
hot_rank: read_post_listing_with_user.hot_rank,
hot_rank_active: read_post_listing_with_user.hot_rank_active,
published: inserted_post.published,
newest_activity_time: inserted_post.published,
updated: None,
subscribed: Some(false),
read: Some(false),
saved: Some(false),
nsfw: false,
embed_title: None,
embed_description: None,
embed_html: None,
thumbnail_url: None,
ap_id: inserted_post.ap_id.to_owned(),
local: true,
creator_actor_id: inserted_user.actor_id.to_owned(),
creator_local: true,
community_actor_id: inserted_community.actor_id.to_owned(),
community_local: true,
};
let like_removed = PostLike::remove(&conn, inserted_user.id, inserted_post.id).unwrap();
let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
Community::delete(&conn, inserted_community.id).unwrap();
User_::delete(&conn, inserted_user.id).unwrap();
// The with user
assert_eq!(
expected_post_listing_with_user,
read_post_listings_with_user[0]
);
assert_eq!(expected_post_listing_with_user, read_post_listing_with_user);
assert_eq!(1, read_post_listings_with_user.len());
// Without the user
assert_eq!(expected_post_listing_no_user, read_post_listings_no_user[0]);
assert_eq!(expected_post_listing_no_user, read_post_listing_no_user);
assert_eq!(1, read_post_listings_no_user.len());
// assert_eq!(expected_post, inserted_post);
// assert_eq!(expected_post, updated_post);
assert_eq!(expected_post_like, inserted_post_like);
assert_eq!(1, like_removed);
assert_eq!(1, num_deleted);
}
}

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

@ -26,14 +26,14 @@ use crate::{
use diesel::{result::Error, *};
use serde::Serialize;
#[derive(Debug, Serialize, Clone)]
#[derive(Debug, PartialEq, Serialize, Clone)]
pub struct PostView {
pub post: Post,
pub creator: UserSafe,
pub community: CommunitySafe,
pub counts: PostAggregates,
pub subscribed: bool, // Left join to CommunityFollower
pub banned_from_community: bool, // Left Join to CommunityUserBan
pub creator_banned_from_community: bool, // Left Join to CommunityUserBan
pub saved: bool, // Left join to PostSaved
pub read: bool, // Left join to PostRead
pub my_vote: Option<i16>, // Left join to PostLike
@ -43,9 +43,9 @@ type PostViewTuple = (
Post,
UserSafe,
CommunitySafe,
Option<CommunityUserBan>,
PostAggregates,
Option<CommunityFollower>,
Option<CommunityUserBan>,
Option<PostSaved>,
Option<PostRead>,
Option<i16>,
@ -56,11 +56,27 @@ impl PostView {
// The left join below will return None in this case
let user_id_join = my_user_id.unwrap_or(-1);
let (post, creator, community, counts, follower, banned_from_community, saved, read, my_vote) =
post::table
let (
post,
creator,
community,
creator_banned_from_community,
counts,
follower,
saved,
read,
my_vote,
) = post::table
.find(post_id)
.inner_join(user_::table)
.inner_join(community::table)
.left_join(
community_user_ban::table.on(
post::community_id
.eq(community_user_ban::community_id)
.and(community_user_ban::user_id.eq(community::creator_id)),
),
)
.inner_join(post_aggregates::table)
.left_join(
community_follower::table.on(
@ -69,13 +85,6 @@ impl PostView {
.and(community_follower::user_id.eq(user_id_join)),
),
)
.left_join(
community_user_ban::table.on(
post::community_id
.eq(community_user_ban::community_id)
.and(community_user_ban::user_id.eq(user_id_join)),
),
)
.left_join(
post_saved::table.on(
post::id
@ -101,9 +110,9 @@ impl PostView {
post::all_columns,
User_::safe_columns_tuple(),
Community::safe_columns_tuple(),
community_user_ban::all_columns.nullable(),
post_aggregates::all_columns,
community_follower::all_columns.nullable(),
community_user_ban::all_columns.nullable(),
post_saved::all_columns.nullable(),
post_read::all_columns.nullable(),
post_like::score.nullable(),
@ -114,9 +123,9 @@ impl PostView {
post,
creator,
community,
creator_banned_from_community: creator_banned_from_community.is_some(),
counts,
subscribed: follower.is_some(),
banned_from_community: banned_from_community.is_some(),
saved: saved.is_some(),
read: read.is_some(),
my_vote,
@ -143,7 +152,7 @@ mod join_types {
sql_types::*,
};
/// TODO awful, but necessary because of the boxed join
// /// TODO awful, but necessary because of the boxed join
pub(super) type BoxedPostJoin<'a> = BoxedSelectStatement<
'a,
(
@ -201,11 +210,11 @@ mod join_types {
Nullable<Text>,
Nullable<Text>,
),
Nullable<(Integer, Integer, Integer, Timestamp)>,
(Integer, Integer, BigInt, BigInt, BigInt, BigInt, Timestamp),
Nullable<(Integer, Integer, Integer, Timestamp, Nullable<Bool>)>,
Nullable<(Integer, Integer, Integer, Timestamp)>,
Nullable<(Integer, Integer, Integer, Timestamp)>,
Nullable<(Integer, Integer, Integer, Timestamp)>,
Nullable<SmallInt>,
),
JoinOn<
@ -239,13 +248,25 @@ mod join_types {
diesel::expression::nullable::Nullable<community::columns::id>,
>,
>,
community_user_ban::table,
LeftOuter,
>,
diesel::expression::operators::And<
diesel::expression::operators::Eq<
post::columns::community_id,
community_user_ban::columns::community_id,
>,
diesel::expression::operators::Eq<
community_user_ban::columns::user_id,
community::columns::creator_id,
>,
>,
>,
post_aggregates::table,
Inner,
>,
diesel::expression::operators::Eq<
diesel::expression::nullable::Nullable<
post_aggregates::columns::post_id,
>,
diesel::expression::nullable::Nullable<post_aggregates::columns::post_id>,
diesel::expression::nullable::Nullable<post::columns::id>,
>,
>,
@ -259,21 +280,7 @@ mod join_types {
>,
diesel::expression::operators::Eq<
community_follower::columns::user_id,
diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>,
>,
>,
>,
community_user_ban::table,
LeftOuter,
>,
diesel::expression::operators::And<
diesel::expression::operators::Eq<
post::columns::community_id,
community_user_ban::columns::community_id,
>,
diesel::expression::operators::Eq<
community_user_ban::columns::user_id,
diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>,
diesel::expression::bound::Bound<Integer, i32>,
>,
>,
>,
@ -284,7 +291,7 @@ mod join_types {
diesel::expression::operators::Eq<post::columns::id, post_saved::columns::post_id>,
diesel::expression::operators::Eq<
post_saved::columns::user_id,
diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>,
diesel::expression::bound::Bound<Integer, i32>,
>,
>,
>,
@ -295,7 +302,7 @@ mod join_types {
diesel::expression::operators::Eq<post::columns::id, post_read::columns::post_id>,
diesel::expression::operators::Eq<
post_read::columns::user_id,
diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>,
diesel::expression::bound::Bound<Integer, i32>,
>,
>,
>,
@ -306,7 +313,7 @@ mod join_types {
diesel::expression::operators::Eq<post::columns::id, post_like::columns::post_id>,
diesel::expression::operators::Eq<
post_like::columns::user_id,
diesel::expression::bound::Bound<diesel::sql_types::Integer, i32>,
diesel::expression::bound::Bound<Integer, i32>,
>,
>,
>,
@ -339,6 +346,13 @@ impl<'a> PostQueryBuilder<'a> {
let query = post::table
.inner_join(user_::table)
.inner_join(community::table)
.left_join(
community_user_ban::table.on(
post::community_id
.eq(community_user_ban::community_id)
.and(community_user_ban::user_id.eq(community::creator_id)),
),
)
.inner_join(post_aggregates::table)
.left_join(
community_follower::table.on(
@ -347,13 +361,6 @@ impl<'a> PostQueryBuilder<'a> {
.and(community_follower::user_id.eq(user_id_join)),
),
)
.left_join(
community_user_ban::table.on(
post::community_id
.eq(community_user_ban::community_id)
.and(community_user_ban::user_id.eq(user_id_join)),
),
)
.left_join(
post_saved::table.on(
post::id
@ -379,9 +386,9 @@ impl<'a> PostQueryBuilder<'a> {
post::all_columns,
User_::safe_columns_tuple(),
Community::safe_columns_tuple(),
community_user_ban::all_columns.nullable(),
post_aggregates::all_columns,
community_follower::all_columns.nullable(),
community_user_ban::all_columns.nullable(),
post_saved::all_columns.nullable(),
post_read::all_columns.nullable(),
post_like::score.nullable(),
@ -567,9 +574,9 @@ impl ViewToVec for PostView {
post: a.0.to_owned(),
creator: a.1.to_owned(),
community: a.2.to_owned(),
counts: a.3.to_owned(),
subscribed: a.4.is_some(),
banned_from_community: a.5.is_some(),
creator_banned_from_community: a.3.is_some(),
counts: a.4.to_owned(),
subscribed: a.5.is_some(),
saved: a.6.is_some(),
read: a.7.is_some(),
my_vote: a.8,
@ -577,3 +584,235 @@ impl ViewToVec for PostView {
.collect::<Vec<Self>>()
}
}
#[cfg(test)]
mod tests {
use crate::{
aggregates::post_aggregates::PostAggregates,
community::*,
post::*,
tests::establish_unpooled_connection,
user::*,
views::post_view::{PostQueryBuilder, PostView},
Crud,
Likeable,
*,
};
#[test]
fn test_crud() {
let conn = establish_unpooled_connection();
let user_name = "tegan".to_string();
let community_name = "test_community_3".to_string();
let post_name = "test post 3".to_string();
let new_user = UserForm {
name: user_name.to_owned(),
preferred_username: None,
password_encrypted: "nope".into(),
email: None,
matrix_user_id: None,
avatar: None,
banner: None,
published: None,
updated: None,
admin: false,
banned: Some(false),
show_nsfw: false,
theme: "browser".into(),
default_sort_type: SortType::Hot as i16,
default_listing_type: ListingType::Subscribed as i16,
lang: "browser".into(),
show_avatars: true,
send_notifications_to_email: false,
actor_id: None,
bio: None,
local: true,
private_key: None,
public_key: None,
last_refreshed_at: None,
};
let inserted_user = User_::create(&conn, &new_user).unwrap();
let new_community = CommunityForm {
name: community_name.to_owned(),
title: "nada".to_owned(),
description: None,
creator_id: inserted_user.id,
category_id: 1,
removed: None,
deleted: None,
updated: None,
nsfw: false,
actor_id: None,
local: true,
private_key: None,
public_key: None,
last_refreshed_at: None,
published: None,
icon: None,
banner: None,
};
let inserted_community = Community::create(&conn, &new_community).unwrap();
let new_post = PostForm {
name: post_name.to_owned(),
url: None,
body: None,
creator_id: inserted_user.id,
community_id: inserted_community.id,
removed: None,
deleted: None,
locked: None,
stickied: None,
updated: None,
nsfw: false,
embed_title: None,
embed_description: None,
embed_html: None,
thumbnail_url: None,
ap_id: None,
local: true,
published: None,
};
let inserted_post = Post::create(&conn, &new_post).unwrap();
let post_like_form = PostLikeForm {
post_id: inserted_post.id,
user_id: inserted_user.id,
score: 1,
};
let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap();
let expected_post_like = PostLike {
id: inserted_post_like.id,
post_id: inserted_post.id,
user_id: inserted_user.id,
published: inserted_post_like.published,
score: 1,
};
let read_post_listings_with_user = PostQueryBuilder::create(&conn, Some(inserted_user.id))
.listing_type(&ListingType::Community)
.sort(&SortType::New)
.for_community_id(inserted_community.id)
.list()
.unwrap();
let read_post_listings_no_user = PostQueryBuilder::create(&conn, None)
.listing_type(&ListingType::Community)
.sort(&SortType::New)
.for_community_id(inserted_community.id)
.list()
.unwrap();
let read_post_listing_no_user = PostView::read(&conn, inserted_post.id, None).unwrap();
let read_post_listing_with_user =
PostView::read(&conn, inserted_post.id, Some(inserted_user.id)).unwrap();
// the non user version
let expected_post_listing_no_user = PostView {
post: Post {
id: inserted_post.id,
name: post_name.to_owned(),
creator_id: inserted_user.id,
url: None,
body: None,
published: inserted_post.published,
updated: None,
community_id: inserted_community.id,
removed: false,
deleted: false,
locked: false,
stickied: false,
nsfw: false,
embed_title: None,
embed_description: None,
embed_html: None,
thumbnail_url: None,
ap_id: inserted_post.ap_id.to_owned(),
local: true,
},
my_vote: None,
creator: UserSafe {
id: inserted_user.id,
name: user_name.to_owned(),
preferred_username: None,
published: inserted_user.published,
avatar: None,
actor_id: inserted_user.actor_id.to_owned(),
local: true,
banned: false,
deleted: false,
bio: None,
banner: None,
admin: false,
updated: None,
matrix_user_id: None,
},
creator_banned_from_community: false,
community: CommunitySafe {
id: inserted_community.id,
name: community_name.to_owned(),
icon: None,
removed: false,
deleted: false,
nsfw: false,
actor_id: inserted_community.actor_id.to_owned(),
local: true,
title: "nada".to_owned(),
description: None,
creator_id: inserted_user.id,
category_id: 1,
updated: None,
banner: None,
published: inserted_community.published,
},
counts: PostAggregates {
id: inserted_post.id, // TODO this might fail
post_id: inserted_post.id,
comments: 0,
score: 1,
upvotes: 1,
downvotes: 0,
newest_comment_time: inserted_post.published,
},
subscribed: false,
read: false,
saved: false,
};
// TODO More needs to be added here
let mut expected_post_listing_with_user = expected_post_listing_no_user.to_owned();
expected_post_listing_with_user.my_vote = Some(1);
let like_removed = PostLike::remove(&conn, inserted_user.id, inserted_post.id).unwrap();
let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
Community::delete(&conn, inserted_community.id).unwrap();
User_::delete(&conn, inserted_user.id).unwrap();
// The with user
assert_eq!(
expected_post_listing_with_user,
read_post_listings_with_user[0]
);
assert_eq!(expected_post_listing_with_user, read_post_listing_with_user);
assert_eq!(1, read_post_listings_with_user.len());
// Without the user
assert_eq!(expected_post_listing_no_user, read_post_listings_no_user[0]);
assert_eq!(expected_post_listing_no_user, read_post_listing_no_user);
assert_eq!(1, read_post_listings_no_user.len());
// assert_eq!(expected_post, inserted_post);
// assert_eq!(expected_post, updated_post);
assert_eq!(expected_post_like, inserted_post_like);
assert_eq!(1, like_removed);
assert_eq!(1, num_deleted);
}
}

9
lemmy_structs/src/post.rs
View file

@ -1,8 +1,11 @@
use lemmy_db::{
comment_view::CommentView,
post_report::PostReportView,
views::{
community_moderator_view::CommunityModeratorView,
community_view::CommunityView,
post_view::PostView,
views::{community_moderator_view::CommunityModeratorView, community_view::CommunityView},
},
};
use serde::{Deserialize, Serialize};
@ -18,7 +21,7 @@ pub struct CreatePost {
#[derive(Serialize, Clone)]
pub struct PostResponse {
pub post: PostView,
pub post_view: PostView,
}
#[derive(Deserialize)]
@ -29,7 +32,7 @@ pub struct GetPost {
#[derive(Serialize)]
pub struct GetPostResponse {
pub post: PostView,
pub post_view: PostView,
pub comments: Vec<CommentView>,
pub community: CommunityView,
pub moderators: Vec<CommunityModeratorView>,

8
lemmy_structs/src/site.rs
View file

@ -3,9 +3,13 @@ use lemmy_db::{
category::*,
comment_view::*,
moderator_views::*,
post_view::*,
user::*,
views::{community_view::CommunityView, site_view::SiteView, user_view::UserViewSafe},
views::{
community_view::CommunityView,
post_view::PostView,
site_view::SiteView,
user_view::UserViewSafe,
},
};
use serde::{Deserialize, Serialize};

2
lemmy_structs/src/user.rs
View file

@ -1,11 +1,11 @@
use lemmy_db::{
comment_view::{CommentView, ReplyView},
post_view::PostView,
private_message_view::PrivateMessageView,
user_mention_view::UserMentionView,
views::{
community_follower_view::CommunityFollowerView,
community_moderator_view::CommunityModeratorView,
post_view::PostView,
user_view::{UserViewDangerous, UserViewSafe},
},
};

22
lemmy_websocket/src/chat_server.rs
View file

@ -368,22 +368,28 @@ impl ChatServer {
pub fn send_post(
&self,
user_operation: &UserOperation,
post: &PostResponse,
post_res: &PostResponse,
websocket_id: Option<ConnectionId>,
) -> Result<(), LemmyError> {
let community_id = post.post.community_id;
let community_id = post_res.post_view.community.id;
// Don't send my data with it
let mut post_sent = post.clone();
post_sent.post.my_vote = None;
post_sent.post.user_id = None;
// TODO no idea what to do here
// let mut post_sent = post_res.clone();
// post_sent.post.my_vote = None;
// post_sent.post.user_id = None;
// Send it to /c/all and that community
self.send_community_room_message(user_operation, &post_sent, 0, websocket_id)?;
self.send_community_room_message(user_operation, &post_sent, community_id, websocket_id)?;
self.send_community_room_message(user_operation, &post_res, 0, websocket_id)?;
self.send_community_room_message(user_operation, &post_res, community_id, websocket_id)?;
// Send it to the post room
self.send_post_room_message(user_operation, &post_sent, post.post.id, websocket_id)?;
self.send_post_room_message(
user_operation,
&post_res,
post_res.post_view.post.id,
websocket_id,
)?;
Ok(())
}

39
src/routes/feeds.rs
View file

@ -6,10 +6,12 @@ use lemmy_api::claims::Claims;
use lemmy_db::{
comment_view::{ReplyQueryBuilder, ReplyView},
community::Community,
post_view::{PostQueryBuilder, PostView},
user::User_,
user_mention_view::{UserMentionQueryBuilder, UserMentionView},
views::site_view::SiteView,
views::{
post_view::{PostQueryBuilder, PostView},
site_view::SiteView,
},
ListingType,
SortType,
};
@ -82,7 +84,7 @@ async fn get_feed_data(
let listing_type_ = listing_type.clone();
let posts = blocking(context.pool(), move |conn| {
PostQueryBuilder::create(&conn)
PostQueryBuilder::create(&conn, None)
.listing_type(&listing_type_)
.sort(&sort_type)
.list()
@ -164,7 +166,7 @@ fn get_feed_user(
let user = User_::find_by_username(&conn, &user_name)?;
let user_url = user.get_profile_url(&Settings::get().hostname);
let posts = PostQueryBuilder::create(&conn)
let posts = PostQueryBuilder::create(&conn, None)
.listing_type(&ListingType::All)
.sort(sort_type)
.for_creator_id(user.id)
@ -190,7 +192,7 @@ fn get_feed_community(
let site_view = SiteView::read(&conn)?;
let community = Community::read_from_name(&conn, &community_name)?;
let posts = PostQueryBuilder::create(&conn)
let posts = PostQueryBuilder::create(&conn, None)
.listing_type(&ListingType::All)
.sort(sort_type)
.for_community_id(community.id)
@ -220,10 +222,9 @@ fn get_feed_front(
let site_view = SiteView::read(&conn)?;
let user_id = Claims::decode(&jwt)?.claims.id;
let posts = PostQueryBuilder::create(&conn)
let posts = PostQueryBuilder::create(&conn, Some(user_id))
.listing_type(&ListingType::Subscribed)
.sort(sort_type)
.my_user_id(user_id)
.list()?;
let items = create_post_items(posts)?;
@ -349,17 +350,17 @@ fn create_post_items(posts: Vec<PostView>) -> Result<Vec<Item>, LemmyError> {
let mut i = ItemBuilder::default();
let mut dc_extension = DublinCoreExtensionBuilder::default();
i.title(p.name);
i.title(p.post.name);
dc_extension.creators(vec![p.creator_actor_id.to_owned()]);
dc_extension.creators(vec![p.creator.actor_id.to_owned()]);
let dt = DateTime::<Utc>::from_utc(p.published, Utc);
let dt = DateTime::<Utc>::from_utc(p.post.published, Utc);
i.pub_date(dt.to_rfc2822());
let post_url = format!(
"{}/post/{}",
Settings::get().get_protocol_and_hostname(),
p.id
p.post.id
);
i.comments(post_url.to_owned());
let guid = GuidBuilder::default()
@ -372,27 +373,27 @@ fn create_post_items(posts: Vec<PostView>) -> Result<Vec<Item>, LemmyError> {
let community_url = format!(
"{}/c/{}",
Settings::get().get_protocol_and_hostname(),
p.community_name
p.community.name
);
// TODO: for category we should just put the name of the category, but then we would have
// to read each community from the db
if let Some(url) = p.url {
if let Some(url) = p.post.url {
i.link(url);
}
// TODO add images
let mut description = format!("submitted by <a href=\"{}\">{}</a> to <a href=\"{}\">{}</a><br>{} points | <a href=\"{}\">{} comments</a>",
p.creator_actor_id,
p.creator_name,
p.creator.actor_id,
p.creator.name,
community_url,
p.community_name,
p.score,
p.community.name,
p.counts.score,
post_url,
p.number_of_comments);
p.counts.comments);
if let Some(body) = p.body {
if let Some(body) = p.post.body {
let html = markdown_to_html(&body);
description.push_str(&html);
}