user-auth store frontend v3

backend/api/src/lib.rs

@@ -327,8 +327,15 @@ async fn list_users(
     }
     return Json(users);
 }
-    async fn login_handler(mut auth: AuthContext, Json(user_sent): Json<booksman_orm::AxumUser>) -> impl IntoResponse {
-        auth.login(&user_sent).await.unwrap();
+    async fn login_handler(mut auth: AuthContext, Extension(ref conn): Extension<DatabaseConnection>, Json(user_sent): Json<booksman_orm::AxumUser>) -> impl IntoResponse {
+        let userdb : user::Model = QueryCore::find_userid_by_name(conn, user_sent.name.clone()).await.unwrap().unwrap();
+        let userid = userdb.id;
+        let corrected_user = booksman_orm::AxumUser {
+            id: userid,
+            name: user_sent.name.clone(),
+            password_hash: user_sent.password_hash.clone()
+        };
+        auth.login(&corrected_user).await.unwrap();
         return "success";
     }
 
@@ -621,8 +628,9 @@ async fn list_book(
 
     let page: usize = params.get("page").unwrap().parse().unwrap();
     let userid: usize = params.get("userid").unwrap().parse().unwrap();
+    let sort: String = params.get("sort").unwrap().to_string();
 
-    let books = QueryCore::find_books_plus_meta_in_page(conn,page,userid,12)
+    let books = QueryCore::find_books_plus_meta_in_page(conn,page,userid,12, sort)
         .await
         .expect("could not list books");
 

backend/orm/src/query.rs

@@ -27,6 +27,11 @@ impl Query {
     }
 
 
+    pub async fn find_userid_by_name(db: &DbConn, name: String) -> Result<Option<user::Model>, DbErr> {
+        User::find().filter(user::Column::UserName.eq(name)).one(db).await
+    }
+
+
     pub async fn find_user_by_id(db: &DbConn, id: i32) -> Result<Option<user::Model>, DbErr> {
         User::find_by_id(id).one(db).await
     }
@@ -48,16 +53,26 @@ impl Query {
         page: u64,
         posts_per_page: u64,
         userid: i32,
+        sort: String,
     ) -> Result<(Vec<book::Model>, u64), DbErr> {
         // Setup paginator
-        let paginator = Book::find()
-            .filter(book::Column::UserId.eq(userid))
-            .order_by_asc(book::Column::Id)
-            .paginate(db, posts_per_page);
-        let num_pages = paginator.num_pages().await?;
+        if sort == "desc".to_string() {
+            let paginator = Book::find()
+                .filter(book::Column::UserId.eq(userid))
+                .order_by_desc(book::Column::Id)
+                .paginate(db, posts_per_page);
+            let num_pages = paginator.num_pages().await?;
+            return paginator.fetch_page(page - 1).await.map(|p| (p, num_pages))
+        } else {
+            let paginator = Book::find()
+                .filter(book::Column::UserId.eq(userid))
+                .order_by_asc(book::Column::Id)
+                .paginate(db, posts_per_page);
+            let num_pages = paginator.num_pages().await?;
+            return paginator.fetch_page(page - 1).await.map(|p| (p, num_pages))
+        }
 
         // Fetch paginated posts
-        paginator.fetch_page(page - 1).await.map(|p| (p, num_pages))
     }
 
 pub async fn find_books_plus_meta_in_page(
@@ -65,9 +80,10 @@ pub async fn find_books_plus_meta_in_page(
         page: usize,
         posts_per_page: usize,
         userid: i32,
+        sort: String,
     ) -> Result<(Vec<BookAndMetaV2>, u64), DbErr> {
         // Setup paginator
-        let books = Self::find_books_in_page(db,page.try_into().unwrap(),posts_per_page.try_into().unwrap(),userid).await?;
+        let books = Self::find_books_in_page(db,page.try_into().unwrap(),posts_per_page.try_into().unwrap(),userid, sort).await?;
         let book_ids: Vec<i32> = books.0.clone().into_iter().map(|b| b.id).collect();
         let mut resbooks: Vec<BookAndMetaV2> = Vec::with_capacity(book_ids.len());
         for book in books.0.iter() {