eta357/LibreTunes-Nix-Test
1
0
Fork 0
Code Pull Requests Actions Activity

Organization and Friend Requests Page

Browse Source
This commit is contained in:
Aidan Westphal 2024-12-07 01:34:12 +00:00
parent 2391016709
commit 49cfbff578
6 changed files with 302 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

227
src/api/friends.rs Normal file
View File

@ -0,0 +1,227 @@
use leptos::*;
use cfg_if::cfg_if;
use crate::frienddata::FriendData;
cfg_if! {
if #[cfg(feature = "ssr")] {
use crate::auth::get_user;
use server_fn::error::NoCustomError;
use crate::database::get_db_conn;
use diesel::prelude::*;
use diesel::dsl::exists;
use crate::models::*;
use crate::schema::*;
use chrono::prelude::*;
}
}
/// Get a user's list of friends from the database
#[server(endpoint = "/profile/friends")]
pub async fn friends(for_user_id: i32)
-> Result<Vec<FriendData>, ServerFnError>
{
let mut db_con = get_db_conn();
let friends = friendships::table
.filter(friendships::friend_1_id.eq(for_user_id))
.filter(friendships::friend_1_id.ne(friendships::friend_2_id))
.inner_join(users::table.on(users::id.eq(friendships::friend_2_id)))
.select((users::all_columns, friendships::created_at))
.order(friendships::created_at.desc())
.order(users::username.asc())
.union(
friendships::table
.filter(friendships::friend_2_id.eq(for_user_id))
.filter(friendships::friend_1_id.ne(friendships::friend_2_id))
.inner_join(users::table.on(users::id.eq(friendships::friend_1_id)))
.select((users::all_columns, friendships::created_at))
.order(friendships::created_at.desc())
.order(users::username.asc())
)
.load(&mut db_con)?;
let friend_list: Vec<FriendData> = friends.into_iter().map(|(user, created_at): (User, NaiveDateTime)| {
FriendData {
username: user.username,
created_at: created_at.into(),
user_id: user.id.unwrap()
}
}).collect();
Ok(friend_list)
}
/// Get a user's list of friend requests (outgoing) from the database
#[server(endpoint = "/profile/friend-requests-outgoing")]
pub async fn friend_requests_outgoing(for_user_id: i32)
-> Result<Vec<FriendData>, ServerFnError>
{
let mut db_con = get_db_conn();
let friends = friend_requests::table
.filter(friend_requests::from_id.eq(for_user_id))
.filter(friend_requests::from_id.ne(friend_requests::to_id))
.inner_join(users::table.on(users::id.eq(friend_requests::to_id)))
.select((users::all_columns, friend_requests::created_at))
.order(friend_requests::created_at.desc())
.order(users::username.asc())
.load(&mut db_con)?;
let friend_list: Vec<FriendData> = friends.into_iter().map(|(user, created_at): (User, NaiveDateTime)| {
FriendData {
username: user.username,
created_at: created_at.into(),
user_id: user.id.unwrap()
}
}).collect();
Ok(friend_list)
}
/// Get a user's list of friend requests (incoming) from the database
#[server(endpoint = "/profile/friend-requests-incoming")]
pub async fn friend_requests_incoming(for_user_id: i32)
-> Result<Vec<FriendData>, ServerFnError>
{
let mut db_con = get_db_conn();
let friends = friend_requests::table
.filter(friend_requests::to_id.eq(for_user_id))
.filter(friend_requests::from_id.ne(friend_requests::to_id))
.inner_join(users::table.on(users::id.eq(friend_requests::from_id)))
.select((users::all_columns, friend_requests::created_at))
.order(friend_requests::created_at.desc())
.order(users::username.asc())
.load(&mut db_con)?;
let friend_list: Vec<FriendData> = friends.into_iter().map(|(user, created_at): (User, NaiveDateTime)| {
FriendData {
username: user.username,
created_at: created_at.into(),
user_id: user.id.unwrap()
}
}).collect();
Ok(friend_list)
}
/// Send a friend request
#[server(endpoint = "/profile/send-friend-request")]
pub async fn send_friend_request(to_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Get current time for request
let timestamp: NaiveDateTime = Utc::now().naive_utc();
// Insert into database (if already exists, won't succeed due to primary key)
diesel::insert_into(crate::schema::friend_requests::table)
.values((friend_requests::created_at.eq(timestamp),friend_requests::from_id.eq(user.id.unwrap()),friend_requests::to_id.eq(to_user_id)))
.execute(&mut db_con)
.map_err(|e| {
let msg = format!("Error saving friend request to database: {}", e);
ServerFnError::<NoCustomError>::ServerError(msg)
})?;
Ok(())
}
/// Remove an outgoing friend request
#[server(endpoint = "/profile/friend-requests-incoming")]
pub async fn delete_friend_request(to_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Delete the friend request
diesel::delete(friend_requests::table
.filter(friend_requests::from_id.eq(user.id.unwrap()))
.filter(friend_requests::to_id.eq(to_user_id))
).execute(&mut db_con)?;
Ok(())
}
/// Remove an existing friendship
#[server(endpoint = "/profile/delete-friend")]
pub async fn delete_friend(for_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Delete the friend request
diesel::delete(friendships::table
.filter(friendships::friend_1_id.eq(user.id.unwrap()))
.filter(friendships::friend_2_id.eq(for_user_id))
).execute(&mut db_con)?;
diesel::delete(friendships::table
.filter(friendships::friend_2_id.eq(user.id.unwrap()))
.filter(friendships::friend_1_id.eq(for_user_id))
).execute(&mut db_con)?;
Ok(())
}
/// Accept a friend request
#[server(endpoint = "/profile/accept-friend-request")]
pub async fn accept_friend_request(to_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Get current time for request
let timestamp: NaiveDateTime = Utc::now().naive_utc();
// Make sure the person has received a friend request from the other person
let req = diesel::select(exists(
friend_requests::table
.filter(friend_requests::from_id.eq(user.id.unwrap()))
.filter(friend_requests::to_id.eq(to_user_id))
)).get_result::<bool>(&mut db_con)?;
if req == false {
Err(ServerFnError::<NoCustomError>::ServerError(format!("Error, the friend request does not exist!")))?;
}
// Delete the friend requests
diesel::delete(friend_requests::table
.filter(friend_requests::from_id.eq(user.id.unwrap()))
.filter(friend_requests::to_id.eq(to_user_id))
).execute(&mut db_con)?;
diesel::delete(friend_requests::table
.filter(friend_requests::to_id.eq(user.id.unwrap()))
.filter(friend_requests::from_id.eq(to_user_id))
).execute(&mut db_con)?;
// Add the new friend request either direction
diesel::insert_into(crate::schema::friendships::table)
.values((friendships::created_at.eq(timestamp),friendships::friend_1_id.eq(user.id.unwrap()),friendships::friend_2_id.eq(to_user_id)))
.execute(&mut db_con)
.map_err(|e| {
let msg = format!("Error saving friendship to database: {}", e);
ServerFnError::<NoCustomError>::ServerError(msg)
})?;
Ok(())
}

