feat: add invitations for pms

Author: QuantGeekDev

migrations/2024-10-24-004753_update_user_roles/down.sql

@@ -0,0 +1,5 @@
+ALTER TABLE users DROP CONSTRAINT valid_role;
+ALTER TABLE users ADD CONSTRAINT valid_role
+    CHECK (role IN ('user', 'admin'));
+
+UPDATE users SET role = 'user' WHERE role = 'developer';

migrations/2024-10-24-004753_update_user_roles/up.sql

@@ -0,0 +1,5 @@
+ALTER TABLE users DROP CONSTRAINT valid_role;
+ALTER TABLE users ADD CONSTRAINT valid_role
+    CHECK (role IN ('admin', 'project_manager', 'developer'));
+
+UPDATE users SET role = 'developer' WHERE role = 'user';

migrations/2024-10-24-004935_add_dev_pm_relationships/down.sql

@@ -0,0 +1 @@
+DROP TABLE dev_pm_relationships;

migrations/2024-10-24-004935_add_dev_pm_relationships/up.sql

@@ -0,0 +1,18 @@
+CREATE TABLE dev_pm_relationships (
+                                      id SERIAL PRIMARY KEY,
+                                      developer_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                                      project_manager_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                                      status VARCHAR NOT NULL CHECK (status IN ('pending', 'accepted', 'rejected')),
+                                      created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                                      updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_dev_pm_developer ON dev_pm_relationships(developer_id);
+CREATE INDEX idx_dev_pm_manager ON dev_pm_relationships(project_manager_id);
+CREATE INDEX idx_dev_pm_status ON dev_pm_relationships(status);
+
+CREATE UNIQUE INDEX idx_unique_dev_pm_relationship
+    ON dev_pm_relationships(developer_id, project_manager_id)
+    WHERE status != 'rejected';
+
+SELECT diesel_manage_updated_at('dev_pm_relationships');

src/main.rs

@@ -9,7 +9,8 @@ mod db;
 mod schema;
 
 use crate::routes::auth::{login, register};
-use crate::routes::snack::{create_snack, delete_snack, list_snacks, update_snack};
+use crate::routes::relationship::{invite_project_manager, list_developers, list_snacks, respond_to_invite};
+use crate::routes::snack::{create_snack, delete_snack, update_snack};
 use dotenv::dotenv;
 use rocket::*;
 
@@ -29,7 +30,7 @@ fn index() -> &'static str {
 fn rocket() -> _ {
     dotenv().ok();
 
-    rocket::build().mount("/", routes![index, create_snack, list_snacks, update_snack, delete_snack, register, login]).register("/", catchers![catchers::unauthorized, catchers::not_found,
+    rocket::build().mount("/", routes![index, invite_project_manager,list_developers, respond_to_invite, create_snack, list_snacks, update_snack, delete_snack, register, login]).register("/", catchers![catchers::unauthorized, catchers::not_found,
      catchers::internal_server_error])
 }
 

src/models/mod.rs

@@ -1,2 +1,3 @@
 pub mod snack;
-pub(crate) mod user;
+pub(crate) mod user;
+pub(crate) mod relationship;

src/models/relationship.rs

@@ -0,0 +1,73 @@
+// src/models/relationship.rs
+use crate::models::user::User;
+use chrono::NaiveDateTime;
+use diesel::prelude::*;
+use serde::{Deserialize, Serialize};
+use diesel::pg::Pg;
+use crate::schema::dev_pm_relationships;
+use crate::schema::dev_pm_relationships::dsl;
+
+#[derive(Queryable, Selectable, Serialize, Identifiable, Associations, Debug)]
+#[diesel(belongs_to(User, foreign_key = developer_id))]
+#[diesel(table_name = crate::schema::dev_pm_relationships)]
+pub struct DevPmRelationship {
+    pub id: i32,
+    pub developer_id: i32,
+    pub project_manager_id: i32,
+    pub status: String,
+    pub created_at: NaiveDateTime,
+    pub updated_at: NaiveDateTime,
+}
+
+#[derive(Insertable)]
+#[diesel(table_name = crate::schema::dev_pm_relationships)]
+pub struct NewDevPmRelationship {
+    pub developer_id: i32,
+    pub project_manager_id: i32,
+    pub status: String,
+}
+
+#[derive(Deserialize)]
+pub struct InvitePmRequest {
+    pub project_manager_id: i32,
+}
+
+#[derive(Deserialize)]
+pub struct RespondToInviteRequest {
+    pub status: String,
+}
+
+// Query builders helper methods
+impl DevPmRelationship {
+    pub fn for_developer(user_id: i32) -> dev_pm_relationships::BoxedQuery<'static, Pg> {
+        use crate::schema::dev_pm_relationships::dsl::*;
+
+        dev_pm_relationships
+            .filter(developer_id.eq(user_id))
+            .into_boxed()
+    }
+
+    pub fn for_project_manager(user_id: i32) -> dev_pm_relationships::BoxedQuery<'static, Pg> {
+        use crate::schema::dev_pm_relationships::dsl::*;
+
+        dev_pm_relationships
+            .filter(project_manager_id.eq(user_id))
+            .into_boxed()
+    }
+
+    pub fn pending() -> dev_pm_relationships::BoxedQuery<'static, Pg> {
+        use crate::schema::dev_pm_relationships::dsl::*;
+
+        dev_pm_relationships
+            .filter(status.eq("pending"))
+            .into_boxed()
+    }
+
+    pub fn accepted() -> dev_pm_relationships::BoxedQuery<'static, Pg> {
+        use crate::schema::dev_pm_relationships::dsl::*;
+
+        dev_pm_relationships
+            .filter(status.eq("accepted"))
+            .into_boxed()
+    }
+}

