Merge pull request #141 from MathisBurger/feature/conditional-join-requests

Join Request Policy

Author: MathisBurger

tasky/migrations/2024-11-13-154306_join_request_policy/down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE groups DROP join_policy;
+DROP TYPE join_request_policy;

tasky/migrations/2024-11-13-154306_join_request_policy/up.sql

@@ -0,0 +1,2 @@
+CREATE TYPE join_request_policy AS ENUM ('open', 'request', 'closed');
+ALTER TABLE groups ADD join_policy join_request_policy NOT NULL DEFAULT 'request';

tasky/src/models/group.rs

@@ -6,6 +6,17 @@ use diesel::prelude::*;
 use diesel::{associations::HasTable, dsl::not};
 use serde::{Deserialize, Serialize};
 
+#[derive(diesel_derive_enum::DbEnum, Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[ExistingTypePath = "crate::schema::sql_types::JoinRequestPolicy"]
+pub enum JoinRequestPolicy {
+    #[serde(rename = "open")]
+    Open,
+    #[serde(rename = "request")]
+    Request,
+    #[serde(rename = "closed")]
+    Closed,
+}
+
 /// Group entity in the database
 #[derive(Queryable, Selectable, AsChangeset, Serialize, Deserialize, Clone)]
 #[diesel(table_name = crate::schema::groups)]
@@ -15,6 +26,7 @@ pub struct Group {
     pub title: String,
     pub members: Vec<Option<i32>>,
     pub tutor: i32,
+    pub join_policy: JoinRequestPolicy,
 }
 
 /// Used to create a group in database
@@ -24,6 +36,7 @@ pub struct CreateGroup {
     pub title: String,
     pub tutor: i32,
     pub members: Vec<i32>,
+    pub join_policy: JoinRequestPolicy,
 }
 
 pub struct GroupRepository;

tasky/src/models/group_join_request.rs

@@ -1,3 +1,4 @@
+use super::notification::{CreateNotification, NotificationRepository};
 use super::{Paginate, PaginatedModel, DB};
 use crate::models::group::Group;
 use crate::schema::group_join_requests;
@@ -6,7 +7,7 @@ use diesel::associations::HasTable;
 use diesel::prelude::*;
 
 /// The group join request in the database
-#[derive(Queryable, Selectable, Identifiable, Associations)]
+#[derive(Queryable, Selectable, Identifiable, Associations, Clone)]
 #[diesel(belongs_to(Group))]
 #[diesel(table_name = group_join_requests)]
 pub struct GroupJoinRequest {
@@ -53,6 +54,14 @@ impl GroupJoinRequestRepository {
             .expect("Cannot get count") as i32
     }
 
+    /// Gets all join requests for a user
+    pub fn get_group_requests_no_pagination(group_id: i32, conn: &mut DB) -> Vec<GroupJoinRequest> {
+        dsl::group_join_requests
+            .filter(dsl::group_id.eq(group_id))
+            .get_results::<GroupJoinRequest>(conn)
+            .expect("Cannot load all join requests for group")
+    }
+
     /// Checks if a request exists
     pub fn request_exists(group_id: i32, user_id: i32, conn: &mut DB) -> bool {
         dsl::group_join_requests
@@ -86,8 +95,23 @@ impl GroupJoinRequestRepository {
 
     /// Deletes a request
     pub fn delete_request(req: GroupJoinRequest, conn: &mut DB) {
+        NotificationRepository::create_notification(
+            &CreateNotification {
+                title: "Join request rejected".to_string(),
+                content: "One of your join requests has been rejected".to_string(),
+                targeted_users: vec![Some(req.requestor)],
+            },
+            conn,
+        );
         diesel::delete(dsl::group_join_requests.filter(dsl::id.eq(req.id)))
             .execute(conn)
             .expect("Cannot delete request");
     }
+
+    /// Deletes all group join requests for a specific group
+    pub fn delete_all_requests_for_group(group_id: i32, conn: &mut DB) {
+        diesel::delete(dsl::group_join_requests.filter(dsl::group_id.eq(group_id)))
+            .execute(conn)
+            .expect("Cannot delete request");
+    }
 }

tasky/src/response/group.rs

@@ -1,5 +1,6 @@
 use crate::api::usernator_api_client::UsernatorApiClient;
 use crate::error::ApiError;
+use crate::models::group::JoinRequestPolicy;
 use crate::models::group_join_request::GroupJoinRequestRepository;
 use crate::models::PaginatedModel;
 use crate::{api::UserRequest, api::UsersRequest, models::group::Group, response::shared::User};
@@ -16,6 +17,7 @@ pub struct GroupResponse {
     pub members: Vec<User>,
     pub tutor: User,
     pub request_count: i32,
+    pub join_policy: JoinRequestPolicy,
 }
 
 /// The minified group response
@@ -25,6 +27,7 @@ pub struct MinifiedGroupResponse {
     pub title: String,
     pub member_count: i32,
     pub tutor: User,
+    pub join_policy: JoinRequestPolicy,
 }
 
 /// The groups response
@@ -52,6 +55,7 @@ impl Enrich<Group> for MinifiedGroupResponse {
             title: from.title.clone(),
             member_count: from.members.len() as i32,
             tutor: tut.into_inner().into(),
+            join_policy: from.join_policy.clone(),
         })
     }
 }