1
src/api/mod.rs
View File

@ -2,3 +2,4 @@ pub mod history;
pub mod profile;
pub mod songs;
pub mod album;
pub mod friends;

212
src/api/profile.rs
View File

@ -5,7 +5,6 @@ use cfg_if::cfg_if;
use crate::songdata::SongData;
use crate::artistdata::ArtistData;
use crate::frienddata::FriendData;
use chrono::NaiveDateTime;
@ -17,11 +16,9 @@ cfg_if! {
use crate::database::get_db_conn;
use diesel::prelude::*;
use diesel::dsl::count;
use diesel::dsl::exists;
use crate::models::*;
use crate::schema::*;
use chrono::prelude::*;
use std::collections::HashMap;
}
}
@ -301,212 +298,3 @@ pub async fn top_artists(for_user_id: i32, start_date: NaiveDateTime, end_date:
Ok(artist_data)
}
/// Get a user's list of friends from the database
#[server(endpoint = "/profile/friends")]
pub async fn friends(for_user_id: i32)
-> Result<Vec<FriendData>, ServerFnError>
{
let mut db_con = get_db_conn();
let friends = friendships::table
.filter(friendships::friend_1_id.eq(for_user_id))
.filter(friendships::friend_1_id.ne(friendships::friend_2_id))
.inner_join(users::table.on(users::id.eq(friendships::friend_2_id)))
.select((users::all_columns, friendships::created_at))
.order(friendships::created_at.desc())
.order(users::username.asc())
.union(
friendships::table
.filter(friendships::friend_2_id.eq(for_user_id))
.filter(friendships::friend_1_id.ne(friendships::friend_2_id))
.inner_join(users::table.on(users::id.eq(friendships::friend_1_id)))
.select((users::all_columns, friendships::created_at))
.order(friendships::created_at.desc())
.order(users::username.asc())
)
.load(&mut db_con)?;
let friend_list: Vec<FriendData> = friends.into_iter().map(|(user, created_at): (User, NaiveDateTime)| {
FriendData {
username: user.username,
created_at: created_at.into(),
user_id: user.id.unwrap()
}
}).collect();
Ok(friend_list)
}
/// Get a user's list of friend requests (outgoing) from the database
#[server(endpoint = "/profile/friend-requests-outgoing")]
pub async fn friend_requests_outgoing(for_user_id: i32)
-> Result<Vec<FriendData>, ServerFnError>
{
let mut db_con = get_db_conn();
let friends = friend_requests::table
.filter(friend_requests::from_id.eq(for_user_id))
.filter(friend_requests::from_id.ne(friend_requests::to_id))
.inner_join(users::table.on(users::id.eq(friend_requests::to_id)))
.select((users::all_columns, friend_requests::created_at))
.order(friend_requests::created_at.desc())
.order(users::username.asc())
.load(&mut db_con)?;
let friend_list: Vec<FriendData> = friends.into_iter().map(|(user, created_at): (User, NaiveDateTime)| {
FriendData {
username: user.username,
created_at: created_at.into(),
user_id: user.id.unwrap()
}
}).collect();
Ok(friend_list)
}
/// Get a user's list of friend requests (incoming) from the database
#[server(endpoint = "/profile/friend-requests-incoming")]
pub async fn friend_requests_incoming(for_user_id: i32)
-> Result<Vec<FriendData>, ServerFnError>
{
let mut db_con = get_db_conn();
let friends = friend_requests::table
.filter(friend_requests::to_id.eq(for_user_id))
.filter(friend_requests::from_id.ne(friend_requests::to_id))
.inner_join(users::table.on(users::id.eq(friend_requests::from_id)))
.select((users::all_columns, friend_requests::created_at))
.order(friend_requests::created_at.desc())
.order(users::username.asc())
.load(&mut db_con)?;
let friend_list: Vec<FriendData> = friends.into_iter().map(|(user, created_at): (User, NaiveDateTime)| {
FriendData {
username: user.username,
created_at: created_at.into(),
user_id: user.id.unwrap()
}
}).collect();
Ok(friend_list)
}
/// Send a friend request
#[server(endpoint = "/profile/send-friend-request")]
pub async fn send_friend_request(to_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Get current time for request
let timestamp: NaiveDateTime = Utc::now().naive_utc();
// Insert into database (if already exists, won't succeed due to primary key)
diesel::insert_into(crate::schema::friend_requests::table)
.values((friend_requests::created_at.eq(timestamp),friend_requests::from_id.eq(user.id.unwrap()),friend_requests::to_id.eq(to_user_id)))
.execute(&mut db_con)
.map_err(|e| {
let msg = format!("Error saving friend request to database: {}", e);
ServerFnError::<NoCustomError>::ServerError(msg)
})?;
Ok(())
}
/// Remove an outgoing friend request
#[server(endpoint = "/profile/friend-requests-incoming")]
pub async fn delete_friend_request(to_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Delete the friend request
diesel::delete(friend_requests::table
.filter(friend_requests::from_id.eq(user.id.unwrap()))
.filter(friend_requests::to_id.eq(to_user_id))
).execute(&mut db_con)?;
Ok(())
}
/// Remove an existing friendship
#[server(endpoint = "/profile/delete-friend")]
pub async fn delete_friend(for_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Delete the friend request
diesel::delete(friendships::table
.filter(friendships::friend_1_id.eq(user.id.unwrap()))
.filter(friendships::friend_2_id.eq(for_user_id))
).execute(&mut db_con)?;
diesel::delete(friendships::table
.filter(friendships::friend_2_id.eq(user.id.unwrap()))
.filter(friendships::friend_1_id.eq(for_user_id))
).execute(&mut db_con)?;
Ok(())
}
/// Accept a friend request
#[server(endpoint = "/profile/accept-friend-request")]
pub async fn accept_friend_request(to_user_id: i32)
-> Result<(), ServerFnError>
{
let mut db_con = get_db_conn();
// Get user id from session
let user = get_user().await
.map_err(|e| ServerFnError::<NoCustomError>::ServerError(format!("Error getting user: {}", e)))?;
// Get current time for request
let timestamp: NaiveDateTime = Utc::now().naive_utc();
// Make sure the person has received a friend request from the other person
let req = diesel::select(exists(
friend_requests::table
.filter(friend_requests::from_id.eq(user.id.unwrap()))
.filter(friend_requests::to_id.eq(to_user_id))
)).get_result::<bool>(&mut db_con)?;
if req == false {
Err(ServerFnError::<NoCustomError>::ServerError(format!("Error, the friend request does not exist!")))?;
}
// Delete the friend requests
diesel::delete(friend_requests::table
.filter(friend_requests::from_id.eq(user.id.unwrap()))
.filter(friend_requests::to_id.eq(to_user_id))
).execute(&mut db_con)?;
diesel::delete(friend_requests::table
.filter(friend_requests::to_id.eq(user.id.unwrap()))
.filter(friend_requests::from_id.eq(to_user_id))
).execute(&mut db_con)?;
// Add the new friend request either direction
diesel::insert_into(crate::schema::friendships::table)
.values((friendships::created_at.eq(timestamp),friendships::friend_1_id.eq(user.id.unwrap()),friendships::friend_2_id.eq(to_user_id)))
.execute(&mut db_con)
.map_err(|e| {
let msg = format!("Error saving friendship to database: {}", e);
ServerFnError::<NoCustomError>::ServerError(msg)
})?;
Ok(())
}

