Navbar stuff

README.md

@@ -9,5 +9,4 @@
 - [ ] Actually do database stuff (@lemonsh)
 - [ ] Cookies! (@lemonsh)
 - [ ] Error messages when something goes wrong (@famfo)
-- [ ] For more then x tasks create a new task page (?) (@famfo)
 

src/database.rs

@@ -53,7 +53,7 @@ impl Database {
     }
 
     // Async might become a problem here
-    pub fn get_tasks(&self) -> templates::Tasks {
+    pub async fn get_tasks(&self) -> templates::Tasks {
         // TODO: actually get the issues from the db based on the category cookies
         let vec = vec![templates::Task {
             title: "finish tmtd".to_string(),
@@ -64,8 +64,9 @@ impl Database {
             description: "DO SOMETHING AAAAAAA".to_string(),
             id: 1,
         }];
+        let logged_in = self.logged_in().await;
 
-        templates::Tasks { tasks: vec }
+        templates::Tasks { tasks: vec, logged_in }
     }
 
     pub async fn create_task(&self, task: &task::CreateTask) {
@@ -109,4 +110,9 @@ impl Database {
         // TODO: find user in DB and check if the password matches
         // TODO: save that the user is logged in a cookie or something
     }
+
+    pub async fn logged_in(&self) -> Option<String> {
+        // TODO: find out if the user is logged in and return the username if yes 
+        None
+    }
 }

src/templates.rs

@@ -19,21 +19,28 @@
 use askama::Template;
 
 #[derive(Template)]
-#[template(path = "index.html")]
+#[template(path = "site/index.html")]
-pub struct Index();
+pub struct Index {
+    pub logged_in: Option<String>,
+}
 
 #[derive(Template)]
-#[template(path = "users.html")]
+#[template(path = "site/users/users.html")]
-pub struct Users();
+pub struct Users {
+    pub logged_in: Option<String>,
+}
 
 #[derive(Template)]
-#[template(path = "admin.html")]
+#[template(path = "site/admin/admin.html")]
-pub struct AdminPanel();
+pub struct AdminPanel {
+    pub logged_in: Option<String>,
+}
 
 #[derive(Template)]
-#[template(path = "task/task_page.html")]
+#[template(path = "site/task/task_page.html")]
 pub struct Tasks {
     pub tasks: Vec<Task>,
+    pub logged_in: Option<String>,
 }
 
 pub struct Task {
@@ -46,13 +53,20 @@ pub struct Task {
 }
 
 #[derive(Template)]
-#[template(path = "task/create_task.html")]
+#[template(path = "site/task/create_task.html")]
-pub struct CreateTask();
+pub struct CreateTask {
+    pub logged_in: Option<String>,
+}
 
 #[derive(Template)]
-#[template(path = "login.html")]
+#[template(path = "site/login/login.html")]
-pub struct Login();
+pub struct Login {
+    pub logged_in: Option<String>,
+}
 
 #[derive(Template)]
-#[template(path = "register.html")]
+#[template(path = "site/login/register.html")]
-pub struct Register();
+pub struct Register {
+    pub logged_in: Option<String>,
+}
+

src/web.rs

@@ -31,28 +31,43 @@ impl App {
         let db = db.clone();
         let server = HttpServer::new(move || {
             actix_web::App::new().service((
-                web::resource("/").route(web::get().to(index)),
+                web::resource("/")
-                web::resource("/users").route(web::get().to(users)),
+                    .app_data(web::Data::new(db.clone()))
+                    .route(web::get().to(index)),
+                web::resource("/users")
+                    .app_data(web::Data::new(db.clone()))
+                    .route(web::get().to(users)),
                 web::resource("/task")
                     .app_data(web::Data::new(db.clone()))
                     .route(web::get().to(tasks)),
-                web::resource("/admin").route(web::get().to(admin)),
+                web::resource("/admin")
-                web::resource("/create").route(web::get().to(create)),
+                    .app_data(web::Data::new(db.clone()))
-                web::resource("/login").route(web::get().to(login)),
+                    .route(web::get().to(admin)),
-                web::resource("/register").route(web::get().to(register)),
+                web::resource("/create")
+                    .app_data(web::Data::new(db.clone()))
+                    .route(web::get().to(create)),
+                web::resource("/login")
+                    .app_data(web::Data::new(db.clone()))
+                    .route(web::get().to(login)),
+                web::resource("/register")
+                    .app_data(web::Data::new(db.clone()))
+                    .route(web::get().to(register)),
                 web::resource("/api/task/create")
                     .app_data(web::Data::new(db.clone()))
                     .route(web::post().to(create_task)),
                 web::resource("/api/task/move")
                     .app_data(web::Data::new(db.clone()))
                     .route(web::post().to(move_task)),
-                web::resource("/api/task/sort").route(web::post().to(sort_task)),
+                //web::resource("/api/task/sort").route(web::post().to(sort_task)),
                 web::resource("/api/login")
                     .app_data(web::Data::new(db.clone()))
                     .route(web::post().to(login_user)),
                 web::resource("/api/register")
                     .app_data(web::Data::new(db.clone()))
                     .route(web::post().to(register_user)),
+                web::resource("/api/logout")
+                    .app_data(web::Data::new(db.clone()))
+                    .route(web::get().to(logout)),
             ))
         })
         .bind(addr)?
@@ -61,44 +76,50 @@ impl App {
     }
 }
 
-async fn index() -> impl Responder {
+async fn index(db: web::Data<Arc<Database>>) -> impl Responder {
-    let index = templates::Index {};
+    let logged_in = db.logged_in().await;
+    let index = templates::Index { logged_in };
     let html = index.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
 
 async fn tasks(db: web::Data<Arc<Database>>) -> impl Responder {
-    let tasks = db.get_tasks();
+    let tasks = db.get_tasks().await;
     let html = tasks.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
 
-async fn users() -> impl Responder {
+async fn users(db: web::Data<Arc<Database>>) -> impl Responder {
-    let users = templates::Users {};
+    let logged_in = db.logged_in().await;
+    let users = templates::Users { logged_in };
     let html = users.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
 
-async fn admin() -> impl Responder {
+async fn admin(db: web::Data<Arc<Database>>) -> impl Responder {
-    let admin_panel = templates::AdminPanel {};
+    let logged_in = db.logged_in().await;
+    let admin_panel = templates::AdminPanel { logged_in };
     let html = admin_panel.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
 
-async fn create() -> impl Responder {
+async fn create(db: web::Data<Arc<Database>>) -> impl Responder {
-    let create = templates::CreateTask {};
+    let logged_in = db.logged_in().await;
+    let create = templates::CreateTask { logged_in };
     let html = create.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
 
-async fn login() -> impl Responder {
+async fn login(db: web::Data<Arc<Database>>) -> impl Responder {
-    let login = templates::Login {};
+    let logged_in = db.logged_in().await;
+    let login = templates::Login { logged_in };
     let html = login.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
 
-async fn register() -> impl Responder {
+async fn register(db: web::Data<Arc<Database>>) -> impl Responder {
-    let register = templates::Register {};
+    let logged_in = db.logged_in().await;
+    let register = templates::Register { logged_in };
     let html = register.render().unwrap();
     HttpResponseBuilder::new(StatusCode::OK).body(html)
 }
@@ -107,8 +128,6 @@ async fn create_task(
     req: web::Form<task::CreateTask>,
     db: web::Data<Arc<Database>>,
 ) -> impl Responder {
-    tracing::debug!("Got POST request on /api/task/create: {:#?}", req);
-    let db = db.clone();
     let task = req.into_inner();
     db.create_task(&task).await;
     HttpResponse::SeeOther()
@@ -117,8 +136,6 @@ async fn create_task(
 }
 
 async fn move_task(req: web::Form<task::MoveTask>, db: web::Data<Arc<Database>>) -> impl Responder {
-    tracing::debug!("Got POST request on /api/task/move: {:#?}", req);
-    let db = db.clone();
     let task = req.into_inner();
     db.move_task(&task).await;
     HttpResponse::SeeOther()
@@ -127,7 +144,6 @@ async fn move_task(req: web::Form<task::MoveTask>, db: web::Data<Arc<Database>>)
 }
 
 async fn sort_task(req: web::Form<task::SortTask>) -> impl Responder {
-    tracing::debug!("Got POST request on /api/task/sort: {:#?}", req);
     // TODO: save selected categories in a cookie or something
     HttpResponse::SeeOther()
         .insert_header(("Location", "/task"))
@@ -135,10 +151,9 @@ async fn sort_task(req: web::Form<task::SortTask>) -> impl Responder {
 }
 
 async fn login_user(req: web::Form<task::Login>, db: web::Data<Arc<Database>>) -> impl Responder {
-    tracing::debug!("Got POST request on /api/login");
     db.login(&req.username, &req.password).await;
     HttpResponse::SeeOther()
-        .insert_header(("Location", "/task"))
+        .insert_header(("Location", "/"))
         .finish()
 }
 
@@ -146,10 +161,16 @@ async fn register_user(
     req: web::Form<task::Register>,
     db: web::Data<Arc<Database>>,
 ) -> impl Responder {
-    tracing::debug!("Got POST request on /api/register");
-    let db = db.clone();
     db.register(&req.username, &req.password).await;
     HttpResponse::SeeOther()
-        .insert_header(("Location", "/task"))
+        .insert_header(("Location", "/"))
         .finish()
 }
+
+async fn logout(db: web::Data<Arc<Database>>) -> impl Responder {
+    // TODO: log the user out
+    HttpResponse::SeeOther()
+        .insert_header(("Location", "/"))
+        .finish()
+}
+

templates/navbar.html

@@ -9,8 +9,14 @@ navbar<br>
         <a href="/admin">admin panel</a>
     </span>
     <span style="float:right">
-        <a href="/login">login</a> |
+        {% match logged_in %}
-        <a href="/register">register</a>
+            {% when Some with (user) %}
+                Logged in as {{ user }} |
+                <a href="/api/logout">logout</a>
+            {% when None %}
+                <a href="/login">login</a> |
+                <a href="/register">register</a>
+        {% endmatch %}
     </span>
 </div>
 

templates/site/task/task_page.html

@@ -22,7 +22,7 @@
 
 <ul>
 {% for task in tasks %}
-    {% include "task/task.html" %}
+    {% include "site/task/task.html" %}
 {% endfor %}
 </ul>