src/routes/auth.rs

@@ -8,17 +8,20 @@ use jsonwebtoken::{encode, EncodingKey, Header};
 use rocket::http::Status;
 use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
+
 #[derive(Deserialize)]
 pub struct RegisterInfo {
     username: String,
     password: String,
+    role: Option<String>,
 }
 
 #[derive(Deserialize)]
 pub struct LoginInfo {
     username: String,
     password: String,
 }
+
 #[derive(Serialize)]
 pub struct TokenResponse {
     token: String,
@@ -30,10 +33,16 @@ pub fn register(info: Json<RegisterInfo>) -> Result<Json<User>, Status> {
     let hashed_password = hash(&info.password, DEFAULT_COST)
         .map_err(|_| Status::InternalServerError)?;
 
+    let user_role = match info.role.as_deref() {
+        Some("developer") => "developer",
+        Some("project_manager") => "project_manager",
+        _ => "developer"
+    }.to_string();
+
     let new_user = NewUser {
         username: info.username.clone(),
         password_hash: hashed_password,
-        role: "user".to_string(),
+        role: user_role,
     };
 
     diesel::insert_into(users)
@@ -66,4 +75,4 @@ pub fn login(info: Json<LoginInfo>) -> Result<Json<TokenResponse>, Status> {
     } else {
         Err(Status::Unauthorized)
     }
-}
+}

src/routes/mod.rs

@@ -1,2 +1,3 @@
 pub mod snack;
-pub mod auth;
+pub mod auth;
+pub mod relationship;

src/routes/relationship.rs