1
src/app.rs
View File

@ -47,6 +47,7 @@ pub fn App() -> impl IntoView {
<Route path="user/:id" view=Profile />
<Route path="user" view=Profile />
<Route path="user/:id/friends" view=Friends />
<Route path="user/:id/friendrequests" view=FriendRequests />
<Route path="album/:id" view=AlbumPage />
</Route>
<Route path="/login" view=Login />

4
src/frienddata.rs
View File

@ -2,7 +2,7 @@ use serde::{Serialize, Deserialize};
use chrono::NaiveDate;
/// Holds information about an album
/// Holds information about a user (friend)
///
/// Intended to be used in the front-end
@ -10,7 +10,7 @@ use chrono::NaiveDate;
pub struct FriendData {
/// Username
pub username: String,
/// Date which the friend was added
/// Date which the user/friend was added
pub created_at: NaiveDate,
/// User's id to be used to locate their profile image
pub user_id: i32

72
src/pages/friends.rs
View File

@ -1,7 +1,7 @@
use leptos::leptos_dom::*;
use leptos::*;
use leptos_router::*;
use crate::api::profile::*;
use crate::api::friends::*;
use crate::components::friend_list::*;
use crate::components::loading::Loading;
@ -62,3 +62,73 @@ pub fn Friends() -> impl IntoView {
}
}
#[component]
pub fn FriendRequests() -> impl IntoView {
let params = use_params::<FriendParams>();
let id = move || {params.with(|params| {
params.as_ref()
.map(|params| params.id)
.map_err(|e| e.clone())
})
};
let friend_list_incoming = create_resource(
id,
|value| async move {
match value {
Ok(v) => {friend_requests_incoming(v).await},
Err(e) => {Err(ServerFnError::Request(format!("Error getting song data: {}", e).into()))},
}
},
);
let friend_list_outgoing = create_resource(
id,
|value| async move {
send_friend_request(1).await;
match value {
Ok(v) => {friend_requests_outgoing(v).await},
Err(e) => {Err(ServerFnError::Request(format!("Error getting song data: {}", e).into()))},
}
},
);
view! {
<div class="friend-page-container">
<h1 class="friend-header"> "Friend Requests:" </h1>
<Transition
fallback=move || view! {
<Loading />
}
>
<ErrorBoundary
fallback=|errors| view! {
{move || errors.get()
.into_iter()
.map(|(_, e)| view! { <p>{e.to_string()}</p>})
.collect_view()
}
}
>
<h2>Sent: </h2>
{
friend_list_outgoing.get().map(|friend_list| {
friend_list.map(|friend_list| {
view! {<FriendList friends={friend_list} />}
})
})
}
<h2>Received: </h2>
{
friend_list_incoming.get().map(|friend_list| {
friend_list.map(|friend_list| {
view! {<FriendList friends={friend_list} />}
})
})
}
</ErrorBoundary>
</Transition>
</div>
}
}