Brought project back to original layout. Fixed user_access search.

Author: penatem1

backend/src/access/mod.rs renamed to backend/src/access.rs

@@ -13,7 +13,6 @@ use crate::errors::{WebdevError, WebdevErrorKind};
 
 use crate::search::{NullableSearch, Search};
 
-use crate::users::models::UserList;
 use super::schema::{access, user_access};
 
 #[derive(Queryable, Serialize, Deserialize)]
@@ -141,23 +140,23 @@ impl UserAccessRequest {
         router!(request,
             (GET) (/) => {
 
-                let mut access_id = Search::NoSearch;
-                let mut user_id = Search::NoSearch;
-                let mut permission_level = NullableSearch::NoSearch;
+                let mut access_id_search = Search::NoSearch;
+                let mut user_id_search = Search::NoSearch;
+                let mut permission_level_search = NullableSearch::NoSearch;
 
                 for (field, query) in url_queries {
-                    match field.as_ref() {
-                        "access_id" => access_id = Search::from_query(query.as_ref())?,
-                        "user_id" => user_id = Search::from_query(query.as_ref())?,
-                        "permission_level" => permission_level = NullableSearch::from_query(query.as_ref())?,
+                    match field.as_ref() as &str {
+                        "access_id" => access_id_search = Search::from_query(query.as_ref())?,
+                        "user_id" => user_id_search = Search::from_query(query.as_ref())?,
+                        "permission_level" => permission_level_search = NullableSearch::from_query(query.as_ref())?,
                         _ => return Err(WebdevError::new(WebdevErrorKind::Format)),
                     }
                 }
 
                 Ok(UserAccessRequest::SearchAccess(SearchUserAccess {
-                    access_id,
-                    user_id,
-                    permission_level,
+                    access_id: access_id_search,
+                    user_id: user_id_search,
+                    permission_level: permission_level_search,
                 }))
             },
 
@@ -196,19 +195,36 @@ impl UserAccessRequest {
 }
 
 pub enum UserAccessResponse {
-    ManyUsers(UserList),
     AccessState(bool),
+    ManyUserAccess(JoinedUserAccessList),
     OneUserAccess(UserAccess),
     NoResponse,
 }
 
 impl UserAccessResponse {
     pub fn to_rouille(self) -> rouille::Response {
         match self {
-            UserAccessResponse::ManyUsers(users) => rouille::Response::json(&users),
             UserAccessResponse::AccessState(state) => rouille::Response::text(if state {"true"} else {"false"}),
+            UserAccessResponse::ManyUserAccess(user_accesses) => rouille::Response::json(&user_accesses),
             UserAccessResponse::OneUserAccess(user_access) => rouille::Response::json(&user_access),
             UserAccessResponse::NoResponse => rouille::Response::empty_204(),
         }
     }
 }
+
+
+
+#[derive(Queryable, Serialize, Deserialize)]
+pub struct JoinedUserAccess {
+    pub permission_id: i64,
+    pub user_id: i64,
+    pub access_id: i64,
+    pub first_name: String,
+    pub last_name: String,
+    pub banner_id: u32,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct JoinedUserAccessList {
+    pub entries: Vec<JoinedUserAccess>,
+}

backend/src/access/models.rs

@@ -1,11 +1,14 @@
 use diesel;
 use diesel::types;
 use diesel::mysql::MysqlConnection;
+use diesel::mysql::Mysql;
 use diesel::query_builder::AsQuery;
 use diesel::QueryDsl;
 use diesel::RunQueryDsl;
 use diesel::ExpressionMethods;
 use diesel::TextExpressionMethods;
+use diesel::NullableExpressionMethods;
+use diesel::query_builder::BoxedSelectStatement;
 
 use crate::errors::{WebdevError, WebdevErrorKind};
 
@@ -15,7 +18,9 @@ use super::models::{
     Access, NewAccess, PartialAccess, AccessRequest, AccessResponse,
 
     UserAccess, NewUserAccess, PartialUserAccess, SearchUserAccess,
-    UserAccessRequest, UserAccessResponse
+    UserAccessRequest, UserAccessResponse,
+
+    JoinedUserAccess, JoinedUserAccessList
 };
 
 use crate::users::models::{User, UserList};
@@ -97,7 +102,7 @@ pub fn handle_user_access(
 ) -> Result<UserAccessResponse, WebdevError> {
     match request {
         UserAccessRequest::SearchAccess(user_access) => {
-            search_user_access(user_access, database_connection).map(|u| UserAccessResponse::ManyUsers(u))
+            search_user_access(user_access, database_connection).map(|u| UserAccessResponse::ManyUserAccess(u))
         },
         UserAccessRequest::GetAccess(permission_id) => {
             get_user_access(permission_id, database_connection).map(|a| UserAccessResponse::OneUserAccess(a))
@@ -120,9 +125,17 @@ pub fn handle_user_access(
 fn search_user_access(
     user_access_search: SearchUserAccess,
     database_connection: &MysqlConnection
-) -> Result<UserList, WebdevError> {
+) -> Result<JoinedUserAccessList, WebdevError> {
     let mut user_access_query = user_access_schema::table
-        .as_query().into_boxed();
+        .inner_join(access_schema::table)
+        .inner_join(users_schema::table)
+        .select((user_access_schema::permission_id,
+            users_schema::id,
+            access_schema::id,
+            users_schema::first_name,
+            users_schema::last_name,
+            users_schema::banner_id))
+        .into_boxed::<Mysql>();
 
     match user_access_search.access_id {
         Search::Partial(s) => {
@@ -176,31 +189,10 @@ fn search_user_access(
         NullableSearch::NoSearch => {}
     }
 
-    let found_access_entries = user_access_query.load::<UserAccess>(database_connection)?;
-
-    let mut out: Vec<User> = Vec::new();
-
-    for user_access in &found_access_entries {
-
-        let mut found_users = users_schema::table
-            .filter(users_schema::id.eq(user_access.user_id))
-            .load::<User>(database_connection)?;
-
-        match found_users.pop() {
-            Some(user) => {
-                let mut found: bool = false;
-                for pending_user in &out {
-                    if pending_user.id == user.id { found = true; }
-                }
-                if !found { out.push(user); }
-            },
-            None => {();},
-        };
-    }
-
-    let user_list = UserList { users: out };
+    let found_access_entries = user_access_query.load::<JoinedUserAccess>(database_connection)?;
+    let joined_list = JoinedUserAccessList { entries: found_access_entries };
 
-    Ok(user_list)
+    Ok(joined_list)
 }
 
 fn get_user_access(