@@ -0,0 +1,141 @@
+use crate::auth::user::AuthenticatedUser;
+use crate::db;
+use crate::models::relationship::{DevPmRelationship, InvitePmRequest, NewDevPmRelationship, RespondToInviteRequest};
+use crate::models::snack::Snack;
+use crate::models::user::User;
+use crate::schema::dev_pm_relationships::{self, developer_id, project_manager_id, status};
+use crate::schema::snacks::{self, user_id};
+use crate::schema::users;
+use diesel::prelude::*;
+use rocket::http::Status;
+use rocket::serde::json::Json;
+
+#[post("/invite-pm", data = "<invite_data>")]
+pub fn invite_project_manager(
+    invite_data: Json<InvitePmRequest>,
+    user: AuthenticatedUser,
+) -> Result<Json<DevPmRelationship>, Status> {
+    let mut conn = db::establish_connection();
+
+    if user.0.role != "developer" {
+        return Err(Status::Forbidden);
+    }
+
+    let pm = users::table
+        .find(invite_data.project_manager_id)
+        .first::<User>(&mut conn)
+        .map_err(|_| Status::NotFound)?;
+
+    if pm.role != "project_manager" {
+        return Err(Status::BadRequest);
+    }
+
+    let existing = DevPmRelationship::for_developer(user.0.id)
+        .filter(project_manager_id.eq(invite_data.project_manager_id))
+        .filter(status.ne("rejected"))
+        .first::<DevPmRelationship>(&mut conn);
+
+    if existing.is_ok() {
+        return Err(Status::BadRequest);
+    }
+
+    let new_relationship = NewDevPmRelationship {
+        developer_id: user.0.id,
+        project_manager_id: invite_data.project_manager_id,
+        status: "pending".to_string(),
+    };
+
+    diesel::insert_into(dev_pm_relationships::table)
+        .values(&new_relationship)
+        .get_result(&mut conn)
+        .map(Json)
+        .map_err(|_| Status::InternalServerError)
+}
+
+#[get("/my-developers")]
+pub fn list_developers(user: AuthenticatedUser) -> Result<Json<Vec<User>>, Status> {
+    let mut conn = db::establish_connection();
+
+    if user.0.role != "project_manager" {
+        return Err(Status::Forbidden);
+    }
+
+    users::table
+        .inner_join(
+            dev_pm_relationships::table
+                .on(developer_id.eq(users::id)
+                    .and(project_manager_id.eq(user.0.id))
+                    .and(status.eq("accepted")))
+        )
+        .select(users::all_columns)
+        .load::<User>(&mut conn)
+        .map(Json)
+        .map_err(|_| Status::InternalServerError)
+}
+
+#[get("/snacks")]
+pub fn list_snacks(user: AuthenticatedUser) -> Result<Json<Vec<Snack>>, Status> {
+    let mut conn = db::establish_connection();
+
+    match user.0.role.as_str() {
+        "admin" => {
+            snacks::table
+                .limit(100)
+                .select(Snack::as_select())
+                .load(&mut conn)
+        }
+        "project_manager" => {
+            snacks::table
+                .inner_join(
+                    dev_pm_relationships::table
+                        .on(user_id.eq(developer_id)
+                            .and(project_manager_id.eq(user.0.id))
+                            .and(status.eq("accepted")))
+                )
+                .select(Snack::as_select())
+                .distinct()
+                .limit(100)
+                .load(&mut conn)
+        }
+        _ => {
+            snacks::table
+                .filter(user_id.eq(user.0.id))
+                .limit(100)
+                .select(Snack::as_select())
+                .load(&mut conn)
+        }
+    }
+        .map(Json)
+        .map_err(|err| {
+            println!("Database error: {:?}", err);
+            Status::InternalServerError
+        })
+}
+
+#[patch("/respond-to-invite/<relationship_id>", data = "<response_data>")]
+pub fn respond_to_invite(
+    relationship_id: i32,
+    response_data: Json<RespondToInviteRequest>,
+    user: AuthenticatedUser,
+) -> Result<Json<DevPmRelationship>, Status> {
+    let mut conn = db::establish_connection();
+
+    if user.0.role != "project_manager" {
+        return Err(Status::Forbidden);
+    }
+
+    let relationship = DevPmRelationship::for_project_manager(user.0.id)
+        .filter(dev_pm_relationships::id.eq(relationship_id))
+        .first::<DevPmRelationship>(&mut conn)
+        .map_err(|_| Status::NotFound)?;
+
+    if relationship.status != "pending" {
+        return Err(Status::BadRequest);
+    }
+
+    diesel::update(dev_pm_relationships::table.find(relationship_id))
+        .set(status.eq(&response_data.status))
+        .get_result(&mut conn)
+        .map(Json)
+        .map_err(|_| Status::InternalServerError)
+}