feat: add endpoint to query all users in a simplified format (#45)

Author: CodeF0x

src/database.rs

@@ -2,15 +2,16 @@ use crate::filters::{
     filter_by_assigned_user, filter_by_labels, filter_by_status, filter_by_title,
 };
 use crate::models::{
-    DataBaseUser, DatabaseSession, NewSession, NewTicket, NewUser, SqliteTicket, Status, Ticket,
+    DataBaseUser, DatabaseSession, DisplayUser, NewSession, NewTicket, NewUser, SqliteTicket,
+    Status, Ticket,
 };
 use crate::payloads::{FilterPayload, TicketPayload};
 use crate::schema::sessions::dsl::sessions;
 use crate::schema::sessions::token;
 use crate::schema::tickets::dsl::tickets;
 use crate::schema::tickets::{body, id, labels, last_modified, status, title};
 use crate::schema::users::dsl::users;
-use crate::schema::users::email;
+use crate::schema::users::{display_name, email};
 use actix_web::web::Json;
 use argonautica::Hasher;
 use diesel::{Connection, ExpressionMethods, QueryDsl, QueryResult, RunQueryDsl, SqliteConnection};
@@ -142,6 +143,12 @@ pub fn get_user_by_email(
     users.filter(email.eq(user_email)).get_result(connection)
 }
 
+pub fn get_all_users(connection: &mut SqliteConnection) -> QueryResult<Vec<DisplayUser>> {
+    users
+        .select((email, display_name))
+        .load::<DisplayUser>(connection)
+}
+
 pub fn filter_tickets_in_database(
     connection: &mut SqliteConnection,
     filter_payload: Json<FilterPayload>,

src/main.rs

@@ -9,17 +9,17 @@ mod test_helpers;
 
 use crate::database::{
     create_ticket, create_user, delete_ticket, edit_ticket, filter_tickets_in_database,
-    get_all_tickets, get_single_ticket, get_user_by_email, remove_session_from_db,
+    get_all_tickets, get_all_users, get_single_ticket, get_user_by_email, remove_session_from_db,
     write_session_to_db, DataBase,
 };
 use crate::middleware::validator;
 use crate::models::{NewSession, NewUser, Ticket, TokenClaims};
 use crate::payloads::{FilterPayload, LoginPayload, TicketPayload};
 use crate::status_messages::{
     CANNOT_LOGOUT, ERROR_COULD_NOT_CREATE_TICKET, ERROR_COULD_NOT_CREATE_USER,
-    ERROR_COULD_NOT_DELETE, ERROR_COULD_NOT_GET, ERROR_COULD_NOT_UPDATE, ERROR_INCORRECT_PASSWORD,
-    ERROR_INVALID_ID, ERROR_NOT_FOUND, ERROR_NOT_LOGGED_IN, ERROR_NO_USER_FOUND,
-    ERROR_USER_ALREADY_EXISTS, SUCCESS_LOGOUT,
+    ERROR_COULD_NOT_DELETE, ERROR_COULD_NOT_GET, ERROR_COULD_NOT_RETRIEVE_USERS,
+    ERROR_COULD_NOT_UPDATE, ERROR_INCORRECT_PASSWORD, ERROR_INVALID_ID, ERROR_NOT_FOUND,
+    ERROR_NOT_LOGGED_IN, ERROR_NO_USER_FOUND, ERROR_USER_ALREADY_EXISTS, SUCCESS_LOGOUT,
 };
 use actix_cors::Cors;
 use actix_web::cookie::time::{Duration, OffsetDateTime};
@@ -54,7 +54,8 @@ async fn main() -> Result<()> {
                     .service(delete)
                     .service(edit)
                     .service(filter_tickets)
-                    .service(logout),
+                    .service(logout)
+                    .service(get_users),
             ),
         )
     })
@@ -258,6 +259,16 @@ async fn login(payload: Json<LoginPayload>) -> impl Responder {
     }
 }
 
+#[get("/users")]
+async fn get_users() -> impl Responder {
+    let mut database = DataBase::new();
+
+    match get_all_users(&mut database.connection) {
+        Ok(all_users) => HttpResponse::Ok().json(all_users),
+        Err(_) => HttpResponse::InternalServerError().json(ERROR_COULD_NOT_RETRIEVE_USERS),
+    }
+}
+
 /*
 * To fully understand the tests and the test data,
 * have a look at the setup_database function in test_helpers.rs.
@@ -754,6 +765,30 @@ mod tests {
         }
     }
 
+    mod test_get_users {
+        use actix_web::{
+            test::{self, TestRequest},
+            App,
+        };
+        use serial_test::serial;
+
+        use crate::{get_users, models::DisplayUser, test_helpers::helpers::setup_database};
+
+        #[actix_web::test]
+        #[serial]
+        async fn test_get_all_users() {
+            setup_database();
+
+            let app = test::init_service(App::new().service(get_users)).await;
+            let req = TestRequest::get().uri("/users").to_request();
+
+            let response: Vec<DisplayUser> = test::call_and_read_body_json(&app, req).await;
+
+            assert_eq!(response[0].email, "test@example.com");
+            assert_eq!(response[0].display_name, "user");
+        }
+    }
+
     mod test_logout {
         use crate::database::DataBase;
         use crate::logout;

src/models.rs

@@ -101,6 +101,12 @@ pub struct DataBaseUser {
     pub password: String,
 }
 
+#[derive(Serialize, Deserialize, Debug, Queryable)]
+pub struct DisplayUser {
+    pub email: String,
+    pub display_name: String,
+}
+
 #[derive(Serialize, Deserialize, Insertable)]
 #[diesel(table_name = crate::schema::users)]
 #[diesel(check_for_backend(diesel::sqlite::Sqlite))]

src/status_messages.rs

@@ -11,6 +11,7 @@ pub const ERROR_COULD_NOT_CREATE_USER: &str = "Could not create user";
 pub const ERROR_INCORRECT_PASSWORD: &str = "Incorrect email or password";
 pub const ERROR_NO_USER_FOUND: &str = "No user found";
 pub const ERROR_USER_ALREADY_EXISTS: &str = "User with that email already exists";
+pub const ERROR_COULD_NOT_RETRIEVE_USERS: &str = "Could not retriever users";
 
 // success messages
 pub const SUCCESS_LOGOUT: &str = "Successfully logged out";