@@ -109,6 +113,7 @@ impl Enrich<Group> for GroupResponse {
                 .map(|x| x.into())
                 .collect(),
             tutor: tut.into_inner().into(),
+            join_policy: from.join_policy.clone(),
             request_count,
         })
     }

tasky/src/routes/group.rs

@@ -4,7 +4,8 @@ use crate::api::SearchStudentsRequest;
 use crate::api::UserRequest;
 use crate::auth_middleware::UserData;
 use crate::error::ApiError;
-use crate::models::group::{CreateGroup, GroupRepository};
+use crate::models::group::{CreateGroup, GroupRepository, JoinRequestPolicy};
+use crate::models::group_join_request::GroupJoinRequestRepository;
 use crate::response::group::{GroupResponse, GroupsResponse};
 use crate::response::shared::User;
 use crate::response::Enrich;
@@ -19,6 +20,7 @@ use tonic::transport::Channel;
 #[derive(Deserialize, Serialize)]
 pub struct CreateGroupRequest {
     pub title: String,
+    pub join_policy: JoinRequestPolicy,
 }
 
 /// Endpoint to create a new group
@@ -39,6 +41,7 @@ pub async fn create_group(
         title: (req.title).clone(),
         tutor: user.user_id,
         members: vec![],
+        join_policy: req.join_policy.clone(),
     };
     if !new_group.is_granted(SecurityAction::Create, &user) {
         return Err(ApiError::Forbidden {
@@ -112,6 +115,60 @@ pub async fn get_group(
     })
 }
 
+#[derive(Deserialize)]
+struct UpdateGroupRequest {
+    pub title: String,
+    pub join_policy: JoinRequestPolicy,
+}
+
+#[post("/groups/{id}")]
+pub async fn update_group(
+    data: web::Data<AppState>,
+    user: web::ReqData<UserData>,
+    path: web::Path<(i32,)>,
+    req: web::Json<UpdateGroupRequest>,
+) -> Result<HttpResponse, ApiError> {
+    let conn = &mut data.db.db.get().unwrap();
+    let mut group =
+        GroupRepository::get_by_id(path.into_inner().0, conn).ok_or(ApiError::BadRequest {
+            message: "No access to group".to_string(),
+        })?;
+
+    if !group.is_granted(SecurityAction::Update, &user) {
+        return Err(ApiError::Forbidden {
+            message: "You are not allowed to update group".to_string(),
+        });
+    }
+
+    let found_group = GroupRepository::get_by_title(&req.title, conn);
+    if found_group.is_some() && group.title.clone() != found_group.unwrap().title {
+        return Err(ApiError::BadRequest {
+            message: "Group with this name already exists".to_string(),
+        });
+    }
+
+    group.title = req.title.clone();
+    group.join_policy = req.join_policy.clone();
+
+    if group.join_policy == JoinRequestPolicy::Open {
+        let requests = GroupJoinRequestRepository::get_group_requests_no_pagination(group.id, conn);
+        group
+            .members
+            .extend(requests.iter().map(|r| Some(r.requestor)));
+        GroupJoinRequestRepository::delete_all_requests_for_group(group.id, conn);
+    } else if group.join_policy == JoinRequestPolicy::Closed {
+        let requests = GroupJoinRequestRepository::get_group_requests_no_pagination(group.id, conn);
+        for join_request in requests.iter() {
+            GroupJoinRequestRepository::delete_request(join_request.clone(), conn);
+        }
+    }
+
+    GroupRepository::update_group(group.clone(), conn);
+
+    let enriched = GroupResponse::enrich(&group, &mut data.user_api.clone(), conn).await?;
+    Ok(HttpResponse::Ok().json(enriched))
+}
+
 #[derive(Deserialize)]
 struct EnlistableQuery {
     pub search: String,

tasky/src/routes/group_join_request.rs

@@ -1,8 +1,9 @@
 use super::PaginationParams;
 use crate::auth_middleware::UserData;
 use crate::error::ApiError;
-use crate::models::group::GroupRepository;
+use crate::models::group::{GroupRepository, JoinRequestPolicy};
 use crate::models::group_join_request::{CreateGroupJoinRequest, GroupJoinRequestRepository};
+use crate::models::notification::{CreateNotification, NotificationRepository};
 use crate::response::group::GroupResponse;
 use crate::response::group_join_request::{GroupJoinRequestResponse, GroupJoinRequestsResponse};
 use crate::response::Enrich;
@@ -19,10 +20,17 @@ pub async fn create_join_request(
 ) -> Result<HttpResponse, ApiError> {
     let conn = &mut data.db.db.get().unwrap();
 
-    let group =
+    let mut group =
         GroupRepository::get_by_id(path.into_inner().0, conn).ok_or(ApiError::BadRequest {
             message: "Group does not exist".to_string(),
         })?;
+
+    if group.join_policy == JoinRequestPolicy::Closed {
+        return Err(ApiError::Forbidden {
+            message: "Join requests are not allowed for this group".to_string(),
+        });
+    }
+
     if !StaticSecurity::is_granted(StaticSecurityAction::IsStudent, &user)
         || group.members.contains(&Some(user.user_id))
     {
@@ -31,6 +39,12 @@ pub async fn create_join_request(
         });
     }
 
+    if group.join_policy == JoinRequestPolicy::Open {
+        group.members.push(Some(user.user_id));
+        GroupRepository::update_group(group, conn);
+        return Ok(HttpResponse::Ok().finish());
+    }
+
     if GroupJoinRequestRepository::request_exists(group.id, user.user_id, conn) {
         return Err(ApiError::Forbidden {
             message: "User already sent a request".to_string(),
@@ -45,6 +59,15 @@ pub async fn create_join_request(
         conn,
     );
 
+    NotificationRepository::create_notification(
+        &CreateNotification {
+            title: "New join request".to_string(),
+            content: format!("New join request in group {}", group.title.clone()),
+            targeted_users: vec![Some(group.tutor)],
+        },
+        conn,
+    );
+
     let resp = GroupJoinRequestResponse::enrich(&request, &mut data.user_api.clone(), conn).await?;
     Ok(HttpResponse::Ok().json(resp))
 }

tasky/src/routes/mod.rs

@@ -20,6 +20,7 @@ pub fn init_services(cfg: &mut web::ServiceConfig) {
         .service(group::get_group)
         .service(group::get_all_groups)
         .service(group::get_all_my_groups)
+        .service(group::update_group)
         .service(group::get_enlistable_users)
         .service(group::enlist_user)
         .service(group::remove_user)

tasky/src/schema.rs

@@ -4,6 +4,10 @@ pub mod sql_types {
     #[derive(diesel::query_builder::QueryId, serde::Deserialize, diesel::sql_types::SqlType)]
     #[diesel(postgres_type(name = "assignment_language"))]
     pub struct AssignmentLanguage;
+
+    #[derive(diesel::query_builder::QueryId, serde::Deserialize, diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "join_request_policy"))]
+    pub struct JoinRequestPolicy;
 }
 
 diesel::table! {
@@ -62,11 +66,15 @@ diesel::table! {
 }
 
 diesel::table! {
+    use diesel::sql_types::*;
+    use super::sql_types::JoinRequestPolicy;
+
     groups (id) {
         id -> Int4,
         title -> Varchar,
         members -> Array<Nullable<Int4>>,
         tutor -> Int4,
+        join_policy -> JoinRequestPolicy,
     }
 }
 

tasky/tests/routes/a_group.rs

@@ -1,7 +1,7 @@
 use super::*;
 use actix_http::StatusCode;
 use serial_test::serial;
-use tasky::routes::group::CreateGroupRequest;
+use tasky::{models::group::JoinRequestPolicy, routes::group::CreateGroupRequest};
 
 #[actix_web::test]
 #[serial]
@@ -11,6 +11,7 @@ async fn test_a_create_group_as_student() {
         .uri("/create_group")
         .set_json(CreateGroupRequest {
             title: "name123".to_string(),
+            join_policy: JoinRequestPolicy::Request,
         });
     req = student(req);
     let resp = test::call_service(&app, req.to_request()).await;
@@ -25,6 +26,7 @@ async fn test_b_create_group_as_tutor() {
         .uri("/create_group")
         .set_json(CreateGroupRequest {
             title: "name".to_string(),
+            join_policy: JoinRequestPolicy::Request,
         });
     req = tutor(req);
     let resp = test::call_service(&app, req.to_request()).await;
@@ -39,6 +41,7 @@ async fn test_c_create_group_as_tutor_duplicate_name() {
         .uri("/create_group")
         .set_json(CreateGroupRequest {
             title: "name".to_string(),
+            join_policy: JoinRequestPolicy::Request,
         });
     req = tutor(req);
     let resp = test::call_service(&app, req.to_request()).await;
@@ -53,6 +56,7 @@ async fn test_d_create_group_as_admin() {
         .uri("/create_group")
         .set_json(CreateGroupRequest {
             title: "name2".to_string(),
+            join_policy: JoinRequestPolicy::Request,
         });
     req = admin(req);
     let resp = test::call_service(&app, req.to_request()).await;